assertron 8.0.0 → 9.0.0

package/src/assert-order/index.ts

@@ -1,2 +1,4 @@
 export * from './AssertOrder'
-export * from './interfaces'
+export * from './InvalidOrder'
+export * from './types'
+

package/src/assertron/assertron.spec.ts

@@ -1,5 +1,4 @@
-import AssertionError from 'assertion-error'
-import a from '..'
+import a, { AssertionError } from '..'
 import { assertThrows, noStackTraceFor } from '../testUtils'
 
 describe('false()', () => {

package/src/assertron/assertron.ts

@@ -1,4 +1,5 @@
-import AssertionError from 'assertion-error'
+import { AssertionError } from '../errors'
+import { notEqualMessage } from '../utils'
 import { falsy } from './falsy'
 import { pathEqual } from './pathEqual'
 import { rejects } from './rejects'
@@ -11,10 +12,7 @@ import { truthy } from './truthy'
 export const assertron = {
   false(value: any) {
     if (value !== false)
-      throw new AssertionError(
-        `Expected value to equal false, but received ${value}`,
-        { value },
-        assertron.false)
+      throw new AssertionError(notEqualMessage(value, false), { ssf: assertron.false })
   },
   falsy,
   pathEqual,
@@ -24,7 +22,8 @@ export const assertron = {
   satisfies,
   throws,
   true(value: any) {
-    if (value !== true) throw new AssertionError(`Expected value to equal true, but received ${value}`, { value }, assertron.true)
+    if (value !== true)
+      throw new AssertionError(notEqualMessage(value, true), { ssf: assertron.true })
   },
   truthy
 }

package/src/assertron/falsy.spec.ts

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

package/src/assertron/falsy.ts

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

package/src/assertron/pathEqual.spec.ts

@@ -1,5 +1,4 @@
-import AssertionError from 'assertion-error'
-import assertron from '..'
+import assertron, { AssertionError } from '..'
 import { assertThrows, noStackTraceFor } from '../testUtils'
 
 test('path with same style passes', () => {

package/src/assertron/pathEqual.ts

@@ -1,11 +1,8 @@
-import AssertionError from 'assertion-error'
 import { pathEqual as isPathEqual } from 'path-equal'
-import { notEqualMessage } from '../errors'
+import { AssertionError } from '../errors'
+import { notEqualMessage } from '../utils'
 
 export function pathEqual(actual: string, expected: string) {
   if (!isPathEqual(actual, expected))
-    throw new AssertionError(
-      notEqualMessage(actual, expected),
-      { actual, expected },
-      pathEqual)
+    throw new AssertionError(notEqualMessage(actual, expected), { ssf: pathEqual })
 }

package/src/assertron/rejects.spec.ts

@@ -1,5 +1,4 @@
 import t from 'assert'
-import AssertionError from 'assertion-error'
 import a from '..'
 import { assertAsyncThrows, noStackTraceFor } from '../testUtils'
 
@@ -28,6 +27,6 @@ test('throws on resolved object promise', async () => {
 })
 
 test('does not contain internal stack trace', async () => {
-  const err = await assertAsyncThrows(() => a.rejects(Promise.resolve({ a: 1 })), AssertionError)
+  const err = await assertAsyncThrows(() => a.rejects(Promise.resolve({ a: 1 })))
   noStackTraceFor('rejects.ts', err)
 })

package/src/assertron/rejects.ts

@@ -1,15 +1,9 @@
-import { tersify } from 'tersify'
-import AssertionError from 'assertion-error'
+import { AssertionError } from '../errors'
+import { notRejectedMessage } from '../utils'
 
 export function rejects(promise: Promise<any>) {
   return promise.then(
-    value => {
-      throw new AssertionError(
-        `Expected promise to reject, but it resolves with ${typeof value === 'string' ?
-          `'${value}'` : tersify(value, { maxLength: Infinity })}`,
-        { value },
-        rejects)
-    },
+    value => { throw new AssertionError(notRejectedMessage(value), { ssf: rejects }) },
     () => { }
   )
 }

package/src/assertron/repeat.spec.ts

@@ -1,5 +1,4 @@
-import a from '..'
-import { FailOnOccurrence } from './repeat'
+import a, { FailOnOccurrence } from '..'
 
 test('repeat function n times', () => {
   let count = 0
@@ -26,8 +25,7 @@ test('repeat async function n times sequentially', async () => {
 test('error is captured as inner error and indicate which call failed', () => {
   let count = 0
   const err = a.throws(() => a.repeat(() => {
-    ++count
-    if (count === 5) throw new Error('failed')
+    if (++count === 5) throw new Error('failed')
   }, 10), FailOnOccurrence)
 
   expect(err.occurrence).toBe(5)

package/src/assertron/repeat.ts

@@ -1,5 +1,5 @@
 import isPromise from 'is-promise';
-import AssertionError from 'assertion-error'
+import { FailOnOccurrence } from '../errors';
 
 /**
  * Repeat the specified function n times and return the last result.
@@ -17,7 +17,7 @@ function repeatRecur<R>(fn: () => R | (() => Promise<R>), i: number, times: numb
     if (isPromise(result)) {
       return result.then(
         () => repeatRecur(fn, i + 1, times),
-        (e) => { throw new FailOnOccurrence(i, e) }
+        (e) => { throw new FailOnOccurrence(i, e, { ssf: repeat }) }
       ) as any
     }
     else {
@@ -26,12 +26,7 @@ function repeatRecur<R>(fn: () => R | (() => Promise<R>), i: number, times: numb
   }
   catch (e) {
     if (e instanceof FailOnOccurrence) throw e
-    throw new FailOnOccurrence(i, e)
+    throw new FailOnOccurrence(i, e, { ssf: repeat })
   }
 }
 
-export class FailOnOccurrence extends AssertionError<{ occurrence: number }> {
-  constructor(public occurrence: number, public error: any) {
-    super(`Failed on ${occurrence} occurrence`)
-  }
-}

package/src/assertron/resolves.spec.ts

@@ -1,6 +1,5 @@
 import t from 'assert'
-import a from '..'
-import AssertionError from 'assertion-error'
+import a, { AssertionError } from '..'
 import { assertAsyncThrows, noStackTraceFor } from '../testUtils'
 
 

package/src/assertron/resolves.ts

@@ -1,16 +1,9 @@
-import { tersify } from 'tersify'
-import AssertionError from 'assertion-error'
+import { AssertionError } from '../errors'
+import { notResolvedMessage } from '../utils'
 
 export function resolves(promise: Promise<any>) {
   return promise.then(
     () => { },
-    error => {
-      throw new AssertionError(`Expected promise to resolve, but it rejects with ${typeof error === 'string' ?
-        `'${error}'` :
-        error instanceof Error ?
-          error :
-          tersify(error, { maxLength: Infinity })}`, { error }, resolves
-      )
-    }
+    error => { throw new AssertionError(notResolvedMessage(error), { ssf: resolves }) }
   )
 }

package/src/assertron/satisfies.spec.ts

@@ -1,20 +1,34 @@
-import AssertionError from 'assertion-error'
-import { every } from 'satisfier'
-import a from '..'
+// import { every } from 'satisfier'
+import { isType } from 'type-plus'
+import a, { AssertionError } from '..'
 import { assertThrows, noStackTraceFor } from '../testUtils'
 
-test('primitive types will pass', () => {
-  a.satisfies(1, 1)
-  a.satisfies('a', 'a')
-  a.satisfies(true, true)
-})
-
-test('primitive types shows value directly in error', () => {
-  a.throws(() => a.satisfies<number>(1, 2), e => e.message === 'Expect actual to satisfy 2, but received 1')
-
-  a.throws(() => a.satisfies<boolean>(true, false), e => e.message === 'Expect actual to satisfy false, but received true')
-
-  a.throws(() => a.satisfies<string>('a', 'b'), e => e.message === `Expect actual to satisfy 'b', but received 'a'`)
+describe('non-composable types', () => {
+  test('accept same type', () => {
+    a.satisfies(null, null)
+    a.satisfies(undefined, undefined)
+    a.satisfies(1, 1)
+    a.satisfies('a', 'a')
+    a.satisfies(true, true)
+  })
+
+  test('predicate parameter is the widen type', () => {
+    a.satisfies(null, (v) => isType<null>(v))
+    a.satisfies(undefined, (v) => isType<undefined>(v))
+    a.satisfies(1, (v) => isType<number>(v))
+    a.satisfies('a', (v) => isType<string>(v))
+    a.satisfies(true, (v) => isType<boolean>(v))
+  })
+
+  test('shows value directly in error', () => {
+    a.throws(() => a.satisfies(1, 2), e => e.message === 'Expect actual to satisfy 2, but received 1')
+    a.throws(() => a.satisfies(true, false), e => e.message === 'Expect actual to satisfy false, but received true')
+    a.throws(() => a.satisfies('a', 'b'), e => e.message === `Expect actual to satisfy 'b', but received 'a'`)
+  })
+
+  test('use regex to check against string', () => {
+    a.satisfies('abc', /a/)
+  })
 })
 
 test('empty object will pass any object', () => {
@@ -26,10 +40,10 @@ test('empty object will fail against primitive types', () => {
   a.throws(() => a.satisfies(1, {} as any), e => e.message === 'Expect actual to satisfy {}, but received 1')
 })
 
-test(`can use satisfier util function such as has()/every()`, () => {
-  a.satisfies([1], every(1))
-  a.throws(() => a.satisfies([1, 2], every(1)), e => e.message === 'Expect actual[1] to satisfy 1, but received 2')
-})
+// test(`can use satisfier util function such as has()/every()`, () => {
+//   a.satisfies([1], every(1))
+//   a.throws(() => a.satisfies([1, 2], every(1)), e => e.message === 'Expect actual[1] to satisfy 1, but received 2')
+// })
 
 test(`array entries are checked`, () => {
   a.throws(() => a.satisfies([1], [2]), e => e.message === `Expect actual[0] to satisfy 2, but received 1`)
@@ -109,3 +123,21 @@ test('does not contain internal stack trace', async () => {
   const err = assertThrows(() => a.satisfies({ a: 1 }, { a: 2 }), AssertionError)
   noStackTraceFor('satisfies.ts', err)
 })
+
+test('allow partial expectation on array entries', () => {
+  type U = { type: 'a', a: string } | { type: 'b', b: string }
+  const x: U[] = [{ type: 'a', a: 'abc' }]
+  a.satisfies(x, [{ type: 'a' }])
+})
+
+test('allow predicate on array', () => {
+  type U = { type: 'a', a: string } | { type: 'b', b: string }
+  const x: U[] = [{ type: 'a', a: 'abc' }]
+  a.satisfies(x, (v) => v[0].type == 'a')
+})
+
+test('allow predicate on array entries', () => {
+  type U = { type: 'a', a: string } | { type: 'b', b: string }
+  const x: U[] = [{ type: 'a', a: 'abc' }]
+  a.satisfies(x, [(v) => v.type == 'a'])
+})

package/src/assertron/satisfies.ts

@@ -1,16 +1,23 @@
-import AssertionError from 'assertion-error'
 import { createSatisfier } from 'satisfier'
-import { And, If, PrimitiveTypes, IsExtend } from 'type-plus'
-import { notSatisfiedMessage } from '../errors'
+import { If, IsExtend, NonComposableTypes } from 'type-plus'
+import { AssertionError } from '../errors'
+import { notSatisfiedMessage } from '../utils'
 
 export type SatisfyExpectation<T> = If<
-  And<IsExtend<T, PrimitiveTypes>, IsExtend<T, Array<any>>>,
-  T | ((v: T) => boolean),
-  {
-    [P in keyof T]?: T[P] extends string
-    ? SatisfyExpectation<T[P]> | ((v: T[P]) => boolean) | RegExp
-    : SatisfyExpectation<T[P]> | ((v: T[P]) => boolean)
-  }>
+  IsExtend<T, string>,
+  T | RegExp,
+  If<
+    IsExtend<T, NonComposableTypes>,
+    T,
+    If<IsExtend<T, Array<any>>,
+      T extends Array<infer E> ? Array<SatisfyExpectation<E>> : never,
+      {
+        [P in keyof T]?: T[P] extends string
+        ? SatisfyExpectation<T[P]> | RegExp
+        : SatisfyExpectation<T[P]>
+      }
+    >>
+> | ((v: T) => boolean)
 
 /**
  * Check if `actual` satisfies criteria in `expected`.
@@ -19,10 +26,6 @@ export type SatisfyExpectation<T> = If<
 export function satisfies<Actual>(actual: Actual, expected: SatisfyExpectation<Actual>) {
   const diff = createSatisfier(expected as any).exec(actual);
   if (diff) {
-    throw new AssertionError(
-      notSatisfiedMessage(diff),
-      { diff },
-      satisfies
-    )
+    throw new AssertionError(notSatisfiedMessage(diff), { ssf: satisfies })
   }
 }

package/src/assertron/throws.spec.ts

@@ -1,59 +1,61 @@
 import t from 'assert'
-import AssertionError from 'assertion-error'
-import a from '..'
+import a, { AssertionError } from '..'
 import { assertAsyncThrows, assertIsError, assertIsPromise, assertThrows, noStackTraceFor } from '../testUtils'
 
-test('when value is PromiseLike returns Promise', async () => {
-  let actual = a.throws(Promise.reject(new Error()), Error)
+test('when value is PromiseLike returns a promise with the rejected value', async () => {
+  let actual = a.throws(Promise.reject(new Error('Miku')), Error)
   assertIsPromise(actual)
+  t.equal((await actual).message, 'Miku')
 
-  actual = a.throws(Promise.reject(new Error()), () => true)
+  actual = a.throws(Promise.reject(new Error('Ren')), () => true)
   assertIsPromise(actual)
+  t.equal((await actual).message, 'Ren')
 
-  actual = a.throws(Promise.reject(new Error()))
+  actual = a.throws(Promise.reject(new Error('Luka')))
   assertIsPromise(actual)
+  t.equal((await actual).message, 'Luka')
 })
 
-test('when value is function returning promise, will return promise', () => {
-  let actual = a.throws(() => Promise.reject(new Error()), Error)
+test('when value is function returning a promise, will return a promise with the rejected value', async () => {
+  let actual = a.throws(() => Promise.reject(new Error('Miku')), Error)
   assertIsPromise(actual)
+  t.equal((await actual).message, 'Miku')
 
-  actual = a.throws(() => Promise.reject(new Error()), () => true)
+  actual = a.throws(() => Promise.reject(new Error('Luka')), () => true)
   assertIsPromise(actual)
+  t.equal((await actual).message, 'Luka')
 
-  actual = a.throws(() => Promise.reject())
+  actual = a.throws(() => Promise.reject('Ren'))
   assertIsPromise(actual)
+  t.equal((await actual), 'Ren')
 })
 
 test('when value is function returns error', () => {
-  let actual = a.throws((() => { throw new Error() }) as () => void, Error)
+  let actual = a.throws((() => { throw new Error() }), Error)
   assertIsError(actual)
 
-  actual = a.throws((() => { throw new Error() }) as () => void)
+  actual = a.throws((() => { throw new Error() }))
   assertIsError(actual)
 })
 
-test('throws InvalidUsage if input is not a function or promise', () => {
+test('throws if input is not a function or promise', () => {
   assertThrows(() => a.throws(0 as any))
   assertThrows(() => a.throws(true as any))
   assertThrows(() => a.throws('...' as any))
   assertThrows(() => a.throws(/foo/ as any))
 })
 
-test('throws for resolved promise', async () => {
-  const actual = await assertAsyncThrows<AssertionError<{ value: string }>>(() => a.throws(Promise.resolve('ok')), AssertionError)
-  t.strictEqual(actual.value, 'ok')
+test('throws for resolved promise', () => {
+  return assertAsyncThrows(() => a.throws(Promise.resolve('ok')), AssertionError)
 })
 
 test('throws error does not contain internal stack trace for resolved promise', async () => {
-  const err = await assertAsyncThrows<AssertionError<{ value: string }>>(() => a.throws(Promise.resolve('ok')), AssertionError)
+  const err = await assertAsyncThrows(() => a.throws(Promise.resolve('ok')), AssertionError)
   noStackTraceFor('throws.ts', err)
 })
 
 test('passes with rejected promise', async () => {
-  const actual = await a.throws<string>(() => new Promise((_, r) => {
-    setImmediate(() => r('no'))
-  }))
+  const actual = await a.throws<string>(() => new Promise((_, r) => setImmediate(() => r('no'))))
   t.strictEqual(actual, 'no')
 })
 
@@ -62,13 +64,14 @@ test('passes with rejected promise passing validator', () => {
 })
 
 test('throws with rejected promise failing validator', async () => {
-  const err = await assertAsyncThrows<AssertionError<{ actual: string }>>(() => a.throws(Promise.reject('no'), err => err !== 'no'))
-
-  t.strictEqual(err.actual, 'no')
+  await assertAsyncThrows(
+    () => a.throws(Promise.reject('no'), err => err !== 'no'),
+    AssertionError)
 })
 
 test('thrown error does not contain internal stack trace with rejected promise failing validator', async () => {
-  const err = await assertAsyncThrows<AssertionError<{ actual: string }>>(() => a.throws(Promise.reject('no'), err => err !== 'no'))
+  const err = await assertAsyncThrows(() => a.throws(Promise.reject('no'), err => err !== 'no'), AssertionError)
+  // Error.captureStackTrace(err, a.throws)
 
   noStackTraceFor('throws.ts', err)
 })
@@ -78,15 +81,14 @@ test('passes with throwing function', () => {
 })
 
 test('throws if function does not', () => {
-  const err = assertThrows<AssertionError<{ value: string }>>(
+  assertThrows(
     () => a.throws(() => { return 'foo' }, AssertionError),
     AssertionError
   )
-  t.strictEqual(err.value, 'foo')
 })
 
 test('thrown error does not contain internal stack track if function does not', () => {
-  const err = assertThrows<AssertionError<{ value: string }>>(
+  const err = assertThrows(
     () => a.throws(() => { return 'foo' }, AssertionError),
     AssertionError
   )
@@ -94,14 +96,13 @@ test('thrown error does not contain internal stack track if function does not',
 })
 
 test('throws if function returns resolved promise', async () => {
-  const err = await assertAsyncThrows<AssertionError<{ value: string }>>(
+  await assertAsyncThrows(
     () => a.throws(() => Promise.resolve('ok')),
     AssertionError)
-  t.strictEqual(err.value, 'ok')
 })
 
 test('thrown error does not contain internal stack trace if function returns resolved promise', async () => {
-  const err = await assertAsyncThrows<AssertionError<{ value: string }>>(
+  const err = await assertAsyncThrows(
     () => a.throws(() => Promise.resolve('ok')),
     AssertionError)
   noStackTraceFor('throws.ts', err)
@@ -118,14 +119,17 @@ test('pass if function returns rejected promise passing valdation', () => {
 })
 
 test('throws if function returns rejected promise not passing valdation', async () => {
-  const err = await assertAsyncThrows<AssertionError<{ actual: any }>>(() => a.throws(() => Promise.reject('ok'), err => err !== 'ok'))
-  t.strictEqual(err.actual, 'ok')
+  await assertAsyncThrows(
+    () => a.throws(() => Promise.reject('ok'), err => err !== 'ok'),
+    AssertionError
+  )
 })
 
 test('thrown error does not contain stack trace if function returns rejected promise not passing valdation', async () => {
-  const err = await assertAsyncThrows<
-    AssertionError<{ actual: any }>
-  >(() => a.throws(() => Promise.reject('ok'), err => err !== 'ok'))
+  const err = await assertAsyncThrows(
+    () => a.throws(() => Promise.reject('ok'), err => err !== 'ok'),
+    AssertionError
+  )
   // console.log('got err', err)
   noStackTraceFor('throws.ts', err)
 })

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
@@ -11,50 +11,34 @@ export function throws(value: PromiseLike<any> | (() => any | PromiseLike<any>),
   if (typeof value !== 'function' && !isPromise(value)) {
     throw new AssertionError(
       '`assertron.throws()` must be called with a function or promise.',
-      undefined,
-      throws
+      { 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: () => any) {
@@ -70,24 +54,14 @@ function tryCatch(fn: () => any) {
   }
   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: ErrorValidator | ErrorConstructor<any> | undefined, error: any) {
-  if (validator) {
-    if (isErrorConstructor(validator)) {
-      if (!(error instanceof validator))
-        throw new AssertionError(
-          unexpectedErrorMessage(error, validator),
-          { actual: error, expected: validator },
-          throws
-        )
-    }
-    else if (!validator(error)) {
-      // console.log('msg:', unexpectedErrorMessage(error, validator))
-      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,5 +1,4 @@
-import AssertionError from 'assertion-error'
-import a from '..'
+import a, { AssertionError } from '..'
 import { assertThrows, noStackTraceFor } from '../testUtils'
 
 test('falsy statement throws', () => {

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)
+  }
+}