@sprucelabs/spruce-cli 18.2.0 → 18.3.1

package/src/__tests__/behavioral/{RegisteringGlobalEvents.test.ts → events/RegisteringGlobalEvents.test.ts}

@@ -1,10 +1,10 @@
 import { versionUtil } from '@sprucelabs/spruce-skill-utils'
 import { test, assert } from '@sprucelabs/test-utils'
 import dotenv from 'dotenv'
-import AbstractSkillTest from '../../tests/AbstractSkillTest'
-import { DEMO_NUMBER_GLOBAL_EVENTS } from '../../tests/constants'
-import testUtil from '../../tests/utilities/test.utility'
-import { RegisteredSkill } from '../../types/cli.types'
+import AbstractSkillTest from '../../../tests/AbstractSkillTest'
+import { DEMO_NUMBER_GLOBAL_EVENTS } from '../../../tests/constants'
+import testUtil from '../../../tests/utilities/test.utility'
+import { RegisteredSkill } from '../../../types/cli.types'
 dotenv.config()
 
 const stamp = new Date().getTime()
@@ -21,8 +21,6 @@ export default class RegisteringGlobalEventsTest extends AbstractSkillTest {
 
 		await this.people.loginAsDemoPerson(DEMO_NUMBER_GLOBAL_EVENTS)
 
-		await this.resetAccount()
-
 		const orgFixture = this.getOrganizationFixture()
 		const skillFixture = this.getSkillFixture()
 
@@ -37,12 +35,6 @@ export default class RegisteringGlobalEventsTest extends AbstractSkillTest {
 
 	protected static async afterAll() {
 		await super.afterAll()
-		await this.resetAccount()
-	}
-
-	private static async resetAccount() {
-		// await this.getOrganizationFixture().clearAllOrgs()
-		// await this.getSkillFixture().clearAllSkills()
 	}
 
 	@test()

package/src/__tests__/behavioral/events/SkillEmitsBootEvents.test.ts

@@ -30,6 +30,7 @@ export default class SkillEmitsBootEventsTest extends AbstractEventTest {
 	@test()
 	protected static async skillEmitsDidBootEventsThatErrorAfterBoot() {
 		await this.installEventFeature('events')
+		this.disablePermissionSyncing()
 		const version = 'v2020_01_01'
 
 		await this.Action('event', 'listen').execute({
@@ -44,4 +45,9 @@ export default class SkillEmitsBootEventsTest extends AbstractEventTest {
 		const err = await assert.doesThrowAsync(() => response.meta?.promise)
 		errorAssert.assertError(err, 'LISTENER_NOT_IMPLEMENTED')
 	}
+
+	private static disablePermissionSyncing() {
+		const env = this.Service('env')
+		env.set('SHOULD_REGISTER_PERMISSIONS', 'false')
+	}
 }

package/src/__tests__/behavioral/{SyncingEventsOnlyFromDependencies.test.ts → events/SyncingEventsOnlyFromDependencies.test.ts}

@@ -1,8 +1,8 @@
 import { diskUtil, namesUtil } from '@sprucelabs/spruce-skill-utils'
 import { test, assert } from '@sprucelabs/test-utils'
 import fsUtil from 'fs-extra'
-import AbstractSkillTest from '../../tests/AbstractSkillTest'
-import { RegisteredSkill } from '../../types/cli.types'
+import AbstractSkillTest from '../../../tests/AbstractSkillTest'
+import { RegisteredSkill } from '../../../types/cli.types'
 
 export default class SyncingEventsOnlyFromDependenciesTest extends AbstractSkillTest {
 	protected static skillCacheKey = 'events'

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

@@ -1,7 +1,7 @@
 import { diskUtil, namesUtil } from '@sprucelabs/spruce-skill-utils'
 import { test, assert } from '@sprucelabs/test-utils'
 import testUtil from '../../../tests/utilities/test.utility'
-import AbstractPermissionsTest from './AbstractPermissionsTest'
+import AbstractPermissionsTest from './support/AbstractPermissionsTest'
 
 export default class CreatingPermissionsTest extends AbstractPermissionsTest {
 	@test('can create permission contract named booking', 'booking')
@@ -16,7 +16,7 @@ export default class CreatingPermissionsTest extends AbstractPermissionsTest {
 	}
 
 	@test()
-	protected static async rendersExpectedTemplate() {
+	protected static async generatesExpectedPermissionContract() {
 		const { contractPath } = await this.executeAndGetContract()
 		const contents = diskUtil.readFile(contractPath)
 		assert.doesInclude(

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

@@ -0,0 +1,24 @@
+import { diskUtil } from '@sprucelabs/spruce-skill-utils'
+import { assert, test } from '@sprucelabs/test-utils'
+import AbstractPermissionsTest from './support/AbstractPermissionsTest'
+
+export default class PermissionPluginTest extends AbstractPermissionsTest {
+	@test()
+	protected static async createsPluginWithExpectedContent() {
+		const expected = this.getPluginPath()
+		await this.assertFilePassesTypeChecks(expected)
+	}
+
+	@test()
+	protected static async pluginIsExpectedContent() {
+		const content = diskUtil.readFile(this.getPluginPath())
+		assert.isEqual(
+			content.trim(),
+			`export { plugin as default } from '@sprucelabs/spruce-permission-plugin'`
+		)
+	}
+
+	private static getPluginPath() {
+		return this.resolveHashSprucePath('features', 'permission.plugin.ts')
+	}
+}

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()
@@ -113,14 +143,34 @@ export default class PermissionStoreTest extends AbstractPermissionsTest {
 		})
 
 		const map = await this.fetchContracts()
+		//@ts-ignore
 		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 +227,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 +242,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,24 @@
+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()
+
+		//@ts-ignore
+		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/{CreatingSchemasWithGenerics.test.ts → schemas/CreatingSchemasWithGenerics.test.ts}

@@ -1,7 +1,7 @@
 import { diskUtil } from '@sprucelabs/spruce-skill-utils'
 import { test, assert } from '@sprucelabs/test-utils'
-import AbstractSchemaTest from '../../tests/AbstractSchemaTest'
-import testUtil from '../../tests/utilities/test.utility'
+import AbstractSchemaTest from '../../../tests/AbstractSchemaTest'
+import testUtil from '../../../tests/utilities/test.utility'
 
 export default class CreatingSchemasWithGenericsTest extends AbstractSchemaTest {
 	@test()

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/{SettingUpSchemasForModuleDistribution.test.ts → schemas/SettingUpSchemasForModuleDistribution.test.ts}

@@ -6,10 +6,10 @@ import {
 } from '@sprucelabs/spruce-skill-utils'
 import { test, assert } from '@sprucelabs/test-utils'
 import { errorAssert } from '@sprucelabs/test-utils'
-import { FeatureActionResponse } from '../../features/features.types'
-import SchemaTemplateItemBuilder from '../../templateItemBuilders/SchemaTemplateItemBuilder'
-import AbstractSkillTest from '../../tests/AbstractSkillTest'
-import testUtil from '../../tests/utilities/test.utility'
+import { FeatureActionResponse } from '../../../features/features.types'
+import SchemaTemplateItemBuilder from '../../../templateItemBuilders/SchemaTemplateItemBuilder'
+import AbstractSkillTest from '../../../tests/AbstractSkillTest'
+import testUtil from '../../../tests/utilities/test.utility'
 
 const LOCAL_NAMESPACE = 'TestingSchemas'
 const REMOTE_NAMESPACE = 'RemoteSchemas'

package/src/__tests__/behavioral/{InstallingASkillAtAnOrg.test.ts → skill/InstallingASkillAtAnOrg.test.ts}

@@ -1,8 +1,8 @@
 import { eventAssertUtil } from '@sprucelabs/spruce-event-utils'
 import { test, assert, assertUtil } from '@sprucelabs/test-utils'
 import { errorAssert } from '@sprucelabs/test-utils'
-import AbstractCliTest from '../../tests/AbstractCliTest'
-import { DEMO_NUMBER_INSTALL_SKILL } from '../../tests/constants'
+import AbstractCliTest from '../../../tests/AbstractCliTest'
+import { DEMO_NUMBER_INSTALL_SKILL } from '../../../tests/constants'
 
 export default class InstallingASkillAtAnOrgTest extends AbstractCliTest {
 	protected static async beforeEach() {

package/src/__tests__/behavioral/{LoggingInAsASkill.test.ts → skill/LoggingInAsASkill.test.ts}

@@ -1,8 +1,8 @@
 import { test, assert } from '@sprucelabs/test-utils'
 import { errorAssert } from '@sprucelabs/test-utils'
-import AbstractSkillTest from '../../tests/AbstractSkillTest'
-import { DEMO_NUMBER_LOGIN_AS_SKILL } from '../../tests/constants'
-import { RegisteredSkill } from '../../types/cli.types'
+import AbstractSkillTest from '../../../tests/AbstractSkillTest'
+import { DEMO_NUMBER_LOGIN_AS_SKILL } from '../../../tests/constants'
+import { RegisteredSkill } from '../../../types/cli.types'
 
 export default class LoggingInAsASkillTest extends AbstractSkillTest {
 	protected static skillCacheKey = 'skills'

package/src/__tests__/behavioral/{RebuildingASkill.test.ts → skill/RebuildingASkill.test.ts}

@@ -1,7 +1,7 @@
 import { test, assert } from '@sprucelabs/test-utils'
 import { errorAssert } from '@sprucelabs/test-utils'
-import CommandService from '../../services/CommandService'
-import AbstractSkillTest from '../../tests/AbstractSkillTest'
+import CommandService from '../../../services/CommandService'
+import AbstractSkillTest from '../../../tests/AbstractSkillTest'
 
 export default class RebuildingASkillTest extends AbstractSkillTest {
 	protected static skillCacheKey = 'skills'