TestGovernatorGuice.java

/*
 * Copyright 2012 Netflix, Inc.
 *
 *    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 com.netflix.governator.guice;

import com.google.common.base.Predicate;
import com.google.common.collect.Iterables;
import com.google.common.collect.Lists;
import com.google.inject.AbstractModule;
import com.google.inject.Guice;
import com.google.inject.Injector;
import com.google.inject.Key;
import com.google.inject.Scopes;
import com.google.inject.TypeLiteral;
import com.netflix.governator.LifecycleInjectorBuilderProvider;
import com.netflix.governator.guice.mocks.ObjectWithGenericInterface;
import com.netflix.governator.guice.mocks.SimpleContainer;
import com.netflix.governator.guice.mocks.SimpleEagerSingleton;
import com.netflix.governator.guice.mocks.SimpleGenericInterface;
import com.netflix.governator.guice.mocks.SimpleInterface;
import com.netflix.governator.guice.mocks.SimplePojo;
import com.netflix.governator.guice.mocks.SimplePojoAlt;
import com.netflix.governator.guice.mocks.SimpleProvider;
import com.netflix.governator.guice.mocks.SimpleProviderAlt;
import com.netflix.governator.guice.mocks.SimpleSingleton;
import com.netflix.governator.guice.mocks.UnreferencedSingleton;
import com.netflix.governator.guice.modules.ObjectA;
import com.netflix.governator.guice.modules.ObjectB;
import com.netflix.governator.lifecycle.DefaultLifecycleListener;
import com.netflix.governator.lifecycle.FilteredLifecycleListener;
import com.netflix.governator.lifecycle.LifecycleListener;
import com.netflix.governator.lifecycle.LifecycleManager;
import com.netflix.governator.lifecycle.LifecycleState;
import com.tngtech.java.junit.dataprovider.DataProviderRunner;
import com.tngtech.java.junit.dataprovider.UseDataProvider;

import org.junit.Assert;
import org.junit.Test;
import org.junit.runner.RunWith;

import java.util.List;

@RunWith(DataProviderRunner.class)
public class TestGovernatorGuice extends LifecycleInjectorBuilderProvider
{
    private static final String PACKAGES = "com.netflix.governator.guice.mocks";

    @Test
    @UseDataProvider("builders")
    public void     testAutoBindSingletonToGenericInterface(LifecycleInjectorBuilder lifecycleInjectorBuilder) throws Exception
    {
        Injector    injector = lifecycleInjectorBuilder
            .usingBasePackages("com.netflix.governator.guice.mocks")
            .createInjector();

        Key<SimpleGenericInterface<String>>     key = Key.get(new TypeLiteral<SimpleGenericInterface<String>>(){});
        SimpleGenericInterface<String>          simple = injector.getInstance(key);

        Assert.assertEquals(simple.getValue(), "a is a");

        ObjectWithGenericInterface              obj = injector.getInstance(ObjectWithGenericInterface.class);
        Assert.assertEquals(obj.getObj().getValue(), "a is a");
    }

    @Test
    @UseDataProvider("builders")
    public void     testAutoBindSingletonToInterface(LifecycleInjectorBuilder lifecycleInjectorBuilder) throws Exception
    {
        Injector    injector = lifecycleInjectorBuilder
            .usingBasePackages("com.netflix.governator.guice.mocks")
            .createInjector();
        SimpleInterface     simple = injector.getInstance(SimpleInterface.class);

        Assert.assertEquals(simple.getValue(), 1234);
    }

    @Test
    @UseDataProvider("builders")
    public void     testAutoBindModules(LifecycleInjectorBuilder lifecycleInjectorBuilder) throws Exception
    {
        Injector    injector = lifecycleInjectorBuilder
            .usingBasePackages("com.netflix.governator.guice.modules")
            .createInjector();
        ObjectA objectA = injector.getInstance(ObjectA.class);
        ObjectB objectB = injector.getInstance(ObjectB.class);

        Assert.assertEquals(objectA.getColor(), "blue");
        Assert.assertEquals(objectB.getSize(), "large");
    }

    @Test @UseDataProvider("builders")
    public void     testAutoBindSingletonVsSingleton(LifecycleInjectorBuilder lifecycleInjectorBuilder) throws Exception
    {
        final List<Object>        objects = Lists.newArrayList();
        final LifecycleListener   listener = new DefaultLifecycleListener()
        {
            @Override
            public <T> void objectInjected(TypeLiteral<T> type, T obj)
            {
                objects.add(obj);
            }

            @Override
            public void stateChanged(Object obj, LifecycleState newState)
            {
            }
        };
        Injector    injector = lifecycleInjectorBuilder
            .usingBasePackages(PACKAGES)
            .withBootstrapModule
            (
                new BootstrapModule()
                {
                    @Override
                    public void configure(BootstrapBinder binder)
                    {
                        binder.bindLifecycleListener().toInstance(new FilteredLifecycleListener(listener, PACKAGES));
                    }
                }
            )
            .createInjector();

        Assert.assertNull
        (
            Iterables.find
            (
                objects,
                new Predicate<Object>()
                {
                    @Override
                    public boolean apply(Object obj)
                    {
                        return obj instanceof UnreferencedSingleton;
                    }
                },
                null
            )
        );
        Assert.assertNotNull
        (
            Iterables.find
                (
                    objects,
                    new Predicate<Object>()
                    {
                        @Override
                        public boolean apply(Object obj)
                        {
                            return obj instanceof SimpleEagerSingleton;
                        }
                    },
                    null
                )
        );

        injector.getInstance(UnreferencedSingleton.class);
        Assert.assertNotNull
        (
            Iterables.find
                (
                    objects,
                    new Predicate<Object>()
                    {
                        @Override
                        public boolean apply(Object obj)
                        {
                            return obj instanceof UnreferencedSingleton;
                        }
                    },
                    null
                )
        );
    }

    @Test
    public void     testSimpleProvider() throws Exception
    {
        Injector                injector = Guice.createInjector
        (
            new AbstractModule()
            {
                @Override
                protected void configure()
                {
                    ProviderBinderUtil.bind(binder(), SimpleProvider.class, Scopes.SINGLETON);
                    ProviderBinderUtil.bind(binder(), SimpleProviderAlt.class, Scopes.SINGLETON);
                }
            }
        );

        SimplePojo pojo = injector.getInstance(SimplePojo.class);
        Assert.assertEquals(pojo.getI(), 1);
        Assert.assertEquals(pojo.getS(), "one");

        SimplePojoAlt pojoAlt = injector.getInstance(SimplePojoAlt.class);
        Assert.assertEquals(pojoAlt.getL(), 3);
        Assert.assertEquals(pojoAlt.getD(), 4.5, 0);
    }

    @Test @UseDataProvider("builders")
    public void     testSimpleSingleton(LifecycleInjectorBuilder lifecycleInjectorBuilder) throws Exception
    {
        Injector            injector = lifecycleInjectorBuilder.usingBasePackages(PACKAGES).createInjector();
        LifecycleManager    manager = injector.getInstance(LifecycleManager.class);
        manager.start();

        SimpleSingleton     instance = injector.getInstance(SimpleSingleton.class);

        Assert.assertEquals(instance.startCount.get(), 1);
        Assert.assertEquals(instance.finishCount.get(), 0);

        manager.close();

        Assert.assertEquals(instance.startCount.get(), 1);
        Assert.assertEquals(instance.finishCount.get(), 1);
    }

    @Test @UseDataProvider("builders")
    public void     testInjectedIntoAnother(LifecycleInjectorBuilder lifecycleInjectorBuilder) throws Exception
    {
        Injector            injector = lifecycleInjectorBuilder.usingBasePackages(PACKAGES).createInjector();
        LifecycleManager    manager = injector.getInstance(LifecycleManager.class);
        manager.start();

        SimpleContainer     instance = injector.getInstance(SimpleContainer.class);

        Assert.assertEquals(instance.simpleObject.startCount.get(), 1);
        Assert.assertEquals(instance.simpleObject.finishCount.get(), 0);

        manager.close();

        Assert.assertEquals(instance.simpleObject.startCount.get(), 1);
        Assert.assertEquals(instance.simpleObject.finishCount.get(), 1);
    }
}