@neurodevs/node-tdd 0.2.5 → 1.0.1

package/src/workspace/JestJsonParser.ts

@@ -0,0 +1,255 @@
+import {
+    AssertionResult,
+    END_DIVIDER,
+    START_DIVIDER,
+    retrocycle,
+} from '@sprucelabs/jest-json-reporter'
+import escapeRegExp from 'lodash/escapeRegExp.js'
+import { SpruceTestFile, TestResultStatus, TestResults } from './test.types.js'
+
+interface AggregatedResult {
+    numTotalTestSuites: number
+    numFailedTestSuites: number
+    numPassedTestSuites: number
+    numFailedTests: number
+    numPassedTests: number
+    numTotalTests: number
+    numPendingTests: number
+    numTodoTests: number
+    testResults: TestResult[]
+}
+
+interface TestResult {
+    testFilePath: string
+    failureMessage?: string | null
+    numFailingTests: number
+    testResults: AssertionResult[]
+}
+
+interface TestInfo {
+    path: string
+}
+
+type JsonParserResult =
+    | {
+          status: 'onRunStart'
+          results: AggregatedResult
+      }
+    | {
+          status: 'onTestCaseResult'
+          test: TestInfo
+          testCaseResult: AssertionResult
+      }
+    | {
+          status: 'onTestFileStart'
+          test: TestInfo
+      }
+    | {
+          status: 'onTestFileResult'
+          test: TestInfo
+          testResult: TestResult
+          aggregatedResult: AggregatedResult
+      }
+
+export default class JestJsonParser {
+    private testResults: TestResults = { totalTestFiles: 0 }
+    private buffer = ''
+
+    public write(data: string) {
+        let dataToProcess = this.buffer + data
+        let endDividerStartIdx = -1
+
+        do {
+            endDividerStartIdx = dataToProcess.search(escapeRegExp(END_DIVIDER))
+            if (endDividerStartIdx > -1) {
+                let startDividerIdx = Math.max(
+                    0,
+                    dataToProcess.search(escapeRegExp(START_DIVIDER))
+                )
+                const endDividerEndIdx = endDividerStartIdx + END_DIVIDER.length
+                if (startDividerIdx > endDividerStartIdx) {
+                    startDividerIdx = -1
+                }
+                const firstSegment = dataToProcess.substr(
+                    startDividerIdx,
+                    endDividerEndIdx - startDividerIdx
+                )
+                const cleanedSegment = firstSegment
+                    .replace(START_DIVIDER, '')
+                    .replace(END_DIVIDER, '')
+                    .trim()
+
+                const result = retrocycle(
+                    JSON.parse(cleanedSegment)
+                ) as JsonParserResult
+
+                this.ingestJestResult(result)
+
+                dataToProcess = dataToProcess.substr(endDividerEndIdx)
+            }
+        } while (endDividerStartIdx > -1)
+
+        this.buffer = dataToProcess
+    }
+
+    private ingestJestResult(result: JsonParserResult) {
+        const testFiles = this.testResults.testFiles ?? []
+        switch (result.status) {
+            case 'onRunStart':
+                this.testResults = {
+                    totalTestFiles: result.results.numTotalTestSuites,
+                }
+                break
+
+            case 'onTestCaseResult': {
+                const relativePath = this.mapAbsoluteJsToRelativeTsPath(
+                    result.test.path
+                )
+                const idx = testFiles.findIndex(
+                    (file) => file.path === relativePath
+                )
+                const test = this.testCaseResultToTest(result.testCaseResult)
+
+                if (idx === -1) {
+                    break
+                }
+                if (!testFiles[idx].tests) {
+                    testFiles[idx].tests = []
+                }
+                testFiles[idx].tests?.push(test)
+                break
+            }
+            case 'onTestFileStart':
+                testFiles.push({
+                    path: this.pullPathFromTestResponse(result),
+                    status: this.pullTestFileStatusFromTestResponse(result),
+                })
+                break
+
+            case 'onTestFileResult': {
+                this.testResults.totalTestFilesComplete =
+                    this.pullTestFilesCompleteFromAggregatedResults(
+                        result.aggregatedResult
+                    )
+                this.testResults.totalTestFiles =
+                    result.aggregatedResult.numTotalTestSuites
+                this.testResults.totalFailed =
+                    result.aggregatedResult.numFailedTests
+                this.testResults.totalPassed =
+                    result.aggregatedResult.numPassedTests
+                this.testResults.totalTests =
+                    result.aggregatedResult.numTotalTests
+                this.testResults.totalSkipped =
+                    result.aggregatedResult.numPendingTests
+                this.testResults.totalTodo =
+                    result.aggregatedResult.numTodoTests
+
+                for (const testResult of result.aggregatedResult.testResults) {
+                    const relativePath = this.mapAbsoluteJsToRelativeTsPath(
+                        testResult.testFilePath
+                    )
+                    const idx = testFiles.findIndex(
+                        (file) => file.path === relativePath
+                    )
+                    const file = {
+                        ...(testFiles[idx] ?? {}),
+                        path: relativePath,
+                        status: this.pullTestFileResultStatus(testResult),
+                        tests: this.pullTestsFromTestFileResult(testResult),
+                    }
+
+                    if (testResult.failureMessage) {
+                        file.errorMessage = testResult.failureMessage
+                    }
+
+                    if (idx === -1) {
+                        testFiles.push(file)
+                    } else {
+                        testFiles[idx] = file
+                    }
+                }
+                break
+            }
+        }
+
+        if (testFiles.length > 0) {
+            this.testResults.testFiles = testFiles
+        }
+    }
+
+    private pullTestFilesCompleteFromAggregatedResults(
+        aggregatedResult: AggregatedResult
+    ) {
+        const total =
+            aggregatedResult.numFailedTestSuites +
+            aggregatedResult.numPassedTestSuites
+
+        return total
+    }
+
+    private pullPathFromTestResponse(result: JsonParserResult) {
+        let path = ''
+
+        switch (result.status) {
+            case 'onTestFileResult':
+            case 'onTestFileStart':
+                path = result.test.path
+                break
+        }
+
+        const tsFile = this.mapAbsoluteJsToRelativeTsPath(path)
+        return tsFile
+    }
+
+    private mapAbsoluteJsToRelativeTsPath(path: string) {
+        const partialPath = path.split('__tests__').pop()
+        if (!partialPath) {
+            throw new Error('INVALID TEST FILE')
+        }
+        const tsFile = partialPath.substr(1, partialPath.length - 3) + 'ts'
+        return tsFile
+    }
+
+    private pullTestFileStatusFromTestResponse(
+        result: JsonParserResult
+    ): SpruceTestFile['status'] {
+        switch (result.status) {
+            case 'onTestFileResult':
+                return this.pullTestFileResultStatus(result.testResult)
+            default:
+                return 'running'
+        }
+    }
+
+    private pullTestFileResultStatus(testResult: TestResult): TestResultStatus {
+        return testResult.failureMessage || testResult.numFailingTests > 0
+            ? 'failed'
+            : 'passed'
+    }
+
+    private pullTestsFromTestFileResult(
+        testResult: TestResult
+    ): SpruceTestFile['tests'] {
+        return testResult.testResults.map((test: AssertionResult) =>
+            this.testCaseResultToTest(test)
+        )
+    }
+
+    private testCaseResultToTest(test: AssertionResult): {
+        name: string
+        status: AssertionResult['status']
+        errorMessages: string[]
+        duration: number
+    } {
+        return {
+            name: test.title,
+            status: test.status,
+            errorMessages: test.failureMessages,
+            duration: test.duration ?? 0,
+        }
+    }
+
+    public getResults(): TestResults {
+        return this.testResults
+    }
+}

package/src/workspace/TKButtonWidget.ts

@@ -0,0 +1,54 @@
+import terminal_kit from 'terminal-kit'
+import { ButtonWidget, ButtonWidgetOptions } from './button.types.js'
+import termKitUtil from './termKit.utility.js'
+import TkBaseWidget, { TkWidgetOptions } from './TkBaseWidget.js'
+const termKit = terminal_kit as any
+
+export default class TKButtonWidget
+    extends TkBaseWidget
+    implements ButtonWidget
+{
+    private button: any
+
+    public readonly type = 'button'
+
+    public constructor(
+        options: TkWidgetOptions & ButtonWidgetOptions & { termKitElement: any }
+    ) {
+        super({
+            ...options,
+        })
+
+        const { parent, text, ...rest } = options
+
+        const frame = termKitUtil.buildFrame(options, parent)
+
+        this.button = new termKit.Button({
+            parent: parent ? parent.getTermKitElement() : undefined,
+            content: text,
+            ...rest,
+            ...frame,
+        })
+
+        this.button.on('submit', this.handleClick.bind(this))
+        this.button.__widget = this
+
+        this.calculateSizeLockDeltas()
+    }
+
+    private handleClick() {
+        void (this as ButtonWidget).emit('click')
+    }
+
+    public getText(): string {
+        throw new Error('Method not implemented.')
+    }
+
+    public setText(text: string): void {
+        this.button.setContent(text)
+    }
+
+    public getTermKitElement() {
+        return this.button
+    }
+}

package/src/workspace/TestLogItemGenerator.ts

@@ -0,0 +1,184 @@
+import chalk from 'chalk'
+import StackCleaner from '../utilities/StackCleaner.js'
+import durationUtil from './duration.utility.js'
+import { SpruceTestFile, TestFileTest, TestRunnerStatus } from './test.types.js'
+
+export default class TestLogItemGenerator {
+    private startTimes: Record<string, number> = {}
+    private testRunnerStatus!: TestRunnerStatus
+
+    public generateLogItemForFile(
+        file: SpruceTestFile,
+        status: TestRunnerStatus
+    ): string {
+        this.testRunnerStatus = status
+
+        let logContent = ''
+        const duration = this.calculateDurationInMsForFile(file)
+
+        logContent += `${this.generateStatusBlock(file.status)}   ${file.path}${
+            duration ? ` ${this.generateDuration(file.status, duration)}` : ''
+        }\n`
+
+        if (file.tests) {
+            file.tests.forEach((test) => {
+                const bullet = this.bulletBasedOnStatus(test.status)
+                logContent += `              ${bullet} ^-${
+                    test.name
+                }^ ${this.generateDuration(test.status, test.duration)}\n`
+            })
+        }
+
+        if (file.status === 'running') {
+            const pendingKey = `${file.path}-pending-${file.tests?.length ?? 0}`
+            logContent += `                ^-${'Running next test... ⚡️⚡️⚡️'}^ ${this.generateDuration(
+                'running',
+                this.calculateDurationInMs(pendingKey)
+            )}\n`
+        }
+
+        return logContent
+    }
+
+    private generateDuration(status: any, duration: number) {
+        if (duration === 0) {
+            return ''
+        }
+        const durationColor = this.colorBasedOnStatus(status)
+        return `^${durationColor}(${durationUtil.msToFriendly(duration)})^`
+    }
+
+    private bulletBasedOnStatus(status: TestFileTest['status'] | 'running') {
+        let bullet = 'y'
+
+        switch (status) {
+            case 'running':
+                bullet = '^g(running)^'
+                break
+            case 'passed':
+                bullet = '^g√^'
+                break
+            case 'failed':
+                bullet = '^rx^'
+                break
+            case 'pending':
+            case 'skipped':
+                bullet = '^y(skipped)^'
+                break
+            case 'todo':
+                bullet = '^y(todo)^'
+                break
+            default:
+                bullet = '??'
+                break
+        }
+
+        return bullet
+    }
+
+    private calculateDurationInMsForFile(file: SpruceTestFile): number {
+        if (file.status !== 'running' && file.tests) {
+            return file.tests.reduce((time, test) => {
+                time += test.duration
+                return time
+            }, 0)
+        }
+
+        const key = file.path
+        return this.calculateDurationInMs(key)
+    }
+
+    private calculateDurationInMs(key: string) {
+        if (!this.startTimes[key]) {
+            this.startTimes[key] = new Date().getTime()
+        }
+
+        const delta = new Date().getTime() - this.startTimes[key]
+        return delta
+    }
+
+    public generateErrorLogItemForFile(file: SpruceTestFile): string {
+        let errorContent = ''
+
+        file.tests?.forEach((test) => {
+            test.errorMessages?.forEach((message) => {
+                const cleaned = StackCleaner.clean(message ?? '')
+                errorContent += ` ${chalk.red(file.path)}\n`
+                errorContent += ` - ${chalk.red(test.name)}\n\n`
+                errorContent +=
+                    cleaned.replace(/\n+ {4}at/i, '\n\n\n   at') + '\n\n\n'
+            })
+        })
+
+        if (!errorContent && file.errorMessage) {
+            errorContent += `${chalk.red(file.path)}\n`
+            errorContent += file.errorMessage + '\n\n\n'
+        }
+
+        return errorContent
+    }
+
+    public resetStartTimes() {
+        this.startTimes = {}
+    }
+
+    private generateStatusBlock(status: SpruceTestFile['status']) {
+        const bgColor = this.colorBasedOnStatus(status)
+
+        let statusLabel = status as string
+        let color = 'k'
+        let padding = 10
+        switch (status) {
+            case 'passed':
+                padding = 11
+                color = 'w'
+                break
+            case 'failed':
+                padding = 11
+                color = 'w'
+                break
+        }
+
+        if (status === 'running' && this.testRunnerStatus === 'stopped') {
+            statusLabel = 'stopped'
+            color = 'w'
+        }
+
+        return `^b^#^${bgColor}^${color}^+${this.centerStringWithSpaces(
+            statusLabel,
+            padding
+        )}^`
+    }
+
+    private colorBasedOnStatus(status: SpruceTestFile['status']) {
+        let color = 'y'
+
+        switch (status) {
+            case 'passed':
+                color = 'g'
+                break
+            case 'failed':
+                color = 'r'
+                break
+        }
+
+        if (status === 'running' && this.testRunnerStatus === 'stopped') {
+            color = 'b'
+        }
+
+        return color
+    }
+
+    private centerStringWithSpaces(text: string, numberOfSpaces: number) {
+        text = text.trim()
+        let l = text.length
+        let w2 = Math.floor(numberOfSpaces / 2)
+        let l2 = Math.floor(l / 2)
+        let s = new Array(w2 - l2 + 1).join(' ')
+        text = s + text + s
+        if (text.length < numberOfSpaces) {
+            text += new Array(numberOfSpaces - text.length + 1).join(' ')
+        }
+        return text
+    }
+}