@sprucelabs/spruce-cli 23.1.0 → 24.1.0

package/src/__tests__/behavioral/DeployingToSandbox.test.ts

@@ -5,6 +5,7 @@ import { errorAssert } from '@sprucelabs/test-utils'
 import AbstractCliTest from '../../tests/AbstractCliTest'
 import testUtil from '../../tests/utilities/test.utility'
 import { ApiClient } from '../../types/apiClient.types'
+import { RegisteredSkill } from '../../types/cli.types'
 
 export default class DeployingToSandboxTest extends AbstractCliTest {
     private static sandboxDemoNumber = process.env.SANDBOX_DEMO_NUMBER as string
@@ -56,7 +57,7 @@ export default class DeployingToSandboxTest extends AbstractCliTest {
             name: 'My new skill',
         })
 
-        await this.resetCurrentSkill()
+        await this.unregisterCurrentSkill()
 
         const env = this.Service('env')
 
@@ -64,14 +65,12 @@ export default class DeployingToSandboxTest extends AbstractCliTest {
         env.unset('SKILL_NAME')
         env.unset('SKILL_SLUG')
 
-        const results = await this.Action('skill', 'boot').execute({
-            local: true,
-        })
+        const results = await this.boot()
 
         assert.isTruthy(results.errors)
 
         errorAssert.assertError(results.errors[0], 'MISSING_PARAMETERS', {
-            parameters: ['env.SKILL_NAME', 'env.SKILL_SLUG'],
+            parameters: ['env.SKILL_NAME'],
         })
     }
 
@@ -81,12 +80,12 @@ export default class DeployingToSandboxTest extends AbstractCliTest {
 
         const expected = await this.getTotalSkills(client)
 
-        const boot = await this.Action('skill', 'boot').execute({ local: true })
-
-        boot.meta?.kill()
+        await assert.doesThrowAsync(
+            () => this.bootAndKill(),
+            "don't have access"
+        )
 
         const actual = await this.getTotalSkills(client)
-
         assert.isEqual(expected, actual)
     }
 
@@ -98,9 +97,7 @@ export default class DeployingToSandboxTest extends AbstractCliTest {
             name: 'My new skill',
         })
 
-        const boot = await this.Action('skill', 'boot').execute({ local: true })
-
-        boot.meta?.kill()
+        await this.bootAndKill()
 
         const skills = await this.fetchSkills(client)
 
@@ -113,20 +110,13 @@ export default class DeployingToSandboxTest extends AbstractCliTest {
     protected static async registersSkillAgain() {
         const { client } = await this.installAndSetupForSandbox()
 
-        const skill = await this.getSkillFixture().registerCurrentSkill({
-            name: 'My new skill',
-        })
+        const skill = await this.registerCurrentSkill('My new skill')
 
-        await this.resetCurrentSkill()
-
-        const env = this.Service('env')
-        env.set('SKILL_ID', skill.id)
-        env.set('SKILL_NAME', skill.name)
-        env.set('SKILL_SLUG', skill.slug)
+        await this.unregisterCurrentSkill()
 
-        const boot = await this.Action('skill', 'boot').execute({ local: true })
+        this.updateEnv(skill)
 
-        boot.meta?.kill()
+        await this.bootAndKill()
 
         const skills = await this.fetchSkills(client)
 
@@ -139,44 +129,81 @@ export default class DeployingToSandboxTest extends AbstractCliTest {
     @test()
     protected static async registersSkillAndCanBootAgain() {
         await this.installAndSetupForSandbox()
+        const skill = await this.registerCurrentSkill('My new skill')
+        await this.unregisterCurrentSkill()
 
-        await this.getSkillFixture().registerCurrentSkill({
-            name: 'My new skill',
-        })
+        this.updateEnv(skill)
 
-        await this.resetCurrentSkill()
-
-        const boot = await this.Action('skill', 'boot').execute({ local: true })
-
-        boot.meta?.kill()
-
-        const boot2 = await this.Action('skill', 'boot').execute({
-            local: true,
-        })
-
-        boot2.meta?.kill()
+        await this.bootAndKill()
+        await this.bootAndKill()
     }
 
     @test()
     protected static async canReRegisterAndThenRegisterConversationsWithoutCrash() {
         await this.installAndSetupForSandbox('conversation-with-sandbox')
 
-        await this.getSkillFixture().registerCurrentSkill({
-            name: 'Conversation test',
-        })
-
-        await this.resetCurrentSkill()
+        const skill = await this.registerCurrentSkill('Conversation test')
+        await this.unregisterCurrentSkill()
+        this.updateEnv(skill)
 
         await this.Action('conversation', 'create').execute({
             nameReadable: 'book an appointment',
             nameCamel: 'bookAnAppointment',
         })
 
-        const boot = await this.Action('skill', 'boot').execute({ local: true })
+        await this.bootAndKill()
+    }
+
+    @test()
+    protected static async logsInSkillIfAlreadyRegisteredButMissingEnv() {
+        await this.installAndSetupForSandbox()
+
+        await this.registerCurrentSkill('Login if already registered')
+
+        const env = this.Service('env')
+
+        const originalSkillId = env.get('SKILL_ID')
+        const orginalSkillApiKey = env.get('SKILL_API_KEY')
+
+        env.set('SKILL_ID', 'this is garbage')
+
+        await this.bootAndKill()
+
+        delete process.env.SKILL_ID
+        delete process.env.SKILL_API_KEY
+
+        const skillId = env.get('SKILL_ID')
+        const apiKey = env.get('SKILL_API_KEY')
+
+        assert.isEqual(
+            skillId,
+            originalSkillId,
+            'It logged in as the wrong skill!'
+        )
+
+        assert.isEqual(
+            apiKey,
+            orginalSkillApiKey,
+            'It logged in with the wrong api key!'
+        )
+    }
 
+    private static updateEnv(skill: RegisteredSkill) {
+        const env = this.Service('env')
+        env.set('SKILL_ID', skill.id)
+        env.set('SKILL_NAME', skill.name)
+    }
+
+    private static async bootAndKill() {
+        const boot = await this.boot()
+        assert.isFalsy(boot.errors)
         boot.meta?.kill()
     }
 
+    private static async boot() {
+        return await this.Action('skill', 'boot').execute({ local: true })
+    }
+
     private static async installAndSetupForSandbox(cacheKey = 'sandbox') {
         const client = await this.getMercuryFixture().connectToApi()
 
@@ -202,7 +229,13 @@ export default class DeployingToSandboxTest extends AbstractCliTest {
         return skills
     }
 
-    private static async resetCurrentSkill() {
+    private static async registerCurrentSkill(name: string) {
+        return await this.getSkillFixture().registerCurrentSkill({
+            name,
+        })
+    }
+
+    private static async unregisterCurrentSkill() {
         const isInstalled =
             this.Service('settings').isMarkedAsInstalled('skill')
         if (!isInstalled) {

package/src/__tests__/behavioral/conversations/CreatingAConversationTopic.test.ts

@@ -5,12 +5,12 @@ import testUtil from '../../../tests/utilities/test.utility'
 import { CliInterface } from '../../../types/cli.types'
 
 export default class CreatingAConversationTopicTest extends AbstractCliTest {
-    @test()
+    @test.skip('bring back if re introducing conversation topics')
     protected static async hasCreateConversationAction() {
         assert.isFunction(this.Action('conversation', 'create').execute)
     }
 
-    @test()
+    @test.skip('bring back if re introducing conversation topics')
     protected static async createsValidConversationTopicDefinition() {
         const cli =
             await this.FeatureFixture().installCachedFeatures('conversation')

package/src/__tests__/behavioral/conversations/RegisteringConversationsOnBoot.test.ts

@@ -2,7 +2,7 @@ import { test, assert } from '@sprucelabs/test-utils'
 import AbstractEventTest from '../../../tests/AbstractEventTest'
 
 export default class RegisteringConversationsOnBootTest extends AbstractEventTest {
-    @test()
+    @test.skip('bring back if re introducing conversation topics')
     protected static async canRegisterConversationsOnBoot() {
         const { currentSkill } =
             await this.seedDummySkillRegisterCurrentSkillAndInstallToOrg(

package/src/__tests__/behavioral/conversations/TestingAConversation.test.ts

@@ -5,12 +5,12 @@ import AbstractCliTest from '../../../tests/AbstractCliTest'
 import testUtil from '../../../tests/utilities/test.utility'
 
 export default class TestingAConversationTest extends AbstractCliTest {
-    @test()
+    @test.skip('bring back if re introducing conversation topics')
     protected static async hasTestConvoFeature() {
         assert.isFunction(this.Action('conversation', 'test').execute)
     }
 
-    @test()
+    @test.skip('bring back if re introducing conversation topics')
     protected static async shouldRunWithoutConversationShouldShutdownOnItsOwn() {
         await this.FeatureFixture().installCachedFeatures('conversation')
 
@@ -33,7 +33,7 @@ export default class TestingAConversationTest extends AbstractCliTest {
         } while (psResults.length > 0)
     }
 
-    @test()
+    @test.skip('bring back if re introducing conversation topics')
     protected static async runsUntilKilled() {
         await this.installAndCreateConversation()
 
@@ -59,7 +59,7 @@ export default class TestingAConversationTest extends AbstractCliTest {
         } while (psResults.length > 0)
     }
 
-    @test()
+    @test.skip('bring back if re introducing conversation topics')
     protected static async doesntReturnErrorWhenKilled() {
         await this.installAndCreateConversation()
         const test = this.Action(
@@ -79,7 +79,7 @@ export default class TestingAConversationTest extends AbstractCliTest {
         assert.isFalsy(results.errors)
     }
 
-    @test()
+    @test.skip('bring back if re introducing conversation topics')
     protected static async returnsErrorWhenScriptErrors() {
         const { createResults } = await this.installAndCreateConversation()
 

package/src/__tests__/behavioral/organization/CreatingAnOrg.test.ts

@@ -14,7 +14,6 @@ export default class CreatingAnOrgTest extends AbstractCliTest {
         const slug = `my-org-${new Date().getTime()}`
 
         await this.FeatureFixture().installCachedFeatures('organizations')
-
         await this.people.loginAsDemoPerson()
 
         const results = await this.Action('organization', 'create').execute({

package/src/__tests__/behavioral/schemas/CreatingSchemasWithGenerics.test.ts

@@ -25,12 +25,13 @@ export default class CreatingSchemasWithGenericsTest extends AbstractSchemaTest
         )
 
         const contents = diskUtil.readFile(match)
+
         assert.doesInclude(contents, '<Type extends string = string>')
         assert.doesInclude(contents, '<Type2 extends string = string>')
         assert.doesInclude(contents, '<Type>')
         assert.doesInclude(
             contents,
-            "typedByGeneric'?: (Type2)| undefined | null"
+            "'typedByGeneric'?: (Type2) | undefined | null"
         )
 
         await this.assertValidActionResponseFiles(results)

package/src/__tests__/behavioral/tests/migrationToInstance/AbstractInstanceTest.ts

@@ -0,0 +1,77 @@
+import { diskUtil, namesUtil } from '@sprucelabs/spruce-skill-utils'
+import { assert } from '@sprucelabs/test-utils'
+import CreateAction from '../../../../features/test/actions/CreateAction'
+import AbstractSkillTest from '../../../../tests/AbstractSkillTest'
+import testUtil from '../../../../tests/utilities/test.utility'
+
+export default abstract class AbstractInstanceTest extends AbstractSkillTest {
+    protected static skillCacheKey = 'tests'
+    protected static action: CreateAction
+
+    protected static async beforeEach() {
+        await super.beforeEach()
+
+        this.action = this.Action('test', 'create')
+    }
+
+    protected static async createTest(
+        name: string,
+        willPromptForSubDir = false
+    ) {
+        const promise = this.action.execute({
+            type: 'behavioral',
+            nameReadable: name,
+            nameCamel: namesUtil.toCamel(name),
+            namePascal: namesUtil.toPascal(name),
+        })
+
+        await this.ui.waitForInput()
+        await this.ui.sendInput('')
+
+        if (willPromptForSubDir) {
+            await this.ui.waitForInput()
+            await this.ui.sendInput('')
+        }
+
+        const results = await promise
+
+        assert.isFalsy(results.errors, 'Error creating test')
+        return results
+    }
+
+    protected static async createTestAndAssertContentsEqual(
+        name: string,
+        expected: string,
+
+        willPromptForSubDir = false
+    ) {
+        const testFile = await this.createTestAndGetCreatedFilePath(
+            name,
+            willPromptForSubDir
+        )
+
+        const contents = diskUtil.readFile(testFile)
+        assert.isEqual(
+            this.normalizeWhitespace(contents),
+            this.normalizeWhitespace(expected),
+            'Instance test does not match expected'
+        )
+    }
+
+    protected static async createTestAndGetCreatedFilePath(
+        name: string,
+        willPromptForSubDir = false
+    ) {
+        const results = await this.createTest(name, willPromptForSubDir)
+
+        const testFile = testUtil.assertFileByNameInGeneratedFiles(
+            `${namesUtil.toPascal(name)}.test.ts`,
+            results.files
+        )
+        return testFile
+    }
+
+    protected static normalizeWhitespace(contents: string) {
+        return contents.replace(/\s/g, '')
+    }
+}

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

@@ -0,0 +1,19 @@
+import { test } from '@sprucelabs/test-utils'
+import AbstractInstanceTest from './AbstractInstanceTest'
+import { generateExpectedInstanceTestContents } from './testFileContentsGenerators'
+
+export default class InstanceBasedTestingTest extends AbstractInstanceTest {
+    @test()
+    protected static async ifNoTestsExistCreatesInstanceTest() {
+        const name = 'My First Test'
+        const expected = generateExpectedInstanceTestContents(name)
+        await this.createTestAndAssertContentsEqual(name, expected)
+    }
+
+    @test()
+    protected static async secondTestAlsoInstance() {
+        const name = 'My Second Test'
+        const expected = generateExpectedInstanceTestContents(name)
+        await this.createTestAndAssertContentsEqual(name, expected, true)
+    }
+}

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

@@ -0,0 +1,99 @@
+import { test, assert } from '@sprucelabs/test-utils'
+import MigrationAction from '../../../../features/test/actions/MigrateAction'
+import AbstractSkillTest from '../../../../tests/AbstractSkillTest'
+import StaticToInstanceMigratorImpl, {
+    StaticToInstanceMigrator,
+    StaticToInstanceMigratorOptions,
+    StaticToInstanceMigratorResults,
+} from '../../../../tests/staticToInstanceMigration/StaticToInstanceMigrator'
+
+export default class MigratingTestsTest extends AbstractSkillTest {
+    private static action: MigrationAction
+    protected static skillCacheKey = 'tests'
+
+    protected static async beforeEach() {
+        await super.beforeEach()
+        StaticToInstanceMigratorImpl.Class = FakeStaticToInstanceMigrator
+        this.action = this.Action('test', 'migrate')
+    }
+
+    @test()
+    protected static async hasMigrateAction() {
+        assert.isFunction(this.Action('test', 'migrate').execute)
+    }
+
+    @test()
+    protected static async migrateCreatsMigrator() {
+        const results = await this.execute()
+        assert.isFalsy(results.errors)
+        assert.isTruthy(this.migrator, 'Migrator not created')
+    }
+
+    @test()
+    protected static async migratorRunsMigratePassingLookupDir() {
+        await this.execute()
+        this.migrator.assertLookupCalledWith(
+            this.resolvePath('src', '__tests__')
+        )
+    }
+
+    @test('returns results from migrator 1', 1, 1)
+    @test('returns results from migrator 2', 2, 3)
+    protected static async returnsResultsFromMigrator(
+        totalTestsSkipped: number,
+        totalTestsUpdated: number
+    ) {
+        FakeStaticToInstanceMigrator.runResults = {
+            totalTestsSkipped,
+            totalTestsUpdated,
+        }
+
+        const results = await this.execute()
+        assert.isEqualDeep(results, {
+            headline: 'Migrated tests from static to instance based.',
+            summaryLines: [
+                `${totalTestsUpdated} test${totalTestsUpdated === 1 ? '' : 's'} updated`,
+                `${totalTestsSkipped} test${totalTestsSkipped === 1 ? '' : 's'} skipped`,
+            ],
+        })
+    }
+
+    private static get migrator(): FakeStaticToInstanceMigrator {
+        return FakeStaticToInstanceMigrator.instance
+    }
+
+    private static async execute() {
+        return await this.action.execute()
+    }
+}
+
+class FakeStaticToInstanceMigrator implements StaticToInstanceMigrator {
+    public static instance: FakeStaticToInstanceMigrator
+    private passedLookupDir?: string
+    public static runResults?: StaticToInstanceMigratorResults
+
+    public constructor(_options: StaticToInstanceMigratorOptions) {
+        FakeStaticToInstanceMigrator.instance = this
+    }
+
+    public async run(
+        lookupDir: string
+    ): Promise<StaticToInstanceMigratorResults> {
+        this.passedLookupDir = lookupDir
+
+        return (
+            FakeStaticToInstanceMigrator.runResults ?? {
+                totalTestsUpdated: 0,
+                totalTestsSkipped: 0,
+            }
+        )
+    }
+
+    public assertLookupCalledWith(expected: string) {
+        assert.isEqual(
+            this.passedLookupDir,
+            expected,
+            `Migrator.run was not called with expected lookup dir.`
+        )
+    }
+}

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