@Test @SpecAssertion(section = NEW_EE, id = "r") public void testNewBeanHasOnlyOneQualifier() { Set<Bean<WrappedEnterpriseBeanLocal>> beans = getBeans(WrappedEnterpriseBeanLocal.class, New.Literal.of( WrappedEnterpriseBean.class)); assert beans.size() == 1; Bean<WrappedEnterpriseBeanLocal> newEnterpriseBean = beans.iterator().next(); assert newEnterpriseBean.getQualifiers().size() == 1; assert newEnterpriseBean.getQualifiers().iterator().next().annotationType().equals(New.class); }
@Test @SpecAssertion(section = NEW_EE, id = "p") public void testNewBeanIsDependentScoped() { Set<Bean<WrappedEnterpriseBeanLocal>> beans = getBeans(WrappedEnterpriseBeanLocal.class, New.Literal.of( WrappedEnterpriseBean.class)); assert beans.size() == 1; Bean<WrappedEnterpriseBeanLocal> newEnterpriseBean = beans.iterator().next(); assert Dependent.class.equals(newEnterpriseBean.getScope()); }
public static <T> BeanAttributes<T> forNewBean(Set<Type> types, final Class<?> javaClass) { Set<Annotation> qualifiers = Collections.<Annotation>singleton(New.Literal.of(javaClass)); return new ImmutableBeanAttributes<T>(Collections.<Class<? extends Annotation>> emptySet(), false, null, qualifiers, types, Dependent.class); }
throw new IllegalStateException("Cannot transform @New when there is no known raw type"); } else if (newQualifier.value().equals(New.class)) { qualifier = New.Literal.of(rawType); qualifierInstance = QualifierInstance.of(qualifier, store);
throw new IllegalStateException("Cannot transform @New when there is no known raw type"); } else if (newQualifier.value().equals(New.class)) { qualifier = New.Literal.of(rawType); qualifierInstance = QualifierInstance.of(qualifier, store);
@Test @SpecAssertions({ @SpecAssertion(section = NEW_EE, id = "j"), @SpecAssertion(section = NEW_EE, id = "k") }) public void testForEachEnterpriseBeanANewBeanExists() { Bean<OrderLocal> orderBean = getBeans(OrderLocal.class).iterator().next(); Set<Bean<OrderLocal>> newOrderBeans = getBeans(OrderLocal.class, New.Literal.of(Order.class)); assert newOrderBeans.size() == 1; Bean<OrderLocal> newOrderBean = newOrderBeans.iterator().next(); assert orderBean.getQualifiers().size() == 2; assert orderBean.getQualifiers().contains(Default.Literal.INSTANCE); assert orderBean.getQualifiers().contains(Any.Literal.INSTANCE); assert orderBean.getTypes().equals(newOrderBean.getTypes()); assert orderBean.getBeanClass().equals(newOrderBean.getBeanClass()); assert newOrderBean.getQualifiers().size() == 1; assert newOrderBean.getQualifiers().iterator().next().annotationType().equals(New.class); Set<Bean<LionLocal>> lionBeans = getBeans(LionLocal.class, TameLiteral.INSTANCE); Set<Bean<LionLocal>> newLionBeans = getBeans(LionLocal.class, New.Literal.of(Lion.class)); assert lionBeans.size() == 1; assert newLionBeans.size() == 1; Bean<LionLocal> lionBean = lionBeans.iterator().next(); Bean<LionLocal> newLionBean = newLionBeans.iterator().next(); assert lionBean.getQualifiers().size() == 2; assert lionBean.getQualifiers().contains(TameLiteral.INSTANCE); assert lionBean.getQualifiers().contains(Any.Literal.INSTANCE); assert newLionBean.getQualifiers().size() == 1; assert newLionBean.getQualifiers().iterator().next().annotationType().equals(New.class); assert lionBean.getTypes().equals(newLionBean.getTypes()); assert lionBean.getBeanClass().equals(newLionBean.getBeanClass()); }
@SuppressWarnings("unchecked") @Test @SpecAssertions({ @SpecAssertion(section = PROCESS_BEAN_ATTRIBUTES, id = "aa"), @SpecAssertion(section = PROCESS_BEAN_ATTRIBUTES, id = "ad") }) public void testManagedBeanAttributes() { assertEquals(getCurrentManager().getBeans(Alpha.class, New.Literal.of(Alpha.class)).size(), 1); // No event is fired for any @New qualified bean assertEquals(extension.getAlphaAttributesObserved(), 1); BeanAttributes<Alpha> attributes = extension.getAlphaAttributes(); assertNotNull(attributes); assertEquals(attributes.getScope(), ApplicationScoped.class); verifyName(attributes, "alpha"); assertTrue(attributes.isAlternative()); assertTrue(typeSetMatches(attributes.getTypes(), Object.class, Alpha.class)); assertTrue(typeSetMatches(attributes.getStereotypes(), AlphaStereotype.class)); assertTrue(annotationSetMatches(attributes.getQualifiers(), AlphaQualifier.class, Named.class, Any.class)); // Event is not fired for managed bean that is not enabled assertNull(extension.getMike()); }
/** * Sets up both the bean and the @New bean with different configurations so that the correct producer method used can be * determined. * * @throws Exception */ @Test @SpecAssertion(section = NEW_EE, id = "v") public void testNewBeanHasNoProducerMethods() throws Exception { FoxLocal fox = getContextualReference(FoxLocal.class); FoxLocal newFox = getContextualReference(FoxLocal.class, New.Literal.of(Fox.class)); fox.setNextLitterSize(3); newFox.setNextLitterSize(5); @SuppressWarnings("serial") Litter theOnlyLitter = getContextualReference(Litter.class, new AnnotationLiteral<Tame>() { }); assert theOnlyLitter.getQuantity() == fox.getNextLitterSize(); }
@Test @SpecAssertion(section = NEW_EE, id = "x") public void testNewBeanHasNoDisposalMethods() throws Exception { FoxLocal fox = getContextualReference(FoxLocal.class); FoxLocal newFox = getContextualReference(FoxLocal.class, New.Literal.of(Fox.class)); @SuppressWarnings("serial") Set<Bean<Litter>> beans = getBeans(Litter.class, new AnnotationLiteral<Tame>() { }); assert beans.size() == 1; Bean<Litter> litterBean = beans.iterator().next(); CreationalContext<Litter> creationalContext = getCurrentManager().createCreationalContext(litterBean); Litter litter = litterBean.create(creationalContext); litterBean.destroy(litter, creationalContext); assert fox.isLitterDisposed(); assert !newFox.isLitterDisposed(); }
private <T> void checkNewQualifiedBean(Bean<T> bean, Type... requiredTypes) { assertTrue(typeSetMatches(bean.getTypes(), requiredTypes)); // Has scope @Dependent, assertEquals(bean.getScope(), Dependent.class); // Has exactly one qualifier... assertTrue(annotationSetMatches(bean.getQualifiers(), New.Literal.of(bean.getBeanClass()))); // Has no bean EL name assertNull(bean.getName()); // Has no stereotypes assertTrue(bean.getStereotypes() == null || bean.getStereotypes().isEmpty()); // Is not an alternative assertFalse(bean.isAlternative()); } }
public static <T> BeanAttributes<T> forNewBean(Set<Type> types, final Class<?> javaClass) { Set<Annotation> qualifiers = Collections.<Annotation>singleton(New.Literal.of(javaClass)); return new ImmutableBeanAttributes<T>(Collections.<Class<? extends Annotation>> emptySet(), false, null, qualifiers, types, Dependent.class); }
public static <T> BeanAttributes<T> forNewBean(Set<Type> types, final Class<?> javaClass) { Set<Annotation> qualifiers = Collections.<Annotation>singleton(New.Literal.of(javaClass)); return new ImmutableBeanAttributes<T>(Collections.<Class<? extends Annotation>> emptySet(), false, null, qualifiers, types, Dependent.class); }
public static <T> BeanAttributes<T> forNewBean(Set<Type> types, final Class<?> javaClass) { Set<Annotation> qualifiers = Collections.<Annotation>singleton(New.Literal.of(javaClass)); return new ImmutableBeanAttributes<T>(Collections.<Class<? extends Annotation>> emptySet(), false, null, qualifiers, types, Dependent.class); }
public static <T> BeanAttributes<T> forNewBean(Set<Type> types, final Class<?> javaClass) { Set<Annotation> qualifiers = Collections.<Annotation>singleton(New.Literal.of(javaClass)); return new ImmutableBeanAttributes<T>(Collections.<Class<? extends Annotation>> emptySet(), false, null, qualifiers, types, Dependent.class); }
@Test @SpecAssertion(section = NEW_EE, id = "s") public void testNewBeanHasNoBeanELName() { Set<Bean<WrappedEnterpriseBeanLocal>> beans = getBeans(WrappedEnterpriseBeanLocal.class, New.Literal.of( WrappedEnterpriseBean.class)); assert beans.size() == 1; Bean<WrappedEnterpriseBeanLocal> newEnterpriseBean = beans.iterator().next(); assert newEnterpriseBean.getName() == null; }
@Test @SpecAssertion(section = NEW_EE, id = "t") public void testNewBeanHasNoStereotypes() { Bean<MonkeyLocal> monkeyBean = getBeans(MonkeyLocal.class).iterator().next(); Bean<MonkeyLocal> newMonkeyBean = getBeans(MonkeyLocal.class, New.Literal.of(Monkey.class)).iterator().next(); assert monkeyBean.getScope().equals(RequestScoped.class); assert newMonkeyBean.getScope().equals(Dependent.class); assert monkeyBean.getName().equals("monkey"); assert newMonkeyBean.getName() == null; }
@Test @SpecAssertion(section = NEW_EE, id = "m") public void testNewBeanHasSameInitializers() { InitializerSimpleBeanLocal bean = getContextualReference(InitializerSimpleBeanLocal.class); InitializerSimpleBeanLocal newBean = getContextualReference(InitializerSimpleBeanLocal.class, New.Literal.of( InitializerSimpleBean.class)); assert bean != newBean; assert bean.getInitializerCalls() == 2; }
@Test @SpecAssertion(section = NEW_EE, id = "n") public void testNewBeanHasSameInjectedFields() { Bean<InitializerSimpleBeanLocal> simpleBean = getBeans(InitializerSimpleBeanLocal.class).iterator().next(); Bean<InitializerSimpleBeanLocal> newSimpleBean = getBeans(InitializerSimpleBeanLocal.class, New.Literal.of(InitializerSimpleBean.class)).iterator().next(); assert !newSimpleBean.getInjectionPoints().isEmpty(); assert simpleBean.getInjectionPoints().equals(newSimpleBean.getInjectionPoints()); }
@Test @SpecAssertion(section = NEW_EE, id = "l") public void testNewBeanHasSameConstructor() { ExplicitConstructor newBean = getContextualReference(ExplicitConstructor.class, New.Literal.of( ExplicitConstructorSessionBean.class)); assert newBean.getConstructorCalls() == 1; assert newBean.getInjectedSimpleBean() != null; }
public Instance<IllegalArgumentException> getIae() { return iae.select(New.Literal.of(IllegalArgumentException.class)); } }