Merge branch 'hotfix/5.92.1' into main

marcosholgado · marcosholgado · commit 1075f2220730 · 2021-08-03T15:50:43.000+01:00
diff --git a/app/src/androidTest/java/com/duckduckgo/app/browser/DuckDuckGoUrlDetectorTest.kt b/app/src/androidTest/java/com/duckduckgo/app/browser/DuckDuckGoUrlDetectorTest.kt
@@ -119,22 +119,22 @@ class DuckDuckGoUrlDetectorTest {
     }
 
     @Test
-    fun whenDomainIsNotDuckDuckGoThenReturnFalse() {
-        assertFalse(testee.isDuckDuckGoDomain("https://example.com"))
+    fun whenIsNotDuckDuckGoEmailUrlThenReturnFalse() {
+        assertFalse(testee.isDuckDuckGoEmailUrl("https://example.com"))
     }
 
     @Test
-    fun whenDomainIsDuckDuckGoThenReturnTrue() {
-        assertTrue(testee.isDuckDuckGoDomain("https://duckduckgo.com"))
+    fun whenIsDuckDuckEmailUrlGoThenReturnTrue() {
+        assertTrue(testee.isDuckDuckGoEmailUrl("https://duckduckgo.com/email"))
     }
 
     @Test
-    fun whenUrlContainsSubdomainAndIsFromDuckDuckGoDomainThenReturnTrue() {
-        assertTrue(testee.isDuckDuckGoDomain("https://test.duckduckgo.com"))
+    fun whenUrlContainsSubdomainAndIsFromDuckDuckGoEmailUrlThenReturnTrue() {
+        assertTrue(testee.isDuckDuckGoEmailUrl("https://test.duckduckgo.com/email"))
     }
 
     @Test
-    fun whenUrlHasNoSchemeAndIsFromDuckDuckGoDomainThenReturnsTrue() {
-        assertTrue(testee.isDuckDuckGoDomain("duckduckgo.com"))
+    fun whenUrlHasNoSchemeAndIsFromDuckDuckGoUrlThenReturnsTrue() {
+        assertTrue(testee.isDuckDuckGoEmailUrl("duckduckgo.com/email"))
     }
 }
diff --git a/app/src/androidTest/java/com/duckduckgo/app/email/EmailInjectorJsTest.kt b/app/src/androidTest/java/com/duckduckgo/app/email/EmailInjectorJsTest.kt
@@ -22,6 +22,7 @@ import androidx.test.filters.SdkSuppress
 import androidx.test.platform.app.InstrumentationRegistry
 import com.duckduckgo.app.browser.DuckDuckGoUrlDetector
 import com.duckduckgo.app.browser.R
+import com.duckduckgo.app.global.DispatcherProvider
 import com.nhaarman.mockitokotlin2.*
 import org.junit.Before
 import org.junit.Test
@@ -30,11 +31,12 @@ import java.io.BufferedReader
 class EmailInjectorJsTest {
 
     private val mockEmailManager: EmailManager = mock()
+    private val mockDispatcherProvider: DispatcherProvider = mock()
     lateinit var testee: EmailInjectorJs
 
     @Before
     fun setup() {
-        testee = EmailInjectorJs(mockEmailManager, DuckDuckGoUrlDetector())
+        testee = EmailInjectorJs(mockEmailManager, DuckDuckGoUrlDetector(), mockDispatcherProvider)
     }
 
     @UiThreadTest
@@ -44,7 +46,7 @@ class EmailInjectorJsTest {
         val jsToEvaluate = getJsToEvaluate()
         val webView = spy(WebView(InstrumentationRegistry.getInstrumentation().targetContext))
 
-        testee.injectEmailAutofillJs(webView, "https://duckduckgo.com")
+        testee.injectEmailAutofillJs(webView, "https://duckduckgo.com/email")
 
         verify(webView).evaluateJavascript(jsToEvaluate, null)
     }
@@ -56,7 +58,7 @@ class EmailInjectorJsTest {
         val jsToEvaluate = getJsToEvaluate()
         val webView = spy(WebView(InstrumentationRegistry.getInstrumentation().targetContext))
 
-        testee.injectEmailAutofillJs(webView, "https://test.duckduckgo.com")
+        testee.injectEmailAutofillJs(webView, "https://test.duckduckgo.com/email")
 
         verify(webView).evaluateJavascript(jsToEvaluate, null)
     }
diff --git a/app/src/androidTest/java/com/duckduckgo/app/email/EmailJavascriptInterfaceTest.kt b/app/src/androidTest/java/com/duckduckgo/app/email/EmailJavascriptInterfaceTest.kt
@@ -16,59 +16,67 @@
 
 package com.duckduckgo.app.email
 
+import android.webkit.WebView
+import com.duckduckgo.app.CoroutineTestRule
+import com.duckduckgo.app.browser.DuckDuckGoUrlDetector
 import com.nhaarman.mockitokotlin2.mock
+import com.nhaarman.mockitokotlin2.never
 import com.nhaarman.mockitokotlin2.verify
 import com.nhaarman.mockitokotlin2.whenever
 import org.junit.Assert.assertEquals
 import org.junit.Before
+import org.junit.Rule
 import org.junit.Test
 
 class EmailJavascriptInterfaceTest {
 
+    @get:Rule
+    val coroutineRule = CoroutineTestRule()
+
     private val mockEmailManager: EmailManager = mock()
+    private val mockWebView: WebView = mock()
     lateinit var testee: EmailJavascriptInterface
     private var counter = 0
 
     @Before
     fun setup() {
-        testee = EmailJavascriptInterface(mockEmailManager) { counter++ }
+        testee = EmailJavascriptInterface(mockEmailManager, mockWebView, DuckDuckGoUrlDetector(), coroutineRule.testDispatcherProvider) { counter++ }
     }
 
     @Test
-    fun whenGetAliasThenGetAliasCalled() {
-        givenAliasExists()
+    fun whenIsSignedInAndUrlIsDuckDuckGoEmailThenIsSignedInCalled() {
+        whenever(mockWebView.url).thenReturn(DUCKDUCKGO_EMAIL_URL)
 
-        testee.getAlias()
+        testee.isSignedIn()
 
-        verify(mockEmailManager).getAlias()
+        verify(mockEmailManager).isSignedIn()
     }
 
     @Test
-    fun whenGetAliasThenReturnNextAliasWrappedInJsonObject() {
-        givenAliasExists()
-
-        assertEquals("{\"nextAlias\": \"alias\"}", testee.getAlias())
-    }
+    fun whenIsSignedInAndUrlIsNotDuckDuckGoEmailThenIsSignedInNotCalled() {
+        whenever(mockWebView.url).thenReturn(NON_EMAIL_URL)
 
-    @Test
-    fun whenGetAliasIfNextAliasDoesNotExistThenReturnEmpty() {
-        givenAliasDoesNotExist()
+        testee.isSignedIn()
 
-        assertEquals("", testee.getAlias())
+        verify(mockEmailManager, never()).isSignedIn()
     }
 
     @Test
-    fun whenIsSignedInThenIsSignedInCalled() {
-        testee.isSignedIn()
+    fun whenStoreCredentialsAndUrlIsDuckDuckGoEmailThenStoreCredentialsCalledWithCorrectParameters() {
+        whenever(mockWebView.url).thenReturn(DUCKDUCKGO_EMAIL_URL)
 
-        verify(mockEmailManager).isSignedIn()
+        testee.storeCredentials("token", "username", "cohort")
+
+        verify(mockEmailManager).storeCredentials("token", "username", "cohort")
     }
 
     @Test
-    fun whenStoreCredentialsThenStoreCredentialsCalledWithCorrectParameters() {
+    fun whenStoreCredentialsAndUrlIsNotDuckDuckGoEmailThenStoreCredentialsNotCalled() {
+        whenever(mockWebView.url).thenReturn(NON_EMAIL_URL)
+
         testee.storeCredentials("token", "username", "cohort")
 
-        verify(mockEmailManager).storeCredentials("token", "username", "cohort")
+        verify(mockEmailManager, never()).storeCredentials("token", "username", "cohort")
     }
 
     @Test
@@ -78,11 +86,8 @@ class EmailJavascriptInterfaceTest {
         assertEquals(1, counter)
     }
 
-    private fun givenAliasExists() {
-        whenever(mockEmailManager.getAlias()).thenReturn("alias")
-    }
-
-    private fun givenAliasDoesNotExist() {
-        whenever(mockEmailManager.getAlias()).thenReturn("")
+    companion object {
+        const val DUCKDUCKGO_EMAIL_URL = "https://duckduckgo.com/email"
+        const val NON_EMAIL_URL = "https://example.com"
     }
 }
diff --git a/app/src/main/java/com/duckduckgo/app/browser/DuckDuckGoUrlDetector.kt b/app/src/main/java/com/duckduckgo/app/browser/DuckDuckGoUrlDetector.kt
@@ -24,8 +24,9 @@ import javax.inject.Inject
 
 class DuckDuckGoUrlDetector @Inject constructor() {
 
-    fun isDuckDuckGoDomain(uri: String): Boolean {
-        return uri.toUri().baseHost?.contains(AppUrl.Url.HOST) ?: false
+    fun isDuckDuckGoEmailUrl(url: String): Boolean {
+        val uri = url.toUri()
+        return uri.baseHost?.contains(AppUrl.Url.HOST) == true && uri.pathSegments.contains(AppUrl.Url.EMAIL_SEGMENT)
     }
 
     fun isDuckDuckGoUrl(uri: String): Boolean {
diff --git a/app/src/main/java/com/duckduckgo/app/email/EmailInjector.kt b/app/src/main/java/com/duckduckgo/app/email/EmailInjector.kt
@@ -22,6 +22,7 @@ import androidx.annotation.UiThread
 import com.duckduckgo.app.browser.DuckDuckGoUrlDetector
 import com.duckduckgo.app.browser.R
 import com.duckduckgo.app.email.EmailJavascriptInterface.Companion.JAVASCRIPT_INTERFACE_NAME
+import com.duckduckgo.app.global.DispatcherProvider
 import java.io.BufferedReader
 
 interface EmailInjector {
@@ -30,11 +31,11 @@ interface EmailInjector {
     fun injectAddressInEmailField(webView: WebView, alias: String?)
 }
 
-class EmailInjectorJs(private val emailManager: EmailManager, private val urlDetector: DuckDuckGoUrlDetector) : EmailInjector {
+class EmailInjectorJs(private val emailManager: EmailManager, private val urlDetector: DuckDuckGoUrlDetector, private val dispatcherProvider: DispatcherProvider) : EmailInjector {
     private val javaScriptInjector = JavaScriptInjector()
 
     override fun addJsInterface(webView: WebView, onTooltipShown: () -> Unit) {
-        webView.addJavascriptInterface(EmailJavascriptInterface(emailManager, onTooltipShown), JAVASCRIPT_INTERFACE_NAME)
+        webView.addJavascriptInterface(EmailJavascriptInterface(emailManager, webView, urlDetector, dispatcherProvider, onTooltipShown), JAVASCRIPT_INTERFACE_NAME)
     }
 
     @UiThread
@@ -49,7 +50,7 @@ class EmailInjectorJs(private val emailManager: EmailManager, private val urlDet
         webView.evaluateJavascript("javascript:${javaScriptInjector.getAliasFunctions(webView.context, alias)}", null)
     }
 
-    private fun isDuckDuckGoUrl(url: String?): Boolean = (url != null && urlDetector.isDuckDuckGoDomain(url))
+    private fun isDuckDuckGoUrl(url: String?): Boolean = (url != null && urlDetector.isDuckDuckGoEmailUrl(url))
 
     private class JavaScriptInjector {
         private lateinit var functions: String
diff --git a/app/src/main/java/com/duckduckgo/app/email/EmailJavascriptInterface.kt b/app/src/main/java/com/duckduckgo/app/email/EmailJavascriptInterface.kt
@@ -17,35 +17,40 @@
 package com.duckduckgo.app.email
 
 import android.webkit.JavascriptInterface
-import timber.log.Timber
+import android.webkit.WebView
+import com.duckduckgo.app.browser.DuckDuckGoUrlDetector
+import com.duckduckgo.app.global.DispatcherProvider
+import kotlinx.coroutines.runBlocking
 
 class EmailJavascriptInterface(
     private val emailManager: EmailManager,
+    private val webView: WebView,
+    private val urlDetector: DuckDuckGoUrlDetector,
+    private val dispatcherProvider: DispatcherProvider,
     private val showNativeTooltip: () -> Unit
 ) {
 
-    @JavascriptInterface
-    fun log(message: String) {
-        Timber.i("EmailInterface $message")
+    private fun isUrlFromDuckDuckGoEmail(): Boolean {
+        return runBlocking(dispatcherProvider.main()) {
+            val url = webView.url
+            (url != null && urlDetector.isDuckDuckGoEmailUrl(url))
+        }
     }
 
     @JavascriptInterface
-    fun getAlias(): String {
-        val nextAlias = emailManager.getAlias()
-
-        return if (nextAlias.isNullOrBlank()) {
-            ""
+    fun isSignedIn(): String {
+        return if (isUrlFromDuckDuckGoEmail()) {
+            emailManager.isSignedIn().toString()
         } else {
-            "{\"nextAlias\": \"$nextAlias\"}"
+            ""
         }
     }
 
-    @JavascriptInterface
-    fun isSignedIn(): String = emailManager.isSignedIn().toString()
-
     @JavascriptInterface
     fun storeCredentials(token: String, username: String, cohort: String) {
-        emailManager.storeCredentials(token, username, cohort)
+        if (isUrlFromDuckDuckGoEmail()) {
+            emailManager.storeCredentials(token, username, cohort)
+        }
     }
 
     @JavascriptInterface
diff --git a/app/src/main/java/com/duckduckgo/app/email/di/EmailModule.kt b/app/src/main/java/com/duckduckgo/app/email/di/EmailModule.kt
@@ -50,8 +50,8 @@ class EmailModule {
     }
 
     @Provides
-    fun providesEmailInjector(emailManager: EmailManager, duckDuckGoUrlDetector: DuckDuckGoUrlDetector): EmailInjector {
-        return EmailInjectorJs(emailManager, duckDuckGoUrlDetector)
+    fun providesEmailInjector(emailManager: EmailManager, duckDuckGoUrlDetector: DuckDuckGoUrlDetector, dispatcherProvider: DispatcherProvider): EmailInjector {
+        return EmailInjectorJs(emailManager, duckDuckGoUrlDetector, dispatcherProvider)
     }
 
     @Provides
diff --git a/app/version/version.properties b/app/version/version.properties
@@ -1 +1 @@
-VERSION=5.92.0
+VERSION=5.92.1
diff --git a/common/src/main/java/com/duckduckgo/app/global/AppUrl.kt b/common/src/main/java/com/duckduckgo/app/global/AppUrl.kt
@@ -26,6 +26,7 @@ class AppUrl {
         const val ABOUT = "https://$HOST/about"
         const val TOSDR = "https://tosdr.org"
         const val PIXEL = "https://improving.duckduckgo.com"
+        const val EMAIL_SEGMENT = "email"
     }
 
     object ParamKey {
diff --git a/submodules/autofill b/submodules/autofill
@@ -1 +1 @@
-Subproject commit e4a5cc4543eb350bd0da197947ccd3423c999f92
+Subproject commit 8a08e934d538e06735df0b13e31f40ace4517b46

Original file line number	Diff line number	Diff line change
`@@ -119,22 +119,22 @@ class DuckDuckGoUrlDetectorTest {`
`119`	`119`	`}`
`120`	`120`
`121`	`121`	`@Test`
`122`		`- fun whenDomainIsNotDuckDuckGoThenReturnFalse() {`
`123`		`- assertFalse(testee.isDuckDuckGoDomain("https://example.com"))`
	`122`	`+ fun whenIsNotDuckDuckGoEmailUrlThenReturnFalse() {`
	`123`	`+ assertFalse(testee.isDuckDuckGoEmailUrl("https://example.com"))`
`124`	`124`	`}`
`125`	`125`
`126`	`126`	`@Test`
`127`		`- fun whenDomainIsDuckDuckGoThenReturnTrue() {`
`128`		`- assertTrue(testee.isDuckDuckGoDomain("https://duckduckgo.com"))`
	`127`	`+ fun whenIsDuckDuckEmailUrlGoThenReturnTrue() {`
	`128`	`+ assertTrue(testee.isDuckDuckGoEmailUrl("https://duckduckgo.com/email"))`
`129`	`129`	`}`
`130`	`130`
`131`	`131`	`@Test`
`132`		`- fun whenUrlContainsSubdomainAndIsFromDuckDuckGoDomainThenReturnTrue() {`
`133`		`- assertTrue(testee.isDuckDuckGoDomain("https://test.duckduckgo.com"))`
	`132`	`+ fun whenUrlContainsSubdomainAndIsFromDuckDuckGoEmailUrlThenReturnTrue() {`
	`133`	`+ assertTrue(testee.isDuckDuckGoEmailUrl("https://test.duckduckgo.com/email"))`
`134`	`134`	`}`
`135`	`135`
`136`	`136`	`@Test`
`137`		`- fun whenUrlHasNoSchemeAndIsFromDuckDuckGoDomainThenReturnsTrue() {`
`138`		`- assertTrue(testee.isDuckDuckGoDomain("duckduckgo.com"))`
	`137`	`+ fun whenUrlHasNoSchemeAndIsFromDuckDuckGoUrlThenReturnsTrue() {`
	`138`	`+ assertTrue(testee.isDuckDuckGoEmailUrl("duckduckgo.com/email"))`
`139`	`139`	`}`
`140`	`140`	`}`
Original file line number	Diff line number	Diff line change
`@@ -24,8 +24,9 @@ import javax.inject.Inject`
`24`	`24`
`25`	`25`	`class DuckDuckGoUrlDetector @Inject constructor() {`
`26`	`26`
`27`		`- fun isDuckDuckGoDomain(uri: String): Boolean {`
`28`		`- return uri.toUri().baseHost?.contains(AppUrl.Url.HOST) ?: false`
	`27`	`+ fun isDuckDuckGoEmailUrl(url: String): Boolean {`
	`28`	`+ val uri = url.toUri()`
	`29`	`+ return uri.baseHost?.contains(AppUrl.Url.HOST) == true && uri.pathSegments.contains(AppUrl.Url.EMAIL_SEGMENT)`
`29`	`30`	`}`
`30`	`31`
`31`	`32`	`fun isDuckDuckGoUrl(uri: String): Boolean {`
Original file line number	Diff line number	Diff line change
`@@ -50,8 +50,8 @@ class EmailModule {`
`50`	`50`	`}`
`51`	`51`
`52`	`52`	`@Provides`
`53`		`- fun providesEmailInjector(emailManager: EmailManager, duckDuckGoUrlDetector: DuckDuckGoUrlDetector): EmailInjector {`
`54`		`- return EmailInjectorJs(emailManager, duckDuckGoUrlDetector)`
	`53`	`+ fun providesEmailInjector(emailManager: EmailManager, duckDuckGoUrlDetector: DuckDuckGoUrlDetector, dispatcherProvider: DispatcherProvider): EmailInjector {`
	`54`	`+ return EmailInjectorJs(emailManager, duckDuckGoUrlDetector, dispatcherProvider)`
`55`	`55`	`}`
`56`	`56`
`57`	`57`	`@Provides`
Original file line number	Diff line number	Diff line change
`@@ -26,6 +26,7 @@ class AppUrl {`
`26`	`26`	`const val ABOUT = "https://$HOST/about"`
`27`	`27`	`const val TOSDR = "https://tosdr.org"`
`28`	`28`	`const val PIXEL = "https://improving.duckduckgo.com"`
	`29`	`+ const val EMAIL_SEGMENT = "email"`
`29`	`30`	`}`
`30`	`31`
`31`	`32`	`object ParamKey {`