@sprucelabs/spruce-cli 18.1.8 → 18.3.0

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

@@ -1,91 +1,271 @@
-import { PermissionContractMap } from '@sprucelabs/mercury-types'
+import { MercuryClientFactory } from '@sprucelabs/mercury-client'
+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 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 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')
+		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()
 	protected static async mixesInAllPermissions() {
+		const contractId = 'oeu-aoeuao'
+		const perm1Id = 'what-the'
+		const perm2Id = 'go-dogs'
+
+		this.updateFirstContractBuilder(contractId, perm1Id, perm2Id)
+
+		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()
+	protected static async passesThroughDependentSkills() {
+		const namespace = this.addRandomDependency()
+
+		let passedTarget: ListPermContractsTargetAndPayload['target']
+
+		await this.eventFaker.fakeListPermissionContracts(({ target }) => {
+			passedTarget = target
+		})
+
+		await this.fetchContracts()
+
+		assert.isEqualDeep(passedTarget, {
+			namespaces: [namespace],
+		})
+	}
+
+	@test()
+	protected static async returnsDependencyMapFromRemoteContracts() {
+		const perm = this.generatePermValues()
+		const perm2 = this.generatePermValues()
+		const perm3 = this.generatePermValues()
+
+		const { contract, contractId } = this.generateContractRowValues([
+			perm,
+			perm2,
+		])
+
+		const { contract: contract2, contractId: contractId2 } =
+			this.generateContractRowValues([perm3])
+
+		await this.eventFaker.fakeListPermissionContracts(() => {
+			return [contract, contract2]
+		})
+
+		const map = await this.fetchContracts()
+		assert.isEqualDeep(map, {
+			[contractId]: [perm.id, perm2.id],
+			[contractId2]: [perm3.id],
+			[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,
+		perm2Id: string
+	) {
 		const file = this.resolvePath(
 			'src',
 			'permissions',
 			`${this.contractName1}.permissions.ts`
 		)
-		diskUtil.writeFile(file, contract1)
+		diskUtil.writeFile(
+			file,
+			generateContractBuilder(contractId, perm1Id, perm2Id)
+		)
+	}
 
-		await this.assertLocalPermissionsEqual({
-			['oeu-aoeuao']: ['what-the', 'go-dogs'],
-			[this.contractName2]: ['can-high-five'],
+	private static generateContractRowValues(
+		permissions: SpruceSchemas.Mercury.v2020_12_25.Permission[]
+	) {
+		const contractId = generateId()
+		const contract = {
+			id: generateId(),
+			contract: {
+				id: contractId,
+				name: generateId(),
+				permissions,
+			},
+		}
+		return { contract, contractId }
+	}
+
+	private static generatePermValues() {
+		const permissionId = generateId()
+		const perm = {
+			id: permissionId,
+			name: generateId(),
+			defaults: {},
+		}
+		return perm
+	}
+
+	private static addRandomDependency() {
+		const dep = this.Service('dependency')
+		const namespace = generateId()
+		dep.add({
+			id: generateId(),
+			namespace,
 		})
+		return namespace
+	}
+
+	private static async fetchContracts() {
+		return this.permissions.fetchContracts()
 	}
 
 	private static async assertLocalPermissionsEqual(
-		expected: PermissionContractMap
+		expected: ImportedPermission[]
 	) {
 		const perms = await this.loadLocalPermissions()
+
+		perms.sort(sortPermissionContracts)
+		expected.sort(sortPermissionContracts)
+
 		assert.isEqualDeep(perms, expected)
 	}
 
 	private static async loadLocalPermissions() {
+		//@ts-ignore
 		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}`
 }
 
-const contract1 = `import {
+function generateContractBuilder(
+	contractId = 'oeu-aoeuao',
+	perm1Id = 'what-the',
+	perm2Id = 'go-dogs'
+) {
+	return `import {
     buildPermissionContract
 } from '@sprucelabs/mercury-types'
 
 const debeePermissions = buildPermissionContract({
-    id: 'oeu-aoeuao',
+    id: '${contractId}',
     name: 'debee',
     description: '',
     requireAllPermissions: false,
     permissions: [
         {
-            id: 'what-the',
+            id: '${perm1Id}',
             name: 'Can give high five',
             description: 'Will this person be allowed to high five?',
             defaults: {
@@ -94,7 +274,7 @@ const debeePermissions = buildPermissionContract({
             requireAllStatuses: false,
         },
         {
-            id: 'go-dogs',
+            id: '${perm2Id}',
             name: 'Can give high five',
             description: 'Will this person be allowed to high five?',
             defaults: {
@@ -107,3 +287,4 @@ const debeePermissions = buildPermissionContract({
 
 export default debeePermissions
 `
+}

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