@sprucelabs/spruce-cli 15.2.15 → 15.2.18

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

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

@@ -1,128 +1,127 @@
+import fsUtil from 'fs'
+import { diskUtil } from '@sprucelabs/spruce-skill-utils'
 import { test, assert } from '@sprucelabs/test'
 import CommandService from '../../../services/CommandService'
 import AbstractCliTest from '../../../tests/AbstractCliTest'
 
 export default class UpgradingASkill4Test extends AbstractCliTest {
-	@test()
-	protected static async upgradeResetsEventCache() {
-		await this.installSetListenerCacheAndBlockExecute()
-
-		await assert.doesThrowAsync(() =>
-			this.Action('node', 'upgrade').execute({})
-		)
-
-		const value = this.Settings().getListenerCache()
-		assert.isFalsy(value)
+	protected static async beforeEach() {
+		await super.beforeEach()
+		CommandService.setMockResponse(new RegExp(/yarn rebuild/gis), {
+			code: 0,
+		})
 	}
 
 	@test()
-	protected static async doesNotResetEventCacheWithOtherAction() {
-		await this.installSetListenerCacheAndBlockExecute()
-
-		await assert.doesThrowAsync(() => this.Action('schema', 'sync').execute({}))
+	protected static async restoresMissingPackagesAndPlugins() {
+		await this.FeatureFixture().installCachedFeatures('views')
 
-		const value = this.Settings().getListenerCache()
-		assert.isEqualDeep(value, { shouldBeDeleted: true })
-	}
-
-	@test('syncs schemas when schemas installed and schemas folder exists', true)
-	@test(
-		'does not syncs schemas when schemas installed but schemas folder does not exist',
-		false
-	)
-	protected static async shouldSyncSchemasIfSchemasIsInstalledAndSchemaFolderExists(
-		shouldCreateSchema: boolean
-	) {
-		await this.FeatureFixture().installCachedFeatures('schemas')
-
-		CommandService.setMockResponse(new RegExp(/yarn/gis), {
-			code: 0,
-		})
+		const features = this.Service('pkg', process.cwd()).get(
+			'testSkillCache.everything'
+		)
 
-		if (shouldCreateSchema) {
-			await this.Action('schema', 'create').execute({
-				nameReadable: 'Test schema!',
-				namePascal: 'AnotherTest',
-				nameCamel: 'anotherTest',
-				description: 'this is so great!',
+		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,
 			})
 		}
 
-		const emitter = this.getEmitter()
-
-		let wasHit = false
-
-		await emitter.on('feature.will-execute', (payload) => {
-			if (payload.featureCode === 'schema' && payload.actionCode === 'sync') {
-				wasHit = true
+		for (const check of checks) {
+			if (check.nodeModule) {
+				pkg.unset(['dependencies', check.nodeModule])
 			}
+			if (check.plugin) {
+				diskUtil.deleteFile(check.plugin)
+			}
+		}
 
-			return {}
-		})
+		CommandService.setMockResponse(/yarn clean/, { code: 0 })
+		CommandService.setMockResponse(/yarn build.dev/, { code: 0 })
 
 		await this.Action('node', 'upgrade').execute({})
 
-		assert.isTrue(wasHit === shouldCreateSchema)
+		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 modulesMovedFromDevToProdDependenciesStayThere() {
-		await this.FeatureFixture().installCachedFeatures('skills')
-
-		await this.moveDependencyToProd('@sprucelabs/resolve-path-aliases')
-		await this.moveDependencyToDev('@sprucelabs/error')
+	protected static async doesNotAskIfNewScriptsAreAddedToSkillFeature() {
+		const cli = await this.FeatureFixture().installCachedFeatures('skills')
 
-		let wasMovedBackToDev = false
-		let wasMovedBackToProd = false
+		const pkg = this.Service('pkg')
 
-		CommandService.setMockResponse(new RegExp(/yarn/gis), {
-			code: 0,
-			callback: (_, args) => {
-				if (
-					args.indexOf('-D') > -1 &&
-					args.indexOf('@sprucelabs/resolve-path-aliases') > -1
-				) {
-					wasMovedBackToDev = true
-				} else if (
-					args.indexOf('-D') === -1 &&
-					args.indexOf('@sprucelabs/error') > -1
-				) {
-					wasMovedBackToProd = true
-				}
-			},
-		})
+		const skillFeature = cli.getFeature('skill')
+		//@ts-ignore
+		skillFeature.scripts['taco'] = 'bravo'
 
 		await this.Action('node', 'upgrade').execute({})
 
-		assert.isFalse(wasMovedBackToDev, 'dependency moved back to dev')
-		assert.isFalse(wasMovedBackToProd, 'dependency moved back to prod')
-	}
+		assert.isEqual(pkg.get(['scripts', 'taco']), 'bravo')
 
-	private static async moveDependencyToDev(name: string) {
-		const pkg = this.Service('pkg')
-		await pkg.uninstall(name)
-		await pkg.install(name, { isDev: true })
+		this.assertSandboxListenerNotWritten()
 	}
-	private static async moveDependencyToProd(name: string) {
+
+	@test()
+	protected static async canOverwriteMultipleChangedScript() {
+		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' })
 
-		await pkg.uninstall(name)
-		await pkg.install(name)
-	}
+		const promise = this.Action('node', 'upgrade').execute({})
 
-	private static async installSetListenerCacheAndBlockExecute() {
-		await this.FeatureFixture().installCachedFeatures('events')
+		await this.waitForInput()
 
-		const settings = this.Settings()
-		settings.setListenerCache({ shouldBeDeleted: true })
+		let last = this.ui.getLastInvocation()
 
-		const emitter = this.getEmitter()
-		void emitter.on('feature.will-execute', () => {
-			throw new Error('Stop!')
-		})
+		assert.isEqual(last.command, 'prompt')
+		await this.ui.sendInput('overwrite')
+
+		last = this.ui.getLastInvocation()
+
+		assert.isEqual(last.command, 'prompt')
+		await this.ui.sendInput('overwrite')
+
+		await promise
+
+		assert.isNotEqual(pkg.get(['scripts', 'build.dev']), 'taco')
+		assert.isNotEqual(pkg.get(['scripts', 'watch.build.dev']), 'taco')
 	}
 
-	private static Settings() {
-		return this.Service('eventSettings')
+	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/UpgradingASkill5.test.ts

@@ -0,0 +1,128 @@
+import { test, assert } from '@sprucelabs/test'
+import CommandService from '../../../services/CommandService'
+import AbstractCliTest from '../../../tests/AbstractCliTest'
+
+export default class UpgradingASkill5Test extends AbstractCliTest {
+	@test()
+	protected static async upgradeResetsEventCache() {
+		await this.installSetListenerCacheAndBlockExecute()
+
+		await assert.doesThrowAsync(() =>
+			this.Action('node', 'upgrade').execute({})
+		)
+
+		const value = this.Settings().getListenerCache()
+		assert.isFalsy(value)
+	}
+
+	@test()
+	protected static async doesNotResetEventCacheWithOtherAction() {
+		await this.installSetListenerCacheAndBlockExecute()
+
+		await assert.doesThrowAsync(() => this.Action('schema', 'sync').execute({}))
+
+		const value = this.Settings().getListenerCache()
+		assert.isEqualDeep(value, { shouldBeDeleted: true })
+	}
+
+	@test('syncs schemas when schemas installed and schemas folder exists', true)
+	@test(
+		'does not syncs schemas when schemas installed but schemas folder does not exist',
+		false
+	)
+	protected static async shouldSyncSchemasIfSchemasIsInstalledAndSchemaFolderExists(
+		shouldCreateSchema: boolean
+	) {
+		await this.FeatureFixture().installCachedFeatures('schemas')
+
+		CommandService.setMockResponse(new RegExp(/yarn/gis), {
+			code: 0,
+		})
+
+		if (shouldCreateSchema) {
+			await this.Action('schema', 'create').execute({
+				nameReadable: 'Test schema!',
+				namePascal: 'AnotherTest',
+				nameCamel: 'anotherTest',
+				description: 'this is so great!',
+			})
+		}
+
+		const emitter = this.getEmitter()
+
+		let wasHit = false
+
+		await emitter.on('feature.will-execute', (payload) => {
+			if (payload.featureCode === 'schema' && payload.actionCode === 'sync') {
+				wasHit = true
+			}
+
+			return {}
+		})
+
+		await this.Action('node', 'upgrade').execute({})
+
+		assert.isTrue(wasHit === shouldCreateSchema)
+	}
+
+	@test()
+	protected static async modulesMovedFromDevToProdDependenciesStayThere() {
+		await this.FeatureFixture().installCachedFeatures('skills')
+
+		await this.moveDependencyToProd('@sprucelabs/resolve-path-aliases')
+		await this.moveDependencyToDev('@sprucelabs/error')
+
+		let wasMovedBackToDev = false
+		let wasMovedBackToProd = false
+
+		CommandService.setMockResponse(new RegExp(/yarn/gis), {
+			code: 0,
+			callback: (_, args) => {
+				if (
+					args.indexOf('-D') > -1 &&
+					args.indexOf('@sprucelabs/resolve-path-aliases') > -1
+				) {
+					wasMovedBackToDev = true
+				} else if (
+					args.indexOf('-D') === -1 &&
+					args.indexOf('@sprucelabs/error') > -1
+				) {
+					wasMovedBackToProd = true
+				}
+			},
+		})
+
+		await this.Action('node', 'upgrade').execute({})
+
+		assert.isFalse(wasMovedBackToDev, 'dependency moved back to dev')
+		assert.isFalse(wasMovedBackToProd, 'dependency moved back to prod')
+	}
+
+	private static async moveDependencyToDev(name: string) {
+		const pkg = this.Service('pkg')
+		await pkg.uninstall(name)
+		await pkg.install(name, { isDev: true })
+	}
+	private static async moveDependencyToProd(name: string) {
+		const pkg = this.Service('pkg')
+
+		await pkg.uninstall(name)
+		await pkg.install(name)
+	}
+
+	private static async installSetListenerCacheAndBlockExecute() {
+		await this.FeatureFixture().installCachedFeatures('events')
+
+		const settings = this.Settings()
+		settings.setListenerCache({ shouldBeDeleted: true })
+
+		const emitter = this.getEmitter()
+		void emitter.on('feature.will-execute', () => {
+			throw new Error('Stop!')
+		})
+	}
+
+	private static Settings() {
+		return this.Service('eventSettings')
+	}
+}