Move database Item search methods into skeleton wizard

And the tests for it. We can now re-use the factory from the previous commit.

extensions/ql-vscode/src/local-databases.ts

@@ -897,31 +897,6 @@ export class DatabaseManager extends DisposableObject {
     }
   }
 
-  public async digForDatabaseItem(
-    language: string,
-    databaseNwo: string,
-  ): Promise<DatabaseItem | undefined> {
-    const dbItems = this.databaseItems || [];
-    const dbs = dbItems.filter(
-      (db) => db.language === language && db.name === databaseNwo,
-    );
-    if (dbs.length === 0) {
-      return undefined;
-    }
-    return dbs[0];
-  }
-
-  public async digForDatabaseWithSameLanguage(
-    language: string,
-  ): Promise<DatabaseItem | undefined> {
-    const dbItems = this.databaseItems || [];
-    const dbs = dbItems.filter((db) => db.language === language);
-    if (dbs.length === 0) {
-      return undefined;
-    }
-    return dbs[0];
-  }
-
   /**
    * Returns the index of the workspace folder that corresponds to the source archive of `item`
    * if there is one, and -1 otherwise.

extensions/ql-vscode/src/skeleton-query-wizard.ts

@@ -7,7 +7,7 @@ import { QueryLanguage } from "./common/query-language";
 import { askForLanguage, isFolderAlreadyInWorkspace } from "./helpers";
 import { getErrorMessage } from "./pure/helpers-pure";
 import { QlPackGenerator } from "./qlpack-generator";
-import { DatabaseManager } from "./local-databases";
+import { DatabaseItem, DatabaseManager } from "./local-databases";
 import * as databaseFetcher from "./databaseFetcher";
 import { ProgressCallback, UserCancellationException } from "./progress";
 
@@ -239,10 +239,10 @@ export class SkeletonQueryWizard {
 
     const databaseNwo = QUERY_LANGUAGE_TO_DATABASE_REPO[this.language];
 
-    // Check that we haven't already downloaded a database for this language
-    const existingDatabaseItem = await this.databaseManager.digForDatabaseItem(
+    const existingDatabaseItem = await this.digForDatabaseItem(
       this.language,
       databaseNwo,
+      this.databaseManager.databaseItems,
     );
 
     if (existingDatabaseItem) {
@@ -250,8 +250,9 @@ export class SkeletonQueryWizard {
       await this.databaseManager.setCurrentDatabaseItem(existingDatabaseItem);
     } else {
       const sameLanguageDatabaseItem =
-        await this.databaseManager.digForDatabaseWithSameLanguage(
+        await this.digForDatabaseWithSameLanguage(
           this.language,
+          this.databaseManager.databaseItems,
         );
 
       if (sameLanguageDatabaseItem) {
@@ -265,4 +266,31 @@ export class SkeletonQueryWizard {
       }
     }
   }
+
+  public async digForDatabaseItem(
+    language: string,
+    databaseNwo: string,
+    databaseItems: readonly DatabaseItem[],
+  ): Promise<DatabaseItem | undefined> {
+    const dbItems = databaseItems || [];
+    const dbs = dbItems.filter(
+      (db) => db.language === language && db.name === databaseNwo,
+    );
+    if (dbs.length === 0) {
+      return undefined;
+    }
+    return dbs[0];
+  }
+
+  public async digForDatabaseWithSameLanguage(
+    language: string,
+    databaseItems: readonly DatabaseItem[],
+  ): Promise<DatabaseItem | undefined> {
+    const dbItems = databaseItems || [];
+    const dbs = dbItems.filter((db) => db.language === language);
+    if (dbs.length === 0) {
+      return undefined;
+    }
+    return dbs[0];
+  }
 }

extensions/ql-vscode/test/vscode-tests/cli-integration/skeleton-query-wizard.test.ts

@@ -13,13 +13,19 @@ import { createFileSync, ensureDirSync, removeSync } from "fs-extra";
 import { join } from "path";
 import { CancellationTokenSource } from "vscode-jsonrpc";
 import { testCredentialsWithStub } from "../../factories/authentication";
-import { DatabaseItem, DatabaseManager } from "../../../src/local-databases";
+import {
+  DatabaseItem,
+  DatabaseManager,
+  FullDatabaseOptions,
+} from "../../../src/local-databases";
 import * as databaseFetcher from "../../../src/databaseFetcher";
+import { createMockDB } from "../../factories/databases/databases";
 
 jest.setTimeout(40_000);
 
 describe("SkeletonQueryWizard", () => {
   let wizard: SkeletonQueryWizard;
+  let mockDatabaseManager: DatabaseManager;
   let dir: tmp.DirResult;
   let storagePath: string;
   let quickPickSpy: jest.SpiedFunction<typeof window.showQuickPick>;
@@ -42,11 +48,6 @@ describe("SkeletonQueryWizard", () => {
   const token = new CancellationTokenSource().token;
   const credentials = testCredentialsWithStub();
   const chosenLanguage = "ruby";
-  const mockDatabaseManager = mockedObject<DatabaseManager>({
-    setCurrentDatabaseItem: jest.fn(),
-    digForDatabaseItem: jest.fn(),
-    digForDatabaseWithSameLanguage: jest.fn(),
-  });
   const mockCli = mockedObject<CodeQLCliServer>({
     resolveLanguages: jest
       .fn()
@@ -65,6 +66,11 @@ describe("SkeletonQueryWizard", () => {
   jest.spyOn(extLogger, "log").mockResolvedValue(undefined);
 
   beforeEach(async () => {
+    mockDatabaseManager = mockedObject<DatabaseManager>({
+      setCurrentDatabaseItem: jest.fn(),
+      databaseItems: [] as DatabaseItem[],
+    });
+
     dir = tmp.dirSync({
       prefix: "skeleton_query_wizard_",
       unsafeCleanup: true,
@@ -214,6 +220,7 @@ describe("SkeletonQueryWizard", () => {
     describe("if database is also already downloaded", () => {
       let databaseNwo: string;
       let databaseItem: DatabaseItem;
+      let mockDatabaseManagerWithItems: DatabaseManager;
 
       beforeEach(async () => {
         databaseNwo = QUERY_LANGUAGE_TO_DATABASE_REPO[chosenLanguage];
@@ -223,9 +230,19 @@ describe("SkeletonQueryWizard", () => {
           language: chosenLanguage,
         } as DatabaseItem;
 
-        jest
-          .spyOn(mockDatabaseManager, "digForDatabaseItem")
-          .mockResolvedValue([databaseItem] as any);
+        mockDatabaseManagerWithItems = mockedObject<DatabaseManager>({
+          setCurrentDatabaseItem: jest.fn(),
+          databaseItems: [databaseItem] as DatabaseItem[],
+        });
+
+        wizard = new SkeletonQueryWizard(
+          mockCli,
+          jest.fn(),
+          credentials,
+          extLogger,
+          mockDatabaseManagerWithItems,
+          token,
+        );
       });
 
       it("should not download a new database for language", async () => {
@@ -237,9 +254,9 @@ describe("SkeletonQueryWizard", () => {
       it("should select an existing database", async () => {
         await wizard.execute();
 
-        expect(mockDatabaseManager.setCurrentDatabaseItem).toHaveBeenCalledWith(
-          [databaseItem],
-        );
+        expect(
+          mockDatabaseManagerWithItems.setCurrentDatabaseItem,
+        ).toHaveBeenCalledWith(databaseItem);
       });
 
       it("should open the new query file", async () => {
@@ -254,12 +271,6 @@ describe("SkeletonQueryWizard", () => {
     });
 
     describe("if database is missing", () => {
-      beforeEach(async () => {
-        jest
-          .spyOn(mockDatabaseManager, "digForDatabaseItem")
-          .mockResolvedValue(undefined);
-      });
-
       describe("if the user choses to downloaded the suggested database from GitHub", () => {
         it("should download a new database for language", async () => {
           await wizard.execute();
@@ -335,4 +346,71 @@ describe("SkeletonQueryWizard", () => {
       });
     });
   });
+
+  describe("digForDatabaseItem", () => {
+    describe("when the item exists", () => {
+      it("should return the database item", async () => {
+        const mockDbItem = createMockDB(dir);
+        const mockDbItem2 = createMockDB(dir);
+
+        const databaseItem = await wizard.digForDatabaseItem(
+          mockDbItem.language,
+          mockDbItem.name,
+          [mockDbItem, mockDbItem2],
+        );
+
+        expect(databaseItem!.language).toEqual(mockDbItem.language);
+        expect(databaseItem!.name).toEqual(mockDbItem.name);
+      });
+    });
+
+    describe("when the item doesn't exist", () => {
+      it("should return nothing", async () => {
+        const mockDbItem = createMockDB(dir);
+        const mockDbItem2 = createMockDB(dir);
+
+        const databaseItem = await wizard.digForDatabaseItem(
+          "ruby",
+          "mock-database-name",
+          [mockDbItem, mockDbItem2],
+        );
+
+        expect(databaseItem).toBeUndefined();
+      });
+    });
+  });
+
+  describe("digForDatabaseWithSameLanguage", () => {
+    describe("when the item exists", () => {
+      it("should return the database item", async () => {
+        const mockDbItem = createMockDB(dir, {
+          language: "ruby",
+        } as FullDatabaseOptions);
+        const mockDbItem2 = createMockDB(dir, {
+          language: "javascript",
+        } as FullDatabaseOptions);
+
+        const databaseItem = await wizard.digForDatabaseWithSameLanguage(
+          "ruby",
+          [mockDbItem, mockDbItem2],
+        );
+
+        expect(databaseItem).toEqual(mockDbItem);
+      });
+    });
+
+    describe("when the item doesn't exist", () => {
+      it("should return nothing", async () => {
+        const mockDbItem = createMockDB(dir);
+        const mockDbItem2 = createMockDB(dir);
+
+        const databaseItem = await wizard.digForDatabaseWithSameLanguage(
+          "ruby",
+          [mockDbItem, mockDbItem2],
+        );
+
+        expect(databaseItem).toBeUndefined();
+      });
+    });
+  });
 });

extensions/ql-vscode/test/vscode-tests/minimal-workspace/local-databases.test.ts

@@ -800,37 +800,4 @@ describe("local databases", () => {
       });
     });
   });
-
-  describe("digForDatabaseItem", () => {
-    describe("when the item exists", () => {
-      it("should return the database item", async () => {
-        const mockDbItem = createMockDB();
-
-        await (databaseManager as any).addDatabaseItem(
-          {} as ProgressCallback,
-          {} as CancellationToken,
-          mockDbItem,
-        );
-
-        const databaseItem = await databaseManager.digForDatabaseItem(
-          mockDbItem.language,
-          mockDbItem.name,
-        );
-
-        expect(databaseItem!.language).toEqual(mockDbItem.language);
-        expect(databaseItem!.name).toEqual(mockDbItem.name);
-      });
-    });
-
-    describe("when the item doesn't exist", () => {
-      it("should return nothing", async () => {
-        const databaseItem = await databaseManager.digForDatabaseItem(
-          "ruby",
-          "mock-database-name",
-        );
-
-        expect(databaseItem).toBeUndefined();
-      });
-    });
-  });
 });