Extra debug logging

Author: award999

src/tasks/SwiftPluginTaskProvider.ts

@@ -99,10 +99,11 @@ export class SwiftPluginTaskProvider implements vscode.TaskProvider {
             task.scope ?? vscode.TaskScope.Workspace,
             task.name,
             "swift-plugin",
-            new SwiftExecution(swift, swiftArgs, {
-                cwd,
-                presentation: task.presentationOptions,
-            }),
+            task.execution ??
+                new SwiftExecution(swift, swiftArgs, {
+                    cwd,
+                    presentation: task.presentationOptions,
+                }),
             task.problemMatchers
         );
         newTask.detail = task.detail ?? `swift ${swiftArgs.join(" ")}`;

test/integration-tests/tasks/SwiftPluginTaskProvider.test.ts

@@ -28,6 +28,7 @@ import {
     cleanOutput,
     executeTaskAndWaitForResult,
     waitForEndTaskProcess,
+    waitForNoRunningTasks,
 } from "../../utilities/tasks";
 import { mutable } from "../../utilities/types";
 import { SwiftExecution } from "../../../src/tasks/SwiftExecution";
@@ -165,6 +166,7 @@ suite("SwiftPluginTaskProvider Test Suite", function () {
         suite(name, () => {
             let resetSettings: (() => Promise<void>) | undefined;
             beforeEach(async function () {
+                await waitForNoRunningTasks();
                 resetSettings = await updateSettings(settings);
             });
 
@@ -198,21 +200,18 @@ suite("SwiftPluginTaskProvider Test Suite", function () {
         suite("createSwiftPluginTask", () => {
             let taskProvider: SwiftPluginTaskProvider;
 
-            setup(() => {
+            beforeEach(async () => {
                 taskProvider = workspaceContext.pluginProvider;
+                await waitForNoRunningTasks();
             });
 
             test("Exit code on success", async () => {
-                const task = taskProvider.createSwiftPluginTask(
-                    folderContext.swiftPackage.plugins[0],
-                    folderContext.toolchain,
-                    {
-                        cwd: folderContext.folder,
-                        scope: folderContext.workspaceFolder,
-                    }
-                );
+                const task = (
+                    await vscode.tasks.fetchTasks({ type: "swift-plugin " })
+                )[0] as SwiftTask;
                 const { exitCode, output } = await executeTaskAndWaitForResult(task);
-                expect(exitCode).to.equal(0);
+                expect(exitCode, output).to.equal(0);
+                console.log("output: " + output);
                 expect(cleanOutput(output)).to.include("Hello, World!");
             });
 

test/integration-tests/ui/ProjectPanelProvider.test.ts

@@ -35,6 +35,7 @@ import { WorkspaceContext } from "../../../src/WorkspaceContext";
 import { Version } from "../../../src/utilities/version";
 import { wait } from "../../../src/utilities/utilities";
 import { SwiftOutputChannel } from "../../../src/ui/SwiftOutputChannel";
+import { Commands } from "../../../src/commands";
 
 suite("ProjectPanelProvider Test Suite", function () {
     let workspaceContext: WorkspaceContext;
@@ -189,7 +190,10 @@ suite("ProjectPanelProvider Test Suite", function () {
                     return snippet;
                 }
             );
-            const result = await vscode.commands.executeCommand("swift.runSnippet", snippet?.name);
+            const result = await vscode.commands.executeCommand(
+                Commands.RUN_SNIPPET,
+                snippet?.name
+            );
             expect(result).to.be.true;
         });
     });

test/utilities/tasks.ts

@@ -37,14 +37,20 @@ export async function executeTaskAndWaitForResult(
     fixture: SwiftTaskFixture | SwiftTask
 ): Promise<{ exitCode?: number; output: string }> {
     const task = "task" in fixture ? fixture.task : fixture;
-    const exitPromise = waitForEndTaskProcess(task);
     const endPromise = waitForEndTask(task);
-    vscode.tasks.executeTask(task);
-    return await new Promise(res =>
+    const promise = new Promise<{ exitCode?: number; output: string }>(res =>
         vscode.tasks.onDidStartTask(async ({ execution }) => {
-            let output = "";
             const runningTask = execution.task as SwiftTask;
+            if (task.detail !== runningTask.detail) {
+                return;
+            }
+            let output = "";
             const disposables = [runningTask.execution.onDidWrite(e => (output += e))];
+            const exitPromise = new Promise<number>(res => {
+                disposables.push(
+                    runningTask.execution.onDidClose(e => res(typeof e === "number" ? e : -1))
+                );
+            });
             const exitCode = await exitPromise;
             await endPromise;
             await new Promise(r => setTimeout(r, 500));
@@ -55,7 +61,57 @@ export async function executeTaskAndWaitForResult(
             });
         })
     );
+    await vscode.tasks.executeTask(task);
+    return await promise;
 }
+// export async function executeTaskAndWaitForResult(
+//     fixture: SwiftTaskFixture | SwiftTask,
+//     expectOutput: boolean = true
+// ): Promise<{ exitCode?: number; output: string }> {
+//     const task = "task" in fixture ? fixture.task : fixture;
+//     // const exitPromise = waitForEndTaskProcess(task);
+//     const writePromise = expectOutput ? waitForWrite(task.execution) : Promise.resolve();
+//     writePromise;
+//     const promise: Promise<{ exitCode?: number; output: string }> = new Promise(
+//         res =>
+//             vscode.tasks.onDidEndTaskProcess(async e => {
+//                 const runningTask = e.execution.task as SwiftTask;
+//                 if (runningTask.detail !== task.detail) {
+//                     return;
+//                 }
+//                 res({
+//                     output: runningTask.execution.swiftProcess.getOutput(),
+//                     exitCode: e.exitCode,
+//                 });
+//             })
+//         // vscode.tasks.onDidStartTask(async ({ execution }) => {
+//         // let output = "";
+//         // const runningTask = execution.task as SwiftTask;
+//         // if (runningTask.detail !== task.detail) {
+//         //     return;
+//         // }
+//         // const runningWritePromise = expectOutput
+//         //     ? waitForWrite(runningTask.execution)
+//         //     : Promise.resolve();
+//         // const runningExitPromise = waitForEndTaskProcess(runningTask);
+//         // const disposables = [
+//         //     runningTask.execution.onDidWrite(e => {
+//         //         output += e;
+//         //         console.log("onDidWrite: " + e);
+//         //     }),
+//         // ];
+//         // const exitCode = await Promise.race([exitPromise, runningExitPromise]);
+//         // await Promise.race([writePromise, runningWritePromise]);
+//         //     disposables.forEach(d => d.dispose());
+//         //     res({
+//         //         output,
+//         //         exitCode,
+//         //     });
+//         // })
+//     );
+//     await vscode.tasks.executeTask(task);
+//     return await promise;
+// }
 
 /**
  * Wait for the writeable fixture to write some output
@@ -65,8 +121,9 @@ export async function executeTaskAndWaitForResult(
  */
 export async function waitForWrite(fixture: { onDidWrite: vscode.Event<string> }): Promise<string> {
     return new Promise<string>(res => {
-        const disposable = fixture.onDidWrite(e => {
-            disposable.dispose();
+        let disposable: vscode.Disposable | undefined = undefined;
+        disposable = fixture.onDidWrite(e => {
+            disposable?.dispose();
             res(e);
         });
     });