@neurodevs/meta-node 0.19.11 → 0.19.13

package/src/__tests__/impl/NpmAutopackage.test.ts

@@ -1,22 +1,20 @@
 import { ChildProcess, exec as execSync } from 'child_process'
 import { readFile, writeFile } from 'fs/promises'
 import { mkdir } from 'fs/promises'
+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,
@@ -34,6 +32,7 @@ import GitAutocommit from '../../impl/GitAutocommit.js'
 import NpmAutopackage, {
     Autopackage,
     AutopackageOptions,
+    TsConfig,
 } from '../../impl/NpmAutopackage.js'
 import FakeAutocommit from '../../testDoubles/Autocommit/FakeAutocommit.js'
 import AbstractPackageTest from '../AbstractPackageTest.js'
@@ -43,10 +42,120 @@ const exec = promisify(execSync)
 export default class NpmAutopackageTest extends AbstractPackageTest {
     private static instance: Autopackage
 
+    private static readonly installDir = this.generateId()
+    private static readonly description = this.generateId()
+    private static readonly gitNamespace = this.generateId()
+    private static readonly npmNamespace = this.generateId()
+    private static readonly keywords = [this.generateId(), this.generateId()]
+    private static readonly license = this.generateId()
+    private static readonly author = this.generateId()
+    private static readonly githubToken = this.generateId()
+    private static readonly randomId = this.generateId()
+
+    private static readonly packageDir = path.join(
+        this.installDir,
+        this.packageName
+    )
+
+    private static readonly packageJsonPath = path.join(
+        this.packageDir,
+        'package.json'
+    )
+
+    private static readonly gitignorePath = path.join(
+        this.packageDir,
+        '.gitignore'
+    )
+
+    private static readonly originalGitignore = this.generateId()
+
+    private static readonly updatedGitignore = `${this.originalGitignore}\nbuild/`
+
+    private static readonly tsconfigPath = path.join(
+        this.packageDir,
+        'tsconfig.json'
+    )
+
+    private static readonly tasksJsonPath = path.join(
+        this.packageDir,
+        '.vscode',
+        'tasks.json'
+    )
+
+    private static readonly testDirPath = path.join(
+        this.packageDir,
+        'src',
+        '__tests__'
+    )
+
+    private static readonly abstractTestPath = path.join(
+        this.testDirPath,
+        'AbstractPackageTest.ts'
+    )
+
+    private static readonly eslintConfigPath = path.join(
+        this.packageDir,
+        'eslint.config.js'
+    )
+
+    private static readonly prettierConfigPath = path.join(
+        this.packageDir,
+        'prettier.config.js'
+    )
+
+    private static readonly customLib = this.generateId()
+    private static readonly customType = this.generateId()
+    private static readonly customInclude = this.generateId()
+    private static readonly customOption = this.generateId()
+
+    private static readonly setupVscodeCmd = 'spruce setup.vscode --all true'
+
+    private static readonly checkGenerateIdVersionCmd = `yarn info @neurodevs/generate-id version --silent`
+    private static readonly checkNodeTddVersionCmd = `yarn info @neurodevs/node-tdd version --silent`
+    private static readonly checkEslintConfigNdxVersionCmd = `yarn info @neurodevs/eslint-config-ndx version --silent`
+    private static readonly checkPrettierConfigNdxVersionCmd = `yarn info @neurodevs/prettier-config-ndx version --silent`
+
+    private static readonly dependencies = {
+        [this.generateId()]: this.generateId(),
+        [this.generateId()]: this.generateId(),
+    }
+
+    private static readonly yarnInstallDevDepsCommand =
+        'yarn add -D @neurodevs/generate-id @neurodevs/node-tdd @neurodevs/eslint-config-ndx @neurodevs/prettier-config-ndx'
+
+    private static readonly abstractTestFile = `import AbstractModuleTest from '@neurodevs/node-tdd'
+
+export default abstract class AbstractPackageTest extends AbstractModuleTest {
+    protected static async beforeEach() {
+        await super.beforeEach()
+    }
+}
+`
+
+    private static readonly eslintConfigFile = `import esConfigNdx from './src/eslint.config.js'
+
+export default esConfigNdx
+`
+
+    private static readonly prettierConfigFile = `import prettierConfigNdx from '@neurodevs/prettier-config-ndx'
+
+export default prettierConfigNdx
+`
+
+    private static readonly 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,
+    }
+
     protected static async beforeEach() {
         await super.beforeEach()
 
-        this.fakeChdir()
         this.fakeExec()
         this.fakeFetch()
         this.fakeMkdir()
@@ -101,7 +210,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,
@@ -114,46 +223,27 @@ export default class NpmAutopackageTest extends AbstractPackageTest {
         )
     }
 
-    @test()
-    protected static async thenChdirToInstallDir() {
-        await this.run()
-
-        assert.isEqual(
-            callsToChdir[0],
-            this.installDir,
-            'Did not change to installDir!'
-        )
-    }
-
     @test()
     protected static async thenGitClone() {
         await this.run()
 
-        assert.isEqual(
-            callsToExec[0]?.command,
-            `git clone https://github.com/${this.gitNamespace}/${this.name}.git`,
+        assert.isEqualDeep(
+            callsToExec[0],
+            {
+                command: `git clone https://github.com/${this.gitNamespace}/${this.packageName}.git`,
+                options: { cwd: this.installDir },
+            },
             'Did not call git clone!'
         )
     }
 
-    @test()
-    protected static async thenChdirToPackageDir() {
-        await this.run()
-
-        assert.isEqual(
-            callsToChdir[1],
-            this.packageDir,
-            'Did not change to packageDir!'
-        )
-    }
-
     @test()
     protected static async thenGitFetchOrigin() {
         await this.run()
 
-        assert.isEqual(
-            callsToExec[1]?.command,
-            `git fetch origin`,
+        assert.isEqualDeep(
+            callsToExec[1],
+            { command: `git fetch origin`, options: { cwd: this.packageDir } },
             'Did not call git fetch origin!'
         )
     }
@@ -162,9 +252,12 @@ export default class NpmAutopackageTest extends AbstractPackageTest {
     protected static async thenGitFetchResetHard() {
         await this.run()
 
-        assert.isEqual(
-            callsToExec[2]?.command,
-            `git reset --hard origin/main`,
+        assert.isEqualDeep(
+            callsToExec[2],
+            {
+                command: `git reset --hard origin/main`,
+                options: { cwd: this.packageDir },
+            },
             'Did not call git reset hard!'
         )
     }
@@ -173,9 +266,12 @@ export default class NpmAutopackageTest extends AbstractPackageTest {
     protected static async thenSpruceCreateModule() {
         await this.run()
 
-        assert.isEqual(
-            callsToExec[4]?.command,
-            this.createModuleCmd,
+        assert.isEqualDeep(
+            callsToExec[4],
+            {
+                command: this.createModuleCmd,
+                options: { cwd: this.packageDir },
+            },
             'Did not call "spruce create.module"!'
         )
     }
@@ -185,8 +281,11 @@ export default class NpmAutopackageTest extends AbstractPackageTest {
         await this.run()
 
         assert.isEqualDeep(
-            FakeAutocommit.callsToConstructor[0]?.commitMessage,
-            `patch: create package (@neurodevs/meta-node: ${this.metaNodeVersion})`,
+            FakeAutocommit.callsToConstructor[0],
+            {
+                commitMessage: `patch: create package (@neurodevs/meta-node: ${this.metaNodeVersion})`,
+                cwd: this.packageDir,
+            },
             'Did not commit create package changes!'
         )
     }
@@ -254,8 +353,11 @@ export default class NpmAutopackageTest extends AbstractPackageTest {
         await this.run()
 
         assert.isEqualDeep(
-            FakeAutocommit.callsToConstructor[1]?.commitMessage,
-            `patch: update package.json (@neurodevs/meta-node: ${this.metaNodeVersion})`,
+            FakeAutocommit.callsToConstructor[1],
+            {
+                commitMessage: `patch: update package.json (@neurodevs/meta-node: ${this.metaNodeVersion})`,
+                cwd: this.packageDir,
+            },
             'Did not commit update package changes!'
         )
     }
@@ -268,7 +370,7 @@ export default class NpmAutopackageTest extends AbstractPackageTest {
             callsToWriteFile[1],
             {
                 file: this.gitignorePath,
-                data: this.buildDirGitignorePattern,
+                data: '\nbuild/\n',
                 options: { encoding: 'utf-8', flag: 'a' },
             },
             'Did not update .gitignore as expected!'
@@ -280,19 +382,54 @@ export default class NpmAutopackageTest extends AbstractPackageTest {
         await this.run()
 
         assert.isEqualDeep(
-            FakeAutocommit.callsToConstructor[2]?.commitMessage,
-            `patch: add build dir to gitignore (@neurodevs/meta-node: ${this.metaNodeVersion})`,
+            FakeAutocommit.callsToConstructor[2],
+            {
+                commitMessage: `patch: add build dir to gitignore (@neurodevs/meta-node: ${this.metaNodeVersion})`,
+                cwd: this.packageDir,
+            },
             'Did not commit .gitignore changes!'
         )
     }
 
+    @test()
+    protected 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!'
+        )
+    }
+
+    @test()
+    protected 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!'
+        )
+    }
+
     @test()
     protected static async thenSpruceSetupVscode() {
         await this.run()
 
-        assert.isEqual(
-            callsToExec[5]?.command,
-            this.setupVscodeCmd,
+        assert.isEqualDeep(
+            callsToExec[5],
+            {
+                command: this.setupVscodeCmd,
+                options: { cwd: this.packageDir },
+            },
             'Did not call "spruce setup.vscode"!'
         )
     }
@@ -302,8 +439,11 @@ export default class NpmAutopackageTest extends AbstractPackageTest {
         await this.run()
 
         assert.isEqualDeep(
-            FakeAutocommit.callsToConstructor[3]?.commitMessage,
-            `patch: setup vscode (@neurodevs/meta-node: ${this.metaNodeVersion})`,
+            FakeAutocommit.callsToConstructor[4],
+            {
+                commitMessage: `patch: setup vscode (@neurodevs/meta-node: ${this.metaNodeVersion})`,
+                cwd: this.packageDir,
+            },
             'Did not commit vscode changes!'
         )
     }
@@ -312,7 +452,7 @@ export default class NpmAutopackageTest extends AbstractPackageTest {
     protected static async thenUpdatesVscodeTasksJson() {
         await this.run()
 
-        assert.isEqualDeep(callsToWriteFile[2], {
+        assert.isEqualDeep(callsToWriteFile[3], {
             file: this.tasksJsonPath,
             data: this.updatedTasksJson,
             options: { encoding: 'utf-8' },
@@ -324,30 +464,41 @@ export default class NpmAutopackageTest extends AbstractPackageTest {
         await this.run()
 
         assert.isEqualDeep(
-            FakeAutocommit.callsToConstructor[4]?.commitMessage,
-            `patch: update vscode tasks.json (@neurodevs/meta-node: ${this.metaNodeVersion})`,
+            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!'
         )
     }
 
     @test()
     protected static async thenInstallsDefaultDevDependencies() {
+        this.setShouldInstallDevDeps()
         await this.run()
 
-        assert.isEqual(
-            callsToExec[8]?.command,
-            this.yarnInstallDevDepsCommand,
+        assert.isEqualDeep(
+            callsToExec[10],
+            {
+                command: this.yarnInstallDevDepsCommand,
+                options: { cwd: this.packageDir },
+            },
             'Did not install default devDependencies!'
         )
     }
 
     @test()
     protected static async thenCommitsInstallDefaultDevDependencies() {
+        this.setShouldInstallDevDeps()
         await this.run()
 
         assert.isEqualDeep(
-            FakeAutocommit.callsToConstructor[5]?.commitMessage,
-            `patch: install default devDependencies (@neurodevs/meta-node: ${this.metaNodeVersion})`,
+            FakeAutocommit.callsToConstructor[6],
+            {
+                commitMessage: `patch: install default devDependencies (@neurodevs/meta-node: ${this.metaNodeVersion})`,
+                cwd: this.packageDir,
+            },
             'Did not commit install devDependencies changes!'
         )
     }
@@ -359,7 +510,7 @@ export default class NpmAutopackageTest extends AbstractPackageTest {
         assert.isEqualDeep(
             callsToMkdir[0],
             {
-                path: 'src/__tests__',
+                path: this.testDirPath,
                 options: { recursive: true },
             },
             'Did not install tests directory!'
@@ -368,13 +519,14 @@ export default class NpmAutopackageTest extends AbstractPackageTest {
 
     @test()
     protected static async thenInstallsAbstractPackageTest() {
+        this.setShouldInstallDevDeps()
         await this.run()
 
         assert.isEqualDeep(
-            callsToWriteFile[3],
+            callsToWriteFile[4],
             {
-                file: this.abstractPackageTestPath,
-                data: this.abstractPackageTestFile,
+                file: this.abstractTestPath,
+                data: this.abstractTestFile,
                 options: { encoding: 'utf-8' },
             },
             'Did not install AbstractPackageTest!'
@@ -383,53 +535,208 @@ export default class NpmAutopackageTest extends AbstractPackageTest {
 
     @test()
     protected static async thenCommitsInstallAbstractPackageTest() {
+        this.setShouldInstallDevDeps()
         await this.run()
 
         assert.isEqualDeep(
-            FakeAutocommit.callsToConstructor[6]?.commitMessage,
-            `patch: install AbstractPackageTest (@neurodevs/meta-node: ${this.metaNodeVersion})`,
+            FakeAutocommit.callsToConstructor[7],
+            {
+                commitMessage: `patch: install AbstractPackageTest (@neurodevs/meta-node: ${this.metaNodeVersion})`,
+                cwd: this.packageDir,
+            },
             'Did not commit install AbstractPackageTest changes!'
         )
     }
 
+    @test()
+    protected 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!'
+        )
+    }
+
+    @test()
+    protected static async thenCommitsInstallEslintConfigFile() {
+        this.setShouldInstallDevDeps()
+        await this.run()
+
+        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!'
+        )
+    }
+
+    @test()
+    protected 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!'
+        )
+    }
+
+    @test()
+    protected 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!'
+        )
+    }
+
     @test()
     protected static async lastlyOpensVscodeAtEnd() {
         await this.run()
 
-        assert.isEqual(
-            callsToExec[9]?.command,
-            'code .',
+        assert.isEqualDeep(
+            callsToExec[10],
+            { command: 'code .', options: { cwd: this.packageDir } },
             'Did not open vscode at end!'
         )
     }
 
     @test()
-    protected static async doesNotCreateRepoInGithubOrgIfDone() {
-        const fakeResponse = new Response(null, {
-            status: 200,
-            statusText: 'OK',
+    protected static async installsDevDependenciesIfGenerateIdNotLatest() {
+        setFakeExecResult(this.checkGenerateIdVersionCmd, {
+            stdout: '0.0.1',
+        } as unknown as ChildProcess)
+
+        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!'
+        )
+    }
+
+    @test()
+    protected 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!'
+        )
+    }
+
+    @test()
+    protected 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!'
+        )
+    }
+
+    @test()
+    protected 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!'
+        )
+    }
+
+    @test()
+    protected static async makeNpmNamespaceOptional() {
+        resetCallsToWriteFile()
+
+        const instance = this.NpmAutopackage({
+            npmNamespace: undefined,
         })
 
-        setFakeFetchResponse(this.reposUrl, fakeResponse)
+        await instance.run()
+
+        assert.doesInclude(
+            callsToWriteFile[0]?.data,
+            `"name": "${this.packageName}"`,
+            'Did not handle missing npmNamespace!'
+        )
+    }
 
-        await this.createAndRunAutopackage()
+    @test()
+    protected 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!')
     }
 
     @test()
     protected 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`
+                    `git clone https://github.com/${this.gitNamespace}/${this.packageName}.git`
             ).length,
             1,
             'Did not clone repo once!'
@@ -438,7 +745,7 @@ export default class NpmAutopackageTest extends AbstractPackageTest {
 
     @test()
     protected static async doesNotSpruceCreateModuleIfDone() {
-        await this.createAndRunAutopackage()
+        await this.runTwice()
 
         assert.isEqual(
             callsToExec.filter((call) => call?.command === this.createModuleCmd)
@@ -450,7 +757,7 @@ export default class NpmAutopackageTest extends AbstractPackageTest {
 
     @test()
     protected static async doesNotRunSetupVscodeIfDone() {
-        await this.createAndRunAutopackage()
+        await this.runTwice()
 
         assert.isEqual(
             callsToExec.filter((call) => call?.command === this.setupVscodeCmd)
@@ -462,7 +769,7 @@ export default class NpmAutopackageTest extends AbstractPackageTest {
 
     @test()
     protected static async doesNotCommitCreatePackageIfDone() {
-        await this.createAndRunAutopackage()
+        await this.runTwice()
 
         assert.isEqual(
             FakeAutocommit.callsToConstructor.filter(
@@ -477,7 +784,7 @@ export default class NpmAutopackageTest extends AbstractPackageTest {
 
     @test()
     protected static async doesNotCommitUpdatePackageIfDone() {
-        await this.createAndRunAutopackage()
+        await this.runTwice()
 
         assert.isEqual(
             FakeAutocommit.callsToConstructor.filter(
@@ -492,7 +799,7 @@ export default class NpmAutopackageTest extends AbstractPackageTest {
 
     @test()
     protected static async doesNotCommitUpdateGitignoreIfDone() {
-        await this.createAndRunAutopackage()
+        await this.runTwice()
 
         assert.isEqual(
             FakeAutocommit.callsToConstructor.filter(
@@ -505,9 +812,24 @@ export default class NpmAutopackageTest extends AbstractPackageTest {
         )
     }
 
+    @test()
+    protected 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!'
+        )
+    }
+
     @test()
     protected static async doesNotCommitSetupVscodeIfDone() {
-        await this.createAndRunAutopackage()
+        await this.runTwice()
 
         assert.isEqual(
             FakeAutocommit.callsToConstructor.filter(
@@ -522,7 +844,7 @@ export default class NpmAutopackageTest extends AbstractPackageTest {
 
     @test()
     protected static async doesNotOverrideOriginalDependencies() {
-        await this.createAndRunAutopackage()
+        await this.runTwice()
 
         assert.isEqualDeep(
             JSON.parse(callsToWriteFile[0]?.data).dependencies,
@@ -533,23 +855,21 @@ export default class NpmAutopackageTest extends AbstractPackageTest {
 
     @test()
     protected 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,
+            1,
             'Did not update tasks.json once!'
         )
     }
 
     @test()
     protected static async doesNotOpenVscodeIfNotCloned() {
-        setPathShouldExist(this.name, true)
+        setPathShouldExist(this.packageDir, true)
 
-        await this.createAndRunAutopackage()
+        await this.run()
 
         assert.isFalse(
             callsToExec.some((call) => call?.command === 'code .'),
@@ -558,105 +878,80 @@ export default class NpmAutopackageTest extends AbstractPackageTest {
     }
 
     @test()
-    protected static async installsDevDependenciesIfGenerateIdNotLatest() {
-        setFakeExecResult(this.checkGenerateIdVersionCmd, {
-            stdout: '0.0.1',
-        } as unknown as ChildProcess)
-
-        await this.createAndRunAutopackage()
-
-        const calls = callsToExec.filter(
-            (call) => call?.command === this.yarnInstallDevDepsCommand
+    protected static async doesNotThrowIfGenerateIdNotInPackageJson() {
+        setFakeReadFileResult(
+            this.packageJsonPath,
+            this.originalPackageJson.replace('@neurodevs/generate-id', '')
         )
 
-        assert.isEqual(
-            calls.length,
-            1,
-            'Should not install default devDependencies if already installed!'
-        )
+        await this.runTwice()
     }
 
     @test()
-    protected static async installsDevDependenciesIfNodeTddNotLatest() {
-        setFakeExecResult(this.checkGenerateIdVersionCmd, {
-            stdout: '1.0.0',
-        } as unknown as ChildProcess)
-
-        setFakeExecResult(this.checkNodeTddVersionCmd, {
-            stdout: '0.0.1',
-        } as unknown as ChildProcess)
+    protected static async doesNotInstallAbstractPackageTestIfTsExists() {
+        setPathShouldExist(this.abstractTestPath, true)
 
-        await this.createAndRunAutopackage()
+        await this.run()
 
-        const calls = callsToExec.filter(
-            (call) => call?.command === this.yarnInstallDevDepsCommand
+        const calls = callsToWriteFile.filter(
+            (call) => call.file === this.abstractTestPath
         )
 
         assert.isEqual(
             calls.length,
-            1,
-            'Should not install default devDependencies if already installed!'
-        )
-    }
-
-    @test()
-    protected static async doesNotThrowIfGenerateIdNotInPackageJson() {
-        setFakeReadFileResult(
-            this.packageJsonPath,
-            this.originalPackageJson.replace('@neurodevs/generate-id', '')
+            0,
+            'Should not install AbstractPackageTest.ts if already exists!'
         )
-
-        await this.createAndRunAutopackage()
     }
 
     @test()
-    protected static async doesNotInstallAbstractPackageTestIfTsExists() {
-        setPathShouldExist(this.abstractPackageTestPath, true)
+    protected static async doesNotInstallAbstractPackageTestIfTsxExists() {
+        setPathShouldExist(`${this.abstractTestPath}x`, true)
 
-        await this.createAndRunAutopackage()
+        await this.run()
 
         const calls = callsToWriteFile.filter(
-            (call) => call.file === this.abstractPackageTestPath
+            (call) => call.file === this.abstractTestPath
         )
 
         assert.isEqual(
             calls.length,
             0,
-            'Should not install AbstractPackageTest.ts if already exists!'
+            'Should not install AbstractPackageTest.tsx if already exists!'
         )
     }
 
     @test()
-    protected static async doesNotInstallAbstractPackageTestIfTsxExists() {
-        setPathShouldExist(`${this.abstractPackageTestPath}x`, true)
+    protected static async doesNotInstallEslintConfigFileIfExists() {
+        setPathShouldExist(this.eslintConfigPath, true)
 
-        await this.createAndRunAutopackage()
+        await this.run()
 
         const calls = callsToWriteFile.filter(
-            (call) => call.file === this.abstractPackageTestPath
+            (call) => call.file === this.eslintConfigPath
         )
 
         assert.isEqual(
             calls.length,
             0,
-            'Should not install AbstractPackageTest.tsx if already exists!'
+            'Should not install eslint.config.js if already exists!'
         )
     }
 
     @test()
-    protected static async makeNpmNamespaceOptional() {
-        resetCallsToWriteFile()
+    protected static async doesNotInstallPrettierConfigFileIfExists() {
+        setPathShouldExist(this.prettierConfigPath, true)
 
-        const instance = this.NpmAutopackage({
-            npmNamespace: undefined,
-        })
+        await this.run()
 
-        await instance.run()
+        const calls = callsToWriteFile.filter(
+            (call) => call.file === this.prettierConfigPath
+        )
 
-        assert.doesInclude(
-            callsToWriteFile[0]?.data,
-            `"name": "${this.name}"`,
-            'Did not handle missing npmNamespace!'
+        assert.isEqual(
+            calls.length,
+            0,
+            'Should not install prettier.config.js if already exists!'
         )
     }
 
@@ -664,32 +959,47 @@ export default class NpmAutopackageTest extends AbstractPackageTest {
         await this.instance.run()
     }
 
-    private static async createAndRunAutopackage() {
-        const instance = this.NpmAutopackage()
-        await instance.run()
-    }
+    private static async runTwice() {
+        await this.run()
 
-    private static get scopedPackageName() {
-        return `@${this.npmNamespace}/${this.name}`
+        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()
     }
 
-    private static get packageDir() {
-        return this.name
+    private static setShouldInstallDevDeps() {
+        setFakeExecResult(this.checkGenerateIdVersionCmd, {
+            stdout: '0.0.1',
+        } as unknown as ChildProcess)
     }
 
-    private static readonly packageJsonPath = 'package.json'
-    private static readonly gitignorePath = '.gitignore'
-    private static readonly buildDirGitignorePattern = '\nbuild/\n'
+    private static get scopedPackageName() {
+        return `@${this.npmNamespace}/${this.packageName}`
+    }
 
     private 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}"`
     }
 
-    private static readonly setupVscodeCmd = 'spruce setup.vscode --all true'
-
-    private static readonly checkGenerateIdVersionCmd = `yarn info @neurodevs/generate-id version --silent`
-    private static readonly checkNodeTddVersionCmd = `yarn info @neurodevs/node-tdd version --silent`
-
     private static orderJsonKeys(
         json: Record<string, unknown>,
         keyOrder: string[]
@@ -713,16 +1023,27 @@ export default class NpmAutopackageTest extends AbstractPackageTest {
         return ordered
     }
 
-    private static fakeChdir() {
-        NpmAutopackage.chdir = fakeChdir
-        resetCallsToChdir()
-    }
-
     private static fakeExec() {
         NpmAutopackage.exec = fakeExec as unknown as typeof exec
         resetCallsToExec()
 
         this.setFakeMetaNodeVersion()
+
+        setFakeExecResult(this.checkGenerateIdVersionCmd, {
+            stdout: '1.0.0',
+        } as unknown as ChildProcess)
+
+        setFakeExecResult(this.checkNodeTddVersionCmd, {
+            stdout: '1.0.0',
+        } as unknown as ChildProcess)
+
+        setFakeExecResult(this.checkEslintConfigNdxVersionCmd, {
+            stdout: '1.0.0',
+        } as unknown as ChildProcess)
+
+        setFakeExecResult(this.checkPrettierConfigNdxVersionCmd, {
+            stdout: '1.0.0',
+        } as unknown as ChildProcess)
     }
 
     private static fakeFetch() {
@@ -739,7 +1060,10 @@ export default class NpmAutopackageTest extends AbstractPackageTest {
         NpmAutopackage.pathExists = fakePathExists
         resetCallsToPathExists()
 
-        setPathShouldExist(this.abstractPackageTestPath, false)
+        setPathShouldExist(this.packageDir, false)
+        setPathShouldExist(this.packageJsonPath, false)
+        setPathShouldExist(this.tasksJsonPath, false)
+        setPathShouldExist(this.abstractTestPath, false)
     }
 
     private static fakeReadFile() {
@@ -752,6 +1076,13 @@ export default class NpmAutopackageTest extends AbstractPackageTest {
             this.tasksJsonPath,
             JSON.stringify(this.originalTasksJson)
         )
+
+        setFakeReadFileResult(
+            this.tsconfigPath,
+            JSON.stringify(this.originalTsconfig)
+        )
+
+        setFakeReadFileResult(this.gitignorePath, this.originalGitignore)
     }
 
     private static fakeWriteFile() {
@@ -773,39 +1104,24 @@ export default class NpmAutopackageTest extends AbstractPackageTest {
         setFakeFetchResponse(this.reposUrl, fakeResponse)
     }
 
-    private static readonly installDir = this.generateId()
-    private static readonly name = this.generateId()
-    private static readonly description = this.generateId()
-    private static readonly gitNamespace = this.generateId()
-    private static readonly npmNamespace = this.generateId()
-    private static readonly keywords = [this.generateId(), this.generateId()]
-    private static readonly license = this.generateId()
-    private static readonly author = this.generateId()
-
-    private static readonly githubToken = this.generateId()
-    private static readonly randomId = this.generateId()
-
     private static get reposUrl() {
-        return `https://api.github.com/repos/${this.gitNamespace}/${this.name}`
+        return `https://api.github.com/repos/${this.gitNamespace}/${this.packageName}`
     }
 
     private static get orgsUrl() {
         return `https://api.github.com/orgs/${this.gitNamespace}/repos`
     }
 
-    private static readonly dependencies = {
-        [this.generateId()]: this.generateId(),
-        [this.generateId()]: this.generateId(),
-    }
-
     private 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',
             },
         })
     }
@@ -815,23 +1131,62 @@ 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,
         })
     }
 
-    private static readonly tasksJsonPath = '.vscode/tasks.json'
+    private static get originalTsconfig(): TsConfig {
+        return {
+            compilerOptions: {
+                lib: [this.customLib],
+                types: [this.customType],
+            },
+            include: [this.customInclude],
+            customOption: this.customOption,
+        }
+    }
+
+    private 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'],
+        }
+    }
 
     private static originalTasksJson = {
         [this.randomId]: this.randomId,
@@ -881,32 +1236,6 @@ export default class NpmAutopackageTest extends AbstractPackageTest {
         )
     }
 
-    private static readonly yarnInstallDevDepsCommand =
-        'yarn add -D @neurodevs/generate-id@latest @neurodevs/node-tdd@latest'
-
-    private static readonly abstractPackageTestPath =
-        'src/__tests__/AbstractPackageTest.ts'
-
-    private static readonly abstractPackageTestFile = `import AbstractModuleTest from '@neurodevs/node-tdd'
-
-export default abstract class AbstractPackageTest extends AbstractModuleTest {
-    protected static async beforeEach() {
-        await super.beforeEach()
-    }
-}
-`
-
-    private static readonly 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,
-    }
-
     private static NpmAutopackage(options?: Partial<AutopackageOptions>) {
         return NpmAutopackage.Create({ ...this.defaultOptions, ...options })
     }