Automatic settings reload and test executable detection (#28)

* Update settings to homogeneously identify the extension as cpputestTestAdapter

* Automatically reload settings

* Update tests

Author: jgonzalezdr

README.md

@@ -8,14 +8,14 @@ This is the implementation for a [CppUTest](https://cpputest.github.io/) Test Ad
 
 ## Setup
 
-To let this plugin know where your tests are set the ```cpputestExplorer.testExecutable``` to the executable of your tests. They are separated by semicolon and support wildcards, so you can add as many executables as you want:
+To let this plugin know where your tests are set the ```cpputestTestAdapter.testExecutable``` to the executable of your tests. They are separated by semicolon and support wildcards, so you can add as many executables as you want:
 ```
 {
-  "cpputestExplorer.testExecutable": "${workspaceFolder}/test/testrunner;${workspaceFolder}/test/subFolder/ut_*",
-  "cpputestExplorer.testExecutablePath": "${workspaceFolder}/test"
+  "cpputestTestAdapter.testExecutable": "${workspaceFolder}/test/testrunner;${workspaceFolder}/test/subFolder/ut_*",
+  "cpputestTestAdapter.testExecutablePath": "${workspaceFolder}/test"
 }
 ```
-They will be executed in the ```cpputestExplorer.testExecutablePath``` path.
+They will be executed in the ```cpputestTestAdapter.testExecutablePath``` path.
 
 If you want to use the debugging functions you will also need to setup a launch.json file with your debugger path and arguments etc. The adapter will take care of the rest. Hopefully.
 

package.json

@@ -68,27 +68,27 @@
   "contributes": {
     "configuration": {
       "type": "object",
-      "title": "CppUTest Explorer configuration",
+      "title": "CppUTest Test Adapter",
       "properties": {
-        "cpputestExplorer.testExecutable": {
-          "description": "executable that contains all tests. Can be multiple executables separated by semicolon. Wildcard is supported (e.g. myExecutable;bin/test/ut_*)",
+        "cpputestTestAdapter.testExecutable": {
+          "description": "Executable that contains all tests. Can be multiple executables separated by semicolon. Wildcard is supported (e.g. myExecutable;bin/test/ut_*)",
           "default": "",
           "type": "string",
           "scope": "resource"
         },
-        "cpputestExplorer.testExecutablePath": {
-          "description": "path where the executable should be run in",
+        "cpputestTestAdapter.testExecutablePath": {
+          "description": "Path where the executable should be run in",
           "default": "",
           "type": "string",
           "scope": "resource"
         },
-        "cpputestExplorer.logpanel": {
-          "description": "write diagnotic logs to an output panel",
+        "cpputestTestAdapter.logpanel": {
+          "description": "Write diagnostic logs to an output panel",
           "type": "boolean",
           "scope": "resource"
         },
-        "cpputestExplorer.logfile": {
-          "description": "write diagnostic logs to the given file",
+        "cpputestTestAdapter.logfile": {
+          "description": "Write diagnostic logs to the given file",
           "type": "string",
           "scope": "resource"
         }

src/Domain/CppUTestContainer.ts

@@ -25,15 +25,16 @@ export default class CppUTestContainer {
     this.onTestStartHandler = handler;
   }
 
-  constructor(runners: ExecutableRunner[], settingsProvider: SettingsProvider, vscodeAdapter: VscodeAdapter, resultParser: ResultParser) {
+  constructor(settingsProvider: SettingsProvider, vscodeAdapter: VscodeAdapter, resultParser: ResultParser) {
     this.settingsProvider = settingsProvider;
-    this.runners = runners;
+    this.runners = [];
     this.vscodeAdapter = vscodeAdapter;
     this.resultParser = resultParser;
     this.suites = new Map<string, CppUTestSuite>();
   }
 
-  public LoadTests(): Promise<CppUTestSuite[]> {
+  public LoadTests(runners: ExecutableRunner[]): Promise<CppUTestSuite[]> {
+    this.runners = runners;
     return Promise.all(this.runners
       .map(runner => runner.GetTestList()
         .then(testString => this.UpdateTestSuite(runner, testString))

src/Infrastructure/VscodeSettingsProvider.ts

@@ -3,24 +3,28 @@ import { glob } from 'glob';
 import { SettingsProvider } from './SettingsProvider';
 
 export default class VscodeSettingsProvider implements SettingsProvider {
-  private readonly Executables: string;
-  private readonly ExecutablePath: string;
+  private config: vscode.WorkspaceConfiguration;
 
-  constructor(config: vscode.WorkspaceConfiguration) {
-    this.Executables = config.testExecutable;
-    this.ExecutablePath = config.testExecutablePath;
+  constructor() {
+    const configSection = "cpputestTestAdapter";
+    this.config = vscode.workspace.getConfiguration(configSection);
+    vscode.workspace.onDidChangeConfiguration(event => {
+      if (event.affectsConfiguration(configSection)) {
+        this.config = vscode.workspace.getConfiguration(configSection);
+      }
+    })
   }
 
   GetWorkspaceFolders(): readonly vscode.WorkspaceFolder[] | undefined {
     return vscode.workspace.workspaceFolders;
   }
 
   public GetTestRunners(): string[] {
-    return this.SplitRunners(this.Executables);
+    return this.SplitRunners(this.config.testExecutable);
   }
 
   public GetTestPath(): string {
-    return this.ResolveSettingsVariable(this.ExecutablePath);
+    return this.ResolveSettingsVariable(this.config.testExecutablePath);
   }
 
 

src/adapter.ts

@@ -12,6 +12,8 @@ import VscodeSettingsProvider from "./Infrastructure/VscodeSettingsProvider";
 import ExecutableRunner from "./Infrastructure/ExecutableRunner";
 import { NodeProcessExecuter } from './Application/NodeProcessExecuter';
 import { VscodeAdapterImplementation } from "./Application/VscodeAdapterImplementation";
+import { SettingsProvider } from "./Infrastructure/SettingsProvider";
+import { ProcessExecuter } from "./Application/ProcessExecuter";
 
 export class CppUTestAdapter implements TestAdapter {
 
@@ -22,7 +24,8 @@ export class CppUTestAdapter implements TestAdapter {
 	private readonly autorunEmitter = new vscode.EventEmitter<RetireEvent>();
 	private readonly mainSuite: CppUTestGroup;
 	private readonly root: CppUTestContainer;
-
+	private readonly settingsProvider: SettingsProvider;
+	private readonly processExecuter: ProcessExecuter;
 
 	get tests(): vscode.Event<TestLoadStartedEvent | TestLoadFinishedEvent> { return this.testsEmitter.event; }
 	get testStates(): vscode.Event<TestRunStartedEvent | TestRunFinishedEvent | TestSuiteEvent | TestEvent> { return this.testStatesEmitter.event; }
@@ -37,13 +40,12 @@ export class CppUTestAdapter implements TestAdapter {
 
 		this.disposables.push(this.testsEmitter, this.testStatesEmitter, this.autorunEmitter);
 
-		const settingsProvider = new VscodeSettingsProvider(vscode.workspace.getConfiguration("cpputestExplorer"));
-		const processExecuter = new NodeProcessExecuter();
+		this.settingsProvider = new VscodeSettingsProvider();
+		this.processExecuter = new NodeProcessExecuter();
 		const vscodeAdapter = new VscodeAdapterImplementation();
-		const runners = settingsProvider.GetTestRunners().map(runner => new ExecutableRunner(processExecuter, runner));
 		const resultParser = new RegexResultParser();
 
-		this.root = new CppUTestContainer(runners, settingsProvider, vscodeAdapter, resultParser);
+		this.root = new CppUTestContainer(this.settingsProvider, vscodeAdapter, resultParser);
 		this.root.OnTestFinish = this.handleTestFinished.bind(this);
 		this.root.OnTestStart = this.handleTestStarted.bind(this);
 
@@ -61,13 +63,9 @@ export class CppUTestAdapter implements TestAdapter {
 		this.testsEmitter.fire(<TestLoadStartedEvent>{ type: 'started' });
 		this.log.info('Loading tests');
 
-		this.root.ClearTests();
-		const loadedTests = await this.root.LoadTests();
+		await this.updateTests();
 
 		this.log.info('Tests loaded');
-
-		this.mainSuite.children = loadedTests;
-		this.testsEmitter.fire(<TestLoadFinishedEvent>{ type: 'finished', suite: this.mainSuite });
 	}
 
 	public async run(tests: string[]): Promise<void> {
@@ -103,7 +101,8 @@ export class CppUTestAdapter implements TestAdapter {
 
 	private async updateTests(): Promise<void> {
 		this.root.ClearTests();
-		const loadedTests = await this.root.LoadTests();
+		const runners = this.settingsProvider.GetTestRunners().map(runner => new ExecutableRunner(this.processExecuter, runner));
+		const loadedTests = await this.root.LoadTests(runners);
 		this.mainSuite.children = loadedTests;
 		this.testsEmitter.fire(<TestLoadFinishedEvent>{ type: 'finished', suite: this.mainSuite });
 	}

src/main.ts

@@ -8,8 +8,8 @@ export async function activate(context: vscode.ExtensionContext) {
 	const workspaceFolder = (vscode.workspace.workspaceFolders || [])[0];
 
 	// create a simple logger that can be configured with the configuration variables
-	// `cpputestExplorer.logpanel"` and `cpputestExplorer.logfile`
-	const log = new Log('cpputestExplorer', workspaceFolder, 'CppUTest Explorer Log');
+	// `cpputestTestAdapter.logToOutputPanel"` and `cpputestTestAdapter.logToFile`
+	const log = new Log('cpputestTestAdapter', workspaceFolder, 'CppUTest Test Adapter Log');
 	context.subscriptions.push(log);
 
 	// get the Test Explorer extension