@neurodevs/ndx-cli 0.1.55 → 0.1.57

package/src/__tests__/modules/commands/BindSnippetCommand.test.ts

@@ -0,0 +1,129 @@
+import { assert, generateId, test } from '@sprucelabs/test-utils'
+import {
+    FakeSnippetKeybinder,
+    SnippetKeybinderOptions,
+} from '@neurodevs/meta-node'
+import {
+    callsToFakePrompts,
+    setFakeResponses,
+} from '../../../testDoubles/prompts/fakePrompts'
+import AbstractCommandRunnerTest from '../../AbstractCommandRunnerTest'
+
+export default class BindSnippetCommandTest extends AbstractCommandRunnerTest {
+    protected static async beforeEach() {
+        await super.beforeEach()
+    }
+
+    @test()
+    protected static async createsInstance() {
+        const instance = await this.run()
+
+        assert.isTruthy(
+            instance,
+            `Failed to create instance for ${this.bindSnippetCommand}!`
+        )
+    }
+
+    @test()
+    protected static async promptsUserForInput() {
+        await this.run()
+
+        assert.isEqualDeep(
+            callsToFakePrompts[0],
+            [
+                {
+                    type: 'text',
+                    name: 'name',
+                    message: this.nameMessage,
+                },
+                {
+                    type: 'text',
+                    name: 'description',
+                    message: this.descriptionMessage,
+                },
+                {
+                    type: 'text',
+                    name: 'lines',
+                    message: this.linesMessage,
+                },
+                {
+                    type: 'text',
+                    name: 'keybinding',
+                    message: this.keybindingMessage,
+                },
+            ],
+            'Did not prompt user for expected input!'
+        )
+    }
+
+    @test()
+    protected static async createsVscodeSnippetKeybinder() {
+        await this.run(this.promptResponses as any)
+
+        assert.isEqualDeep(
+            FakeSnippetKeybinder.callsToConstructor[0],
+            this.keybinderOptions,
+            'Did not create VscodeSnippetKeybinder with expected options!'
+        )
+    }
+
+    @test()
+    protected static async runsVscodeSnippetKeybinder() {
+        await this.run()
+
+        assert.isEqual(
+            FakeSnippetKeybinder.numCallsToRun,
+            1,
+            'Did not call run on VscodeSnippetKeybinder!'
+        )
+    }
+
+    @test()
+    protected static async doesNotContinueIfPromptsIsInterrupted() {
+        await this.run({
+            name: '',
+            description: '',
+            lines: '',
+            keybinding: '',
+        })
+
+        assert.isEqual(
+            FakeSnippetKeybinder.numCallsToRun,
+            0,
+            'Should not have called run on VscodeSnippetKeybinder!'
+        )
+    }
+
+    private static readonly snippetName = generateId()
+    private static readonly snippetDescription = generateId()
+    private static readonly lines = `${generateId()}\n${generateId()}`
+    private static readonly keybinding = generateId()
+
+    private static readonly promptResponses: Record<string, unknown> = {
+        name: this.snippetName,
+        description: this.snippetDescription,
+        lines: this.lines,
+        keybinding: this.keybinding,
+    }
+
+    private static readonly keybinderOptions: SnippetKeybinderOptions = {
+        name: this.snippetName,
+        description: this.snippetDescription,
+        lines: this.lines.split('\n'),
+        keybinding: this.keybinding,
+    }
+
+    private static readonly nameMessage = `Snippet name? Example: Singleton class template`
+    private static readonly descriptionMessage = `Snippet description? Example: A class template based on the singleton pattern`
+    private static readonly linesMessage = `Snippet text content? Newlines allowed. Press Enter twice to finish`
+    private static readonly keybindingMessage = `Snippet keybinding? Examples: ctrl+alt+c, f4`
+
+    private static async run(responses?: Record<string, unknown>) {
+        setFakeResponses(responses ?? this.promptResponses)
+
+        const instance = this.CliCommandRunner([this.bindSnippetCommand])
+        await instance.run()
+
+        return instance
+    }
+}

package/src/__tests__/modules/commands/CreateImplCommand.test.ts

@@ -0,0 +1,137 @@
+import { assert, test } from '@sprucelabs/test-utils'
+import { callsToMkdir } from '@neurodevs/fake-node-core'
+import { FakeAutomodule } from '@neurodevs/meta-node'
+import {
+    callsToFakePrompts,
+    setFakeResponses,
+} from '../../../testDoubles/prompts/fakePrompts'
+import AbstractCommandRunnerTest from '../../AbstractCommandRunnerTest'
+
+export default class CreateImplCommandTest extends AbstractCommandRunnerTest {
+    protected static async beforeEach() {
+        await super.beforeEach()
+    }
+
+    @test()
+    protected static async createsInstance() {
+        const instance = await this.run()
+
+        assert.isTruthy(
+            instance,
+            `Failed to create instance for ${this.createImplCommand}!`
+        )
+    }
+
+    @test()
+    protected static async promptsUserForInput() {
+        await this.run()
+
+        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 doesNotContinueIfPromptsIsInterrupted() {
+        await this.run({
+            interfaceName: '',
+            implName: '',
+        })
+
+        assert.isEqual(
+            FakeAutomodule.numCallsToRun,
+            0,
+            'Should not have called run on ImplAutomodule!'
+        )
+    }
+
+    @test()
+    protected static async createsTestSaveDirIfNotExists() {
+        await this.run()
+
+        assert.isEqualDeep(
+            callsToMkdir[0],
+            { path: this.implTestSaveDir, options: { recursive: true } },
+            'Did not create test save dir!'
+        )
+    }
+
+    @test()
+    protected static async createsModuleSaveDirIfNotExists() {
+        await this.run()
+
+        assert.isEqualDeep(
+            callsToMkdir[1],
+            { path: this.implModuleSaveDir, options: { recursive: true } },
+            'Did not create module save dir!'
+        )
+    }
+
+    @test()
+    protected static async createsFakeSaveDirIfNotExists() {
+        await this.run()
+
+        assert.isEqualDeep(
+            callsToMkdir[2],
+            {
+                path: `src/testDoubles/${this.interfaceName}`,
+                options: { recursive: true },
+            },
+            'Did not create fake save dir!'
+        )
+    }
+
+    @test()
+    protected static async createsImplAutomodule() {
+        await this.run()
+
+        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 runsImplAutomodule() {
+        await this.run()
+
+        assert.isEqual(
+            FakeAutomodule.numCallsToRun,
+            1,
+            'Did not call run on ImplAutomodule!'
+        )
+    }
+
+    private static async run(responses?: Record<string, string>) {
+        setFakeResponses({
+            interfaceName: this.interfaceName,
+            implName: this.implName,
+            ...responses,
+        })
+
+        const instance = this.CliCommandRunner([this.createImplCommand])
+        await instance.run()
+
+        return instance
+    }
+}

package/src/__tests__/modules/commands/CreatePackageCommand.test.ts

@@ -0,0 +1,113 @@
+import { assert, test } from '@sprucelabs/test-utils'
+import { FakeAutopackage } from '@neurodevs/meta-node'
+import {
+    callsToFakePrompts,
+    setFakeResponses,
+} from '../../../testDoubles/prompts/fakePrompts'
+import AbstractCommandRunnerTest from '../../AbstractCommandRunnerTest'
+
+export default class CreatePackageCommandTest extends AbstractCommandRunnerTest {
+    protected static async beforeEach() {
+        await super.beforeEach()
+    }
+
+    @test()
+    protected static async createsInstance() {
+        const instance = await this.run()
+
+        assert.isTruthy(
+            instance,
+            `Failed to create instance for ${this.createPackageCommand}!`
+        )
+    }
+
+    @test()
+    protected static async promptsUserForInput() {
+        await this.run()
+
+        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 doesNotContinueIfPromptsIsInterrupted() {
+        await this.run({
+            packageName: '',
+            description: '',
+        })
+
+        assert.isEqual(
+            FakeAutopackage.numCallsToRun,
+            0,
+            'Should not have called run on Autopackage!'
+        )
+    }
+
+    @test()
+    protected static async createsNpmAutopackage() {
+        await this.run()
+
+        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 runsNpmAutopackage() {
+        await this.run()
+
+        assert.isEqual(
+            FakeAutopackage.numCallsToRun,
+            1,
+            'Did not call run on NpmAutopackage!'
+        )
+    }
+
+    private static async run(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
+    }
+}

package/src/__tests__/modules/commands/CreateUiCommand.test.ts

@@ -0,0 +1,297 @@
+import { assert, test } from '@sprucelabs/test-utils'
+import {
+    callsToExec,
+    resetCallsToExec,
+    callsToWriteFile,
+    callsToMkdir,
+} from '@neurodevs/fake-node-core'
+import { FakeAutomodule } from '@neurodevs/meta-node'
+import {
+    callsToFakePrompts,
+    setFakeResponses,
+} from '../../../testDoubles/prompts/fakePrompts'
+import AbstractCommandRunnerTest from '../../AbstractCommandRunnerTest'
+
+export default class CreateUiCommandTest extends AbstractCommandRunnerTest {
+    protected static async beforeEach() {
+        await super.beforeEach()
+    }
+
+    @test()
+    protected static async createsInstance() {
+        const instance = await this.run()
+
+        assert.isTruthy(
+            instance,
+            `Failed to create instance for ${this.createUiCommand}!`
+        )
+    }
+
+    @test()
+    protected static async promptsInstallDependenciesIfMissing() {
+        this.setFakeReadToEmptyPackageJson()
+
+        await this.run()
+
+        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 installsDependenciesIfMissing() {
+        this.setFakeReadToEmptyPackageJson()
+
+        await this.run({
+            shouldInstall: true,
+        })
+
+        assert.isEqualDeep(
+            callsToExec[0],
+            this.installDependenciesCommand,
+            'Did not install dependencies!'
+        )
+    }
+
+    @test()
+    protected static async installsDevDependenciesIfMissing() {
+        this.setFakeReadToEmptyPackageJson()
+
+        await this.run({
+            shouldInstall: true,
+        })
+
+        assert.isEqualDeep(
+            callsToExec[1],
+            this.installDevDependenciesCommand,
+            'Did not install dependencies!'
+        )
+    }
+
+    @test()
+    protected static async installsIfAnyDepIsMissing() {
+        for (const dep of this.allRequiredDependencies) {
+            this.setFakeReadToAllInstalledExcept(dep)
+            resetCallsToExec()
+
+            await this.run({
+                shouldInstall: true,
+            })
+
+            assert.isEqual(
+                callsToExec[1],
+                this.installDevDependenciesCommand,
+                'Should not have installed devDependencies!'
+            )
+        }
+    }
+
+    @test()
+    protected static async updatesTsconfigIfDepsWereMissing() {
+        this.setFakeReadToEmptyPackageJson()
+        this.setFakeReadFileResultToTsconfig()
+
+        await this.run({
+            shouldInstall: true,
+        })
+
+        assert.isEqualDeep(
+            callsToWriteFile[0],
+            {
+                file: this.tsconfigPath,
+                data: this.updatedTsconfigFile,
+                options: undefined,
+            },
+            'Did not update tsconfig!'
+        )
+    }
+
+    @test()
+    protected static async createsSetupTestsIfDepsWereMissing() {
+        this.setFakeReadToEmptyPackageJson()
+
+        await this.run({
+            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 addsSetupTestsToPackageJsonIfDepsWereMissing() {
+        this.setFakeReadToEmptyPackageJson()
+
+        await this.run({
+            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 recompilesTypescriptIfDepsWereMissing() {
+        this.setFakeReadToEmptyPackageJson()
+
+        await this.run({
+            shouldInstall: true,
+        })
+
+        assert.isEqualDeep(
+            callsToExec[2],
+            'npx tsc',
+            'Did not recompile typescript!'
+        )
+    }
+
+    @test()
+    protected static async doesNotPromptIfDependenciesAreInstalled() {
+        this.setFakeReadToAllInstalled()
+
+        await this.run()
+
+        assert.isEqual(callsToFakePrompts.length, 1, 'Prompted too many times!')
+    }
+
+    @test()
+    protected static async promptsUserForInput() {
+        this.setFakeReadToAllInstalled()
+
+        await this.run()
+
+        assert.isEqualDeep(
+            callsToFakePrompts[0],
+            [
+                {
+                    type: 'text',
+                    name: 'componentName',
+                    message: this.componentNameMessage,
+                },
+            ],
+            'Did not prompt user for expected input!'
+        )
+    }
+
+    @test()
+    protected static async doesNotContinueIfPromptsIsInterrupted() {
+        await this.run({
+            componentName: '',
+        })
+
+        assert.isEqual(
+            FakeAutomodule.numCallsToRun,
+            0,
+            'Should not have called run on UiAutomodule!'
+        )
+    }
+
+    @test()
+    protected static async createsTestSaveDirIfNotExists() {
+        await this.run()
+
+        assert.isEqualDeep(
+            callsToMkdir[0],
+            { path: this.uiTestSaveDir, options: { recursive: true } },
+            'Did not create test save dir!'
+        )
+    }
+
+    @test()
+    protected static async createsModuleSaveDirIfNotExists() {
+        await this.run()
+
+        assert.isEqualDeep(
+            callsToMkdir[1],
+            { path: this.uiModuleSaveDir, options: { recursive: true } },
+            'Did not create module save dir!'
+        )
+    }
+
+    @test()
+    protected static async createsFakeSaveDirIfNotExists() {
+        await this.run()
+
+        assert.isEqualDeep(
+            callsToMkdir[2],
+            {
+                path: this.uiFakeSaveDir,
+                options: { recursive: true },
+            },
+            'Did not create fake save dir!'
+        )
+    }
+
+    @test()
+    protected static async createsUiAutomodule() {
+        await this.run()
+
+        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 runsUiAutomodule() {
+        await this.run()
+
+        assert.isEqual(
+            FakeAutomodule.numCallsToRun,
+            1,
+            'Did not call run on UiAutomodule!'
+        )
+    }
+
+    private static async run(responses?: Record<string, string | boolean>) {
+        setFakeResponses({
+            componentName: this.componentName,
+            ...responses,
+        })
+
+        const instance = this.CliCommandRunner([this.createUiCommand])
+        await instance.run()
+
+        return instance
+    }
+}