Adding first unit tests with mocks

chrome/test/data/webui/test_api.js

 // Copyright (c) 2012 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.
 
 /**
  * @fileoverview Library providing basic test framework functionality.
  */
 
 /**
  * Namespace for |Test|.
@@ skipping 180 matching lines @@
      * @see registerMockGlobals
      */
     makeAndRegisterMockGlobals: function(functionNames) {
       var MockClass = makeMockClass(functionNames);
       this.mockGlobals = mock(MockClass);
       registerMockGlobals(this.mockGlobals, MockClass);
       return this.mockGlobals;
     },
 
     /**
+      * Create a container of mocked standalone functions to handle
+      * '.'-separated |apiNames|, assign it to |this.mockApis|, register its API
+      * overrides and return it.
+      * @return {Mock} Mock handler class.
+      * @see makeMockFunctions
+      * @see registerMockApis
+      */
+    makeAndRegisterMockApis: function (apiNames) {
+      var apiMockNames = [];

[arv (Not doing code reviews), 2013/07/12 14:18:34]

Maybe:

var apiMockNames = apiNames.map(function(name) {
  return name.replace(/\./g, '_');
});

[vadimt, 2013/07/12 18:22:35]

Cool

+      for(var i = 0; i < apiNames.length; i++) {
+        apiMockNames.push(apiNames [i].replace(/\./g, '_'));

[arv (Not doing code reviews), 2013/07/12 14:18:34]

Another option is to keep the '.' in the name. Then the caller would look like:

this.mockApis.expects(once())['chrome.tabs.create'](...)

[vadimt, 2013/07/12 18:22:35]

I considered this. I feel that the using code would become somewhat less clear,
mostly because I cannot include dots in names of saved args. So, the using code
would suffer from inconsistency between expectation method names and saved args
names.

+      }
+
+      this.mockApis = makeMockFunctions(apiMockNames);
+      registerMockApis(this.mockApis);
+      return this.mockApis;
+    },
+
+    /**
+      * Create a container of mocked standalone functions to handle
+      * |functionNames|, assign it to |this.mockLocalFunctions| and return it.
+      * @return {Mock} Mock handler class.

[arv (Not doing code reviews), 2013/07/12 14:18:34]

@param {!Array.<string>} functionNames

[vadimt, 2013/07/12 18:22:35]

Done.

+      * @see makeMockFunctions
+      */
+    makeMockLocalFunctions: function(functionNames) {
+      this.mockLocalFunctions = makeMockFunctions(functionNames);
+      return this.mockLocalFunctions;
+    },
+
+    /**
      * Override this method to perform initialization during preload (such as
      * creating mocks and registering handlers).
      * @type {Function}
      */
     preLoad: function() {},
 
     /**
      * Override this method to perform tasks before running your test.
      * @type {Function}
      */
@@ skipping 288 matching lines @@
     globalOverrides[name] = {
       object: object,
       callback: callback,
     };
 
     if (!deferGlobalOverrides)
       overrideGlobal(name);
   }
 
   /**
+   * Registers the mock API call and its function.
+   * @param {string} name The '_'-separated name of the API call.
+   * @param {function(...)} theFunction Mock function for this API call.
+   */
+  function registerMockApi(name, theFunction) {
+    var path = name.split('_');
+
+    var namespace = this;
+    for(var i = 0; i < path.length-1; ++i) {

[arv (Not doing code reviews), 2013/07/12 14:18:34]

missing whitespaces around bin op

[arv (Not doing code reviews), 2013/07/12 14:18:34]

i++

[vadimt, 2013/07/12 18:22:35]

Done.

[vadimt, 2013/07/12 18:22:35]

Done.

+      var fieldName = path[i];
+      if(!namespace[fieldName])
+        namespace[fieldName] = {};
+
+      namespace = namespace[fieldName];

[arv (Not doing code reviews), 2013/07/12 14:18:34]

Once again I'm confused. It seems like you are building the right object
structure here. So, why don't we allow calling things using:

this.mockApis.expects(once()).chrome.tabs.create(...)

[vadimt, 2013/07/12 18:22:35]

See above about external mock4js that generates the flat list of methods. I have
no control over it, therefore, it remains flat.
However, I have freedom to take these methods and create a hierarchical
structure of global overrides based on them.

+    }
+
+    var fieldName = path[path.length-1];
+    assertEquals(undefined, namespace[fieldName]);
+    namespace[fieldName] = theFunction;
+  }
+
+  /**
    * Empty function for use in making mocks.
    * @const
    */
   function emptyFunction() {}
 
   /**
    * Make a mock from the supplied |methodNames| array.
    * @param {Array.<string>} methodNames Array of names of methods to mock.
    * @return {Function} Constructor with prototype filled in with methods
    *     matching |methodNames|.
    */
   function makeMockClass(methodNames) {
     function MockConstructor() {}
     for(var i = 0; i < methodNames.length; i++)
       MockConstructor.prototype[methodNames[i]] = emptyFunction;
     return MockConstructor;
   }
 
   /**
+    * Create a new class to handle |functionNames|, add method 'functions()'
+    * that returns a container of standalone functions based on the mock class
+    * members, and return it.
+    * @return {Mock} Mock handler class.
+    */
+  function makeMockFunctions(functionNames) {
+    var MockClass = makeMockClass(functionNames);
+    var mockFunctions = mock(MockClass);
+    var mockProxy = mockFunctions.proxy();
+
+    mockFunctions.functions_ = {};
+
+    for (var func in MockClass.prototype) {
+      if (typeof MockClass.prototype[func] === 'function')

[arv (Not doing code reviews), 2013/07/12 14:18:34]

What about accessors? Maybe add a todo?

[vadimt, 2013/07/12 18:22:35]

This method is used to generate:
1. Local functions that are used as (callback etc.) params to the tested
functions.
2. chrome APIs

Both are unlikely to be getters. So, probably, we'll never need them.

But I guess whoever will need them first, will be able to add them here. So, I'd
not create a TODO item, if you don't mind.

+        mockFunctions.functions_[func] = mockProxy[func].bind(mockProxy);
+    }
+
+    mockFunctions.functions = function () {
+      return this.functions_;

[arv (Not doing code reviews), 2013/07/12 14:18:34]

Is this the correct this? If so, maybe just rename all functions_ to function
and you remove this statement.

[vadimt, 2013/07/12 18:22:35]

Yes, this is a correct 'this': the one of mockFunctions.
I've introduced a method to match another method: proxy() which returns the
generated proxied class.

+    };
+
+    return mockFunctions;
+  }
+
+  /**
    * Register all methods of {@code mockClass.prototype} as overrides to global
    * functions of the same name as the method, using the proxy of the
    * |mockObject| to handle the functions.
    * @param {Mock4JS.Mock} mockObject The mock to register callbacks against.
    * @param {function(new:Object)} mockClass Constructor for the mocked class.
    * @see registerMockGlobal
    */
   function registerMockGlobals(mockObject, mockClass) {
     var mockProxy = mockObject.proxy();
     for (var func in mockClass.prototype) {
       if (typeof mockClass.prototype[func] === 'function')
         registerMockGlobal(func, mockProxy, mockProxy[func]);
     }
   }
 
   /**
+   * Register all functions in |mockObject.functions()| as global API calls.
+   * @param {Mock4JS.Mock} mockObject The mock to register callbacks against.
+   * @see registerMockApi
+   */
+  function registerMockApis(mockObject) {
+    var functions = mockObject.functions();
+    for (var func in functions) {
+      if (typeof functions[func] === 'function')
+        registerMockApi(func, functions[func]);
+    }
+  }
+
+  /**
    * Overrides {@code chrome.send} for routing messages to javascript
    * functions. Also falls back to sending with the original chrome object.
    * @param {string} messageName The message to route.
    */
   function send(messageName) {
     var callback = sendCallbacks[messageName];
     if (callback != undefined)
       callback[1].apply(callback[0], Array.prototype.slice.call(arguments, 1));
     else
       this.__proto__.send.apply(this.__proto__, arguments);
@@ skipping 982 matching lines @@
   exports.TEST = TEST;
   exports.TEST_F = TEST_F;
   exports.RUNTIME_TEST_F = TEST_F;
   exports.GEN = GEN;
   exports.GEN_INCLUDE = GEN_INCLUDE;
   exports.WhenTestDone = WhenTestDone;
 
   // Import the Mock4JS helpers.
   Mock4JS.addMockSupport(exports);
 })(this);