lazy: Fix LazyBinder de-duplication.

2 files changed, 111 insertions, 110 deletions

diff --git a/sangria-lazy/src/main/java/com/tavianator/sangria/lazy/LazyBinder.java b/sangria-lazy/src/main/java/com/tavianator/sangria/lazy/LazyBinder.java
index 26d3848..baad5da 100644
--- a/sangria-lazy/src/main/java/com/tavianator/sangria/lazy/LazyBinder.java
+++ b/sangria-lazy/src/main/java/com/tavianator/sangria/lazy/LazyBinder.java
@@ -269,5 +269,22 @@ public class LazyBinder {
                 return visitor.visit(binding);
             }
         }
+
+        @Override
+        public boolean equals(Object obj) {
+            if (obj == this) {
+                return true;
+            } else if (!(obj instanceof LazyProvider)) {
+                return false;
+            }
+
+            LazyProvider<?> other = (LazyProvider<?>) obj;
+            return key.equals(other.key);
+        }
+
+        @Override
+        public int hashCode() {
+            return key.hashCode();
+        }
     }
 }
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));
     }
 }