@neurodevs/node-tdd 0.2.5 → 1.0.0

package/src/utilities/assert.utility.ts

@@ -0,0 +1,295 @@
+import chalk from 'chalk'
+import { escapeRegExp, get, includes, isObject, isObjectLike } from 'lodash-es'
+import AssertionError from './AssertionError.js'
+import { Assert } from './assert.js'
+
+export const UNDEFINED_PLACEHOLDER = '_____________undefined_____________'
+export const FUNCTION_PLACEHOLDER = '_____________function_____________'
+export const CIRCULAR_PLACEHOLDER = '_____________circular_____________'
+export const NULL_PLACEHOLDER = '_____________null_____________'
+
+const assertUtil = {
+    fail(message?: string, stack?: string) {
+        throw new AssertionError(message ?? 'Fail!', stack)
+    },
+
+    stringify(object: any): string {
+        let stringified
+
+        if (Array.isArray(object)) {
+            stringified = `[\n  ${object.map((o) =>
+                this.stringify(o).split('\n').join('\n  ')
+            )}\n]`
+        } else if (typeof object === 'number') {
+            // this hack allows the Test Reporter to render number errors (they got eaten by terminal-kit's style regex)
+            stringified = chalk.bgBlack.white(` ${object} `)
+        } else if (object instanceof Error) {
+            stringified = `${object.stack ?? object.message}`
+        } else if (object instanceof RegExp) {
+            stringified = `${object.toString()}`
+        } else if (typeof object === 'undefined') {
+            stringified = 'undefined'
+        } else if (typeof object === 'string') {
+            stringified = `"${object}"`
+        } else {
+            stringified = JSON.stringify(
+                assertUtil.dropInPlaceholders(object),
+                undefined,
+                2
+            ).replace(/\\/g, '')
+        }
+
+        if (stringified.length > 5000) {
+            stringified =
+                stringified.substr(0, 1000) +
+                '\n\n... big object ...\n\n' +
+                stringified.substr(stringified.length - 1000)
+        }
+
+        stringified = assertUtil.replacePlaceholders(stringified)
+
+        return `${chalk.bold(stringified)}`
+    },
+
+    replacePlaceholders(str: string) {
+        return str
+            .replace(
+                new RegExp(`"${UNDEFINED_PLACEHOLDER}"`, 'g'),
+                chalk.italic('undefined')
+            )
+            .replace(
+                new RegExp(`"${FUNCTION_PLACEHOLDER}"`, 'g'),
+                chalk.italic('Function')
+            )
+            .replace(
+                new RegExp(`"${NULL_PLACEHOLDER}"`, 'g'),
+                chalk.italic('NULL')
+            )
+    },
+
+    dropInPlaceholders(obj: Record<string, any>) {
+        const checkedObjects: { obj: any; depth: number }[] = [
+            { obj, depth: 0 },
+        ]
+
+        let updated = this.dropInPlaceholder(
+            obj,
+            (obj, depth) => {
+                if (
+                    isObject(obj) &&
+                    checkedObjects.some((checked) => {
+                        return checked.obj === obj && checked.depth < depth
+                    })
+                ) {
+                    return true
+                }
+
+                checkedObjects.push({ obj, depth })
+
+                return false
+            },
+            CIRCULAR_PLACEHOLDER
+        )
+
+        updated = this.dropInPlaceholder(
+            updated,
+            (obj) => typeof obj === 'undefined',
+            UNDEFINED_PLACEHOLDER
+        )
+
+        updated = this.dropInPlaceholder(
+            updated,
+            (obj) => typeof obj === 'function',
+            FUNCTION_PLACEHOLDER
+        )
+
+        updated = this.dropInPlaceholder(
+            updated,
+            (obj) => obj === null,
+            NULL_PLACEHOLDER
+        )
+
+        return updated
+    },
+
+    dropInPlaceholder(
+        obj: Record<string, any>,
+        checker: (obj: any, depth: number) => boolean,
+        placeholder: string,
+        depth = 1
+    ) {
+        if (!isObject(obj)) {
+            return obj
+        }
+        const updated: Record<string, any> | any[] = Array.isArray(obj)
+            ? []
+            : {}
+
+        Object.keys(obj).forEach((key) => {
+            //@ts-ignore
+            updated[key] =
+                // @ts-ignore
+                checker(obj[key], depth) ? placeholder : obj[key]
+
+            //@ts-ignore
+            if (typeof updated[key] !== 'function' && isObject(updated[key])) {
+                //@ts-ignore
+                updated[key] = this.dropInPlaceholder(
+                    //@ts-ignore
+                    updated[key],
+                    checker,
+                    placeholder,
+                    depth + 1
+                )
+            }
+        })
+
+        return updated
+    },
+
+    doHaystacksPassCheck(
+        haystacks: any[],
+        needle: any,
+        check: Assert['doesInclude']
+    ) {
+        return !!haystacks.find((haystack) => {
+            try {
+                check(haystack, needle)
+                return true
+            } catch {
+                return false
+            }
+        })
+    },
+
+    assertTypeof(actual: any, type: string, message: string | undefined) {
+        if (typeof actual !== type) {
+            this.fail(message ?? `${JSON.stringify(actual)} is not a ${type}`)
+        }
+    },
+
+    assertErrorIncludes(
+        matcher: string | RegExp | undefined,
+        err: Error,
+        msg?: string | undefined
+    ) {
+        const originalErrorMessage = err.message ?? ''
+        const errorMessage = originalErrorMessage.toLowerCase()
+        const needle =
+            typeof matcher === 'string' ? matcher.toLowerCase() : matcher
+
+        if (
+            typeof needle === 'string' &&
+            errorMessage.search(needle) === -1 &&
+            !errorMessage.includes(needle)
+        ) {
+            this.fail(
+                msg ??
+                    `Expected thrown error whose message contains: \n\n${chalk.bold(
+                        matcher
+                    )}\n\nbut got back:\n\n\`${chalk.bold(originalErrorMessage)}\`.`,
+                '\n\nStack: ' + err.stack
+            )
+        } else if (
+            needle instanceof RegExp &&
+            errorMessage.search(needle) === -1 &&
+            originalErrorMessage.search(needle) === -1
+        ) {
+            this.fail(
+                msg ??
+                    `Expected thrown error whose message matches the regex: \n\n${chalk.bold(
+                        matcher
+                    )}\n\nbut got back:\n\n\`${chalk.bold(originalErrorMessage)}\`.`,
+                '\n\nStack: ' + err.stack
+            )
+        }
+    },
+
+    partialContains(object: any, subObject: any) {
+        const objProps = object ? Object.getOwnPropertyNames(object) : []
+        const subProps = subObject ? Object.getOwnPropertyNames(subObject) : []
+
+        if (objProps.length == 0 || subProps.length === 0) {
+            return
+        }
+
+        if (subProps.length > objProps.length) {
+            return false
+        }
+
+        for (const subProp of subProps) {
+            if (!Object.prototype.hasOwnProperty.call(object, subProp)) {
+                return false
+            }
+
+            if (
+                (!isObjectLike(object[subProp]) ||
+                    !isObjectLike(subObject[subProp])) &&
+                object[subProp] !== subObject[subProp]
+            ) {
+                return false
+            }
+
+            if (
+                isObjectLike(object[subProp]) &&
+                isObjectLike(subObject[subProp]) &&
+                !this.partialContains(object[subProp], subObject[subProp])
+            ) {
+                return false
+            }
+        }
+
+        return true
+    },
+
+    valueAtPath(object: Record<string, any>, path: string) {
+        return get(object, path)
+    },
+
+    parseIncludeNeedle(needle: any): {
+        needleHasArrayNotation: boolean
+        path?: string
+        expected?: any
+    } {
+        const path = Object.keys(needle)[0]
+        const expected = path && needle[path]
+        const needleHasArrayNotation = !!(path && path.search(/\[\]\./) > -1)
+        return { needleHasArrayNotation, path, expected }
+    },
+
+    splitPathBasedOnArrayNotation(path: string, haystack: any) {
+        const pathParts = path.split('[].')
+        const pathToFirstArray = pathParts.shift() ?? ''
+        const pathAfterFirstArray = pathParts.join('[].')
+        const actualBeforeArray = this.valueAtPath(haystack, pathToFirstArray)
+        return { actualBeforeArray, pathAfterFirstArray }
+    },
+
+    foundUsing3rdPartyIncludes(
+        haystack: any,
+        needle: any,
+        isHaystackObject: boolean
+    ) {
+        let passed = false
+        const escapedNeedle =
+            typeof needle === 'string' ? escapeRegExp(needle) : needle
+        if (
+            typeof haystack === 'string' &&
+            typeof needle === 'string' &&
+            haystack.search(escapedNeedle) > -1
+        ) {
+            passed = true
+        }
+
+        if (isHaystackObject && includes(haystack, escapedNeedle)) {
+            passed = true
+        }
+
+        if (isHaystackObject && this.partialContains(haystack, escapedNeedle)) {
+            passed = true
+        }
+        return passed
+    },
+}
+
+export default assertUtil

package/src/utilities/decorators.ts

@@ -0,0 +1,167 @@
+import TestDecoratorResolver, {
+    TestLifecycleListeners,
+} from './TestDecoratorResolver.js'
+
+if (typeof it === 'undefined') {
+    //@ts-ignore
+    global.it = () => {}
+}
+
+let areLifecycleHooksInPlace = false
+
+/** Hooks up before, after, etc. */
+function hookupTestClassToJestLifecycle(Target: any) {
+    if (areLifecycleHooksInPlace) {
+        return
+    }
+
+    areLifecycleHooksInPlace = true
+    const hooks = ['beforeAll', 'beforeEach', 'afterAll', 'afterEach']
+    hooks.forEach((hook) => {
+        // @ts-ignore
+        if (global[hook]) {
+            // @ts-ignore
+            global[hook](async () => {
+                TestDecoratorResolver.resolveTestClass(Target)
+                if (hook === 'beforeEach') {
+                    await TestLifecycleListeners.emitWillRunBeforeEach()
+                    await runBeforeEach(Target)
+                    await TestLifecycleListeners.emitDidRunBeforeEach()
+                } else if (hook === 'afterEach') {
+                    await TestLifecycleListeners.emitWillRunAfterEach()
+                    await runAfterEach(Target)
+                    await TestLifecycleListeners.emitDidRunAfterEach()
+                    TestDecoratorResolver.reset()
+                } else if (hook === 'beforeAll') {
+                    await TestLifecycleListeners.emitWillRunBeforeAll()
+                    await runBeforeAll(Target)
+                    await TestLifecycleListeners.emitDidRunBeforeAll()
+                    TestDecoratorResolver.reset()
+                } else if (hook === 'afterAll') {
+                    await TestLifecycleListeners.emitWillRunAfterAll()
+                    await runAfterAll(Target)
+                    await TestLifecycleListeners.emitDidRunAfterAll()
+                }
+            })
+        }
+    })
+}
+
+async function runBeforeAll(Target: any) {
+    await callStaticHook(Target, 'beforeAll')
+}
+
+async function runAfterAll(Target: any) {
+    await callStaticHook(Target, 'afterAll')
+}
+
+async function callStaticHook(Target: any, hook: 'beforeAll' | 'afterAll') {
+    const Class =
+        TestDecoratorResolver.ActiveTestClass ??
+        (typeof Target === 'function' ? Target : Target.constructor)
+    const cb = Class?.[hook]
+    await cb?.call(Class)
+}
+
+async function runAfterEach(Target: any) {
+    if (TestDecoratorResolver.ActiveTestClass) {
+        const Resolved = TestDecoratorResolver.resolveTestClass(Target)
+        await Resolved.afterEach?.apply(Resolved)
+    } else if (Target.afterEach) {
+        await Target.afterEach?.apply?.(Target)
+    } else {
+        await Target?.constructor.afterEach?.apply?.(Target.constructor)
+    }
+}
+
+async function runBeforeEach(Target: any) {
+    if (TestDecoratorResolver.ActiveTestClass) {
+        const Resolved = TestDecoratorResolver.resolveTestClass(Target)
+        await Resolved.beforeEach?.apply(Resolved)
+    } else if (Target.beforeEach) {
+        await Target.beforeEach?.apply?.(Target)
+    } else {
+        await Target?.constructor.beforeEach?.apply?.(Target.constructor)
+    }
+}
+
+/** Test decorator */
+export default function test(description?: string, ...args: any[]) {
+    return function (
+        Target: any,
+        propertyKey: string,
+        descriptor: PropertyDescriptor
+    ) {
+        hookupTestClassToJestLifecycle(Target)
+
+        it(description ?? propertyKey, async () => {
+            const Resolved = TestDecoratorResolver.resolveTestClass(Target)
+
+            if (!Resolved[propertyKey]) {
+                throw new Error(
+                    `The test '${propertyKey}()' should NOT be static when tests run with suite(). Or, if you are not using suite(), you MUST make your test static.`
+                )
+            }
+
+            const bound = descriptor.value.bind(Resolved)
+
+            //@ts-ignore
+            global.activeTest = {
+                file: Target.name,
+                test: propertyKey,
+            }
+            return bound(...args)
+        })
+    }
+}
+
+export function suite() {
+    return function (Target: any) {
+        TestDecoratorResolver.ActiveTestClass = Target
+    }
+}
+
+/** Only decorator */
+test.only = (description?: string, ...args: any[]) => {
+    return function (
+        target: any,
+        propertyKey: string,
+        descriptor: PropertyDescriptor
+    ) {
+        hookupTestClassToJestLifecycle(target)
+
+        it.only(description ?? propertyKey, async () => {
+            const bound = descriptor.value.bind(
+                TestDecoratorResolver.resolveTestClass(target)
+            )
+            return bound(...args)
+        })
+    }
+}
+
+/** Todo decorator */
+test.todo = (description?: string, ..._args: any[]) => {
+    return function (target: any, propertyKey: string) {
+        hookupTestClassToJestLifecycle(target)
+
+        it.todo(description ?? propertyKey)
+    }
+}
+
+/** Skip decorator */
+test.skip = (description?: string, ...args: any[]) => {
+    return function (
+        target: any,
+        propertyKey: string,
+        descriptor: PropertyDescriptor
+    ) {
+        hookupTestClassToJestLifecycle(target)
+
+        it.skip(description ?? propertyKey, async () => {
+            const bound = descriptor.value.bind(
+                TestDecoratorResolver.resolveTestClass(target)
+            )
+            return bound(...args)
+        })
+    }
+}

package/src/workspace/CommandService.ts

@@ -0,0 +1,256 @@
+import { spawn, SpawnOptions, ChildProcess } from 'child_process'
+import { Writable } from 'stream'
+
+process.setMaxListeners(100)
+
+export default class CommandServiceImpl implements CommandService {
+    private cwd: string
+    private activeChildProcess: ChildProcess | undefined
+    private ignoreCloseErrors = false
+    private static fakeResponses: {
+        command: string | RegExp
+        response: FakedCommandResponse
+    }[] = []
+    private static commandsRunCapturedByMockResponses: string[] = []
+
+    public constructor(cwd: string) {
+        this.cwd = cwd
+    }
+
+    public getCwd() {
+        return this.cwd
+    }
+
+    public setCwd(cwd: string) {
+        this.cwd = cwd
+    }
+
+    public async execute(
+        cmd: string,
+        options?: ExecuteCommandOptions
+    ): Promise<{
+        stdout: string
+    }> {
+        const cwd = this.cwd
+        const args = options?.args || this.parseArgv(cmd)
+        const executable = options?.args ? cmd : args.shift()
+        const boundKill = this.kill.bind(this)
+
+        if (!executable) {
+            throw new Error('Bad params sent to command service')
+        }
+
+        const { mockResponse, mockKey } = this.getMockResponse(executable, args)
+
+        if (mockResponse) {
+            CommandServiceImpl.commandsRunCapturedByMockResponses.push(mockKey)
+            mockResponse.callback?.(executable, args)
+
+            if (mockResponse.code !== 0) {
+                throw new Error(
+                    `Command failed: ${executable} ${args.join(' ')}`
+                )
+            }
+
+            return { stdout: mockResponse.stdout ?? '' }
+        }
+
+        process.on('exit', boundKill)
+
+        return new Promise((resolve, reject) => {
+            let stdout = ''
+            let stderr = ''
+            const spawnOptions: SpawnOptions = options?.shouldStream
+                ? {
+                      stdio: 'inherit',
+                      cwd,
+                      env: {
+                          PATH: process.env.PATH,
+                          IS_CLI: 'true',
+                          FORCE_COLOR: options?.forceColor ? '1' : '0',
+                          ...options?.env,
+                      },
+                  }
+                : {
+                      cwd,
+                      env: {
+                          PATH: process.env.PATH,
+                          IS_CLI: 'true',
+                          FORCE_COLOR: options?.forceColor ? '1' : '0',
+                          ...options?.env,
+                      },
+                      shell: true,
+                      ...options?.spawnOptions,
+                  }
+
+            let child: ChildProcess
+            if (spawnOptions.shell) {
+                const commandStr = options?.args
+                    ? [executable, ...args].join(' ')
+                    : cmd
+                child = spawn(commandStr, spawnOptions)
+            } else {
+                child = spawn(executable, args, spawnOptions)
+            }
+            this.activeChildProcess = child
+
+            if (options?.outStream) {
+                child.stdout?.pipe(options.outStream)
+            }
+
+            child.stdout?.addListener('data', (data) => {
+                options?.onData?.(data.toString())
+                stdout += data
+            })
+
+            child.stderr?.addListener('data', (data) => {
+                options?.onError?.(data.toString())
+                stderr += data
+            })
+
+            const closeHandler = (code: number) => {
+                process.off('exit', boundKill)
+
+                if (!this.activeChildProcess) {
+                    return
+                }
+                this.activeChildProcess = undefined
+
+                setTimeout(() => {
+                    child.stdout?.removeAllListeners()
+                    child.stderr?.removeAllListeners()
+                    child.removeAllListeners()
+
+                    if (
+                        code === 0 ||
+                        this.ignoreCloseErrors ||
+                        options?.ignoreErrors
+                    ) {
+                        resolve({ stdout })
+                        this.ignoreCloseErrors = false
+                    } else {
+                        reject(
+                            new Error(
+                                `Command failed (exit ${code}): ${executable} ${args.join(' ')}\n${stderr}`
+                            )
+                        )
+                    }
+                }, 0)
+            }
+
+            child.addListener('close', closeHandler)
+            child.addListener('exit', closeHandler)
+        })
+    }
+
+    private parseArgv(cmd: string): string[] {
+        const result: string[] = []
+        let current = ''
+        let inQuote = false
+        let quoteChar = ''
+
+        for (let i = 0; i < cmd.length; i++) {
+            const ch = cmd[i]
+            if (inQuote) {
+                if (ch === quoteChar) {
+                    inQuote = false
+                } else {
+                    current += ch
+                }
+            } else if (ch === '"' || ch === "'") {
+                inQuote = true
+                quoteChar = ch
+            } else if (ch === ' ') {
+                if (current.length > 0) {
+                    result.push(current)
+                    current = ''
+                }
+            } else {
+                current += ch
+            }
+        }
+        if (current.length > 0) {
+            result.push(current)
+        }
+        return result
+    }
+
+    public kill = () => {
+        const child = this.activeChildProcess
+        if (child?.pid) {
+            this.ignoreCloseErrors = true
+            try {
+                process.kill(-child.pid, 'SIGTERM')
+            } catch {
+                try {
+                    child.kill('SIGTERM')
+                } catch {}
+            }
+        }
+    }
+
+    public pid = () => {
+        return this.activeChildProcess?.pid
+    }
+
+    private getMockResponse(executable: string, args: string[]) {
+        const mockKey = `${executable} ${args.join(' ')}`.trim()
+        const commands = CommandServiceImpl.fakeResponses
+        const match = commands.find((r) =>
+            r.command instanceof RegExp
+                ? mockKey.search(r.command) > -1
+                : r.command.replace(/ +/gis, '') ===
+                  mockKey.replace(/ +/gis, '')
+        )
+
+        return { mockResponse: match?.response, mockKey }
+    }
+
+    public static fakeCommand(
+        command: string | RegExp,
+        response: FakedCommandResponse
+    ) {
+        this.fakeResponses.unshift({
+            command,
+            response,
+        })
+    }
+
+    public static clearFakedResponses() {
+        this.fakeResponses = []
+    }
+}
+
+export type FakedCommandCallback = (executable: string, args: any[]) => void
+
+interface FakedCommandResponse {
+    code: number
+    stdout?: string
+    stderr?: string
+    callback?: FakedCommandCallback
+}
+
+export interface CommandService {
+    execute(
+        cmd: string,
+        options?: ExecuteCommandOptions
+    ): Promise<{
+        stdout: string
+    }>
+    getCwd(): string
+    setCwd(cwd: string): void
+    kill(): void
+    pid(): number | undefined
+}
+
+export interface ExecuteCommandOptions {
+    ignoreErrors?: boolean
+    args?: string[]
+    shouldStream?: boolean
+    outStream?: Writable
+    onError?: (error: string) => void
+    onData?: (data: string) => void
+    spawnOptions?: SpawnOptions
+    forceColor?: boolean
+    env?: Record<string, any>
+}