@plugjs/expect5 0.4.4 → 0.4.5

package/src/expectation/basic.ts

@@ -1,413 +0,0 @@
-import { diff } from './diff'
-import {
-  assertContextType,
-  ExpectationError,
-  prefixType,
-  stringifyConstructor,
-  stringifyValue,
-  typeOf,
-} from './types'
-
-import type { Expectations } from './expect'
-import type {
-  AssertedType,
-  AssertionFunction,
-  Constructor,
-  ExpectationsContext,
-  JoinExpectations,
-  TypeMappings,
-  TypeName,
-} from './types'
-
-/* === TO BE A ============================================================== */
-
-/** Expects the value to be of the specified {@link TypeName type}. */
-function toBeA<N extends TypeName>(type: N): Expectations<TypeMappings[N]>
-
-/**
- * Expects the value to be of the specified {@link TypeName type}, and further
- * asserts it with the specified callback.
- */
-function toBeA<T, N extends TypeName, A extends AssertionFunction<TypeMappings[N]>>(
-  this: T,
-  type: N,
-  assert: A,
-): Expectations<TypeMappings[N] & AssertedType<A>>
-
-/* Overloaded function implementation */
-function toBeA(
-    this: ExpectationsContext,
-    type: TypeName,
-    assert?: AssertionFunction,
-): Expectations {
-  const match = typeOf(this.value) === type
-  if (match === this.negative) {
-    throw new ExpectationError(this, `to be ${prefixType(type)}`)
-  } else if (assert) {
-    assert(this.expects)
-  }
-  return this.expects
-}
-
-/* === TO BE CLOSE TO ======================================================= */
-
-/**
- * Expects the value to be a `number` within a given +/- delta range of the
- * specified `number`.
- */
-function toBeCloseTo(value: number, delta: number): Expectations<number>
-
-/**
- * Expects the value to be a a `bigint` within a given +/- delta range of the
- * specified `bigint`.
- */
-function toBeCloseTo(value: bigint, delta: bigint): Expectations<bigint>
-
-/* Overloaded function implementation */
-function toBeCloseTo(
-    this: ExpectationsContext,
-    value: number | bigint,
-    delta: number | bigint,
-): Expectations {
-  const min = (value as number) - (delta as number)
-  const max = (value as number) + (delta as number)
-  return this.negated.toBeWithinRange(min, max)
-}
-
-/* === TO BE ERROR ========================================================== */
-
-/** Expects the value to be an {@link Error}. */
-function toBeError(): Expectations<Error>
-
-/** Expects the value to be an {@link Error} with the specified message. */
-function toBeError(message: string): Expectations<Error>
-
-/**
- * Expects the value to be an {@link Error} with its message matching the
- * specified {@link RegExp}.
- */
-function toBeError(matcher: RegExp): Expectations<Error>
-
-/** Expects the value to be an {@link Error} of the specified _type_. */
-function toBeError<C extends Constructor<Error>>(constructor: C): Expectations<InstanceType<C>>
-
-/**
- * Expects the value to be an {@link Error} of the specified _type_  with the
- * specified message
- */
-function toBeError<C extends Constructor<Error>>(constructor: C, message: string): Expectations<InstanceType<C>>
-
-/**
- * Expects the value to be an {@link Error} of the specified _type_  with the
- * specified message
- */
-function toBeError<C extends Constructor<Error>>(constructor: C, matcher: RegExp): Expectations<InstanceType<C>>
-
-/* Overloaded function implementation */
-function toBeError(
-    this: ExpectationsContext,
-    ...args:
-    | []
-    | [ message: string | RegExp ]
-    | [ constructor: Constructor<Error> ]
-    | [ constructor: Constructor<Error>, message: string | RegExp ]
-): Expectations {
-  const [ constructor, message ] =
-    typeof args[0] === 'function' ?
-      [ args[0], args[1] ] :
-      [ Error, args[0] ]
-
-  this.negated.toBeInstanceOf(constructor)
-
-  // if "not.toBeError" ignore the message
-  if (this.negative || (message === undefined)) return this.expects
-
-  return this.expects.toHaveProperty('message', (assert) => {
-    assert.toBeA('string')
-    return typeof message === 'string' ?
-        assert.toStrictlyEqual(message) :
-        assert.toMatch(message)
-  })
-}
-
-
-/* === TO BE GREATER THAN =================================================== */
-
-/** Expects the value to be a `number` greater than the specified `number`. */
-function toBeGreaterThan(value: number): Expectations<number>
-/** Expects the value to be a `bigint` greater than the specified `bigint`. */
-function toBeGreaterThan(value: bigint): Expectations<bigint>
-
-/* Overloaded function implementation */
-function toBeGreaterThan(
-    this: ExpectationsContext,
-    value: number | bigint,
-): Expectations {
-  assertContextType(this, typeof value as 'number' | 'bigint')
-  if ((this.value > value) !== this.negative) return this.expects
-  throw new ExpectationError(this, `to be greater than ${stringifyValue(value)}`)
-}
-
-/* === TO BE GREATER THAN OR EQUAL ========================================== */
-
-/** Expects the value to be a `number` greater than or equal to the specified `number`. */
-function toBeGreaterThanOrEqual(value: number): Expectations<number>
-/** Expects the value to be a `bigint` greater than or equal to the specified `bigint`. */
-function toBeGreaterThanOrEqual(value: bigint): Expectations<bigint>
-
-/* Overloaded function implementation */
-function toBeGreaterThanOrEqual(
-    this: ExpectationsContext,
-    value: number | bigint,
-): Expectations {
-  assertContextType(this, typeof value as 'number' | 'bigint')
-  if ((this.value >= value) !== this.negative) return this.expects
-  throw new ExpectationError(this, `to be greater than or equal to ${stringifyValue(value)}`)
-}
-
-/* === TO BE INSTANCE OF ==================================================== */
-
-/** Expects the value to be an instance of the specified _type_. */
-function toBeInstanceOf<C extends Constructor>(value: C): Expectations<InstanceType<C>>
-
-/* Overloaded function implementation */
-function toBeInstanceOf(
-    this: ExpectationsContext,
-    value: Constructor,
-): Expectations {
-  const match = this.value instanceof value
-  if (match !== this.negative) return this.expects
-  throw new ExpectationError(this, `to be an instance of ${stringifyConstructor(value)}`)
-}
-
-/* === TO BE LESS THAN ====================================================== */
-
-/** Expects the value to be a `number` less than the specified `number`. */
-function toBeLessThan(value: number): Expectations<number>
-/** Expects the value to be a `bigint` less than the specified `bigint`. */
-function toBeLessThan(value: bigint): Expectations<bigint>
-
-/* Overloaded function implementation */
-function toBeLessThan(
-    this: ExpectationsContext,
-    value: number | bigint,
-): Expectations {
-  assertContextType(this, typeof value as 'number' | 'bigint')
-  if ((this.value < value) !== this.negative) return this.expects
-  throw new ExpectationError(this, `to be less than ${stringifyValue(value)}`)
-}
-
-/* === TO BE LESS THAN OR EQUAL ============================================= */
-
-/** Expects the value to be a `number` less than or equal to the specified `number`. */
-function toBeLessThanOrEqual(value: number): Expectations<number>
-/** Expects the value to be a `bigint` less than or equal to the specified `bigint`. */
-function toBeLessThanOrEqual(value: bigint): Expectations<bigint>
-
-/* Overloaded function implementation */
-function toBeLessThanOrEqual(
-    this: ExpectationsContext,
-    value: number | bigint,
-): Expectations {
-  assertContextType(this, typeof value as 'number' | 'bigint')
-  if ((this.value <= value) !== this.negative) return this.expects
-  throw new ExpectationError(this, `to be less than or equal to ${stringifyValue(value)}`)
-}
-
-/* === TO WITHIN RANGE ====================================================== */
-
-/** Expects the value to be a `number` within the specified range (inclusive). */
-function toBeWithinRange(min: number, max: number): Expectations<number>
-/** Expects the value to be a `bigint` within the specified range (inclusive). */
-function toBeWithinRange(min: bigint, max: bigint): Expectations<bigint>
-
-/* Overloaded function implementation */
-function toBeWithinRange(
-    this: ExpectationsContext,
-    min: number | bigint,
-    max: number | bigint,
-): Expectations {
-  if (max < min) {
-    const num = max
-    max = min
-    min = num
-  }
-
-  assertContextType(this, typeof min as 'number' | 'bigint')
-  if (((this.value >= min) && (this.value <= max)) !== this.negative) return this.expects
-  throw new ExpectationError(this, `to be within ${stringifyValue(min)}...${stringifyValue(max)}`)
-}
-
-/* === TO EQUAL ============================================================= */
-
-/** Expects the value to _deeply equal_ to the specified expected value. */
-function toEqual<T>(expected: T): Expectations<T>
-
-/* Overloaded function implementation */
-function toEqual(
-    this: ExpectationsContext,
-    expected: any,
-): Expectations {
-  const result = diff(this.value, expected)
-  if (result.diff === this.negative) return this.expects
-  throw new ExpectationError(this, `to equal ${stringifyValue(expected)}`, result)
-}
-
-/* === TO HAVE LENGTH ======================================================= */
-
-/** Expects the value to have a numerical `length` property with the specified value. */
-function toHaveLength<T, N extends number>(this: T, length: N): JoinExpectations<T, { length: N }>
-
-/* Overloaded function implementation */
-function toHaveLength(
-    this: ExpectationsContext,
-    length: number,
-): Expectations {
-  this.expects.toBeDefined()
-
-  const actualLength = (this.value as any).length
-  if (typeof actualLength !== 'number') {
-    throw new ExpectationError(this, 'to have a numeric "length" property', false)
-  }
-
-  if ((actualLength === length) === this.negative) {
-    throw new ExpectationError(this, `to have length ${stringifyValue(length)}`)
-  }
-
-  return this.expects
-}
-
-/* === TO HAVE PROPERTY ===================================================== */
-
-/** Expects the value to have a property. */
-function toHaveProperty<T, P extends string | number | symbol>(
-  this: T,
-  prop: P,
-): JoinExpectations<T, { [key in P]: unknown }>
-
-/**
- * Expects the value to have a property, and further asserts the property
- * value with the specified callback.
- */
-function toHaveProperty<T, P extends string | number | symbol, A extends AssertionFunction>(
-  this: T,
-  prop: P,
-  assert: A,
-): JoinExpectations<T, { [key in P]: AssertedType<A> }>
-
-/* Overloaded function implementation */
-function toHaveProperty(
-    this: ExpectationsContext,
-    prop: string | symbol | number,
-    assert?: AssertionFunction,
-): Expectations {
-  this.expects.toBeDefined()
-
-  const match = (this.value as any)[prop] !== undefined
-  if (match === this.negative) {
-    throw new ExpectationError(this, `to have property "${String(prop)}"`)
-  } else if (match && assert) {
-    try {
-      assert(this.forProperty(prop))
-    } catch (error) {
-      // any caught error difference gets remapped as a property diff
-      if ((error instanceof ExpectationError) && (error.diff)) {
-        error.diff = {
-          diff: true,
-          value: this.value,
-          props: { [prop]: error.diff },
-        }
-      }
-
-      // re-throw
-      throw error
-    }
-  }
-
-  return this.expects
-}
-
-
-/* === TO HAVE SIZE ========================================================= */
-
-/** Expects the value to have a numerical `size` property with the specified value. */
-function toHaveSize<T, N extends number>(this: T, size: N): JoinExpectations<T, { size: N }>
-
-/* Overloaded function implementation */
-function toHaveSize(
-    this: ExpectationsContext,
-    size: number,
-): Expectations {
-  this.expects.toBeDefined()
-
-  const actualSize = (this.value as any).size
-  if (typeof actualSize !== 'number') {
-    throw new ExpectationError(this, 'to have a numeric "size" property', false)
-  }
-
-  if ((actualSize === size) === this.negative) {
-    throw new ExpectationError(this, `to have size ${stringifyValue(size)}`)
-  }
-
-  return this.expects
-}
-
-/* === TO MATCH ============================================================= */
-
-/** Expects the value to be a `string` _matching_ the specified substring. */
-function toMatch(substring: string): Expectations<string>
-/** Expects the value to be a `string` _matching_ the specified {@link RegExp}. */
-function toMatch(expression: RegExp): Expectations<string>
-
-/* Overloaded function implementation */
-function toMatch(
-    this: ExpectationsContext,
-    expr: string | RegExp,
-): Expectations {
-  assertContextType(this, 'string')
-
-  const match = !! this.value.match(expr)
-  if (match !== this.negative) return this.expects
-
-  throw new ExpectationError(this, `to match ${stringifyValue(expr)}`)
-}
-
-
-/* === TO STRICTLY EQUAL ==================================================== */
-
-/** Expects the value to _strictly equal_ to the specified expected value. */
-function toStrictlyEqual<T>(expected: T): Expectations<T>
-
-/* Overloaded function implementation */
-function toStrictlyEqual(
-    this: ExpectationsContext,
-    expected: any,
-): Expectations {
-  // const value = context.value
-  const match = this.value === expected
-  if (match !== this.negative) return this.expects
-
-  const diff = this.negative ? undefined : { diff: true, value: this.value, expected }
-  throw new ExpectationError(this, `to strictly equal ${stringifyValue(expected)}`, diff)
-}
-
-/* === EXPORTS ============================================================== */
-
-/* coverage ignore next */
-export {
-  toBeA,
-  toBeCloseTo,
-  toBeError,
-  toBeGreaterThan,
-  toBeGreaterThanOrEqual,
-  toBeInstanceOf,
-  toBeLessThan,
-  toBeLessThanOrEqual,
-  toBeWithinRange,
-  toEqual,
-  toHaveLength,
-  toHaveProperty,
-  toHaveSize,
-  toMatch,
-  toStrictlyEqual,
-}

package/src/expectation/throwing.ts

@@ -1,106 +0,0 @@
-import { ExpectationError, assertContextType } from './types'
-
-import type { Expectations } from './expect'
-import type {
-  AssertionFunction,
-  Constructor,
-  ExpectationsContext,
-  JoinExpectations,
-} from './types'
-
-/* === TO THROW ============================================================= */
-
-/** Expects the value to be a `function` throwing _anything_. */
-function toThrow<T>(this: T): JoinExpectations<T, Function>
-
-/**
- * Expects the value to be a `function` throwing, and asserts the
- * thrown value with the specified callback.
- */
-function toThrow<T>(this: T, assert: AssertionFunction): JoinExpectations<T, Function>
-
-/* Overloaded function implementation */
-function toThrow(
-    this: ExpectationsContext,
-    assert?: AssertionFunction,
-): Expectations {
-  assertContextType(this, 'function')
-
-  let thrown: boolean
-  let error: unknown
-  try {
-    this.value()
-    thrown = false
-    error = undefined
-  } catch (caught) {
-    thrown = true
-    error = caught
-  }
-
-  if (thrown === this.negative) {
-    throw new ExpectationError(this, 'to throw')
-  } else if (thrown && assert) {
-    assert(this.forValue(error))
-  }
-
-  return this.expects
-}
-
-/* === TO THROW ERROR ======================================================= */
-
-/** Expects the value to be a `function` throwing an {@link Error}. */
-function toThrowError<T>(this: T): JoinExpectations<T, Function>
-
-/**
- * Expects the value to be a `function` throwing an {@link Error} with the
- * specified _message_.
- */
-function toThrowError<T>(this: T, message: string): JoinExpectations<T, Function>
-
-/**
- * Expects the value to be a `function` throwing an {@link Error} with its
- * _message_ matching the specified {@link RegExp}.
- */
-function toThrowError<T>(this: T, expession: RegExp): JoinExpectations<T, Function>
-
-/**
- * Expects the value to be a `function` throwing an {@link Error} of the
- * specified _type_.
- */
-function toThrowError<T>(this: T, constructor: Constructor<Error>): JoinExpectations<T, Function>
-
-/**
- * Expects the value to be a `function` throwing an {@link Error} of the
- * specified _type_ with the specified _message_.
- */
-function toThrowError<T>(this: T, constructor: Constructor<Error>, message: string): JoinExpectations<T, Function>
-
-/**
- * Expects the value to be a `function` throwing an {@link Error} of the
- * specified _type_ with its _message_ matching the specified {@link RegExp}.
- */
-function toThrowError<T>(this: T, constructor: Constructor<Error>, expression: RegExp): JoinExpectations<T, Function>
-
-/* Overloaded function implementation */
-function toThrowError(
-    this: ExpectationsContext,
-    ...args:
-    | []
-    | [ string ]
-    | [ RegExp ]
-    | [ Constructor<Error> ]
-    | [ Constructor<Error>, string ]
-    | [ Constructor<Error>, RegExp ]
-): Expectations {
-  return this.negated.toThrow((assert) =>
-    // @ts-ignore // can't reconcile the types with overloads...
-    assert.toBeError(...args))
-}
-
-/* === EXPORTS ============================================================== */
-
-/* coverage ignore next */
-export {
-  toThrow,
-  toThrowError,
-}

package/src/expectation/trivial.ts

@@ -1,107 +0,0 @@
-import { ExpectationError, stringifyValue } from './types'
-
-import type { Expectations } from './expect'
-import type { ExpectationsContext } from './types'
-
-/* Expects the value to be _defined_ (that is not `null` nor `undefined`). */
-function toBeDefined<T>(this: T): T
-function toBeDefined(this: ExpectationsContext): Expectations {
-  return check(this, 'to be defined', (value) => (value !== null) && (value !== undefined))
-}
-
-/* Expects the value strictly equal to `false`. */
-function toBeFalse(): Expectations<false>
-function toBeFalse(this: ExpectationsContext): Expectations {
-  return check(this, `to be ${stringifyValue(false)}`, (value) => value === false)
-}
-
-/* Expects the value to be _falsy_ (zero, empty string, `false`, ...). */
-function toBeFalsy<T>(this: T): T
-function toBeFalsy(this: ExpectationsContext): Expectations {
-  return check(this, 'to be falsy', (value) => ! value)
-}
-
-/* Expects the value to be `NaN`. */
-function toBeNaN(): Expectations<number>
-function toBeNaN(this: ExpectationsContext): Expectations {
-  return check(this, `to be ${stringifyValue(NaN)}`, (value) => (typeof value === 'number') && isNaN(value))
-}
-
-/* Expects the value to strictly equal to `-Infinity` (negative infinity). */
-function toBeNegativeInfinity(): Expectations<number>
-function toBeNegativeInfinity(this: ExpectationsContext): Expectations {
-  return check(this, `to equal ${stringifyValue(Number.NEGATIVE_INFINITY)}`, (value) => value === Number.NEGATIVE_INFINITY)
-}
-
-/* Expects the value to strictly equal to `null`. */
-function toBeNull(): Expectations<null>
-function toBeNull(this: ExpectationsContext): Expectations {
-  return check(this, `to be ${stringifyValue(null)}`, (value) => value === null)
-}
-
-/* Expects the value to strictly equal to `null` or `undefined`. */
-function toBeNullable(): Expectations<null | undefined>
-function toBeNullable(this: ExpectationsContext): Expectations {
-  return check(
-      this,
-      `to be ${stringifyValue(null)} or ${stringifyValue(undefined)}`,
-      (value) => ((value === null) || (value === undefined)))
-}
-
-/* Expects the value to strictly equal to `+Infinity` (positive infinity). */
-function toBePositiveInfinity(): Expectations<number>
-function toBePositiveInfinity(this: ExpectationsContext): Expectations {
-  return check(this, `to equal ${stringifyValue(Number.POSITIVE_INFINITY)}`, (value) => value === Number.POSITIVE_INFINITY)
-}
-
-/* Expects the value to strictly equal to `true`. */
-function toBeTrue(): Expectations<true>
-function toBeTrue(this: ExpectationsContext): Expectations {
-  return check(this, `to be ${stringifyValue(true)}`, (value) => value === true)
-}
-
-/* Expects the value to be _falsy_ (non-zero, non-empty string, `true`, ...). */
-function toBeTruthy<T>(this: T): T
-function toBeTruthy(this:ExpectationsContext): Expectations {
-  return check(this, 'to be truthy', (value) => !! value)
-}
-
-/* Expects the value to strictly equal to `undefined`. */
-function toBeUndefined(): Expectations<undefined>
-function toBeUndefined(this: ExpectationsContext): Expectations {
-  return check(this, `to be ${stringifyValue(undefined)}`, (value) => value === undefined)
-}
-
-/* === EXPORTS ============================================================== */
-
-/* coverage ignore next */
-export {
-  toBeDefined,
-  toBeFalse,
-  toBeFalsy,
-  toBeNaN,
-  toBeNegativeInfinity,
-  toBeNull,
-  toBeNullable,
-  toBePositiveInfinity,
-  toBeTrue,
-  toBeTruthy,
-  toBeUndefined,
-}
-
-/* ========================================================================== *
- * INTERNALS                                                                  *
- * ========================================================================== */
-
-function check(
-    context: ExpectationsContext,
-    details: string,
-    cb: (value: unknown) => boolean,
-): Expectations {
-  const match = cb(context.value)
-  if (match === context.negative) {
-    throw new ExpectationError(context, details)
-  } else {
-    return context.expects
-  }
-}