Move functions into class so they can be mocked

We'd like to add test coverage for the openDatabase function (which is
public).

At the moment, this relies on `resolveDatabaseContents` which is just
a standalone function.

This means we're unable to mock it using Jest.

So let's move it into its own class.

This method in turn depends on a `resolveDatabase` function, which we've
also moved into the new class.

The only usages I could find for there functions were from within
the `databases.ts` file.

extensions/ql-vscode/src/databases.ts

@@ -154,67 +154,69 @@ export async function findSourceArchive(
   return undefined;
 }
 
-async function resolveDatabase(
-  databasePath: string,
-): Promise<DatabaseContents> {
-  const name = basename(databasePath);
-
-  // Look for dataset and source archive.
-  const datasetUri = await findDataset(databasePath);
-  const sourceArchiveUri = await findSourceArchive(databasePath);
-
-  return {
-    kind: DatabaseKind.Database,
-    name,
-    datasetUri,
-    sourceArchiveUri,
-  };
-}
-
 /** Gets the relative paths of all `.dbscheme` files in the given directory. */
 async function getDbSchemeFiles(dbDirectory: string): Promise<string[]> {
   return await glob("*.dbscheme", { cwd: dbDirectory });
 }
 
-async function resolveDatabaseContents(
+export class DatabaseResolver {
-  uri: vscode.Uri,
+  public static async resolveDatabaseContents(
-): Promise<DatabaseContents> {
+    uri: vscode.Uri,
-  if (uri.scheme !== "file") {
+  ): Promise<DatabaseContents> {
-    throw new Error(
+    if (uri.scheme !== "file") {
-      `Database URI scheme '${uri.scheme}' not supported; only 'file' URIs are supported.`,
+      throw new Error(
-    );
+        `Database URI scheme '${uri.scheme}' not supported; only 'file' URIs are supported.`,
-  }
+      );
-  const databasePath = uri.fsPath;
+    }
-  if (!(await pathExists(databasePath))) {
+    const databasePath = uri.fsPath;
-    throw new InvalidDatabaseError(
+    if (!(await pathExists(databasePath))) {
-      `Database '${databasePath}' does not exist.`,
+      throw new InvalidDatabaseError(
-    );
+        `Database '${databasePath}' does not exist.`,
+      );
+    }
+
+    const contents = await this.resolveDatabase(databasePath);
+
+    if (contents === undefined) {
+      throw new InvalidDatabaseError(
+        `'${databasePath}' is not a valid database.`,
+      );
+    }
+
+    // Look for a single dbscheme file within the database.
+    // This should be found in the dataset directory, regardless of the form of database.
+    const dbPath = contents.datasetUri.fsPath;
+    const dbSchemeFiles = await getDbSchemeFiles(dbPath);
+    if (dbSchemeFiles.length === 0) {
+      throw new InvalidDatabaseError(
+        `Database '${databasePath}' does not contain a CodeQL dbscheme under '${dbPath}'.`,
+      );
+    } else if (dbSchemeFiles.length > 1) {
+      throw new InvalidDatabaseError(
+        `Database '${databasePath}' contains multiple CodeQL dbschemes under '${dbPath}'.`,
+      );
+    } else {
+      contents.dbSchemeUri = vscode.Uri.file(resolve(dbPath, dbSchemeFiles[0]));
+    }
+    return contents;
   }
 
-  const contents = await resolveDatabase(databasePath);
+  public static async resolveDatabase(
+    databasePath: string,
+  ): Promise<DatabaseContents> {
+    const name = basename(databasePath);
 
-  if (contents === undefined) {
+    // Look for dataset and source archive.
-    throw new InvalidDatabaseError(
+    const datasetUri = await findDataset(databasePath);
-      `'${databasePath}' is not a valid database.`,
+    const sourceArchiveUri = await findSourceArchive(databasePath);
-    );
-  }
 
-  // Look for a single dbscheme file within the database.
+    return {
-  // This should be found in the dataset directory, regardless of the form of database.
+      kind: DatabaseKind.Database,
-  const dbPath = contents.datasetUri.fsPath;
+      name,
-  const dbSchemeFiles = await getDbSchemeFiles(dbPath);
+      datasetUri,
-  if (dbSchemeFiles.length === 0) {
+      sourceArchiveUri,
-    throw new InvalidDatabaseError(
+    };
-      `Database '${databasePath}' does not contain a CodeQL dbscheme under '${dbPath}'.`,
-    );
-  } else if (dbSchemeFiles.length > 1) {
-    throw new InvalidDatabaseError(
-      `Database '${databasePath}' contains multiple CodeQL dbschemes under '${dbPath}'.`,
-    );
-  } else {
-    contents.dbSchemeUri = vscode.Uri.file(resolve(dbPath, dbSchemeFiles[0]));
   }
-  return contents;
 }
 
 /** An item in the list of available databases */
@@ -370,7 +372,9 @@ export class DatabaseItemImpl implements DatabaseItem {
   public async refresh(): Promise<void> {
     try {
       try {
-        this._contents = await resolveDatabaseContents(this.databaseUri);
+        this._contents = await DatabaseResolver.resolveDatabaseContents(
+          this.databaseUri,
+        );
         this._error = undefined;
       } catch (e) {
         this._contents = undefined;
@@ -602,7 +606,7 @@ export class DatabaseManager extends DisposableObject {
     uri: vscode.Uri,
     displayName?: string,
   ): Promise<DatabaseItem> {
-    const contents = await resolveDatabaseContents(uri);
+    const contents = await DatabaseResolver.resolveDatabaseContents(uri);
     // Ignore the source archive for QLTest databases by default.
     const isQLTestDatabase = extname(uri.fsPath) === ".testproj";
     const fullOptions: FullDatabaseOptions = {