Added Dagger 2 architecture to test module

app/build.gradle

@@ -12,9 +12,9 @@ buildscript {
 
 apply plugin: 'com.android.application'
 apply plugin: 'com.neenbedankt.android-apt'
-apply plugin: 'me.tatarka.retrolambda'
 apply plugin: 'com.ofg.uptodate'
 apply from: '../dependencies.gradle'
+apply plugin: 'me.tatarka.retrolambda'
 
 repositories {
     mavenCentral()
@@ -49,8 +49,9 @@ android {
         buildConfigField 'String', 'GIT_SHA', "\"${gitSha}\""
         buildConfigField 'long', 'GIT_TIMESTAMP', "${gitTimestamp}"
 
+
         testApplicationId "${versions.packagename}.tests"
-        testInstrumentationRunner "android.support.test.runner.AndroidJUnitRunner"
+        testInstrumentationRunner "ru.ltst.u2020mvp.U2020InstrumentationRunner"
     }
 
     signingConfigs {
@@ -83,16 +84,6 @@ android {
         }
     }
 
-//    productFlavors {
-//        internal {
-//            applicationId "${packagename}.internal"
-//
-//        }
-//        production {
-//            applicationId "${packagename}"
-//        }
-//    }
-
     lintOptions {
         textReport true
         textOutput 'stdout'
@@ -116,6 +107,9 @@ configurations {
 
 configurations.all {
     resolutionStrategy {
+        force "com.android.support:support-annotations:${SUPPORT_V7_VERSION}"
+        force "com.android.support:recyclerview-v7:${SUPPORT_V7_VERSION}"
+        force "com.android.support:support-v4:${SUPPORT_V4_VERSION}"
         force libraries.supportAnnotation
     }
 }
@@ -170,14 +164,14 @@ dependencies {
 
     //-----tests-----
     // Espresso 2 Dependencies
-    androidTestCompile libraries.testingSupportLib
     androidTestCompile libraries.junit
     androidTestCompile libraries.testRunner
     androidTestCompile libraries.testRules
     androidTestCompile libraries.espressoCore
-//    androidTestCompile('com.android.support.test.espresso:espresso-contrib:2.0') {
-//        exclude module: 'support-annotations'
-//    }
+    androidTestApt libraries.daggerCompiler
+
+    testCompile libraries.mockito
+    testCompile libraries.junit
 }
 
 // change apk name

app/src/androidTest/java/ru/ltst/u2020mvp/TestU2020Application.java

@@ -0,0 +1,23 @@
+package ru.ltst.u2020mvp;
+
+
+public class TestU2020Application extends U2020App {
+    private TestU2020Component component;
+
+    @Override
+    public void buildComponentAndInject() {
+        component = DaggerTestU2020Component.builder()
+                .u2020AppModule(new U2020AppModule(this))
+                .build();
+        component.inject(this);
+    }
+
+    @Override
+    public U2020Component component() {
+        return component;
+    }
+
+    public TestU2020Component getTestComponent() {
+        return component;
+    }
+}

app/src/androidTest/java/ru/ltst/u2020mvp/TestU2020Component.java

@@ -0,0 +1,18 @@
+package ru.ltst.u2020mvp;
+
+import dagger.Component;
+import ru.ltst.u2020mvp.data.DebugDataModule;
+import ru.ltst.u2020mvp.ui.DebugUiModule;
+import ru.ltst.u2020mvp.ui.ExternalIntentActivityTest;
+import ru.ltst.u2020mvp.ui.screen.main.MainActivityTest;
+import ru.ltst.u2020mvp.ui.screen.main.view.MainViewTest;
+
+@ApplicationScope
+@Component(modules = {U2020AppModule.class, DebugUiModule.class, DebugDataModule.class, TestU2020Module.class})
+public interface TestU2020Component extends U2020Component {
+    void inject(MainActivityTest mainActivityTest);
+
+    void inject(ExternalIntentActivityTest externalIntentActivityTest);
+
+    void inject(MainViewTest mainViewTest);
+}

app/src/androidTest/java/ru/ltst/u2020mvp/TestU2020Module.java

@@ -0,0 +1,20 @@
+package ru.ltst.u2020mvp;
+
+import dagger.Module;
+import dagger.Provides;
+import ru.ltst.u2020mvp.ApplicationScope;
+import ru.ltst.u2020mvp.IsInstrumentationTest;
+
+@Module
+public class TestU2020Module {
+    // Low-tech flag to force certain debug build behaviors when running in an instrumentation test.
+    // This value is used in the creation of singletons so it must be set before the graph is created.
+    static boolean instrumentationTest = true;
+
+    @Provides
+    @ApplicationScope
+    @IsInstrumentationTest
+    boolean provideIsInstrumentationTest() {
+        return instrumentationTest;
+    }
+}

app/src/androidTest/java/ru/ltst/u2020mvp/U2020InstrumentationRunner.java

@@ -0,0 +1,13 @@
+package ru.ltst.u2020mvp;
+
+import android.app.Application;
+import android.content.Context;
+import android.support.test.runner.AndroidJUnitRunner;
+
+public class U2020InstrumentationRunner extends AndroidJUnitRunner {
+    @Override
+    public Application newApplication(ClassLoader cl, String className, Context context)
+            throws InstantiationException, IllegalAccessException, ClassNotFoundException {
+        return super.newApplication(cl, TestU2020Application.class.getName(), context);
+    }
+}

app/src/androidTest/java/ru/ltst/u2020mvp/base/BaseTest.java

@@ -0,0 +1,17 @@
+package ru.ltst.u2020mvp.base;
+
+
+import android.support.test.InstrumentationRegistry;
+
+import ru.ltst.u2020mvp.TestU2020Application;
+import ru.ltst.u2020mvp.TestU2020Component;
+
+public abstract class BaseTest {
+    protected TestU2020Application getApp() {
+        return (TestU2020Application) InstrumentationRegistry.getTargetContext().getApplicationContext();
+    }
+
+    protected TestU2020Component getTestComponent() {
+        return getApp().getTestComponent();
+    }
+}

app/src/androidTest/java/ru/ltst/u2020mvp/base/ComponentFinderTest.java

@@ -0,0 +1,27 @@
+package ru.ltst.u2020mvp.base;
+
+import android.content.Context;
+import android.support.test.espresso.matcher.ViewMatchers;
+import android.support.test.rule.ActivityTestRule;
+import android.support.test.runner.AndroidJUnit4;
+
+import org.hamcrest.CoreMatchers;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+import ru.ltst.u2020mvp.ui.screen.main.MainActivity;
+import ru.ltst.u2020mvp.ui.screen.main.MainScope;
+
+@RunWith(AndroidJUnit4.class)
+public class ComponentFinderTest {
+    @Rule
+    public ActivityTestRule<MainActivity> activityTestRule = new ActivityTestRule<>(MainActivity.class);
+
+    @Test
+    public void findActivityComponentTest() {
+        Context context = activityTestRule.getActivity();
+        ViewMatchers.assertThat(ComponentFinder.findActivityComponent(context),
+                CoreMatchers.instanceOf(MainScope.MainComponent.class));
+    }
+}

app/src/androidTest/java/ru/ltst/u2020mvp/base/mvp/BasePresenterTest2.java

@@ -0,0 +1,88 @@
+package ru.ltst.u2020mvp.base.mvp;
+
+
+import android.support.test.espresso.UiController;
+import android.support.test.rule.ActivityTestRule;
+import android.support.test.runner.AndroidJUnit4;
+
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.ExpectedException;
+import org.junit.runner.RunWith;
+
+import ru.ltst.u2020mvp.R;
+import ru.ltst.u2020mvp.ui.screen.main.MainActivity;
+import ru.ltst.u2020mvp.ui.screen.main.MainPresenter;
+import ru.ltst.u2020mvp.ui.screen.main.view.MainView;
+import ru.ltst.u2020mvp.util.SimpleViewAction;
+
+import static android.support.test.espresso.Espresso.onView;
+import static android.support.test.espresso.matcher.ViewMatchers.withId;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+
+@RunWith(AndroidJUnit4.class)
+public class BasePresenterTest2 {
+    @Rule
+    public ExpectedException expectedException = ExpectedException.none();
+    @Rule
+    public ActivityTestRule<MainActivity> activityTestRule =
+            new ActivityTestRule<>(MainActivity.class);
+
+    MainPresenter mainPresenter;
+
+    @Before
+    public void setup() {
+        mainPresenter = activityTestRule.getActivity().getComponent().presenter();
+    }
+
+    @Test
+    public void takeView() throws Exception {
+        assertEquals(true, mainPresenter.hasView());
+        mainPresenter.getView(); //assert no errors
+    }
+
+    @Test
+    public void dropView() throws Exception {
+        expectedException.expect(NullPointerException.class);
+        mainPresenter.dropView(null);
+        onView(withId(R.id.main_drawer_layout))
+                .perform(new SimpleViewAction<MainView>() {
+                    @Override
+                    protected void call(UiController uiController, MainView view) {
+                        mainPresenter.dropView(view);
+                    }
+                });
+        assertEquals(false, mainPresenter.hasView());
+        expectedException.expect(NullPointerException.class);
+        mainPresenter.getView();
+    }
+
+    @Test
+    public void hasView() throws Exception {
+        assertEquals(true, mainPresenter.hasView());
+        onView(withId(R.id.main_drawer_layout))
+                .perform(new SimpleViewAction<MainView>() {
+                    @Override
+                    protected void call(UiController uiController, MainView view) {
+                        mainPresenter.dropView(view);
+                    }
+                });
+        assertEquals(false, mainPresenter.hasView());
+    }
+
+    @Test
+    public void getView() throws Exception {
+        assertNotNull(mainPresenter.getView());
+        onView(withId(R.id.main_drawer_layout))
+                .perform(new SimpleViewAction<MainView>() {
+                    @Override
+                    protected void call(UiController uiController, MainView view) {
+                        mainPresenter.dropView(view);
+                    }
+                });
+        expectedException.expect(NullPointerException.class);
+        mainPresenter.getView();
+    }
+}