@neurodevs/node-tdd 0.2.5 → 1.0.1

package/src/__tests__/behavioral/workspace/TestReporter.test.ts

@@ -0,0 +1,257 @@
+import AbstractModuleTest from '../../../impl/AbstractModuleTest.js'
+import test from '../../../utilities/decorators.js'
+import assert from '../../../utilities/assert.js'
+import TestReporter, {
+    TestReporterOptions,
+} from '../../../workspace/TestReporter.js'
+
+export default class TestReporterTest extends AbstractModuleTest {
+    @test()
+    protected static async canInstantiateTestReporter() {
+        const reporter = this.TestReporter()
+        assert.isTruthy(reporter)
+    }
+
+    @test()
+    protected static async canInstantiateWithOptions() {
+        const reporter = this.TestReporter({
+            cwd: this.cwd,
+            watchMode: 'off',
+            status: 'ready',
+            isDebugging: false,
+        })
+        assert.isTruthy(reporter)
+    }
+
+    @test()
+    protected static async hasStartMethod() {
+        const reporter = this.TestReporter()
+        assert.isFunction(reporter.start)
+    }
+
+    @test()
+    protected static async hasDestroyMethod() {
+        const reporter = this.TestReporter()
+        assert.isFunction(reporter.destroy)
+    }
+
+    @test()
+    protected static async hasUpdateResultsMethod() {
+        const reporter = this.TestReporter()
+        assert.isFunction(reporter.updateResults)
+    }
+
+    @test()
+    protected static async hasSetStatusMethod() {
+        const reporter = this.TestReporter()
+        assert.isFunction(reporter.setStatus)
+    }
+
+    @test()
+    protected static async hasResetMethod() {
+        const reporter = this.TestReporter()
+        assert.isFunction(reporter.reset)
+    }
+
+    @test()
+    protected static async hasAppendErrorMethod() {
+        const reporter = this.TestReporter()
+        assert.isFunction(reporter.appendError)
+    }
+
+    @test()
+    protected static async throwsIfUpdateResultsCalledBeforeStart() {
+        const reporter = this.TestReporter()
+        assert.doesThrow(() => {
+            reporter.updateResults({ totalTestFiles: 0 })
+        })
+    }
+
+    @test()
+    protected static async doesNotDestroyOnUncaughtException() {
+        const reporter = this.TestReporter()
+        let destroyCalled = false
+        let killHandler: ((payload: { code: any }) => void) | undefined
+
+        const fakeWidget: any = new Proxy(
+            {},
+            {
+                get: (_t, prop: string) => {
+                    if (prop === 'getFrame') {
+                        return () => ({
+                            left: 0,
+                            top: 0,
+                            width: 100,
+                            height: 50,
+                        })
+                    }
+                    if (prop === 'getChildById') {
+                        return () => null
+                    }
+                    if (prop === 'getRows') {
+                        return () => [{}]
+                    }
+                    if (prop === 'getFocusedWidget') {
+                        return () => null
+                    }
+                    if (prop === 'on') {
+                        return (event: string, handler: any) => {
+                            if (event === 'kill') {
+                                killHandler = handler
+                            }
+                        }
+                    }
+                    return () => fakeWidget
+                },
+            }
+        )
+
+        reporter.widgets = { Widget: () => fakeWidget }
+        reporter.destroy = async () => {
+            destroyCalled = true
+        }
+
+        await reporter.start()
+
+        assert.isTruthy(killHandler, 'kill handler must be registered')
+
+        killHandler!({
+            code: new Error('terminal-kit mouse boundary crash'),
+        })
+        assert.isFalse(
+            destroyCalled,
+            'uncaughtException must not destroy the UI'
+        )
+
+        killHandler!({ code: 0 })
+        assert.isTrue(
+            destroyCalled,
+            'real exit signal must still destroy the UI'
+        )
+
+        clearInterval(reporter.updateInterval)
+    }
+
+    @test()
+    protected static async grabsInputToResetMouseStateAfterCrash() {
+        const reporter = this.TestReporter()
+        let destroyCalled = false
+        let grabInputCalled = false
+        let killHandler: ((payload: { code: any }) => void) | undefined
+
+        const fakeTerm = {
+            grabInput: () => {
+                grabInputCalled = true
+            },
+        }
+
+        const fakeWidget: any = new Proxy(
+            {},
+            {
+                get: (_t, prop: string) => {
+                    if (prop === 'getFrame') {
+                        return () => ({
+                            left: 0,
+                            top: 0,
+                            width: 100,
+                            height: 50,
+                        })
+                    }
+                    if (prop === 'getChildById') {
+                        return () => null
+                    }
+                    if (prop === 'getRows') {
+                        return () => [{}]
+                    }
+                    if (prop === 'getFocusedWidget') {
+                        return () => null
+                    }
+                    if (prop === 'term') {
+                        return fakeTerm
+                    }
+                    if (prop === 'on') {
+                        return (event: string, handler: any) => {
+                            if (event === 'kill') {
+                                killHandler = handler
+                            }
+                        }
+                    }
+                    return () => fakeWidget
+                },
+            }
+        )
+
+        reporter.widgets = { Widget: () => fakeWidget }
+        reporter.destroy = async () => {
+            destroyCalled = true
+        }
+
+        await reporter.start()
+
+        assert.isTruthy(killHandler, 'kill handler must be registered')
+
+        killHandler!({
+            code: new Error('terminal-kit mouse boundary crash'),
+        })
+        assert.isFalse(
+            destroyCalled,
+            'uncaughtException must not destroy the UI'
+        )
+
+        killHandler!({ code: 0 })
+        assert.isTrue(
+            destroyCalled,
+            'real exit signal must still destroy the UI'
+        )
+
+        assert.isTrue(
+            grabInputCalled,
+            'grabInput must be called to reset mouse state after terminal crash'
+        )
+
+        clearInterval(reporter.updateInterval)
+    }
+
+    @test()
+    protected static async errorLogIsCreatedWithFocusableSetToFalse() {
+        const reporter = this.TestReporter() as any
+        let capturedTextOptions: any
+
+        const fakeCell = { getFrame: () => ({ width: 100, height: 50 }) }
+
+        reporter.orientation = 'landscape'
+
+        reporter.bottomLayout = {
+            getRows: () => [{ id: 'row_1' }],
+            addColumn: () => {},
+            setColumnWidth: () => {},
+            updateLayout: () => {},
+            getChildById: (id: string) => {
+                return id === 'errors' ? fakeCell : null
+            },
+        }
+
+        reporter.widgets = {
+            Widget: (type: string, options: any) => {
+                if (type === 'text') {
+                    capturedTextOptions = options
+                }
+                return {
+                    on: () => {},
+                    getFrame: () => ({ width: 100, height: 50 }),
+                }
+            },
+        }
+
+        reporter.dropInErrorLog()
+
+        assert.isFalse(
+            capturedTextOptions?.focusable,
+            'errorLog must be created with focusable: false to prevent UI lockup on click'
+        )
+    }
+
+    private static TestReporter(options?: TestReporterOptions) {
+        return new TestReporter(options) as any
+    }
+}

package/src/__tests__/behavioral/workspace/TestRunner.test.ts

@@ -0,0 +1,87 @@
+import AbstractModuleTest from '../../../impl/AbstractModuleTest.js'
+import test from '../../../utilities/decorators.js'
+import assert from '../../../utilities/assert.js'
+import TestRunner from '../../../workspace/TestRunner.js'
+import CommandServiceImpl from '../../../workspace/CommandService.js'
+
+export default class TestRunnerTest extends AbstractModuleTest {
+    private static runner: TestRunner
+
+    protected static async beforeEach() {
+        await super.beforeEach()
+        const commandService = new CommandServiceImpl(this.cwd)
+        this.runner = new TestRunner({ cwd: this.cwd, commandService })
+    }
+
+    @test()
+    protected static async canInstantiateTestRunner() {
+        assert.isTruthy(this.runner)
+    }
+
+    @test()
+    protected static async hasHasFailedTestsMethod() {
+        assert.isFunction(this.runner.hasFailedTests)
+    }
+
+    @test()
+    protected static async hasHasSkippedTestsMethod() {
+        assert.isFunction(this.runner.hasSkippedTests)
+    }
+
+    @test()
+    protected static async hasKillMethod() {
+        assert.isFunction(this.runner.kill)
+    }
+
+    @test()
+    protected static async hasRunMethod() {
+        assert.isFunction(this.runner.run)
+    }
+
+    @test()
+    protected static async hasFailedTestsReturnsFalseByDefault() {
+        assert.isFalse(this.runner.hasFailedTests())
+    }
+
+    @test()
+    protected static async hasSkippedTestsReturnsFalseByDefault() {
+        assert.isFalse(this.runner.hasSkippedTests())
+    }
+
+    @test()
+    protected static async emitsDidUpdateEvent() {
+        let emitted = false
+        this.runner.on('did-update', () => {
+            emitted = true
+        })
+        assert.isFalse(emitted)
+        this.runner.emit('did-update', { results: { totalTestFiles: 0 } })
+        assert.isTrue(emitted)
+    }
+
+    @test()
+    protected static async emitsDidErrorEvent() {
+        let errorMessage = ''
+        this.runner.on('did-error', (payload: { message: string }) => {
+            errorMessage = payload.message
+        })
+        this.runner.emit('did-error', { message: 'test error' })
+        assert.isEqual(errorMessage, 'test error')
+    }
+
+    @test()
+    protected static async passesNodeNoWarningsToCommandService() {
+        let capturedEnv: Record<string, any> | undefined
+
+        const commandService = new CommandServiceImpl(this.cwd)
+        commandService.execute = async (_cmd: string, options?: any) => {
+            capturedEnv = options?.env
+            return { stdout: '' }
+        }
+
+        const runner = new TestRunner({ cwd: this.cwd, commandService })
+        await runner.run()
+
+        assert.isEqual(capturedEnv?.NODE_NO_WARNINGS, '1')
+    }
+}

package/src/__tests__/behavioral/workspace/Widgets.test.ts

@@ -0,0 +1,90 @@
+import AbstractModuleTest from '../../../impl/AbstractModuleTest.js'
+import assert from '../../../utilities/assert.js'
+import test from '../../../utilities/decorators.js'
+import WidgetFactory from '../../../workspace/WidgetFactory.js'
+
+export default class WidgetsTest extends AbstractModuleTest {
+    private static factory: WidgetFactory
+
+    protected static async beforeEach() {
+        await super.beforeEach()
+        this.factory = new WidgetFactory()
+    }
+
+    @test()
+    protected static async canCreateFactory() {
+        assert.isTruthy(this.factory)
+    }
+
+    @test()
+    protected static async canCreateTextWidget() {
+        const log = this.buildText()
+        assert.isTruthy(log)
+    }
+
+    @test()
+    protected static async setsStartingFrame() {
+        const text = this.buildText()
+        assert.isEqualDeep(text.getFrame(), {
+            left: 0,
+            top: 0,
+            width: 4,
+            height: 4,
+        })
+    }
+
+    @test()
+    protected static canCreateWindow() {
+        const window = this.factory.Widget('window', {})
+        assert.isTruthy(window)
+    }
+
+    @test()
+    protected static canCreateProgressBar() {
+        const progress = this.factory.Widget('progressBar', {
+            progress: 0,
+        })
+        assert.isTruthy(progress)
+    }
+
+    @test()
+    protected static canCreateText() {
+        const text = this.factory.Widget('text', {})
+        assert.isTruthy(text)
+    }
+
+    @test.skip('enable when ready to fake termkit')
+    protected static canCreateLayout() {
+        const window = this.factory.Widget('window', {})
+        const layout = this.factory.Widget('layout', {
+            parent: window,
+            width: '100%',
+            rows: [
+                {
+                    id: 'row_1',
+                    height: '100%',
+                    columns: [
+                        {
+                            id: 'column_1',
+                            width: '100%',
+                        },
+                    ],
+                },
+            ],
+        })
+        assert.isTruthy(layout)
+
+        const column = layout.getChildById('results')
+
+        assert.isTruthy(column)
+    }
+
+    private static buildText() {
+        return this.factory.Widget('text', {
+            left: 0,
+            top: 0,
+            width: 4,
+            height: 4,
+        })
+    }
+}

package/src/__tests__/mock-terminal-kit.ts

@@ -0,0 +1,115 @@
+export class FakeElement {
+    public outputX: number
+    public outputY: number
+    public outputWidth: number
+    public outputHeight: number
+    public constructorOptions: Record<string, any>
+    private handlers: Record<string, Function[]> = {}
+
+    public constructor(options: Record<string, any> = {}) {
+        this.constructorOptions = options
+        this.outputX = options.x ?? 0
+        this.outputY = options.y ?? 0
+        this.outputWidth = options.width ?? 0
+        this.outputHeight = options.height ?? 0
+    }
+
+    public on(event: string, cb: Function) {
+        if (!this.handlers[event]) {
+            this.handlers[event] = []
+        }
+        this.handlers[event].push(cb)
+    }
+
+    public draw() {}
+    public destroy() {}
+    public resize(options: Record<string, any>) {
+        if (options.x !== undefined) {
+            this.outputX = options.x
+        }
+        if (options.y !== undefined) {
+            this.outputY = options.y
+        }
+        if (options.width !== undefined) {
+            this.outputWidth = options.width
+        }
+        if (options.height !== undefined) {
+            this.outputHeight = options.height
+        }
+    }
+}
+
+export class TextBox extends FakeElement {
+    public content = ''
+    public scrollY = 0
+    public scrollX = 0
+    public textAreaHeight = 0
+    public textBuffer = {
+        cy: 0,
+        selectionRegion: null as any,
+        setSelectionRegion(_: any) {},
+    }
+
+    public setContent(content: string) {
+        this.content = content
+    }
+
+    public setSizeAndPosition(opts: Record<string, any>) {
+        this.resize(opts)
+    }
+
+    public scrollToBottom() {}
+}
+
+export class Bar extends FakeElement {
+    public setValue(_: number) {}
+    public setContent(_: string) {}
+}
+
+export class Layout extends FakeElement {
+    public computed = { xmin: 0, ymin: 0, width: 80, height: 24 }
+    public zChildren: any[] = []
+    public updateLayout() {}
+    public addRow(_row: any) {}
+    public setRowHeight(_idx: number, _h: any) {}
+    public addColumn(_idx: number, _col: any) {}
+    public setColumnWidth(_opts: any) {}
+    public getRows() {
+        return []
+    }
+    public off(_event: string, _cb: any) {}
+    public onParentResize() {}
+}
+
+export class Palette {}
+
+const fakeDocument = {
+    eventSource: { on(_event: string, _cb: any) {} },
+    __widget: null as any,
+    inputWidth: 120,
+    inputHeight: 40,
+    focusElement: { __widget: null },
+    giveFocusTo: (_el: any) => {},
+    destroy: () => {},
+}
+
+const fakeTerm = {
+    createDocument: () => fakeDocument,
+    grabInput: (_opts: any) => {},
+    on: (_event: string, _cb: any) => {},
+    hideCursor: (_v: boolean) => {},
+    windowTitle: (_t: string) => {},
+    styleReset: () => {},
+    clear: () => {},
+    removeAllListeners: () => {},
+}
+
+const terminalKit = {
+    terminal: fakeTerm,
+    TextBox,
+    Bar,
+    Layout,
+    Palette,
+}
+
+export default terminalKit

package/src/__tests__/support/AbstractForInstanceTest.ts

@@ -0,0 +1,12 @@
+import assert from '../../utilities/assert.js'
+
+export default abstract class AbstractForInstanceTest {
+    protected static wasBeforeAllCalled = false
+    public static async beforeAll() {
+        assert.isFalse(
+            this.wasBeforeAllCalled,
+            'beforeAll in parent class not referrenced'
+        )
+        this.wasBeforeAllCalled = true
+    }
+}

package/src/__tests__/support/AbstractLevelOneTest.ts

@@ -0,0 +1,3 @@
+import AbstractBeforeAllLevelTwoTest from './AbstractLevelTwoTest.js'
+
+export default abstract class AbstractBeforeAllLevelOneTest extends AbstractBeforeAllLevelTwoTest {}

package/src/__tests__/support/AbstractLevelTwoTest.ts

@@ -0,0 +1,16 @@
+import AbstractModuleTest from '../../impl/AbstractModuleTest.js'
+
+export default abstract class AbstractBeforeAllLevelTwoTest extends AbstractModuleTest {
+    protected static wasBeforeAllLevelTwoCalled = false
+    protected wasBeforeEachLevelTwoCalled = false
+
+    protected static async beforeAll() {
+        await super.beforeAll()
+        this.wasBeforeAllLevelTwoCalled = true
+    }
+
+    protected async beforeEach() {
+        await super.beforeEach()
+        this.wasBeforeEachLevelTwoCalled = true
+    }
+}

package/src/__tests__/support/AbstractStaticTest.ts

@@ -0,0 +1,16 @@
+import AbstractModuleTest from '../../impl/AbstractModuleTest.js'
+
+export default abstract class AbstractStaticTest extends AbstractModuleTest {
+    protected static didCallAnotherStaticMethodInBeforeEach = false
+    protected static didSetInBeforeAll: boolean
+
+    protected static async beforeAll() {
+        await super.beforeAll()
+        this.callAnotherStaticMethod()
+        this.didSetInBeforeAll = true
+    }
+
+    private static callAnotherStaticMethod() {
+        this.didCallAnotherStaticMethodInBeforeEach = true
+    }
+}

package/src/__tests__/support/AbstractTestOnInstanceTest.ts

@@ -0,0 +1,30 @@
+import AbstractModuleTest from '../../impl/AbstractModuleTest.js'
+
+export default abstract class AbstractTestOnInstanceTest extends AbstractModuleTest {
+    public static beforeAllCount = 0
+    public static beforeEachCount = 0
+    public static afterEachCount = 0
+
+    public static beforeBeforeAllCount = 0
+    public static beforeBeforeAllCount2 = 0
+    public static afterBeforeAllCount = 0
+    public static afterBeforeAllCount2 = 0
+
+    public static beforeBeforeEach = 0
+    public static beforeBeforeEach2 = 0
+
+    public static afterBeforeEach = 0
+    public static afterBeforeEach2 = 0
+
+    public static beforeAfterEach = 0
+    public static beforeAfterEach2 = 0
+
+    public static afterAfterEach = 0
+    public static afterAfterEach2 = 0
+
+    public static beforeAfterAll = 0
+    public static beforeAfterAll2 = 0
+
+    public static afterAfterAll = 0
+    public static afterAfterAll2 = 0
+}