Skip to content

Commit abbebd3

Browse files
koesie10koesie10
authored
Merge pull request #1845 from github/koesie10/variant-analysis-remove-item-tests
Add tests for removing remote queries and variant analyses
2 parents 5138831 + 3346bd4 commit abbebd3

File tree

2 files changed

+281
-61
lines changed

2 files changed

+281
-61
lines changed

‎extensions/ql-vscode/src/vscode-tests/factories/remote-queries/remote-query-history-item.ts‎

Lines changed: 2 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -1,3 +1,4 @@
1+
import { nanoid } from "nanoid";
12
import { RemoteQueryHistoryItem } from "../../../remote-queries/remote-query-history-item";
23
import { QueryStatus } from "../../../query-status";
34

@@ -25,7 +26,7 @@ export function createMockRemoteQueryHistoryItem({
2526
resultCount,
2627
status,
2728
completed: false,
28-
queryId: "queryId",
29+
queryId: nanoid(),
2930
remoteQuery: {
3031
queryName: "query-name",
3132
queryFilePath: "query-file.ql",

‎extensions/ql-vscode/src/vscode-tests/no-workspace/query-history.test.ts‎

Lines changed: 279 additions & 60 deletions
Original file line numberDiff line numberDiff line change
@@ -58,7 +58,7 @@ describe("query-history", () => {
5858
>;
5959
const doCompareCallback = jest.fn();
6060

61-
let queryHistoryManager: QueryHistoryManager | undefined;
61+
let queryHistoryManager: QueryHistoryManager;
6262

6363
let localQueriesResultsViewStub: ResultsView;
6464
let remoteQueriesManagerStub: RemoteQueriesManager;
@@ -177,7 +177,6 @@ describe("query-history", () => {
177177
afterEach(async () => {
178178
if (queryHistoryManager) {
179179
queryHistoryManager.dispose();
180-
queryHistoryManager = undefined;
181180
}
182181
});
183182

@@ -390,77 +389,297 @@ describe("query-history", () => {
390389
});
391390

392391
describe("handleRemoveHistoryItem", () => {
393-
it("should remove an item and not select a new one", async () => {
394-
queryHistoryManager = await createMockQueryHistory(localQueryHistory);
395-
// initialize the selection
396-
await queryHistoryManager.treeView.reveal(localQueryHistory[0], {
397-
select: true,
392+
describe("when the item is a local query", () => {
393+
describe("when the item being removed is not selected", () => {
394+
// deleting the first item when a different item is selected
395+
// will not change the selection
396+
let toDelete: LocalQueryInfo;
397+
let selected: LocalQueryInfo;
398+
399+
beforeEach(async () => {
400+
toDelete = localQueryHistory[1];
401+
selected = localQueryHistory[3];
402+
403+
queryHistoryManager = await createMockQueryHistory(
404+
localQueryHistory,
405+
);
406+
// initialize the selection
407+
await queryHistoryManager.treeView.reveal(localQueryHistory[0], {
408+
select: true,
409+
});
410+
411+
// select the item we want
412+
await queryHistoryManager.treeView.reveal(selected, {
413+
select: true,
414+
});
415+
416+
// should be selected
417+
expect(queryHistoryManager.treeDataProvider.getCurrent()).toEqual(
418+
selected,
419+
);
420+
421+
// remove an item
422+
await queryHistoryManager.handleRemoveHistoryItem(toDelete, [
423+
toDelete,
424+
]);
425+
});
426+
427+
it("should remove the item", () => {
428+
expect(toDelete.completedQuery!.dispose).toBeCalledTimes(1);
429+
expect(queryHistoryManager.treeDataProvider.allHistory).toEqual(
430+
expect.not.arrayContaining([toDelete]),
431+
);
432+
});
433+
434+
it("should not change the selection", () => {
435+
expect(queryHistoryManager.treeDataProvider.getCurrent()).toEqual(
436+
selected,
437+
);
438+
439+
expect(
440+
localQueriesResultsViewStub.showResults,
441+
).toHaveBeenCalledTimes(1);
442+
expect(
443+
localQueriesResultsViewStub.showResults,
444+
).toHaveBeenCalledWith(selected, WebviewReveal.Forced, false);
445+
});
398446
});
399447

400-
// deleting the first item when a different item is selected
401-
// will not change the selection
402-
const toDelete = localQueryHistory[1];
403-
const selected = localQueryHistory[3];
448+
describe("when the item being removed is selected", () => {
449+
// deleting the selected item automatically selects next item
450+
let toDelete: LocalQueryInfo;
451+
let newSelected: LocalQueryInfo;
404452

405-
// select the item we want
406-
await queryHistoryManager.treeView.reveal(selected, { select: true });
453+
beforeEach(async () => {
454+
toDelete = localQueryHistory[1];
455+
newSelected = localQueryHistory[2];
407456

408-
// should be selected
409-
expect(queryHistoryManager.treeDataProvider.getCurrent()).toEqual(
410-
selected,
411-
);
457+
queryHistoryManager = await createMockQueryHistory(
458+
localQueryHistory,
459+
);
412460

413-
// remove an item
414-
await queryHistoryManager.handleRemoveHistoryItem(toDelete, [toDelete]);
461+
// select the item we want
462+
await queryHistoryManager.treeView.reveal(toDelete, {
463+
select: true,
464+
});
465+
await queryHistoryManager.handleRemoveHistoryItem(toDelete, [
466+
toDelete,
467+
]);
468+
});
415469

416-
expect(toDelete.completedQuery!.dispose).toBeCalledTimes(1);
417-
expect(queryHistoryManager.treeDataProvider.getCurrent()).toEqual(
418-
selected,
419-
);
420-
expect(queryHistoryManager.treeDataProvider.allHistory).toEqual(
421-
expect.not.arrayContaining([toDelete]),
422-
);
470+
it("should remove the item", () => {
471+
expect(toDelete.completedQuery!.dispose).toBeCalledTimes(1);
472+
expect(queryHistoryManager.treeDataProvider.allHistory).toEqual(
473+
expect.not.arrayContaining([toDelete]),
474+
);
475+
});
423476

424-
// the same item should be selected
425-
expect(localQueriesResultsViewStub.showResults).toHaveBeenCalledTimes(
426-
1,
427-
);
428-
expect(localQueriesResultsViewStub.showResults).toHaveBeenCalledWith(
429-
selected,
430-
WebviewReveal.Forced,
431-
false,
432-
);
477+
it("should change the selection", () => {
478+
expect(queryHistoryManager.treeDataProvider.getCurrent()).toBe(
479+
newSelected,
480+
);
481+
482+
expect(
483+
localQueriesResultsViewStub.showResults,
484+
).toHaveBeenCalledTimes(1);
485+
expect(
486+
localQueriesResultsViewStub.showResults,
487+
).toHaveBeenCalledWith(newSelected, WebviewReveal.Forced, false);
488+
});
489+
});
433490
});
434491

435-
it("should remove an item and select a new one", async () => {
436-
queryHistoryManager = await createMockQueryHistory(localQueryHistory);
492+
describe("when the item is a remote query", () => {
493+
describe("when the item being removed is not selected", () => {
494+
let toDelete: RemoteQueryHistoryItem;
495+
let selected: RemoteQueryHistoryItem;
437496

438-
// deleting the selected item automatically selects next item
439-
const toDelete = localQueryHistory[1];
440-
const newSelected = localQueryHistory[2];
441-
// avoid triggering the callback by setting the field directly
497+
beforeEach(async () => {
498+
// deleting the first item when a different item is selected
499+
// will not change the selection
500+
toDelete = remoteQueryHistory[1];
501+
selected = remoteQueryHistory[3];
442502

443-
// select the item we want
444-
await queryHistoryManager.treeView.reveal(toDelete, { select: true });
445-
await queryHistoryManager.handleRemoveHistoryItem(toDelete, [toDelete]);
503+
queryHistoryManager = await createMockQueryHistory(allHistory);
446504

447-
expect(toDelete.completedQuery!.dispose).toBeCalledTimes(1);
448-
expect(queryHistoryManager.treeDataProvider.getCurrent()).toBe(
449-
newSelected,
450-
);
451-
expect(queryHistoryManager.treeDataProvider.allHistory).toEqual(
452-
expect.not.arrayContaining([toDelete]),
453-
);
505+
// initialize the selection
506+
await queryHistoryManager.treeView.reveal(remoteQueryHistory[0], {
507+
select: true,
508+
});
454509

455-
// the current item should have been selected
456-
expect(localQueriesResultsViewStub.showResults).toHaveBeenCalledTimes(
457-
1,
458-
);
459-
expect(localQueriesResultsViewStub.showResults).toHaveBeenCalledWith(
460-
newSelected,
461-
WebviewReveal.Forced,
462-
false,
463-
);
510+
// select the item we want
511+
await queryHistoryManager.treeView.reveal(selected, {
512+
select: true,
513+
});
514+
515+
// should be selected
516+
expect(queryHistoryManager.treeDataProvider.getCurrent()).toEqual(
517+
selected,
518+
);
519+
520+
// remove an item
521+
await queryHistoryManager.handleRemoveHistoryItem(toDelete, [
522+
toDelete,
523+
]);
524+
});
525+
526+
it("should remove the item", () => {
527+
expect(
528+
remoteQueriesManagerStub.removeRemoteQuery,
529+
).toHaveBeenCalledWith(toDelete.queryId);
530+
expect(
531+
queryHistoryManager.treeDataProvider.allHistory,
532+
).not.toContain(toDelete);
533+
});
534+
535+
it("should not change the selection", () => {
536+
expect(queryHistoryManager.treeDataProvider.getCurrent()).toEqual(
537+
selected,
538+
);
539+
540+
expect(
541+
remoteQueriesManagerStub.openRemoteQueryResults,
542+
).toHaveBeenCalledWith(selected.queryId);
543+
});
544+
});
545+
546+
describe("when the item being removed is selected", () => {
547+
let toDelete: RemoteQueryHistoryItem;
548+
let newSelected: RemoteQueryHistoryItem;
549+
550+
beforeEach(async () => {
551+
// deleting the selected item automatically selects next item
552+
toDelete = remoteQueryHistory[1];
553+
newSelected = remoteQueryHistory[2];
554+
555+
queryHistoryManager = await createMockQueryHistory(
556+
remoteQueryHistory,
557+
);
558+
559+
// select the item we want
560+
await queryHistoryManager.treeView.reveal(toDelete, {
561+
select: true,
562+
});
563+
await queryHistoryManager.handleRemoveHistoryItem(toDelete, [
564+
toDelete,
565+
]);
566+
});
567+
568+
it("should remove the item", () => {
569+
expect(
570+
remoteQueriesManagerStub.removeRemoteQuery,
571+
).toHaveBeenCalledWith(toDelete.queryId);
572+
expect(
573+
queryHistoryManager.treeDataProvider.allHistory,
574+
).not.toContain(toDelete);
575+
});
576+
577+
it("should change the selection", () => {
578+
expect(queryHistoryManager.treeDataProvider.getCurrent()).toEqual(
579+
newSelected,
580+
);
581+
expect(
582+
remoteQueriesManagerStub.openRemoteQueryResults,
583+
).toHaveBeenCalledWith(newSelected.queryId);
584+
});
585+
});
586+
});
587+
588+
describe("when the item is a variant analysis", () => {
589+
describe("when the item being removed is not selected", () => {
590+
let toDelete: VariantAnalysisHistoryItem;
591+
let selected: VariantAnalysisHistoryItem;
592+
593+
beforeEach(async () => {
594+
// deleting the first item when a different item is selected
595+
// will not change the selection
596+
toDelete = variantAnalysisHistory[1];
597+
selected = variantAnalysisHistory[3];
598+
599+
queryHistoryManager = await createMockQueryHistory(allHistory);
600+
// initialize the selection
601+
await queryHistoryManager.treeView.reveal(
602+
variantAnalysisHistory[0],
603+
{
604+
select: true,
605+
},
606+
);
607+
608+
// select the item we want
609+
await queryHistoryManager.treeView.reveal(selected, {
610+
select: true,
611+
});
612+
613+
// should be selected
614+
expect(queryHistoryManager.treeDataProvider.getCurrent()).toEqual(
615+
selected,
616+
);
617+
618+
// remove an item
619+
await queryHistoryManager.handleRemoveHistoryItem(toDelete, [
620+
toDelete,
621+
]);
622+
});
623+
624+
it("should remove the item", () => {
625+
expect(
626+
variantAnalysisManagerStub.removeVariantAnalysis,
627+
).toHaveBeenCalledWith(toDelete.variantAnalysis);
628+
expect(
629+
queryHistoryManager.treeDataProvider.allHistory,
630+
).not.toContain(toDelete);
631+
});
632+
633+
it("should not change the selection", () => {
634+
expect(queryHistoryManager.treeDataProvider.getCurrent()).toEqual(
635+
selected,
636+
);
637+
expect(variantAnalysisManagerStub.showView).toHaveBeenCalledWith(
638+
selected.variantAnalysis.id,
639+
);
640+
});
641+
});
642+
643+
describe("when the item being removed is selected", () => {
644+
let toDelete: VariantAnalysisHistoryItem;
645+
let newSelected: VariantAnalysisHistoryItem;
646+
647+
beforeEach(async () => {
648+
// deleting the selected item automatically selects next item
649+
toDelete = variantAnalysisHistory[1];
650+
newSelected = variantAnalysisHistory[2];
651+
652+
queryHistoryManager = await createMockQueryHistory(
653+
variantAnalysisHistory,
654+
);
655+
656+
// select the item we want
657+
await queryHistoryManager.treeView.reveal(toDelete, {
658+
select: true,
659+
});
660+
await queryHistoryManager.handleRemoveHistoryItem(toDelete, [
661+
toDelete,
662+
]);
663+
});
664+
665+
it("should remove the item", () => {
666+
expect(
667+
variantAnalysisManagerStub.removeVariantAnalysis,
668+
).toHaveBeenCalledWith(toDelete.variantAnalysis);
669+
expect(
670+
queryHistoryManager.treeDataProvider.allHistory,
671+
).not.toContain(toDelete);
672+
});
673+
674+
it.skip("should change the selection", () => {
675+
expect(queryHistoryManager.treeDataProvider.getCurrent()).toEqual(
676+
newSelected,
677+
);
678+
expect(variantAnalysisManagerStub.showView).toHaveBeenCalledWith(
679+
newSelected.variantAnalysis.id,
680+
);
681+
});
682+
});
464683
});
465684
});
466685

0 commit comments

Comments
 (0)