/extensions/assistedinject/test/com/google/inject/assistedinject/FactoryModuleBuilderTest.java

/**
 * Copyright (C) 2009 Google 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.google.inject.assistedinject;

import static com.google.inject.Asserts.assertContains;
import static com.google.inject.name.Names.named;

import com.google.common.collect.ImmutableSet;
import com.google.common.collect.Iterables;
import com.google.inject.AbstractModule;
import com.google.inject.Binding;
import com.google.inject.CreationException;
import com.google.inject.Guice;
import com.google.inject.Inject;
import com.google.inject.Injector;
import com.google.inject.Key;
import com.google.inject.Module;
import com.google.inject.Provides;
import com.google.inject.Singleton;
import com.google.inject.Stage;
import com.google.inject.TypeLiteral;
import com.google.inject.name.Named;
import com.google.inject.name.Names;
import com.google.inject.spi.Dependency;
import com.google.inject.spi.Element;
import com.google.inject.spi.Elements;
import com.google.inject.spi.HasDependencies;
import com.google.inject.spi.Message;

import junit.framework.TestCase;

import java.util.Collection;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

public class FactoryModuleBuilderTest extends TestCase {
  
  private enum Color { BLUE, GREEN, RED, GRAY, BLACK }

  public void testImplicitForwardingAssistedBindingFailsWithInterface() {
    try {
      Guice.createInjector(new AbstractModule() {
        @Override
        protected void configure() {
          bind(Car.class).to(Golf.class);
          install(new FactoryModuleBuilder().build(ColoredCarFactory.class));
        }
      });
      fail();
    } catch (CreationException ce) {
      assertContains(
          ce.getMessage(), "1) " + Car.class.getName() + " is an interface, not a concrete class.",
          "Unable to create AssistedInject factory.",
          "while locating " + Car.class.getName(),
          "at " + ColoredCarFactory.class.getName() + ".create(");
      assertEquals(1, ce.getErrorMessages().size());
    }
  }
  
  public void testImplicitForwardingAssistedBindingFailsWithAbstractClass() {
    try {
      Guice.createInjector(new AbstractModule() {
        @Override
        protected void configure() {
          bind(AbstractCar.class).to(ArtCar.class);
          install(new FactoryModuleBuilder().build(ColoredAbstractCarFactory.class));
        }
      });
      fail();
    } catch (CreationException ce) {
      assertContains(
          ce.getMessage(), "1) " + AbstractCar.class.getName() + " is abstract, not a concrete class.",
          "Unable to create AssistedInject factory.",
          "while locating " + AbstractCar.class.getName(),
          "at " + ColoredAbstractCarFactory.class.getName() + ".create(");
      assertEquals(1, ce.getErrorMessages().size());
    }
  }

  public void testImplicitForwardingAssistedBindingCreatesNewObjects() {
    final Mustang providedMustang = new Mustang(Color.BLUE);
    Injector injector = Guice.createInjector(new AbstractModule() {
      @Override protected void configure() {
        install(new FactoryModuleBuilder().build(MustangFactory.class));
      }
      @Provides Mustang provide() { return providedMustang; }
    });
    assertSame(providedMustang, injector.getInstance(Mustang.class));
    MustangFactory factory = injector.getInstance(MustangFactory.class);
    Mustang created = factory.create(Color.GREEN);
    assertNotSame(providedMustang, created);
    assertEquals(Color.BLUE, providedMustang.color);
    assertEquals(Color.GREEN, created.color);
  }

  public void testExplicitForwardingAssistedBindingFailsWithInterface() {
    try {
      Guice.createInjector(new AbstractModule() {
        @Override
        protected void configure() {
          bind(Volkswagen.class).to(Golf.class);
          install(new FactoryModuleBuilder()
            .implement(Car.class, Volkswagen.class)
            .build(ColoredCarFactory.class));
        }
      });
      fail();
    } catch (CreationException ce) {
      assertContains(
          ce.getMessage(), "1) " + Volkswagen.class.getName() + " is an interface, not a concrete class.",
          "Unable to create AssistedInject factory.",
          "while locating " + Volkswagen.class.getName(),
          "while locating " + Car.class.getName(),
          "at " + ColoredCarFactory.class.getName() + ".create(");
      assertEquals(1, ce.getErrorMessages().size());
    }
  }

  public void testExplicitForwardingAssistedBindingFailsWithAbstractClass() {
    try {
      Guice.createInjector(new AbstractModule() {
        @Override
        protected void configure() {
          bind(AbstractCar.class).to(ArtCar.class);
          install(new FactoryModuleBuilder()
            .implement(Car.class, AbstractCar.class)
            .build(ColoredCarFactory.class));
        }
      });
      fail();
    } catch (CreationException ce) {
      assertContains(
          ce.getMessage(), "1) " + AbstractCar.class.getName() + " is abstract, not a concrete class.",
          "Unable to create AssistedInject factory.",
          "while locating " + AbstractCar.class.getName(),
          "while locating " + Car.class.getName(),
          "at " + ColoredCarFactory.class.getName() + ".create(");
      assertEquals(1, ce.getErrorMessages().size());
    }
  }
  
  public void testExplicitForwardingAssistedBindingCreatesNewObjects() {
    final Mustang providedMustang = new Mustang(Color.BLUE);
    Injector injector = Guice.createInjector(new AbstractModule() {
      @Override protected void configure() {
        install(new FactoryModuleBuilder().implement(Car.class, Mustang.class).build(
            ColoredCarFactory.class));
      }
      @Provides Mustang provide() { return providedMustang; }
    });
    assertSame(providedMustang, injector.getInstance(Mustang.class));
    ColoredCarFactory factory = injector.getInstance(ColoredCarFactory.class);
    Mustang created = (Mustang)factory.create(Color.GREEN);
    assertNotSame(providedMustang, created);
    assertEquals(Color.BLUE, providedMustang.color);
    assertEquals(Color.GREEN, created.color);
  }

  public void testAnnotatedAndParentBoundReturnValue() {
    Injector injector = Guice.createInjector(new AbstractModule() {
      @Override protected void configure() {
        bind(Car.class).to(Golf.class);

        bind(Integer.class).toInstance(911);
        bind(Double.class).toInstance(5.0d);
        install(new FactoryModuleBuilder()
            .implement(Car.class, Names.named("german"), Beetle.class)
            .implement(Car.class, Names.named("american"), Mustang.class)
            .build(AnnotatedVersatileCarFactory.class));
      }
    });

    AnnotatedVersatileCarFactory factory = injector.getInstance(AnnotatedVersatileCarFactory.class);
    assertTrue(factory.getGermanCar(Color.BLACK) instanceof Beetle);
    assertTrue(injector.getInstance(Car.class) instanceof Golf);
  }

  public void testParentBoundReturnValue() {
    Injector injector = Guice.createInjector(new AbstractModule() {
      @Override protected void configure() {
        bind(Car.class).to(Golf.class);
        bind(Double.class).toInstance(5.0d);
        install(new FactoryModuleBuilder()
            .implement(Car.class, Mustang.class)
            .build(ColoredCarFactory.class));
      }
    });

    ColoredCarFactory factory = injector.getInstance(ColoredCarFactory.class);
    assertTrue(factory.create(Color.RED) instanceof Mustang);
    assertTrue(injector.getInstance(Car.class) instanceof Golf);
  }

  public void testConfigureAnnotatedReturnValue() {
    Injector injector = Guice.createInjector(new AbstractModule() {
      @Override protected void configure() {
        install(new FactoryModuleBuilder()
            .implement(Car.class, Names.named("german"), Beetle.class)
            .implement(Car.class, Names.named("american"), Mustang.class)
            .build(AnnotatedVersatileCarFactory.class));
      }
    });

    AnnotatedVersatileCarFactory factory = injector.getInstance(AnnotatedVersatileCarFactory.class);
    assertTrue(factory.getGermanCar(Color.GRAY) instanceof Beetle);
    assertTrue(factory.getAmericanCar(Color.BLACK) instanceof Mustang);
  }

  public void testNoBindingAssistedInject() {
    Injector injector = Guice.createInjector(new AbstractModule() {
      @Override
      protected void configure() {
        install(new FactoryModuleBuilder().build(MustangFactory.class));
      }
    });

    MustangFactory factory = injector.getInstance(MustangFactory.class);

    Mustang mustang = factory.create(Color.BLUE);
    assertEquals(Color.BLUE, mustang.color);
  }

  public void testBindingAssistedInject() {
    Injector injector = Guice.createInjector(new AbstractModule() {
      @Override
      protected void configure() {
        install(new FactoryModuleBuilder()
            .implement(Car.class, Mustang.class)
            .build(ColoredCarFactory.class));
      }
    });

    ColoredCarFactory factory = injector.getInstance(ColoredCarFactory.class);

    Mustang mustang = (Mustang) factory.create(Color.BLUE);
    assertEquals(Color.BLUE, mustang.color);
  }

  public void testDuplicateBindings() {
    Injector injector = Guice.createInjector(new AbstractModule() {
      @Override
      protected void configure() {
        install(new FactoryModuleBuilder()
            .implement(Car.class, Mustang.class)
            .build(ColoredCarFactory.class));
        install(new FactoryModuleBuilder()
            .implement(Car.class, Mustang.class)
            .build(ColoredCarFactory.class));
      }
    });

    ColoredCarFactory factory = injector.getInstance(ColoredCarFactory.class);

    Mustang mustang = (Mustang) factory.create(Color.BLUE);
    assertEquals(Color.BLUE, mustang.color);
  }

  public void testSimilarBindingsWithConflictingImplementations() {
    try {
      Injector injector = Guice.createInjector(new AbstractModule() {
        @Override
        protected void configure() {
          install(new FactoryModuleBuilder()
              .implement(Car.class, Mustang.class)
              .build(ColoredCarFactory.class));
          install(new FactoryModuleBuilder()
              .implement(Car.class, Golf.class)
              .build(ColoredCarFactory.class));
        }
      });
      injector.getInstance(ColoredCarFactory.class);
      fail();
    } catch (CreationException ce) {
      assertContains(ce.getMessage(),
          "A binding to " + ColoredCarFactory.class.getName() + " was already configured");
      assertEquals(1, ce.getErrorMessages().size());
    }
  }

  public void testMultipleReturnTypes() {
    Injector injector = Guice.createInjector(new AbstractModule() {
      @Override
      protected void configure() {
        bind(Double.class).toInstance(5.0d);
        install(new FactoryModuleBuilder().build(VersatileCarFactory.class));
      }
    });

    VersatileCarFactory factory = injector.getInstance(VersatileCarFactory.class);

    Mustang mustang = factory.getMustang(Color.RED);
    assertEquals(Color.RED, mustang.color);

    Beetle beetle = factory.getBeetle(Color.GREEN);
    assertEquals(Color.GREEN, beetle.color);
  }
  
  public void testParameterizedClassesWithNoImplements() {
    Injector injector = Guice.createInjector(new AbstractModule() {
      @Override
      protected void configure() {
        install(new FactoryModuleBuilder().build(new TypeLiteral<Foo.Factory<String>>() {}));
      }
    });
    
    Foo.Factory<String> factory = injector.getInstance(Key.get(new TypeLiteral<Foo.Factory<String>>() {}));
    @SuppressWarnings("unused")
    Foo<String> foo = factory.create(new Bar());
  }
  
  public void testGenericErrorMessageMakesSense() {
    try {
      Guice.createInjector(new AbstractModule() {
        @Override
        protected void configure() {
         install(new FactoryModuleBuilder().build(Key.get(Foo.Factory.class))); 
        }
      });
      fail();
    } catch(CreationException ce ) {
      // Assert not only that it's the correct message, but also that it's the *only* message.
      Collection<Message> messages = ce.getErrorMessages();
      assertEquals(
          Foo.Factory.class.getName() + " cannot be used as a key; It is not fully specified.", 
          Iterables.getOnlyElement(messages).getMessage());
    }
  }

  interface Car {}

  interface Volkswagen extends Car {}

  interface ColoredCarFactory {
    Car create(Color color);
  }

  interface MustangFactory {
    Mustang create(Color color);
  }

  interface VersatileCarFactory {
    Mustang getMustang(Color color);
    Beetle getBeetle(Color color);
  }

  interface AnnotatedVersatileCarFactory {
    @Named("german") Car getGermanCar(Color color);
    @Named("american") Car getAmericanCar(Color color);
  }

  public static class Golf implements Volkswagen {}

  public static class Mustang implements Car {
    private final Color color;
    @Inject
    public Mustang(@Assisted Color color) {
      this.color = color;
    }
  }

  public static class Beetle implements Car {
    private final Color color;
    @Inject
    public Beetle(@Assisted Color color) {
      this.color = color;
    }
  }
  
  public static class Foo<E> {
    static interface Factory<E> {
      Foo<E> create(Bar bar);
    }
    @SuppressWarnings("unused")
    @Inject Foo(@Assisted Bar bar, Baz<E> baz) {}
  }
  
  public static class Bar {}
  @SuppressWarnings("unused")
  public static class Baz<E> {}
  
  abstract static class AbstractCar implements Car {}  
  interface ColoredAbstractCarFactory {
    AbstractCar create(Color color);
  }  
  public static class ArtCar extends AbstractCar {}
    
  public void testFactoryBindingDependencies() {
    // validate dependencies work in all stages & as a raw element,
    // and that dependencies work for methods, fields, constructors,
    // and for @AssistedInject constructors too.
    Module module = new AbstractModule() {
      @Override
      protected void configure() {
        bind(Integer.class).toInstance(42);
        bind(Double.class).toInstance(4.2d);
        bind(Float.class).toInstance(4.2f);
        bind(String.class).annotatedWith(named("dog")).toInstance("dog");
        bind(String.class).annotatedWith(named("cat1")).toInstance("cat1");
        bind(String.class).annotatedWith(named("cat2")).toInstance("cat2");
        bind(String.class).annotatedWith(named("cat3")).toInstance("cat3");
        bind(String.class).annotatedWith(named("arbitrary")).toInstance("fail!");
        install(new FactoryModuleBuilder()
                .implement(Animal.class, Dog.class)
                .build(AnimalHouse.class));
      }
    };

    Set<Key<?>> expectedKeys = ImmutableSet.<Key<?>>of(
        Key.get(Integer.class),
        Key.get(Double.class),
        Key.get(Float.class),
        Key.get(String.class, named("dog")),
        Key.get(String.class, named("cat1")),
        Key.get(String.class, named("cat2")),
        Key.get(String.class, named("cat3"))
    );
    
    Injector injector = Guice.createInjector(module);
    validateDependencies(expectedKeys, injector.getBinding(AnimalHouse.class));
    
    injector = Guice.createInjector(Stage.TOOL, module);
    validateDependencies(expectedKeys, injector.getBinding(AnimalHouse.class));
    
    List<Element> elements = Elements.getElements(module);
    boolean found = false;
    for(Element element : elements) {
      if(element instanceof Binding) {
        Binding<?> binding = (Binding<?>) element;
        if(binding.getKey().equals(Key.get(AnimalHouse.class))) {
          found = true;
          validateDependencies(expectedKeys, binding);
          break;
        }
      }
    }
    assertTrue(found);
  }
  
  private void validateDependencies(Set<Key<?>> expectedKeys, Binding<?> binding) {
    Set<Dependency<?>> dependencies = ((HasDependencies)binding).getDependencies();
    Set<Key<?>> actualKeys = new HashSet<Key<?>>();
    for (Dependency<?> dependency : dependencies) {
      actualKeys.add(dependency.getKey());
    }
    assertEquals(expectedKeys, actualKeys);
  }
  
  interface AnimalHouse {
    Animal createAnimal(String name);
    Cat createCat(String name);
    Cat createCat(int age);
  }
  
  interface Animal {}
  @SuppressWarnings("unused")
  private static class Dog implements Animal {
    @Inject int a;
    @Inject Dog(@Assisted String a, double b) {}
    @Inject void register(@Named("dog") String a) {}
  }
  @SuppressWarnings("unused")
  private static class Cat implements Animal {
    @Inject float a;
    @AssistedInject Cat(@Assisted String a, @Named("cat1") String b) {}
    @AssistedInject Cat(@Assisted int a, @Named("cat2") String b) {}
    @AssistedInject Cat(@Assisted byte a, @Named("catfail") String b) {} // not a dependency!
    @Inject void register(@Named("cat3") String a) {}
  }
  
  public void testFactoryPublicAndReturnTypeNotPublic() {
    try {
      Guice.createInjector(new AbstractModule() {
        @Override
        protected void configure() {
          install(new FactoryModuleBuilder()
              .implement(Hidden.class, HiddenImpl.class)
              .build(NotHidden.class));
        }
      });
    } catch(CreationException ce) {
      assertEquals(NotHidden.class.getName() + " is public, but has a method that returns a non-public type: "
          + Hidden.class.getName() + ". Due to limitations with java.lang.reflect.Proxy, this is not allowed. "
          + "Please either make the factory non-public or the return type public.",           
          Iterables.getOnlyElement(ce.getErrorMessages()).getMessage());
    }
  }
  
  interface Hidden {}
  public static class HiddenImpl implements Hidden {}
  public interface NotHidden {
    Hidden create();
  }
  
  public void testSingletonScopeOnAssistedClassIsIgnored() {
    try {
      Guice.createInjector(new AbstractModule() {
        @Override
        protected void configure() {
          install(new FactoryModuleBuilder().build(SingletonFactory.class));
        }
      });
      fail();
    } catch (CreationException ce) {
      assertEquals(1, ce.getErrorMessages().size());
      assertEquals("Found scope annotation [" + Singleton.class.getName() + "]"
          + " on implementation class [" + AssistedSingleton.class.getName() + "]"
          + " of AssistedInject factory [" + SingletonFactory.class.getName() + "]."
          + "\nThis is not allowed, please remove the scope annotation.",
          Iterables.getOnlyElement(ce.getErrorMessages()).getMessage());
    }
  }
  
  interface SingletonFactory {
    AssistedSingleton create(String string);
  }

  @SuppressWarnings("GuiceAssistedInjectScoping")
  @Singleton
  static class AssistedSingleton {
    @Inject
    public AssistedSingleton(@SuppressWarnings("unused") @Assisted String string) {
    }
  }
  
}