Refactor to mvvm Jovche

app/build.gradle

@@ -1,5 +1,3 @@
-
-
 plugins {
     id 'kotlin-android'
     id 'kotlin-android-extensions'
@@ -19,7 +17,7 @@ android {
         versionCode 1
         versionName "1.0"
 
-        testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
+        testInstrumentationRunner "software.ninetofive.assignment_tests.CustomTestRunner"
     }
 
     buildTypes {
@@ -28,34 +26,49 @@ android {
             proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro'
         }
     }
+
+    buildFeatures {
+        viewBinding true
+    }
+
     compileOptions {
         sourceCompatibility JavaVersion.VERSION_1_8
         targetCompatibility JavaVersion.VERSION_1_8
     }
+
     kotlinOptions {
         jvmTarget = '1.8'
     }
-}
 
-ext.rxbindingVersion = '2.1.1'
+    sourceSets {
+        def sharedTestDirectory = "src/sharedTest/java"
+        test {
+            java.srcDir sharedTestDirectory
+        }
+        androidTest {
+            java.srcDir sharedTestDirectory
+        }
+    }
+}
 
 dependencies {
 
     implementation 'androidx.core:core-ktx:1.7.0'
+    implementation "androidx.fragment:fragment-ktx:1.4.1"
     implementation 'androidx.appcompat:appcompat:1.4.1'
     implementation 'com.google.android.material:material:1.5.0'
     implementation 'androidx.constraintlayout:constraintlayout:2.1.3'
-    testImplementation 'junit:junit:4.13.2'
-    androidTestImplementation 'androidx.test.ext:junit:1.1.3'
-    androidTestImplementation 'androidx.test.espresso:espresso-core:3.4.0'
 
     // hilt
     implementation "com.google.dagger:hilt-android:$hilt_version"
     kapt "com.google.dagger:hilt-android-compiler:$hilt_version"
 
-    implementation 'io.reactivex.rxjava2:rxkotlin:2.4.0'
-    implementation 'io.reactivex.rxjava2:rxandroid:2.1.1'
-    implementation "com.jakewharton.rxbinding2:rxbinding:$rxbindingVersion"
-    implementation "com.jakewharton.rxbinding2:rxbinding-support-v4:$rxbindingVersion"
-    implementation "com.jakewharton.rxbinding2:rxbinding-appcompat-v7:$rxbindingVersion"
+    androidTestImplementation "androidx.test.espresso:espresso-core:3.4.0"
+    androidTestImplementation "androidx.test.ext:junit-ktx:1.1.3"
+
+    androidTestImplementation "com.google.dagger:hilt-android-testing:$hilt_version"
+    kaptAndroidTest "com.google.dagger:hilt-android-compiler:$hilt_version"
+
+    testImplementation "org.junit.jupiter:junit-jupiter-api:5.8.2"
+    testRuntimeOnly "org.junit.jupiter:junit-jupiter-engine:5.8.2"
 }

app/src/androidTest/java/software/ninetofive/assignment_tests/CustomTestRunner.kt

@@ -0,0 +1,17 @@
+package software.ninetofive.assignment_tests
+
+import android.app.Application
+import android.content.Context
+import androidx.test.runner.AndroidJUnitRunner
+import dagger.hilt.android.testing.HiltTestApplication
+
+class CustomTestRunner : AndroidJUnitRunner() {
+
+    override fun newApplication(
+        classLoader: ClassLoader?,
+        className: String?,
+        context: Context?
+    ): Application {
+        return super.newApplication(classLoader, HiltTestApplication::class.java.name, context)
+    }
+}

app/src/androidTest/java/software/ninetofive/assignment_tests/main/MainScreenRobot.kt

@@ -0,0 +1,81 @@
+package software.ninetofive.assignment_tests.main
+
+import androidx.test.core.app.ActivityScenario
+import androidx.test.espresso.Espresso.onView
+import androidx.test.espresso.action.ViewActions.click
+import androidx.test.espresso.assertion.ViewAssertions.matches
+import androidx.test.espresso.matcher.ViewMatchers.*
+import software.ninetofive.assignment_tests.R
+import software.ninetofive.assignment_tests.main.SelectedScreen.*
+import software.ninetofive.assignment_tests.main.ViewingOption.*
+
+fun launchMainScreen(
+    block: MainScreenRobot.() -> Unit
+): MainScreenRobot {
+    ActivityScenario.launch(MainActivity::class.java)
+    return MainScreenRobot().apply(block)
+}
+
+class MainScreenRobot {
+
+    fun checkSelectedScreenHeaderShown() {
+        onView(withText(R.string.choose_start_screen_header)).check(matches(isDisplayed()))
+    }
+
+    fun tapOnScreenAOption() {
+        onView(withText(R.string.check_start_screen_a)).perform(click())
+    }
+
+    fun tapOnScreenBOption() {
+        onView(withText(R.string.check_start_screen_b)).perform(click())
+    }
+
+    fun tapOnScreenCOption() {
+        onView(withText(R.string.check_start_screen_c)).perform(click())
+    }
+
+    fun checkSelectedScreenOptionIs(selectedScreen: SelectedScreen) {
+        val screenASelected = if (selectedScreen == SCREEN_A) isChecked() else isNotChecked()
+        val screenBSelected = if (selectedScreen == SCREEN_B) isChecked() else isNotChecked()
+        val screenCSelected = if (selectedScreen == SCREEN_C) isChecked() else isNotChecked()
+
+        onView(withId(R.id.radio_screen_a)).check(matches(screenASelected))
+        onView(withId(R.id.radio_screen_b)).check(matches(screenBSelected))
+        onView(withId(R.id.radio_screen_c)).check(matches(screenCSelected))
+    }
+
+    fun checkViewingOptionsHeader() {
+        onView(withText(R.string.check_view_options_label)).check(matches(isDisplayed()))
+    }
+
+    fun tapOnShowNameOption() {
+        onView(withText(R.string.check_view_options_name)).perform(click())
+    }
+
+    fun tapOnDateOption() {
+        onView(withText(R.string.check_view_options_date)).perform(click())
+    }
+
+    fun tapOnNothingOption() {
+        onView(withText(R.string.check_view_options_nothing)).perform(click())
+    }
+
+    fun checkSelectedViewingOptionIs(viewingOption: ViewingOption) {
+        val showNameSelected = if (viewingOption == SHOW_NAME) isChecked() else isNotChecked()
+        val showDateSelected = if (viewingOption == DATE) isChecked() else isNotChecked()
+        val showNothingSelected = if (viewingOption == NOTHING) isChecked() else isNotChecked()
+
+        onView(withId(R.id.radio_show_name)).check(matches(showNameSelected))
+        onView(withId(R.id.radio_show_date)).check(matches(showDateSelected))
+        onView(withId(R.id.radio_show_nothing)).check(matches(showNothingSelected))
+    }
+
+    fun tapOnShowValidDot() {
+        onView(withText(R.string.show_valid_spot_settings_label)).perform(click())
+    }
+
+    fun checkShowValidDotOptionSelected(isSelected: Boolean) {
+        val selected = if (isSelected) isChecked() else isNotChecked()
+        onView(withId(R.id.valid_dot_switch)).check(matches(selected))
+    }
+}

app/src/androidTest/java/software/ninetofive/assignment_tests/main/MainScreenTest.kt

@@ -0,0 +1,89 @@
+package software.ninetofive.assignment_tests.main
+
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import dagger.hilt.android.testing.BindValue
+import dagger.hilt.android.testing.HiltAndroidRule
+import dagger.hilt.android.testing.HiltAndroidTest
+import org.junit.Rule
+import org.junit.Test
+import org.junit.runner.RunWith
+import software.ninetofive.assignment_tests.utils.AppPreferences
+import software.ninetofive.assignment_tests.utils.InMemorySharedPreferences
+
+@HiltAndroidTest
+@RunWith(AndroidJUnit4::class)
+class MainScreenTest {
+
+    @get:Rule
+    val hiltRule = HiltAndroidRule(this)
+
+    @BindValue
+    val appPreferences = AppPreferences(InMemorySharedPreferences())
+
+    @Test
+    fun defaultSelectScreenOptionValue() {
+        launchMainScreen {
+            checkSelectedScreenHeaderShown()
+            //TODO Bug! Default preference (SCREEN_C) is recognised as B on screen
+            checkSelectedScreenOptionIs(SelectedScreen.SCREEN_B)
+        }
+    }
+
+    @Test
+    fun selectScreenOptionInteractions() {
+        appPreferences.setStartScreen(SelectedScreen.SCREEN_A)
+
+        launchMainScreen {
+            checkSelectedScreenHeaderShown()
+            checkSelectedScreenOptionIs(SelectedScreen.SCREEN_A)
+            tapOnScreenBOption()
+            checkSelectedScreenOptionIs(SelectedScreen.SCREEN_B)
+            tapOnScreenCOption()
+            checkSelectedScreenOptionIs(SelectedScreen.SCREEN_C)
+            tapOnScreenAOption()
+            checkSelectedScreenOptionIs(SelectedScreen.SCREEN_A)
+        }
+    }
+
+    @Test
+    fun defaultViewingOptionValue() {
+        launchMainScreen {
+            checkViewingOptionsHeader()
+            checkSelectedViewingOptionIs(ViewingOption.NOTHING)
+        }
+    }
+
+    @Test
+    fun selectViewingOptionInteractions() {
+        appPreferences.setViewingOption(ViewingOption.DATE)
+
+        launchMainScreen {
+            checkViewingOptionsHeader()
+            checkSelectedViewingOptionIs(ViewingOption.DATE)
+            tapOnNothingOption()
+            checkSelectedViewingOptionIs(ViewingOption.NOTHING)
+            tapOnShowNameOption()
+            checkSelectedViewingOptionIs(ViewingOption.SHOW_NAME)
+            tapOnDateOption()
+            checkSelectedViewingOptionIs(ViewingOption.DATE)
+        }
+    }
+
+    @Test
+    fun defaultShowValidDotValue() {
+        launchMainScreen {
+            checkShowValidDotOptionSelected(false)
+        }
+    }
+
+    @Test
+    fun showValidDotOptionInteractions() {
+        launchMainScreen {
+            checkShowValidDotOptionSelected(false)
+            tapOnShowValidDot()
+            checkShowValidDotOptionSelected(true)
+            tapOnShowValidDot()
+            checkShowValidDotOptionSelected(false)
+        }
+    }
+}