Add support for PNI registration ids and PNP change number.

app/src/androidTest/java/org/thoughtcrime/securesms/testing/MockProvider.kt

@@ -0,0 +1,86 @@
+package org.thoughtcrime.securesms.testing
+
+import io.reactivex.rxjava3.core.Single
+import org.mockito.kotlin.any
+import org.mockito.kotlin.doReturn
+import org.mockito.kotlin.mock
+import org.mockito.kotlin.stub
+import org.signal.core.util.Hex
+import org.thoughtcrime.securesms.dependencies.ApplicationDependencies
+import org.thoughtcrime.securesms.pin.KbsRepository
+import org.thoughtcrime.securesms.pin.TokenData
+import org.thoughtcrime.securesms.test.BuildConfig
+import org.whispersystems.signalservice.api.KbsPinData
+import org.whispersystems.signalservice.api.KeyBackupService
+import org.whispersystems.signalservice.api.kbs.HashedPin
+import org.whispersystems.signalservice.api.kbs.MasterKey
+import org.whispersystems.signalservice.api.messages.multidevice.DeviceInfo
+import org.whispersystems.signalservice.api.push.ServiceId
+import org.whispersystems.signalservice.internal.ServiceResponse
+import org.whispersystems.signalservice.internal.contacts.entities.TokenResponse
+import org.whispersystems.signalservice.internal.push.AuthCredentials
+import org.whispersystems.signalservice.internal.push.DeviceInfoList
+import org.whispersystems.signalservice.internal.push.PushServiceSocket
+import org.whispersystems.signalservice.internal.push.SenderCertificate
+import org.whispersystems.signalservice.internal.push.VerifyAccountResponse
+import org.whispersystems.signalservice.internal.push.WhoAmIResponse
+import java.security.SecureRandom
+
+/**
+ * Warehouse of reusable test data and mock configurations.
+ */
+object MockProvider {
+
+  val senderCertificate = SenderCertificate().apply { certificate = ByteArray(0) }
+
+  val lockedFailure = PushServiceSocket.RegistrationLockFailure().apply {
+    backupCredentials = AuthCredentials.create("username", "password")
+  }
+
+  val primaryOnlyDeviceList = DeviceInfoList().apply {
+    devices = listOf(
+      DeviceInfo().apply {
+        id = 1
+      }
+    )
+  }
+
+  fun createVerifyAccountResponse(aci: ServiceId, newPni: ServiceId): VerifyAccountResponse {
+    return VerifyAccountResponse().apply {
+      uuid = aci.toString()
+      pni = newPni.toString()
+      storageCapable = false
+    }
+  }
+
+  fun createWhoAmIResponse(aci: ServiceId, pni: ServiceId, e164: String): WhoAmIResponse {
+    return WhoAmIResponse().apply {
+      this.uuid = aci.toString()
+      this.pni = pni.toString()
+      this.number = e164
+    }
+  }
+
+  fun mockGetRegistrationLockStringFlow(kbsRepository: KbsRepository) {
+    val tokenData: TokenData = mock {
+      on { enclave } doReturn BuildConfig.KBS_ENCLAVE
+      on { basicAuth } doReturn "basicAuth"
+      on { triesRemaining } doReturn 10
+      on { tokenResponse } doReturn TokenResponse()
+    }
+
+    kbsRepository.stub {
+      on { getToken(any() as String) } doReturn Single.just(ServiceResponse.forResult(tokenData, 200, ""))
+    }
+
+    val session: KeyBackupService.RestoreSession = object : KeyBackupService.RestoreSession {
+      override fun hashSalt(): ByteArray = Hex.fromStringCondensed("cba811749042b303a6a7efa5ccd160aea5e3ea243c8d2692bd13d515732f51a8")
+      override fun restorePin(hashedPin: HashedPin?): KbsPinData = KbsPinData(MasterKey.createNew(SecureRandom()), null)
+    }
+
+    val kbsService = ApplicationDependencies.getKeyBackupService(BuildConfig.KBS_ENCLAVE)
+    kbsService.stub {
+      on { newRegistrationSession(any(), any()) } doReturn session
+    }
+  }
+}

app/src/androidTest/java/org/thoughtcrime/securesms/testing/ResponseMocking.kt

@@ -0,0 +1,48 @@
+package org.thoughtcrime.securesms.testing
+
+import okhttp3.mockwebserver.MockResponse
+import okhttp3.mockwebserver.RecordedRequest
+import okhttp3.mockwebserver.SocketPolicy
+import org.thoughtcrime.securesms.util.JsonUtils
+import java.util.concurrent.TimeUnit
+
+typealias ResponseFactory = (request: RecordedRequest) -> MockResponse
+
+/**
+ * Represent an HTTP verb for mocking web requests.
+ */
+sealed class Verb(val verb: String, val path: String, val responseFactory: ResponseFactory)
+
+class Get(path: String, responseFactory: ResponseFactory) : Verb("GET", path, responseFactory)
+
+class Put(path: String, responseFactory: ResponseFactory) : Verb("PUT", path, responseFactory)
+
+fun MockResponse.success(response: Any? = null): MockResponse {
+  return setResponseCode(200).apply {
+    if (response != null) {
+      setBody(JsonUtils.toJson(response))
+    }
+  }
+}
+
+fun MockResponse.failure(code: Int, response: Any? = null): MockResponse {
+  return setResponseCode(code).apply {
+    if (response != null) {
+      setBody(JsonUtils.toJson(response))
+    }
+  }
+}
+
+fun MockResponse.connectionFailure(): MockResponse {
+  return setSocketPolicy(SocketPolicy.DISCONNECT_AT_START)
+}
+
+fun MockResponse.timeout(): MockResponse {
+  return setHeadersDelay(1, TimeUnit.DAYS)
+    .setBodyDelay(1, TimeUnit.DAYS)
+}
+
+inline fun <reified T> RecordedRequest.parsedRequestBody(): T {
+  val bodyString = String(body.readByteArray())
+  return JsonUtils.fromJson(bodyString, T::class.java)
+}

app/src/androidTest/java/org/thoughtcrime/securesms/testing/SignalActivityRule.kt

@@ -8,6 +8,7 @@ import android.content.SharedPreferences
 import android.preference.PreferenceManager
 import androidx.test.core.app.ActivityScenario
 import androidx.test.platform.app.InstrumentationRegistry
+import okhttp3.mockwebserver.MockResponse
 import org.junit.rules.ExternalResource
 import org.signal.libsignal.protocol.IdentityKey
 import org.signal.libsignal.protocol.SignalProtocolAddress
@@ -17,6 +18,7 @@ import org.thoughtcrime.securesms.crypto.ProfileKeyUtil
 import org.thoughtcrime.securesms.database.IdentityDatabase
 import org.thoughtcrime.securesms.database.SignalDatabase
 import org.thoughtcrime.securesms.dependencies.ApplicationDependencies
+import org.thoughtcrime.securesms.dependencies.InstrumentationApplicationDependencyProvider
 import org.thoughtcrime.securesms.keyvalue.SignalStore
 import org.thoughtcrime.securesms.net.DeviceTransferBlockingInterceptor
 import org.thoughtcrime.securesms.profiles.ProfileName
@@ -29,6 +31,8 @@ import org.thoughtcrime.securesms.util.Util
 import org.whispersystems.signalservice.api.profiles.SignalServiceProfile
 import org.whispersystems.signalservice.api.push.ACI
 import org.whispersystems.signalservice.api.push.SignalServiceAddress
+import org.whispersystems.signalservice.internal.ServiceResponse
+import org.whispersystems.signalservice.internal.ServiceResponseProcessor
 import org.whispersystems.signalservice.internal.push.VerifyAccountResponse
 import java.lang.IllegalArgumentException
 import java.util.UUID
@@ -54,6 +58,8 @@ class SignalActivityRule(private val othersCount: Int = 4) : ExternalResource()
     context = InstrumentationRegistry.getInstrumentation().targetContext
     self = setupSelf()
     others = setupOthers()
+
+    InstrumentationApplicationDependencyProvider.clearHandlers()
   }
 
   private fun setupSelf(): Recipient {
@@ -67,18 +73,22 @@ class SignalActivityRule(private val othersCount: Int = 4) : ExternalResource()
 
     val registrationRepository = RegistrationRepository(application)
 
-    registrationRepository.registerAccountWithoutRegistrationLock(
+    InstrumentationApplicationDependencyProvider.addMockWebRequestHandlers(Put("/v2/keys") { MockResponse().success() })
+    val response: ServiceResponse<VerifyAccountResponse> = registrationRepository.registerAccountWithoutRegistrationLock(
       RegistrationData(
         code = "123123",
-        e164 = "+15554045550101",
+        e164 = "+15555550101",
         password = Util.getSecret(18),
         registrationId = registrationRepository.registrationId,
-        profileKey = registrationRepository.getProfileKey("+15554045550101"),
-        fcmToken = null
+        profileKey = registrationRepository.getProfileKey("+15555550101"),
+        fcmToken = null,
+        pniRegistrationId = registrationRepository.pniRegistrationId
       ),
       VerifyAccountResponse(UUID.randomUUID().toString(), UUID.randomUUID().toString(), false)
     ).blockingGet()
 
+    ServiceResponseProcessor.DefaultProcessor(response).resultOrThrow
+
     SignalStore.kbsValues().optOut()
     RegistrationUtil.maybeMarkRegistrationComplete(application)
     SignalDatabase.recipients.setProfileName(Recipient.self().id, ProfileName.fromParts("Tester", "McTesterson"))
@@ -107,7 +117,7 @@ class SignalActivityRule(private val othersCount: Int = 4) : ExternalResource()
     return others
   }
 
-  inline fun <reified T : Activity> launchActivity(initIntent: Intent.() -> Unit): ActivityScenario<T> {
+  inline fun <reified T : Activity> launchActivity(initIntent: Intent.() -> Unit = {}): ActivityScenario<T> {
     return androidx.test.core.app.launchActivity(Intent(context, T::class.java).apply(initIntent))
   }
 

app/src/androidTest/java/org/thoughtcrime/securesms/testing/SignalTestRunner.kt

@@ -0,0 +1,16 @@
+package org.thoughtcrime.securesms.testing
+
+import android.app.Application
+import android.content.Context
+import androidx.test.runner.AndroidJUnitRunner
+import org.thoughtcrime.securesms.SignalInstrumentationApplicationContext
+
+/**
+ * Custom runner that replaces application with [SignalInstrumentationApplicationContext].
+ */
+@Suppress("unused")
+class SignalTestRunner : AndroidJUnitRunner() {
+  override fun newApplication(cl: ClassLoader?, className: String?, context: Context?): Application {
+    return super.newApplication(cl, SignalInstrumentationApplicationContext::class.java.name, context)
+  }
+}

app/src/androidTest/java/org/thoughtcrime/securesms/testing/TestUtils.kt

@@ -0,0 +1,46 @@
+package org.thoughtcrime.securesms.testing
+
+import org.hamcrest.MatcherAssert.assertThat
+import org.hamcrest.Matchers.hasSize
+import org.hamcrest.Matchers.`is`
+import org.hamcrest.Matchers.not
+import org.hamcrest.Matchers.notNullValue
+import org.hamcrest.Matchers.nullValue
+import java.util.concurrent.CountDownLatch
+
+/**
+ * Run the given [runnable] on a new thread and wait for it to finish.
+ */
+fun runSync(runnable: () -> Unit) {
+  val lock = CountDownLatch(1)
+  Thread {
+    try {
+      runnable.invoke()
+    } finally {
+      lock.countDown()
+    }
+  }.start()
+  lock.await()
+}
+
+/* Various kotlin-ifications of hamcrest matchers */
+
+fun <T : Any?> T.assertIsNull() {
+  assertThat(this, nullValue())
+}
+
+fun <T : Any?> T.assertIsNotNull() {
+  assertThat(this, notNullValue())
+}
+
+infix fun <T : Any> T.assertIs(expected: T) {
+  assertThat(this, `is`(expected))
+}
+
+infix fun <T : Any> T.assertIsNot(expected: T) {
+  assertThat(this, not(`is`(expected)))
+}
+
+infix fun <E, T : Collection<E>> T.assertIsSize(expected: Int) {
+  assertThat(this, hasSize(expected))
+}