Add new class and helper for setting test config values

This class will be used to set test config values for the tests. It is
able to set the config value to a specified value for every test and
restore the value to the original value after the test.

Author: koesie10

extensions/ql-vscode/src/config.ts

@@ -332,7 +332,7 @@ const REMOTE_QUERIES_SETTING = new Setting('variantAnalysis', ROOT_SETTING);
  * This setting should be a JSON object where each key is a user-specified name (string),
  * and the value is an array of GitHub repositories (of the form `<owner>/<repo>`).
  */
-const REMOTE_REPO_LISTS = new Setting('repositoryLists', REMOTE_QUERIES_SETTING);
+export const REMOTE_REPO_LISTS = new Setting('repositoryLists', REMOTE_QUERIES_SETTING);
 
 export function getRemoteRepositoryLists(): Record<string, string[]> | undefined {
   return REMOTE_REPO_LISTS.getValue<Record<string, string[]>>() || undefined;
@@ -363,7 +363,7 @@ export function getRemoteRepositoryListsPath(): string | undefined {
  *
  * This setting should be a GitHub repository of the form `<owner>/<repo>`.
  */
-const REMOTE_CONTROLLER_REPO = new Setting('controllerRepo', REMOTE_QUERIES_SETTING);
+export const REMOTE_CONTROLLER_REPO = new Setting('controllerRepo', REMOTE_QUERIES_SETTING);
 
 export function getRemoteControllerRepo(): string | undefined {
   return REMOTE_CONTROLLER_REPO.getValue<string>() || undefined;

extensions/ql-vscode/src/vscode-tests/index-template.ts

@@ -3,6 +3,7 @@ import * as Mocha from 'mocha';
 import * as glob from 'glob-promise';
 import { ensureCli } from './ensureCli';
 import { env } from 'vscode';
+import { testConfigHelper } from './test-config';
 
 
 // Use this handler to avoid swallowing unhandled rejections.
@@ -69,6 +70,9 @@ export async function runTestsInDirectory(testsRoot: string, useCli = false): Pr
       mocha.addFile(path.resolve(testsRoot, f));
     });
 
+  // Setup the config helper. This needs to run before other helpers so any config they setup
+  // is restored.
+  await testConfigHelper(mocha);
 
   // Add helpers. Helper files add global setup and teardown blocks
   // for a test run.

extensions/ql-vscode/src/vscode-tests/test-config.ts

@@ -0,0 +1,93 @@
+import { ConfigurationTarget, workspace } from 'vscode';
+import { CUSTOM_CODEQL_PATH_SETTING, REMOTE_CONTROLLER_REPO, REMOTE_REPO_LISTS, Setting } from '../config';
+
+class TestSetting<T> {
+  private settingState: {
+    globalValue?: T;
+    workspaceValue?: T,
+    workspaceFolderValue?: T,
+  } | undefined;
+
+  constructor(
+    public readonly setting: Setting,
+    private initialTestValue: T | undefined = undefined
+  ) { }
+
+  public async get(): Promise<T | undefined> {
+    return this.section.get(this.setting.name);
+  }
+
+  public async set(value: T | undefined, target: ConfigurationTarget = ConfigurationTarget.Global): Promise<void> {
+    await this.section.update(this.setting.name, value, target);
+  }
+
+  public async setInitialTestValue(value: T | undefined) {
+    this.initialTestValue = value;
+  }
+
+  public async initialSetup() {
+    this.settingState = this.section.inspect(this.setting.name);
+
+    // Unfortunately it's not well-documented how to check whether we can write to a workspace
+    // configuration. This is the best I could come up with. It only fails for initial test values
+    // which are not undefined.
+    if (this.settingState?.workspaceValue !== undefined) {
+      await this.set(this.initialTestValue, ConfigurationTarget.Workspace);
+    }
+    if (this.settingState?.workspaceFolderValue !== undefined) {
+      await this.set(this.initialTestValue, ConfigurationTarget.WorkspaceFolder);
+    }
+
+    await this.setup();
+  }
+
+  public async setup() {
+    await this.set(this.initialTestValue, ConfigurationTarget.Global);
+  }
+
+  public async restoreToInitialValues() {
+    const state = this.section.inspect(this.setting.name);
+
+    // We need to check the state of the setting before we restore it. This is less important for the global
+    // configuration target, but the workspace/workspace folder configuration might not even exist. If they
+    // don't exist, VSCode will error when trying to write the new value (even if that value is undefined).
+    if (state?.globalValue !== this.settingState?.globalValue) {
+      await this.set(this.settingState?.globalValue, ConfigurationTarget.Global);
+    }
+    if (state?.workspaceValue !== this.settingState?.workspaceValue) {
+      await this.set(this.settingState?.workspaceValue, ConfigurationTarget.Workspace);
+    }
+    if (state?.workspaceFolderValue !== this.settingState?.workspaceFolderValue) {
+      await this.set(this.settingState?.workspaceFolderValue, ConfigurationTarget.WorkspaceFolder);
+    }
+  }
+
+  private get section() {
+    if (this.setting.parent === undefined) {
+      throw new Error('Cannot get the value of a root setting.');
+    }
+    return workspace.getConfiguration(this.setting.parent.qualifiedName);
+  }
+}
+
+export const testConfig = {
+  remoteControllerRepo: new TestSetting<string>(REMOTE_CONTROLLER_REPO),
+  remoteRepoLists: new TestSetting<Record<string, string[]>>(REMOTE_REPO_LISTS),
+  cliExecutablePath: new TestSetting<string>(CUSTOM_CODEQL_PATH_SETTING),
+};
+
+export const testConfigHelper = async (mocha: Mocha) => {
+  // Read in all current settings
+  await Promise.all(Object.values(testConfig).map(setting => setting.initialSetup()));
+
+  mocha.rootHooks({
+    async beforeEach() {
+      // Reset the settings to their initial values before each test
+      await Promise.all(Object.values(testConfig).map(setting => setting.setup()));
+    },
+    async afterAll() {
+      // Restore all settings to their default values after each test suite
+      await Promise.all(Object.values(testConfig).map(setting => setting.restoreToInitialValues()));
+    }
+  });
+};