@sprucelabs/spruce-cli 24.0.0 → 24.1.1

package/src/__tests__/behavioral/tests/migrationToInstance/StaticTestFinder.test.ts

@@ -0,0 +1,72 @@
+import AbstractSpruceTest, {
+    test,
+    assert,
+    errorAssert,
+    suite,
+} from '@sprucelabs/test-utils'
+import StaticTestFinderImpl from '../../../../tests/staticToInstanceMigration/StaticTestFinder'
+
+@suite()
+export default class StaticTestFinderTest extends AbstractSpruceTest {
+    private finder: StaticTestFinderImpl = StaticTestFinderImpl.Finder()
+    private testPath?: string
+
+    @test()
+    protected async throwsWithMissing() {
+        //@ts-ignore
+        const err = await assert.doesThrowAsync(() => this.finder.find())
+        errorAssert.assertError(err, 'MISSING_PARAMETERS', {
+            parameters: ['lookupDir'],
+        })
+    }
+
+    @test()
+    protected async matchesStaticTests1() {
+        this.setTestMigrationDir('static_test_migration_1')
+        await this.assertFindResultsEqual([
+            'AnotherStaticTest.test.ts',
+            'StaticTest1.test.ts',
+        ])
+    }
+
+    @test()
+    protected async matchesStaticTests2() {
+        this.setTestMigrationDir('static_test_migration_2')
+        await this.assertFindResultsEqual([
+            'AStaticTest.test.ts',
+            'AnotherStaticTest1.test.ts',
+        ])
+    }
+
+    @test()
+    protected async includesAbstractTestsInOtherDirectories() {
+        this.setTestMigrationDir('static_test_migration_3')
+        await this.assertFindResultsEqual([
+            'AbstractWhateverTest.ts',
+            'AStaticTest2.test.ts',
+        ])
+    }
+
+    private async assertFindResultsEqual(files: string[]) {
+        const results = await this.find()
+        const expected = files.map((file) => this.resolveStaticTestFile(file))
+        assert.isEqualDeep(results, expected)
+    }
+
+    private async find() {
+        return await this.finder.find(this.testPath!)
+    }
+
+    private resolveStaticTestFile(file: string) {
+        return this.resolvePath(this.testPath!, 'src', '__tests__', file)
+    }
+
+    private setTestMigrationDir(dirName: string) {
+        this.testPath = this.resolvePath(
+            'build',
+            '__tests__',
+            'testDirsAndFiles',
+            dirName
+        )
+    }
+}

package/src/__tests__/behavioral/tests/migrationToInstance/StaticTestsWhenAlreadyExists.test.ts

@@ -0,0 +1,31 @@
+import { diskUtil } from '@sprucelabs/spruce-skill-utils'
+import { test } from '@sprucelabs/test-utils'
+import AbstractInstanceTest from './AbstractInstanceTest'
+import { generateExpectedStaticTestContents } from './testFileContentsGenerators'
+
+export default class StaticTestsWhenAlreadyExistsTest extends AbstractInstanceTest {
+    @test()
+    protected static async canCreateStaticTestsWhenAlreadyExists() {
+        const testFile =
+            await this.createTestAndGetCreatedFilePath('AFirstTest')
+
+        diskUtil.writeFile(
+            testFile,
+            generateExpectedStaticTestContents('AFirstTest')
+        )
+
+        await this.createTestAndAssertContentsEqual(
+            'ASecondTest',
+            generateExpectedStaticTestContents('ASecondTest'),
+            true
+        )
+
+        diskUtil.deleteFile(testFile)
+
+        await this.createTestAndAssertContentsEqual(
+            'AThirdTest',
+            generateExpectedStaticTestContents('AThirdTest'),
+            true
+        )
+    }
+}

package/src/__tests__/behavioral/tests/migrationToInstance/StaticToInstanceMigrator.test.ts

@@ -0,0 +1,310 @@
+import AbstractSpruceTest, {
+    test,
+    assert,
+    errorAssert,
+    suite,
+    generateId,
+} from '@sprucelabs/test-utils'
+import {
+    CommandService,
+    ExecuteCommandOptions,
+} from '../../../../services/CommandService'
+import LintService from '../../../../services/LintService'
+import StaticTestFinderImpl, {
+    StaticTestFinder,
+} from '../../../../tests/staticToInstanceMigration/StaticTestFinder'
+import StaticToInstanceMigratorImpl, {
+    StaticToInstanceMigrator,
+} from '../../../../tests/staticToInstanceMigration/StaticToInstanceMigrator'
+import StaticToInstanceTestFileMigratorImpl, {
+    StaticToInstanceTestFileMigrator,
+} from '../../../../tests/staticToInstanceMigration/StaticToInstanceTestFileMigrator'
+
+@suite()
+export default class StaticToInstanceMigratorTest extends AbstractSpruceTest {
+    private testFinder: FakeStaticTestFinder
+    private testFileMigrator: FakeFileMigrator
+    private migrator: StaticToInstanceMigrator
+    private readFiles: string[] = []
+    private fakedFileContents: Record<string, string> = {}
+    private lastWrittenFile?: { destination: string; contents: string }
+    private spyCommandService: SpyCommandService
+
+    public constructor() {
+        super()
+
+        StaticTestFinderImpl.Class = FakeStaticTestFinder
+        StaticToInstanceTestFileMigratorImpl.Class = FakeFileMigrator
+
+        StaticToInstanceMigratorImpl.diskUtil.readFile = (source) => {
+            this.readFiles.push(source)
+            return this.fakedFileContents[source] ?? generateId()
+        }
+
+        StaticToInstanceMigratorImpl.diskUtil.writeFile = (
+            destination: string,
+            contents: string
+        ) => {
+            this.lastWrittenFile = {
+                destination,
+                contents,
+            }
+        }
+
+        this.testFinder = StaticTestFinderImpl.Finder() as FakeStaticTestFinder
+        this.testFileMigrator =
+            StaticToInstanceTestFileMigratorImpl.Migrator() as FakeFileMigrator
+        this.spyCommandService = new SpyCommandService()
+        const lintService = new LintService(
+            this.cwd,
+            () => this.spyCommandService
+        )
+
+        this.migrator = StaticToInstanceMigratorImpl.Migrator({
+            testFinder: this.testFinder,
+            testFileMigrator: this.testFileMigrator,
+            lintService,
+        })
+    }
+
+    @test()
+    protected throwsWithMissing() {
+        const err = assert.doesThrow(() =>
+            //@ts-ignore
+            StaticToInstanceMigratorImpl.Migrator()
+        )
+        errorAssert.assertError(err, 'MISSING_PARAMETERS', {
+            parameters: ['testFinder', 'testFileMigrator', 'lintService'],
+        })
+    }
+
+    @test()
+    protected async runThrowsWithMissing() {
+        //@ts-ignore
+        const err = await assert.doesThrowAsync(() => this.migrator.run())
+        errorAssert.assertError(err, 'MISSING_PARAMETERS', {
+            parameters: ['lookupDir'],
+        })
+    }
+
+    @test()
+    protected async passesLookupDirToTestFinder() {
+        const path = generateId()
+        await this.run(path)
+        assert.isEqual(this.testFinder.lastLookupDir, path)
+    }
+
+    @test('returns stats based on 3 tests found', ['a', 'b', 'c'])
+    @test('returns stats based on 0 tests found', [])
+    protected async returnsStatsBasedOnTestsFound(results: string[]) {
+        this.setFakedFinderResults(results)
+        const stats = await this.run()
+        assert.isEqualDeep(stats, {
+            totalTestsUpdated: this.testFinder.fakedResults.length,
+            totalTestsSkipped: 0,
+        })
+    }
+
+    @test('passes one files contents to migrator', 'a')
+    @test('passes another files contents to migrator', 'b')
+    protected async passesOneFilesContentsToMigrator(filename: string) {
+        this.setFakedFinderResults([filename])
+        await this.run()
+        assert.isEqualDeep(this.readFiles, [filename])
+    }
+
+    @test()
+    protected async passesResultsOfFileToMigrator() {
+        this.setFakedFinderResults(['a'])
+        this.setFakedFileContents({
+            a: generateId(),
+        })
+        await this.run()
+
+        this.assertContentsPassedToFileMigratorEquals([
+            this.fakedFileContents['a'],
+        ])
+    }
+
+    @test()
+    protected async passesResultsOfMultipleFilesToMigrator() {
+        const contents1 = generateId()
+        const contents2 = generateId()
+
+        this.setFakedFinderResults(['what', 'the'])
+
+        this.setFakedFileContents({
+            what: contents1,
+            the: contents2,
+        })
+
+        await this.run()
+
+        this.assertContentsPassedToFileMigratorEquals([contents1, contents2])
+    }
+
+    @test()
+    protected async writesResponseOfMigrate() {
+        const filename = generateId()
+
+        this.setFakedFinderResults([filename])
+        this.setFakedFileContents({
+            [filename]: generateId(),
+        })
+
+        await this.run()
+
+        assert.isEqualDeep(this.lastWrittenFile, {
+            destination: filename,
+            contents: this.testFileMigrator.fakedMigrateResponse,
+        })
+    }
+
+    @test()
+    protected async returnsSkippedIfMigratedIsTheSame() {
+        this.setFakedFinderResults(['a'])
+        const contents = generateId()
+        this.setFakedFileContents({
+            a: contents,
+        })
+
+        this.setMigrateFileResponse(contents)
+
+        const stats = await this.run()
+        assert.isEqualDeep(stats, {
+            totalTestsUpdated: 0,
+            totalTestsSkipped: 1,
+        })
+    }
+
+    @test()
+    protected async countsSkippedAndMatched() {
+        const contents1 = generateId()
+        const contents2 = generateId()
+
+        this.setFakedFinderResults(['what', 'the', 'heck'])
+        this.setFakedFileContents({
+            what: contents1,
+            the: contents2,
+            heck: generateId(),
+        })
+
+        this.testFileMigrator.fakedMigrateResponsesByContents = {
+            [contents1]: contents1,
+            [contents2]: contents2,
+        }
+
+        const stats = await this.run()
+        assert.isEqualDeep(stats, {
+            totalTestsUpdated: 1,
+            totalTestsSkipped: 2,
+        })
+    }
+
+    @test()
+    protected async doesNotWriteFileThatDidNotChange() {
+        this.setFakedFinderResults(['a'])
+        const contents = generateId()
+        this.setFakedFileContents({
+            a: contents,
+        })
+
+        this.setMigrateFileResponse(contents)
+
+        await this.run()
+        assert.isUndefined(this.lastWrittenFile)
+    }
+
+    @test()
+    protected async lintsMigratedFiles() {
+        await this.run()
+        assert.isTrue(this.spyCommandService.didExecute)
+        assert.doesInclude(
+            this.spyCommandService.lastCommand,
+            `await cli.lintFiles(['**/*.ts'])`
+        )
+    }
+
+    @test()
+    protected async shouldLintAfterMigrating() {
+        this.setFakedFinderResults(['match'])
+        this.setFakedFileContents({
+            match: generateId(),
+        })
+
+        StaticToInstanceMigratorImpl.diskUtil.writeFile = () => {
+            assert.isFalse(
+                this.spyCommandService.didExecute,
+                'Should not lint yet'
+            )
+        }
+
+        await this.run()
+    }
+
+    private setMigrateFileResponse(contents: string) {
+        this.testFileMigrator.fakedMigrateResponse = contents
+    }
+
+    private assertContentsPassedToFileMigratorEquals(expected: string[]) {
+        assert.isEqualDeep(
+            this.testFileMigrator.contentsPassedToMigrate,
+            expected
+        )
+    }
+
+    private setFakedFileContents(contents: Record<string, string>) {
+        this.fakedFileContents = contents
+    }
+
+    private setFakedFinderResults(results: string[]) {
+        this.testFinder.fakedResults = results
+    }
+
+    private async run(path?: string) {
+        return await this.migrator.run(path ?? generateId())
+    }
+}
+
+class FakeStaticTestFinder implements StaticTestFinder {
+    public lastLookupDir?: string
+    public fakedResults: string[] = []
+
+    public async find(lookupDir: string): Promise<string[]> {
+        this.lastLookupDir = lookupDir
+        return this.fakedResults
+    }
+}
+
+class FakeFileMigrator implements StaticToInstanceTestFileMigrator {
+    public contentsPassedToMigrate: string[] = []
+    public fakedMigrateResponse = generateId()
+    public fakedMigrateResponsesByContents: Record<string, string> = {}
+
+    public migrate(contents: string): string {
+        this.contentsPassedToMigrate.push(contents)
+        return (
+            this.fakedMigrateResponsesByContents[contents] ??
+            this.fakedMigrateResponse
+        )
+    }
+}
+
+class SpyCommandService implements CommandService {
+    public didExecute = false
+    public lastCommand?: string
+    public async execute(
+        cmd: string,
+        options?: ExecuteCommandOptions
+    ): Promise<{ stdout: string }> {
+        this.lastCommand = options?.args?.[1] ?? cmd
+        this.didExecute = true
+        return {
+            stdout: generateId(),
+        }
+    }
+    public kill(): void {}
+    public pid(): number | undefined {
+        return 0
+    }
+}

package/src/__tests__/behavioral/tests/migrationToInstance/StaticToInstanceTestFileMigrator.test.ts

@@ -0,0 +1,193 @@
+import { diskUtil } from '@sprucelabs/spruce-skill-utils'
+import AbstractSpruceTest, {
+    test,
+    assert,
+    errorAssert,
+    suite,
+} from '@sprucelabs/test-utils'
+import StaticToInstanceTestFileMigratorImpl, {
+    StaticToInstanceTestFileMigrator,
+} from '../../../../tests/staticToInstanceMigration/StaticToInstanceTestFileMigrator'
+
+@suite()
+export default class StaticToInstanceTestFileMigratorTest extends AbstractSpruceTest {
+    private migrator: StaticToInstanceTestFileMigrator =
+        StaticToInstanceTestFileMigratorImpl.Migrator()
+
+    @test()
+    protected throwsWithMissing() {
+        //@ts-ignore
+        const err = assert.doesThrow(() => this.migrate())
+        errorAssert.assertError(err, 'MISSING_PARAMETERS', {
+            parameters: ['contents'],
+        })
+    }
+
+    @test()
+    protected returnsEmptyString() {
+        this.assertMigratedEquals('', '')
+    }
+
+    @test()
+    protected fixesStaticFunction() {
+        this.assertMigratedEquals(
+            `@test()
+protected static myTest() {}`,
+            `@test()
+protected myTest() {}`
+        )
+    }
+
+    @test()
+    protected fixesStaticAsyncFunctions() {
+        this.assertMigratedEquals(
+            `@test()
+protected static async myTest() {}`,
+            `@test()
+protected async myTest() {}`
+        )
+    }
+
+    @test()
+    protected doesNotMessWithStaticInVariableName() {
+        this.assertMigratedEquals(
+            `protected staticInName() {}`,
+            `protected staticInName() {}`
+        )
+    }
+
+    @test()
+    protected addsSuiteDecoratorToClassIfNotThere() {
+        this.assertMigratedEquals(
+            `export default class Test {}`,
+            `@suite()\nexport default class Test {}`
+        )
+    }
+
+    @test()
+    protected doesNotAddSuitIfAnotherClassExported() {
+        this.assertMigratedEquals(
+            `export class Test {}`,
+            `export class Test {}`
+        )
+    }
+
+    @test()
+    protected doesNotAddSuiteIfAlreadyThere() {
+        this.assertMigratedEquals(
+            `@suite()\nexport default class Test {}`,
+            `@suite()\nexport default class Test {}`
+        )
+    }
+
+    @test()
+    protected addsImportIfNotThere() {
+        this.assertMigratedEquals(
+            `import { test } from '@sprucelabs/test-utils'`,
+            `import { test, suite } from '@sprucelabs/test-utils'`
+        )
+    }
+
+    @test()
+    protected doesNotMessWithAnythingWithTestInName() {
+        this.assertMigratedEquals(
+            `protected testing() {}`,
+            `protected testing() {}`
+        )
+    }
+
+    @test()
+    protected doesNoIncludeSuiteTwice() {
+        this.assertMigratedEquals(
+            `import { test, suite } from '@sprucelabs/test-utils'`,
+            `import { test, suite } from '@sprucelabs/test-utils'`
+        )
+    }
+
+    @test()
+    protected includesSuiteEvenIfSuiteIsInAMethodName() {
+        this.assertMigratedEquals(
+            `import { test } from '@sprucelabs/test-utils
+protected suiteMethod() {}`,
+            `import { test, suite } from '@sprucelabs/test-utils
+protected suiteMethod() {}`
+        )
+    }
+
+    @test()
+    protected includesSuiteWithMultipleImports() {
+        this.assertMigratedEquals(
+            `import AbstractSpruceTest, {
+    test,
+    assert,
+    errorAssert,
+} from '@sprucelabs/test-utils'`,
+            `import AbstractSpruceTest, {
+    test, 
+    suite,
+    assert,
+    errorAssert,
+} from '@sprucelabs/test-utils'`
+        )
+    }
+
+    @test()
+    protected canMigrateWholeTest() {
+        const before = this.readTestFile('StaticTest.txt')
+        const expected = this.readTestFile('InstanceTest.txt')
+
+        this.assertMigratedEquals(before, expected)
+    }
+
+    @test()
+    protected properlyMigrationsAbstractTests() {
+        const before = this.readTestFile('AbstractStaticTest.txt')
+        const expected = this.readTestFile('AbstractInstanceTest.txt')
+
+        this.assertMigratedEquals(before, expected)
+    }
+
+    @test()
+    protected canMigrateMoreComplexTest() {
+        const before = this.readTestFile('StaticTest2.txt')
+        const expected = this.readTestFile('InstanceTest2.txt')
+
+        this.assertMigratedEquals(before, expected)
+    }
+
+    @test()
+    protected canMigrateAnotherComplexTest() {
+        const before = this.readTestFile('StaticTest3.txt')
+        const expected = this.readTestFile('InstanceTest3.txt')
+
+        this.assertMigratedEquals(before, expected)
+    }
+
+    private readTestFile(name: string) {
+        return diskUtil.readFile(this.resolveTestClassPath(name))
+    }
+
+    private resolveTestClassPath(name: string) {
+        return this.resolvePath(__dirname, 'support', name)
+    }
+
+    private assertMigratedEquals(contents: string, expected: string) {
+        const actual = this.migrate(contents)
+
+        const cleanedActual = this.cleanString(actual)
+        const cleanedExpected = this.cleanString(expected)
+
+        assert.isTrue(
+            cleanedActual == cleanedExpected,
+            `${actual}\n\ndoes not equal\n\n${expected}`
+        )
+    }
+
+    private cleanString(contents: string) {
+        return contents.replace(/\s{2,}/g, ' ').trim()
+    }
+
+    private migrate(contents: string) {
+        return this.migrator.migrate(contents)
+    }
+}

package/src/__tests__/behavioral/tests/migrationToInstance/support/AbstractInstanceTest.txt

@@ -0,0 +1,24 @@
+import { AbstractSpruceFixtureTest } from '@sprucelabs/spruce-test-fixtures'
+import { assert } from '@sprucelabs/test-utils'
+import HomeIntegrationsStore from '../../stores/HomeIntegrations.store'
+import EventFaker from './EventFaker'
+
+export default abstract class AbstractGoogleTest extends AbstractSpruceFixtureTest {
+    protected eventFaker!: EventFaker
+    private homeIntegrations!: HomeIntegrationsStore
+
+    protected async beforeEach(): Promise<void> {
+        await super.beforeEach()
+        this.eventFaker = new EventFaker()
+        this.homeIntegrations = await this.stores.getStore('homeIntegrations')
+    }
+
+    protected async getFirstHomeIntegration() {
+        const match = await this.homeIntegrations.findOne(
+            {},
+            { shouldIncludePrivateFields: true }
+        )
+        assert.isTruthy(match, 'No home integration found')
+        return match
+    }
+}

package/src/__tests__/behavioral/tests/migrationToInstance/support/AbstractStaticTest.txt

@@ -0,0 +1,24 @@
+import { AbstractSpruceFixtureTest } from '@sprucelabs/spruce-test-fixtures'
+import { assert } from '@sprucelabs/test-utils'
+import HomeIntegrationsStore from '../../stores/HomeIntegrations.store'
+import EventFaker from './EventFaker'
+
+export default abstract class AbstractGoogleTest extends AbstractSpruceFixtureTest {
+    protected static eventFaker: EventFaker
+    private static homeIntegrations: HomeIntegrationsStore
+
+    protected static async beforeEach(): Promise<void> {
+        await super.beforeEach()
+        this.eventFaker = new EventFaker()
+        this.homeIntegrations = await this.stores.getStore('homeIntegrations')
+    }
+
+    protected static async getFirstHomeIntegration() {
+        const match = await this.homeIntegrations.findOne(
+            {},
+            { shouldIncludePrivateFields: true }
+        )
+        assert.isTruthy(match, 'No home integration found')
+        return match
+    }
+}

package/src/__tests__/behavioral/tests/migrationToInstance/support/InstanceTest.txt

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