@sprucelabs/spruce-cli 15.2.16 → 15.2.19

package/src/__tests__/behavioral/skill/UpgradingASkill2.test.ts

@@ -1,233 +1,196 @@
-import { eventDiskUtil } from '@sprucelabs/spruce-event-utils'
+import fsUtil from 'fs'
 import { diskUtil } from '@sprucelabs/spruce-skill-utils'
 import { test, assert } from '@sprucelabs/test'
-import SyncAction from '../../../features/error/actions/SyncAction'
-import UpdateDependenciesAction from '../../../features/node/actions/UpdateDependenciesAction'
 import CommandService from '../../../services/CommandService'
 import AbstractCliTest from '../../../tests/AbstractCliTest'
 import testUtil from '../../../tests/utilities/test.utility'
 export default class UpgradingASkill2Test extends AbstractCliTest {
-	private static originalErrorSyncExecute: any
 	protected static async beforeEach() {
-		if (!this.originalErrorSyncExecute) {
-			this.originalErrorSyncExecute = SyncAction.prototype.execute
-		} else {
-			SyncAction.prototype.execute = this.originalErrorSyncExecute
-		}
-
 		await super.beforeEach()
 		CommandService.setMockResponse(new RegExp(/yarn rebuild/gis), {
 			code: 0,
 		})
 	}
 
-	@test()
-	protected static async doesNotAddResolvePathAliasesToDependenciesAfterUpgrade() {
-		CommandService.clearMockResponses()
-		await this.FeatureFixture().installCachedFeatures('views')
-
-		await this.Action('node', 'upgrade').execute({})
-
-		const dependencies = this.Service('pkg').get('dependencies')
-
-		assert.isFalsy(dependencies['@sprucelabs/resolve-path-aliases'])
-	}
-
-	@test()
-	protected static async featuresNotEnabledDontInstall() {
-		CommandService.clearMockResponses()
-		await this.FeatureFixture().installCachedFeatures('schemas')
+	@test(
+		'Upgrades error.plugin (even if skill is broken)',
+		'error.plugin.ts',
+		'errors'
+	)
+	@test(
+		'Upgrades schema.plugin (even if skill is broken)',
+		'schema.plugin.ts',
+		'schemas'
+	)
+	@test(
+		'Upgrades conversation.plugin (even if skill is broken)',
+		'conversation.plugin.ts',
+		'conversation',
+		false
+	)
+	@test(
+		'Upgrades view.plugin (even if skill is broken)',
+		'view.plugin.ts',
+		'views',
+		false
+	)
+	protected static async upgradesPlugins(
+		pluginName: string,
+		cacheKey: string,
+		shouldMockYarn = true
+	) {
+		await this.FeatureFixture().installCachedFeatures(cacheKey)
+
+		shouldMockYarn && CommandService.setMockResponse(/yarn/, { code: 0 })
+
+		const pluginPath = this.resolveHashSprucePath(`features/${pluginName}`)
+		const originalContents = diskUtil.readFile(pluginPath)
+
+		diskUtil.writeFile(pluginPath, 'aoeuaoeuaoeuaoeu')
 
 		const results = await this.Action('node', 'upgrade').execute({})
 
-		const dependencies = this.Service('pkg').get('dependencies')
-
-		assert.isFalsy(dependencies['@sprucelabs/resolve-path-aliases'])
-
-		assert.doesThrow(() =>
-			testUtil.assertFileByNameInGeneratedFiles(
-				'events.contract.ts',
-				results.files
-			)
-		)
-
-		this.assertViewPluginNotWritten()
-	}
+		assert.isFalsy(results.errors)
 
-	@test()
-	protected static async upgradingSkillSyncsEvents() {
-		await this.FeatureFixture().installCachedFeatures('events')
+		testUtil.assertFileByNameInGeneratedFiles(pluginName, results.files)
 
-		const results = await this.Action('node', 'upgrade').execute({})
-		const events = eventDiskUtil.resolveCombinedEventsContractFile(this.cwd)
+		const updatedContents = diskUtil.readFile(pluginPath)
 
-		assert.isTrue(diskUtil.doesFileExist(events))
+		assert.isEqual(updatedContents, originalContents)
 
-		testUtil.assertFileByNameInGeneratedFiles(
-			'events.contract.ts',
-			results.files
-		)
+		assert.doesInclude(results.summaryLines ?? [], 'successfully')
 	}
 
 	@test()
-	protected static async upgradeCallsUpdateDependencies() {
+	protected static async canSkipPackageScriptChanges() {
 		await this.FeatureFixture().installCachedFeatures('skills')
 
-		UpdateDependenciesAction.prototype.execute = () => {
-			throw new Error('baaaaad')
-		}
+		const pkg = this.Service('pkg')
+		pkg.set({ path: ['scripts', 'build.dev'], value: 'taco' })
 
-		const results = await this.Action('node', 'upgrade').execute({})
+		const promise = this.Action('node', 'upgrade').execute({})
 
-		assert.isTruthy(results.errors)
-		assert.doesInclude(results.errors[0].message, 'baaaaad')
-	}
+		await this.waitForInput()
 
-	@test()
-	protected static async callsCleanFixAndBuildDev() {
-		await this.FeatureFixture().installCachedFeatures('skills')
+		const last = this.ui.getLastInvocation()
 
-		let wasCleanBuildCalled = false
-		UpdateDependenciesAction.prototype.execute = async () => {
-			return {}
-		}
+		assert.isEqual(last.command, 'prompt')
+		assert.doesInclude(last.options.options.choices, { value: 'skip' })
+		assert.doesInclude(last.options.options.choices, { value: 'skipAll' })
+		assert.doesInclude(last.options.options.choices, { value: 'overwrite' })
 
-		CommandService.setMockResponse('yarn clean.build', {
-			code: 0,
-			callback: () => {
-				wasCleanBuildCalled = true
-			},
-		})
+		await this.ui.sendInput('skip')
 
-		let wasBuildDevCalled = false
-
-		CommandService.setMockResponse('yarn build.dev', {
-			code: 0,
-			callback: () => {
-				wasBuildDevCalled = true
-			},
-		})
-
-		const results = await this.Action('node', 'upgrade').execute({})
+		await promise
 
-		assert.isFalsy(results.errors)
-		assert.isTrue(wasCleanBuildCalled)
-		assert.isTrue(wasBuildDevCalled)
+		assert.isEqual(pkg.get(['scripts', 'build.dev']), 'taco')
 	}
 
 	@test()
-	protected static async writesViewPlugin() {
-		await this.FeatureFixture().installCachedFeatures('views')
-
-		const plugin = this.getViewsPluginPath()
-		assert.isTrue(diskUtil.doesFileExist(plugin))
+	protected static async asksForEachScriptChange() {
+		await this.FeatureFixture().installCachedFeatures('skills')
 
-		diskUtil.deleteFile(plugin)
+		const pkg = this.Service('pkg')
+		pkg.set({ path: ['scripts', 'build.dev'], value: 'taco' })
+		pkg.set({ path: ['scripts', 'watch.build.dev'], value: 'taco' })
 
-		assert.isFalse(diskUtil.doesFileExist(plugin))
+		const promise = this.Action('node', 'upgrade').execute({})
 
-		await this.Action('node', 'upgrade').execute({})
+		await this.waitForInput()
 
-		assert.isTrue(diskUtil.doesFileExist(plugin))
-	}
+		let last = this.ui.getLastInvocation()
 
-	@test('sync with errors installed')
-	@test('sync with errors not installed', false)
-	protected static async upgradeSyncsErrors(isInstalled = true) {
-		await this.FeatureFixture().installCachedFeatures(
-			isInstalled ? 'errors' : 'schemas'
-		)
+		assert.isEqual(last.command, 'prompt')
+		await this.ui.sendInput('skip')
 
-		let wasHit = false
+		await this.waitForInput()
 
-		SyncAction.prototype.execute = async () => {
-			wasHit = true
-			return {}
-		}
+		last = this.ui.getLastInvocation()
 
-		this.disableCleanBuildAndYarnAdd()
+		assert.isEqual(last.command, 'prompt')
+		await this.ui.sendInput('skip')
 
-		await this.Action('node', 'upgrade').execute({})
+		await promise
 
-		assert.isEqual(wasHit, isInstalled)
+		assert.isEqual(pkg.get(['scripts', 'build.dev']), 'taco')
+		assert.isEqual(pkg.get(['scripts', 'watch.build.dev']), 'taco')
 	}
 
 	@test()
-	protected static async resetsErrorPluginInSkill() {
+	protected static async canSkipAllScriptChanges() {
 		await this.FeatureFixture().installCachedFeatures('skills')
 
-		const { plugin, expectedContents } = this.destroyErrorPlugin()
+		const pkg = this.Service('pkg')
+		pkg.set({ path: ['scripts', 'build.dev'], value: 'taco' })
+		pkg.set({ path: ['scripts', 'watch.build.dev'], value: 'taco' })
 
-		await this.disableCleanBuildAndYarnAdd()
-
-		const promise = this.Action('node', 'upgrade').execute({
-			upgradeMode: 'askForChanged',
-		})
+		const promise = this.Action('node', 'upgrade').execute({})
 
 		await this.waitForInput()
-		await this.ui.sendInput('overwrite')
 
-		await promise
+		let last = this.ui.getLastInvocation()
 
-		const actualContents = diskUtil.readFile(plugin)
+		assert.isEqual(last.command, 'prompt')
+		await this.ui.sendInput('skipAll')
 
-		assert.isEqual(actualContents, expectedContents)
+		await promise
+
+		assert.isEqual(pkg.get(['scripts', 'build.dev']), 'taco')
+		assert.isEqual(pkg.get(['scripts', 'watch.build.dev']), 'taco')
 	}
 
 	@test()
-	protected static async resetsErrorPluginWhenErrorInstalled() {
-		await this.FeatureFixture().installCachedFeatures('errors')
+	protected static async canOverwriteChangedScript() {
+		await this.FeatureFixture().installCachedFeatures('skills')
 
-		await this.Action('error', 'create').execute({
-			nameReadable: 'Test pass',
-			nameCamel: 'testPass',
-		})
+		const pkg = this.Service('pkg')
+		pkg.set({ path: ['scripts', 'build.dev'], value: 'taco' })
 
-		const { plugin, expectedContents } = this.destroyErrorPlugin()
+		const promise = this.Action('node', 'upgrade').execute({})
 
-		this.disableCleanAndBuild()
+		await this.waitForInput()
 
-		const results = await this.Action('node', 'upgrade').execute({
-			upgradeMode: 'askForChanged',
-		})
+		let last = this.ui.getLastInvocation()
 
-		assert.isFalsy(results.errors)
-		const actualContents = diskUtil.readFile(plugin)
+		assert.isEqual(last.command, 'prompt')
+		await this.ui.sendInput('overwrite')
+
+		await promise
 
-		assert.isEqual(actualContents, expectedContents)
+		assert.isNotEqual(pkg.get(['scripts', 'build.dev']), 'taco')
 	}
 
-	private static destroyErrorPlugin() {
-		const plugin = this.resolveHashSprucePath('errors', 'options.types.ts')
-		const expectedContents = diskUtil.readFile(plugin)
+	@test()
+	protected static async upgradingSkillWithSandboxUpgradesTheListener() {
+		await this.FeatureFixture().installCachedFeatures('sandbox')
+		const results = await this.Action('sandbox', 'setup').execute({})
 
-		diskUtil.writeFile(plugin, 'waka')
-		return { plugin, expectedContents }
-	}
+		const match = testUtil.assertFileByNameInGeneratedFiles(
+			/will-boot/,
+			results.files
+		)
 
-	private static getViewsPluginPath() {
-		return this.resolveHashSprucePath('features', 'view.plugin.ts')
-	}
+		const originalContents = diskUtil.readFile(match)
+		diskUtil.writeFile(match, 'broken')
 
-	protected static assertViewPluginNotWritten() {
-		assert.isFalse(diskUtil.doesFileExist(this.getViewsPluginPath()))
-	}
+		CommandService.setMockResponse(/yarn/, { code: 0 })
 
-	private static disableCleanBuildAndYarnAdd() {
-		this.disableCleanAndBuild()
+		await this.Action('node', 'upgrade').execute({})
 
-		CommandService.setMockResponse(/yarn.*?add/gis, {
-			code: 0,
-		})
+		const newContents = diskUtil.readFile(match)
+		assert.isEqual(originalContents, newContents)
 	}
 
-	private static disableCleanAndBuild() {
-		CommandService.setMockResponse('yarn clean.build', {
-			code: 0,
-		})
-
-		CommandService.setMockResponse('yarn build.dev', {
-			code: 0,
-		})
+	protected static assertSandboxListenerNotWritten() {
+		const listeners = this.resolvePath('src', 'listeners')
+		if (!diskUtil.doesDirExist(listeners)) {
+			return
+		}
+		const matches = fsUtil.readdirSync(listeners)
+		assert.isLength(
+			matches,
+			0,
+			'A sandbox listeners was written and it should not have been.'
+		)
 	}
 }

package/src/__tests__/behavioral/skill/UpgradingASkill3.test.ts

@@ -1,11 +1,20 @@
-import fsUtil from 'fs'
+import { eventDiskUtil } from '@sprucelabs/spruce-event-utils'
 import { diskUtil } from '@sprucelabs/spruce-skill-utils'
 import { test, assert } from '@sprucelabs/test'
+import SyncAction from '../../../features/error/actions/SyncAction'
+import UpdateDependenciesAction from '../../../features/node/actions/UpdateDependenciesAction'
 import CommandService from '../../../services/CommandService'
 import AbstractCliTest from '../../../tests/AbstractCliTest'
-
-export default class UpgradingASkillTest extends AbstractCliTest {
+import testUtil from '../../../tests/utilities/test.utility'
+export default class UpgradingASkill3Test extends AbstractCliTest {
+	private static originalErrorSyncExecute: any
 	protected static async beforeEach() {
+		if (!this.originalErrorSyncExecute) {
+			this.originalErrorSyncExecute = SyncAction.prototype.execute
+		} else {
+			SyncAction.prototype.execute = this.originalErrorSyncExecute
+		}
+
 		await super.beforeEach()
 		CommandService.setMockResponse(new RegExp(/yarn rebuild/gis), {
 			code: 0,
@@ -13,115 +22,212 @@ export default class UpgradingASkillTest extends AbstractCliTest {
 	}
 
 	@test()
-	protected static async restoresMissingPackagesAndPlugins() {
+	protected static async doesNotAddResolvePathAliasesToDependenciesAfterUpgrade() {
+		CommandService.clearMockResponses()
 		await this.FeatureFixture().installCachedFeatures('views')
 
-		const features = this.Service('pkg', process.cwd()).get(
-			'testSkillCache.everything'
+		await this.Action('node', 'upgrade').execute({})
+
+		const dependencies = this.Service('pkg').get('dependencies')
+
+		assert.isFalsy(dependencies['@sprucelabs/resolve-path-aliases'])
+	}
+
+	@test()
+	protected static async featuresNotEnabledDontInstall() {
+		CommandService.clearMockResponses()
+		await this.FeatureFixture().installCachedFeatures('schemas')
+
+		const results = await this.Action('node', 'upgrade').execute({})
+
+		const dependencies = this.Service('pkg').get('dependencies')
+
+		assert.isFalsy(dependencies['@sprucelabs/resolve-path-aliases'])
+
+		assert.doesThrow(() =>
+			testUtil.assertFileByNameInGeneratedFiles(
+				'events.contract.ts',
+				results.files
+			)
 		)
 
-		const pkg = this.Service('pkg')
-		const checks: { nodeModule?: string; plugin?: string }[] = []
-
-		for (const feat of features) {
-			const { code } = feat
-			const nodeModule = `@sprucelabs/spruce-${code}-plugin`
-			const path = this.resolveHashSprucePath('features', `${code}.plugin.ts`)
-			const plugin = diskUtil.doesFileExist(path) ? path : undefined
-
-			checks.push({
-				nodeModule: pkg.get(['dependencies', nodeModule])
-					? nodeModule
-					: undefined,
-				plugin,
-			})
-		}
+		this.assertViewPluginNotWritten()
+	}
+
+	@test()
+	protected static async upgradingSkillSyncsEvents() {
+		await this.FeatureFixture().installCachedFeatures('events')
+
+		const results = await this.Action('node', 'upgrade').execute({})
+		const events = eventDiskUtil.resolveCombinedEventsContractFile(this.cwd)
+
+		assert.isTrue(diskUtil.doesFileExist(events))
+
+		testUtil.assertFileByNameInGeneratedFiles(
+			'events.contract.ts',
+			results.files
+		)
+	}
+
+	@test()
+	protected static async upgradeCallsUpdateDependencies() {
+		await this.FeatureFixture().installCachedFeatures('skills')
 
-		for (const check of checks) {
-			if (check.nodeModule) {
-				pkg.unset(['dependencies', check.nodeModule])
-			}
-			if (check.plugin) {
-				diskUtil.deleteFile(check.plugin)
-			}
+		UpdateDependenciesAction.prototype.execute = () => {
+			throw new Error('baaaaad')
 		}
 
-		CommandService.setMockResponse(/yarn clean/, { code: 0 })
-		CommandService.setMockResponse(/yarn build.dev/, { code: 0 })
+		const results = await this.Action('node', 'upgrade').execute({})
 
-		await this.Action('node', 'upgrade').execute({})
+		assert.isTruthy(results.errors)
+		assert.doesInclude(results.errors[0].message, 'baaaaad')
+	}
 
-		for (const check of checks) {
-			if (check.nodeModule) {
-				assert.isTruthy(
-					pkg.get(['dependencies', check.nodeModule]),
-					`${check.nodeModule} was not added back as a dependencies.`
-				)
-			}
-			if (check.plugin) {
-				assert.isTrue(
-					diskUtil.doesFileExist(check.plugin),
-					`${check.plugin} was not rewritten.`
-				)
-			}
+	@test()
+	protected static async callsCleanFixAndBuildDev() {
+		await this.FeatureFixture().installCachedFeatures('skills')
+
+		let wasCleanBuildCalled = false
+		UpdateDependenciesAction.prototype.execute = async () => {
+			return {}
 		}
+
+		CommandService.setMockResponse('yarn clean.build', {
+			code: 0,
+			callback: () => {
+				wasCleanBuildCalled = true
+			},
+		})
+
+		let wasBuildDevCalled = false
+
+		CommandService.setMockResponse('yarn build.dev', {
+			code: 0,
+			callback: () => {
+				wasBuildDevCalled = true
+			},
+		})
+
+		const results = await this.Action('node', 'upgrade').execute({})
+
+		assert.isFalsy(results.errors)
+		assert.isTrue(wasCleanBuildCalled)
+		assert.isTrue(wasBuildDevCalled)
 	}
 
 	@test()
-	protected static async doesNotAskIfNewScriptsAreAddedToSkillFeature() {
-		const cli = await this.FeatureFixture().installCachedFeatures('skills')
+	protected static async writesViewPlugin() {
+		await this.FeatureFixture().installCachedFeatures('views')
 
-		const pkg = this.Service('pkg')
+		const plugin = this.getViewsPluginPath()
+		assert.isTrue(diskUtil.doesFileExist(plugin))
 
-		const skillFeature = cli.getFeature('skill')
-		//@ts-ignore
-		skillFeature.scripts['taco'] = 'bravo'
+		diskUtil.deleteFile(plugin)
+
+		assert.isFalse(diskUtil.doesFileExist(plugin))
 
 		await this.Action('node', 'upgrade').execute({})
 
-		assert.isEqual(pkg.get(['scripts', 'taco']), 'bravo')
+		assert.isTrue(diskUtil.doesFileExist(plugin))
+	}
+
+	@test('sync with errors installed')
+	@test('sync with errors not installed', false)
+	protected static async upgradeSyncsErrors(isInstalled = true) {
+		await this.FeatureFixture().installCachedFeatures(
+			isInstalled ? 'errors' : 'schemas'
+		)
+
+		let wasHit = false
+
+		SyncAction.prototype.execute = async () => {
+			wasHit = true
+			return {}
+		}
+
+		this.disableCleanBuildAndYarnAdd()
 
-		this.assertSandboxListenerNotWritten()
+		await this.Action('node', 'upgrade').execute({})
+
+		assert.isEqual(wasHit, isInstalled)
 	}
 
 	@test()
-	protected static async canOverwriteMultipleChangedScript() {
+	protected static async resetsErrorPluginInSkill() {
 		await this.FeatureFixture().installCachedFeatures('skills')
 
-		const pkg = this.Service('pkg')
-		pkg.set({ path: ['scripts', 'build.dev'], value: 'taco' })
-		pkg.set({ path: ['scripts', 'watch.build.dev'], value: 'taco' })
+		const { plugin, expectedContents } = this.destroyErrorPlugin()
 
-		const promise = this.Action('node', 'upgrade').execute({})
+		await this.disableCleanBuildAndYarnAdd()
+
+		const promise = this.Action('node', 'upgrade').execute({
+			upgradeMode: 'askForChanged',
+		})
 
 		await this.waitForInput()
+		await this.ui.sendInput('overwrite')
 
-		let last = this.ui.getLastInvocation()
+		await promise
 
-		assert.isEqual(last.command, 'prompt')
-		await this.ui.sendInput('overwrite')
+		const actualContents = diskUtil.readFile(plugin)
 
-		last = this.ui.getLastInvocation()
+		assert.isEqual(actualContents, expectedContents)
+	}
 
-		assert.isEqual(last.command, 'prompt')
-		await this.ui.sendInput('overwrite')
+	@test()
+	protected static async resetsErrorPluginWhenErrorInstalled() {
+		await this.FeatureFixture().installCachedFeatures('errors')
 
-		await promise
+		await this.Action('error', 'create').execute({
+			nameReadable: 'Test pass',
+			nameCamel: 'testPass',
+		})
+
+		const { plugin, expectedContents } = this.destroyErrorPlugin()
+
+		this.disableCleanAndBuild()
+
+		const results = await this.Action('node', 'upgrade').execute({
+			upgradeMode: 'askForChanged',
+		})
+
+		assert.isFalsy(results.errors)
+		const actualContents = diskUtil.readFile(plugin)
 
-		assert.isNotEqual(pkg.get(['scripts', 'build.dev']), 'taco')
-		assert.isNotEqual(pkg.get(['scripts', 'watch.build.dev']), 'taco')
+		assert.isEqual(actualContents, expectedContents)
 	}
 
-	protected static assertSandboxListenerNotWritten() {
-		const listeners = this.resolvePath('src', 'listeners')
-		if (!diskUtil.doesDirExist(listeners)) {
-			return
-		}
-		const matches = fsUtil.readdirSync(listeners)
-		assert.isLength(
-			matches,
-			0,
-			'A sandbox listeners was written and it should not have been.'
-		)
+	private static destroyErrorPlugin() {
+		const plugin = this.resolveHashSprucePath('errors', 'options.types.ts')
+		const expectedContents = diskUtil.readFile(plugin)
+
+		diskUtil.writeFile(plugin, 'waka')
+		return { plugin, expectedContents }
+	}
+
+	private static getViewsPluginPath() {
+		return this.resolveHashSprucePath('features', 'view.plugin.ts')
+	}
+
+	protected static assertViewPluginNotWritten() {
+		assert.isFalse(diskUtil.doesFileExist(this.getViewsPluginPath()))
+	}
+
+	private static disableCleanBuildAndYarnAdd() {
+		this.disableCleanAndBuild()
+
+		CommandService.setMockResponse(/yarn.*?add/gis, {
+			code: 0,
+		})
+	}
+
+	private static disableCleanAndBuild() {
+		CommandService.setMockResponse('yarn clean.build', {
+			code: 0,
+		})
+
+		CommandService.setMockResponse('yarn build.dev', {
+			code: 0,
+		})
 	}
 }