assertron 7.1.2 → 9.0.1

package/src/assertron/throws.ts

@@ -1,7 +1,7 @@
-import AssertionError from 'assertion-error';
 import isPromise from 'is-promise';
-import { ErrorConstructor, ErrorValidator, notRejectedMessage, notThrownMessage, returnNotRejectedMessage, unexpectedErrorMessage } from '../errors';
-import { isErrorConstructor } from '../errors/util';
+import { AssertionError } from '../errors';
+import { ErrorConstructor, ErrorValidator } from '../types';
+import { isErrorConstructor, notRejectedMessage, notThrownMessage, unexpectedErrorMessage } from '../utils';
 
 export function throws<E extends Error>(value: PromiseLike<any>, error?: ErrorValidator | ErrorConstructor<E>): Promise<E>
 export function throws<E extends Error>(value: (...args: any[]) => never, error?: ErrorValidator | ErrorConstructor<E>): E
@@ -10,54 +10,38 @@ export function throws<T, R = any>(value: (...args: any[]) => R, validator?: Err
 export function throws(value: PromiseLike<any> | (() => any | PromiseLike<any>), validator?: ErrorValidator | ErrorConstructor<any>): any {
   if (typeof value !== 'function' && !isPromise(value)) {
     throw new AssertionError(
-      '`assertron.throws()` must be called with a functio n or promise.',
-      undefined,
-      throws
+      '`assertron.throws()` must be called with a function or promise.',
+      { ssf: throws }
     )
   }
 
-  if (isPromise(value)) {
-    return value.then(
-      value => {
-        throw new AssertionError(
-          notRejectedMessage(value),
-          { value },
-          throws)
-      },
-      err => {
-        validateError(validator, err)
-        return err
+  if (!isPromise(value)) {
+    const { threw, err, result } = tryCatch(value)
+    if (threw) {
+      if (failValidation(validator, err)) {
+        throw new AssertionError(unexpectedErrorMessage(err, validator), { ssf: throws })
       }
-    )
-  }
-  const { threw, err, result } = tryCatch(value)
-  if (threw) {
-    validateError(validator, err)
-    return err
+      return err
+    }
+    value = result;
   }
-  if (isPromise(result)) {
-    return result.then(
-      value => {
-        throw new AssertionError(
-          returnNotRejectedMessage(value),
-          { value },
-          throws)
-      },
+
+  if (isPromise(value)) {
+    return value.then(
+      value => { throw new AssertionError(notRejectedMessage(value), { ssf: throws }) },
       err => {
-        validateError(validator, err)
+        if (failValidation(validator, err)) {
+          throw new AssertionError(unexpectedErrorMessage(err, validator), { ssf: throws })
+        }
         return err
       }
     )
   }
 
-  throw new AssertionError(
-    notThrownMessage(result),
-    { value: result },
-    throws
-  )
+  throw new AssertionError(notThrownMessage(value), { ssf: throws })
 }
 
-function tryCatch(fn) {
+function tryCatch(fn: () => any) {
   let result
   let err
   let threw = false
@@ -70,22 +54,14 @@ function tryCatch(fn) {
   }
   return { threw, err, result }
 }
+function failValidation(validator: ErrorValidator | ErrorConstructor<any> | undefined, error: any): validator is ErrorValidator | ErrorConstructor<any> {
+  if (!validator) return false
 
-function validateError(validator, error) {
-  if (validator) {
-    if (isErrorConstructor(validator)) {
-      if (!(error instanceof validator))
-        throw new AssertionError(
-          unexpectedErrorMessage(error, validator),
-          { actual: error, expected: validator },
-          throws
-        )
-    }
-    else if (!validator(error))
-      throw new AssertionError(
-        unexpectedErrorMessage(error, validator),
-        { actual: error, expected: validator },
-        throws
-      )
+  if (isErrorConstructor(validator)) {
+    return !(error instanceof validator)
+  }
+  else {
+    return !validator(error)
   }
 }
+

package/src/assertron/truthy.spec.ts

@@ -1,6 +1,5 @@
-import AssertionError from 'assertion-error';
-import a from '..';
-import { assertThrows, noStackTraceFor } from '../testUtils';
+import a, { AssertionError } from '..'
+import { assertThrows, noStackTraceFor } from '../testUtils'
 
 test('falsy statement throws', () => {
   assertThrows(() => a.truthy(false), AssertionError)

package/src/assertron/truthy.ts

@@ -1,9 +1,8 @@
-import AssertionError from 'assertion-error';
+import { AssertionError } from '../errors';
 
 export function truthy(value: any) {
   if (!value) throw new AssertionError(
     `Expected value to be truthy, but received ${value}`,
-    { value },
-    truthy
+    { ssf: truthy }
   )
 }

package/src/errors.ts

@@ -0,0 +1,22 @@
+import { IsoError, ModuleError } from 'iso-error'
+import { RequiredPick } from 'type-plus'
+import { failOnOccurrence } from './utils'
+
+/**
+ * A base error for all assertion errors
+ */
+export class AssertionError extends ModuleError {
+  constructor(message: string, options: AssertionError.Options) {
+    super('assertron', message, options)
+  }
+}
+
+export namespace AssertionError {
+  export type Options = RequiredPick<IsoError.Options, 'ssf'>
+}
+
+export class FailOnOccurrence extends AssertionError {
+  constructor(public occurrence: number, public error: any, options: AssertionError.Options) {
+    super(failOnOccurrence(occurrence, error), options)
+  }
+}

package/src/index.ts

@@ -1,5 +1,6 @@
 import { assertron } from './assertron'
 
-export * from './assertron'
 export * from './assert-order'
+export * from './errors'
+export * from './assertron'
 export default assertron

package/src/testUtils.ts

@@ -1,11 +1,12 @@
 // istanbul ignore file
-import t from 'assert';
-import AssertionError from 'assertion-error';
-import isPromise from 'is-promise';
-import { isError } from 'lodash';
-import { ErrorConstructor } from './errors';
+import t from 'assert'
+import isPromise from 'is-promise'
+import { isError } from 'lodash'
+import { ErrorConstructor } from './types'
 
-export function runAsync(fn) {
+export type AnyFunction = (...args: any[]) => any
+
+export function runAsync(fn: AnyFunction) {
   return new Promise((resolve, reject) => {
     setTimeout(() => {
       try {
@@ -18,7 +19,7 @@ export function runAsync(fn) {
   })
 }
 
-export function runSequentialAsync(...fns) {
+export function runSequentialAsync(...fns: AnyFunction[]) {
   return new Promise((resolve, reject) => {
     setTimeout(() => {
       try {
@@ -35,7 +36,7 @@ export function runSequentialAsync(...fns) {
   })
 }
 
-export function runParallelAsync(...fns) {
+export function runParallelAsync(...fns: AnyFunction[]) {
   return Promise.all(fns.map(fn => runAsync(fn)))
 }
 
@@ -48,11 +49,11 @@ export function assertIsError(err: Error) {
   t(isError(err))
 }
 
-export function assertThrows<E extends Error>(fn, ErrorType?: ErrorConstructor<E>): E {
+export function assertThrows<E extends Error>(fn: AnyFunction, ErrorType?: ErrorConstructor<E>): E {
   try {
     fn()
   }
-  catch (e) {
+  catch (e: any) {
     if (ErrorType && !(e instanceof ErrorType)) {
       throw new Error(`thrown error ${e} is not of expected type ${ErrorType}`)
     }
@@ -61,21 +62,23 @@ export function assertThrows<E extends Error>(fn, ErrorType?: ErrorConstructor<E
   throw new Error(`${fn} does not throw as expected`)
 }
 
-export async function assertAsyncThrows<E extends Error>(fn, ErrorType?: ErrorConstructor<E>): Promise<E> {
+export async function assertAsyncThrows<E extends Error>(fn: AnyFunction, ErrorType?: ErrorConstructor<E>): Promise<E> {
   try {
     await fn()
   }
-  catch (e) {
+  catch (e: any) {
+    // console.log('catch clause', e)
     if (ErrorType && !(e instanceof ErrorType)) {
       throw new Error(`thrown error ${e} is not of expected type ${ErrorType}`)
     }
+    // console.log('returning e')
     return e
   }
   throw new Error(`${fn} does not throw as expected`)
 }
 
 
-export function noStackTraceFor(filename: string, err: AssertionError) {
+export function noStackTraceFor(filename: string, err: Error) {
   if (err.stack && RegExp(filename).test(err.stack))
     throw new Error(`contains internal stack: \n${err.stack}`)
 }

package/src/{errors/interfaces.ts → types.ts}

@@ -1,3 +1,3 @@
 
-export type ErrorValidator = (value) => boolean
+export type ErrorValidator = (value: any) => boolean
 export type ErrorConstructor<E extends Error> = new (...args: any[]) => E

package/src/utils/index.ts

@@ -0,0 +1,12 @@
+import { tersify } from 'tersify';
+
+export * from './isErrorConstructor';
+export * from './notEqualMessage';
+export * from './notSatisfiedMessage';
+export * from './notThrownMessage';
+export * from './promiseMessages';
+export * from './unexpectedErrorMessage';
+
+export function failOnOccurrence(occurrence: number, error: any) {
+  return `Failed on ${occurrence} occurrence: ${tersify(error, { maxLength: Infinity })}`
+}

package/src/utils/isErrorConstructor.ts

@@ -0,0 +1,5 @@
+import { ErrorConstructor } from '../types'
+
+export function isErrorConstructor(validator: any): validator is ErrorConstructor<any> {
+  return Object.prototype.isPrototypeOf.call(Error.prototype, validator.prototype)
+}

package/src/utils/notEqualMessage.ts

@@ -0,0 +1,4 @@
+
+export function notEqualMessage(actual: any, expected: any) {
+  return `Expected value to equal ${expected}, but received ${actual}`
+}

package/src/{errors/NotSatisfied.ts → utils/notSatisfiedMessage.ts}

@@ -22,6 +22,6 @@ function isIndice(node: string | number): node is number {
   return typeof node === 'number'
 }
 
-function formatValue(value) {
+function formatValue(value: any) {
   return tersify(value)
 }

package/src/utils/notThrownMessage.ts

@@ -0,0 +1,5 @@
+import { tersify } from 'tersify'
+
+export function notThrownMessage(value: any) {
+  return `Expect function to throw, but it returned '${tersify(value)}' instead.`
+}

package/src/utils/promiseMessages.ts

@@ -0,0 +1,12 @@
+import { tersify } from 'tersify'
+
+export function notRejectedMessage(value: any) {
+  return `Expected promise to reject, but it resolves with ` + (typeof value === 'string'
+    ? `'${value}'` : tersify(value, { maxLength: Infinity }))
+}
+
+export function notResolvedMessage(error: any) {
+  return `Expected promise to resolve, but it rejects with ` + (typeof error === 'string'
+    ? `'${error}'` : error instanceof Error ? error : tersify(error, { maxLength: Infinity }))
+}
+

package/src/{errors → utils}/unexpectedErrorMessage.ts

@@ -1,7 +1,8 @@
 import { tersify } from 'tersify';
-import { ErrorConstructor, ErrorValidator } from '.';
-import { isErrorConstructor } from './util';
+import { ErrorConstructor, ErrorValidator } from '../types';
+import { isErrorConstructor } from './isErrorConstructor';
 
 export function unexpectedErrorMessage(actual: any, expected: ErrorValidator | ErrorConstructor<any>) {
-  return `Unexpected error. Expecting '${isErrorConstructor(expected) ? expected.name : tersify(expected)}' but received ${tersify(actual)}`
+  return `Unexpected error. Expecting '${isErrorConstructor(expected) ?
+    expected.name : tersify(expected)}' but received ${tersify(actual)}`
 }

package/dist-es2015/assert-order/AssertOrder.d.ts

@@ -1,40 +0,0 @@
-export declare class AssertOrder {
-    /**
-     * Gets the current expecting step.
-     */
-    readonly currentStep: number;
-    private state;
-    constructor(plan?: number);
-    /**
-     * Asserts the current step is `step`.
-     * @param step expected step.
-     */
-    is(step: number): void;
-    /**
-     * Asserts the current step is not `step`.
-     * @param step not expected step.
-     */
-    not(step: number): void;
-    /**
-     * Reset to specified step.
-     */
-    jump(step: number): void;
-    /**
-     * Move to next step.
-     */
-    move(): void;
-    /**
-     * Asserts the specified step will run once.
-     */
-    once(step: number): void;
-    on(step: number, assert: (step: number) => void): void;
-    atLeastOnce(step: number): number;
-    any(steps: number[]): number;
-    onAny(steps: number[], ...asserts: Function[]): void;
-    end(timeout: number): Promise<number>;
-    end(): number;
-    exactly(step: number, times: number): number;
-    wait(step: number): Promise<void>;
-    wait(step: number, callback: () => void): void;
-    private assert;
-}

package/dist-es2015/assert-order/AssertOrder.js

@@ -1,132 +0,0 @@
-import { InvalidOrder } from './InvalidOrder';
-import { StateMachine } from './StateMachine';
-// order.atLeast(step, count) // expected to be executed at least `count` times
-// order.atMost(step, count) // exected to be executed at most `count` times
-export class AssertOrder {
-    /**
-     * Gets the current expecting step.
-     */
-    get currentStep() {
-        return this.state.step;
-    }
-    constructor(plan) {
-        this.state = new StateMachine(plan);
-    }
-    /**
-     * Asserts the current step is `step`.
-     * @param step expected step.
-     */
-    is(step) {
-        this.assert('is', step);
-    }
-    /**
-     * Asserts the current step is not `step`.
-     * @param step not expected step.
-     */
-    not(step) {
-        if (this.state.isValid(step)) {
-            throw new InvalidOrder(this.state.get(), 'not', this.not, step);
-        }
-    }
-    /**
-     * Reset to specified step.
-     */
-    jump(step) {
-        this.state.jump(step);
-    }
-    /**
-     * Move to next step.
-     */
-    move() {
-        this.state.move();
-    }
-    /**
-     * Asserts the specified step will run once.
-     */
-    once(step) {
-        this.assert('once', step);
-        this.state.move();
-    }
-    on(step, assert) {
-        this.state.on(step, () => {
-            assert(step);
-        });
-    }
-    atLeastOnce(step) {
-        const nextStep = step + 1;
-        if (this.state.step === step) {
-            this.state.move();
-            return this.state.moveSubStep();
-        }
-        else if (this.state.step === nextStep && this.state.subStep > 0) {
-            return this.state.moveSubStep();
-        }
-        else
-            throw new InvalidOrder(this.state.get(), 'atLeastOnce', this.atLeastOnce, step);
-    }
-    any(steps) {
-        const index = steps.indexOf(this.state.step);
-        if (index === -1)
-            throw new InvalidOrder(this.state.get(), 'any', this.any, steps);
-        this.state.move();
-        return steps[index];
-    }
-    onAny(steps, ...asserts) {
-        steps.forEach(step => {
-            this.state.on(step, () => {
-                let firstError;
-                let hasPass = false;
-                asserts.forEach(assert => {
-                    try {
-                        assert(step);
-                        hasPass = true;
-                    }
-                    catch (err) {
-                        if (!firstError)
-                            firstError = err;
-                    }
-                });
-                if (!hasPass)
-                    throw firstError;
-            });
-        });
-        return;
-    }
-    end(timeout) {
-        if (timeout) {
-            return new Promise(r => {
-                setTimeout(r, timeout);
-            }).then(() => {
-                return this.end();
-            });
-        }
-        if (!this.state.isMaxStepDefined()) {
-            this.state.stopAccepting();
-            return this.state.getTimeTaken();
-        }
-        if (this.state.isAccepting()) {
-            throw new InvalidOrder(this.state.get(), 'end', this.end);
-        }
-    }
-    exactly(step, times) {
-        if (this.state.isNotValid(step))
-            throw new InvalidOrder(this.state.get(), 'exactly', this.exactly, step, times);
-        if (this.state.maxSubStep === undefined) {
-            this.state.maxSubStep = times;
-            this.state.minSubStep = times;
-        }
-        return this.state.moveSubStep();
-    }
-    wait(step, callback) {
-        if (callback)
-            this.on(step, callback);
-        else
-            return new Promise(a => { this.on(step, a); });
-    }
-    assert(method, step) {
-        if (this.state.isNotValid(step)) {
-            throw new InvalidOrder(this.state.get(), method, this[method], step);
-        }
-    }
-}
-//# sourceMappingURL=AssertOrder.js.map

package/dist-es2015/assert-order/AssertOrder.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"AssertOrder.js","sourceRoot":"","sources":["../../src/assert-order/AssertOrder.ts"],"names":[],"mappings":"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"}

package/dist-es2015/assert-order/InvalidOrder.d.ts

@@ -1,8 +0,0 @@
-import AssertionError from 'assertion-error';
-import { State } from './interfaces';
-export declare class InvalidOrder extends AssertionError {
-    method: string;
-    args: any[];
-    state: State;
-    constructor(state: State, method: string, ssf: Function, ...args: any[]);
-}

package/dist-es2015/assert-order/InvalidOrder.js

@@ -1,31 +0,0 @@
-import AssertionError from 'assertion-error';
-export class InvalidOrder extends AssertionError {
-    constructor(state, method, ssf, ...args) {
-        const message = method === 'end' ? getEndMessage(state) : getExpectingMessage(state, method, args);
-        super(message, { method, state, args }, ssf);
-    }
-}
-function getEndMessage(state) {
-    return `Planned for ${state.maxStep} step but expecting step ${state.step} when 'end()' is called`;
-}
-function getExpectingMessage(state, method, args) {
-    return `Expecting ${getExpectingCalls(state)}, but received '${method}(${getMethodArgs(args)})'`;
-}
-function getExpectingCalls(state) {
-    let message;
-    if (state.subStep === 0) {
-        const methods = ['is', 'once', 'any'];
-        message = methods.map(m => ['any'].indexOf(m) === -1 ?
-            `'${m}(${state.step})'` :
-            `'${m}([${state.step}])'`).join(', ');
-    }
-    else {
-        const methods = ['exactly'];
-        message = methods.map(m => `'${m}(${state.step}, ${state.maxSubStep})'`).join(', ');
-    }
-    return message;
-}
-function getMethodArgs(args) {
-    return args.map(a => Array.isArray(a) ? `[${a.join(', ')}]` : a).join(', ');
-}
-//# sourceMappingURL=InvalidOrder.js.map

package/dist-es2015/assert-order/InvalidOrder.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"InvalidOrder.js","sourceRoot":"","sources":["../../src/assert-order/InvalidOrder.ts"],"names":[],"mappings":"AAAA,OAAO,cAAc,MAAM,iBAAiB,CAAC;AAG7C,MAAM,OAAO,YAAa,SAAQ,cAAc;IAI9C,YAAY,KAAY,EAAE,MAAc,EAAE,GAAa,EAAE,GAAG,IAAW;QACrE,MAAM,OAAO,GAAG,MAAM,KAAK,KAAK,CAAC,CAAC,CAAC,aAAa,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,mBAAmB,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,CAAC,CAAA;QAClG,KAAK,CAAC,OAAO,EAAE,EAAE,MAAM,EAAE,KAAK,EAAE,IAAI,EAAE,EAAE,GAAG,CAAC,CAAA;IAC9C,CAAC;CACF;AAED,SAAS,aAAa,CAAC,KAAY;IACjC,OAAO,eAAe,KAAK,CAAC,OAAO,4BAA4B,KAAK,CAAC,IAAI,yBAAyB,CAAA;AACpG,CAAC;AAED,SAAS,mBAAmB,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI;IAC9C,OAAO,aAAa,iBAAiB,CAAC,KAAK,CAAC,mBAAmB,MAAM,IAAI,aAAa,CAAC,IAAI,CAAC,IAAI,CAAA;AAClG,CAAC;AAED,SAAS,iBAAiB,CAAC,KAAY;IACrC,IAAI,OAAe,CAAA;IACnB,IAAI,KAAK,CAAC,OAAO,KAAK,CAAC,EAAE;QACvB,MAAM,OAAO,GAAG,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,CAAC,CAAA;QACrC,OAAO,GAAG,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;YACpD,IAAI,CAAC,IAAI,KAAK,CAAC,IAAI,IAAI,CAAC,CAAC;YACzB,IAAI,CAAC,KAAK,KAAK,CAAC,IAAI,KAAK,CAC1B,CAAC,IAAI,CAAC,IAAI,CAAC,CAAA;KACb;SACI;QACH,MAAM,OAAO,GAAG,CAAC,SAAS,CAAC,CAAA;QAC3B,OAAO,GAAG,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,IAAI,KAAK,CAAC,IAAI,KAAK,KAAK,CAAC,UAAU,IAAI,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAA;KACpF;IACD,OAAO,OAAO,CAAA;AAChB,CAAC;AAED,SAAS,aAAa,CAAC,IAAW;IAChC,OAAO,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAA;AAC7E,CAAC"}

package/dist-es2015/assert-order/StateMachine.d.ts

@@ -1,23 +0,0 @@
-import { State } from './interfaces';
-export declare class StateMachine {
-    listeners: {};
-    step: number;
-    maxStep?: number;
-    subStep: number;
-    minSubStep?: number;
-    maxSubStep?: number;
-    private startTick;
-    constructor(maxStep?: number);
-    jump(step: number): number;
-    move(): number;
-    moveSubStep(): number;
-    get(): State;
-    on(step: number, listener: any): void;
-    isNotValid(step: number): boolean;
-    isValid(step: number): boolean;
-    isMaxStepDefined(): boolean;
-    stopAccepting(): void;
-    isAccepting(): boolean;
-    getTimeTaken(): any;
-    private getStartTick;
-}