@sprucelabs/spruce-cli 15.1.8 → 15.2.0

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

@@ -1,7 +1,9 @@
+import { diskUtil } from '@sprucelabs/spruce-skill-utils'
 import { test, assert } from '@sprucelabs/test'
 import LintService from '../../../services/LintService'
 import AbstractTestTest from '../../../tests/AbstractTestTest'
 import testUtil from '../../../tests/utilities/test.utility'
+import uiAssert from '../../../tests/utilities/uiAssert.utility'
 
 export default class CreatingBehavioralTestsTest extends AbstractTestTest {
 	@test()
@@ -10,7 +12,7 @@ export default class CreatingBehavioralTestsTest extends AbstractTestTest {
 	}
 
 	@test()
-	protected static async requiresInstallIfSkilLNotInstalled() {
+	protected static async requiresInstallIfFeatureNotInstalled() {
 		await this.installTests('testsInNodeModule')
 
 		const testFeature = this.getFeatureInstaller().getFeature('test')
@@ -32,15 +34,7 @@ export default class CreatingBehavioralTestsTest extends AbstractTestTest {
 	)
 	protected static async canCreateBehavioralTest(testName: string) {
 		LintService.enableLinting()
-		await this.installTests()
-		const promise = this.Action('test', 'create').execute({
-			type: 'behavioral',
-			nameReadable: 'Can book appointment',
-			nameCamel: 'canBookAppointment',
-			namePascal: 'CanBookAppointment',
-		})
-
-		await this.waitForInput()
+		const { promise } = await this.installAndStartTestActionAndWaitForInput()
 
 		this.selectOptionBasedOnLabel(testName)
 
@@ -60,4 +54,129 @@ export default class CreatingBehavioralTestsTest extends AbstractTestTest {
 			/false.*?does not equal.*?true/gis
 		)
 	}
+
+	@test('finds folders inside behavioral', 'behavioral')
+	@test('finds folders inside implementation', 'implementation')
+	protected static async promptsToSelectFolderIfInsideTestDir(
+		testType: string
+	) {
+		await this.installTests()
+
+		this.createTestSubDir(testType, 'dummy1')
+
+		const { promise } = await this.installStartTestSelectSubclassWaitForInput(
+			testType
+		)
+
+		uiAssert.assertSelectRenderChoice(this.ui, '.', testType)
+		uiAssert.assertSelectRenderChoice(this.ui, `dummy1`, `${testType}/dummy1`)
+
+		await this.ui.sendInput('.')
+
+		await promise
+	}
+
+	@test()
+	protected static async listsManyDirsIfExistInsideTestDir() {
+		await this.installTests()
+
+		const dirs = ['dir1', 'dir2', 'dir3']
+
+		for (const dir of dirs) {
+			this.createTestSubDir('behavioral', dir)
+		}
+
+		const { promise } = await this.installStartTestSelectSubclassWaitForInput()
+
+		for (const dir of dirs) {
+			uiAssert.assertSelectRenderChoice(this.ui, `${dir}`, `behavioral/${dir}`)
+		}
+
+		await this.ui.sendInput('.')
+
+		await promise
+	}
+
+	@test('can select subdir 1', 'test')
+	@test('can select subdir 2', 'test-2')
+	protected static async selectingAnOptionRendersToSubDir(dirName: string) {
+		await this.installTests()
+		this.createTestSubDir('behavioral', dirName)
+
+		const { promise } = await this.installStartTestSelectSubclassWaitForInput(
+			'behavioral'
+		)
+
+		await this.ui.sendInput(`${dirName}`)
+
+		const results = await promise
+
+		const expectedPath = this.resolvePath(
+			'src',
+			'__tests__',
+			'behavioral',
+			dirName,
+			'CanBookAppointment.test.ts'
+		)
+
+		assert.isEqual(expectedPath, results.files?.[0]?.path)
+	}
+
+	@test()
+	protected static async doesNotListFiles() {
+		await this.installTests()
+		this.createTestSubDir('behavioral', 'subdir')
+
+		const file = this.resolveTestDir('behavioral', 'test.ts')
+		diskUtil.writeFile(file, 'what the!?')
+
+		const { promise } = await this.installStartTestSelectSubclassWaitForInput()
+
+		uiAssert.assertSelectDidNotRenderChoice(
+			this.ui,
+			'test',
+			`behavioral/test/test.ts`
+		)
+
+		await promise
+	}
+
+	private static async installStartTestSelectSubclassWaitForInput(
+		testType?: string,
+		selectedSubClass?: string
+	) {
+		const { promise } = await this.installAndStartTestActionAndWaitForInput(
+			testType
+		)
+
+		await this.ui.sendInput(selectedSubClass ?? '')
+
+		await uiAssert.assertRendersSelect(this.ui)
+
+		return { promise }
+	}
+
+	private static createTestSubDir(...testDirs: string[]) {
+		const newDir = this.resolveTestDir(...testDirs)
+		diskUtil.createDir(newDir)
+	}
+
+	private static resolveTestDir(...testDirs: string[]) {
+		return this.resolvePath('src', '__tests__', ...testDirs)
+	}
+
+	private static async installAndStartTestActionAndWaitForInput(
+		testType = 'behavioral'
+	) {
+		await this.installTests()
+		const promise = this.Action('test', 'create').execute({
+			type: testType,
+			nameReadable: 'Can book appointment',
+			nameCamel: 'canBookAppointment',
+			namePascal: 'CanBookAppointment',
+		})
+
+		await this.waitForInput()
+		return { promise }
+	}
 }

package/src/features/test/actions/CreateAction.ts

@@ -19,7 +19,7 @@ export default class CreateAction extends AbstractAction<OptionsSchema> {
 		const { testDestinationDir, namePascal, nameCamel, type } =
 			normalizedOptions
 
-		const resolvedDestination = diskUtil.resolvePath(
+		let resolvedDestination = diskUtil.resolvePath(
 			this.cwd,
 			testDestinationDir,
 			type
@@ -28,7 +28,6 @@ export default class CreateAction extends AbstractAction<OptionsSchema> {
 		this.ui.startLoading('Checking potential parent test classes')
 
 		const testFeature = this.parent as TestFeature
-		const candidates = await testFeature.buildParentClassCandidates()
 
 		this.ui.stopLoading()
 
@@ -36,34 +35,22 @@ export default class CreateAction extends AbstractAction<OptionsSchema> {
 			| undefined
 			| { name: string; importPath: string; isDefaultExport: boolean }
 
-		if (candidates.length > 0) {
-			const idx = await this.ui.prompt({
-				type: 'select',
-				isRequired: true,
-				label: 'Which abstract test class do you want to extend?',
-				options: {
-					choices: [
-						{ value: '', label: 'AbstractSpruceTest (default)' },
-						...candidates.map((candidate, idx) => ({
-							value: `${idx}`,
-							label: candidate.label,
-						})),
-					],
-				},
-			})
-
-			if (idx !== '' && candidates[+idx]) {
-				const match = candidates[+idx]
+		const candidates = await testFeature.buildParentClassCandidates()
 
-				if (match) {
-					await this.optionallyInstallFeatureBasedOnSelection(match)
+		if (candidates.length > 0) {
+			parentTestClass =
+				await this.promptForParentTestClassAndOptionallyInstallDependencies(
+					candidates,
+					parentTestClass,
+					resolvedDestination
+				)
+		}
 
-					parentTestClass = this.buildParentClassFromCandidate(
-						match,
-						resolvedDestination
-					)
-				}
-			}
+		if (diskUtil.doesDirExist(resolvedDestination)) {
+			resolvedDestination = await this.promptForSubDir(
+				resolvedDestination,
+				type
+			)
 		}
 
 		this.ui.startLoading('Generating test file...')
@@ -83,6 +70,74 @@ export default class CreateAction extends AbstractAction<OptionsSchema> {
 			hints: ["run `spruce test` in your skill when you're ready!"],
 		}
 	}
+	private async promptForSubDir(resolvedDestination: string, type: string) {
+		const subdirs = diskUtil
+			.readDir(resolvedDestination)
+			.filter((d) =>
+				diskUtil.isDir(diskUtil.resolvePath(resolvedDestination, d))
+			)
+
+		if (subdirs.length > 0) {
+			const match = await this.ui.prompt({
+				type: 'select',
+				label: 'Where should I write this test?',
+				isRequired: true,
+				options: {
+					choices: [
+						{
+							value: '.',
+							label: `${type}`,
+						},
+						...subdirs.map((dir) => ({
+							value: `${dir}`,
+							label: `${type}/${dir}`,
+						})),
+					],
+				},
+			})
+
+			resolvedDestination = diskUtil.resolvePath(resolvedDestination, match)
+		}
+		return resolvedDestination
+	}
+
+	private async promptForParentTestClassAndOptionallyInstallDependencies(
+		candidates: ParentClassCandidate[],
+		parentTestClass:
+			| { name: string; importPath: string; isDefaultExport: boolean }
+			| undefined,
+		resolvedDestination: string
+	) {
+		const idx = await this.ui.prompt({
+			type: 'select',
+			isRequired: true,
+			label: 'Which abstract test class do you want to extend?',
+			options: {
+				choices: [
+					{ value: '', label: 'AbstractSpruceTest (default)' },
+					...candidates.map((candidate, idx) => ({
+						value: `${idx}`,
+						label: candidate.label,
+					})),
+				],
+			},
+		})
+
+		if (idx !== '' && candidates[+idx]) {
+			const match = candidates[+idx]
+
+			if (match) {
+				await this.optionallyInstallFeatureBasedOnSelection(match)
+
+				parentTestClass = this.buildParentClassFromCandidate(
+					match,
+					resolvedDestination
+				)
+			}
+		}
+		return parentTestClass
+	}
+
 	private async optionallyInstallFeatureBasedOnSelection(
 		match: ParentClassCandidate
 	) {

package/src/tests/utilities/uiAssert.utility.ts

@@ -1,7 +1,7 @@
 import { assert } from '@sprucelabs/test'
 import SpyInterface from '../../interfaces/SpyInterface'
 
-const uiAssertUtil = {
+const uiAssert = {
 	async assertRendersSelect(ui: SpyInterface) {
 		await ui.waitForInput()
 
@@ -10,6 +10,8 @@ const uiAssertUtil = {
 			last.options.options.choices,
 			`I expected a select, I did not find one!`
 		)
+
+		return last.options
 	},
 
 	assertSelectDidNotRenderChoice(
@@ -25,6 +27,15 @@ const uiAssertUtil = {
 		})
 	},
 
+	assertSelectRenderChoice(ui: SpyInterface, value: string, label: string) {
+		const last = ui.getLastInvocation()
+
+		assert.doesInclude(last.options.options.choices, {
+			value,
+			label,
+		})
+	},
+
 	async assertRendersConfirmWriteFile(ui: SpyInterface) {
 		await ui.waitForInput()
 
@@ -42,4 +53,4 @@ const uiAssertUtil = {
 	},
 }
 
-export default uiAssertUtil
+export default uiAssert