Fix/test executable path (#76)

* README.md: Update test executable settings description for clarity

adapter.ts: Use test path from settings for working directory in execution options

* Add tests for workingDirectory option in ExecutableRunner and testExecutablePath resolution in SettingsProvider

* The expression testPath || undefined is redundant. If testPath is falsy (empty string, null, undefined), it will already be falsy and can be used directly. Simply use workingDirectory: testPath instead.

Author: h1day

README.md

@@ -17,7 +17,10 @@ To let this plugin know where your tests are set the ```cpputestTestAdapter.test
   "cpputestTestAdapter.testExecutablePath": "${workspaceFolder}/test"
 }
 ```
-They will be executed in the ```cpputestTestAdapter.testExecutablePath``` path.
+
+Both settings support the ```${workspaceFolder}``` variable. The ```testExecutablePath``` determines the working directory:
+- If set, all test executables will be run from this directory
+- If not set, each test executable will be run from its own directory (the directory containing the executable)
 
 To arrange for a task to be run prior to running tests or refreshing the test list, set ```cpputestTestAdapter.preLaunchTask``` to the name of a task from tasks.json. This can be used to rebuild the test executable, for example.
 

src/adapter.ts

@@ -145,9 +145,10 @@ export class CppUTestAdapter implements TestAdapter {
 	}
 
 	private GetExecutionOptions(): ExecutableRunnerOptions | undefined {
+		const testPath = this.settingsProvider.GetTestPath();
 		return {
 			objDumpExecutable: this.settingsProvider.GetObjDumpPath(),
-			workingDirectory: undefined // this is calculated inside the ExecutableRunner, not really good style
+			workingDirectory: testPath
 		}
 	}
 

tests/ExecutableRunner.spec.ts

@@ -164,6 +164,70 @@ describe("ExecutableRunner should", () => {
     runner.KillProcess();
     verify(mockedExecuter.KillProcess()).called();
   })
+
+  describe("workingDirectory option", () => {
+    it("should use provided workingDirectory option", async () => {
+      const log = mock<Log>();
+      const mockedExecuter = mock<ProcessExecuter>();
+      const customWorkingDir = "/custom/working/directory";
+      let capturedOptions: any;
+
+      when(mockedExecuter.ExecFile(anything(), anything(), anything(), anything()))
+        .thenCall((cmd: string, args: any, options: any, callback: Function) => {
+          capturedOptions = options;
+          callback(undefined, "output", "");
+        });
+
+      const executer = instance(mockedExecuter);
+      const runner = new ExecutableRunner(executer, "/path/to/test.exe", log, 
+        { workingDirectory: customWorkingDir });
+
+      await runner.GetTestList(TestLocationFetchMode.Disabled);
+
+      expect(capturedOptions.cwd).to.equal(customWorkingDir);
+    });
+
+    it("should use executable directory when workingDirectory not provided", async () => {
+      const log = mock<Log>();
+      const mockedExecuter = mock<ProcessExecuter>();
+      const executablePath = "/path/to/test.exe";
+      let capturedOptions: any;
+
+      when(mockedExecuter.ExecFile(anything(), anything(), anything(), anything()))
+        .thenCall((cmd: string, args: any, options: any, callback: Function) => {
+          capturedOptions = options;
+          callback(undefined, "output", "");
+        });
+
+      const executer = instance(mockedExecuter);
+      const runner = new ExecutableRunner(executer, executablePath, log);
+
+      await runner.GetTestList(TestLocationFetchMode.Disabled);
+
+      expect(capturedOptions.cwd).to.equal("/path/to");
+    });
+
+    it("should use workingDirectory for test execution", async () => {
+      const log = mock<Log>();
+      const mockedExecuter = mock<ProcessExecuter>();
+      const customWorkingDir = "/custom/test/directory";
+      let capturedOptions: any;
+
+      when(mockedExecuter.ExecFile(anything(), anything(), anything(), anything()))
+        .thenCall((cmd: string, args: any, options: any, callback: Function) => {
+          capturedOptions = options;
+          callback(undefined, ".", "");
+        });
+
+      const executer = instance(mockedExecuter);
+      const runner = new ExecutableRunner(executer, "/path/to/test.exe", log, 
+        { workingDirectory: customWorkingDir });
+
+      await runner.RunTest("TestGroup", "TestName");
+
+      expect(capturedOptions.cwd).to.equal(customWorkingDir);
+    });
+  });
 })
 
 function setupMockCalls(error: ExecException | undefined, returnValue: string, errorValue: string) {

tests/SettingsProvider.spec.ts

@@ -135,4 +135,37 @@ describe("SettingsProvider should", () => {
         const actualPath = settingsProvider.GetTestRunners()
         expect(actualPath).to.have.members(expectedPath);
     })
+
+    describe("testExecutablePath variable resolution", () => {
+        it("should resolve ${workspaceFolder} in testExecutablePath", () => {
+            const logger = mock<Log>();
+            config.testExecutablePath = "${workspaceFolder}/test";
+            const expectedPath = "myFolder/test";
+
+            const settingsProvider = new TestSettingsProvider(logger, config, filesToFind);
+
+            const actualPath = settingsProvider.GetTestPath();
+            expect(actualPath).to.equal(expectedPath);
+        });
+
+        it("should return empty string when testExecutablePath is empty", () => {
+            const logger = mock<Log>();
+            config.testExecutablePath = "";
+
+            const settingsProvider = new TestSettingsProvider(logger, config, filesToFind);
+
+            const actualPath = settingsProvider.GetTestPath();
+            expect(actualPath).to.equal("");
+        });
+
+        it("should return string as-is when no variables present", () => {
+            const logger = mock<Log>();
+            config.testExecutablePath = "/absolute/path/test";
+
+            const settingsProvider = new TestSettingsProvider(logger, config, filesToFind);
+
+            const actualPath = settingsProvider.GetTestPath();
+            expect(actualPath).to.equal("/absolute/path/test");
+        });
+    });
 });