Some unit tests

chrome/browser/resources/google_now/background_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 background.js.
  * @constructor
  * @extends {testing.Test}
  */
 function GoogleNowBackgroundUnitTest () {
@@ skipping 300 matching lines @@
 
       // Check the output parameter.
       assertEquals(
           JSON.stringify({
             'ID 2': { testField: 'RESULT 2' },
             'ID 3': { testField: 'TEST_FIELD3'},
             'ID 1': { testField: 'RESULT 1' }}),
           JSON.stringify(mergedCards));
     });
 
+TEST_F(
+    'GoogleNowBackgroundUnitTest',
+    'MergeAndShowNotificationCards',
+    function() {
+      // Tests mergeAndShowNotificationCards function.

[robliao, 2013/10/21 23:08:33]

Discuss what is passed in and what's expected.

[vadimt, 2013/10/22 00:57:07]

Done.

+
+      // Setup and expectations.
+      var testGroups = {
+        'TEST GROUP 1': {testField: 'TEST VALUE 1'},
+        'TEST GROUP 2': {testField: 'TEST VALUE 2'}
+      };
+
+      this.makeAndRegisterMockGlobals(['mergeGroup', 'showNotificationCards']);
+
+      var mergeGroupSavedArgs = new SaveMockArguments();
+      this.mockGlobals.expects(once()).
+          mergeGroup(
+              mergeGroupSavedArgs.match(eqJSON({})),
+              mergeGroupSavedArgs.match(eqJSON({testField: 'TEST VALUE 1'}))).
+          will(callFunction(function() {
+            mergeGroupSavedArgs.arguments[0].card1 = {
+              testValue: 'TEST CARD VALUE 1'
+            };
+          }));
+      this.mockGlobals.expects(once()).
+          mergeGroup(
+              mergeGroupSavedArgs.match(
+                  eqJSON({card1: {testValue: 'TEST CARD VALUE 1'}})),

[robliao, 2013/10/21 23:08:33]

Is card1 guaranteed to be the first thing considered? The ordering of fields
that point to non-primitive types is undefined.

http://www.ecma-international.org/ecma-262/5.1/#sec-12.6.4

[vadimt, 2013/10/22 00:57:07]

This is how our JS implementation works.
I doubt that V8 will suddently change the implementation, since they realize how
many people they'll break.
And even if they do this, they'll likely give us an early notice, so that we'll
have time to modify the tests (or fight back).

Note that we also rely on eqJSON, which assumes certain order of filds in
JSON-filed objects, and this never broke so far, even though the tests we run
presumably thousands of times.

[robliao, 2013/10/22 16:52:14]

I think v8 is one of those implementations where the order can change on you.

Either way, for this test, should be fine unless it starts flaking at us.
On 2013/10/22 00:57:07, vadimt wrote:

+              mergeGroupSavedArgs.match(
+                  eqJSON({testField: 'TEST VALUE 2'}))).
+          will(callFunction(function() {
+              mergeGroupSavedArgs.arguments[0].card2 = {
+                testValue: 'TEST CARD VALUE 2'
+              };
+          }));
+      this.mockGlobals.expects(once()).
+          showNotificationCards(eqJSON({
+            card1: {testValue: 'TEST CARD VALUE 1'},
+            card2: {testValue: 'TEST CARD VALUE 2'}
+          }));
+
+      // Invoking the tested function.
+      mergeAndShowNotificationCards(testGroups);
+    });
+
+// TODO(vadimt): Add more tests for parseAndShowNotificationCards().
+TEST_F(
+    'GoogleNowBackgroundUnitTest',
+    'ParseAndShowNotificationCardsAdd1Remove1',
+    function() {
+      // Tests parseAndShowNotificationCards function for the case when the
+      // extension has 2 groups, and the server sends update with 2 groups, one
+      // of which is new, and another one matches a stored group. The client
+      // has to delete the group that didn't receive an update, keep the
+      // existing group that received an update, and add a new stored group for
+      // the new group from the server.
+
+      // Setup and expectations.
+      Date.now = function() { return 500; };
+
+      var serverResponse = {
+        groups: {
+          GROUP1: {},
+          GROUP2: {}
+        }
+      };
+
+      var storedGroups = {
+        GROUP2: {
+          cards: ['c2'],
+          cardsTimestamp: 239,
+          nextPollTime: 10000,
+          rank: 1
+        },
+        GROUP3: {
+          cards: ['c3'],
+          cardsTimestamp: 240,
+          nextPollTime: 10001,
+          rank: 2
+        }
+      };
+
+      var expectedUpdatedGroups = {
+        GROUP1: {
+          cards: [],
+          nextPollTime: Date.now()
+        },
+        GROUP2: {
+          cards: ['c2'],
+          cardsTimestamp: 239,
+          nextPollTime: 10000,
+          rank: 1
+        }
+      };
+
+      this.makeAndRegisterMockGlobals(
+          ['scheduleNextPoll', 'mergeAndShowNotificationCards', 'recordEvent']);
+
+      this.makeAndRegisterMockApis([
+        'chrome.storage.local.set',
+        'instrumented.storage.local.get'
+      ]);
+
+      var storageGetSavedArgs = new SaveMockArguments();
+      this.mockApis.expects(once()).
+          instrumented_storage_local_get(
+              storageGetSavedArgs.match(eq('notificationGroups')),
+              storageGetSavedArgs.match(ANYTHING)).
+          will(invokeCallback(
+              storageGetSavedArgs, 1, {notificationGroups: storedGroups}));
+
+      this.mockGlobals.expects(once()).
+          scheduleNextPoll(eqJSON(expectedUpdatedGroups));
+
+      this.mockApis.expects(once()).
+          chrome_storage_local_set(
+              eqJSON({notificationGroups: expectedUpdatedGroups}));
+
+      this.mockGlobals.expects(once()).
+          mergeAndShowNotificationCards(eqJSON(expectedUpdatedGroups));
+
+      this.mockGlobals.expects(once()).
+          recordEvent(GoogleNowEvent.CARDS_PARSE_SUCCESS);
+
+      // Invoking the tested function.
+      parseAndShowNotificationCards(JSON.stringify(serverResponse));
+    });
+
 /**
  * Mocks global functions and APIs that initialize() depends upon.
  * @param {Test} fixture Test fixture.
  */
 function mockInitializeDependencies(fixture) {
   fixture.makeAndRegisterMockGlobals([
     'recordEvent',
     'setBackgroundEnable',
     'startPollingCards'
   ]);
@@ skipping 404 matching lines @@
               chromeTabsCreateSavedArgs.match(eqJSON({url: testActionUrl})),
               chromeTabsCreateSavedArgs.match(ANYTHING)).
           will(invokeCallback(chromeTabsCreateSavedArgs, 1, testCreatedTab));
       this.mockApis.expects(once()).chrome_windows_create(
           eqJSON({url: testActionUrl, focused: true}));
 
       // Invoking the tested function.
       onNotificationClicked(
           testNotificationId, this.mockLocalFunctions.functions().selector);
     });