beartest-js 6.0.4 → 7.0.1

package/.prettierrc

@@ -1,5 +1,9 @@
 {
   "tabWidth": 2,
-  "useTabs": false,
-  "printWidth": 100
+  "printWidth": 125,
+  "singleQuote": true,
+  "semi": false,
+  "trailingComma": "none",
+  "bracketSpacing": true,
+  "arrowParens": "always"
 }

package/README.md

@@ -22,7 +22,19 @@ The Beartest test runner uses common js to load files.
 
 ### Usage
 
-_Beartest_ implements the following functions `describe`, `it`, `beforeAll`, `beforeEach`, `afterEach`, `afterAll`, `it.skip`, and `it.only`. All provided functions work in a similar way as the corresponding functions in Jest.
+_Beartest_ exports a `test` function that provides the following API:
+- `test(name, fn)` - Define a test
+- `test.describe(name, fn)` - Group tests into a suite
+- `test.before(fn)` - Run before all tests in a suite
+- `test.beforeEach(fn)` - Run before each test in a suite
+- `test.after(fn)` - Run after all tests in a suite
+- `test.afterEach(fn)` - Run after each test in a suite
+- `test.skip(name, fn)` - Skip a test
+- `test.only(name, fn)` - Run only this test
+- `test.describe.skip(name, fn)` - Skip a suite
+- `test.describe.only(name, fn)` - Run only this suite
+
+All provided functions work in a similar way as the corresponding functions in Jest.
 
 ### Example
 
@@ -43,7 +55,7 @@ test.describe("Math Testing", () => {
 
 ### Running Tests
 
-Additionally, a very basic test runner is included. This test runner accepts a glob pattern as a command line argument. The test runner can be invoked with `yarn beartest "glob-pattern"`. By default, it will look for `**/*.test.js`.
+Additionally, a very basic test runner is included. This test runner accepts a glob pattern as a command line argument. The test runner can be invoked with `yarn beartest "glob-pattern"`. By default, it will look for `**/*.test.*`.
 
 Suggested package script:
 

package/beartest.js

@@ -1,100 +1,144 @@
-const rgb = require("barecolor");
-
+const path = require('node:path')
 async function RunSerially(fnArray) {
-  for (const fn of fnArray) {
-    await fn();
-  }
+  for (const fn of fnArray) await fn()
 }
-const suiteStack = [];
-let testRunPromise = Promise.resolve();
-const top = () => (suiteStack.length ? suiteStack[suiteStack.length - 1] : null);
-const topSafe = () => (suiteStack.length ? suiteStack[suiteStack.length - 1] : makeSuite(""));
 
-const registerTest = (suite, name, fn) => async () => {
-  const prefix = "  ".repeat(suite.depth);
+async function* runTestSuite(options = {}) {
+  const suite = top()
+  const tests = (suite.tests.some((t) => t.only) ? suite.tests.filter((t) => t.only) : suite.tests).filter(
+    (t) => !options.only?.length || options.only[0] === t.name
+  )
   try {
-    await suite.beforeEach();
-    await fn();
-    rgb.green(prefix + `✓`);
-    rgb.gray(` ${name}\n`);
-  } catch (e) {
-    rgb.red(`\n${prefix}✗ ${name} \n\n`);
-    throw e;
+    await RunSerially(suite.before)
+    for (let index = 0; index < tests.length; index++) {
+      const test = tests[index]
+      let startTime
+
+      const testDetails = { name: test.name, nesting: suiteStack.length, testNumber: index, skip: test.skip }
+      const startEvent = { type: 'test:start', data: { name: test.name, nesting: suiteStack.length, type: test.type } }
+      const pass = (duration) => ({
+        type: 'test:pass',
+        data: { details: { duration_ms: duration, type: test.type }, ...testDetails }
+      })
+      if (test.skip) {
+        yield startEvent
+        yield pass(0)
+      } else {
+        try {
+          await RunSerially(suite.beforeEach)
+          yield startEvent
+          startTime = Date.now()
+
+          if (test.type === 'suite') {
+            suiteStack.push({ before: [], beforeEach: [], after: [], afterEach: [], tests: [], name: test.name })
+            try {
+              await test.fn()
+              for await (const event of runTestSuite({ only: options.only ? options.only.slice(1) : undefined })) {
+                yield event
+              }
+            } finally {
+              suiteStack.pop()
+            }
+          } else {
+            await test.fn()
+          }
+          yield pass(Date.now() - startTime)
+        } catch (e) {
+          const error = new Error('[TEST FAILURE]', { cause: e })
+          yield {
+            type: 'test:fail',
+            data: {
+              details: { duration_ms: startTime ? Date.now() - startTime : NaN, type: test.type, error },
+              ...testDetails
+            }
+          }
+          throw e
+        } finally {
+          await RunSerially(suite.afterEach)
+        }
+      }
+    }
   } finally {
-    await suite.afterEach();
+    await RunSerially(suite.after)
   }
-};
+}
 
-async function runSuite(suite) {
-  const prefix = "  ".repeat(suite.depth);
-  const tests = suite.only.length > 0 ? suite.only : suite.tests;
-  rgb.cyanln(prefix + suite.headline + " ");
-  try {
-    await suite.beforeAll();
-    await RunSerially(tests);
-  } finally {
-    await suite.afterAll();
+const suiteStack = []
+
+function top() {
+  if (!suiteStack.length) {
+    suiteStack.push({ before: [], beforeEach: [], after: [], afterEach: [], tests: [], name: '' })
   }
+  return suiteStack[suiteStack.length - 1]
 }
 
-function makeSuite(headline, only = false, fn = null) {
-  const parent = fn ? topSafe() : top();
-  const self = {
-    depth: parent ? parent.depth + 1 : 0,
-    headline,
-    beforeAllHooks: [],
-    async beforeAll() {
-      await RunSerially(this.beforeAllHooks);
-    },
-    beforeEachHooks: [],
-    async beforeEach() {
-      if (parent) await parent.beforeEach();
-      await RunSerially(this.beforeEachHooks);
-    },
-    afterAllHooks: [],
-    async afterAll() {
-      await RunSerially(this.afterAllHooks);
-    },
-    afterEachHooks: [],
-    async afterEach() {
-      await RunSerially(this.afterEachHooks);
-      if (parent) await parent.afterEach();
-    },
-    tests: [],
-    only: [],
-  };
-  if (parent && only) parent.only.push(() => runSuite(self));
-  if (parent && !only) parent.tests.push(() => runSuite(self));
-  suiteStack.push(self);
-  if (fn) fn();
-  if (fn) suiteStack.pop();
-  if (self.depth === 0) {
-    testRunPromise = new Promise((resolve) => setTimeout(resolve, 0)).then(() => {
-      suiteStack.pop();
-      return runSuite(self);
-    });
+const describe = (name, fn) => top().tests.push({ name: name, type: 'suite', fn, skip: false, only: false })
+describe.skip = (name, fn) => top().tests.push({ name: name, type: 'suite', fn, skip: true, only: false })
+describe.only = (name, fn) => top().tests.push({ name: name, type: 'suite', fn, skip: false, only: true })
+const it = (name, fn) => top().tests.push({ name: name, type: 'test', fn, skip: false, only: false })
+it.only = (name, fn) => top().tests.push({ name: name, type: 'test', fn, skip: false, only: true })
+it.skip = (name, fn) => top().tests.push({ name: name, type: 'test', fn, skip: true, only: false })
+const before = (fn) => top().before.push(fn)
+const beforeEach = (fn) => top().beforeEach.push(fn)
+const after = (fn) => top().after.push(fn)
+const afterEach = (fn) => top().afterEach.push(fn)
+
+async function* runTests(options = {}) {
+  let index = 0
+  for await (const file of options.files) {
+    const name = file
+    const suiteDetails = { name: name, nesting: 0, testNumber: index, skip: false }
+    suiteStack.push({ before: [], beforeEach: [], after: [], afterEach: [], tests: [], name })
+    let suiteStart
+    try {
+      require(file)
+      yield { type: 'test:start', data: { name: name, nesting: 0, type: 'suite' } }
+      suiteStart = Date.now()
+      for await (let event of runTestSuite({ only: options.only })) {
+        yield event
+      }
+      yield {
+        type: 'test:pass',
+        data: { details: { duration_ms: Date.now() - suiteStart, type: 'suite' }, ...suiteDetails }
+      }
+    } catch (e) {
+      yield {
+        type: 'test:fail',
+        data: {
+          details: { duration_ms: suiteStart ? Date.now() - suiteStart : NaN, type: 'suite', error: e },
+          ...suiteDetails
+        }
+      }
+      throw e
+    } finally {
+      suiteStack.pop()
+      index++
+    }
   }
-  return self;
 }
 
-const describe = (headline, fn) => makeSuite(headline, false, fn);
-describe.skip = () => {};
-describe.only = (headline, fn) => makeSuite(headline, true, fn);
-const it = (name, fn) => topSafe().tests.push(registerTest(topSafe(), name, fn));
-it.only = (name, fn) => topSafe().only.push(registerTest(topSafe(), name, fn));
-it.skip = () => {};
-const before = (fn) => topSafe().beforeAllHooks.push(fn);
-const after = (fn) => topSafe().afterAllHooks.push(fn);
-const beforeEach = (fn) => topSafe().beforeEachHooks.push(fn);
-const afterEach = (fn) => topSafe().afterEachHooks.push(fn);
+if (!suiteStack.length) {
+  new Promise((resolve) => setTimeout(resolve, 0)).then(async () => {
+    if (suiteStack.length) {
+      for await (let event of runTestSuite()) {
+        const prefix = '  '.repeat(event.data.nesting)
+        if (event.type === 'test:start' && event.data.type === 'suite') {
+          if (path.isAbsolute(event.data.name)) {
+            console.log(
+              `\x1b[36m${prefix}${path.parse(event.data.name).name} (${path.relative('./', event.data.name)})\x1b[0m`
+            )
+          } else {
+            console.log(`\x1b[36m${prefix}${event.data.name}\x1b[0m`)
+          }
+        } else if (event.type === 'test:pass' && event.data.details.type === 'test' && !event.data.skip) {
+          console.log(`\x1b[32m\n${prefix}✓\x1b[0m\x1b[90m ${event.data.name}\n\x1b[0m`)
+        } else if (event.type === 'test:fail' && event.data.details.type === 'test') {
+          console.log(`\x1b[31m\n${prefix}✗ ${event.data.name}\n\x1b[0m`)
+        }
+      }
+      process.exit(0)
+    }
+  })
+}
 
-module.exports = {
-  test: Object.assign(it, {
-    describe,
-    before,
-    after,
-    beforeEach,
-    afterEach,
-  }),
-  runner: { waitForTests: () => testRunPromise },
-};
+module.exports = { test: Object.assign(it, { describe, before, beforeEach, after, afterEach }), run: runTests }

package/cli.js

@@ -0,0 +1,22 @@
+#!/usr/bin/env node
+const { run } = require('./beartest')
+const fs = require('node:fs')
+
+async function cli() {
+  const globStr = process.argv[2] || '**/*.test.*'
+
+  const files = await Array.fromAsync(fs.promises.glob(globStr))
+
+  for await (let event of run({ files: files })) {
+    const prefix = '  '.repeat(event.data.nesting)
+    if (event.type === 'test:start' && event.data.type === 'suite') {
+      process.stdout.write(`\x1b[36m${prefix}${event.data.name} \n\x1b[0m`)
+    } else if (event.type === 'test:pass' && event.data.details.type === 'test' && !event.data.skip) {
+      process.stdout.write(`\x1b[32m${prefix}✓\x1b[0m\x1b[90m ${event.data.name}\n\x1b[0m`)
+    } else if (event.type === 'test:fail' && event.data.details.type === 'test') {
+      process.stdout.write(`\x1b[31m\n${prefix}✗ ${event.data.name} \n\n\x1b[0m`)
+    }
+  }
+}
+
+cli()

package/index.d.ts

@@ -1,16 +1,92 @@
-type testFn = (name: string, fn: () => unknown) => void;
-
-type BearTest = testFn & {
-  skip: testFn;
-  only: testFn;
-  describe: testFn & { skip: testFn; only: testFn };
-  before(fn: () => unknown): void;
-  after(fn: () => unknown): void;
-  beforeEach(fn: () => unknown): void;
-  afterEach(fn: () => unknown): void;
-};
-
-export declare const test: BearTest;
-export declare const runner: {
-  waitForTests: Promise<void>;
-};
+export type TestConfig = {
+  name: string
+  skip: boolean
+  only: boolean
+  type: 'suite' | 'test'
+  fn: () => unknown
+}
+
+export interface TestSuite {
+  before: (() => unknown)[]
+  beforeEach: (() => unknown)[]
+  after: (() => unknown)[]
+  afterEach: (() => unknown)[]
+  tests: TestConfig[]
+  name: string
+}
+
+export type TestEvent = TestStart | TestPass | TestFail
+
+export interface TestStart {
+  type: 'test:start'
+  data: {
+    /** The test name. */
+    name: string
+    /** The nesting level of the test. */
+    nesting: number
+    type: 'suite' | 'test' | undefined
+  }
+}
+
+export interface TestPass {
+  type: 'test:pass'
+  data: {
+    details: {
+      /** The duration of the test in milliseconds. */
+      duration_ms: number
+      /** The type of the test, used to denote whether this is a suite. */
+      type: 'suite' | 'test' | undefined
+    }
+    /** The test name. */
+    name: string
+    /** The nesting level of the test. */
+    nesting: number
+    /** The ordinal number of the test. */
+    testNumber: number
+    /** Present if context.skip is called. */
+    skip: boolean
+  }
+}
+
+export interface TestFail {
+  type: 'test:fail'
+  data: {
+    /** Additional execution metadata. */
+    details: {
+      /** The duration of the test in milliseconds. */
+      duration_ms: number
+      /** An error wrapping the error thrown by the test. */
+      error: Error
+      /** The type of the test, used to denote whether this is a suite. */
+      type: 'suite' | 'test' | undefined
+    }
+    /** The test name. */
+    name: string
+    /** The nesting level of the test. */
+    nesting: number
+    /** The ordinal number of the test. */
+    testNumber: number
+    /** Present if context.skip is called. */
+    skip: boolean
+  }
+}
+
+export interface TestFunction {
+  (name: string, fn: () => unknown): void
+  only(name: string, fn: () => unknown): void
+  skip(name: string, fn: () => unknown): void
+  describe: DescribeFunction
+  before(callback: () => unknown): void
+  beforeEach(callback: () => unknown): void
+  after(callback: () => unknown): void
+  afterEach(callback: () => unknown): void
+}
+
+export interface DescribeFunction {
+  (name: string, fn: () => unknown): void
+  only: (name: string, fn: () => unknown) => void
+  skip: (name: string, fn: () => unknown) => void
+}
+
+export const test: TestFunction
+export const run: (options: { files: AsyncIterable<string> | Iterable<string> }) => AsyncGenerator<TestEvent>

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "beartest-js",
-  "version": "6.0.4",
+  "version": "7.0.1",
   "description": "Bear Bones Testing",
   "repository": {
     "type": "git",
@@ -8,21 +8,23 @@
   },
   "types": "./index.d.ts",
   "main": "./index.js",
+  "exports": {
+    ".": {
+      "require": "./index.js",
+      "import": "./index.js"
+    },
+    "./package.json": "./package.json"
+  },
   "bin": {
-    "beartest": "testrunner.js"
+    "beartest": "cli.js"
   },
   "author": "Grant Colestock",
   "license": "MIT",
   "type": "commonjs",
-  "dependencies": {
-    "barecolor": "^1.0.1",
-    "tiny-glob": "^0.2.8"
-  },
   "bugs": {
     "url": "https://github.com/rubber-duck-software/beartest/issues"
   },
   "homepage": "https://github.com/rubber-duck-software/beartest#readme",
-  "devDependencies": {},
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1"
   }

package/testrunner.js

@@ -1,23 +0,0 @@
-#!/usr/bin/env node
-const beartest = require("./beartest");
-const glob = require("tiny-glob");
-const rgb = require("barecolor");
-const path = require("path");
-
-async function runTests() {
-  try {
-    const globStr = process.argv[2] || "**/*.test.*";
-    const files = await glob(globStr, { absolute: true });
-    for (const file of files) {
-      rgb.blue(`${path.parse(file).name} (${path.relative("./", file)})\n`);
-      require(file);
-      await beartest.runner.waitForTests();
-    }
-    process.exit(0);
-  } catch (e) {
-    console.error(e);
-    process.exit(1);
-  }
-}
-
-runTests();