@neurodevs/node-tdd 1.0.5 → 1.0.7

package/src/utilities/assert.utility.ts

@@ -1,295 +0,0 @@
-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

@@ -1,167 +0,0 @@
-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

@@ -1,256 +0,0 @@
-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>
-}