@sprucelabs/spruce-cli 20.0.5 → 21.0.0

package/src/tests/AbstractCliTest.ts

@@ -11,7 +11,7 @@ import EventFaker from '../__tests__/support/EventFaker'
 import AbstractAction from '../features/AbstractAction'
 import { FeatureOptions } from '../features/AbstractFeature'
 import ActionExecuter, {
-	ActionExecuterOptions,
+    ActionExecuterOptions,
 } from '../features/ActionExecuter'
 import ActionFactory from '../features/ActionFactory'
 import EventStore from '../features/event/stores/EventStore'
@@ -27,17 +27,17 @@ import ImportService from '../services/ImportService'
 import LintService from '../services/LintService'
 import ServiceFactory, { Service, ServiceMap } from '../services/ServiceFactory'
 import StoreFactory, {
-	StoreCode,
-	CreateStoreOptions,
-	StoreFactoryOptions,
-	StoreMap,
+    StoreCode,
+    CreateStoreOptions,
+    StoreFactoryOptions,
+    StoreMap,
 } from '../stores/StoreFactory'
 import { ApiClientFactoryOptions } from '../types/apiClient.types'
 import { CliBootOptions, OptionOverrides } from '../types/cli.types'
 import WriterFactory from '../writers/WriterFactory'
 import CommandFaker from './CommandFaker'
 import FeatureFixture, {
-	FeatureFixtureOptions,
+    FeatureFixtureOptions,
 } from './fixtures/FeatureFixture'
 import MercuryFixture from './fixtures/MercuryFixture'
 import OrganizationFixture from './fixtures/OrganizationFixture'
@@ -47,472 +47,481 @@ import ViewFixture from './fixtures/ViewFixture'
 import testUtil from './utilities/test.utility'
 
 export default abstract class AbstractCliTest extends AbstractSpruceTest {
-	protected static cliRoot = pathUtil.join(__dirname, '..')
-	protected static homeDir: string
-	protected static commandFaker: CommandFaker
+    protected static cliRoot = pathUtil.join(__dirname, '..')
+    protected static homeDir: string
+    protected static commandFaker: CommandFaker
 
-	private static _ui: SpyInterface
-	private static _emitter?: GlobalEmitter
-	private static mercuryFixture?: MercuryFixture
-	private static personFixture?: PersonFixture
-	private static organizationFixture?: OrganizationFixture
-	private static skillFixture?: SkillFixture
-	private static _featureInstaller?: FeatureInstaller
-	private static viewFixture?: ViewFixture
-	private static originalEnv: { [x: string]: string | undefined }
-	private static _writers?: WriterFactory
-	protected static eventFaker: EventFaker
+    private static _ui: SpyInterface
+    private static _emitter?: GlobalEmitter
+    private static mercuryFixture?: MercuryFixture
+    private static personFixture?: PersonFixture
+    private static organizationFixture?: OrganizationFixture
+    private static skillFixture?: SkillFixture
+    private static _featureInstaller?: FeatureInstaller
+    private static viewFixture?: ViewFixture
+    private static originalEnv: Record<string, string | undefined>
+    private static _writers?: WriterFactory
+    protected static eventFaker: EventFaker
 
-	protected static async beforeAll() {
-		await super.beforeAll()
-		await this.cleanTestDirsAndFiles()
+    protected static async beforeAll() {
+        await super.beforeAll()
+        await this.cleanTestDirsAndFiles()
 
-		LintService.disableLinting()
-		ServiceFactory.reset()
+        LintService.disableLinting()
+        ServiceFactory.reset()
+        WriterFactory.reset()
 
-		ImportService.setCacheDir(diskUtil.createRandomTempDir())
-		ImportService.enableCaching()
+        ImportService.setCacheDir(diskUtil.createRandomTempDir())
+        ImportService.enableCaching()
 
-		this.eventFaker = new EventFaker()
+        this.eventFaker = new EventFaker()
 
-		process.env.ENABLE_INSTALL_ENTERTAINMENT = 'false'
+        process.env.ENABLE_INSTALL_ENTERTAINMENT = 'false'
 
-		this.originalEnv = { ...process.env }
-	}
+        this.originalEnv = { ...process.env }
+    }
 
-	protected static async beforeEach() {
-		await super.beforeEach()
+    protected static async beforeEach() {
+        await super.beforeEach()
 
-		delete this._writers
+        delete this._writers
 
-		ActionFactory.clearActionOverrides()
+        ActionFactory.clearActionOverrides()
 
-		//@ts-ignore
-		process.env = { ...this.originalEnv }
+        //@ts-ignore
+        process.env = { ...this.originalEnv }
 
-		testUtil.startLogTimer()
+        testUtil.startLogTimer()
 
-		SchemaRegistry.getInstance().forgetAllSchemas()
+        SchemaRegistry.getInstance().forgetAllSchemas()
+
+        this.cwd = this.freshTmpDir()
+        this.homeDir = this.freshTmpDir()
 
-		this.cwd = this.freshTmpDir()
-		this.homeDir = this.freshTmpDir()
-
-		AuthService.homeDir = this.homeDir
-
-		this._emitter = undefined
-		this._featureInstaller = undefined
-
-		OnboardingStore.overrideCwd(diskUtil.createRandomTempDir())
-
-		this.ui.reset()
-		this.ui.invocations = []
-		this.ui.setCursorPosition({ x: 0, y: 0 })
-
-		this.clearFixtures()
-
-		ImportService.clearCache()
-		SkillStore.clearCurrentSkill()
-		EventStore.clearCache()
-		CommandService.clearFakedResponses()
-		MercuryClientFactory.reset()
-		MercuryClientFactory.setIsTestMode(false)
-
-		this.commandFaker = new CommandFaker()
-	}
-
-	protected static async afterEach() {
-		await super.afterEach()
-
-		await this.organizationFixture?.clearAllOrgs()
-		await this.mercuryFixture?.disconnectAll()
-
-		this.clearFixtures()
-
-		if (this._ui?.isWaitingForInput()) {
-			throw new Error(
-				`Terminal interface is waiting for input. Make sure you are invoking this.term.sendInput() as many times as needed.`
-			)
-		}
-
-		if (diskUtil.doesDirExist(this.cwd) && testUtil.shouldClearCache()) {
-			diskUtil.deleteDir(this.cwd)
-		}
-
-		if (diskUtil.doesDirExist(this.homeDir) && testUtil.shouldClearCache()) {
-			diskUtil.deleteDir(this.homeDir)
-		}
-
-		if (testUtil.shouldCleanupAfterEach()) {
-			FeatureFixture.deleteOldSkillDirs()
-		}
-	}
-
-	protected static async afterAll() {
-		await super.afterAll()
-		if (testUtil.shouldCleanupAfterAll()) {
-			FeatureFixture.deleteOldSkillDirs()
-		}
-	}
-
-	private static async cleanTestDirsAndFiles() {
-		const pattern = this.resolveTestPath('**/*.d.ts')
-		const matches = await globby(pattern)
-
-		for (const match of matches) {
-			diskUtil.deleteFile(match)
-		}
-	}
-
-	private static clearFixtures() {
-		this._emitter = undefined
-		this.mercuryFixture = undefined
-		this.organizationFixture = undefined
-		this.personFixture = undefined
-		this.skillFixture = undefined
-		this.viewFixture = undefined
-	}
-
-	protected static freshTmpDir() {
-		const tmpDirectory = testUtil.resolveTestDir(uuid.v4())
-		fs.ensureDirSync(tmpDirectory)
-		return tmpDirectory
-	}
-
-	protected static get ui() {
-		if (!this._ui) {
-			this._ui = new SpyInterface()
-		}
-
-		return this._ui
-	}
-
-	protected static get emitter() {
-		if (!this._emitter) {
-			this._emitter = CliGlobalEmitter.Emitter()
-		}
-		return this._emitter
-	}
-
-	protected static set emitter(emitter: GlobalEmitter) {
-		this._emitter = emitter
-	}
-
-	protected static resolveTestPath(...pathAfterTestDirsAndFiles: string[]) {
-		return pathUtil.join(
-			this.cliRoot,
-			'__tests__',
-			'testDirsAndFiles',
-			...pathAfterTestDirsAndFiles
-		)
-	}
-
-	protected static async Cli(options?: CliBootOptions) {
-		return this.FeatureFixture(options).Cli({
-			cwd: this.cwd,
-			homeDir: this.homeDir,
-			...(options ?? {}),
-		})
-	}
-
-	protected static async linkLocalPackages() {
-		const fixture = this.FeatureFixture()
-		await fixture.linkLocalPackages()
-	}
-
-	protected static Service<S extends Service>(
-		type: S,
-		cwd?: string
-	): ServiceMap[S] {
-		const sf = this.ServiceFactory()
-		return sf.Service(cwd ?? this.cwd, type)
-	}
-
-	protected static ServiceFactory() {
-		return new ServiceFactory()
-	}
-
-	protected static FeatureFixture(options?: Partial<FeatureFixtureOptions>) {
-		return new FeatureFixture({
-			cwd: this.cwd,
-			serviceFactory: this.ServiceFactory(),
-			ui: this.ui,
-			apiClientFactory: this.getMercuryFixture().getApiClientFactory(),
-			featureInstaller: this.featureInstaller,
-			emitter: this.emitter,
-			...options,
-		})
-	}
-
-	protected static getMercuryFixture() {
-		if (!this.mercuryFixture) {
-			this.mercuryFixture = new MercuryFixture(this.cwd, this.ServiceFactory())
-		}
-
-		return this.mercuryFixture
-	}
-
-	protected static get people() {
-		if (!this.personFixture) {
-			this.personFixture = new PersonFixture(
-				this.getMercuryFixture().getApiClientFactory()
-			)
-		}
-
-		return this.personFixture
-	}
-
-	protected static getViewFixture() {
-		if (!this.viewFixture) {
-			const viewWriter = this.writers.Writer('view', { fileDescriptions: [] })
-			this.viewFixture = new ViewFixture(
-				this.cwd,
-				viewWriter,
-				this.Action('view', 'sync')
-			)
-		}
-
-		return this.viewFixture
-	}
-
-	protected static get writers() {
-		if (!this._writers) {
-			this._writers = this.WriterFactory()
-		}
-
-		return this._writers
-	}
-
-	private static WriterFactory() {
-		return new WriterFactory({
-			templates,
-			ui: this.ui,
-			settings: this.Service('settings'),
-		})
-	}
-
-	protected static async skipInstallSkillPrompts<
-		E extends () => Promise<FeatureActionResponse>,
-	>(
-		execute?: E
-	): Promise<E extends undefined ? undefined : FeatureActionResponse> {
-		const promise = execute?.()
-
-		await this.waitForInput()
-		await this.ui.sendInput('n')
-
-		await this.waitForInput()
-		await this.ui.sendInput('')
-
-		const results = await promise
-
-		return results as any
-	}
-
-	protected static getOrganizationFixture() {
-		if (!this.organizationFixture) {
-			this.organizationFixture = new OrganizationFixture(
-				this.people,
-				this.StoreFactory()
-			)
-		}
-
-		return this.organizationFixture
-	}
-
-	protected static getSkillFixture() {
-		if (!this.skillFixture) {
-			this.skillFixture = new SkillFixture(
-				this.people,
-				this.StoreFactory(),
-				this.getMercuryFixture().getApiClientFactory()
-			)
-		}
-
-		return this.skillFixture
-	}
-
-	protected static resolveHashSprucePath(...filePath: string[]) {
-		return diskUtil.resolveHashSprucePath(this.cwd, ...filePath)
-	}
-
-	protected static get featureInstaller() {
-		if (!this._featureInstaller) {
-			const installer = this.FeatureInstaller()
-			this._featureInstaller = installer
-		}
-
-		return this._featureInstaller
-	}
-
-	protected static set featureInstaller(installer: FeatureInstaller) {
-		this._featureInstaller = installer
-	}
-
-	protected static FeatureInstaller(options?: Partial<FeatureOptions>) {
-		const serviceFactory = this.ServiceFactory()
-		const storeFactory = this.StoreFactory(options)
-		const emitter = options?.emitter ?? this.emitter
-		const apiClientFactory = this.getMercuryFixture().getApiClientFactory()
-
-		const actionExecuter = this.ActionExecuter()
-
-		const installer = FeatureInstallerFactory.WithAllFeatures({
-			cwd: this.cwd,
-			serviceFactory,
-			storeFactory,
-			ui: this.ui,
-			emitter,
-			apiClientFactory,
-			actionExecuter,
-			...options,
-		})
-		return installer
-	}
-
-	protected static StoreFactory(options?: Partial<StoreFactoryOptions>) {
-		const serviceFactory = this.ServiceFactory()
-
-		return new StoreFactory({
-			cwd: this.cwd,
-			serviceFactory,
-			homeDir: this.homeDir,
-			apiClientFactory: this.getMercuryFixture().getApiClientFactory(),
-			emitter: this.emitter,
-			...options,
-		})
-	}
-
-	protected static Store<C extends StoreCode>(
-		code: C,
-		options?: CreateStoreOptions<C>
-	): StoreMap[C] {
-		return this.StoreFactory().Store(code, {
-			cwd: this.cwd,
-			...(options as any),
-		})
-	}
-
-	protected static async waitForInput() {
-		return this.ui.waitForInput()
-	}
-
-	protected static async assertIsFeatureInstalled(code: FeatureCode) {
-		const isInstalled = await this.featureInstaller.isInstalled(code)
-		assert.isTrue(isInstalled)
-	}
-
-	protected static async assertValidActionResponseFiles(
-		results: FeatureActionResponse
-	) {
-		for (const file of results.files ?? []) {
-			await this.assertFilePassesTypeChecks(file.path)
-		}
-
-		// await Promise.all(
-		// 	(results.files ?? []).map((file) => {
-		// 		const checker = this.Service('typeChecker')
-		// 		return checker.check(file.path)
-		// 	})
-		// )
-	}
-
-	protected static async assertFilePassesTypeChecks(file: string) {
-		const checker = this.Service('typeChecker')
-		await checker.check(file)
-	}
-
-	protected static async connectToApi(options?: ApiClientFactoryOptions) {
-		return this.getMercuryFixture().connectToApi(options)
-	}
-
-	protected static async openInVsCode(options?: {
-		file?: string
-		dir?: string
-		timeout?: number
-	}) {
-		await this.Action('vscode', 'setup').execute({ all: true })
-
-		await this.Service('command').execute(
-			`code ${options?.file ?? options?.dir ?? this.cwd}`
-		)
-		await this.wait(options?.timeout ?? 99999999)
-	}
-
-	protected static async openInFinder(options?: {
-		file?: string
-		dir?: string
-		timeout?: number
-	}) {
-		await this.Service('command').execute(
-			`open ${options?.file ?? options?.dir ?? this.cwd}`
-		)
-		await this.wait(options?.timeout ?? 99999999)
-	}
-
-	protected static log(...args: any[]) {
-		testUtil.log(...args)
-	}
-
-	protected static Action<
-		Action extends AbstractAction = AbstractAction,
-		F extends FeatureCode = FeatureCode,
-	>(featureCode: F, actionCode: string, options?: ExecuterOptions): Action {
-		const executer = this.ActionExecuter({
-			shouldThrowOnListenerError: true,
-			...options,
-		}).Action(featureCode, actionCode)
-
-		return executer as any
-	}
-
-	protected static ActionExecuter(options?: ExecuterOptions) {
-		const serviceFactory = this.ServiceFactory()
-
-		const actionFactory = new ActionFactory({
-			writerFactory: this.writers,
-			ui: this.ui,
-			emitter: this.emitter,
-			apiClientFactory: this.getMercuryFixture().getApiClientFactory(),
-			cwd: this.cwd,
-			serviceFactory,
-			storeFactory: this.StoreFactory(),
-			templates,
-			optionOverrides: {
-				'sync.schemas': {
-					shouldInstallMissingDependencies: true,
-				},
-				...options?.optionOverrides,
-			},
-		})
-
-		const executer = new ActionExecuter({
-			ui: this.ui,
-			emitter: this.emitter,
-			actionFactory,
-			featureInstallerFactory: () => {
-				return this.featureInstaller
-			},
-			shouldAutoHandleDependencies: false,
-			...options,
-		})
-
-		return executer
-	}
-
-	protected static selectOptionBasedOnLabel(label: string) {
-		const last = this.ui.getLastInvocation()
-		assert.doesInclude(last.options.options.choices, {
-			label,
-		})
-
-		const match = last.options.options.choices.find(
-			(o: any) => o.label === label
-		)
-
-		void this.ui.sendInput(`${match.value}`)
-	}
+        AuthService.homeDir = this.homeDir
+
+        this._emitter = undefined
+        this._featureInstaller = undefined
+
+        OnboardingStore.overrideCwd(diskUtil.createRandomTempDir())
+
+        this.ui.reset()
+        this.ui.invocations = []
+        this.ui.setCursorPosition({ x: 0, y: 0 })
+
+        this.clearFixtures()
+
+        ImportService.clearCache()
+        SkillStore.clearCurrentSkill()
+        EventStore.clearCache()
+        CommandService.clearFakedResponses()
+        MercuryClientFactory.reset()
+        MercuryClientFactory.setIsTestMode(false)
+
+        this.commandFaker = new CommandFaker()
+    }
+
+    protected static async afterEach() {
+        await super.afterEach()
+
+        await this.organizationFixture?.clearAllOrgs()
+        await this.mercuryFixture?.disconnectAll()
+
+        this.clearFixtures()
+
+        if (this._ui?.isWaitingForInput()) {
+            throw new Error(
+                `Terminal interface is waiting for input. Make sure you are invoking this.term.sendInput() as many times as needed.`
+            )
+        }
+
+        if (diskUtil.doesDirExist(this.cwd) && testUtil.shouldClearCache()) {
+            diskUtil.deleteDir(this.cwd)
+        }
+
+        if (
+            diskUtil.doesDirExist(this.homeDir) &&
+            testUtil.shouldClearCache()
+        ) {
+            diskUtil.deleteDir(this.homeDir)
+        }
+
+        if (testUtil.shouldCleanupAfterEach()) {
+            FeatureFixture.deleteOldSkillDirs()
+        }
+    }
+
+    protected static async afterAll() {
+        await super.afterAll()
+        if (testUtil.shouldCleanupAfterAll()) {
+            FeatureFixture.deleteOldSkillDirs()
+        }
+    }
+
+    private static async cleanTestDirsAndFiles() {
+        const pattern = this.resolveTestPath('**/*.d.ts')
+        const matches = await globby(pattern)
+
+        for (const match of matches) {
+            diskUtil.deleteFile(match)
+        }
+    }
+
+    private static clearFixtures() {
+        this._emitter = undefined
+        this.mercuryFixture = undefined
+        this.organizationFixture = undefined
+        this.personFixture = undefined
+        this.skillFixture = undefined
+        this.viewFixture = undefined
+    }
+
+    protected static freshTmpDir() {
+        const tmpDirectory = testUtil.resolveTestDir(uuid.v4())
+        fs.ensureDirSync(tmpDirectory)
+        return tmpDirectory
+    }
+
+    protected static get ui() {
+        if (!this._ui) {
+            this._ui = new SpyInterface()
+        }
+
+        return this._ui
+    }
+
+    protected static get emitter() {
+        if (!this._emitter) {
+            this._emitter = CliGlobalEmitter.Emitter()
+        }
+        return this._emitter
+    }
+
+    protected static set emitter(emitter: GlobalEmitter) {
+        this._emitter = emitter
+    }
+
+    protected static resolveTestPath(...pathAfterTestDirsAndFiles: string[]) {
+        return pathUtil.join(
+            this.cliRoot,
+            '__tests__',
+            'testDirsAndFiles',
+            ...pathAfterTestDirsAndFiles
+        )
+    }
+
+    protected static async Cli(options?: CliBootOptions) {
+        return this.FeatureFixture(options).Cli({
+            cwd: this.cwd,
+            homeDir: this.homeDir,
+            ...(options ?? {}),
+        })
+    }
+
+    protected static async linkLocalPackages() {
+        const fixture = this.FeatureFixture()
+        await fixture.linkLocalPackages()
+    }
+
+    protected static Service<S extends Service>(
+        type: S,
+        cwd?: string
+    ): ServiceMap[S] {
+        const sf = this.ServiceFactory()
+        return sf.Service(cwd ?? this.cwd, type)
+    }
+
+    protected static ServiceFactory() {
+        return new ServiceFactory()
+    }
+
+    protected static FeatureFixture(options?: Partial<FeatureFixtureOptions>) {
+        return new FeatureFixture({
+            cwd: this.cwd,
+            serviceFactory: this.ServiceFactory(),
+            ui: this.ui,
+            apiClientFactory: this.getMercuryFixture().getApiClientFactory(),
+            featureInstaller: this.featureInstaller,
+            emitter: this.emitter,
+            ...options,
+        })
+    }
+
+    protected static getMercuryFixture() {
+        if (!this.mercuryFixture) {
+            this.mercuryFixture = new MercuryFixture(
+                this.cwd,
+                this.ServiceFactory()
+            )
+        }
+
+        return this.mercuryFixture
+    }
+
+    protected static get people() {
+        if (!this.personFixture) {
+            this.personFixture = new PersonFixture(
+                this.getMercuryFixture().getApiClientFactory()
+            )
+        }
+
+        return this.personFixture
+    }
+
+    protected static getViewFixture() {
+        if (!this.viewFixture) {
+            const viewWriter = this.writers.Writer('view', {
+                fileDescriptions: [],
+            })
+            this.viewFixture = new ViewFixture(
+                this.cwd,
+                viewWriter,
+                this.Action('view', 'sync')
+            )
+        }
+
+        return this.viewFixture
+    }
+
+    protected static get writers() {
+        if (!this._writers) {
+            this._writers = this.WriterFactory()
+        }
+
+        return this._writers
+    }
+
+    private static WriterFactory() {
+        return new WriterFactory({
+            templates,
+            ui: this.ui,
+            settings: this.Service('settings'),
+        })
+    }
+
+    protected static async skipInstallSkillPrompts<
+        E extends () => Promise<FeatureActionResponse>,
+    >(
+        execute?: E
+    ): Promise<E extends undefined ? undefined : FeatureActionResponse> {
+        const promise = execute?.()
+
+        await this.waitForInput()
+        await this.ui.sendInput('n')
+
+        await this.waitForInput()
+        await this.ui.sendInput('')
+
+        const results = await promise
+
+        return results as any
+    }
+
+    protected static getOrganizationFixture() {
+        if (!this.organizationFixture) {
+            this.organizationFixture = new OrganizationFixture(
+                this.people,
+                this.StoreFactory()
+            )
+        }
+
+        return this.organizationFixture
+    }
+
+    protected static getSkillFixture() {
+        if (!this.skillFixture) {
+            this.skillFixture = new SkillFixture(
+                this.people,
+                this.StoreFactory(),
+                this.getMercuryFixture().getApiClientFactory()
+            )
+        }
+
+        return this.skillFixture
+    }
+
+    protected static resolveHashSprucePath(...filePath: string[]) {
+        return diskUtil.resolveHashSprucePath(this.cwd, ...filePath)
+    }
+
+    protected static get featureInstaller() {
+        if (!this._featureInstaller) {
+            const installer = this.FeatureInstaller()
+            this._featureInstaller = installer
+        }
+
+        return this._featureInstaller
+    }
+
+    protected static set featureInstaller(installer: FeatureInstaller) {
+        this._featureInstaller = installer
+    }
+
+    protected static FeatureInstaller(options?: Partial<FeatureOptions>) {
+        const serviceFactory = this.ServiceFactory()
+        const storeFactory = this.StoreFactory(options)
+        const emitter = options?.emitter ?? this.emitter
+        const apiClientFactory = this.getMercuryFixture().getApiClientFactory()
+
+        const actionExecuter = this.ActionExecuter()
+
+        const installer = FeatureInstallerFactory.WithAllFeatures({
+            cwd: this.cwd,
+            serviceFactory,
+            storeFactory,
+            ui: this.ui,
+            emitter,
+            apiClientFactory,
+            actionExecuter,
+            ...options,
+        })
+        return installer
+    }
+
+    protected static StoreFactory(options?: Partial<StoreFactoryOptions>) {
+        const serviceFactory = this.ServiceFactory()
+
+        return new StoreFactory({
+            cwd: this.cwd,
+            serviceFactory,
+            homeDir: this.homeDir,
+            apiClientFactory: this.getMercuryFixture().getApiClientFactory(),
+            emitter: this.emitter,
+            ...options,
+        })
+    }
+
+    protected static Store<C extends StoreCode>(
+        code: C,
+        options?: CreateStoreOptions<C>
+    ): StoreMap[C] {
+        return this.StoreFactory().Store(code, {
+            cwd: this.cwd,
+            ...(options as any),
+        })
+    }
+
+    protected static async waitForInput() {
+        return this.ui.waitForInput()
+    }
+
+    protected static async assertIsFeatureInstalled(code: FeatureCode) {
+        const isInstalled = await this.featureInstaller.isInstalled(code)
+        assert.isTrue(isInstalled)
+    }
+
+    protected static async assertValidActionResponseFiles(
+        results: FeatureActionResponse
+    ) {
+        for (const file of results.files ?? []) {
+            await this.assertFilePassesTypeChecks(file.path)
+        }
+
+        // await Promise.all(
+        // 	(results.files ?? []).map((file) => {
+        // 		const checker = this.Service('typeChecker')
+        // 		return checker.check(file.path)
+        // 	})
+        // )
+    }
+
+    protected static async assertFilePassesTypeChecks(file: string) {
+        const checker = this.Service('typeChecker')
+        await checker.check(file)
+    }
+
+    protected static async connectToApi(options?: ApiClientFactoryOptions) {
+        return this.getMercuryFixture().connectToApi(options)
+    }
+
+    protected static async openInVsCode(options?: {
+        file?: string
+        dir?: string
+        timeout?: number
+    }) {
+        await this.Action('vscode', 'setup').execute({ all: true })
+
+        await this.Service('command').execute(
+            `code ${options?.file ?? options?.dir ?? this.cwd}`
+        )
+        await this.wait(options?.timeout ?? 99999999)
+    }
+
+    protected static async openInFinder(options?: {
+        file?: string
+        dir?: string
+        timeout?: number
+    }) {
+        await this.Service('command').execute(
+            `open ${options?.file ?? options?.dir ?? this.cwd}`
+        )
+        await this.wait(options?.timeout ?? 99999999)
+    }
+
+    protected static log(...args: any[]) {
+        testUtil.log(...args)
+    }
+
+    protected static Action<
+        Action extends AbstractAction = AbstractAction,
+        F extends FeatureCode = FeatureCode,
+    >(featureCode: F, actionCode: string, options?: ExecuterOptions): Action {
+        const executer = this.ActionExecuter({
+            shouldThrowOnListenerError: true,
+            ...options,
+        }).Action(featureCode, actionCode)
+
+        return executer as any
+    }
+
+    protected static ActionExecuter(options?: ExecuterOptions) {
+        const serviceFactory = this.ServiceFactory()
+
+        const actionFactory = new ActionFactory({
+            writerFactory: this.writers,
+            ui: this.ui,
+            emitter: this.emitter,
+            apiClientFactory: this.getMercuryFixture().getApiClientFactory(),
+            cwd: this.cwd,
+            serviceFactory,
+            storeFactory: this.StoreFactory(),
+            templates,
+            optionOverrides: {
+                'sync.schemas': {
+                    shouldInstallMissingDependencies: true,
+                },
+                ...options?.optionOverrides,
+            },
+        })
+
+        const executer = new ActionExecuter({
+            ui: this.ui,
+            emitter: this.emitter,
+            actionFactory,
+            featureInstallerFactory: () => {
+                return this.featureInstaller
+            },
+            shouldAutoHandleDependencies: false,
+            ...options,
+        })
+
+        return executer
+    }
+
+    protected static selectOptionBasedOnLabel(label: string) {
+        const last = this.ui.getLastInvocation()
+        assert.doesInclude(last.options.options.choices, {
+            label,
+        })
+
+        const match = last.options.options.choices.find(
+            (o: any) => o.label === label
+        )
+
+        void this.ui.sendInput(`${match.value}`)
+    }
 }
 
 type ExecuterOptions = Partial<ActionExecuterOptions> & {
-	optionOverrides?: OptionOverrides
+    optionOverrides?: OptionOverrides
 }