qunitx 0.8.2 → 0.8.3

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "qunitx",
   "type": "module",
-  "version": "0.8.2",
+  "version": "0.8.3",
   "description": "A universal test framework for testing any js file on node.js, browser or deno with QUnit API",
   "author": "Izel Nakri",
   "license": "MIT",

package/shims/deno/assert.js

@@ -1,6 +1,6 @@
 import { AssertionError as DenoAssertionError, assertRejects, assertThrows } from "https://deno.land/std@0.192.0/testing/asserts.ts";
 import '../../vendor/qunit.js';
-import { objectValuesSubset } from '../shared/index.js';
+import { objectValues, objectValuesSubset, validateExpectedExceptionArgs, validateException } from '../shared/index.js';
 import util from 'node:util';
 
 export class AssertionError extends DenoAssertionError {
@@ -62,7 +62,7 @@ export default {
     }
   },
   true(state, message) {
-    if (state === true) {
+    if (state !== true) {
       throw new AssertionError({
         actual: state,
         expected: true,
@@ -72,7 +72,7 @@ export default {
     }
   },
   false(state, message) {
-    if (state === false) {
+    if (state !== false) {
       throw new AssertionError({
         actual: state,
         expected: true,
@@ -82,7 +82,7 @@ export default {
     }
   },
   equal(actual, expected, message) {
-    if (actual == expected) {
+    if (actual != expected) {
       throw new AssertionError({
         actual,
         expected,
@@ -93,7 +93,7 @@ export default {
     }
   },
   notEqual(actual, expected, message) {
-    if (actual != expected) {
+    if (actual == expected) {
       throw new AssertionError({
         actual,
         expected,
@@ -106,7 +106,7 @@ export default {
   propEqual(actual, expected, message) {
     let targetActual = objectValues(actual);
     let targetExpected = objectValues(expected);
-    if (!window.QUnit.window.QUnit.equiv(targetActual, targetExpected)) {
+    if (!window.QUnit.equiv(targetActual, targetExpected)) {
       throw new AssertionError({
         actual: targetActual,
         expected: targetExpected,
@@ -195,23 +195,73 @@ export default {
       });
     }
   },
-  throws: assertThrows,
-  rejects: assertRejects,
-};
+  throws(blockFn, expectedInput, assertionMessage) {
+    let [expected, message] = validateExpectedExceptionArgs(expectedInput, assertionMessage, 'rejects');
+    if (typeof blockFn !== 'function') {
+      throw new AssertionError({
+        actual: blockFn,
+        expected: Function,
+        message: 'The value provided to `assert.throws` was not a function.',
+        stackStartFn: this.throws,
+      });
+    }
 
-function objectValues(obj) {
-  let allowArray = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
-  let vals = allowArray && is('array', obj) ? [] : {};
+    try {
+      blockFn();
+    } catch (error) {
+      let validation = validateException(error, expected, message);
+      if (validation.result === false) {
+        throw new AssertionError({
+          actual: validation.result,
+          expected: validation.expected,
+          message: validation.message,
+          stackStartFn: this.throws,
+        });
+      }
 
-  for (var key in obj) {
-    if (hasOwn$1.call(obj, key)) {
-      let val = obj[key];
-      vals[key] = val === Object(val) ? objectValues(val, allowArray) : val;
+      return;
     }
-  }
 
-  return vals;
-}
+    throw new AssertionError({
+      actual: blockFn,
+      expected: expected,
+      message: 'Function passed to `assert.throws` did not throw an exception!',
+      stackStartFn: this.throws,
+    });
+  },
+  async rejects(promise, expectedInput, assertionMessage) {
+    let [expected, message] = validateExpectedExceptionArgs(expectedInput, assertionMessage, 'rejects');
+    let then = promise && promise.then;
+    if (typeof then !== 'function') {
+      throw new AssertionError({
+        actual: promise,
+        expected: expected,
+        message: 'The value provided to `assert.rejects` was not a promise!',
+        stackStartFn: this.rejects,
+      });
+    }
+
+    try {
+      await promise;
+      throw new AssertionError({
+        actual: promise,
+        expected: expected,
+        message: 'The promise returned by the `assert.rejects` callback did not reject!',
+        stackStartFn: this.rejects,
+      });
+    } catch (error) {
+      let validation = validateException(error, expected, message);
+      if (validation.result === false) {
+        throw new AssertionError({
+          actual: validation.result,
+          expected: validation.expected,
+          message: validation.message,
+          stackStartFn: this.rejects,
+        });
+      }
+    }
+  }
+};
 
 function defaultMessage(actual, description, expected) {
   return `
@@ -226,3 +276,4 @@ ${inspect(expected)}`
 function inspect(value) {
   return util.inspect(value, { depth: 10, colors: true, compact: false });
 }
+

package/shims/node/assert.js

@@ -1,5 +1,5 @@
 import QUnit from '../../vendor/qunit.js';
-import { objectValuesSubset } from '../shared/index.js';
+import { objectValues, objectValuesSubset, validateExpectedExceptionArgs, validateException } from '../shared/index.js';
 import assert, { AssertionError } from 'node:assert';
 import util from 'node:util';
 
@@ -56,7 +56,7 @@ export default {
     }
   },
   true(state, message) {
-    if (state === true) {
+    if (state !== true) {
       throw new AssertionError({
         actual: state,
         expected: true,
@@ -66,7 +66,7 @@ export default {
     }
   },
   false(state, message) {
-    if (state === false) {
+    if (state !== false) {
       throw new AssertionError({
         actual: state,
         expected: true,
@@ -76,7 +76,7 @@ export default {
     }
   },
   equal(actual, expected, message) {
-    if (actual == expected) {
+    if (actual != expected) {
       throw new AssertionError({
         actual,
         expected,
@@ -87,7 +87,7 @@ export default {
     }
   },
   notEqual(actual, expected, message) {
-    if (actual != expected) {
+    if (actual == expected) {
       throw new AssertionError({
         actual,
         expected,
@@ -189,23 +189,73 @@ export default {
       });
     }
   },
-  throws: assert.throws,
-  rejects: assert.rejects,
-};
+  throws(blockFn, expectedInput, assertionMessage) {
+    let [expected, message] = validateExpectedExceptionArgs(expectedInput, assertionMessage, 'rejects');
+    if (typeof blockFn !== 'function') {
+      throw new AssertionError({
+        actual: blockFn,
+        expected: Function,
+        message: 'The value provided to `assert.throws` was not a function.',
+        stackStartFn: this.throws,
+      });
+    }
 
-function objectValues(obj) {
-  let allowArray = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
-  let vals = allowArray && is('array', obj) ? [] : {};
+    try {
+      blockFn();
+    } catch (error) {
+      let validation = validateException(error, expected, message);
+      if (validation.result === false) {
+        throw new AssertionError({
+          actual: validation.result,
+          expected: validation.expected,
+          message: validation.message,
+          stackStartFn: this.throws,
+        });
+      }
 
-  for (var key in obj) {
-    if (hasOwn$1.call(obj, key)) {
-      let val = obj[key];
-      vals[key] = val === Object(val) ? objectValues(val, allowArray) : val;
+      return;
     }
-  }
 
-  return vals;
-}
+    throw new AssertionError({
+      actual: blockFn,
+      expected: expected,
+      message: 'Function passed to `assert.throws` did not throw an exception!',
+      stackStartFn: this.throws,
+    });
+  },
+  async rejects(promise, expectedInput, assertionMessage) {
+    let [expected, message] = validateExpectedExceptionArgs(expectedInput, assertionMessage, 'rejects');
+    let then = promise && promise.then;
+    if (typeof then !== 'function') {
+      throw new AssertionError({
+        actual: promise,
+        expected: expected,
+        message: 'The value provided to `assert.rejects` was not a promise!',
+        stackStartFn: this.rejects,
+      });
+    }
+
+    try {
+      await promise;
+      throw new AssertionError({
+        actual: promise,
+        expected: expected,
+        message: 'The promise returned by the `assert.rejects` callback did not reject!',
+        stackStartFn: this.rejects,
+      });
+    } catch (error) {
+      let validation = validateException(error, expected, message);
+      if (validation.result === false) {
+        throw new AssertionError({
+          actual: validation.result,
+          expected: validation.expected,
+          message: validation.message,
+          stackStartFn: this.rejects,
+        });
+      }
+    }
+  }
+};
 
 function defaultMessage(actual, description, expected) {
   return `

package/shims/shared/index.js

@@ -1,4 +1,67 @@
+const hasOwn = Object.prototype.hasOwnProperty
+
+function _typeof(obj) {
+  "@babel/helpers - typeof";
+
+  return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) {
+    return typeof obj;
+  } : function (obj) {
+    return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
+  }, _typeof(obj);
+}
+
+export function objectType(obj) {
+  if (typeof obj === 'undefined') {
+    return 'undefined';
+  }
+
+  // Consider: typeof null === object
+  if (obj === null) {
+    return 'null';
+  }
+  var match = toString.call(obj).match(/^\[object\s(.*)\]$/);
+  var type = match && match[1];
+  switch (type) {
+    case 'Number':
+      if (isNaN(obj)) {
+        return 'nan';
+      }
+      return 'number';
+    case 'String':
+    case 'Boolean':
+    case 'Array':
+    case 'Set':
+    case 'Map':
+    case 'Date':
+    case 'RegExp':
+    case 'Function':
+    case 'Symbol':
+      return type.toLowerCase();
+    default:
+      return _typeof(obj);
+  }
+}
+
+function is(type, obj) {
+  return objectType(obj) === type;
+}
+
+export function objectValues(obj) {
+  let allowArray = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
+  let vals = allowArray && is('array', obj) ? [] : {};
+
+  for (var key in obj) {
+    if (hasOwn.call(obj, key)) {
+      let val = obj[key];
+      vals[key] = val === Object(val) ? objectValues(val, allowArray) : val;
+    }
+  }
+
+  return vals;
+}
+
 /**
+ *
  * Recursively clone an object into a plain object, taking only the
  * subset of own enumerable properties that exist a given model.
  *
@@ -19,11 +82,91 @@ export function objectValuesSubset(obj, model) {
   // This enables subsetting [20, 30] with {1: 30}.
   var subset = {};
   for (var key in model) {
-    if (hasOwn$1.call(model, key) && hasOwn$1.call(obj, key)) {
+    if (hasOwn.call(model, key) && hasOwn.call(obj, key)) {
       subset[key] = objectValuesSubset(obj[key], model[key]);
     }
   }
   return subset;
 }
 
-export default { objectValuesSubset };
+export function validateExpectedExceptionArgs(expected, message, assertionMethod) {
+  var expectedType = objectType(expected);
+
+  // 'expected' is optional unless doing string comparison
+  if (expectedType === 'string') {
+    if (message === undefined) {
+      message = expected;
+      expected = undefined;
+      return [expected, message];
+    } else {
+      throw new Error('assert.' + assertionMethod + ' does not accept a string value for the expected argument.\n' + 'Use a non-string object value (e.g. RegExp or validator function) ' + 'instead if necessary.');
+    }
+  }
+  var valid = !expected ||
+  // TODO: be more explicit here
+  expectedType === 'regexp' || expectedType === 'function' || expectedType === 'object';
+  if (!valid) {
+    throw new Error('Invalid expected value type (' + expectedType + ') ' + 'provided to assert.' + assertionMethod + '.');
+  }
+  return [expected, message];
+}
+
+export function validateException(actual, expected, message) {
+  var result = false;
+  var expectedType = objectType(expected);
+
+  // These branches should be exhaustive, based on validation done in validateExpectedException
+
+  // We don't want to validate
+  if (!expected) {
+    result = true;
+
+    // Expected is a regexp
+  } else if (expectedType === 'regexp') {
+    result = expected.test(errorString(actual));
+
+    // Log the string form of the regexp
+    expected = String(expected);
+
+    // Expected is a constructor, maybe an Error constructor.
+    // Note the extra check on its prototype - this is an implicit
+    // requirement of "instanceof", else it will throw a TypeError.
+  } else if (expectedType === 'function' && expected.prototype !== undefined && actual instanceof expected) {
+    result = true;
+
+    // Expected is an Error object
+  } else if (expectedType === 'object') {
+    result = actual instanceof expected.constructor && actual.name === expected.name && actual.message === expected.message;
+
+    // Log the string form of the Error object
+    expected = errorString(expected);
+
+    // Expected is a validation function which returns true if validation passed
+  } else if (expectedType === 'function') {
+    // protect against accidental semantics which could hard error in the test
+    try {
+      result = expected.call({}, actual) === true;
+      expected = null;
+    } catch (e) {
+      // assign the "expected" to a nice error string to communicate the local failure to the user
+      expected = errorString(e);
+    }
+  }
+  return [result, expected, message];
+}
+
+function errorString(error) {
+  // Use String() instead of toString() to handle non-object values like undefined or null.
+  var resultErrorString = String(error);
+
+  // If the error wasn't a subclass of Error but something like
+  // an object literal with name and message properties...
+  if (resultErrorString.slice(0, 7) === '[object') {
+    // Based on https://es5.github.io/#x15.11.4.4
+    return (error.name || 'Error') + (error.message ? ": ".concat(error.message) : '');
+  } else {
+    return resultErrorString;
+  }
+}
+
+export default { objectValues, objectValuesSubset, validateExpectedExceptionArgs, validateException };