Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(47)

Unified Diff: chrome/android/junit/src/org/chromium/chrome/browser/offlinepages/OfflinePageTabObserverTest.java

Issue 1822853002: [Offline pages] Refactoring: Merge Connectivity Listener into TabObserver (Closed) Base URL: https://chromium.googlesource.com/chromium/src.git@spy-chrome-activity
Patch Set: Addressing CR feedback Created 4 years, 9 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
« no previous file with comments | « chrome/android/javatests/src/org/chromium/chrome/browser/offlinepages/OfflinePageUtilsTest.java ('k') | no next file » | no next file with comments »
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
Index: chrome/android/junit/src/org/chromium/chrome/browser/offlinepages/OfflinePageTabObserverTest.java
diff --git a/chrome/android/junit/src/org/chromium/chrome/browser/offlinepages/OfflinePageTabObserverTest.java b/chrome/android/junit/src/org/chromium/chrome/browser/offlinepages/OfflinePageTabObserverTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..82064477f4791b1d27f75c1f79452babb8bef2bf
--- /dev/null
+++ b/chrome/android/junit/src/org/chromium/chrome/browser/offlinepages/OfflinePageTabObserverTest.java
@@ -0,0 +1,329 @@
+// Copyright 2016 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+package org.chromium.chrome.browser.offlinepages;
+
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+import static org.mockito.Mockito.any;
+import static org.mockito.Mockito.doNothing;
+import static org.mockito.Mockito.doReturn;
+import static org.mockito.Mockito.eq;
+import static org.mockito.Mockito.spy;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+
+import android.content.Context;
+
+import org.chromium.base.BaseChromiumApplication;
+import org.chromium.base.test.util.Feature;
+import org.chromium.chrome.browser.snackbar.SnackbarManager;
+import org.chromium.chrome.browser.snackbar.SnackbarManager.SnackbarController;
+import org.chromium.chrome.browser.tab.Tab;
+import org.chromium.testing.local.LocalRobolectricTestRunner;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Mock;
+import org.mockito.MockitoAnnotations;
+import org.robolectric.annotation.Config;
+
+/**
+ * Unit tests for OfflinePageUtils.
+ */
+@RunWith(LocalRobolectricTestRunner.class)
+@Config(manifest = Config.NONE, application = BaseChromiumApplication.class)
+public class OfflinePageTabObserverTest {
+ // Using a null tab, as it cannot be mocked. TabHelper will help return proper mocked responses.
+ private static final Tab TAB = null;
+ private static final int TAB_ID = 77;
+
+ @Mock private Context mContext;
+ @Mock private SnackbarManager mSnackbarManager;
+ @Mock private SnackbarController mSnackbarController;
+ @Mock private OfflinePageTabObserver.TabHelper mTabHelper;
+
+ private OfflinePageTabObserver createObserver() {
+ OfflinePageTabObserver observer =
+ spy(new OfflinePageTabObserver(mContext, mSnackbarManager, mSnackbarController));
+ // Mocking out all of the calls that touch on NetworkChangeNotifier, which we cannot
+ // directly mock out.
+ doNothing().when(observer).startObservingNetworkChanges();
+ doNothing().when(observer).stopObservingNetworkChanges();
+ // TODO(fgorski): This call has to be mocked out until we update OfflinePageUtils.
+ // It also goes to NetworkChangeNotifier from there.
+ doReturn(false).when(observer).isConnected();
+ // TODO(fgorski): This call has to be mocked out until we update OfflinePageUtils.
+ doNothing().when(observer).showReloadSnackbar();
+ return observer;
+ }
+
+ @Before
+ public void setUp() throws Exception {
+ MockitoAnnotations.initMocks(this);
+
+ // Setting up a mock tab helper. These are the values common to most tests, but individual
+ // tests might easily overwrite them.
+ doReturn(TAB_ID).when(mTabHelper).getTabId(any(Tab.class));
+ doReturn(true).when(mTabHelper).isTabShowing(any(Tab.class));
+ doReturn(true).when(mTabHelper).isOfflinePage(any(Tab.class));
+ OfflinePageTabObserver.setTabHelperForTesting(mTabHelper);
+
+ // Setting up mock snackbar manager.
+ doNothing().when(mSnackbarManager).dismissSnackbars(eq(mSnackbarController));
+ }
+
+ @Test
+ @Feature({"OfflinePages"})
+ public void testBasicState() {
+ OfflinePageTabObserver observer = createObserver();
+ assertFalse(observer.isObservingNetworkChanges());
+ assertFalse(observer.wasSnackbarShown());
+ }
+
+ @Test
+ @Feature({"OfflinePages"})
+ public void testStartObservingTab() {
+ OfflinePageTabObserver observer = createObserver();
+
+ doReturn(false).when(mTabHelper).isOfflinePage(any(Tab.class));
+ observer.startObservingTab(TAB);
+
+ assertFalse(observer.isObservingNetworkChanges());
+ assertFalse(observer.isObservingTab(TAB));
+ assertFalse(observer.wasSnackbarShown());
+
+ doReturn(true).when(mTabHelper).isOfflinePage(any(Tab.class));
+ observer.startObservingTab(TAB);
+
+ assertTrue(observer.isObservingNetworkChanges());
+ assertTrue(observer.isObservingTab(TAB));
+ assertFalse(observer.wasSnackbarShown());
+ }
+
+ @Test
+ @Feature({"OfflinePages"})
+ public void testStopObservingTab() {
+ OfflinePageTabObserver observer = createObserver();
+
+ doReturn(true).when(mTabHelper).isOfflinePage(any(Tab.class));
+ observer.startObservingTab(TAB);
+
+ assertTrue(observer.isObservingNetworkChanges());
+ assertTrue(observer.isObservingTab(TAB));
+ assertFalse(observer.wasSnackbarShown());
+
+ // Try to stop observing a tab that is not observed.
+ doReturn(42).when(mTabHelper).getTabId(any(Tab.class));
+ observer.stopObservingTab(TAB);
+
+ assertFalse(observer.isObservingTab(TAB));
+ doReturn(TAB_ID).when(mTabHelper).getTabId(any(Tab.class));
+ assertTrue(observer.isObservingTab(TAB));
+ assertTrue(observer.isObservingNetworkChanges());
+ assertFalse(observer.wasSnackbarShown());
+
+ observer.stopObservingTab(TAB);
+ assertFalse(observer.isObservingNetworkChanges());
+ assertFalse(observer.isObservingTab(TAB));
+ assertFalse(observer.wasSnackbarShown());
+ }
+
+ @Test
+ @Feature({"OfflinePages"})
+ public void testOnShown() {
+ OfflinePageTabObserver observer = createObserver();
+
+ observer.startObservingTab(TAB);
+ observer.onShown(TAB);
+
+ verify(observer, times(0)).showReloadSnackbar();
+ assertFalse(observer.wasSnackbarShown());
+
+ // Make sure the tab is hidden.
+ doReturn(false).when(mTabHelper).isTabShowing(any(Tab.class));
+ observer.onHidden(TAB);
+
+ // If connected when showing the tab, reload snackbar should be shown as well.
+ doReturn(true).when(observer).isConnected();
+ observer.onShown(TAB);
+
+ verify(observer, times(1)).showReloadSnackbar();
+ assertTrue(observer.wasSnackbarShown());
+ }
+
+ @Test
+ @Feature({"OfflinePages"})
+ public void testOnHidden() {
+ OfflinePageTabObserver observer = createObserver();
+
+ observer.startObservingTab(TAB);
+ doReturn(false).when(mTabHelper).isTabShowing(any(Tab.class));
+ // Hide the tab.
+ observer.onHidden(TAB);
+
+ assertFalse(observer.wasSnackbarShown());
+ assertTrue(observer.isObservingTab(TAB));
+ verify(mSnackbarManager, times(1)).dismissSnackbars(eq(mSnackbarController));
+ }
+
+ @Test
+ @Feature({"OfflinePages"})
+ public void testOnHidden_afterSnackbarShown() {
+ OfflinePageTabObserver observer = createObserver();
+
+ observer.startObservingTab(TAB);
+ // Ensure the snackbar is shown first.
+ doReturn(true).when(observer).isConnected();
+ observer.onShown(TAB);
+
+ doReturn(false).when(mTabHelper).isTabShowing(any(Tab.class));
+ observer.onHidden(TAB);
+
+ verify(mSnackbarManager, times(1)).dismissSnackbars(eq(mSnackbarController));
+ assertFalse(observer.wasSnackbarShown());
+ }
+
+ @Test
+ @Feature({"OfflinePages"})
+ public void testOnDestroyed() {
+ OfflinePageTabObserver observer = createObserver();
+
+ observer.startObservingTab(TAB);
+ doReturn(true).when(observer).isConnected();
+ observer.onShown(TAB);
+
+ observer.onDestroyed(TAB);
+
+ verify(observer, times(1)).stopObservingTab(any(Tab.class));
+ verify(mTabHelper, times(1)).removeObserver(any(Tab.class), eq(observer));
+ assertFalse(observer.wasSnackbarShown());
+ assertFalse(observer.isObservingTab(TAB));
+ }
+
+ @Test
+ @Feature({"OfflinePages"})
+ public void testOnUrlUpdated() {
+ OfflinePageTabObserver observer = createObserver();
+
+ observer.startObservingTab(TAB);
+ // URL updated, but tab still shows offline page.
+ observer.onUrlUpdated(TAB);
+
+ assertTrue(observer.isObservingTab(TAB));
+ verify(observer, times(0)).stopObservingTab(any(Tab.class));
+ verify(mSnackbarManager, times(1)).dismissSnackbars(eq(mSnackbarController));
+
+ // URL updated and tab no longer shows offline page.
+ doReturn(false).when(mTabHelper).isOfflinePage(any(Tab.class));
+ observer.onUrlUpdated(TAB);
+
+ assertFalse(observer.isObservingTab(TAB));
+ verify(observer, times(1)).stopObservingTab(any(Tab.class));
+ verify(mSnackbarManager, times(2)).dismissSnackbars(eq(mSnackbarController));
+ }
+
+ @Test
+ @Feature({"OfflinePages"})
+ public void testAddObserverForTab() {
+ OfflinePageTabObserver observer = createObserver();
+ OfflinePageTabObserver.setInstanceForTesting(observer);
+
+ // Method under test.
+ OfflinePageTabObserver.addObserverForTab(TAB);
+
+ verify(mTabHelper, times(1)).addObserver(any(Tab.class), eq(observer));
+ verify(observer, times(1)).startObservingTab(any(Tab.class));
+ assertTrue(observer.isObservingTab(TAB));
+ assertFalse(observer.wasSnackbarShown());
+ }
+
+ @Test
+ @Feature({"OfflinePages"})
+ public void testAddObserverForTab_whenConnected() {
+ OfflinePageTabObserver observer = createObserver();
+ OfflinePageTabObserver.setInstanceForTesting(observer);
+
+ doReturn(true).when(observer).isConnected();
+
+ // Method under test.
+ OfflinePageTabObserver.addObserverForTab(TAB);
+
+ verify(mTabHelper, times(1)).addObserver(any(Tab.class), eq(observer));
+ verify(observer, times(1)).startObservingTab(any(Tab.class));
+ assertTrue(observer.isObservingTab(TAB));
+ assertTrue(observer.wasSnackbarShown());
+ }
+
+ @Test
+ @Feature({"OfflinePages"})
+ public void testOnConnectionTypeChanged_notConnected() {
+ OfflinePageTabObserver observer = createObserver();
+
+ // Ensures that observer actually listens for network notifications and tab is shown.
+ observer.startObservingTab(TAB);
+ observer.onShown(TAB);
+ assertTrue(observer.isObservingNetworkChanges());
+
+ // Notification comes, but we are still disconnected.
+ observer.onConnectionTypeChanged(0);
+
+ verify(observer, times(0)).showReloadSnackbar();
+ assertFalse(observer.wasSnackbarShown());
+ }
+
+ @Test
+ @Feature({"OfflinePages"})
+ public void testOnConnectionTypeChanged_tabNotShowing() {
+ OfflinePageTabObserver observer = createObserver();
+
+ // Ensures that observer actually listens for network notifications and tab is hidden.
+ observer.startObservingTab(TAB);
+ doReturn(false).when(mTabHelper).isTabShowing(any(Tab.class));
+ observer.onHidden(TAB);
+
+ doReturn(true).when(observer).isConnected();
+ assertTrue(observer.isObservingNetworkChanges());
+ observer.onConnectionTypeChanged(0);
+
+ verify(observer, times(0)).showReloadSnackbar();
+ assertFalse(observer.wasSnackbarShown());
+ }
+
+ @Test
+ @Feature({"OfflinePages"})
+ public void testOnConnectionTypeChanged_wasSnackbarShown() {
+ OfflinePageTabObserver observer = createObserver();
+
+ doReturn(true).when(observer).isConnected();
+
+ // Ensures that observer actually listens for network notifications and tab is shown when
+ // connected, which means snackbar is shown as well.
+ observer.startObservingTab(TAB);
+ verify(observer, times(1)).showReloadSnackbar();
+ assertTrue(observer.wasSnackbarShown());
+
+ assertTrue(observer.isObservingNetworkChanges());
+ observer.onConnectionTypeChanged(0);
+ verify(observer, times(1)).showReloadSnackbar();
+ assertTrue(observer.wasSnackbarShown());
+ }
+
+ @Test
+ @Feature({"OfflinePages"})
+ public void testOnConnectionTypeChanged() {
+ OfflinePageTabObserver observer = createObserver();
+
+ // Ensures that observer actually listens for network notifications and tab is shown.
+ observer.startObservingTab(TAB);
+ observer.onShown(TAB);
+
+ doReturn(true).when(observer).isConnected();
+ observer.onConnectionTypeChanged(0);
+
+ verify(observer, times(1)).showReloadSnackbar();
+ assertTrue(observer.wasSnackbarShown());
+ assertTrue(observer.isObservingNetworkChanges());
+ }
+}
« no previous file with comments | « chrome/android/javatests/src/org/chromium/chrome/browser/offlinepages/OfflinePageUtilsTest.java ('k') | no next file » | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698