@neurodevs/meta-node 0.6.1 → 0.7.0

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

@@ -1,38 +1,51 @@
+import { exec as execSync } from 'child_process'
+import { readFile, writeFile } from 'fs/promises'
+import { promisify } from 'util'
 import { test, assert, generateId } from '@sprucelabs/test-utils'
+import {
+    callsToChdir,
+    callsToExec,
+    callsToFetch,
+    callsToReadFile,
+    callsToWriteFile,
+    fakeChdir,
+    fakeExec,
+    fakeFetch,
+    fakePathExists,
+    fakeReadFile,
+    fakeWriteFile,
+    resetCallsToChdir,
+    resetCallsToExec,
+    resetCallsToFetch,
+    resetCallsToPathExists,
+    resetCallsToReadFile,
+    resetCallsToWriteFile,
+    setFakeReadFileResult,
+} from '@neurodevs/fake-node-core'
 import NpmAutopackage, {
     Autopackage,
     AutopackageOptions,
 } from '../../modules/NpmAutopackage'
 import AbstractPackageTest from '../AbstractPackageTest'
 
+const exec = promisify(execSync)
+
 export default class NpmAutopackageTest extends AbstractPackageTest {
     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.fakeChdir()
-        this.fakeExecSync()
-        this.fakeExistsSync()
+        this.fakeExec()
+        this.fakePathExists()
         this.fakeFetch()
-        this.fakeReadFileSync()
-        this.fakeWriteFileSync()
+        this.fakeReadFile()
+        this.fakeWriteFile()
 
         process.env.GITHUB_TOKEN = this.githubToken
 
         this.instance = this.NpmAutopackage()
-        await this.instance.run()
     }
 
     @test()
@@ -56,10 +69,12 @@ export default class NpmAutopackageTest extends AbstractPackageTest {
 
     @test()
     protected static async firstCreateRepoInGithubOrg() {
+        await this.run()
+
         assert.isEqualDeep(
             {
-                passedUrl: this.callsToFetch[0]?.url,
-                passedInit: this.callsToFetch[0]?.init,
+                passedUrl: callsToFetch[0]?.input,
+                passedInit: callsToFetch[0]?.init,
             },
             {
                 passedUrl: `https://api.github.com/orgs/${this.gitNamespace}/repos`,
@@ -86,8 +101,10 @@ export default class NpmAutopackageTest extends AbstractPackageTest {
 
     @test()
     protected static async secondChdirToInstallDir() {
+        await this.run()
+
         assert.isEqual(
-            this.callsToChdir[0],
+            callsToChdir[0],
             this.installDir,
             'Did not change to installDir!'
         )
@@ -95,8 +112,10 @@ export default class NpmAutopackageTest extends AbstractPackageTest {
 
     @test()
     protected static async thirdGitClone() {
+        await this.run()
+
         assert.isEqual(
-            this.callsToExecSync[0],
+            callsToExec[0],
             `git clone https://github.com/${this.gitNamespace}/${this.packageName}.git`,
             'Did not call git clone!'
         )
@@ -104,8 +123,10 @@ export default class NpmAutopackageTest extends AbstractPackageTest {
 
     @test()
     protected static async fourthSpruceCreateModule() {
+        await this.run()
+
         assert.isEqual(
-            this.callsToExecSync[1],
+            callsToExec[1],
             this.createModuleCmd,
             'Did not call "spruce create.module"!'
         )
@@ -113,8 +134,10 @@ export default class NpmAutopackageTest extends AbstractPackageTest {
 
     @test()
     protected static async fifthCommitCreatePackage() {
+        await this.run()
+
         assert.isEqualDeep(
-            this.callsToExecSync.slice(2, 5),
+            callsToExec.slice(2, 5),
             ['git add .', 'git commit -m "patch: create package"', 'git push'],
             'Did not commit create package changes!'
         )
@@ -122,8 +145,10 @@ export default class NpmAutopackageTest extends AbstractPackageTest {
 
     @test()
     protected static async sixthChdirToPackageDir() {
+        await this.run()
+
         assert.isEqual(
-            this.callsToChdir[1],
+            callsToChdir[1],
             this.packageDir,
             'Did not change to packageDir!'
         )
@@ -131,7 +156,9 @@ export default class NpmAutopackageTest extends AbstractPackageTest {
 
     @test()
     protected static async seventhReadPackageJson() {
-        assert.isEqualDeep(this.callsToReadFileSync[0], {
+        await this.run()
+
+        assert.isEqualDeep(callsToReadFile[0], {
             path: this.packageJsonPath,
             options: { encoding: 'utf-8' },
         })
@@ -139,42 +166,44 @@ export default class NpmAutopackageTest extends AbstractPackageTest {
 
     @test()
     protected static async eighthUpdatePackageJson() {
-        const actual = this.callsToWriteFileSync[0]
+        await this.run()
+
+        const actual = callsToWriteFile[0]
+
+        const ordered = this.orderJsonKeys(JSON.parse(this.updatedJsonFile), [
+            'name',
+            'version',
+            'description',
+            'keywords',
+            'license',
+            'author',
+            'homepage',
+            'repository',
+            'bugs',
+            'main',
+            'bin',
+            'files',
+            'scripts',
+            'dependencies',
+            'devDependencies',
+            'jest',
+            'skill',
+        ])
 
         const expected = {
-            path: this.packageJsonPath,
-            data: this.orderJsonKeys(JSON.parse(this.updatedJsonFile), [
-                'name',
-                'version',
-                'description',
-                'keywords',
-                'license',
-                'author',
-                'homepage',
-                'repository',
-                'bugs',
-                'main',
-                'bin',
-                'files',
-                'scripts',
-                'dependencies',
-                'devDependencies',
-                'jest',
-                'skill',
-            ]),
+            file: this.packageJsonPath,
+            data: JSON.stringify(ordered, null, 2) + '\n',
             options: { encoding: 'utf-8' },
         }
 
-        const normalize = (s: string) => s.replace(/\s+/g, '').trim()
-
         assert.isEqualDeep(
             {
                 ...actual,
-                data: normalize(actual.data),
+                data: this.normalize(actual.data),
             },
             {
                 ...expected,
-                data: normalize(expected.data),
+                data: this.normalize(expected.data),
             },
             'Did not update package.json as expected!'
         )
@@ -182,8 +211,10 @@ export default class NpmAutopackageTest extends AbstractPackageTest {
 
     @test()
     protected static async ninthCommitUpdatePackage() {
+        await this.run()
+
         assert.isEqualDeep(
-            this.callsToExecSync.slice(5, 8),
+            callsToExec.slice(5, 8),
             ['git add .', 'git commit -m "patch: update package"', 'git push'],
             'Did not commit update package changes!'
         )
@@ -191,25 +222,25 @@ export default class NpmAutopackageTest extends AbstractPackageTest {
 
     @test()
     protected static async tenthAddBuildDirToGitignore() {
-        const actual = this.callsToWriteFileSync[1]
-
-        const expected = {
-            path: this.gitignorePath,
-            data: '\nbuild/\n',
-            options: { encoding: 'utf-8', flag: 'a' },
-        }
+        await this.run()
 
         assert.isEqualDeep(
-            actual,
-            expected,
+            callsToWriteFile[1],
+            {
+                file: this.gitignorePath,
+                data: this.buildDirGitignorePattern,
+                options: { encoding: 'utf-8', flag: 'a' },
+            },
             'Did not update .gitignore as expected!'
         )
     }
 
     @test()
     protected static async eleventhCommitUpdateGitignore() {
+        await this.run()
+
         assert.isEqualDeep(
-            this.callsToExecSync.slice(8, 11),
+            callsToExec.slice(8, 11),
             [
                 'git add .',
                 'git commit -m "patch: add build dir to gitignore"',
@@ -221,8 +252,10 @@ export default class NpmAutopackageTest extends AbstractPackageTest {
 
     @test()
     protected static async twelfthSpruceSetupVscode() {
+        await this.run()
+
         assert.isEqual(
-            this.callsToExecSync[11],
+            callsToExec[11],
             NpmAutopackageTest.setupVscodeCmd,
             'Did not call "spruce setup.vscode"!'
         )
@@ -230,8 +263,10 @@ export default class NpmAutopackageTest extends AbstractPackageTest {
 
     @test()
     protected static async lastlyCommitVscodeChanges() {
+        await this.run()
+
         assert.isEqualDeep(
-            this.callsToExecSync.slice(12, 15),
+            callsToExec.slice(12, 15),
             ['git add .', 'git commit -m "patch: setup vscode"', 'git push'],
             'Did not commit vscode changes!'
         )
@@ -239,8 +274,10 @@ export default class NpmAutopackageTest extends AbstractPackageTest {
 
     @test()
     protected static async doesNotCloneRepoIfDone() {
+        await this.createAndRunAutopackage()
+
         assert.isEqual(
-            this.callsToExecSync.filter(
+            callsToExec.filter(
                 (cmd) =>
                     cmd ===
                     `git clone https://github.com/${this.gitNamespace}/${this.packageName}.git`
@@ -255,8 +292,7 @@ export default class NpmAutopackageTest extends AbstractPackageTest {
         await this.createAndRunAutopackage()
 
         assert.isEqual(
-            this.callsToExecSync.filter((cmd) => cmd === this.createModuleCmd)
-                .length,
+            callsToExec.filter((cmd) => cmd === this.createModuleCmd).length,
             1,
             'Did not call spruce create.module once!'
         )
@@ -267,8 +303,7 @@ export default class NpmAutopackageTest extends AbstractPackageTest {
         await this.createAndRunAutopackage()
 
         assert.isEqual(
-            this.callsToExecSync.filter((cmd) => cmd === this.setupVscodeCmd)
-                .length,
+            callsToExec.filter((cmd) => cmd === this.setupVscodeCmd).length,
             1,
             'Did not call spruce setup.vscode once!'
         )
@@ -279,7 +314,7 @@ export default class NpmAutopackageTest extends AbstractPackageTest {
         await this.createAndRunAutopackage()
 
         assert.isEqual(
-            this.callsToExecSync.filter(
+            callsToExec.filter(
                 (cmd) => cmd === 'git commit -m "patch: create package"'
             ).length,
             1,
@@ -292,7 +327,7 @@ export default class NpmAutopackageTest extends AbstractPackageTest {
         await this.createAndRunAutopackage()
 
         assert.isEqual(
-            this.callsToExecSync.filter(
+            callsToExec.filter(
                 (cmd) => cmd === 'git commit -m "patch: update package"'
             ).length,
             1,
@@ -305,7 +340,7 @@ export default class NpmAutopackageTest extends AbstractPackageTest {
         await this.createAndRunAutopackage()
 
         assert.isEqual(
-            this.callsToExecSync.filter(
+            callsToExec.filter(
                 (cmd) =>
                     cmd === 'git commit -m "patch: add build dir to gitignore"'
             ).length,
@@ -319,7 +354,7 @@ export default class NpmAutopackageTest extends AbstractPackageTest {
         await this.createAndRunAutopackage()
 
         assert.isEqual(
-            this.callsToExecSync.filter(
+            callsToExec.filter(
                 (cmd) => cmd === 'git commit -m "patch: setup vscode"'
             ).length,
             1,
@@ -329,13 +364,19 @@ export default class NpmAutopackageTest extends AbstractPackageTest {
 
     @test()
     protected static async doesNotOverrideOriginalDependencies() {
+        await this.createAndRunAutopackage()
+
         assert.isEqualDeep(
-            JSON.parse(this.callsToWriteFileSync[0]?.data).dependencies,
+            JSON.parse(callsToWriteFile[0]?.data).dependencies,
             this.dependencies,
             'Did not update package.json as expected!'
         )
     }
 
+    private static async run() {
+        await this.instance.run()
+    }
+
     private static async createAndRunAutopackage() {
         const instance = this.NpmAutopackage()
         await instance.run()
@@ -357,6 +398,8 @@ export default class NpmAutopackageTest extends AbstractPackageTest {
         return `${this.packageDir}/.gitignore`
     }
 
+    private static readonly buildDirGitignorePattern = '\nbuild/\n'
+
     private static get createModuleCmd() {
         return `spruce create.module --name "${this.packageName}" --destination "${this.packageDir}" --description "${this.packageDescription}"`
     }
@@ -383,73 +426,39 @@ export default class NpmAutopackageTest extends AbstractPackageTest {
             ordered[key] = json[key]
         }
 
-        return JSON.stringify(ordered)
+        return ordered
     }
 
     private static fakeChdir() {
-        NpmAutopackage.chdir = (dir: string) => {
-            this.callsToChdir.push(dir)
-        }
-        this.callsToChdir = []
+        NpmAutopackage.chdir = fakeChdir
+        resetCallsToChdir()
     }
 
-    private static fakeExecSync() {
-        // @ts-ignore
-        NpmAutopackage.execSync = (cmd: string) => {
-            this.callsToExecSync.push(cmd)
-        }
-        this.callsToExecSync = []
-    }
-
-    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.callsToExistsSync = []
+    private static fakeExec() {
+        NpmAutopackage.exec = fakeExec as unknown as typeof exec
+        resetCallsToExec()
+    }
+
+    private static fakePathExists() {
+        NpmAutopackage.pathExists = fakePathExists
+        resetCallsToPathExists()
     }
 
     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.updatedJsonFile
-                }
-                return this.originalJsonFile
-            } 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 = []
+        NpmAutopackage.fetch = fakeFetch as unknown as typeof fetch
+        resetCallsToFetch()
+    }
+
+    private static fakeReadFile() {
+        NpmAutopackage.readFile = fakeReadFile as unknown as typeof readFile
+        resetCallsToReadFile()
+
+        setFakeReadFileResult(this.originalJsonFile)
+    }
+
+    private static fakeWriteFile() {
+        NpmAutopackage.writeFile = fakeWriteFile as unknown as typeof writeFile
+        resetCallsToWriteFile()
     }
 
     private static get originalJsonFile() {
@@ -486,18 +495,6 @@ export default class NpmAutopackageTest extends AbstractPackageTest {
         })
     }
 
-    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()

package/src/index.ts

@@ -29,14 +29,3 @@ 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 fakeReadFile } from './testDoubles/fs/fakeReadFile'
-export * from './testDoubles/fs/fakeReadFile'
-
-export { default as fakeWriteFile } from './testDoubles/fs/fakeWriteFile'
-export * from './testDoubles/fs/fakeWriteFile'

package/src/modules/GitAutocloner.ts

@@ -1,11 +1,13 @@
-import { execSync } from 'child_process'
-import { existsSync } from 'fs'
+import { exec as execSync } from 'child_process'
 import { chdir } from 'process'
+import { promisify } from 'util'
+import { pathExists } from 'fs-extra'
 
 export default class GitAutocloner implements Autocloner {
     public static Class?: AutoclonerConstructor
-    public static execSync = execSync
-    public static existsSync = existsSync
+    public static chdir = chdir
+    public static exec = promisify(execSync)
+    public static pathExists = pathExists
 
     private urls!: string[]
     private dirPath!: string
@@ -25,19 +27,22 @@ export default class GitAutocloner implements Autocloner {
         this.urls = urls
         this.dirPath = dirPath
 
-        this.throwIfDirPathDoesNotExist()
+        await this.throwIfDirPathDoesNotExist()
+
         this.changeDirectoryToDirPath()
-        this.cloneReposFromUrls()
+        await this.cloneReposFromUrls()
     }
 
-    private throwIfDirPathDoesNotExist() {
-        if (!this.dirPathExists) {
+    private async throwIfDirPathDoesNotExist() {
+        const dirPathExists = await this.checkIfDirPathExists()
+
+        if (!dirPathExists) {
             this.throwDirPathDoesNotExist()
         }
     }
 
-    private get dirPathExists() {
-        return this.existsSync(this.dirPath)
+    private async checkIfDirPathExists() {
+        return this.pathExists(this.dirPath)
     }
 
     private throwDirPathDoesNotExist() {
@@ -45,26 +50,28 @@ export default class GitAutocloner implements Autocloner {
     }
 
     private changeDirectoryToDirPath() {
-        chdir(this.dirPath)
+        this.chdir(this.dirPath)
     }
 
-    private cloneReposFromUrls() {
-        this.urls.forEach((url) => {
+    private async cloneReposFromUrls() {
+        for (const url of this.urls) {
             this.currentUrl = url
-            this.cloneCurrentUrl()
-        })
+            await this.cloneCurrentUrl()
+        }
     }
 
-    private cloneCurrentUrl() {
-        if (!this.currentRepoExists) {
-            this.tryToCloneRepo()
+    private async cloneCurrentUrl() {
+        const currentRepoExists = await this.checkIfCurrentRepoExists()
+
+        if (!currentRepoExists) {
+            await this.tryToCloneRepo()
         } else {
             this.log.info(`Repo exists, skipping: ${this.currentRepoName}!`)
         }
     }
 
-    private get currentRepoExists() {
-        return this.existsSync(this.currentRepoName)
+    private async checkIfCurrentRepoExists() {
+        return this.pathExists(this.currentRepoName)
     }
 
     private get currentRepoName() {
@@ -73,9 +80,9 @@ export default class GitAutocloner implements Autocloner {
 
     private readonly regexForRepoName = /\/([a-zA-Z0-9_.-]+)\.git/
 
-    private tryToCloneRepo() {
+    private async tryToCloneRepo() {
         try {
-            this.execSync(`git clone ${this.currentUrl}`)
+            await this.exec(`git clone ${this.currentUrl}`)
         } catch (err: any) {
             this.currentError = err
             this.throwGitCloneFailed()
@@ -90,12 +97,16 @@ export default class GitAutocloner implements Autocloner {
         return `Git clone failed for repo: ${this.currentUrl}!\n\n${this.currentError}\n\n`
     }
 
-    private get existsSync() {
-        return GitAutocloner.existsSync
+    private get chdir() {
+        return GitAutocloner.chdir
+    }
+
+    private get exec() {
+        return GitAutocloner.exec
     }
 
-    private get execSync() {
-        return GitAutocloner.execSync
+    private get pathExists() {
+        return GitAutocloner.pathExists
     }
 }