[fenix] For https://github.com/mozilla-mobile/fenix/issues/24949: Remove malformed message when evaluating it.

app/src/main/java/org/mozilla/fenix/gleanplumb/NimbusMessagingStorage.kt

@@ -27,6 +27,12 @@ class NimbusMessagingStorage(
     private val messagingFeature: FeatureHolder<Messaging>,
     private val attributeProvider: CustomAttributeProvider? = null
 ) {
+    /**
+     * Contains all malformed messages where they key can be the value or a trigger of the message
+     * and the value is the message id.
+     */
+    @VisibleForTesting
+    internal val malFormedMap = mutableMapOf<String, String>()
     private val logger = Logger("MessagingStorage")
     private val nimbusFeature = messagingFeature.value()
     private val customAttributes: JSONObject
@@ -125,7 +131,10 @@ class NimbusMessagingStorage(
         } else {
             val safeAction = nimbusActions[unsafeAction]
             if (safeAction.isNullOrBlank() || safeAction.isEmpty()) {
+                if (!malFormedMap.containsKey(unsafeAction)) {
                     reportMalformedMessage(messageId)
+                }
+                malFormedMap[unsafeAction] = messageId
                 return null
             }
             safeAction
@@ -141,7 +150,10 @@ class NimbusMessagingStorage(
         return unsafeTriggers.map {
             val safeTrigger = nimbusTriggers[it]
             if (safeTrigger.isNullOrBlank() || safeTrigger.isEmpty()) {
+                if (!malFormedMap.containsKey(it)) {
                     reportMalformedMessage(messageId)
+                }
+                malFormedMap[it] = messageId
                 return null
             }
             safeTrigger
@@ -172,11 +184,15 @@ class NimbusMessagingStorage(
         return message.triggers.all { condition ->
             jexlCache[condition]
                 ?: try {
+                    if (malFormedMap.containsKey(condition)) {
+                        return false
+                    }
                     helper.evalJexl(condition).also { result ->
                         jexlCache[condition] = result
                     }
                 } catch (e: NimbusException.EvaluationException) {
                     reportMalformedMessage(message.id)
+                    malFormedMap[condition] = message.id
                     logger.info("Unable to evaluate $condition")
                     false
                 }

app/src/test/java/org/mozilla/fenix/gleanplumb/NimbusMessagingStorageTest.kt

@@ -247,6 +247,29 @@ class NimbusMessagingStorageTest {
         assertTrue(malformedWasReported)
     }
 
+    @Test
+    fun `GIVEN a previously stored malformed action WHEN calling sanitizeAction THEN return null and not report malFormed`() {
+        val actionsMap = mapOf("action-1" to "action-1-url")
+
+        storage.malFormedMap["malformed-action"] = "messageId"
+
+        val action = storage.sanitizeAction("messageId", "malformed-action", actionsMap)
+
+        assertNull(action)
+        assertFalse(malformedWasReported)
+    }
+
+    @Test
+    fun `GIVEN a non-previously stored malformed action WHEN calling sanitizeAction THEN return null and report malFormed`() {
+        val actionsMap = mapOf("action-1" to "action-1-url")
+
+        val action = storage.sanitizeAction("messageId", "malformed-action", actionsMap)
+
+        assertNull(action)
+        assertTrue(storage.malFormedMap.containsKey("malformed-action"))
+        assertTrue(malformedWasReported)
+    }
+
     @Test
     fun `WHEN calling updateMetadata THEN delegate to metadataStorage`() = runBlockingTest {
 
@@ -279,6 +302,29 @@ class NimbusMessagingStorageTest {
         assertTrue(malformedWasReported)
     }
 
+    @Test
+    fun `GIVEN a previously stored malformed trigger WHEN calling sanitizeTriggers THEN no report malformed and return null`() {
+        val triggersMap = mapOf("trigger-1" to "trigger-1-expression")
+
+        storage.malFormedMap[" "] = "messageId"
+
+        val trigger = storage.sanitizeTriggers("messageId", listOf(" "), triggersMap)
+
+        assertNull(trigger)
+        assertFalse(malformedWasReported)
+    }
+
+    @Test
+    fun `GIVEN a non previously stored malformed trigger WHEN calling sanitizeTriggers THEN report malformed and return null`() {
+        val triggersMap = mapOf("trigger-1" to "trigger-1-expression")
+
+        val trigger = storage.sanitizeTriggers("messageId", listOf(" "), triggersMap)
+
+        assertNull(trigger)
+        assertTrue(storage.malFormedMap.containsKey(" "))
+        assertTrue(malformedWasReported)
+    }
+
     @Test
     fun `GIVEN a valid trigger WHEN calling sanitizeAction THEN return the trigger`() {
         val triggersMap = mapOf("trigger-1" to "trigger-1-expression")
@@ -374,6 +420,52 @@ class NimbusMessagingStorageTest {
         assertFalse(result)
     }
 
+    @Test
+    fun `GIVEN a previously malformed trigger WHEN calling isMessageEligible THEN return false and not evaluate`() {
+        val helper: GleanPlumbMessageHelper = mockk(relaxed = true)
+        val message = Message(
+            "same-id",
+            mockk(relaxed = true),
+            action = "action",
+            mockk(relaxed = true),
+            listOf("trigger"),
+            Message.Metadata("same-id")
+        )
+
+        storage.malFormedMap["trigger"] = "same-id"
+
+        every { helper.evalJexl(any()) } throws NimbusException.EvaluationException("")
+
+        val result = storage.isMessageEligible(message, helper)
+
+        assertFalse(result)
+        verify(exactly = 0) { helper.evalJexl("trigger") }
+        assertFalse(malformedWasReported)
+    }
+
+    @Test
+    fun `GIVEN a non previously malformed trigger WHEN calling isMessageEligible THEN return false and not evaluate`() {
+        val helper: GleanPlumbMessageHelper = mockk(relaxed = true)
+        val message = Message(
+            "same-id",
+            mockk(relaxed = true),
+            action = "action",
+            mockk(relaxed = true),
+            listOf("trigger"),
+            Message.Metadata("same-id")
+        )
+
+        every { helper.evalJexl(any()) } throws NimbusException.EvaluationException("")
+
+        assertFalse(storage.malFormedMap.containsKey("trigger"))
+
+        val result = storage.isMessageEligible(message, helper)
+
+        assertFalse(result)
+        assertTrue(storage.malFormedMap.containsKey("trigger"))
+        assertTrue(malformedWasReported)
+    }
+
     @Test
     fun `GIVEN none available messages are eligible WHEN calling getNextMessage THEN return null`() {
         val spiedStorage = spyk(storage)