@neurodevs/meta-node 0.7.0 → 0.9.0

package/src/__tests__/AbstractAutomoduleTest.ts

@@ -0,0 +1,83 @@
+import { writeFile } from 'fs/promises'
+import { assert, generateId } from '@sprucelabs/test-utils'
+import {
+    fakePathExists,
+    fakeWriteFile,
+    resetCallsToPathExists,
+    resetCallsToWriteFile,
+    setPathShouldExist,
+} from '@neurodevs/fake-node-core'
+import AbstractAutomodule from '../modules/AbstractAutomodule'
+import { Automodule } from '../types'
+import AbstractPackageTest from './AbstractPackageTest'
+
+export default class AbstractAutomoduleTest extends AbstractPackageTest {
+    protected static instance: Automodule
+
+    protected static async beforeEach() {
+        await super.beforeEach()
+
+        this.setFakePathExists()
+        this.setFakeWriteFile()
+    }
+
+    protected static async runAbstractTests() {
+        await this.runThrowsIfTestSaveDirMissing()
+        await this.runThrowsIfModuleSaveDirMissing()
+        await this.runThrowsIfFakeSaveDirMissing()
+    }
+
+    protected static async runThrowsIfTestSaveDirMissing() {
+        setPathShouldExist(this.testSaveDir, false)
+
+        await assert.doesThrowAsync(
+            async () => await this.run(),
+            `testSaveDir does not exist: ${this.testSaveDir}!`
+        )
+    }
+
+    protected static async runThrowsIfModuleSaveDirMissing() {
+        setPathShouldExist(this.testSaveDir, true)
+        setPathShouldExist(this.moduleSaveDir, false)
+
+        await assert.doesThrowAsync(
+            async () => await this.run(),
+            `moduleSaveDir does not exist: ${this.moduleSaveDir}!`
+        )
+    }
+
+    protected static async runThrowsIfFakeSaveDirMissing() {
+        setPathShouldExist(this.moduleSaveDir, true)
+        setPathShouldExist(this.fakeSaveDir, false)
+
+        await assert.doesThrowAsync(
+            async () => await this.run(),
+            `fakeSaveDir does not exist: ${this.fakeSaveDir}!`
+        )
+    }
+
+    protected static async run() {
+        return this.instance.run()
+    }
+
+    protected static readonly testSaveDir = generateId()
+    protected static readonly moduleSaveDir = generateId()
+    protected static readonly fakeSaveDir = generateId()
+    protected static readonly indexFilePath = './src/index.ts'
+
+    protected static setFakePathExists() {
+        AbstractAutomodule.pathExists = fakePathExists
+
+        setPathShouldExist(this.testSaveDir, true)
+        setPathShouldExist(this.moduleSaveDir, true)
+        setPathShouldExist(this.fakeSaveDir, true)
+        setPathShouldExist(this.indexFilePath, true)
+
+        resetCallsToPathExists()
+    }
+
+    protected static setFakeWriteFile() {
+        AbstractAutomodule.writeFile = fakeWriteFile as typeof writeFile
+        resetCallsToWriteFile()
+    }
+}

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

@@ -1,81 +1,40 @@
 import { exec as execSync } from 'child_process'
-import { readFile, writeFile } from 'fs/promises'
+import { readFile } from 'fs/promises'
 import { promisify } from 'util'
 import { test, assert, generateId } from '@sprucelabs/test-utils'
 import {
     callsToExec,
     callsToWriteFile,
     fakeExec,
-    fakePathExists,
     fakeReadFile,
     fakeReadFileResult,
-    fakeWriteFile,
+    resetCallsToExec,
     resetCallsToReadFile,
-    resetCallsToWriteFile,
     setFakeReadFileResult,
-    setPathShouldExist,
 } from '@neurodevs/fake-node-core'
-import ImplAutomodule, { Automodule } from '../../modules/ImplAutomodule'
-import AbstractPackageTest from '../AbstractPackageTest'
+import ImplAutomodule from '../../modules/ImplAutomodule'
+import AbstractAutomoduleTest from '../AbstractAutomoduleTest'
 
 const exec = promisify(execSync)
 
-export default class ImplAutomoduleTest extends AbstractPackageTest {
-    private static instance: Automodule
-
+export default class ImplAutomoduleTest extends AbstractAutomoduleTest {
     protected static async beforeEach() {
         await super.beforeEach()
 
         this.setFakeExec()
-        this.setFakePathExists()
         this.setFakeReadFile()
-        this.setFakeWriteFile()
 
         this.instance = this.ImplAutomodule()
     }
 
     @test()
-    protected static async createsInstance() {
-        assert.isTruthy(this.instance, 'Failed to create instance!')
-    }
-
-    @test()
-    protected static async runThrowsIfTestSaveDirMissing() {
-        setPathShouldExist(this.testSaveDir, false)
-
-        const err = await assert.doesThrowAsync(async () => await this.run())
-
-        assert.isEqual(
-            err.message,
-            `testSaveDir does not exist: ${this.testSaveDir}!`,
-            'Did not receive the expected error!'
-        )
+    protected static async passesAbstractTests() {
+        await this.runAbstractTests()
     }
 
     @test()
-    protected static async runThrowsIfModuleSaveDirMissing() {
-        setPathShouldExist(this.moduleSaveDir, false)
-
-        const err = await assert.doesThrowAsync(async () => await this.run())
-
-        assert.isEqual(
-            err.message,
-            `moduleSaveDir does not exist: ${this.moduleSaveDir}!`,
-            'Did not receive the expected error!'
-        )
-    }
-
-    @test()
-    protected static async runThrowsIfFakeSaveDirMissing() {
-        setPathShouldExist(this.fakeSaveDir, false)
-
-        const err = await assert.doesThrowAsync(async () => await this.run())
-
-        assert.isEqual(
-            err.message,
-            `fakeSaveDir does not exist: ${this.fakeSaveDir}!`,
-            'Did not receive the expected error!'
-        )
+    protected static async createsInstance() {
+        assert.isTruthy(this.instance, 'Failed to create instance!')
     }
 
     @test()
@@ -83,11 +42,13 @@ export default class ImplAutomoduleTest extends AbstractPackageTest {
         await this.run()
 
         assert.isEqualDeep(
-            callsToWriteFile[0],
+            {
+                file: callsToWriteFile[0].file,
+                data: this.normalize(callsToWriteFile[0].data),
+            },
             {
                 file: `${this.testSaveDir}/${this.implName}.test.ts`,
-                data: this.testFilePattern,
-                options: undefined,
+                data: this.normalize(this.testFilePattern),
             },
             'Did not write expected test file!'
         )
@@ -159,21 +120,9 @@ export default class ImplAutomoduleTest extends AbstractPackageTest {
         )
     }
 
-    private static async run() {
-        return await this.instance.run()
-    }
-
     private static setFakeExec() {
         ImplAutomodule.exec = fakeExec as unknown as typeof exec
-    }
-
-    private static setFakePathExists() {
-        ImplAutomodule.pathExists = fakePathExists
-
-        setPathShouldExist(this.testSaveDir, true)
-        setPathShouldExist(this.moduleSaveDir, true)
-        setPathShouldExist(this.fakeSaveDir, true)
-        setPathShouldExist(this.indexFilePath, true)
+        resetCallsToExec()
     }
 
     private static setFakeReadFile() {
@@ -181,17 +130,9 @@ export default class ImplAutomoduleTest extends AbstractPackageTest {
         resetCallsToReadFile()
     }
 
-    private static setFakeWriteFile() {
-        ImplAutomodule.writeFile = fakeWriteFile as typeof writeFile
-        resetCallsToWriteFile()
-    }
     private static readonly interfaceName = `B-${generateId()}`
     private static readonly implName = generateId()
 
-    private static readonly testSaveDir = generateId()
-    private static readonly moduleSaveDir = generateId()
-    private static readonly fakeSaveDir = generateId()
-
     private static get testFilePattern() {
         return `
             import AbstractSpruceTest, { test, assert } from '@sprucelabs/test-utils'
@@ -199,10 +140,10 @@ export default class ImplAutomoduleTest extends AbstractPackageTest {
 
             export default class ${this.implName}Test extends AbstractSpruceTest {
                 private static instance: ${this.interfaceName}
-                
+
                 protected static async beforeEach() {
                     await super.beforeEach()
-                    
+
                     this.instance = this.${this.implName}()
                 }
                 
@@ -254,8 +195,6 @@ export default class ImplAutomoduleTest extends AbstractPackageTest {
         `
     }
 
-    private static readonly indexFilePath = './src/index.ts'
-
     private static get indexFilePattern() {
         return `
             ${fakeReadFileResult}

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

@@ -0,0 +1,174 @@
+import { test, assert, generateId } from '@sprucelabs/test-utils'
+import { callsToWriteFile } from '@neurodevs/fake-node-core'
+import UiAutomodule from '../../modules/UiAutomodule'
+import AbstractAutomoduleTest from '../AbstractAutomoduleTest'
+
+export default class UiAutomoduleTest extends AbstractAutomoduleTest {
+    protected static async beforeEach() {
+        await super.beforeEach()
+
+        this.instance = this.UiAutomodule()
+    }
+
+    @test()
+    protected static async passesAbstractTests() {
+        await this.runAbstractTests()
+    }
+
+    @test()
+    protected static async createsInstance() {
+        assert.isTruthy(this.instance, 'Failed to create instance!')
+    }
+
+    @test()
+    protected static async createsTestFileAsExpected() {
+        await this.run()
+
+        assert.isEqualDeep(
+            callsToWriteFile[0],
+            {
+                file: `${this.testSaveDir}/${this.componentName}.test.tsx`,
+                data: this.testFilePattern,
+                options: undefined,
+            },
+            'Did not write expected test file!'
+        )
+    }
+
+    @test()
+    protected static async createsModuleFileAsExpected() {
+        await this.run()
+
+        assert.isEqualDeep(
+            callsToWriteFile[1],
+            {
+                file: `${this.moduleSaveDir}/${this.componentName}.tsx`,
+                data: this.moduleFilePattern,
+                options: undefined,
+            },
+            'Did not write expected module file!'
+        )
+    }
+
+    @test()
+    protected static async createsFakeFileAsExpected() {
+        await this.run()
+
+        assert.isEqualDeep(
+            callsToWriteFile[2],
+            {
+                file: `${this.fakeSaveDir}/Fake${this.componentName}.tsx`,
+                data: this.fakeFilePattern,
+                options: undefined,
+            },
+            'Did not write expected module file!'
+        )
+    }
+
+    private static readonly componentName = generateId()
+
+    private static readonly componentNameKebabCase = this.toKebabCase(
+        this.componentName
+    )
+
+    private static get testFilePattern() {
+        return `
+            import { test, assert } from '@sprucelabs/test-utils'
+            import { render, RenderResult } from '@testing-library/react'
+            import ${this.componentName} from '../../ui/${this.componentName}'
+            import AbstractPackageTest from '../AbstractPackageTest'
+
+            export default class ${this.componentName}Test extends AbstractPackageTest {
+                private static result: RenderResult
+
+                protected static async beforeEach() {
+                    await super.beforeEach()
+
+                    this.result = this.render()
+                }
+
+                @test()
+                protected static async rendersComponent() {
+                    assert.isTruthy(this.result, 'Failed to render component!')
+                }
+
+                @test()
+                protected static async rendersTopLevelDivWithExpectedClass() {
+                    assert.isEqual(
+                        this.div.className,
+                        this.className,
+                        'Incorrect class for top-level div!'
+                    )
+                }
+
+                private static get div() {
+                    return this.getByTestId(this.className)
+                }
+
+                private static get getByTestId() {
+                    return this.result.getByTestId
+                }
+
+                private static readonly className = '${this.componentNameKebabCase}'
+
+                protected static render() {
+                    return render(<${this.componentName} />)
+                }
+            }
+        `
+    }
+
+    private static get moduleFilePattern() {
+        return `
+            import React from 'react'
+
+            const ${this.componentName}: React.FC = () => {
+                return (
+                    <div
+                        className="${this.componentNameKebabCase}"
+                        data-testid="${this.componentNameKebabCase}"
+                    />
+                )
+            }
+
+            export default ${this.componentName}
+        `
+    }
+
+    private static get fakeFilePattern() {
+        return `
+            import React from 'react'
+            import { ${this.componentName}Props } from '../ui/${this.componentName}'
+
+            export let last${this.componentName}Props: ${this.componentName}Props | undefined
+
+            const Fake${this.componentName}: React.FC<${this.componentName}Props> = (
+                props: ${this.componentName}Props
+            ) => {
+                last${this.componentName}Props = props
+
+                return (
+                    <div data-testid="${this.componentNameKebabCase}" />
+                )
+            }
+
+            export default Fake${this.componentName}
+        `
+    }
+
+    private static toKebabCase(str: string): string {
+        return str
+            .replace(/([a-z])([A-Z])/g, '$1-$2')
+            .replace(/[\s_]+/g, '-')
+            .toLowerCase()
+    }
+
+    private static UiAutomodule() {
+        return UiAutomodule.Create({
+            testSaveDir: this.testSaveDir,
+            moduleSaveDir: this.moduleSaveDir,
+            fakeSaveDir: this.fakeSaveDir,
+            componentName: this.componentName,
+        })
+    }
+}

package/src/index.ts

@@ -16,9 +16,15 @@ export * from './testDoubles/Autodocumenter/FakeAutodocumenter'
 
 // Automodule
 
+export { default as AbstractAutomodule } from './modules/AbstractAutomodule'
+export * from './modules/AbstractAutomodule'
+
 export { default as ImplAutomodule } from './modules/ImplAutomodule'
 export * from './modules/ImplAutomodule'
 
+export { default as UiAutomodule } from './modules/UiAutomodule'
+export * from './modules/UiAutomodule'
+
 export { default as FakeAutomodule } from './testDoubles/Automodule/FakeAutomodule'
 export * from './testDoubles/Automodule/FakeAutomodule'
 

package/src/modules/AbstractAutomodule.ts

@@ -0,0 +1,133 @@
+import { writeFile } from 'fs/promises'
+import { pathExists } from 'fs-extra'
+import { Automodule, BaseAutomoduleOptions } from '../types'
+
+export default abstract class AbstractAutomodule implements Automodule {
+    public static pathExists = pathExists
+    public static writeFile = writeFile
+
+    protected testSaveDir: string
+    protected moduleSaveDir: string
+    protected fakeSaveDir: string
+
+    protected testFileName!: string
+    protected testFileContent!: string
+    protected moduleFileName!: string
+    protected moduleFileContent!: string
+    protected fakeFileName!: string
+    protected fakeFileContent!: string
+
+    protected constructor(options: BaseAutomoduleOptions) {
+        const { testSaveDir, moduleSaveDir, fakeSaveDir } = options
+
+        this.testSaveDir = testSaveDir
+        this.moduleSaveDir = moduleSaveDir
+        this.fakeSaveDir = fakeSaveDir
+    }
+
+    public abstract run(): Promise<void>
+
+    protected async runAbstract(options: AbstractAutomoduleRunOptions) {
+        const {
+            testFileName,
+            testFileContent,
+            moduleFileName,
+            moduleFileContent,
+            fakeFileName,
+            fakeFileContent,
+        } = options
+
+        this.testFileName = testFileName
+        this.testFileContent = testFileContent
+        this.moduleFileName = moduleFileName
+        this.moduleFileContent = moduleFileContent
+        this.fakeFileName = fakeFileName
+        this.fakeFileContent = fakeFileContent
+
+        await this.throwIfDirectoriesDoNotExist()
+
+        await this.createTestFile()
+        await this.createModuleFile()
+        await this.createFakeFile()
+    }
+
+    private async throwIfDirectoriesDoNotExist() {
+        await this.throwIfTestDirDoesNotExist()
+        await this.throwIfModuleDirDoesNotExist()
+        await this.throwIfFakeDirDoesNotExist()
+    }
+
+    private async throwIfTestDirDoesNotExist() {
+        const testDirExists = await this.pathExists(this.testSaveDir)
+
+        if (!testDirExists) {
+            this.throw(`testSaveDir does not exist: ${this.testSaveDir}!`)
+        }
+    }
+
+    private async throwIfModuleDirDoesNotExist() {
+        const moduleDirExists = await this.pathExists(this.moduleSaveDir)
+
+        if (!moduleDirExists) {
+            this.throw(`moduleSaveDir does not exist: ${this.moduleSaveDir}!`)
+        }
+    }
+
+    private async throwIfFakeDirDoesNotExist() {
+        const fakeDirExists = await this.pathExists(this.fakeSaveDir)
+
+        if (!fakeDirExists) {
+            this.throw(`fakeSaveDir does not exist: ${this.fakeSaveDir}!`)
+        }
+    }
+
+    private throw(err: string) {
+        throw new Error(err)
+    }
+
+    private async createTestFile() {
+        await this.writeFile(this.testFilePath, this.testFileContent)
+    }
+
+    private get testFilePath() {
+        return `${this.testSaveDir}/${this.testFileName}`
+    }
+
+    private async createModuleFile() {
+        await this.writeFile(this.moduleFilePath, this.moduleFileContent)
+    }
+
+    private get moduleFilePath() {
+        return `${this.moduleSaveDir}/${this.moduleFileName}`
+    }
+
+    private async createFakeFile() {
+        await this.writeFile(this.fakeFilePath, this.fakeFileContent)
+    }
+
+    private get fakeFilePath() {
+        return `${this.fakeSaveDir}/${this.fakeFileName}`
+    }
+
+    private get pathExists() {
+        return AbstractAutomodule.pathExists
+    }
+
+    protected get writeFile() {
+        return AbstractAutomodule.writeFile
+    }
+}
+
+export interface AbstractAutomoduleOptions extends BaseAutomoduleOptions {
+    testFileName: string
+    testFileContent: string
+}
+
+export interface AbstractAutomoduleRunOptions {
+    testFileName: string
+    testFileContent: string
+    moduleFileName: string
+    moduleFileContent: string
+    fakeFileName: string
+    fakeFileContent: string
+}