@sprucelabs/spruce-cli 24.0.0 → 24.1.0

package/src/__tests__/testDirsAndFiles/static_test_migration_2/src/__tests__/AStaticTest.test.ts

@@ -0,0 +1,33 @@
+import { fake } from '@sprucelabs/spruce-test-fixtures'
+import AbstractSpruceTest, {
+    test,
+    assert,
+    errorAssert,
+} from '@sprucelabs/test-utils'
+
+@fake.login()
+export default class StaticTestFinderTest extends AbstractSpruceTest {
+    @test()
+    protected static async throwsWithMissing() {
+        const finder = StaticTestFinder.Finder()
+        const err = await assert.doesThrowAsync(() => finder.find())
+        errorAssert.assertError(err, 'MISSING_PARAMETERS', {
+            parameters: ['lookupDir'],
+        })
+    }
+
+    @test()
+    protected static async yourNextTest() {
+        assert.isTrue(false)
+    }
+}
+
+class StaticTestFinder {
+    public static Finder() {
+        return new this()
+    }
+
+    public async find() {
+        // assertOptions({}, ['lookupDir'])
+    }
+}

package/src/__tests__/testDirsAndFiles/static_test_migration_2/src/__tests__/AnotherStaticTest1.test.ts

@@ -0,0 +1,33 @@
+import { fake } from '@sprucelabs/spruce-test-fixtures'
+import AbstractSpruceTest, {
+    test,
+    assert,
+    errorAssert,
+} from '@sprucelabs/test-utils'
+
+@fake.login()
+export default class StaticTestFinderTest extends AbstractSpruceTest {
+    @test()
+    protected static async throwsWithMissing() {
+        const finder = StaticTestFinder.Finder()
+        const err = await assert.doesThrowAsync(() => finder.find())
+        errorAssert.assertError(err, 'MISSING_PARAMETERS', {
+            parameters: ['lookupDir'],
+        })
+    }
+
+    @test()
+    protected static async yourNextTest() {
+        assert.isTrue(false)
+    }
+}
+
+class StaticTestFinder {
+    public static Finder() {
+        return new this()
+    }
+
+    public async find() {
+        // assertOptions({}, ['lookupDir'])
+    }
+}

package/src/__tests__/testDirsAndFiles/static_test_migration_3/src/__tests__/AStaticTest2.test.ts

@@ -0,0 +1,17 @@
+import { fake } from "@sprucelabs/spruce-test-fixtures";
+import {
+  test,
+  assert,
+} from "@sprucelabs/test-utils";
+import AbstractWhateverTest from "./AbstractWhateverTest";
+
+@fake.login()
+export default class StaticTestFinderTest extends AbstractWhateverTest {
+  @test()
+  protected static async throwsWithMissing() {}
+
+  @test()
+  protected static async yourNextTest() {
+    assert.isTrue(false);
+  }
+}

package/src/__tests__/testDirsAndFiles/static_test_migration_3/src/__tests__/AbstractWhateverTest.ts

@@ -0,0 +1,3 @@
+import AbstractSpruceTest from "@sprucelabs/test-utils";
+
+export default abstract class AbstractWhateverTest extends AbstractSpruceTest {}

package/src/features/test/actions/CreateAction.ts

@@ -1,4 +1,5 @@
 import pathUtil from 'path'
+import globby from '@sprucelabs/globby'
 import { namesUtil } from '@sprucelabs/spruce-skill-utils'
 import { diskUtil } from '@sprucelabs/spruce-skill-utils'
 import { SpruceSchemas } from '#spruce/schemas/schemas.types'
@@ -51,6 +52,9 @@ export default class CreateAction extends AbstractAction<OptionsSchema> {
             'devDependencies.@sprucelabs/spruce-test-fixtures'
         )
 
+        let doesStaticTestExist =
+            await this.doesStaticTestAlreadyExist(resolvedDestination)
+
         const results = await writer.writeTest(resolvedDestination, {
             ...normalizedOptions,
             type,
@@ -58,6 +62,7 @@ export default class CreateAction extends AbstractAction<OptionsSchema> {
             parentTestClass,
             isTestFixturesInstalled,
             namePascal: namePascal ?? namesUtil.toPascal(nameCamel),
+            testType: doesStaticTestExist ? 'static' : 'instance',
         })
 
         return {
@@ -66,6 +71,18 @@ export default class CreateAction extends AbstractAction<OptionsSchema> {
         }
     }
 
+    private async doesStaticTestAlreadyExist(resolvedDestination: string) {
+        const matches = await globby(resolvedDestination + `/**/*.test.ts`)
+        let doesStaticTestExist = false
+
+        const match = matches[0]
+        if (match) {
+            const contents = diskUtil.readFile(matches[0])
+            doesStaticTestExist = contents.includes('static')
+        }
+        return doesStaticTestExist
+    }
+
     private async promptForSubDir(resolvedDestination: string) {
         const match = await this.ui.prompt({
             type: 'directory',

package/src/features/test/actions/MigrateAction.ts

@@ -0,0 +1,41 @@
+import { buildSchema } from '@sprucelabs/schema'
+import { diskUtil } from '@sprucelabs/spruce-skill-utils'
+import StaticTestFinderImpl from '../../../tests/staticToInstanceMigration/StaticTestFinder'
+import StaticToInstanceMigratorImpl from '../../../tests/staticToInstanceMigration/StaticToInstanceMigrator'
+import StaticToInstanceTestFileMigratorImpl from '../../../tests/staticToInstanceMigration/StaticToInstanceTestFileMigrator'
+import AbstractAction from '../../AbstractAction'
+import { FeatureActionResponse } from '../../features.types'
+
+export default class MigrationAction extends AbstractAction<OptionsSchema> {
+    public optionsSchema = optionsSchema
+    public commandAliases = ['migrate.tests']
+    public invocationMessage = 'Migrating tests from static to instance... 🌲'
+
+    public async execute(): Promise<FeatureActionResponse> {
+        const testFinder = StaticTestFinderImpl.Finder()
+        const testFileMigrator = StaticToInstanceTestFileMigratorImpl.Migrator()
+        const migrator = StaticToInstanceMigratorImpl.Migrator({
+            testFinder,
+            testFileMigrator,
+        })
+
+        const path = diskUtil.resolvePath(this.cwd, 'src', '__tests__')
+        const { totalTestsSkipped, totalTestsUpdated } =
+            await migrator.run(path)
+
+        return {
+            headline: 'Migrated tests from static to instance based.',
+            summaryLines: [
+                `${totalTestsUpdated} test${totalTestsUpdated === 1 ? '' : 's'} updated`,
+                `${totalTestsSkipped} test${totalTestsSkipped === 1 ? '' : 's'} skipped`,
+            ],
+        }
+    }
+}
+
+const optionsSchema = buildSchema({
+    id: 'migrateTests',
+    fields: {},
+})
+
+type OptionsSchema = typeof optionsSchema

package/src/tests/staticToInstanceMigration/StaticTestFinder.ts

@@ -0,0 +1,25 @@
+import globby from '@sprucelabs/globby'
+import { assertOptions } from '@sprucelabs/schema'
+
+export default class StaticTestFinderImpl implements StaticTestFinder {
+    public static Class?: new () => StaticTestFinder
+
+    public static Finder(): StaticTestFinder {
+        return new (this.Class ?? this)()
+    }
+
+    public async find(lookupDir: string) {
+        assertOptions({ lookupDir }, ['lookupDir'])
+
+        const matches = await globby([
+            `${lookupDir}/**/Abstract*Test.ts`,
+            `${lookupDir}/**/*.test.ts`,
+        ])
+
+        return matches
+    }
+}
+
+export interface StaticTestFinder {
+    find(lookupDir: string): Promise<string[]>
+}

package/src/tests/staticToInstanceMigration/StaticToInstanceMigrator.ts

@@ -0,0 +1,73 @@
+import { assertOptions } from '@sprucelabs/schema'
+import { diskUtil } from '@sprucelabs/spruce-skill-utils'
+import StaticTestFinder from './StaticTestFinder'
+import { StaticToInstanceTestFileMigrator } from './StaticToInstanceTestFileMigrator'
+
+export default class StaticToInstanceMigratorImpl
+    implements StaticToInstanceMigrator
+{
+    public static diskUtil = diskUtil
+    public static Class?: new (
+        options: StaticToInstanceMigratorOptions
+    ) => StaticToInstanceMigrator
+
+    private testFinder: StaticTestFinder
+    private testFileMigrator: StaticToInstanceTestFileMigrator
+
+    protected constructor(options: StaticToInstanceMigratorOptions) {
+        const { testFinder, testFileMigrator } = options
+        this.testFinder = testFinder
+        this.testFileMigrator = testFileMigrator
+    }
+
+    public static Migrator(options: StaticToInstanceMigratorOptions) {
+        assertOptions(options, ['testFinder', 'testFileMigrator'])
+        return new (this.Class ?? this)(options)
+    }
+
+    public async run(lookupDir: string) {
+        assertOptions({ lookupDir }, ['lookupDir'])
+        const matches = await this.testFinder.find(lookupDir)
+
+        let totalTestsUpdated = 0
+        let totalTestsSkipped = 0
+
+        for (const match of matches) {
+            const contents = this.readFile(match)
+            const updated = this.testFileMigrator.migrate(contents)
+            if (contents === updated) {
+                totalTestsSkipped++
+            } else {
+                totalTestsUpdated++
+                this.writeFile(match, updated)
+            }
+        }
+
+        return {
+            totalTestsUpdated,
+            totalTestsSkipped,
+        }
+    }
+
+    private readFile(match: string) {
+        return StaticToInstanceMigratorImpl.diskUtil.readFile(match)
+    }
+
+    private writeFile(match: string, updated: string) {
+        StaticToInstanceMigratorImpl.diskUtil.writeFile(match, updated)
+    }
+}
+
+export interface StaticToInstanceMigratorOptions {
+    testFinder: StaticTestFinder
+    testFileMigrator: StaticToInstanceTestFileMigrator
+}
+
+export interface StaticToInstanceMigratorResults {
+    totalTestsUpdated: number
+    totalTestsSkipped: number
+}
+
+export interface StaticToInstanceMigrator {
+    run(lookupDir: string): Promise<StaticToInstanceMigratorResults>
+}

package/src/tests/staticToInstanceMigration/StaticToInstanceTestFileMigrator.ts

@@ -0,0 +1,197 @@
+import { assertOptions } from '@sprucelabs/schema'
+
+export default class StaticToInstanceTestFileMigratorImpl
+    implements StaticToInstanceTestFileMigrator
+{
+    public static Class?: new () => StaticToInstanceTestFileMigrator
+
+    public static Migrator() {
+        return new (this.Class ?? this)()
+    }
+
+    public migrate(contents: string) {
+        assertOptions({ contents }, ['contents'])
+
+        // 1a. Remove `static ` only when it appears immediately before a method
+        //    that has the `@test()` decorator
+        // 1b. If the contents include `export default abstract class`,
+        //     remove `static` from all methods
+        const includesAbstractExport = contents.includes(
+            'export default abstract class'
+        )
+        let cleanedUp = includesAbstractExport
+            ? contents.replaceAll(' static ', ' ')
+            : contents.replace(
+                  // Matches @test() or @seed(...) followed (on next line) by optional visibility and `static`.
+                  /(@(?:test\(\)|seed\([^)]*\))\s*\n\s*(?:public|protected)\s+)static\s+/g,
+                  '$1'
+              )
+
+        // 2. Add `@suite()` above `export default class` if it's not already present
+        if (!cleanedUp.includes('@suite')) {
+            cleanedUp = cleanedUp.replace(
+                /export default class/,
+                '@suite()\nexport default class'
+            )
+        }
+
+        // 3. Ensure `suite` is imported from `@sprucelabs/test-utils`
+        if (!this.hasSuiteImport(cleanedUp)) {
+            if (cleanedUp.includes('{ test')) {
+                cleanedUp = cleanedUp.replace('{ test', '{ test, suite')
+            } else if (cleanedUp.includes('test }')) {
+                cleanedUp = cleanedUp.replace('test }', 'test, suite }')
+            } else {
+                cleanedUp = cleanedUp.replace('test,', 'test,\n    suite,')
+            }
+        }
+
+        const thisCallNames = this.findThisCalls(cleanedUp)
+        for (const name of thisCallNames) {
+            cleanedUp = this.removeStaticFromDeclaration(cleanedUp, name)
+        }
+
+        // 4. lifecicle methods
+        const methods = ['beforeEach', 'afterEach']
+        for (const method of methods) {
+            cleanedUp = cleanedUp.replace(
+                `protected static async ${method}()`,
+                `protected async ${method}()`
+            )
+        }
+
+        cleanedUp = this.fixNonNullAssertions(cleanedUp)
+
+        return cleanedUp
+    }
+
+    private hasSuiteImport(text: string): boolean {
+        const pattern = new RegExp(
+            `import\\s+(?:[\\s\\S]*?\\bsuite\\b[\\s\\S]*?)\\s+from\\s+['"]@sprucelabs/test-utils['"]`
+        )
+        return pattern.test(text)
+    }
+
+    private findThisCalls(contents: string): string[] {
+        // Matches `this.myProp` if followed by space, punctuation, parentheses, or end of string
+        const thisPropertyRegex = /this\.(\w+)(?=[\s.(),;]|$)/g
+        const names: string[] = []
+        let match: RegExpExecArray | null
+
+        while ((match = thisPropertyRegex.exec(contents)) !== null) {
+            const propName = match[1]
+            if (!names.includes(propName)) {
+                names.push(propName)
+            }
+        }
+
+        return names
+    }
+
+    private removeStaticFromDeclaration(
+        contents: string,
+        name: string
+    ): string {
+        /**
+         * 1) Remove `static` for methods/getters/setters, e.g.:
+         *    private static async doSomething() => private async doSomething()
+         *    private static get value() => private get value()
+         *    private static set value(v) => private set value(v)
+         */
+        const methodPattern = new RegExp(
+            `((?:public|protected|private)?\\s+)?` + // group 1
+                `static\\s+` + // literal "static "
+                `(?:(async)\\s+)?` + // group 2: "async"?
+                `(?:(get|set)\\s+)?` + // group 3: "get" or "set"?
+                `(${name})\\s*\\(`, // group 4: the identifier + '('
+            'g'
+        )
+        let updated = contents.replace(
+            methodPattern,
+            (match, g1, g2, g3, g4) => {
+                const asyncPart = g2 ? g2 + ' ' : ''
+                const accessorPart = g3 ? g3 + ' ' : ''
+                // Rebuild the declaration without "static"
+                return `${g1 ?? ''}${asyncPart}${accessorPart}${g4}(`
+            }
+        )
+
+        /**
+         * 2) Remove `static` from property declarations and add a non-null assertion.
+         *    e.g.
+         *    private static myProp: Type => private myProp!: Type
+         */
+        const propertyPattern = new RegExp(
+            `((?:public|protected|private)?\\s+)?` + // group 1: optional visibility
+                `static\\s+` + // literal "static "
+                `(${name})` + // group 2: the property name
+                `(?=[\\s=:\\[;]|$)`, // lookahead: space, '=', ':', '[', ';', or end-of-string
+            'g'
+        )
+        updated = updated.replace(propertyPattern, (match, g1, g2) => {
+            // g1 = "private " / "public " / "protected " or empty
+            // g2 = property name
+            return `${g1 ?? ''}${g2}!`
+        })
+
+        return updated
+    }
+
+    private fixNonNullAssertions(contents: string): string {
+        const lines = contents.split('\n')
+
+        const propertyRegex =
+            /^(\s*)(public|protected|private)(\s+readonly)?\s+(\w+)\s*(!)?\s*:\s*([^=;]+)(=.*)?;?$/
+
+        const updatedLines = lines.map((originalLine) => {
+            // Skip lines containing "static"
+            if (originalLine.includes('static')) {
+                return originalLine
+            }
+
+            const match = originalLine.match(propertyRegex)
+            if (!match) {
+                return originalLine
+            }
+
+            let [
+                ,
+                leadingWhitespace,
+                visibility,
+                readonlyPart = '',
+                propName,
+                exclamation,
+                typeDecl,
+                assignment,
+            ] = match
+
+            // Trim trailing whitespace from the type
+            typeDecl = typeDecl.trim()
+
+            if (assignment) {
+                // Remove the bang if there's an assignment
+                exclamation = ''
+
+                // Remove trailing semicolon
+                assignment = assignment.replace(/;$/, '')
+
+                // Ensure we always have " = " at the start
+                // E.g. "=something" => " = something"
+                assignment = assignment.replace(/^=\s*/, ' = ')
+            } else {
+                // No assignment? Add bang
+                exclamation = '!'
+            }
+
+            // Rebuild line, preserving leading indentation
+            const rebuilt = `${leadingWhitespace}${visibility}${readonlyPart} ${propName}${exclamation}: ${typeDecl}${assignment ?? ''}`
+            return rebuilt
+        })
+
+        return updatedLines.join('\n')
+    }
+}
+
+export interface StaticToInstanceTestFileMigrator {
+    migrate(contents: string): string
+}