Merge branch 'release/5.89.0'

Author: joshliebe

app/build.gradle

@@ -41,6 +41,9 @@ android {
             }
         }
     }
+    buildFeatures {
+        viewBinding = true
+    }
     compileOptions {
         sourceCompatibility = JavaVersion.VERSION_1_8
         targetCompatibility = JavaVersion.VERSION_1_8
@@ -122,6 +125,7 @@ android {
 dependencies {
     implementation project(path: ':statistics')
     implementation project(path: ':common')
+    implementation project(path: ':common-ui')
     implementation project(path: ':di')
 
     implementation AndroidX.legacy.supportV4
@@ -164,6 +168,7 @@ dependencies {
     implementation AndroidX.fragmentKtx
 
     // ViewModel and LiveData
+    implementation AndroidX.lifecycle.runtimeKtx
     implementation AndroidX.lifecycle.viewModelKtx
     implementation AndroidX.lifecycle.liveDataKtx
     implementation AndroidX.lifecycle.process
@@ -213,6 +218,7 @@ dependencies {
     androidTestImplementation Testing.mockito.kotlin
     androidTestImplementation Square.okHttp3.mockWebServer
     androidTestImplementation "org.jetbrains.kotlin:kotlin-reflect:_"
+    androidTestImplementation 'app.cash.turbine:turbine:_'
 }
 
 tasks.register('fastlaneVersionCode') {

app/src/androidTest/java/com/duckduckgo/app/browser/BrowserChromeClientTest.kt

@@ -20,31 +20,45 @@ package com.duckduckgo.app.browser
 
 import android.content.Context
 import android.graphics.Bitmap
+import android.net.Uri
 import android.os.Message
 import android.view.View
+import android.webkit.ValueCallback
 import android.webkit.WebChromeClient
 import android.webkit.WebView
 import androidx.test.annotation.UiThreadTest
 import androidx.test.platform.app.InstrumentationRegistry.getInstrumentation
 import com.duckduckgo.app.global.exception.UncaughtExceptionRepository
+import com.duckduckgo.app.global.exception.UncaughtExceptionSource
 import com.nhaarman.mockitokotlin2.*
+import junit.framework.TestCase.assertTrue
+import kotlinx.coroutines.ExperimentalCoroutinesApi
+import kotlinx.coroutines.runBlocking
+import kotlinx.coroutines.test.TestCoroutineScope
 import org.junit.Before
 import org.junit.Test
+import org.mockito.ArgumentMatchers.anyInt
+import org.mockito.ArgumentMatchers.anyString
 
 class BrowserChromeClientTest {
 
     private lateinit var testee: BrowserChromeClient
     private lateinit var webView: TestWebView
     private lateinit var mockWebViewClientListener: WebViewClientListener
     private lateinit var mockUncaughtExceptionRepository: UncaughtExceptionRepository
+    private lateinit var mockFilePathCallback: ValueCallback<Array<Uri>>
+    private lateinit var mockFileChooserParams: WebChromeClient.FileChooserParams
     private val fakeView = View(getInstrumentation().targetContext)
 
+    @ExperimentalCoroutinesApi
     @UiThreadTest
     @Before
     fun setup() {
         mockUncaughtExceptionRepository = mock()
-        testee = BrowserChromeClient(mockUncaughtExceptionRepository)
+        testee = BrowserChromeClient(mockUncaughtExceptionRepository, TestCoroutineScope())
         mockWebViewClientListener = mock()
+        mockFilePathCallback = mock()
+        mockFileChooserParams = mock()
         testee.webViewClientListener = mockWebViewClientListener
         webView = TestWebView(getInstrumentation().targetContext)
     }
@@ -78,12 +92,28 @@ class BrowserChromeClientTest {
         verify(mockCustomViewCallback, times(2)).onCustomViewHidden()
     }
 
+    @Test
+    fun whenCustomViewShownThrowsExceptionThenRecordException() = runBlocking {
+        val exception = RuntimeException()
+        whenever(mockWebViewClientListener.goFullScreen(any())).thenThrow(exception)
+        testee.onShowCustomView(fakeView, null)
+        verify(mockUncaughtExceptionRepository).recordUncaughtException(exception, UncaughtExceptionSource.SHOW_CUSTOM_VIEW)
+    }
+
     @Test
     fun whenHideCustomViewCalledThenListenerInstructedToExistFullScreen() {
         testee.onHideCustomView()
         verify(mockWebViewClientListener).exitFullScreen()
     }
 
+    @Test
+    fun whenHideCustomViewThrowsExceptionThenRecordException() = runBlocking {
+        val exception = RuntimeException()
+        whenever(mockWebViewClientListener.exitFullScreen()).thenThrow(exception)
+        testee.onHideCustomView()
+        verify(mockUncaughtExceptionRepository).recordUncaughtException(exception, UncaughtExceptionSource.HIDE_CUSTOM_VIEW)
+    }
+
     @UiThreadTest
     @Test
     fun whenOnProgressChangedCalledThenListenerInstructedToUpdateProgress() {
@@ -98,6 +128,15 @@ class BrowserChromeClientTest {
         verify(mockWebViewClientListener).navigationStateChanged(any())
     }
 
+    @UiThreadTest
+    @Test
+    fun whenOnProgressChangedThrowsExceptionThenRecordException() = runBlocking {
+        val exception = RuntimeException()
+        whenever(mockWebViewClientListener.progressChanged(anyInt())).thenThrow(exception)
+        testee.onProgressChanged(webView, 10)
+        verify(mockUncaughtExceptionRepository).recordUncaughtException(exception, UncaughtExceptionSource.ON_PROGRESS_CHANGED)
+    }
+
     @UiThreadTest
     @Test
     fun whenOnCreateWindowWithUserGestureThenMessageOpenedInNewTab() {
@@ -120,6 +159,36 @@ class BrowserChromeClientTest {
         verify(mockWebViewClientListener).iconReceived(webView.url, bitmap)
     }
 
+    @Test
+    fun whenOnReceivedTitleThenTitleReceived() {
+        val title = "title"
+        testee.onReceivedTitle(webView, title)
+        verify(mockWebViewClientListener).titleReceived(title)
+    }
+
+    @Test
+    fun whenOnReceivedTitleThrowsExceptionThenRecordException() = runBlocking {
+        val exception = RuntimeException()
+        whenever(mockWebViewClientListener.titleReceived(anyString())).thenThrow(exception)
+        testee.onReceivedTitle(webView, "")
+        verify(mockUncaughtExceptionRepository).recordUncaughtException(exception, UncaughtExceptionSource.RECEIVED_PAGE_TITLE)
+    }
+
+    @Test
+    fun whenOnShowFileChooserCalledThenShowFileChooser() {
+        assertTrue(testee.onShowFileChooser(webView, mockFilePathCallback, mockFileChooserParams))
+        verify(mockWebViewClientListener).showFileChooser(mockFilePathCallback, mockFileChooserParams)
+    }
+
+    @Test
+    fun whenShowFileChooserThrowsExceptionThenRecordException() = runBlocking {
+        val exception = RuntimeException()
+        whenever(mockWebViewClientListener.showFileChooser(any(), any())).thenThrow(exception)
+        assertTrue(testee.onShowFileChooser(webView, mockFilePathCallback, mockFileChooserParams))
+        verify(mockUncaughtExceptionRepository).recordUncaughtException(exception, UncaughtExceptionSource.SHOW_FILE_CHOOSER)
+        verify(mockFilePathCallback).onReceiveValue(null)
+    }
+
     private val mockMsg = Message().apply {
         target = mock()
         obj = mock<WebView.WebViewTransport>()

app/src/androidTest/java/com/duckduckgo/app/browser/BrowserTabViewModelTest.kt

@@ -16,6 +16,7 @@
 
 package com.duckduckgo.app.browser
 
+import android.content.Intent
 import android.graphics.Bitmap
 import android.net.Uri
 import android.view.MenuItem
@@ -47,6 +48,7 @@ import com.duckduckgo.app.browser.BrowserTabViewModel.FireButton
 import com.duckduckgo.app.browser.LongPressHandler.RequiredAction.DownloadFile
 import com.duckduckgo.app.browser.LongPressHandler.RequiredAction.OpenInNewTab
 import com.duckduckgo.app.browser.addtohome.AddToHomeCapabilityDetector
+import com.duckduckgo.app.browser.applinks.AppLinksHandler
 import com.duckduckgo.app.browser.downloader.FileDownloader
 import com.duckduckgo.app.browser.favicon.FaviconManager
 import com.duckduckgo.app.browser.favicon.FaviconSource
@@ -112,15 +114,11 @@ import com.duckduckgo.app.trackerdetection.EntityLookup
 import com.duckduckgo.app.trackerdetection.model.TrackingEvent
 import com.duckduckgo.app.usage.search.SearchCountDao
 import com.duckduckgo.app.widget.ui.WidgetCapabilities
+import com.nhaarman.mockitokotlin2.*
 import com.nhaarman.mockitokotlin2.any
-import com.nhaarman.mockitokotlin2.anyOrNull
 import com.nhaarman.mockitokotlin2.atLeastOnce
-import com.nhaarman.mockitokotlin2.doAnswer
 import com.nhaarman.mockitokotlin2.doReturn
 import com.nhaarman.mockitokotlin2.eq
-import com.nhaarman.mockitokotlin2.firstValue
-import com.nhaarman.mockitokotlin2.lastValue
-import com.nhaarman.mockitokotlin2.mock
 import com.nhaarman.mockitokotlin2.whenever
 import dagger.Lazy
 import io.reactivex.Observable
@@ -135,18 +133,21 @@ import kotlinx.coroutines.flow.asStateFlow
 import kotlinx.coroutines.flow.consumeAsFlow
 import kotlinx.coroutines.flow.flowOf
 import kotlinx.coroutines.runBlocking
+import kotlinx.coroutines.test.TestCoroutineScope
 import kotlinx.coroutines.test.runBlockingTest
 import org.junit.After
 import org.junit.Assert.*
 import org.junit.Before
 import org.junit.Rule
 import org.junit.Test
 import org.mockito.ArgumentCaptor
-import org.mockito.ArgumentMatchers.anyString
 import org.mockito.Captor
 import org.mockito.Mock
 import org.mockito.Mockito
 import org.mockito.Mockito.*
+import org.mockito.Mockito.never
+import org.mockito.Mockito.times
+import org.mockito.Mockito.verify
 import org.mockito.MockitoAnnotations
 import org.mockito.internal.util.DefaultMockingDetails
 import java.io.File
@@ -263,6 +264,12 @@ class BrowserTabViewModelTest {
     @Mock
     private lateinit var mockFavoritesRepository: FavoritesRepository
 
+    @Mock
+    private lateinit var mockSpecialUrlDetector: SpecialUrlDetector
+
+    @Mock
+    private lateinit var mockAppLinksHandler: AppLinksHandler
+
     private val lazyFaviconManager = Lazy { mockFaviconManager }
 
     private lateinit var mockAutoCompleteApi: AutoCompleteApi
@@ -272,6 +279,9 @@ class BrowserTabViewModelTest {
     @Captor
     private lateinit var commandCaptor: ArgumentCaptor<Command>
 
+    @Captor
+    private lateinit var appLinkCaptor: ArgumentCaptor<() -> Unit>
+
     private lateinit var db: AppDatabase
 
     private lateinit var testee: BrowserTabViewModel
@@ -351,7 +361,7 @@ class BrowserTabViewModelTest {
             bookmarksDao = mockBookmarksDao,
             longPressHandler = mockLongPressHandler,
             webViewSessionStorage = webViewSessionStorage,
-            specialUrlDetector = SpecialUrlDetectorImpl(),
+            specialUrlDetector = mockSpecialUrlDetector,
             faviconManager = mockFaviconManager,
             addToHomeCapabilityDetector = mockAddToHomeCapabilityDetector,
             ctaViewModel = ctaViewModel,
@@ -373,7 +383,9 @@ class BrowserTabViewModelTest {
             globalPrivacyControl = GlobalPrivacyControlManager(mockSettingsStore),
             fireproofDialogsEventHandler = fireproofDialogsEventHandler,
             emailManager = mockEmailManager,
-            favoritesRepository = mockFavoritesRepository
+            favoritesRepository = mockFavoritesRepository,
+            appCoroutineScope = TestCoroutineScope(),
+            appLinksHandler = mockAppLinksHandler
         )
 
         testee.loadData("abc", null, false)
@@ -558,17 +570,6 @@ class BrowserTabViewModelTest {
         verify(mockFavoritesRepository, times(0)).insert(any(), any())
     }
 
-    @Test
-    fun whenQuickAccessItemClickedThenSubmitNewQuery() {
-        val savedSite = Favorite(1, "title", "http://example.com", 0)
-
-        testee.onQuickAccesItemClicked(savedSite)
-
-        assertCommandIssued<Command.SubmitQuery> {
-            assertEquals("http://example.com", this.url)
-        }
-    }
-
     @Test
     fun whenQuickAccessDeletedThenRepositoryUpdated() = coroutineRule.runBlocking {
         val savedSite = Favorite(1, "title", "http://example.com", 0)
@@ -1123,6 +1124,14 @@ class BrowserTabViewModelTest {
         assertTrue(commandCaptor.allValues.any { it == Command.HideKeyboard })
     }
 
+    @Test
+    fun whenEnteringAppLinkQueryThenNavigateInBrowser() {
+        whenever(mockOmnibarConverter.convertQueryToUrl("foo", null)).thenReturn("foo.com")
+        testee.onUserSubmittedQuery("foo")
+        verify(mockCommandObserver, atLeastOnce()).onChanged(commandCaptor.capture())
+        assertTrue(commandCaptor.allValues.any { it == Command.HideKeyboard })
+    }
+
     @Test
     fun whenNotifiedEnteringFullScreenThenViewStateUpdatedWithFullScreenFlag() {
         val stubView = View(getInstrumentation().targetContext)
@@ -3009,24 +3018,24 @@ class BrowserTabViewModelTest {
     @Test
     fun whenExternalAppLinkClickedIfGpcIsEnabledThenAddHeaderToUrl() {
         whenever(mockSettingsStore.globalPrivacyControlEnabled).thenReturn(true)
-        val intentType = SpecialUrlDetector.UrlType.IntentType("query", mock(), null)
+        val intentType = SpecialUrlDetector.UrlType.NonHttpAppLink("query", mock(), null)
 
-        testee.externalAppLinkClicked(intentType)
+        testee.nonHttpAppLinkClicked(intentType)
         verify(mockCommandObserver, atLeastOnce()).onChanged(commandCaptor.capture())
 
-        val command = commandCaptor.lastValue as Command.HandleExternalAppLink
+        val command = commandCaptor.lastValue as Command.HandleNonHttpAppLink
         assertEquals(GPC_HEADER_VALUE, command.headers[GPC_HEADER])
     }
 
     @Test
     fun whenExternalAppLinkClickedIfGpcIsDisabledThenDoNotAddHeaderToUrl() {
         whenever(mockSettingsStore.globalPrivacyControlEnabled).thenReturn(false)
-        val intentType = SpecialUrlDetector.UrlType.IntentType("query", mock(), null)
+        val intentType = SpecialUrlDetector.UrlType.NonHttpAppLink("query", mock(), null)
 
-        testee.externalAppLinkClicked(intentType)
+        testee.nonHttpAppLinkClicked(intentType)
         verify(mockCommandObserver, atLeastOnce()).onChanged(commandCaptor.capture())
 
-        val command = commandCaptor.lastValue as Command.HandleExternalAppLink
+        val command = commandCaptor.lastValue as Command.HandleNonHttpAppLink
         assertTrue(command.headers.isEmpty())
     }
 
@@ -3195,6 +3204,54 @@ class BrowserTabViewModelTest {
         assertCommandNotIssued<Command.ShowEmailTooltip>()
     }
 
+    @Test
+    fun whenHandleAppLinkCalledThenHandleAppLink() {
+        val urlType = SpecialUrlDetector.UrlType.AppLink(uriString = "http://example.com")
+        testee.handleAppLink(urlType, isRedirect = false, isForMainFrame = true)
+        verify(mockAppLinksHandler).handleAppLink(isRedirect = eq(false), isForMainFrame = eq(true), capture(appLinkCaptor))
+        appLinkCaptor.value.invoke()
+        assertCommandIssued<Command.HandleAppLink>()
+    }
+
+    @Test
+    fun whenHandleNonHttpAppLinkCalledThenHandleNonHttpAppLink() {
+        val urlType = SpecialUrlDetector.UrlType.NonHttpAppLink("market://details?id=com.example", Intent(), "http://example.com")
+        testee.handleNonHttpAppLink(urlType, false)
+        verify(mockAppLinksHandler).handleNonHttpAppLink(isRedirect = eq(false), capture(appLinkCaptor))
+        appLinkCaptor.value.invoke()
+        assertCommandIssued<Command.HandleNonHttpAppLink>()
+    }
+
+    @Test
+    fun whenResetAppLinkStateCalledThenResetAppLinkState() {
+        testee.resetAppLinkState()
+        verify(mockAppLinksHandler).reset()
+    }
+
+    @Test
+    fun whenUserSubmittedQueryIsAppLinkThenOpenAppLinkInBrowser() {
+        whenever(mockOmnibarConverter.convertQueryToUrl("foo", null)).thenReturn("foo.com")
+        whenever(mockSpecialUrlDetector.determineType(anyString())).thenReturn(SpecialUrlDetector.UrlType.AppLink(uriString = "http://foo.com"))
+        testee.onUserSubmittedQuery("foo")
+        verify(mockAppLinksHandler).enterBrowserState()
+        assertCommandIssued<Navigate>()
+    }
+
+    @Test
+    fun whenSubmittedQueryAndNavigationStateIsNullThenResetHistoryCommandSent() {
+        whenever(mockOmnibarConverter.convertQueryToUrl("nytimes.com", null)).thenReturn("nytimes.com")
+        testee.onUserSubmittedQuery("nytimes.com")
+        assertCommandIssued<Command.ResetHistory>()
+    }
+
+    @Test
+    fun whenSubmittedQueryAndNavigationStateIsNotNullThenResetHistoryCommandNotSent() {
+        setupNavigation(isBrowsing = true)
+        whenever(mockOmnibarConverter.convertQueryToUrl("nytimes.com", null)).thenReturn("nytimes.com")
+        testee.onUserSubmittedQuery("nytimes.com")
+        assertCommandNotIssued<Command.ResetHistory>()
+    }
+
     private suspend fun givenFireButtonPulsing() {
         whenever(mockUserStageStore.getUserAppStage()).thenReturn(AppStage.DAX_ONBOARDING)
         dismissedCtaDaoChannel.send(listOf(DismissedCta(CtaId.DAX_DIALOG_TRACKERS_FOUND)))