aboutsummaryrefslogtreecommitdiff
path: root/node_modules/ava/lib/assert.js
diff options
context:
space:
mode:
Diffstat (limited to 'node_modules/ava/lib/assert.js')
-rw-r--r--node_modules/ava/lib/assert.js449
1 files changed, 0 insertions, 449 deletions
diff --git a/node_modules/ava/lib/assert.js b/node_modules/ava/lib/assert.js
deleted file mode 100644
index 18009b97d..000000000
--- a/node_modules/ava/lib/assert.js
+++ /dev/null
@@ -1,449 +0,0 @@
-'use strict';
-const concordance = require('concordance');
-const coreAssert = require('core-assert');
-const observableToPromise = require('observable-to-promise');
-const isObservable = require('is-observable');
-const isPromise = require('is-promise');
-const concordanceOptions = require('./concordance-options').default;
-const concordanceDiffOptions = require('./concordance-options').diff;
-const enhanceAssert = require('./enhance-assert');
-const snapshotManager = require('./snapshot-manager');
-
-function formatDescriptorDiff(actualDescriptor, expectedDescriptor, options) {
- options = Object.assign({}, options, concordanceDiffOptions);
- return {
- label: 'Difference:',
- formatted: concordance.diffDescriptors(actualDescriptor, expectedDescriptor, options)
- };
-}
-
-function formatDescriptorWithLabel(label, descriptor) {
- return {
- label,
- formatted: concordance.formatDescriptor(descriptor, concordanceOptions)
- };
-}
-
-function formatWithLabel(label, value) {
- return formatDescriptorWithLabel(label, concordance.describe(value, concordanceOptions));
-}
-
-class AssertionError extends Error {
- constructor(opts) {
- super(opts.message || '');
- this.name = 'AssertionError';
-
- this.assertion = opts.assertion;
- this.fixedSource = opts.fixedSource;
- this.improperUsage = opts.improperUsage || false;
- this.operator = opts.operator;
- this.values = opts.values || [];
-
- // Raw expected and actual objects are stored for custom reporters
- // (such as wallaby.js), that manage worker processes directly and
- // use the values for custom diff views
- this.raw = opts.raw;
-
- // Reserved for power-assert statements
- this.statements = [];
-
- if (opts.stack) {
- this.stack = opts.stack;
- }
- }
-}
-exports.AssertionError = AssertionError;
-
-function getStack() {
- const obj = {};
- Error.captureStackTrace(obj, getStack);
- return obj.stack;
-}
-
-function wrapAssertions(callbacks) {
- const pass = callbacks.pass;
- const pending = callbacks.pending;
- const fail = callbacks.fail;
- const log = callbacks.log;
-
- const noop = () => {};
- const makeRethrow = reason => () => {
- throw reason;
- };
-
- const assertions = {
- pass() {
- pass(this);
- },
-
- fail(message) {
- fail(this, new AssertionError({
- assertion: 'fail',
- message: message || 'Test failed via `t.fail()`'
- }));
- },
-
- is(actual, expected, message) {
- if (Object.is(actual, expected)) {
- pass(this);
- } else {
- const result = concordance.compare(actual, expected, concordanceOptions);
- const actualDescriptor = result.actual || concordance.describe(actual, concordanceOptions);
- const expectedDescriptor = result.expected || concordance.describe(expected, concordanceOptions);
-
- if (result.pass) {
- fail(this, new AssertionError({
- assertion: 'is',
- message,
- raw: {actual, expected},
- values: [formatDescriptorWithLabel('Values are deeply equal to each other, but they are not the same:', actualDescriptor)]
- }));
- } else {
- fail(this, new AssertionError({
- assertion: 'is',
- message,
- raw: {actual, expected},
- values: [formatDescriptorDiff(actualDescriptor, expectedDescriptor)]
- }));
- }
- }
- },
-
- not(actual, expected, message) {
- if (Object.is(actual, expected)) {
- fail(this, new AssertionError({
- assertion: 'not',
- message,
- raw: {actual, expected},
- values: [formatWithLabel('Value is the same as:', actual)]
- }));
- } else {
- pass(this);
- }
- },
-
- log(text) {
- log(this, text);
- },
-
- deepEqual(actual, expected, message) {
- const result = concordance.compare(actual, expected, concordanceOptions);
- if (result.pass) {
- pass(this);
- } else {
- const actualDescriptor = result.actual || concordance.describe(actual, concordanceOptions);
- const expectedDescriptor = result.expected || concordance.describe(expected, concordanceOptions);
- fail(this, new AssertionError({
- assertion: 'deepEqual',
- message,
- raw: {actual, expected},
- values: [formatDescriptorDiff(actualDescriptor, expectedDescriptor)]
- }));
- }
- },
-
- notDeepEqual(actual, expected, message) {
- const result = concordance.compare(actual, expected, concordanceOptions);
- if (result.pass) {
- const actualDescriptor = result.actual || concordance.describe(actual, concordanceOptions);
- fail(this, new AssertionError({
- assertion: 'notDeepEqual',
- message,
- raw: {actual, expected},
- values: [formatDescriptorWithLabel('Value is deeply equal:', actualDescriptor)]
- }));
- } else {
- pass(this);
- }
- },
-
- throws(fn, err, message) {
- let promise;
- if (isPromise(fn)) {
- promise = fn;
- } else if (isObservable(fn)) {
- promise = observableToPromise(fn);
- } else if (typeof fn !== 'function') {
- fail(this, new AssertionError({
- assertion: 'throws',
- improperUsage: true,
- message: '`t.throws()` must be called with a function, Promise, or Observable',
- values: [formatWithLabel('Called with:', fn)]
- }));
- return;
- }
-
- let coreAssertThrowsErrorArg;
- if (typeof err === 'string') {
- const expectedMessage = err;
- coreAssertThrowsErrorArg = error => error.message === expectedMessage;
- } else {
- // Assume it's a constructor function or regular expression
- coreAssertThrowsErrorArg = err;
- }
-
- const test = (fn, stack) => {
- let actual;
- let threw = false;
- try {
- coreAssert.throws(() => {
- try {
- fn();
- } catch (err) {
- actual = err;
- threw = true;
- throw err;
- }
- }, coreAssertThrowsErrorArg);
- return actual;
- } catch (err) {
- throw new AssertionError({
- assertion: 'throws',
- message,
- stack,
- values: threw ?
- [formatWithLabel('Threw unexpected exception:', actual)] :
- null
- });
- }
- };
-
- if (promise) {
- // Record stack before it gets lost in the promise chain.
- const stack = getStack();
- const intermediate = promise.then(value => {
- throw new AssertionError({
- assertion: 'throws',
- message: 'Expected promise to be rejected, but it was resolved instead',
- values: [formatWithLabel('Resolved with:', value)]
- });
- }, reason => test(makeRethrow(reason), stack));
-
- pending(this, intermediate);
- // Don't reject the returned promise, even if the assertion fails.
- return intermediate.catch(noop);
- }
-
- try {
- const retval = test(fn);
- pass(this);
- return retval;
- } catch (err) {
- fail(this, err);
- }
- },
-
- notThrows(fn, message) {
- let promise;
- if (isPromise(fn)) {
- promise = fn;
- } else if (isObservable(fn)) {
- promise = observableToPromise(fn);
- } else if (typeof fn !== 'function') {
- fail(this, new AssertionError({
- assertion: 'notThrows',
- improperUsage: true,
- message: '`t.notThrows()` must be called with a function, Promise, or Observable',
- values: [formatWithLabel('Called with:', fn)]
- }));
- return;
- }
-
- const test = (fn, stack) => {
- try {
- coreAssert.doesNotThrow(fn);
- } catch (err) {
- throw new AssertionError({
- assertion: 'notThrows',
- message,
- stack,
- values: [formatWithLabel('Threw:', err.actual)]
- });
- }
- };
-
- if (promise) {
- // Record stack before it gets lost in the promise chain.
- const stack = getStack();
- const intermediate = promise.then(noop, reason => test(makeRethrow(reason), stack));
- pending(this, intermediate);
- // Don't reject the returned promise, even if the assertion fails.
- return intermediate.catch(noop);
- }
-
- try {
- test(fn);
- pass(this);
- } catch (err) {
- fail(this, err);
- }
- },
-
- ifError(actual, message) {
- if (actual) {
- fail(this, new AssertionError({
- assertion: 'ifError',
- message,
- values: [formatWithLabel('Error:', actual)]
- }));
- } else {
- pass(this);
- }
- },
-
- snapshot(expected, optionsOrMessage, message) {
- const options = {};
- if (typeof optionsOrMessage === 'string') {
- message = optionsOrMessage;
- } else if (optionsOrMessage) {
- options.id = optionsOrMessage.id;
- }
- options.expected = expected;
- options.message = message;
-
- let result;
- try {
- result = this._test.compareWithSnapshot(options);
- } catch (err) {
- if (!(err instanceof snapshotManager.SnapshotError)) {
- throw err;
- }
-
- const improperUsage = {name: err.name, snapPath: err.snapPath};
- if (err instanceof snapshotManager.VersionMismatchError) {
- improperUsage.snapVersion = err.snapVersion;
- improperUsage.expectedVersion = err.expectedVersion;
- }
-
- fail(this, new AssertionError({
- assertion: 'snapshot',
- message: message || 'Could not compare snapshot',
- improperUsage
- }));
- return;
- }
-
- if (result.pass) {
- pass(this);
- } else if (result.actual) {
- fail(this, new AssertionError({
- assertion: 'snapshot',
- message: message || 'Did not match snapshot',
- values: [formatDescriptorDiff(result.actual, result.expected, {invert: true})]
- }));
- } else {
- fail(this, new AssertionError({
- assertion: 'snapshot',
- message: message || 'No snapshot available, run with --update-snapshots'
- }));
- }
- }
- };
-
- const enhancedAssertions = enhanceAssert(pass, fail, {
- truthy(actual, message) {
- if (!actual) {
- throw new AssertionError({
- assertion: 'truthy',
- message,
- operator: '!!',
- values: [formatWithLabel('Value is not truthy:', actual)]
- });
- }
- },
-
- falsy(actual, message) {
- if (actual) {
- throw new AssertionError({
- assertion: 'falsy',
- message,
- operator: '!',
- values: [formatWithLabel('Value is not falsy:', actual)]
- });
- }
- },
-
- true(actual, message) {
- if (actual !== true) {
- throw new AssertionError({
- assertion: 'true',
- message,
- values: [formatWithLabel('Value is not `true`:', actual)]
- });
- }
- },
-
- false(actual, message) {
- if (actual !== false) {
- throw new AssertionError({
- assertion: 'false',
- message,
- values: [formatWithLabel('Value is not `false`:', actual)]
- });
- }
- },
-
- regex(string, regex, message) {
- if (typeof string !== 'string') {
- throw new AssertionError({
- assertion: 'regex',
- improperUsage: true,
- message: '`t.regex()` must be called with a string',
- values: [formatWithLabel('Called with:', string)]
- });
- }
- if (!(regex instanceof RegExp)) {
- throw new AssertionError({
- assertion: 'regex',
- improperUsage: true,
- message: '`t.regex()` must be called with a regular expression',
- values: [formatWithLabel('Called with:', regex)]
- });
- }
-
- if (!regex.test(string)) {
- throw new AssertionError({
- assertion: 'regex',
- message,
- values: [
- formatWithLabel('Value must match expression:', string),
- formatWithLabel('Regular expression:', regex)
- ]
- });
- }
- },
-
- notRegex(string, regex, message) {
- if (typeof string !== 'string') {
- throw new AssertionError({
- assertion: 'notRegex',
- improperUsage: true,
- message: '`t.notRegex()` must be called with a string',
- values: [formatWithLabel('Called with:', string)]
- });
- }
- if (!(regex instanceof RegExp)) {
- throw new AssertionError({
- assertion: 'notRegex',
- improperUsage: true,
- message: '`t.notRegex()` must be called with a regular expression',
- values: [formatWithLabel('Called with:', regex)]
- });
- }
-
- if (regex.test(string)) {
- throw new AssertionError({
- assertion: 'notRegex',
- message,
- values: [
- formatWithLabel('Value must not match expression:', string),
- formatWithLabel('Regular expression:', regex)
- ]
- });
- }
- }
- });
-
- return Object.assign(assertions, enhancedAssertions);
-}
-exports.wrapAssertions = wrapAssertions;
generated by cgit v1.2.3 (git 2.39.1) at 2025-09-12 12:48:24 +0000