@neurodevs/node-tdd 0.2.5 → 1.0.0

package/src/impl/AbstractModuleTest.ts

@@ -1,18 +1,67 @@
-import { createRequire } from 'module'
+import path from 'path'
+
 import generateId from '@neurodevs/generate-id'
 
-const require = createRequire(import.meta.url)
+export default class AbstractModuleTest {
+    protected static cwd: string
 
-const { default: AbstractSpruceTest } = require('@sprucelabs/test-utils') as {
-    default: (typeof import('@sprucelabs/test-utils'))['default']
-}
+    protected static async beforeAll() {
+        this.cwd = process.cwd()
+    }
+
+    protected static async beforeEach() {}
+    protected static async afterEach() {}
+    protected static async afterAll() {}
+
+    protected static generateId(includeDashes?: boolean) {
+        return generateId(includeDashes)
+    }
+
+    protected static async wait(ms = 1) {
+        return new Promise((resolve) => {
+            setTimeout(() => resolve(true), ms)
+        })
+    }
+
+    protected static log(...args: any[]) {
+        const str = args.map((a) => `${a}`).join(' ')
+        process.stderr.write(str)
+    }
+
+    protected static resolvePath(...filePath: string[]) {
+        let builtPath = path.join(...filePath)
+
+        if (builtPath[0] !== '/') {
+            if (builtPath.slice(0, 2) === './') {
+                builtPath = builtPath.slice(1)
+            }
+
+            builtPath = path.join(this.cwd, builtPath)
+        }
+
+        return builtPath
+    }
+
+    protected cwd = process.cwd()
+
+    protected async beforeAll() {}
+    protected async beforeEach() {}
+    protected async afterEach() {}
+    protected async afterAll() {}
+
+    protected generateId(includeDashes?: boolean) {
+        return AbstractModuleTest.generateId(includeDashes)
+    }
+
+    protected wait(ms = 1) {
+        return AbstractModuleTest.wait(ms)
+    }
 
-export default class AbstractModuleTest extends AbstractSpruceTest {
-    protected static async beforeEach() {
-        await super.beforeEach()
+    protected log(...args: any[]) {
+        AbstractModuleTest.log(...args)
     }
 
-    protected static generateId() {
-        return generateId()
+    protected resolvePath(...filePath: string[]) {
+        return AbstractModuleTest.resolvePath(...filePath)
     }
 }

package/src/index.ts

@@ -5,8 +5,8 @@ export default AbstractModuleTest
 export { default as AbstractModuleTest } from './impl/AbstractModuleTest.js'
 export * from './impl/AbstractModuleTest.js'
 
-export { default as test } from './functions/test.js'
-export * from './functions/test.js'
+export { default as test } from './utilities/decorators.js'
+export * from './utilities/decorators.js'
 
-export { default as assert } from './functions/assert.js'
-export * from './functions/assert.js'
+export { default as assert } from './utilities/assert.js'
+export * from './utilities/assert.js'

package/src/utilities/AssertionError.ts

@@ -0,0 +1,14 @@
+import StackCleaner from './StackCleaner.js'
+
+export default class AssertionError extends Error {
+    public constructor(message: string, stack?: string) {
+        super(message)
+        this.message = message
+        this.stack =
+            this.message +
+            '\n' +
+            StackCleaner.clean(
+                `${(stack ?? this.stack ?? '').replace(message, '')}`
+            )
+    }
+}

package/src/utilities/StackCleaner.ts

@@ -0,0 +1,14 @@
+export default class StackCleaner {
+    private static matchPattern =
+        /node-tdd\/(?!src\/__tests__)|node_modules|internal\/process\/task_queues|@babel|regenerator-runtime\/runtime/gi
+
+    public static clean(stack: string): string {
+        const lines = stack.split(/\r?\n/)
+        const filtered = lines.filter(
+            (line) => line.search(this.matchPattern) === -1
+        )
+        const newStack = filtered.join('\n')
+
+        return newStack
+    }
+}

package/src/utilities/TestDecoratorResolver.ts

@@ -0,0 +1,118 @@
+export default class TestDecoratorResolver {
+    public static ActiveTestClass?: any
+    private static __activeTest: any
+
+    public static resolveTestClass(target: any) {
+        if (!this.__activeTest) {
+            this.__activeTest = this.ActiveTestClass
+                ? new this.ActiveTestClass()
+                : target
+        }
+
+        return this.__activeTest
+    }
+
+    public static getActiveTest() {
+        return this.__activeTest
+    }
+
+    public static reset() {
+        delete this.__activeTest
+    }
+
+    public static onWillCallBeforeAll(cb: TestLifecycleListener) {
+        TestLifecycleListeners.willBeforeAllListeners.push(cb)
+    }
+
+    public static onDidCallBeforeAll(cb: TestLifecycleListener) {
+        TestLifecycleListeners.didBeforeAllListeners.push(cb)
+    }
+
+    public static onWillCallBeforeEach(cb: TestLifecycleListener) {
+        TestLifecycleListeners.willBeforeEachListeners.push(cb)
+    }
+
+    public static onDidCallBeforeEach(cb: TestLifecycleListener) {
+        TestLifecycleListeners.didBeforeEachListeners.push(cb)
+    }
+
+    public static onWillCallAfterEach(cb: TestLifecycleListener) {
+        TestLifecycleListeners.willAfterEachListeners.push(cb)
+    }
+
+    public static onDidCallAfterEach(cb: TestLifecycleListener) {
+        TestLifecycleListeners.didAfterEachListeners.push(cb)
+    }
+
+    public static onWillCallAfterAll(cb: TestLifecycleListener) {
+        TestLifecycleListeners.willAfterAllListeners.push(cb)
+    }
+
+    public static onDidCallAfterAll(cb: TestLifecycleListener) {
+        TestLifecycleListeners.didAfterAllListeners.push(cb)
+    }
+}
+
+type TestLifecycleListener = (Test: any) => any | Promise<any>
+
+export class TestLifecycleListeners {
+    public static willBeforeAllListeners: TestLifecycleListener[] = []
+    public static didBeforeAllListeners: TestLifecycleListener[] = []
+
+    public static willBeforeEachListeners: TestLifecycleListener[] = []
+    public static didBeforeEachListeners: TestLifecycleListener[] = []
+
+    public static willAfterEachListeners: TestLifecycleListener[] = []
+    public static didAfterEachListeners: TestLifecycleListener[] = []
+
+    public static willAfterAllListeners: TestLifecycleListener[] = []
+    public static didAfterAllListeners: TestLifecycleListener[] = []
+
+    public static async emitWillRunBeforeAll() {
+        for (const cb of this.willBeforeAllListeners) {
+            await cb(TestDecoratorResolver.getActiveTest().constructor)
+        }
+    }
+
+    public static async emitDidRunBeforeAll() {
+        for (const cb of this.didBeforeAllListeners) {
+            await cb(TestDecoratorResolver.getActiveTest().constructor)
+        }
+    }
+
+    public static async emitWillRunBeforeEach() {
+        for (const cb of this.willBeforeEachListeners) {
+            await cb(TestDecoratorResolver.getActiveTest())
+        }
+    }
+
+    public static async emitDidRunBeforeEach() {
+        for (const cb of this.didBeforeEachListeners) {
+            await cb(TestDecoratorResolver.getActiveTest())
+        }
+    }
+
+    public static async emitWillRunAfterEach() {
+        for (const cb of this.willAfterEachListeners) {
+            await cb(TestDecoratorResolver.getActiveTest())
+        }
+    }
+
+    public static async emitDidRunAfterEach() {
+        for (const cb of this.didAfterEachListeners) {
+            await cb(TestDecoratorResolver.getActiveTest())
+        }
+    }
+
+    public static async emitWillRunAfterAll() {
+        for (const cb of this.willAfterAllListeners) {
+            await cb(TestDecoratorResolver.getActiveTest().constructor)
+        }
+    }
+
+    public static async emitDidRunAfterAll() {
+        for (const cb of this.didAfterAllListeners) {
+            await cb(TestDecoratorResolver.getActiveTest().constructor)
+        }
+    }
+}