@sprucelabs/spruce-cli 18.2.0 → 18.3.0

package/src/__tests__/behavioral/permissions/PermissionStore.test.ts

@@ -1,54 +1,84 @@
 import { MercuryClientFactory } from '@sprucelabs/mercury-client'
-import { PermissionContractMap, SpruceSchemas } from '@sprucelabs/mercury-types'
+import { SpruceSchemas } from '@sprucelabs/mercury-types'
 import { diskUtil } from '@sprucelabs/spruce-skill-utils'
 import { test, assert, generateId } from '@sprucelabs/test-utils'
-import PermissionStore from '../../../features/permission/stores/PermissionStore'
-import EventFaker, {
-	ListPermContractsTargetAndPayload,
-} from '../../support/EventFaker'
-import AbstractPermissionsTest from './AbstractPermissionsTest'
+import PermissionStore, {
+	ImportedPermission,
+} from '../../../features/permission/stores/PermissionStore'
+import { ApiClientFactoryOptions } from '../../../types/apiClient.types'
+import { ListPermContractsTargetAndPayload } from '../../support/EventFaker'
+import AbstractPermissionsTest from './support/AbstractPermissionsTest'
+import generateShortAlphaId from './support/generateShortAlphaId'
+import { sortPermissionContracts } from './support/sortPermissionContracts'
 
 export default class PermissionStoreTest extends AbstractPermissionsTest {
-	protected static skillCacheKey = 'permissions'
 	private static permissions: PermissionStore
 	private static contractName1: string
 	private static contractName2: string
-	private static eventFaker: EventFaker
+	private static fqid1: string
+	private static fqid2: string
+	private static namespace: string
 
 	protected static async beforeAll() {
 		await super.beforeAll()
+		const namespace = await this.Service('pkg').getSkillNamespace()
+		this.namespace = namespace
+
 		this.contractName1 = generateShortAlphaId()
+		this.fqid1 = `${namespace}.${this.contractName1}`
+
 		this.contractName2 = generateShortAlphaId()
+		const contractId = this.contractName2
+		this.fqid2 = buildPermissionContractId(contractId, namespace)
 	}
 
 	protected static async beforeEach() {
 		await super.beforeEach()
 		MercuryClientFactory.setIsTestMode(true)
 		this.permissions = this.Store('permission')
-		this.eventFaker = new EventFaker()
+		await this.eventFaker.fakeListPermissionContracts(() => {})
 	}
 
 	@test()
 	protected static async loadsNoLocalByDefault() {
 		const permissions = await this.loadLocalPermissions()
-		assert.isEqualDeep(permissions, {})
+		assert.isEqualDeep(permissions, [])
 	}
 
 	@test()
 	protected static async loadsOneContract() {
 		await this.createPermissionContract(this.contractName1)
-		await this.assertLocalPermissionsEqual({
-			[this.contractName1]: ['can-high-five'],
-		})
+		await this.assertLocalPermissionsEqual([
+			{
+				id: this.fqid1,
+				permissions: ['can-high-five'],
+				path: this.resolvePath(
+					`src/permissions/${this.contractName1}.permissions.ts`
+				),
+			},
+		])
 	}
 
 	@test()
 	protected static async loadsSecondContract() {
 		await this.createPermissionContract(this.contractName2)
-		await this.assertLocalPermissionsEqual({
-			[this.contractName1]: ['can-high-five'],
-			[this.contractName2]: ['can-high-five'],
-		})
+
+		await this.assertLocalPermissionsEqual([
+			{
+				id: this.fqid2,
+				permissions: ['can-high-five'],
+				path: this.resolvePath(
+					`src/permissions/${this.contractName2}.permissions.ts`
+				),
+			},
+			{
+				id: this.fqid1,
+				permissions: ['can-high-five'],
+				path: this.resolvePath(
+					`src/permissions/${this.contractName1}.permissions.ts`
+				),
+			},
+		])
 	}
 
 	@test()
@@ -59,22 +89,22 @@ export default class PermissionStoreTest extends AbstractPermissionsTest {
 
 		this.updateFirstContractBuilder(contractId, perm1Id, perm2Id)
 
-		await this.assertLocalPermissionsEqual({
-			[contractId]: [perm1Id, perm2Id],
-			[this.contractName2]: ['can-high-five'],
-		})
-	}
-
-	@test()
-	protected static async remotePermsEmitsListContracts() {
-		let wasHit = false
-
-		await this.eventFaker.fakeListPermissionContracts(() => {
-			wasHit = true
-		})
-
-		await PermissionStoreTest.fetchContracts()
-		assert.isTrue(wasHit)
+		await this.assertLocalPermissionsEqual([
+			{
+				id: this.fqid2,
+				permissions: ['can-high-five'],
+				path: this.resolvePath(
+					`src/permissions/${this.contractName2}.permissions.ts`
+				),
+			},
+			{
+				id: buildPermissionContractId(contractId, this.namespace),
+				permissions: [perm1Id, perm2Id],
+				path: this.resolvePath(
+					`src/permissions/${this.contractName1}.permissions.ts`
+				),
+			},
+		])
 	}
 
 	@test()
@@ -116,11 +146,30 @@ export default class PermissionStoreTest extends AbstractPermissionsTest {
 		assert.isEqualDeep(map, {
 			[contractId]: [perm.id, perm2.id],
 			[contractId2]: [perm3.id],
-			[this.contractName2]: ['can-high-five'],
-			'oeu-aoeuao': ['what-the', 'go-dogs'],
+			[this.fqid2]: ['can-high-five'],
+			[buildPermissionContractId('oeu-aoeuao', this.namespace)]: [
+				'what-the',
+				'go-dogs',
+			],
 		})
 	}
 
+	@test()
+	protected static async connectsAsSkill() {
+		let passedOptions: ApiClientFactoryOptions | undefined
+
+		//@ts-ignore
+		const old = this.permissions.connectToApi.bind(this.permissions)
+		//@ts-ignore
+		this.permissions.connectToApi = (options) => {
+			passedOptions = options
+			return old(passedOptions)
+		}
+
+		await this.fetchContracts()
+		assert.isEqualDeep(passedOptions, { shouldAuthAsCurrentSkill: true })
+	}
+
 	private static updateFirstContractBuilder(
 		contractId: string,
 		perm1Id: string,
@@ -177,9 +226,13 @@ export default class PermissionStoreTest extends AbstractPermissionsTest {
 	}
 
 	private static async assertLocalPermissionsEqual(
-		expected: PermissionContractMap
+		expected: ImportedPermission[]
 	) {
 		const perms = await this.loadLocalPermissions()
+
+		perms.sort(sortPermissionContracts)
+		expected.sort(sortPermissionContracts)
+
 		assert.isEqualDeep(perms, expected)
 	}
 
@@ -188,8 +241,12 @@ export default class PermissionStoreTest extends AbstractPermissionsTest {
 		return await this.permissions.loadLocalPermissions()
 	}
 }
-function generateShortAlphaId() {
-	return generateId().replace(/[0-9]/g, '').substring(0, 5)
+
+function buildPermissionContractId(
+	contractId: string,
+	namespace?: string
+): string {
+	return `${namespace}.${contractId}`
 }
 
 function generateContractBuilder(

package/src/__tests__/behavioral/permissions/PermissionWriter.test.ts

@@ -0,0 +1,23 @@
+import { PermissionContractMap } from '@sprucelabs/mercury-types'
+import { test, generateId } from '@sprucelabs/test-utils'
+import AbstractPermissionsTest from './support/AbstractPermissionsTest'
+
+export default class PermissionWriterTest extends AbstractPermissionsTest {
+	@test()
+	protected static async writesProperContractId() {
+		const contractId = generateId()
+		const perm1 = generateId()
+		const perm2 = generateId()
+
+		await this.writeTypesFile({
+			[contractId]: [perm1, perm2],
+		})
+
+		await this.writeTestFileAndAssertValid(contractId, perm1, perm2)
+	}
+
+	private static async writeTypesFile(map: PermissionContractMap) {
+		const writer = this.writers.Writer('permission', { fileDescriptions: [] })
+		await writer.writeTypesFile(this.cwd, map)
+	}
+}

package/src/__tests__/behavioral/permissions/SyncingPermissions.test.ts

@@ -1,25 +1,142 @@
-import { test } from '@sprucelabs/test-utils'
+import { MercuryClientFactory } from '@sprucelabs/mercury-client'
+import { diskUtil } from '@sprucelabs/spruce-skill-utils'
+import { assert, test } from '@sprucelabs/test-utils'
+import ActionFactory from '../../../features/ActionFactory'
 import SyncAction from '../../../features/permission/actions/SyncAction'
-import AbstractSkillTest from '../../../tests/AbstractSkillTest'
 import testUtil from '../../../tests/utilities/test.utility'
+import AbstractPermissionsTest from './support/AbstractPermissionsTest'
+import generateShortAlphaId from './support/generateShortAlphaId'
+import { sortPermissionContracts } from './support/sortPermissionContracts'
 
-export default class SyncingPermissionsTest extends AbstractSkillTest {
-	protected static skillCacheKey = 'permissions'
-	private static sync: SyncAction
+export default class SyncingPermissionsTest extends AbstractPermissionsTest {
+	private static syncAction: SyncAction
+	private static contractId1: string
+	private static contractId2: string
+
+	protected static async beforeAll() {
+		await super.beforeAll()
+		this.contractId1 = generateShortAlphaId()
+		this.contractId2 = generateShortAlphaId()
+	}
 
 	protected static async beforeEach() {
 		await super.beforeEach()
-		this.sync = this.Action('permission', 'sync')
+		this.syncAction = this.Action('permission', 'sync')
+		MercuryClientFactory.setIsTestMode(true)
+		ExecuteTrackingAction.wasExecuteInvoked = false
+		await this.eventFaker.fakeListPermissionContracts()
 	}
 
 	@test()
 	protected static async generatesExpectedTypesFile() {
-		const results = await this.sync.execute()
+		const results = await this.sync()
+
 		const expected = this.resolveHashSprucePath(
 			`permissions/permissions.types.ts`
 		)
 
 		testUtil.assertFileByPathInGeneratedFiles(expected, results.files)
-		await this.assertValidActionResponseFiles(results)
+	}
+
+	@test()
+	protected static async syncsNewPermissionsWhenMade() {
+		await this.createPermissionContract(this.contractId1)
+		await this.writeTestFileAndAssertValid(
+			`testing-permissions.${this.contractId1}`
+		)
+	}
+
+	@test()
+	protected static async upgradingSyncsPermissions() {
+		this.beginTrackingExecute()
+		await this.emitDidExecuteUpgrade()
+		assert.isTrue(ExecuteTrackingAction.wasExecuteInvoked)
+	}
+
+	@test()
+	protected static async doesNotSyncIfNotInstalled() {
+		this.beginTrackingExecute()
+		this.featureInstaller.isInstalled = async (code) => code === 'node'
+
+		await this.emitDidExecuteUpgrade()
+		assert.isFalse(ExecuteTrackingAction.wasExecuteInvoked)
+	}
+
+	@test()
+	protected static async generatesCombinedFile() {
+		assert.isTrue(diskUtil.doesFileExist(this.getCombinedPath()))
+	}
+
+	@test()
+	protected static async combinedFileImportsAllPermissions() {
+		await this.createPermissionContract(this.contractId2)
+
+		const imported = await this.Service('import').importDefault(
+			this.getCombinedPath()
+		)
+
+		assert.isEqualDeep(
+			imported.sort(sortPermissionContracts),
+			[
+				{
+					id: this.contractId1,
+					name: this.contractId1,
+					description: '',
+					requireAllPermissions: false,
+					permissions: [
+						{
+							id: 'can-high-five',
+							name: 'Can give high five',
+							description: 'Will this person be allowed to high five?',
+							defaults: { skill: false },
+							requireAllStatuses: false,
+						},
+					],
+				},
+				{
+					id: this.contractId2,
+					name: this.contractId2,
+					description: '',
+					requireAllPermissions: false,
+					permissions: [
+						{
+							id: 'can-high-five',
+							name: 'Can give high five',
+							description: 'Will this person be allowed to high five?',
+							defaults: { skill: false },
+							requireAllStatuses: false,
+						},
+					],
+				},
+			].sort(sortPermissionContracts)
+		)
+	}
+
+	private static getCombinedPath() {
+		return this.resolveHashSprucePath('permissions', 'permissions.ts')
+	}
+
+	private static beginTrackingExecute() {
+		ActionFactory.setActionClass('permission', 'sync', ExecuteTrackingAction)
+	}
+
+	private static async sync() {
+		return await this.syncAction.execute()
+	}
+
+	private static async emitDidExecuteUpgrade() {
+		await this.emitter.emitAndFlattenResponses('feature.did-execute', {
+			actionCode: 'upgrade',
+			featureCode: 'node',
+			results: {},
+		})
+	}
+}
+
+class ExecuteTrackingAction extends SyncAction {
+	public static wasExecuteInvoked = false
+	public async execute() {
+		ExecuteTrackingAction.wasExecuteInvoked = true
+		return {}
 	}
 }

package/src/__tests__/behavioral/permissions/support/AbstractPermissionsTest.ts

@@ -0,0 +1,38 @@
+import { diskUtil, namesUtil } from '@sprucelabs/spruce-skill-utils'
+import CreateAction from '../../../../features/permission/actions/CreateAction'
+import AbstractSkillTest from '../../../../tests/AbstractSkillTest'
+import EventFaker from '../../../support/EventFaker'
+import renderPermissionTestFile from './renderPermissionTestFile'
+
+export default abstract class AbstractPermissionsTest extends AbstractSkillTest {
+	protected static skillCacheKey = 'permissions'
+	protected static createAction: CreateAction
+	protected static eventFaker: EventFaker
+
+	protected static async beforeEach() {
+		await super.beforeEach()
+		this.createAction = this.Action('permission', 'create')
+		this.eventFaker = new EventFaker()
+	}
+
+	protected static async createPermissionContract(nameReadable: string) {
+		return await this.createAction.execute({
+			nameReadable,
+			nameCamel: namesUtil.toCamel(nameReadable),
+		})
+	}
+
+	protected static async writeTestFileAndAssertValid(
+		contractId: string,
+		perm1?: string,
+		perm2?: string
+	) {
+		const contents = renderPermissionTestFile(contractId, perm1, perm2)
+		const destination = this.resolvePath('src', 'test.ts')
+		diskUtil.writeFile(destination, contents)
+
+		await this.assertFilePassesTypeChecks(destination)
+
+		return destination
+	}
+}

package/src/__tests__/behavioral/permissions/support/generateShortAlphaId.ts

@@ -0,0 +1,5 @@
+import { generateId } from '@sprucelabs/test-utils'
+
+export default function generateShortAlphaId() {
+	return generateId().replace(/[0-9]/g, '').substring(0, 5)
+}

package/src/__tests__/behavioral/permissions/support/renderPermissionTestFile.ts

@@ -0,0 +1,27 @@
+export default function renderPermissionTestFile(
+	contractId: string,
+	perm1?: string,
+	perm2?: string
+) {
+	const parts = [
+		`import '${'#' + 'spruce/permissions/permissions.types'}'
+import { PermissionContractId${
+			perm1 ? ', PermissionId' : ''
+		} } from '@sprucelabs/mercury-types'
+
+const contractId: PermissionContractId = '${contractId}'
+console.log(contractId)`,
+	]
+
+	if (perm1) {
+		parts.push(`const perm1: PermissionId<'${contractId}'> = '${perm1}'
+console.log(perm1)`)
+	}
+
+	if (perm2) {
+		parts.push(`const perm2: PermissionId<'${contractId}'> = '${perm2}'
+console.log(perm2)`)
+	}
+
+	return parts.join('\n')
+}

package/src/__tests__/behavioral/permissions/support/sortPermissionContracts.ts

@@ -0,0 +1,3 @@
+export function sortPermissionContracts(a: { id: string }, b: { id: string }) {
+	return a.id > b.id ? 1 : -1
+}

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

@@ -17,18 +17,6 @@ export default class GettingSchemasFromHealthCheckTest extends AbstractSchemaTes
 		await this.assertExpectedSchemas(cli, cleanedExpected)
 	}
 
-	private static async assertExpectedSchemas(
-		cli: CliInterface,
-		expected: Schema[]
-	) {
-		const health = await cli.checkHealth()
-		assert.isFalsy(health.skill.errors)
-		assert.isTruthy(health.schema)
-		assert.isEqual(health.schema.status, 'passed')
-
-		assert.isEqualDeep(this.sortSchemas(health.schema.schemas), expected)
-	}
-
 	@test()
 	protected static async getsCoreAndLocalSchemasFromHealthCheck() {
 		const cli = await this.installAndSyncSchemas()
@@ -60,4 +48,16 @@ export default class GettingSchemasFromHealthCheckTest extends AbstractSchemaTes
 		await this.Action('schema', 'sync').execute({})
 		return cli
 	}
+
+	private static async assertExpectedSchemas(
+		cli: CliInterface,
+		expected: Schema[]
+	) {
+		const health = await cli.checkHealth()
+		assert.isFalsy(health.skill.errors)
+		assert.isTruthy(health.schema)
+		assert.isEqual(health.schema.status, 'passed')
+
+		assert.isEqualDeep(this.sortSchemas(health.schema.schemas), expected)
+	}
 }

package/src/__tests__/behavioral/tests/CreatingATest.test.ts

@@ -19,8 +19,8 @@ export default class CreatingBehavioralTestsTest extends AbstractTestTest {
 		const candidates = await testFeature.buildParentClassCandidates()
 
 		assert.doesInclude(candidates, {
-			label: 'AbstractSpruceFixtureTest (requires install)',
-			name: 'AbstractSpruceFixtureTest',
+			label: 'AbstractStoreTest (requires install)',
+			name: 'AbstractStoreTest',
 		})
 	}
 

package/src/__tests__/behavioral/upgrading/UpgradingANodeModule.test.ts

@@ -33,7 +33,10 @@ export default class UpgradingANodeModuleTest extends AbstractCliTest {
 
 	@test()
 	protected static async upgradingWritesExpectedFiles() {
+		CommandService.fakeCommand(/build/gis, { code: 0 })
+
 		const shouldNotBeFound = ['src/.spruce/skill.ts', 'src/.spruce/features']
+		diskUtil.deleteDir(this.resolveHashSprucePath('features'))
 
 		const results = await this.Action('node', 'upgrade').execute({})
 

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

@@ -8,6 +8,7 @@ import AbstractCliTest from '../../../tests/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
@@ -23,7 +24,7 @@ export default class UpgradingASkill3Test extends AbstractCliTest {
 
 	@test()
 	protected static async doesNotAddResolvePathAliasesToDependenciesAfterUpgrade() {
-		CommandService.clearMockResponses()
+		CommandService.clearFakedResponses()
 		await this.FeatureFixture().installCachedFeatures('views')
 
 		await this.Action('node', 'upgrade').execute({})
@@ -35,7 +36,7 @@ export default class UpgradingASkill3Test extends AbstractCliTest {
 
 	@test()
 	protected static async featuresNotEnabledDontInstall() {
-		CommandService.clearMockResponses()
+		CommandService.clearFakedResponses()
 		await this.FeatureFixture().installCachedFeatures('schemas')
 
 		const results = await this.Action('node', 'upgrade').execute({})

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

@@ -7,7 +7,7 @@ import AbstractCliTest from '../../../tests/AbstractCliTest'
 export default class UpgradingASkill4Test extends AbstractCliTest {
 	protected static async beforeEach() {
 		await super.beforeEach()
-		CommandService.fakeCommand(new RegExp(/yarn rebuild/gis), {
+		CommandService.fakeCommand(new RegExp(/rebuild/gis), {
 			code: 0,
 		})
 	}

package/src/__tests__/implementation/ActionExecuter2.test.ts

@@ -31,7 +31,7 @@ export default class FeatureCommandExecuterContTest extends AbstractSchemaTest {
 
 	@test()
 	protected static async shouldEmitExecutionEvents() {
-		this.setupMockCommands()
+		this.fakeInstallCommands()
 
 		const executer = this.Action('skill', 'create', {
 			shouldAutoHandleDependencies: true,
@@ -129,7 +129,7 @@ export default class FeatureCommandExecuterContTest extends AbstractSchemaTest {
 
 	@test()
 	protected static async shouldReturnProperSummary() {
-		this.setupMockCommands()
+		this.fakeInstallCommands()
 
 		const executer = this.Action('skill', 'create', {
 			shouldAutoHandleDependencies: true,
@@ -148,7 +148,7 @@ export default class FeatureCommandExecuterContTest extends AbstractSchemaTest {
 
 	@test()
 	protected static async shouldAskInstallDependentFeatures() {
-		this.setupMockCommands()
+		this.fakeInstallCommands()
 
 		const executer = this.Action('schema', 'create', {
 			shouldAutoHandleDependencies: true,
@@ -169,7 +169,7 @@ export default class FeatureCommandExecuterContTest extends AbstractSchemaTest {
 
 	@test()
 	protected static async shouldAddListenerWithoutBreakingOnSkill() {
-		this.setupMockCommands()
+		this.fakeInstallCommands()
 
 		await this.FeatureFixture().installCachedFeatures('schemas')
 
@@ -180,7 +180,14 @@ export default class FeatureCommandExecuterContTest extends AbstractSchemaTest {
 
 		await this.waitForInput()
 
+		await this.ui.sendInput('Y')
+		await this.waitForInput()
+		await this.ui.sendInput('\n')
+
+		await this.waitForInput()
+
 		await this.ui.sendInput('skill')
+
 		await this.ui.sendInput('will-boot')
 
 		const results = await promise
@@ -264,8 +271,8 @@ export default class FeatureCommandExecuterContTest extends AbstractSchemaTest {
 		return { promise }
 	}
 
-	private static setupMockCommands() {
-		CommandService.fakeCommand(new RegExp(/npm.*?install .*?/gis), {
+	private static fakeInstallCommands() {
+		CommandService.fakeCommand(new RegExp(/yarn|npm/gis), {
 			code: 0,
 		})
 	}

package/src/__tests__/implementation/GlobalEmitter.test.ts

@@ -1,4 +1,4 @@
-import { test, assert } from '@sprucelabs/test-utils'
+import { test, assert, generateId } from '@sprucelabs/test-utils'
 import AbstractCliTest from '../../tests/AbstractCliTest'
 
 export default class GlobalEmitterTest extends AbstractCliTest {
@@ -7,4 +7,25 @@ export default class GlobalEmitterTest extends AbstractCliTest {
 		//@ts-ignore
 		assert.isTrue(this.emitter.shouldEmitSequentally)
 	}
+
+	@test()
+	protected static async didExecuteAcceptsInstalledPackages() {
+		await this.emitter.on('feature.did-execute', () => {
+			return {
+				packagesInstalled: [
+					{
+						isDev: true,
+						name: generateId(),
+						version: generateId(),
+					},
+				],
+			}
+		})
+
+		await this.emitter.emitAndFlattenResponses('feature.did-execute', {
+			actionCode: generateId(),
+			featureCode: 'permission',
+			results: {},
+		})
+	}
 }

package/src/__tests__/implementation/SkillStore.test.ts

@@ -109,8 +109,7 @@ export default class SkillStoreTest extends AbstractCliTest {
 
 		errorAssert.assertError(err, 'GENERIC')
 
-		const pkg = this.Service('pkg')
-		const namespace = pkg.get('skill.namespace')
+		const namespace = this.Service('pkg').getSkillNamespace()
 		assert.isEqual(namespace, slug)
 	}
 

package/src/features/AbstractAction.ts

@@ -69,8 +69,8 @@ export default abstract class AbstractAction<S extends Schema = Schema>
 		options: SchemaValues<S>
 	): Promise<FeatureActionResponse>
 
-	protected Action(featureCode: string, actionCode: string) {
-		return this.actionExecuter.Action(featureCode as any, actionCode)
+	protected Action(featureCode: FeatureCode, actionCode: string) {
+		return this.actionExecuter.Action(featureCode, actionCode)
 	}
 
 	public Service<S extends Service>(type: S, cwd?: string): ServiceMap[S] {