From 6bf0a5cb5034a7e684dcc3500e841785237ce2dd Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Sun, 7 Apr 2024 19:32:43 +0200 Subject: Adding upstream version 1:115.7.0. Signed-off-by: Daniel Baumann --- testing/modules/AppData.sys.mjs | 88 +++ testing/modules/AppInfo.sys.mjs | 139 +++++ testing/modules/Assert.sys.mjs | 695 +++++++++++++++++++++ testing/modules/CoverageUtils.sys.mjs | 210 +++++++ testing/modules/FileTestUtils.sys.mjs | 127 ++++ testing/modules/MockRegistrar.sys.mjs | 127 ++++ testing/modules/MockRegistry.sys.mjs | 145 +++++ testing/modules/Sinon.sys.mjs | 40 ++ testing/modules/StructuredLog.sys.mjs | 304 +++++++++ testing/modules/TestUtils.sys.mjs | 381 +++++++++++ testing/modules/XPCShellContentUtils.sys.mjs | 490 +++++++++++++++ testing/modules/moz.build | 39 ++ testing/modules/tests/browser/browser.ini | 1 + .../modules/tests/browser/browser_test_assert.js | 21 + testing/modules/tests/xpcshell/test_assert.js | 470 ++++++++++++++ .../modules/tests/xpcshell/test_mockRegistrar.js | 65 ++ .../modules/tests/xpcshell/test_structuredlog.js | 147 +++++ testing/modules/tests/xpcshell/xpcshell.ini | 6 + 18 files changed, 3495 insertions(+) create mode 100644 testing/modules/AppData.sys.mjs create mode 100644 testing/modules/AppInfo.sys.mjs create mode 100644 testing/modules/Assert.sys.mjs create mode 100644 testing/modules/CoverageUtils.sys.mjs create mode 100644 testing/modules/FileTestUtils.sys.mjs create mode 100644 testing/modules/MockRegistrar.sys.mjs create mode 100644 testing/modules/MockRegistry.sys.mjs create mode 100644 testing/modules/Sinon.sys.mjs create mode 100644 testing/modules/StructuredLog.sys.mjs create mode 100644 testing/modules/TestUtils.sys.mjs create mode 100644 testing/modules/XPCShellContentUtils.sys.mjs create mode 100644 testing/modules/moz.build create mode 100644 testing/modules/tests/browser/browser.ini create mode 100644 testing/modules/tests/browser/browser_test_assert.js create mode 100644 testing/modules/tests/xpcshell/test_assert.js create mode 100644 testing/modules/tests/xpcshell/test_mockRegistrar.js create mode 100644 testing/modules/tests/xpcshell/test_structuredlog.js create mode 100644 testing/modules/tests/xpcshell/xpcshell.ini (limited to 'testing/modules') diff --git a/testing/modules/AppData.sys.mjs b/testing/modules/AppData.sys.mjs new file mode 100644 index 0000000000..0eaa3ba722 --- /dev/null +++ b/testing/modules/AppData.sys.mjs @@ -0,0 +1,88 @@ +/* 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/. */ + +// Reference needed in order for fake app dir provider to be active. +var gFakeAppDirectoryProvider; + +/** + * Installs a fake UAppData directory. + * + * This is needed by tests because a UAppData directory typically isn't + * present in the test environment. + * + * We create the new UAppData directory under the profile's directory + * because the profile directory is automatically cleaned as part of + * test shutdown. + * + * This returns a promise that will be resolved once the new directory + * is created and installed. + */ +export var makeFakeAppDir = function () { + let dirMode = 0o700; + let baseFile = Services.dirsvc.get("ProfD", Ci.nsIFile); + let appD = baseFile.clone(); + appD.append("UAppData"); + + if (gFakeAppDirectoryProvider) { + return Promise.resolve(appD.path); + } + + function makeDir(f) { + if (f.exists()) { + return; + } + + dump("Creating directory: " + f.path + "\n"); + f.create(Ci.nsIFile.DIRECTORY_TYPE, dirMode); + } + + makeDir(appD); + + let reportsD = appD.clone(); + reportsD.append("Crash Reports"); + + let pendingD = reportsD.clone(); + pendingD.append("pending"); + let submittedD = reportsD.clone(); + submittedD.append("submitted"); + + makeDir(reportsD); + makeDir(pendingD); + makeDir(submittedD); + + let provider = { + getFile(prop, persistent) { + persistent.value = true; + if (prop == "UAppData") { + return appD.clone(); + } + + throw Components.Exception("", Cr.NS_ERROR_FAILURE); + }, + + QueryInterace(iid) { + if ( + iid.equals(Ci.nsIDirectoryServiceProvider) || + iid.equals(Ci.nsISupports) + ) { + return this; + } + + throw Components.Exception("", Cr.NS_ERROR_NO_INTERFACE); + }, + }; + + // Register the new provider. + Services.dirsvc.registerProvider(provider); + + // And undefine the old one. + try { + Services.dirsvc.undefine("UAppData"); + } catch (ex) {} + + gFakeAppDirectoryProvider = provider; + + dump("Successfully installed fake UAppDir\n"); + return Promise.resolve(appD.path); +}; diff --git a/testing/modules/AppInfo.sys.mjs b/testing/modules/AppInfo.sys.mjs new file mode 100644 index 0000000000..13e20851b2 --- /dev/null +++ b/testing/modules/AppInfo.sys.mjs @@ -0,0 +1,139 @@ +/* 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/. */ + +let origPlatformInfo = Cc["@mozilla.org/xre/app-info;1"].getService( + Ci.nsIPlatformInfo +); + +// eslint-disable-next-line mozilla/use-services +let origRuntime = Cc["@mozilla.org/xre/app-info;1"].getService( + Ci.nsIXULRuntime +); + +/** + * Create new XULAppInfo instance with specified options. + * + * options is a object with following keys: + * ID: nsIXULAppInfo.ID + * name: nsIXULAppInfo.name + * version: nsIXULAppInfo.version + * platformVersion: nsIXULAppInfo.platformVersion + * OS: nsIXULRuntime.OS + * appBuildID: nsIXULRuntime.appBuildID + * lastAppBuildID: nsIXULRuntime.lastAppBuildID + * lastAppVersion: nsIXULRuntime.lastAppVersion + * + * crashReporter: nsICrashReporter interface is implemented if true + */ +export var newAppInfo = function (options = {}) { + let appInfo = { + // nsIXULAppInfo + vendor: "Mozilla", + name: options.name ?? "xpcshell", + ID: options.ID ?? "xpcshell@tests.mozilla.org", + version: options.version ?? "1", + appBuildID: options.appBuildID ?? "20160315", + + // nsIPlatformInfo + platformVersion: options.platformVersion ?? "p-ver", + platformBuildID: origPlatformInfo.platformBuildID, + + // nsIXULRuntime + ...Ci.nsIXULRuntime, + inSafeMode: false, + logConsoleErrors: true, + OS: options.OS ?? "XPCShell", + XPCOMABI: "noarch-spidermonkey", + invalidateCachesOnRestart() {}, + shouldBlockIncompatJaws: false, + processType: origRuntime.processType, + uniqueProcessID: origRuntime.uniqueProcessID, + + fissionAutostart: origRuntime.fissionAutostart, + sessionHistoryInParent: origRuntime.sessionHistoryInParent, + browserTabsRemoteAutostart: origRuntime.browserTabsRemoteAutostart, + get maxWebProcessCount() { + return origRuntime.maxWebProcessCount; + }, + get launcherProcessState() { + return origRuntime.launcherProcessState; + }, + + // nsIWinAppHelper + get userCanElevate() { + return false; + }, + }; + + appInfo.lastAppBuildID = options.lastAppBuildID ?? appInfo.appBuildID; + appInfo.lastAppVersion = options.lastAppVersion ?? appInfo.version; + + let interfaces = [ + Ci.nsIXULAppInfo, + Ci.nsIPlatformInfo, + Ci.nsIXULRuntime, + Ci.nsICrashReporter, + ]; + if ("nsIWinAppHelper" in Ci) { + interfaces.push(Ci.nsIWinAppHelper); + } + + // nsICrashReporter + appInfo.annotations = {}; + appInfo.annotateCrashReport = function (key, data) { + if (options.crashReporter) { + this.annotations[key] = data; + } else { + throw Components.Exception("", Cr.NS_ERROR_NOT_INITIALIZED); + } + }; + + appInfo.QueryInterface = ChromeUtils.generateQI(interfaces); + + return appInfo; +}; + +var currentAppInfo = newAppInfo(); + +/** + * Obtain a reference to the current object used to define XULAppInfo. + */ +export var getAppInfo = function () { + return currentAppInfo; +}; + +/** + * Update the current application info. + * + * See newAppInfo for options. + * + * To change the current XULAppInfo, simply call this function. If there was + * a previously registered app info object, it will be unloaded and replaced. + */ +export var updateAppInfo = function (options) { + currentAppInfo = newAppInfo(options); + + let id = Components.ID("{fbfae60b-64a4-44ef-a911-08ceb70b9f31}"); + let contractid = "@mozilla.org/xre/app-info;1"; + let registrar = Components.manager.QueryInterface(Ci.nsIComponentRegistrar); + + // Unregister an existing factory if one exists. + try { + let existing = Components.manager.getClassObjectByContractID( + contractid, + Ci.nsIFactory + ); + registrar.unregisterFactory(id, existing); + } catch (ex) {} + + let factory = { + createInstance(iid) { + return currentAppInfo.QueryInterface(iid); + }, + }; + + Services.appinfo = currentAppInfo; + + registrar.registerFactory(id, "XULAppInfo", contractid, factory); +}; diff --git a/testing/modules/Assert.sys.mjs b/testing/modules/Assert.sys.mjs new file mode 100644 index 0000000000..bd1393e674 --- /dev/null +++ b/testing/modules/Assert.sys.mjs @@ -0,0 +1,695 @@ +/* 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/. */ + +// Originally from narwhal.js (http://narwhaljs.org) +// Copyright (c) 2009 Thomas Robinson <280north.com> +// MIT license: http://opensource.org/licenses/MIT + +const { ObjectUtils } = ChromeUtils.import( + "resource://gre/modules/ObjectUtils.jsm" +); + +/** + * This module is based on the + * `CommonJS spec `_ + * + * When you see a jsdoc comment that contains a number, it's a reference to a + * specific section of the CommonJS spec. + * + * 1. The assert module provides functions that throw AssertionError's when + * particular conditions are not met. + * + * To use the module you may instantiate it first. + * + * @param {reporterFunc} reporterFunc + * Allows consumers to override reporting for this instance. + * @param {boolean} isDefault + * Used by test suites to set ``reporterFunc`` as the default + * used by the global instance, which is called for example + * by other test-only modules. This is false when the + * reporter is set by content scripts, because they may still + * run in the parent process. + * + * @class + */ +export function Assert(reporterFunc, isDefault) { + if (reporterFunc) { + this.setReporter(reporterFunc); + } + if (isDefault) { + Assert.setReporter(reporterFunc); + } +} + +// This allows using the Assert object as an additional global instance. +Object.setPrototypeOf(Assert, Assert.prototype); + +function instanceOf(object, type) { + return Object.prototype.toString.call(object) == "[object " + type + "]"; +} + +function replacer(key, value) { + if (value === undefined) { + return "" + value; + } + if (typeof value === "number" && (isNaN(value) || !isFinite(value))) { + return value.toString(); + } + if (typeof value === "function" || instanceOf(value, "RegExp")) { + return value.toString(); + } + return value; +} + +const kTruncateLength = 128; + +function truncate(text, newLength = kTruncateLength) { + if (typeof text == "string") { + return text.length < newLength ? text : text.slice(0, newLength); + } + return text; +} + +function getMessage(error, prefix = "") { + let actual, expected; + // Wrap calls to JSON.stringify in try...catch blocks, as they may throw. If + // so, fall back to toString(). + try { + actual = JSON.stringify(error.actual, replacer); + } catch (ex) { + actual = Object.prototype.toString.call(error.actual); + } + try { + expected = JSON.stringify(error.expected, replacer); + } catch (ex) { + expected = Object.prototype.toString.call(error.expected); + } + let message = prefix; + if (error.operator) { + let truncateLength = error.truncate ? kTruncateLength : Infinity; + message += + (prefix ? " - " : "") + + truncate(actual, truncateLength) + + " " + + error.operator + + " " + + truncate(expected, truncateLength); + } + return message; +} + +/** + * 2. The AssertionError is defined in assert. + * + * At present only the four keys mentioned below are used and + * understood by the spec. Implementations or sub modules can pass + * other keys to the AssertionError's constructor - they will be + * ignored. + * + * @example + * + * new assert.AssertionError({ + * message: message, + * actual: actual, + * expected: expected, + * operator: operator, + * truncate: truncate + * }); + * + */ +Assert.AssertionError = function (options) { + this.name = "AssertionError"; + this.actual = options.actual; + this.expected = options.expected; + this.operator = options.operator; + this.message = getMessage(this, options.message, options.truncate); + // The part of the stack that comes from this module is not interesting. + let stack = Components.stack; + do { + stack = stack.asyncCaller || stack.caller; + } while ( + stack && + stack.filename && + stack.filename.includes("Assert.sys.mjs") + ); + this.stack = stack; +}; + +// assert.AssertionError instanceof Error +Assert.AssertionError.prototype = Object.create(Error.prototype, { + constructor: { + value: Assert.AssertionError, + enumerable: false, + writable: true, + configurable: true, + }, +}); + +Assert.prototype._reporter = null; + +/** + * This callback type is used for custom assertion report handling. + * + * @callback reporterFunc + * @param {AssertionError|null} err + * An error object when the assertion failed, or null when it passed. + * @param {String} message + * Message describing the assertion. + * @param {Stack} stack + * Stack trace of the assertion function. + */ + +/** + * Set a custom assertion report handler function. + * + * @example + * + * Assert.setReporter(function customReporter(err, message, stack) { + * if (err) { + * do_report_result(false, err.message, err.stack); + * } else { + * do_report_result(true, message, stack); + * } + * }); + * + * @param {reporterFunc} reporterFunc + * Report handler function. + */ +Assert.prototype.setReporter = function (reporterFunc) { + this._reporter = reporterFunc; +}; + +/** + * 3. All of the following functions must throw an AssertionError when a + * corresponding condition is not met, with a message that may be undefined if + * not provided. All assertion methods provide both the actual and expected + * values to the assertion error for display purposes. + * + * This report method only throws errors on assertion failures, as per spec, + * but consumers of this module (think: xpcshell-test, mochitest) may want to + * override this default implementation. + * + * @example + * + * // The following will report an assertion failure. + * this.report(1 != 2, 1, 2, "testing JS number math!", "=="); + * + * @param {boolean} failed + * Indicates if the assertion failed or not. + * @param {*} actual + * The result of evaluating the assertion. + * @param {*} [expected] + * Expected result from the test author. + * @param {String} [message] + * Short explanation of the expected result. + * @param {String} [operator] + * Operation qualifier used by the assertion method (ex: '=='). + * @param {boolean} [truncate=true] + * Whether or not ``actual`` and ``expected`` should be truncated when printing. + */ +Assert.prototype.report = function ( + failed, + actual, + expected, + message, + operator, + truncate = true +) { + // Although not ideal, we allow a "null" message due to the way some of the extension tests + // work. + if (message !== undefined && message !== null && typeof message != "string") { + this.ok( + false, + `Expected a string or undefined for the error message to Assert.*, got ${typeof message}` + ); + } + let err = new Assert.AssertionError({ + message, + actual, + expected, + operator, + truncate, + }); + if (!this._reporter) { + // If no custom reporter is set, throw the error. + if (failed) { + throw err; + } + } else { + this._reporter(failed ? err : null, err.message, err.stack); + } +}; + +/** + * 4. Pure assertion tests whether a value is truthy, as determined by !!guard. + * ``assert.ok(guard, message_opt);`` + * This statement is equivalent to ``assert.equal(true, !!guard, message_opt);``. + * To test strictly for the value true, use ``assert.strictEqual(true, guard, + * message_opt);``. + * + * @param {*} value + * Test subject to be evaluated as truthy. + * @param {String} [message] + * Short explanation of the expected result. + */ +Assert.prototype.ok = function (value, message) { + if (arguments.length > 2) { + this.report( + true, + false, + true, + "Too many arguments passed to `Assert.ok()`", + "==" + ); + } else { + this.report(!value, value, true, message, "=="); + } +}; + +/** + * 5. The equality assertion tests shallow, coercive equality with ==. + * ``assert.equal(actual, expected, message_opt);`` + * + * @param {*} actual + * Test subject to be evaluated as equivalent to ``expected``. + * @param {*} expected + * Test reference to evaluate against ``actual``. + * @param {String} [message] + * Short explanation of the expected result. + */ +Assert.prototype.equal = function equal(actual, expected, message) { + this.report(actual != expected, actual, expected, message, "=="); +}; + +/** + * 6. The non-equality assertion tests for whether two objects are not equal + * with ``!=`` + * + * @example + * assert.notEqual(actual, expected, message_opt); + * + * @param {*} actual + * Test subject to be evaluated as NOT equivalent to ``expected``. + * @param {*} expected + * Test reference to evaluate against ``actual``. + * @param {String} [message] + * Short explanation of the expected result. + */ +Assert.prototype.notEqual = function notEqual(actual, expected, message) { + this.report(actual == expected, actual, expected, message, "!="); +}; + +/** + * 7. The equivalence assertion tests a deep equality relation. + * assert.deepEqual(actual, expected, message_opt); + * + * We check using the most exact approximation of equality between two objects + * to keep the chance of false positives to a minimum. + * `JSON.stringify` is not designed to be used for this purpose; objects may + * have ambiguous `toJSON()` implementations that would influence the test. + * + * @param {*} actual + * Test subject to be evaluated as equivalent to ``expected``, including nested properties. + * @param {*} expected + * Test reference to evaluate against ``actual``. + * @param {String} [message] + * Short explanation of the expected result. + */ +Assert.prototype.deepEqual = function deepEqual(actual, expected, message) { + this.report( + !ObjectUtils.deepEqual(actual, expected), + actual, + expected, + message, + "deepEqual", + false + ); +}; + +/** + * 8. The non-equivalence assertion tests for any deep inequality. + * assert.notDeepEqual(actual, expected, message_opt); + * + * @param {*} actual + * Test subject to be evaluated as NOT equivalent to ``expected``, including nested + * properties. + * @param {*} expected + * Test reference to evaluate against ``actual``. + * @param {String} [message] + * Short explanation of the expected result. + */ +Assert.prototype.notDeepEqual = function notDeepEqual( + actual, + expected, + message +) { + this.report( + ObjectUtils.deepEqual(actual, expected), + actual, + expected, + message, + "notDeepEqual", + false + ); +}; + +/** + * 9. The strict equality assertion tests strict equality, as determined by ===. + * ``assert.strictEqual(actual, expected, message_opt);`` + * + * @param {*} actual + * Test subject to be evaluated as strictly equivalent to ``expected``. + * @param {*} expected + * Test reference to evaluate against ``actual``. + * @param {String} [message] + * Short explanation of the expected result. + */ +Assert.prototype.strictEqual = function strictEqual(actual, expected, message) { + this.report(actual !== expected, actual, expected, message, "==="); +}; + +/** + * 10. The strict non-equality assertion tests for strict inequality, as + * determined by !==. ``assert.notStrictEqual(actual, expected, message_opt);`` + * + * @param {*} actual + * Test subject to be evaluated as NOT strictly equivalent to ``expected``. + * @param {*} expected + * Test reference to evaluate against ``actual``. + * @param {String} [message] + * Short explanation of the expected result. + */ +Assert.prototype.notStrictEqual = function notStrictEqual( + actual, + expected, + message +) { + this.report(actual === expected, actual, expected, message, "!=="); +}; + +function checkExpectedArgument(instance, funcName, expected) { + if (!expected) { + instance.ok( + false, + `Error: The 'expected' argument was not supplied to Assert.${funcName}()` + ); + } + + if ( + !instanceOf(expected, "RegExp") && + typeof expected !== "function" && + typeof expected !== "object" + ) { + instance.ok( + false, + `Error: The 'expected' argument to Assert.${funcName}() must be a RegExp, function or an object` + ); + } +} + +function expectedException(actual, expected) { + if (!actual || !expected) { + return false; + } + + if (instanceOf(expected, "RegExp")) { + return expected.test(actual); + // We need to guard against the right hand parameter of "instanceof" lacking + // the "prototype" property, which is true of arrow functions in particular. + } else if ( + !(typeof expected === "function" && !expected.prototype) && + actual instanceof expected + ) { + return true; + } else if (expected.call({}, actual) === true) { + return true; + } + + return false; +} + +/** + * 11. Expected to throw an error: + * assert.throws(block, Error_opt, message_opt); + * + * Example: + * ```js + * // The following will verify that an error of type TypeError was thrown: + * Assert.throws(() => testBody(), TypeError); + * // The following will verify that an error was thrown with an error message matching "hello": + * Assert.throws(() => testBody(), /hello/); + * ``` + * + * @param {Function} block + * Function to evaluate and catch eventual thrown errors. + * @param {RegExp|Function} expected + * This parameter can be either a RegExp or a function. The function is + * either the error type's constructor, or it's a method that returns + * a boolean that describes the test outcome. + * @param {String} [message] + * Short explanation of the expected result. + */ +Assert.prototype.throws = function (block, expected, message) { + checkExpectedArgument(this, "throws", expected); + + // `true` if we realize that we have added an + // error to `ChromeUtils.recentJSDevError` and + // that we probably need to clean it up. + let cleanupRecentJSDevError = false; + if ("recentJSDevError" in ChromeUtils) { + // Check that we're in a build of Firefox that supports + // the `recentJSDevError` mechanism (i.e. Nightly build). + if (ChromeUtils.recentJSDevError === undefined) { + // There was no previous error, so if we throw + // an error here, we may need to clean it up. + cleanupRecentJSDevError = true; + } + } + + let actual; + + try { + block(); + } catch (e) { + actual = e; + } + + message = + (expected.name ? " (" + expected.name + ")." : ".") + + (message ? " " + message : "."); + + if (!actual) { + this.report(true, actual, expected, "Missing expected exception" + message); + } + + if (actual && !expectedException(actual, expected)) { + throw actual; + } + + this.report(false, expected, expected, message); + + // Make sure that we don't cause failures for JS Dev Errors that + // were expected, typically for tests that attempt to check + // that we react properly to TypeError, ReferenceError, SyntaxError. + if (cleanupRecentJSDevError) { + let recentJSDevError = ChromeUtils.recentJSDevError; + if (recentJSDevError) { + if (expectedException(recentJSDevError)) { + ChromeUtils.clearRecentJSDevError(); + } + } + } +}; + +/** + * A promise that is expected to reject: + * assert.rejects(promise, expected, message); + * + * @param {Promise} promise + * A promise that is expected to reject. + * @param {?} [expected] + * Test reference to evaluate against the rejection result. + * @param {String} [message] + * Short explanation of the expected result. + */ +Assert.prototype.rejects = function (promise, expected, message) { + checkExpectedArgument(this, "rejects", expected); + return new Promise((resolve, reject) => { + return promise + .then( + () => + this.report( + true, + null, + expected, + "Missing expected exception " + message + ), + err => { + if (!expectedException(err, expected)) { + reject(err); + return; + } + this.report(false, err, expected, message); + resolve(); + } + ) + .catch(reject); + }); +}; + +function compareNumbers(expression, lhs, rhs, message, operator) { + let lhsIsNumber = typeof lhs == "number" && !Number.isNaN(lhs); + let rhsIsNumber = typeof rhs == "number" && !Number.isNaN(rhs); + + if (lhsIsNumber && rhsIsNumber) { + this.report(expression, lhs, rhs, message, operator); + return; + } + + let errorMessage; + if (!lhsIsNumber && !rhsIsNumber) { + errorMessage = "Neither '" + lhs + "' nor '" + rhs + "' are numbers"; + } else { + errorMessage = "'" + (lhsIsNumber ? rhs : lhs) + "' is not a number"; + } + this.report(true, lhs, rhs, errorMessage); +} + +/** + * The lhs must be greater than the rhs. + * assert.greater(lhs, rhs, message_opt); + * + * @param {Number} lhs + * The left-hand side value. + * @param {Number} rhs + * The right-hand side value. + * @param {String} [message] + * Short explanation of the comparison result. + */ +Assert.prototype.greater = function greater(lhs, rhs, message) { + compareNumbers.call(this, lhs <= rhs, lhs, rhs, message, ">"); +}; + +/** + * The lhs must be greater than or equal to the rhs. + * assert.greaterOrEqual(lhs, rhs, message_opt); + * + * @param {Number} [lhs] + * The left-hand side value. + * @param {Number} [rhs] + * The right-hand side value. + * @param {String} [message] + * Short explanation of the comparison result. + */ +Assert.prototype.greaterOrEqual = function greaterOrEqual(lhs, rhs, message) { + compareNumbers.call(this, lhs < rhs, lhs, rhs, message, ">="); +}; + +/** + * The lhs must be less than the rhs. + * assert.less(lhs, rhs, message_opt); + * + * @param {Number} [lhs] + * The left-hand side value. + * @param {Number} [rhs] + * The right-hand side value. + * @param {String} [message] + * Short explanation of the comparison result. + */ +Assert.prototype.less = function less(lhs, rhs, message) { + compareNumbers.call(this, lhs >= rhs, lhs, rhs, message, "<"); +}; + +/** + * The lhs must be less than or equal to the rhs. + * assert.lessOrEqual(lhs, rhs, message_opt); + * + * @param {Number} [lhs] + * The left-hand side value. + * @param {Number} [rhs] + * The right-hand side value. + * @param {String} [message] + * Short explanation of the comparison result. + */ +Assert.prototype.lessOrEqual = function lessOrEqual(lhs, rhs, message) { + compareNumbers.call(this, lhs > rhs, lhs, rhs, message, "<="); +}; + +/** + * The lhs must be a string that matches the rhs regular expression. + * rhs can be specified either as a string or a RegExp object. If specified as a + * string it will be interpreted as a regular expression so take care to escape + * special characters such as "?" or "(" if you need the actual characters. + * + * @param {String} lhs + * The string to be tested. + * @param {String|RegExp} rhs + * The regular expression that the string will be tested with. + * Note that if passed as a string, this will be interpreted. + * as a regular expression. + * @param {String} [message] + * Short explanation of the comparison result. + */ +Assert.prototype.stringMatches = function stringMatches(lhs, rhs, message) { + if (typeof rhs != "string" && !instanceOf(rhs, "RegExp")) { + this.report( + true, + lhs, + String(rhs), + `Expected a string or a RegExp for rhs, but "${rhs}" isn't a string or a RegExp object.` + ); + return; + } + + if (typeof lhs != "string") { + this.report( + true, + lhs, + String(rhs), + `Expected a string for lhs, but "${lhs}" isn't a string.` + ); + return; + } + + if (typeof rhs == "string") { + try { + rhs = new RegExp(rhs); + } catch { + this.report( + true, + lhs, + rhs, + `Expected a valid regular expression for rhs, but "${rhs}" isn't one.` + ); + return; + } + } + + const isCorrect = rhs.test(lhs); + this.report(!isCorrect, lhs, rhs.toString(), message, "matches"); +}; + +/** + * The lhs must be a string that contains the rhs string. + * + * @param {String} lhs + * The string to be tested (haystack). + * @param {String} rhs + * The string to be found (needle). + * @param {String} [message] + * Short explanation of the expected result. + */ +Assert.prototype.stringContains = function stringContains(lhs, rhs, message) { + if (typeof lhs != "string" || typeof rhs != "string") { + this.report( + true, + lhs, + rhs, + `Expected a string for both lhs and rhs, but either "${lhs}" or "${rhs}" is not a string.` + ); + } + + const isCorrect = lhs.includes(rhs); + this.report(!isCorrect, lhs, rhs, message, "includes"); +}; diff --git a/testing/modules/CoverageUtils.sys.mjs b/testing/modules/CoverageUtils.sys.mjs new file mode 100644 index 0000000000..990d82ad7a --- /dev/null +++ b/testing/modules/CoverageUtils.sys.mjs @@ -0,0 +1,210 @@ +/* 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/. */ + +import { addDebuggerToGlobal } from "resource://gre/modules/jsdebugger.sys.mjs"; + +// eslint-disable-next-line mozilla/reject-globalThis-modification +addDebuggerToGlobal(globalThis); + +/** + * Records coverage for each test by way of the js debugger. + */ +export var CoverageCollector = function (prefix) { + this._prefix = prefix; + this._dbg = new Debugger(); + this._dbg.collectCoverageInfo = true; + this._dbg.addAllGlobalsAsDebuggees(); + this._scripts = this._dbg.findScripts(); + + this._dbg.onNewScript = script => { + this._scripts.push(script); + }; + + // Source -> coverage data; + this._allCoverage = {}; + this._encoder = new TextEncoder(); + + this._testIndex = 0; +}; + +CoverageCollector.prototype._getLinesCovered = function () { + let coveredLines = {}; + let currentCoverage = {}; + this._scripts.forEach(s => { + let scriptName = s.url; + let cov = s.getOffsetsCoverage(); + if (!cov) { + return; + } + + cov.forEach(covered => { + let { lineNumber, columnNumber, offset, count } = covered; + if (!count) { + return; + } + + if (!currentCoverage[scriptName]) { + currentCoverage[scriptName] = {}; + } + if (!this._allCoverage[scriptName]) { + this._allCoverage[scriptName] = {}; + } + + let key = [lineNumber, columnNumber, offset].join("#"); + if (!currentCoverage[scriptName][key]) { + currentCoverage[scriptName][key] = count; + } else { + currentCoverage[scriptName][key] += count; + } + }); + }); + + // Covered lines are determined by comparing every offset mentioned as of the + // the completion of a test to the last time we measured coverage. If an + // offset in a line is novel as of this test, or a count has increased for + // any offset on a particular line, that line must have been covered. + for (let scriptName in currentCoverage) { + for (let key in currentCoverage[scriptName]) { + if ( + !this._allCoverage[scriptName] || + !this._allCoverage[scriptName][key] || + this._allCoverage[scriptName][key] < currentCoverage[scriptName][key] + ) { + // eslint-disable-next-line no-unused-vars + let [lineNumber, colNumber, offset] = key.split("#"); + if (!coveredLines[scriptName]) { + coveredLines[scriptName] = new Set(); + } + coveredLines[scriptName].add(parseInt(lineNumber, 10)); + this._allCoverage[scriptName][key] = currentCoverage[scriptName][key]; + } + } + } + + return coveredLines; +}; + +CoverageCollector.prototype._getUncoveredLines = function () { + let uncoveredLines = {}; + this._scripts.forEach(s => { + let scriptName = s.url; + let scriptOffsets = s.getAllOffsets(); + + if (!uncoveredLines[scriptName]) { + uncoveredLines[scriptName] = new Set(); + } + + // Get all lines in the script + scriptOffsets.forEach(function (element, index) { + if (!element) { + return; + } + uncoveredLines[scriptName].add(index); + }); + }); + + // For all covered lines, delete their entry + for (let scriptName in this._allCoverage) { + for (let key in this._allCoverage[scriptName]) { + // eslint-disable-next-line no-unused-vars + let [lineNumber, columnNumber, offset] = key.split("#"); + uncoveredLines[scriptName].delete(parseInt(lineNumber, 10)); + } + } + + return uncoveredLines; +}; + +CoverageCollector.prototype._getMethodNames = function () { + let methodNames = {}; + this._scripts.forEach(s => { + let method = s.displayName; + // If the method name is undefined, we return early + if (!method) { + return; + } + + let scriptName = s.url; + let tempMethodCov = []; + let scriptOffsets = s.getAllOffsets(); + + if (!methodNames[scriptName]) { + methodNames[scriptName] = {}; + } + + /** + * Get all lines contained within the method and + * push a record of the form: + * : + */ + scriptOffsets.forEach(function (element, index) { + if (!element) { + return; + } + tempMethodCov.push(index); + }); + methodNames[scriptName][method] = tempMethodCov; + }); + + return methodNames; +}; + +/** + * Records lines covered since the last time coverage was recorded, + * associating them with the given test name. The result is written + * to a json file in a specified directory. + */ +CoverageCollector.prototype.recordTestCoverage = function (testName) { + dump("Collecting coverage for: " + testName + "\n"); + let rawLines = this._getLinesCovered(testName); + let methods = this._getMethodNames(); + let uncoveredLines = this._getUncoveredLines(); + let result = []; + let versionControlBlock = { version: 1.0 }; + result.push(versionControlBlock); + + for (let scriptName in rawLines) { + let rec = { + testUrl: testName, + sourceFile: scriptName, + methods: {}, + covered: [], + uncovered: [], + }; + + if ( + typeof methods[scriptName] != "undefined" && + methods[scriptName] != null + ) { + for (let [methodName, methodLines] of Object.entries( + methods[scriptName] + )) { + rec.methods[methodName] = methodLines; + } + } + + for (let line of rawLines[scriptName]) { + rec.covered.push(line); + } + + for (let line of uncoveredLines[scriptName]) { + rec.uncovered.push(line); + } + + result.push(rec); + } + let path = this._prefix + "/jscov_" + Date.now() + ".json"; + dump("Writing coverage to: " + path + "\n"); + return IOUtils.writeUTF8(path, JSON.stringify(result, undefined, 2), { + tmpPath: `${path}.tmp`, + }); +}; + +/** + * Tear down the debugger after all tests are complete. + */ +CoverageCollector.prototype.finalize = function () { + this._dbg.removeAllDebuggees(); + this._dbg.enabled = false; +}; diff --git a/testing/modules/FileTestUtils.sys.mjs b/testing/modules/FileTestUtils.sys.mjs new file mode 100644 index 0000000000..5e5c3f67f0 --- /dev/null +++ b/testing/modules/FileTestUtils.sys.mjs @@ -0,0 +1,127 @@ +/* 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/. */ + +/** + * Provides testing functions dealing with local files and their contents. + */ + +import { DownloadPaths } from "resource://gre/modules/DownloadPaths.sys.mjs"; +import { FileUtils } from "resource://gre/modules/FileUtils.sys.mjs"; +import { XPCOMUtils } from "resource://gre/modules/XPCOMUtils.sys.mjs"; + +import { Assert } from "resource://testing-common/Assert.sys.mjs"; + +let gFileCounter = 1; +let gPathsToRemove = []; + +export var FileTestUtils = { + /** + * Returns a reference to a temporary file that is guaranteed not to exist and + * to have never been created before. If a file or a directory with this name + * is created by the test, it will be deleted when all tests terminate. + * + * @param suggestedName [optional] + * Any extension on this template file name will be preserved. If this + * is unspecified, the returned file name will have the generic ".dat" + * extension, which may indicate either a binary or a text data file. + * + * @return nsIFile pointing to a non-existent file in a temporary directory. + * + * @note It is not enough to delete the file if it exists, or to delete the + * file after calling nsIFile.createUnique, because on Windows the + * delete operation in the file system may still be pending, preventing + * a new file with the same name to be created. + */ + getTempFile(suggestedName = "test.dat") { + // Prepend a serial number to the extension in the suggested leaf name. + let [base, ext] = DownloadPaths.splitBaseNameAndExtension(suggestedName); + let leafName = base + "-" + gFileCounter + ext; + gFileCounter++; + + // Get a file reference under the temporary directory for this test file. + let file = this._globalTemporaryDirectory.clone(); + file.append(leafName); + Assert.ok(!file.exists(), "Sanity check the temporary file doesn't exist."); + + // Since directory iteration on Windows may not see files that have just + // been created, keep track of the known file names to be removed. + gPathsToRemove.push(file.path); + return file; + }, + + /** + * Attemps to remove the given file or directory recursively, in a way that + * works even on Windows, where race conditions may occur in the file system + * when creating and removing files at the pace of the test suites. + * + * The function may fail silently if access is denied. This means that it + * should only be used to clean up temporary files, rather than for cases + * where the removal is part of a test and must be guaranteed. + * + * @param path + * String representing the path to remove. + */ + async tolerantRemove(path) { + try { + await IOUtils.remove(path, { recursive: true }); + } catch (ex) { + // On Windows, we may get an access denied error instead of a no such file + // error if the file existed before, and was recently deleted. There is no + // way to distinguish this from an access list issue because checking for + // the file existence would also result in the same error. + if ( + !DOMException.isInstance(ex) || + ex.name !== "NotFoundError" || + ex.name !== "NotAllowedError" + ) { + throw ex; + } + } + }, +}; + +/** + * Returns a reference to a global temporary directory that will be deleted + * when all tests terminate. + */ +XPCOMUtils.defineLazyGetter( + FileTestUtils, + "_globalTemporaryDirectory", + function () { + // While previous test runs should have deleted their temporary directories, + // on Windows they might still be pending deletion on the physical file + // system. This makes a simple nsIFile.createUnique call unreliable, and we + // have to use a random number to make a collision unlikely. + let randomNumber = Math.floor(Math.random() * 1000000); + let dir = new FileUtils.File( + PathUtils.join(PathUtils.tempDir, `testdir-${randomNumber}`) + ); + dir.createUnique(Ci.nsIFile.DIRECTORY_TYPE, FileUtils.PERMS_DIRECTORY); + + // We need to run this *after* the profile-before-change phase because + // otherwise we can race other shutdown blockers who have created files in + // our temporary directory. This can cause our shutdown blocker to fail due + // to, e.g., JSONFile attempting to flush its contents to disk while we are + // trying to delete the file. + + IOUtils.sendTelemetry.addBlocker("Removing test files", async () => { + // Remove the files we know about first. + for (let path of gPathsToRemove) { + await FileTestUtils.tolerantRemove(path); + } + + if (!(await IOUtils.exists(dir.path))) { + return; + } + + // Detect any extra files, like the ".part" files of downloads. + for (const child of await IOUtils.getChildren(dir.path)) { + await FileTestUtils.tolerantRemove(child); + } + // This will fail if any test leaves inaccessible files behind. + await IOUtils.remove(dir.path, { recursive: false }); + }); + return dir; + } +); diff --git a/testing/modules/MockRegistrar.sys.mjs b/testing/modules/MockRegistrar.sys.mjs new file mode 100644 index 0000000000..2241c129ca --- /dev/null +++ b/testing/modules/MockRegistrar.sys.mjs @@ -0,0 +1,127 @@ +/* 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/. */ + +const Cm = Components.manager; + +import { Log } from "resource://gre/modules/Log.sys.mjs"; + +var logger = Log.repository.getLogger("MockRegistrar"); + +export var MockRegistrar = Object.freeze({ + _registeredComponents: new Map(), + _originalCIDs: new Map(), + get registrar() { + return Cm.QueryInterface(Ci.nsIComponentRegistrar); + }, + + /** + * Register a mock to override target interfaces. + * The target interface may be accessed through _genuine property of the mock. + * If you register multiple mocks to the same contract ID, you have to call + * unregister in reverse order. Otherwise the previous factory will not be + * restored. + * + * @param contractID The contract ID of the interface which is overridden by + the mock. + * e.g. "@mozilla.org/file/directory_service;1" + * @param mock An object which implements interfaces for the contract ID. + * @param args An array which is passed in the constructor of mock. + * + * @return The CID of the mock. + */ + register(contractID, mock, args) { + let originalCID; + let originalFactory; + try { + originalCID = this._originalCIDs.get(contractID); + if (!originalCID) { + originalCID = this.registrar.contractIDToCID(contractID); + this._originalCIDs.set(contractID, originalCID); + } + + originalFactory = Cm.getClassObject(originalCID, Ci.nsIFactory); + } catch (e) { + // There's no original factory. Ignore and just register the new + // one. + } + + let cid = Services.uuid.generateUUID(); + + let factory = { + createInstance(iid) { + let wrappedMock; + if (mock.prototype && mock.prototype.constructor) { + wrappedMock = Object.create(mock.prototype); + mock.apply(wrappedMock, args); + } else if (typeof mock == "function") { + wrappedMock = mock(); + } else { + wrappedMock = mock; + } + + if (originalFactory) { + try { + let genuine = originalFactory.createInstance(iid); + wrappedMock._genuine = genuine; + } catch (ex) { + logger.info("Creating original instance failed", ex); + } + } + + return wrappedMock.QueryInterface(iid); + }, + QueryInterface: ChromeUtils.generateQI(["nsIFactory"]), + }; + + this.registrar.registerFactory( + cid, + "A Mock for " + contractID, + contractID, + factory + ); + + this._registeredComponents.set(cid, { + contractID, + factory, + originalCID, + }); + + return cid; + }, + + /** + * Unregister the mock. + * + * @param cid The CID of the mock. + */ + unregister(cid) { + let component = this._registeredComponents.get(cid); + if (!component) { + return; + } + + this.registrar.unregisterFactory(cid, component.factory); + if (component.originalCID) { + // Passing `null` for the factory re-maps the contract ID to the + // entry for its original CID. + this.registrar.registerFactory( + component.originalCID, + "", + component.contractID, + null + ); + } + + this._registeredComponents.delete(cid); + }, + + /** + * Unregister all registered mocks. + */ + unregisterAll() { + for (let cid of this._registeredComponents.keys()) { + this.unregister(cid); + } + }, +}); diff --git a/testing/modules/MockRegistry.sys.mjs b/testing/modules/MockRegistry.sys.mjs new file mode 100644 index 0000000000..e9351e576d --- /dev/null +++ b/testing/modules/MockRegistry.sys.mjs @@ -0,0 +1,145 @@ +/* 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/. */ + +import { MockRegistrar } from "resource://testing-common/MockRegistrar.sys.mjs"; + +export class MockRegistry { + constructor() { + // Three level structure of Maps pointing to Maps pointing to Maps + // this.roots is the top of the structure and has ROOT_KEY_* values + // as keys. Maps at the second level are the values of the first + // level Map, they have registry keys (also called paths) as keys. + // Third level maps are the values in second level maps, they have + // map registry names to corresponding values (which in this implementation + // are always strings). + this.roots = new Map([ + [Ci.nsIWindowsRegKey.ROOT_KEY_LOCAL_MACHINE, new Map()], + [Ci.nsIWindowsRegKey.ROOT_KEY_CURRENT_USER, new Map()], + [Ci.nsIWindowsRegKey.ROOT_KEY_CLASSES_ROOT, new Map()], + ]); + + let registry = this; + + /** + * This is a mock nsIWindowsRegistry implementation. It only implements a + * subset of the interface used in tests. In particular, only values + * of type string are supported. + */ + function MockWindowsRegKey() {} + MockWindowsRegKey.prototype = { + values: null, + + // --- Overridden nsISupports interface functions --- + QueryInterface: ChromeUtils.generateQI(["nsIWindowsRegKey"]), + + // --- Overridden nsIWindowsRegKey interface functions --- + open(root, path, mode) { + let rootKey = registry.getRoot(root); + if (!rootKey.has(path)) { + rootKey.set(path, new Map()); + } + this.values = rootKey.get(path); + }, + + close() { + this.values = null; + }, + + get valueCount() { + if (!this.values) { + throw Components.Exception("", Cr.NS_ERROR_FAILURE); + } + return this.values.size; + }, + + hasValue(name) { + if (!this.values) { + return false; + } + return this.values.has(name); + }, + + getValueType(name) { + return Ci.nsIWindowsRegKey.TYPE_STRING; + }, + + getValueName(index) { + if (!this.values || index >= this.values.size) { + throw Components.Exception("", Cr.NS_ERROR_FAILURE); + } + let names = Array.from(this.values.keys()); + return names[index]; + }, + + readStringValue(name) { + if (!this.values) { + throw new Error("invalid registry path"); + } + return this.values.get(name); + }, + }; + + // See bug 1688838 - nsNotifyAddrListener::CheckAdaptersAddresses might + // attempt to use the registry off the main thread, so we disable that + // feature while the mock registry is active. + this.oldSuffixListPref = Services.prefs.getBoolPref( + "network.notify.dnsSuffixList" + ); + Services.prefs.setBoolPref("network.notify.dnsSuffixList", false); + + this.oldCheckForProxiesPref = Services.prefs.getBoolPref( + "network.notify.checkForProxies" + ); + Services.prefs.setBoolPref("network.notify.checkForProxies", false); + + this.oldCheckForNRPTPref = Services.prefs.getBoolPref( + "network.notify.checkForNRPT" + ); + Services.prefs.setBoolPref("network.notify.checkForNRPT", false); + + this.cid = MockRegistrar.register( + "@mozilla.org/windows-registry-key;1", + MockWindowsRegKey + ); + } + + shutdown() { + MockRegistrar.unregister(this.cid); + Services.prefs.setBoolPref( + "network.notify.dnsSuffixList", + this.oldSuffixListPref + ); + Services.prefs.setBoolPref( + "network.notify.checkForProxies", + this.oldCheckForProxiesPref + ); + Services.prefs.setBoolPref( + "network.notify.checkForNRPT", + this.oldCheckForNRPTPref + ); + this.cid = null; + } + + getRoot(root) { + if (!this.roots.has(root)) { + throw new Error(`No such root ${root}`); + } + return this.roots.get(root); + } + + setValue(root, path, name, value) { + let rootKey = this.getRoot(root); + + if (!rootKey.has(path)) { + rootKey.set(path, new Map()); + } + + let pathmap = rootKey.get(path); + if (value == null) { + pathmap.delete(name); + } else { + pathmap.set(name, value); + } + } +} diff --git a/testing/modules/Sinon.sys.mjs b/testing/modules/Sinon.sys.mjs new file mode 100644 index 0000000000..d4edb4bba9 --- /dev/null +++ b/testing/modules/Sinon.sys.mjs @@ -0,0 +1,40 @@ +/* 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/. */ + +// ================================================ +// Load mocking/stubbing library sinon +// docs: http://sinonjs.org/releases/v7.2.7/ +import { + clearInterval, + clearTimeout, + setInterval, + setIntervalWithTarget, + setTimeout, + setTimeoutWithTarget, +} from "resource://gre/modules/Timer.sys.mjs"; + +const obj = { + global: { + clearInterval, + clearTimeout, + setInterval, + setIntervalWithTarget, + setTimeout, + setTimeoutWithTarget, + Date, + }, + clearInterval, + clearTimeout, + setInterval, + setIntervalWithTarget, + setTimeout, + setTimeoutWithTarget, +}; +Services.scriptloader.loadSubScript( + "resource://testing-common/sinon-7.2.7.js", + obj +); + +export const sinon = obj.global.sinon; +// ================================================ diff --git a/testing/modules/StructuredLog.sys.mjs b/testing/modules/StructuredLog.sys.mjs new file mode 100644 index 0000000000..fa569e3409 --- /dev/null +++ b/testing/modules/StructuredLog.sys.mjs @@ -0,0 +1,304 @@ +/* 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/. */ + +/** + * TestLogger: Logger class generating messages compliant with the + * structured logging protocol for tests exposed by mozlog + * + * @param {string} name + * The name of the logger to instantiate. + * @param {function} [dumpFun] + * An underlying function to be used to log raw messages. This function + * will receive the complete serialized json string to log. + * @param {object} [scope] + * The scope that the dumpFun is loaded in, so that messages are cloned + * into that scope before passing them. + */ +export class StructuredLogger { + name = null; + #dumpFun = null; + #dumpScope = null; + + constructor(name, dumpFun = dump, scope = null) { + this.name = name; + this.#dumpFun = dumpFun; + this.#dumpScope = scope; + } + + testStart(test) { + var data = { test: this.#testId(test) }; + this.logData("test_start", data); + } + + testStatus( + test, + subtest, + status, + expected = "PASS", + message = null, + stack = null, + extra = null + ) { + if (subtest === null || subtest === undefined) { + // Fix for assertions that don't pass in a name + subtest = "undefined assertion name"; + } + + var data = { + test: this.#testId(test), + subtest, + status, + }; + + // handle case: known fail + if (expected === status && status != "SKIP") { + data.status = "PASS"; + } + if (expected != status && status != "SKIP") { + data.expected = expected; + } + if (message !== null) { + data.message = String(message); + } + if (stack !== null) { + data.stack = stack; + } + if (extra !== null) { + data.extra = extra; + } + + this.logData("test_status", data); + } + + testEnd( + test, + status, + expected = "OK", + message = null, + stack = null, + extra = null + ) { + var data = { test: this.#testId(test), status }; + + // handle case: known fail + if (expected === status && status != "SKIP") { + data.status = "OK"; + } + if (expected != status && status != "SKIP") { + data.expected = expected; + } + if (message !== null) { + data.message = String(message); + } + if (stack !== null) { + data.stack = stack; + } + if (extra !== null) { + data.extra = extra; + } + + this.logData("test_end", data); + } + + assertionCount(test, count, minExpected = 0, maxExpected = 0) { + var data = { + test: this.#testId(test), + min_expected: minExpected, + max_expected: maxExpected, + count, + }; + + this.logData("assertion_count", data); + } + + suiteStart( + ids, + name = null, + runinfo = null, + versioninfo = null, + deviceinfo = null, + extra = null + ) { + Object.keys(ids).map(function (manifest) { + ids[manifest] = ids[manifest].map(x => this.#testId(x)); + }, this); + var data = { tests: ids }; + + if (name !== null) { + data.name = name; + } + + if (runinfo !== null) { + data.runinfo = runinfo; + } + + if (versioninfo !== null) { + data.versioninfo = versioninfo; + } + + if (deviceinfo !== null) { + data.deviceinfo = deviceinfo; + } + + if (extra !== null) { + data.extra = extra; + } + + this.logData("suite_start", data); + } + + suiteEnd(extra = null) { + var data = {}; + + if (extra !== null) { + data.extra = extra; + } + + this.logData("suite_end", data); + } + + /** + * Unstructured logging functions. The "extra" parameter can always by used to + * log suite specific data. If a "stack" field is provided it is logged at the + * top level of the data object for the benefit of mozlog's formatters. + */ + log(level, message, extra = null) { + var data = { + level, + message: String(message), + }; + + if (extra !== null) { + data.extra = extra; + if ("stack" in extra) { + data.stack = extra.stack; + } + } + + this.logData("log", data); + } + + debug(message, extra = null) { + this.log("DEBUG", message, extra); + } + + info(message, extra = null) { + this.log("INFO", message, extra); + } + + warning(message, extra = null) { + this.log("WARNING", message, extra); + } + + error(message, extra = null) { + this.log("ERROR", message, extra); + } + + critical(message, extra = null) { + this.log("CRITICAL", message, extra); + } + + processOutput(thread, message) { + this.logData("process_output", { + message, + thread, + }); + } + + logData(action, data = {}) { + var allData = { + action, + time: Date.now(), + thread: null, + pid: null, + source: this.name, + }; + + for (var field in data) { + allData[field] = data[field]; + } + + if (this.#dumpScope) { + this.#dumpFun(Cu.cloneInto(allData, this.#dumpScope)); + } else { + this.#dumpFun(allData); + } + } + + #testId(test) { + if (Array.isArray(test)) { + return test.join(" "); + } + return test; + } +} + +/** + * StructuredFormatter: Formatter class turning structured messages + * into human-readable messages. + */ +export class StructuredFormatter { + // The time at which the whole suite of tests started. + #suiteStartTime = null; + + #testStartTimes = new Map(); + + log(message) { + return message.message; + } + + suite_start(message) { + this.#suiteStartTime = message.time; + return "SUITE-START | Running " + message.tests.length + " tests"; + } + + test_start(message) { + this.#testStartTimes.set(message.test, new Date().getTime()); + return "TEST-START | " + message.test; + } + + test_status(message) { + var statusInfo = + message.test + + " | " + + message.subtest + + (message.message ? " | " + message.message : ""); + if (message.expected) { + return ( + "TEST-UNEXPECTED-" + + message.status + + " | " + + statusInfo + + " - expected: " + + message.expected + ); + } + return "TEST-" + message.status + " | " + statusInfo; + } + + test_end(message) { + var startTime = this.#testStartTimes.get(message.test); + this.#testStartTimes.delete(message.test); + var statusInfo = + message.test + (message.message ? " | " + String(message.message) : ""); + var result; + if (message.expected) { + result = + "TEST-UNEXPECTED-" + + message.status + + " | " + + statusInfo + + " - expected: " + + message.expected; + } else { + return "TEST-" + message.status + " | " + statusInfo; + } + result = result + " | took " + message.time - startTime + "ms"; + return result; + } + + suite_end(message) { + return "SUITE-END | took " + message.time - this.#suiteStartTime + "ms"; + } +} diff --git a/testing/modules/TestUtils.sys.mjs b/testing/modules/TestUtils.sys.mjs new file mode 100644 index 0000000000..51030f5fbc --- /dev/null +++ b/testing/modules/TestUtils.sys.mjs @@ -0,0 +1,381 @@ +/* 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/. */ + +/** + * Contains a limited number of testing functions that are commonly used in a + * wide variety of situations, for example waiting for an event loop tick or an + * observer notification. + * + * More complex functions are likely to belong to a separate test-only module. + * Examples include Assert.sys.mjs for generic assertions, FileTestUtils.sys.mjs + * to work with local files and their contents, and BrowserTestUtils.sys.mjs to + * work with browser windows and tabs. + * + * Individual components also offer testing functions to other components, for + * example LoginTestUtils.jsm. + */ + +import { clearTimeout, setTimeout } from "resource://gre/modules/Timer.sys.mjs"; + +const ConsoleAPIStorage = Cc["@mozilla.org/consoleAPI-storage;1"].getService( + Ci.nsIConsoleAPIStorage +); + +/** + * TestUtils provides generally useful test utilities. + * It can be used from mochitests, browser mochitests and xpcshell tests alike. + * + * @class + */ +export var TestUtils = { + executeSoon(callbackFn) { + Services.tm.dispatchToMainThread(callbackFn); + }, + + waitForTick() { + return new Promise(resolve => this.executeSoon(resolve)); + }, + + /** + * Waits for a console message matching the specified check function to be + * observed. + * + * @param {function} checkFn [optional] + * Called with the message as its argument, should return true if the + * notification is the expected one, or false if it should be ignored + * and listening should continue. + * + * @note Because this function is intended for testing, any error in checkFn + * will cause the returned promise to be rejected instead of waiting for + * the next notification, since this is probably a bug in the test. + * + * @return {Promise} + * @resolves The message from the observed notification. + */ + consoleMessageObserved(checkFn) { + return new Promise((resolve, reject) => { + let removed = false; + function observe(message) { + try { + if (checkFn && !checkFn(message)) { + return; + } + ConsoleAPIStorage.removeLogEventListener(observe); + // checkFn could reference objects that need to be destroyed before + // the end of the test, so avoid keeping a reference to it after the + // promise resolves. + checkFn = null; + removed = true; + + resolve(message); + } catch (ex) { + ConsoleAPIStorage.removeLogEventListener(observe); + checkFn = null; + removed = true; + reject(ex); + } + } + + ConsoleAPIStorage.addLogEventListener( + observe, + Cc["@mozilla.org/systemprincipal;1"].createInstance(Ci.nsIPrincipal) + ); + + TestUtils.promiseTestFinished?.then(() => { + if (removed) { + return; + } + + ConsoleAPIStorage.removeLogEventListener(observe); + let text = + "Console message observer not removed before the end of test"; + reject(text); + }); + }); + }, + + /** + * Listens for any console messages (logged via console.*) and returns them + * when the returned function is called. + * + * @returns {function} + * Returns an async function that when called will wait for a tick, then stop + * listening to any more console messages and finally will return the + * messages that have been received. + */ + listenForConsoleMessages() { + let messages = []; + function observe(message) { + messages.push(message); + } + + ConsoleAPIStorage.addLogEventListener( + observe, + Cc["@mozilla.org/systemprincipal;1"].createInstance(Ci.nsIPrincipal) + ); + + return async () => { + await TestUtils.waitForTick(); + ConsoleAPIStorage.removeLogEventListener(observe); + return messages; + }; + }, + + /** + * Waits for the specified topic to be observed. + * + * @param {string} topic + * The topic to observe. + * @param {function} checkFn [optional] + * Called with (subject, data) as arguments, should return true if the + * notification is the expected one, or false if it should be ignored + * and listening should continue. If not specified, the first + * notification for the specified topic resolves the returned promise. + * + * @note Because this function is intended for testing, any error in checkFn + * will cause the returned promise to be rejected instead of waiting for + * the next notification, since this is probably a bug in the test. + * + * @return {Promise} + * @resolves The array [subject, data] from the observed notification. + */ + topicObserved(topic, checkFn) { + let startTime = Cu.now(); + return new Promise((resolve, reject) => { + let removed = false; + function observer(subject, topic, data) { + try { + if (checkFn && !checkFn(subject, data)) { + return; + } + Services.obs.removeObserver(observer, topic); + // checkFn could reference objects that need to be destroyed before + // the end of the test, so avoid keeping a reference to it after the + // promise resolves. + checkFn = null; + removed = true; + ChromeUtils.addProfilerMarker( + "TestUtils", + { startTime, category: "Test" }, + "topicObserved: " + topic + ); + resolve([subject, data]); + } catch (ex) { + Services.obs.removeObserver(observer, topic); + checkFn = null; + removed = true; + reject(ex); + } + } + Services.obs.addObserver(observer, topic); + + TestUtils.promiseTestFinished?.then(() => { + if (removed) { + return; + } + + Services.obs.removeObserver(observer, topic); + let text = topic + " observer not removed before the end of test"; + reject(text); + ChromeUtils.addProfilerMarker( + "TestUtils", + { startTime, category: "Test" }, + "topicObserved: " + text + ); + }); + }); + }, + + /** + * Waits for the specified preference to be change. + * + * @param {string} prefName + * The pref to observe. + * @param {function} checkFn [optional] + * Called with the new preference value as argument, should return true if the + * notification is the expected one, or false if it should be ignored + * and listening should continue. If not specified, the first + * notification for the specified topic resolves the returned promise. + * + * @note Because this function is intended for testing, any error in checkFn + * will cause the returned promise to be rejected instead of waiting for + * the next notification, since this is probably a bug in the test. + * + * @return {Promise} + * @resolves The value of the preference. + */ + waitForPrefChange(prefName, checkFn) { + return new Promise((resolve, reject) => { + Services.prefs.addObserver( + prefName, + function observer(subject, topic, data) { + try { + let prefValue = null; + switch (Services.prefs.getPrefType(prefName)) { + case Services.prefs.PREF_STRING: + prefValue = Services.prefs.getStringPref(prefName); + break; + case Services.prefs.PREF_INT: + prefValue = Services.prefs.getIntPref(prefName); + break; + case Services.prefs.PREF_BOOL: + prefValue = Services.prefs.getBoolPref(prefName); + break; + } + if (checkFn && !checkFn(prefValue)) { + return; + } + Services.prefs.removeObserver(prefName, observer); + resolve(prefValue); + } catch (ex) { + Services.prefs.removeObserver(prefName, observer); + reject(ex); + } + } + ); + }); + }, + + /** + * Takes a screenshot of an area and returns it as a data URL. + * + * @param eltOrRect {Element|Rect} + * The DOM node or rect ({left, top, width, height}) to screenshot. + * @param win {Window} + * The current window. + */ + screenshotArea(eltOrRect, win) { + if (Element.isInstance(eltOrRect)) { + eltOrRect = eltOrRect.getBoundingClientRect(); + } + let { left, top, width, height } = eltOrRect; + let canvas = win.document.createElementNS( + "http://www.w3.org/1999/xhtml", + "canvas" + ); + let ctx = canvas.getContext("2d"); + let ratio = win.devicePixelRatio; + canvas.width = width * ratio; + canvas.height = height * ratio; + ctx.scale(ratio, ratio); + ctx.drawWindow(win, left, top, width, height, "#fff"); + return canvas.toDataURL(); + }, + + /** + * Will poll a condition function until it returns true. + * + * @param condition + * A condition function that must return true or false. If the + * condition ever throws, this function fails and rejects the + * returned promise. The function can be an async function. + * @param msg + * A message used to describe the condition being waited for. + * This message will be used to reject the promise should the + * wait fail. It is also used to add a profiler marker. + * @param interval + * The time interval to poll the condition function. Defaults + * to 100ms. + * @param maxTries + * The number of times to poll before giving up and rejecting + * if the condition has not yet returned true. Defaults to 50 + * (~5 seconds for 100ms intervals) + * @return Promise + * Resolves with the return value of the condition function. + * Rejects if timeout is exceeded or condition ever throws. + * + * NOTE: This is intentionally not using setInterval, using setTimeout + * instead. setInterval is not promise-safe. + */ + waitForCondition(condition, msg, interval = 100, maxTries = 50) { + let startTime = Cu.now(); + return new Promise((resolve, reject) => { + let tries = 0; + let timeoutId = 0; + async function tryOnce() { + timeoutId = 0; + if (tries >= maxTries) { + msg += ` - timed out after ${maxTries} tries.`; + ChromeUtils.addProfilerMarker( + "TestUtils", + { startTime, category: "Test" }, + `waitForCondition - ${msg}` + ); + condition = null; + reject(msg); + return; + } + + let conditionPassed = false; + try { + conditionPassed = await condition(); + } catch (e) { + ChromeUtils.addProfilerMarker( + "TestUtils", + { startTime, category: "Test" }, + `waitForCondition - ${msg}` + ); + msg += ` - threw exception: ${e}`; + condition = null; + reject(msg); + return; + } + + if (conditionPassed) { + ChromeUtils.addProfilerMarker( + "TestUtils", + { startTime, category: "Test" }, + `waitForCondition succeeded after ${tries} retries - ${msg}` + ); + // Avoid keeping a reference to the condition function after the + // promise resolves, as this function could itself reference objects + // that should be GC'ed before the end of the test. + condition = null; + resolve(conditionPassed); + return; + } + tries++; + timeoutId = setTimeout(tryOnce, interval); + } + + TestUtils.promiseTestFinished?.then(() => { + if (!timeoutId) { + return; + } + + clearTimeout(timeoutId); + msg += " - still pending at the end of the test"; + ChromeUtils.addProfilerMarker( + "TestUtils", + { startTime, category: "Test" }, + `waitForCondition - ${msg}` + ); + reject("waitForCondition timer - " + msg); + }); + + TestUtils.executeSoon(tryOnce); + }); + }, + + shuffle(array) { + let results = []; + for (let i = 0; i < array.length; ++i) { + let randomIndex = Math.floor(Math.random() * (i + 1)); + results[i] = results[randomIndex]; + results[randomIndex] = array[i]; + } + return results; + }, + + assertPackagedBuild() { + const omniJa = Services.dirsvc.get("XCurProcD", Ci.nsIFile); + omniJa.append("omni.ja"); + if (!omniJa.exists()) { + throw new Error( + "This test requires a packaged build, " + + "run 'mach package' and then use --appname=dist" + ); + } + }, +}; diff --git a/testing/modules/XPCShellContentUtils.sys.mjs b/testing/modules/XPCShellContentUtils.sys.mjs new file mode 100644 index 0000000000..ccd6a912e7 --- /dev/null +++ b/testing/modules/XPCShellContentUtils.sys.mjs @@ -0,0 +1,490 @@ +/* -*- Mode: indent-tabs-mode: nil; js-indent-level: 2 -*- */ +/* vim: set sts=2 sw=2 et tw=80: */ +/* 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/. */ + +import { ExtensionUtils } from "resource://gre/modules/ExtensionUtils.sys.mjs"; + +import { XPCOMUtils } from "resource://gre/modules/XPCOMUtils.sys.mjs"; + +// Windowless browsers can create documents that rely on XUL Custom Elements: +ChromeUtils.importESModule( + "resource://gre/modules/CustomElementsListener.sys.mjs" +); + +// Need to import ActorManagerParent.sys.mjs so that the actors are initialized +// before running extension XPCShell tests. +ChromeUtils.importESModule("resource://gre/modules/ActorManagerParent.sys.mjs"); + +const lazy = {}; + +ChromeUtils.defineESModuleGetters(lazy, { + ContentTask: "resource://testing-common/ContentTask.sys.mjs", + SpecialPowersParent: "resource://testing-common/SpecialPowersParent.sys.mjs", + TestUtils: "resource://testing-common/TestUtils.sys.mjs", +}); + +XPCOMUtils.defineLazyModuleGetters(lazy, { + HttpServer: "resource://testing-common/httpd.js", +}); + +XPCOMUtils.defineLazyServiceGetters(lazy, { + proxyService: [ + "@mozilla.org/network/protocol-proxy-service;1", + "nsIProtocolProxyService", + ], +}); + +const { promiseDocumentLoaded, promiseEvent, promiseObserved } = ExtensionUtils; + +var gRemoteContentScripts = Services.appinfo.browserTabsRemoteAutostart; +const REMOTE_CONTENT_SUBFRAMES = Services.appinfo.fissionAutostart; + +function frameScript() { + // We need to make sure that the ExtensionPolicy service has been initialized + // as it sets up the observers that inject extension content scripts. + Cc["@mozilla.org/addons/policy-service;1"].getService(); + + Services.obs.notifyObservers(this, "tab-content-frameloader-created"); + + // eslint-disable-next-line mozilla/balanced-listeners, no-undef + addEventListener( + "MozHeapMinimize", + () => { + Services.obs.notifyObservers(null, "memory-pressure", "heap-minimize"); + }, + true, + true + ); +} + +let kungFuDeathGrip = new Set(); +function promiseBrowserLoaded(browser, url, redirectUrl) { + url = url && Services.io.newURI(url); + redirectUrl = redirectUrl && Services.io.newURI(redirectUrl); + + return new Promise(resolve => { + const listener = { + QueryInterface: ChromeUtils.generateQI([ + "nsISupportsWeakReference", + "nsIWebProgressListener", + ]), + + onStateChange(webProgress, request, stateFlags, statusCode) { + request.QueryInterface(Ci.nsIChannel); + + let requestURI = + request.originalURI || + webProgress.DOMWindow.document.documentURIObject; + if ( + webProgress.isTopLevel && + (url?.equals(requestURI) || redirectUrl?.equals(requestURI)) && + stateFlags & Ci.nsIWebProgressListener.STATE_STOP + ) { + resolve(); + kungFuDeathGrip.delete(listener); + browser.removeProgressListener(listener); + } + }, + }; + + // addProgressListener only supports weak references, so we need to + // use one. But we also need to make sure it stays alive until we're + // done with it, so thunk away a strong reference to keep it alive. + kungFuDeathGrip.add(listener); + browser.addProgressListener( + listener, + Ci.nsIWebProgress.NOTIFY_STATE_WINDOW + ); + }); +} + +class ContentPage { + constructor( + remote = gRemoteContentScripts, + remoteSubframes = REMOTE_CONTENT_SUBFRAMES, + extension = null, + privateBrowsing = false, + userContextId = undefined + ) { + this.remote = remote; + + // If an extension has been passed, overwrite remote + // with extension.remote to be sure that the ContentPage + // will have the same remoteness of the extension. + if (extension) { + this.remote = extension.remote; + } + + this.remoteSubframes = this.remote && remoteSubframes; + this.extension = extension; + this.privateBrowsing = privateBrowsing; + this.userContextId = userContextId; + + this.browserReady = this._initBrowser(); + } + + async _initBrowser() { + let chromeFlags = 0; + if (this.remote) { + chromeFlags |= Ci.nsIWebBrowserChrome.CHROME_REMOTE_WINDOW; + } + if (this.remoteSubframes) { + chromeFlags |= Ci.nsIWebBrowserChrome.CHROME_FISSION_WINDOW; + } + if (this.privateBrowsing) { + chromeFlags |= Ci.nsIWebBrowserChrome.CHROME_PRIVATE_WINDOW; + } + this.windowlessBrowser = Services.appShell.createWindowlessBrowser( + true, + chromeFlags + ); + + let system = Services.scriptSecurityManager.getSystemPrincipal(); + + let chromeShell = this.windowlessBrowser.docShell.QueryInterface( + Ci.nsIWebNavigation + ); + + chromeShell.createAboutBlankContentViewer(system, system); + this.windowlessBrowser.browsingContext.useGlobalHistory = false; + let loadURIOptions = { + triggeringPrincipal: system, + }; + chromeShell.loadURI( + Services.io.newURI("chrome://extensions/content/dummy.xhtml"), + loadURIOptions + ); + + await promiseObserved( + "chrome-document-global-created", + win => win.document == chromeShell.document + ); + + let chromeDoc = await promiseDocumentLoaded(chromeShell.document); + + let { SpecialPowers } = chromeDoc.ownerGlobal; + SpecialPowers.xpcshellScope = XPCShellContentUtils.currentScope; + SpecialPowers.setAsDefaultAssertHandler(); + + let browser = chromeDoc.createXULElement("browser"); + browser.setAttribute("type", "content"); + browser.setAttribute("disableglobalhistory", "true"); + browser.setAttribute("messagemanagergroup", "webext-browsers"); + browser.setAttribute("nodefaultsrc", "true"); + if (this.userContextId) { + browser.setAttribute("usercontextid", this.userContextId); + } + + if (this.extension?.remote) { + browser.setAttribute("remote", "true"); + browser.setAttribute("remoteType", "extension"); + } + + // Ensure that the extension is loaded into the correct + // BrowsingContextGroupID by default. + if (this.extension) { + browser.setAttribute( + "initialBrowsingContextGroupId", + this.extension.browsingContextGroupId + ); + } + + let awaitFrameLoader = Promise.resolve(); + if (this.remote) { + awaitFrameLoader = promiseEvent(browser, "XULFrameLoaderCreated"); + browser.setAttribute("remote", "true"); + + browser.setAttribute("maychangeremoteness", "true"); + browser.addEventListener( + "DidChangeBrowserRemoteness", + this.didChangeBrowserRemoteness.bind(this) + ); + } + + chromeDoc.documentElement.appendChild(browser); + + // Forcibly flush layout so that we get a pres shell soon enough, see + // bug 1274775. + browser.getBoundingClientRect(); + + await awaitFrameLoader; + + this.browser = browser; + + this.loadFrameScript(frameScript); + + return browser; + } + + get browsingContext() { + return this.browser.browsingContext; + } + + get SpecialPowers() { + return this.browser.ownerGlobal.SpecialPowers; + } + + loadFrameScript(func) { + let frameScript = `data:text/javascript,(${encodeURI(func)}).call(this)`; + this.browser.messageManager.loadFrameScript(frameScript, true, true); + } + + addFrameScriptHelper(func) { + let frameScript = `data:text/javascript,${encodeURI(func)}`; + this.browser.messageManager.loadFrameScript(frameScript, false, true); + } + + didChangeBrowserRemoteness(event) { + // XXX: Tests can load their own additional frame scripts, so we may need to + // track all scripts that have been loaded, and reload them here? + this.loadFrameScript(frameScript); + } + + async loadURL(url, redirectUrl = undefined) { + await this.browserReady; + + this.browser.fixupAndLoadURIString(url, { + triggeringPrincipal: Services.scriptSecurityManager.getSystemPrincipal(), + }); + return promiseBrowserLoaded(this.browser, url, redirectUrl); + } + + async fetch(...args) { + return this.spawn(args, async (url, options) => { + let resp = await this.content.fetch(url, options); + return resp.text(); + }); + } + + spawn(params, task) { + return this.SpecialPowers.spawn(this.browser, params, task); + } + + // Like spawn(), but uses the legacy ContentTask infrastructure rather than + // SpecialPowers. Exists only because the author of the SpecialPowers + // migration did not have the time to fix all of the legacy users who relied + // on the old semantics. + // + // DO NOT USE IN NEW CODE + legacySpawn(params, task) { + lazy.ContentTask.setTestScope(XPCShellContentUtils.currentScope); + + return lazy.ContentTask.spawn(this.browser, params, task); + } + + async close() { + await this.browserReady; + + let { messageManager } = this.browser; + + this.browser.removeEventListener( + "DidChangeBrowserRemoteness", + this.didChangeBrowserRemoteness.bind(this) + ); + this.browser = null; + + this.windowlessBrowser.close(); + this.windowlessBrowser = null; + + await lazy.TestUtils.topicObserved( + "message-manager-disconnect", + subject => subject === messageManager + ); + } +} + +export var XPCShellContentUtils = { + currentScope: null, + fetchScopes: new Map(), + + initCommon(scope) { + this.currentScope = scope; + + // We need to load at least one frame script into every message + // manager to ensure that the scriptable wrapper for its global gets + // created before we try to access it externally. If we don't, we + // fail sanity checks on debug builds the first time we try to + // create a wrapper, because we should never have a global without a + // cached wrapper. + Services.mm.loadFrameScript("data:text/javascript,//", true, true); + + scope.registerCleanupFunction(() => { + this.currentScope = null; + + return Promise.all( + Array.from(this.fetchScopes.values(), promise => + promise.then(scope => scope.close()) + ) + ); + }); + }, + + init(scope) { + // QuotaManager crashes if it doesn't have a profile. + scope.do_get_profile(); + + this.initCommon(scope); + + lazy.SpecialPowersParent.registerActor(); + }, + + initMochitest(scope) { + this.initCommon(scope); + }, + + ensureInitialized(scope) { + if (!this.currentScope) { + if (scope.do_get_profile) { + this.init(scope); + } else { + this.initMochitest(scope); + } + } + }, + + /** + * Creates a new HttpServer for testing, and begins listening on the + * specified port. Automatically shuts down the server when the test + * unit ends. + * + * @param {object} [options = {}] + * The options object. + * @param {integer} [options.port = -1] + * The port to listen on. If omitted, listen on a random + * port. The latter is the preferred behavior. + * @param {sequence?} [options.hosts = null] + * A set of hosts to accept connections to. Support for this is + * implemented using a proxy filter. + * + * @returns {HttpServer} + * The HTTP server instance. + */ + createHttpServer({ port = -1, hosts } = {}) { + let server = new lazy.HttpServer(); + server.start(port); + + if (hosts) { + const hostsSet = new Set(); + const serverHost = "localhost"; + const serverPort = server.identity.primaryPort; + + for (let host of hosts) { + if (host.startsWith("[") && host.endsWith("]")) { + // HttpServer expects IPv6 addresses in bracket notation, but the + // proxy filter uses nsIURI.host, which does not have brackets. + hostsSet.add(host.slice(1, -1)); + } else { + hostsSet.add(host); + } + server.identity.add("http", host, 80); + } + + const proxyFilter = { + proxyInfo: lazy.proxyService.newProxyInfo( + "http", + serverHost, + serverPort, + "", + "", + 0, + 4096, + null + ), + + applyFilter(channel, defaultProxyInfo, callback) { + if (hostsSet.has(channel.URI.host)) { + callback.onProxyFilterResult(this.proxyInfo); + } else { + callback.onProxyFilterResult(defaultProxyInfo); + } + }, + }; + + lazy.proxyService.registerChannelFilter(proxyFilter, 0); + this.currentScope.registerCleanupFunction(() => { + lazy.proxyService.unregisterChannelFilter(proxyFilter); + }); + } + + this.currentScope.registerCleanupFunction(() => { + return new Promise(resolve => { + server.stop(resolve); + }); + }); + + return server; + }, + + registerJSON(server, path, obj) { + server.registerPathHandler(path, (request, response) => { + response.setHeader("content-type", "application/json", true); + response.write(JSON.stringify(obj)); + }); + }, + + get remoteContentScripts() { + return gRemoteContentScripts; + }, + + set remoteContentScripts(val) { + gRemoteContentScripts = !!val; + }, + + async fetch(origin, url, options) { + let fetchScopePromise = this.fetchScopes.get(origin); + if (!fetchScopePromise) { + fetchScopePromise = this.loadContentPage(origin); + this.fetchScopes.set(origin, fetchScopePromise); + } + + let fetchScope = await fetchScopePromise; + return fetchScope.fetch(url, options); + }, + + /** + * Loads a content page into a hidden docShell. + * + * @param {string} url + * The URL to load. + * @param {object} [options = {}] + * @param {ExtensionWrapper} [options.extension] + * If passed, load the URL as an extension page for the given + * extension. + * @param {boolean} [options.remote] + * If true, load the URL in a content process. If false, load + * it in the parent process. + * @param {boolean} [options.remoteSubframes] + * If true, load cross-origin frames in separate content processes. + * This is ignored if |options.remote| is false. + * @param {string} [options.redirectUrl] + * An optional URL that the initial page is expected to + * redirect to. + * + * @returns {ContentPage} + */ + loadContentPage( + url, + { + extension = undefined, + remote = undefined, + remoteSubframes = undefined, + redirectUrl = undefined, + privateBrowsing = false, + userContextId = undefined, + } = {} + ) { + let contentPage = new ContentPage( + remote, + remoteSubframes, + extension && extension.extension, + privateBrowsing, + userContextId + ); + + return contentPage.loadURL(url, redirectUrl).then(() => { + return contentPage; + }); + }, +}; diff --git a/testing/modules/moz.build b/testing/modules/moz.build new file mode 100644 index 0000000000..0261c5a5ce --- /dev/null +++ b/testing/modules/moz.build @@ -0,0 +1,39 @@ +# -*- Mode: python; indent-tabs-mode: nil; tab-width: 40 -*- +# vim: set filetype=python: +# 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/. + +XPCSHELL_TESTS_MANIFESTS += ["tests/xpcshell/xpcshell.ini"] +BROWSER_CHROME_MANIFESTS += ["tests/browser/browser.ini"] + +TESTING_JS_MODULES += [ + "AppData.sys.mjs", + "AppInfo.sys.mjs", + "Assert.sys.mjs", + "CoverageUtils.sys.mjs", + "FileTestUtils.sys.mjs", + "MockRegistrar.sys.mjs", + "sinon-7.2.7.js", + "Sinon.sys.mjs", + "StructuredLog.sys.mjs", + "TestUtils.sys.mjs", + "XPCShellContentUtils.sys.mjs", +] + +if CONFIG["MOZ_WIDGET_TOOLKIT"] == "windows": + TESTING_JS_MODULES += [ + "MockRegistry.sys.mjs", + ] + + +TEST_HARNESS_FILES.testing.mochitest.tests.SimpleTest += ["StructuredLog.sys.mjs"] + +with Files("**"): + BUG_COMPONENT = ("Testing", "General") + +with Files("tests/xpcshell/**"): + BUG_COMPONENT = ("Testing", "XPCShell Harness") + +with Files("tests/browser/**"): + BUG_COMPONENT = ("Testing", "General") diff --git a/testing/modules/tests/browser/browser.ini b/testing/modules/tests/browser/browser.ini new file mode 100644 index 0000000000..4dcdddffc3 --- /dev/null +++ b/testing/modules/tests/browser/browser.ini @@ -0,0 +1 @@ +[browser_test_assert.js] diff --git a/testing/modules/tests/browser/browser_test_assert.js b/testing/modules/tests/browser/browser_test_assert.js new file mode 100644 index 0000000000..ea0823e60d --- /dev/null +++ b/testing/modules/tests/browser/browser_test_assert.js @@ -0,0 +1,21 @@ +/* Any copyright is dedicated to the Public Domain. +http://creativecommons.org/publicdomain/zero/1.0/ */ + +function test() { + export_assertions(); + + ok(true, "pass ok"); + is(true, true, "pass is"); + isnot(false, true, "pass isnot"); + todo(false, "pass todo"); + todo_is(false, true, "pass todo_is"); + todo_isnot(true, true, "pass todo_isnot"); + info("info message"); + + var func = is; + func(1, 1, "pass indirect is"); + + stringMatches("hello world", /llo\s/); + stringMatches("hello world", "llo\\s"); + stringContains("hello world", "llo"); +} diff --git a/testing/modules/tests/xpcshell/test_assert.js b/testing/modules/tests/xpcshell/test_assert.js new file mode 100644 index 0000000000..0168bedd7a --- /dev/null +++ b/testing/modules/tests/xpcshell/test_assert.js @@ -0,0 +1,470 @@ +/* Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ */ + +// Test cases borrowed and adapted from: +// https://github.com/joyent/node/blob/6101eb184db77d0b11eb96e48744e57ecce4b73d/test/simple/test-assert.js +// MIT license: http://opensource.org/licenses/MIT + +var { Assert } = ChromeUtils.importESModule( + "resource://testing-common/Assert.sys.mjs" +); + +function run_test() { + let assert = new Assert(); + + function makeBlock(f, ...args) { + return function () { + return f.apply(assert, args); + }; + } + + function protoCtrChain(o) { + let result = []; + while ((o = o.__proto__)) { + result.push(o.constructor); + } + return result.join(); + } + + function indirectInstanceOf(obj, cls) { + if (obj instanceof cls) { + return true; + } + let clsChain = protoCtrChain(cls.prototype); + let objChain = protoCtrChain(obj); + return objChain.slice(-clsChain.length) === clsChain; + } + + assert.ok( + indirectInstanceOf(Assert.AssertionError.prototype, Error), + "Assert.AssertionError instanceof Error" + ); + + assert.throws( + makeBlock(assert.ok, false), + Assert.AssertionError, + "ok(false)" + ); + + assert.ok(true, "ok(true)"); + + assert.ok("test", "ok('test')"); + + assert.throws( + makeBlock(assert.equal, true, false), + Assert.AssertionError, + "equal" + ); + + assert.equal(null, null, "equal"); + + assert.equal(undefined, undefined, "equal"); + + assert.equal(null, undefined, "equal"); + + assert.equal(true, true, "equal"); + + assert.notEqual(true, false, "notEqual"); + + assert.throws( + makeBlock(assert.notEqual, true, true), + Assert.AssertionError, + "notEqual" + ); + + assert.throws( + makeBlock(assert.strictEqual, 2, "2"), + Assert.AssertionError, + "strictEqual" + ); + + assert.throws( + makeBlock(assert.strictEqual, null, undefined), + Assert.AssertionError, + "strictEqual" + ); + + assert.notStrictEqual(2, "2", "notStrictEqual"); + + // deepEquals joy! + // 7.2 + assert.deepEqual( + new Date(2000, 3, 14), + new Date(2000, 3, 14), + "deepEqual date" + ); + assert.deepEqual(new Date(NaN), new Date(NaN), "deepEqual invalid dates"); + + assert.throws( + makeBlock(assert.deepEqual, new Date(), new Date(2000, 3, 14)), + Assert.AssertionError, + "deepEqual date" + ); + + // 7.3 + assert.deepEqual(/a/, /a/); + assert.deepEqual(/a/g, /a/g); + assert.deepEqual(/a/i, /a/i); + assert.deepEqual(/a/m, /a/m); + assert.deepEqual(/a/gim, /a/gim); + assert.throws(makeBlock(assert.deepEqual, /ab/, /a/), Assert.AssertionError); + assert.throws(makeBlock(assert.deepEqual, /a/g, /a/), Assert.AssertionError); + assert.throws(makeBlock(assert.deepEqual, /a/i, /a/), Assert.AssertionError); + assert.throws(makeBlock(assert.deepEqual, /a/m, /a/), Assert.AssertionError); + assert.throws( + makeBlock(assert.deepEqual, /a/gim, /a/im), + Assert.AssertionError + ); + + let re1 = /a/; + re1.lastIndex = 3; + assert.throws(makeBlock(assert.deepEqual, re1, /a/), Assert.AssertionError); + + // 7.4 + assert.deepEqual(4, "4", "deepEqual == check"); + assert.deepEqual(true, 1, "deepEqual == check"); + assert.throws( + makeBlock(assert.deepEqual, 4, "5"), + Assert.AssertionError, + "deepEqual == check" + ); + + // 7.5 + // having the same number of owned properties && the same set of keys + assert.deepEqual({ a: 4 }, { a: 4 }); + assert.deepEqual({ a: 4, b: "2" }, { a: 4, b: "2" }); + assert.deepEqual([4], ["4"]); + assert.throws( + makeBlock(assert.deepEqual, { a: 4 }, { a: 4, b: true }), + Assert.AssertionError + ); + assert.deepEqual(["a"], { 0: "a" }); + + let a1 = [1, 2, 3]; + let a2 = [1, 2, 3]; + a1.a = "test"; + a1.b = true; + a2.b = true; + a2.a = "test"; + assert.throws( + makeBlock(assert.deepEqual, Object.keys(a1), Object.keys(a2)), + Assert.AssertionError + ); + assert.deepEqual(a1, a2); + + let nbRoot = { + toString() { + return this.first + " " + this.last; + }, + }; + + function nameBuilder(first, last) { + this.first = first; + this.last = last; + return this; + } + nameBuilder.prototype = nbRoot; + + function nameBuilder2(first, last) { + this.first = first; + this.last = last; + return this; + } + nameBuilder2.prototype = nbRoot; + + let nb1 = new nameBuilder("Ryan", "Dahl"); + let nb2 = new nameBuilder2("Ryan", "Dahl"); + + assert.deepEqual(nb1, nb2); + + nameBuilder2.prototype = Object; + nb2 = new nameBuilder2("Ryan", "Dahl"); + assert.throws(makeBlock(assert.deepEqual, nb1, nb2), Assert.AssertionError); + + // String literal + object + assert.throws(makeBlock(assert.deepEqual, "a", {}), Assert.AssertionError); + + // Testing the throwing + function thrower(errorConstructor) { + throw new errorConstructor("test"); + } + makeBlock(thrower, Assert.AssertionError); + makeBlock(thrower, Assert.AssertionError); + + // the basic calls work + assert.throws( + makeBlock(thrower, Assert.AssertionError), + Assert.AssertionError, + "message" + ); + assert.throws( + makeBlock(thrower, Assert.AssertionError), + Assert.AssertionError + ); + assert.throws( + makeBlock(thrower, Assert.AssertionError), + Assert.AssertionError + ); + + // if not passing an error, catch all. + assert.throws(makeBlock(thrower, TypeError), TypeError); + + // when passing a type, only catch errors of the appropriate type + let threw = false; + try { + assert.throws(makeBlock(thrower, TypeError), Assert.AssertionError); + } catch (e) { + threw = true; + assert.ok(e instanceof TypeError, "type"); + } + assert.equal( + true, + threw, + "Assert.throws with an explicit error is eating extra errors", + Assert.AssertionError + ); + threw = false; + + function ifError(err) { + if (err) { + throw err; + } + } + assert.throws(function () { + ifError(new Error("test error")); + }, /test error/); + + // make sure that validating using constructor really works + threw = false; + try { + assert.throws(function () { + throw new Error({}); + }, Array); + } catch (e) { + threw = true; + } + assert.ok(threw, "wrong constructor validation"); + + // use a RegExp to validate error message + assert.throws(makeBlock(thrower, TypeError), /test/); + + // use a fn to validate error object + assert.throws(makeBlock(thrower, TypeError), function (err) { + if (err instanceof TypeError && /test/.test(err)) { + return true; + } + return false; + }); + // do the same with an arrow function + assert.throws(makeBlock(thrower, TypeError), err => { + if (err instanceof TypeError && /test/.test(err)) { + return true; + } + return false; + }); + + function testAssertionMessage(actual, expected) { + try { + assert.equal(actual, ""); + } catch (e) { + assert.equal( + e.toString(), + ["AssertionError:", expected, "==", '""'].join(" ") + ); + } + } + testAssertionMessage(undefined, '"undefined"'); + testAssertionMessage(null, "null"); + testAssertionMessage(true, "true"); + testAssertionMessage(false, "false"); + testAssertionMessage(0, "0"); + testAssertionMessage(100, "100"); + testAssertionMessage(NaN, '"NaN"'); + testAssertionMessage(Infinity, '"Infinity"'); + testAssertionMessage(-Infinity, '"-Infinity"'); + testAssertionMessage("", '""'); + testAssertionMessage("foo", '"foo"'); + testAssertionMessage([], "[]"); + testAssertionMessage([1, 2, 3], "[1,2,3]"); + testAssertionMessage(/a/, '"/a/"'); + testAssertionMessage(/abc/gim, '"/abc/gim"'); + testAssertionMessage(function f() {}, '"function f() {}"'); + testAssertionMessage({}, "{}"); + testAssertionMessage({ a: undefined, b: null }, '{"a":"undefined","b":null}'); + testAssertionMessage( + { a: NaN, b: Infinity, c: -Infinity }, + '{"a":"NaN","b":"Infinity","c":"-Infinity"}' + ); + + // https://github.com/joyent/node/issues/2893 + try { + assert.throws(function () { + ifError(null); + }); + } catch (e) { + threw = true; + assert.equal( + e.message, + "Error: The 'expected' argument was not supplied to Assert.throws() - false == true" + ); + } + assert.ok(threw); + + // https://github.com/joyent/node/issues/5292 + try { + assert.equal(1, 2); + } catch (e) { + assert.equal(e.toString().split("\n")[0], "AssertionError: 1 == 2"); + } + + try { + assert.equal(1, 2, "oh no"); + } catch (e) { + assert.equal(e.toString().split("\n")[0], "AssertionError: oh no - 1 == 2"); + } + + // Need to JSON.stringify so that their length is > 128 characters. + let longArray0 = Array.from(Array(50), (v, i) => i); + let longArray1 = longArray0.concat([51]); + try { + assert.deepEqual(longArray0, longArray1); + } catch (e) { + let message = e.toString(); + // Just check that they're both entirely present in the message + assert.ok(message.includes(JSON.stringify(longArray0))); + assert.ok(message.includes(JSON.stringify(longArray1))); + } + + // Test XPCShell-test integration: + ok(true, "OK, this went well"); + deepEqual(/a/g, /a/g, "deep equal should work on RegExp"); + deepEqual(/a/gim, /a/gim, "deep equal should work on RegExp"); + deepEqual( + { a: 4, b: "1" }, + { b: "1", a: 4 }, + "deep equal should work on regular Object" + ); + deepEqual(a1, a2, "deep equal should work on Array with Object properties"); + + // Test robustness of reporting: + equal( + new Assert.AssertionError({ + actual: { + toJSON() { + throw new Error("bam!"); + }, + }, + expected: "foo", + operator: "=", + }).message, + '[object Object] = "foo"' + ); + + let message; + assert.greater(3, 2); + try { + assert.greater(2, 2); + } catch (e) { + message = e.toString().split("\n")[0]; + } + assert.equal(message, "AssertionError: 2 > 2"); + + assert.greaterOrEqual(2, 2); + try { + assert.greaterOrEqual(1, 2); + } catch (e) { + message = e.toString().split("\n")[0]; + } + assert.equal(message, "AssertionError: 1 >= 2"); + + assert.less(1, 2); + try { + assert.less(2, 2); + } catch (e) { + message = e.toString().split("\n")[0]; + } + assert.equal(message, "AssertionError: 2 < 2"); + + assert.lessOrEqual(2, 2); + try { + assert.lessOrEqual(2, 1); + } catch (e) { + message = e.toString().split("\n")[0]; + } + assert.equal(message, "AssertionError: 2 <= 1"); + + try { + assert.greater(NaN, 0); + } catch (e) { + message = e.toString().split("\n")[0]; + } + assert.equal(message, "AssertionError: 'NaN' is not a number"); + + try { + assert.greater(0, NaN); + } catch (e) { + message = e.toString().split("\n")[0]; + } + assert.equal(message, "AssertionError: 'NaN' is not a number"); + + /* ---- stringMatches ---- */ + assert.stringMatches("hello world", /llo\s/); + assert.stringMatches("hello world", "llo\\s"); + assert.throws( + () => assert.stringMatches("hello world", /foo/), + /^AssertionError: "hello world" matches "\/foo\/"/ + ); + assert.throws( + () => assert.stringMatches(5, /foo/), + /^AssertionError: Expected a string for lhs, but "5" isn't a string./ + ); + assert.throws( + () => assert.stringMatches("foo bar", "+"), + /^AssertionError: Expected a valid regular expression for rhs, but "\+" isn't one./ + ); + + /* ---- stringContains ---- */ + assert.stringContains("hello world", "llo"); + assert.throws( + () => assert.stringContains(5, "foo"), + /^AssertionError: Expected a string for both lhs and rhs, but either "5" or "foo" is not a string./ + ); + + run_next_test(); +} + +add_task(async function test_rejects() { + let assert = new Assert(); + + // A helper function to test failures. + async function checkRejectsFails(err, expected) { + try { + await assert.rejects(Promise.reject(err), expected); + ok(false, "should have thrown"); + } catch (ex) { + deepEqual(ex, err, "Assert.rejects threw the original unexpected error"); + } + } + + // A "throwable" error that's not an actual Error(). + let SomeErrorLikeThing = function () {}; + + // The actual tests... + + // An explicit error object: + // An instance to check against. + await assert.rejects(Promise.reject(new Error("oh no")), Error, "rejected"); + // A regex to match against the message. + await assert.rejects(Promise.reject(new Error("oh no")), /oh no/, "rejected"); + + // Failure cases: + // An instance to check against that doesn't match. + await checkRejectsFails(new Error("something else"), SomeErrorLikeThing); + // A regex that doesn't match. + await checkRejectsFails(new Error("something else"), /oh no/); + + // Check simple string messages. + await assert.rejects(Promise.reject("oh no"), /oh no/, "rejected"); + // Wrong message. + await checkRejectsFails("something else", /oh no/); +}); diff --git a/testing/modules/tests/xpcshell/test_mockRegistrar.js b/testing/modules/tests/xpcshell/test_mockRegistrar.js new file mode 100644 index 0000000000..de4224a092 --- /dev/null +++ b/testing/modules/tests/xpcshell/test_mockRegistrar.js @@ -0,0 +1,65 @@ +/* Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ */ + +const { MockRegistrar } = ChromeUtils.importESModule( + "resource://testing-common/MockRegistrar.sys.mjs" +); + +function platformInfo(injectedValue) { + this.platformVersion = injectedValue; +} + +platformInfo.prototype = { + platformVersion: "some version", + platformBuildID: "some id", + QueryInterface: ChromeUtils.generateQI(["nsIPlatformInfo"]), +}; + +add_test(function test_register() { + let localPlatformInfo = { + platformVersion: "local version", + platformBuildID: "local id", + QueryInterface: ChromeUtils.generateQI(["nsIPlatformInfo"]), + }; + + MockRegistrar.register("@mozilla.org/xre/app-info;1", localPlatformInfo); + Assert.equal( + Cc["@mozilla.org/xre/app-info;1"].createInstance(Ci.nsIPlatformInfo) + .platformVersion, + "local version" + ); + run_next_test(); +}); + +add_test(function test_register_with_arguments() { + MockRegistrar.register("@mozilla.org/xre/app-info;1", platformInfo, [ + "override", + ]); + Assert.equal( + Cc["@mozilla.org/xre/app-info;1"].createInstance(Ci.nsIPlatformInfo) + .platformVersion, + "override" + ); + run_next_test(); +}); + +add_test(function test_register_twice() { + MockRegistrar.register("@mozilla.org/xre/app-info;1", platformInfo, [ + "override", + ]); + Assert.equal( + Cc["@mozilla.org/xre/app-info;1"].createInstance(Ci.nsIPlatformInfo) + .platformVersion, + "override" + ); + + MockRegistrar.register("@mozilla.org/xre/app-info;1", platformInfo, [ + "override again", + ]); + Assert.equal( + Cc["@mozilla.org/xre/app-info;1"].createInstance(Ci.nsIPlatformInfo) + .platformVersion, + "override again" + ); + run_next_test(); +}); diff --git a/testing/modules/tests/xpcshell/test_structuredlog.js b/testing/modules/tests/xpcshell/test_structuredlog.js new file mode 100644 index 0000000000..5288bbcbb3 --- /dev/null +++ b/testing/modules/tests/xpcshell/test_structuredlog.js @@ -0,0 +1,147 @@ +/* Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ */ + +function run_test() { + const { StructuredLogger } = ChromeUtils.importESModule( + "resource://testing-common/StructuredLog.sys.mjs" + ); + + let testBuffer = []; + + let appendBuffer = function (msg) { + testBuffer.push(JSON.stringify(msg)); + }; + + let assertLastMsg = function (refData) { + // Check all fields in refData agree with those in the + // last message logged, and pop that message. + let lastMsg = JSON.parse(testBuffer.pop()); + for (let field in refData) { + deepEqual(lastMsg[field], refData[field]); + } + // The logger should always set the source to the logger name. + equal(lastMsg.source, "test_log"); + }; + + let logger = new StructuredLogger("test_log", appendBuffer); + + // Test unstructured logging + logger.info("Test message"); + assertLastMsg({ + action: "log", + message: "Test message", + level: "INFO", + }); + + logger.info("Test message", { foo: "bar" }); + assertLastMsg({ + action: "log", + message: "Test message", + level: "INFO", + extra: { foo: "bar" }, + }); + + // Test end / start actions + logger.testStart("aTest"); + assertLastMsg({ + test: "aTest", + action: "test_start", + }); + + logger.testEnd("aTest", "OK"); + assertLastMsg({ + test: "aTest", + action: "test_end", + status: "OK", + }); + + // A failed test populates the "expected" field. + logger.testStart("aTest"); + logger.testEnd("aTest", "FAIL", "PASS"); + assertLastMsg({ + action: "test_end", + test: "aTest", + status: "FAIL", + expected: "PASS", + }); + + // A failed test populates the "expected" field. + logger.testStart("aTest"); + logger.testEnd("aTest", "FAIL", "PASS", null, "Many\nlines\nof\nstack\n"); + assertLastMsg({ + action: "test_end", + test: "aTest", + status: "FAIL", + expected: "PASS", + stack: "Many\nlines\nof\nstack\n", + }); + + // Skipped tests don't log failures + logger.testStart("aTest"); + logger.testEnd("aTest", "SKIP", "PASS"); + ok(!JSON.parse(testBuffer[testBuffer.length - 1]).hasOwnProperty("expected")); + assertLastMsg({ + action: "test_end", + test: "aTest", + status: "SKIP", + }); + + logger.testStatus("aTest", "foo", "PASS", "PASS", "Passed test"); + ok(!JSON.parse(testBuffer[testBuffer.length - 1]).hasOwnProperty("expected")); + assertLastMsg({ + action: "test_status", + test: "aTest", + subtest: "foo", + status: "PASS", + message: "Passed test", + }); + + logger.testStatus("aTest", "bar", "FAIL"); + assertLastMsg({ + action: "test_status", + test: "aTest", + subtest: "bar", + status: "FAIL", + expected: "PASS", + }); + + logger.testStatus( + "aTest", + "bar", + "FAIL", + "PASS", + null, + "Many\nlines\nof\nstack\n" + ); + assertLastMsg({ + action: "test_status", + test: "aTest", + subtest: "bar", + status: "FAIL", + expected: "PASS", + stack: "Many\nlines\nof\nstack\n", + }); + + // Skipped tests don't log failures + logger.testStatus("aTest", "baz", "SKIP"); + ok(!JSON.parse(testBuffer[testBuffer.length - 1]).hasOwnProperty("expected")); + assertLastMsg({ + action: "test_status", + test: "aTest", + subtest: "baz", + status: "SKIP", + }); + + // Suite start and end messages. + var ids = { aManifest: ["aTest"] }; + logger.suiteStart(ids); + assertLastMsg({ + action: "suite_start", + tests: { aManifest: ["aTest"] }, + }); + + logger.suiteEnd(); + assertLastMsg({ + action: "suite_end", + }); +} diff --git a/testing/modules/tests/xpcshell/xpcshell.ini b/testing/modules/tests/xpcshell/xpcshell.ini new file mode 100644 index 0000000000..9401dc3abf --- /dev/null +++ b/testing/modules/tests/xpcshell/xpcshell.ini @@ -0,0 +1,6 @@ +[DEFAULT] +head = + +[test_assert.js] +[test_mockRegistrar.js] +[test_structuredlog.js] -- cgit v1.2.3