| /** |
| * Copyright (C) 2015 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.spi; |
| |
| import static com.google.inject.Asserts.assertContains; |
| import static com.google.inject.name.Names.named; |
| import static java.lang.annotation.ElementType.METHOD; |
| import static java.lang.annotation.RetentionPolicy.RUNTIME; |
| |
| import com.google.common.collect.ImmutableSet; |
| import com.google.common.collect.Iterables; |
| import com.google.inject.AbstractModule; |
| import com.google.inject.Binder; |
| import com.google.inject.Binding; |
| import com.google.inject.CreationException; |
| import com.google.inject.Exposed; |
| import com.google.inject.Guice; |
| import com.google.inject.Injector; |
| import com.google.inject.Key; |
| import com.google.inject.Module; |
| import com.google.inject.PrivateModule; |
| import com.google.inject.internal.util.StackTraceElements; |
| import com.google.inject.name.Named; |
| import com.google.inject.name.Names; |
| |
| import junit.framework.TestCase; |
| |
| import java.lang.annotation.Annotation; |
| import java.lang.annotation.Documented; |
| import java.lang.annotation.Retention; |
| import java.lang.annotation.Target; |
| import java.util.Set; |
| |
| /** Tests for {@link ModuleAnnotatedMethodScanner} usage. */ |
| public class ModuleAnnotatedMethodScannerTest extends TestCase { |
| |
| public void testScanning() throws Exception { |
| Module module = new AbstractModule() { |
| @Override protected void configure() {} |
| |
| @TestProvides @Named("foo") String foo() { |
| return "foo"; |
| } |
| |
| @TestProvides @Named("foo2") String foo2() { |
| return "foo2"; |
| } |
| }; |
| Injector injector = Guice.createInjector(module, NamedMunger.module()); |
| |
| // assert no bindings named "foo" or "foo2" exist -- they were munged. |
| assertMungedBinding(injector, String.class, "foo", "foo"); |
| assertMungedBinding(injector, String.class, "foo2", "foo2"); |
| |
| Binding<String> fooBinding = injector.getBinding(Key.get(String.class, named("foo-munged"))); |
| Binding<String> foo2Binding = injector.getBinding(Key.get(String.class, named("foo2-munged"))); |
| // Validate the provider has a sane toString |
| assertEquals(methodName(TestProvides.class, "foo", module), |
| fooBinding.getProvider().toString()); |
| assertEquals(methodName(TestProvides.class, "foo2", module), |
| foo2Binding.getProvider().toString()); |
| } |
| |
| public void testMoreThanOneClaimedAnnotationFails() throws Exception { |
| Module module = new AbstractModule() { |
| @Override protected void configure() {} |
| |
| @TestProvides @TestProvides2 String foo() { |
| return "foo"; |
| } |
| }; |
| try { |
| Guice.createInjector(module, NamedMunger.module()); |
| fail(); |
| } catch(CreationException expected) { |
| assertEquals(1, expected.getErrorMessages().size()); |
| assertContains(expected.getMessage(), |
| "More than one annotation claimed by NamedMunger on method " |
| + module.getClass().getName() + ".foo(). Methods can only have " |
| + "one annotation claimed per scanner."); |
| } |
| } |
| |
| private String methodName(Class<? extends Annotation> annotation, String method, Object container) |
| throws Exception { |
| return "@" + annotation.getName() + " " |
| + StackTraceElements.forMember(container.getClass().getDeclaredMethod(method)); |
| } |
| |
| @Documented @Target(METHOD) @Retention(RUNTIME) |
| private @interface TestProvides {} |
| |
| @Documented @Target(METHOD) @Retention(RUNTIME) |
| private @interface TestProvides2 {} |
| |
| private static class NamedMunger extends ModuleAnnotatedMethodScanner { |
| static Module module() { |
| return new AbstractModule() { |
| @Override protected void configure() { |
| binder().scanModulesForAnnotatedMethods(new NamedMunger()); |
| } |
| }; |
| } |
| |
| @Override |
| public String toString() { |
| return "NamedMunger"; |
| } |
| |
| @Override |
| public Set<? extends Class<? extends Annotation>> annotationClasses() { |
| return ImmutableSet.of(TestProvides.class, TestProvides2.class); |
| } |
| |
| @Override |
| public <T> Key<T> prepareMethod(Binder binder, Annotation annotation, Key<T> key, |
| InjectionPoint injectionPoint) { |
| return Key.get(key.getTypeLiteral(), |
| Names.named(((Named) key.getAnnotation()).value() + "-munged")); |
| } |
| } |
| |
| private void assertMungedBinding(Injector injector, Class<?> clazz, String originalName, |
| Object expectedValue) { |
| assertNull(injector.getExistingBinding(Key.get(clazz, named(originalName)))); |
| Binding<?> fooBinding = injector.getBinding(Key.get(clazz, named(originalName + "-munged"))); |
| assertEquals(expectedValue, fooBinding.getProvider().get()); |
| } |
| |
| public void testFailingScanner() { |
| try { |
| Guice.createInjector(new SomeModule(), FailingScanner.module()); |
| fail(); |
| } catch (CreationException expected) { |
| Message m = Iterables.getOnlyElement(expected.getErrorMessages()); |
| assertEquals( |
| "An exception was caught and reported. Message: Failing in the scanner.", |
| m.getMessage()); |
| assertEquals(IllegalStateException.class, m.getCause().getClass()); |
| ElementSource source = (ElementSource) Iterables.getOnlyElement(m.getSources()); |
| assertEquals(SomeModule.class.getName(), |
| Iterables.getOnlyElement(source.getModuleClassNames())); |
| assertEquals(String.class.getName() + " " + SomeModule.class.getName() + ".aString()", |
| source.toString()); |
| } |
| } |
| |
| public static class FailingScanner extends ModuleAnnotatedMethodScanner { |
| static Module module() { |
| return new AbstractModule() { |
| @Override protected void configure() { |
| binder().scanModulesForAnnotatedMethods(new FailingScanner()); |
| } |
| }; |
| } |
| |
| @Override public Set<? extends Class<? extends Annotation>> annotationClasses() { |
| return ImmutableSet.of(TestProvides.class); |
| } |
| |
| @Override public <T> Key<T> prepareMethod( |
| Binder binder, Annotation rawAnnotation, Key<T> key, InjectionPoint injectionPoint) { |
| throw new IllegalStateException("Failing in the scanner."); |
| } |
| } |
| |
| static class SomeModule extends AbstractModule { |
| @TestProvides String aString() { |
| return "Foo"; |
| } |
| |
| @Override protected void configure() {} |
| } |
| |
| public void testChildInjectorInheritsScanner() { |
| Injector parent = Guice.createInjector(NamedMunger.module()); |
| Injector child = parent.createChildInjector(new AbstractModule() { |
| @Override protected void configure() {} |
| |
| @TestProvides @Named("foo") String foo() { |
| return "foo"; |
| } |
| }); |
| assertMungedBinding(child, String.class, "foo", "foo"); |
| } |
| |
| public void testChildInjectorScannersDontImpactSiblings() { |
| Module module = new AbstractModule() { |
| @Override |
| protected void configure() {} |
| |
| @TestProvides @Named("foo") String foo() { |
| return "foo"; |
| } |
| }; |
| Injector parent = Guice.createInjector(); |
| Injector child = parent.createChildInjector(NamedMunger.module(), module); |
| assertMungedBinding(child, String.class, "foo", "foo"); |
| |
| // no foo nor foo-munged in sibling, since scanner never saw it. |
| Injector sibling = parent.createChildInjector(module); |
| assertNull(sibling.getExistingBinding(Key.get(String.class, named("foo")))); |
| assertNull(sibling.getExistingBinding(Key.get(String.class, named("foo-munged")))); |
| } |
| |
| public void testPrivateModuleInheritScanner_usingPrivateModule() { |
| Injector injector = Guice.createInjector(NamedMunger.module(), new PrivateModule() { |
| @Override protected void configure() {} |
| |
| @Exposed @TestProvides @Named("foo") String foo() { |
| return "foo"; |
| } |
| }); |
| assertMungedBinding(injector, String.class, "foo", "foo"); |
| } |
| |
| public void testPrivateModuleInheritScanner_usingPrivateBinder() { |
| Injector injector = Guice.createInjector(NamedMunger.module(), new AbstractModule() { |
| @Override protected void configure() { |
| binder().newPrivateBinder().install(new AbstractModule() { |
| @Override protected void configure() {} |
| |
| @Exposed @TestProvides @Named("foo") String foo() { |
| return "foo"; |
| } |
| }); |
| } |
| }); |
| assertMungedBinding(injector, String.class, "foo", "foo"); |
| } |
| |
| public void testPrivateModuleScannersDontImpactSiblings_usingPrivateModule() { |
| Injector injector = Guice.createInjector(new PrivateModule() { |
| @Override protected void configure() { |
| install(NamedMunger.module()); |
| } |
| |
| @Exposed @TestProvides @Named("foo") String foo() { |
| return "foo"; |
| } |
| }, new PrivateModule() { |
| @Override protected void configure() {} |
| |
| // ignored! (because the scanner doesn't run over this module) |
| @Exposed @TestProvides @Named("foo") String foo() { |
| return "foo"; |
| } |
| }); |
| assertMungedBinding(injector, String.class, "foo", "foo"); |
| } |
| |
| public void testPrivateModuleScannersDontImpactSiblings_usingPrivateBinder() { |
| Injector injector = Guice.createInjector(new AbstractModule() { |
| @Override protected void configure() { |
| binder().newPrivateBinder().install(new AbstractModule() { |
| @Override protected void configure() { |
| install(NamedMunger.module()); |
| } |
| |
| @Exposed @TestProvides @Named("foo") String foo() { |
| return "foo"; |
| } |
| }); |
| } |
| }, new AbstractModule() { |
| @Override protected void configure() { |
| binder().newPrivateBinder().install(new AbstractModule() { |
| @Override protected void configure() {} |
| |
| // ignored! (because the scanner doesn't run over this module) |
| @Exposed @TestProvides @Named("foo") String foo() { |
| return "foo"; |
| } |
| }); |
| }}); |
| assertMungedBinding(injector, String.class, "foo", "foo"); |
| } |
| } |