[jboss-cvs] JBossAS SVN: r106573 - projects/weld-int/branches/Deployment_WELDINT-1/deployer/src/test/java/org/jboss/test/deployers/test.
jboss-cvs-commits at lists.jboss.org
jboss-cvs-commits at lists.jboss.org
Mon Jul 12 02:39:56 EDT 2010
Author: flavia.rainone at jboss.com
Date: 2010-07-12 02:39:56 -0400 (Mon, 12 Jul 2010)
New Revision: 106573
Modified:
projects/weld-int/branches/Deployment_WELDINT-1/deployer/src/test/java/org/jboss/test/deployers/test/JBossDeploymentTestCase.java
Log:
[WELDINT-1] JBossDeploymentTestCase: tests the environment (classes and resources) of Weld deployments
Modified: projects/weld-int/branches/Deployment_WELDINT-1/deployer/src/test/java/org/jboss/test/deployers/test/JBossDeploymentTestCase.java
===================================================================
--- projects/weld-int/branches/Deployment_WELDINT-1/deployer/src/test/java/org/jboss/test/deployers/test/JBossDeploymentTestCase.java 2010-07-12 04:41:08 UTC (rev 106572)
+++ projects/weld-int/branches/Deployment_WELDINT-1/deployer/src/test/java/org/jboss/test/deployers/test/JBossDeploymentTestCase.java 2010-07-12 06:39:56 UTC (rev 106573)
@@ -21,18 +21,48 @@
*/
package org.jboss.test.deployers.test;
-import java.util.List;
+import java.net.URL;
+import java.util.Collection;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.Set;
import junit.framework.Test;
+import org.jboss.deployers.structure.spi.DeploymentUnit;
+import org.jboss.shrinkwrap.api.ShrinkWrap;
+import org.jboss.shrinkwrap.api.container.LibraryContainer;
+import org.jboss.shrinkwrap.api.spec.EnterpriseArchive;
+import org.jboss.shrinkwrap.api.spec.JavaArchive;
+import org.jboss.shrinkwrap.api.spec.WebArchive;
+import org.jboss.test.deployers.support.CheckableBootstrap;
+import org.jboss.test.deployers.support.MockArchiveManifest;
+import org.jboss.test.deployers.support.MockEjbServices;
+import org.jboss.test.deployers.support.MockEmptyEjbServices;
+import org.jboss.test.deployers.support.MockTransactionServices;
+import org.jboss.test.deployers.support.MockWeldBootstrap;
+import org.jboss.test.deployers.support.WeldDEWrapper;
+import org.jboss.test.deployers.support.crm.CrmWebBean;
+import org.jboss.test.deployers.support.ejb.BusinessInterface;
+import org.jboss.test.deployers.support.ejb.MySLSBean;
+import org.jboss.test.deployers.support.ext.ExternalWebBean;
+import org.jboss.test.deployers.support.jar.PlainJavaBean;
+import org.jboss.test.deployers.support.jsf.NotWBJsfBean;
+import org.jboss.test.deployers.support.ui.UIWebBean;
+import org.jboss.test.deployers.support.util.SomeUtil;
+import org.jboss.test.deployers.support.web.ServletWebBean;
+import org.jboss.vfs.VirtualFile;
import org.jboss.weld.bootstrap.spi.BeanDeploymentArchive;
+import org.jboss.weld.bootstrap.spi.Deployment;
+import org.jboss.wsf.spi.metadata.j2ee.SLSBMetaData;
/**
- * JBoss Deployment test case.
+ * JBossDeployment test case.
*
+ * @author <a href="mailto:ales.justin at jboss.org">Ales Justin</a>
* @author <a href="mailto:flavia.rainone at jboss.com">Flavia Rainone</a>
*/
-public class JBossDeploymentTestCase extends AbstractDeploymentTest
+public class JBossDeploymentTestCase extends AbstractWeldTest
{
public JBossDeploymentTestCase(String name)
{
@@ -44,13 +74,682 @@
return suite(JBossDeploymentTestCase.class);
}
- protected int getExpectedArchives()
+ private DeploymentUnit unit;
+
+ public void setUp() throws Exception
{
- return 3;
+ super.setUp();
+ JavaArchive mockJar = ShrinkWrap.create("mock.jar", JavaArchive.class);
+ mockJar.addClass(CheckableBootstrap.class);
+ mockJar.addClass(MockEjbServices.class);
+ mockJar.addClass(MockEmptyEjbServices.class);
+ mockJar.addClass(MockTransactionServices.class);
+ mockJar.addClass(MockWeldBootstrap.class);
+ mockJar.addClass(WeldDEWrapper.class);
+ assertDeploy(mockJar);
}
+
+ public void tearDown() throws Exception
+ {
+ undeploy(unit);
+ super.tearDown();
+ }
+
+ public void testEjbJar() throws Exception
+ {
+ JavaArchive ejbJar = createEjbJar(true);
+ unit = assertDeploy(ejbJar);
- protected void assertNewBeanDeploymentArchive(List<BeanDeploymentArchive> archives, BeanDeploymentArchive newBDA)
+ Deployment deployment = (Deployment) getBean(Deployment.class);
+ BeanDeploymentArchive bda = assertOneBDA(deployment, "ejb.jar");
+ assertExpectedClasses(bda, PlainJavaBean.class);
+ assertExpectedResources(bda, "ejb.jar");
+ }
+
+
+ private void assertBDAId(BeanDeploymentArchive bda, String name)
{
- assertSame(newBDA, archives.iterator().next());
+ assertTrue("BDA id \"" + bda.getId() + "\" expected to end with suffix \"" + name + "/}\"",
+ bda.getId().endsWith(name + "/}"));
}
-}
\ No newline at end of file
+
+ public void testEjbJarWithoutXml() throws Exception
+ {
+ JavaArchive ejbJar = createEjbJar(false);
+ unit = assertDeploy(ejbJar);
+
+ assertNoBean(Deployment.class);
+ }
+
+ public void testEjbJarInEar() throws Exception
+ {
+ EnterpriseArchive ear = ShrinkWrap.create("simple.ear", EnterpriseArchive.class);
+ JavaArchive ejbJar = createEjbJar(true);
+ ear.addModule(ejbJar);
+ MockArchiveManifest.addManifest(ear);
+ unit = assertDeploy(ear);
+
+ Deployment deployment = (Deployment) getBean(Deployment.class);
+ BeanDeploymentArchive bda = assertOneBDA(deployment, "simple.ear");
+ assertExpectedClasses(bda, PlainJavaBean.class);
+ assertExpectedResources(bda, unit.getSimpleName() + "/ejb.jar");
+ }
+
+ public void testEjbJarWithoutXmlInEar() throws Exception
+ {
+ EnterpriseArchive ear = ShrinkWrap.create("simple.ear", EnterpriseArchive.class);
+ JavaArchive ejbJar = createEjbJar(false);
+ ear.addModule(ejbJar);
+ MockArchiveManifest.addManifest(ear);
+ unit = assertDeploy(ear);
+
+ assertNoBean(Deployment.class);
+ }
+
+ public void testEjbJarsInEar() throws Exception
+ {
+ EnterpriseArchive ear = ShrinkWrap.create("simple.ear", EnterpriseArchive.class);
+ JavaArchive ejbJar1 = createEjbJar("ejbJar1.jar", true, PlainJavaBean.class);
+ ear.addModule(ejbJar1);
+ JavaArchive ejbJar2 = createEjbJar("ejbJar2.jar", true, MySLSBean.class, SLSBMetaData.class);
+ ear.addModule(ejbJar2);
+ MockArchiveManifest.addManifest(ear);
+ unit = assertDeploy(ear);
+
+ Deployment deployment = (Deployment) getBean(Deployment.class);
+ BeanDeploymentArchive bda = assertOneBDA(deployment, "simple.ear");
+ assertExpectedClasses(bda, PlainJavaBean.class, MySLSBean.class,
+ SLSBMetaData.class);
+ assertExpectedResources(bda, "simple.ear/ejbJar1.jar", "simple.ear/ejbJar2.jar");
+ }
+
+
+ public void testMixedEjbJarsInEar() throws Exception
+ {
+ EnterpriseArchive ear = ShrinkWrap.create("simple.ear", EnterpriseArchive.class);
+ JavaArchive ejbJar1 = createEjbJar("ejbJar1.jar", false, PlainJavaBean.class);
+ ear.addModule(ejbJar1);
+ JavaArchive ejbJar2 = createEjbJar("ejbJar2.jar", true, MySLSBean.class, SLSBMetaData.class);
+ ear.addModule(ejbJar2);
+ MockArchiveManifest.addManifest(ear);
+ unit = assertDeploy(ear);
+
+ Deployment deployment = (Deployment) getBean(Deployment.class);
+ BeanDeploymentArchive bda = assertOneBDA(deployment, "simple.ear");
+ assertExpectedClasses(bda, MySLSBean.class, SLSBMetaData.class);
+ assertExpectedResources(bda, "simple.ear/ejbJar2.jar");
+ }
+
+ public void testEjbJarsWithoutXmlInEar() throws Exception
+ {
+ EnterpriseArchive ear = ShrinkWrap.create("simple.ear", EnterpriseArchive.class);
+ JavaArchive ejbJar1 = createEjbJar("ejbJar1.jar", false, PlainJavaBean.class);
+ ear.addModule(ejbJar1);
+ JavaArchive ejbJar2 = createEjbJar("ejbJar2.jar", false, MySLSBean.class, SLSBMetaData.class);
+ ear.addModule(ejbJar2);
+ MockArchiveManifest.addManifest(ear);
+ unit = assertDeploy(ear);
+
+ assertNoBean(Deployment.class);
+ }
+
+ public void testWar() throws Exception
+ {
+ WebArchive war = createWar(true);
+ unit = assertDeploy(war);
+
+ Deployment deployment = (Deployment) getBean(Deployment.class);
+ BeanDeploymentArchive bda = assertOneBDA(deployment, "simple.war");
+ assertExpectedClasses(bda, ServletWebBean.class);
+ assertExpectedWarResources(bda, unit.getSimpleName(), true);
+ }
+
+ public void testWarWithLib() throws Exception
+ {
+ WebArchive war = createWarWithLib(true, true);
+ unit = assertDeploy(war);
+
+ Deployment deployment = (Deployment) getBean(Deployment.class);
+ BeanDeploymentArchive bda = assertOneBDA(deployment, "simple.war");
+ assertExpectedClasses(bda, ServletWebBean.class, UIWebBean.class);
+ assertExpectedWarResources(bda, unit.getSimpleName(), true, "lib.jar");
+ }
+
+ public void testWarWithLibs() throws Exception
+ {
+ WebArchive war = createWarWithLibs(true, true, true);
+ unit = assertDeploy(war);
+
+ Deployment deployment = (Deployment) getBean(Deployment.class);
+ BeanDeploymentArchive bda = assertOneBDA(deployment, "simple.war");
+ assertExpectedClasses(bda, ServletWebBean.class, UIWebBean.class, CrmWebBean.class);
+ assertExpectedWarResources(bda, unit.getSimpleName(), true, "lib1.jar", "lib2.jar");
+ }
+
+ public void testWarWithLibWithoutXml() throws Exception
+ {
+ WebArchive war = createWarWithLib(true, false);
+ unit = assertDeploy(war);
+
+ Deployment deployment = (Deployment) getBean(Deployment.class);
+ BeanDeploymentArchive bda = assertOneBDA(deployment, "simple.war");
+ assertExpectedClasses(bda, ServletWebBean.class);
+ assertExpectedWarResources(bda, unit.getSimpleName(), true);
+ }
+
+ public void testWarWithLibsWithoutXml() throws Exception
+ {
+ WebArchive war = createWarWithLibs(true, false, false);
+ unit = assertDeploy(war);
+
+ Deployment deployment = (Deployment) getBean(Deployment.class);
+ BeanDeploymentArchive bda = assertOneBDA(deployment, "simple.war");
+ assertExpectedClasses(bda, ServletWebBean.class);
+ assertExpectedWarResources(bda, unit.getSimpleName(), true);
+ }
+
+ public void testWarWithMixedLibs() throws Exception
+ {
+ WebArchive war = createWarWithLibs(true, true, false);
+ unit = assertDeploy(war);
+
+ Deployment deployment = (Deployment) getBean(Deployment.class);
+ BeanDeploymentArchive bda = assertOneBDA(deployment, "simple.war");
+ assertExpectedClasses(bda, ServletWebBean.class, UIWebBean.class);
+ assertExpectedWarResources(bda, unit.getSimpleName(), true, "lib1.jar");
+ }
+
+ public void testWarWithoutXmlWithLib() throws Exception
+ {
+ WebArchive war = createWarWithLib(false, true);
+ unit = assertDeploy(war);
+
+ Deployment deployment = (Deployment) getBean(Deployment.class);
+ BeanDeploymentArchive bda = assertOneBDA(deployment, "simple.war");
+ assertExpectedClasses(bda, UIWebBean.class);
+ assertExpectedWarResources(bda, unit.getSimpleName(), false, "lib.jar");
+ }
+
+ public void testWarWithoutXmlWithLibs() throws Exception
+ {
+ WebArchive war = createWarWithLibs(false, true, true);
+ unit = assertDeploy(war);
+
+ Deployment deployment = (Deployment) getBean(Deployment.class);
+ BeanDeploymentArchive bda = assertOneBDA(deployment, "simple.war");
+ assertExpectedClasses(bda, UIWebBean.class, CrmWebBean.class);
+ assertExpectedWarResources(bda, unit.getSimpleName(), false, "lib1.jar", "lib2.jar");
+ }
+
+ public void testWarWithoutXmlWithLibWithoutXml() throws Exception
+ {
+ WebArchive war = createWarWithLib(false, false);
+ unit = assertDeploy(war);
+
+ assertNoBean(Deployment.class);
+ }
+
+ public void testWarWithoutXmlWithMixedLibs() throws Exception
+ {
+ WebArchive war = createWarWithLibs(false, true, false);
+ unit = assertDeploy(war);
+
+ Deployment deployment = (Deployment) getBean(Deployment.class);
+ BeanDeploymentArchive bda = assertOneBDA(deployment, "simple.war");
+ assertExpectedClasses(bda, UIWebBean.class);
+ assertExpectedWarResources(bda, unit.getSimpleName(), false, "lib1.jar");
+ }
+
+ public void testWarWithoutXmlWithLibsWithoutXml() throws Exception
+ {
+ WebArchive war = createWarWithLibs(false, false, false);
+ unit = assertDeploy(war);
+
+ assertNoBean(Deployment.class);
+ }
+
+ public void testWarWithoutXml() throws Exception
+ {
+ WebArchive war = createWar(false);
+ unit = assertDeploy(war);
+
+ assertNoBean(Deployment.class);
+ }
+
+ public void testWarInEar() throws Exception
+ {
+ EnterpriseArchive ear = ShrinkWrap.create("warinear.ear", EnterpriseArchive.class);
+ WebArchive war = createWar(true);
+ ear.addModule(war);
+ MockArchiveManifest.addManifest(ear);
+ unit = assertDeploy(ear);
+
+ Deployment deployment = (Deployment) getBean(Deployment.class);
+ BeanDeploymentArchive bda = assertOneBDA(deployment, "warinear.ear/simple.war");
+ assertExpectedClasses(bda, ServletWebBean.class);
+ assertExpectedWarResources(bda, "simple.war", true);
+ }
+
+ public void testWarsInEar() throws Exception
+ {
+ EnterpriseArchive ear = ShrinkWrap.create("warinear.ear", EnterpriseArchive.class);
+ WebArchive war = createWar("simple1.war", true, ServletWebBean.class);
+ ear.addModule(war);
+ war = createWar("simple2.war", true, NotWBJsfBean.class);
+ ear.addModule(war);
+ MockArchiveManifest.addManifest(ear);
+ unit = assertDeploy(ear);
+
+ Deployment deployment = (Deployment) getBean(Deployment.class);
+ Collection<BeanDeploymentArchive> bdas = getBDAs(deployment);
+ assertEquals(2, bdas.size());
+ Iterator<BeanDeploymentArchive> iterator = bdas.iterator();
+ BeanDeploymentArchive bda = iterator.next();
+ BeanDeploymentArchive bda1, bda2;
+ if (bda.getId().contains("simple1.war"))
+ {
+ bda1 = bda;
+ bda2 = iterator.next();
+ }
+ else
+ {
+ bda2 = bda;
+ bda1 = iterator.next();
+ }
+ assertBDAId(bda1, "warinear.ear/simple1.war");
+ assertExpectedClasses(bda1, ServletWebBean.class);
+ assertExpectedWarResources(bda1, "simple1.war", true);
+
+ assertBDAId(bda2, "warinear.ear/simple2.war");
+ assertExpectedClasses(bda2, NotWBJsfBean.class);
+ assertExpectedWarResources(bda2, "simple2.war", true);
+
+ Collection<BeanDeploymentArchive> reachableBDAs = getReachableBDAs(bda1);
+ assertTrue(reachableBDAs.isEmpty());
+ reachableBDAs = getReachableBDAs(bda2);
+ assertTrue(reachableBDAs.isEmpty());
+ }
+
+ public void testMixedWarsInEar() throws Exception
+ {
+ EnterpriseArchive ear = ShrinkWrap.create("warinear.ear", EnterpriseArchive.class);
+ WebArchive war = createWar("simple1.war", true, ServletWebBean.class);
+ ear.addModule(war);
+ war = createWar("simple2.war", false, NotWBJsfBean.class);
+ ear.addModule(war);
+ MockArchiveManifest.addManifest(ear);
+ unit = assertDeploy(ear);
+
+ Deployment deployment = (Deployment) getBean(Deployment.class);
+ BeanDeploymentArchive bda = assertOneBDA(deployment, "warinear.ear/simple1.war");
+ assertExpectedClasses(bda, ServletWebBean.class);
+ assertExpectedWarResources(bda, "warinear.ear/simple1.war", true);
+ }
+
+ public void testWarsWithoutXmlInEar() throws Exception
+ {
+ EnterpriseArchive ear = ShrinkWrap.create("warinear.ear", EnterpriseArchive.class);
+ WebArchive war = createWar("simple1.war", false, ServletWebBean.class);
+ ear.addModule(war);
+ war = createWar("simple2.war", false, NotWBJsfBean.class);
+ ear.addModule(war);
+ MockArchiveManifest.addManifest(ear);
+ unit = assertDeploy(ear);
+
+ assertNoBean(Deployment.class);
+ }
+
+ public void testWarWithLibInEar() throws Exception
+ {
+ EnterpriseArchive ear = ShrinkWrap.create("warinear.ear", EnterpriseArchive.class);
+ WebArchive war = createWarWithLib(true, true);
+ ear.addModule(war);
+ MockArchiveManifest.addManifest(ear);
+ unit = assertDeploy(ear);
+
+ Deployment deployment = (Deployment) getBean(Deployment.class);
+ BeanDeploymentArchive bda = assertOneBDA(deployment, "warinear.ear/simple.war");
+ assertExpectedClasses(bda, ServletWebBean.class, UIWebBean.class);
+ assertExpectedWarResources(bda, "simple.war", true, "lib.jar");
+ }
+
+ public void testWarWithLibWithoutXmlInEar() throws Exception
+ {
+ EnterpriseArchive ear = ShrinkWrap.create("warinear.ear", EnterpriseArchive.class);
+ WebArchive war = createWarWithLib(true, false);
+ ear.addModule(war);
+ MockArchiveManifest.addManifest(ear);
+ unit = assertDeploy(ear);
+
+ Deployment deployment = (Deployment) getBean(Deployment.class);
+ BeanDeploymentArchive bda = assertOneBDA(deployment, "warinear.ear/simple.war");
+ assertExpectedClasses(bda, ServletWebBean.class);
+ assertExpectedWarResources(bda, "simple.war", true);
+ }
+
+ public void testWarWithoutXmlWithLibWithoutXmlInEar() throws Exception
+ {
+ EnterpriseArchive ear = ShrinkWrap.create("warinear.ear", EnterpriseArchive.class);
+ WebArchive war = createWarWithLib(false, false);
+ ear.addModule(war);
+ MockArchiveManifest.addManifest(ear);
+ unit = assertDeploy(ear);
+
+ assertNoBean(Deployment.class);
+ }
+
+ public void testWarWithoutXmlWithLibInEar() throws Exception
+ {
+ EnterpriseArchive ear = ShrinkWrap.create("warinear.ear", EnterpriseArchive.class);
+ WebArchive war = createWarWithLib(false, true);
+ ear.addModule(war);
+ MockArchiveManifest.addManifest(ear);
+ unit = assertDeploy(ear);
+
+ Deployment deployment = (Deployment) getBean(Deployment.class);
+ BeanDeploymentArchive bda = assertOneBDA(deployment, "warinear.ear/simple.war");
+ assertExpectedClasses(bda, UIWebBean.class);
+ assertExpectedWarResources(bda, "simple.war", false, "lib.jar");
+ }
+
+ public void testBasicEar() throws Exception
+ {
+ VirtualFile ear = createBasicEar();
+ unit = assertDeploy(ear);
+
+ Deployment deployment = (Deployment) getBean(Deployment.class);
+ Collection<BeanDeploymentArchive> bdas = getBDAs(deployment);
+ assertEquals(3, bdas.size());
+ BeanDeploymentArchive earBDA = null, simpleWarBDA = null, crmWarBDA = null;
+ for (BeanDeploymentArchive bda: bdas)
+ {
+ if (bda.getId().contains("simple.war"))
+ {
+ simpleWarBDA = bda;
+ assertBDAId(simpleWarBDA, "top-level.ear/simple.war");
+ assertExpectedClasses(simpleWarBDA, UIWebBean.class, ServletWebBean.class);
+ assertExpectedWarResources(simpleWarBDA, "simple.war", true, "ui.jar");
+ }
+ else if (bda.getId().contains("crm.war"))
+ {
+ crmWarBDA = bda;
+ assertBDAId(crmWarBDA, "top-level.ear/crm.war");
+ assertExpectedClasses(crmWarBDA, CrmWebBean.class);
+ assertExpectedResources(crmWarBDA, "crm.jar");
+ }
+ else
+ {
+ earBDA = bda;
+ assertBDAId(earBDA, "top-level.ear");
+ assertExpectedClasses(earBDA, BusinessInterface.class, MySLSBean.class,
+ ExternalWebBean.class, PlainJavaBean.class);
+ assertExpectedResources(earBDA, "ejbs.jar", "ext.jar", "simple.jar");
+ }
+ }
+ Collection<BeanDeploymentArchive> reachableBDAs = getReachableBDAs(earBDA);
+ assertTrue(reachableBDAs.isEmpty());
+ reachableBDAs = getReachableBDAs(simpleWarBDA);
+ assertEquals(1, reachableBDAs.size());
+ assertSame(earBDA, reachableBDAs.iterator().next());
+ }
+
+ public void testBasicEarFullCDI() throws Exception
+ {
+ EnterpriseArchive ear = ShrinkWrap.create("top-level.ear", EnterpriseArchive.class);
+ createLib(ear, "util.jar", true, SomeUtil.class);
+ createLib(ear, "ext.jar", true, ExternalWebBean.class);
+ JavaArchive ejbJar = createEjbJar("simple.jar", true, PlainJavaBean.class);
+ ear.addModule(ejbJar);
+ ejbJar = createEjbJar("ejbs.jar", true, MySLSBean.class, BusinessInterface.class);
+ ear.addModule(ejbJar);
+ WebArchive war = createWar("simple.war", true, ServletWebBean.class);
+ createLib(war, "ui.jar", true, UIWebBean.class);
+ ear.addModule(war);
+ war = createWar("crm.war", true, NotWBJsfBean.class);
+ createLib(war, "crm.jar", true, CrmWebBean.class);
+ ear.addModule(war);
+ unit = assertDeploy(ear);
+
+ Deployment deployment = (Deployment) getBean(Deployment.class);
+ Collection<BeanDeploymentArchive> bdas = getBDAs(deployment);
+ assertEquals(3, bdas.size());
+ BeanDeploymentArchive earBDA = null, simpleWarBDA = null, crmWarBDA = null;
+ for (BeanDeploymentArchive bda: bdas)
+ {
+ if (bda.getId().contains("simple.war"))
+ {
+ simpleWarBDA = bda;
+ assertBDAId(simpleWarBDA, "top-level.ear/simple.war");
+ assertExpectedClasses(simpleWarBDA, UIWebBean.class, ServletWebBean.class);
+ assertExpectedWarResources(simpleWarBDA, "top-level.ear/simple.war", true, "ui.jar");
+ }
+ else if (bda.getId().contains("crm.war"))
+ {
+ crmWarBDA = bda;
+ assertBDAId(crmWarBDA, "top-level.ear/crm.war");
+ assertExpectedClasses(crmWarBDA, CrmWebBean.class, NotWBJsfBean.class);
+ assertExpectedWarResources(crmWarBDA, "top-level.ear/crm.war", true, "crm.jar");
+ }
+ else
+ {
+ earBDA = bda;
+ assertBDAId(earBDA, "top-level.ear");
+ assertExpectedClasses(earBDA, BusinessInterface.class, MySLSBean.class,
+ ExternalWebBean.class, PlainJavaBean.class, SomeUtil.class);
+ assertExpectedResources(earBDA, "top-level.ear/lib/util.jar",
+ "top-level.ear/lib/ext.jar", "top-level.ear/simple.jar",
+ "top-level.ear/ejbs.jar");
+ }
+ }
+
+ Collection<BeanDeploymentArchive> reachableBDAs = getReachableBDAs(earBDA);
+ assertTrue(reachableBDAs.isEmpty());
+ reachableBDAs = getReachableBDAs(simpleWarBDA);
+ assertEquals(1, reachableBDAs.size());
+ assertSame(earBDA, reachableBDAs.iterator().next());
+ }
+
+ public void testBasicEarWithoutXml() throws Exception
+ {
+ EnterpriseArchive ear = ShrinkWrap.create("simple.ear", EnterpriseArchive.class);
+ createLib(ear, "util.jar", false, SomeUtil.class);
+ createLib(ear, "ext.jar", false, ExternalWebBean.class);
+ JavaArchive ejbJar = createEjbJar("simple.jar", false, PlainJavaBean.class);
+ ear.addModule(ejbJar);
+ ejbJar = createEjbJar("ejbs.jar", false, MySLSBean.class, BusinessInterface.class);
+ ear.addModule(ejbJar);
+ WebArchive war = createWar("simple.war", false, ServletWebBean.class);
+ createLib(war, "ui.jar", false, UIWebBean.class);
+ ear.addModule(war);
+ war = createWar("crm.war", false, NotWBJsfBean.class);
+ createLib(war, "crm.jar", false, CrmWebBean.class);
+ ear.addModule(war);
+ unit = assertDeploy(ear);
+
+ assertNoBean(Deployment.class);
+ }
+
+ private static void addExpectedResource(Set<String> expected, String unit)
+ {
+ addExpectedResource(expected, unit, "/META-INF/beans.xml");
+ }
+
+ private static void addExpectedResource(Set<String> expected, String unit, String suffix)
+ {
+ expected.add(unit + suffix);
+ }
+
+ private static void addExpectedClass(Set<String> expected, Class<?> clazz)
+ {
+ expected.add(clazz.getName());
+ }
+
+ private void assertExpectedClasses(BeanDeploymentArchive bda, Set<String> expected)
+ {
+ Collection<Class<?>> weldClasses = bda.getBeanClasses();
+ assertNotNull(weldClasses);
+ assertTrue("Unexpected empty weld classes collection", expected.isEmpty() || !weldClasses.isEmpty());
+ for (Class<?> clazz : weldClasses)
+ {
+ assertTrue("Found unexpected class: " + clazz.getName(), expected.remove(clazz.getName()));
+ }
+ assertEmpty("Should be emtpy, missing " + expected, expected);
+ }
+
+ private void assertExpectedClasses(BeanDeploymentArchive bda, Class<?>... classes)
+ {
+ Set<String> expected = new HashSet<String>();
+ for(Class<?> clazz: classes)
+ {
+ addExpectedClass(expected, clazz);
+ }
+ assertExpectedClasses(bda, expected);
+ }
+
+ private void assertExpectedResources(BeanDeploymentArchive bda, Set<String> expected)
+ {
+ Collection<URL> weldXml = bda.getBeansXml();
+ assertNotNull(weldXml);
+ assertTrue("Unexpected empty weld XML collection", expected.isEmpty() || !weldXml.isEmpty());
+ for (URL url : weldXml)
+ {
+ boolean found = false;
+ Iterator<String> iter = expected.iterator();
+ while (iter.hasNext())
+ {
+ String expectedURL = iter.next();
+ if (url.toExternalForm().endsWith(expectedURL))
+ {
+ iter.remove();
+ found = true;
+ break;
+ }
+ }
+ assertTrue("Unexpected wb url: " + url, found);
+ }
+ assertEmpty("Should be emtpy, missing " + expected, expected);
+ }
+
+ public void assertExpectedResources(BeanDeploymentArchive bda, String... units)
+ {
+ Set<String> expected = new HashSet<String>();
+ for (String unit: units)
+ {
+ addExpectedResource(expected, unit);
+ }
+ assertExpectedResources(bda, expected);
+ }
+
+ public void assertExpectedWarResources(BeanDeploymentArchive bda, String warUnit, boolean warResourceExpected, String... units)
+ {
+ Set<String> expected = new HashSet<String>();
+ if (warResourceExpected)
+ addExpectedResource(expected, warUnit, "/WEB-INF/beans.xml");
+ for (String unit: units)
+ {
+ addExpectedResource(expected, warUnit, "/WEB-INF/lib/" + unit + "/META-INF/beans.xml");
+ }
+ assertExpectedResources(bda, expected);
+ }
+
+ private JavaArchive createEjbJar(boolean jarCDI)
+ {
+ return createEjbJar("ejb.jar", jarCDI, PlainJavaBean.class);
+ }
+
+ private JavaArchive createEjbJar(String jarName, boolean jarCDI, Class<?>... classes)
+ {
+ JavaArchive ejbJar = ShrinkWrap.create(jarName, JavaArchive.class);
+ for (Class<?> clazz: classes)
+ {
+ ejbJar.addClass(clazz);
+ }
+ MockArchiveManifest.addManifest(ejbJar, jarCDI);
+ return ejbJar;
+ }
+
+ private WebArchive createWar(boolean warCDI)
+ {
+ return createWar("simple.war", warCDI, ServletWebBean.class);
+ }
+
+ private WebArchive createWar(String warName, boolean warCDI, Class<?>... classes)
+ {
+ WebArchive war = ShrinkWrap.create(warName, WebArchive.class);
+ for (Class<?> clazz: classes)
+ {
+ war.addClass(clazz);
+ }
+ MockArchiveManifest.addManifest(war, warCDI);
+ return war;
+ }
+
+ private WebArchive createWarWithLib(boolean warCDI, boolean libCDI)
+ {
+ WebArchive war = createWar(warCDI);
+ createLib(war, "lib.jar", libCDI, UIWebBean.class);
+ return war;
+ }
+
+ private WebArchive createWarWithLibs(boolean warCDI, boolean lib1CDI, boolean lib2CDI)
+ {
+ WebArchive war = createWar(warCDI);
+ createLib(war, "lib1.jar", lib1CDI, UIWebBean.class);
+ createLib(war, "lib2.jar", lib2CDI, CrmWebBean.class);
+ return war;
+ }
+
+
+ private void createLib(LibraryContainer<?> archive, String libName, boolean cdi, Class<?>... classes)
+ {
+ JavaArchive lib = ShrinkWrap.create(libName, JavaArchive.class);
+ if (cdi)
+ {
+ MockArchiveManifest.addCDIManifest(lib);
+ }
+ for (Class<?> libClass: classes)
+ {
+ lib.addClass(libClass);
+ }
+ archive.addLibrary(lib);
+ }
+
+ public Collection<BeanDeploymentArchive> getReachableBDAs(BeanDeploymentArchive bda)
+ {
+ Collection<BeanDeploymentArchive> result = new HashSet<BeanDeploymentArchive>();
+ getReachableBDAs(bda, result);
+ result.remove(bda);
+ return result;
+ }
+
+ private void getReachableBDAs(BeanDeploymentArchive bda, Collection<BeanDeploymentArchive> result)
+ {
+ if (result.contains(bda))
+ {
+ return;
+ }
+ result.add(bda);
+ for (BeanDeploymentArchive reachableBDA: bda.getBeanDeploymentArchives())
+ {
+ getReachableBDAs(reachableBDA, result);
+ }
+ }
+
+ private BeanDeploymentArchive assertOneBDA(Deployment deployment, String name)
+ {
+ Collection<BeanDeploymentArchive> bdas = getBDAs(deployment);
+ assertEquals(1, bdas.size());
+ BeanDeploymentArchive bda = bdas.iterator().next();
+ assertBDAId(bda, name);
+ assertTrue(getReachableBDAs(bda).isEmpty());
+ return bda;
+ }
+
+ private Collection<BeanDeploymentArchive> getBDAs(Deployment deployment)
+ {
+ assertNotNull(deployment);
+ Collection<BeanDeploymentArchive> bdas = deployment.getBeanDeploymentArchives();
+ assertNotNull(bdas);
+ return bdas;
+ }
+}
More information about the jboss-cvs-commits
mailing list