fix(deeplink): stop links that fail for good from replaying on every launch (#27)

* test(deeplink): pin terminal-failure replay and referendum path matching

These fail on main: a link that fails for good is kept as pending and
replayed on every launch, and /open/governance matches the referendum
handler.

* fix(deeplink): drop a pending link once it fails for good

RootDeepLinkHandler cleared the persisted pending link only on success or
when no handler matched. A link that reached a handler and failed with a
DeepLinkHandlingException stayed in preferences and was replayed on
every launch. Clear it on terminal handling failures in both the fresh
and pending paths; this also recovers installs already stuck on update.
Other failures keep the link pending for a retry.

* fix(deeplink): match the referendum path exactly

ReferendumDeepLinkHandler matched any path starting with /open/gov, so
the governance banner link /open/governance went to the referendum
screen and failed with ReferendumIsNotSpecified.

feature-deep-linking/build.gradle

@@ -31,6 +31,8 @@ dependencies {
     implementation daggerDep
     ksp daggerCompiler
 
+    testImplementation project(':test-shared')
+
     androidTestImplementation androidTestRunnerDep
     androidTestImplementation androidTestRulesDep
     androidTestImplementation androidJunitDep

feature-deep-linking/src/main/java/io/novafoundation/nova/feature_deep_linking/presentation/handling/RootDeepLinkHandler.kt

@@ -2,6 +2,7 @@ package io.novafoundation.nova.feature_deep_linking.presentation.handling
 
 import android.net.Uri
 import io.novafoundation.nova.common.utils.onFailureInstance
+import io.novafoundation.nova.feature_deep_linking.presentation.handling.common.DeepLinkHandlingException
 import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.merge
 
@@ -23,12 +24,18 @@ class RootDeepLinkHandler(
 
         return handleDeepLinkInternal(pendingDeepLink)
             .onSuccess { pendingDeepLinkProvider.clear() }
+            // A pending link that reaches a handler but fails with a terminal error (malformed/unresolvable),
+            // or matches no handler, will never succeed on retry - clear it so it does not replay on every launch.
+            .onFailureInstance<DeepLinkHandlingException, Unit> { pendingDeepLinkProvider.clear() }
+            .onFailureInstance<HandlerNotFoundException, Unit> { pendingDeepLinkProvider.clear() }
     }
 
     override suspend fun handleDeepLink(data: Uri): Result<Unit> {
         pendingDeepLinkProvider.save(data)
         return handleDeepLinkInternal(data)
             .onSuccess { pendingDeepLinkProvider.clear() }
+            // Same as above: a terminal handling failure must not be persisted, otherwise it bricks every launch.
+            .onFailureInstance<DeepLinkHandlingException, Unit> { pendingDeepLinkProvider.clear() }
             .onFailureInstance<HandlerNotFoundException, Unit> { pendingDeepLinkProvider.clear() } // If we haven't find any handler - no need to save deep link
     }
 

feature-deep-linking/src/test/java/io/novafoundation/nova/feature_deep_linking/presentation/handling/RootDeepLinkHandlerTest.kt

@@ -0,0 +1,51 @@
+package io.novafoundation.nova.feature_deep_linking.presentation.handling
+
+import android.net.Uri
+import io.novafoundation.nova.feature_deep_linking.presentation.handling.common.DeepLinkHandlingException.ReferendumHandlingException
+import io.novafoundation.nova.test_shared.whenever
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.emptyFlow
+import kotlinx.coroutines.runBlocking
+import org.junit.Test
+import org.mockito.Mockito.mock
+import org.mockito.Mockito.never
+import org.mockito.Mockito.verify
+
+class RootDeepLinkHandlerTest {
+
+    private val link = mock(Uri::class.java)
+    private val pendingDeepLinkProvider = mock(PendingDeepLinkProvider::class.java)
+
+    private class FailingHandler(private val error: Throwable) : DeepLinkHandler {
+        override val callbackFlow: Flow<CallbackEvent> = emptyFlow()
+        override suspend fun matches(data: Uri) = true
+        override suspend fun handleDeepLink(data: Uri): Result<Unit> = Result.failure(error)
+    }
+
+    private fun rootWith(error: Throwable) = RootDeepLinkHandler(pendingDeepLinkProvider, listOf(FailingHandler(error)))
+
+    // A link that reaches a handler and fails for good was kept as pending and replayed on every
+    // launch, showing "Referendum not found" each time the app opened.
+    @Test
+    fun `a fresh link that fails for good is not kept as pending`() = runBlocking {
+        rootWith(ReferendumHandlingException.ReferendumIsNotSpecified).handleDeepLink(link)
+
+        verify(pendingDeepLinkProvider).clear()
+    }
+
+    @Test
+    fun `a pending link that fails for good is dropped`() = runBlocking {
+        whenever(pendingDeepLinkProvider.get()).thenReturn(link)
+
+        rootWith(ReferendumHandlingException.ReferendumIsNotSpecified).checkAndHandlePendingDeepLink()
+
+        verify(pendingDeepLinkProvider).clear()
+    }
+
+    @Test
+    fun `a link that fails for another reason stays pending for a retry`() = runBlocking {
+        rootWith(IllegalStateException("not ready yet")).handleDeepLink(link)
+
+        verify(pendingDeepLinkProvider, never()).clear()
+    }
+}