@neurodevs/ndx-cli 0.1.54 → 0.1.57

package/src/__tests__/modules/CliCommandRunner.test.ts

@@ -1,81 +1,11 @@
-import { exec as execSync } from 'child_process'
-import { mkdir, readFile, writeFile } from 'fs/promises'
-import os from 'os'
-import path from 'path'
-import { promisify } from 'util'
 import { test, assert, generateId } from '@sprucelabs/test-utils'
-import {
-    callsToExec,
-    callsToLog,
-    callsToMkdir,
-    callsToWriteFile,
-    fakeExec,
-    fakeLog,
-    fakeMkdir,
-    fakeReadFile,
-    fakeWriteFile,
-    resetCallsToExec,
-    resetCallsToLog,
-    resetCallsToMkdir,
-    resetCallsToReadFile,
-    resetCallsToWriteFile,
-    setFakeReadFileResult,
-} from '@neurodevs/fake-node-core'
-import {
-    FakeAutomodule,
-    FakeAutopackage,
-    ImplAutomodule,
-    NpmAutopackage,
-    UiAutomodule,
-} from '@neurodevs/meta-node'
-import prompts from 'prompts'
-import CliCommandRunner from '../../modules/CliCommandRunner'
-import fakePrompts, {
-    callsToFakePrompts,
-    resetCallsToFakePrompts,
-    setFakeResponses,
-} from '../../testDoubles/prompts/fakePrompts'
-import AbstractPackageTest from '../AbstractPackageTest'
+import { callsToLog } from '@neurodevs/fake-node-core'
 
-const exec = promisify(execSync)
-
-export default class CliCommandRunnerTest extends AbstractPackageTest {
-    private static readonly createImplCommand = 'create.impl'
-    private static readonly interfaceName = generateId()
-    private static readonly implName = generateId()
-
-    private static readonly createPackageCommand = 'create.package'
-    private static readonly packageName = generateId()
-    private static readonly description = generateId()
-    private static readonly keywords = [generateId(), generateId()]
-    private static readonly githubToken = generateId()
-
-    private static readonly defaultKeywords = ['nodejs', 'typescript', 'tdd']
-
-    private static get keywordsWithDefaults() {
-        return [...this.defaultKeywords, ...this.keywords]
-    }
-
-    private static readonly createUiCommand = 'create.ui'
-    private static readonly componentName = generateId()
-
-    private static readonly upgradePackageCommand = 'upgrade.package'
+import AbstractCommandRunnerTest from '../AbstractCommandRunnerTest'
 
+export default class CliCommandRunnerTest extends AbstractCommandRunnerTest {
     protected static async beforeEach() {
         await super.beforeEach()
-
-        this.setFakeImplAutomodule()
-        this.setFakeUiAutomodule()
-        this.setFakeAutopackage()
-
-        this.setFakeExec()
-        this.setFakeLog()
-        this.setFakeMkdir()
-        this.setFakePrompts()
-        this.setFakeReadFile()
-        this.setFakeWriteFile()
-
-        process.env.GITHUB_TOKEN = this.githubToken
     }
 
     @test()
@@ -94,468 +24,6 @@ export default class CliCommandRunnerTest extends AbstractPackageTest {
         )
     }
 
-    @test()
-    protected static async createImplCreatesInstance() {
-        const instance = await this.runCreateImpl()
-
-        assert.isTruthy(
-            instance,
-            `Failed to create instance for ${this.createImplCommand}!`
-        )
-    }
-
-    @test()
-    protected static async createImplPromptsUserForInput() {
-        await this.runCreateImpl()
-
-        assert.isEqualDeep(
-            callsToFakePrompts[0],
-            [
-                {
-                    type: 'text',
-                    name: 'interfaceName',
-                    message: this.interfaceNameMessage,
-                },
-                {
-                    type: 'text',
-                    name: 'implName',
-                    message: this.implNameMessage,
-                },
-            ],
-            'Did not prompt user for expected input!'
-        )
-    }
-
-    @test()
-    protected static async createImplDoesNotContinueIfPromptsIsInterrupted() {
-        await this.runCreateImpl({
-            interfaceName: '',
-            implName: '',
-        })
-
-        assert.isEqual(
-            FakeAutomodule.numCallsToRun,
-            0,
-            'Should not have called run on ImplAutomodule!'
-        )
-    }
-
-    @test()
-    protected static async createImplCreatesTestSaveDirIfNotExists() {
-        await this.runCreateImpl()
-
-        assert.isEqualDeep(
-            callsToMkdir[0],
-            { path: this.implTestSaveDir, options: { recursive: true } },
-            'Did not create test save dir!'
-        )
-    }
-
-    @test()
-    protected static async createImplCreatesModuleSaveDirIfNotExists() {
-        await this.runCreateImpl()
-
-        assert.isEqualDeep(
-            callsToMkdir[1],
-            { path: this.implModuleSaveDir, options: { recursive: true } },
-            'Did not create module save dir!'
-        )
-    }
-
-    @test()
-    protected static async createImplCreatesFakeSaveDirIfNotExists() {
-        await this.runCreateImpl()
-
-        assert.isEqualDeep(
-            callsToMkdir[2],
-            {
-                path: `src/testDoubles/${this.interfaceName}`,
-                options: { recursive: true },
-            },
-            'Did not create fake save dir!'
-        )
-    }
-
-    @test()
-    protected static async createImplCreatesImplAutomodule() {
-        await this.runCreateImpl()
-
-        assert.isEqualDeep(
-            FakeAutomodule.callsToConstructor[0],
-            {
-                testSaveDir: this.implTestSaveDir,
-                moduleSaveDir: this.implModuleSaveDir,
-                fakeSaveDir: this.implFakeSaveDir,
-                interfaceName: this.interfaceName,
-                implName: this.implName,
-            },
-            'Did not create ImplAutomodule with expected options!'
-        )
-    }
-
-    @test()
-    protected static async createImplRunsImplAutomodule() {
-        await this.runCreateImpl()
-
-        assert.isEqual(
-            FakeAutomodule.numCallsToRun,
-            1,
-            'Did not call run on ImplAutomodule!'
-        )
-    }
-
-    @test()
-    protected static async createPackageCreatesInstance() {
-        const instance = await this.runCreatePackage()
-
-        assert.isTruthy(
-            instance,
-            `Failed to create instance for ${this.createPackageCommand}!`
-        )
-    }
-
-    @test()
-    protected static async createPackagePromptsUserForInput() {
-        await this.runCreatePackage()
-
-        assert.isEqualDeep(
-            JSON.stringify(callsToFakePrompts[0]),
-            JSON.stringify([
-                {
-                    type: 'text',
-                    name: 'packageName',
-                    message: this.packageNameMessage,
-                },
-                {
-                    type: 'text',
-                    name: 'description',
-                    message: this.packageDescriptionMessage,
-                },
-                {
-                    type: 'text',
-                    name: 'keywords',
-                    message:
-                        'Enter keywords (comma or space separated, lowercase, optional):',
-                    initial: '',
-                    format: (value: string) =>
-                        value ? this.splitOnCommaOrWhitespace(value) : [],
-                },
-            ]),
-            'Did not prompt user for expected input!'
-        )
-    }
-
-    @test()
-    protected static async createPackageDoesNotContinueIfPromptsIsInterrupted() {
-        await this.runCreatePackage({
-            packageName: '',
-            description: '',
-        })
-
-        assert.isEqual(
-            FakeAutopackage.numCallsToRun,
-            0,
-            'Should not have called run on Autopackage!'
-        )
-    }
-
-    @test()
-    protected static async createPackageCreatesNpmAutopackage() {
-        await this.runCreatePackage()
-
-        assert.isEqualDeep(
-            FakeAutopackage.callsToConstructor[0],
-            {
-                name: this.packageName,
-                description: this.description,
-                keywords: this.keywordsWithDefaults,
-                gitNamespace: 'neurodevs',
-                npmNamespace: 'neurodevs',
-                installDir: this.expandHomeDir('~/dev'),
-                license: 'MIT',
-                author: 'Eric Yates <hello@ericthecurious.com>',
-            },
-            'Did not create NpmAutopackage with expected options!'
-        )
-    }
-
-    @test()
-    protected static async createPackageRunsNpmAutopackage() {
-        await this.runCreatePackage()
-
-        assert.isEqual(
-            FakeAutopackage.numCallsToRun,
-            1,
-            'Did not call run on NpmAutopackage!'
-        )
-    }
-
-    @test()
-    protected static async createUiCreatesInstance() {
-        const instance = await this.runCreateUi()
-
-        assert.isTruthy(
-            instance,
-            `Failed to create instance for ${this.createUiCommand}!`
-        )
-    }
-
-    @test()
-    protected static async createUiPromptsInstallDependenciesIfMissing() {
-        this.setFakeReadToEmptyPackageJson()
-
-        await this.runCreateUi()
-
-        assert.isEqualDeep(
-            callsToFakePrompts[0],
-            [
-                {
-                    type: 'confirm',
-                    name: 'shouldInstall',
-                    message:
-                        'Some required dependencies are missing! Press Enter to install, or any other key to abort.',
-                    initial: true,
-                },
-            ],
-            'Did not prompt user for expected input!'
-        )
-    }
-
-    @test()
-    protected static async createUiInstallsDependenciesIfMissing() {
-        this.setFakeReadToEmptyPackageJson()
-
-        await this.runCreateUi({
-            shouldInstall: true,
-        })
-
-        assert.isEqualDeep(
-            callsToExec[0],
-            this.installDependenciesCommand,
-            'Did not install dependencies!'
-        )
-    }
-
-    @test()
-    protected static async createUiInstallsDevDependenciesIfMissing() {
-        this.setFakeReadToEmptyPackageJson()
-
-        await this.runCreateUi({
-            shouldInstall: true,
-        })
-
-        assert.isEqualDeep(
-            callsToExec[1],
-            this.installDevDependenciesCommand,
-            'Did not install dependencies!'
-        )
-    }
-
-    @test()
-    protected static async createUiInstallsIfAnyDepIsMissing() {
-        for (const dep of this.allRequiredDependencies) {
-            this.setFakeReadToAllInstalledExcept(dep)
-            resetCallsToExec()
-
-            await this.runCreateUi({
-                shouldInstall: true,
-            })
-
-            assert.isEqual(
-                callsToExec[1],
-                this.installDevDependenciesCommand,
-                'Should not have installed devDependencies!'
-            )
-        }
-    }
-
-    @test()
-    protected static async createUiUpdatesTsconfigIfDepsWereMissing() {
-        this.setFakeReadToEmptyPackageJson()
-        this.setFakeReadFileResultToTsconfig()
-
-        await this.runCreateUi({
-            shouldInstall: true,
-        })
-
-        assert.isEqualDeep(
-            callsToWriteFile[0],
-            {
-                file: this.tsconfigPath,
-                data: this.updatedTsconfigFile,
-                options: undefined,
-            },
-            'Did not update tsconfig!'
-        )
-    }
-
-    @test()
-    protected static async createUiCreatesSetupTestsIfDepsWereMissing() {
-        this.setFakeReadToEmptyPackageJson()
-
-        await this.runCreateUi({
-            shouldInstall: true,
-        })
-
-        assert.isEqualDeep(
-            callsToWriteFile[1],
-            {
-                file: 'src/__tests__/setupTests.ts',
-                data: this.setupTestsFile,
-                options: undefined,
-            },
-            'Did not create setupTests script!'
-        )
-    }
-
-    @test()
-    protected static async createUiAddsSetupTestsToPackageJsonIfDepsWereMissing() {
-        this.setFakeReadToEmptyPackageJson()
-
-        await this.runCreateUi({
-            shouldInstall: true,
-        })
-
-        assert.isEqualDeep(
-            callsToWriteFile[2],
-            {
-                file: 'package.json',
-                data: JSON.stringify(
-                    {
-                        jest: {
-                            setupFiles: [
-                                '<rootDir>/build/__tests__/setupTests.js',
-                            ],
-                        },
-                    },
-                    null,
-                    4
-                ),
-                options: undefined,
-            },
-            'Did not update package.json!'
-        )
-    }
-
-    @test()
-    protected static async createUiRecompilesTypescriptIfDepsWereMissing() {
-        this.setFakeReadToEmptyPackageJson()
-
-        await this.runCreateUi({
-            shouldInstall: true,
-        })
-
-        assert.isEqualDeep(
-            callsToExec[2],
-            'npx tsc',
-            'Did not recompile typescript!'
-        )
-    }
-
-    @test()
-    protected static async createUiDoesNotPromptIfDependenciesAreInstalled() {
-        this.setFakeReadToAllInstalled()
-
-        await this.runCreateUi()
-
-        assert.isEqual(callsToFakePrompts.length, 1, 'Prompted too many times!')
-    }
-
-    @test()
-    protected static async createUiPromptsUserForInput() {
-        this.setFakeReadToAllInstalled()
-
-        await this.runCreateUi()
-
-        assert.isEqualDeep(
-            callsToFakePrompts[0],
-            [
-                {
-                    type: 'text',
-                    name: 'componentName',
-                    message: this.componentNameMessage,
-                },
-            ],
-            'Did not prompt user for expected input!'
-        )
-    }
-
-    @test()
-    protected static async createUiDoesNotContinueIfPromptsIsInterrupted() {
-        await this.runCreateUi({
-            componentName: '',
-        })
-
-        assert.isEqual(
-            FakeAutomodule.numCallsToRun,
-            0,
-            'Should not have called run on UiAutomodule!'
-        )
-    }
-
-    @test()
-    protected static async createUiCreatesTestSaveDirIfNotExists() {
-        await this.runCreateUi()
-
-        assert.isEqualDeep(
-            callsToMkdir[0],
-            { path: this.uiTestSaveDir, options: { recursive: true } },
-            'Did not create test save dir!'
-        )
-    }
-
-    @test()
-    protected static async createUiCreatesModuleSaveDirIfNotExists() {
-        await this.runCreateUi()
-
-        assert.isEqualDeep(
-            callsToMkdir[1],
-            { path: this.uiModuleSaveDir, options: { recursive: true } },
-            'Did not create module save dir!'
-        )
-    }
-
-    @test()
-    protected static async createUiCreatesFakeSaveDirIfNotExists() {
-        await this.runCreateUi()
-
-        assert.isEqualDeep(
-            callsToMkdir[2],
-            {
-                path: this.uiFakeSaveDir,
-                options: { recursive: true },
-            },
-            'Did not create fake save dir!'
-        )
-    }
-
-    @test()
-    protected static async createUiCreatesUiAutomodule() {
-        await this.runCreateUi()
-
-        assert.isEqualDeep(
-            FakeAutomodule.callsToConstructor[0],
-            {
-                testSaveDir: this.uiTestSaveDir,
-                moduleSaveDir: this.uiModuleSaveDir,
-                fakeSaveDir: this.uiFakeSaveDir,
-                componentName: this.componentName,
-            },
-            'Did not create UiAutomodule with expected options!'
-        )
-    }
-
-    @test()
-    protected static async createUiRunsUiAutomodule() {
-        await this.runCreateUi()
-
-        assert.isEqual(
-            FakeAutomodule.numCallsToRun,
-            1,
-            'Did not call run on UiAutomodule!'
-        )
-    }
-
     @test()
     protected static async helpOutputsHelpTextToConsole() {
         const instance = this.CliCommandRunner(['help'])
@@ -591,379 +59,4 @@ export default class CliCommandRunnerTest extends AbstractPackageTest {
             'Help command should not execute any shell commands!'
         )
     }
-
-    @test()
-    protected static async upgradePackageCreatesInstance() {
-        const instance = await this.runUpgradePackage()
-
-        assert.isTruthy(
-            instance,
-            `Failed to create instance for ${this.upgradePackageCommand}!`
-        )
-    }
-
-    @test()
-    protected static async upgradePackageCreatesNpmAutopackage() {
-        await this.runUpgradePackage()
-
-        assert.isEqualDeep(
-            FakeAutopackage.callsToConstructor[0],
-            {
-                ...this.infoFromPackageJson,
-                name: `${this.packageName}`,
-                gitNamespace: 'neurodevs',
-                npmNamespace: 'neurodevs',
-                installDir: this.expandHomeDir('~/dev'),
-                license: 'MIT',
-                author: 'Eric Yates <hello@ericthecurious.com>',
-            },
-            'Did not create NpmAutopackage with expected options!'
-        )
-    }
-
-    @test()
-    protected static async upgradePackageRunsNpmAutopackage() {
-        await this.runUpgradePackage()
-
-        assert.isEqual(
-            FakeAutopackage.numCallsToRun,
-            1,
-            'Did not call run on NpmAutopackage!'
-        )
-    }
-
-    @test()
-    protected static async upgradePackageAddsDefaultKeywordsIfMissing() {
-        await this.runUpgradePackage({
-            name: this.packageName,
-            description: this.description,
-            keywords: [] as string[],
-        })
-
-        assert.isEqualDeep(
-            FakeAutopackage.callsToConstructor[0]?.keywords,
-            this.defaultKeywords,
-            'Did not add default keywords!'
-        )
-    }
-
-    @test()
-    protected static async upgradePackageDoesNotOverwriteKeywordsEvenIfDefaultsMissing() {
-        const keywords = [generateId(), generateId()]
-
-        await this.runUpgradePackage({
-            name: this.packageName,
-            description: this.description,
-            keywords,
-        })
-
-        assert.isEqualDeep(
-            FakeAutopackage.callsToConstructor[0]?.keywords,
-            [...this.defaultKeywords, ...keywords],
-            'Should not have overwritten keywords!'
-        )
-    }
-
-    @test()
-    protected static async upgradePackageExtractsPackageNameFromScopedName() {
-        await this.runUpgradePackage({
-            name: this.packageName,
-            description: this.description,
-            keywords: this.keywordsWithDefaults,
-        })
-
-        assert.isEqualDeep(
-            FakeAutopackage.callsToConstructor[0]?.name,
-            this.packageName,
-            'Did not extract package name from scoped name!'
-        )
-    }
-
-    private static async runCreateUi(
-        responses?: Record<string, string | boolean>
-    ) {
-        setFakeResponses({
-            componentName: this.componentName,
-            ...responses,
-        })
-
-        const instance = this.CliCommandRunner([this.createUiCommand])
-        await instance.run()
-
-        return instance
-    }
-
-    private static setFakeReadFileResultToTsconfig() {
-        setFakeReadFileResult(this.tsconfigPath, this.originalTsconfigFile)
-    }
-
-    private static setFakeReadToEmptyPackageJson() {
-        setFakeReadFileResult('package.json', '{}')
-    }
-
-    private static setFakeReadToAllInstalledExcept(dep: string) {
-        setFakeReadFileResult(
-            'package.json',
-            this.allInstalled.replace(dep, '')
-        )
-    }
-
-    private static setFakeReadToAllInstalled() {
-        setFakeReadFileResult('package.json', this.allInstalled)
-    }
-
-    private static setFakePackageJson(
-        responses?: Record<string, string | string[]>
-    ) {
-        const infoFromPackageJson = {
-            ...this.infoFromPackageJson,
-            ...responses,
-        }
-
-        setFakeReadFileResult(
-            'package.json',
-            JSON.stringify(infoFromPackageJson)
-        )
-
-        return infoFromPackageJson
-    }
-
-    private static readonly infoFromPackageJson = {
-        name: this.packageName,
-        description: this.description,
-        keywords: this.keywordsWithDefaults,
-    }
-
-    private static readonly allInstalled = `
-        {
-            "dependencies": {
-                "react": "^...",
-                "react-dom": "^..."
-            },
-            "devDependencies": {
-                "@types/react": "^...",
-                "@types/react-dom": "^...",
-                "@types/jsdom": "^...",
-                "@testing-library/react": "^...",
-                "@testing-library/dom": "^...",
-                "@testing-library/jest-dom": "^...",
-                "jsdom": "^..."
-            }   
-        }
-    `
-
-    private static readonly allRequiredDependencies = [
-        'react',
-        'react-dom',
-        '@types/react',
-        '@types/react-dom',
-        '@types/jsdom',
-        '@testing-library/react',
-        '@testing-library/dom',
-        '@testing-library/jest-dom',
-        'jsdom',
-    ]
-
-    private static readonly installDependenciesCommand =
-        'yarn add react react-dom'
-
-    private static readonly installDevDependenciesCommand =
-        'yarn add -D @types/react @types/react-dom @types/jsdom @testing-library/react @testing-library/dom @testing-library/jest-dom jsdom'
-
-    private static async runCreateImpl(responses?: Record<string, string>) {
-        setFakeResponses({
-            interfaceName: this.interfaceName,
-            implName: this.implName,
-            ...responses,
-        })
-
-        const instance = this.CliCommandRunner([this.createImplCommand])
-        await instance.run()
-
-        return instance
-    }
-
-    private static async runCreatePackage(responses?: Record<string, string>) {
-        setFakeResponses({
-            packageName: this.packageName,
-            description: this.description,
-            keywords: this.keywords,
-            ...responses,
-        })
-
-        const instance = this.CliCommandRunner([this.createPackageCommand])
-        await instance.run()
-
-        return instance
-    }
-
-    private static async runUpgradePackage(
-        responses?: Record<string, string | string[]>
-    ) {
-        this.setFakePackageJson(responses)
-
-        const instance = this.CliCommandRunner([this.upgradePackageCommand])
-        await instance.run()
-
-        return instance
-    }
-
-    private static expandHomeDir(inputPath: string): string {
-        return inputPath.startsWith('~')
-            ? path.join(os.homedir(), inputPath.slice(1))
-            : inputPath
-    }
-
-    private static splitOnCommaOrWhitespace(value: string) {
-        return value
-            .split(/[\s,]+/)
-            .map((v: string) => v.trim())
-            .filter(Boolean)
-    }
-
-    private static readonly implTestSaveDir = 'src/__tests__/modules'
-    private static readonly implModuleSaveDir = 'src/modules'
-
-    private static get implFakeSaveDir() {
-        return `src/testDoubles/${this.interfaceName}`
-    }
-
-    private static readonly uiTestSaveDir = 'src/__tests__/ui'
-    private static readonly uiModuleSaveDir = 'src/ui'
-
-    private static get uiFakeSaveDir() {
-        return `src/testDoubles/${this.componentName}`
-    }
-
-    private static readonly tsconfigPath = 'tsconfig.json'
-    private static readonly randomId = generateId()
-
-    private static readonly originalTsconfigFile = JSON.stringify(
-        {
-            [this.randomId]: this.randomId,
-            compilerOptions: {
-                [this.randomId]: this.randomId,
-            },
-        },
-        null,
-        4
-    )
-
-    private static readonly updatedTsconfigFile = JSON.stringify(
-        {
-            [this.randomId]: this.randomId,
-            compilerOptions: {
-                jsx: 'react-jsx',
-                [this.randomId]: this.randomId,
-            },
-            include: ['src'],
-        },
-        null,
-        4
-    )
-
-    private static setFakeImplAutomodule() {
-        ImplAutomodule.Class = FakeAutomodule
-        FakeAutomodule.resetTestDouble()
-    }
-
-    private static setFakeUiAutomodule() {
-        UiAutomodule.Class = FakeAutomodule
-        FakeAutomodule.resetTestDouble()
-    }
-
-    private static setFakeAutopackage() {
-        NpmAutopackage.Class = FakeAutopackage
-        FakeAutopackage.resetTestDouble()
-    }
-
-    private static setFakeExec() {
-        CliCommandRunner.exec = fakeExec as unknown as typeof exec
-        resetCallsToExec()
-    }
-
-    private static setFakeLog() {
-        CliCommandRunner.log = fakeLog as unknown as typeof CliCommandRunner.log
-        resetCallsToLog()
-    }
-
-    private static setFakeMkdir() {
-        CliCommandRunner.mkdir = fakeMkdir as unknown as typeof mkdir
-        resetCallsToMkdir()
-    }
-
-    private static setFakePrompts() {
-        CliCommandRunner.prompts = fakePrompts as unknown as typeof prompts
-        resetCallsToFakePrompts()
-    }
-
-    private static setFakeReadFile() {
-        CliCommandRunner.readFile = fakeReadFile as unknown as typeof readFile
-        resetCallsToReadFile()
-
-        this.setFakeReadToAllInstalled()
-        this.setFakeReadFileResultToTsconfig()
-    }
-
-    private static setFakeWriteFile() {
-        CliCommandRunner.writeFile =
-            fakeWriteFile as unknown as typeof writeFile
-        resetCallsToWriteFile()
-    }
-
-    private static readonly interfaceNameMessage =
-        'What should the interface be called? Example: YourInterface'
-
-    private static readonly implNameMessage =
-        'What should the implementation class be called? Example: YourInterfaceImpl'
-
-    private static readonly packageNameMessage =
-        'What should the package be called? Example: useful-package'
-
-    private static readonly packageDescriptionMessage =
-        'What should the package description be? Example: A useful package.'
-
-    private static readonly componentNameMessage =
-        'What should the component be called? Example: YourComponent'
-
-    private static readonly setupTestsFile = `
-        import { JSDOM } from 'jsdom'
-
-        const jsdom = new JSDOM('<!doctype html><html><body></body></html>', {
-            url: 'http://localhost',
-        })
-
-        global.window = jsdom.window as unknown as Window & typeof globalThis
-        global.document = jsdom.window.document
-        global.navigator = jsdom.window.navigator
-        global.HTMLElement = jsdom.window.HTMLElement
-        global.getComputedStyle = jsdom.window.getComputedStyle
-
-        global.ResizeObserver = class {
-            public observe() {}
-            public unobserve() {}
-            public disconnect() {}
-        }
-
-        global.SVGElement = jsdom.window.SVGElement
-    `
-
-    private static readonly helpText = `ndx CLI (Command Line Interface)
-
-    Available commands:
-
-    - create.impl       Create implementation for interface with test and fake.
-    - create.package    Create npm package using latest template.
-    - create.ui         Create React component with test and fake.
-    - upgrade.package   Upgrade existing npm package to latest template.
-    - help, --help, -h  Show this help text.
-    
-    Usage:
-
-    - ndx <command> [options]
-    `
-
-    private static CliCommandRunner(args: string[]) {
-        return CliCommandRunner.Create(args)
-    }
 }