Register a new user for every Android test

Author: Saket Narayan

app/src/androidTest/java/org/simple/clinic/AuthenticationRule.kt

@@ -1,10 +1,14 @@
 package org.simple.clinic
 
 import com.google.common.truth.Truth.assertThat
+import io.bloco.faker.Faker
 import org.junit.rules.TestRule
 import org.junit.runner.Description
 import org.junit.runners.model.Statement
-import org.simple.clinic.login.LoginResult
+import org.simple.clinic.facility.Facility
+import org.simple.clinic.facility.FacilitySyncApiV1
+import org.simple.clinic.patient.SyncStatus
+import org.simple.clinic.registration.RegistrationResult
 import org.simple.clinic.user.User
 import org.simple.clinic.user.UserSession
 import org.simple.clinic.user.UserStatus
@@ -19,6 +23,15 @@ class AuthenticationRule : TestRule {
   @Inject
   lateinit var testData: TestData
 
+  @Inject
+  lateinit var facilityApi: FacilitySyncApiV1
+
+  @Inject
+  lateinit var facilityDao: Facility.RoomDao
+
+  @Inject
+  lateinit var faker: Faker
+
   override fun apply(base: Statement, description: Description): Statement {
     return object : Statement() {
       override fun evaluate() {
@@ -33,7 +46,7 @@ class AuthenticationRule : TestRule {
         try {
           // Login also needs to happen inside this try block so that in case
           // of a failure, logout() still gets called to reset all app data.
-          login()
+          register()
           base.evaluate()
 
         } finally {
@@ -43,11 +56,28 @@ class AuthenticationRule : TestRule {
     }
   }
 
-  private fun login() {
-    val loginResult = userSession.saveOngoingLoginEntry(testData.qaOngoingLoginEntry())
-        .andThen(userSession.loginWithOtp(testData.qaUserOtp()))
+  private fun register() {
+    val facilities = facilityApi.pull(10)
+        .map { it.facilities }
+        .map { facilities -> facilities.map { it.toDatabaseModel(SyncStatus.DONE) } }
         .blockingGet()
-    assertThat(loginResult).isInstanceOf(LoginResult.Success::class.java)
+    facilityDao.save(facilities)
+
+    while (true) {
+      val registrationEntry = testData.ongoingRegistrationEntry(
+          phoneNumber = faker.number.number(10),
+          pin = testData.qaUserPin(),
+          facilities = facilities)
+
+      val registrationResult = userSession.saveOngoingRegistrationEntry(registrationEntry)
+          .andThen(userSession.loginFromOngoingRegistrationEntry())
+          .andThen(userSession.register())
+          .blockingGet()
+
+      if (registrationResult is RegistrationResult.Success) {
+        break
+      }
+    }
 
     val (accessToken) = userSession.accessToken()
     assertThat(accessToken).isNotNull()

app/src/androidTest/java/org/simple/clinic/TestData.kt

@@ -6,6 +6,7 @@ import org.simple.clinic.di.AppScope
 import org.simple.clinic.drugs.sync.PrescribedDrugPayload
 import org.simple.clinic.facility.Facility
 import org.simple.clinic.facility.FacilityPayload
+import org.simple.clinic.facility.FacilityRepository
 import org.simple.clinic.medicalhistory.MedicalHistory
 import org.simple.clinic.medicalhistory.sync.MedicalHistoryPayload
 import org.simple.clinic.overdue.Appointment
@@ -20,9 +21,9 @@ import org.simple.clinic.patient.SyncStatus
 import org.simple.clinic.patient.sync.PatientAddressPayload
 import org.simple.clinic.patient.sync.PatientPayload
 import org.simple.clinic.patient.sync.PatientPhoneNumberPayload
-import org.simple.clinic.user.OngoingLoginEntry
 import org.simple.clinic.user.OngoingRegistrationEntry
 import org.simple.clinic.user.User
+import org.simple.clinic.user.UserSession
 import org.simple.clinic.user.UserStatus
 import org.threeten.bp.Instant
 import org.threeten.bp.LocalDate
@@ -36,18 +37,25 @@ private fun <T : Enum<T>> randomOfEnum(enumClass: KClass<T>): T {
 }
 
 @AppScope
-class TestData @Inject constructor(private val faker: Faker) {
+class TestData @Inject constructor(
+    private val faker: Faker,
+    private val facilityRepository: FacilityRepository,
+    private val userSession: UserSession
+) {
 
-  fun qaUserUuid() = UUID.fromString("c6834f82-3305-4144-9dc8-5f77c908ebf1")
+  fun qaUserUuid(): UUID =
+      userSession.requireLoggedInUser()
+          .map { it.uuid }
+          .blockingFirst()
 
-  fun qaUserOtp(): String = "000000"
+  fun qaUserPin() = "1712"
 
-  fun qaOngoingLoginEntry() = OngoingLoginEntry(qaUserUuid(), phoneNumber = "0000", pin = "0000")
+  fun qaUserOtp() = "000000"
 
-  @Deprecated(message = "Get real facilities from the server instead. Look at UserSessionAndroidTest for examples.")
-  fun qaUserFacilityUuid(): UUID {
-    return UUID.fromString("43dad34c-139e-4e5f-976e-a3ef1d9ac977")
-  }
+  fun qaUserFacilityUuid(): UUID =
+      facilityRepository.currentFacility(userSession)
+          .map { it.uuid }
+          .blockingFirst()
 
   fun patientPayload(
       fullName: String = faker.name.name(),
@@ -161,11 +169,14 @@ class TestData @Inject constructor(private val faker: Faker) {
         loggedInStatus = loggedInStatus)
   }
 
-  fun ongoingRegistrationEntry(facilities: List<Facility>): OngoingRegistrationEntry {
-    val pin = faker.number.number(4)
+  fun ongoingRegistrationEntry(
+      phoneNumber: String = faker.number.number(10),
+      pin: String = qaUserPin(),
+      facilities: List<Facility>
+  ): OngoingRegistrationEntry {
     return OngoingRegistrationEntry(
         uuid = UUID.randomUUID(),
-        phoneNumber = faker.number.number(10),
+        phoneNumber = phoneNumber,
         fullName = faker.name.name(),
         pin = pin,
         pinConfirmation = pin,
@@ -355,7 +366,7 @@ class TestData @Inject constructor(private val faker: Faker) {
     val ongoingPhoneNumber = phone?.let {
       OngoingPatientEntry.PhoneNumber(phone, PatientPhoneNumberType.MOBILE, active = true)
     }
-    return OngoingPatientEntry(ongoingPersonalDetails, ongoingAddress, ongoingPhoneNumber)
 
+    return OngoingPatientEntry(ongoingPersonalDetails, ongoingAddress, ongoingPhoneNumber)
   }
 }

app/src/androidTest/java/org/simple/clinic/bp/sync/BloodPressureSyncAndroidTest.kt

@@ -139,7 +139,7 @@ class BloodPressureSyncAndroidTest {
 
   @Test
   fun when_pulling_measurements_then_paginate_till_the_server_does_not_have_anymore_measurements() {
-    lastPullTimestamp.set(Just(Instant.now().minusMillis(100)))
+    lastPullTimestamp.set(Just(Instant.EPOCH))
 
     val measurementsToInsert = 2 * configProvider.blockingGet().batchSize + 7
 

app/src/androidTest/java/org/simple/clinic/drugs/sync/PrescriptionSyncAndroidTest.kt

@@ -143,7 +143,7 @@ class PrescriptionSyncAndroidTest {
 
   @Test
   fun when_pulling_prescriptions_then_paginate_till_the_server_does_not_have_anymore_prescriptions() {
-    lastPullTimestamp.set(Just(Instant.now().minusMillis(100)))
+    lastPullTimestamp.set(Just(Instant.EPOCH))
 
     val prescriptionsToInsert = 2 * configProvider.blockingGet().batchSize + 7
     insertDummyPrescriptions(count = prescriptionsToInsert).blockingAwait()

app/src/androidTest/java/org/simple/clinic/user/UserSessionAndroidTest.kt

@@ -3,9 +3,11 @@ package org.simple.clinic.user
 import android.support.test.runner.AndroidJUnit4
 import com.google.common.truth.Truth.assertThat
 import org.junit.Before
+import org.junit.Rule
 import org.junit.Test
 import org.junit.runner.RunWith
 import org.simple.clinic.AppDatabase
+import org.simple.clinic.AuthenticationRule
 import org.simple.clinic.TestClinicApp
 import org.simple.clinic.TestData
 import org.simple.clinic.facility.FacilityRepository
@@ -39,16 +41,22 @@ class UserSessionAndroidTest {
   @Inject
   lateinit var facilityApi: FacilitySyncApiV1
 
+  @get:Rule
+  val authenticationRule = AuthenticationRule()
+
   @Before
   fun setUp() {
     TestClinicApp.appComponent().inject(this)
-    userSession.logout().blockingAwait()
   }
 
   @Test
   fun when_correct_login_params_are_given_then_login_should_happen_and_session_data_should_be_persisted() {
+    val ongoingLoginEntry = userSession.requireLoggedInUser()
+        .map { OngoingLoginEntry(userId = it.uuid, phoneNumber = it.phoneNumber, pin = testData.qaUserPin()) }
+        .blockingFirst()
+
     val lawgon = userSession
-        .saveOngoingLoginEntry(testData.qaOngoingLoginEntry())
+        .saveOngoingLoginEntry(ongoingLoginEntry)
         .andThen(userSession.loginWithOtp(testData.qaUserOtp()))
         .blockingGet()
 
@@ -60,17 +68,14 @@ class UserSessionAndroidTest {
     assertThat(userSession.isUserLoggedIn()).isTrue()
     assertThat(loggedInUser!!.status).isEqualTo(UserStatus.APPROVED_FOR_SYNCING)
     assertThat(loggedInUser.loggedInStatus).isEqualTo(LOGGED_IN)
-
-    val currentFacility = facilityRepository
-        .currentFacility(userSession)
-        .blockingFirst()
-    assertThat(currentFacility.uuid).isEqualTo(UUID.fromString("43dad34c-139e-4e5f-976e-a3ef1d9ac977"))
   }
 
   @Test
   fun when_incorrect_login_params_are_given_then_login_should_fail() {
+    userSession.logout().blockingAwait()
+
     val lawgon = userSession
-        .saveOngoingLoginEntry(OngoingLoginEntry(testData.qaUserUuid(), "9919299", "0102"))
+        .saveOngoingLoginEntry(OngoingLoginEntry(UUID.randomUUID(), "9919299", "0102"))
         .andThen(userSession.loginWithOtp(testData.qaUserOtp()))
         .blockingGet()
 
@@ -83,14 +88,16 @@ class UserSessionAndroidTest {
 
   @Test
   fun when_logging_in_from_registration_entry_user_should_be_logged_in_locally() {
+    userSession.logout().blockingAwait()
+
     val facilities = facilityApi.pull(10)
         .map { it.facilities }
         .map { facilities -> facilities.map { it.toDatabaseModel(SyncStatus.DONE) } }
         .blockingGet()
     appDatabase.facilityDao().save(facilities)
 
     val selectedFacilities = facilities.subList(0, 2)
-    val ongoingRegistrationEntry = testData.ongoingRegistrationEntry(selectedFacilities)
+    val ongoingRegistrationEntry = testData.ongoingRegistrationEntry(facilities = selectedFacilities)
     userSession.saveOngoingRegistrationEntry(ongoingRegistrationEntry)
         .andThen(userSession.loginFromOngoingRegistrationEntry())
         .blockingAwait()
@@ -110,8 +117,12 @@ class UserSessionAndroidTest {
 
   @Test
   fun when_user_is_logged_out_then_all_app_data_should_get_cleared() {
+    val ongoingLoginEntry = userSession.requireLoggedInUser()
+        .map { OngoingLoginEntry(userId = it.uuid, phoneNumber = it.phoneNumber, pin = testData.qaUserPin()) }
+        .blockingFirst()
+
     userSession
-        .saveOngoingLoginEntry(testData.qaOngoingLoginEntry())
+        .saveOngoingLoginEntry(ongoingLoginEntry)
         .andThen(userSession.loginWithOtp(testData.qaUserOtp()))
         .toCompletable()
         .andThen(userSession.logout())
@@ -124,14 +135,16 @@ class UserSessionAndroidTest {
 
   @Test
   fun when_registering_a_user_is_registered_then_the_logged_in_user_should_be_sent_to_the_server() {
+    userSession.logout().blockingAwait()
+
     val facilities = facilityApi.pull(10)
         .map { it.facilities }
         .map { facilities -> facilities.map { it.toDatabaseModel(SyncStatus.DONE) } }
         .blockingGet()
     appDatabase.facilityDao().save(facilities)
 
     val selectedFacilities = facilities.subList(0, 2)
-    val ongoingRegistrationEntry = testData.ongoingRegistrationEntry(selectedFacilities)
+    val ongoingRegistrationEntry = testData.ongoingRegistrationEntry(facilities = selectedFacilities)
 
     val registrationResult = userSession
         .saveOngoingRegistrationEntry(ongoingRegistrationEntry)
@@ -146,7 +159,11 @@ class UserSessionAndroidTest {
 
   @Test
   fun when_saving_a_user_locally_it_should_save_the_user_locally_with_a_status_of_not_signed_in() {
-    val findUserResult = userSession.findExistingUser(testData.qaOngoingLoginEntry().phoneNumber).blockingGet()
+    val ongoingLoginEntry = userSession.requireLoggedInUser()
+        .map { OngoingLoginEntry(userId = it.uuid, phoneNumber = it.phoneNumber, pin = testData.qaUserPin()) }
+        .blockingFirst()
+
+    val findUserResult = userSession.findExistingUser(ongoingLoginEntry.phoneNumber).blockingGet()
     assertThat(findUserResult).isInstanceOf(FindUserResult.Found::class.java)
 
     val foundUserPayload = (findUserResult as FindUserResult.Found).user
@@ -165,8 +182,12 @@ class UserSessionAndroidTest {
 
   @Test
   fun when_logged_in_user_is_cleared_the_local_saved_user_must_be_removed_from_database() {
+    val ongoingLoginEntry = userSession.requireLoggedInUser()
+        .map { OngoingLoginEntry(userId = it.uuid, phoneNumber = it.phoneNumber, pin = testData.qaUserPin()) }
+        .blockingFirst()
+
     val lawgon = userSession
-        .saveOngoingLoginEntry(testData.qaOngoingLoginEntry())
+        .saveOngoingLoginEntry(ongoingLoginEntry)
         .andThen(userSession.loginWithOtp(testData.qaUserOtp()))
         .blockingGet()
 
@@ -183,7 +204,11 @@ class UserSessionAndroidTest {
 
   @Test
   fun when_login_otp_is_requested_successfully_it_must_update_the_logged_in_status_of_the_user() {
-    val findUserResult = userSession.findExistingUser(testData.qaOngoingLoginEntry().phoneNumber).blockingGet()
+    val ongoingLoginEntry = userSession.requireLoggedInUser()
+        .map { OngoingLoginEntry(userId = it.uuid, phoneNumber = it.phoneNumber, pin = testData.qaUserPin()) }
+        .blockingFirst()
+
+    val findUserResult = userSession.findExistingUser(ongoingLoginEntry.phoneNumber).blockingGet()
     assertThat(findUserResult).isInstanceOf(FindUserResult.Found::class.java)
 
     val foundUser = (findUserResult as FindUserResult.Found).user
@@ -194,7 +219,7 @@ class UserSessionAndroidTest {
     assertThat(userSession.loggedInUserImmediate()!!.loggedInStatus).isEqualTo(NOT_LOGGED_IN)
 
     val requestOtpResult = userSession
-        .saveOngoingLoginEntry(testData.qaOngoingLoginEntry())
+        .saveOngoingLoginEntry(ongoingLoginEntry)
         .andThen(userSession.requestLoginOtp())
         .blockingGet()