@neurodevs/meta-node 0.0.1 → 0.2.0

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

@@ -11,80 +11,376 @@ import NpmAutopackage, {
 export default class NpmAutopackageTest extends AbstractSpruceTest {
     private static instance: Autopackage
 
+    private static callsToChdir: string[] = []
+    private static callsToExecSync: string[] = []
+    private static callsToExistsSync: string[] = []
+    private static callsToFetch: { url: string; init: RequestInit }[] = []
+    private static callsToReadFileSync: { path: string; options: any }[] = []
+    private static callsToWriteFileSync: {
+        path: string
+        data: any
+        options: any
+    }[] = []
+
     protected static async beforeEach() {
         await super.beforeEach()
 
-        this.fakeExecToPreventActual()
-        this.fakeChdirToPreventActual()
+        this.fakeChdir()
+        this.fakeExecSync()
+        this.fakeExistsSync()
+        this.fakeFetch()
+        this.fakeReadFileSync()
+        this.fakeWriteFileSync()
+
+        process.env.GITHUB_TOKEN = this.githubToken
 
         this.instance = await this.NpmAutopackage()
     }
 
     @test()
-    protected static async createsNpmAutopackageInstance() {
-        assert.isTruthy(this.instance, 'Should create an instance!')
+    protected static async createsInstance() {
+        assert.isTruthy(this.instance, 'Failed to create instance!')
+    }
+
+    @test()
+    protected static async throwsIfGithubTokenNotSet() {
+        delete process.env.GITHUB_TOKEN
+
+        await assert.doesThrowAsync(
+            async () => {
+                await this.NpmAutopackage()
+            },
+            'Please set process.env.GITHUB_TOKEN!',
+            'Did not throw with missing process.env.GITHUB_TOKEN!'
+        )
+    }
+
+    @test()
+    protected static async firstCreateRepoInGithubOrg() {
+        assert.isEqualDeep(
+            {
+                passedUrl: this.callsToFetch[0]?.url,
+                passedInit: this.callsToFetch[0]?.init,
+            },
+            {
+                passedUrl: `https://api.github.com/orgs/${this.gitNamespace}/repos`,
+                passedInit: {
+                    method: 'POST',
+                    headers: {
+                        Authorization: `token ${this.githubToken}`,
+                        Accept: 'application/vnd.github+json',
+                        'Content-Type': 'application/json',
+                    },
+                    body: JSON.stringify({
+                        name: this.packageName,
+                        private: false,
+                        description: this.packageDescription,
+                        auto_init: true,
+                        gitignore_template: 'Node',
+                        license_template: 'mit',
+                    }),
+                },
+            },
+            'Did not call fetch as expected!'
+        )
     }
 
     @test()
-    protected static async firstCallsChdirToInstallDir() {
+    protected static async secondChdirToInstallDir() {
         assert.isEqual(
             this.callsToChdir[0],
             this.installDir,
-            'Should have changed dir!'
+            'Did not change to installDir!'
         )
     }
 
     @test()
-    protected static async thenCallsSpruceCreateModule() {
+    protected static async thirdGitClone() {
         assert.isEqual(
             this.callsToExecSync[0],
+            `git clone https://github.com/${this.gitNamespace}/${this.packageName}.git`,
+            'Did not call git clone!'
+        )
+    }
+
+    @test()
+    protected static async fourthSpruceCreateModule() {
+        assert.isEqual(
+            this.callsToExecSync[1],
             this.createModuleCmd,
-            'Should have called "spruce create.module"!'
+            'Did not call "spruce create.module"!'
         )
     }
 
     @test()
-    protected static async thenCallsChdirToNewlyCreatedDir() {
+    protected static async fifthCommitCreatePackage() {
+        assert.isEqualDeep(
+            this.callsToExecSync.slice(2, 5),
+            ['git add .', 'git commit -m "patch: create package"', 'git push'],
+            'Did not commit create package changes!'
+        )
+    }
+
+    @test()
+    protected static async sixthChdirToPackageDir() {
         assert.isEqual(
             this.callsToChdir[1],
-            `${this.installDir}/${this.packageName}`,
-            'Should have changed dir!'
+            this.packageDir,
+            'Did not change to packageDir!'
         )
     }
 
     @test()
-    protected static async thenSetsUpNewGitRepo() {
+    protected static async seventhReadPackageJson() {
+        assert.isEqualDeep(this.callsToReadFileSync[0], {
+            path: this.packageJsonPath,
+            options: { encoding: 'utf-8' },
+        })
+    }
+
+    @test()
+    protected static async eighthUpdatePackageJson() {
+        const actual = this.callsToWriteFileSync[0]
+
+        const expected = {
+            path: this.packageJsonPath,
+            data: this.orderJsonKeys(JSON.parse(this.updatedPackageJson), [
+                'name',
+                'version',
+                'description',
+                'keywords',
+                'license',
+                'author',
+                'homepage',
+                'repository',
+                'bugs',
+                'main',
+                'scripts',
+                'dependencies',
+                'devDependencies',
+                'jest',
+                'skill',
+            ]),
+            options: { encoding: 'utf-8' },
+        }
+
+        const normalize = (s: string) => s.replace(/\s+/g, '').trim()
+
         assert.isEqualDeep(
-            this.callsToExecSync.slice(1, 5),
+            {
+                ...actual,
+                data: normalize(actual.data),
+            },
+            {
+                ...expected,
+                data: normalize(expected.data),
+            },
+            'Did not update package.json as expected!'
+        )
+    }
+
+    @test()
+    protected static async ninthCommitUpdatePackage() {
+        assert.isEqualDeep(
+            this.callsToExecSync.slice(5, 8),
+            ['git add .', 'git commit -m "patch: update package"', 'git push'],
+            'Did not commit update package changes!'
+        )
+    }
+
+    @test()
+    protected static async tenthAddBuildDirToGitignore() {
+        const actual = this.callsToWriteFileSync[1]
+
+        const expected = {
+            path: this.gitignorePath,
+            data: '\nbuild/\n',
+            options: { encoding: 'utf-8', flag: 'a' },
+        }
+
+        assert.isEqualDeep(
+            actual,
+            expected,
+            'Did not update .gitignore as expected!'
+        )
+    }
+
+    @test()
+    protected static async eleventhCommitUpdateGitignore() {
+        assert.isEqualDeep(
+            this.callsToExecSync.slice(8, 11),
             [
-                'git init',
                 'git add .',
-                'git commit -m "patch: create module"',
-                `git remote add origin "https://github.com/${this.gitNamespace}/${this.packageName}.git"`,
+                'git commit -m "patch: add build dir to gitignore"',
+                'git push',
             ],
-            'Should have called "git init"!'
+            'Did not commit .gitignore changes!'
         )
     }
 
     @test()
-    protected static async thenCallsSpruceSetupVscode() {
+    protected static async twelfthSpruceSetupVscode() {
         assert.isEqual(
-            this.callsToExecSync[5],
-            'spruce setup.vscode --all true',
-            'Should have called "spruce setup.vscode"!'
+            this.callsToExecSync[11],
+            NpmAutopackageTest.setupVscodeCmd,
+            'Did not call "spruce setup.vscode"!'
         )
     }
 
     @test()
-    protected static async thenGitCommitsVscodeChanges() {
+    protected static async lastlyCommitVscodeChanges() {
         assert.isEqualDeep(
-            this.callsToExecSync.slice(6, 8),
-            ['git add .', 'git commit -m "patch: setup vscode"'],
-            'Should have committed vscode changes!'
+            this.callsToExecSync.slice(12, 15),
+            ['git add .', 'git commit -m "patch: setup vscode"', 'git push'],
+            'Did not commit vscode changes!'
+        )
+    }
+
+    @test()
+    protected static async doesNotCloneRepoIfDone() {
+        await this.NpmAutopackage()
+
+        assert.isEqual(
+            this.callsToExecSync.filter(
+                (cmd) =>
+                    cmd ===
+                    `git clone https://github.com/${this.gitNamespace}/${this.packageName}.git`
+            ).length,
+            1,
+            'Did not clone repo once!'
+        )
+    }
+
+    @test()
+    protected static async doesNotSpruceCreateModuleIfDone() {
+        await this.NpmAutopackage()
+
+        assert.isEqual(
+            this.callsToExecSync.filter((cmd) => cmd === this.createModuleCmd)
+                .length,
+            1,
+            'Did not call spruce create.module once!'
+        )
+    }
+
+    @test()
+    protected static async doesNotRunSetupVscodeIfDone() {
+        await this.NpmAutopackage()
+
+        assert.isEqual(
+            this.callsToExecSync.filter((cmd) => cmd === this.setupVscodeCmd)
+                .length,
+            1,
+            'Did not call spruce setup.vscode once!'
+        )
+    }
+
+    @test()
+    protected static async doesNotCommitCreatePackageIfDone() {
+        await this.NpmAutopackage()
+
+        assert.isEqual(
+            this.callsToExecSync.filter(
+                (cmd) => cmd === 'git commit -m "patch: create package"'
+            ).length,
+            1,
+            'Did not commit create package changes once!'
+        )
+    }
+
+    @test()
+    protected static async doesNotCommitUpdatePackageIfDone() {
+        await this.NpmAutopackage()
+
+        assert.isEqual(
+            this.callsToExecSync.filter(
+                (cmd) => cmd === 'git commit -m "patch: update package"'
+            ).length,
+            1,
+            'Did not commit update package changes once!'
         )
     }
 
-    private static fakeExecToPreventActual() {
+    @test()
+    protected static async doesNotCommitUpdateGitignoreIfDone() {
+        await this.NpmAutopackage()
+
+        assert.isEqual(
+            this.callsToExecSync.filter(
+                (cmd) =>
+                    cmd === 'git commit -m "patch: add build dir to gitignore"'
+            ).length,
+            1,
+            'Did not commit gitignore changes once!'
+        )
+    }
+
+    @test()
+    protected static async doesNotCommitVscodeIfDone() {
+        await this.NpmAutopackage()
+
+        assert.isEqual(
+            this.callsToExecSync.filter(
+                (cmd) => cmd === 'git commit -m "patch: setup vscode"'
+            ).length,
+            1,
+            'Did not commit vscode changes once!'
+        )
+    }
+
+    private static get scopedPackage() {
+        return `${this.gitNamespace}/${this.packageName}`
+    }
+
+    private static get packageDir() {
+        return `${this.installDir}/${this.packageName}`
+    }
+
+    private static get packageJsonPath() {
+        return `${this.packageDir}/package.json`
+    }
+
+    private static get gitignorePath() {
+        return `${this.packageDir}/.gitignore`
+    }
+
+    private static get createModuleCmd() {
+        return `spruce create.module --name "${this.packageName}" --destination "${this.packageDir}" --description "${this.packageDescription}"`
+    }
+
+    private static readonly setupVscodeCmd = 'spruce setup.vscode --all true'
+
+    private static orderJsonKeys(
+        json: Record<string, unknown>,
+        keyOrder: string[]
+    ) {
+        const ordered: Record<string, any> = {}
+
+        for (const key of keyOrder) {
+            if (key in json) {
+                ordered[key] = json[key]
+            }
+        }
+
+        const remainingKeys = Object.keys(json)
+            .filter((k) => !keyOrder.includes(k))
+            .sort()
+
+        for (const key of remainingKeys) {
+            ordered[key] = json[key]
+        }
+
+        return JSON.stringify(ordered)
+    }
+
+    private static fakeChdir() {
+        NpmAutopackage.chdir = (dir: string) => {
+            this.callsToChdir.push(dir)
+        }
+        this.callsToChdir = []
+    }
+
+    private static fakeExecSync() {
         // @ts-ignore
         NpmAutopackage.execSync = (cmd: string) => {
             this.callsToExecSync.push(cmd)
@@ -92,23 +388,106 @@ export default class NpmAutopackageTest extends AbstractSpruceTest {
         this.callsToExecSync = []
     }
 
-    private static fakeChdirToPreventActual() {
-        NpmAutopackage.chdir = (dir: string) => {
-            this.callsToChdir.push(dir)
+    private static fakeExistsSync() {
+        // @ts-ignore
+        NpmAutopackage.existsSync = (path: string) => {
+            if (this.callsToExistsSync.includes(path)) {
+                this.callsToExistsSync.push(path)
+                return true
+            } else {
+                this.callsToExistsSync.push(path)
+                return false
+            }
         }
-        this.callsToChdir = []
+        this.callsToExistsSync = []
     }
 
-    private static callsToExecSync: string[] = []
-    private static callsToChdir: string[] = []
+    private static fakeFetch() {
+        // @ts-ignore
+        NpmAutopackage.fetch = async (url: string, init: RequestInit) => {
+            this.callsToFetch.push({ url, init })
+        }
+        this.callsToFetch = []
+    }
+
+    private static fakeReadFileSync() {
+        // @ts-ignore
+        NpmAutopackage.readFileSync = (path: string, options: any) => {
+            this.callsToReadFileSync.push({ path, options })
+
+            if (path === this.packageJsonPath) {
+                if (
+                    this.callsToReadFileSync.filter(
+                        ({ path }) => path === this.packageJsonPath
+                    ).length > 1
+                ) {
+                    return this.updatedPackageJson
+                }
+                return this.oldPackageJson
+            } else if (path === this.gitignorePath) {
+                if (
+                    this.callsToReadFileSync.filter(
+                        ({ path }) => path === this.gitignorePath
+                    ).length > 1
+                ) {
+                    return 'node_modules/\n\nbuild/\n'
+                }
+                return 'node_modules/\n'
+            }
+            return ''
+        }
+        this.callsToReadFileSync = []
+    }
+
+    private static get oldPackageJson() {
+        return JSON.stringify({
+            name: this.packageName,
+            description: 'Old description',
+        })
+    }
+
+    private static get updatedPackageJson() {
+        return JSON.stringify({
+            ...JSON.parse(this.oldPackageJson),
+            name: `@${this.scopedPackage}`,
+            keywords: this.keywords,
+            license: this.license,
+            author: this.author,
+            main: 'build/index.js',
+            homepage: `https://github.com/${this.scopedPackage}`,
+            repository: {
+                type: 'git',
+                url: `git+https://github.com/${this.scopedPackage}.git`,
+            },
+            bugs: {
+                url: `https://github.com/${this.scopedPackage}/issues`,
+            },
+            dependencies: {},
+        })
+    }
+
+    private static fakeWriteFileSync() {
+        // @ts-ignore
+        NpmAutopackage.writeFileSync = (
+            path: string,
+            data: any,
+            options: any
+        ) => {
+            this.callsToWriteFileSync.push({ path, data, options })
+        }
+        this.callsToWriteFileSync = []
+    }
 
     private static readonly packageName = generateId()
     private static readonly packageDescription = generateId()
     private static readonly gitNamespace = generateId()
     private static readonly npmNamespace = generateId()
     private static readonly installDir = generateId()
+    private static readonly keywords = [generateId(), generateId()]
+    private static readonly license = generateId()
+    private static readonly author = generateId()
 
-    private static readonly createModuleCmd = `spruce create.module --name "${this.packageName}" --destination "${this.installDir}/${this.packageName}" --description "${this.packageDescription}"`
+    private static readonly githubToken = generateId()
 
     private static readonly defaultOptions = {
         name: this.packageName,
@@ -116,6 +495,9 @@ export default class NpmAutopackageTest extends AbstractSpruceTest {
         gitNamespace: this.gitNamespace,
         npmNamespace: this.npmNamespace,
         installDir: this.installDir,
+        keywords: this.keywords,
+        license: this.license,
+        author: this.author,
     }
 
     private static NpmAutopackage(options?: Partial<AutopackageOptions>) {

package/src/index.ts

@@ -1,8 +1,3 @@
-// Autopackage
-
-export { default as NpmAutopackage } from './modules/NpmAutopackage'
-export * from './modules/NpmAutopackage'
-
 // Autocloner
 
 export { default as GitAutocloner } from './modules/GitAutocloner'
@@ -10,3 +5,27 @@ export * from './modules/GitAutocloner'
 
 export { default as FakeAutocloner } from './testDoubles/Autocloner/FakeAutocloner'
 export * from './testDoubles/Autocloner/FakeAutocloner'
+
+// Automodule
+
+export { default as NodeAutomodule } from './modules/NodeAutomodule'
+export * from './modules/NodeAutomodule'
+
+export { default as FakeAutomodule } from './testDoubles/Automodule/FakeAutomodule'
+export * from './testDoubles/Automodule/FakeAutomodule'
+
+// Autopackage
+
+export { default as NpmAutopackage } from './modules/NpmAutopackage'
+export * from './modules/NpmAutopackage'
+
+export { default as FakeAutopackage } from './testDoubles/Autopackage/FakeAutopackage'
+export * from './testDoubles/Autopackage/FakeAutopackage'
+
+// fs
+
+export { default as fakePathExists } from './testDoubles/fs/fakePathExists'
+export * from './testDoubles/fs/fakePathExists'
+
+export { default as fakeWriteFile } from './testDoubles/fs/fakeWriteFile'
+export * from './testDoubles/fs/fakeWriteFile'

package/src/modules/GitAutocloner.ts

@@ -32,12 +32,16 @@ export default class GitAutocloner implements Autocloner {
 
     private throwIfDirPathDoesNotExist() {
         if (!this.dirPathExists) {
-            throw new Error(this.dirPathDoesNotExistMessage)
+            this.throwDirPathDoesNotExist()
         }
     }
 
-    private get dirPathDoesNotExistMessage() {
-        return `dirPath does not exist: ${this.dirPath}!`
+    private get dirPathExists() {
+        return this.existsSync(this.dirPath)
+    }
+
+    private throwDirPathDoesNotExist() {
+        throw new Error(`dirPath does not exist: ${this.dirPath}!`)
     }
 
     private changeDirectoryToDirPath() {
@@ -55,10 +59,20 @@ export default class GitAutocloner implements Autocloner {
         if (!this.currentRepoExists) {
             this.tryToCloneRepo()
         } else {
-            this.log.info(this.repoExistsMessage)
+            this.log.info(`Repo exists, skipping: ${this.currentRepoName}!`)
         }
     }
 
+    private get currentRepoExists() {
+        return this.existsSync(this.currentRepoName)
+    }
+
+    private get currentRepoName() {
+        return this.currentUrl.match(this.regexForRepoName)![1]
+    }
+
+    private readonly regexForRepoName = /\/([a-zA-Z0-9_.-]+)\.git/
+
     private tryToCloneRepo() {
         try {
             this.execSync(`git clone ${this.currentUrl}`)
@@ -76,22 +90,6 @@ export default class GitAutocloner implements Autocloner {
         return `Git clone failed for repo: ${this.currentUrl}!\n\n${this.currentError}\n\n`
     }
 
-    private get dirPathExists() {
-        return this.existsSync(this.dirPath)
-    }
-
-    private get currentRepoName() {
-        return this.currentUrl.match(this.regex)![1]
-    }
-
-    private get currentRepoExists() {
-        return this.existsSync(this.currentRepoName)
-    }
-
-    private get repoExistsMessage() {
-        return `Repo already exists, skipping: ${this.currentRepoName}!`
-    }
-
     private get existsSync() {
         return GitAutocloner.existsSync
     }
@@ -99,8 +97,6 @@ export default class GitAutocloner implements Autocloner {
     private get execSync() {
         return GitAutocloner.execSync
     }
-
-    private readonly regex = /\/([a-zA-Z0-9_.-]+)\.git/
 }
 
 export interface Autocloner {