codeceptjs 4.0.0-beta.1 → 4.0.0-beta.10.esm-aria

package/lib/assert/include.js

@@ -1,79 +1,74 @@
-import Assertion from '../assert.js';
-import AssertionFailedError from './error.js';
-import { template } from '../utils.js';
-import * as output from '../output.js';
+import Assertion from '../assert.js'
+import AssertionFailedError from './error.js'
+import { template } from '../utils.js'
+import output from '../output.js'
 
-const MAX_LINES = 10;
+const MAX_LINES = 10
 
 class InclusionAssertion extends Assertion {
   constructor(params) {
-    params.jar = params.jar || 'string';
+    params.jar = params.jar || 'string'
     const comparator = function (needle, haystack) {
       if (Array.isArray(haystack)) {
-        return haystack.filter(part => part.indexOf(needle) >= 0).length > 0;
+        return haystack.filter(part => part.indexOf(needle) >= 0).length > 0
       }
-      return haystack.indexOf(needle) >= 0;
-    };
-    super(comparator, params);
-    this.params.type = 'to include';
+      return haystack.indexOf(needle) >= 0
+    }
+    super(comparator, params)
+    this.params.type = 'to include'
   }
 
   getException() {
-    const params = this.params;
-    params.jar = template(params.jar, params);
-    const err = new AssertionFailedError(params, '{{customMessage}}expected {{jar}} {{type}} "{{needle}}"');
-    err.expected = params.needle;
-    err.actual = params.haystack;
+    const params = this.params
+    params.jar = template(params.jar, params)
+    const err = new AssertionFailedError(params, '{{customMessage}}expected {{jar}} {{type}} "{{needle}}"')
+    err.expected = params.needle
+    err.actual = params.haystack
     if (Array.isArray(this.params.haystack)) {
-      this.params.haystack = this.params.haystack.join('\n___(next element)___\n');
+      this.params.haystack = this.params.haystack.join('\n___(next element)___\n')
     }
     err.cliMessage = function () {
-      const msg = this.template
-        .replace('{{jar}}', output.output.colors.bold('{{jar}}'))
-        .replace('{{needle}}', output.output.colors.bold('{{needle}}'));
-      return template(msg, this.params);
-    };
-    return err;
+      const msg = this.template.replace('{{jar}}', output.colors.bold('{{jar}}')).replace('{{needle}}', output.colors.bold('{{needle}}'))
+      return template(msg, this.params)
+    }
+    return err
   }
 
   getFailedAssertion() {
-    const err = this.getException();
-    const lines = this.params.haystack.split('\n');
+    const err = this.getException()
+    const lines = this.params.haystack.split('\n')
     if (lines.length > MAX_LINES) {
-      const more = lines.length - MAX_LINES;
-      err.actual = `${lines.slice(0, MAX_LINES).join('\n')}\n--( ${more} lines more )---`;
+      const more = lines.length - MAX_LINES
+      err.actual = `${lines.slice(0, MAX_LINES).join('\n')}\n--( ${more} lines more )---`
     }
-    return err;
+    return err
   }
 
   getFailedNegation() {
-    this.params.type = 'not to include';
-    const err = this.getException();
-    const pattern = new RegExp(`^.*?\n?^.*?\n?^.*?${escapeRegExp(this.params.needle)}.*?$\n?.*$\n?.*$`, 'm');
-    const matched = this.params.haystack.match(pattern);
-    if (!matched) return err;
-    err.actual = matched[0].replace(this.params.needle, output.output.colors.bold(this.params.needle));
-    err.actual = `------\n${err.actual}\n------`;
-    return err;
+    this.params.type = 'not to include'
+    const err = this.getException()
+    const pattern = new RegExp(`^.*?\n?^.*?\n?^.*?${escapeRegExp(this.params.needle)}.*?$\n?.*$\n?.*$`, 'm')
+    const matched = this.params.haystack.match(pattern)
+    if (!matched) return err
+    err.actual = matched[0].replace(this.params.needle, output.colors.bold(this.params.needle))
+    err.actual = `------\n${err.actual}\n------`
+    return err
   }
 
   addAssertParams() {
-    this.params.needle = arguments[0];
-    this.params.haystack = arguments[1];
-    this.params.customMessage = arguments[2] ? `${arguments[2]}\n\n` : '';
+    this.params.needle = arguments[0]
+    this.params.haystack = arguments[1]
+    this.params.customMessage = arguments[2] ? `${arguments[2]}\n\n` : ''
   }
 }
 
-export { InclusionAssertion as Assertion };
-export function includes(needleType) {
-  needleType = needleType || 'string';
-  return new InclusionAssertion({ jar: needleType });
+export { InclusionAssertion as Assertion }
+export const includes = needleType => {
+  needleType = needleType || 'string'
+  return new InclusionAssertion({ jar: needleType })
 }
+export const fileIncludes = file => new InclusionAssertion({ file, jar: 'file {{file}}' })
 
 function escapeRegExp(str) {
-  return str.replace(/[\-\[\]\/\{\}\(\)\*\+\?\.\\\^\$\|]/g, '\\$&');
-}
-
-export function fileIncludes(file) {
-  return new InclusionAssertion({ file, jar: 'file {{file}}' });
+  return str.replace(/[\-\[\]\/\{\}\(\)\*\+\?\.\\\^\$\|]/g, '\\$&')
 }

package/lib/assert/throws.js

@@ -1,20 +1,20 @@
 function errorThrown(actual, expected) {
-  if (!expected) return null;
-  if (!actual) throw new Error(`Expected ${expected} error to be thrown`);
-  const msg = actual.inspect ? actual.inspect() : actual.toString();
+  if (!expected) return null
+  if (!actual) throw new Error(`Expected ${expected} error to be thrown`)
+  const msg = actual.inspect ? actual.inspect() : actual.toString()
   if (expected instanceof RegExp) {
-    if (msg.match(expected)) return null;
-    throw new Error(`Expected error to be thrown with message matching ${expected} while '${msg}' caught`);
+    if (msg.match(expected)) return null
+    throw new Error(`Expected error to be thrown with message matching ${expected} while '${msg}' caught`)
   }
   if (typeof expected === 'string') {
-    if (msg === expected) return null;
-    throw new Error(`Expected error to be thrown with message ${expected} while '${msg}' caught`);
+    if (msg === expected) return null
+    throw new Error(`Expected error to be thrown with message ${expected} while '${msg}' caught`)
   }
   if (typeof expected === 'object') {
-    if (actual.constructor.name !== expected.constructor.name) throw new Error(`Expected ${expected} error to be thrown but ${actual} was caught`);
-    if (expected.message && expected.message !== msg) throw new Error(`Expected error to be thrown with message ${expected.message} while '${msg}' caught`);
+    if (actual.constructor.name !== expected.constructor.name) throw new Error(`Expected ${expected} error to be thrown but ${actual} was caught`)
+    if (expected.message && expected.message !== msg) throw new Error(`Expected error to be thrown with message ${expected.message} while '${msg}' caught`)
   }
-  return null;
+  return null
 }
 
-export default errorThrown;
+export default errorThrown

package/lib/assert/truth.js

@@ -1,39 +1,39 @@
-import Assertion from '../assert.js';
-import AssertionFailedError from './error.js';
-import { template } from '../utils.js';
-import * as output from '../output.js';
+import Assertion from '../assert.js'
+import AssertionFailedError from './error.js'
+import { template } from '../utils.js'
+import output from '../output.js'
 
 class TruthAssertion extends Assertion {
   constructor(params) {
-    super((value) => {
+    super(value => {
       if (Array.isArray(value)) {
-        return value.filter(val => !!val).length > 0;
+        return value.filter(val => !!val).length > 0
       }
-      return !!value;
-    }, params);
-    this.params.type = this.params.type || 'to be true';
+      return !!value
+    }, params)
+    this.params.type = this.params.type || 'to be true'
   }
 
   getException() {
-    const err = new AssertionFailedError(this.params, '{{customMessage}}expected {{subject}} {{type}}');
+    const err = new AssertionFailedError(this.params, '{{customMessage}}expected {{subject}} {{type}}')
     err.cliMessage = () => {
-      const msg = err.template
-        .replace('{{subject}}', output.colors.bold('{{subject}}'));
-      return template(msg, this.params);
-    };
-    return err;
+      const msg = err.template.replace('{{subject}}', output.colors.bold('{{subject}}'))
+      return template(msg, this.params)
+    }
+    return err
   }
 
   addAssertParams() {
-    this.params.value = this.params.actual = arguments[0];
-    this.params.expected = true;
-    this.params.customMessage = arguments[1] ? `${arguments[1]}\n\n` : '';
+    this.params.value = this.params.actual = arguments[0]
+    this.params.expected = true
+    this.params.customMessage = arguments[1] ? `${arguments[1]}\n\n` : ''
   }
 }
 
-export function truth(subject, type) {
-  return new TruthAssertion({ subject, type });
-}
+export { TruthAssertion as Assertion }
+export const truth = (subject, type) => new TruthAssertion({ subject, type })
+
 export default {
   Assertion: TruthAssertion,
-};
+  truth: (subject, type) => new TruthAssertion({ subject, type }),
+}

package/lib/assert.js

@@ -1,4 +1,4 @@
-import AssertionFailedError from './assert/error.js';
+import AssertionFailedError from './assert/error.js'
 
 /**
  * Abstract assertion class introduced for more verbose and customizable messages.
@@ -20,11 +20,11 @@ import AssertionFailedError from './assert/error.js';
  * to get more customizable exception messages.
  *
  */
-export default class Assertion {
+class Assertion {
   constructor(comparator, params) {
-    this.comparator = comparator;
-    this.params = params || {};
-    this.params.customMessage = '';
+    this.comparator = comparator
+    this.params = params || {}
+    this.params.customMessage = ''
   }
 
   /**
@@ -32,10 +32,10 @@ export default class Assertion {
    * Fails if comparator function with provided arguments returns false
    */
   assert() {
-    this.addAssertParams.apply(this, arguments);
-    const result = this.comparator.apply(this.params, arguments);
-    if (result) return; // should increase global assertion counter
-    throw this.getFailedAssertion();
+    this.addAssertParams.apply(this, arguments)
+    const result = this.comparator.apply(this.params, arguments)
+    if (result) return // should increase global assertion counter
+    throw this.getFailedAssertion()
   }
 
   /**
@@ -43,10 +43,10 @@ export default class Assertion {
    * Fails if comparator function with provided arguments returns true
    */
   negate() {
-    this.addAssertParams.apply(this, arguments);
-    const result = this.comparator.apply(this.params, arguments);
-    if (!result) return; // should increase global assertion counter
-    throw this.getFailedNegation();
+    this.addAssertParams.apply(this, arguments)
+    const result = this.comparator.apply(this.params, arguments)
+    if (!result) return // should increase global assertion counter
+    throw this.getFailedNegation()
   }
 
   /**
@@ -55,16 +55,18 @@ export default class Assertion {
   addAssertParams() {}
 
   getException() {
-    return new AssertionFailedError(this.params, '');
+    return new AssertionFailedError(this.params, '')
   }
 
   getFailedNegation() {
-    const err = this.getException();
-    err.params.type = `not ${err.params.type}`;
-    return err;
+    const err = this.getException()
+    err.params.type = `not ${err.params.type}`
+    return err
   }
 
   getFailedAssertion() {
-    return this.getException();
+    return this.getException()
   }
 }
+
+export default Assertion