Fixup SwiftPackage tests, less coupling in task queue

Author: plemarquand

src/FolderContext.ts

@@ -58,7 +58,12 @@ export class FolderContext implements vscode.Disposable {
     ) {
         this.packageWatcher = new PackageWatcher(this, workspaceContext.logger);
         this.backgroundCompilation = new BackgroundCompilation(this);
-        this.taskQueue = new TaskQueue(this);
+        this.taskQueue = new TaskQueue(
+            workspaceContext.tasks,
+            workspaceContext.statusItem,
+            workspaceContext.logger,
+            this.name
+        );
         this.testRunManager = new TestRunManager();
 
         // In order to track down why a FolderContext may be created when we don't want one,

src/SwiftPackage.ts

@@ -266,16 +266,17 @@ export class SwiftPackage {
     public async loadPackageState(
         folderContext: FolderContext,
         disableSwiftPMIntegration: boolean = false
-    ): Promise<void> {
+    ): Promise<SwiftPackageState> {
         // When SwiftPM integration is disabled, return empty package structure
         if (disableSwiftPMIntegration) {
-            this.contentsResolve({
+            const empty = {
                 name: path.basename(folderContext.folder.fsPath),
                 products: [],
                 dependencies: [],
                 targets: [],
-            });
-            return;
+            };
+            this.contentsResolve(empty);
+            return empty;
         }
 
         try {
@@ -290,26 +291,21 @@ export class SwiftPackage {
             };
 
             this.contentsResolve(packageState);
-        } catch (error) {
-            const execError = error as { stderr: string };
+            return packageState;
+        } catch (error: unknown) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
             // if caught error and it begins with "error: root manifest" then there is no Package.swift
             if (
-                execError.stderr !== undefined &&
-                (execError.stderr.startsWith("error: root manifest") ||
-                    execError.stderr.startsWith("error: Could not find Package.swift"))
+                errorMessage.startsWith("error: root manifest") ||
+                errorMessage.startsWith("error: Could not find Package.swift")
             ) {
-                this.contentsResolve({
-                    name: path.basename(folderContext.folder.fsPath),
-                    products: [],
-                    dependencies: [],
-                    targets: [],
-                });
-                return;
+                this.contentsResolve(undefined);
+                return undefined;
             } else {
                 // otherwise it is an error loading the Package.swift so return `null` indicating
-                // we have a package but we failed to load it
-                this.contentsReject(Error(getErrorDescription(error)));
-                return;
+                // we have a package but we failed to load it. Calling resolve instead of reject is intent
+                this.contentsResolve(Error(getErrorDescription(error)));
+                return undefined;
             }
         }
     }
@@ -393,7 +389,12 @@ export class SwiftPackage {
         });
         this.contentsResolve = res!;
         this.contentsReject = rej!;
-        await this.loadPackageState(folderContext, disableSwiftPMIntegration);
+        const loadedContents = await this.loadPackageState(
+            folderContext,
+            disableSwiftPMIntegration
+        );
+
+        this._contents = loadedContents;
     }
 
     /** Reload Package.resolved file */

src/commands/dependencies/common.ts

@@ -67,13 +67,18 @@ export async function executeSwiftPackageCommand<T>(
     const success = await executeTaskWithUI(task, config.uiMessage, folderContext, false);
     updateAfterError(success, folderContext);
 
-    const stdout = outputChunks.join("");
-    if (!stdout.trim()) {
+    const output = outputChunks.join("");
+
+    if (!success) {
+        throw new Error(output);
+    }
+
+    if (!output.trim()) {
         throw new Error(`No output received from swift ${config.commandName} command`);
     }
 
     try {
-        const trimmedOutput = SwiftPackage.trimStdout(stdout);
+        const trimmedOutput = SwiftPackage.trimStdout(output);
         const parsedOutput = JSON.parse(trimmedOutput);
 
         // Validate the parsed output is an object

src/tasks/TaskQueue.ts

@@ -14,8 +14,10 @@
 import * as vscode from "vscode";
 
 import { FolderContext } from "../FolderContext";
-import { WorkspaceContext } from "../WorkspaceContext";
+import { SwiftLogger } from "../logging/SwiftLogger";
+import { StatusItem } from "../ui/StatusItem";
 import { execSwift, poll } from "../utilities/utilities";
+import { TaskManager } from "./TaskManager";
 
 export interface SwiftOperationOptions {
     // Should I show a status item
@@ -39,7 +41,8 @@ export interface SwiftOperation {
     isBuildOperation: boolean;
     // run operation
     run(
-        workspaceContext: WorkspaceContext,
+        taskManager: TaskManager,
+        logger: SwiftLogger,
         token: vscode.CancellationToken | undefined
     ): Promise<number | undefined>;
 }
@@ -82,14 +85,15 @@ export class TaskOperation implements SwiftOperation {
     }
 
     run(
-        workspaceContext: WorkspaceContext,
+        taskManager: TaskManager,
+        logger: SwiftLogger,
         token?: vscode.CancellationToken
     ): Promise<number | undefined> {
         if (token?.isCancellationRequested) {
             return Promise.resolve(undefined);
         }
-        workspaceContext.logger.info(`Exec Task: ${this.task.detail ?? this.task.name}`);
-        return workspaceContext.tasks.executeTaskAndWait(this.task, token);
+        logger.info(`Exec Task: ${this.task.detail ?? this.task.name}`);
+        return taskManager.executeTaskAndWait(this.task, token);
     }
 }
 
@@ -153,8 +157,8 @@ class QueuedOperation {
         public token?: vscode.CancellationToken
     ) {}
 
-    run(workspaceContext: WorkspaceContext): Promise<number | undefined> {
-        return this.operation.run(workspaceContext, this.token);
+    run(taskManager: TaskManager, logger: SwiftLogger): Promise<number | undefined> {
+        return this.operation.run(taskManager, logger, this.token);
     }
 }
 
@@ -164,17 +168,16 @@ class QueuedOperation {
  * Queue swift task operations to be executed serially
  */
 export class TaskQueue implements vscode.Disposable {
-    queue: QueuedOperation[];
+    queue: QueuedOperation[] = [];
     activeOperation?: QueuedOperation;
-    workspaceContext: WorkspaceContext;
-    disabled: boolean;
+    disabled: boolean = false;
 
-    constructor(private folderContext: FolderContext) {
-        this.queue = [];
-        this.workspaceContext = folderContext.workspaceContext;
-        this.activeOperation = undefined;
-        this.disabled = false;
-    }
+    constructor(
+        private taskManager: TaskManager,
+        private statusItem: StatusItem,
+        private logger: SwiftLogger,
+        private name: string
+    ) {}
 
     dispose() {
         this.queue = [];
@@ -244,34 +247,25 @@ export class TaskQueue implements vscode.Disposable {
                 this.activeOperation = operation;
                 // show active task status item
                 if (operation.showStatusItem === true) {
-                    this.workspaceContext.statusItem.start(operation.operation.statusItemId);
+                    this.statusItem.start(operation.operation.statusItemId);
                 }
                 // wait while queue is disabled before running task
                 await this.waitWhileDisabled();
                 // log start
                 if (operation.log) {
-                    this.workspaceContext.logger.info(
-                        `${operation.log}: starting ... `,
-                        this.folderContext.name
-                    );
+                    this.logger.info(`${operation.log}: starting ... `, this.name);
                 }
                 operation
-                    .run(this.workspaceContext)
+                    .run(this.taskManager, this.logger)
                     .then(result => {
                         // log result
                         if (operation.log && !operation.token?.isCancellationRequested) {
                             switch (result) {
                                 case 0:
-                                    this.workspaceContext.logger.info(
-                                        `${operation.log}: ... done.`,
-                                        this.folderContext.name
-                                    );
+                                    this.logger.info(`${operation.log}: ... done.`, this.name);
                                     break;
                                 default:
-                                    this.workspaceContext.logger.error(
-                                        `${operation.log}: ... failed.`,
-                                        this.folderContext.name
-                                    );
+                                    this.logger.error(`${operation.log}: ... failed.`, this.name);
                                     break;
                             }
                         }
@@ -280,10 +274,7 @@ export class TaskQueue implements vscode.Disposable {
                     .catch(error => {
                         // log error
                         if (operation.log) {
-                            this.workspaceContext.logger.error(
-                                `${operation.log}: ${error}`,
-                                this.folderContext.name
-                            );
+                            this.logger.error(`${operation.log}: ${error}`, this.name);
                         }
                         this.finishTask(operation, { fail: error });
                     });
@@ -294,7 +285,7 @@ export class TaskQueue implements vscode.Disposable {
     private finishTask(operation: QueuedOperation, result: TaskQueueResult) {
         operation.cb(result);
         if (operation.showStatusItem === true) {
-            this.workspaceContext.statusItem.end(operation.operation.statusItemId);
+            this.statusItem.end(operation.operation.statusItemId);
         }
         this.activeOperation = undefined;
         void this.processQueue();