Merge branch 'release/5.22.0'

Author: subsymbolic

app/schemas/com.duckduckgo.app.global.db.AppDatabase/12.json

@@ -202,11 +202,10 @@ class BrowserTabViewModelTest {
             searchCountDao = mockSearchCountDao
         )
 
-        testee.loadData("abc", null)
+        testee.loadData("abc", null, false)
         testee.command.observeForever(mockCommandObserver)
 
         whenever(mockOmnibarConverter.convertQueryToUrl(any())).thenReturn("duckduckgo.com")
-
     }
 
     @After
@@ -317,57 +316,117 @@ class BrowserTabViewModelTest {
     }
 
     @Test
-    fun whenViewModelNotifiedThatWebViewIsLoadingThenViewStateIsUpdated() {
+    fun whenBrowsingAndViewModelNotifiedThatWebViewIsLoadingThenViewStateIsUpdated() {
+        isBrowsing(true)
         testee.loadingStarted("http://example.com")
         assertTrue(loadingViewState().isLoading)
     }
 
     @Test
-    fun whenViewModelNotifiedThatWebViewHasFinishedLoadingThenViewStateIsUpdated() {
+    fun whenNotBrowsingAndViewModelNotifiedThatWebViewIsLoadingThenViewStateIsNotUpdated() {
+        isBrowsing(false)
+        testee.loadingStarted("http://example.com")
+        assertFalse(loadingViewState().isLoading)
+    }
+
+    @Test
+    fun whenBrowsingAndViewModelNotifiedThatWebViewHasFinishedLoadingThenViewStateIsUpdated() {
+        isBrowsing(true)
+        testee.loadingStarted("http://example.com")
         testee.loadingFinished(null)
         assertFalse(loadingViewState().isLoading)
     }
 
     @Test
-    fun whenLoadingFinishedAndInitialUrlNeverProgressedThenUrlUpdated() {
+    fun whenBrowsingAndLoadingFinishedAndInitialUrlNeverProgressedThenUrlUpdated() {
         val initialUrl = "http://foo.com/abc"
         val finalUrl = "http://bar.com/abc"
+        isBrowsing(true)
         testee.loadingStarted(initialUrl)
         testee.loadingFinished(finalUrl)
         assertEquals(finalUrl, testee.url)
     }
 
     @Test
-    fun whenLoadingFinishedAndInitialUrlProgressedThenUrlNotUpdated() {
+    fun whenNotBrowsingAndLoadingFinishedAndInitialUrlNeverProgressedThenUrlNotUpdated() {
+        val initialUrl = "http://foo.com/abc"
+        val finalUrl = "http://bar.com/abc"
+        isBrowsing(false)
+        testee.loadingStarted(initialUrl)
+        testee.loadingFinished(finalUrl)
+        assertNull(testee.url)
+    }
+
+    @Test
+    fun whenBrowsingAndLoadingFinishedAndInitialUrlProgressedThenUrlNotUpdated() {
         val initialUrl = "http://foo.com/abc"
         val finalUrl = "http://foo.com/xyz"
+        isBrowsing(true)
         testee.loadingStarted(initialUrl)
         testee.progressChanged(initialUrl, 10)
         testee.loadingFinished(finalUrl)
         assertEquals(initialUrl, testee.url)
     }
 
     @Test
-    fun whenLoadingFinishedWithUrlThenSiteVisitedEntryAddedToLeaderboardDao() {
+    fun whenNotBrowsingAndLoadingFinishedAndInitialUrlProgressedThenUrlNotUpdated() {
+        val initialUrl = "http://foo.com/abc"
+        val finalUrl = "http://foo.com/xyz"
+        isBrowsing(false)
+        testee.loadingStarted(initialUrl)
+        testee.progressChanged(initialUrl, 10)
+        testee.loadingFinished(finalUrl)
+        assertNull(testee.url)
+    }
+
+    @Test
+    fun whenBrowsingAndLoadingFinishedWithUrlThenSiteVisitedEntryAddedToLeaderboardDao() {
+        isBrowsing(true)
         testee.loadingStarted("http://example.com/abc")
         testee.loadingFinished("http://example.com/abc")
         verify(mockNetworkLeaderboardDao).insert(SiteVisitedEntity("example.com"))
     }
 
     @Test
-    fun whenLoadingFinishedWithUrlThenOmnibarTextUpdatedToMatch() {
+    fun whenNotBrowsingAndLoadingFinishedWithUrlThenSiteVisitedEntryNotAddedToLeaderboardDao() {
+        isBrowsing(false)
+        testee.loadingStarted("http://example.com/abc")
+        testee.loadingFinished("http://example.com/abc")
+        verify(mockNetworkLeaderboardDao, never()).insert(SiteVisitedEntity("example.com"))
+    }
+
+    @Test
+    fun whenBrowsingAndLoadingFinishedWithUrlThenOmnibarTextUpdatedToMatch() {
+        isBrowsing(true)
         val exampleUrl = "http://example.com/abc"
         testee.loadingFinished(exampleUrl)
         assertEquals(exampleUrl, omnibarViewState().omnibarText)
     }
 
     @Test
-    fun whenLoadingFinishedWithQueryUrlThenOmnibarTextUpdatedToShowQuery() {
+    fun whenNotBrowsingAndLoadingFinishedWithUrlThenOmnibarTextRemainsBlank() {
+        isBrowsing(false)
+        val exampleUrl = "http://example.com/abc"
+        testee.loadingFinished(exampleUrl)
+        assertEquals("", omnibarViewState().omnibarText)
+    }
+
+    @Test
+    fun whenBrowsingAndLoadingFinishedWithQueryUrlThenOmnibarTextUpdatedToShowQuery() {
+        isBrowsing(true)
         val queryUrl = "http://duckduckgo.com?q=test"
         testee.loadingFinished(queryUrl)
         assertEquals("test", omnibarViewState().omnibarText)
     }
 
+    @Test
+    fun whenNotBrowsingAndLoadingFinishedWithQueryUrlThenOmnibarTextextRemainsBlank() {
+        isBrowsing(false)
+        val queryUrl = "http://duckduckgo.com?q=test"
+        testee.loadingFinished(queryUrl)
+        assertEquals("", omnibarViewState().omnibarText)
+    }
+
     @Test
     fun whenLoadingFinishedWithNoUrlThenOmnibarTextUpdatedToMatch() {
         val exampleUrl = "http://example.com/abc"
@@ -406,13 +465,23 @@ class BrowserTabViewModelTest {
     }
 
     @Test
-    fun whenUrlStartsLoadingWithProgressChangeThenUrlUpdated() {
+    fun whenBrowsingAndUrlStartsLoadingWithProgressChangeThenUrlUpdated() {
         val url = "foo.com"
+        isBrowsing(true)
         testee.loadingStarted(url)
         testee.progressChanged(url, 10)
         assertEquals(url, testee.url)
     }
 
+    @Test
+    fun whenNotBrowsingAndUrlStartsLoadingWithProgressChangeThenUrlNotUpdated() {
+        val url = "foo.com"
+        isBrowsing(false)
+        testee.loadingStarted(url)
+        testee.progressChanged(url, 10)
+        assertNull(testee.url)
+    }
+
     @Test
     fun whenUrlStartsLoadingButProgressHasNotChangedThenUrlNotUpdated() {
         testee.loadingStarted("foo.com")
@@ -426,11 +495,17 @@ class BrowserTabViewModelTest {
     }
 
     @Test
-    fun whenUrlChangedThenViewStateIsUpdated() {
-        changeUrl("duckduckgo.com")
+    fun whenBrowsingAndUrlChangedThenViewStateIsUpdated() {
+        changeUrl("duckduckgo.com", true)
         assertEquals("duckduckgo.com", omnibarViewState().omnibarText)
     }
 
+    @Test
+    fun whenNotBrowsingAndUrlChangedThenUrlIsNotUpdated() {
+        changeUrl("duckduckgo.com", false)
+        assertEquals("", omnibarViewState().omnibarText)
+    }
+
     @Test
     fun whenUrlChangedWithDuckDuckGoUrlContainingQueryThenUrlRewrittenToContainQuery() {
         changeUrl("http://duckduckgo.com?q=test")
@@ -456,7 +531,9 @@ class BrowserTabViewModelTest {
     }
 
     @Test
-    fun whenViewModelGetsProgressUpdateThenViewStateIsUpdated() {
+    fun whenBrowsingAndViewModelGetsProgressUpdateThenViewStateIsUpdated() {
+        isBrowsing(true)
+
         testee.progressChanged("", 0)
         assertEquals(0, loadingViewState().progress)
 
@@ -467,6 +544,14 @@ class BrowserTabViewModelTest {
         assertEquals(100, loadingViewState().progress)
     }
 
+
+    @Test
+    fun whenNotBrowserAndViewModelGetsProgressUpdateThenViewStateIsNotUpdated() {
+        isBrowsing(false)
+        testee.progressChanged("", 10)
+        assertEquals(0, loadingViewState().progress)
+    }
+
     @Test
     fun whenLoadingStartedThenPrivacyGradeIsCleared() {
         testee.loadingStarted("http://example.com")
@@ -751,6 +836,104 @@ class BrowserTabViewModelTest {
         assertFalse(browserViewState().isDesktopBrowsingMode)
     }
 
+    @Test
+    fun whenHomeShowingAndNeverBrowsedThenForwardButtonInactive() {
+        setupNavigation(isBrowsing = false)
+        assertFalse(browserViewState().canGoForward)
+    }
+
+    @Test
+    fun whenHomeShowingByPressingBackOnBrowserThenForwardButtonActive() {
+        setupNavigation(isBrowsing = true)
+        testee.onUserPressedBack()
+        assertFalse(browserViewState().browserShowing)
+        assertTrue(browserViewState().canGoForward)
+    }
+
+    @Test
+    fun whenBrowserShowingAndCanGoForwardThenForwardButtonActive() {
+        setupNavigation(isBrowsing = true, canGoForward = true)
+        assertTrue(browserViewState().canGoForward)
+    }
+
+    @Test
+    fun whenBrowserShowingAndCannotGoForwardThenForwardButtonInactive() {
+        setupNavigation(isBrowsing = true, canGoForward = false)
+        assertFalse(browserViewState().canGoForward)
+    }
+
+    @Test
+    fun whenHomeShowingThenBackButtonInactiveEvenIfBrowserCanGoBack() {
+        setupNavigation(isBrowsing = false, canGoBack = false)
+        assertFalse(browserViewState().canGoBack)
+
+        setupNavigation(isBrowsing = false, canGoBack = true)
+        assertFalse(browserViewState().canGoBack)
+    }
+
+    @Test
+    fun whenBrowserShowingAndCanGoBackThenBackButtonActive() {
+        setupNavigation(isBrowsing = true, canGoBack = true)
+        assertTrue(browserViewState().canGoBack)
+    }
+
+    @Test
+    fun whenBrowserShowingAndCannotGoBackAndSkipHomeThenBackButtonInactive() {
+        setupNavigation(skipHome = true, isBrowsing = true, canGoBack = false)
+        assertFalse(browserViewState().canGoBack)
+    }
+
+    @Test
+    fun whenBrowserShowingAndCannotGoBackAndNotSkipHomeThenBackButtonActive() {
+        setupNavigation(skipHome = false, isBrowsing = true, canGoBack = false)
+        assertTrue(browserViewState().canGoBack)
+    }
+
+    @Test
+    fun whenUserBrowsingPressesForwardThenNavigatesForward() {
+        isBrowsing(true)
+        testee.onUserPressedForward()
+        assertTrue(captureCommands().lastValue == Command.NavigateForward)
+    }
+
+    @Test
+    fun whenUserOnHomePressesForwardThenBrowserShownAndPageRefreshed() {
+        isBrowsing(false)
+        testee.onUserPressedForward()
+        assertTrue(browserViewState().browserShowing)
+        assertTrue(captureCommands().lastValue == Command.Refresh)
+    }
+
+    @Test
+    fun whenUserBrowsingPressesBackAndBrowserCanGoBackThenNavigatesToPreviousPageAndHandledTrue() {
+        setupNavigation(isBrowsing = true, canGoBack = true, stepsToPreviousPage = 2)
+        assertTrue(testee.onUserPressedBack())
+
+        val backCommand = captureCommands().lastValue as Command.NavigateBack
+        assertNotNull(backCommand)
+        assertEquals(2, backCommand.steps)
+    }
+
+    @Test
+    fun whenUserBrowsingPressesBackAndBrowserCannotGoBackAndHomeNotSkippedThenHomeShownAndHandledTrue() {
+        setupNavigation(skipHome = false, isBrowsing = true, canGoBack = false)
+        assertTrue(testee.onUserPressedBack())
+        assertFalse(browserViewState().browserShowing)
+        assertEquals("", omnibarViewState().omnibarText)
+    }
+
+    @Test
+    fun whenUserBrowsingPressesBackAndBrowserCannotGoBackAndHomeIsSkippedThenHandledFalse() {
+        setupNavigation(skipHome = true, isBrowsing = false, canGoBack = false)
+        assertFalse(testee.onUserPressedBack())
+    }
+
+    @Test
+    fun whenUserOnHomePressesBackThenReturnsHandledFalse() {
+        isBrowsing(false)
+        assertFalse(testee.onUserPressedBack())
+    }
+
     @Test
     fun whenUserSelectsDesktopSiteWhenOnMobileSpecificSiteThenUrlModified() {
         testee.desktopSiteModeToggled("http://m.example.com", desktopSiteRequested = true)
@@ -802,6 +985,7 @@ class BrowserTabViewModelTest {
 
     @Test
     fun whenOnSiteAndBrokenSiteSelectedThenBrokenSiteFeedbackCommandSentWithUrl() {
+        isBrowsing(true)
         changeUrl("foo.com")
         testee.onBrokenSiteSelected()
         val command = captureCommands().value as Command.BrokenSiteFeedback
@@ -885,7 +1069,22 @@ class BrowserTabViewModelTest {
         verify(mockHandler, atLeastOnce()).proceed(username, password)
     }
 
-    private fun changeUrl(url: String?) {
+    private fun isBrowsing(isBrowsing: Boolean) {
+        testee.browserViewState.value = browserViewState().copy(browserShowing = isBrowsing)
+    }
+
+    private fun setupNavigation(skipHome: Boolean = false, isBrowsing: Boolean, canGoForward: Boolean = false, canGoBack: Boolean = false, stepsToPreviousPage:Int = 0) {
+        testee.skipHome = skipHome
+        isBrowsing(isBrowsing)
+        val nav: BrowserWebViewClient.BrowserNavigationOptions = mock()
+        whenever(nav.canGoForward).thenReturn(canGoForward)
+        whenever(nav.canGoBack).thenReturn(canGoBack)
+        whenever(nav.stepsToPreviousPage).thenReturn(stepsToPreviousPage)
+        testee.navigationOptionsChanged(nav)
+    }
+
+    private fun changeUrl(url: String?, isBrowsing: Boolean = true) {
+        isBrowsing(isBrowsing)
         testee.loadingStarted(url)
         testee.progressChanged(url, 100)
     }

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

@@ -111,12 +111,12 @@ class BrowserViewModelTest {
     @Test
     fun whenTabsUpdatedAndNoTabsThenNewTabAddedToRepository() {
         testee.onTabsUpdated(ArrayList())
-        verify(mockTabRepository).add(null, true)
+        verify(mockTabRepository).add(null, false, true)
     }
 
     @Test
     fun whenTabsUpdatedWithTabsThenNewTabNotLaunched() {
-        testee.onTabsUpdated(asList(TabEntity(TAB_ID, "", "", true, 0)))
+        testee.onTabsUpdated(asList(TabEntity(TAB_ID, "", "", false, true, 0)))
         verify(mockCommandObserver, never()).onChanged(any())
     }