Sulkta-OSS/element-x-ada
3
0
Fork 0
Code Issues 1 Pull requests 10 Projects Releases Packages Wiki Activity Actions

fix(deps): update dependency org.matrix.rustcomponents:sdk-android to v25.6.18 (#4894)

Browse source 
Co-authored-by: renovate[bot] <29139614+renovate[bot]@users.noreply.github.com>
Co-authored-by: Jorge Martín <jorgem@element.io>
This commit is contained in:
renovate[bot] 2025-06-18 15:10:47 +00:00 • committed by GitHub
parent b2e17622ed
commit 31bb1848e4
23 changed files with 193 additions and 89 deletions
Download patch file Download diff file Expand all files Collapse all files

22
features/location/impl/src/main/kotlin/io/element/android/features/location/impl/send/SendLocationPresenter.kt
View file

@ -26,6 +26,10 @@ import io.element.android.libraries.architecture.Presenter
import io.element.android.libraries.core.meta.BuildMeta
import io.element.android.libraries.matrix.api.room.JoinedRoom
import io.element.android.libraries.matrix.api.room.location.AssetType
import io.element.android.libraries.matrix.api.room.message.ReplyParameters
import io.element.android.libraries.matrix.api.room.message.replyInThread
import io.element.android.libraries.matrix.ui.messages.reply.eventId
import io.element.android.libraries.textcomposer.model.MessageComposerMode
import io.element.android.services.analytics.api.AnalyticsService
import kotlinx.coroutines.launch
import javax.inject.Inject
@ -98,6 +102,18 @@ class SendLocationPresenter @Inject constructor(
event: SendLocationEvents.SendLocation,
mode: SendLocationState.Mode,
) {
val replyMode = messageComposerContext.composerMode as? MessageComposerMode.Reply
val replyParams = replyMode?.replyToDetails?.let { details ->
if (replyMode.inThread) {
replyInThread(details.eventId())
} else {
ReplyParameters(
inReplyToEventId = details.eventId(),
enforceThreadReply = false,
replyWithinThread = false
)
}
}
when (mode) {
SendLocationState.Mode.PinLocation -> {
val geoUri = event.cameraPosition.toGeoUri()
@ -106,7 +122,8 @@ class SendLocationPresenter @Inject constructor(
geoUri = geoUri,
description = null,
zoomLevel = MapDefaults.DEFAULT_ZOOM.toInt(),
assetType = AssetType.PIN
assetType = AssetType.PIN,
replyParameters = replyParams,
)
analyticsService.capture(
Composer(
@ -124,7 +141,8 @@ class SendLocationPresenter @Inject constructor(
geoUri = geoUri,
description = null,
zoomLevel = MapDefaults.DEFAULT_ZOOM.toInt(),
assetType = AssetType.SENDER
assetType = AssetType.SENDER,
replyParameters = replyParams,
)
analyticsService.capture(
Composer(

9
features/location/impl/src/test/kotlin/io/element/android/features/location/impl/send/SendLocationPresenterTest.kt
View file

@ -22,6 +22,7 @@ import io.element.android.features.location.impl.common.permissions.PermissionsS
import io.element.android.features.messages.test.FakeMessageComposerContext
import io.element.android.libraries.matrix.api.room.JoinedRoom
import io.element.android.libraries.matrix.api.room.location.AssetType
import io.element.android.libraries.matrix.api.room.message.ReplyParameters
import io.element.android.libraries.matrix.api.timeline.item.event.toEventOrTransactionId
import io.element.android.libraries.matrix.test.AN_EVENT_ID
import io.element.android.libraries.matrix.test.core.aBuildMeta
@ -263,7 +264,7 @@ class SendLocationPresenterTest {
@Test
fun `share sender location`() = runTest {
val sendLocationResult = lambdaRecorder<String, String, String?, Int?, AssetType?, Result<Unit>> { _, _, _, _, _ ->
val sendLocationResult = lambdaRecorder<String, String, String?, Int?, AssetType?, ReplyParameters?, Result<Unit>> { _, _, _, _, _, _ ->
Result.success(Unit)
}
val joinedRoom = FakeJoinedRoom(
@ -310,6 +311,7 @@ class SendLocationPresenterTest {
value(null),
value(15),
value(AssetType.SENDER),
value(null),
)
assertThat(fakeAnalyticsService.capturedEvents.size).isEqualTo(1)
@ -326,7 +328,7 @@ class SendLocationPresenterTest {
@Test
fun `share pin location`() = runTest {
val sendLocationResult = lambdaRecorder<String, String, String?, Int?, AssetType?, Result<Unit>> { _, _, _, _, _ ->
val sendLocationResult = lambdaRecorder<String, String, String?, Int?, AssetType?, ReplyParameters?, Result<Unit>> { _, _, _, _, _, _ ->
Result.success(Unit)
}
val joinedRoom = FakeJoinedRoom(
@ -373,6 +375,7 @@ class SendLocationPresenterTest {
value(null),
value(15),
value(AssetType.PIN),
value(null),
)
assertThat(fakeAnalyticsService.capturedEvents.size).isEqualTo(1)
@ -389,7 +392,7 @@ class SendLocationPresenterTest {
@Test
fun `composer context passes through analytics`() = runTest {
val sendLocationResult = lambdaRecorder<String, String, String?, Int?, AssetType?, Result<Unit>> { _, _, _, _, _ ->
val sendLocationResult = lambdaRecorder<String, String, String?, Int?, AssetType?, ReplyParameters?, Result<Unit>> { _, _, _, _, _, _ ->
Result.success(Unit)
}
val joinedRoom = FakeJoinedRoom(

5
features/messages/impl/src/main/kotlin/io/element/android/features/messages/impl/draft/ComposerDraftService.kt
View file

@ -8,9 +8,10 @@
package io.element.android.features.messages.impl.draft
import io.element.android.libraries.matrix.api.core.RoomId
import io.element.android.libraries.matrix.api.core.ThreadId
import io.element.android.libraries.matrix.api.room.draft.ComposerDraft
interface ComposerDraftService {
suspend fun loadDraft(roomId: RoomId, isVolatile: Boolean): ComposerDraft?
suspend fun updateDraft(roomId: RoomId, draft: ComposerDraft?, isVolatile: Boolean)
suspend fun loadDraft(roomId: RoomId, threadRoot: ThreadId?, isVolatile: Boolean): ComposerDraft?
suspend fun updateDraft(roomId: RoomId, threadRoot: ThreadId?, draft: ComposerDraft?, isVolatile: Boolean)
}

5
features/messages/impl/src/main/kotlin/io/element/android/features/messages/impl/draft/ComposerDraftStore.kt
View file

@ -8,9 +8,10 @@
package io.element.android.features.messages.impl.draft
import io.element.android.libraries.matrix.api.core.RoomId
import io.element.android.libraries.matrix.api.core.ThreadId
import io.element.android.libraries.matrix.api.room.draft.ComposerDraft
interface ComposerDraftStore {
suspend fun loadDraft(roomId: RoomId): ComposerDraft?
suspend fun updateDraft(roomId: RoomId, draft: ComposerDraft?)
suspend fun loadDraft(roomId: RoomId, threadRoot: ThreadId?): ComposerDraft?
suspend fun updateDraft(roomId: RoomId, threadRoot: ThreadId?, draft: ComposerDraft?)
}

9
features/messages/impl/src/main/kotlin/io/element/android/features/messages/impl/draft/DefaultComposerDraftService.kt
View file

@ -10,6 +10,7 @@ package io.element.android.features.messages.impl.draft
import com.squareup.anvil.annotations.ContributesBinding
import io.element.android.libraries.di.RoomScope
import io.element.android.libraries.matrix.api.core.RoomId
import io.element.android.libraries.matrix.api.core.ThreadId
import io.element.android.libraries.matrix.api.room.draft.ComposerDraft
import javax.inject.Inject
@ -18,12 +19,12 @@ class DefaultComposerDraftService @Inject constructor(
private val volatileComposerDraftStore: VolatileComposerDraftStore,
private val matrixComposerDraftStore: MatrixComposerDraftStore,
) : ComposerDraftService {
override suspend fun loadDraft(roomId: RoomId, isVolatile: Boolean): ComposerDraft? {
return getStore(isVolatile).loadDraft(roomId)
override suspend fun loadDraft(roomId: RoomId, threadRoot: ThreadId?, isVolatile: Boolean): ComposerDraft? {
return getStore(isVolatile).loadDraft(roomId, threadRoot)
}
override suspend fun updateDraft(roomId: RoomId, draft: ComposerDraft?, isVolatile: Boolean) {
getStore(isVolatile).updateDraft(roomId, draft)
override suspend fun updateDraft(roomId: RoomId, threadRoot: ThreadId?, draft: ComposerDraft?, isVolatile: Boolean) {
getStore(isVolatile).updateDraft(roomId, threadRoot, draft)
}
private fun getStore(isVolatile: Boolean): ComposerDraftStore {

13
features/messages/impl/src/main/kotlin/io/element/android/features/messages/impl/draft/MatrixComposerDraftStore.kt
View file

@ -9,6 +9,7 @@ package io.element.android.features.messages.impl.draft
import io.element.android.libraries.matrix.api.MatrixClient
import io.element.android.libraries.matrix.api.core.RoomId
import io.element.android.libraries.matrix.api.core.ThreadId
import io.element.android.libraries.matrix.api.room.draft.ComposerDraft
import timber.log.Timber
import javax.inject.Inject
@ -20,26 +21,26 @@ import javax.inject.Inject
class MatrixComposerDraftStore @Inject constructor(
private val client: MatrixClient,
) : ComposerDraftStore {
override suspend fun loadDraft(roomId: RoomId): ComposerDraft? {
override suspend fun loadDraft(roomId: RoomId, threadRoot: ThreadId?): ComposerDraft? {
return client.getRoom(roomId)?.use { room ->
room.loadComposerDraft()
room.loadComposerDraft(threadRoot)
.onFailure {
Timber.e(it, "Failed to load composer draft for room $roomId")
}
.onSuccess { draft ->
room.clearComposerDraft()
room.clearComposerDraft(threadRoot)
Timber.d("Loaded composer draft for room $roomId : $draft")
}
.getOrNull()
}
}
override suspend fun updateDraft(roomId: RoomId, draft: ComposerDraft?) {
override suspend fun updateDraft(roomId: RoomId, threadRoot: ThreadId?, draft: ComposerDraft?) {
client.getRoom(roomId)?.use { room ->
val updateDraftResult = if (draft == null) {
room.clearComposerDraft()
room.clearComposerDraft(threadRoot)
} else {
room.saveComposerDraft(draft)
room.saveComposerDraft(draft, threadRoot)
}
updateDraftResult
.onFailure {

15
features/messages/impl/src/main/kotlin/io/element/android/features/messages/impl/draft/VolatileComposerDraftStore.kt
View file

@ -8,6 +8,7 @@
package io.element.android.features.messages.impl.draft
import io.element.android.libraries.matrix.api.core.RoomId
import io.element.android.libraries.matrix.api.core.ThreadId
import io.element.android.libraries.matrix.api.room.draft.ComposerDraft
import javax.inject.Inject
@ -17,18 +18,20 @@ import javax.inject.Inject
* Currently it's used to store draft message when moving to edit mode.
*/
class VolatileComposerDraftStore @Inject constructor() : ComposerDraftStore {
private val drafts: MutableMap<RoomId, ComposerDraft> = mutableMapOf()
private val drafts: MutableMap<String, ComposerDraft> = mutableMapOf()
override suspend fun loadDraft(roomId: RoomId): ComposerDraft? {
override suspend fun loadDraft(roomId: RoomId, threadRoot: ThreadId?): ComposerDraft? {
val key = threadRoot?.value ?: roomId.value
// Remove the draft from the map when it is loaded
return drafts.remove(roomId)
return drafts.remove(key)
}
override suspend fun updateDraft(roomId: RoomId, draft: ComposerDraft?) {
override suspend fun updateDraft(roomId: RoomId, threadRoot: ThreadId?, draft: ComposerDraft?) {
val key = threadRoot?.value ?: roomId.value
if (draft == null) {
drafts.remove(roomId)
drafts.remove(key)
} else {
drafts[roomId] = draft
drafts[key] = draft
}
}
}

18
features/messages/impl/src/main/kotlin/io/element/android/features/messages/impl/messagecomposer/MessageComposerPresenter.kt
View file

@ -219,7 +219,12 @@ class MessageComposerPresenter @AssistedInject constructor(
)
LaunchedEffect(Unit) {
val draft = draftService.loadDraft(room.roomId, isVolatile = false)
val draft = draftService.loadDraft(
roomId = room.roomId,
// TODO support threads in composer
threadRoot = null,
isVolatile = false
)
if (draft != null) {
applyDraft(draft, markdownTextEditorState, richTextEditorState)
}
@ -539,7 +544,9 @@ class MessageComposerPresenter @AssistedInject constructor(
draftService.updateDraft(
roomId = room.roomId,
draft = draft,
isVolatile = isVolatile
isVolatile = isVolatile,
// TODO support threads in composer
threadRoot = null,
)
}
@ -700,7 +707,12 @@ class MessageComposerPresenter @AssistedInject constructor(
fromEdit: Boolean,
) {
// Use the volatile draft only when coming from edit mode otherwise.
val draft = draftService.loadDraft(room.roomId, isVolatile = true).takeIf { fromEdit }
val draft = draftService.loadDraft(
roomId = room.roomId,
// TODO support threads in composer
threadRoot = null,
isVolatile = true
).takeIf { fromEdit }
if (draft != null) {
applyDraft(draft, markdownTextEditorState, richTextEditorState)
} else {

7
features/messages/impl/src/main/kotlin/io/element/android/features/messages/impl/timeline/components/MessageShieldView.kt
View file

@ -80,6 +80,7 @@ internal fun MessageShield.toText(): String {
is MessageShield.UnverifiedIdentity -> CommonStrings.event_shield_reason_unverified_identity
is MessageShield.SentInClear -> CommonStrings.event_shield_reason_sent_in_clear
is MessageShield.VerificationViolation -> CommonStrings.event_shield_reason_previously_verified
is MessageShield.MismatchedSender -> CommonStrings.event_shield_mismatched_sender
}
)
}
@ -91,7 +92,8 @@ internal fun MessageShield.toIcon(): ImageVector {
is MessageShield.UnknownDevice,
is MessageShield.UnsignedDevice,
is MessageShield.UnverifiedIdentity,
is MessageShield.VerificationViolation -> CompoundIcons.HelpSolid()
is MessageShield.VerificationViolation,
is MessageShield.MismatchedSender -> CompoundIcons.HelpSolid()
is MessageShield.SentInClear -> CompoundIcons.LockOff()
}
}
@ -122,6 +124,9 @@ internal fun MessageShieldViewPreview() {
MessageShieldView(
shield = MessageShield.VerificationViolation(false)
)
MessageShieldView(
shield = MessageShield.MismatchedSender(false)
)
}
}
}

18
features/messages/impl/src/test/kotlin/io/element/android/features/messages/impl/draft/FakeComposerDraftService.kt
View file

@ -8,12 +8,22 @@
package io.element.android.features.messages.impl.draft
import io.element.android.libraries.matrix.api.core.RoomId
import io.element.android.libraries.matrix.api.core.ThreadId
import io.element.android.libraries.matrix.api.room.draft.ComposerDraft
class FakeComposerDraftService : ComposerDraftService {
var loadDraftLambda: (RoomId, Boolean) -> ComposerDraft? = { _, _ -> null }
override suspend fun loadDraft(roomId: RoomId, isVolatile: Boolean): ComposerDraft? = loadDraftLambda(roomId, isVolatile)
var loadDraftLambda: (RoomId, ThreadId?, Boolean) -> ComposerDraft? = { _, _, _ -> null }
override suspend fun loadDraft(
roomId: RoomId,
threadRoot: ThreadId?,
isVolatile: Boolean
): ComposerDraft? = loadDraftLambda(roomId, threadRoot, isVolatile)
var saveDraftLambda: (RoomId, ComposerDraft?, Boolean) -> Unit = { _, _, _ -> }
override suspend fun updateDraft(roomId: RoomId, draft: ComposerDraft?, isVolatile: Boolean) = saveDraftLambda(roomId, draft, isVolatile)
var saveDraftLambda: (RoomId, ThreadId?, ComposerDraft?, Boolean) -> Unit = { _, _, _, _ -> }
override suspend fun updateDraft(
roomId: RoomId,
threadRoot: ThreadId?,
draft: ComposerDraft?,
isVolatile: Boolean
) = saveDraftLambda(roomId, threadRoot, draft, isVolatile)
}

41
features/messages/impl/src/test/kotlin/io/element/android/features/messages/impl/draft/VolatileComposerDraftStoreTest.kt
View file

@ -11,6 +11,7 @@ import com.google.common.truth.Truth.assertThat
import io.element.android.libraries.matrix.api.room.draft.ComposerDraft
import io.element.android.libraries.matrix.api.room.draft.ComposerDraftType
import io.element.android.libraries.matrix.test.A_ROOM_ID
import io.element.android.libraries.matrix.test.A_THREAD_ID
import kotlinx.coroutines.test.runTest
import org.junit.Test
@ -21,27 +22,51 @@ class VolatileComposerDraftStoreTest {
@Test
fun `when storing a non-null draft and then loading it, it's loaded and removed`() = runTest {
val initialDraft = sut.loadDraft(roomId)
val initialDraft = sut.loadDraft(roomId = roomId, threadRoot = null)
assertThat(initialDraft).isNull()
sut.updateDraft(roomId, draft)
sut.updateDraft(roomId = roomId, threadRoot = null, draft = draft)
val loadedDraft = sut.loadDraft(roomId)
val loadedDraft = sut.loadDraft(roomId = roomId, threadRoot = null)
assertThat(loadedDraft).isEqualTo(draft)
val loadedDraftAfter = sut.loadDraft(roomId)
val loadedDraftAfter = sut.loadDraft(roomId = roomId, threadRoot = null)
assertThat(loadedDraftAfter).isNull()
// In thread:
val threadRoot = A_THREAD_ID
val initialThreadDraft = sut.loadDraft(roomId = roomId, threadRoot = threadRoot)
assertThat(initialThreadDraft).isNull()
sut.updateDraft(roomId = roomId, threadRoot = threadRoot, draft = draft)
val loadedThreadDraft = sut.loadDraft(roomId = roomId, threadRoot = threadRoot)
assertThat(loadedThreadDraft).isEqualTo(draft)
val loadedThreadDraftAfter = sut.loadDraft(roomId = roomId, threadRoot = threadRoot)
assertThat(loadedThreadDraftAfter).isNull()
}
@Test
fun `when storing a null draft and then loading it, it's removing the previous one`() = runTest {
val initialDraft = sut.loadDraft(roomId)
val initialDraft = sut.loadDraft(roomId = roomId, threadRoot = null)
assertThat(initialDraft).isNull()
sut.updateDraft(roomId, draft)
sut.updateDraft(roomId, null)
sut.updateDraft(roomId = roomId, threadRoot = null, draft = draft)
sut.updateDraft(roomId = roomId, threadRoot = null, draft = null)
val loadedDraft = sut.loadDraft(roomId)
val loadedDraft = sut.loadDraft(roomId = roomId, threadRoot = null)
assertThat(loadedDraft).isNull()
// In thread:
val threadRoot = A_THREAD_ID
val initialThreadDraft = sut.loadDraft(roomId = roomId, threadRoot = threadRoot)
assertThat(initialThreadDraft).isNull()
sut.updateDraft(roomId = roomId, threadRoot = threadRoot, draft = draft)
sut.updateDraft(roomId = roomId, threadRoot = threadRoot, draft = null)
val loadedThreadDraft = sut.loadDraft(roomId = roomId, threadRoot = threadRoot)
assertThat(loadedThreadDraft).isNull()
}
}

60
features/messages/impl/src/test/kotlin/io/element/android/features/messages/impl/messagecomposer/MessageComposerPresenterTest.kt
View file

@ -37,6 +37,7 @@ import io.element.android.libraries.featureflag.api.FeatureFlags
import io.element.android.libraries.featureflag.test.FakeFeatureFlagService
import io.element.android.libraries.matrix.api.core.EventId
import io.element.android.libraries.matrix.api.core.RoomId
import io.element.android.libraries.matrix.api.core.ThreadId
import io.element.android.libraries.matrix.api.media.ImageInfo
import io.element.android.libraries.matrix.api.media.VideoInfo
import io.element.android.libraries.matrix.api.permalink.PermalinkBuilder
@ -178,10 +179,10 @@ class MessageComposerPresenterTest {
@Test
fun `present - change mode to edit`() = runTest {
val loadDraftLambda = lambdaRecorder { _: RoomId, _: Boolean ->
val loadDraftLambda = lambdaRecorder { _: RoomId, _: ThreadId?, _: Boolean ->
ComposerDraft(A_MESSAGE, A_MESSAGE, ComposerDraftType.NewMessage)
}
val updateDraftLambda = lambdaRecorder { _: RoomId, _: ComposerDraft?, _: Boolean -> }
val updateDraftLambda = lambdaRecorder { _: RoomId, _: ThreadId?, _: ComposerDraft?, _: Boolean -> }
val draftService = FakeComposerDraftService().apply {
this.loadDraftLambda = loadDraftLambda
this.saveDraftLambda = updateDraftLambda
@ -207,23 +208,23 @@ class MessageComposerPresenterTest {
.isCalledExactly(2)
.withSequence(
// Automatic load of draft
listOf(value(A_ROOM_ID), value(false)),
listOf(value(A_ROOM_ID), value(null), value(false)),
// Load of volatile draft when closing edit mode
listOf(value(A_ROOM_ID), value(true))
listOf(value(A_ROOM_ID), value(null), value(true))
)
assert(updateDraftLambda)
.isCalledOnce()
.with(value(A_ROOM_ID), any(), value(true))
.with(value(A_ROOM_ID), value(null), any(), value(true))
}
}
@Test
fun `present - change mode to edit caption`() = runTest {
val loadDraftLambda = lambdaRecorder { _: RoomId, _: Boolean ->
val loadDraftLambda = lambdaRecorder { _: RoomId, _: ThreadId?, _: Boolean ->
ComposerDraft(A_MESSAGE, A_MESSAGE, ComposerDraftType.NewMessage)
}
val updateDraftLambda = lambdaRecorder { _: RoomId, _: ComposerDraft?, _: Boolean -> }
val updateDraftLambda = lambdaRecorder { _: RoomId, _: ThreadId?, _: ComposerDraft?, _: Boolean -> }
val draftService = FakeComposerDraftService().apply {
this.loadDraftLambda = loadDraftLambda
this.saveDraftLambda = updateDraftLambda
@ -249,13 +250,13 @@ class MessageComposerPresenterTest {
.isCalledExactly(2)
.withSequence(
// Automatic load of draft
listOf(value(A_ROOM_ID), value(false)),
listOf(value(A_ROOM_ID), value(null), value(false)),
// Load of volatile draft when closing edit mode
listOf(value(A_ROOM_ID), value(true))
listOf(value(A_ROOM_ID), value(null), value(true))
)
assert(updateDraftLambda)
.isCalledOnce()
.with(value(A_ROOM_ID), any(), value(true))
.with(value(A_ROOM_ID), value(null), any(), value(true))
}
}
@ -303,10 +304,10 @@ class MessageComposerPresenterTest {
@Test
fun `present - change mode to reply after edit`() = runTest {
val loadDraftLambda = lambdaRecorder { _: RoomId, _: Boolean ->
val loadDraftLambda = lambdaRecorder { _: RoomId, _: ThreadId?, _: Boolean ->
ComposerDraft(A_MESSAGE, A_MESSAGE, ComposerDraftType.NewMessage)
}
val updateDraftLambda = lambdaRecorder { _: RoomId, _: ComposerDraft?, _: Boolean -> }
val updateDraftLambda = lambdaRecorder { _: RoomId, _: ThreadId?, _: ComposerDraft?, _: Boolean -> }
val draftService = FakeComposerDraftService().apply {
this.loadDraftLambda = loadDraftLambda
this.saveDraftLambda = updateDraftLambda
@ -333,11 +334,11 @@ class MessageComposerPresenterTest {
assert(loadDraftLambda)
.isCalledOnce()
.with(value(A_ROOM_ID), value(false))
.with(value(A_ROOM_ID), value(null), value(false))
assert(updateDraftLambda)
.isCalledOnce()
.with(value(A_ROOM_ID), any(), value(true))
.with(value(A_ROOM_ID), value(null), any(), value(true))
}
}
@ -1246,7 +1247,7 @@ class MessageComposerPresenterTest {
@Test
fun `present - when there is no draft, nothing is restored`() = runTest {
val loadDraftLambda = lambdaRecorder<RoomId, Boolean, ComposerDraft?> { _, _ -> null }
val loadDraftLambda = lambdaRecorder<RoomId, ThreadId?, Boolean, ComposerDraft?> { _, _, _ -> null }
val composerDraftService = FakeComposerDraftService().apply {
this.loadDraftLambda = loadDraftLambda
}
@ -1257,7 +1258,7 @@ class MessageComposerPresenterTest {
awaitFirstItem()
assert(loadDraftLambda)
.isCalledOnce()
.with(value(A_ROOM_ID), value(false))
.with(value(A_ROOM_ID), value(null), value(false))
ensureAllEventsConsumed()
}
@ -1265,7 +1266,7 @@ class MessageComposerPresenterTest {
@Test
fun `present - when there is a draft for new message with plain text, it is restored`() = runTest {
val loadDraftLambda = lambdaRecorder<RoomId, Boolean, ComposerDraft?> { _, _ ->
val loadDraftLambda = lambdaRecorder<RoomId, ThreadId?, Boolean, ComposerDraft?> { _, _, _ ->
ComposerDraft(plainText = A_MESSAGE, htmlText = null, draftType = ComposerDraftType.NewMessage)
}
val composerDraftService = FakeComposerDraftService().apply {
@ -1286,7 +1287,7 @@ class MessageComposerPresenterTest {
}
assert(loadDraftLambda)
.isCalledOnce()
.with(value(A_ROOM_ID), value(false))
.with(value(A_ROOM_ID), value(null), value(false))
ensureAllEventsConsumed()
}
@ -1294,7 +1295,7 @@ class MessageComposerPresenterTest {
@Test
fun `present - when there is a draft for new message with rich text, it is restored`() = runTest {
val loadDraftLambda = lambdaRecorder<RoomId, Boolean, ComposerDraft?> { _, _ ->
val loadDraftLambda = lambdaRecorder<RoomId, ThreadId?, Boolean, ComposerDraft?> { _, _, _ ->
ComposerDraft(
plainText = A_MESSAGE,
htmlText = A_MESSAGE,
@ -1320,14 +1321,14 @@ class MessageComposerPresenterTest {
}
assert(loadDraftLambda)
.isCalledOnce()
.with(value(A_ROOM_ID), value(false))
.with(value(A_ROOM_ID), value(null), value(false))
ensureAllEventsConsumed()
}
}
@Test
fun `present - when there is a draft for edit, it is restored`() = runTest {
val loadDraftLambda = lambdaRecorder<RoomId, Boolean, ComposerDraft?> { _, _ ->
val loadDraftLambda = lambdaRecorder<RoomId, ThreadId?, Boolean, ComposerDraft?> { _, _, _ ->
ComposerDraft(
plainText = A_MESSAGE,
htmlText = null,
@ -1354,7 +1355,7 @@ class MessageComposerPresenterTest {
}
assert(loadDraftLambda)
.isCalledOnce()
.with(value(A_ROOM_ID), value(false))
.with(value(A_ROOM_ID), value(null), value(false))
ensureAllEventsConsumed()
}
@ -1362,7 +1363,7 @@ class MessageComposerPresenterTest {
@Test
fun `present - when there is a draft for reply, it is restored`() = runTest {
val loadDraftLambda = lambdaRecorder<RoomId, Boolean, ComposerDraft?> { _, _ ->
val loadDraftLambda = lambdaRecorder<RoomId, ThreadId?, Boolean, ComposerDraft?> { _, _, _ ->
ComposerDraft(
plainText = A_MESSAGE,
htmlText = null,
@ -1400,7 +1401,7 @@ class MessageComposerPresenterTest {
}
assert(loadDraftLambda)
.isCalledOnce()
.with(value(A_ROOM_ID), value(false))
.with(value(A_ROOM_ID), value(null), value(false))
assert(loadReplyDetailsLambda)
.isCalledOnce()
@ -1412,7 +1413,7 @@ class MessageComposerPresenterTest {
@Test
fun `present - when save draft event is invoked and composer is empty then service is called with null draft`() = runTest {
val saveDraftLambda = lambdaRecorder<RoomId, ComposerDraft?, Boolean, Unit> { _, _, _ -> }
val saveDraftLambda = lambdaRecorder<RoomId, ThreadId?, ComposerDraft?, Boolean, Unit> { _, _, _, _ -> }
val composerDraftService = FakeComposerDraftService().apply {
this.saveDraftLambda = saveDraftLambda
}
@ -1425,13 +1426,13 @@ class MessageComposerPresenterTest {
advanceUntilIdle()
assert(saveDraftLambda)
.isCalledOnce()
.with(value(A_ROOM_ID), value(null), value(false))
.with(value(A_ROOM_ID), value(null), value(null), value(false))
}
}
@Test
fun `present - when save draft event is invoked and composer is not empty then service is called`() = runTest {
val saveDraftLambda = lambdaRecorder<RoomId, ComposerDraft?, Boolean, Unit> { _, _, _ -> }
val saveDraftLambda = lambdaRecorder<RoomId, ThreadId?, ComposerDraft?, Boolean, Unit> { _, _, _, _ -> }
val composerDraftService = FakeComposerDraftService().apply {
this.saveDraftLambda = saveDraftLambda
}
@ -1478,27 +1479,32 @@ class MessageComposerPresenterTest {
.withSequence(
listOf(
value(A_ROOM_ID),
value(null),
value(ComposerDraft(plainText = A_MESSAGE, htmlText = null, draftType = ComposerDraftType.NewMessage)),
value(false)
),
listOf(
value(A_ROOM_ID),
value(null),
value(ComposerDraft(plainText = A_MESSAGE, htmlText = A_MESSAGE, draftType = ComposerDraftType.NewMessage)),
value(false)
),
listOf(
value(A_ROOM_ID),
value(null),
value(ComposerDraft(plainText = A_MESSAGE, htmlText = A_MESSAGE, draftType = ComposerDraftType.NewMessage)),
// The volatile draft created when switching to edit mode.
value(true)
),
listOf(
value(A_ROOM_ID),
value(null),
value(ComposerDraft(plainText = A_MESSAGE, htmlText = A_MESSAGE, draftType = ComposerDraftType.Edit(AN_EVENT_ID))),
value(false)
),
listOf(
value(A_ROOM_ID),
value(null),
// When moving from edit mode, text composer is cleared, so the draft is null
value(null),
value(false)