@sprucelabs/spruce-cli 15.1.8 → 15.2.3

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')
@@ -27,20 +29,12 @@ export default class CreatingBehavioralTestsTest extends AbstractTestTest {
 		'AbstractSpruceFixtureTest'
 	)
 	@test(
-		'can create behavioral test with AbstractSpruceFixtureTest',
+		'can create behavioral test with AbstractStoreTest',
 		'AbstractStoreTest (requires install)'
 	)
 	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,124 @@ 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.installAndStartTestActionAndWaitForInput(
+			testType
+		)
+
+		uiAssert.assertSelectRenderChoice(this.ui, '.', testType)
+		uiAssert.assertSelectRenderChoice(this.ui, `dummy1`, `${testType}/dummy1`)
+
+		await this.ui.sendInput('.')
+		await this.waitAndSelectSubClass()
+
+		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.installAndStartTestActionAndWaitForInput()
+
+		for (const dir of dirs) {
+			uiAssert.assertSelectRenderChoice(this.ui, `${dir}`, `behavioral/${dir}`)
+		}
+
+		await this.ui.sendInput('.')
+
+		await this.waitAndSelectSubClass()
+
+		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.installAndStartTestActionAndWaitForInput(
+			'behavioral'
+		)
+
+		await this.ui.sendInput(`${dirName}`)
+
+		await this.waitAndSelectSubClass()
+
+		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!?')
+
+		await this.installAndStartTestActionAndWaitForInput()
+
+		uiAssert.assertSelectDidNotRenderChoice(
+			this.ui,
+			'test',
+			`behavioral/test/test.ts`
+		)
+
+		this.ui.reset()
+	}
+
+	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 }
+	}
+
+	private static async waitAndSelectSubClass(selectedSubClass?: string) {
+		await this.waitForInput()
+		await this.ui.sendInput(selectedSubClass ?? '')
+	}
 }

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

@@ -27,17 +27,7 @@ const featuresWithRegisteredTests: {
 export default class SelectingAnAbstractTestClassTest extends AbstractTestTest {
 	@test()
 	protected static async asksForYouToSelectABaseClass() {
-		await this.installTests()
-		await this.copyTestFiles()
-
-		const { choices, promise } =
-			await this.executeCreateUntilAbstractClassSelection()
-
-		for (const expected of expectedAbstractTests) {
-			assert.doesInclude(choices, { label: expected })
-		}
-
-		this.selectOptionBasedOnLabel('AbstractBananaTestDifferentThanFileName')
+		const { promise } = await this.installCopyTestFilesSelectLocalAbstractTest()
 
 		const results = await promise
 
@@ -46,12 +36,27 @@ export default class SelectingAnAbstractTestClassTest extends AbstractTestTest {
 			results.files
 		)
 
-		await this.Service('build').build()
+		await this.buildAndAssertTestFailsAsExpected()
+	}
 
-		await assert.doesThrowAsync(
-			() => this.Service('command').execute('yarn test'),
-			/false.*?does not equal.*?true/gis
-		)
+	@test()
+	protected static async canSelectAbstractClassWhileSelectingSubDir() {
+		const testDir = this.resolvePath('src', '__tests__', 'behavioral', 'taco')
+		diskUtil.createDir(testDir)
+
+		await this.installAndCopyTestFiles()
+
+		const { promise } = await this.invokeCreateActionAndWaitForInput()
+
+		await this.ui.sendInput('taco')
+
+		await this.waitForInput()
+
+		this.selectOptionBasedOnLabel('AbstractBananaTestDifferentThanFileName')
+
+		await promise
+
+		await this.buildAndAssertTestFailsAsExpected()
 	}
 
 	@test()
@@ -169,6 +174,35 @@ export default class SelectingAnAbstractTestClassTest extends AbstractTestTest {
 		}
 	}
 
+	private static async buildAndAssertTestFailsAsExpected() {
+		await this.Service('build').build()
+
+		await assert.doesThrowAsync(
+			() => this.Service('command').execute('yarn test'),
+			/false.*?does not equal.*?true/gis
+		)
+	}
+
+	private static async installCopyTestFilesSelectLocalAbstractTest() {
+		await this.installAndCopyTestFiles()
+
+		const { choices, promise } =
+			await this.executeCreateUntilAbstractClassSelection()
+
+		for (const expected of expectedAbstractTests) {
+			assert.doesInclude(choices, { label: expected })
+		}
+
+		this.selectOptionBasedOnLabel('AbstractBananaTestDifferentThanFileName')
+
+		return { promise }
+	}
+
+	private static async installAndCopyTestFiles() {
+		await this.installTests()
+		await this.copyTestFiles()
+	}
+
 	private static async copyTestFiles() {
 		const source = this.resolveTestPath('abstract_tests')
 		const destination = this.resolvePath('src')
@@ -177,13 +211,7 @@ export default class SelectingAnAbstractTestClassTest extends AbstractTestTest {
 	}
 
 	private static async executeCreateUntilAbstractClassSelection() {
-		const promise = this.Action('test', 'create').execute({
-			type: 'behavioral',
-			nameReadable: 'Can book appointment',
-			nameCamel: 'canBookAppointment',
-		})
-
-		await this.waitForInput()
+		const { promise } = await this.invokeCreateActionAndWaitForInput()
 
 		const last = this.ui.getLastInvocation()
 		const { choices } = last.options.options ?? {}
@@ -193,4 +221,15 @@ export default class SelectingAnAbstractTestClassTest extends AbstractTestTest {
 			choices: SelectChoice[]
 		}
 	}
+
+	private static async invokeCreateActionAndWaitForInput() {
+		const promise = this.Action('test', 'create').execute({
+			type: 'behavioral',
+			nameReadable: 'Can book appointment',
+			nameCamel: '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 (diskUtil.doesDirExist(resolvedDestination)) {
+			resolvedDestination = await this.promptForSubDir(
+				resolvedDestination,
+				type
+			)
+		}
 
-					parentTestClass = this.buildParentClassFromCandidate(
-						match,
-						resolvedDestination
-					)
-				}
-			}
+		if (candidates.length > 0) {
+			parentTestClass =
+				await this.promptForParentTestClassAndOptionallyInstallDependencies(
+					candidates,
+					parentTestClass,
+					resolvedDestination
+				)
 		}
 
 		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