Add an test strategy parameter in the ApplicationTestModule that allows injecting either a mock, spy or real DataManager during tests

Author: Ivan Carballo

app/src/androidTest/java/uk/co/ribot/androidboilerplate/MainActivityTest.java

@@ -16,6 +16,7 @@
 import rx.Observable;
 import uk.co.ribot.androidboilerplate.data.model.Ribot;
 import uk.co.ribot.androidboilerplate.test.common.TestDataFactory;
+import uk.co.ribot.androidboilerplate.test.common.injection.module.ApplicationTestModule;
 import uk.co.ribot.androidboilerplate.test.common.rules.ClearDataRule;
 import uk.co.ribot.androidboilerplate.test.common.rules.TestComponentRule;
 import uk.co.ribot.androidboilerplate.ui.main.MainActivity;
@@ -30,16 +31,17 @@
 @RunWith(AndroidJUnit4.class)
 public class MainActivityTest {
 
-    public final TestComponentRule component =
-            new TestComponentRule(InstrumentationRegistry.getTargetContext(), true);
+    public final TestComponentRule component = new TestComponentRule(
+            InstrumentationRegistry.getTargetContext(),
+            ApplicationTestModule.DataManagerTestStrategy.SPY);
     public final ClearDataRule clearDataRule = new ClearDataRule(component);
     public final ActivityTestRule<MainActivity> main =
             new ActivityTestRule<>(MainActivity.class, false, false);
 
     // TestComponentRule needs to go first to make sure the Dagger ApplicationTestComponent is set
     // in the Application before any Activity is launched.
     @Rule
-    public TestRule chain = RuleChain.outerRule(component).around(clearDataRule).around(main);
+    public final TestRule chain = RuleChain.outerRule(component).around(clearDataRule).around(main);
 
     @Test
     public void listOfRibotsShows() {

app/src/commonTest/java/uk/co/ribot/androidboilerplate/test/common/TestDataManager.java

@@ -1,7 +1,6 @@
 package uk.co.ribot.androidboilerplate.test.common;
 
 import android.app.Application;
-import android.content.Context;
 
 import org.mockito.Mockito;
 

app/src/commonTest/java/uk/co/ribot/androidboilerplate/test/common/injection/module/ApplicationTestModule.java

@@ -20,12 +20,24 @@
  */
 @Module
 public class ApplicationTestModule {
+
+    public enum DataManagerTestStrategy { REAL, MOCK, SPY }
+
     private final Application mApplication;
-    private boolean mMockableDataManager;
+    private DataManagerTestStrategy mDataManagerTestStrategy;
 
-    public ApplicationTestModule(Application application, boolean mockableDataManager) {
+    /**
+     * Create a module that provides application dependencies for a testing environment.
+     * It takes a dataManagerTestStrategy that can be 1) REAL: provides real instances of
+     * the DataManager, 2) MOCK: provides Mockito mock instances of the DataManager that must be
+     * stubbed, 3) SPY: provides an Mockito spy instance of the DataManager that can be partially
+     * stubbed, you can read more about Mockito spies and mocks to help you choose the best
+     * strategy for your tests.
+     */
+    public ApplicationTestModule(Application application,
+                                 DataManagerTestStrategy dataManagerTestStrategy) {
         mApplication = application;
-        mMockableDataManager = mockableDataManager;
+        mDataManagerTestStrategy = dataManagerTestStrategy;
     }
 
     @Provides
@@ -37,8 +49,14 @@ Application provideApplication() {
     @Provides
     @Singleton
     DataManager provideDataManager() {
-        TestDataManager testDataManager = new TestDataManager(mApplication);
-        return mMockableDataManager ? spy(testDataManager) : testDataManager;
+        switch (mDataManagerTestStrategy) {
+            case MOCK:
+                return mock(TestDataManager.class);
+            case SPY:
+                return spy(new TestDataManager(mApplication));
+            default:
+                return new TestDataManager(mApplication);
+        }
     }
 
     @Provides

app/src/commonTest/java/uk/co/ribot/androidboilerplate/test/common/injection/module/DataManagerTestModule.java

@@ -1,9 +1,6 @@
 package uk.co.ribot.androidboilerplate.test.common.injection.module;
 
 import android.app.Application;
-import android.content.Context;
-
-import org.mockito.Mockito;
 
 import dagger.Module;
 import dagger.Provides;

app/src/commonTest/java/uk/co/ribot/androidboilerplate/test/common/rules/TestComponentRule.java

@@ -26,26 +26,35 @@ public class TestComponentRule implements TestRule {
 
     private TestComponent mTestComponent;
     private Context mContext;
-    private boolean mMockableDataManager;
+    private ApplicationTestModule.DataManagerTestStrategy mDataManagerTestStrategy;
 
     /**
-     * If mockableDataManager is true, it will crate a data manager using Mockito.spy()
-     * Spy objects call real methods unless they are stubbed. So the DataManager will work as
-     * usual unless an specific method is mocked.
-     * A full mock DataManager is not an option because there are several methods that still
-     * need to return the real value, i.e dataManager.getSubscribeScheduler()
+     * Create a rule that sets up a Dagger TestComponent to inject test dependencies such as mocks.
+     *
+     * It takes a dataManagerTestStrategy that can be:
+     * 1) REAL: injects real instances of the DataManager
+     * 2) MOCK: injects Mockito mock instances of the DataManager that must be stubbed
+     * 3) SPY: injects an Mockito spy instance of the DataManager that can be partially stubbed.
+     * You can read more about Mockito spies and mocks to help you choose the best
+     * strategy for your tests.
      */
-    public TestComponentRule(Context context, boolean mockableDataManager) {
-        init(context, mockableDataManager);
+    public TestComponentRule(Context context,
+                             ApplicationTestModule.DataManagerTestStrategy dmTestStrategy) {
+        init(context, dmTestStrategy);
     }
 
+    /**
+     * Create a rule that sets up a Dagger TestComponent to inject test dependencies such as mocks.
+     * It will use the default dataManagerTestStrategy that is REAL.
+     */
     public TestComponentRule(Context context) {
-        init(context, false);
+        init(context, ApplicationTestModule.DataManagerTestStrategy.REAL);
     }
 
-    private void init(Context context, boolean mockableDataManager) {
+    private void init(Context context,
+                      ApplicationTestModule.DataManagerTestStrategy dataManagerTestStrategy) {
         mContext = context;
-        mMockableDataManager = mockableDataManager;
+        mDataManagerTestStrategy = dataManagerTestStrategy;
     }
 
     public TestComponent getTestComponent() {
@@ -56,6 +65,15 @@ public Context getContext() {
         return mContext;
     }
 
+    public ApplicationTestModule.DataManagerTestStrategy getDataManagerTestStrategy() {
+        return mDataManagerTestStrategy;
+    }
+
+    /**
+     * This could return a real instance, a Mockito.mock or a Mockito.spy depending on the
+     * strategy chosen. You can use {@link #getDataManagerTestStrategy()} to get the current
+     * strategy.
+     */
     public TestDataManager getDataManager() {
         return (TestDataManager) mTestComponent.dataManager();
     }
@@ -75,7 +93,7 @@ public PreferencesHelper getPreferencesHelper() {
     private void setupDaggerTestComponentInApplication() {
         BoilerplateApplication application = BoilerplateApplication.get(mContext);
         ApplicationTestModule module = new ApplicationTestModule(application,
-                mMockableDataManager);
+                mDataManagerTestStrategy);
         mTestComponent = DaggerTestComponent.builder()
                 .applicationTestModule(module)
                 .build();

app/src/main/java/uk/co/ribot/androidboilerplate/data/DataManager.java

@@ -1,8 +1,6 @@
 package uk.co.ribot.androidboilerplate.data;
 
 import android.app.Application;
-import android.content.Context;
-import android.test.mock.MockApplication;
 
 import com.squareup.otto.Bus;
 

app/src/main/java/uk/co/ribot/androidboilerplate/injection/module/DataManagerModule.java

@@ -1,7 +1,6 @@
 package uk.co.ribot.androidboilerplate.injection.module;
 
 import android.app.Application;
-import android.content.Context;
 
 import dagger.Module;
 import dagger.Provides;

app/src/main/java/uk/co/ribot/androidboilerplate/injection/module/PresentersModule.java

@@ -1,9 +1,6 @@
 package uk.co.ribot.androidboilerplate.injection.module;
 
 import android.app.Application;
-import android.content.Context;
-
-import java.lang.ref.WeakReference;
 
 import dagger.Module;
 import dagger.Provides;

app/src/test/java/uk/co/ribot/androidboilerplate/MainPresenterTest.java

@@ -10,14 +10,13 @@
 
 import rx.Observable;
 import uk.co.ribot.androidboilerplate.data.model.Ribot;
-import uk.co.ribot.androidboilerplate.util.MockDependenciesHelper;
 import uk.co.ribot.androidboilerplate.test.common.TestDataFactory;
+import uk.co.ribot.androidboilerplate.test.common.runner.RxJavaTestRunner;
 import uk.co.ribot.androidboilerplate.ui.main.MainMvpView;
 import uk.co.ribot.androidboilerplate.ui.main.MainPresenter;
-import uk.co.ribot.androidboilerplate.test.common.runner.RxJavaTestRunner;
+import uk.co.ribot.androidboilerplate.util.MockDependenciesHelper;
 
 import static org.mockito.Matchers.anyListOf;
-import static org.mockito.Matchers.anyString;
 import static org.mockito.Mockito.doReturn;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.never;
@@ -51,7 +50,7 @@ public void loadRibotsReturnsRibots() {
         mMainPresenter.loadRibots();
         verify(mMockMainMvpView).showRibots(ribots);
         verify(mMockMainMvpView, never()).showRibotsEmpty();
-        verify(mMockMainMvpView, never()).showError(anyString());
+        verify(mMockMainMvpView, never()).showError();
     }
 
     @Test
@@ -63,7 +62,7 @@ public void loadRibotsReturnsEmptyList() {
         mMainPresenter.loadRibots();
         verify(mMockMainMvpView).showRibotsEmpty();
         verify(mMockMainMvpView, never()).showRibots(anyListOf(Ribot.class));
-        verify(mMockMainMvpView, never()).showError(anyString());
+        verify(mMockMainMvpView, never()).showError();
     }
 
     @Test
@@ -73,7 +72,7 @@ public void loadRibotsFails() {
                 .getRibots();
 
         mMainPresenter.loadRibots();
-        verify(mMockMainMvpView).showError(anyString());
+        verify(mMockMainMvpView).showError();
         verify(mMockMainMvpView, never()).showRibotsEmpty();
         verify(mMockMainMvpView, never()).showRibots(anyListOf(Ribot.class));
     }

app/src/test/java/uk/co/ribot/androidboilerplate/util/MockDependenciesHelper.java

@@ -29,8 +29,10 @@ public class MockDependenciesHelper {
 
     public MockDependenciesHelper() {
         mMockApplication = Mockito.mock(BoilerplateApplication.class);
+        ApplicationTestModule applicationTestModule = new ApplicationTestModule(mMockApplication,
+                ApplicationTestModule.DataManagerTestStrategy.MOCK);
         mTestComponent = DaggerTestComponent.builder()
-                .applicationTestModule(new ApplicationTestModule(mMockApplication, true))
+                .applicationTestModule(applicationTestModule)
                 .build();
 
         when(mMockApplication.getComponent())