@neurodevs/node-tdd 1.0.6 → 1.0.7

package/src/workspace/JestJsonParser.ts

@@ -1,255 +0,0 @@
-import {
-    AssertionResult,
-    END_DIVIDER,
-    START_DIVIDER,
-    retrocycle,
-} from '@sprucelabs/jest-json-reporter'
-import { escapeRegExp } from 'lodash-es'
-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

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

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