ComponentLifecycleTest.java

/*
 * Grapht, an open source dependency injector.
 * Copyright 2014-2015 various contributors (see CONTRIBUTORS.txt)
 * Copyright 2010-2014 Regents of the University of Minnesota
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License as
 * published by the Free Software Foundation; either version 2.1 of the
 * License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
 * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
 * details.
 *
 * You should have received a copy of the GNU General Public License along with
 * this program; if not, write to the Free Software Foundation, Inc., 51
 * Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 */
package org.grouplens.grapht.util;

import org.grouplens.grapht.InjectionException;
import org.grouplens.grapht.Injector;
import org.grouplens.grapht.InjectorBuilder;
import org.junit.Ignore;
import org.junit.Test;

import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;
import javax.inject.Inject;

import static org.hamcrest.Matchers.*;
import static org.junit.Assert.*;

/*
 * Grapht, an open source dependency injector.
 * Copyright 2014-2015 various contributors (see CONTRIBUTORS.txt)
 * Copyright 2010-2014 Regents of the University of Minnesota
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License as
 * published by the Free Software Foundation; either version 2.1 of the
 * License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
 * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
 * details.
 *
 * You should have received a copy of the GNU General Public License along with
 * this program; if not, write to the Free Software Foundation, Inc., 51
 * Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 */
public class ComponentLifecycleTest {

    @Test
    public void testClosesAutoCloseable() throws Exception {
        InjectorBuilder bld = InjectorBuilder.create();
        Flag closed
                = new Flag();
        bld.bind(Flag.class).to(closed);
        Injector injector = bld.build();
        try {
            CloseableComponent comp = injector.getInstance(CloseableComponent.class);
            assertThat(comp, notNullValue());
        } finally {
            injector.close();
        }
        // Check that close was called.
        assertTrue("close was called", closed.isSet());
    }

    /**
     * If we inject an instance of an AutoCloseable, it should not be closed.
     */
    @Test
    public void testDoesNotCloseAutoCloseableInstance() throws Exception {
        InjectorBuilder bld = InjectorBuilder.create();
        Flag closed = new Flag();
        bld.bind(Flag.class).to(closed);
        bld.bind(CloseableComponent.class).to(new CloseableComponent(closed));
        Injector injector = bld.build();
        try {
            CloseableComponent comp = injector.getInstance(CloseableComponent.class);
            assertThat(comp, notNullValue());
        } finally {
            injector.close();
        }
        // Check that close was not called.
        assertFalse("close was called", closed.isSet());
    }

    /**
     * Test that the lifecycle management calls pre-destroy methods.
     */
    @Test
    public void testCallsPreDestroy() throws Exception {
        InjectorBuilder bld = InjectorBuilder.create();
        Flag closed = new Flag();
        bld.bind(Flag.class).to(closed);
        Injector injector = bld.build();
        try {
            LifecycleShutdownComponent comp = injector.getInstance(LifecycleShutdownComponent.class);
            assertThat(comp, notNullValue());
        } finally {
            injector.close();
        }
        // Check that close was called.
        assertTrue("close was called", closed.isSet());
    }

    /**
     * Test that the lifecycle management does not call pre-destroy methods on an instance.
     */
    @Test
    public void testDoesNotCallPreDestroyOnInstance() throws Exception {
        InjectorBuilder bld = InjectorBuilder.create();
        Flag closed = new Flag();
        bld.bind(LifecycleShutdownComponent.class).to(new LifecycleShutdownComponent(closed));
        Injector injector = bld.build();
        try {
            LifecycleShutdownComponent comp = injector.getInstance(LifecycleShutdownComponent.class);
            assertThat(comp, notNullValue());
        } finally {
            injector.close();
        }
        // Check that close was called.
        assertFalse("close was called", closed.isSet());
    }

    /**
     * Test that the lifecycle management calls post-construct methods
     */
    @Test
    public void testCallsPostConstruct() throws Exception {
        InjectorBuilder bld = InjectorBuilder.create();
        Flag setup = new Flag();
        bld.bind(Flag.class).to(setup);
        Injector injector = bld.build();
        try {
            PostConstructComponent comp = injector.getInstance(PostConstructComponent.class);
            assertThat(comp, notNullValue());
            assertTrue("setup was called", setup.isSet());
        } finally {
            injector.close();
        }
        // Check that close was called.
        assertTrue("close was called", setup.isSet());
    }

    /**
     * Flag component for detecting closure.
     */
    public static class Flag {
        private boolean value = false;

        public void set() {
            value = true;
        }

        public boolean isSet() {
            return value;
        }
    }

    /**
     * Component implementing AutoCloseable that should be closed.
     */
    public static class CloseableComponent implements AutoCloseable {
        private final Flag flag;

        @Inject
        public CloseableComponent(Flag f) {
            flag = f;
        }

        @Override
        public void close() throws Exception {
            flag.set();
        }
    }

    /**
     * Component with PreDestroy method that must be called.
     */
    public static class LifecycleShutdownComponent {
        private final Flag flag;

        @Inject
        public LifecycleShutdownComponent(Flag f) {
            flag = f;
        }

        @PreDestroy
        public void shutdown() {
            flag.set();
        }
    }

    /**
     * component with post-construct methods
     */
    public static class PostConstructComponent {
        private Flag setup;

        // we use setter injection to make sure PostConstruct is called after setters
        @Inject
        public void setFlag(Flag f) {
            setup = f;
        }

        @PostConstruct
        public void setup() {
            assertThat(setup, notNullValue());
            setup.set();
        }
    }
}