extensions/renderer/resources/test_custom_bindings.js

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 // test_custom_bindings.js
   6 // mini-framework for ExtensionApiTest browser tests
   7
   8 var binding = require('binding').Binding.create('test');
   9
  10 var environmentSpecificBindings = require('test_environment_specific_bindings');
  11 var GetExtensionAPIDefinitionsForTest =
  12     requireNative('apiDefinitions').GetExtensionAPIDefinitionsForTest;
  13 var GetAPIFeatures = requireNative('test_features').GetAPIFeatures;
  14 var uncaughtExceptionHandler = require('uncaught_exception_handler');
  15 var userGestures = requireNative('user_gestures');
  16
  17 var RunWithNativesEnabledModuleSystem =
  18     requireNative('v8_context').RunWithNativesEnabledModuleSystem;
  19
  20 binding.registerCustomHook(function(api) {
  21   var chromeTest = api.compiledApi;
  22   var apiFunctions = api.apiFunctions;
  23
  24   chromeTest.tests = chromeTest.tests || [];
  25
  26   var currentTest = null;
  27   var lastTest = null;
  28   var testsFailed = 0;
  29   var testCount = 1;
  30   var failureException = 'chrome.test.failure';
  31
  32   // Helper function to get around the fact that function names in javascript
  33   // are read-only, and you can't assign one to anonymous functions.
  34   function testName(test) {
  35     return test ? (test.name || test.generatedName) : "(no test)";
  36   }
  37
  38   function testDone() {
  39     environmentSpecificBindings.testDone(chromeTest.runNextTest);
  40   }
  41
  42   function allTestsDone() {
  43     if (testsFailed == 0) {
  44       chromeTest.notifyPass();
  45     } else {
  46       chromeTest.notifyFail('Failed ' + testsFailed + ' of ' +
  47                              testCount + ' tests');
  48     }
  49   }
  50
  51   var pendingCallbacks = 0;
  52
  53   apiFunctions.setHandleRequest('callbackAdded', function() {
  54     pendingCallbacks++;
  55
  56     var called = null;
  57     return function() {
  58       if (called != null) {
  59         var redundantPrefix = 'Error\n';
  60         chromeTest.fail(
  61           'Callback has already been run. ' +
  62           'First call:\n' +
  63           $String.slice(called, redundantPrefix.length) + '\n' +
  64           'Second call:\n' +
  65           $String.slice(new Error().stack, redundantPrefix.length));
  66       }
  67       called = new Error().stack;
  68
  69       pendingCallbacks--;
  70       if (pendingCallbacks == 0) {
  71         chromeTest.succeed();
  72       }
  73     };
  74   });
  75
  76   apiFunctions.setHandleRequest('runNextTest', function() {
  77     // There may have been callbacks which were interrupted by failure
  78     // exceptions.
  79     pendingCallbacks = 0;
  80
  81     lastTest = currentTest;
  82     currentTest = chromeTest.tests.shift();
  83
  84     if (!currentTest) {
  85       allTestsDone();
  86       return;
  87     }
  88
  89     try {
  90       chromeTest.log("( RUN      ) " + testName(currentTest));
  91       uncaughtExceptionHandler.setHandler(function(message, e) {
  92         if (e !== failureException)
  93           chromeTest.fail('uncaught exception: ' + message);
  94       });
  95       currentTest.call();
  96     } catch (e) {
  97       uncaughtExceptionHandler.handle(e.message, e);
  98     }
  99   });
 100
 101   apiFunctions.setHandleRequest('fail', function(message) {
 102     chromeTest.log("(  FAILED  ) " + testName(currentTest));
 103
 104     var stack = {};
 105     Error.captureStackTrace(stack, chromeTest.fail);
 106
 107     if (!message)
 108       message = "FAIL (no message)";
 109
 110     message += "\n" + stack.stack;
 111     console.log("[FAIL] " + testName(currentTest) + ": " + message);
 112     testsFailed++;
 113     testDone();
 114
 115     // Interrupt the rest of the test.
 116     throw failureException;
 117   });
 118
 119   apiFunctions.setHandleRequest('succeed', function() {
 120     console.log("[SUCCESS] " + testName(currentTest));
 121     chromeTest.log("(  SUCCESS )");
 122     testDone();
 123   });
 124
 125   apiFunctions.setHandleRequest('runWithModuleSystem', function(callback) {
 126     RunWithNativesEnabledModuleSystem(callback);
 127   });
 128
 129   apiFunctions.setHandleRequest('assertTrue', function(test, message) {
 130     chromeTest.assertBool(test, true, message);
 131   });
 132
 133   apiFunctions.setHandleRequest('assertFalse', function(test, message) {
 134     chromeTest.assertBool(test, false, message);
 135   });
 136
 137   apiFunctions.setHandleRequest('assertBool',
 138                                 function(test, expected, message) {
 139     if (test !== expected) {
 140       if (typeof(test) == "string") {
 141         if (message)
 142           message = test + "\n" + message;
 143         else
 144           message = test;
 145       }
 146       chromeTest.fail(message);
 147     }
 148   });
 149
 150   apiFunctions.setHandleRequest('checkDeepEq', function(expected, actual) {
 151     if ((expected === null) != (actual === null))
 152       return false;
 153
 154     if (expected === actual)
 155       return true;
 156
 157     if (typeof(expected) !== typeof(actual))
 158       return false;
 159
 160     for (var p in actual) {
 161       if ($Object.hasOwnProperty(actual, p) &&
 162           !$Object.hasOwnProperty(expected, p)) {
 163         return false;
 164       }
 165     }
 166     for (var p in expected) {
 167       if ($Object.hasOwnProperty(expected, p) &&
 168           !$Object.hasOwnProperty(actual, p)) {
 169         return false;
 170       }
 171     }
 172
 173     for (var p in expected) {
 174       var eq = true;
 175       switch (typeof(expected[p])) {
 176         case 'object':
 177           eq = chromeTest.checkDeepEq(expected[p], actual[p]);
 178           break;
 179         case 'function':
 180           eq = (typeof(actual[p]) != 'undefined' &&
 181                 expected[p].toString() == actual[p].toString());
 182           break;
 183         default:
 184           eq = (expected[p] == actual[p] &&
 185                 typeof(expected[p]) == typeof(actual[p]));
 186           break;
 187       }
 188       if (!eq)
 189         return false;
 190     }
 191     return true;
 192   });
 193
 194   apiFunctions.setHandleRequest('assertEq',
 195                                 function(expected, actual, message) {
 196     var error_msg = "API Test Error in " + testName(currentTest);
 197     if (message)
 198       error_msg += ": " + message;
 199     if (typeof(expected) == 'object') {
 200       if (!chromeTest.checkDeepEq(expected, actual)) {
 201         error_msg += "\nActual: " + $JSON.stringify(actual) +
 202                      "\nExpected: " + $JSON.stringify(expected);
 203         chromeTest.fail(error_msg);
 204       }
 205       return;
 206     }
 207     if (expected != actual) {
 208       chromeTest.fail(error_msg +
 209                        "\nActual: " + actual + "\nExpected: " + expected);
 210     }
 211     if (typeof(expected) != typeof(actual)) {
 212       chromeTest.fail(error_msg +
 213                        " (type mismatch)\nActual Type: " + typeof(actual) +
 214                        "\nExpected Type:" + typeof(expected));
 215     }
 216   });
 217
 218   apiFunctions.setHandleRequest('assertNoLastError', function() {
 219     if (chrome.runtime.lastError != undefined) {
 220       chromeTest.fail("lastError.message == " +
 221                        chrome.runtime.lastError.message);
 222     }
 223   });
 224
 225   apiFunctions.setHandleRequest('assertLastError', function(expectedError) {
 226     chromeTest.assertEq(typeof(expectedError), 'string');
 227     chromeTest.assertTrue(chrome.runtime.lastError != undefined,
 228         "No lastError, but expected " + expectedError);
 229     chromeTest.assertEq(expectedError, chrome.runtime.lastError.message);
 230   });
 231
 232   apiFunctions.setHandleRequest('assertThrows',
 233                                 function(fn, self, args, message) {
 234     chromeTest.assertTrue(typeof fn == 'function');
 235     try {
 236       fn.apply(self, args);
 237       chromeTest.fail('Did not throw error: ' + fn);
 238     } catch (e) {
 239       if (e != failureException && message !== undefined) {
 240         if (message instanceof RegExp) {
 241           chromeTest.assertTrue(message.test(e.message),
 242                                 e.message + ' should match ' + message)
 243         } else {
 244           chromeTest.assertEq(message, e.message);
 245         }
 246       }
 247     }
 248   });
 249
 250   function safeFunctionApply(func, args) {
 251     try {
 252       if (func)
 253         return $Function.apply(func, undefined, args);
 254     } catch (e) {
 255       var msg = "uncaught exception " + e;
 256       chromeTest.fail(msg);
 257     }
 258   };
 259
 260   // Wrapper for generating test functions, that takes care of calling
 261   // assertNoLastError() and (optionally) succeed() for you.
 262   apiFunctions.setHandleRequest('callback', function(func, expectedError) {
 263     if (func) {
 264       chromeTest.assertEq(typeof(func), 'function');
 265     }
 266     var callbackCompleted = chromeTest.callbackAdded();
 267
 268     return function() {
 269       if (expectedError == null) {
 270         chromeTest.assertNoLastError();
 271       } else {
 272         chromeTest.assertLastError(expectedError);
 273       }
 274
 275       var result;
 276       if (func) {
 277         result = safeFunctionApply(func, arguments);
 278       }
 279
 280       callbackCompleted();
 281       return result;
 282     };
 283   });
 284
 285   apiFunctions.setHandleRequest('listenOnce', function(event, func) {
 286     var callbackCompleted = chromeTest.callbackAdded();
 287     var listener = function() {
 288       event.removeListener(listener);
 289       safeFunctionApply(func, arguments);
 290       callbackCompleted();
 291     };
 292     event.addListener(listener);
 293   });
 294
 295   apiFunctions.setHandleRequest('listenForever', function(event, func) {
 296     var callbackCompleted = chromeTest.callbackAdded();
 297
 298     var listener = function() {
 299       safeFunctionApply(func, arguments);
 300     };
 301
 302     var done = function() {
 303       event.removeListener(listener);
 304       callbackCompleted();
 305     };
 306
 307     event.addListener(listener);
 308     return done;
 309   });
 310
 311   apiFunctions.setHandleRequest('callbackPass', function(func) {
 312     return chromeTest.callback(func);
 313   });
 314
 315   apiFunctions.setHandleRequest('callbackFail', function(expectedError, func) {
 316     return chromeTest.callback(func, expectedError);
 317   });
 318
 319   apiFunctions.setHandleRequest('runTests', function(tests) {
 320     chromeTest.tests = tests;
 321     testCount = chromeTest.tests.length;
 322     chromeTest.runNextTest();
 323   });
 324
 325   apiFunctions.setHandleRequest('getApiDefinitions', function() {
 326     return GetExtensionAPIDefinitionsForTest();
 327   });
 328
 329   apiFunctions.setHandleRequest('getApiFeatures', function() {
 330     return GetAPIFeatures();
 331   });
 332
 333   apiFunctions.setHandleRequest('isProcessingUserGesture', function() {
 334     return userGestures.IsProcessingUserGesture();
 335   });
 336
 337   apiFunctions.setHandleRequest('runWithUserGesture', function(callback) {
 338     chromeTest.assertEq(typeof(callback), 'function');
 339     return userGestures.RunWithUserGesture(callback);
 340   });
 341
 342   apiFunctions.setHandleRequest('runWithoutUserGesture', function(callback) {
 343     chromeTest.assertEq(typeof(callback), 'function');
 344     return userGestures.RunWithoutUserGesture(callback);
 345   });
 346
 347   apiFunctions.setHandleRequest('setExceptionHandler', function(callback) {
 348     chromeTest.assertEq(typeof(callback), 'function');
 349     uncaughtExceptionHandler.setHandler(callback);
 350   });
 351
 352   environmentSpecificBindings.registerHooks(api);
 353 });
 354
 355 exports.binding = binding.generate();