@neurodevs/meta-node 0.19.11 → 0.19.13

package/build/__tests__/impl/NpmAutopackage.test.js

@@ -5,8 +5,9 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
 import { exec as execSync } from 'child_process';
+import path from 'path';
 import { promisify } from 'util';
-import { callsToChdir, callsToExec, callsToFetch, callsToMkdir, callsToReadFile, callsToWriteFile, fakeChdir, fakeExec, fakeFetch, fakeMkdir, fakePathExists, fakeReadFile, fakeWriteFile, resetCallsToChdir, resetCallsToExec, resetCallsToFetch, resetCallsToMkdir, resetCallsToPathExists, resetCallsToReadFile, resetCallsToWriteFile, setFakeExecResult, setFakeFetchResponse, setFakeReadFileResult, setPathShouldExist, } from '@neurodevs/fake-node-core';
+import { callsToExec, callsToFetch, callsToMkdir, callsToReadFile, callsToWriteFile, fakeExec, fakeFetch, fakeMkdir, fakePathExists, fakeReadFile, fakeWriteFile, resetCallsToExec, resetCallsToFetch, resetCallsToMkdir, resetCallsToPathExists, resetCallsToReadFile, resetCallsToWriteFile, setFakeExecResult, setFakeFetchResponse, setFakeReadFileResult, setPathShouldExist, } from '@neurodevs/fake-node-core';
 import { test, assert } from '@neurodevs/node-tdd';
 import GitAutocommit from '../../impl/GitAutocommit.js';
 import NpmAutopackage from '../../impl/NpmAutopackage.js';
@@ -15,9 +16,68 @@ import AbstractPackageTest from '../AbstractPackageTest.js';
 const exec = promisify(execSync);
 export default class NpmAutopackageTest extends AbstractPackageTest {
     static instance;
+    static installDir = this.generateId();
+    static description = this.generateId();
+    static gitNamespace = this.generateId();
+    static npmNamespace = this.generateId();
+    static keywords = [this.generateId(), this.generateId()];
+    static license = this.generateId();
+    static author = this.generateId();
+    static githubToken = this.generateId();
+    static randomId = this.generateId();
+    static packageDir = path.join(this.installDir, this.packageName);
+    static packageJsonPath = path.join(this.packageDir, 'package.json');
+    static gitignorePath = path.join(this.packageDir, '.gitignore');
+    static originalGitignore = this.generateId();
+    static updatedGitignore = `${this.originalGitignore}\nbuild/`;
+    static tsconfigPath = path.join(this.packageDir, 'tsconfig.json');
+    static tasksJsonPath = path.join(this.packageDir, '.vscode', 'tasks.json');
+    static testDirPath = path.join(this.packageDir, 'src', '__tests__');
+    static abstractTestPath = path.join(this.testDirPath, 'AbstractPackageTest.ts');
+    static eslintConfigPath = path.join(this.packageDir, 'eslint.config.js');
+    static prettierConfigPath = path.join(this.packageDir, 'prettier.config.js');
+    static customLib = this.generateId();
+    static customType = this.generateId();
+    static customInclude = this.generateId();
+    static customOption = this.generateId();
+    static setupVscodeCmd = 'spruce setup.vscode --all true';
+    static checkGenerateIdVersionCmd = `yarn info @neurodevs/generate-id version --silent`;
+    static checkNodeTddVersionCmd = `yarn info @neurodevs/node-tdd version --silent`;
+    static checkEslintConfigNdxVersionCmd = `yarn info @neurodevs/eslint-config-ndx version --silent`;
+    static checkPrettierConfigNdxVersionCmd = `yarn info @neurodevs/prettier-config-ndx version --silent`;
+    static dependencies = {
+        [this.generateId()]: this.generateId(),
+        [this.generateId()]: this.generateId(),
+    };
+    static yarnInstallDevDepsCommand = 'yarn add -D @neurodevs/generate-id @neurodevs/node-tdd @neurodevs/eslint-config-ndx @neurodevs/prettier-config-ndx';
+    static abstractTestFile = `import AbstractModuleTest from '@neurodevs/node-tdd'
+
+export default abstract class AbstractPackageTest extends AbstractModuleTest {
+    protected static async beforeEach() {
+        await super.beforeEach()
+    }
+}
+`;
+    static eslintConfigFile = `import esConfigNdx from './src/eslint.config.js'
+
+export default esConfigNdx
+`;
+    static prettierConfigFile = `import prettierConfigNdx from '@neurodevs/prettier-config-ndx'
+
+export default prettierConfigNdx
+`;
+    static defaultOptions = {
+        installDir: this.installDir,
+        name: this.packageName,
+        description: this.description,
+        gitNamespace: this.gitNamespace,
+        npmNamespace: this.npmNamespace,
+        keywords: this.keywords,
+        license: this.license,
+        author: this.author,
+    };
     static async beforeEach() {
         await super.beforeEach();
-        this.fakeChdir();
         this.fakeExec();
         this.fakeFetch();
         this.fakeMkdir();
@@ -54,7 +114,7 @@ export default class NpmAutopackageTest extends AbstractPackageTest {
                     'Content-Type': 'application/json',
                 },
                 body: JSON.stringify({
-                    name: this.name,
+                    name: this.packageName,
                     private: false,
                     description: this.description,
                     auto_init: true,
@@ -64,33 +124,37 @@ export default class NpmAutopackageTest extends AbstractPackageTest {
             },
         }, 'Did not call fetch as expected!');
     }
-    static async thenChdirToInstallDir() {
-        await this.run();
-        assert.isEqual(callsToChdir[0], this.installDir, 'Did not change to installDir!');
-    }
     static async thenGitClone() {
         await this.run();
-        assert.isEqual(callsToExec[0]?.command, `git clone https://github.com/${this.gitNamespace}/${this.name}.git`, 'Did not call git clone!');
-    }
-    static async thenChdirToPackageDir() {
-        await this.run();
-        assert.isEqual(callsToChdir[1], this.packageDir, 'Did not change to packageDir!');
+        assert.isEqualDeep(callsToExec[0], {
+            command: `git clone https://github.com/${this.gitNamespace}/${this.packageName}.git`,
+            options: { cwd: this.installDir },
+        }, 'Did not call git clone!');
     }
     static async thenGitFetchOrigin() {
         await this.run();
-        assert.isEqual(callsToExec[1]?.command, `git fetch origin`, 'Did not call git fetch origin!');
+        assert.isEqualDeep(callsToExec[1], { command: `git fetch origin`, options: { cwd: this.packageDir } }, 'Did not call git fetch origin!');
     }
     static async thenGitFetchResetHard() {
         await this.run();
-        assert.isEqual(callsToExec[2]?.command, `git reset --hard origin/main`, 'Did not call git reset hard!');
+        assert.isEqualDeep(callsToExec[2], {
+            command: `git reset --hard origin/main`,
+            options: { cwd: this.packageDir },
+        }, 'Did not call git reset hard!');
     }
     static async thenSpruceCreateModule() {
         await this.run();
-        assert.isEqual(callsToExec[4]?.command, this.createModuleCmd, 'Did not call "spruce create.module"!');
+        assert.isEqualDeep(callsToExec[4], {
+            command: this.createModuleCmd,
+            options: { cwd: this.packageDir },
+        }, 'Did not call "spruce create.module"!');
     }
     static async thenCommitCreatePackage() {
         await this.run();
-        assert.isEqualDeep(FakeAutocommit.callsToConstructor[0]?.commitMessage, `patch: create package (@neurodevs/meta-node: ${this.metaNodeVersion})`, 'Did not commit create package changes!');
+        assert.isEqualDeep(FakeAutocommit.callsToConstructor[0], {
+            commitMessage: `patch: create package (@neurodevs/meta-node: ${this.metaNodeVersion})`,
+            cwd: this.packageDir,
+        }, 'Did not commit create package changes!');
     }
     static async thenReadPackageJson() {
         await this.run();
@@ -136,31 +200,58 @@ export default class NpmAutopackageTest extends AbstractPackageTest {
     }
     static async thenCommitUpdatePackage() {
         await this.run();
-        assert.isEqualDeep(FakeAutocommit.callsToConstructor[1]?.commitMessage, `patch: update package.json (@neurodevs/meta-node: ${this.metaNodeVersion})`, 'Did not commit update package changes!');
+        assert.isEqualDeep(FakeAutocommit.callsToConstructor[1], {
+            commitMessage: `patch: update package.json (@neurodevs/meta-node: ${this.metaNodeVersion})`,
+            cwd: this.packageDir,
+        }, 'Did not commit update package changes!');
     }
     static async thenAddBuildDirToGitignore() {
         await this.run();
         assert.isEqualDeep(callsToWriteFile[1], {
             file: this.gitignorePath,
-            data: this.buildDirGitignorePattern,
+            data: '\nbuild/\n',
             options: { encoding: 'utf-8', flag: 'a' },
         }, 'Did not update .gitignore as expected!');
     }
     static async thenCommitUpdateGitignore() {
         await this.run();
-        assert.isEqualDeep(FakeAutocommit.callsToConstructor[2]?.commitMessage, `patch: add build dir to gitignore (@neurodevs/meta-node: ${this.metaNodeVersion})`, 'Did not commit .gitignore changes!');
+        assert.isEqualDeep(FakeAutocommit.callsToConstructor[2], {
+            commitMessage: `patch: add build dir to gitignore (@neurodevs/meta-node: ${this.metaNodeVersion})`,
+            cwd: this.packageDir,
+        }, 'Did not commit .gitignore changes!');
+    }
+    static async thenUpdatesTsconfig() {
+        await this.run();
+        assert.isEqualDeep(callsToWriteFile[2], {
+            file: this.tsconfigPath,
+            data: JSON.stringify(this.updatedTsconfig, null, 4) + '\n',
+            options: { encoding: 'utf-8', flag: 'a' },
+        }, 'Did not update tsconfig as expected!');
+    }
+    static async thenCommitsUpdateTsconfig() {
+        await this.run();
+        assert.isEqualDeep(FakeAutocommit.callsToConstructor[3], {
+            commitMessage: `patch: update tsconfig (@neurodevs/meta-node: ${this.metaNodeVersion})`,
+            cwd: this.packageDir,
+        }, 'Did not commit tsconfig changes!');
     }
     static async thenSpruceSetupVscode() {
         await this.run();
-        assert.isEqual(callsToExec[5]?.command, this.setupVscodeCmd, 'Did not call "spruce setup.vscode"!');
+        assert.isEqualDeep(callsToExec[5], {
+            command: this.setupVscodeCmd,
+            options: { cwd: this.packageDir },
+        }, 'Did not call "spruce setup.vscode"!');
     }
     static async thenCommitVscodeChanges() {
         await this.run();
-        assert.isEqualDeep(FakeAutocommit.callsToConstructor[3]?.commitMessage, `patch: setup vscode (@neurodevs/meta-node: ${this.metaNodeVersion})`, 'Did not commit vscode changes!');
+        assert.isEqualDeep(FakeAutocommit.callsToConstructor[4], {
+            commitMessage: `patch: setup vscode (@neurodevs/meta-node: ${this.metaNodeVersion})`,
+            cwd: this.packageDir,
+        }, 'Did not commit vscode changes!');
     }
     static async thenUpdatesVscodeTasksJson() {
         await this.run();
-        assert.isEqualDeep(callsToWriteFile[2], {
+        assert.isEqualDeep(callsToWriteFile[3], {
             file: this.tasksJsonPath,
             data: this.updatedTasksJson,
             options: { encoding: 'utf-8' },
@@ -168,164 +259,253 @@ export default class NpmAutopackageTest extends AbstractPackageTest {
     }
     static async thenCommitsUpdateVscodeTasksJson() {
         await this.run();
-        assert.isEqualDeep(FakeAutocommit.callsToConstructor[4]?.commitMessage, `patch: update vscode tasks.json (@neurodevs/meta-node: ${this.metaNodeVersion})`, 'Did not commit updated vscode tasks.json changes!');
+        assert.isEqualDeep(FakeAutocommit.callsToConstructor[5], {
+            commitMessage: `patch: update vscode tasks.json (@neurodevs/meta-node: ${this.metaNodeVersion})`,
+            cwd: this.packageDir,
+        }, 'Did not commit updated vscode tasks.json changes!');
     }
     static async thenInstallsDefaultDevDependencies() {
+        this.setShouldInstallDevDeps();
         await this.run();
-        assert.isEqual(callsToExec[8]?.command, this.yarnInstallDevDepsCommand, 'Did not install default devDependencies!');
+        assert.isEqualDeep(callsToExec[10], {
+            command: this.yarnInstallDevDepsCommand,
+            options: { cwd: this.packageDir },
+        }, 'Did not install default devDependencies!');
     }
     static async thenCommitsInstallDefaultDevDependencies() {
+        this.setShouldInstallDevDeps();
         await this.run();
-        assert.isEqualDeep(FakeAutocommit.callsToConstructor[5]?.commitMessage, `patch: install default devDependencies (@neurodevs/meta-node: ${this.metaNodeVersion})`, 'Did not commit install devDependencies changes!');
+        assert.isEqualDeep(FakeAutocommit.callsToConstructor[6], {
+            commitMessage: `patch: install default devDependencies (@neurodevs/meta-node: ${this.metaNodeVersion})`,
+            cwd: this.packageDir,
+        }, 'Did not commit install devDependencies changes!');
     }
     static async thenInstallsTestsDirectory() {
         await this.run();
         assert.isEqualDeep(callsToMkdir[0], {
-            path: 'src/__tests__',
+            path: this.testDirPath,
             options: { recursive: true },
         }, 'Did not install tests directory!');
     }
     static async thenInstallsAbstractPackageTest() {
+        this.setShouldInstallDevDeps();
         await this.run();
-        assert.isEqualDeep(callsToWriteFile[3], {
-            file: this.abstractPackageTestPath,
-            data: this.abstractPackageTestFile,
+        assert.isEqualDeep(callsToWriteFile[4], {
+            file: this.abstractTestPath,
+            data: this.abstractTestFile,
             options: { encoding: 'utf-8' },
         }, 'Did not install AbstractPackageTest!');
     }
     static async thenCommitsInstallAbstractPackageTest() {
+        this.setShouldInstallDevDeps();
+        await this.run();
+        assert.isEqualDeep(FakeAutocommit.callsToConstructor[7], {
+            commitMessage: `patch: install AbstractPackageTest (@neurodevs/meta-node: ${this.metaNodeVersion})`,
+            cwd: this.packageDir,
+        }, 'Did not commit install AbstractPackageTest changes!');
+    }
+    static async thenInstallsEslintConfigFile() {
+        this.setShouldInstallDevDeps();
+        await this.run();
+        assert.isEqualDeep(callsToWriteFile[5], {
+            file: this.eslintConfigPath,
+            data: this.eslintConfigFile,
+            options: { encoding: 'utf-8' },
+        }, 'Did not install eslint.config.js!');
+    }
+    static async thenCommitsInstallEslintConfigFile() {
+        this.setShouldInstallDevDeps();
         await this.run();
-        assert.isEqualDeep(FakeAutocommit.callsToConstructor[6]?.commitMessage, `patch: install AbstractPackageTest (@neurodevs/meta-node: ${this.metaNodeVersion})`, 'Did not commit install AbstractPackageTest changes!');
+        assert.isEqualDeep(FakeAutocommit.callsToConstructor[8], {
+            commitMessage: `patch: install eslint.config.js (@neurodevs/meta-node: ${this.metaNodeVersion})`,
+            cwd: this.packageDir,
+        }, 'Did not commit install eslint.config.js changes!');
+    }
+    static async thenInstallsPrettierConfigFile() {
+        this.setShouldInstallDevDeps();
+        await this.run();
+        assert.isEqualDeep(callsToWriteFile[6], {
+            file: this.prettierConfigPath,
+            data: this.prettierConfigFile,
+            options: { encoding: 'utf-8' },
+        }, 'Did not install prettier.config.js!');
+    }
+    static async thenCommitsInstallPrettierConfigFile() {
+        this.setShouldInstallDevDeps();
+        await this.run();
+        assert.isEqualDeep(FakeAutocommit.callsToConstructor[9], {
+            commitMessage: `patch: install prettier.config.js (@neurodevs/meta-node: ${this.metaNodeVersion})`,
+            cwd: this.packageDir,
+        }, 'Did not commit install prettier.config.js changes!');
     }
     static async lastlyOpensVscodeAtEnd() {
         await this.run();
-        assert.isEqual(callsToExec[9]?.command, 'code .', 'Did not open vscode at end!');
+        assert.isEqualDeep(callsToExec[10], { command: 'code .', options: { cwd: this.packageDir } }, 'Did not open vscode at end!');
     }
-    static async doesNotCreateRepoInGithubOrgIfDone() {
-        const fakeResponse = new Response(null, {
-            status: 200,
-            statusText: 'OK',
+    static async installsDevDependenciesIfGenerateIdNotLatest() {
+        setFakeExecResult(this.checkGenerateIdVersionCmd, {
+            stdout: '0.0.1',
         });
-        setFakeFetchResponse(this.reposUrl, fakeResponse);
-        await this.createAndRunAutopackage();
+        await this.runTwice();
+        const calls = callsToExec.filter((call) => call?.command === this.yarnInstallDevDepsCommand);
+        assert.isEqualDeep(calls[0], {
+            command: this.yarnInstallDevDepsCommand,
+            options: { cwd: this.packageDir },
+        }, 'Should install default devDependencies if not already installed!');
+    }
+    static async installsDevDependenciesIfNodeTddNotLatest() {
+        this.setShouldInstallDevDeps();
+        await this.runTwice();
+        const calls = callsToExec.filter((call) => call?.command === this.yarnInstallDevDepsCommand);
+        assert.isEqualDeep(calls[0], {
+            command: this.yarnInstallDevDepsCommand,
+            options: { cwd: this.packageDir },
+        }, 'Should install default devDependencies if not already installed!');
+    }
+    static async installsDevDependenciesIfEslintConfigNdxNotLatest() {
+        this.setShouldInstallDevDeps();
+        await this.runTwice();
+        const calls = callsToExec.filter((call) => call?.command === this.yarnInstallDevDepsCommand);
+        assert.isEqualDeep(calls[0], {
+            command: this.yarnInstallDevDepsCommand,
+            options: { cwd: this.packageDir },
+        }, 'Should install default devDependencies if not already installed!');
+    }
+    static async installsDevDependenciesIfPrettierConfigNdxNotLatest() {
+        this.setShouldInstallDevDeps();
+        await this.runTwice();
+        const calls = callsToExec.filter((call) => call?.command === this.yarnInstallDevDepsCommand);
+        assert.isEqualDeep(calls[0], {
+            command: this.yarnInstallDevDepsCommand,
+            options: { cwd: this.packageDir },
+        }, 'Should install default devDependencies if not already installed!');
+    }
+    static async makeNpmNamespaceOptional() {
+        resetCallsToWriteFile();
+        const instance = this.NpmAutopackage({
+            npmNamespace: undefined,
+        });
+        await instance.run();
+        assert.doesInclude(callsToWriteFile[0]?.data, `"name": "${this.packageName}"`, 'Did not handle missing npmNamespace!');
+    }
+    static async doesNotCreateRepoInGithubOrgIfDone() {
+        await this.runTwice();
         const numCalls = callsToFetch.filter((call) => call.input === this.orgsUrl).length;
-        assert.isEqual(numCalls, 0, 'Should not have created repo!');
+        assert.isEqual(numCalls, 1, 'Should have created repo once!');
     }
     static async doesNotCloneRepoIfDone() {
-        await this.createAndRunAutopackage();
+        await this.runTwice();
         assert.isEqual(callsToExec.filter((call) => call?.command ===
-            `git clone https://github.com/${this.gitNamespace}/${this.name}.git`).length, 1, 'Did not clone repo once!');
+            `git clone https://github.com/${this.gitNamespace}/${this.packageName}.git`).length, 1, 'Did not clone repo once!');
     }
     static async doesNotSpruceCreateModuleIfDone() {
-        await this.createAndRunAutopackage();
+        await this.runTwice();
         assert.isEqual(callsToExec.filter((call) => call?.command === this.createModuleCmd)
             .length, 1, 'Did not call spruce create.module once!');
     }
     static async doesNotRunSetupVscodeIfDone() {
-        await this.createAndRunAutopackage();
+        await this.runTwice();
         assert.isEqual(callsToExec.filter((call) => call?.command === this.setupVscodeCmd)
             .length, 1, 'Did not call spruce setup.vscode once!');
     }
     static async doesNotCommitCreatePackageIfDone() {
-        await this.createAndRunAutopackage();
+        await this.runTwice();
         assert.isEqual(FakeAutocommit.callsToConstructor.filter((call) => call?.commitMessage ===
             `patch: create package (@neurodevs/meta-node: ${this.metaNodeVersion})`).length, 1, 'Did not commit create package changes once!');
     }
     static async doesNotCommitUpdatePackageIfDone() {
-        await this.createAndRunAutopackage();
+        await this.runTwice();
         assert.isEqual(FakeAutocommit.callsToConstructor.filter((call) => call?.commitMessage ===
             `patch: update package.json (@neurodevs/meta-node: ${this.metaNodeVersion})`).length, 1, 'Did not commit update package changes once!');
     }
     static async doesNotCommitUpdateGitignoreIfDone() {
-        await this.createAndRunAutopackage();
+        await this.runTwice();
         assert.isEqual(FakeAutocommit.callsToConstructor.filter((call) => call?.commitMessage ===
             `patch: add build dir to gitignore (@neurodevs/meta-node: ${this.metaNodeVersion})`).length, 1, 'Did not commit gitignore changes once!');
     }
+    static async doesNotCommitUpdateTsconfigIfDone() {
+        await this.runTwice();
+        assert.isEqual(FakeAutocommit.callsToConstructor.filter((call) => call?.commitMessage ===
+            `patch: update tsconfig (@neurodevs/meta-node: ${this.metaNodeVersion})`).length, 1, 'Did not commit tsconfig changes once!');
+    }
     static async doesNotCommitSetupVscodeIfDone() {
-        await this.createAndRunAutopackage();
+        await this.runTwice();
         assert.isEqual(FakeAutocommit.callsToConstructor.filter((call) => call?.commitMessage ===
             `patch: setup vscode (@neurodevs/meta-node: ${this.metaNodeVersion})`).length, 1, 'Did not commit vscode changes once!');
     }
     static async doesNotOverrideOriginalDependencies() {
-        await this.createAndRunAutopackage();
+        await this.runTwice();
         assert.isEqualDeep(JSON.parse(callsToWriteFile[0]?.data).dependencies, this.dependencies, 'Did not update package.json as expected!');
     }
     static async doesNotUpdateTasksJsonIfAlreadyDone() {
-        setFakeReadFileResult(this.tasksJsonPath, this.updatedTasksJson);
-        await this.createAndRunAutopackage();
+        await this.runTwice();
         assert.isEqualDeep(callsToWriteFile.filter((call) => call.file === this.tasksJsonPath)
-            .length, 0, 'Did not update tasks.json once!');
+            .length, 1, 'Did not update tasks.json once!');
     }
     static async doesNotOpenVscodeIfNotCloned() {
-        setPathShouldExist(this.name, true);
-        await this.createAndRunAutopackage();
+        setPathShouldExist(this.packageDir, true);
+        await this.run();
         assert.isFalse(callsToExec.some((call) => call?.command === 'code .'), 'Should not open vscode if not cloned!');
     }
-    static async installsDevDependenciesIfGenerateIdNotLatest() {
-        setFakeExecResult(this.checkGenerateIdVersionCmd, {
-            stdout: '0.0.1',
-        });
-        await this.createAndRunAutopackage();
-        const calls = callsToExec.filter((call) => call?.command === this.yarnInstallDevDepsCommand);
-        assert.isEqual(calls.length, 1, 'Should not install default devDependencies if already installed!');
-    }
-    static async installsDevDependenciesIfNodeTddNotLatest() {
-        setFakeExecResult(this.checkGenerateIdVersionCmd, {
-            stdout: '1.0.0',
-        });
-        setFakeExecResult(this.checkNodeTddVersionCmd, {
-            stdout: '0.0.1',
-        });
-        await this.createAndRunAutopackage();
-        const calls = callsToExec.filter((call) => call?.command === this.yarnInstallDevDepsCommand);
-        assert.isEqual(calls.length, 1, 'Should not install default devDependencies if already installed!');
-    }
     static async doesNotThrowIfGenerateIdNotInPackageJson() {
         setFakeReadFileResult(this.packageJsonPath, this.originalPackageJson.replace('@neurodevs/generate-id', ''));
-        await this.createAndRunAutopackage();
+        await this.runTwice();
     }
     static async doesNotInstallAbstractPackageTestIfTsExists() {
-        setPathShouldExist(this.abstractPackageTestPath, true);
-        await this.createAndRunAutopackage();
-        const calls = callsToWriteFile.filter((call) => call.file === this.abstractPackageTestPath);
+        setPathShouldExist(this.abstractTestPath, true);
+        await this.run();
+        const calls = callsToWriteFile.filter((call) => call.file === this.abstractTestPath);
         assert.isEqual(calls.length, 0, 'Should not install AbstractPackageTest.ts if already exists!');
     }
     static async doesNotInstallAbstractPackageTestIfTsxExists() {
-        setPathShouldExist(`${this.abstractPackageTestPath}x`, true);
-        await this.createAndRunAutopackage();
-        const calls = callsToWriteFile.filter((call) => call.file === this.abstractPackageTestPath);
+        setPathShouldExist(`${this.abstractTestPath}x`, true);
+        await this.run();
+        const calls = callsToWriteFile.filter((call) => call.file === this.abstractTestPath);
         assert.isEqual(calls.length, 0, 'Should not install AbstractPackageTest.tsx if already exists!');
     }
-    static async makeNpmNamespaceOptional() {
-        resetCallsToWriteFile();
-        const instance = this.NpmAutopackage({
-            npmNamespace: undefined,
-        });
-        await instance.run();
-        assert.doesInclude(callsToWriteFile[0]?.data, `"name": "${this.name}"`, 'Did not handle missing npmNamespace!');
+    static async doesNotInstallEslintConfigFileIfExists() {
+        setPathShouldExist(this.eslintConfigPath, true);
+        await this.run();
+        const calls = callsToWriteFile.filter((call) => call.file === this.eslintConfigPath);
+        assert.isEqual(calls.length, 0, 'Should not install eslint.config.js if already exists!');
+    }
+    static async doesNotInstallPrettierConfigFileIfExists() {
+        setPathShouldExist(this.prettierConfigPath, true);
+        await this.run();
+        const calls = callsToWriteFile.filter((call) => call.file === this.prettierConfigPath);
+        assert.isEqual(calls.length, 0, 'Should not install prettier.config.js if already exists!');
     }
     static async run() {
         await this.instance.run();
     }
-    static async createAndRunAutopackage() {
-        const instance = this.NpmAutopackage();
-        await instance.run();
+    static async runTwice() {
+        await this.run();
+        setPathShouldExist(this.packageDir, true);
+        setPathShouldExist(this.packageJsonPath, true);
+        setPathShouldExist(this.abstractTestPath, true);
+        setPathShouldExist(this.tasksJsonPath, true);
+        setFakeReadFileResult(this.packageJsonPath, this.updatedPackageJson);
+        setFakeReadFileResult(this.gitignorePath, this.updatedGitignore);
+        setFakeReadFileResult(this.tasksJsonPath, this.updatedTasksJson);
+        setFakeReadFileResult(this.tsconfigPath, JSON.stringify(this.updatedTsconfig));
+        const fakeResponse = new Response(null, {
+            status: 200,
+            statusText: 'OK',
+        });
+        setFakeFetchResponse(this.reposUrl, fakeResponse);
+        await this.run();
     }
-    static get scopedPackageName() {
-        return `@${this.npmNamespace}/${this.name}`;
+    static setShouldInstallDevDeps() {
+        setFakeExecResult(this.checkGenerateIdVersionCmd, {
+            stdout: '0.0.1',
+        });
     }
-    static get packageDir() {
-        return this.name;
+    static get scopedPackageName() {
+        return `@${this.npmNamespace}/${this.packageName}`;
     }
-    static packageJsonPath = 'package.json';
-    static gitignorePath = '.gitignore';
-    static buildDirGitignorePattern = '\nbuild/\n';
     static get createModuleCmd() {
-        return `spruce create.module --name "${this.name}" --destination "." --description "${this.description}"`;
+        return `spruce create.module --name "${this.packageName}" --destination "." --description "${this.description}"`;
     }
-    static setupVscodeCmd = 'spruce setup.vscode --all true';
-    static checkGenerateIdVersionCmd = `yarn info @neurodevs/generate-id version --silent`;
-    static checkNodeTddVersionCmd = `yarn info @neurodevs/node-tdd version --silent`;
     static orderJsonKeys(json, keyOrder) {
         const ordered = {};
         for (const key of keyOrder) {
@@ -341,14 +521,22 @@ export default class NpmAutopackageTest extends AbstractPackageTest {
         }
         return ordered;
     }
-    static fakeChdir() {
-        NpmAutopackage.chdir = fakeChdir;
-        resetCallsToChdir();
-    }
     static fakeExec() {
         NpmAutopackage.exec = fakeExec;
         resetCallsToExec();
         this.setFakeMetaNodeVersion();
+        setFakeExecResult(this.checkGenerateIdVersionCmd, {
+            stdout: '1.0.0',
+        });
+        setFakeExecResult(this.checkNodeTddVersionCmd, {
+            stdout: '1.0.0',
+        });
+        setFakeExecResult(this.checkEslintConfigNdxVersionCmd, {
+            stdout: '1.0.0',
+        });
+        setFakeExecResult(this.checkPrettierConfigNdxVersionCmd, {
+            stdout: '1.0.0',
+        });
     }
     static fakeFetch() {
         NpmAutopackage.fetch = fakeFetch;
@@ -361,13 +549,18 @@ export default class NpmAutopackageTest extends AbstractPackageTest {
     static fakePathExists() {
         NpmAutopackage.pathExists = fakePathExists;
         resetCallsToPathExists();
-        setPathShouldExist(this.abstractPackageTestPath, false);
+        setPathShouldExist(this.packageDir, false);
+        setPathShouldExist(this.packageJsonPath, false);
+        setPathShouldExist(this.tasksJsonPath, false);
+        setPathShouldExist(this.abstractTestPath, false);
     }
     static fakeReadFile() {
         NpmAutopackage.readFile = fakeReadFile;
         resetCallsToReadFile();
         setFakeReadFileResult(this.packageJsonPath, this.originalPackageJson);
         setFakeReadFileResult(this.tasksJsonPath, JSON.stringify(this.originalTasksJson));
+        setFakeReadFileResult(this.tsconfigPath, JSON.stringify(this.originalTsconfig));
+        setFakeReadFileResult(this.gitignorePath, this.originalGitignore);
     }
     static fakeWriteFile() {
         NpmAutopackage.writeFile = fakeWriteFile;
@@ -384,34 +577,22 @@ export default class NpmAutopackageTest extends AbstractPackageTest {
         });
         setFakeFetchResponse(this.reposUrl, fakeResponse);
     }
-    static installDir = this.generateId();
-    static name = this.generateId();
-    static description = this.generateId();
-    static gitNamespace = this.generateId();
-    static npmNamespace = this.generateId();
-    static keywords = [this.generateId(), this.generateId()];
-    static license = this.generateId();
-    static author = this.generateId();
-    static githubToken = this.generateId();
-    static randomId = this.generateId();
     static get reposUrl() {
-        return `https://api.github.com/repos/${this.gitNamespace}/${this.name}`;
+        return `https://api.github.com/repos/${this.gitNamespace}/${this.packageName}`;
     }
     static get orgsUrl() {
         return `https://api.github.com/orgs/${this.gitNamespace}/repos`;
     }
-    static dependencies = {
-        [this.generateId()]: this.generateId(),
-        [this.generateId()]: this.generateId(),
-    };
     static get originalPackageJson() {
         return JSON.stringify({
-            name: this.name,
+            name: this.packageName,
             description: 'Old description',
             dependencies: this.dependencies,
             devDependencies: {
                 '@neurodevs/generate-id': '^1.0.0',
                 '@neurodevs/node-tdd': '^1.0.0',
+                '@neurodevs/eslint-config-ndx': '^1.0.0',
+                '@neurodevs/prettier-config-ndx': '^1.0.0',
             },
         });
     }
@@ -420,22 +601,60 @@ export default class NpmAutopackageTest extends AbstractPackageTest {
             ...JSON.parse(this.originalPackageJson),
             name: this.scopedPackageName,
             description: this.description,
+            type: 'module',
             keywords: this.keywords,
             license: this.license,
             author: this.author,
             main: 'build/index.js',
-            homepage: `https://github.com/${this.gitNamespace}/${this.name}`,
+            homepage: `https://github.com/${this.gitNamespace}/${this.packageName}`,
             repository: {
                 type: 'git',
-                url: `git+https://github.com/${this.gitNamespace}/${this.name}.git`,
+                url: `git+https://github.com/${this.gitNamespace}/${this.packageName}.git`,
             },
             bugs: {
-                url: `https://github.com/${this.gitNamespace}/${this.name}/issues`,
+                url: `https://github.com/${this.gitNamespace}/${this.packageName}/issues`,
             },
             dependencies: this.dependencies,
         });
     }
-    static tasksJsonPath = '.vscode/tasks.json';
+    static get originalTsconfig() {
+        return {
+            compilerOptions: {
+                lib: [this.customLib],
+                types: [this.customType],
+            },
+            include: [this.customInclude],
+            customOption: this.customOption,
+        };
+    }
+    static get updatedTsconfig() {
+        return {
+            ...this.originalTsconfig,
+            compilerOptions: {
+                module: 'nodenext',
+                moduleResolution: 'nodenext',
+                target: 'ES2022',
+                lib: [this.customLib, 'ES2022'],
+                types: [this.customType, 'node'],
+                baseUrl: 'src',
+                outDir: 'build',
+                sourceMap: false,
+                strict: true,
+                noImplicitAny: true,
+                noImplicitReturns: true,
+                noUnusedLocals: true,
+                forceConsistentCasingInFileNames: true,
+                declaration: true,
+                skipLibCheck: true,
+                esModuleInterop: true,
+                moduleDetection: 'force',
+                allowJs: true,
+                resolveJsonModule: true,
+                experimentalDecorators: true,
+            },
+            include: [this.customInclude, './src/*.ts', './src/**/*.ts'],
+        };
+    }
     static originalTasksJson = {
         [this.randomId]: this.randomId,
         tasks: [
@@ -478,26 +697,6 @@ export default class NpmAutopackageTest extends AbstractPackageTest {
             ],
         }, null, 4);
     }
-    static yarnInstallDevDepsCommand = 'yarn add -D @neurodevs/generate-id@latest @neurodevs/node-tdd@latest';
-    static abstractPackageTestPath = 'src/__tests__/AbstractPackageTest.ts';
-    static abstractPackageTestFile = `import AbstractModuleTest from '@neurodevs/node-tdd'
-
-export default abstract class AbstractPackageTest extends AbstractModuleTest {
-    protected static async beforeEach() {
-        await super.beforeEach()
-    }
-}
-`;
-    static defaultOptions = {
-        installDir: this.installDir,
-        name: this.name,
-        description: this.description,
-        gitNamespace: this.gitNamespace,
-        npmNamespace: this.npmNamespace,
-        keywords: this.keywords,
-        license: this.license,
-        author: this.author,
-    };
     static NpmAutopackage(options) {
         return NpmAutopackage.Create({ ...this.defaultOptions, ...options });
     }
@@ -511,15 +710,9 @@ __decorate([
 __decorate([
     test()
 ], NpmAutopackageTest, "firstCreateRepoInGithubOrg", null);
-__decorate([
-    test()
-], NpmAutopackageTest, "thenChdirToInstallDir", null);
 __decorate([
     test()
 ], NpmAutopackageTest, "thenGitClone", null);
-__decorate([
-    test()
-], NpmAutopackageTest, "thenChdirToPackageDir", null);
 __decorate([
     test()
 ], NpmAutopackageTest, "thenGitFetchOrigin", null);
@@ -547,6 +740,12 @@ __decorate([
 __decorate([
     test()
 ], NpmAutopackageTest, "thenCommitUpdateGitignore", null);
+__decorate([
+    test()
+], NpmAutopackageTest, "thenUpdatesTsconfig", null);
+__decorate([
+    test()
+], NpmAutopackageTest, "thenCommitsUpdateTsconfig", null);
 __decorate([
     test()
 ], NpmAutopackageTest, "thenSpruceSetupVscode", null);
@@ -574,9 +773,36 @@ __decorate([
 __decorate([
     test()
 ], NpmAutopackageTest, "thenCommitsInstallAbstractPackageTest", null);
+__decorate([
+    test()
+], NpmAutopackageTest, "thenInstallsEslintConfigFile", null);
+__decorate([
+    test()
+], NpmAutopackageTest, "thenCommitsInstallEslintConfigFile", null);
+__decorate([
+    test()
+], NpmAutopackageTest, "thenInstallsPrettierConfigFile", null);
+__decorate([
+    test()
+], NpmAutopackageTest, "thenCommitsInstallPrettierConfigFile", null);
 __decorate([
     test()
 ], NpmAutopackageTest, "lastlyOpensVscodeAtEnd", null);
+__decorate([
+    test()
+], NpmAutopackageTest, "installsDevDependenciesIfGenerateIdNotLatest", null);
+__decorate([
+    test()
+], NpmAutopackageTest, "installsDevDependenciesIfNodeTddNotLatest", null);
+__decorate([
+    test()
+], NpmAutopackageTest, "installsDevDependenciesIfEslintConfigNdxNotLatest", null);
+__decorate([
+    test()
+], NpmAutopackageTest, "installsDevDependenciesIfPrettierConfigNdxNotLatest", null);
+__decorate([
+    test()
+], NpmAutopackageTest, "makeNpmNamespaceOptional", null);
 __decorate([
     test()
 ], NpmAutopackageTest, "doesNotCreateRepoInGithubOrgIfDone", null);
@@ -598,6 +824,9 @@ __decorate([
 __decorate([
     test()
 ], NpmAutopackageTest, "doesNotCommitUpdateGitignoreIfDone", null);
+__decorate([
+    test()
+], NpmAutopackageTest, "doesNotCommitUpdateTsconfigIfDone", null);
 __decorate([
     test()
 ], NpmAutopackageTest, "doesNotCommitSetupVscodeIfDone", null);
@@ -610,12 +839,6 @@ __decorate([
 __decorate([
     test()
 ], NpmAutopackageTest, "doesNotOpenVscodeIfNotCloned", null);
-__decorate([
-    test()
-], NpmAutopackageTest, "installsDevDependenciesIfGenerateIdNotLatest", null);
-__decorate([
-    test()
-], NpmAutopackageTest, "installsDevDependenciesIfNodeTddNotLatest", null);
 __decorate([
     test()
 ], NpmAutopackageTest, "doesNotThrowIfGenerateIdNotInPackageJson", null);
@@ -627,5 +850,8 @@ __decorate([
 ], NpmAutopackageTest, "doesNotInstallAbstractPackageTestIfTsxExists", null);
 __decorate([
     test()
-], NpmAutopackageTest, "makeNpmNamespaceOptional", null);
+], NpmAutopackageTest, "doesNotInstallEslintConfigFileIfExists", null);
+__decorate([
+    test()
+], NpmAutopackageTest, "doesNotInstallPrettierConfigFileIfExists", null);
 //# sourceMappingURL=NpmAutopackage.test.js.map