Wrap tests for removal in handleRemoveHistoryItem describe block

Instead of having them dangle around.

Author: elenatanasoiu

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

@@ -325,77 +325,79 @@ describe('query-history', () => {
     });
   });
 
-  it('should remove an item and not select a new one', async () => {
-    queryHistoryManager = await createMockQueryHistory(allHistory);
-    // initialize the selection
-    await queryHistoryManager.treeView.reveal(allHistory[0], { select: true });
-
-    // deleting the first item when a different item is selected
-    // will not change the selection
-    const toDelete = allHistory[1];
-    const selected = allHistory[3];
-
-    // select the item we want
-    await queryHistoryManager.treeView.reveal(selected, { select: true });
-
-    // should be selected
-    expect(queryHistoryManager.treeDataProvider.getCurrent()).to.deep.eq(selected);
-
-    // remove an item
-    await queryHistoryManager.handleRemoveHistoryItem(toDelete, [toDelete]);
-
-    if (toDelete.t == 'local') {
-      expect(toDelete.completedQuery!.dispose).to.have.been.calledOnce;
-    } else if (toDelete.t == 'remote') {
-      expect(remoteQueriesManagerStub.removeRemoteQuery).to.have.been.calledOnceWith((toDelete as RemoteQueryHistoryItem).queryId);
-    } else if (toDelete.t == 'variant-analysis') {
-      expect(variantAnalysisManagerStub.removeVariantAnalysis).to.have.been.calledOnceWith((toDelete as VariantAnalysisHistoryItem).variantAnalysis.id);
-    }
+  describe('handleRemoveHistoryItem', () => {
+    it('should remove an item and not select a new one', async () => {
+      queryHistoryManager = await createMockQueryHistory(allHistory);
+      // initialize the selection
+      await queryHistoryManager.treeView.reveal(allHistory[0], { select: true });
 
-    // the same item should be selected
-    if (selected.t == 'local') {
-      expect(localQueriesResultsViewStub.showResults).to.have.been.calledOnceWith(selected);
-    } else if (toDelete.t == 'remote') {
-      expect(remoteQueriesManagerStub.openRemoteQueryResults).to.have.been.calledOnceWith((selected as RemoteQueryHistoryItem).queryId);
-    } else if (toDelete.t == 'variant-analysis') {
-      expect(variantAnalysisManagerStub.showView).to.have.been.calledOnceWith((selected as VariantAnalysisHistoryItem).variantAnalysis.id);
-    }
+      // deleting the first item when a different item is selected
+      // will not change the selection
+      const toDelete = allHistory[1];
+      const selected = allHistory[3];
 
-    expect(queryHistoryManager.treeDataProvider.getCurrent()).to.deep.eq(selected);
-    expect(queryHistoryManager.treeDataProvider.allHistory).not.to.contain(toDelete);
-  });
+      // select the item we want
+      await queryHistoryManager.treeView.reveal(selected, { select: true });
 
-  it('should remove an item and select a new one', async () => {
-    queryHistoryManager = await createMockQueryHistory(allHistory);
+      // should be selected
+      expect(queryHistoryManager.treeDataProvider.getCurrent()).to.deep.eq(selected);
 
-    // deleting the selected item automatically selects next item
-    const toDelete = allHistory[1];
-    const newSelected = allHistory[2];
-    // avoid triggering the callback by setting the field directly
+      // 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]);
+      if (toDelete.t == 'local') {
+        expect(toDelete.completedQuery!.dispose).to.have.been.calledOnce;
+      } else if (toDelete.t == 'remote') {
+        expect(remoteQueriesManagerStub.removeRemoteQuery).to.have.been.calledOnceWith((toDelete as RemoteQueryHistoryItem).queryId);
+      } else if (toDelete.t == 'variant-analysis') {
+        expect(variantAnalysisManagerStub.removeVariantAnalysis).to.have.been.calledOnceWith((toDelete as VariantAnalysisHistoryItem).variantAnalysis.id);
+      }
 
-    if (toDelete.t == 'local') {
-      expect(toDelete.completedQuery!.dispose).to.have.been.calledOnce;
-    } else if (toDelete.t == 'remote') {
-      expect(remoteQueriesManagerStub.removeRemoteQuery).to.have.been.calledOnceWith((toDelete as RemoteQueryHistoryItem).queryId);
-    } else if (toDelete.t == 'variant-analysis') {
-      expect(variantAnalysisManagerStub.removeVariantAnalysis).to.have.been.calledOnceWith((toDelete as VariantAnalysisHistoryItem).variantAnalysis.id);
-    }
+      // the same item should be selected
+      if (selected.t == 'local') {
+        expect(localQueriesResultsViewStub.showResults).to.have.been.calledOnceWith(selected);
+      } else if (toDelete.t == 'remote') {
+        expect(remoteQueriesManagerStub.openRemoteQueryResults).to.have.been.calledOnceWith((selected as RemoteQueryHistoryItem).queryId);
+      } else if (toDelete.t == 'variant-analysis') {
+        expect(variantAnalysisManagerStub.showView).to.have.been.calledOnceWith((selected as VariantAnalysisHistoryItem).variantAnalysis.id);
+      }
 
-    // the current item should have been selected
-    if (newSelected.t == 'local') {
-      expect(localQueriesResultsViewStub.showResults).to.have.been.calledOnceWith(newSelected);
-    } else if (toDelete.t == 'remote') {
-      expect(remoteQueriesManagerStub.openRemoteQueryResults).to.have.been.calledOnceWith((newSelected as RemoteQueryHistoryItem).queryId);
-    } else if (toDelete.t == 'variant-analysis') {
-      expect(variantAnalysisManagerStub.showView).to.have.been.calledOnceWith((newSelected as VariantAnalysisHistoryItem).variantAnalysis.id);
-    }
+      expect(queryHistoryManager.treeDataProvider.getCurrent()).to.deep.eq(selected);
+      expect(queryHistoryManager.treeDataProvider.allHistory).not.to.contain(toDelete);
+    });
+
+    it('should remove an item and select a new one', async () => {
+      queryHistoryManager = await createMockQueryHistory(allHistory);
+
+      // deleting the selected item automatically selects next item
+      const toDelete = allHistory[1];
+      const newSelected = allHistory[2];
+      // avoid triggering the callback by setting the field directly
+
+      // select the item we want
+      await queryHistoryManager.treeView.reveal(toDelete, { select: true });
+      await queryHistoryManager.handleRemoveHistoryItem(toDelete, [toDelete]);
+
+      if (toDelete.t == 'local') {
+        expect(toDelete.completedQuery!.dispose).to.have.been.calledOnce;
+      } else if (toDelete.t == 'remote') {
+        expect(remoteQueriesManagerStub.removeRemoteQuery).to.have.been.calledOnceWith((toDelete as RemoteQueryHistoryItem).queryId);
+      } else if (toDelete.t == 'variant-analysis') {
+        expect(variantAnalysisManagerStub.removeVariantAnalysis).to.have.been.calledOnceWith((toDelete as VariantAnalysisHistoryItem).variantAnalysis.id);
+      }
+
+      // the current item should have been selected
+      if (newSelected.t == 'local') {
+        expect(localQueriesResultsViewStub.showResults).to.have.been.calledOnceWith(newSelected);
+      } else if (toDelete.t == 'remote') {
+        expect(remoteQueriesManagerStub.openRemoteQueryResults).to.have.been.calledOnceWith((newSelected as RemoteQueryHistoryItem).queryId);
+      } else if (toDelete.t == 'variant-analysis') {
+        expect(variantAnalysisManagerStub.showView).to.have.been.calledOnceWith((newSelected as VariantAnalysisHistoryItem).variantAnalysis.id);
+      }
 
-    expect(queryHistoryManager.treeDataProvider.getCurrent()).to.eq(newSelected);
-    expect(queryHistoryManager.treeDataProvider.allHistory).not.to.contain(toDelete);
+      expect(queryHistoryManager.treeDataProvider.getCurrent()).to.eq(newSelected);
+      expect(queryHistoryManager.treeDataProvider.allHistory).not.to.contain(toDelete);
+    });
   });
 
   describe('HistoryTreeDataProvider', () => {