mrva/vscode-codeql
1
0
Fork 0
Code Issues Pull Requests Actions 2 Packages Projects Releases Wiki Activity

Merge remote-tracking branch 'origin/main' into koesie10/upgrade-vsce

Browse Source
This commit is contained in:
Koen Vlaswinkel
2022-12-09 10:36:02 +01:00
parent 1cb0b0b6cb 698b6ad0e4
commit 3bd61ae1a6
4 changed files with 283 additions and 63 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
.github/workflows/main.yml vendored
View File

@@ -185,7 +185,7 @@ jobs:
strategy:
matrix:
os: [ubuntu-latest, windows-latest]
version: ['v2.7.6', 'v2.8.5', 'v2.9.4', 'v2.10.5', 'v2.11.4', 'nightly']
version: ['v2.7.6', 'v2.8.5', 'v2.9.4', 'v2.10.5', 'v2.11.5', 'nightly']
fail-fast: false
env:
CLI_VERSION: ${{ matrix.version }}

2
extensions/ql-vscode/src/vscode-tests/ensureCli.ts
View File

@@ -38,7 +38,7 @@ const _10MB = _1MB * 10;
// CLI version to test. Hard code the latest as default. And be sure
// to update the env if it is not otherwise set.
const CLI_VERSION = process.env.CLI_VERSION || "v2.11.4";
const CLI_VERSION = process.env.CLI_VERSION || "v2.11.5";
process.env.CLI_VERSION = CLI_VERSION;
// Base dir where CLIs will be downloaded into

3
extensions/ql-vscode/src/vscode-tests/factories/remote-queries/remote-query-history-item.ts
View File

@@ -1,3 +1,4 @@
import { nanoid } from "nanoid";
import { RemoteQueryHistoryItem } from "../../../remote-queries/remote-query-history-item";
import { QueryStatus } from "../../../query-status";
@@ -25,7 +26,7 @@ export function createMockRemoteQueryHistoryItem({
resultCount,
status,
completed: false,
queryId: "queryId",
queryId: nanoid(),
remoteQuery: {
queryName: "query-name",
queryFilePath: "query-file.ql",

339
extensions/ql-vscode/src/vscode-tests/no-workspace/query-history.test.ts
View File

@@ -58,7 +58,7 @@ describe("query-history", () => {
>;
const doCompareCallback = jest.fn();
let queryHistoryManager: QueryHistoryManager | undefined;
let queryHistoryManager: QueryHistoryManager;
let localQueriesResultsViewStub: ResultsView;
let remoteQueriesManagerStub: RemoteQueriesManager;
@@ -177,7 +177,6 @@ describe("query-history", () => {
afterEach(async () => {
if (queryHistoryManager) {
queryHistoryManager.dispose();
queryHistoryManager = undefined;
}
});
@@ -390,77 +389,297 @@ describe("query-history", () => {
});
describe("handleRemoveHistoryItem", () => {
it("should remove an item and not select a new one", async () => {
queryHistoryManager = await createMockQueryHistory(localQueryHistory);
// initialize the selection
await queryHistoryManager.treeView.reveal(localQueryHistory[0], {
select: true,
describe("when the item is a local query", () => {
describe("when the item being removed is not selected", () => {
// deleting the first item when a different item is selected
// will not change the selection
let toDelete: LocalQueryInfo;
let selected: LocalQueryInfo;
beforeEach(async () => {
toDelete = localQueryHistory[1];
selected = localQueryHistory[3];
queryHistoryManager = await createMockQueryHistory(
localQueryHistory,
);
// initialize the selection
await queryHistoryManager.treeView.reveal(localQueryHistory[0], {
select: true,
});
// select the item we want
await queryHistoryManager.treeView.reveal(selected, {
select: true,
});
// should be selected
expect(queryHistoryManager.treeDataProvider.getCurrent()).toEqual(
selected,
);
// remove an item
await queryHistoryManager.handleRemoveHistoryItem(toDelete, [
toDelete,
]);
});
it("should remove the item", () => {
expect(toDelete.completedQuery!.dispose).toBeCalledTimes(1);
expect(queryHistoryManager.treeDataProvider.allHistory).toEqual(
expect.not.arrayContaining([toDelete]),
);
});
it("should not change the selection", () => {
expect(queryHistoryManager.treeDataProvider.getCurrent()).toEqual(
selected,
);
expect(
localQueriesResultsViewStub.showResults,
).toHaveBeenCalledTimes(1);
expect(
localQueriesResultsViewStub.showResults,
).toHaveBeenCalledWith(selected, WebviewReveal.Forced, false);
});
});
// deleting the first item when a different item is selected
// will not change the selection
const toDelete = localQueryHistory[1];
const selected = localQueryHistory[3];
describe("when the item being removed is selected", () => {
// deleting the selected item automatically selects next item
let toDelete: LocalQueryInfo;
let newSelected: LocalQueryInfo;
// select the item we want
await queryHistoryManager.treeView.reveal(selected, { select: true });
beforeEach(async () => {
toDelete = localQueryHistory[1];
newSelected = localQueryHistory[2];
// should be selected
expect(queryHistoryManager.treeDataProvider.getCurrent()).toEqual(
selected,
);
queryHistoryManager = await createMockQueryHistory(
localQueryHistory,
);
// remove an item
await queryHistoryManager.handleRemoveHistoryItem(toDelete, [toDelete]);
// select the item we want
await queryHistoryManager.treeView.reveal(toDelete, {
select: true,
});
await queryHistoryManager.handleRemoveHistoryItem(toDelete, [
toDelete,
]);
});
expect(toDelete.completedQuery!.dispose).toBeCalledTimes(1);
expect(queryHistoryManager.treeDataProvider.getCurrent()).toEqual(
selected,
);
expect(queryHistoryManager.treeDataProvider.allHistory).toEqual(
expect.not.arrayContaining([toDelete]),
);
it("should remove the item", () => {
expect(toDelete.completedQuery!.dispose).toBeCalledTimes(1);
expect(queryHistoryManager.treeDataProvider.allHistory).toEqual(
expect.not.arrayContaining([toDelete]),
);
});
// the same item should be selected
expect(localQueriesResultsViewStub.showResults).toHaveBeenCalledTimes(
1,
);
expect(localQueriesResultsViewStub.showResults).toHaveBeenCalledWith(
selected,
WebviewReveal.Forced,
false,
);
it("should change the selection", () => {
expect(queryHistoryManager.treeDataProvider.getCurrent()).toBe(
newSelected,
);
expect(
localQueriesResultsViewStub.showResults,
).toHaveBeenCalledTimes(1);
expect(
localQueriesResultsViewStub.showResults,
).toHaveBeenCalledWith(newSelected, WebviewReveal.Forced, false);
});
});
});
it("should remove an item and select a new one", async () => {
queryHistoryManager = await createMockQueryHistory(localQueryHistory);
describe("when the item is a remote query", () => {
describe("when the item being removed is not selected", () => {
let toDelete: RemoteQueryHistoryItem;
let selected: RemoteQueryHistoryItem;
// deleting the selected item automatically selects next item
const toDelete = localQueryHistory[1];
const newSelected = localQueryHistory[2];
// avoid triggering the callback by setting the field directly
beforeEach(async () => {
// deleting the first item when a different item is selected
// will not change the selection
toDelete = remoteQueryHistory[1];
selected = remoteQueryHistory[3];
// select the item we want
await queryHistoryManager.treeView.reveal(toDelete, { select: true });
await queryHistoryManager.handleRemoveHistoryItem(toDelete, [toDelete]);
queryHistoryManager = await createMockQueryHistory(allHistory);
expect(toDelete.completedQuery!.dispose).toBeCalledTimes(1);
expect(queryHistoryManager.treeDataProvider.getCurrent()).toBe(
newSelected,
);
expect(queryHistoryManager.treeDataProvider.allHistory).toEqual(
expect.not.arrayContaining([toDelete]),
);
// initialize the selection
await queryHistoryManager.treeView.reveal(remoteQueryHistory[0], {
select: true,
});
// the current item should have been selected
expect(localQueriesResultsViewStub.showResults).toHaveBeenCalledTimes(
1,
);
expect(localQueriesResultsViewStub.showResults).toHaveBeenCalledWith(
newSelected,
WebviewReveal.Forced,
false,
);
// select the item we want
await queryHistoryManager.treeView.reveal(selected, {
select: true,
});
// should be selected
expect(queryHistoryManager.treeDataProvider.getCurrent()).toEqual(
selected,
);
// remove an item
await queryHistoryManager.handleRemoveHistoryItem(toDelete, [
toDelete,
]);
});
it("should remove the item", () => {
expect(
remoteQueriesManagerStub.removeRemoteQuery,
).toHaveBeenCalledWith(toDelete.queryId);
expect(
queryHistoryManager.treeDataProvider.allHistory,
).not.toContain(toDelete);
});
it("should not change the selection", () => {
expect(queryHistoryManager.treeDataProvider.getCurrent()).toEqual(
selected,
);
expect(
remoteQueriesManagerStub.openRemoteQueryResults,
).toHaveBeenCalledWith(selected.queryId);
});
});
describe("when the item being removed is selected", () => {
let toDelete: RemoteQueryHistoryItem;
let newSelected: RemoteQueryHistoryItem;
beforeEach(async () => {
// deleting the selected item automatically selects next item
toDelete = remoteQueryHistory[1];
newSelected = remoteQueryHistory[2];
queryHistoryManager = await createMockQueryHistory(
remoteQueryHistory,
);
// select the item we want
await queryHistoryManager.treeView.reveal(toDelete, {
select: true,
});
await queryHistoryManager.handleRemoveHistoryItem(toDelete, [
toDelete,
]);
});
it("should remove the item", () => {
expect(
remoteQueriesManagerStub.removeRemoteQuery,
).toHaveBeenCalledWith(toDelete.queryId);
expect(
queryHistoryManager.treeDataProvider.allHistory,
).not.toContain(toDelete);
});
it("should change the selection", () => {
expect(queryHistoryManager.treeDataProvider.getCurrent()).toEqual(
newSelected,
);
expect(
remoteQueriesManagerStub.openRemoteQueryResults,
).toHaveBeenCalledWith(newSelected.queryId);
});
});
});
describe("when the item is a variant analysis", () => {
describe("when the item being removed is not selected", () => {
let toDelete: VariantAnalysisHistoryItem;
let selected: VariantAnalysisHistoryItem;
beforeEach(async () => {
// deleting the first item when a different item is selected
// will not change the selection
toDelete = variantAnalysisHistory[1];
selected = variantAnalysisHistory[3];
queryHistoryManager = await createMockQueryHistory(allHistory);
// initialize the selection
await queryHistoryManager.treeView.reveal(
variantAnalysisHistory[0],
{
select: true,
},
);
// select the item we want
await queryHistoryManager.treeView.reveal(selected, {
select: true,
});
// should be selected
expect(queryHistoryManager.treeDataProvider.getCurrent()).toEqual(
selected,
);
// remove an item
await queryHistoryManager.handleRemoveHistoryItem(toDelete, [
toDelete,
]);
});
it("should remove the item", () => {
expect(
variantAnalysisManagerStub.removeVariantAnalysis,
).toHaveBeenCalledWith(toDelete.variantAnalysis);
expect(
queryHistoryManager.treeDataProvider.allHistory,
).not.toContain(toDelete);
});
it("should not change the selection", () => {
expect(queryHistoryManager.treeDataProvider.getCurrent()).toEqual(
selected,
);
expect(variantAnalysisManagerStub.showView).toHaveBeenCalledWith(
selected.variantAnalysis.id,
);
});
});
describe("when the item being removed is selected", () => {
let toDelete: VariantAnalysisHistoryItem;
let newSelected: VariantAnalysisHistoryItem;
beforeEach(async () => {
// deleting the selected item automatically selects next item
toDelete = variantAnalysisHistory[1];
newSelected = variantAnalysisHistory[2];
queryHistoryManager = await createMockQueryHistory(
variantAnalysisHistory,
);
// select the item we want
await queryHistoryManager.treeView.reveal(toDelete, {
select: true,
});
await queryHistoryManager.handleRemoveHistoryItem(toDelete, [
toDelete,
]);
});
it("should remove the item", () => {
expect(
variantAnalysisManagerStub.removeVariantAnalysis,
).toHaveBeenCalledWith(toDelete.variantAnalysis);
expect(
queryHistoryManager.treeDataProvider.allHistory,
).not.toContain(toDelete);
});
it.skip("should change the selection", () => {
expect(queryHistoryManager.treeDataProvider.getCurrent()).toEqual(
newSelected,
);
expect(variantAnalysisManagerStub.showView).toHaveBeenCalledWith(
newSelected.variantAnalysis.id,
);
});
});
});
});