The Tor Browser: comparison addon-sdk/source/lib/sdk/test.js

comparison: addon-sdk/source/lib/sdk/test.js

addon-sdk/source/lib/sdk/test.js

branch: TOR_BUG_3246
changeset 7: 129ffea94266

equal deleted inserted replaced

--1:000000000000
+:932cdcf7624f
+/* This Source Code Form is subject to the terms of the Mozilla Public
+* License, v. 2.0. If a copy of the MPL was not distributed with this
+* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+"use strict";
+module.metadata = {
+"stability": "unstable"
+};
+const { Cu } = require("chrome");
+const { Task } = Cu.import("resource://gre/modules/Task.jsm", {});
+const { defer } = require("sdk/core/promise");
+const BaseAssert = require("sdk/test/assert").Assert;
+const { isFunction, isObject } = require("sdk/lang/type");
+exports.Assert = BaseAssert;
+function extend(target) {
+let descriptor = {}
+Array.slice(arguments, 1).forEach(function(source) {
+Object.getOwnPropertyNames(source).forEach(function onEach(name) {
+descriptor[name] = Object.getOwnPropertyDescriptor(source, name);
+});
+});
+return Object.create(target, descriptor);
+}
+/**
+* Function takes test `suite` object in CommonJS format and defines all of the
+* tests from that suite and nested suites in a jetpack format on a given
+* `target` object. Optionally third argument `prefix` can be passed to prefix
+* all the test names.
+*/
+function defineTestSuite(target, suite, prefix) {
+prefix = prefix || "";
+// If suite defines `Assert` that's what `assert` object have to be created
+// from and passed to a test function (This allows custom assertion functions)
+// See for details: http://wiki.commonjs.org/wiki/Unit_Testing/1.1
+let Assert = suite.Assert || BaseAssert;
+// Going through each item in the test suite and wrapping it into a
+// Jetpack test format.
+Object.keys(suite).forEach(function(key) {
+// If name starts with test then it's a test function or suite.
+if (key.indexOf("test") === 0) {
+let test = suite[key];
+// For each test function so we create a wrapper test function in a
+// jetpack format and copy that to a `target` exports.
+if (isFunction(test)) {
+// Since names of the test may match across suites we use full object
+// path as a name to avoid overriding same function.
+target[prefix + key] = function(options) {
+// Creating `assert` functions for this test.
+let assert = Assert(options);
+assert.end = () => options.done();
+// If test function is a generator use a task JS to allow yield-ing
+// style test runs.
+if (test.isGenerator && test.isGenerator()) {
+options.waitUntilDone();
+Task.spawn(test.bind(null, assert)).
+then(null, assert.fail).
+then(assert.end);
+}
+// If CommonJS test function expects more than one argument
+// it means that test is async and second argument is a callback
+// to notify that test is finished.
+else if (1 < test.length) {
+// Letting test runner know that test is executed async and
+// creating a callback function that CommonJS tests will call
+// once it's done.
+options.waitUntilDone();
+test(assert, function() {
+options.done();
+});
+}
+// Otherwise CommonJS test is synchronous so we call it only with
+// one argument.
+else {
+test(assert);
+}
+}
+}
+// If it's an object then it's a test suite containing test function
+// and / or nested test suites. In that case we just extend prefix used
+// and call this function to copy and wrap tests from nested suite.
+else if (isObject(test)) {
+// We need to clone `tests` instead of modifying it, since it's very
+// likely that it is frozen (usually test suites imported modules).
+test = extend(Object.prototype, test, {
+Assert: test.Assert || Assert
+});
+defineTestSuite(target, test, prefix + key + ".");
+}
+}
+});
+}
+/**
+* This function is a CommonJS test runner function, but since Jetpack test
+* runner and test format is different from CommonJS this function shims given
+* `exports` with all its tests into a Jetpack test format so that the built-in
+* test runner will be able to run CommonJS test without manual changes.
+*/
+exports.run = function run(exports) {
+// We can't leave old properties on exports since those are test in a CommonJS
+// format that why we move everything to a new `suite` object.
+let suite = {};
+Object.keys(exports).forEach(function(key) {
+suite[key] = exports[key];
+delete exports[key];
+});
+// Now we wrap all the CommonJS tests to a Jetpack format and define
+// those to a given `exports` object since that where jetpack test runner
+// will look for them.
+defineTestSuite(exports, suite);
+};