[Crash Reporting] Only upload Chrome crash reports over unmetered networks.

chrome/android/junit/src/org/chromium/chrome/browser/preferences/privacy/PrivacyPreferencesManagerTest.java

 // Copyright 2015 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.preferences.privacy;
 
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
 import android.content.Context;
-import android.support.test.filters.SmallTest;
-import android.test.InstrumentationTestCase;
-import android.test.UiThreadTest;
+import android.net.ConnectivityManager;
+import android.net.NetworkInfo;
+
+import static org.junit.Assert.assertEquals;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.robolectric.RuntimeEnvironment;
+import org.robolectric.annotation.Config;
 
 import org.chromium.base.CommandLine;
 import org.chromium.base.ContextUtils;
-import org.chromium.base.test.util.AdvancedMockContext;
-import org.chromium.base.test.util.Feature;
+import org.chromium.testing.local.LocalRobolectricTestRunner;
 
 /**
- *  Tests "Usage and Crash reporting" preferences.
+ * junit tests for {@link PrivacyPreferencesManager}'s handling of "Usage and Crash reporting"
+ * preferences.
  */
-public class PrivacyPreferencesManagerTest extends InstrumentationTestCase {
-
+@RunWith(LocalRobolectricTestRunner.class)
+@Config(manifest = Config.NONE)
+public class PrivacyPreferencesManagerTest {
+    // Parameters to simulate user- and network-permission state.
     private static final boolean CONNECTED = true;
     private static final boolean DISCONNECTED = false;
 
-    private static final boolean WIFI_ON = true;
-    private static final boolean WIFI_OFF = false;
+    private static final boolean METERED = true;
+    private static final boolean UNMETERED = false;
 
-    private static final boolean METRICS_UPLOAD_OK = true;
+    private static final boolean METRICS_REPORTING_ENABLED = true;
+    private static final boolean METRICS_REPORTING_DISABLED = false;
+
+    // Used to set test expectations.
+    private static final boolean METRICS_UPLOAD_PERMITTED = true;
     private static final boolean METRICS_UPLOAD_NOT_PERMITTED = false;
 
-    private static final boolean CRASH_NETWORK_OK = true;
-    private static final boolean CRASH_NETWORK_NOT_PERMITTED = false;
+    private static final boolean CRASH_NETWORK_AVAILABLE = true;
+    private static final boolean CRASH_NETWORK_UNAVAILABLE = false;
 
-    private static final boolean METRIC_REPORTING_ENABLED = true;
-    private static final boolean METRIC_REPORTING_DISABLED = false;
+    @Test
+    public void testUsageAndCrashReportingAccessors() {
+        CommandLine.init(null);
+        runTest(CONNECTED, UNMETERED, METRICS_REPORTING_ENABLED, METRICS_UPLOAD_PERMITTED,

[Maria, 2017/03/20 23:23:40]

So I recently saw a presentation on junit4 and using ParameterSet to do exactly
this (permutation of function calls into a helper). It was in the context of
instrumentation, but I wonder if that works in roboelectric too. I am going to
add +yolandyan@chromium.org here and he should be able to tell you the syntax if
it's available. Makes these sorts of tests look nicer.

+                CRASH_NETWORK_AVAILABLE);
+        runTest(CONNECTED, METERED, METRICS_REPORTING_ENABLED, METRICS_UPLOAD_PERMITTED,
+                CRASH_NETWORK_UNAVAILABLE);
+        runTest(DISCONNECTED, UNMETERED, METRICS_REPORTING_ENABLED, METRICS_UPLOAD_NOT_PERMITTED,
+                CRASH_NETWORK_UNAVAILABLE);
 
-    // Perform the same test a few times to make sure any sort of
-    // caching still works.
-    private static final int REPS = 3;
-
-    @SmallTest
-    @Feature({"Android-AppBase"})
-    @UiThreadTest
-    public void testAllowCrashDumpUploadNowCellDev() {
-        CommandLine.init(null);
-        runTest(CONNECTED, WIFI_ON, METRIC_REPORTING_ENABLED, METRICS_UPLOAD_OK, CRASH_NETWORK_OK);
-        runTest(CONNECTED, WIFI_OFF, METRIC_REPORTING_ENABLED, METRICS_UPLOAD_OK,
-                CRASH_NETWORK_NOT_PERMITTED);
-        runTest(DISCONNECTED, WIFI_OFF, METRIC_REPORTING_ENABLED, METRICS_UPLOAD_NOT_PERMITTED,
-                CRASH_NETWORK_NOT_PERMITTED);
-
-        runTest(CONNECTED, WIFI_ON, METRIC_REPORTING_DISABLED, METRICS_UPLOAD_NOT_PERMITTED,
-                CRASH_NETWORK_OK);
-        runTest(CONNECTED, WIFI_OFF, METRIC_REPORTING_DISABLED, METRICS_UPLOAD_NOT_PERMITTED,
-                CRASH_NETWORK_NOT_PERMITTED);
-        runTest(DISCONNECTED, WIFI_OFF, METRIC_REPORTING_DISABLED, METRICS_UPLOAD_NOT_PERMITTED,
-                CRASH_NETWORK_NOT_PERMITTED);
+        runTest(CONNECTED, UNMETERED, METRICS_REPORTING_DISABLED, METRICS_UPLOAD_NOT_PERMITTED,
+                CRASH_NETWORK_AVAILABLE);
+        runTest(CONNECTED, METERED, METRICS_REPORTING_DISABLED, METRICS_UPLOAD_NOT_PERMITTED,
+                CRASH_NETWORK_UNAVAILABLE);
+        runTest(DISCONNECTED, UNMETERED, METRICS_REPORTING_DISABLED, METRICS_UPLOAD_NOT_PERMITTED,
+                CRASH_NETWORK_UNAVAILABLE);
     }
 
-    private void runTest(boolean isConnected, boolean wifiOn, boolean isMetricsReportingEnabled,
+    private void runTest(boolean isConnected, boolean isMetered, boolean isMetricsReportingEnabled,
             boolean expectedMetricsUploadPermitted,
             boolean expectedNetworkAvailableForCrashUploads) {
-        PermissionContext context = new PermissionContext(getInstrumentation().getTargetContext());
-        ContextUtils.initApplicationContextForTests(context.getApplicationContext());
-        PrivacyPreferencesManager preferenceManager = new MockPrivacyPreferencesManager(
-                context, isConnected, wifiOn, isMetricsReportingEnabled);
+        // Mock out the network info accessors.
+        NetworkInfo networkInfo = mock(NetworkInfo.class);
+        when(networkInfo.isConnected()).thenReturn(isConnected);
 
-        for (int i = 0; i < REPS; i++) {
-            String state = String.format("[connected = %b, wifi = %b, reporting = %b]", isConnected,
-                    wifiOn, isMetricsReportingEnabled);
-            String msg = String.format("Metrics reporting should be %1$b for %2$s",
-                    expectedMetricsUploadPermitted, state);
-            assertEquals(msg, expectedMetricsUploadPermitted,
-                    preferenceManager.isMetricsUploadPermitted());
+        ConnectivityManager connectivityManager = mock(ConnectivityManager.class);
+        when(connectivityManager.getActiveNetworkInfo()).thenReturn(networkInfo);
+        when(connectivityManager.isActiveNetworkMetered()).thenReturn(isMetered);
 
-            msg = String.format("Crash reporting should be %1$b for wifi %2$s",
-                    expectedNetworkAvailableForCrashUploads, wifiOn);
-            assertEquals(msg, expectedNetworkAvailableForCrashUploads,
-                    preferenceManager.isNetworkAvailableForCrashUploads());
-        }
+        Context context = mock(Context.class);
+        when(context.getSystemService(Context.CONNECTIVITY_SERVICE))
+                .thenReturn(connectivityManager);
+
+        // Perform other setup.
+        ContextUtils.initApplicationContextForTests(RuntimeEnvironment.application);
+        PrivacyPreferencesManager preferenceManager = new TestPrivacyPreferencesManager(context);
+        preferenceManager.setUsageAndCrashReporting(isMetricsReportingEnabled);
+
+        // Test the usage and crash reporting permission accessors!
+        String state = String.format("[connected = %b, metered = %b, reporting = %b]", isConnected,
+                isMetered, isMetricsReportingEnabled);
+        String msg = String.format(
+                "Metrics reporting should be %1$b for %2$s", expectedMetricsUploadPermitted, state);
+        assertEquals(
+                msg, expectedMetricsUploadPermitted, preferenceManager.isMetricsUploadPermitted());
+
+        msg = String.format("Crash reporting should be %1$b for metered state %2$s",
+                expectedNetworkAvailableForCrashUploads, isMetered);
+        assertEquals(msg, expectedNetworkAvailableForCrashUploads,
+                preferenceManager.isNetworkAvailableForCrashUploads());
     }
 
-    private static class MockPrivacyPreferencesManager extends PrivacyPreferencesManager {
-        private final boolean mIsConnected;
-        private final boolean mIsWifi;
-
-        MockPrivacyPreferencesManager(Context context, boolean isConnected, boolean isWifi,
-                boolean isMetricsReportingEnabled) {
+    private static class TestPrivacyPreferencesManager extends PrivacyPreferencesManager {
+        TestPrivacyPreferencesManager(Context context) {
             super(context);
-            mIsConnected = isConnected;
-            mIsWifi = isWifi;
-
-            setUsageAndCrashReporting(isMetricsReportingEnabled);
         }
 
-        @Override
-        public boolean isNetworkAvailable() {
-            return mIsConnected;
-        }
-
-        @Override
-        public boolean isWiFiOrEthernetNetwork() {
-            return mIsWifi;
-        }
-    }
-
-    private static class PermissionContext extends AdvancedMockContext {
-        public PermissionContext(Context targetContext) {
-            super(targetContext);
-        }
-
-        @Override
-        public Object getSystemService(String name) {
-            if (Context.CONNECTIVITY_SERVICE.equals(name)) {
-                return null;
-            }
-            fail("Should not ask for any other service than the ConnectionManager.");
-            return super.getSystemService(name);
-        }
+        // Stub out this call, as it could otherwise call into native code.
+        public void syncUsageAndCrashReportingPrefs() {}
     }
 }