fix: asset update handling for unknown content (#3844)

Author: Garzas

logic/src/commonMain/kotlin/com/wire/kalium/logic/sync/receiver/asset/AssetMessageHandler.kt

@@ -147,29 +147,33 @@ internal class AssetMessageHandlerImpl(
     ): Message.Regular? {
         val assetMessageContent = when (persistedMessage.content) {
             is MessageContent.Asset -> persistedMessage.content as MessageContent.Asset
-            is MessageContent.RestrictedAsset -> {
-                // original message was a restricted asset message, ignoring
-                return null
-            }
-
+            is MessageContent.RestrictedAsset -> null // original message was a restricted asset message, ignoring
             is MessageContent.FailedDecryption,
             is MessageContent.Knock,
             is MessageContent.Location,
             is MessageContent.Composite,
             is MessageContent.Text,
             is MessageContent.Multipart,
-            is MessageContent.Unknown -> error("Invalid asset message content type ${persistedMessage.content.getType()}")
-        }
-        // The message was previously received with just metadata info, so let's update it with the raw data info
-        return persistedMessage.copy(
-            content = assetMessageContent.copy(
-                value = assetMessageContent.value.copy(
-                    remoteData = remoteData
+            is MessageContent.Unknown -> {
+                kaliumLogger.e(
+                    "Invalid asset message content type=${persistedMessage.content.getType()} " +
+                        "messageId=${persistedMessage.id} conversationId=${persistedMessage.conversationId}"
                 )
-            ),
-            // If update message for any reason has still invalid encryption keys, message can't still be shown
-            visibility = if (remoteData.hasValidData()) Message.Visibility.VISIBLE else Message.Visibility.HIDDEN
-        )
+                null
+            }
+        }
+        return assetMessageContent?.let { asset ->
+            // The message was previously received with just metadata info, so let's update it with the raw data info
+            persistedMessage.copy(
+                content = asset.copy(
+                    value = asset.value.copy(
+                        remoteData = remoteData
+                    )
+                ),
+                // If update message for any reason has still invalid encryption keys, message can't still be shown
+                visibility = if (remoteData.hasValidData()) Message.Visibility.VISIBLE else Message.Visibility.HIDDEN
+            )
+        }
     }
 }
 

logic/src/commonMain/kotlin/com/wire/kalium/logic/sync/receiver/conversation/message/ApplicationMessageHandler.kt

@@ -259,7 +259,17 @@ internal class ApplicationMessageHandlerImpl(
             is MessageContent.Text -> handleTextMessage(message, content)
             is MessageContent.FailedDecryption -> persistMessage(message)
             is MessageContent.Knock -> persistMessage(message)
-            is MessageContent.Asset -> assetMessageHandler.handle(message)
+            is MessageContent.Asset -> {
+                try {
+                    assetMessageHandler.handle(message)
+                } catch (exception: IllegalStateException) {
+                    logger.e(
+                        "AssetMessageHandler failed for messageId=${message.id} conversationId=${message.conversationId}",
+                        exception
+                    )
+                }
+            }
+
             is MessageContent.RestrictedAsset -> {
                 /* no-op */
             }

logic/src/jvmTest/kotlin/com/wire/kalium/logic/sync/receiver/asset/AssetMessageHandlerTest.kt

@@ -242,6 +242,35 @@ class AssetMessageHandlerTest {
         }.wasInvoked(exactly = once)
     }
 
+    @Test
+    fun givenUnknownMessageStored_whenHandlingAssetUpdate_itDoesNotCrashOrPersist() = runTest {
+        // Given
+        val storedUnknownMessage = COMPLETE_ASSET_MESSAGE.copy(
+            content = MessageContent.Unknown(typeName = "some-new-type"),
+            visibility = Message.Visibility.HIDDEN
+        )
+        val updateAssetMessage = COMPLETE_ASSET_MESSAGE
+        val isFileSharingEnabled = FileSharingStatus.Value.EnabledAll
+        val (arrangement, assetMessageHandler) = Arrangement()
+            .withSuccessfulFileSharingFlag(isFileSharingEnabled)
+            .withSuccessfulStoredMessage(storedUnknownMessage)
+            .arrange()
+
+        // When
+        assetMessageHandler.handle(updateAssetMessage)
+
+        // Then
+        coVerify {
+            arrangement.messageRepository.getMessageById(
+                eq(updateAssetMessage.conversationId),
+                eq(updateAssetMessage.id)
+            )
+        }.wasInvoked(exactly = once)
+
+        coVerify { arrangement.persistMessage(any()) }
+            .wasNotInvoked()
+    }
+
     @Test
     fun givenValidPreviewAssetMessageStoredAndExtensionIsAllowed_whenHandlingTheUpdate_itIsCorrectlyProcessedAndVisible() = runTest {
         // Given