assertron 7.1.2 → 9.0.1

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

@@ -5,41 +5,51 @@
 [![NPM version][npm-image]][npm-url]
 [![NPM downloads][downloads-image]][downloads-url]
 
-[![TravisCI][travis-image]][travis-url]
-[![CircleCI][circleci-image]][circleci-url]
+[![Github NodeJS][github-nodejs]][github-action-url]
 [![Codecov][codecov-image]][codecov-url]
 [![Coverage Status][coveralls-image]][coveralls-url]
 
-[![Greenkeeper badge](https://badges.greenkeeper.io/unional/assertron.svg)](https://greenkeeper.io/)
-[![semantic-release](https://img.shields.io/badge/%20%20%F0%9F%93%A6%F0%9F%9A%80-semantic--release-e10079.svg)](https://github.com/semantic-release/semantic-release)
+[![Semantic Release][semantic-release-image]][semantic-release-url]
+
+[![Visual Studio Code][vscode-image]][vscode-url]
 
 A supplementary assertion library that runs on both NodeJS and browser.
 
 ## assertron
 
-`assertron` provides additional or improved assertion functions of the `assert` module.
+`assertron` provides a collection of assertion methods.
 
-```ts
-import { assertron } from 'assertron'
+### assertron.false(value)
 
-assertron.throws(Promise.reject(new Error('foo')))
-assertron.throws(() => { throw new Error('foo') })
-assertron.throws(() => Promise.reject(new Error('foo')))
+Asserts the provided value is false.
 
-assertron.pathEqual('dir/sub-dir/file.txt', 'dir\\sub-dir\\file.txt')
-```
+### assertron.falsy(value)
+
+Asserts the provided value is falsy.
+
+### assertron.pathEqual(actual, expected)
+
+Asserts the two paths are equal regardless of operating system differences.
+
+### assertron.rejects(promise)
+
+Asserts the promise rejects.
 
 ### assertron.repeat(fn, times)
 
 Repeat the specified function n times and return the last result.
 If the result is a promise, it will run the function sequentially.
 
+### assertron.resolves(promise)
+
+Asserts the promise resolves.
+
 ### assertron.satisfies(actual, expected)
 
 `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.
@@ -56,9 +66,33 @@ a.satisfies({ a: 'foo' }, { a: /boo/ })
 a.satisfies({ a: 1 }, { a: () => false })
 ```
 
+### assertron.throws(...)
+
+Asserts the promise, function, or async function throws (or rejects) an error.
+
+```ts
+import { assertron } from 'assertron'
+
+await assertron.throws(Promise.reject(new Error('foo')))
+assertron.throws(() => { throw new Error('foo') })
+await assertron.throws(() => Promise.reject(new Error('foo')))
+
+const e1 = await assertron.throws(Promise.reject(new SpecificError('foo')), SpecificError)
+const e2 = assertron.throws(() => { throw new SpecificError('foo') }, SpecificError)
+const e3 = await assertron.throws(() => Promise.reject(new SpecificError('foo')), SpecificError)
+```
+
+### assertron.true(value)
+
+Asserts the provided value is true.
+
+### assertron.truthy(value)
+
+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)
 
@@ -94,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'
@@ -138,19 +172,16 @@ for (let i = 1; i <= 4; i++) {
 }
 ```
 
-There are more methods available. Use TypeScript to discover them!
+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>"
@@ -164,43 +195,27 @@ 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
 ```
 
-Generated by `generator-unional@0.0.1`
-
 [npm-image]: https://img.shields.io/npm/v/assertron.svg?style=flat
 [npm-url]: https://npmjs.org/package/assertron
 [downloads-image]: https://img.shields.io/npm/dm/assertron.svg?style=flat
 [downloads-url]: https://npmjs.org/package/assertron
 
-[travis-image]: https://img.shields.io/travis/unional/assertron/master.svg?style=flat
-[travis-url]: https://travis-ci.org/unional/assertron?branch=master
-[circleci-image]: https://circleci.com/gh/unional/assertron/tree/master.svg?style=shield
-[circleci-url]: https://circleci.com/gh/unional/assertron/tree/master
-
+[github-nodejs]: https://github.com/unional/assertron/workflows/nodejs/badge.svg
+[github-action-url]: https://github.com/unional/assertron/actions
 [codecov-image]: https://codecov.io/gh/unional/assertron/branch/master/graph/badge.svg
 [codecov-url]: https://codecov.io/gh/unional/assertron
 [coveralls-image]: https://coveralls.io/repos/github/unional/assertron/badge.svg
 [coveralls-url]: https://coveralls.io/github/unional/assertron
 
-[green-keeper-image]: https://badges.greenkeeper.io/unional/assertron.svg
-[green-keeper-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
+
+[vscode-image]: https://img.shields.io/badge/vscode-ready-green.svg
+[vscode-url]: https://code.visualstudio.com/

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "assertron",
-  "version": "7.1.2",
+  "version": "9.0.1",
   "description": "A supplementary assertion library",
   "homepage": "https://github.com/unional/assertron",
   "bugs": {
@@ -15,41 +15,79 @@
     "name": "Homa Wong",
     "email": "homawong@gmail.com"
   },
+  "sideEffects": false,
+  "main": "cjs/index.js",
+  "module": "esm/index.js",
+  "jsnext:main": "esm/index.js",
+  "browser": {
+    "perf_hooks": false
+  },
+  "typings": "cjs/index.d.ts",
   "files": [
-    "dist",
-    "dist-es5",
-    "dist-es2015",
+    "cjs",
+    "esm",
     "src"
   ],
-  "main": "dist-es5/index.js",
-  "module": "dist-es2015/index.js",
-  "typings": "dist-es5/index.d.ts",
   "scripts": {
-    "build": "npm run build-es5 && npm run build-es2015",
-    "build-es2015": "tsc -p tsconfig.es2015.json",
-    "build-es5": "tsc -p tsconfig.es5.json",
-    "clean": "rimraf dist dist-es5 dist-es2015",
+    "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 cjs esm lib libm",
     "coverage": "jest --coverage",
-    "dependency-check": "dependency-check . --unused --no-dev && dependency-check . --missing --no-dev -i perf_hooks",
-    "lint": "tslint -p tsconfig.json",
+    "depcheck": "yarn dependency-check",
+    "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",
     "test": "jest",
-    "verify": "npm run lint && npm run build && npm run dependency-check && npm run coverage",
-    "watch": "jest --watch"
+    "test:watch": "jest --watch",
+    "verify": "yarn lint && yarn build && yarn dependency-check && yarn coverage",
+    "watch": "yarn test:watch"
   },
-  "browser": {
-    "perf_hooks": false
+  "husky": {
+    "hooks": {
+      "commit-msg": "commitlint -E HUSKY_GIT_PARAMS"
+    }
   },
   "dependencies": {
-    "assertion-error": "^1.1.0",
     "is-node": "^1.0.2",
-    "is-promise": "^2.1.0",
+    "is-promise": "^4.0.0",
+    "iso-error": "^4.1.0",
     "path-equal": "^1.1.1",
-    "satisfier": "^5.0.2",
-    "tersify": "^3.0.1"
+    "satisfier": "^5.1.1",
+    "tersify": "^3.7.9",
+    "tslib": "^2.3.1",
+    "type-plus": "^4.0.0"
   },
   "devDependencies": {
-    "@types/lodash": "^4.14.126",
-    "@unional/devpkg-node": "^1.3.0",
-    "lodash": "^4.17.11"
+    "@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,7 +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()
@@ -256,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)
 })
@@ -266,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)
 })
@@ -287,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)
 
@@ -295,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)
 })
@@ -311,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)
 })
@@ -332,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)
 })
@@ -422,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()
@@ -435,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,21 +73,21 @@ 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
+        let firstError: any
         let hasPass = false
         asserts.forEach(assert => {
           try {
@@ -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[method], step)
+      throw new InvalidOrder(this.state.get(), method, [step], { ssf: (this as any)[method] })
     }
   }
 }

package/src/assert-order/InvalidOrder.ts

@@ -1,13 +1,9 @@
-import AssertionError from 'assertion-error';
-import { State } from './interfaces';
+import { AssertionError } from '../errors'
+import { State } from './types'
 
 export class InvalidOrder extends AssertionError {
-  method: string
-  args: any[]
-  state: State
-  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)
   }
 }
 
@@ -15,7 +11,7 @@ function getEndMessage(state: State) {
   return `Planned for ${state.maxStep} step but expecting step ${state.step} when 'end()' is called`
 }
 
-function getExpectingMessage(state, method, args) {
+function getExpectingMessage(state: State, method: string, args: any[]) {
   return `Expecting ${getExpectingCalls(state)}, but received '${method}(${getMethodArgs(args)})'`
 }
 
@@ -23,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,48 +13,47 @@ 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 startTick
-let timeTaken
+let timeTracker: { start(): void, taken(): number }
 // istanbul ignore else
-// tslint:disable-next-line
 if (process && typeof process.hrtime === 'function') {
-  startTick = process.hrtime
-  timeTaken = function (startTick) {
-    const [second, nanoSecond] = process.hrtime(startTick)
-    return second * 1000 + nanoSecond / 1e6
+  let tick: [number, number]
+  timeTracker = {
+    start() { tick = process.hrtime() },
+    taken() {
+      const [second, nanoSecond] = process.hrtime(tick)
+      return second * 1000 + nanoSecond / 1e6
+    }
   }
 }
-// tslint:disable-next-line
 else if (performance && typeof performance.now === 'function') {
-  startTick = performance.now
-  timeTaken = function (startTick) {
-    const end = performance.now()
-    return end - startTick
+  let tick: number
+  timeTracker = {
+    start() { tick = performance.now() },
+    taken() { return performance.now() - tick }
   }
 }
 else {
-  startTick = function () {
-    return new Date().valueOf()
-  }
-  timeTaken = function (startTick) {
-    return new Date().valueOf() - startTick
+  let tick: number
+  timeTracker = {
+    start() { tick = new Date().valueOf() },
+    taken() { return new Date().valueOf() - tick }
   }
 }
 
 export class StateMachine {
-  listeners = {}
-  step: number = 1
+  listeners: Record<number, Array<() => void>> = {}
+  step = 1
   maxStep?: number
 
-  subStep: number = 0
+  subStep = 0
   minSubStep?: number
   maxSubStep?: number
-  private startTick: [number, number] | number
   constructor(maxStep?: number) {
     this.maxStep = maxStep
-    this.startTick = this.getStartTick()
+    timeTracker.start()
   }
   jump(step: number) {
     this.step = step
@@ -87,7 +85,7 @@ export class StateMachine {
       maxSubStep
     }
   }
-  on(step: number, listener) {
+  on(step: number, listener: () => void) {
     this.listeners[step] = [listener]
   }
   isNotValid(step: number) {
@@ -107,9 +105,6 @@ export class StateMachine {
     return this.maxStep ? this.maxStep >= this.step : true
   }
   getTimeTaken() {
-    return timeTaken(this.startTick)
-  }
-  private getStartTick() {
-    return startTick()
+    return timeTracker.taken()
   }
 }

package/src/assert-order/index.ts

@@ -1,2 +1,4 @@
 export * from './AssertOrder'
-export * from './interfaces'
+export * from './InvalidOrder'
+export * from './types'
+

package/src/assert-order/internalInterfaces.ts

@@ -1,5 +1,5 @@
 export interface Steps {
-  once?: number[]
-  some?: number[]
-  all?: number[]
+  once?: number[],
+  some?: number[],
+  all?: number[],
 }

package/src/assert-order/types.ts

@@ -0,0 +1,7 @@
+export interface State {
+  step: number,
+  maxStep?: number,
+  subStep: number,
+  minSubStep?: number,
+  maxSubStep?: number,
+}

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', () => {
@@ -21,7 +20,6 @@ describe('false()', () => {
   })
 })
 
-
 describe('true()', () => {
   test('non-true statement throws', () => {
     assertThrows(() => a.true(false), AssertionError)