lib: add strict option to Assert

Author: miguelmarcondesf

doc/api/assert.md

@@ -230,6 +230,8 @@ The `Assert` class allows creating independent assertion instances with custom o
 * `options` {Object}
   * `diff` {string} If set to `'full'`, shows the full diff in assertion errors. Defaults to `'simple'`.
     Accepted values: `'simple'`, `'full'`.
+  * `strict` {boolean} If set to `true`, non-strict methods behave like their
+    corresponding strict methods. Defaults to `true`.
 
 Creates a new assertion instance. The `diff` option controls the verbosity of diffs in assertion error messages.
 

lib/assert.js

@@ -88,18 +88,22 @@ const NO_EXCEPTION_SENTINEL = {};
  * Assert options.
  * @typedef {object} AssertOptions
  * @property {'full'|'simple'} [diff='simple'] - If set to 'full', shows the full diff in assertion errors.
+ * @property {boolean} [strict=true] - If set to true, non-strict methods behave like their corresponding
+ *   strict methods.
  */
 
 /**
  * @class Assert
  * @param {AssertOptions} [options] - Optional configuration for assertions.
  * @throws {ERR_INVALID_ARG_TYPE} If not called with `new`.
  */
-function Assert(options = {}) {
+function Assert(options) {
   if (!new.target) {
     throw new ERR_INVALID_ARG_TYPE('Assert', 'constructor', Assert);
   }
 
+  options = ObjectAssign({ strict: true }, options);
+
   const allowedDiffs = ['simple', 'full'];
   if (
     options.diff !== undefined &&
@@ -120,6 +124,13 @@ function Assert(options = {}) {
     configurable: false,
     writable: false,
   });
+
+  if (options.strict) {
+    this.equal = this.strictEqual;
+    this.deepEqual = this.deepStrictEqual;
+    this.notEqual = this.notStrictEqual;
+    this.notDeepEqual = this.notDeepStrictEqual;
+  }
 }
 
 // All of the following functions must throw an AssertionError
@@ -864,7 +875,7 @@ function strict(...args) {
   innerOk(strict, args.length, ...args);
 }
 
-const assertInstance = new Assert({ diff: 'simple' });
+const assertInstance = new Assert({ diff: 'simple', strict: false });
 [
   'ok', 'fail', 'equal', 'notEqual', 'deepEqual', 'notDeepEqual',
   'deepStrictEqual', 'notDeepStrictEqual', 'strictEqual',

test/parallel/test-assert-class.js

@@ -24,8 +24,8 @@ test('Assert constructor requires new', () => {
   );
 });
 
-test('Assert class basic instance', () => {
-  const assertInstance = new Assert({ diff: undefined });
+test('Assert class non strict', () => {
+  const assertInstance = new Assert({ diff: undefined, strict: false });
 
   assertInstance.ok(assert.AssertionError.prototype instanceof Error,
                     'assert.AssertionError instanceof Error');
@@ -44,6 +44,8 @@ test('Assert class basic instance', () => {
     }
   );
   assertInstance.equal(undefined, undefined);
+  assertInstance.equal(null, undefined);
+  assertInstance.equal(2, '2');
   assertInstance.notEqual(true, false);
   assertInstance.throws(
     () => assertInstance.deepEqual(/a/),
@@ -117,6 +119,15 @@ test('Assert class basic instance', () => {
   /* eslint-enable no-restricted-syntax */
 });
 
+test('Assert class strict', () => {
+  const assertInstance = new Assert();
+
+  assertInstance.equal(assertInstance.equal, assertInstance.strictEqual);
+  assertInstance.equal(assertInstance.deepEqual, assertInstance.deepStrictEqual);
+  assertInstance.equal(assertInstance.notEqual, assertInstance.notStrictEqual);
+  assertInstance.equal(assertInstance.notDeepEqual, assertInstance.notDeepStrictEqual);
+});
+
 test('Assert class with invalid diff option', () => {
   assert.throws(
     () => new Assert({ diff: 'invalid' }),
@@ -128,8 +139,8 @@ test('Assert class with invalid diff option', () => {
   );
 });
 
-test('Assert class with full diff', () => {
-  const assertInstance = new Assert({ diff: 'full' });
+test('Assert class non strict with full diff', () => {
+  const assertInstance = new Assert({ diff: 'full', strict: false });
 
   const longStringOfAs = 'A'.repeat(1025);
   const longStringOFBs = 'B'.repeat(1025);
@@ -173,8 +184,8 @@ test('Assert class with full diff', () => {
   });
 });
 
-test('Assert class with simple diff', () => {
-  const assertInstance = new Assert({ diff: 'simple' });
+test('Assert class non strict with simple diff', () => {
+  const assertInstance = new Assert({ diff: 'simple', strict: false });
 
   const longStringOfAs = 'A'.repeat(1025);
   const longStringOFBs = 'B'.repeat(1025);