org.jboss.cdi.tck.tests.extensions.lifecycle.events.TestExtension Maven / Gradle / Ivy

Show more of this group Show more artifacts with this name
Show all versions of cdi-tck-impl Show documentation
CDI TCK tests
There is a newer version: 2.0.5.SP1
/*
 * JBoss, Home of Professional Open Source
 * Copyright 2014, Red Hat, Inc., and individual contributors
 * by the @authors tag. See the copyright.txt in the distribution for a
 * full listing of individual contributors.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 * http://www.apache.org/licenses/LICENSE-2.0
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.jboss.cdi.tck.tests.extensions.lifecycle.events;

import static org.testng.Assert.fail;

import javax.enterprise.event.Observes;
import javax.enterprise.inject.spi.AfterBeanDiscovery;
import javax.enterprise.inject.spi.AfterDeploymentValidation;
import javax.enterprise.inject.spi.AfterTypeDiscovery;
import javax.enterprise.inject.spi.BeanManager;
import javax.enterprise.inject.spi.BeforeBeanDiscovery;
import javax.enterprise.inject.spi.Extension;
import javax.enterprise.inject.spi.ProcessAnnotatedType;
import javax.enterprise.inject.spi.ProcessBean;
import javax.enterprise.inject.spi.ProcessBeanAttributes;
import javax.enterprise.inject.spi.ProcessInjectionPoint;
import javax.enterprise.inject.spi.ProcessInjectionTarget;
import javax.enterprise.inject.spi.ProcessManagedBean;
import javax.enterprise.inject.spi.ProcessObserverMethod;
import javax.enterprise.inject.spi.ProcessProducer;
import javax.enterprise.inject.spi.ProcessProducerField;
import javax.enterprise.inject.spi.ProcessProducerMethod;
import javax.enterprise.inject.spi.ProcessSessionBean;
import javax.enterprise.inject.spi.ProcessSyntheticAnnotatedType;

public class TestExtension implements Extension {

    private BeforeBeanDiscovery bbd;
    private AfterTypeDiscovery atd;
    private AfterBeanDiscovery abd;
    private ProcessAnnotatedType pat;
    private ProcessSyntheticAnnotatedType psat;
    private AfterDeploymentValidation adv;
    private ProcessBean pb;
    private ProcessBeanAttributes pba;
    private ProcessObserverMethod pom;
    private ProcessInjectionTarget pit;
    private ProcessInjectionPoint pip;
    private ProcessProducer pp;
    private ProcessManagedBean pmb;
    private ProcessSessionBean psb;
    private ProcessProducerField ppf;
    private ProcessProducerMethod ppm;

    void observesBeforeBeanDiscovery(@Observes BeforeBeanDiscovery event, BeanManager bm) {
        this.bbd = event;
        bbd.addAnnotatedType(bm.createAnnotatedType(SimpleBean.class), TestExtension.class.getName() + ":" + SimpleBean.class.getName());
    }

    void observesProcessAnnotatedType(@Observes ProcessAnnotatedType event) {
        if (!(event instanceof ProcessSyntheticAnnotatedType)) {
            this.pat = event;
        }
    }

    void observesProcessSyntheticAnnotatedType(@Observes ProcessSyntheticAnnotatedType event) {
        this.psat = event;
    }

    void observesAfterTypeDiscovery(@Observes AfterTypeDiscovery event) {
        this.atd = event;
    }

    void observesProcessInjectionTarget(@Observes ProcessInjectionTarget event) {
        this.pit = event;
    }

    void observesProcessProducer(@Observes ProcessProducer event) {
        this.pp = event;
    }

    void observesProcessInjectionPoint(@Observes ProcessInjectionPoint event) {
        this.pip = event;
    }

    void observesProcessBeanAttributes(@Observes ProcessBeanAttributes event) {
        this.pba = event;
    }

    // Modifying  PAT in another lifecycle event should also fail with IllegalStateException
    void observesProcessBean(@Observes ProcessBean event, BeanManager bm) {

        this.pb = event;
        try {
            pat.getAnnotatedType();
            fail("Expected exception not thrown");
        } catch (IllegalStateException expected) {
        }

        try {
            pat.setAnnotatedType(bm.createAnnotatedType(SimpleBean.class));
            fail("Expected exception not thrown");
        } catch (IllegalStateException expected) {
        }

    }

    void observesProcessManagedBean(@Observes ProcessManagedBean event) {
        this.pmb = event;
    }

    void observesProcessSessionBean(@Observes ProcessSessionBean event) {
        this.psb = event;
    }

    void observesProcessProducerField(@Observes ProcessProducerField event) {
        this.ppf = event;
    }

    void observesProcessSessionBean(@Observes ProcessProducerMethod event) {
        this.ppm = event;
    }

    void observesProcessObserverMethod(@Observes ProcessObserverMethod event) {
        this.pom = event;
    }

    void observesAfterBeanDiscovery(@Observes AfterBeanDiscovery event) {
        this.abd = event;
    }

    void observesAfterDeploymentValidation(@Observes AfterDeploymentValidation event) {
        this.adv = event;
    }

    public BeforeBeanDiscovery getBeforeBeanDiscovery() {
        return bbd;
    }

    public AfterTypeDiscovery getAfterTypeDiscovery() {
        return atd;
    }

    public AfterBeanDiscovery getAfterBeanDiscovery() {
        return abd;
    }

    public AfterDeploymentValidation getAfterDeploymentValidation() {
        return adv;
    }

    public ProcessBean getProcessBean() {
        return pb;
    }

    public ProcessAnnotatedType getProcessAnnotatedType() {
        return pat;
    }

    public ProcessSyntheticAnnotatedType getProcessSyntheticAnnotatedType() {
        return psat;
    }

    public ProcessBeanAttributes getProcessBeanAttributes() {
        return pba;
    }

    public ProcessObserverMethod getProcessObserverMethod() {
        return pom;
    }

    public ProcessInjectionTarget getProcessInjectionTarget() {
        return pit;
    }

    public ProcessInjectionPoint getProcessInjectionPoint() {
        return pip;
    }

    public ProcessProducer getProcessProducer() {
        return pp;
    }

    public ProcessManagedBean getProcessManagedBean() {
        return pmb;
    }

    public ProcessSessionBean getProcessSessionBean() {
        return psb;
    }

    public ProcessProducerField getProcessProducerField() {
        return ppf;
    }

    public ProcessProducerMethod getProcessProducerMethod() {
        return ppm;
    }

}