tor-browser

asserts.js (5623B)

---

/* Any copyright is dedicated to the Public Domain.
* http://creativecommons.org/publicdomain/zero/1.0/ */

"use strict";

/**
* @todo Bug 2005403
* Move this to main assert module, could look like:
* await Assert.continueOnAssert(async function() {
*   Assert.ok();
*   await Assert.rejects();
*   ...
* });
*/
function SoftAssert() {
 this.failures = [];
}

SoftAssert.prototype._recordFailure = function (err, context) {
 this.failures.push({
   message: err.message,
   name: err.name,
   stack: err.stack,
   context,
 });
};

SoftAssert.prototype.throws = function (
 block,
 expectedError,
 message = "throws failed"
) {
 try {
   Assert.throws(block, expectedError, message);

   this._recordFailure(new Error("Did not throw"), {
     type: "throws",
     expectedError,
     message,
   });
 } catch {}
};

SoftAssert.prototype.ok = function (condition, message = "ok failed") {
 try {
   Assert.ok(condition, message);
 } catch (err) {
   this._recordFailure(err, { type: "ok", condition, message });
 }
};

SoftAssert.prototype.equal = function (
 actual,
 expected,
 message = "equal failed"
) {
 try {
   Assert.equal(actual, expected, message);
 } catch (err) {
   this._recordFailure(err, { type: "equal", actual, expected, message });
 }
};

SoftAssert.prototype.notEqual = function (
 actual,
 expected,
 message = "notEqual failed"
) {
 try {
   Assert.notEqual(actual, expected, message);
 } catch (err) {
   this._recordFailure(err, { type: "notEqual", actual, expected, message });
 }
};

SoftAssert.prototype.deepEqual = function (
 actual,
 expected,
 message = "deepEqual failed"
) {
 try {
   Assert.deepEqual(actual, expected, message);
 } catch (err) {
   this._recordFailure(err, { type: "deepEqual", actual, expected, message });
 }
};

SoftAssert.prototype.notDeepEqual = function (
 actual,
 expected,
 message = "notDeepEqual failed"
) {
 try {
   Assert.notDeepEqual(actual, expected, message);
 } catch (err) {
   this._recordFailure(err, {
     type: "notDeepEqual",
     actual,
     expected,
     message,
   });
 }
};

SoftAssert.prototype.strictEqual = function (
 actual,
 expected,
 message = "strictEqual failed"
) {
 try {
   Assert.strictEqual(actual, expected, message);
 } catch (err) {
   this._recordFailure(err, {
     type: "strictEqual",
     actual,
     expected,
     message,
   });
 }
};

SoftAssert.prototype.notStrictEqual = function (
 actual,
 expected,
 message = "notStrictEqual failed"
) {
 try {
   Assert.notStrictEqual(actual, expected, message);
 } catch (err) {
   this._recordFailure(err, {
     type: "notStrictEqual",
     actual,
     expected,
     message,
   });
 }
};

SoftAssert.prototype.rejects = async function (
 actual,
 expected,
 message = "rejects failed"
) {
 try {
   await Assert.rejects(actual, expected, message);
 } catch (err) {
   this._recordFailure(err, { type: "rejects", actual, expected, message });
 }
};

SoftAssert.prototype.greater = function (
 actual,
 expected,
 message = "greater failed"
) {
 try {
   Assert.greater(actual, expected, message);
 } catch (err) {
   this._recordFailure(err, { type: "greater", actual, expected, message });
 }
};

SoftAssert.prototype.greaterOrEqual = function (
 actual,
 expected,
 message = "greaterOrEqual failed"
) {
 try {
   Assert.greaterOrEqual(actual, expected, message);
 } catch (err) {
   this._recordFailure(err, {
     type: "greaterOrEqual",
     actual,
     expected,
     message,
   });
 }
};

SoftAssert.prototype.less = function (
 actual,
 expected,
 message = "less failed"
) {
 try {
   Assert.less(actual, expected, message);
 } catch (err) {
   this._recordFailure(err, { type: "less", actual, expected, message });
 }
};

SoftAssert.prototype.lessOrEqual = function (
 actual,
 expected,
 message = "lessOrEqual failed"
) {
 try {
   Assert.lessOrEqual(actual, expected, message);
 } catch (err) {
   this._recordFailure(err, {
     type: "lessOrEqual",
     actual,
     expected,
     message,
   });
 }
};

// Call this at the end to fail the test if any soft asserts failed.
SoftAssert.prototype.assertAll = function (label = "Soft assertion failures") {
 if (!this.failures.length) {
   return;
 }

 let details = `${label} (${this.failures.length}):\n`;
 for (let i = 0; i < this.failures.length; i++) {
   const f = this.failures[i];
   details += `\n[${i + 1}] ${f.message}\n`;
   if (f.context) {
     details += `   Context: ${JSON.stringify(f.context)}\n`;
   }
   if (f.stack) {
     details += `   Stack: ${f.stack}\n`;
   }
 }

 // One combined failure at the end:
 throw new Error(details);
};

function softAssertions(Assert) {
 /**
  * Provides a way to execute multiple assertions without exiting
  * a test after the first assertion failure. All assertions in the
  * provided callback will run even if some assertions fail. If an
  * assertion fails, the test will fail and provide details on the
  * failed assertion(s).
  *
  * @example
  * Assert.withSoftAssertions(function(soft) {
  *   // Use usual Assert functions via `soft` reference:
  *   soft.equal(conversation.id.length, 12);
  *   soft.ok(Array.isArray(conversation.messages));
  *   soft.ok(!isNaN(conversation.createdDate));
  * });
  *
  * @param {Function} tests - A callback that acceps a `soft` object to run assertions with.
  */
 Assert.withSoftAssertions = function (tests) {
   const soft = new SoftAssert();
   tests(soft);
   soft.assertAll();
 };
}

softAssertions(Assert);