mobile/element-android
mobile/element-android
1
0
Fork 0
mirror of https://github.com/element-hq/element-android synced 2024-07-22 10:34:58 +00:00
Code Issues Actions 3 Packages Projects Releases Wiki Activity

Merge pull request #7854 from vector-im/fix/mna/info-session-without-crypto-support

Browse source 
[Session manager] Missing info when a session does not support encryption (PSG-1074)
This commit is contained in:
Maxime NATUREL 2023-01-05 17:42:08 +01:00 committed by GitHub
parent c6a0a03bf2 5373771566
commit f1bd9b2cf3
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
15 changed files with 166 additions and 74 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

1
changelog.d/7853.bugfix Normal file
View file

@ -0,0 +1 @@
[Session manager] Missing info when a session does not support encryption

2
vector/src/main/java/im/vector/app/features/settings/devices/DevicesViewModel.kt
View file

@ -142,7 +142,7 @@ class DevicesViewModel @AssistedInject constructor(
.map { deviceInfo ->
val cryptoDeviceInfo = cryptoList.firstOrNull { it.deviceId == deviceInfo.deviceId }
val trustLevelForShield = getEncryptionTrustLevelForDeviceUseCase.execute(currentSessionCrossSigningInfo, cryptoDeviceInfo)
val isInactive = checkIfSessionIsInactiveUseCase.execute(deviceInfo.lastSeenTs ?: 0)
val isInactive = checkIfSessionIsInactiveUseCase.execute(deviceInfo.lastSeenTs)
DeviceFullInfo(deviceInfo, cryptoDeviceInfo, trustLevelForShield, isInactive)
}
}

40
vector/src/main/java/im/vector/app/features/settings/devices/v2/DevicesViewModel.kt
View file

@ -18,7 +18,6 @@ package im.vector.app.features.settings.devices.v2
import android.content.SharedPreferences
import com.airbnb.mvrx.MavericksViewModelFactory
import com.airbnb.mvrx.Success
import dagger.assisted.Assisted
import dagger.assisted.AssistedFactory
import dagger.assisted.AssistedInject
@ -32,10 +31,10 @@ import im.vector.app.features.settings.devices.v2.signout.SignoutSessionsReAuthN
import im.vector.app.features.settings.devices.v2.signout.SignoutSessionsUseCase
import im.vector.app.features.settings.devices.v2.verification.CheckIfCurrentSessionCanBeVerifiedUseCase
import im.vector.app.features.settings.devices.v2.verification.GetCurrentSessionCrossSigningInfoUseCase
import kotlinx.coroutines.flow.combine
import kotlinx.coroutines.flow.launchIn
import kotlinx.coroutines.flow.onEach
import kotlinx.coroutines.launch
import org.matrix.android.sdk.api.extensions.orFalse
import org.matrix.android.sdk.api.session.uia.DefaultBaseAuth
import timber.log.Timber
@ -103,27 +102,27 @@ class DevicesViewModel @AssistedInject constructor(
}
private fun observeDevices() {
getDeviceFullInfoListUseCase.execute(
val allSessionsFlow = getDeviceFullInfoListUseCase.execute(
filterType = DeviceManagerFilterType.ALL_SESSIONS,
excludeCurrentDevice = false
excludeCurrentDevice = false,
)
val unverifiedSessionsFlow = getDeviceFullInfoListUseCase.execute(
filterType = DeviceManagerFilterType.UNVERIFIED,
excludeCurrentDevice = true,
)
val inactiveSessionsFlow = getDeviceFullInfoListUseCase.execute(
filterType = DeviceManagerFilterType.INACTIVE,
excludeCurrentDevice = true,
)
.execute { async ->
if (async is Success) {
val deviceFullInfoList = async.invoke()
val unverifiedSessionsCount = deviceFullInfoList.count { !it.cryptoDeviceInfo?.trustLevel?.isCrossSigningVerified().orFalse() }
val inactiveSessionsCount = deviceFullInfoList.count { it.isInactive }
copy(
devices = async,
unverifiedSessionsCount = unverifiedSessionsCount,
inactiveSessionsCount = inactiveSessionsCount,
)
} else {
copy(
devices = async
)
}
}
combine(allSessionsFlow, unverifiedSessionsFlow, inactiveSessionsFlow) { allSessions, unverifiedSessions, inactiveSessions ->
DeviceFullInfoList(
allSessions = allSessions,
unverifiedSessionsCount = unverifiedSessions.size,
inactiveSessionsCount = inactiveSessions.size,
)
}
.execute { async -> copy(devices = async) }
}
private fun refreshDevicesOnCryptoDevicesChange() {
@ -185,6 +184,7 @@ class DevicesViewModel @AssistedInject constructor(
private fun getDeviceIdsOfOtherSessions(state: DevicesViewState): List<String> {
val currentDeviceId = state.currentSessionCrossSigningInfo.deviceId
return state.devices()
?.allSessions
?.mapNotNull { fullInfo -> fullInfo.deviceInfo.deviceId.takeUnless { it == currentDeviceId } }
.orEmpty()
}

10
vector/src/main/java/im/vector/app/features/settings/devices/v2/DevicesViewState.kt
View file

@ -23,9 +23,13 @@ import im.vector.app.features.settings.devices.v2.verification.CurrentSessionCro
data class DevicesViewState(
val currentSessionCrossSigningInfo: CurrentSessionCrossSigningInfo = CurrentSessionCrossSigningInfo(),
val devices: Async<List<DeviceFullInfo>> = Uninitialized,
val unverifiedSessionsCount: Int = 0,
val inactiveSessionsCount: Int = 0,
val devices: Async<DeviceFullInfoList> = Uninitialized,
val isLoading: Boolean = false,
val isShowingIpAddress: Boolean = false,
) : MavericksState
data class DeviceFullInfoList(
val allSessions: List<DeviceFullInfo>,
val unverifiedSessionsCount: Int,
val inactiveSessionsCount: Int,
)

2
vector/src/main/java/im/vector/app/features/settings/devices/v2/GetDeviceFullInfoListUseCase.kt
View file

@ -75,7 +75,7 @@ class GetDeviceFullInfoListUseCase @Inject constructor(
.map { deviceInfo ->
val cryptoDeviceInfo = cryptoList.firstOrNull { it.deviceId == deviceInfo.deviceId }
val roomEncryptionTrustLevel = getEncryptionTrustLevelForDeviceUseCase.execute(currentSessionCrossSigningInfo, cryptoDeviceInfo)
val isInactive = checkIfSessionIsInactiveUseCase.execute(deviceInfo.lastSeenTs ?: 0)
val isInactive = checkIfSessionIsInactiveUseCase.execute(deviceInfo.lastSeenTs)
val isCurrentDevice = currentSessionCrossSigningInfo.deviceId == cryptoDeviceInfo?.deviceId
val deviceExtendedInfo = parseDeviceUserAgentUseCase.execute(deviceInfo.getBestLastSeenUserAgent())
val matrixClientInfo = deviceInfo.deviceId

12
vector/src/main/java/im/vector/app/features/settings/devices/v2/VectorSettingsDevicesFragment.kt
View file

@ -55,7 +55,6 @@ import im.vector.app.features.settings.devices.v2.signout.BuildConfirmSignoutDia
import im.vector.app.features.workers.signout.SignOutUiWorker
import org.matrix.android.sdk.api.auth.data.LoginFlowTypes
import org.matrix.android.sdk.api.extensions.orFalse
import org.matrix.android.sdk.api.session.crypto.model.RoomEncryptionTrustLevel
import javax.inject.Inject
/**
@ -282,13 +281,15 @@ class VectorSettingsDevicesFragment :
override fun invalidate() = withState(viewModel) { state ->
if (state.devices is Success) {
val devices = state.devices()
val deviceFullInfoList = state.devices()
val devices = deviceFullInfoList?.allSessions
val currentDeviceId = state.currentSessionCrossSigningInfo.deviceId
val currentDeviceInfo = devices?.firstOrNull { it.deviceInfo.deviceId == currentDeviceId }
val isCurrentSessionVerified = currentDeviceInfo?.roomEncryptionTrustLevel == RoomEncryptionTrustLevel.Trusted
val otherDevices = devices?.filter { it.deviceInfo.deviceId != currentDeviceId }
val inactiveSessionsCount = deviceFullInfoList?.inactiveSessionsCount ?: 0
val unverifiedSessionsCount = deviceFullInfoList?.unverifiedSessionsCount ?: 0
renderSecurityRecommendations(state.inactiveSessionsCount, state.unverifiedSessionsCount, isCurrentSessionVerified)
renderSecurityRecommendations(inactiveSessionsCount, unverifiedSessionsCount)
renderCurrentSessionView(currentDeviceInfo, hasOtherDevices = otherDevices?.isNotEmpty().orFalse())
renderOtherSessionsView(otherDevices, state.isShowingIpAddress)
} else {
@ -303,9 +304,8 @@ class VectorSettingsDevicesFragment :
private fun renderSecurityRecommendations(
inactiveSessionsCount: Int,
unverifiedSessionsCount: Int,
isCurrentSessionVerified: Boolean,
) {
val isUnverifiedSectionVisible = unverifiedSessionsCount > 0 && isCurrentSessionVerified
val isUnverifiedSectionVisible = unverifiedSessionsCount > 0
val isInactiveSectionVisible = inactiveSessionsCount > 0
if (isUnverifiedSectionVisible.not() && isInactiveSectionVisible.not()) {
hideSecurityRecommendations()

4
vector/src/main/java/im/vector/app/features/settings/devices/v2/filter/FilterDevicesUseCase.kt
View file

@ -37,7 +37,9 @@ class FilterDevicesUseCase @Inject constructor() {
// when current session is not verified, other session status cannot be trusted
DeviceManagerFilterType.VERIFIED -> isCurrentSessionVerified && it.cryptoDeviceInfo?.trustLevel?.isCrossSigningVerified().orFalse()
// when current session is not verified, other session status cannot be trusted
DeviceManagerFilterType.UNVERIFIED -> isCurrentSessionVerified && !it.cryptoDeviceInfo?.trustLevel?.isCrossSigningVerified().orFalse()
DeviceManagerFilterType.UNVERIFIED ->
(isCurrentSessionVerified && !it.cryptoDeviceInfo?.trustLevel?.isCrossSigningVerified().orFalse()) ||
it.cryptoDeviceInfo == null
DeviceManagerFilterType.INACTIVE -> it.isInactive
}
}

14
vector/src/main/java/im/vector/app/features/settings/devices/v2/list/CheckIfSessionIsInactiveUseCase.kt
View file

@ -24,11 +24,13 @@ class CheckIfSessionIsInactiveUseCase @Inject constructor(
private val clock: Clock,
) {
fun execute(lastSeenTs: Long): Boolean {
// In case of the server doesn't send the last seen date.
if (lastSeenTs == 0L) return true
val diffMilliseconds = clock.epochMillis() - lastSeenTs
return diffMilliseconds >= TimeUnit.DAYS.toMillis(SESSION_IS_MARKED_AS_INACTIVE_AFTER_DAYS.toLong())
fun execute(lastSeenTsMillis: Long?): Boolean {
return if (lastSeenTsMillis == null || lastSeenTsMillis <= 0) {
// in these situations we cannot say anything about the inactivity of the session
false
} else {
val diffMilliseconds = clock.epochMillis() - lastSeenTsMillis
diffMilliseconds >= TimeUnit.DAYS.toMillis(SESSION_IS_MARKED_AS_INACTIVE_AFTER_DAYS.toLong())
}
}
}

3
vector/src/main/java/im/vector/app/features/settings/devices/v2/list/OtherSessionsController.kt
View file

@ -63,12 +63,13 @@ class OtherSessionsController @Inject constructor(
}
val drawableColor = host.colorProvider.getColorFromAttribute(R.attr.vctr_content_secondary)
val descriptionDrawable = if (device.isInactive) host.drawableProvider.getDrawable(R.drawable.ic_inactive_sessions, drawableColor) else null
val sessionName = device.deviceInfo.displayName ?: device.deviceInfo.deviceId
otherSessionItem {
id(device.deviceInfo.deviceId)
deviceType(device.deviceExtendedInfo.deviceType)
roomEncryptionTrustLevel(device.roomEncryptionTrustLevel)
sessionName(device.deviceInfo.displayName)
sessionName(sessionName)
sessionDescription(description)
sessionDescriptionDrawable(descriptionDrawable)
sessionDescriptionColor(descriptionColor)

7
vector/src/main/java/im/vector/app/features/settings/devices/v2/list/SessionInfoView.kt
View file

@ -62,9 +62,10 @@ class SessionInfoView @JvmOverloads constructor(
stringProvider: StringProvider,
) {
renderDeviceInfo(
sessionInfoViewState.deviceFullInfo.deviceInfo.displayName.orEmpty(),
sessionInfoViewState.deviceFullInfo.deviceExtendedInfo.deviceType,
stringProvider,
sessionName = sessionInfoViewState.deviceFullInfo.deviceInfo.displayName
?: sessionInfoViewState.deviceFullInfo.deviceInfo.deviceId.orEmpty(),
deviceType = sessionInfoViewState.deviceFullInfo.deviceExtendedInfo.deviceType,
stringProvider = stringProvider,
)
renderVerificationStatus(
sessionInfoViewState.deviceFullInfo.roomEncryptionTrustLevel,

6
vector/src/main/java/im/vector/app/features/settings/devices/v2/overview/GetDeviceFullInfoUseCase.kt
View file

@ -49,10 +49,10 @@ class GetDeviceFullInfoUseCase @Inject constructor(
) { currentSessionCrossSigningInfo, deviceInfo, cryptoDeviceInfo ->
val info = deviceInfo.getOrNull()
val cryptoInfo = cryptoDeviceInfo.getOrNull()
val fullInfo = if (info != null && cryptoInfo != null) {
val fullInfo = if (info != null) {
val roomEncryptionTrustLevel = getEncryptionTrustLevelForDeviceUseCase.execute(currentSessionCrossSigningInfo, cryptoInfo)
val isInactive = checkIfSessionIsInactiveUseCase.execute(info.lastSeenTs ?: 0)
val isCurrentDevice = currentSessionCrossSigningInfo.deviceId == cryptoInfo.deviceId
val isInactive = checkIfSessionIsInactiveUseCase.execute(info.lastSeenTs)
val isCurrentDevice = currentSessionCrossSigningInfo.deviceId == info.deviceId
val deviceUserAgent = parseDeviceUserAgentUseCase.execute(info.getBestLastSeenUserAgent())
val matrixClientInfo = info.deviceId
?.takeIf { it.isNotEmpty() }

23
vector/src/test/java/im/vector/app/features/settings/devices/v2/DevicesViewModelTest.kt
View file

@ -21,6 +21,7 @@ import com.airbnb.mvrx.Success
import com.airbnb.mvrx.test.MavericksTestRule
import im.vector.app.core.session.clientinfo.MatrixClientInfoContent
import im.vector.app.features.settings.devices.v2.details.extended.DeviceExtendedInfo
import im.vector.app.features.settings.devices.v2.filter.DeviceManagerFilterType
import im.vector.app.features.settings.devices.v2.list.DeviceType
import im.vector.app.features.settings.devices.v2.verification.CheckIfCurrentSessionCanBeVerifiedUseCase
import im.vector.app.features.settings.devices.v2.verification.CurrentSessionCrossSigningInfo
@ -176,10 +177,7 @@ class DevicesViewModelTest {
val viewModelTest = createViewModel().test()
// Then
viewModelTest.assertLatestState {
it.devices is Success && it.devices.invoke() == deviceFullInfoList &&
it.inactiveSessionsCount == 1 && it.unverifiedSessionsCount == 1
}
viewModelTest.assertLatestState { it.devices is Success && it.devices.invoke() == deviceFullInfoList }
viewModelTest.finish()
}
@ -403,7 +401,7 @@ class DevicesViewModelTest {
/**
* Generate mocked deviceFullInfo list with 1 unverified and inactive + 1 verified and active.
*/
private fun givenDeviceFullInfoList(deviceId1: String, deviceId2: String): List<DeviceFullInfo> {
private fun givenDeviceFullInfoList(deviceId1: String, deviceId2: String): DeviceFullInfoList {
val verifiedCryptoDeviceInfo = mockk<CryptoDeviceInfo>()
every { verifiedCryptoDeviceInfo.trustLevel } returns DeviceTrustLevel(crossSigningVerified = true, locallyVerified = true)
val unverifiedCryptoDeviceInfo = mockk<CryptoDeviceInfo>()
@ -432,10 +430,15 @@ class DevicesViewModelTest {
deviceExtendedInfo = DeviceExtendedInfo(DeviceType.MOBILE),
matrixClientInfo = MatrixClientInfoContent(),
)
val deviceFullInfoList = listOf(deviceFullInfo1, deviceFullInfo2)
val deviceFullInfoListFlow = flowOf(deviceFullInfoList)
every { getDeviceFullInfoListUseCase.execute(any(), any()) } returns deviceFullInfoListFlow
return deviceFullInfoList
val devices = listOf(deviceFullInfo1, deviceFullInfo2)
every { getDeviceFullInfoListUseCase.execute(DeviceManagerFilterType.ALL_SESSIONS, any()) } returns flowOf(devices)
every { getDeviceFullInfoListUseCase.execute(DeviceManagerFilterType.UNVERIFIED, any()) } returns flowOf(listOf(deviceFullInfo2))
every { getDeviceFullInfoListUseCase.execute(DeviceManagerFilterType.INACTIVE, any()) } returns flowOf(listOf(deviceFullInfo1))
return DeviceFullInfoList(
allSessions = devices,
unverifiedSessionsCount = 1,
inactiveSessionsCount = 1,
)
}
private fun givenInitialViewState(deviceId1: String, deviceId2: String): DevicesViewState {
@ -444,8 +447,6 @@ class DevicesViewModelTest {
return DevicesViewState(
currentSessionCrossSigningInfo = currentSessionCrossSigningInfo,
devices = Success(deviceFullInfoList),
unverifiedSessionsCount = 1,
inactiveSessionsCount = 1,
isLoading = false,
)
}

19
vector/src/test/java/im/vector/app/features/settings/devices/v2/filter/FilterDevicesUseCaseTest.kt
View file

@ -22,6 +22,7 @@ import im.vector.app.features.settings.devices.v2.details.extended.DeviceExtende
import im.vector.app.features.settings.devices.v2.list.DeviceType
import im.vector.app.features.settings.devices.v2.verification.CurrentSessionCrossSigningInfo
import org.amshove.kluent.shouldBeEqualTo
import org.amshove.kluent.shouldContain
import org.amshove.kluent.shouldContainAll
import org.junit.Test
import org.matrix.android.sdk.api.session.crypto.crosssigning.DeviceTrustLevel
@ -82,11 +83,22 @@ private val inactiveUnverifiedDevice = DeviceFullInfo(
matrixClientInfo = MatrixClientInfoContent(),
)
private val deviceWithoutEncryptionSupport = DeviceFullInfo(
deviceInfo = DeviceInfo(deviceId = "DEVICE_WITHOUT_ENCRYPTION_SUPPORT"),
cryptoDeviceInfo = null,
roomEncryptionTrustLevel = null,
isInactive = false,
isCurrentDevice = false,
deviceExtendedInfo = DeviceExtendedInfo(DeviceType.UNKNOWN),
matrixClientInfo = MatrixClientInfoContent(),
)
private val devices = listOf(
activeVerifiedDevice,
inactiveVerifiedDevice,
activeUnverifiedDevice,
inactiveUnverifiedDevice,
deviceWithoutEncryptionSupport,
)
class FilterDevicesUseCaseTest {
@ -123,8 +135,8 @@ class FilterDevicesUseCaseTest {
val currentSessionCrossSigningInfo = givenCurrentSessionVerified(true)
val filteredDeviceList = filterDevicesUseCase.execute(currentSessionCrossSigningInfo, devices, DeviceManagerFilterType.UNVERIFIED, emptyList())
filteredDeviceList.size shouldBeEqualTo 2
filteredDeviceList shouldContainAll listOf(activeUnverifiedDevice, inactiveUnverifiedDevice)
filteredDeviceList.size shouldBeEqualTo 3
filteredDeviceList shouldContainAll listOf(activeUnverifiedDevice, inactiveUnverifiedDevice, deviceWithoutEncryptionSupport)
}
@Test
@ -132,7 +144,8 @@ class FilterDevicesUseCaseTest {
val currentSessionCrossSigningInfo = givenCurrentSessionVerified(false)
val filteredDeviceList = filterDevicesUseCase.execute(currentSessionCrossSigningInfo, devices, DeviceManagerFilterType.UNVERIFIED, emptyList())
filteredDeviceList.size shouldBeEqualTo 0
filteredDeviceList.size shouldBeEqualTo 1
filteredDeviceList shouldContain deviceWithoutEncryptionSupport
}
@Test

50
vector/src/test/java/im/vector/app/features/settings/devices/v2/list/CheckIfSessionIsInactiveUseCaseTest.kt
View file

@ -17,43 +17,69 @@
package im.vector.app.features.settings.devices.v2.list
import im.vector.app.test.fakes.FakeClock
import org.amshove.kluent.shouldBeEqualTo
import org.amshove.kluent.shouldBeFalse
import org.amshove.kluent.shouldBeTrue
import org.junit.Test
import java.util.concurrent.TimeUnit
private const val A_TIMESTAMP = 1654689143L
private const val A_TIMESTAMP_MILLIS = 1654689143000L
class CheckIfSessionIsInactiveUseCaseTest {
private val clock = FakeClock().apply { givenEpoch(A_TIMESTAMP) }
private val clock = FakeClock().apply { givenEpoch(A_TIMESTAMP_MILLIS) }
private val checkIfSessionIsInactiveUseCase = CheckIfSessionIsInactiveUseCase(clock)
@Test
fun `given an old last seen date then session is inactive`() {
val lastSeenDate = A_TIMESTAMP - TimeUnit.DAYS.toMillis(SESSION_IS_MARKED_AS_INACTIVE_AFTER_DAYS.toLong()) - 1
val lastSeenDate = A_TIMESTAMP_MILLIS - TimeUnit.DAYS.toMillis(SESSION_IS_MARKED_AS_INACTIVE_AFTER_DAYS.toLong()) - 1
checkIfSessionIsInactiveUseCase.execute(lastSeenDate) shouldBeEqualTo true
val result = checkIfSessionIsInactiveUseCase.execute(lastSeenDate)
result.shouldBeTrue()
}
@Test
fun `given a last seen date equal to the threshold then session is inactive`() {
val lastSeenDate = A_TIMESTAMP - TimeUnit.DAYS.toMillis(SESSION_IS_MARKED_AS_INACTIVE_AFTER_DAYS.toLong())
val lastSeenDate = A_TIMESTAMP_MILLIS - TimeUnit.DAYS.toMillis(SESSION_IS_MARKED_AS_INACTIVE_AFTER_DAYS.toLong())
checkIfSessionIsInactiveUseCase.execute(lastSeenDate) shouldBeEqualTo true
val result = checkIfSessionIsInactiveUseCase.execute(lastSeenDate)
result.shouldBeTrue()
}
@Test
fun `given a recent last seen date then session is active`() {
val lastSeenDate = A_TIMESTAMP - TimeUnit.DAYS.toMillis(SESSION_IS_MARKED_AS_INACTIVE_AFTER_DAYS.toLong()) + 1
val lastSeenDate = A_TIMESTAMP_MILLIS - TimeUnit.DAYS.toMillis(SESSION_IS_MARKED_AS_INACTIVE_AFTER_DAYS.toLong()) + 1
checkIfSessionIsInactiveUseCase.execute(lastSeenDate) shouldBeEqualTo false
val result = checkIfSessionIsInactiveUseCase.execute(lastSeenDate)
result.shouldBeFalse()
}
@Test
fun `given a last seen date as zero then session is inactive`() {
// In case of the server doesn't send the last seen date.
fun `given a last seen date as zero then session is not inactive`() {
val lastSeenDate = 0L
checkIfSessionIsInactiveUseCase.execute(lastSeenDate) shouldBeEqualTo true
val result = checkIfSessionIsInactiveUseCase.execute(lastSeenDate)
result.shouldBeFalse()
}
@Test
fun `given a last seen date as null then session is not inactive`() {
val lastSeenDate = null
val result = checkIfSessionIsInactiveUseCase.execute(lastSeenDate)
result.shouldBeFalse()
}
@Test
fun `given a last seen date as negative then session is not inactive`() {
val lastSeenDate = -3L
val result = checkIfSessionIsInactiveUseCase.execute(lastSeenDate)
result.shouldBeFalse()
}
}

47
vector/src/test/java/im/vector/app/features/settings/devices/v2/overview/GetDeviceFullInfoUseCaseTest.kt
View file

@ -117,6 +117,45 @@ class GetDeviceFullInfoUseCaseTest {
}
}
@Test
fun `given current session and no crypto info for device when getting device info then the result is correct`() = runTest {
// Given
val currentSessionCrossSigningInfo = givenCurrentSessionCrossSigningInfo()
val deviceInfo = givenADeviceInfo()
val cryptoDeviceInfo = null
val trustLevel = givenTrustLevel(currentSessionCrossSigningInfo, cryptoDeviceInfo)
val isInactive = false
val isCurrentDevice = true
every { checkIfSessionIsInactiveUseCase.execute(any()) } returns isInactive
every { parseDeviceUserAgentUseCase.execute(any()) } returns DeviceExtendedInfo(DeviceType.MOBILE)
val matrixClientInfo = givenAMatrixClientInfo()
fakeActiveSessionHolder.fakeSession.fakeCryptoService.cryptoDeviceInfoWithIdLiveData = MutableLiveData(Optional(null))
fakeActiveSessionHolder.fakeSession.fakeCryptoService.cryptoDeviceInfoWithIdLiveData.givenAsFlow()
// When
val deviceFullInfo = getDeviceFullInfoUseCase.execute(A_DEVICE_ID).firstOrNull()
// Then
deviceFullInfo shouldBeEqualTo DeviceFullInfo(
deviceInfo = deviceInfo,
cryptoDeviceInfo = cryptoDeviceInfo,
roomEncryptionTrustLevel = trustLevel,
isInactive = isInactive,
isCurrentDevice = isCurrentDevice,
deviceExtendedInfo = DeviceExtendedInfo(DeviceType.MOBILE),
matrixClientInfo = matrixClientInfo,
)
verify {
fakeActiveSessionHolder.instance.getSafeActiveSession()
getCurrentSessionCrossSigningInfoUseCase.execute()
getEncryptionTrustLevelForDeviceUseCase.execute(currentSessionCrossSigningInfo, cryptoDeviceInfo)
fakeActiveSessionHolder.fakeSession.fakeCryptoService.getMyDevicesInfoLive(A_DEVICE_ID).asFlow()
fakeActiveSessionHolder.fakeSession.fakeCryptoService.getLiveCryptoDeviceInfoWithId(A_DEVICE_ID).asFlow()
checkIfSessionIsInactiveUseCase.execute(A_TIMESTAMP)
getMatrixClientInfoUseCase.execute(fakeActiveSessionHolder.fakeSession, A_DEVICE_ID)
}
}
@Test
fun `given current session and no info for device when getting device info then the result is empty`() = runTest {
// Given
@ -131,9 +170,11 @@ class GetDeviceFullInfoUseCaseTest {
// Then
deviceFullInfo.shouldBeNull()
verify { fakeActiveSessionHolder.instance.getSafeActiveSession() }
verify { fakeActiveSessionHolder.fakeSession.fakeCryptoService.getMyDevicesInfoLive(A_DEVICE_ID).asFlow() }
verify { fakeActiveSessionHolder.fakeSession.fakeCryptoService.getLiveCryptoDeviceInfoWithId(A_DEVICE_ID).asFlow() }
verify {
fakeActiveSessionHolder.instance.getSafeActiveSession()
fakeActiveSessionHolder.fakeSession.fakeCryptoService.getMyDevicesInfoLive(A_DEVICE_ID).asFlow()
fakeActiveSessionHolder.fakeSession.fakeCryptoService.getLiveCryptoDeviceInfoWithId(A_DEVICE_ID).asFlow()
}
}
@Test