fix: use workspace root as cwd for ECS

* Set cwd for ECS process

* use workspace root as default cwd for ECS

* add unit tests for DefaultProcessRunner

---------

Co-authored-by: Cezary Marcinik <cezary.marcinik@o2.pl>

Author: nsrosenqvist

src/core/ConfigLoader.ts

@@ -5,6 +5,7 @@ export interface EcsConfig {
   ecsPath: string;
   configPath: string;
   onSave: boolean;
+  workspaceRoot: string;
 }
 
 export class ConfigLoader {
@@ -14,9 +15,12 @@ export class ConfigLoader {
 
     const ecsPath = ConfigLoader.resolveEcsPath(workspaceFolder, config);
     const configPath = ConfigLoader.resolveConfigPath(workspaceFolder, config);
+
     const onSave = config.get<boolean>("onsave", false);
 
-    return { ecsPath, configPath, onSave };
+    const workspaceRoot = workspaceFolder;
+
+    return { ecsPath, configPath, onSave, workspaceRoot };
   }
 
   public static loadConfigForFile(resource: vscode.Uri): EcsConfig {
@@ -27,7 +31,9 @@ export class ConfigLoader {
     const configPath = ConfigLoader.resolveConfigPath(workspaceFolder, config);
     const onSave = config.get<boolean>("onsave", false);
 
-    return { ecsPath, configPath, onSave };
+    const workspaceRoot = workspaceFolder;
+
+    return { ecsPath, configPath, onSave, workspaceRoot };
   }
 
   private static resolvePath(
@@ -44,7 +50,6 @@ export class ConfigLoader {
     } else {
       filePath = path.join(workspaceFolder, defaultRelativePath);
     }
-
     return filePath;
   }
 
@@ -84,24 +89,23 @@ export class ConfigLoader {
 
     const activeEditor = vscode.window.activeTextEditor;
     if (activeEditor) {
-      const workspaceFolder = vscode.workspace.getWorkspaceFolder(
+      const folder = vscode.workspace.getWorkspaceFolder(
         activeEditor.document.uri
       );
-      if (workspaceFolder) {
-        return workspaceFolder.uri.fsPath;
+      if (folder) {
+        return folder.uri.fsPath;
       }
     }
 
     return workspaceFolders[0].uri.fsPath;
   }
 
   private static getWorkspaceFolderForFile(resource: vscode.Uri): string {
-    const workspaceFolder = vscode.workspace.getWorkspaceFolder(resource);
-    if (workspaceFolder) {
-      return workspaceFolder.uri.fsPath;
-    } else {
+    const folder = vscode.workspace.getWorkspaceFolder(resource);
+    if (!folder) {
       vscode.window.showErrorMessage("Workspace folder not found");
       throw new Error("Workspace folder not found");
     }
+    return folder.uri.fsPath;
   }
 }

src/core/EcsCommandRunner.ts

@@ -16,7 +16,8 @@ export class EcsCommandRunner {
       await this.processRunner.runEcsCheck(
         this.ecsConfig.ecsPath,
         this.ecsConfig.configPath,
-        tempFilePath
+        tempFilePath,
+        this.ecsConfig.workspaceRoot
       );
       const newContent = await this.fileHandler.readTempFile(tempFilePath);
       return newContent;
@@ -29,7 +30,8 @@ export class EcsCommandRunner {
     await this.processRunner.runEcsCheck(
       this.ecsConfig.ecsPath,
       this.ecsConfig.configPath,
-      filePath
+      filePath,
+      this.ecsConfig.workspaceRoot
     );
   }
 }

src/core/ProcessRunner.ts

@@ -4,38 +4,44 @@ export interface ProcessRunner {
   runEcsCheck(
     ecsPath: string,
     configPath: string,
-    targetPath: string
+    targetPath: string,
+    workspaceRoot: string
   ): Promise<void>;
 }
 
 export class DefaultProcessRunner implements ProcessRunner {
   runEcsCheck(
     ecsPath: string,
     configPath: string,
-    targetPath: string
+    targetPath: string,
+    workspaceRoot: string
   ): Promise<void> {
     return new Promise<void>((resolve, reject) => {
-      const process = spawn("php", [
-        ecsPath,
-        "check",
-        targetPath,
-        "--fix",
-        `--config=${configPath}`,
-        "--no-progress-bar",
-        "--quiet",
-      ]);
+      const processHandle = spawn(
+        "php",
+        [
+          ecsPath,
+          "check",
+          targetPath,
+          "--fix",
+          `--config=${configPath}`,
+          "--no-progress-bar",
+          "--quiet",
+        ],
+        { cwd: workspaceRoot }
+      );
 
       let stderrData = "";
 
-      process.stderr.on("data", (data) => {
+      processHandle.stderr.on("data", (data) => {
         stderrData += data.toString();
       });
 
-      process.on("error", (err) => {
+      processHandle.on("error", (err) => {
         reject(err);
       });
 
-      process.on("close", (code) => {
+      processHandle.on("close", (code) => {
         if (code === 0) {
           resolve();
         } else {

src/test/unit/core/EcsCommandRunner.test.ts

@@ -24,6 +24,7 @@ suite("EcsCommandRunner", () => {
       ecsPath: "/path/to/ecs",
       configPath: "/path/to/ecs.php",
       onSave: false,
+      workspaceRoot: "./",
     };
 
     tempFileProviderMock = sinon.createStubInstance(DefaultTempFileProvider);

src/test/unit/core/ProcessRunner.test.ts

@@ -0,0 +1,131 @@
+import * as assert from "assert";
+import * as sinon from "sinon";
+import { DefaultProcessRunner } from "../../../core/ProcessRunner";
+
+suite("DefaultProcessRunner", () => {
+  let spawnStub: sinon.SinonStub;
+
+  setup(() => {
+    spawnStub = sinon.stub(require("child_process"), "spawn");
+  });
+
+  teardown(() => {
+    sinon.restore();
+  });
+
+  test("should spawn php process with correct arguments and cwd", async () => {
+    const fakeChildProcess = {
+      stdout: { on: sinon.stub() },
+      stderr: { on: sinon.stub() },
+      on: sinon.stub(),
+    };
+    spawnStub.returns(fakeChildProcess);
+
+    fakeChildProcess.on.withArgs("close").yields(0);
+
+    const runner = new DefaultProcessRunner();
+
+    await runner.runEcsCheck(
+      "/path/to/ecs",
+      "/path/to/ecs.php",
+      "/some/target.php",
+      "/my/workspace/root"
+    );
+
+    assert.strictEqual(spawnStub.callCount, 1, "spawn should be called once");
+
+    const [command, args, options] = spawnStub.firstCall.args;
+
+    assert.strictEqual(command, "php", "Should call php");
+
+    assert.deepStrictEqual(
+      args,
+      [
+        "/path/to/ecs",
+        "check",
+        "/some/target.php",
+        "--fix",
+        "--config=/path/to/ecs.php",
+        "--no-progress-bar",
+        "--quiet",
+      ],
+      "Should pass correct arguments to ECS"
+    );
+
+    assert.strictEqual(
+      options.cwd,
+      "/my/workspace/root",
+      "Should use the workspaceRoot as cwd"
+    );
+  });
+
+  test("should resolve if exit code is 0", async () => {
+    const fakeChildProcess = {
+      stdout: { on: sinon.stub() },
+      stderr: { on: sinon.stub() },
+      on: sinon.stub(),
+    };
+    spawnStub.returns(fakeChildProcess);
+
+    fakeChildProcess.on.withArgs("close").yields(0);
+
+    const runner = new DefaultProcessRunner();
+    await assert.doesNotReject(
+      runner.runEcsCheck(
+        "/path/to/ecs",
+        "/path/to/ecs.php",
+        "file.php",
+        "/my/ws"
+      )
+    );
+  });
+
+  test("should reject if exit code is non-zero", async () => {
+    const fakeChildProcess = {
+      stdout: { on: sinon.stub() },
+      stderr: { on: sinon.stub() },
+      on: sinon.stub(),
+    };
+    spawnStub.returns(fakeChildProcess);
+
+    fakeChildProcess.on.withArgs("close").yields(1);
+
+    fakeChildProcess.stderr.on
+      .withArgs("data")
+      .callsArgWith(1, "Some ECS error");
+
+    const runner = new DefaultProcessRunner();
+    await assert.rejects(
+      runner.runEcsCheck(
+        "/path/to/ecs",
+        "/path/to/ecs.php",
+        "file.php",
+        "/my/ws"
+      ),
+      /ECS exited with code 1\nSome ECS error/
+    );
+  });
+
+  test("should reject on process error event", async () => {
+    const fakeChildProcess = {
+      stdout: { on: sinon.stub() },
+      stderr: { on: sinon.stub() },
+      on: sinon.stub(),
+    };
+    spawnStub.returns(fakeChildProcess);
+
+    const testError = new Error("Spawn error");
+    fakeChildProcess.on.withArgs("error").yields(testError);
+
+    const runner = new DefaultProcessRunner();
+    await assert.rejects(
+      runner.runEcsCheck(
+        "/path/to/ecs",
+        "/path/to/ecs.php",
+        "file.php",
+        "/my/ws"
+      ),
+      /Spawn error/
+    );
+  });
+});