Create new file and copy paste tests

This commit is contained in:
Nora
2023-01-18 10:07:52 +00:00
parent 6c523db0ad
commit 5b6587cc18
2 changed files with 445 additions and 391 deletions

View File

@@ -0,0 +1,444 @@
import { TreeItemCollapsibleState, ThemeIcon } from "vscode";
import { join } from "path";
import { ensureDir, remove, writeJson } from "fs-extra";
import { DbConfig } from "../../../../src/databases/config/db-config";
import { DbManager } from "../../../../src/databases/db-manager";
import { DbConfigStore } from "../../../../src/databases/config/db-config-store";
import { DbTreeDataProvider } from "../../../../src/databases/ui/db-tree-data-provider";
import {
DbItemKind,
LocalDatabaseDbItem,
} from "../../../../src/databases/db-item";
import { DbTreeViewItem } from "../../../../src/databases/ui/db-tree-view-item";
import { ExtensionApp } from "../../../../src/common/vscode/vscode-app";
import { createMockExtensionContext } from "../../../factories/extension-context";
import { createDbConfig } from "../../../factories/db-config-factories";
describe("db panel rendering nodes", () => {
const workspaceStoragePath = join(__dirname, "test-workspace-storage");
const globalStoragePath = join(__dirname, "test-global-storage");
const extensionPath = join(__dirname, "../../../../");
const dbConfigFilePath = join(
workspaceStoragePath,
DbConfigStore.databaseConfigFileName,
);
let dbTreeDataProvider: DbTreeDataProvider;
let dbManager: DbManager;
let dbConfigStore: DbConfigStore;
beforeAll(async () => {
const extensionContext = createMockExtensionContext({
extensionPath,
globalStoragePath,
workspaceStoragePath,
});
await ensureDir(workspaceStoragePath);
const app = new ExtensionApp(extensionContext);
dbConfigStore = new DbConfigStore(app, false);
dbManager = new DbManager(app, dbConfigStore);
});
beforeEach(async () => {
await ensureDir(workspaceStoragePath);
});
afterEach(async () => {
await remove(workspaceStoragePath);
});
it("should render default local and remote nodes when the config is empty", async () => {
const dbConfig: DbConfig = createDbConfig();
await saveDbConfig(dbConfig);
const dbTreeItems = await dbTreeDataProvider.getChildren();
expect(dbTreeItems).toBeTruthy();
const items = dbTreeItems!;
expect(items.length).toBe(2);
const remoteRootNode = items[0];
expect(remoteRootNode.dbItem).toBeTruthy();
expect(remoteRootNode.dbItem?.kind).toBe(DbItemKind.RootRemote);
expect(remoteRootNode.label).toBe("remote");
expect(remoteRootNode.tooltip).toBe("Remote databases");
expect(remoteRootNode.collapsibleState).toBe(
TreeItemCollapsibleState.Collapsed,
);
expect(remoteRootNode.children).toBeTruthy();
expect(remoteRootNode.children.length).toBe(3);
const systemDefinedListItems = remoteRootNode.children.filter(
(item) => item.dbItem?.kind === DbItemKind.RemoteSystemDefinedList,
);
expect(systemDefinedListItems.length).toBe(3);
checkRemoteSystemDefinedListItem(systemDefinedListItems[0], 10);
checkRemoteSystemDefinedListItem(systemDefinedListItems[1], 100);
checkRemoteSystemDefinedListItem(systemDefinedListItems[2], 1000);
const localRootNode = items[1];
expect(localRootNode.dbItem).toBeTruthy();
expect(localRootNode.dbItem?.kind).toBe(DbItemKind.RootLocal);
expect(localRootNode.label).toBe("local");
expect(localRootNode.tooltip).toBe("Local databases");
expect(localRootNode.collapsibleState).toBe(
TreeItemCollapsibleState.Collapsed,
);
expect(localRootNode.children).toBeTruthy();
expect(localRootNode.children.length).toBe(0);
});
it("should render remote repository list nodes", async () => {
const dbConfig: DbConfig = createDbConfig({
remoteLists: [
{
name: "my-list-1",
repositories: ["owner1/repo1", "owner1/repo2"],
},
{
name: "my-list-2",
repositories: ["owner1/repo1", "owner2/repo1", "owner2/repo2"],
},
],
});
await saveDbConfig(dbConfig);
const dbTreeItems = await dbTreeDataProvider.getChildren();
expect(dbTreeItems).toBeTruthy();
const items = dbTreeItems!;
expect(items.length).toBe(2);
const remoteRootNode = items[0];
expect(remoteRootNode.dbItem).toBeTruthy();
expect(remoteRootNode.collapsibleState).toBe(
TreeItemCollapsibleState.Collapsed,
);
expect(remoteRootNode.children).toBeTruthy();
expect(remoteRootNode.children.length).toBe(5);
const systemDefinedListItems = remoteRootNode.children.filter(
(item) => item.dbItem?.kind === DbItemKind.RemoteSystemDefinedList,
);
expect(systemDefinedListItems.length).toBe(3);
const userDefinedListItems = remoteRootNode.children.filter(
(item) => item.dbItem?.kind === DbItemKind.VariantAnalysisUserDefinedList,
);
expect(userDefinedListItems.length).toBe(2);
checkUserDefinedListItem(userDefinedListItems[0], "my-list-1", [
"owner1/repo1",
"owner1/repo2",
]);
checkUserDefinedListItem(userDefinedListItems[1], "my-list-2", [
"owner1/repo1",
"owner2/repo1",
"owner2/repo2",
]);
});
it("should render owner list nodes", async () => {
const dbConfig: DbConfig = createDbConfig({
remoteOwners: ["owner1", "owner2"],
});
await saveDbConfig(dbConfig);
const dbTreeItems = await dbTreeDataProvider.getChildren();
expect(dbTreeItems).toBeTruthy();
const items = dbTreeItems!;
expect(items.length).toBe(2);
const remoteRootNode = items[0];
expect(remoteRootNode.dbItem).toBeTruthy();
expect(remoteRootNode.collapsibleState).toBe(
TreeItemCollapsibleState.Collapsed,
);
expect(remoteRootNode.children).toBeTruthy();
expect(remoteRootNode.children.length).toBe(5);
const ownerListItems = remoteRootNode.children.filter(
(item) => item.dbItem?.kind === DbItemKind.RemoteOwner,
);
expect(ownerListItems.length).toBe(2);
checkOwnerItem(ownerListItems[0], "owner1");
checkOwnerItem(ownerListItems[1], "owner2");
});
it("should render repository nodes", async () => {
const dbConfig: DbConfig = createDbConfig({
remoteRepos: ["owner1/repo1", "owner1/repo2"],
});
await saveDbConfig(dbConfig);
const dbTreeItems = await dbTreeDataProvider.getChildren();
expect(dbTreeItems).toBeTruthy();
const items = dbTreeItems!;
expect(items.length).toBe(2);
const remoteRootNode = items[0];
expect(remoteRootNode.dbItem).toBeTruthy();
expect(remoteRootNode.collapsibleState).toBe(
TreeItemCollapsibleState.Collapsed,
);
expect(remoteRootNode.children).toBeTruthy();
expect(remoteRootNode.children.length).toBe(5);
const repoItems = remoteRootNode.children.filter(
(item) => item.dbItem?.kind === DbItemKind.RemoteRepo,
);
expect(repoItems.length).toBe(2);
checkRemoteRepoItem(repoItems[0], "owner1/repo1");
checkRemoteRepoItem(repoItems[1], "owner1/repo2");
});
it("should render local list nodes", async () => {
const dbConfig: DbConfig = createDbConfig({
localLists: [
{
name: "my-list-1",
databases: [
{
name: "db1",
dateAdded: 1668428293677,
language: "cpp",
storagePath: "/path/to/db1/",
},
{
name: "db2",
dateAdded: 1668428472731,
language: "cpp",
storagePath: "/path/to/db2/",
},
],
},
{
name: "my-list-2",
databases: [
{
name: "db3",
dateAdded: 1668428472731,
language: "ruby",
storagePath: "/path/to/db3/",
},
],
},
],
});
await saveDbConfig(dbConfig);
const dbTreeItems = await dbTreeDataProvider.getChildren();
expect(dbTreeItems).toBeTruthy();
const items = dbTreeItems!;
expect(items.length).toBe(2);
const localRootNode = items[1];
expect(localRootNode.dbItem).toBeTruthy();
expect(localRootNode.collapsibleState).toBe(
TreeItemCollapsibleState.Collapsed,
);
expect(localRootNode.children).toBeTruthy();
expect(localRootNode.children.length).toBe(2);
const localListItems = localRootNode.children.filter(
(item) => item.dbItem?.kind === DbItemKind.LocalList,
);
expect(localListItems.length).toBe(2);
checkLocalListItem(localListItems[0], "my-list-1", [
{
kind: DbItemKind.LocalDatabase,
databaseName: "db1",
dateAdded: 1668428293677,
language: "cpp",
storagePath: "/path/to/db1/",
selected: false,
},
{
kind: DbItemKind.LocalDatabase,
databaseName: "db2",
dateAdded: 1668428472731,
language: "cpp",
storagePath: "/path/to/db2/",
selected: false,
},
]);
checkLocalListItem(localListItems[1], "my-list-2", [
{
kind: DbItemKind.LocalDatabase,
databaseName: "db3",
dateAdded: 1668428472731,
language: "ruby",
storagePath: "/path/to/db3/",
selected: false,
},
]);
});
it("should render local database nodes", async () => {
const dbConfig: DbConfig = createDbConfig({
localDbs: [
{
name: "db1",
dateAdded: 1668428293677,
language: "csharp",
storagePath: "/path/to/db1/",
},
{
name: "db2",
dateAdded: 1668428472731,
language: "go",
storagePath: "/path/to/db2/",
},
],
});
await saveDbConfig(dbConfig);
const dbTreeItems = await dbTreeDataProvider.getChildren();
expect(dbTreeItems).toBeTruthy();
const items = dbTreeItems!;
expect(items.length).toBe(2);
const localRootNode = items[1];
expect(localRootNode.dbItem).toBeTruthy();
expect(localRootNode.collapsibleState).toBe(
TreeItemCollapsibleState.Collapsed,
);
expect(localRootNode.children).toBeTruthy();
expect(localRootNode.children.length).toBe(2);
const localDatabaseItems = localRootNode.children.filter(
(item) => item.dbItem?.kind === DbItemKind.LocalDatabase,
);
expect(localDatabaseItems.length).toBe(2);
checkLocalDatabaseItem(localDatabaseItems[0], {
kind: DbItemKind.LocalDatabase,
databaseName: "db1",
dateAdded: 1668428293677,
language: "csharp",
storagePath: "/path/to/db1/",
selected: false,
});
checkLocalDatabaseItem(localDatabaseItems[1], {
kind: DbItemKind.LocalDatabase,
databaseName: "db2",
dateAdded: 1668428472731,
language: "go",
storagePath: "/path/to/db2/",
selected: false,
});
});
async function saveDbConfig(dbConfig: DbConfig): Promise<void> {
await writeJson(dbConfigFilePath, dbConfig);
// Ideally we would just initialise the db config store at the start
// of each test and then rely on the file watcher to update the config.
// However, this requires adding sleep to the tests to allow for the
// file watcher to catch up, so we instead initialise the config store here.
await dbConfigStore.initialize();
dbTreeDataProvider = new DbTreeDataProvider(dbManager);
}
function checkRemoteSystemDefinedListItem(
item: DbTreeViewItem,
n: number,
): void {
expect(item.label).toBe(`Top ${n} repositories`);
expect(item.tooltip).toBe(`Top ${n} repositories of a language`);
expect(item.iconPath).toEqual(new ThemeIcon("github"));
expect(item.collapsibleState).toBe(TreeItemCollapsibleState.None);
checkDbItemActions(item, ["canBeSelected"]);
}
function checkUserDefinedListItem(
item: DbTreeViewItem,
listName: string,
repos: string[],
): void {
expect(item.label).toBe(listName);
expect(item.tooltip).toBeUndefined();
expect(item.iconPath).toBeUndefined();
expect(item.collapsibleState).toBe(TreeItemCollapsibleState.Collapsed);
checkDbItemActions(item, ["canBeSelected", "canBeRenamed", "canBeRemoved"]);
expect(item.children).toBeTruthy();
expect(item.children.length).toBe(repos.length);
for (let i = 0; i < repos.length; i++) {
checkRemoteRepoItem(item.children[i], repos[i]);
}
}
function checkOwnerItem(item: DbTreeViewItem, ownerName: string): void {
expect(item.label).toBe(ownerName);
expect(item.tooltip).toBeUndefined();
expect(item.iconPath).toEqual(new ThemeIcon("organization"));
expect(item.collapsibleState).toBe(TreeItemCollapsibleState.None);
checkDbItemActions(item, [
"canBeSelected",
"canBeRemoved",
"canBeOpenedOnGitHub",
]);
expect(item.children).toBeTruthy();
expect(item.children.length).toBe(0);
}
function checkRemoteRepoItem(item: DbTreeViewItem, repoName: string): void {
expect(item.label).toBe(repoName);
expect(item.tooltip).toBeUndefined();
expect(item.iconPath).toEqual(new ThemeIcon("database"));
expect(item.collapsibleState).toBe(TreeItemCollapsibleState.None);
checkDbItemActions(item, [
"canBeSelected",
"canBeRemoved",
"canBeOpenedOnGitHub",
]);
}
function checkLocalListItem(
item: DbTreeViewItem,
listName: string,
databases: LocalDatabaseDbItem[],
): void {
expect(item.label).toBe(listName);
expect(item.tooltip).toBeUndefined();
expect(item.iconPath).toBeUndefined();
expect(item.collapsibleState).toBe(TreeItemCollapsibleState.Collapsed);
checkDbItemActions(item, ["canBeSelected", "canBeRemoved", "canBeRenamed"]);
expect(item.children).toBeTruthy();
expect(item.children.length).toBe(databases.length);
for (let i = 0; i < databases.length; i++) {
checkLocalDatabaseItem(item.children[i], databases[i]);
}
}
function checkLocalDatabaseItem(
item: DbTreeViewItem,
database: LocalDatabaseDbItem,
): void {
expect(item.label).toBe(database.databaseName);
expect(item.tooltip).toBe(`Language: ${database.language}`);
expect(item.iconPath).toEqual(new ThemeIcon("database"));
expect(item.collapsibleState).toBe(TreeItemCollapsibleState.None);
checkDbItemActions(item, ["canBeSelected", "canBeRemoved", "canBeRenamed"]);
}
function checkDbItemActions(item: DbTreeViewItem, actions: string[]): void {
const itemActions = item.contextValue?.split(",");
expect(itemActions).toBeDefined();
expect(itemActions!.length).toBe(actions.length);
for (const action of actions) {
expect(itemActions).toContain(action);
}
}
});

View File

@@ -8,11 +8,7 @@ import {
import { DbManager } from "../../../../src/databases/db-manager";
import { DbConfigStore } from "../../../../src/databases/config/db-config-store";
import { DbTreeDataProvider } from "../../../../src/databases/ui/db-tree-data-provider";
import {
DbItemKind,
DbListKind,
LocalDatabaseDbItem,
} from "../../../../src/databases/db-item";
import { DbItemKind, DbListKind } from "../../../../src/databases/db-item";
import {
DbTreeViewItem,
SELECTED_DB_ITEM_RESOURCE_URI,
@@ -55,299 +51,6 @@ describe("db panel", () => {
await remove(workspaceStoragePath);
});
describe("rendering nodes", () => {
it("should render default local and remote nodes when the config is empty", async () => {
const dbConfig: DbConfig = createDbConfig();
await saveDbConfig(dbConfig);
const dbTreeItems = await dbTreeDataProvider.getChildren();
expect(dbTreeItems).toBeTruthy();
const items = dbTreeItems!;
expect(items.length).toBe(2);
const remoteRootNode = items[0];
expect(remoteRootNode.dbItem).toBeTruthy();
expect(remoteRootNode.dbItem?.kind).toBe(DbItemKind.RootRemote);
expect(remoteRootNode.label).toBe("remote");
expect(remoteRootNode.tooltip).toBe("Remote databases");
expect(remoteRootNode.collapsibleState).toBe(
TreeItemCollapsibleState.Collapsed,
);
expect(remoteRootNode.children).toBeTruthy();
expect(remoteRootNode.children.length).toBe(3);
const systemDefinedListItems = remoteRootNode.children.filter(
(item) => item.dbItem?.kind === DbItemKind.RemoteSystemDefinedList,
);
expect(systemDefinedListItems.length).toBe(3);
checkRemoteSystemDefinedListItem(systemDefinedListItems[0], 10);
checkRemoteSystemDefinedListItem(systemDefinedListItems[1], 100);
checkRemoteSystemDefinedListItem(systemDefinedListItems[2], 1000);
const localRootNode = items[1];
expect(localRootNode.dbItem).toBeTruthy();
expect(localRootNode.dbItem?.kind).toBe(DbItemKind.RootLocal);
expect(localRootNode.label).toBe("local");
expect(localRootNode.tooltip).toBe("Local databases");
expect(localRootNode.collapsibleState).toBe(
TreeItemCollapsibleState.Collapsed,
);
expect(localRootNode.children).toBeTruthy();
expect(localRootNode.children.length).toBe(0);
});
it("should render remote repository list nodes", async () => {
const dbConfig: DbConfig = createDbConfig({
remoteLists: [
{
name: "my-list-1",
repositories: ["owner1/repo1", "owner1/repo2"],
},
{
name: "my-list-2",
repositories: ["owner1/repo1", "owner2/repo1", "owner2/repo2"],
},
],
});
await saveDbConfig(dbConfig);
const dbTreeItems = await dbTreeDataProvider.getChildren();
expect(dbTreeItems).toBeTruthy();
const items = dbTreeItems!;
expect(items.length).toBe(2);
const remoteRootNode = items[0];
expect(remoteRootNode.dbItem).toBeTruthy();
expect(remoteRootNode.collapsibleState).toBe(
TreeItemCollapsibleState.Collapsed,
);
expect(remoteRootNode.children).toBeTruthy();
expect(remoteRootNode.children.length).toBe(5);
const systemDefinedListItems = remoteRootNode.children.filter(
(item) => item.dbItem?.kind === DbItemKind.RemoteSystemDefinedList,
);
expect(systemDefinedListItems.length).toBe(3);
const userDefinedListItems = remoteRootNode.children.filter(
(item) =>
item.dbItem?.kind === DbItemKind.VariantAnalysisUserDefinedList,
);
expect(userDefinedListItems.length).toBe(2);
checkUserDefinedListItem(userDefinedListItems[0], "my-list-1", [
"owner1/repo1",
"owner1/repo2",
]);
checkUserDefinedListItem(userDefinedListItems[1], "my-list-2", [
"owner1/repo1",
"owner2/repo1",
"owner2/repo2",
]);
});
it("should render owner list nodes", async () => {
const dbConfig: DbConfig = createDbConfig({
remoteOwners: ["owner1", "owner2"],
});
await saveDbConfig(dbConfig);
const dbTreeItems = await dbTreeDataProvider.getChildren();
expect(dbTreeItems).toBeTruthy();
const items = dbTreeItems!;
expect(items.length).toBe(2);
const remoteRootNode = items[0];
expect(remoteRootNode.dbItem).toBeTruthy();
expect(remoteRootNode.collapsibleState).toBe(
TreeItemCollapsibleState.Collapsed,
);
expect(remoteRootNode.children).toBeTruthy();
expect(remoteRootNode.children.length).toBe(5);
const ownerListItems = remoteRootNode.children.filter(
(item) => item.dbItem?.kind === DbItemKind.RemoteOwner,
);
expect(ownerListItems.length).toBe(2);
checkOwnerItem(ownerListItems[0], "owner1");
checkOwnerItem(ownerListItems[1], "owner2");
});
it("should render repository nodes", async () => {
const dbConfig: DbConfig = createDbConfig({
remoteRepos: ["owner1/repo1", "owner1/repo2"],
});
await saveDbConfig(dbConfig);
const dbTreeItems = await dbTreeDataProvider.getChildren();
expect(dbTreeItems).toBeTruthy();
const items = dbTreeItems!;
expect(items.length).toBe(2);
const remoteRootNode = items[0];
expect(remoteRootNode.dbItem).toBeTruthy();
expect(remoteRootNode.collapsibleState).toBe(
TreeItemCollapsibleState.Collapsed,
);
expect(remoteRootNode.children).toBeTruthy();
expect(remoteRootNode.children.length).toBe(5);
const repoItems = remoteRootNode.children.filter(
(item) => item.dbItem?.kind === DbItemKind.RemoteRepo,
);
expect(repoItems.length).toBe(2);
checkRemoteRepoItem(repoItems[0], "owner1/repo1");
checkRemoteRepoItem(repoItems[1], "owner1/repo2");
});
it("should render local list nodes", async () => {
const dbConfig: DbConfig = createDbConfig({
localLists: [
{
name: "my-list-1",
databases: [
{
name: "db1",
dateAdded: 1668428293677,
language: "cpp",
storagePath: "/path/to/db1/",
},
{
name: "db2",
dateAdded: 1668428472731,
language: "cpp",
storagePath: "/path/to/db2/",
},
],
},
{
name: "my-list-2",
databases: [
{
name: "db3",
dateAdded: 1668428472731,
language: "ruby",
storagePath: "/path/to/db3/",
},
],
},
],
});
await saveDbConfig(dbConfig);
const dbTreeItems = await dbTreeDataProvider.getChildren();
expect(dbTreeItems).toBeTruthy();
const items = dbTreeItems!;
expect(items.length).toBe(2);
const localRootNode = items[1];
expect(localRootNode.dbItem).toBeTruthy();
expect(localRootNode.collapsibleState).toBe(
TreeItemCollapsibleState.Collapsed,
);
expect(localRootNode.children).toBeTruthy();
expect(localRootNode.children.length).toBe(2);
const localListItems = localRootNode.children.filter(
(item) => item.dbItem?.kind === DbItemKind.LocalList,
);
expect(localListItems.length).toBe(2);
checkLocalListItem(localListItems[0], "my-list-1", [
{
kind: DbItemKind.LocalDatabase,
databaseName: "db1",
dateAdded: 1668428293677,
language: "cpp",
storagePath: "/path/to/db1/",
selected: false,
},
{
kind: DbItemKind.LocalDatabase,
databaseName: "db2",
dateAdded: 1668428472731,
language: "cpp",
storagePath: "/path/to/db2/",
selected: false,
},
]);
checkLocalListItem(localListItems[1], "my-list-2", [
{
kind: DbItemKind.LocalDatabase,
databaseName: "db3",
dateAdded: 1668428472731,
language: "ruby",
storagePath: "/path/to/db3/",
selected: false,
},
]);
});
it("should render local database nodes", async () => {
const dbConfig: DbConfig = createDbConfig({
localDbs: [
{
name: "db1",
dateAdded: 1668428293677,
language: "csharp",
storagePath: "/path/to/db1/",
},
{
name: "db2",
dateAdded: 1668428472731,
language: "go",
storagePath: "/path/to/db2/",
},
],
});
await saveDbConfig(dbConfig);
const dbTreeItems = await dbTreeDataProvider.getChildren();
expect(dbTreeItems).toBeTruthy();
const items = dbTreeItems!;
expect(items.length).toBe(2);
const localRootNode = items[1];
expect(localRootNode.dbItem).toBeTruthy();
expect(localRootNode.collapsibleState).toBe(
TreeItemCollapsibleState.Collapsed,
);
expect(localRootNode.children).toBeTruthy();
expect(localRootNode.children.length).toBe(2);
const localDatabaseItems = localRootNode.children.filter(
(item) => item.dbItem?.kind === DbItemKind.LocalDatabase,
);
expect(localDatabaseItems.length).toBe(2);
checkLocalDatabaseItem(localDatabaseItems[0], {
kind: DbItemKind.LocalDatabase,
databaseName: "db1",
dateAdded: 1668428293677,
language: "csharp",
storagePath: "/path/to/db1/",
selected: false,
});
checkLocalDatabaseItem(localDatabaseItems[1], {
kind: DbItemKind.LocalDatabase,
databaseName: "db2",
dateAdded: 1668428472731,
language: "go",
storagePath: "/path/to/db2/",
selected: false,
});
});
});
describe("selecting an item", () => {
it("should mark selected remote db list as selected", async () => {
const dbConfig: DbConfig = createDbConfig({
@@ -779,99 +482,6 @@ describe("db panel", () => {
dbTreeDataProvider = new DbTreeDataProvider(dbManager);
}
function checkRemoteSystemDefinedListItem(
item: DbTreeViewItem,
n: number,
): void {
expect(item.label).toBe(`Top ${n} repositories`);
expect(item.tooltip).toBe(`Top ${n} repositories of a language`);
expect(item.iconPath).toEqual(new ThemeIcon("github"));
expect(item.collapsibleState).toBe(TreeItemCollapsibleState.None);
checkDbItemActions(item, ["canBeSelected"]);
}
function checkUserDefinedListItem(
item: DbTreeViewItem,
listName: string,
repos: string[],
): void {
expect(item.label).toBe(listName);
expect(item.tooltip).toBeUndefined();
expect(item.iconPath).toBeUndefined();
expect(item.collapsibleState).toBe(TreeItemCollapsibleState.Collapsed);
checkDbItemActions(item, ["canBeSelected", "canBeRenamed", "canBeRemoved"]);
expect(item.children).toBeTruthy();
expect(item.children.length).toBe(repos.length);
for (let i = 0; i < repos.length; i++) {
checkRemoteRepoItem(item.children[i], repos[i]);
}
}
function checkOwnerItem(item: DbTreeViewItem, ownerName: string): void {
expect(item.label).toBe(ownerName);
expect(item.tooltip).toBeUndefined();
expect(item.iconPath).toEqual(new ThemeIcon("organization"));
expect(item.collapsibleState).toBe(TreeItemCollapsibleState.None);
checkDbItemActions(item, [
"canBeSelected",
"canBeRemoved",
"canBeOpenedOnGitHub",
]);
expect(item.children).toBeTruthy();
expect(item.children.length).toBe(0);
}
function checkRemoteRepoItem(item: DbTreeViewItem, repoName: string): void {
expect(item.label).toBe(repoName);
expect(item.tooltip).toBeUndefined();
expect(item.iconPath).toEqual(new ThemeIcon("database"));
expect(item.collapsibleState).toBe(TreeItemCollapsibleState.None);
checkDbItemActions(item, [
"canBeSelected",
"canBeRemoved",
"canBeOpenedOnGitHub",
]);
}
function checkLocalListItem(
item: DbTreeViewItem,
listName: string,
databases: LocalDatabaseDbItem[],
): void {
expect(item.label).toBe(listName);
expect(item.tooltip).toBeUndefined();
expect(item.iconPath).toBeUndefined();
expect(item.collapsibleState).toBe(TreeItemCollapsibleState.Collapsed);
checkDbItemActions(item, ["canBeSelected", "canBeRemoved", "canBeRenamed"]);
expect(item.children).toBeTruthy();
expect(item.children.length).toBe(databases.length);
for (let i = 0; i < databases.length; i++) {
checkLocalDatabaseItem(item.children[i], databases[i]);
}
}
function checkLocalDatabaseItem(
item: DbTreeViewItem,
database: LocalDatabaseDbItem,
): void {
expect(item.label).toBe(database.databaseName);
expect(item.tooltip).toBe(`Language: ${database.language}`);
expect(item.iconPath).toEqual(new ThemeIcon("database"));
expect(item.collapsibleState).toBe(TreeItemCollapsibleState.None);
checkDbItemActions(item, ["canBeSelected", "canBeRemoved", "canBeRenamed"]);
}
function checkDbItemActions(item: DbTreeViewItem, actions: string[]): void {
const itemActions = item.contextValue?.split(",");
expect(itemActions).toBeDefined();
expect(itemActions!.length).toBe(actions.length);
for (const action of actions) {
expect(itemActions).toContain(action);
}
}
function checkErrorItem(
item: DbTreeViewItem,
label: string,