|
| 1 | +import * as path from 'path'; |
| 2 | +import * as vscode from 'vscode'; |
| 3 | +import type { AspireEditorCommandProvider } from '../editor/AspireEditorCommandProvider'; |
| 4 | +import { |
| 5 | + addIntegrationTestProjectUnavailable, |
| 6 | + addIntegrationTestProjectUnsupported, |
| 7 | + noAppHostInWorkspace, |
| 8 | +} from '../loc/strings'; |
| 9 | +import { aspireTestAppHostCapability, type CapabilityStatus } from '../types/configInfo'; |
| 10 | +import { AspireTerminalProvider, shellArg } from '../utils/AspireTerminalProvider'; |
| 11 | +import { ConfigInfoProvider } from '../utils/configInfoProvider'; |
| 12 | +import { extensionLogOutputChannel } from '../utils/logging'; |
| 13 | +import { getCliPathTargetForUri, type CliPathResolutionTarget } from '../utils/cliPathVariables'; |
| 14 | + |
| 15 | +export const addIntegrationTestProjectSupportedContext = 'aspire.addIntegrationTestProjectSupported'; |
| 16 | + |
| 17 | +interface AspireTestAppHostCapabilityOptions { |
| 18 | + readonly cancellationToken?: vscode.CancellationToken; |
| 19 | + readonly forceRefresh?: boolean; |
| 20 | +} |
| 21 | + |
| 22 | +export type AddIntegrationTestProjectRefreshSubscription = |
| 23 | + (listener: () => void) => vscode.Disposable; |
| 24 | + |
| 25 | +export async function getAspireTestAppHostCapabilityStatus( |
| 26 | + configInfoProvider: ConfigInfoProvider, |
| 27 | + cliPath: string, |
| 28 | + target: CliPathResolutionTarget, |
| 29 | + options?: AspireTestAppHostCapabilityOptions, |
| 30 | +): Promise<CapabilityStatus> { |
| 31 | + return await configInfoProvider.getCapabilityStatus( |
| 32 | + aspireTestAppHostCapability, |
| 33 | + { |
| 34 | + cliPath, |
| 35 | + target, |
| 36 | + cancellationToken: options?.cancellationToken, |
| 37 | + forceRefresh: options?.forceRefresh, |
| 38 | + suppressErrors: true, |
| 39 | + }); |
| 40 | +} |
| 41 | + |
| 42 | +export class AddIntegrationTestProjectAvailability implements vscode.Disposable { |
| 43 | + private _refreshGeneration = 0; |
| 44 | + private _refreshCancellation: vscode.CancellationTokenSource | undefined; |
| 45 | + private _disposed = false; |
| 46 | + private readonly _refreshSubscription: vscode.Disposable; |
| 47 | + |
| 48 | + constructor( |
| 49 | + private readonly _editorCommandProvider: AspireEditorCommandProvider, |
| 50 | + private readonly _terminalProvider: AspireTerminalProvider, |
| 51 | + private readonly _configInfoProvider: ConfigInfoProvider, |
| 52 | + subscribeToRefresh: AddIntegrationTestProjectRefreshSubscription, |
| 53 | + ) { |
| 54 | + this._refreshSubscription = subscribeToRefresh(() => void this.refresh()); |
| 55 | + } |
| 56 | + |
| 57 | + async refresh(): Promise<void> { |
| 58 | + const generation = ++this._refreshGeneration; |
| 59 | + this._refreshCancellation?.cancel(); |
| 60 | + this._refreshCancellation?.dispose(); |
| 61 | + const cancellation = new vscode.CancellationTokenSource(); |
| 62 | + this._refreshCancellation = cancellation; |
| 63 | + |
| 64 | + await this._publish(false, generation); |
| 65 | + if (this._isStale(generation)) { |
| 66 | + return; |
| 67 | + } |
| 68 | + |
| 69 | + try { |
| 70 | + const appHostPath = await this._editorCommandProvider.getAppHostPath(); |
| 71 | + if (!appHostPath |
| 72 | + || path.extname(appHostPath).toLowerCase() !== '.csproj' |
| 73 | + || this._isStale(generation)) { |
| 74 | + return; |
| 75 | + } |
| 76 | + |
| 77 | + const target = getCliPathTargetForUri(vscode.Uri.file(appHostPath)); |
| 78 | + const cliPath = await this._terminalProvider.getAspireCliExecutablePath(target); |
| 79 | + if (this._isStale(generation)) { |
| 80 | + return; |
| 81 | + } |
| 82 | + |
| 83 | + const capabilityStatus = await getAspireTestAppHostCapabilityStatus( |
| 84 | + this._configInfoProvider, |
| 85 | + cliPath, |
| 86 | + target, |
| 87 | + { cancellationToken: cancellation.token }); |
| 88 | + await this._publish(capabilityStatus === 'supported', generation); |
| 89 | + } |
| 90 | + catch (error) { |
| 91 | + if (!cancellation.token.isCancellationRequested && !this._isStale(generation)) { |
| 92 | + extensionLogOutputChannel.warn(`Unable to determine integration test scaffolding availability: ${String(error)}`); |
| 93 | + } |
| 94 | + } |
| 95 | + finally { |
| 96 | + if (this._refreshCancellation === cancellation) { |
| 97 | + this._refreshCancellation = undefined; |
| 98 | + } |
| 99 | + cancellation.dispose(); |
| 100 | + } |
| 101 | + } |
| 102 | + |
| 103 | + dispose(): void { |
| 104 | + this._disposed = true; |
| 105 | + this._refreshGeneration++; |
| 106 | + this._refreshCancellation?.cancel(); |
| 107 | + this._refreshCancellation?.dispose(); |
| 108 | + this._refreshCancellation = undefined; |
| 109 | + this._refreshSubscription.dispose(); |
| 110 | + void vscode.commands.executeCommand('setContext', addIntegrationTestProjectSupportedContext, false); |
| 111 | + } |
| 112 | + |
| 113 | + private _isStale(generation: number): boolean { |
| 114 | + return this._disposed || generation !== this._refreshGeneration; |
| 115 | + } |
| 116 | + |
| 117 | + private async _publish(supported: boolean, generation: number): Promise<void> { |
| 118 | + if (this._isStale(generation)) { |
| 119 | + return; |
| 120 | + } |
| 121 | + |
| 122 | + await vscode.commands.executeCommand( |
| 123 | + 'setContext', |
| 124 | + addIntegrationTestProjectSupportedContext, |
| 125 | + supported); |
| 126 | + } |
| 127 | +} |
| 128 | + |
| 129 | +export async function addIntegrationTestProject( |
| 130 | + editorCommandProvider: AspireEditorCommandProvider, |
| 131 | + terminalProvider: AspireTerminalProvider, |
| 132 | + configInfoProvider: ConfigInfoProvider, |
| 133 | +): Promise<void> { |
| 134 | + const appHostPath = await editorCommandProvider.getAppHostPath(); |
| 135 | + if (!appHostPath) { |
| 136 | + await vscode.window.showErrorMessage(noAppHostInWorkspace); |
| 137 | + return; |
| 138 | + } |
| 139 | + |
| 140 | + const target = getCliPathTargetForUri(vscode.Uri.file(appHostPath)); |
| 141 | + let cliPath: string; |
| 142 | + try { |
| 143 | + cliPath = await terminalProvider.getAspireCliExecutablePath(target); |
| 144 | + } catch (error) { |
| 145 | + extensionLogOutputChannel.warn(`Unable to resolve the Aspire CLI for integration test scaffolding: ${String(error)}`); |
| 146 | + await vscode.window.showErrorMessage(addIntegrationTestProjectUnavailable); |
| 147 | + return; |
| 148 | + } |
| 149 | + |
| 150 | + const capabilityStatus = await getAspireTestAppHostCapabilityStatus( |
| 151 | + configInfoProvider, |
| 152 | + cliPath, |
| 153 | + target, |
| 154 | + { forceRefresh: true }); |
| 155 | + if (capabilityStatus === 'unsupported') { |
| 156 | + await vscode.window.showErrorMessage(addIntegrationTestProjectUnsupported); |
| 157 | + return; |
| 158 | + } |
| 159 | + if (capabilityStatus === 'unavailable') { |
| 160 | + await vscode.window.showErrorMessage(addIntegrationTestProjectUnavailable); |
| 161 | + return; |
| 162 | + } |
| 163 | + |
| 164 | + await terminalProvider.sendAspireCommandToAspireTerminal( |
| 165 | + ['new', 'aspire-test', '--apphost', shellArg(appHostPath)], |
| 166 | + true, |
| 167 | + undefined, |
| 168 | + { cliPath, target }); |
| 169 | +} |
0 commit comments