javax.enterprise.context.NormalScope Java Examples

public Class<? extends Annotation> scope() {
    if (null == scope) {
        synchronized (this) {
            if (null == scope) {
                Class<?> c = getClass();
                if (c.isAnnotationPresent(RequestScoped.class)) {
                    scope = RequestScoped.class;
                } else if (c.isAnnotationPresent(SessionScoped.class)) {
                    scope = SessionScoped.class;
                } else if (c.isAnnotationPresent(ApplicationScoped.class)) {
                    scope = ApplicationScoped.class;
                } else {
                    scope = NormalScope.class;
                }
            }
        }
    }
    return scope;
}
 

ContextConfigurator(Class<? extends Annotation> scopeAnnotation, Consumer<ContextConfigurator> configuratorConsumer) {
    this.consumed = new AtomicBoolean(false);
    this.scopeAnnotation = Objects.requireNonNull(scopeAnnotation);
    this.params = new HashMap<>();
    this.configuratorConsumer = configuratorConsumer;
    this.isNormal = scopeAnnotation.isAnnotationPresent(NormalScope.class);
}
 

boolean isNormalScope(Class<? extends Annotation> annotationType) {
    if (annotationType.isAnnotationPresent(NormalScope.class)) {
        return true;
    }
    for (InjectableContext context : contexts) {
        if (context.getScope().equals(annotationType) && context.isNormal()) {
            return true;
        }
    }
    return false;
}
 

<T> void excludeBeans(@Observes @WithAnnotations({Scope.class, NormalScope.class}) ProcessAnnotatedType<T> pat) {

        if (excludedBeanClasses.contains(pat.getAnnotatedType().getJavaClass())) {
            pat.veto();
            return;
        }

        Set<Type> typeClosure = pat.getAnnotatedType().getTypeClosure();
        for (Type excludedBeanType : excludedBeanTypes) {
            if (typeClosure.contains(excludedBeanType)) {
                pat.veto();
                return;
            }
        }
    }
 

private static Set<Annotation> getScopes(AnnotatedElement element) {
    Set<Annotation> scopes = new HashSet<>();
    for (Annotation annotation : element.getAnnotations()) {
        if (annotation.annotationType().isAnnotationPresent(Scope.class) || annotation.annotationType().isAnnotationPresent(NormalScope.class)) {
            scopes.add(annotation);
        }
    }
    return scopes;
}
 

/**
 * Activate and deactivate contexts for the given normal scopes for the lifetime of the initialized Weld container, by default for each test method
 * execution.
 * <p>
 * {@link ApplicationScoped} is ignored as it is always active.
 * </p>
 *
 * @param normalScopes
 * @return self
 */
@SafeVarargs
public final T activate(Class<? extends Annotation>... normalScopes) {
    for (Class<? extends Annotation> scope : normalScopes) {
        if (ApplicationScoped.class.equals(scope)) {
            continue;
        }
        if (!scope.isAnnotationPresent(NormalScope.class)) {
            throw new IllegalArgumentException("Only annotations annotated with @NormalScope are supported!");
        }
        this.scopesToActivate.add(scope);
    }
    return self();
}
 

@Before
public void setUp() {
    final Class beanClass = Object.class;
    when(bean.getBeanClass()).thenReturn(beanClass);
    when(beanManager.isNormalScope(any())).thenAnswer(invocationOnMock ->
            Class.class.cast(invocationOnMock.getArguments()[0]).isAnnotationPresent(NormalScope.class));
    when(beanManager.getReference(eq(bean), eq(beanClass), any()))
            .thenAnswer(i -> new Object()); // ensure to create one instance per call, this is what we test
}
 

@Test
@SuppressWarnings({"unchecked", "rawTypes"})
public void testCreationalContextsNotReleasedOnClientCloseUsingNormalScope() throws Exception {
    IMocksControl control = EasyMock.createStrictControl();
    BeanManager mockedBeanMgr = control.createMock(BeanManager.class);
    CreationalContext<?> mockedCreationalCtx = control.createMock(CreationalContext.class);
    Bean<?> mockedBean = control.createMock(Bean.class);
    List<String> stringList = new ArrayList<>(Collections.singleton("xyz"));

    EasyMock.expect(mockedBeanMgr.getBeans(List.class))
            .andReturn(Collections.singleton(mockedBean));
    EasyMock.expect(mockedBeanMgr.createCreationalContext(mockedBean))
            .andReturn((CreationalContext) mockedCreationalCtx);
    EasyMock.expect(mockedBeanMgr.getReference(mockedBean, List.class, mockedCreationalCtx))
            .andReturn(stringList);
    EasyMock.expect(mockedBean.getScope())
            .andReturn((Class) NormalScope.class);
    EasyMock.expect(mockedBeanMgr.isNormalScope(NormalScope.class))
            .andReturn(true);
    control.replay();

    Bus bus = new ExtensionManagerBus();
    bus.setExtension(mockedBeanMgr, BeanManager.class);

    Instance<List> i = CDIUtils.getInstanceFromCDI(List.class, bus);

    i.release();

    control.verify();
}
 

boolean isScope(Class<? extends Annotation> annotationType) {
    if (annotationType.isAnnotationPresent(Scope.class) || annotationType.isAnnotationPresent(NormalScope.class)) {
        return true;
    }
    return contexts.stream().map(InjectableContext::getScope).filter(annotationType::equals).findAny().isPresent();
}
 

private static boolean hasBeanDefiningAnnotation(Class<?> clazz) {
    return isAnnotated(clazz, NormalScope.class) || isAnnotated(clazz, Dependent.class) ||
            isAnnotated(clazz, Interceptor.class) || isAnnotated(clazz, Decorator.class) ||
            isAnnotated(clazz, Stereotype.class);
}
 

/**
 * 
 * @return {@code true} if this context represents a normal scope
 */
default boolean isNormal() {
    return getScope().isAnnotationPresent(NormalScope.class);
}