Rename processMessageItem to simple format

features/roomlist/impl/src/main/kotlin/io/element/android/features/roomlist/impl/RoomListPresenter.kt

@@ -200,7 +200,7 @@ class RoomListPresenter @Inject constructor(
                         hasUnread = roomSummary.details.unreadNotificationCount > 0,
                         timestamp = lastMessageTimestampFormatter.format(roomSummary.details.lastMessageTimestamp),
                         lastMessage = roomSummary.details.lastMessage?.let { message ->
-                            roomLastMessageFormatter.processMessageItem(message.event, roomSummary.details.isDirect)
+                            roomLastMessageFormatter.format(message.event, roomSummary.details.isDirect)
                         }.orEmpty(),
                         avatarData = avatarData,
                     )

libraries/eventformatter/api/src/main/kotlin/io/element/android/libraries/eventformatter/api/RoomLastMessageFormatter.kt

@@ -19,5 +19,5 @@ package io.element.android.libraries.eventformatter.api
 import io.element.android.libraries.matrix.api.timeline.item.event.EventTimelineItem
 
 interface RoomLastMessageFormatter {
-    fun processMessageItem(event: EventTimelineItem, isDmRoom: Boolean): CharSequence?
+    fun format(event: EventTimelineItem, isDmRoom: Boolean): CharSequence?
 }

libraries/eventformatter/impl/src/main/kotlin/io/element/android/libraries/eventformatter/impl/DefaultRoomLastMessageFormatter.kt

@@ -59,7 +59,7 @@ class DefaultRoomLastMessageFormatter @Inject constructor(
     private val matrixClient: MatrixClient,
 ) : RoomLastMessageFormatter {
 
-    override fun processMessageItem(event: EventTimelineItem, isDmRoom: Boolean): CharSequence? {
+    override fun format(event: EventTimelineItem, isDmRoom: Boolean): CharSequence? {
         val isOutgoing = event.sender == matrixClient.sessionId
         val senderDisplayName = (event.senderProfile as? ProfileTimelineDetails.Ready)?.displayName ?: event.sender.value
         return when (val content = event.content) {

libraries/eventformatter/impl/src/test/kotlin/io/element/android/libraries/eventformatter/impl/DefaultRoomLastMessageFormatterTests.kt

@@ -77,7 +77,7 @@ class DefaultRoomLastMessageFormatterTests {
         val senderName = "Someone"
         sequenceOf(false, true).forEach { isDm ->
             val message = createRoomEvent(false, senderName, RedactedContent)
-            val result = formatter.processMessageItem(message, isDm)
+            val result = formatter.format(message, isDm)
             if (isDm) {
                 Truth.assertThat(result).isEqualTo(expected)
             } else {
@@ -93,7 +93,7 @@ class DefaultRoomLastMessageFormatterTests {
         val body = "body"
         val info = ImageInfo(null, null, null, null, null, null, null)
         val message = createRoomEvent(false, null, StickerContent(body, info, "url"))
-        val result = formatter.processMessageItem(message, false)
+        val result = formatter.format(message, false)
         Truth.assertThat(result).isEqualTo(body)
     }
 
@@ -104,7 +104,7 @@ class DefaultRoomLastMessageFormatterTests {
         val senderName = "Someone"
         sequenceOf(false, true).forEach { isDm ->
             val message = createRoomEvent(false, senderName, UnableToDecryptContent(UnableToDecryptContent.Data.Unknown))
-            val result = formatter.processMessageItem(message, isDm)
+            val result = formatter.format(message, isDm)
             if (isDm) {
                 Truth.assertThat(result).isEqualTo(expected)
             } else {
@@ -126,7 +126,7 @@ class DefaultRoomLastMessageFormatterTests {
                 UnknownContent,
             ).forEach { type ->
                 val message = createRoomEvent(false, senderName, type)
-                val result = formatter.processMessageItem(message, isDm)
+                val result = formatter.format(message, isDm)
                 if (isDm) {
                     Truth.assertWithMessage("$type was not properly handled").that(result).isEqualTo(expected)
                 } else {
@@ -165,7 +165,7 @@ class DefaultRoomLastMessageFormatterTests {
             sharedContentMessagesTypes.forEach { type ->
                 val content = createMessageContent(type)
                 val message = createRoomEvent(sentByYou = false, senderDisplayName = "Someone", content = content)
-                val result = formatter.processMessageItem(message, isDmRoom = isDm)
+                val result = formatter.format(message, isDmRoom = isDm)
                 if (isDm) {
                     resultsInDm.add(type to result)
                 } else {
@@ -173,7 +173,7 @@ class DefaultRoomLastMessageFormatterTests {
                 }
             }
             val unknownMessage = createRoomEvent(sentByYou = false, senderDisplayName = "Someone", content = createMessageContent(UnknownMessageType))
-            val result = UnknownMessageType to formatter.processMessageItem(unknownMessage, isDmRoom = isDm)
+            val result = UnknownMessageType to formatter.format(unknownMessage, isDmRoom = isDm)
             if (isDm) {
                 resultsInDm.add(result)
             } else {
@@ -237,11 +237,11 @@ class DefaultRoomLastMessageFormatterTests {
         val someoneContent = RoomMembershipContent(UserId("@someone_else:domain"), MembershipChange.JOINED)
 
         val youJoinedRoomEvent = createRoomEvent(sentByYou = true, senderDisplayName = null, content = youContent)
-        val youJoinedRoom = formatter.processMessageItem(youJoinedRoomEvent, false)
+        val youJoinedRoom = formatter.format(youJoinedRoomEvent, false)
         Truth.assertThat(youJoinedRoom).isEqualTo("You joined the room")
 
         val someoneJoinedRoomEvent = createRoomEvent(sentByYou = false, senderDisplayName = otherName, content = someoneContent)
-        val someoneJoinedRoom = formatter.processMessageItem(someoneJoinedRoomEvent, false)
+        val someoneJoinedRoom = formatter.format(someoneJoinedRoomEvent, false)
         Truth.assertThat(someoneJoinedRoom).isEqualTo("${someoneContent.userId} joined the room")
     }
 
@@ -253,11 +253,11 @@ class DefaultRoomLastMessageFormatterTests {
         val someoneContent = RoomMembershipContent(UserId("@someone_else:domain"), MembershipChange.LEFT)
 
         val youLeftRoomEvent = createRoomEvent(sentByYou = true, senderDisplayName = null, content = youContent)
-        val youLeftRoom = formatter.processMessageItem(youLeftRoomEvent, false)
+        val youLeftRoom = formatter.format(youLeftRoomEvent, false)
         Truth.assertThat(youLeftRoom).isEqualTo("You left the room")
 
         val someoneLeftRoomEvent = createRoomEvent(sentByYou = false, senderDisplayName = otherName, content = someoneContent)
-        val someoneLeftRoom = formatter.processMessageItem(someoneLeftRoomEvent, false)
+        val someoneLeftRoom = formatter.format(someoneLeftRoomEvent, false)
         Truth.assertThat(someoneLeftRoom).isEqualTo("${someoneContent.userId} left the room")
     }
 
@@ -271,19 +271,19 @@ class DefaultRoomLastMessageFormatterTests {
         val someoneKickedContent = RoomMembershipContent(UserId("@someone_else:domain"), MembershipChange.KICKED_AND_BANNED)
 
         val youBannedEvent = createRoomEvent(sentByYou = true, senderDisplayName = null, content = youContent)
-        val youBanned = formatter.processMessageItem(youBannedEvent, false)
+        val youBanned = formatter.format(youBannedEvent, false)
         Truth.assertThat(youBanned).isEqualTo("You banned ${youContent.userId}")
 
         val youKickBannedEvent = createRoomEvent(sentByYou = true, senderDisplayName = null, content = youKickedContent)
-        val youKickedBanned = formatter.processMessageItem(youKickBannedEvent, false)
+        val youKickedBanned = formatter.format(youKickBannedEvent, false)
         Truth.assertThat(youKickedBanned).isEqualTo("You banned ${youContent.userId}")
 
         val someoneBannedEvent = createRoomEvent(sentByYou = false, senderDisplayName = otherName, content = someoneContent)
-        val someoneBanned = formatter.processMessageItem(someoneBannedEvent, false)
+        val someoneBanned = formatter.format(someoneBannedEvent, false)
         Truth.assertThat(someoneBanned).isEqualTo("$otherName banned ${someoneContent.userId}")
 
         val someoneKickBannedEvent = createRoomEvent(sentByYou = false, senderDisplayName = otherName, content = someoneKickedContent)
-        val someoneKickBanned = formatter.processMessageItem(someoneKickBannedEvent, false)
+        val someoneKickBanned = formatter.format(someoneKickBannedEvent, false)
         Truth.assertThat(someoneKickBanned).isEqualTo("$otherName banned ${someoneContent.userId}")
     }
 
@@ -295,11 +295,11 @@ class DefaultRoomLastMessageFormatterTests {
         val someoneContent = RoomMembershipContent(UserId("@someone_else:domain"), MembershipChange.UNBANNED)
 
         val youUnbannedEvent = createRoomEvent(sentByYou = true, senderDisplayName = null, content = youContent)
-        val youUnbanned = formatter.processMessageItem(youUnbannedEvent, false)
+        val youUnbanned = formatter.format(youUnbannedEvent, false)
         Truth.assertThat(youUnbanned).isEqualTo("You unbanned ${youContent.userId}")
 
         val someoneUnbannedEvent = createRoomEvent(sentByYou = false, senderDisplayName = otherName, content = someoneContent)
-        val someoneUnbanned = formatter.processMessageItem(someoneUnbannedEvent, false)
+        val someoneUnbanned = formatter.format(someoneUnbannedEvent, false)
         Truth.assertThat(someoneUnbanned).isEqualTo("$otherName unbanned ${someoneContent.userId}")
     }
 
@@ -311,11 +311,11 @@ class DefaultRoomLastMessageFormatterTests {
         val someoneContent = RoomMembershipContent(UserId("@someone_else:domain"), MembershipChange.KICKED)
 
         val youKickedEvent = createRoomEvent(sentByYou = true, senderDisplayName = null, content = youContent)
-        val youKicked = formatter.processMessageItem(youKickedEvent, false)
+        val youKicked = formatter.format(youKickedEvent, false)
         Truth.assertThat(youKicked).isEqualTo("You removed ${youContent.userId}")
 
         val someoneKickedEvent = createRoomEvent(sentByYou = false, senderDisplayName = otherName, content = someoneContent)
-        val someoneKicked = formatter.processMessageItem(someoneKickedEvent, false)
+        val someoneKicked = formatter.format(someoneKickedEvent, false)
         Truth.assertThat(someoneKicked).isEqualTo("$otherName removed ${someoneContent.userId}")
     }
 
@@ -327,15 +327,15 @@ class DefaultRoomLastMessageFormatterTests {
         val someoneContent = RoomMembershipContent(UserId("@someone_else:domain"), MembershipChange.INVITED)
 
         val youWereInvitedEvent = createRoomEvent(sentByYou = false, senderDisplayName = otherName, content = youContent)
-        val youWereInvited = formatter.processMessageItem(youWereInvitedEvent, false)
+        val youWereInvited = formatter.format(youWereInvitedEvent, false)
         Truth.assertThat(youWereInvited).isEqualTo("$otherName invited you")
 
         val youInvitedEvent = createRoomEvent(sentByYou = true, senderDisplayName = null, content = someoneContent)
-        val youInvited = formatter.processMessageItem(youInvitedEvent, false)
+        val youInvited = formatter.format(youInvitedEvent, false)
         Truth.assertThat(youInvited).isEqualTo("You invited ${someoneContent.userId}")
 
         val someoneInvitedEvent = createRoomEvent(sentByYou = false, senderDisplayName = otherName, content = someoneContent)
-        val someoneInvited = formatter.processMessageItem(someoneInvitedEvent, false)
+        val someoneInvited = formatter.format(someoneInvitedEvent, false)
         Truth.assertThat(someoneInvited).isEqualTo("$otherName invited ${someoneContent.userId}")
     }
 
@@ -347,11 +347,11 @@ class DefaultRoomLastMessageFormatterTests {
         val someoneContent = RoomMembershipContent(UserId("@someone_else:domain"), MembershipChange.INVITATION_ACCEPTED)
 
         val youAcceptedInviteEvent = createRoomEvent(sentByYou = true, senderDisplayName = null, content = youContent)
-        val youAcceptedInvite = formatter.processMessageItem(youAcceptedInviteEvent, false)
+        val youAcceptedInvite = formatter.format(youAcceptedInviteEvent, false)
         Truth.assertThat(youAcceptedInvite).isEqualTo("You accepted the invite")
 
         val someoneAcceptedInviteEvent = createRoomEvent(sentByYou = false, senderDisplayName = otherName, content = someoneContent)
-        val someoneAcceptedInvite = formatter.processMessageItem(someoneAcceptedInviteEvent, false)
+        val someoneAcceptedInvite = formatter.format(someoneAcceptedInviteEvent, false)
         Truth.assertThat(someoneAcceptedInvite).isEqualTo("${someoneContent.userId} accepted the invite")
     }
 
@@ -363,11 +363,11 @@ class DefaultRoomLastMessageFormatterTests {
         val someoneContent = RoomMembershipContent(UserId("@someone_else:domain"), MembershipChange.INVITATION_REJECTED)
 
         val youRejectedInviteEvent = createRoomEvent(sentByYou = true, senderDisplayName = null, content = youContent)
-        val youRejectedInvite = formatter.processMessageItem(youRejectedInviteEvent, false)
+        val youRejectedInvite = formatter.format(youRejectedInviteEvent, false)
         Truth.assertThat(youRejectedInvite).isEqualTo("You rejected the invitation")
 
         val someoneRejectedInviteEvent = createRoomEvent(sentByYou = false, senderDisplayName = otherName, content = someoneContent)
-        val someoneRejectedInvite = formatter.processMessageItem(someoneRejectedInviteEvent, false)
+        val someoneRejectedInvite = formatter.format(someoneRejectedInviteEvent, false)
         Truth.assertThat(someoneRejectedInvite).isEqualTo("${someoneContent.userId} rejected the invitation")
     }
 
@@ -378,11 +378,11 @@ class DefaultRoomLastMessageFormatterTests {
         val someoneContent = RoomMembershipContent(UserId("@someone_else:domain"), MembershipChange.INVITATION_REVOKED)
 
         val youRevokedInviteEvent = createRoomEvent(sentByYou = true, senderDisplayName = null, content = someoneContent)
-        val youRevokedInvite = formatter.processMessageItem(youRevokedInviteEvent, false)
+        val youRevokedInvite = formatter.format(youRevokedInviteEvent, false)
         Truth.assertThat(youRevokedInvite).isEqualTo("You revoked the invitation for ${someoneContent.userId} to join the room")
 
         val someoneRevokedInviteEvent = createRoomEvent(sentByYou = false, senderDisplayName = otherName, content = someoneContent)
-        val someoneRevokedInvite = formatter.processMessageItem(someoneRevokedInviteEvent, false)
+        val someoneRevokedInvite = formatter.format(someoneRevokedInviteEvent, false)
         Truth.assertThat(someoneRevokedInvite).isEqualTo("$otherName revoked the invitation for ${someoneContent.userId} to join the room")
     }
 
@@ -394,11 +394,11 @@ class DefaultRoomLastMessageFormatterTests {
         val someoneContent = RoomMembershipContent(UserId("@someone_else:domain"), MembershipChange.KNOCKED)
 
         val youKnockedEvent = createRoomEvent(sentByYou = true, senderDisplayName = null, content = youContent)
-        val youKnocked = formatter.processMessageItem(youKnockedEvent, false)
+        val youKnocked = formatter.format(youKnockedEvent, false)
         Truth.assertThat(youKnocked).isEqualTo("You requested to join")
 
         val someoneKnockedEvent = createRoomEvent(sentByYou = false, senderDisplayName = otherName, content = someoneContent)
-        val someoneKnocked = formatter.processMessageItem(someoneKnockedEvent, false)
+        val someoneKnocked = formatter.format(someoneKnockedEvent, false)
         Truth.assertThat(someoneKnocked).isEqualTo("${someoneContent.userId} requested to join")
     }
 
@@ -409,11 +409,11 @@ class DefaultRoomLastMessageFormatterTests {
         val someoneContent = RoomMembershipContent(UserId("@someone_else:domain"), MembershipChange.KNOCK_ACCEPTED)
 
         val youAcceptedKnockEvent = createRoomEvent(sentByYou = true, senderDisplayName = null, content = someoneContent)
-        val youAcceptedKnock = formatter.processMessageItem(youAcceptedKnockEvent, false)
+        val youAcceptedKnock = formatter.format(youAcceptedKnockEvent, false)
         Truth.assertThat(youAcceptedKnock).isEqualTo("${someoneContent.userId} allowed you to join")
 
         val someoneAcceptedKnockEvent = createRoomEvent(sentByYou = false, senderDisplayName = otherName, content = someoneContent)
-        val someoneAcceptedKnock = formatter.processMessageItem(someoneAcceptedKnockEvent, false)
+        val someoneAcceptedKnock = formatter.format(someoneAcceptedKnockEvent, false)
         Truth.assertThat(someoneAcceptedKnock).isEqualTo("$otherName allowed ${someoneContent.userId} to join")
     }
 
@@ -425,11 +425,11 @@ class DefaultRoomLastMessageFormatterTests {
         val someoneContent = RoomMembershipContent(UserId("@someone_else:domain"), MembershipChange.KNOCK_RETRACTED)
 
         val youRetractedKnockEvent = createRoomEvent(sentByYou = true, senderDisplayName = null, content = youContent)
-        val youRetractedKnock = formatter.processMessageItem(youRetractedKnockEvent, false)
+        val youRetractedKnock = formatter.format(youRetractedKnockEvent, false)
         Truth.assertThat(youRetractedKnock).isEqualTo("You cancelled your request to join")
 
         val someoneRetractedKnockEvent = createRoomEvent(sentByYou = false, senderDisplayName = otherName, content = someoneContent)
-        val someoneRetractedKnock = formatter.processMessageItem(someoneRetractedKnockEvent, false)
+        val someoneRetractedKnock = formatter.format(someoneRetractedKnockEvent, false)
         Truth.assertThat(someoneRetractedKnock).isEqualTo("${someoneContent.userId} is no longer interested in joining")
     }
 
@@ -441,15 +441,15 @@ class DefaultRoomLastMessageFormatterTests {
         val someoneContent = RoomMembershipContent(UserId("@someone_else:domain"), MembershipChange.KNOCK_DENIED)
 
         val youDeniedKnockEvent = createRoomEvent(sentByYou = true, senderDisplayName = null, content = someoneContent)
-        val youDeniedKnock = formatter.processMessageItem(youDeniedKnockEvent, false)
+        val youDeniedKnock = formatter.format(youDeniedKnockEvent, false)
         Truth.assertThat(youDeniedKnock).isEqualTo("You rejected ${someoneContent.userId}'s request to join")
 
         val someoneDeniedKnockEvent = createRoomEvent(sentByYou = false, senderDisplayName = otherName, content = someoneContent)
-        val someoneDeniedKnock = formatter.processMessageItem(someoneDeniedKnockEvent, false)
+        val someoneDeniedKnock = formatter.format(someoneDeniedKnockEvent, false)
         Truth.assertThat(someoneDeniedKnock).isEqualTo("$otherName rejected ${someoneContent.userId}'s request to join")
 
         val someoneDeniedYourKnockEvent = createRoomEvent(sentByYou = false, senderDisplayName = otherName, content = youContent)
-        val someoneDeniedYourKnock = formatter.processMessageItem(someoneDeniedYourKnockEvent, false)
+        val someoneDeniedYourKnock = formatter.format(someoneDeniedYourKnockEvent, false)
         Truth.assertThat(someoneDeniedYourKnock).isEqualTo("$otherName rejected your request to join")
     }
 
@@ -461,7 +461,7 @@ class DefaultRoomLastMessageFormatterTests {
         val results = otherChanges.map { change ->
             val content = RoomMembershipContent(A_USER_ID, change)
             val event = createRoomEvent(sentByYou = false, senderDisplayName = "Someone", content = content)
-            val result = formatter.processMessageItem(event, false)
+            val result = formatter.format(event, false)
             change to result
         }
         val expected = otherChanges.map { it to null }
@@ -480,19 +480,19 @@ class DefaultRoomLastMessageFormatterTests {
         val removedContent = StateContent("", OtherState.RoomAvatar(null))
 
         val youChangedRoomAvatarEvent = createRoomEvent(sentByYou = true, senderDisplayName = null, content = changedContent)
-        val youChangedRoomAvatar = formatter.processMessageItem(youChangedRoomAvatarEvent, false)
+        val youChangedRoomAvatar = formatter.format(youChangedRoomAvatarEvent, false)
         Truth.assertThat(youChangedRoomAvatar).isEqualTo("You changed the room avatar")
 
         val someoneChangedRoomAvatarEvent = createRoomEvent(sentByYou = false, senderDisplayName = otherName, content = changedContent)
-        val someoneChangedRoomAvatar = formatter.processMessageItem(someoneChangedRoomAvatarEvent, false)
+        val someoneChangedRoomAvatar = formatter.format(someoneChangedRoomAvatarEvent, false)
         Truth.assertThat(someoneChangedRoomAvatar).isEqualTo("$otherName changed the room avatar")
 
         val youRemovedRoomAvatarEvent = createRoomEvent(sentByYou = true, senderDisplayName = null, content = removedContent)
-        val youRemovedRoomAvatar = formatter.processMessageItem(youRemovedRoomAvatarEvent, false)
+        val youRemovedRoomAvatar = formatter.format(youRemovedRoomAvatarEvent, false)
         Truth.assertThat(youRemovedRoomAvatar).isEqualTo("You removed the room avatar")
 
         val someoneRemovedRoomAvatarEvent = createRoomEvent(sentByYou = false, senderDisplayName = otherName, content = removedContent)
-        val someoneRemovedRoomAvatar = formatter.processMessageItem(someoneRemovedRoomAvatarEvent, false)
+        val someoneRemovedRoomAvatar = formatter.format(someoneRemovedRoomAvatarEvent, false)
         Truth.assertThat(someoneRemovedRoomAvatar).isEqualTo("$otherName removed the room avatar")
     }
 
@@ -503,11 +503,11 @@ class DefaultRoomLastMessageFormatterTests {
         val content = StateContent("", OtherState.RoomCreate)
 
         val youCreatedRoomMessage = createRoomEvent(sentByYou = true, senderDisplayName = null, content = content)
-        val youCreatedRoom = formatter.processMessageItem(youCreatedRoomMessage, false)
+        val youCreatedRoom = formatter.format(youCreatedRoomMessage, false)
         Truth.assertThat(youCreatedRoom).isEqualTo("You created the room")
 
         val someoneCreatedRoomEvent = createRoomEvent(sentByYou = false, senderDisplayName = otherName, content = content)
-        val someoneCreatedRoom = formatter.processMessageItem(someoneCreatedRoomEvent, false)
+        val someoneCreatedRoom = formatter.format(someoneCreatedRoomEvent, false)
         Truth.assertThat(someoneCreatedRoom).isEqualTo("$otherName created the room")
     }
 
@@ -518,11 +518,11 @@ class DefaultRoomLastMessageFormatterTests {
         val content = StateContent("", OtherState.RoomEncryption)
 
         val youCreatedRoomMessage = createRoomEvent(sentByYou = true, senderDisplayName = null, content = content)
-        val youCreatedRoom = formatter.processMessageItem(youCreatedRoomMessage, false)
+        val youCreatedRoom = formatter.format(youCreatedRoomMessage, false)
         Truth.assertThat(youCreatedRoom).isEqualTo("Encryption enabled")
 
         val someoneCreatedRoomEvent = createRoomEvent(sentByYou = false, senderDisplayName = otherName, content = content)
-        val someoneCreatedRoom = formatter.processMessageItem(someoneCreatedRoomEvent, false)
+        val someoneCreatedRoom = formatter.format(someoneCreatedRoomEvent, false)
         Truth.assertThat(someoneCreatedRoom).isEqualTo("Encryption enabled")
     }
 
@@ -535,19 +535,19 @@ class DefaultRoomLastMessageFormatterTests {
         val removedContent = StateContent("", OtherState.RoomName(null))
 
         val youChangedRoomNameEvent = createRoomEvent(sentByYou = true, senderDisplayName = null, content = changedContent)
-        val youChangedRoomName = formatter.processMessageItem(youChangedRoomNameEvent, false)
+        val youChangedRoomName = formatter.format(youChangedRoomNameEvent, false)
         Truth.assertThat(youChangedRoomName).isEqualTo("You changed the room name to: $newName")
 
         val someoneChangedRoomNameEvent = createRoomEvent(sentByYou = false, senderDisplayName = otherName, content = changedContent)
-        val someoneChangedRoomName = formatter.processMessageItem(someoneChangedRoomNameEvent, false)
+        val someoneChangedRoomName = formatter.format(someoneChangedRoomNameEvent, false)
         Truth.assertThat(someoneChangedRoomName).isEqualTo("$otherName changed the room name to: $newName")
 
         val youRemovedRoomNameEvent = createRoomEvent(sentByYou = true, senderDisplayName = null, content = removedContent)
-        val youRemovedRoomName = formatter.processMessageItem(youRemovedRoomNameEvent, false)
+        val youRemovedRoomName = formatter.format(youRemovedRoomNameEvent, false)
         Truth.assertThat(youRemovedRoomName).isEqualTo("You removed the room name")
 
         val someoneRemovedRoomNameEvent = createRoomEvent(sentByYou = false, senderDisplayName = otherName, content = removedContent)
-        val someoneRemovedRoomName = formatter.processMessageItem(someoneRemovedRoomNameEvent, false)
+        val someoneRemovedRoomName = formatter.format(someoneRemovedRoomNameEvent, false)
         Truth.assertThat(someoneRemovedRoomName).isEqualTo("$otherName removed the room name")
     }
 
@@ -560,19 +560,19 @@ class DefaultRoomLastMessageFormatterTests {
         val removedContent = StateContent("", OtherState.RoomThirdPartyInvite(null))
 
         val youInvitedSomeoneEvent = createRoomEvent(sentByYou = true, senderDisplayName = null, content = changedContent)
-        val youInvitedSomeone = formatter.processMessageItem(youInvitedSomeoneEvent, false)
+        val youInvitedSomeone = formatter.format(youInvitedSomeoneEvent, false)
         Truth.assertThat(youInvitedSomeone).isEqualTo("You sent an invitation to $inviteeName to join the room")
 
         val someoneInvitedSomeoneEvent = createRoomEvent(sentByYou = false, senderDisplayName = otherName, content = changedContent)
-        val someoneInvitedSomeone = formatter.processMessageItem(someoneInvitedSomeoneEvent, false)
+        val someoneInvitedSomeone = formatter.format(someoneInvitedSomeoneEvent, false)
         Truth.assertThat(someoneInvitedSomeone).isEqualTo("$otherName sent an invitation to $inviteeName to join the room")
 
         val youInvitedNoOneEvent = createRoomEvent(sentByYou = true, senderDisplayName = null, content = removedContent)
-        val youInvitedNoOne = formatter.processMessageItem(youInvitedNoOneEvent, false)
+        val youInvitedNoOne = formatter.format(youInvitedNoOneEvent, false)
         Truth.assertThat(youInvitedNoOne).isNull()
 
         val someoneInvitedNoOneEvent = createRoomEvent(sentByYou = false, senderDisplayName = otherName, content = removedContent)
-        val someoneInvitedNoOne = formatter.processMessageItem(someoneInvitedNoOneEvent, false)
+        val someoneInvitedNoOne = formatter.format(someoneInvitedNoOneEvent, false)
         Truth.assertThat(someoneInvitedNoOne).isNull()
     }
 
@@ -585,19 +585,19 @@ class DefaultRoomLastMessageFormatterTests {
         val removedContent = StateContent("", OtherState.RoomTopic(null))
 
         val youChangedRoomTopicEvent = createRoomEvent(sentByYou = true, senderDisplayName = null, content = changedContent)
-        val youChangedRoomTopic = formatter.processMessageItem(youChangedRoomTopicEvent, false)
+        val youChangedRoomTopic = formatter.format(youChangedRoomTopicEvent, false)
         Truth.assertThat(youChangedRoomTopic).isEqualTo("You changed the topic to: $roomTopic")
 
         val someoneChangedRoomTopicEvent = createRoomEvent(sentByYou = false, senderDisplayName = otherName, content = changedContent)
-        val someoneChangedRoomTopic = formatter.processMessageItem(someoneChangedRoomTopicEvent, false)
+        val someoneChangedRoomTopic = formatter.format(someoneChangedRoomTopicEvent, false)
         Truth.assertThat(someoneChangedRoomTopic).isEqualTo("$otherName changed the topic to: $roomTopic")
 
         val youRemovedRoomTopicEvent = createRoomEvent(sentByYou = true, senderDisplayName = null, content = removedContent)
-        val youRemovedRoomTopic = formatter.processMessageItem(youRemovedRoomTopicEvent, false)
+        val youRemovedRoomTopic = formatter.format(youRemovedRoomTopicEvent, false)
         Truth.assertThat(youRemovedRoomTopic).isEqualTo("You removed the room topic")
 
         val someoneRemovedRoomTopicEvent = createRoomEvent(sentByYou = false, senderDisplayName = otherName, content = removedContent)
-        val someoneRemovedRoomTopic = formatter.processMessageItem(someoneRemovedRoomTopicEvent, false)
+        val someoneRemovedRoomTopic = formatter.format(someoneRemovedRoomTopicEvent, false)
         Truth.assertThat(someoneRemovedRoomTopic).isEqualTo("$otherName removed the room topic")
     }
 
@@ -613,7 +613,7 @@ class DefaultRoomLastMessageFormatterTests {
         val results = otherStates.map { state ->
             val content = StateContent("", state)
             val event = createRoomEvent(sentByYou = false, senderDisplayName = "Someone", content = content)
-            val result = formatter.processMessageItem(event, false)
+            val result = formatter.format(event, false)
             state to result
         }
         val expected = otherStates.map { it to null }
@@ -635,35 +635,35 @@ class DefaultRoomLastMessageFormatterTests {
         val sameContent = aProfileChangeMessageContent(avatarUrl = "same_avatar_url", prevAvatarUrl = "same_avatar_url")
 
         val youChangedAvatarEvent = createRoomEvent(sentByYou = true, senderDisplayName = null, content = changedContent)
-        val youChangedAvatar = formatter.processMessageItem(youChangedAvatarEvent, false)
+        val youChangedAvatar = formatter.format(youChangedAvatarEvent, false)
         Truth.assertThat(youChangedAvatar).isEqualTo("You changed your avatar")
 
         val someoneChangeAvatarEvent = createRoomEvent(sentByYou = false, senderDisplayName = otherName, content = changedContent)
-        val someoneChangeAvatar = formatter.processMessageItem(someoneChangeAvatarEvent, false)
+        val someoneChangeAvatar = formatter.format(someoneChangeAvatarEvent, false)
         Truth.assertThat(someoneChangeAvatar).isEqualTo("$otherName changed their avatar")
 
         val youSetAvatarEvent = createRoomEvent(sentByYou = true, senderDisplayName = null, content = setContent)
-        val youSetAvatar = formatter.processMessageItem(youSetAvatarEvent, false)
+        val youSetAvatar = formatter.format(youSetAvatarEvent, false)
         Truth.assertThat(youSetAvatar).isEqualTo("You changed your avatar")
 
         val someoneSetAvatarEvent = createRoomEvent(sentByYou = false, senderDisplayName = otherName, content = setContent)
-        val someoneSetAvatar = formatter.processMessageItem(someoneSetAvatarEvent, false)
+        val someoneSetAvatar = formatter.format(someoneSetAvatarEvent, false)
         Truth.assertThat(someoneSetAvatar).isEqualTo("$otherName changed their avatar")
 
         val youRemovedAvatarEvent = createRoomEvent(sentByYou = true, senderDisplayName = null, content = removedContent)
-        val youRemovedAvatar = formatter.processMessageItem(youRemovedAvatarEvent, false)
+        val youRemovedAvatar = formatter.format(youRemovedAvatarEvent, false)
         Truth.assertThat(youRemovedAvatar).isEqualTo("You changed your avatar")
 
         val someoneRemovedAvatarEvent = createRoomEvent(sentByYou = false, senderDisplayName = otherName, content = removedContent)
-        val someoneRemovedAvatar = formatter.processMessageItem(someoneRemovedAvatarEvent, false)
+        val someoneRemovedAvatar = formatter.format(someoneRemovedAvatarEvent, false)
         Truth.assertThat(someoneRemovedAvatar).isEqualTo("$otherName changed their avatar")
 
         val unchangedEvent = createRoomEvent(sentByYou = true, senderDisplayName = otherName, content = sameContent)
-        val unchangedResult = formatter.processMessageItem(unchangedEvent, false)
+        val unchangedResult = formatter.format(unchangedEvent, false)
         Truth.assertThat(unchangedResult).isNull()
 
         val invalidEvent = createRoomEvent(sentByYou = true, senderDisplayName = otherName, content = invalidContent)
-        val invalidResult = formatter.processMessageItem(invalidEvent, false)
+        val invalidResult = formatter.format(invalidEvent, false)
         Truth.assertThat(invalidResult).isNull()
     }
 
@@ -680,35 +680,35 @@ class DefaultRoomLastMessageFormatterTests {
         val invalidContent = aProfileChangeMessageContent(displayName = null, prevDisplayName = null)
 
         val youChangedDisplayNameEvent = createRoomEvent(sentByYou = true, senderDisplayName = null, content = changedContent)
-        val youChangedDisplayName = formatter.processMessageItem(youChangedDisplayNameEvent, false)
+        val youChangedDisplayName = formatter.format(youChangedDisplayNameEvent, false)
         Truth.assertThat(youChangedDisplayName).isEqualTo("You changed your display name from $oldDisplayName to $newDisplayName")
 
         val someoneChangedDisplayNameEvent = createRoomEvent(sentByYou = false, senderDisplayName = otherName, content = changedContent)
-        val someoneChangedDisplayName = formatter.processMessageItem(someoneChangedDisplayNameEvent, false)
+        val someoneChangedDisplayName = formatter.format(someoneChangedDisplayNameEvent, false)
         Truth.assertThat(someoneChangedDisplayName).isEqualTo("$otherName changed their display name from $oldDisplayName to $newDisplayName")
 
         val youSetDisplayNameEvent = createRoomEvent(sentByYou = true, senderDisplayName = null, content = setContent)
-        val youSetDisplayName = formatter.processMessageItem(youSetDisplayNameEvent, false)
+        val youSetDisplayName = formatter.format(youSetDisplayNameEvent, false)
         Truth.assertThat(youSetDisplayName).isEqualTo("You set your display name to $newDisplayName")
 
         val someoneSetDisplayNameEvent = createRoomEvent(sentByYou = false, senderDisplayName = otherName, content = setContent)
-        val someoneSetDisplayName = formatter.processMessageItem(someoneSetDisplayNameEvent, false)
+        val someoneSetDisplayName = formatter.format(someoneSetDisplayNameEvent, false)
         Truth.assertThat(someoneSetDisplayName).isEqualTo("$otherName set their display name to $newDisplayName")
 
         val youRemovedDisplayNameEvent = createRoomEvent(sentByYou = true, senderDisplayName = null, content = removedContent)
-        val youRemovedDisplayName = formatter.processMessageItem(youRemovedDisplayNameEvent, false)
+        val youRemovedDisplayName = formatter.format(youRemovedDisplayNameEvent, false)
         Truth.assertThat(youRemovedDisplayName).isEqualTo("You removed your display name (it was $oldDisplayName)")
 
         val someoneRemovedDisplayNameEvent = createRoomEvent(sentByYou = false, senderDisplayName = otherName, content = removedContent)
-        val someoneRemovedDisplayName = formatter.processMessageItem(someoneRemovedDisplayNameEvent, false)
+        val someoneRemovedDisplayName = formatter.format(someoneRemovedDisplayNameEvent, false)
         Truth.assertThat(someoneRemovedDisplayName).isEqualTo("$otherName removed their display name (it was $oldDisplayName)")
 
         val unchangedEvent = createRoomEvent(sentByYou = true, senderDisplayName = otherName, content = sameContent)
-        val unchangedResult = formatter.processMessageItem(unchangedEvent, false)
+        val unchangedResult = formatter.format(unchangedEvent, false)
         Truth.assertThat(unchangedResult).isNull()
 
         val invalidEvent = createRoomEvent(sentByYou = true, senderDisplayName = otherName, content = invalidContent)
-        val invalidResult = formatter.processMessageItem(invalidEvent, false)
+        val invalidResult = formatter.format(invalidEvent, false)
         Truth.assertThat(invalidResult).isNull()
     }
 
@@ -737,15 +737,15 @@ class DefaultRoomLastMessageFormatterTests {
         )
 
         val youChangedBothEvent = createRoomEvent(sentByYou = true, senderDisplayName = null, content = changedContent)
-        val youChangedBoth = formatter.processMessageItem(youChangedBothEvent, false)
+        val youChangedBoth = formatter.format(youChangedBothEvent, false)
         Truth.assertThat(youChangedBoth).isEqualTo("You changed your display name from $oldDisplayName to $newDisplayName\n(avatar was changed too)")
 
         val invalidContentEvent = createRoomEvent(sentByYou = true, senderDisplayName = null, content = invalidContent)
-        val invalidMessage = formatter.processMessageItem(invalidContentEvent, false)
+        val invalidMessage = formatter.format(invalidContentEvent, false)
         Truth.assertThat(invalidMessage).isNull()
 
         val sameContentEvent = createRoomEvent(sentByYou = true, senderDisplayName = null, content = sameContent)
-        val sameMessage = formatter.processMessageItem(sameContentEvent, false)
+        val sameMessage = formatter.format(sameContentEvent, false)
         Truth.assertThat(sameMessage).isNull()
     }
 

libraries/eventformatter/test/src/main/kotlin/io/element/android/libraries/eventformatter/test/FakeRoomLastMessageFormatter.kt

@@ -21,12 +21,13 @@ import io.element.android.libraries.matrix.api.timeline.item.event.EventTimeline
 
 class FakeRoomLastMessageFormatter : RoomLastMessageFormatter {
 
-    private var processMessageItemResult: CharSequence? = null
+    private var result: CharSequence? = null
-    override fun processMessageItem(event: EventTimelineItem, isDmRoom: Boolean): CharSequence? {
+
-        return processMessageItemResult
+    override fun format(event: EventTimelineItem, isDmRoom: Boolean): CharSequence? {
+        return result
     }
 
-    fun givenRoomSummaryResult(result: CharSequence?) {
+    fun givenFormatResult(result: CharSequence?) {
-        processMessageItemResult = result
+        this.result = result
     }
 }