org.apache.deltaspike.cdise.api.CdiContainer Java Examples

void applyAfterClassConfig()
{
    CdiContainer container = CdiContainerLoader.getCdiContainer();

    stopStartedScopes(container);

    if (this.containerStarted)
    {
        if (CdiTestSuiteRunner.isStopContainerAllowed())
        {
            shutdownExternalContainers();

            container.shutdown(); //stop the container on the same level which started it
            CdiTestSuiteRunner.setContainerStarted(false);
        }
    }
}
 

@Test
public void basicInjection() // useless because of tcks but nice to have when working on this specific container
{
    final CdiContainer container = CdiContainerLoader.getCdiContainer();
    container.boot();

    try
    {
        final BeanManager beanManager = container.getBeanManager();
        assertEquals("foo", Foo.class.cast(beanManager.getReference(beanManager.resolve(beanManager.getBeans(Foo.class)), Foo.class, null)).name());
    }
    finally
    {
        container.shutdown();
    }
}
 

@Test
public void testContainerBoot()
{
    CdiContainer cc = CdiContainerLoader.getCdiContainer();
    Assert.assertNotNull(cc);

    cc.boot();
    cc.getContextControl().startContexts();

    BeanManager bm = cc.getBeanManager();
    Assert.assertNotNull(bm);
    
    Set<Bean<?>> beans = bm.getBeans(CarRepair.class);
    Bean<?> bean = bm.resolve(beans);
    
    CarRepair carRepair = (CarRepair) bm.getReference(bean, CarRepair.class, bm.createCreationalContext(bean));
    Assert.assertNotNull(carRepair);

    Assert.assertNotNull(carRepair.getCar());
    Assert.assertNotNull(carRepair.getCar().getUser());

    cc.shutdown();
}
 

@Test
public void testBootRequest() throws Exception
{
    CdiContainer cdiContainer = CdiContainerLoader.getCdiContainer();
    cdiContainer.boot();
    cdiContainer.getContextControl().startContexts();
    int port = createServer();
    testRead(port);

    try
    {
        shutdown();
    }
    finally
    {
        cdiContainer.shutdown(); //also calls #stopContexts
    }
}
 

public static void main(String[] args)
{
    CdiContainer cdiContainer = CdiContainerLoader.getCdiContainer();
    cdiContainer.boot();

    ContextControl contextControl = cdiContainer.getContextControl();
    contextControl.startContext(ApplicationScoped.class);

    SettingsBean settingsBean = BeanProvider.getContextualReference(SettingsBean.class, false);

    LOG.info("configured int-value #1: " + settingsBean.getIntProperty1());
    LOG.info("configured long-value #2: " + settingsBean.getProperty2());
    LOG.info("configured inverse-value #2: " + settingsBean.getInverseProperty());
    LOG.info("configured location (custom config): " + settingsBean.getLocationId().name());
    
    cdiContainer.shutdown();
}
 

public static void main(String[] args) throws InterruptedException
{
    CdiContainer cdiContainer = CdiContainerLoader.getCdiContainer();
    cdiContainer.boot();

    ContextControl contextControl = cdiContainer.getContextControl();
    contextControl.startContext(ApplicationScoped.class);

    GlobalResultHolder globalResultHolder =
        BeanProvider.getContextualReference(GlobalResultHolder.class);

    while (globalResultHolder.getCount() < 100)
    {
        Thread.sleep(500);
        LOG.info("current count: " + globalResultHolder.getCount());
    }
    LOG.info("completed!");

    contextControl.stopContext(ApplicationScoped.class);
    cdiContainer.shutdown();
}
 

void applyBeforeFeatureConfig(Class testClass) {
    CdiContainer container = CdiContainerLoader.getCdiContainer();

    if (!isContainerStarted()) {
        container.boot(CdiTestSuiteRunner.getTestContainerConfig());
        containerStarted = true;
        bootExternalContainers(testClass);
    }

    List<Class<? extends Annotation>> restrictedScopes = new ArrayList<Class<? extends Annotation>>();

    //controlled by the container and not supported by weld:
    restrictedScopes.add(ApplicationScoped.class);
    restrictedScopes.add(Singleton.class);

    if (this.parent == null && this.testControl.getClass().equals(TestControlLiteral.class)) {
        //skip scope-handling if @TestControl isn't used explicitly on the test-class -> TODO re-visit it
        restrictedScopes.add(RequestScoped.class);
        restrictedScopes.add(SessionScoped.class);
    }

    this.previousProjectStage = ProjectStageProducer.getInstance().getProjectStage();
    ProjectStageProducer.setProjectStage(this.projectStage);

    startScopes(container, testClass, null, restrictedScopes.toArray(new Class[restrictedScopes.size()]));
}
 

void applyAfterFeatureConfig() {
    ProjectStageProducer.setProjectStage(previousProjectStage);
    previousProjectStage = null;

    CdiContainer container = CdiContainerLoader.getCdiContainer();

    stopStartedScopes(container);

    if (this.containerStarted) {
        if (isStopContainerAllowed()) {
            shutdownExternalContainers();

            container.shutdown(); //stop the container on the same level which started it
            containerStarted = false;
        }
    }
}
 

@Override
public CdiContainer start() {
    final CdiContainer cdiContainer = CdiContainerLoader.getCdiContainer();
    cdiContainer.boot(configuration("cdictrl"));
    cdiContainer.getContextControl().startContexts();
    return cdiContainer;
}
 

private void stopStartedScopes(CdiContainer container) {
    while (!this.startedScopes.empty()) {
        Class<? extends Annotation> scopeAnnotation = this.startedScopes.pop();
        //TODO check if context was started by parent
        try {
            container.getContextControl().stopContext(scopeAnnotation);
            onScopeStopped(scopeAnnotation);
        } catch (RuntimeException e) {
            Logger logger = Logger.getLogger(CdiCucumberTestRunner.class.getName());
            logger.setLevel(Level.SEVERE);
            logger.log(Level.SEVERE, "failed to stop scope @" + scopeAnnotation.getName(), e);
        }
    }
}
 

private void stopStartedScopes(CdiContainer container)
{
    try
    {
        automaticScopeHandlingActive.set(TRUE);

        while (!this.startedScopes.empty())
        {
            Class<? extends Annotation> scopeAnnotation = this.startedScopes.pop();
            //TODO check if context was started by parent
            try
            {
                container.getContextControl().stopContext(scopeAnnotation);
                onScopeStopped(scopeAnnotation);
            }
            catch (RuntimeException e)
            {
                Logger logger = Logger.getLogger(CdiTestRunner.class.getName());
                logger.setLevel(Level.SEVERE);
                logger.log(Level.SEVERE, "failed to stop scope @" + scopeAnnotation.getName(), e);
            }
        }
    }
    finally
    {
        automaticScopeHandlingActive.remove();
        automaticScopeHandlingActive.set(null);
    }
}
 

@Override
public void run(RunNotifier runNotifier)
{
    CdiContainer container = CdiContainerLoader.getCdiContainer();

    if (!containerStarted)
    {
        container.boot(CdiTestSuiteRunner.getTestContainerConfig());
        containerStarted = true;
    }

    super.run(runNotifier);
}
 

void applyBeforeClassConfig(Class<?> testClass)
{
    CdiContainer container = CdiContainerLoader.getCdiContainer();

    if (!isContainerStarted())
    {
        if (!CdiTestSuiteRunner.isContainerStarted())
        {
            // We are setting this system property to make the deployment for Weld "flat"
            // This (amongst other things) means that alternatives enabled via beans.xml will be 
            // enabled globally
            // Beginning with Weld 2.x you could use Weld.property(), but here we depend on Weld 1.x API
            // Note that Weld 1 was "flat" anyway, so this property only affects newer versions of Weld
            System.setProperty("org.jboss.weld.se.archive.isolation", "false");

            CdiTestSuiteRunner.applyTestSpecificMetaData(testClass);

            container.boot(CdiTestSuiteRunner.getTestContainerConfig());
            setContainerStarted();

            bootExternalContainers(testClass);
        }
    }

    List<Class<? extends Annotation>> restrictedScopes = new ArrayList<Class<? extends Annotation>>();

    //controlled by the container and not supported by weld:
    restrictedScopes.add(ApplicationScoped.class);
    restrictedScopes.add(Singleton.class);

    if (this.parent == null && this.testControl.getClass().equals(TestControlLiteral.class))
    {
        //skip scope-handling if @TestControl isn't used explicitly on the test-class -> TODO re-visit it
        restrictedScopes.add(RequestScoped.class);
        restrictedScopes.add(SessionScoped.class);
    }

    startScopes(container, testClass, null, restrictedScopes.toArray(new Class[restrictedScopes.size()]));
}
 

@Override
public void run(RunNotifier notifier)
{
    if (this.testSuiteClass == null)
    {
        throw new IllegalStateException("no test-suite class found");
    }

    CdiContainer container = CdiContainerLoader.getCdiContainer();

    if (!containerStarted)
    {
        applyTestSpecificMetaData(getTestClass().getJavaClass());

        container.boot(getTestContainerConfig());
        containerStarted = true;
    }

    notifier.addListener(new LogRunListener());

    try
    {
        super.run(notifier);
    }
    finally
    {
        if (STOP_CONTAINER)
        {
            container.shutdown();
            containerStarted = false;
        }
    }
}
 

protected void startContainer()
{
    CdiContainer cdiContainer = CdiContainerLoader.getCdiContainer();
    cdiContainer.boot();
    ContextControl contextControl = cdiContainer.getContextControl();
    contextControl.startContext(ApplicationScoped.class);
    contextControl.startContext(SessionScoped.class);
    contextControl.startContext(RequestScoped.class);
}
 

private void startScopes(CdiContainer container,
                         Class testClass,
                         Method testMethod,
                         Class<? extends Annotation>... restrictedScopes)
{
    try
    {
        automaticScopeHandlingActive.set(TRUE);

        ContextControl contextControl = container.getContextControl();

        List<Class<? extends Annotation>> scopeClasses = new ArrayList<Class<? extends Annotation>>();

        Collections.addAll(scopeClasses, this.testControl.startScopes());

        if (scopeClasses.isEmpty())
        {
            addScopesForDefaultBehavior(scopeClasses);
        }
        else
        {
            List<TestControlValidator> testControlValidatorList =
                ServiceUtils.loadServiceImplementations(TestControlValidator.class);

            for (TestControlValidator testControlValidator : testControlValidatorList)
            {
                if (testControlValidator instanceof TestAware)
                {
                    if (testMethod != null)
                    {
                        ((TestAware)testControlValidator).setTestMethod(testMethod);
                    }
                    ((TestAware)testControlValidator).setTestClass(testClass);
                }
                try
                {
                    testControlValidator.validate(this.testControl);
                }
                finally
                {
                    if (testControlValidator instanceof TestAware)
                    {
                        ((TestAware)testControlValidator).setTestClass(null);
                        ((TestAware)testControlValidator).setTestMethod(null);
                    }
                }
            }
        }

        for (Class<? extends Annotation> scopeAnnotation : scopeClasses)
        {
            if (this.parent != null && this.parent.isScopeStarted(scopeAnnotation))
            {
                continue;
            }

            if (isRestrictedScope(scopeAnnotation, restrictedScopes))
            {
                continue;
            }

            try
            {
                //force a clean context - TODO discuss onScopeStopped call
                contextControl.stopContext(scopeAnnotation);

                contextControl.startContext(scopeAnnotation);
                this.startedScopes.add(scopeAnnotation);

                onScopeStarted(scopeAnnotation);
            }
            catch (RuntimeException e)
            {
                Logger logger = Logger.getLogger(CdiTestRunner.class.getName());
                logger.setLevel(Level.SEVERE);
                logger.log(Level.SEVERE, "failed to start scope @" + scopeAnnotation.getName(), e);
            }
        }
    }
    finally
    {
        automaticScopeHandlingActive.set(null);
        automaticScopeHandlingActive.remove();
    }
}
 

public static void main(final String[] args) throws Exception {
   CdiContainer cdiContainer = CdiContainerLoader.getCdiContainer();
   cdiContainer.boot();

   cdiContainer.shutdown();
}
 

private ContextControl getContextControl()
{
    CdiContainer container = CdiContainerLoader.getCdiContainer();
    return container.getContextControl();
}
 

private void startScopes(CdiContainer container,
                         Class testClass,
                         Method testMethod,
                         Class<? extends Annotation>... restrictedScopes) {

    ContextControl contextControl = container.getContextControl();

    List<Class<? extends Annotation>> scopeClasses = new ArrayList<Class<? extends Annotation>>();

    Collections.addAll(scopeClasses, this.testControl.startScopes());

    if (scopeClasses.isEmpty()) {
        addScopesForDefaultBehavior(scopeClasses);
    } else {
        List<TestControlValidator> testControlValidatorList =
                ServiceUtils.loadServiceImplementations(TestControlValidator.class);

        for (TestControlValidator testControlValidator : testControlValidatorList) {
            if (testControlValidator instanceof TestAware) {
                if (testMethod != null) {
                    ((TestAware) testControlValidator).setTestMethod(testMethod);
                }
                ((TestAware) testControlValidator).setTestClass(testClass);
            }
            try {
                testControlValidator.validate(this.testControl);
            } finally {
                if (testControlValidator instanceof TestAware) {
                    ((TestAware) testControlValidator).setTestClass(null);
                    ((TestAware) testControlValidator).setTestMethod(null);
                }
            }
        }
    }

    for (Class<? extends Annotation> scopeAnnotation : scopeClasses) {
        if (this.parent != null && this.parent.isScopeStarted(scopeAnnotation)) {
            continue;
        }

        if (isRestrictedScope(scopeAnnotation, restrictedScopes)) {
            continue;
        }

        try {
            //force a clean context - TODO discuss onScopeStopped call
            contextControl.stopContext(scopeAnnotation);

            contextControl.startContext(scopeAnnotation);
            this.startedScopes.add(scopeAnnotation);

            onScopeStarted(scopeAnnotation);
        } catch (RuntimeException e) {
            Logger logger = Logger.getLogger(CdiCucumberTestRunner.class.getName());
            logger.setLevel(Level.SEVERE);
            logger.log(Level.SEVERE, "failed to start scope @" + scopeAnnotation.getName(), e);
        }
    }

}
 

@Override
public void stop(final CdiContainer cdiContainer) {
    cdiContainer.getContextControl().stopContexts();
    cdiContainer.shutdown();
}
 

@Test
public void testParallelThreadExecution() throws Exception
{
    final CdiContainer cc = CdiContainerLoader.getCdiContainer();
    Assert.assertNotNull(cc);

    cc.boot();
    cc.getContextControl().startContexts();

    final BeanManager bm = cc.getBeanManager();
    Assert.assertNotNull(bm);

    final AtomicInteger numErrors = new AtomicInteger(0);
    final ContextControl contextControl = cc.getContextControl();

    Runnable runnable = new Runnable()
    {
        @Override
        public void run()
        {
            try
            {
                contextControl.startContext(SessionScoped.class);
                contextControl.startContext(RequestScoped.class);


                Set<Bean<?>> beans = bm.getBeans(CarRepair.class);
                Bean<?> bean = bm.resolve(beans);

                CarRepair carRepair = (CarRepair)
                        bm.getReference(bean, CarRepair.class, bm.createCreationalContext(bean));
                Assert.assertNotNull(carRepair);

                for (int i = 0; i < 100000; i++)
                {
                    // we need the threads doing something ;)
                    Assert.assertNotNull(carRepair.getCar());
                    Assert.assertNotNull(carRepair.getCar().getUser());
                    Assert.assertNull(carRepair.getCar().getUser().getName());
                }
                contextControl.stopContext(RequestScoped.class);
                contextControl.stopContext(SessionScoped.class);
            }
            catch (Throwable e)
            {
                log.log(Level.SEVERE, "An exception happened on a new worker thread", e);
                numErrors.incrementAndGet();
            }
        }
    };


    Thread[] threads = new Thread[NUM_THREADS];
    for (int i = 0 ; i < NUM_THREADS; i++)
    {
        threads[i] = new Thread(runnable);
    }

    for (int i = 0 ; i < NUM_THREADS; i++)
    {
        threads[i].start();
    }

    for (int i = 0 ; i < NUM_THREADS; i++)
    {
        threads[i].join();
    }

    Assert.assertEquals("An error happened while executing parallel threads", 0, numErrors.get());


    cc.shutdown();
}
 

/**
 * Stops and starts: application-, session- and request-scope.
 * <p/>
 * application-scoped instance has a ref to
 * request-scoped instance which has a ref to
 * session-scoped instance.
 * <p/>
 * If the deepest ref has the expected value, all levels in between were resetted correctly.
 */
@Test
public void testRestartContexts()
{
    CdiContainer cdiContainer = CdiContainerLoader.getCdiContainer();
    Assert.assertNotNull(cdiContainer);

    cdiContainer.boot();
    cdiContainer.getContextControl().startContexts();

    BeanManager beanManager = cdiContainer.getBeanManager();
    Assert.assertNotNull(beanManager);

    Set<Bean<?>> beans = beanManager.getBeans(CarRepair.class);
    Bean<?> bean = beanManager.resolve(beans);

    CarRepair carRepair = (CarRepair)
        beanManager.getReference(bean, CarRepair.class, beanManager.createCreationalContext(bean));

    Assert.assertNotNull(carRepair);

    Car car = carRepair.getCar();

    Assert.assertNotNull(car);
    Assert.assertNotNull(car.getUser());


    carRepair.getCar().getUser().setName("tester");
    Assert.assertEquals("tester", car.getUser().getName());

    Assert.assertFalse(CarRepair.isPreDestroyCalled());
    Assert.assertFalse(Car.isPreDestroyCalled());
    Assert.assertFalse(TestUser.isPreDestroyCalled());

    cdiContainer.getContextControl().stopContexts();

    Assert.assertTrue(CarRepair.isPreDestroyCalled());
    Assert.assertTrue(Car.isPreDestroyCalled());
    Assert.assertTrue(TestUser.isPreDestroyCalled());

    try
    {
        car.getUser();

        // accessing the car should have triggered a ContextNotActiveException
        Assert.fail();
    }
    catch (ContextNotActiveException e)
    {
        //do nothing - exception expected
    }

    cdiContainer.getContextControl().startContexts();

    carRepair = (CarRepair)
        beanManager.getReference(bean, CarRepair.class, beanManager.createCreationalContext(bean));

    Assert.assertNotNull(carRepair.getCar());
    Assert.assertNotNull(carRepair.getCar().getUser());
    Assert.assertNull(carRepair.getCar().getUser().getName());

    cdiContainer.shutdown();
}
 

@LockedCDIImplementation(versions = {
        @LockedVersionRange(implementation = CdiImplementation.WELD11, versionRange = "[1.1.14,1.2)"),
        @LockedVersionRange(implementation = CdiImplementation.WELD20, versionRange = "[2.0.1.Final,2.1)")
    })
@Test
public void testShutdownWithInactiveContexts()
{
    CdiContainer cdiContainer = CdiContainerLoader.getCdiContainer();
    Assert.assertNotNull(cdiContainer);

    cdiContainer.boot();
    cdiContainer.getContextControl().startContexts();

    // now do some random stuff
    BeanManager beanManager = cdiContainer.getBeanManager();
    Assert.assertNotNull(beanManager);

    Set<Bean<?>> beans = beanManager.getBeans(CarRepair.class);
    Bean<?> bean = beanManager.resolve(beans);

    CarRepair carRepair = (CarRepair)
            beanManager.getReference(bean, CarRepair.class, beanManager.createCreationalContext(bean));

    Assert.assertNotNull(carRepair);

    Car car = carRepair.getCar();

    Assert.assertNotNull(car);
    Assert.assertNotNull(car.getUser());


    carRepair.getCar().getUser().setName("tester");
    Assert.assertEquals("tester", car.getUser().getName());

    Assert.assertFalse(CarRepair.isPreDestroyCalled());
    Assert.assertFalse(Car.isPreDestroyCalled());
    Assert.assertFalse(TestUser.isPreDestroyCalled());

    cdiContainer.getContextControl().stopContexts();

    Assert.assertTrue(CarRepair.isPreDestroyCalled());
    Assert.assertTrue(Car.isPreDestroyCalled());
    Assert.assertTrue(TestUser.isPreDestroyCalled());

    cdiContainer.shutdown();
}