assertron 9.0.8 → 9.2.0

package/src/assertron/assertron.ts

@@ -1,29 +0,0 @@
-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(notEqualMessage(value, false), { ssf: assertron.false })
-  },
-  falsy,
-  pathEqual,
-  rejects,
-  repeat,
-  resolves,
-  satisfies,
-  throws,
-  true(value: any) {
-    if (value !== true)
-      throw new AssertionError(notEqualMessage(value, true), { ssf: assertron.true })
-  },
-  truthy
-}

package/src/assertron/falsy.spec.ts

@@ -1,20 +0,0 @@
-import a, { AssertionError } from '..'
-import { assertThrows, noStackTraceFor } from '../testUtils'
-
-test('non-false statement throws', () => {
-  assertThrows(() => a.falsy(true), AssertionError)
-  assertThrows(() => a.falsy(1 === 1), AssertionError)
-  assertThrows(() => a.falsy(1), AssertionError)
-  assertThrows(() => a.falsy({}), AssertionError)
-  assertThrows(() => a.falsy(() => true), AssertionError)
-})
-
-test('does not contain internal stack trace', () => {
-  const err = assertThrows(() => a.falsy(true), AssertionError)
-  noStackTraceFor('falsy.ts', err)
-})
-
-test('false statement pass', () => {
-  a.falsy(false)
-  a.falsy(1 === 2 as any)
-})

package/src/assertron/index.ts

@@ -1 +0,0 @@
-export * from './assertron'

package/src/assertron/pathEqual.spec.ts

@@ -1,28 +0,0 @@
-import assertron, { AssertionError } from '..'
-import { assertThrows, noStackTraceFor } from '../testUtils'
-
-test('path with same style passes', () => {
-  assertron.pathEqual('a', 'a')
-  assertron.pathEqual('a/b', 'a/b')
-  assertron.pathEqual('a\\b', 'a\\b')
-})
-
-test('same style different value throws', () => {
-  assertThrows(() => assertron.pathEqual('a', 'b'))
-})
-
-test('UNIX style matches Windows style', () => {
-  assertron.pathEqual('a/b', 'a\\b')
-  assertron.pathEqual('a/b/c', 'a\\b\\c')
-  assertron.pathEqual('a\\b', 'a/b')
-  assertron.pathEqual('a\\b\\c', 'a/b/c')
-})
-
-test(`/d/foo should match d:\\foo`, () => {
-  assertron.pathEqual('/d/foo', 'd:\\foo')
-})
-
-test('does not contain internal stack trace', () => {
-  const err = assertThrows(() => assertron.pathEqual('a', 'b'), AssertionError)
-  noStackTraceFor('pathEqual.ts', err)
-})

package/src/assertron/rejects.spec.ts

@@ -1,32 +0,0 @@
-import t from 'assert'
-import a from '..'
-import { assertAsyncThrows, noStackTraceFor } from '../testUtils'
-
-test('pass on rejected promise', async () => {
-  await a.rejects(Promise.reject(1))
-})
-
-test('throws on resolved string promise', async () => {
-  const err = await a.throws(a.rejects(Promise.resolve('abc')))
-  t.strictEqual(err.message, `Expected promise to reject, but it resolves with 'abc'`)
-})
-
-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 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 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 })))
-  noStackTraceFor('rejects.ts', err)
-})

package/src/assertron/repeat.spec.ts

@@ -1,47 +0,0 @@
-import a, { FailOnOccurrence } from '..'
-
-test('repeat function n times', () => {
-  let count = 0
-  a.repeat(() => ++count, 10)
-
-  expect(count).toBe(10)
-})
-
-test('repeat async function n times sequentially', async () => {
-  let count = 0
-  let actual = ''
-  const aa = await a.repeat(() => new Promise<string>(a => {
-    setTimeout(() => {
-      ++count
-      actual += String(count)
-      a(actual)
-    }, Math.random() * 10)
-  }), 10)
-
-  expect(actual).toBe('12345678910')
-  expect(actual).toBe(aa)
-})
-
-test('error is captured as inner error and indicate which call failed', () => {
-  let count = 0
-  const err = a.throws(() => a.repeat(() => {
-    if (++count === 5) throw new Error('failed')
-  }, 10), FailOnOccurrence)
-
-  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
-  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), FailOnOccurrence)
-
-  expect(err.occurrence).toBe(5)
-  expect(err.error.message).toBe('failed')
-})

package/src/assertron/resolves.spec.ts

@@ -1,29 +0,0 @@
-import t from 'assert'
-import a, { AssertionError } from '..'
-import { assertAsyncThrows, noStackTraceFor } from '../testUtils'
-
-
-test('pass on resolved promise', async () => {
-  await a.resolves(Promise.resolve())
-})
-
-test('throws on rejected string promise', async () => {
-  const err = await a.throws(a.resolves(Promise.reject('abc')), AssertionError)
-  t.strictEqual(err.message, `Expected promise to resolve, but it rejects with 'abc'`)
-})
-
-test('throws on rejected error promise', async () => {
-  const err = await a.throws(a.resolves(Promise.reject(new Error('foo'))), AssertionError)
-  t.strictEqual(err.message, `Expected promise to resolve, but it rejects with Error: foo`)
-})
-
-test('throws on rejected object promise', async () => {
-  const err = await a.throws(a.resolves(Promise.reject({ a: 1 })), AssertionError)
-  t.strictEqual(err.message, `Expected promise to resolve, but it rejects with { a: 1 }`)
-})
-
-test('does not contain internal stack trace', async () => {
-  const err = await assertAsyncThrows(() => a.resolves(Promise.reject({ a: 1 })), AssertionError)
-  noStackTraceFor('resolves.ts', err)
-})
-

package/src/assertron/satisfies.spec.ts

@@ -1,159 +0,0 @@
-import { every, has, isInRange, some } 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', () => {
-  a.satisfies({}, {})
-  a.satisfies({ a: 1 }, {})
-})
-
-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(`array entries are checked`, () => {
-  a.throws(() => a.satisfies([1], [2]), e => e.message === `Expect actual[0] to satisfy 2, but received 1`)
-})
-
-test('work with primitive array', () => {
-  a.satisfies([1, 2, 3], [1, 2, 3])
-  a.satisfies([true, false], [true, false])
-  a.satisfies(['a', 'b'], ['a', 'b'])
-})
-
-test(`check deep entry in array`, () => {
-  a.throws(() => a.satisfies([1, { a: { b: 1 } }], [1, { a: { b: 2 } }]), e => e.message === `Expect actual[1].a.b to satisfy 2, but received 1`)
-})
-
-test('missing property will fail', () => {
-  a.throws(() => a.satisfies({}, { a: 1 }), e => e.message === `Expect a to satisfy 1, but received undefined`)
-})
-
-test('missing property at deeper level', () => {
-  a.throws(() => a.satisfies({ a: {} }, { a: { b: 1 } }), e => e.message === `Expect a.b to satisfy 1, but received undefined`)
-})
-
-test('extra property will pass', () => {
-  a.satisfies({ a: 1, b: 2 }, { a: 1 })
-})
-
-test('property not match will fail', () => {
-  a.throws(() => a.satisfies({ a: 1 }, { a: 2 }), e => e.message === `Expect a to satisfy 2, but received 1`)
-})
-
-test('regex will match regex', () => {
-  a.satisfies({ a: /foo/ }, { a: /foo/ })
-})
-
-test('regex will be used to match', () => {
-  a.satisfies({ a: 'foo' }, { a: /foo/ })
-})
-
-test('function will use as predicate', () => {
-  a.satisfies({ a: 1 }, { a: a => a === 1 })
-})
-
-test('predicate error should mention path', () => {
-  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 b => b === 2, but received 1`)
-})
-
-test('can check parent property', () => {
-  class Foo {
-    foo = 'foo'
-  }
-  class Boo extends Foo {
-    boo = 'boo'
-  }
-  const boo = new Boo()
-  a.satisfies(boo, { foo: 'foo' })
-})
-
-test('actual of type any should not have type checking error', () => {
-  const actual: any = { a: 1 }
-  a.satisfies(actual, { a: 1 })
-})
-
-test('Work with null in array', () => {
-  interface Foo {
-    payload: any
-  }
-  const action: Foo = { payload: [null, 3, 4] }
-  a.satisfies(action, { payload: [null, 3, 4] })
-})
-
-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'])
-})
-
-test('using has()', () => {
-  a.satisfies([1, 2, 3], has(2))
-})
-
-test('using every()', () => {
-  a.satisfies([1, 2, 3], every((x: number) => x > 0))
-})
-
-test('using isInRange()', () => {
-  a.satisfies(1, isInRange(1, 3))
-})
-
-test('using some()', () => {
-  a.satisfies([1, 2, 3], some((x: number) => x % 2 === 0))
-})

package/src/assertron/throws.spec.ts

@@ -1,184 +0,0 @@
-import t from 'assert'
-import a, { AssertionError } from '..'
-import { assertAsyncThrows, assertIsError, assertIsPromise, assertThrows, noStackTraceFor } from '../testUtils'
-
-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('Ren')), () => true)
-  assertIsPromise(actual)
-  t.equal((await actual).message, 'Ren')
-
-  actual = a.throws(Promise.reject(new Error('Luka')))
-  assertIsPromise(actual)
-  t.equal((await actual).message, 'Luka')
-})
-
-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('Luka')), () => true)
-  assertIsPromise(actual)
-  t.equal((await actual).message, 'Luka')
-
-  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() }), Error)
-  assertIsError(actual)
-
-  actual = a.throws((() => { throw new Error() }))
-  assertIsError(actual)
-})
-
-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', () => {
-  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(() => 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'))))
-  t.strictEqual(actual, 'no')
-})
-
-test('passes with rejected promise passing validator', () => {
-  return a.throws(Promise.reject('no'), err => err === 'no')
-})
-
-test('throws with rejected promise failing validator', async () => {
-  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(() => a.throws(Promise.reject('no'), err => err !== 'no'), AssertionError)
-  // Error.captureStackTrace(err, a.throws)
-
-  noStackTraceFor('throws.ts', err)
-})
-
-test('passes with throwing function', () => {
-  a.throws(() => { throw new Error('foo') })
-})
-
-test('throws if function does not', () => {
-  assertThrows(
-    () => a.throws(() => { return 'foo' }, AssertionError),
-    AssertionError
-  )
-})
-
-test('thrown error does not contain internal stack track if function does not', () => {
-  const err = assertThrows(
-    () => a.throws(() => { return 'foo' }, AssertionError),
-    AssertionError
-  )
-  noStackTraceFor('throws.ts', err)
-})
-
-test('throws if function returns resolved promise', async () => {
-  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(
-    () => a.throws(() => Promise.resolve('ok')),
-    AssertionError)
-  noStackTraceFor('throws.ts', err)
-})
-
-test('pass if function returns rejected promise', () => {
-  return a.throws(() => { return Promise.reject('ok') })
-})
-
-test('pass if function returns rejected promise passing valdation', () => {
-  return a.throws(
-    () => { return Promise.reject('ok') },
-    err => err === 'ok')
-})
-
-test('throws if function returns rejected promise not passing valdation', async () => {
-  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(
-    () => a.throws(() => Promise.reject('ok'), err => err !== 'ok'),
-    AssertionError
-  )
-  // console.log('got err', err)
-  noStackTraceFor('throws.ts', err)
-})
-
-class FakeError extends Error {
-  constructor(msg?: string) {
-    super(msg || 'some fake msg')
-
-    Object.setPrototypeOf(this, new.target.prototype)
-  }
-  foo = 'foo'
-}
-
-test('validate Promise using Error constructor', async () => {
-  const err = await a.throws(Promise.reject(new FakeError('abc')), FakeError)
-  t.strictEqual(err.foo, 'foo')
-})
-
-test('validate Promise using another Error constructor will throw', async () => {
-  const err = await assertAsyncThrows(() => a.throws(Promise.reject(new FakeError()), AssertionError), AssertionError)
-
-  t.strictEqual(err.message, `Unexpected error. Expecting 'AssertionError' but received FakeError('some fake msg')`)
-})
-
-test('validate () => Promise using Error constructor', async () => {
-  const err = await a.throws(() => Promise.reject(new FakeError()), FakeError)
-  t.strictEqual(err.foo, 'foo')
-})
-
-test('validate () => Promise using another Error constructor will throw', () => {
-  return assertAsyncThrows(() => a.throws(() => Promise.reject(new FakeError()), AssertionError))
-})
-
-test('validate () => throw using Error constructor', async () => {
-  const err = await a.throws((() => { throw new FakeError() }) as any, FakeError)
-  t.strictEqual(err.foo, 'foo')
-})
-
-test('validate () => throw using another Error constructor will throw', async () => {
-  return t.throws(() => a.throws((() => { throw new FakeError() }) as any, AssertionError))
-})
-
-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.`)
-})

package/src/assertron/truthy.spec.ts

@@ -1,23 +0,0 @@
-import a, { AssertionError } from '..'
-import { assertThrows, noStackTraceFor } from '../testUtils'
-
-test('falsy statement throws', () => {
-  assertThrows(() => a.truthy(false), AssertionError)
-  assertThrows(() => a.truthy(''), AssertionError)
-  assertThrows(() => a.truthy(0), AssertionError)
-  assertThrows(() => a.truthy(null), AssertionError)
-  assertThrows(() => a.truthy(undefined), AssertionError)
-})
-
-test('truthy statement pass', () => {
-  a.truthy(true)
-  a.truthy('a')
-  a.truthy(-1)
-  a.truthy({})
-  a.truthy(() => false)
-})
-
-test('does not contain internal stack trace', () => {
-  const err = assertThrows(() => a.truthy(false), AssertionError)
-  noStackTraceFor('truthy.ts', err)
-})

package/src/index.ts

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

package/src/utils/index.ts

@@ -1,12 +0,0 @@
-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/notSatisfiedMessage.spec.ts

@@ -1,31 +0,0 @@
-import t from 'assert';
-import { notSatisfiedMessage } from '.';
-
-test('array should be tersified', () => {
-
-  t.strictEqual(notSatisfiedMessage([{
-    path: ['a'],
-    actual: {
-      a: [1, 2, 3]
-    },
-    expected: {
-      b: ['a', 'b', 'c']
-    }
-  }]), `Expect a to satisfy { b: ['a', 'b', 'c'] }, but received { a: [1, 2, 3] }`)
-})
-
-test(`root diff is displayed as 'actual'`, () => {
-  t.strictEqual(notSatisfiedMessage([{
-    path: [],
-    actual: 1,
-    expected: 2
-  }]), `Expect actual to satisfy 2, but received 1`)
-})
-
-test(`root diff is displayed as 'actual'`, () => {
-  t.strictEqual(notSatisfiedMessage([{
-    path: ['[0]'],
-    actual: 1,
-    expected: 2
-  }]), `Expect [0] to satisfy 2, but received 1`)
-})