assertron 7.1.3 → 9.0.2

package/LICENSE

@@ -14,8 +14,8 @@ all copies or substantial portions of the Software.
 
 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES, OR OTHER
 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 THE SOFTWARE.

package/README.md

@@ -9,7 +9,6 @@
 [![Codecov][codecov-image]][codecov-url]
 [![Coverage Status][coveralls-image]][coveralls-url]
 
-[![Greenkeeper][greenkeeper-image]][greenkeeper-url]
 [![Semantic Release][semantic-release-image]][semantic-release-url]
 
 [![Visual Studio Code][vscode-image]][vscode-url]
@@ -26,7 +25,7 @@ Asserts the provided value is false.
 
 ### assertron.falsy(value)
 
-Asserts the provides value is falsy.
+Asserts the provided value is falsy.
 
 ### assertron.pathEqual(actual, expected)
 
@@ -50,7 +49,7 @@ Asserts the promise resolves.
 `assertron.satisfies()` checks if `actual` meets the requirements specified by `expected`.
 Each property in `expected` can be a value, a `RegExp`, or a predicate function.
 It uses `satisfier` internally to check for validity.
-Check out [`sateisfier`](https://github.com/unional/satisfier) for more detail.
+Check out [`satisfier`](https://github.com/unional/satisfier) for more detail.
 
 ```ts
 import a from 'assertron' // assertron is also exported as default.
@@ -69,7 +68,7 @@ a.satisfies({ a: 1 }, { a: () => false })
 
 ### assertron.throws(...)
 
-Asserts the promise, function, or async function throws (or reject) an error.
+Asserts the promise, function, or async function throws (or rejects) an error.
 
 ```ts
 import { assertron } from 'assertron'
@@ -93,7 +92,7 @@ Asserts the provided value is truthy.
 
 ## AssertOrder
 
-Assert code are executed in expected order.
+Assert the code is executed in the expected order.
 
 ### order.once(step: number)
 
@@ -129,7 +128,7 @@ boo()
 
 ### order.atLeastOnce(step: number)
 
-Assert step `step` have executed at least once.
+Assert the `step` executed at least once.
 
 ```ts
 import { AssertOrder } from 'assertron'
@@ -178,14 +177,11 @@ There are other methods available. Use TypeScript to discover them!
 ## Contribute
 
 ```sh
-# right after fork
-npm install
+yarn
 
-# begin making changes
+# start making changes
 git checkout -b <branch>
-npm run watch
-
-# edit `webpack.config.dev.js` to exclude dependencies for the global build.
+yarn watch
 
 # after making change(s)
 git commit -m "<commit message>"
@@ -199,23 +195,11 @@ git push
 There are a few useful commands you can use during development.
 
 ```sh
-# Run tests (and lint) automatically whenever you save a file.
-npm run watch
-
-# Run tests with coverage stats (but won't fail you if coverage does not meet criteria)
-npm run test
-
-# Manually verify the project.
-# This will be ran during 'npm preversion' so you normally don't need to run this yourself.
-npm run verify
+yarn test
 
-# Build the project.
-# You normally don't need to do this.
-npm run build
+yarn watch
 
-# Run tslint
-# You normally don't need to do this as `npm run watch` and `npm version` will automatically run lint for you.
-npm run lint
+yarn verify
 ```
 
 [npm-image]: https://img.shields.io/npm/v/assertron.svg?style=flat
@@ -230,8 +214,6 @@ npm run lint
 [coveralls-image]: https://coveralls.io/repos/github/unional/assertron/badge.svg
 [coveralls-url]: https://coveralls.io/github/unional/assertron
 
-[greenkeeper-image]: https://badges.greenkeeper.io/unional/assertron.svg
-[greenkeeper-url]: https://greenkeeper.io/
 [semantic-release-image]: https://img.shields.io/badge/%20%20%F0%9F%93%A6%F0%9F%9A%80-semantic--release-e10079.svg
 [semantic-release-url]: https://github.com/semantic-release/semantic-release
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "assertron",
-  "version": "7.1.3",
+  "version": "9.0.2",
   "description": "A supplementary assertion library",
   "homepage": "https://github.com/unional/assertron",
   "bugs": {
@@ -16,31 +16,29 @@
     "email": "homawong@gmail.com"
   },
   "sideEffects": false,
-  "main": "lib/index.js",
-  "module": "libm/index.js",
-  "jsnext:main": "libm/index.js",
+  "main": "cjs/index.js",
+  "module": "esm/index.js",
+  "jsnext:main": "esm/index.js",
   "browser": {
     "perf_hooks": false
   },
-  "typings": "lib/index.d.ts",
+  "typings": "cjs/index.d.ts",
   "files": [
-    "lib",
-    "libm",
+    "cjs",
+    "esm",
     "src"
   ],
   "scripts": {
-    "build": "yarn build:libm && yarn build:lib",
-    "build:lib": "tsc -p tsconfig.lib.json",
-    "build:libm": "tsc -p tsconfig.libm.json",
+    "build": "yarn build:esm && yarn build:cjs",
+    "build:cjs": "tsc -p tsconfig.cjs.json",
+    "build:esm": "tsc -p tsconfig.esm.json",
     "build:watch": "tsc --watch",
-    "clean": "rimraf .nyc_output .ts coverage lib libm",
-    "codacy": "cat coverage/lcov.info | codacy-coverage",
+    "clean": "rimraf .nyc_output .ts coverage cjs esm lib libm",
     "coverage": "jest --coverage",
     "depcheck": "yarn dependency-check",
-    "dependency-check": "dependency-check . --unused --no-dev -i global-store -i @types/node -i standard-log-color && dependency-check . --missing --no-dev",
+    "dependency-check": "dependency-check . --unused --no-dev -i type-plus -i global-store -i @types/node -i standard-log-color && dependency-check . --missing --no-dev",
     "lint": "eslint --ext=js,ts .",
     "nuke": "yarn clean && rimraf node_modules",
-    "semantic-release": "semantic-release",
     "test": "jest",
     "test:watch": "jest --watch",
     "verify": "yarn lint && yarn build && yarn dependency-check && yarn coverage",
@@ -52,28 +50,44 @@
     }
   },
   "dependencies": {
-    "assertion-error": "^1.1.0",
     "is-node": "^1.0.2",
-    "is-promise": "^2.1.0",
-    "path-equal": "^1.1.1",
-    "satisfier": "^5.1.0",
-    "tersify": "^3.7.0",
-    "tslib": "^1.11.1"
+    "is-promise": "^4.0.0",
+    "iso-error": "^4.1.0",
+    "path-equal": "^1.1.3",
+    "satisfier": "^5.1.1",
+    "tersify": "^3.7.11",
+    "tslib": "^2.3.1",
+    "type-plus": "^4.0.0"
   },
   "devDependencies": {
-    "@babel/core": "^7.8.6",
-    "@babel/plugin-proposal-nullish-coalescing-operator": "^7.8.3",
-    "@babel/plugin-proposal-optional-chaining": "^7.8.3",
-    "@babel/preset-env": "^7.8.6",
-    "@babel/preset-typescript": "^7.8.3",
-    "@commitlint/cli": "^8.3.5",
-    "@commitlint/config-conventional": "^8.3.4",
-    "@types/lodash": "^4.14.149",
-    "@unional/devpkg-node": "^1.5.0",
-    "codacy-coverage": "^3.4.0",
-    "commitlint-circle": "^1.0.0",
-    "husky": "^4.2.3",
-    "lodash": "^4.17.15",
-    "semantic-release": "^17.0.4"
+    "@babel/core": "^7.16.5",
+    "@babel/plugin-proposal-nullish-coalescing-operator": "^7.16.5",
+    "@babel/plugin-proposal-optional-chaining": "^7.16.5",
+    "@babel/preset-env": "^7.16.5",
+    "@babel/preset-typescript": "^7.16.5",
+    "@commitlint/cli": "^16.0.0",
+    "@commitlint/config-conventional": "^16.0.0",
+    "@types/jest": "^27.0.3",
+    "@types/lodash": "^4.14.178",
+    "@types/node": "^17.0.4",
+    "@typescript-eslint/eslint-plugin": "^5.8.0",
+    "@typescript-eslint/parser": "^5.8.0",
+    "babel-jest": "^27.4.5",
+    "dependency-check": "^4.1.0",
+    "eslint": "^8.5.0",
+    "eslint-plugin-harmony": "^6.0.0",
+    "husky": "^7.0.4",
+    "jest": "^27.4.5",
+    "jest-junit": "^13.0.0",
+    "jest-progress-tracker": "^3.0.1",
+    "jest-validate": "^27.4.2",
+    "jest-watch-repeat": "^2.0.0",
+    "jest-watch-suspend": "^1.1.2",
+    "jest-watch-toggle-config": "^2.0.1",
+    "jest-watch-typeahead": "^1.0.0",
+    "node-supported-releases": "^0.0.0",
+    "rimraf": "^3.0.2",
+    "typescript": "^4.5.4",
+    "update-notifier": "^5.1.0"
   }
 }

package/src/assert-order/AssertOrder.spec.ts

@@ -1,6 +1,5 @@
 import t from 'assert';
-import AssertionError from 'assertion-error';
-import a, { AssertOrder, State } from '..';
+import a, { AssertOrder, InvalidOrder, State } from '..';
 
 test('is() expecting 1', () => {
   const order = new AssertOrder()
@@ -255,7 +254,7 @@ test(`onAny() throws if all assert functions throws`, () => {
 test('AssertOrder(0) accepts no step >= 1', () => {
   const order = new AssertOrder(0)
 
-  const err = a.throws(() => order.once(1)) as AssertionError<{ state: any }>
+  const err = a.throws(() => order.once(1), InvalidOrder)
 
   t.strictEqual(err.state.maxStep, 0)
 })
@@ -265,7 +264,7 @@ test('AssertOrder(1) accepts step 1 but not 2', () => {
 
   order.once(1)
 
-  const err = a.throws(() => order.once(2)) as AssertionError<{ state: any }>
+  const err = a.throws(() => order.once(2), InvalidOrder)
 
   t.strictEqual(err.state.maxStep, 1)
 })
@@ -286,7 +285,7 @@ test('end() would mark to not accepting more steps if plan is not defined', () =
   let order = new AssertOrder()
   order.end()
 
-  let err = a.throws(() => order.once(1)) as AssertionError<{ state: any }>
+  let err = a.throws(() => order.once(1), InvalidOrder)
 
   t.strictEqual(err.state.maxStep, 0)
 
@@ -294,7 +293,7 @@ test('end() would mark to not accepting more steps if plan is not defined', () =
   order.once(1)
   order.end()
 
-  err = a.throws(() => order.once(2)) as AssertionError<{ state: any }>
+  err = a.throws(() => order.once(2), InvalidOrder)
 
   t.strictEqual(err.state.maxStep, 1)
 })
@@ -310,7 +309,7 @@ test('end() throws if planned step not met', () => {
   const order = new AssertOrder(2)
   order.once(1)
 
-  const err = a.throws(() => order.end()) as AssertionError<{ state: any }>
+  const err = a.throws(() => order.end(), InvalidOrder)
 
   t.strictEqual(err.state.maxStep, 2)
 })
@@ -331,7 +330,7 @@ test('end(n) waits n milliseconds and fail when step not met', async () => {
   setTimeout(() => {
     order.once(1)
   }, 10)
-  const err = await a.throws(order.end(1)) as AssertionError<{ state: any }>
+  const err = await a.throws(order.end(1), InvalidOrder)
 
   t.strictEqual(err.state.maxStep, 1)
 })
@@ -421,7 +420,7 @@ test('wait(step, callback) will execute the async callback but not wait for it a
   const o2 = new AssertOrder(1)
 
   order.wait(1, () => {
-    return new Promise(a => {
+    return new Promise<void>(a => {
       setImmediate(() => {
         o2.once(1)
         a()
@@ -434,8 +433,8 @@ test('wait(step, callback) will execute the async callback but not wait for it a
   return o2.end(100)
 })
 
-async function assertOrderThrows(fn, state: Partial<State>, method, ...args) {
-  const err = await a.throws(fn) as AssertionError<{ state: any, method: string, args: any[] }>
+async function assertOrderThrows(fn: () => any, state: Partial<State>, method: string, ...args: any[]) {
+  const err = await a.throws(fn, InvalidOrder)
   t.strictEqual(err.method, method)
   t.deepStrictEqual(err.args, args)
   if (state.step) {

package/src/assert-order/AssertOrder.ts

@@ -31,7 +31,7 @@ export class AssertOrder {
    */
   not(step: number) {
     if (this.state.isValid(step)) {
-      throw new InvalidOrder(this.state.get(), 'not', this.not, step)
+      throw new InvalidOrder(this.state.get(), 'not', [step], { ssf: this.not })
     }
   }
 
@@ -73,18 +73,18 @@ export class AssertOrder {
       return this.state.moveSubStep()
     }
     else
-      throw new InvalidOrder(this.state.get(), 'atLeastOnce', this.atLeastOnce, step)
+      throw new InvalidOrder(this.state.get(), 'atLeastOnce', [step], { ssf: this.atLeastOnce })
   }
 
   any(steps: number[]) {
     const index = steps.indexOf(this.state.step)
     if (index === -1)
-      throw new InvalidOrder(this.state.get(), 'any', this.any, steps)
+      throw new InvalidOrder(this.state.get(), 'any', [steps], { ssf: this.any })
 
     this.state.move()
     return steps[index]
   }
-  onAny(steps: number[], ...asserts: Function[]) {
+  onAny(steps: number[], ...asserts: Array<(...args: any[]) => any>) {
     steps.forEach(step => {
       this.state.on(step, () => {
         let firstError: any
@@ -121,12 +121,12 @@ export class AssertOrder {
     }
 
     if (this.state.isAccepting()) {
-      throw new InvalidOrder(this.state.get(), 'end', this.end)
+      throw new InvalidOrder(this.state.get(), 'end', [], { ssf: this.end })
     }
   }
   exactly(step: number, times: number) {
     if (this.state.isNotValid(step))
-      throw new InvalidOrder(this.state.get(), 'exactly', this.exactly, step, times)
+      throw new InvalidOrder(this.state.get(), 'exactly', [step, times], { ssf: this.exactly })
 
     if (this.state.maxSubStep === undefined) {
       this.state.maxSubStep = times
@@ -145,7 +145,7 @@ export class AssertOrder {
   }
   private assert(method: string, step: number) {
     if (this.state.isNotValid(step)) {
-      throw new InvalidOrder(this.state.get(), method, (this as any)[method], step)
+      throw new InvalidOrder(this.state.get(), method, [step], { ssf: (this as any)[method] })
     }
   }
 }

package/src/assert-order/InvalidOrder.ts

@@ -1,10 +1,9 @@
-import AssertionError from 'assertion-error';
-import { State } from './interfaces';
+import { AssertionError } from '../errors'
+import { State } from './types'
 
 export class InvalidOrder extends AssertionError {
-  constructor(state: State, method: string, ssf: Function, ...args: any[]) {
-    const message = method === 'end' ? getEndMessage(state) : getExpectingMessage(state, method, args)
-    super(message, { method, state, args }, ssf)
+  constructor(public state: State, public method: string, public args: any[], options: AssertionError.Options) {
+    super(method === 'end' ? getEndMessage(state) : getExpectingMessage(state, method, args), options)
   }
 }
 
@@ -20,9 +19,8 @@ function getExpectingCalls(state: State) {
   let message: string
   if (state.subStep === 0) {
     const methods = ['is', 'once', 'any']
-    message = methods.map(m => ['any'].indexOf(m) === -1 ?
-      `'${m}(${state.step})'` :
-      `'${m}([${state.step}])'`
+    message = methods.map(
+      m => `'${m}(${['any'].indexOf(m) === -1 ? state.step : `[${state.step}]`})'`
     ).join(', ')
   }
   else {

package/src/assert-order/StateMachine.ts

@@ -1,11 +1,10 @@
 import isNode from 'is-node'
-import { State } from './interfaces'
+import { State } from './types'
 
 // istanbul ignore next
 function nodeVersionIsOrAbove(major: number, minor = 0, patch = 0) {
-  // without this, systemjs will complain `process is not defined`
-  if (!global.process)
-    return false
+  // without this, systemJS will complain `process is not defined`
+  if (!global.process) return false
   const versionString = process.version.startsWith('v') ? process.version.slice(1) : process.version
   const [actualMajor, actualMinor, actualPatch] = versionString.split('.').map(s => parseInt(s, 10))
   const checking = major * 1000 * 1000 + minor * 1000 + patch
@@ -14,6 +13,7 @@ function nodeVersionIsOrAbove(major: number, minor = 0, patch = 0) {
 }
 
 // istanbul ignore next
+// eslint-disable-next-line @typescript-eslint/no-var-requires
 const performance = isNode && nodeVersionIsOrAbove(8, 5) ? require('perf_hooks').performance : undefined
 
 let timeTracker: { start(): void, taken(): number }

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,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'
 
 describe('false()', () => {
   test('non-false statement throws', () => {

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,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 { FailOnOccurance } from './repeat';
+import a, { FailOnOccurrence } from '..'
 
 test('repeat function n times', () => {
   let count = 0
@@ -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
-  const 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')
 })