assertron 7.1.2 → 9.0.1

package/src/assertron/assertron.ts

@@ -1,20 +1,18 @@
-import AssertionError from 'assertion-error';
-import { falsy } from './falsy';
-import { pathEqual } from './pathEqual';
-import { rejects } from './rejects';
-import { repeat } from './repeat';
-import { resolves } from './resolves';
-import { satisfies } from './satisfies';
-import { throws } from './throws';
-import { truthy } from './truthy';
+import { AssertionError } from '../errors'
+import { notEqualMessage } from '../utils'
+import { falsy } from './falsy'
+import { pathEqual } from './pathEqual'
+import { rejects } from './rejects'
+import { repeat } from './repeat'
+import { resolves } from './resolves'
+import { satisfies } from './satisfies'
+import { throws } from './throws'
+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,6 +1,5 @@
-import a from '..';
-import AssertionError from 'assertion-error'
-import { assertThrows, noStackTraceFor } from '../testUtils';
+import a, { AssertionError } from '..'
+import { assertThrows, noStackTraceFor } from '../testUtils'
 
 test('non-false statement throws', () => {
   assertThrows(() => a.falsy(true), AssertionError)

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,6 +1,5 @@
-import AssertionError from 'assertion-error';
-import assertron from '..';
-import { assertThrows, noStackTraceFor } from '../testUtils';
+import assertron, { AssertionError } from '..'
+import { assertThrows, noStackTraceFor } from '../testUtils'
 
 test('path with same style passes', () => {
   assertron.pathEqual('a', 'a')

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 { pathEqual as isPathEqual } from 'path-equal'
+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,7 +1,6 @@
-import t from 'assert';
-import AssertionError from 'assertion-error';
-import a from '..';
-import { assertAsyncThrows, noStackTraceFor } from '../testUtils';
+import t from 'assert'
+import a from '..'
+import { assertAsyncThrows, noStackTraceFor } from '../testUtils'
 
 test('pass on rejected promise', async () => {
   await a.rejects(Promise.reject(1))
@@ -12,22 +11,22 @@ test('throws on resolved string promise', async () => {
   t.strictEqual(err.message, `Expected promise to reject, but it resolves with 'abc'`)
 })
 
-test('throws on resovled boolean promise', async () => {
+test('throws on resolved boolean promise', async () => {
   const err = await a.throws(a.rejects(Promise.resolve(true)))
   t.strictEqual(err.message, `Expected promise to reject, but it resolves with true`)
 })
 
-test('throws on resovled object promise', async () => {
+test('throws on resolved object promise', async () => {
   const err = await a.throws(a.rejects(Promise.resolve(2)))
   t.strictEqual(err.message, `Expected promise to reject, but it resolves with 2`)
 })
 
-test('throws on resovled object promise', async () => {
+test('throws on resolved object promise', async () => {
   const err = await a.throws(a.rejects(Promise.resolve({ a: 1 })))
   t.strictEqual(err.message, `Expected promise to reject, but it resolves with { a: 1 }`)
 })
 
 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,17 +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 { FailOnOccurance } from './repeat';
+import a, { FailOnOccurrence } from '..'
 
 test('repeat function n times', () => {
   let count = 0
@@ -11,7 +10,7 @@ test('repeat function n times', () => {
 test('repeat async function n times sequentially', async () => {
   let count = 0
   let actual = ''
-  let aa = await a.repeat(() => new Promise<string>(a => {
+  const aa = await a.repeat(() => new Promise<string>(a => {
     setTimeout(() => {
       ++count
       actual += String(count)
@@ -26,24 +25,23 @@ 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')
-  }, 10), FailOnOccurance)
+    if (++count === 5) throw new Error('failed')
+  }, 10), FailOnOccurrence)
 
-  expect(err.occurance).toBe(5)
+  expect(err.occurrence).toBe(5)
   expect(err.error.message).toBe('failed')
 })
 
 test('rejected error is captured as inner error and indicate which call failed', async () => {
   let count = 0
-  let err = await a.throws(a.repeat(() => new Promise((a, r) => {
+  const err = await a.throws(a.repeat(() => new Promise<void>((a, r) => {
     setTimeout(() => {
       ++count
       if (count === 5) r(new Error('failed'))
       else a()
     }, Math.random() * 10)
-  }), 10), FailOnOccurance)
+  }), 10), FailOnOccurrence)
 
-  expect(err.occurance).toBe(5)
+  expect(err.occurrence).toBe(5)
   expect(err.error.message).toBe('failed')
 })

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,19 +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`)
@@ -74,12 +88,11 @@ test('function will use as predicate', () => {
 })
 
 test('predicate error should mention path', () => {
-  a.throws(() => a.satisfies({ a: 1 }, { a: () => false }), e => e.message === `Expect a to satisfy fn() { return false }, but received 1`)
+  a.throws(() => a.satisfies({ a: 1 }, { a: () => false }), e => e.message === `Expect a to satisfy () => false, but received 1`)
 })
 
 test('deep predicate error should mention path', () => {
-
-  a.throws(() => a.satisfies({ a: { b: 1 } }, { a: { b: b => b === 2 } }), e => e.message === `Expect a.b to satisfy fn(b) { return b === 2 }, but received 1`)
+  a.throws(() => a.satisfies({ a: { b: 1 } }, { a: { b: b => b === 2 } }), e => e.message === `Expect a.b to satisfy b => b === 2, but received 1`)
 })
 
 test('can check parent property', () => {
@@ -94,7 +107,7 @@ test('can check parent property', () => {
 })
 
 test('actual of type any should not have type checking error', () => {
-  let actual: any = { a: 1 }
+  const actual: any = { a: 1 }
   a.satisfies(actual, { a: 1 })
 })
 
@@ -102,7 +115,7 @@ test('Work with null in array', () => {
   interface Foo {
     payload: any;
   }
-  let action: Foo = { payload: [null, 3, 4] }
+  const action: Foo = { payload: [null, 3, 4] }
   a.satisfies(action, { payload: [null, 3, 4] })
 })
 
@@ -110,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,26 +81,30 @@ test('passes with throwing function', () => {
 })
 
 test('throws if function does not', () => {
-  const err = assertThrows<AssertionError<{ value: string }>>(() => a.throws(
-    () => { return 'foo' }, AssertionError),
-    AssertionError)
-  t.strictEqual(err.value, 'foo')
+  assertThrows(
+    () => a.throws(() => { return 'foo' }, AssertionError),
+    AssertionError
+  )
 })
 
 test('thrown error does not contain internal stack track if function does not', () => {
-  const err = assertThrows<AssertionError<{ value: string }>>(() => a.throws(
-    () => { return 'foo' }, AssertionError),
-    AssertionError)
+  const err = assertThrows(
+    () => a.throws(() => { return 'foo' }, AssertionError),
+    AssertionError
+  )
   noStackTraceFor('throws.ts', err)
 })
 
 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)
 })
 
@@ -112,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)
 })
 
@@ -163,3 +176,9 @@ test(`a.throws(() => never) returns error of type Error`, () => {
   const err = a.throws(() => { throw new Error('failure') })
   expect(err.message).toBe('failure')
 })
+
+test('throw if function returns an object', () => {
+  class Dummy { a = 1; foo() { } }
+  const err = assertThrows(() => a.throws(() => new Dummy()), AssertionError)
+  expect(err.message).toBe(`Expect function to throw, but it returned 'Dummy { a: 1 }' instead.`)
+})