From af52e472b4f0b00b0d00c04b3fa54a79f94b9a49 Mon Sep 17 00:00:00 2001 From: Tavian Barnes Date: Sun, 14 Sep 2014 23:56:51 -0400 Subject: lazy: Implement Lazy, very much like Dagger's. --- .../java/com/tavianator/sangria/lazy/LazyTest.java | 243 +++++++++++++++++++++ 1 file changed, 243 insertions(+) create mode 100644 sangria-lazy/src/test/java/com/tavianator/sangria/lazy/LazyTest.java (limited to 'sangria-lazy/src/test/java') 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 new file mode 100644 index 0000000..ff63c03 --- /dev/null +++ b/sangria-lazy/src/test/java/com/tavianator/sangria/lazy/LazyTest.java @@ -0,0 +1,243 @@ +/**************************************************************************** + * Sangria * + * Copyright (C) 2014 Tavian Barnes * + * * + * 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.tavianator.sangria.lazy; + +import java.lang.annotation.Retention; +import java.lang.annotation.RetentionPolicy; +import java.util.*; +import javax.inject.Inject; +import javax.inject.Qualifier; + +import com.google.inject.AbstractModule; +import com.google.inject.Binding; +import com.google.inject.CreationException; +import com.google.inject.Guice; +import com.google.inject.Injector; +import com.google.inject.Key; +import com.google.inject.Module; +import com.google.inject.spi.DefaultBindingTargetVisitor; +import com.google.inject.spi.Element; +import com.google.inject.spi.Elements; +import org.junit.Test; + +import static org.hamcrest.Matchers.*; +import static org.junit.Assert.*; + +/** + * Tests for {@link Lazy} injection. + * + * @author Tavian Barnes (tavianator@tavianator.com) + * @version 1.2 + * @since 1.2 + */ +public class LazyTest { + @Retention(RetentionPolicy.RUNTIME) + @Qualifier + private @interface Simple { + } + + private interface Abstract { + } + + private static class Concrete implements Abstract { + static final ThreadLocal INSTANCES = new ThreadLocal() { + @Override + protected Integer initialValue() { + return 0; + } + }; + + @Inject + Concrete() { + INSTANCES.set(INSTANCES.get() + 1); + } + } + + private static class HasConcrete { + @Inject Lazy lazy; + } + + private static class HasQualifiedAbstract { + @Inject @Simple Lazy lazy; + } + + @Test + public void testJustInTime() { + testHasConcrete(Guice.createInjector()); + } + + @Test + public void testExplicitBindings() { + testHasConcrete(Guice.createInjector(new AbstractModule() { + @Override + protected void configure() { + binder().requireExplicitBindings(); + + bind(Concrete.class); + LazyBinder.create(binder()) + .bind(Concrete.class); + } + })); + } + + private void testHasConcrete(Injector injector) { + int before = Concrete.INSTANCES.get(); + + HasConcrete hasConcrete = new HasConcrete(); + injector.injectMembers(hasConcrete); + assertThat(Concrete.INSTANCES.get(), equalTo(before)); + + Concrete instance = hasConcrete.lazy.get(); + assertThat(Concrete.INSTANCES.get(), equalTo(before + 1)); + + Concrete instance2 = hasConcrete.lazy.get(); + assertThat(instance2, sameInstance(instance)); + assertThat(Concrete.INSTANCES.get(), equalTo(before + 1)); + + HasConcrete hasConcrete2 = new HasConcrete(); + injector.injectMembers(hasConcrete2); + assertThat(Concrete.INSTANCES.get(), equalTo(before + 1)); + + Concrete instance3 = hasConcrete2.lazy.get(); + assertThat(instance3, not(sameInstance(instance))); + assertThat(Concrete.INSTANCES.get(), equalTo(before + 2)); + } + + @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); + } + })); + } + + @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 void testQualifiedAbstract(Injector injector) { + int before = Concrete.INSTANCES.get(); + + HasQualifiedAbstract hasQualifiedAbstract = new HasQualifiedAbstract(); + injector.injectMembers(hasQualifiedAbstract); + assertThat(Concrete.INSTANCES.get(), equalTo(before)); + + Abstract instance = hasQualifiedAbstract.lazy.get(); + assertThat(Concrete.INSTANCES.get(), equalTo(before + 1)); + + Abstract instance2 = hasQualifiedAbstract.lazy.get(); + assertThat(instance2, sameInstance(instance2)); + assertThat(Concrete.INSTANCES.get(), equalTo(before + 1)); + + HasQualifiedAbstract hasQualifiedAbstract2 = new HasQualifiedAbstract(); + injector.injectMembers(hasQualifiedAbstract2); + assertThat(Concrete.INSTANCES.get(), equalTo(before + 1)); + + Abstract instance3 = hasQualifiedAbstract2.lazy.get(); + assertThat(instance3, not(sameInstance(instance))); + assertThat(Concrete.INSTANCES.get(), equalTo(before + 2)); + } + + @Test(expected = CreationException.class) + public void testMissingBinding() { + Guice.createInjector(new AbstractModule() { + @Override + protected void configure() { + LazyBinder.create(binder()) + .bind(Abstract.class); + } + }); + } + + @Test(expected = CreationException.class) + public void testMissingQualifiedBinding() { + Guice.createInjector(new AbstractModule() { + @Override + protected void configure() { + LazyBinder.create(binder()) + .bind(Abstract.class) + .annotatedWith(Simple.class); + } + }); + } + + private static class TestVisitor extends DefaultBindingTargetVisitor implements LazyBindingVisitor { + @Override + public Boolean visit(LazyBinding binding) { + assertThat(binding.getTargetKey().equals(new Key(Simple.class) { }), is(true)); + return true; + } + + @Override + protected Boolean visitOther(Binding binding) { + return false; + } + } + + private boolean visit(Binding binding) { + return binding.acceptTargetVisitor(new TestVisitor()); + } + + @Test + public void testExtensionSpi() { + Module module = new AbstractModule() { + @Override + protected void configure() { + // TODO: Expose the SPI for unqualified bindings + LazyBinder.create(binder()) + .bind(Abstract.class) + .annotatedWith(Simple.class) + .to(Concrete.class); + } + }; + + List elements = Elements.getElements(module); + + int passed = 0; + for (Element element : elements) { + if (element instanceof Binding) { + if (visit((Binding)element)) { + ++passed; + } + } + } + assertThat(passed, equalTo(1)); + + Injector injector = Guice.createInjector(Elements.getModule(elements)); + assertThat(visit(injector.getBinding(new Key>(Simple.class) { })), is(true)); + assertThat(visit(injector.getBinding(new Key(Simple.class) { })), is(false)); + assertThat(visit(injector.getBinding(new Key() { })), is(false)); + } +} -- cgit v1.2.3 From 2517e3a84c69862453111ef4efdad314074cb32d Mon Sep 17 00:00:00 2001 From: Tavian Barnes Date: Mon, 15 Sep 2014 20:29:47 -0400 Subject: lazy: Add LazySingleton scope. --- .../com/tavianator/sangria/lazy/LazyScopes.java | 59 +++++++++++++++ .../com/tavianator/sangria/lazy/LazySingleton.java | 41 +++++++++++ .../tavianator/sangria/lazy/SangriaLazyModule.java | 44 ++++++++++++ .../tavianator/sangria/lazy/LazySingletonTest.java | 83 ++++++++++++++++++++++ 4 files changed, 227 insertions(+) create mode 100644 sangria-lazy/src/main/java/com/tavianator/sangria/lazy/LazyScopes.java create mode 100644 sangria-lazy/src/main/java/com/tavianator/sangria/lazy/LazySingleton.java create mode 100644 sangria-lazy/src/main/java/com/tavianator/sangria/lazy/SangriaLazyModule.java create mode 100644 sangria-lazy/src/test/java/com/tavianator/sangria/lazy/LazySingletonTest.java (limited to 'sangria-lazy/src/test/java') diff --git a/sangria-lazy/src/main/java/com/tavianator/sangria/lazy/LazyScopes.java b/sangria-lazy/src/main/java/com/tavianator/sangria/lazy/LazyScopes.java new file mode 100644 index 0000000..beb1294 --- /dev/null +++ b/sangria-lazy/src/main/java/com/tavianator/sangria/lazy/LazyScopes.java @@ -0,0 +1,59 @@ +/**************************************************************************** + * Sangria * + * Copyright (C) 2014 Tavian Barnes * + * * + * 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.tavianator.sangria.lazy; + +import com.google.inject.Key; +import com.google.inject.Provider; +import com.google.inject.Scope; +import com.google.inject.Scopes; + +/** + * Lazy scope implementations. + * + * @author Tavian Barnes (tavianator@tavianator.com) + * @version 1.2 + * @since 1.2 + */ +public class LazyScopes { + /** + * Lazy version of {@link Scopes#SINGLETON}. + * + * @see LazySingleton + */ + public static final Scope LAZY_SINGLETON = new Scope() { + public Provider scope(final Key key, final Provider creator) { + final Provider singleton = Scopes.SINGLETON.scope(key, creator); + + return new Provider() { + public T get() { + return singleton.get(); + } + + @Override + public String toString() { + return String.format("%s[%s]", creator, LAZY_SINGLETON); + } + }; + } + + @Override + public String toString() { + return "LazyScopes.LAZY_SINGLETON"; + } + }; +} diff --git a/sangria-lazy/src/main/java/com/tavianator/sangria/lazy/LazySingleton.java b/sangria-lazy/src/main/java/com/tavianator/sangria/lazy/LazySingleton.java new file mode 100644 index 0000000..b8f0482 --- /dev/null +++ b/sangria-lazy/src/main/java/com/tavianator/sangria/lazy/LazySingleton.java @@ -0,0 +1,41 @@ +/**************************************************************************** + * Sangria * + * Copyright (C) 2014 Tavian Barnes * + * * + * 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.tavianator.sangria.lazy; + +import java.lang.annotation.Documented; +import java.lang.annotation.Retention; +import java.lang.annotation.Target; +import javax.inject.Scope; +import javax.inject.Singleton; + +import static java.lang.annotation.ElementType.*; +import static java.lang.annotation.RetentionPolicy.*; + +/** + * Like {@link Singleton}, but always lazy. + * + * @author Tavian Barnes (tavianator@tavianator.com) + * @version 1.2 + * @since 1.2 + */ +@Scope +@Documented +@Target({ TYPE, METHOD }) +@Retention(RUNTIME) +public @interface LazySingleton { +} diff --git a/sangria-lazy/src/main/java/com/tavianator/sangria/lazy/SangriaLazyModule.java b/sangria-lazy/src/main/java/com/tavianator/sangria/lazy/SangriaLazyModule.java new file mode 100644 index 0000000..ff4a02a --- /dev/null +++ b/sangria-lazy/src/main/java/com/tavianator/sangria/lazy/SangriaLazyModule.java @@ -0,0 +1,44 @@ +/**************************************************************************** + * Sangria * + * Copyright (C) 2014 Tavian Barnes * + * * + * 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.tavianator.sangria.lazy; + +import com.google.inject.AbstractModule; + +/** + * Module for lazy initialization features. + * + * @author Tavian Barnes (tavianator@tavianator.com) + * @version 1.2 + * @since 1.2 + */ +public class SangriaLazyModule extends AbstractModule { + @Override + protected void configure() { + bindScope(LazySingleton.class, LazyScopes.LAZY_SINGLETON); + } + + @Override + public boolean equals(Object o) { + return o instanceof SangriaLazyModule; + } + + @Override + public int hashCode() { + return SangriaLazyModule.class.hashCode(); + } +} diff --git a/sangria-lazy/src/test/java/com/tavianator/sangria/lazy/LazySingletonTest.java b/sangria-lazy/src/test/java/com/tavianator/sangria/lazy/LazySingletonTest.java new file mode 100644 index 0000000..69fabce --- /dev/null +++ b/sangria-lazy/src/test/java/com/tavianator/sangria/lazy/LazySingletonTest.java @@ -0,0 +1,83 @@ +/**************************************************************************** + * Sangria * + * Copyright (C) 2014 Tavian Barnes * + * * + * 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.tavianator.sangria.lazy; + +import javax.inject.Inject; +import javax.inject.Provider; + +import com.google.inject.Guice; +import com.google.inject.Injector; +import com.google.inject.Module; +import com.google.inject.Stage; +import org.junit.Test; + +import static org.hamcrest.Matchers.*; +import static org.junit.Assert.*; + +/** + * Tests for the {@link LazySingleton} scope. + * + * @author Tavian Barnes (tavianator@tavianator.com) + * @version 1.2 + * @since 1.2 + */ +public class LazySingletonTest { + @LazySingleton + private static class Scoped { + static final ThreadLocal INSTANCES = new ThreadLocal() { + @Override + protected Integer initialValue() { + return 0; + } + }; + + @Inject + Scoped() { + INSTANCES.set(INSTANCES.get() + 1); + } + } + + @Test + public void testDevelopment() { + test(Stage.DEVELOPMENT, new SangriaLazyModule()); + } + + @Test + public void testProduction() { + test(Stage.PRODUCTION, new SangriaLazyModule()); + } + + @Test + public void testDuplicateModule() { + test(Stage.PRODUCTION, new SangriaLazyModule(), new SangriaLazyModule()); + } + + private void test(Stage stage, Module... modules) { + int before = Scoped.INSTANCES.get(); + + Injector injector = Guice.createInjector(stage, modules); + Provider provider = injector.getProvider(Scoped.class); + assertThat(Scoped.INSTANCES.get(), equalTo(before)); + + Scoped instance = provider.get(); + assertThat(Scoped.INSTANCES.get(), equalTo(before + 1)); + + assertThat(provider.get(), sameInstance(instance)); + assertThat(Scoped.INSTANCES.get(), equalTo(before + 1)); + } +} -- cgit v1.2.3