Unit tests for attempt manager

chrome/browser/resources/google_now/utility_unittest.gtestjs

 // Copyright 2013 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.
 
 /**
  * Test fixture for utility.js.
  * @constructor
  * @extends {testing.Test}
  */
 function GoogleNowUtilityUnitTest () {
@@ skipping 161 matching lines @@
   this.mockGlobals.expects(once()).
       buildErrorWithMessageForServer('Not in instrumented callback').
       will(returnValue(testError));
   this.mockGlobals.expects(once()).
       reportError(eqJSON(testError));
 
   // Invocation.
   wrapper.checkInWrappedCallback();
 
   // Step 4. Check that there won't be errors whe the page unloads.
-  assertTrue(onSuspendHandlerContainer.length == 1,
-             'onSuspendHandlerContainer.length must be 1');
+  assertEquals(1, onSuspendHandlerContainer.length);
   onSuspendHandlerContainer[0]();
 });
 
 TEST_F('GoogleNowUtilityUnitTest', 'WrapperWrapCallbackPlugin', function() {
   // Tests calling plugin's prologue and epilogue.
 
   // Setup.
   this.makeMockLocalFunctions([
     'callback',
     'pluginFactory',
@@ skipping 180 matching lines @@
   // Step 3. Firing runtime.onSuspend event.
   // Expectations.
   this.mockGlobals.expects(once()).
       buildErrorWithMessageForServer(stringContains(
           'ASSERT: Pending callbacks when unloading event page')).
       will(returnValue(testError));
   this.mockGlobals.expects(once()).
       reportError(eqJSON(testError));
 
   // Invocation.
-  assertTrue(onSuspendHandlerContainer.length == 1,
-             'onSuspendHandlerContainer.length must be 1');
+  assertEquals(1, onSuspendHandlerContainer.length);
   onSuspendHandlerContainer[0]();
 });
 
 TEST_F('GoogleNowUtilityUnitTest',
        'WrapperOnSuspendListenerSuccess',
        function() {
   // Tests that upon unloading event page, we don't get an error if there are no
   // pending required callbacks.
 
   // Setup.
@@ skipping 21 matching lines @@
   Mock4JS.verifyAllMocks();
 
   // Step 3. Calling wrapped callback.
   // Expectations.
   this.mockLocalFunctions.expects(once()).callback();
 
   // Invocation.
   wrappedCallback();
 
   // Step 4. Firing runtime.onSuspend event.
-  assertTrue(onSuspendHandlerContainer.length == 1,
-             'onSuspendHandlerContainer.length must be 1');
+  assertEquals(1, onSuspendHandlerContainer.length);
   onSuspendHandlerContainer[0]();
 });
 
 var taskNameA = 'TASK A';
 var taskNameB = 'TASK B';
 var taskNameC = 'TASK C';
 
 function areTasksConflicting(newTaskName, scheduledTaskName) {
   // Task B is conflicting with Task A. This means that if Task B is added when
   // Task A is running, Task B will be ignored (but not vice versa). No other
   // pair is conflicting.
   return newTaskName == taskNameB && scheduledTaskName == taskNameA;
 }
 
 function setUpTaskManagerTest(fixture) {
-  // We want to mock wrapper using makeAndRegisterMockApis(), which requires
-  // the mocked functions to not exist as a precondition. Resetting 'wrapper' to
-  // 'undefined'.
-  wrapper = undefined;
-
   fixture.makeAndRegisterMockApis([
     'wrapper.checkInWrappedCallback',
     'wrapper.registerWrapperPluginFactory',
     'wrapper.debugGetStateString'
   ]);
   fixture.makeMockLocalFunctions(['task1', 'task2', 'task3']);
   fixture.makeAndRegisterMockGlobals(['reportError']);
 
   fixture.mockApis.stubs().wrapper_checkInWrappedCallback();
   fixture.mockApis.stubs().wrapper_debugGetStateString().
@@ skipping 154 matching lines @@
       will(callFunction(function() {
         test.pluginFactory();
       }));
   // Invocation.
   test.tasks.add(taskNameA, this.mockLocalFunctions.functions().task1);
   Mock4JS.verifyAllMocks();
 
   // Step 2. Invoke onSuspend event of the task manager.
   // Setup and expectations. The 2 callbacks in onSuspendHandlerContainer are
   // from the wrapper and the task manager.
-  assertTrue(onSuspendHandlerContainer.length == 2,
-             'onSuspendHandlerContainer.length must be 2');
+  assertEquals(2, onSuspendHandlerContainer.length);
   this.mockGlobals.expects(once()).reportError(eqToString(
       'Error: ASSERT: Incomplete task when unloading event page,' +
       ' queue = [{"name":"TASK A"}], testWrapperDebugState'));
   // Invocation.
   onSuspendHandlerContainer[1]();
 });
 
 TEST_F('GoogleNowUtilityUnitTest', 'TaskManagerSuspendSuccess', function() {
   // Tests that task manager's onSuspend method does not reports an error if all
   // tasks completed.
@@ skipping 84 matching lines @@
   // finished despite the pending non-task callback.
   task1PluginInstance.prologue();
   task1PluginInstance.epilogue();
   Mock4JS.verifyAllMocks();
 
   // Step 4. Checking that task1 is finished by submitting task2, which should
   // be executed immediately.
   this.mockLocalFunctions.expects(once()).task2(ANYTHING);
   test.tasks.add(taskNameC, this.mockLocalFunctions.functions().task2);
 });
+
+var testAttemptAlarmName = 'attempt-scheduler-testAttempts';
+var testAttemptStorageKey = 'current-delay-testAttempts';
+var testInitialDelaySeconds = 239;
+var testMaximumDelaySeconds = 2239;
+// Value to be returned by mocked Math.random(). We want the value returned by
+// Math.random() to be predictable to be able to check results against expected
+// values. Random seeding won't work because it doesn't guarantee a specific
+// result of Math.random().

[robliao, 2013/09/05 00:09:39]

Not exactly true. A fixed seed would be okay, but fixed seeding isn't possible
in JS at the moment.

[vadimt, 2013/09/05 00:30:00]

Done.

+var testRandomValue = 0.31415926;
+
+function createTestAttempStorageEntry(delaySeconds) {
+  // Creates a test storage object that attempt manager uses to store current
+  // delay.
+  var storageObject = {};
+  storageObject[testAttemptStorageKey] = delaySeconds;
+  return storageObject;
+}
+
+function setupAttemptManagerTest(fixture) {
+  Math.random = function() { return testRandomValue; }
+
+  fixture.makeMockLocalFunctions([
+    'attempt',
+    'planForNextCallback',
+    'isRunningCallback'
+  ]);
+  fixture.makeAndRegisterMockApis([
+    'chrome.alarms.clear',
+    'chrome.alarms.create',
+    'chrome.storage.local.remove',
+    'chrome.storage.local.set',
+    'instrumented.alarms.get',
+    'instrumented.storage.local.get'
+  ]);
+
+  var testAttempts = buildAttemptManager(
+      'testAttempts',
+      fixture.mockLocalFunctions.functions().attempt,
+      testInitialDelaySeconds,
+      testMaximumDelaySeconds);
+  Mock4JS.verifyAllMocks();
+
+  return {
+    attempts: testAttempts
+  };
+}
+
+TEST_F('GoogleNowUtilityUnitTest', 'AttemptManagerStartStop', function() {
+  // Tests starting and stopping an attempt manager.
+
+  // Setup.
+  var test = setupAttemptManagerTest(this);
+
+  // Step 1. Checking that attempt manager is not running.
+  // Expectations.
+  var alarmsGetSavedArgs = new SaveMockArguments();
+  this.mockApis.expects(once()).
+      instrumented_alarms_get(
+          alarmsGetSavedArgs.match(eq(testAttemptAlarmName)),
+          alarmsGetSavedArgs.match(ANYTHING)).
+      will(invokeCallback(alarmsGetSavedArgs, 1, undefined));
+  this.mockLocalFunctions.expects(once()).isRunningCallback(false);
+  // Invocation.
+  test.attempts.isRunning(
+      this.mockLocalFunctions.functions().isRunningCallback);
+  Mock4JS.verifyAllMocks();
+
+  // Step 2. Starting attempt manager with no parameters.
+  // Expectations.
+  var expectedRetryDelaySeconds =
+      testInitialDelaySeconds * (1 + testRandomValue * 0.2);
+  this.mockApis.expects(once()).chrome_alarms_create(
+    testAttemptAlarmName,
+    eqJSON({
+      delayInMinutes: expectedRetryDelaySeconds / 60,
+      periodInMinutes: testMaximumDelaySeconds / 60
+    }));
+  this.mockApis.expects(once()).chrome_storage_local_set(
+      eqJSON(createTestAttempStorageEntry(expectedRetryDelaySeconds)));
+  // Invocation.
+  test.attempts.start();
+  Mock4JS.verifyAllMocks();
+
+  // Step 3. Checking that attempt manager is running.
+  // Expectations.
+  alarmsGetSavedArgs = new SaveMockArguments();
+  this.mockApis.expects(once()).
+      instrumented_alarms_get(
+          alarmsGetSavedArgs.match(eq(testAttemptAlarmName)),
+          alarmsGetSavedArgs.match(ANYTHING)).
+      will(invokeCallback(alarmsGetSavedArgs, 1, {testField: 'TEST VALUE'}));
+  this.mockLocalFunctions.expects(once()).isRunningCallback(true);
+  // Invocation.
+  test.attempts.isRunning(
+      this.mockLocalFunctions.functions().isRunningCallback);
+  Mock4JS.verifyAllMocks();
+
+  // Step 4. Stopping task manager.
+  // Expectations.
+  this.mockApis.expects(once()).chrome_alarms_clear(testAttemptAlarmName);
+  this.mockApis.expects(once()).chrome_storage_local_remove(
+      testAttemptStorageKey);
+  // Invocation.
+  test.attempts.stop();
+});
+
+TEST_F('GoogleNowUtilityUnitTest', 'AttemptManagerStartWithParam', function() {
+  // Tests starting an attempt manager with a parameter.
+
+  // Setup.
+  var test = setupAttemptManagerTest(this);
+  var testFirstDelaySeconds = 1039;
+
+  // Starting attempt manager with a parameter specifying first delay.
+  // Expectations.
+  this.mockApis.expects(once()).chrome_alarms_create(
+      testAttemptAlarmName,
+      eqJSON({
+        delayInMinutes: testFirstDelaySeconds / 60,
+        periodInMinutes: testMaximumDelaySeconds / 60
+      }));
+  this.mockApis.expects(once()).chrome_storage_local_remove(
+    testAttemptStorageKey);
+  // Invocation.
+  test.attempts.start(testFirstDelaySeconds);
+});
+
+TEST_F('GoogleNowUtilityUnitTest', 'AttemptManagerExponGrowth', function() {
+  // Tests that retry time grows exponentially.
+
+  // Setup.
+  var test = setupAttemptManagerTest(this);
+  var testStoredRetryDelay = 433;
+
+  // Call planForNext, which prepares next attempt. Current retry time
+  // is less than 1/2 of the maximum delay.
+  // Expectations.
+  var expectedRetryDelaySeconds =
+      testStoredRetryDelay * 2 * (1 + testRandomValue * 0.2);
+  var storageGetSavedArgs = new SaveMockArguments();
+  this.mockApis.expects(once()).instrumented_storage_local_get(
+          storageGetSavedArgs.match(eq(testAttemptStorageKey)),
+          storageGetSavedArgs.match(ANYTHING)).
+      will(invokeCallback(
+          storageGetSavedArgs,
+          1,
+          createTestAttempStorageEntry(testStoredRetryDelay)));
+  this.mockApis.expects(once()).chrome_alarms_create(
+      testAttemptAlarmName,
+      eqJSON({
+        delayInMinutes: expectedRetryDelaySeconds / 60,
+        periodInMinutes: testMaximumDelaySeconds / 60}));
+  this.mockApis.expects(once()).chrome_storage_local_set(
+      eqJSON(createTestAttempStorageEntry(expectedRetryDelaySeconds)));
+  this.mockLocalFunctions.expects(once()).planForNextCallback();
+  // Invocation.
+  test.attempts.planForNext(
+      this.mockLocalFunctions.functions().planForNextCallback);
+});
+
+TEST_F('GoogleNowUtilityUnitTest', 'AttemptManagerGrowthLimit', function() {
+  // Tests that retry time stops growing at the maximum value.
+
+  // Setup.
+  var test = setupAttemptManagerTest(this);
+  var testStoredRetryDelay = 1500;
+
+  // Call planForNext, which prepares next attempt. Current retry time
+  // is greater than 1/2 of the maximum delay.
+  // Expectations.
+  var expectedRetryDelaySeconds = testMaximumDelaySeconds;
+  var storageGetSavedArgs = new SaveMockArguments();
+  this.mockApis.expects(once()).
+      instrumented_storage_local_get(
+          storageGetSavedArgs.match(eq(testAttemptStorageKey)),
+          storageGetSavedArgs.match(ANYTHING)).
+      will(invokeCallback(
+          storageGetSavedArgs,
+          1,
+          createTestAttempStorageEntry(testStoredRetryDelay)));
+  this.mockApis.expects(once()).chrome_alarms_create(
+      testAttemptAlarmName,
+      eqJSON({
+        delayInMinutes: expectedRetryDelaySeconds / 60,
+        periodInMinutes: testMaximumDelaySeconds / 60
+      }));
+  this.mockApis.expects(once()).chrome_storage_local_set(
+      eqJSON(createTestAttempStorageEntry(expectedRetryDelaySeconds)));
+  this.mockLocalFunctions.expects(once()).planForNextCallback();
+  // Invocation.
+  test.attempts.planForNext(
+      this.mockLocalFunctions.functions().planForNextCallback);
+});
+
+TEST_F('GoogleNowUtilityUnitTest', 'AttemptManagerAlarm', function() {
+  // Tests that firing the alarm invokes the attempt.
+
+  // Setup.
+  var test = setupAttemptManagerTest(this);
+  var onAlarmHandlerContainer = getMockHandlerContainer('alarms.onAlarm');
+  assertEquals(1, onAlarmHandlerContainer.length);
+
+  // Fire the alarm and check that this invokes the attemp callback.
+  // Expectations.
+  var alarmsGetSavedArgs = new SaveMockArguments();
+  this.mockApis.expects(once()).
+      instrumented_alarms_get(
+          alarmsGetSavedArgs.match(eq(testAttemptAlarmName)),
+          alarmsGetSavedArgs.match(ANYTHING)).
+      will(invokeCallback(alarmsGetSavedArgs, 1, {testField: 'TEST VALUE'}));
+  this.mockLocalFunctions.expects(once()).attempt();
+  // Invocation.
+  onAlarmHandlerContainer[0]({name: testAttemptAlarmName});
+});