summaryrefslogtreecommitdiffstats
path: root/sangria-lazy/src/test/java
diff options
context:
space:
mode:
Diffstat (limited to 'sangria-lazy/src/test/java')
-rw-r--r--sangria-lazy/src/test/java/com/tavianator/sangria/lazy/LazyTest.java204
1 files changed, 94 insertions, 110 deletions
diff --git a/sangria-lazy/src/test/java/com/tavianator/sangria/lazy/LazyTest.java b/sangria-lazy/src/test/java/com/tavianator/sangria/lazy/LazyTest.java
index 8bea02d..ee6200a 100644
--- a/sangria-lazy/src/test/java/com/tavianator/sangria/lazy/LazyTest.java
+++ b/sangria-lazy/src/test/java/com/tavianator/sangria/lazy/LazyTest.java
@@ -22,6 +22,7 @@ import java.lang.annotation.RetentionPolicy;
import java.util.*;
import javax.inject.Inject;
import javax.inject.Qualifier;
+import javax.inject.Singleton;
import com.google.inject.AbstractModule;
import com.google.inject.Binding;
@@ -30,6 +31,8 @@ import com.google.inject.Guice;
import com.google.inject.Injector;
import com.google.inject.Key;
import com.google.inject.Module;
+import com.google.inject.ProvidedBy;
+import com.google.inject.Provider;
import com.google.inject.spi.DefaultBindingTargetVisitor;
import com.google.inject.spi.Element;
import com.google.inject.spi.Elements;
@@ -43,7 +46,7 @@ import static org.junit.Assert.*;
* Tests for {@link Lazy} injection.
*
* @author Tavian Barnes (tavianator@tavianator.com)
- * @version 1.2
+ * @version 1.3
* @since 1.2
*/
public class LazyTest {
@@ -52,157 +55,139 @@ public class LazyTest {
private @interface Simple {
}
+ @ProvidedBy(CountingProvider.class)
private interface Abstract {
}
- private static class Concrete implements Abstract {
- static final ThreadLocal<Integer> INSTANCES = new ThreadLocal<Integer>() {
- @Override
- protected Integer initialValue() {
- return 0;
- }
- };
+ @Singleton
+ private static class CountingProvider implements Provider<Abstract> {
+ int count = 0;
@Inject
- Concrete() {
- INSTANCES.set(INSTANCES.get() + 1);
+ CountingProvider() {
+ }
+
+ @Override
+ public Abstract get() {
+ ++count;
+ return new Abstract() { };
}
}
- private static class HasConcrete {
- final Lazy<Concrete> lazy;
+ private static class HasLazy {
+ final Lazy<Abstract> lazy;
@Inject
- HasConcrete(Lazy<Concrete> lazy) {
+ HasLazy(Lazy<Abstract> lazy) {
this.lazy = lazy;
}
}
- private static class HasQualifiedAbstract {
- @Inject @Simple Lazy<Abstract> lazy;
+ private static class HasSimpleLazy extends HasLazy {
+ @Inject
+ HasSimpleLazy(@Simple Lazy<Abstract> lazy) {
+ super(lazy);
+ }
}
- @Test
- public void testJustInTime() {
- testHasConcrete(Guice.createInjector());
- }
+ private void test(Injector injector, Class<? extends HasLazy> type) {
+ CountingProvider provider = injector.getInstance(CountingProvider.class);
+ HasLazy hasLazy = injector.getInstance(type);
+ assertThat(provider.count, equalTo(0));
- @Test
- public void testExplicitBindings() {
- testHasConcrete(Guice.createInjector(new AbstractModule() {
- @Override
- protected void configure() {
- binder().requireExplicitBindings();
+ Abstract a = hasLazy.lazy.get();
+ assertThat(provider.count, equalTo(1));
- bind(HasConcrete.class);
+ assertThat(hasLazy.lazy.get(), sameInstance(a));
+ assertThat(provider.count, equalTo(1));
- bind(Concrete.class);
- LazyBinder.create(binder())
- .bind(Concrete.class);
- }
- }));
- }
+ hasLazy = injector.getInstance(type);
+ assertThat(provider.count, equalTo(1));
- @Test
- public void testBestPractices() {
- Module module = new AbstractModule() {
- @Override
- protected void configure() {
- bind(HasConcrete.class);
+ a = hasLazy.lazy.get();
+ assertThat(provider.count, equalTo(2));
- bind(Concrete.class);
- LazyBinder.create(binder())
- .bind(Concrete.class);
- }
- };
- assertThat(module, is(atomic()));
- assertThat(module, followsBestPractices());
+ assertThat(hasLazy.lazy.get(), sameInstance(a));
+ assertThat(provider.count, equalTo(2));
}
- private void testHasConcrete(Injector injector) {
- int before = Concrete.INSTANCES.get();
-
- HasConcrete hasConcrete = injector.getInstance(HasConcrete.class);
- assertThat(Concrete.INSTANCES.get(), equalTo(before));
-
- Concrete instance = hasConcrete.lazy.get();
- assertThat(Concrete.INSTANCES.get(), equalTo(before + 1));
+ @Test
+ public void testJustInTime() {
+ test(Guice.createInjector(), HasLazy.class);
+ }
- Concrete instance2 = hasConcrete.lazy.get();
- assertThat(instance2, sameInstance(instance));
- assertThat(Concrete.INSTANCES.get(), equalTo(before + 1));
+ private static final Module EXPLICIT_MODULE = new AbstractModule() {
+ @Override
+ protected void configure() {
+ bind(Abstract.class)
+ .toProvider(CountingProvider.class);
- HasConcrete hasConcrete2 = injector.getInstance(HasConcrete.class);
- assertThat(Concrete.INSTANCES.get(), equalTo(before + 1));
+ LazyBinder.create(binder())
+ .bind(Abstract.class);
- Concrete instance3 = hasConcrete2.lazy.get();
- assertThat(instance3, not(sameInstance(instance)));
- assertThat(Concrete.INSTANCES.get(), equalTo(before + 2));
- }
+ bind(HasLazy.class);
+ }
+ };
@Test
- public void testBindSeparately() {
- testQualifiedAbstract(Guice.createInjector(new AbstractModule() {
- @Override
- protected void configure() {
- bind(Abstract.class)
- .annotatedWith(Simple.class)
- .to(Concrete.class);
-
- LazyBinder.create(binder())
- .bind(Abstract.class)
- .annotatedWith(Simple.class);
- }
- }));
+ public void testExplicitBindings() {
+ test(Guice.createInjector(EXPLICIT_MODULE), HasLazy.class);
}
- @Test
- public void testBindTogether() {
- testQualifiedAbstract(Guice.createInjector(new AbstractModule() {
- @Override
- protected void configure() {
- LazyBinder.create(binder())
- .bind(Abstract.class)
- .annotatedWith(Simple.class)
- .to(Concrete.class);
- }
- }));
- }
+ private static final Module BIND_SEPARATELY_MODULE = new AbstractModule() {
+ @Override
+ protected void configure() {
+ bind(Abstract.class)
+ .annotatedWith(Simple.class)
+ .toProvider(CountingProvider.class);
- private void testQualifiedAbstract(Injector injector) {
- int before = Concrete.INSTANCES.get();
+ LazyBinder.create(binder())
+ .bind(Abstract.class)
+ .annotatedWith(Simple.class);
- HasQualifiedAbstract hasQualifiedAbstract = injector.getInstance(HasQualifiedAbstract.class);
- assertThat(Concrete.INSTANCES.get(), equalTo(before));
+ bind(HasSimpleLazy.class);
+ }
+ };
- Abstract instance = hasQualifiedAbstract.lazy.get();
- assertThat(Concrete.INSTANCES.get(), equalTo(before + 1));
+ @Test
+ public void testBindSeparately() {
+ test(Guice.createInjector(BIND_SEPARATELY_MODULE), HasSimpleLazy.class);
+ }
- Abstract instance2 = hasQualifiedAbstract.lazy.get();
- assertThat(instance2, sameInstance(instance2));
- assertThat(Concrete.INSTANCES.get(), equalTo(before + 1));
+ private static final Module BIND_TOGETHER_MODULE = new AbstractModule() {
+ @Override
+ protected void configure() {
+ LazyBinder.create(binder())
+ .bind(Abstract.class)
+ .annotatedWith(Simple.class)
+ .toProvider(CountingProvider.class);
- HasQualifiedAbstract hasQualifiedAbstract2 = injector.getInstance(HasQualifiedAbstract.class);
- assertThat(Concrete.INSTANCES.get(), equalTo(before + 1));
+ bind(HasSimpleLazy.class);
+ }
+ };
- Abstract instance3 = hasQualifiedAbstract2.lazy.get();
- assertThat(instance3, not(sameInstance(instance)));
- assertThat(Concrete.INSTANCES.get(), equalTo(before + 2));
+ @Test
+ public void testBindTogether() {
+ test(Guice.createInjector(BIND_TOGETHER_MODULE), HasSimpleLazy.class);
}
- @Test(expected = CreationException.class)
- public void testMissingBinding() {
- Guice.createInjector(new AbstractModule() {
+ @Test
+ public void testBestPractices() {
+ Module module = new AbstractModule() {
@Override
protected void configure() {
- LazyBinder.create(binder())
- .bind(Abstract.class);
+ install(EXPLICIT_MODULE);
+ install(BIND_SEPARATELY_MODULE);
+ install(BIND_TOGETHER_MODULE);
}
- });
+ };
+
+ assertThat(module, is(atomic()));
+ assertThat(module, followsBestPractices());
}
@Test(expected = CreationException.class)
- public void testMissingQualifiedBinding() {
+ public void testMissingBinding() {
Guice.createInjector(new AbstractModule() {
@Override
protected void configure() {
@@ -239,7 +224,7 @@ public class LazyTest {
LazyBinder.create(binder())
.bind(Abstract.class)
.annotatedWith(Simple.class)
- .to(Concrete.class);
+ .toProvider(CountingProvider.class);
}
};
@@ -258,6 +243,5 @@ public class LazyTest {
Injector injector = Guice.createInjector(Elements.getModule(elements));
assertThat(visit(injector.getBinding(new Key<Lazy<Abstract>>(Simple.class) { })), is(true));
assertThat(visit(injector.getBinding(new Key<Abstract>(Simple.class) { })), is(false));
- assertThat(visit(injector.getBinding(new Key<Concrete>() { })), is(false));
}
}
generated by cgit v1.2.3 (git 2.39.1) at 2024-11-26 11:06:57 +0000