#20 - Swap/Change SystemContext objects with mocks

Author: rbygrave

src/main/java/io/dinject/BootContext.java

@@ -3,6 +3,7 @@
 import io.dinject.core.BeanContextFactory;
 import io.dinject.core.Builder;
 import io.dinject.core.BuilderFactory;
+import io.dinject.core.SuppliedBean;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
@@ -51,7 +52,7 @@ public class BootContext {
 
   private boolean shutdownHook = true;
 
-  private final List<Object> suppliedBeans = new ArrayList<>();
+  private final List<SuppliedBean> suppliedBeans = new ArrayList<>();
 
   private final Set<String> includeModules = new LinkedHashSet<>();
 
@@ -181,7 +182,23 @@ public BootContext withIgnoreMissingModuleDependencies() {
    * @return This BootContext
    */
   public BootContext withBeans(Object... beans) {
-    suppliedBeans.addAll(Arrays.asList(beans));
+    for (Object bean : beans) {
+      suppliedBeans.add(new SuppliedBean(suppliedType(bean.getClass()), bean));
+    }
+    return this;
+  }
+
+  /**
+   * Add a supplied bean instance with the given injection type.
+   * <p>
+   * This is typically a test double often created by Mockito or similar.
+   * </p>
+   *
+   * @param type The dependency injection type this bean is target for
+   * @param bean The supplied bean instance to use (typically a test mock)
+   */
+  public BootContext withBean(Class<?> type, Object bean) {
+    suppliedBeans.add(new SuppliedBean(type, bean));
     return this;
   }
 
@@ -214,6 +231,19 @@ public BeanContext load() {
     return beanContext;
   }
 
+  /**
+   * Return the type that we map the supplied bean to.
+   */
+  private Class<?> suppliedType(Class<?> suppliedClass) {
+    Class<?> suppliedSuper = suppliedClass.getSuperclass();
+    if (Object.class.equals(suppliedSuper)) {
+      return suppliedClass;
+    } else {
+      // prefer to use the super type of the supplied bean (test double)
+      return suppliedSuper;
+    }
+  }
+
   /**
    * Internal shutdown hook.
    */

src/main/java/io/dinject/core/BuilderFactory.java

@@ -14,7 +14,7 @@ public class BuilderFactory {
    *
    * @param suppliedBeans The list of beans (typically test doubles) supplied when building the context.
    */
-  public static Builder newRootBuilder(List<Object> suppliedBeans) {
+  public static Builder newRootBuilder(List<SuppliedBean> suppliedBeans) {
     return new DBuilder(suppliedBeans);
   }
 

src/main/java/io/dinject/core/DBeanMap.java

@@ -18,60 +18,36 @@
  */
 class DBeanMap {
 
-  private final Map<String, DContextEntry> beans;
+  private final Map<String, DContextEntry> beans = new LinkedHashMap<>();
 
   /**
-   * Create for root builder with supplied beans (usually test doubles).
-   * <p>
-   * Supplied beans are typically test doubles (used in testing) that replace the normally
-   * injected bean. For example, a stub for a database API.
-   * </p>
+   * Create for context builder.
    */
-  DBeanMap(List<Object> suppliedBeans) {
-    if (suppliedBeans.isEmpty()) {
-      beans = null;
-    } else {
-      beans = new LinkedHashMap<>();
-      for (Object suppliedBean : suppliedBeans) {
-        addSuppliedBean(suppliedBean);
-      }
-    }
+  DBeanMap() {
   }
 
   /**
-   * Create for context builder.
+   * Add test double supplied beans.
    */
-  DBeanMap() {
-    beans = new LinkedHashMap<>();
+  void add(List<SuppliedBean> suppliedBeans) {
+    for (SuppliedBean suppliedBean : suppliedBeans) {
+      addSuppliedBean(suppliedBean);
+    }
   }
 
-  private void addSuppliedBean(Object bean) {
+  private void addSuppliedBean(SuppliedBean supplied) {
 
-    Class<?> suppliedClass = bean.getClass();
-    Class<?> suppliedType = suppliedType(suppliedClass);
-    Named annotation = suppliedClass.getAnnotation(Named.class);
+    Class<?> suppliedType = supplied.getType();
+    Named annotation = suppliedType.getAnnotation(Named.class);
     String name = (annotation == null) ? null : annotation.value();
 
-    DContextEntryBean entryBean = DContextEntryBean.of(bean, name, SUPPLIED);
+    DContextEntryBean entryBean = DContextEntryBean.of(supplied.getBean(), name, SUPPLIED);
     beans.computeIfAbsent(suppliedType.getCanonicalName(), s -> new DContextEntry()).add(entryBean);
-    for (Class<?> anInterface : suppliedClass.getInterfaces()) {
+    for (Class<?> anInterface : suppliedType.getInterfaces()) {
       beans.computeIfAbsent(anInterface.getCanonicalName(), s -> new DContextEntry()).add(entryBean);
     }
   }
 
-  /**
-   * Return the type that we map the supplied bean to.
-   */
-  private Class<?> suppliedType(Class<?> suppliedClass) {
-    Class<?> suppliedSuper = suppliedClass.getSuperclass();
-    if (Object.class.equals(suppliedSuper)) {
-      return suppliedClass;
-    } else {
-      // prefer to use the super type of the supplied bean (test double)
-      return suppliedSuper;
-    }
-  }
-
   void registerPrimary(Object bean, String name, Class<?>... types) {
     registerWith(PRIMARY, bean, name, types);
   }
@@ -102,10 +78,6 @@ void registerWith(int flag, Object bean, String name, Class<?>... types) {
   @SuppressWarnings("unchecked")
   <T> T getBean(Class<T> type, String name) {
 
-    if (beans == null) {
-      // no beans in the root suppliedBeanMap
-      return null;
-    }
     DContextEntry entry = beans.get(type.getCanonicalName());
     if (entry != null) {
       T bean = (T) entry.get(name);
@@ -118,10 +90,6 @@ <T> T getBean(Class<T> type, String name) {
 
   <T> BeanEntry<T> candidate(Class<T> type, String name) {
 
-    if (beans == null) {
-      // no beans in the root suppliedBeanMap
-      return null;
-    }
     DContextEntry entry = beans.get(type.getCanonicalName());
     if (entry != null) {
       return entry.candidate(name);
@@ -134,25 +102,17 @@ <T> BeanEntry<T> candidate(Class<T> type, String name) {
    */
   @SuppressWarnings("unchecked")
   void addAll(Class type, List list) {
-    if (beans != null) {
-      DContextEntry entry = beans.get(type.getCanonicalName());
-      if (entry != null) {
-        entry.addAll(list);
-      }
+    DContextEntry entry = beans.get(type.getCanonicalName());
+    if (entry != null) {
+      entry.addAll(list);
     }
   }
 
   /**
-   * Return true if the bean for the given type should be created.
-   * <p>
-   * Return false indicates the type has a supplied (test double) instance that should be used instead and that
-   * means context building will skip creating this bean.
-   * </p>
+   * Return true if there is a supplied bean for this type.
    */
-  boolean isAddBeanFor(String type) {
-    if (beans == null) {
-      return true;
-    }
-    return !beans.containsKey(type);
+  boolean isSupplied(String type) {
+    DContextEntry entry = beans.get(type);
+    return entry != null && entry.isSupplied();
   }
 }

src/main/java/io/dinject/core/DBuilder.java

@@ -34,7 +34,7 @@ class DBuilder implements Builder {
   /**
    * Supplied beans (test doubles) given to the context prior to building.
    */
-  private final DBeanMap suppliedBeanMap;
+  private final boolean hasSuppliedBeans;
 
   /**
    * The context/module name.
@@ -67,17 +67,20 @@ class DBuilder implements Builder {
     this.name = name;
     this.provides = provides;
     this.dependsOn = dependsOn;
-    this.suppliedBeanMap = null;
+    this.hasSuppliedBeans = false;
   }
 
   /**
    * Create for the root builder with supplied beans (test doubles).
    */
-  DBuilder(List<Object> suppliedBeans) {
+  DBuilder(List<SuppliedBean> suppliedBeans) {
     this.name = null;
     this.provides = null;
     this.dependsOn = null;
-    this.suppliedBeanMap = new DBeanMap(suppliedBeans);
+    this.hasSuppliedBeans = (suppliedBeans != null && !suppliedBeans.isEmpty());
+    if (hasSuppliedBeans) {
+      beanMap.add(suppliedBeans);
+    }
   }
 
   @Override
@@ -102,8 +105,11 @@ public void setParent(Builder parent) {
 
   @Override
   public boolean isAddBeanFor(Class<?> addForType, Class<?> injectTarget) {
-    if (suppliedBeanMap != null) {
-      return suppliedBeanMap.isAddBeanFor(addForType.getName());
+    if (hasSuppliedBeans) {
+      return !beanMap.isSupplied(addForType.getName());
+    }
+    if (parent == null) {
+      return true;
     }
     this.injectTarget = injectTarget;
     return parent.isAddBeanFor(addForType);
@@ -119,13 +125,6 @@ public boolean isAddBeanFor(Class<?> injectTarget) {
   public <T> List<T> getList(Class<T> interfaceType) {
 
     List list = new ArrayList<>();
-    if (suppliedBeanMap != null) {
-      suppliedBeanMap.addAll(interfaceType, list);
-      if (!list.isEmpty()) {
-        // not sure if this is correct, supplied so skip
-        return (List<T>) list;
-      }
-    }
 
     beanMap.addAll(interfaceType, list);
     for (BeanContext childContext : children.values()) {
@@ -140,13 +139,6 @@ public <T> List<T> getList(Class<T> interfaceType) {
   @Override
   public <T> BeanEntry<T> candidate(Class<T> cls, String name) {
 
-    if (suppliedBeanMap != null) {
-      BeanEntry<T> entry = suppliedBeanMap.candidate(cls, name);
-      if (entry != null) {
-        return entry;
-      }
-    }
-
     DBeanContext.EntrySort<T> entrySort = new DBeanContext.EntrySort<>();
     entrySort.add(beanMap.candidate(cls, name));
     for (BeanContext childContext : children.values()) {

src/main/java/io/dinject/core/DContextEntry.java

@@ -59,6 +59,18 @@ void add(DContextEntryBean entryBean) {
     entries.add(entryBean);
   }
 
+  /**
+   * Return true if a supplied bean is one of the entries.
+   */
+  boolean isSupplied() {
+    for (DContextEntryBean entry : entries) {
+      if (entry.isSupplied()) {
+        return true;
+      }
+    }
+    return false;
+  }
+
   static class EntryMatcher {
 
     private final String name;

src/main/java/io/dinject/core/DContextEntryBean.java

@@ -66,6 +66,10 @@ boolean isSecondary() {
     return flag == BeanEntry.SECONDARY;
   }
 
+  boolean isSupplied() {
+    return flag == BeanEntry.SUPPLIED;
+  }
+
   @SuppressWarnings("unchecked")
   BeanEntry getBeanEntry() {
     return new BeanEntry(flag, getBean(), name);

src/main/java/io/dinject/core/SuppliedBean.java

@@ -0,0 +1,38 @@
+package io.dinject.core;
+
+/**
+ * Holds beans supplied to the dependency injection.
+ * <p>
+ * These are typically test doubles or mock instances that we supply in testing.
+ * When we supply bean instances they take precedence over other beans that
+ * would normally be injected.
+ * </p>
+ */
+public class SuppliedBean {
+
+  private final Class<?> type;
+
+  private final Object bean;
+
+  /**
+   * Create with a given target type and bean instance.
+   */
+  public SuppliedBean(Class<?> type, Object bean) {
+    this.type = type;
+    this.bean = bean;
+  }
+
+  /**
+   * Return the dependency injection target type.
+   */
+  public Class<?> getType() {
+    return type;
+  }
+
+  /**
+   * Return the bean instance to use (often a test double or mock).
+   */
+  public Object getBean() {
+    return bean;
+  }
+}

src/test/java/org/example/coffee/BootContextAddTest.java

@@ -3,6 +3,7 @@
 import io.dinject.BeanContext;
 import io.dinject.BootContext;
 import org.junit.Test;
+import org.mockito.Mockito;
 
 import static org.assertj.core.api.Assertions.assertThat;
 
@@ -61,6 +62,23 @@ public void withBean_expect_testDoublePumpUsed() {
     }
   }
 
+  @Test
+  public void withMockitoMock_expect_mockUsed() {
+
+    Pump mock = Mockito.mock(Pump.class);
+
+    try (BeanContext context = new BootContext()
+      .withBean(Pump.class, mock)
+      .load()) {
+
+      Pump pump = context.getBean(Pump.class);
+      assertThat(pump).isSameAs(mock);
+
+      CoffeeMaker coffeeMaker = context.getBean(CoffeeMaker.class);
+      assertThat(coffeeMaker).isNotNull();
+    }
+  }
+
   /**
    * Our test double that we want to wire.
    */