core/src/test/java/com/opensymphony/xwork2/inject/ContainerImplTest.java

/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you 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 com.opensymphony.xwork2.inject;

import junit.framework.TestCase;

import java.security.Permission;
import java.util.concurrent.Callable;

/**
 * ContainerImpl Tester.
 *
 * @author Lukasz Lenart
 * @version 1.0
 * @since <pre>11/26/2008</pre>
 */
public class ContainerImplTest extends TestCase {

    private Container c;

    @Override
    protected void setUp() throws Exception {
        System.setSecurityManager(null);

        super.setUp();
        ContainerBuilder cb = new ContainerBuilder();
        cb.constant("methodCheck.name", "Lukasz");
        cb.constant("fieldCheck.name", "Lukasz");
        cb.factory(EarlyInitializable.class, EarlyInitializableBean.class, Scope.SINGLETON);
        cb.factory(Initializable.class, InitializableBean.class, Scope.SINGLETON);
        cb.factory(EarlyInitializable.class, "prototypeEarlyInitializable", EarlyInitializableBean.class, Scope.PROTOTYPE);
        cb.factory(Initializable.class, "prototypeInitializable", InitializableBean.class, Scope.PROTOTYPE);
        cb.factory(Initializable.class, "requestInitializable", InitializableBean.class, Scope.REQUEST);
        cb.factory(Initializable.class, "sessionInitializable", InitializableBean.class, Scope.SESSION);
        cb.factory(Initializable.class, "threadInitializable", InitializableBean.class, Scope.THREAD);
        cb.factory(Initializable.class, "wizardInitializable", InitializableBean.class, Scope.WIZARD);
        c = cb.create(false);
        c.setScopeStrategy(new TestScopeStrategy());

        Class.forName(FieldCheck.class.getName());
        Class.forName(ContainerImpl.FieldInjector.class.getName());
    }

    /**
     * Inject values into field
     */
    public void testFieldInjector() throws Exception {

        FieldCheck fieldCheck = new FieldCheck();

        try {
            c.inject(fieldCheck);
            assertTrue(true);
        } catch (DependencyException expected) {
            fail("No exception expected!");
        }

        assertEquals(fieldCheck.getName(), "Lukasz");
    }

    /**
     * Inject values into method
     */
    public void testMethodInjector() throws Exception {

        MethodCheck methodCheck = new MethodCheck();

        try {
            c.inject(methodCheck);
            assertTrue(true);
        } catch (DependencyException expected) {
            fail("No exception expected!");
        }
    }

    /**
     * Inject values into field under SecurityManager
     */
    public void testFieldInjectorWithSecurityEnabled() throws Exception {
        System.setSecurityManager(new TestSecurityManager());

        FieldCheck fieldCheck = new FieldCheck();

        try {
            c.inject(fieldCheck);
            fail("Exception should be thrown!");
        } catch (Error | DependencyException expected) {
            assertTrue(true);
        }
    }

    /**
     * Inject values into method under SecurityManager
     */
    public void testMethodInjectorWithSecurityEnabled() throws Exception {
        System.setSecurityManager(new TestSecurityManager());

        MethodCheck methodCheck = new MethodCheck();

        try {
            c.inject(methodCheck);
            fail("Exception should be thrown!");
        } catch (DependencyException | Error expected) {
            assertTrue(true);
        }
    }

    public void testEarlyInitializable() throws Exception {
        assertTrue("should being initialized already", EarlyInitializableBean.initializedEarly);

        EarlyInitializableCheck earlyInitializableCheck = new EarlyInitializableCheck();
        c.inject(earlyInitializableCheck);
        assertEquals("initialized early", ((EarlyInitializableBean) earlyInitializableCheck.getEarlyInitializable()).getMessage());
        assertEquals("initialized early", ((EarlyInitializableBean) earlyInitializableCheck.getPrototypeEarlyInitializable()).getMessage());

        EarlyInitializableCheck earlyInitializableCheck2 = new EarlyInitializableCheck();
        c.inject(earlyInitializableCheck2);
        assertEquals("singletons should not being initialized twice", "initialized early",
                ((EarlyInitializableBean) earlyInitializableCheck2.getEarlyInitializable()).getMessage());
        assertEquals("initialized early", ((EarlyInitializableBean) earlyInitializableCheck2.getPrototypeEarlyInitializable()).getMessage());

        assertEquals("singletons should being instantiated once",
                earlyInitializableCheck.getEarlyInitializable(), earlyInitializableCheck2.getEarlyInitializable());
        assertNotSame("prototypes should being instantiated for each injection",
                earlyInitializableCheck.getPrototypeEarlyInitializable(), earlyInitializableCheck2.getPrototypeEarlyInitializable());
    }

    public void testInitializable() throws Exception {
        assertFalse("should not being initialized already", InitializableBean.initialized);

        InitializableCheck initializableCheck = new InitializableCheck();
        c.inject(initializableCheck);
        assertTrue("should being initialized here", InitializableBean.initialized);
        assertEquals("initialized", ((InitializableBean) initializableCheck.getInitializable()).getMessage());
        assertEquals("initialized", ((InitializableBean) initializableCheck.getPrototypeInitializable()).getMessage());

        InitializableCheck initializableCheck2 = new InitializableCheck();
        c.inject(initializableCheck2);
        assertEquals("singletons should not being initialized twice", "initialized",
                ((InitializableBean) initializableCheck2.getInitializable()).getMessage());
        assertEquals("initialized", ((InitializableBean) initializableCheck2.getPrototypeInitializable()).getMessage());
        assertEquals("threads should not being initialized twice", "initialized",
                ((InitializableBean) initializableCheck2.getThreadInitializable()).getMessage());

        assertEquals("singletons should being instantiated once",
                initializableCheck.getInitializable(), initializableCheck2.getInitializable());
        assertNotSame("prototypes should being instantiated for each injection",
                initializableCheck.getPrototypeInitializable(), initializableCheck2.getPrototypeInitializable());
        assertEquals("threads should being instantiated once for each thread",
                initializableCheck.getThreadInitializable(), initializableCheck2.getThreadInitializable());

        final InitializableCheck initializableCheck3 = new InitializableCheck();
        final TestScopeStrategy testScopeStrategy = new TestScopeStrategy();
        Thread thread = new Thread(new Runnable() {
            @Override
            public void run() {
                ContainerBuilder cb2 = new ContainerBuilder();
                cb2.factory(EarlyInitializable.class, EarlyInitializableBean.class, Scope.SINGLETON);
                cb2.factory(Initializable.class, InitializableBean.class, Scope.SINGLETON);
                cb2.factory(EarlyInitializable.class, "prototypeEarlyInitializable", EarlyInitializableBean.class, Scope.PROTOTYPE);
                cb2.factory(Initializable.class, "prototypeInitializable", InitializableBean.class, Scope.PROTOTYPE);
                cb2.factory(Initializable.class, "requestInitializable", InitializableBean.class, Scope.REQUEST);
                cb2.factory(Initializable.class, "sessionInitializable", InitializableBean.class, Scope.SESSION);
                cb2.factory(Initializable.class, "threadInitializable", InitializableBean.class, Scope.THREAD);
                cb2.factory(Initializable.class, "wizardInitializable", InitializableBean.class, Scope.WIZARD);
                Container c2 = cb2.create(false);
                c2.setScopeStrategy(testScopeStrategy);
                c2.inject(initializableCheck3);
            }
        });
        thread.run();
        thread.join();
        assertNotSame("threads should being instantiated in new threads",
                initializableCheck.getThreadInitializable(), initializableCheck3.getThreadInitializable());
        assertEquals("initialized", ((InitializableBean) initializableCheck3.getThreadInitializable()).getMessage());

        assertEquals("initialized", ((InitializableBean) initializableCheck3.getRequestInitializable()).getMessage());
        assertEquals("initialized", ((InitializableBean) initializableCheck3.getSessionInitializable()).getMessage());
        assertEquals("initialized", ((InitializableBean) initializableCheck3.getWizardInitializable()).getMessage());

        assertEquals(testScopeStrategy.requestInitializable, initializableCheck3.getRequestInitializable());
        assertEquals(testScopeStrategy.sessionInitializable, initializableCheck3.getSessionInitializable());
        assertEquals(testScopeStrategy.wizardInitializable, initializableCheck3.getWizardInitializable());
    }

    public static class FieldCheck {

        @Inject("fieldCheck.name")
        private String name;

        public String getName() {
            return name;
        }
    }

    public static class MethodCheck {

        private String name;

        @Inject("methodCheck.name")
        private void setName(String name) {
            this.name = name;
        }

        public String getName() {
            return name;
        }

    }

    class InitializableCheck {

        private Initializable initializable;
        private Initializable prototypeInitializable;
        private Initializable requestInitializable;
        private Initializable sessionInitializable;
        private Initializable threadInitializable;
        private Initializable wizardInitializable;

        @Inject
        public void setInitializable(Initializable initializable) {
            this.initializable = initializable;
        }

        @Inject("prototypeInitializable")
        public void setPrototypeInitializable(Initializable prototypeInitializable) {
            this.prototypeInitializable = prototypeInitializable;
        }

        @Inject("requestInitializable")
        public void setRequestInitializable(Initializable requestInitializable) {
            this.requestInitializable = requestInitializable;
        }

        @Inject("sessionInitializable")
        public void setSessionInitializable(Initializable sessionInitializable) {
            this.sessionInitializable = sessionInitializable;
        }

        @Inject("threadInitializable")
        public void setThreadInitializable(Initializable threadInitializable) {
            this.threadInitializable = threadInitializable;
        }

        @Inject("wizardInitializable")
        public void setWizardInitializable(Initializable wizardInitializable) {
            this.wizardInitializable = wizardInitializable;
        }

        public Initializable getRequestInitializable() {
            return requestInitializable;
        }

        public Initializable getSessionInitializable() {
            return sessionInitializable;
        }

        public Initializable getThreadInitializable() {
            return threadInitializable;
        }

        public Initializable getWizardInitializable() {
            return wizardInitializable;
        }

        public Initializable getInitializable() {
            return initializable;
        }

        public Initializable getPrototypeInitializable() {
            return prototypeInitializable;
        }
    }

    class EarlyInitializableCheck {

        private EarlyInitializable earlyInitializable;
        private EarlyInitializable prototypeEarlyInitializable;

        @Inject
        public void setEarlyInitializable(EarlyInitializable earlyInitializable) {
            this.earlyInitializable = earlyInitializable;
        }

        @Inject("prototypeEarlyInitializable")
        public void setPrototypeEarlyInitializable(EarlyInitializable prototypeEarlyInitializable) {
            this.prototypeEarlyInitializable = prototypeEarlyInitializable;
        }

        public EarlyInitializable getEarlyInitializable() {
            return earlyInitializable;
        }

        public EarlyInitializable getPrototypeEarlyInitializable() {
            return prototypeEarlyInitializable;
        }
    }

    class TestSecurityManager extends SecurityManager {

        @Override
        public void checkPermission(Permission perm) {
            if (!"setSecurityManager".equals(perm.getName())) {
                super.checkPermission(perm);
            }
        }
    }

    class TestScopeStrategy implements Scope.Strategy {
        Initializable requestInitializable;
        Initializable sessionInitializable;
        Initializable wizardInitializable;

        @Override
        public <T> T findInRequest(Class<T> type, String name, Callable<? extends T> factory) throws Exception {
            if (requestInitializable == null) {
                requestInitializable = (Initializable) factory.call();
            }
            return (T) requestInitializable;
        }

        @Override
        public <T> T findInSession(Class<T> type, String name, Callable<? extends T> factory) throws Exception {
            if (sessionInitializable == null) {
                sessionInitializable = (Initializable) factory.call();
            }
            return (T) sessionInitializable;
        }

        @Override
        public <T> T findInWizard(Class<T> type, String name, Callable<? extends T> factory) throws Exception {
            if (wizardInitializable == null) {
                wizardInitializable = (Initializable) factory.call();
            }
            return (T) wizardInitializable;
        }
    }
}