diff --git a/matrix-sdk-android/src/androidTest/java/org/matrix/android/sdk/common/CommonTestHelper.kt b/matrix-sdk-android/src/androidTest/java/org/matrix/android/sdk/common/CommonTestHelper.kt index 8f81c79129..a8b351a174 100644 --- a/matrix-sdk-android/src/androidTest/java/org/matrix/android/sdk/common/CommonTestHelper.kt +++ b/matrix-sdk-android/src/androidTest/java/org/matrix/android/sdk/common/CommonTestHelper.kt @@ -20,8 +20,9 @@ import android.content.Context import android.net.Uri import androidx.lifecycle.Observer import androidx.test.internal.runner.junit4.statement.UiThreadStatement +import kotlinx.coroutines.CoroutineScope import kotlinx.coroutines.Dispatchers -import kotlinx.coroutines.GlobalScope +import kotlinx.coroutines.SupervisorJob import kotlinx.coroutines.delay import kotlinx.coroutines.launch import kotlinx.coroutines.runBlocking @@ -55,6 +56,7 @@ import java.util.concurrent.TimeUnit class CommonTestHelper(context: Context) { val matrix: TestMatrix + val coroutineScope = CoroutineScope(SupervisorJob() + Dispatchers.Main) fun getTestInterceptor(session: Session): MockOkHttpInterceptor? = TestModule.interceptorForSession(session.sessionId) as? MockOkHttpInterceptor @@ -93,30 +95,45 @@ class CommonTestHelper(context: Context) { * * @param session the session to sync */ - @Suppress("EXPERIMENTAL_API_USAGE") - fun syncSession(session: Session, timeout: Long = TestConstants.timeOutMillis) { + fun syncSession(session: Session, timeout: Long = TestConstants.timeOutMillis * 10) { val lock = CountDownLatch(1) - - val job = GlobalScope.launch(Dispatchers.Main) { - session.open() - } - runBlocking { job.join() } - - session.startSync(true) - - val syncLiveData = runBlocking(Dispatchers.Main) { - session.getSyncStateLive() - } - val syncObserver = object : Observer { - override fun onChanged(t: SyncState?) { - if (session.hasAlreadySynced()) { - lock.countDown() - syncLiveData.removeObserver(this) + coroutineScope.launch { + session.startSync(true) + val syncLiveData = session.getSyncStateLive() + val syncObserver = object : Observer { + override fun onChanged(t: SyncState?) { + if (session.hasAlreadySynced()) { + lock.countDown() + syncLiveData.removeObserver(this) + } } } + syncLiveData.observeForever(syncObserver) } - GlobalScope.launch(Dispatchers.Main) { syncLiveData.observeForever(syncObserver) } + await(lock, timeout) + } + /** + * This methods clear the cache and waits for initialSync + * + * @param session the session to sync + */ + fun clearCacheAndSync(session: Session, timeout: Long = TestConstants.timeOutMillis) { + val lock = CountDownLatch(1) + coroutineScope.launch { + session.clearCache() + val syncLiveData = session.getSyncStateLive() + val syncObserver = object : Observer { + override fun onChanged(t: SyncState?) { + if (session.hasAlreadySynced()) { + lock.countDown() + syncLiveData.removeObserver(this) + } + } + } + syncLiveData.observeForever(syncObserver) + session.startSync(true) + } await(lock, timeout) } @@ -130,41 +147,40 @@ class CommonTestHelper(context: Context) { fun sendTextMessage(room: Room, message: String, nbOfMessages: Int, timeout: Long = TestConstants.timeOutMillis): List { val timeline = room.createTimeline(null, TimelineSettings(10)) val sentEvents = ArrayList(nbOfMessages) - val latch = CountDownLatch(1) - val timelineListener = object : Timeline.Listener { - override fun onTimelineFailure(throwable: Throwable) { - } + waitWithLatch(timeout ) { latch -> + val timelineListener = object : Timeline.Listener { + override fun onTimelineFailure(throwable: Throwable) { + } - override fun onNewTimelineEvents(eventIds: List) { - // noop - } + override fun onNewTimelineEvents(eventIds: List) { + // noop + } - override fun onTimelineUpdated(snapshot: List) { - val newMessages = snapshot - .filter { it.root.sendState == SendState.SYNCED } - .filter { it.root.getClearType() == EventType.MESSAGE } - .filter { it.root.getClearContent().toModel()?.body?.startsWith(message) == true } + override fun onTimelineUpdated(snapshot: List) { + val newMessages = snapshot + .filter { it.root.sendState == SendState.SYNCED } + .filter { it.root.getClearType() == EventType.MESSAGE } + .filter { it.root.getClearContent().toModel()?.body?.startsWith(message) == true } - if (newMessages.size == nbOfMessages) { - sentEvents.addAll(newMessages) - // Remove listener now, if not at the next update sendEvents could change - timeline.removeListener(this) - latch.countDown() + if (newMessages.size == nbOfMessages) { + sentEvents.addAll(newMessages) + // Remove listener now, if not at the next update sendEvents could change + timeline.removeListener(this) + latch.countDown() + } } } + timeline.start() + timeline.addListener(timelineListener) + for (i in 0 until nbOfMessages) { + room.sendTextMessage(message + " #" + (i + 1)) + // Sleep a bit otherwise database will be flowed and sync won't be live (we might end up with gap then...) + delay(50) + } } - timeline.start() - timeline.addListener(timelineListener) - for (i in 0 until nbOfMessages) { - room.sendTextMessage(message + " #" + (i + 1)) - } - // Wait 3 second more per message - await(latch, timeout = timeout + 3_000L * nbOfMessages) timeline.dispose() - // Check that all events has been created assertEquals("Message number do not match $sentEvents", nbOfMessages.toLong(), sentEvents.size.toLong()) - return sentEvents } @@ -237,10 +253,10 @@ class CommonTestHelper(context: Context) { assertTrue(registrationResult is RegistrationResult.Success) val session = (registrationResult as RegistrationResult.Success).session + session.open() if (sessionTestParams.withInitialSync) { syncSession(session, 60_000) } - return session } @@ -265,7 +281,7 @@ class CommonTestHelper(context: Context) { .getLoginWizard() .login(userName, password, "myDevice") } - + session.open() if (sessionTestParams.withInitialSync) { syncSession(session) } @@ -331,21 +347,21 @@ class CommonTestHelper(context: Context) { } @Suppress("EXPERIMENTAL_API_USAGE") - fun retryPeriodicallyWithLatch(latch: CountDownLatch, condition: (() -> Boolean)) { - GlobalScope.launch { - while (true) { - delay(1000) - if (condition()) { - latch.countDown() - return@launch - } + suspend fun retryPeriodicallyWithLatch(latch: CountDownLatch, condition: (() -> Boolean)) { + while (true) { + delay(1000) + if (condition()) { + latch.countDown() + return } } } - fun waitWithLatch(timeout: Long? = TestConstants.timeOutMillis, block: (CountDownLatch) -> Unit) { + fun waitWithLatch(timeout: Long? = TestConstants.timeOutMillis, block: suspend (CountDownLatch) -> Unit) { val latch = CountDownLatch(1) - block(latch) + coroutineScope.launch { + block(latch) + } await(latch, timeout) } diff --git a/matrix-sdk-android/src/androidTest/java/org/matrix/android/sdk/common/CryptoTestHelper.kt b/matrix-sdk-android/src/androidTest/java/org/matrix/android/sdk/common/CryptoTestHelper.kt index a8cbc160dd..47bf91f362 100644 --- a/matrix-sdk-android/src/androidTest/java/org/matrix/android/sdk/common/CryptoTestHelper.kt +++ b/matrix-sdk-android/src/androidTest/java/org/matrix/android/sdk/common/CryptoTestHelper.kt @@ -19,10 +19,6 @@ package org.matrix.android.sdk.common import android.os.SystemClock import android.util.Log import androidx.lifecycle.Observer -import kotlinx.coroutines.Dispatchers -import kotlinx.coroutines.GlobalScope -import kotlinx.coroutines.launch -import kotlinx.coroutines.runBlocking import org.junit.Assert.assertEquals import org.junit.Assert.assertNotNull import org.junit.Assert.assertNull @@ -31,6 +27,7 @@ import org.matrix.android.sdk.api.auth.UIABaseAuth import org.matrix.android.sdk.api.auth.UserInteractiveAuthInterceptor import org.matrix.android.sdk.api.auth.UserPasswordAuth import org.matrix.android.sdk.api.auth.registration.RegistrationFlowResponse +import org.matrix.android.sdk.api.extensions.orFalse import org.matrix.android.sdk.api.session.Session import org.matrix.android.sdk.api.session.crypto.verification.IncomingSasVerificationTransaction import org.matrix.android.sdk.api.session.crypto.verification.OutgoingSasVerificationTransaction @@ -44,16 +41,16 @@ import org.matrix.android.sdk.api.session.room.model.Membership import org.matrix.android.sdk.api.session.room.model.RoomSummary import org.matrix.android.sdk.api.session.room.model.create.CreateRoomParams import org.matrix.android.sdk.api.session.room.roomSummaryQueryParams +import org.matrix.android.sdk.api.util.Optional import org.matrix.android.sdk.internal.crypto.MXCRYPTO_ALGORITHM_MEGOLM import org.matrix.android.sdk.internal.crypto.MXCRYPTO_ALGORITHM_MEGOLM_BACKUP import org.matrix.android.sdk.internal.crypto.keysbackup.model.MegolmBackupAuthData import org.matrix.android.sdk.internal.crypto.keysbackup.model.MegolmBackupCreationInfo import java.util.UUID -import java.util.concurrent.CountDownLatch import kotlin.coroutines.Continuation import kotlin.coroutines.resume -class CryptoTestHelper(private val mTestHelper: CommonTestHelper) { +class CryptoTestHelper(private val testHelper: CommonTestHelper) { private val messagesFromAlice: List = listOf("0 - Hello I'm Alice!", "4 - Go!") private val messagesFromBob: List = listOf("1 - Hello I'm Bob!", "2 - Isn't life grand?", "3 - Let's go to the opera.") @@ -64,20 +61,27 @@ class CryptoTestHelper(private val mTestHelper: CommonTestHelper) { * @return alice session */ fun doE2ETestWithAliceInARoom(encryptedRoom: Boolean = true): CryptoTestData { - val aliceSession = mTestHelper.createAccount(TestConstants.USER_ALICE, defaultSessionParams) + val aliceSession = testHelper.createAccount(TestConstants.USER_ALICE, defaultSessionParams) - val roomId = mTestHelper.runBlockingTest { + val roomId = testHelper.runBlockingTest { aliceSession.createRoom(CreateRoomParams().apply { name = "MyRoom" }) } - if (encryptedRoom) { - val room = aliceSession.getRoom(roomId)!! - - mTestHelper.runBlockingTest { + testHelper.waitWithLatch { latch -> + val room = aliceSession.getRoom(roomId)!! room.enableEncryption() + val roomSummaryLive = room.getRoomSummaryLive() + val roomSummaryObserver = object : Observer> { + override fun onChanged(roomSummary: Optional) { + if (roomSummary.getOrNull()?.isEncrypted.orFalse()) { + roomSummaryLive.removeObserver(this) + latch.countDown() + } + } + } + roomSummaryLive.observeForever(roomSummaryObserver) } } - return CryptoTestData(roomId, listOf(aliceSession)) } @@ -92,54 +96,37 @@ class CryptoTestHelper(private val mTestHelper: CommonTestHelper) { val aliceRoom = aliceSession.getRoom(aliceRoomId)!! - val bobSession = mTestHelper.createAccount(TestConstants.USER_BOB, defaultSessionParams) + val bobSession = testHelper.createAccount(TestConstants.USER_BOB, defaultSessionParams) - val lock1 = CountDownLatch(1) - - val bobRoomSummariesLive = runBlocking(Dispatchers.Main) { - bobSession.getRoomSummariesLive(roomSummaryQueryParams { }) - } - - val newRoomObserver = object : Observer> { - override fun onChanged(t: List?) { - if (t?.isNotEmpty() == true) { - lock1.countDown() - bobRoomSummariesLive.removeObserver(this) + testHelper.waitWithLatch { latch -> + val bobRoomSummariesLive = bobSession.getRoomSummariesLive(roomSummaryQueryParams { }) + val newRoomObserver = object : Observer> { + override fun onChanged(t: List?) { + if (t?.isNotEmpty() == true) { + bobRoomSummariesLive.removeObserver(this) + latch.countDown() + } } } - } - - GlobalScope.launch(Dispatchers.Main) { bobRoomSummariesLive.observeForever(newRoomObserver) - } - - mTestHelper.runBlockingTest { aliceRoom.invite(bobSession.myUserId) } - mTestHelper.await(lock1) - - val lock = CountDownLatch(1) - - val roomJoinedObserver = object : Observer> { - override fun onChanged(t: List?) { - if (bobSession.getRoom(aliceRoomId) - ?.getRoomMember(aliceSession.myUserId) - ?.membership == Membership.JOIN) { - lock.countDown() - bobRoomSummariesLive.removeObserver(this) + testHelper.waitWithLatch { latch -> + val bobRoomSummariesLive = bobSession.getRoomSummariesLive(roomSummaryQueryParams { }) + val roomJoinedObserver = object : Observer> { + override fun onChanged(t: List?) { + if (bobSession.getRoom(aliceRoomId) + ?.getRoomMember(bobSession.myUserId) + ?.membership == Membership.JOIN) { + bobRoomSummariesLive.removeObserver(this) + latch.countDown() + } } } - } - - GlobalScope.launch(Dispatchers.Main) { bobRoomSummariesLive.observeForever(roomJoinedObserver) + bobSession.joinRoom(aliceRoomId) } - - mTestHelper.runBlockingTest { bobSession.joinRoom(aliceRoomId) } - - mTestHelper.await(lock) - // Ensure bob can send messages to the room // val roomFromBobPOV = bobSession.getRoom(aliceRoomId)!! // assertNotNull(roomFromBobPOV.powerLevels) @@ -171,13 +158,13 @@ class CryptoTestHelper(private val mTestHelper: CommonTestHelper) { * @Return Sam session */ fun createSamAccountAndInviteToTheRoom(room: Room): Session { - val samSession = mTestHelper.createAccount(TestConstants.USER_SAM, defaultSessionParams) + val samSession = testHelper.createAccount(TestConstants.USER_SAM, defaultSessionParams) - mTestHelper.runBlockingTest { + testHelper.runBlockingTest { room.invite(samSession.myUserId, null) } - mTestHelper.runBlockingTest { + testHelper.runBlockingTest { samSession.joinRoom(room.roomId, null, emptyList()) } @@ -194,23 +181,20 @@ class CryptoTestHelper(private val mTestHelper: CommonTestHelper) { val bobSession = cryptoTestData.secondSession!! bobSession.cryptoService().setWarnOnUnknownDevices(false) - aliceSession.cryptoService().setWarnOnUnknownDevices(false) val roomFromBobPOV = bobSession.getRoom(aliceRoomId)!! val roomFromAlicePOV = aliceSession.getRoom(aliceRoomId)!! // Alice sends a message - mTestHelper.sendTextMessage(roomFromAlicePOV, messagesFromAlice[0], 1) -// roomFromAlicePOV.sendTextMessage(messagesFromAlice[0]) + testHelper.sendTextMessage(roomFromAlicePOV, messagesFromAlice[0], 1) // Bob send 3 messages - mTestHelper.sendTextMessage(roomFromBobPOV, messagesFromBob[0], 1) - mTestHelper.sendTextMessage(roomFromBobPOV, messagesFromBob[1], 1) - mTestHelper.sendTextMessage(roomFromBobPOV, messagesFromBob[2], 1) + testHelper.sendTextMessage(roomFromBobPOV, messagesFromBob[0], 1) + testHelper.sendTextMessage(roomFromBobPOV, messagesFromBob[1], 1) + testHelper.sendTextMessage(roomFromBobPOV, messagesFromBob[2], 1) // Alice sends a message - mTestHelper.sendTextMessage(roomFromAlicePOV, messagesFromAlice[1], 1) - + testHelper.sendTextMessage(roomFromAlicePOV, messagesFromAlice[1], 1) return cryptoTestData } @@ -256,60 +240,44 @@ class CryptoTestHelper(private val mTestHelper: CommonTestHelper) { ) } - @Suppress("EXPERIMENTAL_API_USAGE") fun createDM(alice: Session, bob: Session): String { - val roomId = mTestHelper.runBlockingTest { - alice.createDirectRoom(bob.myUserId) - } - - mTestHelper.waitWithLatch { latch -> - val bobRoomSummariesLive = runBlocking(Dispatchers.Main) { - bob.getRoomSummariesLive(roomSummaryQueryParams { }) - } - + var roomId: String = "" + testHelper.waitWithLatch { latch -> + roomId = alice.createDirectRoom(bob.myUserId) + val bobRoomSummariesLive = bob.getRoomSummariesLive(roomSummaryQueryParams { }) val newRoomObserver = object : Observer> { override fun onChanged(t: List?) { val indexOfFirst = t?.indexOfFirst { it.roomId == roomId } ?: -1 if (indexOfFirst != -1) { - latch.countDown() bobRoomSummariesLive.removeObserver(this) + latch.countDown() } } } - - GlobalScope.launch(Dispatchers.Main) { - bobRoomSummariesLive.observeForever(newRoomObserver) - } + bobRoomSummariesLive.observeForever(newRoomObserver) } - mTestHelper.waitWithLatch { latch -> - val bobRoomSummariesLive = runBlocking(Dispatchers.Main) { - bob.getRoomSummariesLive(roomSummaryQueryParams { }) - } - + testHelper.waitWithLatch { latch -> + val bobRoomSummariesLive = bob.getRoomSummariesLive(roomSummaryQueryParams { }) val newRoomObserver = object : Observer> { override fun onChanged(t: List?) { if (bob.getRoom(roomId) ?.getRoomMember(bob.myUserId) ?.membership == Membership.JOIN) { - latch.countDown() bobRoomSummariesLive.removeObserver(this) + latch.countDown() } } } - - GlobalScope.launch(Dispatchers.Main) { - bobRoomSummariesLive.observeForever(newRoomObserver) - } - - mTestHelper.runBlockingTest { bob.joinRoom(roomId) } + bobRoomSummariesLive.observeForever(newRoomObserver) + bob.joinRoom(roomId) } return roomId } fun initializeCrossSigning(session: Session) { - mTestHelper.doSync { + testHelper.doSync { session.cryptoService().crossSigningService() .initializeCrossSigning( object : UserInteractiveAuthInterceptor { @@ -346,8 +314,8 @@ class CryptoTestHelper(private val mTestHelper: CommonTestHelper) { var bobPovTx: IncomingSasVerificationTransaction? = null // wait for alice to get the ready - mTestHelper.waitWithLatch { - mTestHelper.retryPeriodicallyWithLatch(it) { + testHelper.waitWithLatch { + testHelper.retryPeriodicallyWithLatch(it) { bobPovTx = bobVerificationService.getExistingTransaction(alice.myUserId, requestID) as? IncomingSasVerificationTransaction Log.v("TEST", "== bobPovTx is ${alicePovTx?.uxState}") if (bobPovTx?.state == VerificationTxState.OnStarted) { @@ -359,16 +327,16 @@ class CryptoTestHelper(private val mTestHelper: CommonTestHelper) { } } - mTestHelper.waitWithLatch { - mTestHelper.retryPeriodicallyWithLatch(it) { + testHelper.waitWithLatch { + testHelper.retryPeriodicallyWithLatch(it) { alicePovTx = aliceVerificationService.getExistingTransaction(bob.myUserId, requestID) as? OutgoingSasVerificationTransaction Log.v("TEST", "== alicePovTx is ${alicePovTx?.uxState}") alicePovTx?.state == VerificationTxState.ShortCodeReady } } // wait for alice to get the ready - mTestHelper.waitWithLatch { - mTestHelper.retryPeriodicallyWithLatch(it) { + testHelper.waitWithLatch { + testHelper.retryPeriodicallyWithLatch(it) { bobPovTx = bobVerificationService.getExistingTransaction(alice.myUserId, requestID) as? IncomingSasVerificationTransaction Log.v("TEST", "== bobPovTx is ${alicePovTx?.uxState}") if (bobPovTx?.state == VerificationTxState.OnStarted) { @@ -383,38 +351,38 @@ class CryptoTestHelper(private val mTestHelper: CommonTestHelper) { bobPovTx!!.userHasVerifiedShortCode() alicePovTx!!.userHasVerifiedShortCode() - mTestHelper.waitWithLatch { - mTestHelper.retryPeriodicallyWithLatch(it) { + testHelper.waitWithLatch { + testHelper.retryPeriodicallyWithLatch(it) { alice.cryptoService().crossSigningService().isUserTrusted(bob.myUserId) } } - mTestHelper.waitWithLatch { - mTestHelper.retryPeriodicallyWithLatch(it) { + testHelper.waitWithLatch { + testHelper.retryPeriodicallyWithLatch(it) { alice.cryptoService().crossSigningService().isUserTrusted(bob.myUserId) } } } fun doE2ETestWithManyMembers(numberOfMembers: Int): CryptoTestData { - val aliceSession = mTestHelper.createAccount(TestConstants.USER_ALICE, defaultSessionParams) + val aliceSession = testHelper.createAccount(TestConstants.USER_ALICE, defaultSessionParams) aliceSession.cryptoService().setWarnOnUnknownDevices(false) - val roomId = mTestHelper.runBlockingTest { + val roomId = testHelper.runBlockingTest { aliceSession.createRoom(CreateRoomParams().apply { name = "MyRoom" }) } val room = aliceSession.getRoom(roomId)!! - mTestHelper.runBlockingTest { + testHelper.runBlockingTest { room.enableEncryption() } val sessions = mutableListOf(aliceSession) for (index in 1 until numberOfMembers) { - val session = mTestHelper.createAccount("User_$index", defaultSessionParams) - mTestHelper.runBlockingTest(timeout = 600_000) { room.invite(session.myUserId, null) } + val session = testHelper.createAccount("User_$index", defaultSessionParams) + testHelper.runBlockingTest(timeout = 600_000) { room.invite(session.myUserId, null) } println("TEST -> " + session.myUserId + " invited") - mTestHelper.runBlockingTest { session.joinRoom(room.roomId, null, emptyList()) } + testHelper.runBlockingTest { session.joinRoom(room.roomId, null, emptyList()) } println("TEST -> " + session.myUserId + " joined") sessions.add(session) } diff --git a/matrix-sdk-android/src/androidTest/java/org/matrix/android/sdk/internal/crypto/PreShareKeysTest.kt b/matrix-sdk-android/src/androidTest/java/org/matrix/android/sdk/internal/crypto/PreShareKeysTest.kt index 825fba570a..d0f63227f5 100644 --- a/matrix-sdk-android/src/androidTest/java/org/matrix/android/sdk/internal/crypto/PreShareKeysTest.kt +++ b/matrix-sdk-android/src/androidTest/java/org/matrix/android/sdk/internal/crypto/PreShareKeysTest.kt @@ -36,12 +36,12 @@ import org.matrix.android.sdk.internal.crypto.model.event.RoomKeyContent @FixMethodOrder(MethodSorters.JVM) class PreShareKeysTest : InstrumentedTest { - private val mTestHelper = CommonTestHelper(context()) - private val mCryptoTestHelper = CryptoTestHelper(mTestHelper) + private val testHelper = CommonTestHelper(context()) + private val cryptoTestHelper = CryptoTestHelper(testHelper) @Test fun ensure_outbound_session_happy_path() { - val testData = mCryptoTestHelper.doE2ETestWithAliceAndBobInARoom(true) + val testData = cryptoTestHelper.doE2ETestWithAliceAndBobInARoom(true) val e2eRoomID = testData.roomId val aliceSession = testData.firstSession val bobSession = testData.secondSession!! @@ -58,12 +58,12 @@ class PreShareKeysTest : InstrumentedTest { Log.d("#Test", "Room Key Received from alice $preShareCount") // Force presharing of new outbound key - mTestHelper.doSync { + testHelper.doSync { aliceSession.cryptoService().prepareToEncrypt(e2eRoomID, it) } - mTestHelper.waitWithLatch { latch -> - mTestHelper.retryPeriodicallyWithLatch(latch) { + testHelper.waitWithLatch { latch -> + testHelper.retryPeriodicallyWithLatch(latch) { val newGossipCount = bobSession.cryptoService().getGossipingEvents().count { it.senderId == aliceSession.myUserId && it.getClearType() == EventType.ROOM_KEY @@ -88,16 +88,16 @@ class PreShareKeysTest : InstrumentedTest { assertEquals("The session received by bob should match what alice sent", 0, sharedIndex) // Just send a real message as test - val sentEvent = mTestHelper.sendTextMessage(aliceSession.getRoom(e2eRoomID)!!, "Allo", 1).first() + val sentEvent = testHelper.sendTextMessage(aliceSession.getRoom(e2eRoomID)!!, "Allo", 1).first() assertEquals(megolmSessionId, sentEvent.root.content.toModel()?.sessionId, "Unexpected megolm session") - mTestHelper.waitWithLatch { latch -> - mTestHelper.retryPeriodicallyWithLatch(latch) { + testHelper.waitWithLatch { latch -> + testHelper.retryPeriodicallyWithLatch(latch) { bobSession.getRoom(e2eRoomID)?.getTimeLineEvent(sentEvent.eventId)?.root?.getClearType() == EventType.MESSAGE } } - mTestHelper.signOutAndClose(aliceSession) - mTestHelper.signOutAndClose(bobSession) + testHelper.signOutAndClose(aliceSession) + testHelper.signOutAndClose(bobSession) } } diff --git a/matrix-sdk-android/src/androidTest/java/org/matrix/android/sdk/internal/crypto/UnwedgingTest.kt b/matrix-sdk-android/src/androidTest/java/org/matrix/android/sdk/internal/crypto/UnwedgingTest.kt index cf31294e2f..458eae6ab2 100644 --- a/matrix-sdk-android/src/androidTest/java/org/matrix/android/sdk/internal/crypto/UnwedgingTest.kt +++ b/matrix-sdk-android/src/androidTest/java/org/matrix/android/sdk/internal/crypto/UnwedgingTest.kt @@ -62,8 +62,8 @@ import kotlin.coroutines.resume class UnwedgingTest : InstrumentedTest { private lateinit var messagesReceivedByBob: List - private val mTestHelper = CommonTestHelper(context()) - private val mCryptoTestHelper = CryptoTestHelper(mTestHelper) + private val testHelper = CommonTestHelper(context()) + private val cryptoTestHelper = CryptoTestHelper(testHelper) @Before fun init() { @@ -85,7 +85,7 @@ class UnwedgingTest : InstrumentedTest { */ @Test fun testUnwedging() { - val cryptoTestData = mCryptoTestHelper.doE2ETestWithAliceAndBobInARoom() + val cryptoTestData = cryptoTestHelper.doE2ETestWithAliceAndBobInARoom() val aliceSession = cryptoTestData.firstSession val aliceRoomId = cryptoTestData.roomId @@ -133,7 +133,7 @@ class UnwedgingTest : InstrumentedTest { roomFromAlicePOV.sendTextMessage("First message") // Wait for the message to be received by Bob - mTestHelper.await(latch) + testHelper.await(latch) bobTimeline.removeListener(bobEventsListener) messagesReceivedByBob.size shouldBe 1 @@ -161,7 +161,7 @@ class UnwedgingTest : InstrumentedTest { roomFromAlicePOV.sendTextMessage("Second message") // Wait for the message to be received by Bob - mTestHelper.await(latch) + testHelper.await(latch) bobTimeline.removeListener(bobEventsListener) messagesReceivedByBob.size shouldBe 2 @@ -179,7 +179,7 @@ class UnwedgingTest : InstrumentedTest { aliceSession.cryptoService().discardOutboundSession(roomFromAlicePOV.roomId) // Wait for the message to be received by Bob - mTestHelper.waitWithLatch { + testHelper.waitWithLatch { bobEventsListener = createEventListener(it, 3) bobTimeline.addListener(bobEventsListener) messagesReceivedByBob = emptyList() @@ -201,11 +201,11 @@ class UnwedgingTest : InstrumentedTest { Assert.assertEquals(EventType.MESSAGE, messagesReceivedByBob[1].root.getClearType()) Assert.assertEquals(EventType.MESSAGE, messagesReceivedByBob[2].root.getClearType()) // Bob Should not be able to decrypt last message, because session could not be sent as the olm channel was wedged - mTestHelper.await(bobFinalLatch) + testHelper.await(bobFinalLatch) bobTimeline.removeListener(bobHasThreeDecryptedEventsListener) // It's a trick to force key request on fail to decrypt - mTestHelper.doSync { + testHelper.doSync { bobSession.cryptoService().crossSigningService() .initializeCrossSigning( object : UserInteractiveAuthInterceptor { @@ -222,8 +222,8 @@ class UnwedgingTest : InstrumentedTest { } // Wait until we received back the key - mTestHelper.waitWithLatch { - mTestHelper.retryPeriodicallyWithLatch(it) { + testHelper.waitWithLatch { + testHelper.retryPeriodicallyWithLatch(it) { // we should get back the key and be able to decrypt val result = tryOrNull { bobSession.cryptoService().decryptEvent(messagesReceivedByBob[0].root, "") @@ -235,7 +235,7 @@ class UnwedgingTest : InstrumentedTest { bobTimeline.dispose() - cryptoTestData.cleanUp(mTestHelper) + cryptoTestData.cleanUp(testHelper) } private fun createEventListener(latch: CountDownLatch, expectedNumberOfMessages: Int): Timeline.Listener { diff --git a/matrix-sdk-android/src/androidTest/java/org/matrix/android/sdk/internal/crypto/crosssigning/XSigningTest.kt b/matrix-sdk-android/src/androidTest/java/org/matrix/android/sdk/internal/crypto/crosssigning/XSigningTest.kt index 44af87bcbe..d9cc7a8ac0 100644 --- a/matrix-sdk-android/src/androidTest/java/org/matrix/android/sdk/internal/crypto/crosssigning/XSigningTest.kt +++ b/matrix-sdk-android/src/androidTest/java/org/matrix/android/sdk/internal/crypto/crosssigning/XSigningTest.kt @@ -45,14 +45,14 @@ import kotlin.coroutines.resume @FixMethodOrder(MethodSorters.NAME_ASCENDING) class XSigningTest : InstrumentedTest { - private val mTestHelper = CommonTestHelper(context()) - private val mCryptoTestHelper = CryptoTestHelper(mTestHelper) + private val testHelper = CommonTestHelper(context()) + private val cryptoTestHelper = CryptoTestHelper(testHelper) @Test fun test_InitializeAndStoreKeys() { - val aliceSession = mTestHelper.createAccount(TestConstants.USER_ALICE, SessionTestParams(true)) + val aliceSession = testHelper.createAccount(TestConstants.USER_ALICE, SessionTestParams(true)) - mTestHelper.doSync { + testHelper.doSync { aliceSession.cryptoService().crossSigningService() .initializeCrossSigning(object : UserInteractiveAuthInterceptor { override fun performStage(flowResponse: RegistrationFlowResponse, errCode: String?, promise: Continuation) { @@ -79,12 +79,12 @@ class XSigningTest : InstrumentedTest { assertTrue("Signing Keys should be trusted", aliceSession.cryptoService().crossSigningService().checkUserTrust(aliceSession.myUserId).isVerified()) - mTestHelper.signOutAndClose(aliceSession) + testHelper.signOutAndClose(aliceSession) } @Test fun test_CrossSigningCheckBobSeesTheKeys() { - val cryptoTestData = mCryptoTestHelper.doE2ETestWithAliceAndBobInARoom() + val cryptoTestData = cryptoTestHelper.doE2ETestWithAliceAndBobInARoom() val aliceSession = cryptoTestData.firstSession val bobSession = cryptoTestData.secondSession @@ -98,21 +98,21 @@ class XSigningTest : InstrumentedTest { password = TestConstants.PASSWORD ) - mTestHelper.doSync { + testHelper.doSync { aliceSession.cryptoService().crossSigningService().initializeCrossSigning(object : UserInteractiveAuthInterceptor { override fun performStage(flowResponse: RegistrationFlowResponse, errCode: String?, promise: Continuation) { promise.resume(aliceAuthParams) } }, it) } - mTestHelper.doSync { bobSession.cryptoService().crossSigningService().initializeCrossSigning(object : UserInteractiveAuthInterceptor { + testHelper.doSync { bobSession.cryptoService().crossSigningService().initializeCrossSigning(object : UserInteractiveAuthInterceptor { override fun performStage(flowResponse: RegistrationFlowResponse, errCode: String?, promise: Continuation) { promise.resume(bobAuthParams) } }, it) } // Check that alice can see bob keys - mTestHelper.doSync> { aliceSession.cryptoService().downloadKeys(listOf(bobSession.myUserId), true, it) } + testHelper.doSync> { aliceSession.cryptoService().downloadKeys(listOf(bobSession.myUserId), true, it) } val bobKeysFromAlicePOV = aliceSession.cryptoService().crossSigningService().getUserCrossSigningKeys(bobSession.myUserId) assertNotNull("Alice can see bob Master key", bobKeysFromAlicePOV!!.masterKey()) @@ -124,13 +124,13 @@ class XSigningTest : InstrumentedTest { assertFalse("Bob keys from alice pov should not be trusted", bobKeysFromAlicePOV.isTrusted()) - mTestHelper.signOutAndClose(aliceSession) - mTestHelper.signOutAndClose(bobSession) + testHelper.signOutAndClose(aliceSession) + testHelper.signOutAndClose(bobSession) } @Test fun test_CrossSigningTestAliceTrustBobNewDevice() { - val cryptoTestData = mCryptoTestHelper.doE2ETestWithAliceAndBobInARoom() + val cryptoTestData = cryptoTestHelper.doE2ETestWithAliceAndBobInARoom() val aliceSession = cryptoTestData.firstSession val bobSession = cryptoTestData.secondSession @@ -144,12 +144,12 @@ class XSigningTest : InstrumentedTest { password = TestConstants.PASSWORD ) - mTestHelper.doSync { aliceSession.cryptoService().crossSigningService().initializeCrossSigning(object : UserInteractiveAuthInterceptor { + testHelper.doSync { aliceSession.cryptoService().crossSigningService().initializeCrossSigning(object : UserInteractiveAuthInterceptor { override fun performStage(flowResponse: RegistrationFlowResponse, errCode: String?, promise: Continuation) { promise.resume(aliceAuthParams) } }, it) } - mTestHelper.doSync { bobSession.cryptoService().crossSigningService().initializeCrossSigning(object : UserInteractiveAuthInterceptor { + testHelper.doSync { bobSession.cryptoService().crossSigningService().initializeCrossSigning(object : UserInteractiveAuthInterceptor { override fun performStage(flowResponse: RegistrationFlowResponse, errCode: String?, promise: Continuation) { promise.resume(bobAuthParams) } @@ -157,21 +157,21 @@ class XSigningTest : InstrumentedTest { // Check that alice can see bob keys val bobUserId = bobSession.myUserId - mTestHelper.doSync> { aliceSession.cryptoService().downloadKeys(listOf(bobUserId), true, it) } + testHelper.doSync> { aliceSession.cryptoService().downloadKeys(listOf(bobUserId), true, it) } val bobKeysFromAlicePOV = aliceSession.cryptoService().crossSigningService().getUserCrossSigningKeys(bobUserId) assertTrue("Bob keys from alice pov should not be trusted", bobKeysFromAlicePOV?.isTrusted() == false) - mTestHelper.doSync { aliceSession.cryptoService().crossSigningService().trustUser(bobUserId, it) } + testHelper.doSync { aliceSession.cryptoService().crossSigningService().trustUser(bobUserId, it) } // Now bobs logs in on a new device and verifies it // We will want to test that in alice POV, this new device would be trusted by cross signing - val bobSession2 = mTestHelper.logIntoAccount(bobUserId, SessionTestParams(true)) + val bobSession2 = testHelper.logIntoAccount(bobUserId, SessionTestParams(true)) val bobSecondDeviceId = bobSession2.sessionParams.deviceId!! // Check that bob first session sees the new login - val data = mTestHelper.doSync> { + val data = testHelper.doSync> { bobSession.cryptoService().downloadKeys(listOf(bobUserId), true, it) } @@ -183,12 +183,12 @@ class XSigningTest : InstrumentedTest { assertNotNull("Bob Second device should be known and persisted from first", bobSecondDevicePOVFirstDevice) // Manually mark it as trusted from first session - mTestHelper.doSync { + testHelper.doSync { bobSession.cryptoService().crossSigningService().trustDevice(bobSecondDeviceId, it) } // Now alice should cross trust bob's second device - val data2 = mTestHelper.doSync> { + val data2 = testHelper.doSync> { aliceSession.cryptoService().downloadKeys(listOf(bobUserId), true, it) } @@ -200,8 +200,8 @@ class XSigningTest : InstrumentedTest { val result = aliceSession.cryptoService().crossSigningService().checkDeviceTrust(bobUserId, bobSecondDeviceId, null) assertTrue("Bob second device should be trusted from alice POV", result.isCrossSignedVerified()) - mTestHelper.signOutAndClose(aliceSession) - mTestHelper.signOutAndClose(bobSession) - mTestHelper.signOutAndClose(bobSession2) + testHelper.signOutAndClose(aliceSession) + testHelper.signOutAndClose(bobSession) + testHelper.signOutAndClose(bobSession2) } } diff --git a/matrix-sdk-android/src/androidTest/java/org/matrix/android/sdk/internal/crypto/encryption/EncryptionTest.kt b/matrix-sdk-android/src/androidTest/java/org/matrix/android/sdk/internal/crypto/encryption/EncryptionTest.kt index da5e90abdd..189fc405eb 100644 --- a/matrix-sdk-android/src/androidTest/java/org/matrix/android/sdk/internal/crypto/encryption/EncryptionTest.kt +++ b/matrix-sdk-android/src/androidTest/java/org/matrix/android/sdk/internal/crypto/encryption/EncryptionTest.kt @@ -40,8 +40,9 @@ import java.util.concurrent.CountDownLatch @RunWith(AndroidJUnit4::class) @FixMethodOrder(MethodSorters.NAME_ASCENDING) class EncryptionTest : InstrumentedTest { - private val mTestHelper = CommonTestHelper(context()) - private val mCryptoTestHelper = CryptoTestHelper(mTestHelper) + + private val testHelper = CommonTestHelper(context()) + private val cryptoTestHelper = CryptoTestHelper(testHelper) @Test fun test_EncryptionEvent() { @@ -69,7 +70,7 @@ class EncryptionTest : InstrumentedTest { } private fun performTest(roomShouldBeEncrypted: Boolean, action: (Room) -> Unit) { - val cryptoTestData = mCryptoTestHelper.doE2ETestWithAliceInARoom(encryptedRoom = false) + val cryptoTestData = cryptoTestHelper.doE2ETestWithAliceInARoom(encryptedRoom = false) val aliceSession = cryptoTestData.firstSession val room = aliceSession.getRoom(cryptoTestData.roomId)!! @@ -101,12 +102,12 @@ class EncryptionTest : InstrumentedTest { timeline.addListener(timelineListener) action.invoke(room) - - mTestHelper.await(latch) + testHelper.await(latch) timeline.dispose() - - room.isEncrypted() shouldBe roomShouldBeEncrypted - - cryptoTestData.cleanUp(mTestHelper) + testHelper.waitWithLatch { + room.isEncrypted() shouldBe roomShouldBeEncrypted + it.countDown() + } + cryptoTestData.cleanUp(testHelper) } } diff --git a/matrix-sdk-android/src/androidTest/java/org/matrix/android/sdk/internal/crypto/gossiping/KeyShareTests.kt b/matrix-sdk-android/src/androidTest/java/org/matrix/android/sdk/internal/crypto/gossiping/KeyShareTests.kt index 40659cef11..01b2a358d0 100644 --- a/matrix-sdk-android/src/androidTest/java/org/matrix/android/sdk/internal/crypto/gossiping/KeyShareTests.kt +++ b/matrix-sdk-android/src/androidTest/java/org/matrix/android/sdk/internal/crypto/gossiping/KeyShareTests.kt @@ -63,15 +63,14 @@ import kotlin.coroutines.resume @FixMethodOrder(MethodSorters.JVM) class KeyShareTests : InstrumentedTest { - private val mTestHelper = CommonTestHelper(context()) - private val mCryptoTestHelper = CryptoTestHelper(mTestHelper) + private val commonTestHelper = CommonTestHelper(context()) @Test fun test_DoNotSelfShareIfNotTrusted() { - val aliceSession = mTestHelper.createAccount(TestConstants.USER_ALICE, SessionTestParams(true)) + val aliceSession = commonTestHelper.createAccount(TestConstants.USER_ALICE, SessionTestParams(true)) // Create an encrypted room and add a message - val roomId = mTestHelper.runBlockingTest { + val roomId = commonTestHelper.runBlockingTest { aliceSession.createRoom( CreateRoomParams().apply { visibility = RoomDirectoryVisibility.PRIVATE @@ -83,11 +82,11 @@ class KeyShareTests : InstrumentedTest { assertNotNull(room) Thread.sleep(4_000) assertTrue(room?.isEncrypted() == true) - val sentEventId = mTestHelper.sendTextMessage(room!!, "My Message", 1).first().eventId + val sentEventId = commonTestHelper.sendTextMessage(room!!, "My Message", 1).first().eventId // Open a new sessionx - val aliceSession2 = mTestHelper.logIntoAccount(aliceSession.myUserId, SessionTestParams(true)) + val aliceSession2 = commonTestHelper.logIntoAccount(aliceSession.myUserId, SessionTestParams(true)) val roomSecondSessionPOV = aliceSession2.getRoom(roomId) @@ -105,25 +104,24 @@ class KeyShareTests : InstrumentedTest { // Try to request aliceSession2.cryptoService().requestRoomKeyForEvent(receivedEvent.root) - val waitLatch = CountDownLatch(1) val eventMegolmSessionId = receivedEvent.root.content.toModel()?.sessionId var outGoingRequestId: String? = null - mTestHelper.retryPeriodicallyWithLatch(waitLatch) { - aliceSession2.cryptoService().getOutgoingRoomKeyRequests() - .filter { req -> - // filter out request that was known before - !outgoingRequestsBefore.any { req.requestId == it.requestId } - } - .let { - val outgoing = it.firstOrNull { it.sessionId == eventMegolmSessionId } - outGoingRequestId = outgoing?.requestId - outgoing != null - } + commonTestHelper.waitWithLatch { latch -> + commonTestHelper.retryPeriodicallyWithLatch(latch) { + aliceSession2.cryptoService().getOutgoingRoomKeyRequests() + .filter { req -> + // filter out request that was known before + !outgoingRequestsBefore.any { req.requestId == it.requestId } + } + .let { + val outgoing = it.firstOrNull { it.sessionId == eventMegolmSessionId } + outGoingRequestId = outgoing?.requestId + outgoing != null + } + } } - mTestHelper.await(waitLatch) - Log.v("TEST", "=======> Outgoing requet Id is $outGoingRequestId") val outgoingRequestAfter = aliceSession2.cryptoService().getOutgoingRoomKeyRequests() @@ -134,8 +132,8 @@ class KeyShareTests : InstrumentedTest { // The first session should see an incoming request // the request should be refused, because the device is not trusted - mTestHelper.waitWithLatch { latch -> - mTestHelper.retryPeriodicallyWithLatch(latch) { + commonTestHelper.waitWithLatch { latch -> + commonTestHelper.retryPeriodicallyWithLatch(latch) { // DEBUG LOGS aliceSession.cryptoService().getIncomingRoomKeyRequests().let { Log.v("TEST", "Incoming request Session 1 (looking for $outGoingRequestId)") @@ -164,8 +162,8 @@ class KeyShareTests : InstrumentedTest { // Re request aliceSession2.cryptoService().reRequestRoomKeyForEvent(receivedEvent.root) - mTestHelper.waitWithLatch { latch -> - mTestHelper.retryPeriodicallyWithLatch(latch) { + commonTestHelper.waitWithLatch { latch -> + commonTestHelper.retryPeriodicallyWithLatch(latch) { aliceSession.cryptoService().getIncomingRoomKeyRequests().let { Log.v("TEST", "Incoming request Session 1") Log.v("TEST", "=========================") @@ -180,8 +178,8 @@ class KeyShareTests : InstrumentedTest { } Thread.sleep(6_000) - mTestHelper.waitWithLatch { latch -> - mTestHelper.retryPeriodicallyWithLatch(latch) { + commonTestHelper.waitWithLatch { latch -> + commonTestHelper.retryPeriodicallyWithLatch(latch) { aliceSession2.cryptoService().getOutgoingRoomKeyRequests().let { it.any { it.requestBody?.sessionId == eventMegolmSessionId && it.state == OutgoingGossipingRequestState.CANCELLED } } @@ -194,15 +192,15 @@ class KeyShareTests : InstrumentedTest { fail("should have been able to decrypt") } - mTestHelper.signOutAndClose(aliceSession) - mTestHelper.signOutAndClose(aliceSession2) + commonTestHelper.signOutAndClose(aliceSession) + commonTestHelper.signOutAndClose(aliceSession2) } @Test fun test_ShareSSSSSecret() { - val aliceSession1 = mTestHelper.createAccount(TestConstants.USER_ALICE, SessionTestParams(true)) + val aliceSession1 = commonTestHelper.createAccount(TestConstants.USER_ALICE, SessionTestParams(true)) - mTestHelper.doSync { + commonTestHelper.doSync { aliceSession1.cryptoService().crossSigningService() .initializeCrossSigning( object : UserInteractiveAuthInterceptor { @@ -218,25 +216,25 @@ class KeyShareTests : InstrumentedTest { } // Also bootstrap keybackup on first session - val creationInfo = mTestHelper.doSync { + val creationInfo = commonTestHelper.doSync { aliceSession1.cryptoService().keysBackupService().prepareKeysBackupVersion(null, null, it) } - val version = mTestHelper.doSync { + val version = commonTestHelper.doSync { aliceSession1.cryptoService().keysBackupService().createKeysBackupVersion(creationInfo, it) } // Save it for gossiping aliceSession1.cryptoService().keysBackupService().saveBackupRecoveryKey(creationInfo.recoveryKey, version = version.version) - val aliceSession2 = mTestHelper.logIntoAccount(aliceSession1.myUserId, SessionTestParams(true)) + val aliceSession2 = commonTestHelper.logIntoAccount(aliceSession1.myUserId, SessionTestParams(true)) val aliceVerificationService1 = aliceSession1.cryptoService().verificationService() val aliceVerificationService2 = aliceSession2.cryptoService().verificationService() // force keys download - mTestHelper.doSync> { + commonTestHelper.doSync> { aliceSession1.cryptoService().downloadKeys(listOf(aliceSession1.myUserId), true, it) } - mTestHelper.doSync> { + commonTestHelper.doSync> { aliceSession2.cryptoService().downloadKeys(listOf(aliceSession2.myUserId), true, it) } @@ -276,8 +274,8 @@ class KeyShareTests : InstrumentedTest { aliceVerificationService2.beginKeyVerification(VerificationMethod.SAS, aliceSession1.myUserId, aliceSession1.sessionParams.deviceId ?: "", txId) - mTestHelper.waitWithLatch { latch -> - mTestHelper.retryPeriodicallyWithLatch(latch) { + commonTestHelper.waitWithLatch { latch -> + commonTestHelper.retryPeriodicallyWithLatch(latch) { aliceSession1.cryptoService().getDeviceInfo(aliceSession1.myUserId, aliceSession2.sessionParams.deviceId ?: "")?.isVerified == true } } @@ -290,31 +288,31 @@ class KeyShareTests : InstrumentedTest { // SSK and USK private keys should have been shared - mTestHelper.waitWithLatch(60_000) { latch -> - mTestHelper.retryPeriodicallyWithLatch(latch) { + commonTestHelper.waitWithLatch(60_000) { latch -> + commonTestHelper.retryPeriodicallyWithLatch(latch) { Log.d("#TEST", "CAN XS :${aliceSession2.cryptoService().crossSigningService().getMyCrossSigningKeys()}") aliceSession2.cryptoService().crossSigningService().canCrossSign() } } // Test that key backup key has been shared to - mTestHelper.waitWithLatch(60_000) { latch -> + commonTestHelper.waitWithLatch(60_000) { latch -> val keysBackupService = aliceSession2.cryptoService().keysBackupService() - mTestHelper.retryPeriodicallyWithLatch(latch) { + commonTestHelper.retryPeriodicallyWithLatch(latch) { Log.d("#TEST", "Recovery :${keysBackupService.getKeyBackupRecoveryKeyInfo()?.recoveryKey}") keysBackupService.getKeyBackupRecoveryKeyInfo()?.recoveryKey == creationInfo.recoveryKey } } - mTestHelper.signOutAndClose(aliceSession1) - mTestHelper.signOutAndClose(aliceSession2) + commonTestHelper.signOutAndClose(aliceSession1) + commonTestHelper.signOutAndClose(aliceSession2) } @Test fun test_ImproperKeyShareBug() { - val aliceSession = mTestHelper.createAccount(TestConstants.USER_ALICE, SessionTestParams(true)) + val aliceSession = commonTestHelper.createAccount(TestConstants.USER_ALICE, SessionTestParams(true)) - mTestHelper.doSync { + commonTestHelper.doSync { aliceSession.cryptoService().crossSigningService() .initializeCrossSigning( object : UserInteractiveAuthInterceptor { @@ -331,7 +329,7 @@ class KeyShareTests : InstrumentedTest { } // Create an encrypted room and send a couple of messages - val roomId = mTestHelper.runBlockingTest { + val roomId = commonTestHelper.runBlockingTest { aliceSession.createRoom( CreateRoomParams().apply { visibility = RoomDirectoryVisibility.PRIVATE @@ -343,12 +341,12 @@ class KeyShareTests : InstrumentedTest { assertNotNull(roomAlicePov) Thread.sleep(1_000) assertTrue(roomAlicePov?.isEncrypted() == true) - val secondEventId = mTestHelper.sendTextMessage(roomAlicePov!!, "Message", 3)[1].eventId + val secondEventId = commonTestHelper.sendTextMessage(roomAlicePov!!, "Message", 3)[1].eventId // Create bob session - val bobSession = mTestHelper.createAccount(TestConstants.USER_BOB, SessionTestParams(true)) - mTestHelper.doSync { + val bobSession = commonTestHelper.createAccount(TestConstants.USER_BOB, SessionTestParams(true)) + commonTestHelper.doSync { bobSession.cryptoService().crossSigningService() .initializeCrossSigning( object : UserInteractiveAuthInterceptor { @@ -365,11 +363,11 @@ class KeyShareTests : InstrumentedTest { } // Let alice invite bob - mTestHelper.runBlockingTest { + commonTestHelper.runBlockingTest { roomAlicePov.invite(bobSession.myUserId, null) } - mTestHelper.runBlockingTest { + commonTestHelper.runBlockingTest { bobSession.joinRoom(roomAlicePov.roomId, null, emptyList()) } @@ -377,7 +375,7 @@ class KeyShareTests : InstrumentedTest { aliceSession.cryptoService().discardOutboundSession(roomAlicePov.roomId) // and now resend a new message to reset index to 0 - mTestHelper.sendTextMessage(roomAlicePov, "After", 1) + commonTestHelper.sendTextMessage(roomAlicePov, "After", 1) val roomRoomBobPov = aliceSession.getRoom(roomId) val beforeJoin = roomRoomBobPov!!.getTimeLineEvent(secondEventId) diff --git a/matrix-sdk-android/src/androidTest/java/org/matrix/android/sdk/internal/crypto/gossiping/WithHeldTests.kt b/matrix-sdk-android/src/androidTest/java/org/matrix/android/sdk/internal/crypto/gossiping/WithHeldTests.kt index c939952dc9..c835c2d40b 100644 --- a/matrix-sdk-android/src/androidTest/java/org/matrix/android/sdk/internal/crypto/gossiping/WithHeldTests.kt +++ b/matrix-sdk-android/src/androidTest/java/org/matrix/android/sdk/internal/crypto/gossiping/WithHeldTests.kt @@ -41,8 +41,8 @@ import org.matrix.android.sdk.internal.crypto.model.event.WithHeldCode @FixMethodOrder(MethodSorters.JVM) class WithHeldTests : InstrumentedTest { - private val mTestHelper = CommonTestHelper(context()) - private val mCryptoTestHelper = CryptoTestHelper(mTestHelper) + private val testHelper = CommonTestHelper(context()) + private val cryptoTestHelper = CryptoTestHelper(testHelper) @Test fun test_WithHeldUnverifiedReason() { @@ -50,19 +50,19 @@ class WithHeldTests : InstrumentedTest { // ARRANGE // ============================= - val aliceSession = mTestHelper.createAccount(TestConstants.USER_ALICE, SessionTestParams(true)) - val bobSession = mTestHelper.createAccount(TestConstants.USER_BOB, SessionTestParams(true)) + val aliceSession = testHelper.createAccount(TestConstants.USER_ALICE, SessionTestParams(true)) + val bobSession = testHelper.createAccount(TestConstants.USER_BOB, SessionTestParams(true)) // Initialize cross signing on both - mCryptoTestHelper.initializeCrossSigning(aliceSession) - mCryptoTestHelper.initializeCrossSigning(bobSession) + cryptoTestHelper.initializeCrossSigning(aliceSession) + cryptoTestHelper.initializeCrossSigning(bobSession) - val roomId = mCryptoTestHelper.createDM(aliceSession, bobSession) - mCryptoTestHelper.verifySASCrossSign(aliceSession, bobSession, roomId) + val roomId = cryptoTestHelper.createDM(aliceSession, bobSession) + cryptoTestHelper.verifySASCrossSign(aliceSession, bobSession, roomId) val roomAlicePOV = aliceSession.getRoom(roomId)!! - val bobUnverifiedSession = mTestHelper.logIntoAccount(bobSession.myUserId, SessionTestParams(true)) + val bobUnverifiedSession = testHelper.logIntoAccount(bobSession.myUserId, SessionTestParams(true)) // ============================= // ACT @@ -71,11 +71,11 @@ class WithHeldTests : InstrumentedTest { // Alice decide to not send to unverified sessions aliceSession.cryptoService().setGlobalBlacklistUnverifiedDevices(true) - val timelineEvent = mTestHelper.sendTextMessage(roomAlicePOV, "Hello Bob", 1).first() + val timelineEvent = testHelper.sendTextMessage(roomAlicePOV, "Hello Bob", 1).first() // await for bob unverified session to get the message - mTestHelper.waitWithLatch { latch -> - mTestHelper.retryPeriodicallyWithLatch(latch) { + testHelper.waitWithLatch { latch -> + testHelper.retryPeriodicallyWithLatch(latch) { bobUnverifiedSession.getRoom(roomId)?.getTimeLineEvent(timelineEvent.eventId) != null } } @@ -101,10 +101,10 @@ class WithHeldTests : InstrumentedTest { // enable back sending to unverified aliceSession.cryptoService().setGlobalBlacklistUnverifiedDevices(false) - val secondEvent = mTestHelper.sendTextMessage(roomAlicePOV, "Verify your device!!", 1).first() + val secondEvent = testHelper.sendTextMessage(roomAlicePOV, "Verify your device!!", 1).first() - mTestHelper.waitWithLatch { latch -> - mTestHelper.retryPeriodicallyWithLatch(latch) { + testHelper.waitWithLatch { latch -> + testHelper.retryPeriodicallyWithLatch(latch) { val ev = bobUnverifiedSession.getRoom(roomId)?.getTimeLineEvent(secondEvent.eventId) // wait until it's decrypted ev?.root?.getClearType() == EventType.MESSAGE @@ -123,17 +123,17 @@ class WithHeldTests : InstrumentedTest { Assert.assertEquals("Cause should be unverified", WithHeldCode.UNVERIFIED.value, technicalMessage) } - mTestHelper.signOutAndClose(aliceSession) - mTestHelper.signOutAndClose(bobSession) - mTestHelper.signOutAndClose(bobUnverifiedSession) + testHelper.signOutAndClose(aliceSession) + testHelper.signOutAndClose(bobSession) + testHelper.signOutAndClose(bobUnverifiedSession) } @Test fun test_WithHeldNoOlm() { - val testData = mCryptoTestHelper.doE2ETestWithAliceAndBobInARoom() + val testData = cryptoTestHelper.doE2ETestWithAliceAndBobInARoom() val aliceSession = testData.firstSession val bobSession = testData.secondSession!! - val aliceInterceptor = mTestHelper.getTestInterceptor(aliceSession) + val aliceInterceptor = testHelper.getTestInterceptor(aliceSession) // Simulate no OTK aliceInterceptor!!.addRule(MockOkHttpInterceptor.SimpleRule( @@ -147,11 +147,11 @@ class WithHeldTests : InstrumentedTest { val roomAlicePov = aliceSession.getRoom(testData.roomId)!! - val eventId = mTestHelper.sendTextMessage(roomAlicePov, "first message", 1).first().eventId + val eventId = testHelper.sendTextMessage(roomAlicePov, "first message", 1).first().eventId // await for bob session to get the message - mTestHelper.waitWithLatch { latch -> - mTestHelper.retryPeriodicallyWithLatch(latch) { + testHelper.waitWithLatch { latch -> + testHelper.retryPeriodicallyWithLatch(latch) { bobSession.getRoom(testData.roomId)?.getTimeLineEvent(eventId) != null } } @@ -177,14 +177,14 @@ class WithHeldTests : InstrumentedTest { // Add a new device for bob aliceInterceptor.clearRules() - val bobSecondSession = mTestHelper.logIntoAccount(bobSession.myUserId, SessionTestParams(withInitialSync = true)) + val bobSecondSession = testHelper.logIntoAccount(bobSession.myUserId, SessionTestParams(withInitialSync = true)) // send a second message - val secondMessageId = mTestHelper.sendTextMessage(roomAlicePov, "second message", 1).first().eventId + val secondMessageId = testHelper.sendTextMessage(roomAlicePov, "second message", 1).first().eventId // Check that the // await for bob SecondSession session to get the message - mTestHelper.waitWithLatch { latch -> - mTestHelper.retryPeriodicallyWithLatch(latch) { + testHelper.waitWithLatch { latch -> + testHelper.retryPeriodicallyWithLatch(latch) { bobSecondSession.getRoom(testData.roomId)?.getTimeLineEvent(secondMessageId) != null } } @@ -194,27 +194,27 @@ class WithHeldTests : InstrumentedTest { Assert.assertEquals("Alice should have marked bob's device for this session", 1, chainIndex2) aliceInterceptor.clearRules() - testData.cleanUp(mTestHelper) - mTestHelper.signOutAndClose(bobSecondSession) + testData.cleanUp(testHelper) + testHelper.signOutAndClose(bobSecondSession) } @Test fun test_WithHeldKeyRequest() { - val testData = mCryptoTestHelper.doE2ETestWithAliceAndBobInARoom() + val testData = cryptoTestHelper.doE2ETestWithAliceAndBobInARoom() val aliceSession = testData.firstSession val bobSession = testData.secondSession!! val roomAlicePov = aliceSession.getRoom(testData.roomId)!! - val eventId = mTestHelper.sendTextMessage(roomAlicePov, "first message", 1).first().eventId + val eventId = testHelper.sendTextMessage(roomAlicePov, "first message", 1).first().eventId - mTestHelper.signOutAndClose(bobSession) + testHelper.signOutAndClose(bobSession) // Create a new session for bob - val bobSecondSession = mTestHelper.logIntoAccount(bobSession.myUserId, SessionTestParams(true)) + val bobSecondSession = testHelper.logIntoAccount(bobSession.myUserId, SessionTestParams(true)) // initialize to force request keys if missing - mCryptoTestHelper.initializeCrossSigning(bobSecondSession) + cryptoTestHelper.initializeCrossSigning(bobSecondSession) // Trust bob second device from Alice POV aliceSession.cryptoService().crossSigningService().trustDevice(bobSecondSession.sessionParams.deviceId!!, NoOpMatrixCallback()) @@ -223,8 +223,8 @@ class WithHeldTests : InstrumentedTest { var sessionId: String? = null // Check that the // await for bob SecondSession session to get the message - mTestHelper.waitWithLatch { latch -> - mTestHelper.retryPeriodicallyWithLatch(latch) { + testHelper.waitWithLatch { latch -> + testHelper.retryPeriodicallyWithLatch(latch) { val timeLineEvent = bobSecondSession.getRoom(testData.roomId)?.getTimeLineEvent(eventId)?.also { // try to decrypt and force key request tryOrNull { bobSecondSession.cryptoService().decryptEvent(it.root, "") } @@ -235,8 +235,8 @@ class WithHeldTests : InstrumentedTest { } // Check that bob second session requested the key - mTestHelper.waitWithLatch { latch -> - mTestHelper.retryPeriodicallyWithLatch(latch) { + testHelper.waitWithLatch { latch -> + testHelper.retryPeriodicallyWithLatch(latch) { val wc = bobSecondSession.cryptoService().getWithHeldMegolmSession(roomAlicePov.roomId, sessionId!!) wc?.code == WithHeldCode.UNAUTHORISED } diff --git a/matrix-sdk-android/src/androidTest/java/org/matrix/android/sdk/internal/crypto/keysbackup/KeysBackupTest.kt b/matrix-sdk-android/src/androidTest/java/org/matrix/android/sdk/internal/crypto/keysbackup/KeysBackupTest.kt index 0785dba8b9..2a07b74115 100644 --- a/matrix-sdk-android/src/androidTest/java/org/matrix/android/sdk/internal/crypto/keysbackup/KeysBackupTest.kt +++ b/matrix-sdk-android/src/androidTest/java/org/matrix/android/sdk/internal/crypto/keysbackup/KeysBackupTest.kt @@ -22,7 +22,6 @@ import org.junit.Assert.assertFalse import org.junit.Assert.assertNotNull import org.junit.Assert.assertNull import org.junit.Assert.assertTrue -import org.junit.Assert.fail import org.junit.FixMethodOrder import org.junit.Test import org.junit.runner.RunWith @@ -43,7 +42,6 @@ import org.matrix.android.sdk.internal.crypto.keysbackup.model.MegolmBackupCreat import org.matrix.android.sdk.internal.crypto.keysbackup.model.rest.KeysVersion import org.matrix.android.sdk.internal.crypto.keysbackup.model.rest.KeysVersionResult import org.matrix.android.sdk.internal.crypto.model.ImportRoomKeysResult -import java.util.ArrayList import java.util.Collections import java.util.concurrent.CountDownLatch @@ -51,9 +49,9 @@ import java.util.concurrent.CountDownLatch @FixMethodOrder(MethodSorters.JVM) class KeysBackupTest : InstrumentedTest { - private val mTestHelper = CommonTestHelper(context()) - private val mCryptoTestHelper = CryptoTestHelper(mTestHelper) - private val mKeysBackupTestHelper = KeysBackupTestHelper(mTestHelper, mCryptoTestHelper) + private val testHelper = CommonTestHelper(context()) + private val cryptoTestHelper = CryptoTestHelper(testHelper) + private val keysBackupTestHelper = KeysBackupTestHelper(testHelper, cryptoTestHelper) /** * - From doE2ETestWithAliceAndBobInARoomWithEncryptedMessages, we should have no backed up keys @@ -62,7 +60,7 @@ class KeysBackupTest : InstrumentedTest { */ @Test fun roomKeysTest_testBackupStore_ok() { - val cryptoTestData = mCryptoTestHelper.doE2ETestWithAliceAndBobInARoomWithEncryptedMessages() + val cryptoTestData = cryptoTestHelper.doE2ETestWithAliceAndBobInARoomWithEncryptedMessages() // From doE2ETestWithAliceAndBobInARoomWithEncryptedMessages, we should have no backed up keys val cryptoStore = (cryptoTestData.firstSession.cryptoService().keysBackupService() as DefaultKeysBackupService).store @@ -92,7 +90,7 @@ class KeysBackupTest : InstrumentedTest { assertEquals(sessionsCount, cryptoTestData.firstSession.cryptoService().inboundGroupSessionsCount(false)) assertEquals(0, cryptoTestData.firstSession.cryptoService().inboundGroupSessionsCount(true)) - cryptoTestData.cleanUp(mTestHelper) + cryptoTestData.cleanUp(testHelper) } /** @@ -100,7 +98,7 @@ class KeysBackupTest : InstrumentedTest { */ @Test fun prepareKeysBackupVersionTest() { - val bobSession = mTestHelper.createAccount(TestConstants.USER_BOB, KeysBackupTestConstants.defaultSessionParams) + val bobSession = testHelper.createAccount(TestConstants.USER_BOB, KeysBackupTestConstants.defaultSessionParams) assertNotNull(bobSession.cryptoService().keysBackupService()) @@ -110,7 +108,7 @@ class KeysBackupTest : InstrumentedTest { assertFalse(keysBackup.isEnabled) - val megolmBackupCreationInfo = mTestHelper.doSync { + val megolmBackupCreationInfo = testHelper.doSync { keysBackup.prepareKeysBackupVersion(null, null, it) } @@ -120,7 +118,7 @@ class KeysBackupTest : InstrumentedTest { assertNotNull(megolmBackupCreationInfo.recoveryKey) stateObserver.stopAndCheckStates(null) - mTestHelper.signOutAndClose(bobSession) + testHelper.signOutAndClose(bobSession) } /** @@ -128,7 +126,7 @@ class KeysBackupTest : InstrumentedTest { */ @Test fun createKeysBackupVersionTest() { - val bobSession = mTestHelper.createAccount(TestConstants.USER_BOB, KeysBackupTestConstants.defaultSessionParams) + val bobSession = testHelper.createAccount(TestConstants.USER_BOB, KeysBackupTestConstants.defaultSessionParams) val keysBackup = bobSession.cryptoService().keysBackupService() @@ -136,14 +134,14 @@ class KeysBackupTest : InstrumentedTest { assertFalse(keysBackup.isEnabled) - val megolmBackupCreationInfo = mTestHelper.doSync { + val megolmBackupCreationInfo = testHelper.doSync { keysBackup.prepareKeysBackupVersion(null, null, it) } assertFalse(keysBackup.isEnabled) // Create the version - mTestHelper.doSync { + testHelper.doSync { keysBackup.createKeysBackupVersion(megolmBackupCreationInfo, it) } @@ -151,7 +149,7 @@ class KeysBackupTest : InstrumentedTest { assertTrue(keysBackup.isEnabled) stateObserver.stopAndCheckStates(null) - mTestHelper.signOutAndClose(bobSession) + testHelper.signOutAndClose(bobSession) } /** @@ -160,8 +158,9 @@ class KeysBackupTest : InstrumentedTest { */ @Test fun backupAfterCreateKeysBackupVersionTest() { - val cryptoTestData = mCryptoTestHelper.doE2ETestWithAliceAndBobInARoomWithEncryptedMessages() + val cryptoTestData = cryptoTestHelper.doE2ETestWithAliceAndBobInARoomWithEncryptedMessages() + keysBackupTestHelper.waitForKeybackUpBatching() val keysBackup = cryptoTestData.firstSession.cryptoService().keysBackupService() val latch = CountDownLatch(1) @@ -171,9 +170,9 @@ class KeysBackupTest : InstrumentedTest { val stateObserver = StateObserver(keysBackup, latch, 5) - mKeysBackupTestHelper.prepareAndCreateKeysBackupData(keysBackup) + keysBackupTestHelper.prepareAndCreateKeysBackupData(keysBackup) - mTestHelper.await(latch) + testHelper.await(latch) val nbOfKeys = cryptoTestData.firstSession.cryptoService().inboundGroupSessionsCount(false) val backedUpKeys = cryptoTestData.firstSession.cryptoService().inboundGroupSessionsCount(true) @@ -191,7 +190,7 @@ class KeysBackupTest : InstrumentedTest { KeysBackupState.ReadyToBackUp ) ) - cryptoTestData.cleanUp(mTestHelper) + cryptoTestData.cleanUp(testHelper) } /** @@ -199,13 +198,13 @@ class KeysBackupTest : InstrumentedTest { */ @Test fun backupAllGroupSessionsTest() { - val cryptoTestData = mCryptoTestHelper.doE2ETestWithAliceAndBobInARoomWithEncryptedMessages() + val cryptoTestData = cryptoTestHelper.doE2ETestWithAliceAndBobInARoomWithEncryptedMessages() val keysBackup = cryptoTestData.firstSession.cryptoService().keysBackupService() val stateObserver = StateObserver(keysBackup) - mKeysBackupTestHelper.prepareAndCreateKeysBackupData(keysBackup) + keysBackupTestHelper.prepareAndCreateKeysBackupData(keysBackup) // Check that backupAllGroupSessions returns valid data val nbOfKeys = cryptoTestData.firstSession.cryptoService().inboundGroupSessionsCount(false) @@ -214,7 +213,7 @@ class KeysBackupTest : InstrumentedTest { var lastBackedUpKeysProgress = 0 - mTestHelper.doSync { + testHelper.doSync { keysBackup.backupAllGroupSessions(object : ProgressListener { override fun onProgress(progress: Int, total: Int) { assertEquals(nbOfKeys, total) @@ -230,7 +229,7 @@ class KeysBackupTest : InstrumentedTest { assertEquals("All keys must have been marked as backed up", nbOfKeys, backedUpKeys) stateObserver.stopAndCheckStates(null) - cryptoTestData.cleanUp(mTestHelper) + cryptoTestData.cleanUp(testHelper) } /** @@ -243,7 +242,7 @@ class KeysBackupTest : InstrumentedTest { */ @Test fun testEncryptAndDecryptKeysBackupData() { - val cryptoTestData = mCryptoTestHelper.doE2ETestWithAliceAndBobInARoomWithEncryptedMessages() + val cryptoTestData = cryptoTestHelper.doE2ETestWithAliceAndBobInARoomWithEncryptedMessages() val keysBackup = cryptoTestData.firstSession.cryptoService().keysBackupService() as DefaultKeysBackupService @@ -252,7 +251,7 @@ class KeysBackupTest : InstrumentedTest { // - Pick a megolm key val session = keysBackup.store.inboundGroupSessionsToBackup(1)[0] - val keyBackupCreationInfo = mKeysBackupTestHelper.prepareAndCreateKeysBackupData(keysBackup).megolmBackupCreationInfo + val keyBackupCreationInfo = keysBackupTestHelper.prepareAndCreateKeysBackupData(keysBackup).megolmBackupCreationInfo // - Check encryptGroupSession() returns stg val keyBackupData = keysBackup.encryptGroupSession(session) @@ -270,10 +269,10 @@ class KeysBackupTest : InstrumentedTest { decryption!!) assertNotNull(sessionData) // - Compare the decrypted megolm key with the original one - mKeysBackupTestHelper.assertKeysEquals(session.exportKeys(), sessionData) + keysBackupTestHelper.assertKeysEquals(session.exportKeys(), sessionData) stateObserver.stopAndCheckStates(null) - cryptoTestData.cleanUp(mTestHelper) + cryptoTestData.cleanUp(testHelper) } /** @@ -284,10 +283,10 @@ class KeysBackupTest : InstrumentedTest { */ @Test fun restoreKeysBackupTest() { - val testData = mKeysBackupTestHelper.createKeysBackupScenarioWithPassword(null) + val testData = keysBackupTestHelper.createKeysBackupScenarioWithPassword(null) // - Restore the e2e backup from the homeserver - val importRoomKeysResult = mTestHelper.doSync { + val importRoomKeysResult = testHelper.doSync { testData.aliceSession2.cryptoService().keysBackupService().restoreKeysWithRecoveryKey(testData.aliceSession2.cryptoService().keysBackupService().keysBackupVersion!!, testData.prepareKeysBackupDataResult.megolmBackupCreationInfo.recoveryKey, null, @@ -297,9 +296,9 @@ class KeysBackupTest : InstrumentedTest { ) } - mKeysBackupTestHelper.checkRestoreSuccess(testData, importRoomKeysResult.totalNumberOfKeys, importRoomKeysResult.successfullyNumberOfImportedKeys) + keysBackupTestHelper.checkRestoreSuccess(testData, importRoomKeysResult.totalNumberOfKeys, importRoomKeysResult.successfullyNumberOfImportedKeys) - testData.cleanUp(mTestHelper) + testData.cleanUp(testHelper) } /** @@ -369,7 +368,7 @@ class KeysBackupTest : InstrumentedTest { fun trustKeyBackupVersionTest() { // - Do an e2e backup to the homeserver with a recovery key // - And log Alice on a new device - val testData = mKeysBackupTestHelper.createKeysBackupScenarioWithPassword(null) + val testData = keysBackupTestHelper.createKeysBackupScenarioWithPassword(null) val stateObserver = StateObserver(testData.aliceSession2.cryptoService().keysBackupService()) @@ -379,7 +378,7 @@ class KeysBackupTest : InstrumentedTest { assertEquals(KeysBackupState.NotTrusted, testData.aliceSession2.cryptoService().keysBackupService().state) // - Trust the backup from the new device - mTestHelper.doSync { + testHelper.doSync { testData.aliceSession2.cryptoService().keysBackupService().trustKeysBackupVersion( testData.aliceSession2.cryptoService().keysBackupService().keysBackupVersion!!, true, @@ -388,21 +387,21 @@ class KeysBackupTest : InstrumentedTest { } // Wait for backup state to be ReadyToBackUp - mKeysBackupTestHelper.waitForKeysBackupToBeInState(testData.aliceSession2, KeysBackupState.ReadyToBackUp) + keysBackupTestHelper.waitForKeysBackupToBeInState(testData.aliceSession2, KeysBackupState.ReadyToBackUp) // - Backup must be enabled on the new device, on the same version assertEquals(testData.prepareKeysBackupDataResult.version, testData.aliceSession2.cryptoService().keysBackupService().keysBackupVersion?.version) assertTrue(testData.aliceSession2.cryptoService().keysBackupService().isEnabled) // - Retrieve the last version from the server - val keysVersionResult = mTestHelper.doSync { + val keysVersionResult = testHelper.doSync { testData.aliceSession2.cryptoService().keysBackupService().getCurrentVersion(it) } // - It must be the same assertEquals(testData.prepareKeysBackupDataResult.version, keysVersionResult!!.version) - val keysBackupVersionTrust = mTestHelper.doSync { + val keysBackupVersionTrust = testHelper.doSync { testData.aliceSession2.cryptoService().keysBackupService().getKeysBackupTrust(keysVersionResult, it) } @@ -411,7 +410,7 @@ class KeysBackupTest : InstrumentedTest { assertEquals(2, keysBackupVersionTrust.signatures.size) stateObserver.stopAndCheckStates(null) - testData.cleanUp(mTestHelper) + testData.cleanUp(testHelper) } /** @@ -428,7 +427,7 @@ class KeysBackupTest : InstrumentedTest { fun trustKeyBackupVersionWithRecoveryKeyTest() { // - Do an e2e backup to the homeserver with a recovery key // - And log Alice on a new device - val testData = mKeysBackupTestHelper.createKeysBackupScenarioWithPassword(null) + val testData = keysBackupTestHelper.createKeysBackupScenarioWithPassword(null) val stateObserver = StateObserver(testData.aliceSession2.cryptoService().keysBackupService()) @@ -438,7 +437,7 @@ class KeysBackupTest : InstrumentedTest { assertEquals(KeysBackupState.NotTrusted, testData.aliceSession2.cryptoService().keysBackupService().state) // - Trust the backup from the new device with the recovery key - mTestHelper.doSync { + testHelper.doSync { testData.aliceSession2.cryptoService().keysBackupService().trustKeysBackupVersionWithRecoveryKey( testData.aliceSession2.cryptoService().keysBackupService().keysBackupVersion!!, testData.prepareKeysBackupDataResult.megolmBackupCreationInfo.recoveryKey, @@ -447,21 +446,21 @@ class KeysBackupTest : InstrumentedTest { } // Wait for backup state to be ReadyToBackUp - mKeysBackupTestHelper.waitForKeysBackupToBeInState(testData.aliceSession2, KeysBackupState.ReadyToBackUp) + keysBackupTestHelper.waitForKeysBackupToBeInState(testData.aliceSession2, KeysBackupState.ReadyToBackUp) // - Backup must be enabled on the new device, on the same version assertEquals(testData.prepareKeysBackupDataResult.version, testData.aliceSession2.cryptoService().keysBackupService().keysBackupVersion?.version) assertTrue(testData.aliceSession2.cryptoService().keysBackupService().isEnabled) // - Retrieve the last version from the server - val keysVersionResult = mTestHelper.doSync { + val keysVersionResult = testHelper.doSync { testData.aliceSession2.cryptoService().keysBackupService().getCurrentVersion(it) } // - It must be the same assertEquals(testData.prepareKeysBackupDataResult.version, keysVersionResult!!.version) - val keysBackupVersionTrust = mTestHelper.doSync { + val keysBackupVersionTrust = testHelper.doSync { testData.aliceSession2.cryptoService().keysBackupService().getKeysBackupTrust(keysVersionResult, it) } @@ -470,7 +469,7 @@ class KeysBackupTest : InstrumentedTest { assertEquals(2, keysBackupVersionTrust.signatures.size) stateObserver.stopAndCheckStates(null) - testData.cleanUp(mTestHelper) + testData.cleanUp(testHelper) } /** @@ -485,7 +484,7 @@ class KeysBackupTest : InstrumentedTest { fun trustKeyBackupVersionWithWrongRecoveryKeyTest() { // - Do an e2e backup to the homeserver with a recovery key // - And log Alice on a new device - val testData = mKeysBackupTestHelper.createKeysBackupScenarioWithPassword(null) + val testData = keysBackupTestHelper.createKeysBackupScenarioWithPassword(null) val stateObserver = StateObserver(testData.aliceSession2.cryptoService().keysBackupService()) @@ -501,7 +500,7 @@ class KeysBackupTest : InstrumentedTest { "Bad recovery key", TestMatrixCallback(latch, false) ) - mTestHelper.await(latch) + testHelper.await(latch) // - The new device must still see the previous backup as not trusted assertNotNull(testData.aliceSession2.cryptoService().keysBackupService().keysBackupVersion) @@ -509,7 +508,7 @@ class KeysBackupTest : InstrumentedTest { assertEquals(KeysBackupState.NotTrusted, testData.aliceSession2.cryptoService().keysBackupService().state) stateObserver.stopAndCheckStates(null) - testData.cleanUp(mTestHelper) + testData.cleanUp(testHelper) } /** @@ -528,7 +527,7 @@ class KeysBackupTest : InstrumentedTest { // - Do an e2e backup to the homeserver with a password // - And log Alice on a new device - val testData = mKeysBackupTestHelper.createKeysBackupScenarioWithPassword(password) + val testData = keysBackupTestHelper.createKeysBackupScenarioWithPassword(password) val stateObserver = StateObserver(testData.aliceSession2.cryptoService().keysBackupService()) @@ -538,7 +537,7 @@ class KeysBackupTest : InstrumentedTest { assertEquals(KeysBackupState.NotTrusted, testData.aliceSession2.cryptoService().keysBackupService().state) // - Trust the backup from the new device with the password - mTestHelper.doSync { + testHelper.doSync { testData.aliceSession2.cryptoService().keysBackupService().trustKeysBackupVersionWithPassphrase( testData.aliceSession2.cryptoService().keysBackupService().keysBackupVersion!!, password, @@ -547,21 +546,21 @@ class KeysBackupTest : InstrumentedTest { } // Wait for backup state to be ReadyToBackUp - mKeysBackupTestHelper.waitForKeysBackupToBeInState(testData.aliceSession2, KeysBackupState.ReadyToBackUp) + keysBackupTestHelper.waitForKeysBackupToBeInState(testData.aliceSession2, KeysBackupState.ReadyToBackUp) // - Backup must be enabled on the new device, on the same version assertEquals(testData.prepareKeysBackupDataResult.version, testData.aliceSession2.cryptoService().keysBackupService().keysBackupVersion?.version) assertTrue(testData.aliceSession2.cryptoService().keysBackupService().isEnabled) // - Retrieve the last version from the server - val keysVersionResult = mTestHelper.doSync { + val keysVersionResult = testHelper.doSync { testData.aliceSession2.cryptoService().keysBackupService().getCurrentVersion(it) } // - It must be the same assertEquals(testData.prepareKeysBackupDataResult.version, keysVersionResult!!.version) - val keysBackupVersionTrust = mTestHelper.doSync { + val keysBackupVersionTrust = testHelper.doSync { testData.aliceSession2.cryptoService().keysBackupService().getKeysBackupTrust(keysVersionResult, it) } @@ -570,7 +569,7 @@ class KeysBackupTest : InstrumentedTest { assertEquals(2, keysBackupVersionTrust.signatures.size) stateObserver.stopAndCheckStates(null) - testData.cleanUp(mTestHelper) + testData.cleanUp(testHelper) } /** @@ -588,7 +587,7 @@ class KeysBackupTest : InstrumentedTest { // - Do an e2e backup to the homeserver with a password // - And log Alice on a new device - val testData = mKeysBackupTestHelper.createKeysBackupScenarioWithPassword(password) + val testData = keysBackupTestHelper.createKeysBackupScenarioWithPassword(password) val stateObserver = StateObserver(testData.aliceSession2.cryptoService().keysBackupService()) @@ -604,7 +603,7 @@ class KeysBackupTest : InstrumentedTest { badPassword, TestMatrixCallback(latch, false) ) - mTestHelper.await(latch) + testHelper.await(latch) // - The new device must still see the previous backup as not trusted assertNotNull(testData.aliceSession2.cryptoService().keysBackupService().keysBackupVersion) @@ -612,7 +611,7 @@ class KeysBackupTest : InstrumentedTest { assertEquals(KeysBackupState.NotTrusted, testData.aliceSession2.cryptoService().keysBackupService().state) stateObserver.stopAndCheckStates(null) - testData.cleanUp(mTestHelper) + testData.cleanUp(testHelper) } /** @@ -623,7 +622,7 @@ class KeysBackupTest : InstrumentedTest { */ @Test fun restoreKeysBackupWithAWrongRecoveryKeyTest() { - val testData = mKeysBackupTestHelper.createKeysBackupScenarioWithPassword(null) + val testData = keysBackupTestHelper.createKeysBackupScenarioWithPassword(null) // - Try to restore the e2e backup with a wrong recovery key val latch2 = CountDownLatch(1) @@ -640,12 +639,12 @@ class KeysBackupTest : InstrumentedTest { } } ) - mTestHelper.await(latch2) + testHelper.await(latch2) // onSuccess may not have been called assertNull(importRoomKeysResult) - testData.cleanUp(mTestHelper) + testData.cleanUp(testHelper) } /** @@ -658,12 +657,12 @@ class KeysBackupTest : InstrumentedTest { fun testBackupWithPassword() { val password = "password" - val testData = mKeysBackupTestHelper.createKeysBackupScenarioWithPassword(password) + val testData = keysBackupTestHelper.createKeysBackupScenarioWithPassword(password) // - Restore the e2e backup with the password val steps = ArrayList() - val importRoomKeysResult = mTestHelper.doSync { + val importRoomKeysResult = testHelper.doSync { testData.aliceSession2.cryptoService().keysBackupService().restoreKeyBackupWithPassword(testData.aliceSession2.cryptoService().keysBackupService().keysBackupVersion!!, password, null, @@ -698,9 +697,9 @@ class KeysBackupTest : InstrumentedTest { assertEquals(50, (steps[103] as StepProgressListener.Step.ImportingKey).progress) assertEquals(100, (steps[104] as StepProgressListener.Step.ImportingKey).progress) - mKeysBackupTestHelper.checkRestoreSuccess(testData, importRoomKeysResult.totalNumberOfKeys, importRoomKeysResult.successfullyNumberOfImportedKeys) + keysBackupTestHelper.checkRestoreSuccess(testData, importRoomKeysResult.totalNumberOfKeys, importRoomKeysResult.successfullyNumberOfImportedKeys) - testData.cleanUp(mTestHelper) + testData.cleanUp(testHelper) } /** @@ -714,7 +713,7 @@ class KeysBackupTest : InstrumentedTest { val password = "password" val wrongPassword = "passw0rd" - val testData = mKeysBackupTestHelper.createKeysBackupScenarioWithPassword(password) + val testData = keysBackupTestHelper.createKeysBackupScenarioWithPassword(password) // - Try to restore the e2e backup with a wrong password val latch2 = CountDownLatch(1) @@ -731,12 +730,12 @@ class KeysBackupTest : InstrumentedTest { } } ) - mTestHelper.await(latch2) + testHelper.await(latch2) // onSuccess may not have been called assertNull(importRoomKeysResult) - testData.cleanUp(mTestHelper) + testData.cleanUp(testHelper) } /** @@ -749,10 +748,10 @@ class KeysBackupTest : InstrumentedTest { fun testUseRecoveryKeyToRestoreAPasswordBasedKeysBackup() { val password = "password" - val testData = mKeysBackupTestHelper.createKeysBackupScenarioWithPassword(password) + val testData = keysBackupTestHelper.createKeysBackupScenarioWithPassword(password) // - Restore the e2e backup with the recovery key. - val importRoomKeysResult = mTestHelper.doSync { + val importRoomKeysResult = testHelper.doSync { testData.aliceSession2.cryptoService().keysBackupService().restoreKeysWithRecoveryKey(testData.aliceSession2.cryptoService().keysBackupService().keysBackupVersion!!, testData.prepareKeysBackupDataResult.megolmBackupCreationInfo.recoveryKey, null, @@ -762,9 +761,9 @@ class KeysBackupTest : InstrumentedTest { ) } - mKeysBackupTestHelper.checkRestoreSuccess(testData, importRoomKeysResult.totalNumberOfKeys, importRoomKeysResult.successfullyNumberOfImportedKeys) + keysBackupTestHelper.checkRestoreSuccess(testData, importRoomKeysResult.totalNumberOfKeys, importRoomKeysResult.successfullyNumberOfImportedKeys) - testData.cleanUp(mTestHelper) + testData.cleanUp(testHelper) } /** @@ -775,7 +774,7 @@ class KeysBackupTest : InstrumentedTest { */ @Test fun testUsePasswordToRestoreARecoveryKeyBasedKeysBackup() { - val testData = mKeysBackupTestHelper.createKeysBackupScenarioWithPassword(null) + val testData = keysBackupTestHelper.createKeysBackupScenarioWithPassword(null) // - Try to restore the e2e backup with a password val latch2 = CountDownLatch(1) @@ -792,12 +791,12 @@ class KeysBackupTest : InstrumentedTest { } } ) - mTestHelper.await(latch2) + testHelper.await(latch2) // onSuccess may not have been called assertNull(importRoomKeysResult) - testData.cleanUp(mTestHelper) + testData.cleanUp(testHelper) } /** @@ -807,22 +806,22 @@ class KeysBackupTest : InstrumentedTest { @Test fun testIsKeysBackupTrusted() { // - Create a backup version - val cryptoTestData = mCryptoTestHelper.doE2ETestWithAliceAndBobInARoomWithEncryptedMessages() + val cryptoTestData = cryptoTestHelper.doE2ETestWithAliceAndBobInARoomWithEncryptedMessages() val keysBackup = cryptoTestData.firstSession.cryptoService().keysBackupService() val stateObserver = StateObserver(keysBackup) // - Do an e2e backup to the homeserver - mKeysBackupTestHelper.prepareAndCreateKeysBackupData(keysBackup) + keysBackupTestHelper.prepareAndCreateKeysBackupData(keysBackup) // Get key backup version from the homeserver - val keysVersionResult = mTestHelper.doSync { + val keysVersionResult = testHelper.doSync { keysBackup.getCurrentVersion(it) } // - Check the returned KeyBackupVersion is trusted - val keysBackupVersionTrust = mTestHelper.doSync { + val keysBackupVersionTrust = testHelper.doSync { keysBackup.getKeysBackupTrust(keysVersionResult!!, it) } @@ -837,7 +836,7 @@ class KeysBackupTest : InstrumentedTest { assertEquals(signature.device!!.deviceId, cryptoTestData.firstSession.sessionParams.deviceId) stateObserver.stopAndCheckStates(null) - cryptoTestData.cleanUp(mTestHelper) + cryptoTestData.cleanUp(testHelper) } /** @@ -849,9 +848,8 @@ class KeysBackupTest : InstrumentedTest { */ @Test fun testCheckAndStartKeysBackupWhenRestartingAMatrixSession() { - fail("This test still fail. To investigate") // - Create a backup version - val cryptoTestData = mCryptoTestHelper.doE2ETestWithAliceAndBobInARoomWithEncryptedMessages() + val cryptoTestData = cryptoTestHelper.doE2ETestWithAliceAndBobInARoomWithEncryptedMessages() val keysBackup = cryptoTestData.firstSession.cryptoService().keysBackupService() @@ -859,15 +857,15 @@ class KeysBackupTest : InstrumentedTest { assertFalse(keysBackup.isEnabled) - val keyBackupCreationInfo = mKeysBackupTestHelper.prepareAndCreateKeysBackupData(keysBackup) + val keyBackupCreationInfo = keysBackupTestHelper.prepareAndCreateKeysBackupData(keysBackup) assertTrue(keysBackup.isEnabled) // - Restart alice session // - Log Alice on a new device - val aliceSession2 = mTestHelper.logIntoAccount(cryptoTestData.firstSession.myUserId, KeysBackupTestConstants.defaultSessionParamsWithInitialSync) + val aliceSession2 = testHelper.logIntoAccount(cryptoTestData.firstSession.myUserId, KeysBackupTestConstants.defaultSessionParamsWithInitialSync) - cryptoTestData.cleanUp(mTestHelper) + cryptoTestData.cleanUp(testHelper) val keysBackup2 = aliceSession2.cryptoService().keysBackupService() @@ -891,13 +889,13 @@ class KeysBackupTest : InstrumentedTest { } } }) - mTestHelper.await(latch) + testHelper.await(latch) assertEquals(keyBackupCreationInfo.version, keysBackup2.currentBackupVersion) stateObserver.stopAndCheckStates(null) stateObserver2.stopAndCheckStates(null) - mTestHelper.signOutAndClose(aliceSession2) + testHelper.signOutAndClose(aliceSession2) } /** @@ -911,7 +909,7 @@ class KeysBackupTest : InstrumentedTest { @Test fun testBackupWhenAnotherBackupWasCreated() { // - Create a backup version - val cryptoTestData = mCryptoTestHelper.doE2ETestWithAliceAndBobInARoomWithEncryptedMessages() + val cryptoTestData = cryptoTestHelper.doE2ETestWithAliceAndBobInARoomWithEncryptedMessages() val keysBackup = cryptoTestData.firstSession.cryptoService().keysBackupService() @@ -939,15 +937,15 @@ class KeysBackupTest : InstrumentedTest { }) // - Make alice back up her keys to her homeserver - mKeysBackupTestHelper.prepareAndCreateKeysBackupData(keysBackup) + keysBackupTestHelper.prepareAndCreateKeysBackupData(keysBackup) assertTrue(keysBackup.isEnabled) - mTestHelper.await(latch0) + testHelper.await(latch0) // - Create a new backup with fake data on the homeserver, directly using the rest client - val megolmBackupCreationInfo = mCryptoTestHelper.createFakeMegolmBackupCreationInfo() - mTestHelper.doSync { + val megolmBackupCreationInfo = cryptoTestHelper.createFakeMegolmBackupCreationInfo() + testHelper.doSync { (keysBackup as DefaultKeysBackupService).createFakeKeysBackupVersion(megolmBackupCreationInfo, it) } @@ -957,14 +955,14 @@ class KeysBackupTest : InstrumentedTest { // - Make alice back up all her keys again val latch2 = CountDownLatch(1) keysBackup.backupAllGroupSessions(null, TestMatrixCallback(latch2, false)) - mTestHelper.await(latch2) + testHelper.await(latch2) // -> That must fail and her backup state must be WrongBackUpVersion assertEquals(KeysBackupState.WrongBackUpVersion, keysBackup.state) assertFalse(keysBackup.isEnabled) stateObserver.stopAndCheckStates(null) - cryptoTestData.cleanUp(mTestHelper) + cryptoTestData.cleanUp(testHelper) } /** @@ -982,17 +980,17 @@ class KeysBackupTest : InstrumentedTest { @Test fun testBackupAfterVerifyingADevice() { // - Create a backup version - val cryptoTestData = mCryptoTestHelper.doE2ETestWithAliceAndBobInARoomWithEncryptedMessages() + val cryptoTestData = cryptoTestHelper.doE2ETestWithAliceAndBobInARoomWithEncryptedMessages() val keysBackup = cryptoTestData.firstSession.cryptoService().keysBackupService() val stateObserver = StateObserver(keysBackup) // - Make alice back up her keys to her homeserver - mKeysBackupTestHelper.prepareAndCreateKeysBackupData(keysBackup) + keysBackupTestHelper.prepareAndCreateKeysBackupData(keysBackup) // Wait for keys backup to finish by asking again to backup keys. - mTestHelper.doSync { + testHelper.doSync { keysBackup.backupAllGroupSessions(null, it) } @@ -1001,14 +999,14 @@ class KeysBackupTest : InstrumentedTest { val aliceUserId = cryptoTestData.firstSession.myUserId // - Log Alice on a new device - val aliceSession2 = mTestHelper.logIntoAccount(aliceUserId, KeysBackupTestConstants.defaultSessionParamsWithInitialSync) + val aliceSession2 = testHelper.logIntoAccount(aliceUserId, KeysBackupTestConstants.defaultSessionParamsWithInitialSync) // - Post a message to have a new megolm session aliceSession2.cryptoService().setWarnOnUnknownDevices(false) val room2 = aliceSession2.getRoom(cryptoTestData.roomId)!! - mTestHelper.sendTextMessage(room2, "New key", 1) + testHelper.sendTextMessage(room2, "New key", 1) // - Try to backup all in aliceSession2, it must fail val keysBackup2 = aliceSession2.cryptoService().keysBackupService() @@ -1025,7 +1023,7 @@ class KeysBackupTest : InstrumentedTest { super.onSuccess(data) } }) - mTestHelper.await(latch2) + testHelper.await(latch2) assertFalse(isSuccessful) @@ -1049,12 +1047,12 @@ class KeysBackupTest : InstrumentedTest { } } }) - mTestHelper.await(latch4) + testHelper.await(latch4) // -> It must use the same backup version assertEquals(oldKeyBackupVersion, aliceSession2.cryptoService().keysBackupService().currentBackupVersion) - mTestHelper.doSync { + testHelper.doSync { aliceSession2.cryptoService().keysBackupService().backupAllGroupSessions(null, it) } @@ -1063,8 +1061,8 @@ class KeysBackupTest : InstrumentedTest { stateObserver.stopAndCheckStates(null) stateObserver2.stopAndCheckStates(null) - mTestHelper.signOutAndClose(aliceSession2) - cryptoTestData.cleanUp(mTestHelper) + testHelper.signOutAndClose(aliceSession2) + cryptoTestData.cleanUp(testHelper) } /** @@ -1074,7 +1072,7 @@ class KeysBackupTest : InstrumentedTest { @Test fun deleteKeysBackupTest() { // - Create a backup version - val cryptoTestData = mCryptoTestHelper.doE2ETestWithAliceAndBobInARoomWithEncryptedMessages() + val cryptoTestData = cryptoTestHelper.doE2ETestWithAliceAndBobInARoomWithEncryptedMessages() val keysBackup = cryptoTestData.firstSession.cryptoService().keysBackupService() @@ -1082,17 +1080,17 @@ class KeysBackupTest : InstrumentedTest { assertFalse(keysBackup.isEnabled) - val keyBackupCreationInfo = mKeysBackupTestHelper.prepareAndCreateKeysBackupData(keysBackup) + val keyBackupCreationInfo = keysBackupTestHelper.prepareAndCreateKeysBackupData(keysBackup) assertTrue(keysBackup.isEnabled) // Delete the backup - mTestHelper.doSync { keysBackup.deleteBackup(keyBackupCreationInfo.version, it) } + testHelper.doSync { keysBackup.deleteBackup(keyBackupCreationInfo.version, it) } // Backup is now disabled assertFalse(keysBackup.isEnabled) stateObserver.stopAndCheckStates(null) - cryptoTestData.cleanUp(mTestHelper) + cryptoTestData.cleanUp(testHelper) } } diff --git a/matrix-sdk-android/src/androidTest/java/org/matrix/android/sdk/internal/crypto/keysbackup/KeysBackupTestHelper.kt b/matrix-sdk-android/src/androidTest/java/org/matrix/android/sdk/internal/crypto/keysbackup/KeysBackupTestHelper.kt index a625ffc0e9..4922dc667d 100644 --- a/matrix-sdk-android/src/androidTest/java/org/matrix/android/sdk/internal/crypto/keysbackup/KeysBackupTestHelper.kt +++ b/matrix-sdk-android/src/androidTest/java/org/matrix/android/sdk/internal/crypto/keysbackup/KeysBackupTestHelper.kt @@ -32,8 +32,12 @@ import org.matrix.android.sdk.internal.crypto.keysbackup.model.rest.KeysVersion import java.util.concurrent.CountDownLatch class KeysBackupTestHelper( - private val mTestHelper: CommonTestHelper, - private val mCryptoTestHelper: CryptoTestHelper) { + private val testHelper: CommonTestHelper, + private val cryptoTestHelper: CryptoTestHelper) { + + fun waitForKeybackUpBatching(){ + Thread.sleep(400) + } /** * Common initial condition @@ -43,7 +47,9 @@ class KeysBackupTestHelper( * @param password optional password */ fun createKeysBackupScenarioWithPassword(password: String?): KeysBackupScenarioData { - val cryptoTestData = mCryptoTestHelper.doE2ETestWithAliceAndBobInARoomWithEncryptedMessages() + val cryptoTestData = cryptoTestHelper.doE2ETestWithAliceAndBobInARoomWithEncryptedMessages() + + waitForKeybackUpBatching() val cryptoStore = (cryptoTestData.firstSession.cryptoService().keysBackupService() as DefaultKeysBackupService).store val keysBackup = cryptoTestData.firstSession.cryptoService().keysBackupService() @@ -57,7 +63,7 @@ class KeysBackupTestHelper( var lastProgress = 0 var lastTotal = 0 - mTestHelper.doSync { + testHelper.doSync { keysBackup.backupAllGroupSessions(object : ProgressListener { override fun onProgress(progress: Int, total: Int) { lastProgress = progress @@ -72,7 +78,7 @@ class KeysBackupTestHelper( val aliceUserId = cryptoTestData.firstSession.myUserId // - Log Alice on a new device - val aliceSession2 = mTestHelper.logIntoAccount(aliceUserId, KeysBackupTestConstants.defaultSessionParamsWithInitialSync) + val aliceSession2 = testHelper.logIntoAccount(aliceUserId, KeysBackupTestConstants.defaultSessionParamsWithInitialSync) // Test check: aliceSession2 has no keys at login Assert.assertEquals(0, aliceSession2.cryptoService().inboundGroupSessionsCount(false)) @@ -92,7 +98,7 @@ class KeysBackupTestHelper( password: String? = null): PrepareKeysBackupDataResult { val stateObserver = StateObserver(keysBackup) - val megolmBackupCreationInfo = mTestHelper.doSync { + val megolmBackupCreationInfo = testHelper.doSync { keysBackup.prepareKeysBackupVersion(password, null, it) } @@ -101,7 +107,7 @@ class KeysBackupTestHelper( Assert.assertFalse(keysBackup.isEnabled) // Create the version - val keysVersion = mTestHelper.doSync { + val keysVersion = testHelper.doSync { keysBackup.createKeysBackupVersion(megolmBackupCreationInfo, it) } @@ -136,7 +142,7 @@ class KeysBackupTestHelper( } }) - mTestHelper.await(latch) + testHelper.await(latch) } fun assertKeysEquals(keys1: MegolmSessionData?, keys2: MegolmSessionData?) { diff --git a/matrix-sdk-android/src/androidTest/java/org/matrix/android/sdk/internal/crypto/ssss/QuadSTests.kt b/matrix-sdk-android/src/androidTest/java/org/matrix/android/sdk/internal/crypto/ssss/QuadSTests.kt index b343d7334a..cbc67831f5 100644 --- a/matrix-sdk-android/src/androidTest/java/org/matrix/android/sdk/internal/crypto/ssss/QuadSTests.kt +++ b/matrix-sdk-android/src/androidTest/java/org/matrix/android/sdk/internal/crypto/ssss/QuadSTests.kt @@ -18,10 +18,6 @@ package org.matrix.android.sdk.internal.crypto.ssss import androidx.lifecycle.Observer import androidx.test.ext.junit.runners.AndroidJUnit4 -import kotlinx.coroutines.Dispatchers -import kotlinx.coroutines.GlobalScope -import kotlinx.coroutines.launch -import kotlinx.coroutines.runBlocking import org.junit.Assert.assertEquals import org.junit.Assert.assertNotNull import org.junit.Assert.assertNull @@ -45,13 +41,12 @@ import org.matrix.android.sdk.common.TestConstants import org.matrix.android.sdk.internal.crypto.SSSS_ALGORITHM_AES_HMAC_SHA2 import org.matrix.android.sdk.internal.crypto.crosssigning.toBase64NoPadding import org.matrix.android.sdk.internal.crypto.secrets.DefaultSharedSecretStorageService -import java.util.concurrent.CountDownLatch @RunWith(AndroidJUnit4::class) @FixMethodOrder(MethodSorters.JVM) class QuadSTests : InstrumentedTest { - private val mTestHelper = CommonTestHelper(context()) + private val testHelper = CommonTestHelper(context()) private val emptyKeySigner = object : KeySigner { override fun sign(canonicalJson: String): Map>? { @@ -60,35 +55,29 @@ class QuadSTests : InstrumentedTest { } @Test - @Suppress("EXPERIMENTAL_API_USAGE") fun test_Generate4SKey() { - val aliceSession = mTestHelper.createAccount(TestConstants.USER_ALICE, SessionTestParams(true)) + val aliceSession = testHelper.createAccount(TestConstants.USER_ALICE, SessionTestParams(true)) val quadS = aliceSession.sharedSecretStorageService val TEST_KEY_ID = "my.test.Key" - mTestHelper.runBlockingTest { + testHelper.runBlockingTest { quadS.generateKey(TEST_KEY_ID, null, "Test Key", emptyKeySigner) } - // Assert Account data is updated - val accountDataLock = CountDownLatch(1) var accountData: UserAccountDataEvent? = null - - val liveAccountData = runBlocking(Dispatchers.Main) { - aliceSession.accountDataService().getLiveUserAccountDataEvent("${DefaultSharedSecretStorageService.KEY_ID_BASE}.$TEST_KEY_ID") - } - val accountDataObserver = Observer?> { t -> - if (t?.getOrNull()?.type == "${DefaultSharedSecretStorageService.KEY_ID_BASE}.$TEST_KEY_ID") { - accountData = t.getOrNull() - accountDataLock.countDown() + // Assert Account data is updated + testHelper.waitWithLatch { + val liveAccountData = aliceSession.accountDataService().getLiveUserAccountDataEvent("${DefaultSharedSecretStorageService.KEY_ID_BASE}.$TEST_KEY_ID") + val accountDataObserver = Observer?> { t -> + if (t?.getOrNull()?.type == "${DefaultSharedSecretStorageService.KEY_ID_BASE}.$TEST_KEY_ID") { + accountData = t.getOrNull() + } + it.countDown() } + liveAccountData.observeForever(accountDataObserver) } - GlobalScope.launch(Dispatchers.Main) { liveAccountData.observeForever(accountDataObserver) } - - mTestHelper.await(accountDataLock) - assertNotNull("Key should be stored in account data", accountData) val parsed = SecretStorageKeyContent.fromJson(accountData!!.content) assertNotNull("Key Content cannot be parsed", parsed) @@ -96,36 +85,29 @@ class QuadSTests : InstrumentedTest { assertEquals("Unexpected key name", "Test Key", parsed.name) assertNull("Key was not generated from passphrase", parsed.passphrase) - // Set as default key - GlobalScope.launch { - quadS.setDefaultKey(TEST_KEY_ID) - } - var defaultKeyAccountData: UserAccountDataEvent? = null - val defaultDataLock = CountDownLatch(1) - - val liveDefAccountData = runBlocking(Dispatchers.Main) { - aliceSession.accountDataService().getLiveUserAccountDataEvent(DefaultSharedSecretStorageService.DEFAULT_KEY_ID) - } - val accountDefDataObserver = Observer?> { t -> - if (t?.getOrNull()?.type == DefaultSharedSecretStorageService.DEFAULT_KEY_ID) { - defaultKeyAccountData = t.getOrNull()!! - defaultDataLock.countDown() + // Set as default key + testHelper.waitWithLatch { latch -> + quadS.setDefaultKey(TEST_KEY_ID) + val liveDefAccountData = + aliceSession.accountDataService().getLiveUserAccountDataEvent(DefaultSharedSecretStorageService.DEFAULT_KEY_ID) + val accountDefDataObserver = Observer?> { t -> + if (t?.getOrNull()?.type == DefaultSharedSecretStorageService.DEFAULT_KEY_ID) { + defaultKeyAccountData = t.getOrNull()!! + latch.countDown() + } } + liveDefAccountData.observeForever(accountDefDataObserver) } - GlobalScope.launch(Dispatchers.Main) { liveDefAccountData.observeForever(accountDefDataObserver) } - - mTestHelper.await(defaultDataLock) - assertNotNull(defaultKeyAccountData?.content) assertEquals("Unexpected default key ${defaultKeyAccountData?.content}", TEST_KEY_ID, defaultKeyAccountData?.content?.get("key")) - mTestHelper.signOutAndClose(aliceSession) + testHelper.signOutAndClose(aliceSession) } @Test fun test_StoreSecret() { - val aliceSession = mTestHelper.createAccount(TestConstants.USER_ALICE, SessionTestParams(true)) + val aliceSession = testHelper.createAccount(TestConstants.USER_ALICE, SessionTestParams(true)) val keyId = "My.Key" val info = generatedSecret(aliceSession, keyId, true) @@ -133,7 +115,7 @@ class QuadSTests : InstrumentedTest { // Store a secret val clearSecret = "42".toByteArray().toBase64NoPadding() - mTestHelper.runBlockingTest { + testHelper.runBlockingTest { aliceSession.sharedSecretStorageService.storeSecret( "secret.of.life", clearSecret, @@ -154,7 +136,7 @@ class QuadSTests : InstrumentedTest { // Try to decrypt?? - val decryptedSecret = mTestHelper.runBlockingTest { + val decryptedSecret = testHelper.runBlockingTest { aliceSession.sharedSecretStorageService.getSecret( "secret.of.life", null, // default key @@ -163,32 +145,32 @@ class QuadSTests : InstrumentedTest { } assertEquals("Secret mismatch", clearSecret, decryptedSecret) - mTestHelper.signOutAndClose(aliceSession) + testHelper.signOutAndClose(aliceSession) } @Test fun test_SetDefaultLocalEcho() { - val aliceSession = mTestHelper.createAccount(TestConstants.USER_ALICE, SessionTestParams(true)) + val aliceSession = testHelper.createAccount(TestConstants.USER_ALICE, SessionTestParams(true)) val quadS = aliceSession.sharedSecretStorageService val TEST_KEY_ID = "my.test.Key" - mTestHelper.runBlockingTest { + testHelper.runBlockingTest { quadS.generateKey(TEST_KEY_ID, null, "Test Key", emptyKeySigner) } // Test that we don't need to wait for an account data sync to access directly the keyid from DB - mTestHelper.runBlockingTest { + testHelper.runBlockingTest { quadS.setDefaultKey(TEST_KEY_ID) } - mTestHelper.signOutAndClose(aliceSession) + testHelper.signOutAndClose(aliceSession) } @Test fun test_StoreSecretWithMultipleKey() { - val aliceSession = mTestHelper.createAccount(TestConstants.USER_ALICE, SessionTestParams(true)) + val aliceSession = testHelper.createAccount(TestConstants.USER_ALICE, SessionTestParams(true)) val keyId1 = "Key.1" val key1Info = generatedSecret(aliceSession, keyId1, true) val keyId2 = "Key2" @@ -196,7 +178,7 @@ class QuadSTests : InstrumentedTest { val mySecretText = "Lorem ipsum dolor sit amet, consectetur adipiscing elit" - mTestHelper.runBlockingTest { + testHelper.runBlockingTest { aliceSession.sharedSecretStorageService.storeSecret( "my.secret", mySecretText.toByteArray().toBase64NoPadding(), @@ -216,33 +198,33 @@ class QuadSTests : InstrumentedTest { assertNotNull(encryptedContent?.get(keyId2)) // Assert that can decrypt with both keys - mTestHelper.runBlockingTest { + testHelper.runBlockingTest { aliceSession.sharedSecretStorageService.getSecret("my.secret", keyId1, RawBytesKeySpec.fromRecoveryKey(key1Info.recoveryKey)!! ) } - mTestHelper.runBlockingTest { + testHelper.runBlockingTest { aliceSession.sharedSecretStorageService.getSecret("my.secret", keyId2, RawBytesKeySpec.fromRecoveryKey(key2Info.recoveryKey)!! ) } - mTestHelper.signOutAndClose(aliceSession) + testHelper.signOutAndClose(aliceSession) } @Test fun test_GetSecretWithBadPassphrase() { - val aliceSession = mTestHelper.createAccount(TestConstants.USER_ALICE, SessionTestParams(true)) + val aliceSession = testHelper.createAccount(TestConstants.USER_ALICE, SessionTestParams(true)) val keyId1 = "Key.1" val passphrase = "The good pass phrase" val key1Info = generatedSecretFromPassphrase(aliceSession, passphrase, keyId1, true) val mySecretText = "Lorem ipsum dolor sit amet, consectetur adipiscing elit" - mTestHelper.runBlockingTest { + testHelper.runBlockingTest { aliceSession.sharedSecretStorageService.storeSecret( "my.secret", mySecretText.toByteArray().toBase64NoPadding(), @@ -250,7 +232,7 @@ class QuadSTests : InstrumentedTest { ) } - mTestHelper.runBlockingTest { + testHelper.runBlockingTest { aliceSession.sharedSecretStorageService.getSecret("my.secret", keyId1, RawBytesKeySpec.fromPassphrase( @@ -262,7 +244,7 @@ class QuadSTests : InstrumentedTest { } // Now try with correct key - mTestHelper.runBlockingTest { + testHelper.runBlockingTest { aliceSession.sharedSecretStorageService.getSecret("my.secret", keyId1, RawBytesKeySpec.fromPassphrase( @@ -273,42 +255,37 @@ class QuadSTests : InstrumentedTest { ) } - mTestHelper.signOutAndClose(aliceSession) + testHelper.signOutAndClose(aliceSession) } @Suppress("EXPERIMENTAL_API_USAGE") private fun assertAccountData(session: Session, type: String): UserAccountDataEvent { - val accountDataLock = CountDownLatch(1) var accountData: UserAccountDataEvent? = null - - val liveAccountData = runBlocking(Dispatchers.Main) { - session.accountDataService().getLiveUserAccountDataEvent(type) - } - val accountDataObserver = Observer?> { t -> - if (t?.getOrNull()?.type == type) { - accountData = t.getOrNull() - accountDataLock.countDown() + testHelper.waitWithLatch { + val liveAccountData = session.accountDataService().getLiveUserAccountDataEvent(type) + val accountDataObserver = Observer?> { t -> + if (t?.getOrNull()?.type == type) { + accountData = t.getOrNull() + it.countDown() + } } + liveAccountData.observeForever(accountDataObserver) } - GlobalScope.launch(Dispatchers.Main) { liveAccountData.observeForever(accountDataObserver) } - mTestHelper.await(accountDataLock) - assertNotNull("Account Data type:$type should be found", accountData) - return accountData!! } private fun generatedSecret(session: Session, keyId: String, asDefault: Boolean = true): SsssKeyCreationInfo { val quadS = session.sharedSecretStorageService - val creationInfo = mTestHelper.runBlockingTest { + val creationInfo = testHelper.runBlockingTest { quadS.generateKey(keyId, null, keyId, emptyKeySigner) } assertAccountData(session, "${DefaultSharedSecretStorageService.KEY_ID_BASE}.$keyId") if (asDefault) { - mTestHelper.runBlockingTest { + testHelper.runBlockingTest { quadS.setDefaultKey(keyId) } assertAccountData(session, DefaultSharedSecretStorageService.DEFAULT_KEY_ID) @@ -320,7 +297,7 @@ class QuadSTests : InstrumentedTest { private fun generatedSecretFromPassphrase(session: Session, passphrase: String, keyId: String, asDefault: Boolean = true): SsssKeyCreationInfo { val quadS = session.sharedSecretStorageService - val creationInfo = mTestHelper.runBlockingTest { + val creationInfo = testHelper.runBlockingTest { quadS.generateKeyWithPassphrase( keyId, keyId, @@ -331,7 +308,7 @@ class QuadSTests : InstrumentedTest { assertAccountData(session, "${DefaultSharedSecretStorageService.KEY_ID_BASE}.$keyId") if (asDefault) { - mTestHelper.runBlockingTest { + testHelper.runBlockingTest { quadS.setDefaultKey(keyId) } assertAccountData(session, DefaultSharedSecretStorageService.DEFAULT_KEY_ID) diff --git a/matrix-sdk-android/src/androidTest/java/org/matrix/android/sdk/internal/crypto/verification/SASTest.kt b/matrix-sdk-android/src/androidTest/java/org/matrix/android/sdk/internal/crypto/verification/SASTest.kt index e0d49b3f5e..c914da6f71 100644 --- a/matrix-sdk-android/src/androidTest/java/org/matrix/android/sdk/internal/crypto/verification/SASTest.kt +++ b/matrix-sdk-android/src/androidTest/java/org/matrix/android/sdk/internal/crypto/verification/SASTest.kt @@ -53,12 +53,12 @@ import java.util.concurrent.CountDownLatch @RunWith(AndroidJUnit4::class) @FixMethodOrder(MethodSorters.NAME_ASCENDING) class SASTest : InstrumentedTest { - private val mTestHelper = CommonTestHelper(context()) - private val mCryptoTestHelper = CryptoTestHelper(mTestHelper) + private val testHelper = CommonTestHelper(context()) + private val cryptoTestHelper = CryptoTestHelper(testHelper) @Test fun test_aliceStartThenAliceCancel() { - val cryptoTestData = mCryptoTestHelper.doE2ETestWithAliceAndBobInARoom() + val cryptoTestData = cryptoTestHelper.doE2ETestWithAliceAndBobInARoom() val aliceSession = cryptoTestData.firstSession val bobSession = cryptoTestData.secondSession @@ -83,7 +83,7 @@ class SASTest : InstrumentedTest { val aliceKeyTx = aliceVerificationService.getExistingTransaction(bobSession.myUserId, txID!!) assertNotNull("Alice should have a started transaction", aliceKeyTx) - mTestHelper.await(bobTxCreatedLatch) + testHelper.await(bobTxCreatedLatch) bobVerificationService.removeListener(bobListener) val bobKeyTx = bobVerificationService.getExistingTransaction(aliceSession.myUserId, txID) @@ -116,7 +116,7 @@ class SASTest : InstrumentedTest { bobVerificationService.addListener(bobListener2) aliceSasTx.cancel(CancelCode.User) - mTestHelper.await(cancelLatch) + testHelper.await(cancelLatch) assertTrue("Should be cancelled on alice side", aliceSasTx.state is VerificationTxState.Cancelled) assertTrue("Should be cancelled on bob side", bobSasTx.state is VerificationTxState.Cancelled) @@ -133,13 +133,13 @@ class SASTest : InstrumentedTest { assertNull(bobVerificationService.getExistingTransaction(aliceSession.myUserId, txID)) assertNull(aliceVerificationService.getExistingTransaction(bobSession.myUserId, txID)) - cryptoTestData.cleanUp(mTestHelper) + cryptoTestData.cleanUp(testHelper) } @Test fun test_key_agreement_protocols_must_include_curve25519() { fail("Not passing for the moment") - val cryptoTestData = mCryptoTestHelper.doE2ETestWithAliceAndBobInARoom() + val cryptoTestData = cryptoTestHelper.doE2ETestWithAliceAndBobInARoom() val bobSession = cryptoTestData.secondSession!! @@ -186,17 +186,17 @@ class SASTest : InstrumentedTest { fakeBobStart(bobSession, aliceUserID, aliceDevice, tid, protocols = protocols) - mTestHelper.await(cancelLatch) + testHelper.await(cancelLatch) assertEquals("Request should be cancelled with m.unknown_method", CancelCode.UnknownMethod, cancelReason) - cryptoTestData.cleanUp(mTestHelper) + cryptoTestData.cleanUp(testHelper) } @Test fun test_key_agreement_macs_Must_include_hmac_sha256() { fail("Not passing for the moment") - val cryptoTestData = mCryptoTestHelper.doE2ETestWithAliceAndBobInARoom() + val cryptoTestData = cryptoTestHelper.doE2ETestWithAliceAndBobInARoom() val bobSession = cryptoTestData.secondSession!! @@ -223,18 +223,18 @@ class SASTest : InstrumentedTest { fakeBobStart(bobSession, aliceUserID, aliceDevice, tid, mac = mac) - mTestHelper.await(cancelLatch) + testHelper.await(cancelLatch) val cancelReq = canceledToDeviceEvent!!.content.toModel()!! assertEquals("Request should be cancelled with m.unknown_method", CancelCode.UnknownMethod.value, cancelReq.code) - cryptoTestData.cleanUp(mTestHelper) + cryptoTestData.cleanUp(testHelper) } @Test fun test_key_agreement_short_code_include_decimal() { fail("Not passing for the moment") - val cryptoTestData = mCryptoTestHelper.doE2ETestWithAliceAndBobInARoom() + val cryptoTestData = cryptoTestHelper.doE2ETestWithAliceAndBobInARoom() val bobSession = cryptoTestData.secondSession!! @@ -261,12 +261,12 @@ class SASTest : InstrumentedTest { fakeBobStart(bobSession, aliceUserID, aliceDevice, tid, codes = codes) - mTestHelper.await(cancelLatch) + testHelper.await(cancelLatch) val cancelReq = canceledToDeviceEvent!!.content.toModel()!! assertEquals("Request should be cancelled with m.unknown_method", CancelCode.UnknownMethod.value, cancelReq.code) - cryptoTestData.cleanUp(mTestHelper) + cryptoTestData.cleanUp(testHelper) } private fun fakeBobStart(bobSession: Session, @@ -303,7 +303,7 @@ class SASTest : InstrumentedTest { // If a device has two verifications in progress with the same device, then it should cancel both verifications. @Test fun test_aliceStartTwoRequests() { - val cryptoTestData = mCryptoTestHelper.doE2ETestWithAliceAndBobInARoom() + val cryptoTestData = cryptoTestHelper.doE2ETestWithAliceAndBobInARoom() val aliceSession = cryptoTestData.firstSession val bobSession = cryptoTestData.secondSession @@ -332,10 +332,10 @@ class SASTest : InstrumentedTest { aliceVerificationService.beginKeyVerification(VerificationMethod.SAS, bobUserId, bobDeviceId, null) aliceVerificationService.beginKeyVerification(VerificationMethod.SAS, bobUserId, bobDeviceId, null) - mTestHelper.await(aliceCreatedLatch) - mTestHelper.await(aliceCancelledLatch) + testHelper.await(aliceCreatedLatch) + testHelper.await(aliceCancelledLatch) - cryptoTestData.cleanUp(mTestHelper) + cryptoTestData.cleanUp(testHelper) } /** @@ -343,7 +343,7 @@ class SASTest : InstrumentedTest { */ @Test fun test_aliceAndBobAgreement() { - val cryptoTestData = mCryptoTestHelper.doE2ETestWithAliceAndBobInARoom() + val cryptoTestData = cryptoTestHelper.doE2ETestWithAliceAndBobInARoom() val aliceSession = cryptoTestData.firstSession val bobSession = cryptoTestData.secondSession @@ -383,7 +383,7 @@ class SASTest : InstrumentedTest { val bobUserId = bobSession.myUserId val bobDeviceId = bobSession.cryptoService().getMyDevice().deviceId aliceVerificationService.beginKeyVerification(VerificationMethod.SAS, bobUserId, bobDeviceId, null) - mTestHelper.await(aliceAcceptedLatch) + testHelper.await(aliceAcceptedLatch) assertTrue("Should have receive a commitment", accepted!!.commitment?.trim()?.isEmpty() == false) @@ -397,12 +397,12 @@ class SASTest : InstrumentedTest { assertTrue("all agreed Short Code should be known by alice", startReq!!.shortAuthenticationStrings.contains(it)) } - cryptoTestData.cleanUp(mTestHelper) + cryptoTestData.cleanUp(testHelper) } @Test fun test_aliceAndBobSASCode() { - val cryptoTestData = mCryptoTestHelper.doE2ETestWithAliceAndBobInARoom() + val cryptoTestData = cryptoTestHelper.doE2ETestWithAliceAndBobInARoom() val aliceSession = cryptoTestData.firstSession val bobSession = cryptoTestData.secondSession @@ -444,8 +444,8 @@ class SASTest : InstrumentedTest { val bobUserId = bobSession.myUserId val bobDeviceId = bobSession.cryptoService().getMyDevice().deviceId val verificationSAS = aliceVerificationService.beginKeyVerification(VerificationMethod.SAS, bobUserId, bobDeviceId, null) - mTestHelper.await(aliceSASLatch) - mTestHelper.await(bobSASLatch) + testHelper.await(aliceSASLatch) + testHelper.await(bobSASLatch) val aliceTx = aliceVerificationService.getExistingTransaction(bobUserId, verificationSAS!!) as SASDefaultVerificationTransaction val bobTx = bobVerificationService.getExistingTransaction(aliceSession.myUserId, verificationSAS) as SASDefaultVerificationTransaction @@ -453,12 +453,12 @@ class SASTest : InstrumentedTest { assertEquals("Should have same SAS", aliceTx.getShortCodeRepresentation(SasMode.DECIMAL), bobTx.getShortCodeRepresentation(SasMode.DECIMAL)) - cryptoTestData.cleanUp(mTestHelper) + cryptoTestData.cleanUp(testHelper) } @Test fun test_happyPath() { - val cryptoTestData = mCryptoTestHelper.doE2ETestWithAliceAndBobInARoom() + val cryptoTestData = cryptoTestHelper.doE2ETestWithAliceAndBobInARoom() val aliceSession = cryptoTestData.firstSession val bobSession = cryptoTestData.secondSession @@ -520,8 +520,8 @@ class SASTest : InstrumentedTest { val bobUserId = bobSession.myUserId val bobDeviceId = bobSession.cryptoService().getMyDevice().deviceId aliceVerificationService.beginKeyVerification(VerificationMethod.SAS, bobUserId, bobDeviceId, null) - mTestHelper.await(aliceSASLatch) - mTestHelper.await(bobSASLatch) + testHelper.await(aliceSASLatch) + testHelper.await(bobSASLatch) // Assert that devices are verified val bobDeviceInfoFromAlicePOV: CryptoDeviceInfo? = aliceSession.cryptoService().getDeviceInfo(bobUserId, bobDeviceId) @@ -532,12 +532,12 @@ class SASTest : InstrumentedTest { assertTrue("alice device should be verified from bob point of view", aliceDeviceInfoFromBobPOV!!.isVerified) assertTrue("bob device should be verified from alice point of view", bobDeviceInfoFromAlicePOV!!.isVerified) - cryptoTestData.cleanUp(mTestHelper) + cryptoTestData.cleanUp(testHelper) } @Test fun test_ConcurrentStart() { - val cryptoTestData = mCryptoTestHelper.doE2ETestWithAliceAndBobInARoom() + val cryptoTestData = cryptoTestHelper.doE2ETestWithAliceAndBobInARoom() val aliceSession = cryptoTestData.firstSession val bobSession = cryptoTestData.secondSession @@ -553,8 +553,8 @@ class SASTest : InstrumentedTest { var requestID: String? = null - mTestHelper.waitWithLatch { - mTestHelper.retryPeriodicallyWithLatch(it) { + testHelper.waitWithLatch { + testHelper.retryPeriodicallyWithLatch(it) { val prAlicePOV = aliceVerificationService.getExistingVerificationRequests(bobSession.myUserId).firstOrNull() requestID = prAlicePOV?.transactionId Log.v("TEST", "== alicePOV is $prAlicePOV") @@ -564,8 +564,8 @@ class SASTest : InstrumentedTest { Log.v("TEST", "== requestID is $requestID") - mTestHelper.waitWithLatch { - mTestHelper.retryPeriodicallyWithLatch(it) { + testHelper.waitWithLatch { + testHelper.retryPeriodicallyWithLatch(it) { val prBobPOV = bobVerificationService.getExistingVerificationRequests(aliceSession.myUserId).firstOrNull() Log.v("TEST", "== prBobPOV is $prBobPOV") prBobPOV?.transactionId == requestID @@ -579,8 +579,8 @@ class SASTest : InstrumentedTest { ) // wait for alice to get the ready - mTestHelper.waitWithLatch { - mTestHelper.retryPeriodicallyWithLatch(it) { + testHelper.waitWithLatch { + testHelper.retryPeriodicallyWithLatch(it) { val prAlicePOV = aliceVerificationService.getExistingVerificationRequests(bobSession.myUserId).firstOrNull() Log.v("TEST", "== prAlicePOV is $prAlicePOV") prAlicePOV?.transactionId == requestID && prAlicePOV?.isReady != null @@ -606,22 +606,22 @@ class SASTest : InstrumentedTest { var alicePovTx: SasVerificationTransaction? var bobPovTx: SasVerificationTransaction? - mTestHelper.waitWithLatch { - mTestHelper.retryPeriodicallyWithLatch(it) { + testHelper.waitWithLatch { + testHelper.retryPeriodicallyWithLatch(it) { alicePovTx = aliceVerificationService.getExistingTransaction(bobSession.myUserId, requestID!!) as? SasVerificationTransaction Log.v("TEST", "== alicePovTx is $alicePovTx") alicePovTx?.state == VerificationTxState.ShortCodeReady } } // wait for alice to get the ready - mTestHelper.waitWithLatch { - mTestHelper.retryPeriodicallyWithLatch(it) { + testHelper.waitWithLatch { + testHelper.retryPeriodicallyWithLatch(it) { bobPovTx = bobVerificationService.getExistingTransaction(aliceSession.myUserId, requestID!!) as? SasVerificationTransaction Log.v("TEST", "== bobPovTx is $bobPovTx") bobPovTx?.state == VerificationTxState.ShortCodeReady } } - cryptoTestData.cleanUp(mTestHelper) + cryptoTestData.cleanUp(testHelper) } } diff --git a/matrix-sdk-android/src/androidTest/java/org/matrix/android/sdk/internal/crypto/verification/qrcode/VerificationTest.kt b/matrix-sdk-android/src/androidTest/java/org/matrix/android/sdk/internal/crypto/verification/qrcode/VerificationTest.kt index 397f7f9441..36306aa383 100644 --- a/matrix-sdk-android/src/androidTest/java/org/matrix/android/sdk/internal/crypto/verification/qrcode/VerificationTest.kt +++ b/matrix-sdk-android/src/androidTest/java/org/matrix/android/sdk/internal/crypto/verification/qrcode/VerificationTest.kt @@ -40,8 +40,8 @@ import kotlin.coroutines.resume @RunWith(AndroidJUnit4::class) @FixMethodOrder(MethodSorters.JVM) class VerificationTest : InstrumentedTest { - private val mTestHelper = CommonTestHelper(context()) - private val mCryptoTestHelper = CryptoTestHelper(mTestHelper) + private val testHelper = CommonTestHelper(context()) + private val cryptoTestHelper = CryptoTestHelper(testHelper) data class ExpectedResult( val sasIsSupported: Boolean = false, @@ -155,12 +155,12 @@ class VerificationTest : InstrumentedTest { bobSupportedMethods: List, expectedResultForAlice: ExpectedResult, expectedResultForBob: ExpectedResult) { - val cryptoTestData = mCryptoTestHelper.doE2ETestWithAliceAndBobInARoom() + val cryptoTestData = cryptoTestHelper.doE2ETestWithAliceAndBobInARoom() val aliceSession = cryptoTestData.firstSession val bobSession = cryptoTestData.secondSession!! - mTestHelper.doSync { callback -> + testHelper.doSync { callback -> aliceSession.cryptoService().crossSigningService() .initializeCrossSigning( object : UserInteractiveAuthInterceptor { @@ -176,7 +176,7 @@ class VerificationTest : InstrumentedTest { }, callback) } - mTestHelper.doSync { callback -> + testHelper.doSync { callback -> bobSession.cryptoService().crossSigningService() .initializeCrossSigning( object : UserInteractiveAuthInterceptor { @@ -234,7 +234,7 @@ class VerificationTest : InstrumentedTest { val bobUserId = bobSession.myUserId // Step 1: Alice starts a verification request aliceVerificationService.requestKeyVerificationInDMs(aliceSupportedMethods, bobUserId, cryptoTestData.roomId) - mTestHelper.await(latch) + testHelper.await(latch) aliceReadyPendingVerificationRequest!!.let { pr -> pr.isSasSupported() shouldBe expectedResultForAlice.sasIsSupported @@ -248,6 +248,6 @@ class VerificationTest : InstrumentedTest { pr.otherCanScanQrCode() shouldBe expectedResultForBob.otherCanScanQrCode } - cryptoTestData.cleanUp(mTestHelper) + cryptoTestData.cleanUp(testHelper) } } diff --git a/matrix-sdk-android/src/androidTest/java/org/matrix/android/sdk/session/room/timeline/TimelineForwardPaginationTest.kt b/matrix-sdk-android/src/androidTest/java/org/matrix/android/sdk/session/room/timeline/TimelineForwardPaginationTest.kt index dfa6ec10ae..bc9722c922 100644 --- a/matrix-sdk-android/src/androidTest/java/org/matrix/android/sdk/session/room/timeline/TimelineForwardPaginationTest.kt +++ b/matrix-sdk-android/src/androidTest/java/org/matrix/android/sdk/session/room/timeline/TimelineForwardPaginationTest.kt @@ -65,14 +65,8 @@ class TimelineForwardPaginationTest : InstrumentedTest { message, numberOfMessagesToSend) - // Alice clear the cache - commonTestHelper.runBlockingTest { - aliceSession.clearCache() - } - - // And restarts the sync - aliceSession.startSync(true) - + // Alice clear the cache and restart the sync + commonTestHelper.clearCacheAndSync(aliceSession) val aliceTimeline = roomFromAlicePOV.createTimeline(null, TimelineSettings(30)) aliceTimeline.start() diff --git a/matrix-sdk-android/src/androidTest/java/org/matrix/android/sdk/session/space/SpaceCreationTest.kt b/matrix-sdk-android/src/androidTest/java/org/matrix/android/sdk/session/space/SpaceCreationTest.kt index 5911414c25..808020f37a 100644 --- a/matrix-sdk-android/src/androidTest/java/org/matrix/android/sdk/session/space/SpaceCreationTest.kt +++ b/matrix-sdk-android/src/androidTest/java/org/matrix/android/sdk/session/space/SpaceCreationTest.kt @@ -16,9 +16,7 @@ package org.matrix.android.sdk.session.space -import kotlinx.coroutines.GlobalScope import kotlinx.coroutines.delay -import kotlinx.coroutines.launch import kotlinx.coroutines.runBlocking import org.junit.Assert.assertEquals import org.junit.Assert.assertNotNull @@ -57,11 +55,9 @@ class SpaceCreationTest : InstrumentedTest { val topic = "A public space for test" var spaceId: String = "" commonTestHelper.waitWithLatch { - GlobalScope.launch { - spaceId = session.spaceService().createSpace(roomName, topic, null, true) - // wait a bit to let the summary update it self :/ - it.countDown() - } + spaceId = session.spaceService().createSpace(roomName, topic, null, true) + // wait a bit to let the summary update it self :/ + it.countDown() } val syncedSpace = session.spaceService().getSpace(spaceId) @@ -148,50 +144,40 @@ class SpaceCreationTest : InstrumentedTest { // create a room var firstChild: String? = null commonTestHelper.waitWithLatch { - GlobalScope.launch { - firstChild = aliceSession.createRoom(CreateRoomParams().apply { - this.name = "FirstRoom" - this.topic = "Description of first room" - this.preset = CreateRoomPreset.PRESET_PUBLIC_CHAT - }) - it.countDown() - } + firstChild = aliceSession.createRoom(CreateRoomParams().apply { + this.name = "FirstRoom" + this.topic = "Description of first room" + this.preset = CreateRoomPreset.PRESET_PUBLIC_CHAT + }) + it.countDown() } commonTestHelper.waitWithLatch { - GlobalScope.launch { - syncedSpace?.addChildren(firstChild!!, listOf(aliceSession.sessionParams.homeServerHost ?: ""), "a", suggested = true) - it.countDown() - } + syncedSpace?.addChildren(firstChild!!, listOf(aliceSession.sessionParams.homeServerHost ?: ""), "a", suggested = true) + it.countDown() } var secondChild: String? = null commonTestHelper.waitWithLatch { - GlobalScope.launch { - secondChild = aliceSession.createRoom(CreateRoomParams().apply { - this.name = "SecondRoom" - this.topic = "Description of second room" - this.preset = CreateRoomPreset.PRESET_PUBLIC_CHAT - }) - it.countDown() - } + secondChild = aliceSession.createRoom(CreateRoomParams().apply { + this.name = "SecondRoom" + this.topic = "Description of second room" + this.preset = CreateRoomPreset.PRESET_PUBLIC_CHAT + }) + it.countDown() } commonTestHelper.waitWithLatch { - GlobalScope.launch { - syncedSpace?.addChildren(secondChild!!, listOf(aliceSession.sessionParams.homeServerHost ?: ""), "b", suggested = true) - it.countDown() - } + syncedSpace?.addChildren(secondChild!!, listOf(aliceSession.sessionParams.homeServerHost ?: ""), "b", suggested = true) + it.countDown() } // Try to join from bob, it's a public space no need to invite var joinResult: JoinSpaceResult? = null commonTestHelper.waitWithLatch { - GlobalScope.launch { - joinResult = bobSession.spaceService().joinSpace(spaceId) - // wait a bit to let the summary update it self :/ - it.countDown() - } + joinResult = bobSession.spaceService().joinSpace(spaceId) + // wait a bit to let the summary update it self :/ + it.countDown() } assertEquals(JoinSpaceResult.Success, joinResult) diff --git a/matrix-sdk-android/src/androidTest/java/org/matrix/android/sdk/session/space/SpaceHierarchyTest.kt b/matrix-sdk-android/src/androidTest/java/org/matrix/android/sdk/session/space/SpaceHierarchyTest.kt index 09b0daf898..3344a91370 100644 --- a/matrix-sdk-android/src/androidTest/java/org/matrix/android/sdk/session/space/SpaceHierarchyTest.kt +++ b/matrix-sdk-android/src/androidTest/java/org/matrix/android/sdk/session/space/SpaceHierarchyTest.kt @@ -19,8 +19,6 @@ package org.matrix.android.sdk.session.space import android.util.Log import androidx.lifecycle.Observer import kotlinx.coroutines.Dispatchers -import kotlinx.coroutines.GlobalScope -import kotlinx.coroutines.launch import kotlinx.coroutines.runBlocking import org.junit.Assert.assertEquals import org.junit.Assert.assertNotNull @@ -63,36 +61,28 @@ class SpaceHierarchyTest : InstrumentedTest { val topic = "A public space for test" var spaceId: String = "" commonTestHelper.waitWithLatch { - GlobalScope.launch { - spaceId = session.spaceService().createSpace(spaceName, topic, null, true) - it.countDown() - } + spaceId = session.spaceService().createSpace(spaceName, topic, null, true) + it.countDown() } val syncedSpace = session.spaceService().getSpace(spaceId) var roomId: String = "" commonTestHelper.waitWithLatch { - GlobalScope.launch { - roomId = session.createRoom(CreateRoomParams().apply { name = "General" }) - it.countDown() - } + roomId = session.createRoom(CreateRoomParams().apply { name = "General" }) + it.countDown() } val viaServers = listOf(session.sessionParams.homeServerHost ?: "") commonTestHelper.waitWithLatch { - GlobalScope.launch { - syncedSpace!!.addChildren(roomId, viaServers, null, true) - it.countDown() - } + syncedSpace!!.addChildren(roomId, viaServers, null, true) + it.countDown() } commonTestHelper.waitWithLatch { - GlobalScope.launch { - session.spaceService().setSpaceParent(roomId, spaceId, true, viaServers) - it.countDown() - } + session.spaceService().setSpaceParent(roomId, spaceId, true, viaServers) + it.countDown() } Thread.sleep(9000) @@ -205,29 +195,23 @@ class SpaceHierarchyTest : InstrumentedTest { val spaceA = session.spaceService().getSpace(spaceAInfo.spaceId) val viaServers = listOf(session.sessionParams.homeServerHost ?: "") commonTestHelper.waitWithLatch { - GlobalScope.launch { - spaceA!!.addChildren(spaceCInfo.spaceId, viaServers, null, true) - session.spaceService().setSpaceParent(spaceCInfo.spaceId, spaceAInfo.spaceId, true, viaServers) - it.countDown() - } + spaceA!!.addChildren(spaceCInfo.spaceId, viaServers, null, true) + session.spaceService().setSpaceParent(spaceCInfo.spaceId, spaceAInfo.spaceId, true, viaServers) + it.countDown() } // Create orphan rooms var orphan1 = "" commonTestHelper.waitWithLatch { - GlobalScope.launch { - orphan1 = session.createRoom(CreateRoomParams().apply { name = "O1" }) - it.countDown() - } + orphan1 = session.createRoom(CreateRoomParams().apply { name = "O1" }) + it.countDown() } var orphan2 = "" commonTestHelper.waitWithLatch { - GlobalScope.launch { - orphan2 = session.createRoom(CreateRoomParams().apply { name = "O2" }) - it.countDown() - } + orphan2 = session.createRoom(CreateRoomParams().apply { name = "O2" }) + it.countDown() } val allRooms = session.getRoomSummaries(roomSummaryQueryParams { excludeType = listOf(RoomType.SPACE) }) @@ -250,11 +234,9 @@ class SpaceHierarchyTest : InstrumentedTest { // Add a non canonical child and check that it does not appear as orphan commonTestHelper.waitWithLatch { - GlobalScope.launch { - val a3 = session.createRoom(CreateRoomParams().apply { name = "A3" }) - spaceA!!.addChildren(a3, viaServers, null, false) - it.countDown() - } + val a3 = session.createRoom(CreateRoomParams().apply { name = "A3" }) + spaceA!!.addChildren(a3, viaServers, null, false) + it.countDown() } Thread.sleep(2_000) @@ -283,20 +265,16 @@ class SpaceHierarchyTest : InstrumentedTest { val spaceA = session.spaceService().getSpace(spaceAInfo.spaceId) val viaServers = listOf(session.sessionParams.homeServerHost ?: "") commonTestHelper.waitWithLatch { - GlobalScope.launch { - spaceA!!.addChildren(spaceCInfo.spaceId, viaServers, null, true) - session.spaceService().setSpaceParent(spaceCInfo.spaceId, spaceAInfo.spaceId, true, viaServers) - it.countDown() - } + spaceA!!.addChildren(spaceCInfo.spaceId, viaServers, null, true) + session.spaceService().setSpaceParent(spaceCInfo.spaceId, spaceAInfo.spaceId, true, viaServers) + it.countDown() } // add back A as subspace of C commonTestHelper.waitWithLatch { - GlobalScope.launch { - val spaceC = session.spaceService().getSpace(spaceCInfo.spaceId) - spaceC!!.addChildren(spaceAInfo.spaceId, viaServers, null, true) - it.countDown() - } + val spaceC = session.spaceService().getSpace(spaceCInfo.spaceId) + spaceC!!.addChildren(spaceAInfo.spaceId, viaServers, null, true) + it.countDown() } Thread.sleep(1000) @@ -336,12 +314,9 @@ class SpaceHierarchyTest : InstrumentedTest { session.spaceService().setSpaceParent(spaceBInfo.spaceId, spaceAInfo.spaceId, true, viaServers) } - val flatAChildren = runBlocking(Dispatchers.Main) { - session.getFlattenRoomSummaryChildrenOfLive(spaceAInfo.spaceId) - } - commonTestHelper.waitWithLatch { latch -> + val flatAChildren = session.getFlattenRoomSummaryChildrenOfLive(spaceAInfo.spaceId) val childObserver = object : Observer> { override fun onChanged(children: List?) { // Log.d("## TEST", "Space A flat children update : ${children?.map { it.name }}") @@ -360,14 +335,12 @@ class SpaceHierarchyTest : InstrumentedTest { )) // add C as subspace of B - runBlocking { - val spaceB = session.spaceService().getSpace(spaceBInfo.spaceId) - spaceB!!.addChildren(spaceCInfo.spaceId, viaServers, null, true) - } + val spaceB = session.spaceService().getSpace(spaceBInfo.spaceId) + spaceB!!.addChildren(spaceCInfo.spaceId, viaServers, null, true) // C1 and C2 should be in flatten child of A now - GlobalScope.launch(Dispatchers.Main) { flatAChildren.observeForever(childObserver) } + flatAChildren.observeForever(childObserver) } // Test part one of the rooms @@ -376,7 +349,7 @@ class SpaceHierarchyTest : InstrumentedTest { val bRoom = session.getRoom(bRoomId) commonTestHelper.waitWithLatch { latch -> - + val flatAChildren = session.getFlattenRoomSummaryChildrenOfLive(spaceAInfo.spaceId) val childObserver = object : Observer> { override fun onChanged(children: List?) { System.out.println("## TEST | Space A flat children update : ${children?.map { it.name }}") @@ -389,13 +362,10 @@ class SpaceHierarchyTest : InstrumentedTest { } // part from b room - runBlocking { - bRoom!!.leave(null) - } + bRoom!!.leave(null) // The room should have disapear from flat children - GlobalScope.launch(Dispatchers.Main) { flatAChildren.observeForever(childObserver) } + flatAChildren.observeForever(childObserver) } - commonTestHelper.signOutAndClose(session) } @@ -404,88 +374,59 @@ class SpaceHierarchyTest : InstrumentedTest { val roomIds: List ) - @Suppress("EXPERIMENTAL_API_USAGE") private fun createPublicSpace(session: Session, spaceName: String, childInfo: List> /** Name, auto-join, canonical*/ ): TestSpaceCreationResult { var spaceId = "" - commonTestHelper.waitWithLatch { - GlobalScope.launch { - spaceId = session.spaceService().createSpace(spaceName, "Test Topic", null, true) - it.countDown() + var roomIds: List = emptyList() + commonTestHelper.waitWithLatch { latch -> + spaceId = session.spaceService().createSpace(spaceName, "Test Topic", null, true) + val syncedSpace = session.spaceService().getSpace(spaceId) + val viaServers = listOf(session.sessionParams.homeServerHost ?: "") + + roomIds = childInfo.map { entry -> + session.createRoom(CreateRoomParams().apply { name = entry.first }) } - } - - val syncedSpace = session.spaceService().getSpace(spaceId) - val viaServers = listOf(session.sessionParams.homeServerHost ?: "") - - val roomIds = - childInfo.map { entry -> - var roomId = "" - commonTestHelper.waitWithLatch { - GlobalScope.launch { - roomId = session.createRoom(CreateRoomParams().apply { name = entry.first }) - it.countDown() - } - } - roomId - } - - roomIds.forEachIndexed { index, roomId -> - runBlocking { + roomIds.forEachIndexed { index, roomId -> syncedSpace!!.addChildren(roomId, viaServers, null, childInfo[index].second) val canonical = childInfo[index].third if (canonical != null) { session.spaceService().setSpaceParent(roomId, spaceId, canonical, viaServers) } } + latch.countDown() } return TestSpaceCreationResult(spaceId, roomIds) } - @Suppress("EXPERIMENTAL_API_USAGE") private fun createPrivateSpace(session: Session, spaceName: String, childInfo: List> /** Name, auto-join, canonical*/ ): TestSpaceCreationResult { var spaceId = "" + var roomIds: List = emptyList() commonTestHelper.waitWithLatch { - GlobalScope.launch { - spaceId = session.spaceService().createSpace(spaceName, "My Private Space", null, false) - it.countDown() - } - } - - val syncedSpace = session.spaceService().getSpace(spaceId) - val viaServers = listOf(session.sessionParams.homeServerHost ?: "") - - val roomIds = - childInfo.map { entry -> - var roomId = "" - commonTestHelper.waitWithLatch { - GlobalScope.launch { - val homeServerCapabilities = session - .getHomeServerCapabilities() - roomId = session.createRoom(CreateRoomParams().apply { - name = entry.first - this.featurePreset = RestrictedRoomPreset( - homeServerCapabilities, - listOf( - RoomJoinRulesAllowEntry.restrictedToRoom(spaceId) - ) - ) - }) - it.countDown() - } + spaceId = session.spaceService().createSpace(spaceName, "My Private Space", null, false) + val syncedSpace = session.spaceService().getSpace(spaceId) + val viaServers = listOf(session.sessionParams.homeServerHost ?: "") + roomIds = + childInfo.map { entry -> + val homeServerCapabilities = session + .getHomeServerCapabilities() + session.createRoom(CreateRoomParams().apply { + name = entry.first + this.featurePreset = RestrictedRoomPreset( + homeServerCapabilities, + listOf( + RoomJoinRulesAllowEntry.restrictedToRoom(spaceId) + ) + ) + }) } - roomId - } - - roomIds.forEachIndexed { index, roomId -> - runBlocking { + roomIds.forEachIndexed { index, roomId -> syncedSpace!!.addChildren(roomId, viaServers, null, childInfo[index].second) val canonical = childInfo[index].third if (canonical != null) { @@ -540,7 +481,6 @@ class SpaceHierarchyTest : InstrumentedTest { } @Test - @Suppress("EXPERIMENTAL_API_USAGE") fun testParentRelation() { val aliceSession = commonTestHelper.createAccount("Alice", SessionTestParams(true)) val bobSession = commonTestHelper.createAccount("Bib", SessionTestParams(true)) @@ -560,11 +500,9 @@ class SpaceHierarchyTest : InstrumentedTest { var bobRoomId = "" commonTestHelper.waitWithLatch { - GlobalScope.launch { - bobRoomId = bobSession.createRoom(CreateRoomParams().apply { name = "A Bob Room" }) - bobSession.getRoom(bobRoomId)!!.invite(aliceSession.myUserId) - it.countDown() - } + bobRoomId = bobSession.createRoom(CreateRoomParams().apply { name = "A Bob Room" }) + bobSession.getRoom(bobRoomId)!!.invite(aliceSession.myUserId) + it.countDown() } commonTestHelper.runBlockingTest { @@ -578,10 +516,8 @@ class SpaceHierarchyTest : InstrumentedTest { } commonTestHelper.waitWithLatch { - GlobalScope.launch { - bobSession.spaceService().setSpaceParent(bobRoomId, spaceAInfo.spaceId, false, listOf(bobSession.sessionParams.homeServerHost ?: "")) - it.countDown() - } + bobSession.spaceService().setSpaceParent(bobRoomId, spaceAInfo.spaceId, false, listOf(bobSession.sessionParams.homeServerHost ?: "")) + it.countDown() } commonTestHelper.waitWithLatch { latch -> @@ -601,19 +537,17 @@ class SpaceHierarchyTest : InstrumentedTest { // Let's now try to make alice admin of the room commonTestHelper.waitWithLatch { - GlobalScope.launch { - val room = bobSession.getRoom(bobRoomId)!! - val currentPLContent = room - .getStateEvent(EventType.STATE_ROOM_POWER_LEVELS) - ?.let { it.content.toModel() } + val room = bobSession.getRoom(bobRoomId)!! + val currentPLContent = room + .getStateEvent(EventType.STATE_ROOM_POWER_LEVELS) + ?.let { it.content.toModel() } - val newPowerLevelsContent = currentPLContent - ?.setUserPowerLevel(aliceSession.myUserId, Role.Admin.value) - ?.toContent() + val newPowerLevelsContent = currentPLContent + ?.setUserPowerLevel(aliceSession.myUserId, Role.Admin.value) + ?.toContent() - room.sendStateEvent(EventType.STATE_ROOM_POWER_LEVELS, null, newPowerLevelsContent!!) - it.countDown() - } + room.sendStateEvent(EventType.STATE_ROOM_POWER_LEVELS, null, newPowerLevelsContent!!) + it.countDown() } commonTestHelper.waitWithLatch { latch -> @@ -628,10 +562,8 @@ class SpaceHierarchyTest : InstrumentedTest { } commonTestHelper.waitWithLatch { - GlobalScope.launch { - aliceSession.spaceService().setSpaceParent(bobRoomId, spaceAInfo.spaceId, false, listOf(bobSession.sessionParams.homeServerHost ?: "")) - it.countDown() - } + aliceSession.spaceService().setSpaceParent(bobRoomId, spaceAInfo.spaceId, false, listOf(bobSession.sessionParams.homeServerHost ?: "")) + it.countDown() } commonTestHelper.waitWithLatch { latch ->