assertron 7.1.3 → 9.0.2

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 FailOnOccurance(i, e) }
+        (e) => { throw new FailOnOccurrence(i, e, { ssf: repeat }) }
       ) as any
     }
     else {
@@ -25,13 +25,8 @@ function repeatRecur<R>(fn: () => R | (() => Promise<R>), i: number, times: numb
     }
   }
   catch (e) {
-    if (e instanceof FailOnOccurance) throw e
-    throw new FailOnOccurance(i, e)
+    if (e instanceof FailOnOccurrence) throw e
+    throw new FailOnOccurrence(i, e, { ssf: repeat })
   }
 }
 
-export class FailOnOccurance extends AssertionError {
-  constructor(public occurance: number, public error: any) {
-    super(`Failed on ${occurance} occurance`)
-  }
-}

package/src/assertron/resolves.spec.ts

@@ -1,7 +1,6 @@
-import t from 'assert';
-import a from '..';
-import AssertionError from 'assertion-error';
-import { assertAsyncThrows, noStackTraceFor } from '../testUtils';
+import t from 'assert'
+import a, { AssertionError } from '..'
+import { assertAsyncThrows, noStackTraceFor } from '../testUtils'
 
 
 test('pass on resolved promise', async () => {

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 { 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'`)
+// import { every } from 'satisfier'
+import { isType } from 'type-plus'
+import a, { AssertionError } from '..'
+import { assertThrows, noStackTraceFor } from '../testUtils'
+
+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,18 +1,31 @@
-import AssertionError from 'assertion-error';
-import { createSatisfier } from 'satisfier';
-import { notSatisfiedMessage } from '../errors';
+import { createSatisfier } from 'satisfier'
+import { If, IsExtend, NonComposableTypes } from 'type-plus'
+import { AssertionError } from '../errors'
+import { notSatisfiedMessage } from '../utils'
+
+export type SatisfyExpectation<T> = If<
+  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`.
  * @param expected All properties can be a value which will be compared to the same property in `actual`, RegExp, or a predicate function that will be used to check against the property.
  */
-export function satisfies<Actual extends any>(actual: Actual, expected: any) {
-  const diff = createSatisfier(expected).exec(actual);
+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 { assertAsyncThrows, assertIsError, assertIsPromise, assertThrows, noStackTraceFor } from '../testUtils';
+import t from 'assert'
+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,12 +96,15 @@ 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 }>>(() => a.throws(() => Promise.resolve('ok')), AssertionError)
-  t.strictEqual(err.value, 'ok')
+  await assertAsyncThrows(
+    () => a.throws(() => Promise.resolve('ok')),
+    AssertionError)
 })
 
 test('thrown error does not contain internal stack trace if function returns 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)
 })
 
@@ -114,12 +119,18 @@ 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
@@ -10,51 +10,35 @@ 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: () => any) {
@@ -70,22 +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))
-      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/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/{errors/util.ts → utils/isErrorConstructor.ts}

@@ -1,4 +1,4 @@
-import { ErrorConstructor } from './interfaces'
+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/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 }))
+}
+