@sprucelabs/spruce-cli 23.1.0 → 24.1.0

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

@@ -0,0 +1,252 @@
+import AbstractSpruceTest, {
+    test,
+    assert,
+    errorAssert,
+    suite,
+    generateId,
+} from '@sprucelabs/test-utils'
+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 }
+
+    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.migrator = StaticToInstanceMigratorImpl.Migrator({
+            testFinder: this.testFinder,
+            testFileMigrator: this.testFileMigrator,
+        })
+    }
+
+    @test()
+    protected throwsWithMissing() {
+        const err = assert.doesThrow(() =>
+            //@ts-ignore
+            StaticToInstanceMigratorImpl.Migrator()
+        )
+        errorAssert.assertError(err, 'MISSING_PARAMETERS', {
+            parameters: ['testFinder', 'testFileMigrator'],
+        })
+    }
+
+    @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)
+    }
+
+    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
+        )
+    }
+}

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'])
+    }
+}

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

@@ -0,0 +1,63 @@
+import { fake, seed } from '@sprucelabs/spruce-test-fixtures'
+import { assert, test, suite } from '@sprucelabs/test-utils'
+import { HomeIntegration, PublicHomeIntegration } from '../../../google.types'
+import AbstractGoogleTest from '../../support/AbstractGoogleTest'
+
+@fake.login()
+@suite()
+export default class ListHomeIntegrationsLIstenerTest extends AbstractGoogleTest {
+    protected async beforeEach(): Promise<void> {
+        await super.beforeEach()
+        await this.bootSkill()
+    }
+
+    protected async afterEach(): Promise<void> {
+    }
+
+    @test()
+    protected async skillIsListening() {
+        await this.emit()
+    }
+
+    @test()
+    @seed('homeIntegrations', 1)
+    protected async canReturnFirstHomeIntegration() {
+        const expected = await this.getFirstHomeIntegration()
+        const integrations = await this.emit()
+        assert.isLength(integrations, 1)
+        const first = integrations[0]
+        this.assertIntegrationEqualsExpected(first, expected)
+    }
+
+    @test()
+    @seed('homeIntegrations', 2)
+    protected async canReturnMultipleHomeIntegrations() {
+        const expected = await this.homeIntegrations.find(
+            {},
+            {},
+            { shouldIncludePrivateFields: true }
+        )
+        const integrations = await this.emit()
+        assert.isLength(integrations, 2)
+        this.assertIntegrationEqualsExpected(integrations[0], expected[0])
+        this.assertIntegrationEqualsExpected(integrations[1], expected[1])
+    }
+
+    private assertIntegrationEqualsExpected(
+        first: PublicHomeIntegration,
+        expected: HomeIntegration
+    ) {
+        assert.isEqual(first.id, expected.id)
+        assert.isEqual(first.name, expected.name)
+        assert.isEqual(first.description, expected.description)
+    }
+
+    private async emit() {
+        const [{ integrations }] =
+            await this.fakedClient.emitAndFlattenResponses(
+                'google.list-home-integrations::v2025_02_08'
+            )
+
+        return integrations
+    }
+}