[Offline pages] Updates to background scheduling to use BTS

chrome/android/junit/src/org/chromium/chrome/browser/offlinepages/OfflineBackgroundTaskTest.java

+// 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.doReturn;
+import static org.mockito.Mockito.eq;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+
+import android.app.Activity;
+import android.content.Context;
+import android.os.Bundle;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.ArgumentCaptor;
+import org.mockito.ArgumentMatchers;
+import org.mockito.Captor;
+import org.mockito.Mock;
+import org.mockito.MockitoAnnotations;
+import org.robolectric.RuntimeEnvironment;
+import org.robolectric.annotation.Config;
+
+import org.chromium.base.ActivityState;
+import org.chromium.base.ApplicationStatus;
+import org.chromium.base.BaseSwitches;
+import org.chromium.base.Callback;
+import org.chromium.base.CommandLine;
+import org.chromium.base.ContextUtils;
+import org.chromium.base.SysUtils;
+import org.chromium.base.test.util.Feature;
+import org.chromium.chrome.browser.DisableHistogramsRule;
+import org.chromium.components.background_task_scheduler.BackgroundTaskScheduler;
+import org.chromium.components.background_task_scheduler.BackgroundTaskSchedulerFactory;
+import org.chromium.components.background_task_scheduler.TaskInfo;
+import org.chromium.net.ConnectionType;
+import org.chromium.testing.local.LocalRobolectricTestRunner;
+
+/**
+ * Unit tests for OfflineBackgroundTask.
+ */
+@RunWith(LocalRobolectricTestRunner.class)
+@Config(manifest = Config.NONE, shadows = {ShadowDeviceConditions.class})
+public class OfflineBackgroundTaskTest {
+    private static final boolean REQUIRE_POWER = true;
+    private static final boolean REQUIRE_UNMETERED = true;
+    private static final boolean POWER_CONNECTED = true;
+    private static final int MINIMUM_BATTERY_LEVEL = 33;
+    private static final String IS_LOW_END_DEVICE_SWITCH =
+            "--" + BaseSwitches.ENABLE_LOW_END_DEVICE_MODE;
+
+    @Rule
+    public DisableHistogramsRule mDisableHistogramsRule = new DisableHistogramsRule();
+
+    private Bundle mTaskExtras;
+    private long mTestTime;
+    private TriggerConditions mTriggerConditions =
+            new TriggerConditions(!REQUIRE_POWER, MINIMUM_BATTERY_LEVEL, REQUIRE_UNMETERED);
+    private DeviceConditions mDeviceConditions = new DeviceConditions(
+            !POWER_CONNECTED, MINIMUM_BATTERY_LEVEL + 5, ConnectionType.CONNECTION_3G);
+    private Callback<Boolean> mCallback;
+    private Activity mTestActivity;
+
+    @Mock
+    private BackgroundSchedulerProcessor mBackgroundSchedulerProcessor;
+
+    @Mock
+    private BackgroundTaskScheduler mTaskScheduler;
+    @Captor
+    private ArgumentCaptor<TaskInfo> mTaskInfo;
+
+    @Before
+    public void setUp() throws Exception {
+        MockitoAnnotations.initMocks(this);
+        ContextUtils.initApplicationContextForTests(RuntimeEnvironment.application);
+        BackgroundTaskSchedulerFactory.setSchedulerForTesting(mTaskScheduler);
+        doReturn(true)
+                .when(mTaskScheduler)
+                .schedule(eq(RuntimeEnvironment.application), mTaskInfo.capture());
+
+        ShadowDeviceConditions.setCurrentConditions(mDeviceConditions);
+
+        // Build a bundle with trigger conditions.
+        mTaskExtras = new Bundle();
+        TaskExtrasPacker.packTimeInBundle(mTaskExtras);
+        TaskExtrasPacker.packTriggerConditionsInBundle(mTaskExtras, mTriggerConditions);
+
+        mCallback = new Callback<Boolean>() {
+            @Override
+            public void onResult(Boolean result) {
+                // Result explicitly ignored.
+            }
+        };
+
+        // Run tests as a low-end device.
+        CommandLine.init(new String[] {"testcommand", IS_LOW_END_DEVICE_SWITCH});
+
+        // Set up single, stopped Activity.
+        ApplicationStatus.destroyForJUnitTests();
+        mTestActivity = new Activity();
+        ApplicationStatus.onStateChangeForTesting(mTestActivity, ActivityState.CREATED);
+        ApplicationStatus.onStateChangeForTesting(mTestActivity, ActivityState.STOPPED);
+    }
+
+    @After
+    public void tearDown() throws Exception {
+        // Clean up static state for subsequent Robolectric tests.
+        CommandLine.reset();
+        SysUtils.reset();
+        ApplicationStatus.destroyForJUnitTests();
+    }
+
+    @Test
+    @Feature({"OfflinePages"})
+    public void testCheckConditions_BatteryConditions() {
+        // Setup low battery conditions with no power connected.
+        DeviceConditions deviceConditionsLowBattery = new DeviceConditions(
+                !POWER_CONNECTED, MINIMUM_BATTERY_LEVEL - 1, ConnectionType.CONNECTION_WIFI);
+        ShadowDeviceConditions.setCurrentConditions(deviceConditionsLowBattery);
+
+        /// Verify that conditions for processing are not met.
+        assertFalse(
+                OfflineBackgroundTask.checkConditions(RuntimeEnvironment.application, mTaskExtras));
+
+        // Set battery percentage below minimum level, but connect batter.

[Pete Williamson, 2017/05/24 21:41:03]

batter -> power

[fgorski, 2017/05/24 23:10:13]

Done.

+        DeviceConditions deviceConditionsPowerConnected = new DeviceConditions(
+                POWER_CONNECTED, MINIMUM_BATTERY_LEVEL - 1, ConnectionType.CONNECTION_WIFI);
+        ShadowDeviceConditions.setCurrentConditions(deviceConditionsPowerConnected);
+
+        // Now verify that same battery level, with power connected, will pass the conditions.
+        assertTrue(
+                OfflineBackgroundTask.checkConditions(RuntimeEnvironment.application, mTaskExtras));
+    }
+
+    @Test
+    @Feature({"OfflinePages"})
+    public void testCheckConditions_OnLowEndDevice() {
+        // Transition the test Activity to a running state.
+        ApplicationStatus.onStateChangeForTesting(mTestActivity, ActivityState.STARTED);
+
+        // Verify that conditions for processing are not met.
+        assertFalse(
+                OfflineBackgroundTask.checkConditions(RuntimeEnvironment.application, mTaskExtras));
+
+        // Switch activity state to stopped.
+        ApplicationStatus.onStateChangeForTesting(mTestActivity, ActivityState.STOPPED);
+
+        // Now verify that condition check passes when Activity is stopped.
+        assertTrue(
+                OfflineBackgroundTask.checkConditions(RuntimeEnvironment.application, mTaskExtras));
+    }
+
+    @Test
+    @Feature({"OfflinePages"})
+    public void testStartBackgroundRequests() {
+        // Set up bridge behavior.
+        doReturn(true)
+                .when(mBackgroundSchedulerProcessor)
+                .startScheduledProcessing(
+                        any(DeviceConditions.class), ArgumentMatchers.<Callback<Boolean>>any());
+
+        assertTrue(OfflineBackgroundTask.startScheduledProcessing(mBackgroundSchedulerProcessor,
+                RuntimeEnvironment.application, mTaskExtras, mCallback));
+
+        // Check with BackgroundSchedulerProcessor that processing started.
+        verify(mBackgroundSchedulerProcessor, times(1))
+                .startScheduledProcessing(eq(mDeviceConditions), eq(mCallback));
+    }
+
+    @Test
+    @Feature({"OfflinePages"})
+    public void testStartBackgroundRequestsNotStarted() {
+        // Nothing scheduled yet.
+        verify(mTaskScheduler, times(0)).schedule(any(Context.class), any(TaskInfo.class));
+
+        // Processing will not be started here.
+        doReturn(false)
+                .when(mBackgroundSchedulerProcessor)
+                .startScheduledProcessing(
+                        any(DeviceConditions.class), ArgumentMatchers.<Callback<Boolean>>any());
+
+        assertFalse(OfflineBackgroundTask.startScheduledProcessing(mBackgroundSchedulerProcessor,
+                RuntimeEnvironment.application, mTaskExtras, mCallback));
+
+        // Check with BackgroundSchedulerProcessor that it did not start.
+        verify(mBackgroundSchedulerProcessor, times(1))
+                .startScheduledProcessing(eq(mDeviceConditions), eq(mCallback));
+    }
+}