google/inject/JitBindingsTest.java

/*
 * Copyright (C) 2010 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;

import static com.google.common.collect.ImmutableSet.of;
import static com.google.inject.Asserts.assertContains;
import static com.google.inject.JitBindingsTest.GetBindingCheck.ALLOW_BINDING;
import static com.google.inject.JitBindingsTest.GetBindingCheck.FAIL_ALL;

import java.util.Set;
import junit.framework.TestCase;

/**
 * Some tests for {@link Binder#requireExplicitBindings()}
 *
 * @author sberlin (at) gmail.com (Sam Berlin)
 */
public class JitBindingsTest extends TestCase {

  private String jitFailed(Class<?> clazz) {
    return jitFailed(TypeLiteral.get(clazz));
  }

  private String jitFailed(TypeLiteral<?> clazz) {
    return "Explicit bindings are required and " + clazz + " is not explicitly bound.";
  }

  private String jitInParentFailed(Class<?> clazz) {
    return jitInParentFailed(TypeLiteral.get(clazz));
  }

  private String jitInParentFailed(TypeLiteral<?> clazz) {
    return "Explicit bindings are required and " + clazz + " would be bound in a parent injector.";
  }

  private String inChildMessage(Class<?> clazz) {
    return "Unable to create binding for "
        + clazz.getName()
        + ". It was already configured on one or more child injectors or private modules";
  }

  public void testLinkedBindingWorks() {
    Injector injector =
        Guice.createInjector(
            new AbstractModule() {
              @Override
              protected void configure() {
                binder().requireExplicitBindings();
                bind(Foo.class).to(FooImpl.class);
              }
            });
    // Foo was explicitly bound
    ensureWorks(injector, Foo.class);
    // FooImpl was implicitly bound, it is an error to call getInstance or getProvider,
    // It is OK to call getBinding for introspection, but an error to get the provider
    // of the binding
    ensureFails(injector, ALLOW_BINDING, FooImpl.class);
  }

  public void testMoreBasicsWork() {
    Injector injector =
        Guice.createInjector(
            new AbstractModule() {
              @Override
              protected void configure() {
                binder().requireExplicitBindings();
                bind(Foo.class).to(FooImpl.class);
                bind(Bar.class);
                bind(FooBar.class);
              }
            });
    // Foo, Bar & FooBar was explicitly bound
    ensureWorks(injector, FooBar.class, Bar.class, Foo.class);
    // FooImpl was implicitly bound, it is an error to call getInstance or getProvider,
    // It is OK to call getBinding for introspection, but an error to get the provider
    // of the binding
    ensureFails(injector, ALLOW_BINDING, FooImpl.class);
  }

  public void testLinkedEagerSingleton() {
    Injector injector =
        Guice.createInjector(
            new AbstractModule() {
              @Override
              protected void configure() {
                binder().requireExplicitBindings();
                bind(Foo.class).to(FooImpl.class).asEagerSingleton();
              }
            });
    // Foo was explicitly bound
    ensureWorks(injector, Foo.class);
    // FooImpl was implicitly bound, it is an error to call getInstance or getProvider,
    // It is OK to call getBinding for introspection, but an error to get the provider
    // of the binding
    ensureFails(injector, ALLOW_BINDING, FooImpl.class);
  }

  public void testBasicsWithEagerSingleton() {
    Injector injector =
        Guice.createInjector(
            new AbstractModule() {
              @Override
              protected void configure() {
                binder().requireExplicitBindings();
                bind(Foo.class).to(FooImpl.class).asEagerSingleton();
                bind(Bar.class);
                bind(FooBar.class);
              }
            });
    // Foo, Bar & FooBar was explicitly bound
    ensureWorks(injector, FooBar.class, Bar.class, Foo.class);
    // FooImpl was implicitly bound, it is an error to call getInstance or getProvider,
    // It is OK to call getBinding for introspection, but an error to get the provider
    // of the binding
    ensureFails(injector, ALLOW_BINDING, FooImpl.class);
  }

  public void testLinkedToScoped() {
    Injector injector =
        Guice.createInjector(
            new AbstractModule() {
              @Override
              protected void configure() {
                binder.requireExplicitBindings();
                bind(Foo.class).to(ScopedFooImpl.class);
              }
            });
    // Foo was explicitly bound
    ensureWorks(injector, Foo.class);
    // FooSingletonImpl was implicitly bound, it is an error to call getInstance or getProvider,
    // It is OK to call getBinding for introspection, but an error to get the provider
    // of the binding
    ensureFails(injector, ALLOW_BINDING, ScopedFooImpl.class);
  }

  public void testBasicsWithScoped() {
    Injector injector =
        Guice.createInjector(
            new AbstractModule() {
              @Override
              protected void configure() {
                binder().requireExplicitBindings();
                bind(Foo.class).to(ScopedFooImpl.class);
                bind(Bar.class);
                bind(FooBar.class);
              }
            });
    // Foo, Bar & FooBar was explicitly bound
    ensureWorks(injector, FooBar.class, Bar.class, Foo.class);
    // FooSingletonImpl was implicitly bound, it is an error to call getInstance or getProvider,
    // It is OK to call getBinding for introspection, but an error to get the provider
    // of the binding
    ensureFails(injector, ALLOW_BINDING, ScopedFooImpl.class);
  }

  public void testFailsIfInjectingScopedDirectlyWhenItIsntBound() {
    try {
      Guice.createInjector(
          new AbstractModule() {
            @Override
            protected void configure() {
              binder().requireExplicitBindings();
              bind(Foo.class).to(ScopedFooImpl.class);
              bind(WantsScopedFooImpl.class);
            }
          });
      fail();
    } catch (CreationException expected) {
      assertContains(expected.getMessage(), jitFailed(ScopedFooImpl.class));
      assertEquals(1, expected.getErrorMessages().size());
    }
  }

  public void testLinkedProviderBindingWorks() {
    Injector injector =
        Guice.createInjector(
            new AbstractModule() {
              @Override
              protected void configure() {
                binder().requireExplicitBindings();
                bind(Foo.class).toProvider(FooProvider.class);
              }
            });
    // Foo was explicitly bound
    ensureWorks(injector, Foo.class);
    // FooImpl was not bound at all (even implicitly), it is an error
    // to call getInstance, getProvider, or getBinding.
    ensureFails(injector, FAIL_ALL, FooImpl.class);
  }

  public void testJitGetFails() {
    try {
      Guice.createInjector(
              new AbstractModule() {
                @Override
                protected void configure() {
                  binder().requireExplicitBindings();
                }
              })
          .getInstance(Bar.class);
      fail("should have failed");
    } catch (ConfigurationException expected) {
      assertContains(expected.getMessage(), jitFailed(Bar.class));
      assertEquals(1, expected.getErrorMessages().size());
    }
  }

  public void testJitInjectionFails() {
    try {
      Guice.createInjector(
          new AbstractModule() {
            @Override
            protected void configure() {
              binder().requireExplicitBindings();
              bind(Foo.class).to(FooImpl.class);
              bind(FooBar.class);
            }
          });
      fail("should have failed");
    } catch (CreationException expected) {
      assertContains(expected.getMessage(), jitFailed(Bar.class));
      assertEquals(1, expected.getErrorMessages().size());
    }
  }

  public void testJitProviderGetFails() {
    try {
      Guice.createInjector(
              new AbstractModule() {
                @Override
                protected void configure() {
                  binder().requireExplicitBindings();
                }
              })
          .getProvider(Bar.class);
      fail("should have failed");
    } catch (ConfigurationException expected) {
      assertContains(expected.getMessage(), jitFailed(Bar.class));
      assertEquals(1, expected.getErrorMessages().size());
    }
  }

  public void testJitProviderInjectionFails() {
    try {
      Guice.createInjector(
          new AbstractModule() {
            @Override
            protected void configure() {
              binder().requireExplicitBindings();
              bind(Foo.class).to(FooImpl.class);
              bind(ProviderFooBar.class);
            }
          });
      fail("should have failed");
    } catch (CreationException expected) {
      assertContains(expected.getMessage(), jitFailed(Bar.class));
      assertEquals(1, expected.getErrorMessages().size());
    }
  }

  public void testImplementedBy() {
    Injector injector =
        Guice.createInjector(
            new AbstractModule() {
              @Override
              protected void configure() {
                binder().requireExplicitBindings();
                bind(ImplBy.class);
              }
            });
    ensureWorks(injector, ImplBy.class);
    ensureFails(injector, ALLOW_BINDING, ImplByImpl.class);
  }

  public void testImplementedBySomethingThatIsAnnotated() {
    Injector injector =
        Guice.createInjector(
            new AbstractModule() {
              @Override
              protected void configure() {
                binder().requireExplicitBindings();
                bind(ImplByScoped.class);
              }
            });
    ensureWorks(injector, ImplByScoped.class);
    ensureFails(injector, ALLOW_BINDING, ImplByScopedImpl.class);
  }

  public void testProvidedBy() {
    Injector injector =
        Guice.createInjector(
            new AbstractModule() {
              @Override
              protected void configure() {
                binder().requireExplicitBindings();
                bind(ProvBy.class);
              }
            });
    ensureWorks(injector, ProvBy.class);
    ensureFails(injector, ALLOW_BINDING, ProvByProvider.class);
  }

  public void testProviderMethods() {
    Injector injector =
        Guice.createInjector(
            new AbstractModule() {
              @Override
              protected void configure() {
                binder().requireExplicitBindings();
              }

              @SuppressWarnings("unused")
              @Provides
              Foo foo() {
                return new FooImpl();
              }
            });
    ensureWorks(injector, Foo.class);
  }

  public void testChildInjectorInheritsOption() {
    Injector parent =
        Guice.createInjector(
            new AbstractModule() {
              @Override
              protected void configure() {
                binder().requireExplicitBindings();
                bind(Bar.class);
              }
            });
    ensureWorks(parent, Bar.class);
    ensureFails(parent, FAIL_ALL, FooImpl.class, FooBar.class, Foo.class);

    try {
      parent.createChildInjector(
          new AbstractModule() {
            @Override
            protected void configure() {
              bind(FooBar.class);
            }
          });
      fail("should have failed");
    } catch (CreationException expected) {
      assertContains(expected.getMessage(), jitFailed(Foo.class));
      assertEquals(1, expected.getErrorMessages().size());
    }

    Injector child =
        parent.createChildInjector(
            new AbstractModule() {
              @Override
              protected void configure() {
                bind(Foo.class).to(FooImpl.class);
              }
            });
    ensureWorks(child, Foo.class, Bar.class);
    ensureFails(child, ALLOW_BINDING, FooImpl.class);
    ensureInChild(parent, FooImpl.class, Foo.class);
    // TODO(sameb): FooBar may or may not be in a child injector, depending on if GC has run.
    // We should fix failed child injectors to remove their contents from the parent blacklist
    // immediately, rather than waiting on GC to do it.
    // FooBar was succesfully inserted into the child injector (and parent blacklist), but then
    // JIT bindings it depended on failed, making the child injector invalid.

    Injector grandchild =
        child.createChildInjector(
            new AbstractModule() {
              @Override
              protected void configure() {
                bind(FooBar.class);
              }
            });
    ensureWorks(grandchild, FooBar.class, Foo.class, Bar.class);
    ensureFails(grandchild, ALLOW_BINDING, FooImpl.class);
    ensureFails(child, ALLOW_BINDING, FooImpl.class);
    ensureInChild(parent, FooImpl.class, FooBar.class, Foo.class);
  }

  public void testChildInjectorAddsOption() {
    Injector parent =
        Guice.createInjector(
            new AbstractModule() {
              @Override
              protected void configure() {
                bind(Bar.class);
              }
            });
    int totalParentBindings = parent.getAllBindings().size();

    try {
      parent.createChildInjector(
          new AbstractModule() {
            @Override
            protected void configure() {
              binder().requireExplicitBindings();
              bind(FooBar.class);
            }
          });
      fail("should have failed");
    } catch (CreationException expected) {
      assertContains(expected.getMessage(), jitFailed(Foo.class));
      assertEquals(1, expected.getErrorMessages().size());
    }
    assertEquals(totalParentBindings, parent.getAllBindings().size());

    Injector child =
        parent.createChildInjector(
            new AbstractModule() {
              @Override
              protected void configure() {
                binder().requireExplicitBindings();
                bind(Foo.class).to(FooImpl.class);
                bind(FooImpl.class);
              }
            });
    assertEquals(totalParentBindings, parent.getAllBindings().size());
    ensureWorks(child, Foo.class, Bar.class);

    Injector grandchild =
        child.createChildInjector(
            new AbstractModule() {
              @Override
              protected void configure() {
                bind(FooBar.class);
              }
            });
    assertEquals(totalParentBindings, parent.getAllBindings().size());
    ensureWorks(grandchild, FooBar.class, Foo.class, Bar.class);

    // Make sure siblings of children don't inherit each others settings...
    // a new child should be able to get FooImpl.
    child = parent.createChildInjector();
    ensureWorks(child, FooImpl.class);
  }

  public void testPrivateModulesInheritOptions() {
    try {
      Guice.createInjector(
          new AbstractModule() {
            @Override
            protected void configure() {
              binder().requireExplicitBindings();
              bind(Foo.class).to(FooImpl.class);

              install(
                  new PrivateModule() {
                    @Override
                    public void configure() {
                      bind(FooBar.class);
                      expose(FooBar.class);
                    }
                  });
            }
          });
      fail("should have failed");
    } catch (CreationException expected) {
      assertContains(expected.getMessage(), jitFailed(Bar.class));
      assertEquals(1, expected.getErrorMessages().size());
    }

    Injector injector =
        Guice.createInjector(
            new AbstractModule() {
              @Override
              protected void configure() {
                binder().requireExplicitBindings();

                install(
                    new PrivateModule() {
                      @Override
                      public void configure() {
                        bind(Foo.class).to(FooImpl.class);
                        expose(Foo.class);
                      }
                    });
              }
            });
    ensureInChild(injector, FooImpl.class);
  }

  public void testPrivateModuleAddsOption() {
    try {
      Guice.createInjector(
          new AbstractModule() {
            @Override
            protected void configure() {
              bind(Foo.class).to(FooImpl.class);

              // Fails because FooBar is in the private module,
              // and it wants Bar, but Bar would be JIT.
              install(
                  new PrivateModule() {
                    @Override
                    public void configure() {
                      binder().requireExplicitBindings();
                      bind(FooBar.class);
                      expose(FooBar.class);
                    }
                  });
            }
          });
      fail("should have failed");
    } catch (CreationException expected) {
      assertContains(expected.getMessage(), jitFailed(Bar.class));
      assertEquals(1, expected.getErrorMessages().size());
    }
  }

  public void testPrivateModuleSiblingsDontShareOption() {
    Guice.createInjector(
        new AbstractModule() {
          @Override
          protected void configure() {
            bind(Foo.class).to(FooImpl.class);

            install(
                new PrivateModule() {
                  @Override
                  public void configure() {
                    binder().requireExplicitBindings();
                  }
                });

            // This works, even though Bar is JIT,
            // because the requireExplicitBindings isn't shared
            // between sibling private modules.
            install(
                new PrivateModule() {
                  @Override
                  public void configure() {
                    bind(FooBar.class);
                    expose(FooBar.class);
                  }
                });
          }
        });
  }

  public void testTypeLiteralsCanBeInjected() {
    Injector injector =
        Guice.createInjector(
            new AbstractModule() {
              @Override
              protected void configure() {
                binder().requireExplicitBindings();
                bind(new TypeLiteral<WantsTypeLiterals<String>>() {});
                bind(new TypeLiteral<Set<String>>() {}).toInstance(of("bar"));
              }
            });

    WantsTypeLiterals<String> foo = injector.getInstance(new Key<WantsTypeLiterals<String>>() {});
    assertEquals(foo.literal.getRawType(), String.class);
    assertEquals(of("bar"), foo.set);
  }

  public void testMembersInjectorsCanBeInjected() {
    Injector injector =
        Guice.createInjector(
            new AbstractModule() {
              @Override
              protected void configure() {
                binder().requireExplicitBindings();
              }

              @Provides
              String data(MembersInjector<String> mi) {
                String data = "foo";
                mi.injectMembers(data);
                return data;
              }
            });

    String data = injector.getInstance(String.class);
    assertEquals("foo", data);
  }

  public void testJitLinkedBindingInParentFails() {
    try {
      Guice.createInjector(
          new AbstractModule() {
            @Override
            protected void configure() {
              install(
                  new PrivateModule() {
                    @Override
                    protected void configure() {
                      binder().requireExplicitBindings();
                      bind(Foo.class).to(FooImpl.class);
                    }
                  });
            }
          });
      fail("should have failed");
    } catch (CreationException expected) {
      assertContains(expected.getMessage(), jitInParentFailed(FooImpl.class));
      assertEquals(1, expected.getErrorMessages().size());
    }
  }

  public void testJitProviderBindingInParentFails() {
    try {
      Guice.createInjector(
          new AbstractModule() {
            @Override
            protected void configure() {
              install(
                  new PrivateModule() {
                    @Override
                    protected void configure() {
                      binder().requireExplicitBindings();
                      bind(Foo.class).toProvider(FooProvider.class);
                    }
                  });
            }
          });
      fail("should have failed");
    } catch (CreationException expected) {
      assertContains(expected.getMessage(), jitInParentFailed(FooProvider.class));
      assertEquals(1, expected.getErrorMessages().size());
    }
  }

  public void testJitImplementedByBindingInParentFails() {
    try {
      Guice.createInjector(
          new AbstractModule() {
            @Override
            protected void configure() {
              install(
                  new PrivateModule() {
                    @Override
                    protected void configure() {
                      binder().requireExplicitBindings();
                      bind(ImplBy.class);
                    }
                  });
            }
          });
      fail("should have failed");
    } catch (CreationException expected) {
      assertContains(expected.getMessage(), jitInParentFailed(ImplByImpl.class));
      assertEquals(1, expected.getErrorMessages().size());
    }
  }

  public void testJitProvidedByBindingInParentFails() {
    try {
      Guice.createInjector(
          new AbstractModule() {
            @Override
            protected void configure() {
              install(
                  new PrivateModule() {
                    @Override
                    protected void configure() {
                      binder().requireExplicitBindings();
                      bind(ProvBy.class);
                    }
                  });
            }
          });
      fail("should have failed");
    } catch (CreationException expected) {
      assertContains(expected.getMessage(), jitInParentFailed(ProvByProvider.class));
      assertEquals(1, expected.getErrorMessages().size());
    }
  }

  private void ensureWorks(Injector injector, Class<?>... classes) {
    for (int i = 0; i < classes.length; i++) {
      injector.getInstance(classes[i]);
      injector.getProvider(classes[i]).get();
      injector.getBinding(classes[i]).getProvider().get();
    }
  }

  enum GetBindingCheck {
    FAIL_ALL,
    ALLOW_BINDING,
    ALLOW_BINDING_PROVIDER
  }

  private void ensureFails(Injector injector, GetBindingCheck getBinding, Class<?>... classes) {
    for (int i = 0; i < classes.length; i++) {
      try {
        injector.getInstance(classes[i]);
        fail("should have failed tring to retrieve class: " + classes[i]);
      } catch (ConfigurationException expected) {
        assertContains(expected.getMessage(), jitFailed(classes[i]));
        assertEquals(1, expected.getErrorMessages().size());
      }

      try {
        injector.getProvider(classes[i]);
        fail("should have failed tring to retrieve class: " + classes[i]);
      } catch (ConfigurationException expected) {
        assertContains(expected.getMessage(), jitFailed(classes[i]));
        assertEquals(1, expected.getErrorMessages().size());
      }

      if (getBinding == GetBindingCheck.ALLOW_BINDING
          || getBinding == GetBindingCheck.ALLOW_BINDING_PROVIDER) {
        Binding<?> binding = injector.getBinding(classes[i]);
        try {
          binding.getProvider();
          if (getBinding != GetBindingCheck.ALLOW_BINDING_PROVIDER) {
            fail("should have failed trying to retrieve class: " + classes[i]);
          }
        } catch (ConfigurationException expected) {
          if (getBinding == GetBindingCheck.ALLOW_BINDING_PROVIDER) {
            throw expected;
          }
          assertContains(expected.getMessage(), jitFailed(classes[i]));
          assertEquals(1, expected.getErrorMessages().size());
        }
      } else {
        try {
          injector.getBinding(classes[i]);
          fail("should have failed tring to retrieve class: " + classes[i]);
        } catch (ConfigurationException expected) {
          assertContains(expected.getMessage(), jitFailed(classes[i]));
          assertEquals(1, expected.getErrorMessages().size());
        }
      }
    }
  }

  private void ensureInChild(Injector injector, Class<?>... classes) {
    for (int i = 0; i < classes.length; i++) {
      try {
        injector.getInstance(classes[i]);
        fail("should have failed tring to retrieve class: " + classes[i]);
      } catch (ConfigurationException expected) {
        assertContains(expected.getMessage(), inChildMessage(classes[i]));
        assertEquals(1, expected.getErrorMessages().size());
      }

      try {
        injector.getProvider(classes[i]);
        fail("should have failed tring to retrieve class: " + classes[i]);
      } catch (ConfigurationException expected) {
        assertContains(expected.getMessage(), inChildMessage(classes[i]));
        assertEquals(1, expected.getErrorMessages().size());
      }

      try {
        injector.getBinding(classes[i]);
        fail("should have failed tring to retrieve class: " + classes[i]);
      } catch (ConfigurationException expected) {
        assertContains(expected.getMessage(), inChildMessage(classes[i]));
        assertEquals(1, expected.getErrorMessages().size());
      }
    }
  }

  private static interface Foo {}

  private static class FooImpl implements Foo {}

  @Singleton
  private static class ScopedFooImpl implements Foo {}

  private static class WantsScopedFooImpl {
    @SuppressWarnings("unused")
    @Inject
    ScopedFooImpl scopedFoo;
  }

  private static class Bar {}

  private static class FooBar {
    @SuppressWarnings("unused")
    @Inject
    Foo foo;

    @SuppressWarnings("unused")
    @Inject
    Bar bar;
  }

  private static class ProviderFooBar {
    @SuppressWarnings("unused")
    @Inject
    Provider<Foo> foo;

    @SuppressWarnings("unused")
    @Inject
    Provider<Bar> bar;
  }

  private static class FooProvider implements Provider<Foo> {
    @Override
    public Foo get() {
      return new FooImpl();
    }
  }

  @ImplementedBy(ImplByImpl.class)
  private static interface ImplBy {}

  private static class ImplByImpl implements ImplBy {}

  @ImplementedBy(ImplByScopedImpl.class)
  private static interface ImplByScoped {}

  @Singleton
  private static class ImplByScopedImpl implements ImplByScoped {}

  @ProvidedBy(ProvByProvider.class)
  private static interface ProvBy {}

  private static class ProvByProvider implements Provider<ProvBy> {
    @Override
    public ProvBy get() {
      return new ProvBy() {};
    }
  }

  private static class WantsTypeLiterals<T> {
    TypeLiteral<T> literal;
    Set<T> set;

    @Inject
    WantsTypeLiterals(TypeLiteral<T> literal, Set<T> set) {
      this.literal = literal;
      this.set = set;
    }
  }
}