Fix failing tests

duckduckgo · Feb 3, 2025 · a2affdd · a2affdd
1 parent e6791ee
commit a2affdd
Showing 1 changed file with 40 additions and 37 deletions.
diff --git a/...java/com/duckduckgo/app/browser/webview/RealMaliciousSiteBlockerWebViewIntegrationTest.kt b/...java/com/duckduckgo/app/browser/webview/RealMaliciousSiteBlockerWebViewIntegrationTest.kt
@@ -3,22 +3,25 @@ package com.duckduckgo.app.browser.webview
 import android.webkit.WebResourceRequest
 import androidx.core.net.toUri
 import androidx.test.ext.junit.runners.AndroidJUnit4
+import com.duckduckgo.app.browser.webview.RealMaliciousSiteBlockerWebViewIntegration.IsMaliciousViewData
+import com.duckduckgo.app.browser.webview.RealMaliciousSiteBlockerWebViewIntegration.IsMaliciousViewData.MaliciousSite
+import com.duckduckgo.app.browser.webview.RealMaliciousSiteBlockerWebViewIntegration.IsMaliciousViewData.Safe
 import com.duckduckgo.app.pixels.remoteconfig.AndroidBrowserConfigFeature
 import com.duckduckgo.common.test.CoroutineTestRule
 import com.duckduckgo.feature.toggles.api.FakeFeatureToggleFactory
 import com.duckduckgo.feature.toggles.api.Toggle.State
 import com.duckduckgo.malicioussiteprotection.api.MaliciousSiteProtection
-import com.duckduckgo.malicioussiteprotection.api.MaliciousSiteProtection.IsMaliciousResult.MALICIOUS
+import com.duckduckgo.malicioussiteprotection.api.MaliciousSiteProtection.Feed.MALWARE
+import com.duckduckgo.malicioussiteprotection.api.MaliciousSiteProtection.IsMaliciousResult.ConfirmedResult
 import com.duckduckgo.malicioussiteprotection.api.MaliciousSiteProtection.IsMaliciousResult.WaitForConfirmation
+import com.duckduckgo.malicioussiteprotection.api.MaliciousSiteProtection.MaliciousStatus
+import com.duckduckgo.malicioussiteprotection.api.MaliciousSiteProtection.MaliciousStatus.Malicious
 import junit.framework.TestCase.assertEquals
 import junit.framework.TestCase.assertTrue
 import kotlinx.coroutines.CompletableDeferred
 import kotlinx.coroutines.channels.Channel
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.test.runTest
-import org.junit.Assert.assertFalse
-import org.junit.Assert.assertNotNull
-import org.junit.Assert.assertNull
 import org.junit.Before
 import org.junit.Rule
 import org.junit.Test
@@ -52,40 +55,40 @@ class RealMaliciousSiteBlockerWebViewIntegrationTest {
     }
 
     @Test
-    fun `shouldOverrideUrlLoading returns false when feature is disabled`() = runTest {
+    fun `shouldOverrideUrlLoading returns safe when feature is disabled`() = runTest {
         updateFeatureEnabled(false)
 
         val result = testee.shouldOverrideUrlLoading(exampleUri, true) {}
-        assertFalse(result)
+        assertEquals(Safe, result)
     }
 
     @Test
-    fun `shouldInterceptRequest returns null when feature is disabled`() = runTest {
+    fun `shouldInterceptRequest returns safe when feature is disabled`() = runTest {
         val request = mock(WebResourceRequest::class.java)
         whenever(request.url).thenReturn(exampleUri)
         updateFeatureEnabled(false)
 
         val result = testee.shouldIntercept(request, null) {}
-        assertNull(result)
+        assertEquals(Safe, result)
     }
 
     @Test
-    fun `shouldOverrideUrlLoading returns false when url is already processed`() = runTest {
+    fun `shouldOverrideUrlLoading returns safe when url is already processed`() = runTest {
         testee.processedUrls.add(exampleUri.toString())
 
         val result = testee.shouldOverrideUrlLoading(exampleUri, true) {}
-        assertFalse(result)
+        assertEquals(Safe, result)
     }
 
     @Test
     fun `shouldInterceptRequest returns result when feature is enabled, is malicious, and is mainframe`() = runTest {
         val request = mock(WebResourceRequest::class.java)
         whenever(request.url).thenReturn(maliciousUri)
         whenever(request.isForMainFrame).thenReturn(true)
-        whenever(maliciousSiteProtection.isMalicious(any(), any())).thenReturn(MALICIOUS)
+        whenever(maliciousSiteProtection.isMalicious(any(), any())).thenReturn(ConfirmedResult(Malicious(MALWARE)))
 
         val result = testee.shouldIntercept(request, maliciousUri) {}
-        assertNotNull(result)
+        assertEquals(MaliciousSite(maliciousUri, MALWARE, false), result)
     }
 
     @Test
@@ -94,56 +97,56 @@ class RealMaliciousSiteBlockerWebViewIntegrationTest {
         whenever(request.url).thenReturn(maliciousUri)
         whenever(request.isForMainFrame).thenReturn(true)
         whenever(request.requestHeaders).thenReturn(mapOf("Sec-Fetch-Dest" to "iframe"))
-        whenever(maliciousSiteProtection.isMalicious(any(), any())).thenReturn(MALICIOUS)
+        whenever(maliciousSiteProtection.isMalicious(any(), any())).thenReturn(ConfirmedResult(Malicious(MALWARE)))
 
         val result = testee.shouldIntercept(request, maliciousUri) {}
-        assertNotNull(result)
+        assertEquals(MaliciousSite(maliciousUri, MALWARE, false), result)
     }
 
     @Test
-    fun `shouldInterceptRequest returns null when feature is enabled, is malicious, and is not mainframe nor iframe`() = runTest {
+    fun `shouldInterceptRequest returns safe when feature is enabled, is malicious, and is not mainframe nor iframe`() = runTest {
         val request = mock(WebResourceRequest::class.java)
         whenever(request.url).thenReturn(maliciousUri)
         whenever(request.isForMainFrame).thenReturn(false)
-        whenever(maliciousSiteProtection.isMalicious(any(), any())).thenReturn(MALICIOUS)
+        whenever(maliciousSiteProtection.isMalicious(any(), any())).thenReturn(ConfirmedResult(Malicious(MALWARE)))
 
         val result = testee.shouldIntercept(request, maliciousUri) {}
-        assertNull(result)
+        assertEquals(Safe, result)
     }
 
     @Test
-    fun `shouldOverride returns false when feature is enabled, is malicious, and is not mainframe`() = runTest {
-        whenever(maliciousSiteProtection.isMalicious(any(), any())).thenReturn(MALICIOUS)
+    fun `shouldOverride returns safe when feature is enabled, is malicious, and is not mainframe`() = runTest {
+        whenever(maliciousSiteProtection.isMalicious(any(), any())).thenReturn(ConfirmedResult(Malicious(MALWARE)))
 
         val result = testee.shouldOverrideUrlLoading(maliciousUri, false) {}
-        assertFalse(result)
+        assertEquals(Safe, result)
     }
 
     @Test
-    fun `shouldOverride returns true when feature is enabled, is malicious, and is mainframe`() = runTest {
-        whenever(maliciousSiteProtection.isMalicious(any(), any())).thenReturn(MALICIOUS)
+    fun `shouldOverride returns malicious when feature is enabled, is malicious, and is mainframe`() = runTest {
+        whenever(maliciousSiteProtection.isMalicious(any(), any())).thenReturn(ConfirmedResult(Malicious(MALWARE)))
 
         val result = testee.shouldOverrideUrlLoading(maliciousUri, true) {}
-        assertTrue(result)
+        assertEquals(IsMaliciousViewData.MaliciousSite(maliciousUri, MALWARE, false), result)
     }
 
     @Test
-    fun `shouldOverride returns false when feature is enabled, is malicious, and not mainframe nor iframe`() = runTest {
-        whenever(maliciousSiteProtection.isMalicious(any(), any())).thenReturn(MALICIOUS)
+    fun `shouldOverride returns safe when feature is enabled, is malicious, and not mainframe nor iframe`() = runTest {
+        whenever(maliciousSiteProtection.isMalicious(any(), any())).thenReturn(ConfirmedResult(Malicious(MALWARE)))
 
         val result = testee.shouldOverrideUrlLoading(maliciousUri, false) {}
-        assertFalse(result)
+        assertEquals(Safe, result)
     }
 
     @Test
-    fun `shouldIntercept returns null when feature is enabled, is malicious, and is mainframe but webView has different host`() = runTest {
-        whenever(maliciousSiteProtection.isMalicious(any(), any())).thenReturn(MALICIOUS)
+    fun `shouldIntercept returns safe when feature is enabled, is malicious, and is mainframe but webView has different host`() = runTest {
+        whenever(maliciousSiteProtection.isMalicious(any(), any())).thenReturn(ConfirmedResult(Malicious(MALWARE)))
         val request = mock(WebResourceRequest::class.java)
         whenever(request.url).thenReturn(maliciousUri)
         whenever(request.isForMainFrame).thenReturn(false)
 
         val result = testee.shouldIntercept(request, exampleUri) {}
-        assertNull(result)
+        assertEquals(Safe, result)
     }
 
     @Test
@@ -164,21 +167,21 @@ class RealMaliciousSiteBlockerWebViewIntegrationTest {
         val secondCallbackDeferred = CompletableDeferred<Boolean>()
 
         whenever(maliciousSiteProtection.isMalicious(any(), any())).thenAnswer { invocation ->
-            val callback = invocation.getArgument<(Boolean) -> Unit>(1)
+            val callback = invocation.getArgument<(Malicious) -> Unit>(1)
 
             launch {
                 callbackChannel.receive()
-                callback(true)
+                callback(Malicious(MALWARE))
             }
             WaitForConfirmation
         }
 
         testee.shouldOverrideUrlLoading(maliciousUri, true) { isMalicious ->
-            firstCallbackDeferred.complete(isMalicious)
+            firstCallbackDeferred.complete(isMalicious is Malicious)
         }
 
         testee.shouldOverrideUrlLoading(exampleUri, true) { isMalicious ->
-            secondCallbackDeferred.complete(isMalicious)
+            secondCallbackDeferred.complete(isMalicious is Malicious)
         }
 
         callbackChannel.send(Unit)
@@ -202,23 +205,23 @@ class RealMaliciousSiteBlockerWebViewIntegrationTest {
         val secondCallbackDeferred = CompletableDeferred<Boolean>()
 
         whenever(maliciousSiteProtection.isMalicious(any(), any())).thenAnswer { invocation ->
-            val callback = invocation.getArgument<(Boolean) -> Unit>(1)
+            val callback = invocation.getArgument<(MaliciousStatus) -> Unit>(1)
 
             launch {
                 callbackChannel.receive()
-                callback(true)
+                callback(Malicious(MALWARE))
             }
             WaitForConfirmation
         }
 
         testee.shouldOverrideUrlLoading(maliciousUri, true) { isMalicious ->
-            firstCallbackDeferred.complete(isMalicious)
+            firstCallbackDeferred.complete(isMalicious is Malicious)
         }
 
         callbackChannel.send(Unit)
 
         testee.shouldOverrideUrlLoading(exampleUri, true) { isMalicious ->
-            secondCallbackDeferred.complete(isMalicious)
+            secondCallbackDeferred.complete(isMalicious is Malicious)
         }
 
         callbackChannel.send(Unit)