@Inject public CdiInterceptorWrapper(BeanManager beanManager) { // get the original interceptor from the bean manager directly // to avoid CDI bootstrap issues caused by wrong extension ordering final Set<Bean<?>> interceptorBeans = beanManager.getBeans(ValidationInterceptor.class); final Bean<?> interceptorBean = beanManager.resolve(interceptorBeans); this.interceptor = (ValidationInterceptor) beanManager.getReference( interceptorBean, ValidationInterceptor.class, beanManager.createCreationalContext(interceptorBean)); }
@Override @SuppressWarnings("unchecked") public void inject(Object instance) { if (beanManager != null) { AnnotatedType annotatedType = beanManager.createAnnotatedType((Class) instance.getClass()); InjectionTarget injectionTarget = beanManager.createInjectionTarget(annotatedType); CreationalContext context = beanManager.createCreationalContext(null); injectionTarget.inject(instance, context); } }
public class MenuChangeListener { // Outcommented because it's broken in current GF/WF versions. // @Inject // private Event<MenuChangeEvent> event; @Inject private BeanManager beanManager; @PostPersist @PostUpdate @PostRemove public void onChange(Menu menu) { // Outcommented because it's broken in current GF/WF versions. // event.fire(new MenuChangeEvent(menu)); beanManager.fireEvent(new MenuChangeEvent(menu)); } }
/** * Creates a new Jersey-specific {@link javax.enterprise.inject.spi.Bean} instance. */ public RequestScopeBean(BeanManager beanManager) { AnnotatedType<CdiRequestScope> annotatedType = beanManager.createAnnotatedType(CdiRequestScope.class); this.injectionTarget = beanManager.createInjectionTarget(annotatedType); }
@SuppressWarnings("unchecked") private static <T> T getReference(BeanManager bm, Type type, Bean<?> bean) { return (T) bm.getReference(bean, type, bm.createCreationalContext(bean)); }
@Test(groups = REWRITE) @SpecAssertion(section = FIRING_EVENTS, id = "a") public void testInjectedAnyEventCanFireEvent() { Bean<MiniBar> miniBarBean = getUniqueBean(MiniBar.class); InjectionPoint eventInjection = null; for (InjectionPoint candidate : miniBarBean.getInjectionPoints()) { if (candidate.getMember().getName().equals("miniBarEvent")) { eventInjection = candidate; break; assertNotNull(eventInjection); assertEquals(eventInjection.getQualifiers().size(), 1); assertTrue(eventInjection.getQualifiers().contains(Any.Literal.INSTANCE)); CreationalContext<MiniBar> miniBarCc = getCurrentManager().createCreationalContext(miniBarBean); MiniBar miniBar = miniBarBean.create(miniBarCc); miniBar.stock(); assertTrue(billing.isActive());
@Test @SpecAssertion(section = CONTEXT, id = "q") @SpecAssertion(section = BEAN, id = "aa") public void testDestroyedInstanceMustNotBeReturnedByGet() { assert getBeans(MySessionBean.class).size() == 1; Bean<MySessionBean> mySessionBean = getBeans(MySessionBean.class).iterator().next(); CreationalContext<MySessionBean> sessionCreationalContext = getCurrentManager().createCreationalContext(mySessionBean); MySessionBean beanInstance = mySessionBean.create(sessionCreationalContext); assert beanInstance != null; Context sessionContext = getCurrentManager().getContext(SessionScoped.class); destroyContext(sessionContext); setContextActive(sessionContext); beanInstance = sessionContext.get(mySessionBean); assert beanInstance == null; }
@Test @SpecAssertions({ @SpecAssertion(section = ANNOTATED_TYPE_CONFIGURATOR, id = "bd"), @SpecAssertion(section = ANNOTATED_TYPE_CONFIGURATOR, id = "bg"), @SpecAssertion(section = ANNOTATED_TYPE_CONFIGURATOR, id = "bi"), @SpecAssertion(section = ANNOTATED_TYPE_CONFIGURATOR, id = "bj"), @SpecAssertion(section = ANNOTATED_CONSTRUCTOR_CONFIGURATOR, id = "b"), @SpecAssertion(section = ANNOTATED_METHOD_CONFIGURATOR, id = "b"), @SpecAssertion(section = ANNOTATED_CONSTRUCTOR_CONFIGURATOR, id = "f"), @SpecAssertion(section = ANNOTATED_FIELD_CONFIGURATOR, id = "b"), @SpecAssertion(section = ANNOTATED_PARAMETER_CONFIGURATOR, id = "b") }) public void addMethodsOfAnnotationTypecConfigurator() { Bean<Dog> dogBean = getUniqueBean(Dog.class); CreationalContext<Dog> creationalContext = getCurrentManager().createCreationalContext(dogBean); Dog dog = dogBean.create(creationalContext); assertNotNull(dogBean); assertEquals(dogBean.getScope(), RequestScoped.class); assertNotNull(dog.getFeed()); assertEquals(dog.getName(), DogDependenciesProducer.dogName); List<InjectionPoint> dogsInjectionPoints = dogBean.getInjectionPoints().stream() .filter(injectionPoint -> injectionPoint.getQualifiers().contains(new Dogs.DogsLiteral())).collect( Collectors.toList()); assertEquals(dogsInjectionPoints.size(), 2); Optional<InjectionPoint> feedIpOptional = dogsInjectionPoints.stream().filter(injectionPoint -> injectionPoint.getType().equals(Feed.class)) .findFirst(); assertTrue(feedIpOptional.isPresent()); dogBean.destroy(dog, creationalContext); assertTrue(DogDependenciesProducer.disposerCalled.get()); }
@Test @SpecAssertion(section = OBSERVES, id = "a") public void testPrivateObserverMethodInvoked() { PrivateObserver.reset(); getCurrentManager().fireEvent(new Delivery()); assertTrue(PrivateObserver.isObserved); }
@Test @SpecAssertion(section = INTERCEPTION_FACTORY, id = "g") public void interceptionFactoryBeanIsAvailable() { Bean<?> interceptionFactoryBean = getCurrentManager().resolve(getCurrentManager().getBeans(InterceptionFactory.class)); Assert.assertEquals(Dependent.class, interceptionFactoryBean.getScope()); Assert.assertEquals(Stream.of(Default.Literal.INSTANCE, Any.Literal.INSTANCE).collect(Collectors.toSet()), interceptionFactoryBean.getQualifiers()); }
@Test @SpecAssertion(section = BM_RESOLVE_AMBIGUOUS_DEP, id = "a") public void testAmbiguousDependencyResolved() { Set<Bean<?>> beans = getCurrentManager().getBeans(Food.class); assertEquals(beans.size(), 2); Bean<?> bean = getCurrentManager().resolve(beans); assertNotNull(bean); assertTrue(bean.isAlternative()); assertTrue(typeSetMatches(bean.getTypes(), Food.class, Soy.class, Object.class)); }
@Test(groups = INTEGRATION) @SpecAssertions({ @SpecAssertion(section = DIRECT_AND_INDIRECT_SPECIALIZATION_EE, id = "k") }) public void testSpecializingBeanHasNameOfSpecializedBean() { String expectedName = "farmer"; Set<Bean<?>> beans = getCurrentManager().getBeans(expectedName); assertEquals(beans.size(), 1); Bean<?> farmerBean = beans.iterator().next(); assertEquals(farmerBean.getName(), expectedName); assertEquals(farmerBean.getBeanClass(), LazyFarmer.class); }
@Test @SpecAssertions({ @SpecAssertion(section = ALTERNATIVE_METADATA_SOURCES, id = "hf"), @SpecAssertion(section = ALTERNATIVE_METADATA_SOURCES, id = "ad") }) public void testGetBaseTypeUsedToDetermineTypeOfDisposerInjectionPoint() { Bean<Bill> bill = getBeans(Bill.class, new CheapLiteral()).iterator().next(); CreationalContext<Bill> context = getCurrentManager().createCreationalContext(bill); Bill instance = getCurrentManager().getContext(bill.getScope()).get(bill); bill.destroy(instance, context); assertEquals(getContextualReference(Grocery.class, Any.Literal.INSTANCE).getDisposerFruit().getMetadata().getType(), TropicalFruit.class); assertTrue(GroceryWrapper.isGetBaseTypeOfBillDisposerParameterUsed()); // ad assertion assertTrue(getContextualReference(Grocery.class, Any.Literal.INSTANCE).getDisposerFruit().getMetadata().getQualifiers().contains(Any.Literal.INSTANCE)); }
@Test @SpecAssertion(section = ALTERNATIVE_METADATA_SOURCES, id = "ab") public void testDisposesIsAppliedToMethodParameter() { Bean<Yogurt> yogurt = getBeans(Yogurt.class, new ExpensiveLiteral()).iterator().next(); CreationalContext<Yogurt> context = getCurrentManager().createCreationalContext(yogurt); Yogurt instance = getCurrentManager().getContext(yogurt.getScope()).get(yogurt, context); yogurt.destroy(instance, context); assertTrue(Grocery.isDisposerMethodCalled()); }
@SuppressWarnings("serial") @Test @SpecAssertions({ @SpecAssertion(section = BEFORE_BEAN_DISCOVERY, id = "b") }) public void testAddAnnotatedTypeWithConfigurator() { Bean<Baz> bazBean = getUniqueBean(Baz.class, Pro.ProLiteral.INSTANCE); assertEquals(bazBean.getScope(), RequestScoped.class); Baz baz = (Baz) getCurrentManager().getReference(bazBean, Baz.class, getCurrentManager().createCreationalContext(bazBean)); assertFalse(baz.getBarInstance().isUnsatisfied()); }
@Test @SpecAssertions({ @SpecAssertion(section = ALTERNATIVE_METADATA_SOURCES, id = "j"), @SpecAssertion(section = ALTERNATIVE_METADATA_SOURCES, id = "ac") }) public void testGetBaseTypeUsedToDetermineTypeOfDisposalParameter() throws NoSuchMethodException { Bean<Carrot> carrot = getBeans(Carrot.class, new CheapLiteral()).iterator().next(); CreationalContext<Carrot> context = getCurrentManager().createCreationalContext(carrot); Carrot instance = getCurrentManager().getContext(carrot.getScope()).get(carrot, context); carrot.destroy(instance, context); // ac assertion - disposal method called after adding extra qualifier to disposer parameter assertNotNull(getContextualReference(Grocery.class, Any.Literal.INSTANCE).getWrappedDisposalParameter()); assertEquals(getContextualReference(Grocery.class, Any.Literal.INSTANCE).getWrappedDisposalParameter().getClass(), Carrot.class); }
@Test(groups = JAVAEE_FULL) @SpecAssertions({ @SpecAssertion(section = DECLARING_SELECTED_ALTERNATIVES_BEAN_ARCHIVE_EE, id = "bb") }) public void testAlternatives() throws Exception { Set<Bean<?>> beans = getCurrentManager().getBeans(AlternativeBar.class); assertEquals(beans.size(), 1); assertEquals(beans.iterator().next().getBeanClass(), AlternativeBar.class); // Bar alternative is enabled in F only assertFalse(barInspector.getBar().isAlternative()); }
@Test(groups = { JAX_WS, JAVAEE_FULL }) @SpecAssertion(section = RESOURCE_LIFECYCLE, id = "le") public void testInjectionOfWebServiceReference() { Bean<ManagedBean> managedBean = getUniqueBean(ManagedBean.class); CreationalContext<ManagedBean> creationalContext = getCurrentManager().createCreationalContext(managedBean); ManagedBean instance = managedBean.create(creationalContext); Assert.assertNotNull(instance.getTranslator()); Assert.assertEquals(instance.getTranslator().translate(), TranslatorEndpoint.MESSAGE); } }
@Test(dataProvider = ARQUILLIAN_DATA_PROVIDER) @SpecAssertion(section = MEMBER_LEVEL_INHERITANCE, id = "g") public void testObserver(Foo foo) throws Exception { assertNotNull(foo); getCurrentManager().fireEvent(new Qux(null)); assertNotNull(foo.getT1BazEvent()); assertEquals(foo.getT1ObserverInjectionPoint(), "ok"); }
@SuppressWarnings("unchecked") @Test @SpecAssertions({ @SpecAssertion(section = BM_OBTAIN_INJECTABLE_REFERENCE, id = "b") }) public void testGetInjectableReferenceReturnsDelegateForDelegateInjectionPoint() { // Get hold of the correct IP by inspecting the ones the container created for LoggerConsumer assert getBeans(LoggerConsumer.class).size() == 1; Bean<LoggerConsumer> bean = getBeans(LoggerConsumer.class).iterator().next(); InjectionPoint loggerInjectionPoint = null; for (InjectionPoint ip : bean.getInjectionPoints()) { if (ip.getAnnotated().getTypeClosure().contains(Logger.class) && ip.getQualifiers().size() == 1 && ip.getQualifiers().contains(Default.Literal.INSTANCE)) { loggerInjectionPoint = ip; } } // Now lookup an injectable reference and check that it is of type Logger CreationalContext<Logger> creationalContext = getCurrentManager().createCreationalContext( (Bean<Logger>) loggerInjectionPoint.getBean()); Object injectedDelegateLogger = getCurrentManager().getInjectableReference(loggerInjectionPoint, creationalContext); assert injectedDelegateLogger instanceof Logger; Logger logger = (Logger) injectedDelegateLogger; // User the logger String message = "foo123"; TimestampLogger.reset(); logger.log(message); assert message.equals(TimestampLogger.getLoggedMessage()); } }