Merge pull request #21288 from guerler/update_last_queue

Update last queue process handler

Author: guerler

client/src/components/Dataset/DatasetView.test.js

@@ -41,6 +41,7 @@ const mockDataset = {
     genome_build: "hg38",
     misc_blurb: "100 lines",
     misc_info: "Additional info",
+    peek: "Needs a peek",
 };
 
 const errorDataset = { ...mockDataset, state: "error" };
@@ -102,7 +103,7 @@ async function mountDatasetView(tab = "preview", options = {}) {
         attachTo: document.createElement("div"),
         stubs: {
             // Only shallow stub certain components
-            "font-awesome-icon": true,
+            FontAwesomeIcon: true,
             Heading: {
                 template: "<div><slot></slot></div>",
                 props: ["h1", "separator"],
@@ -183,10 +184,20 @@ async function mountLoadingDatasetView() {
 
 describe("DatasetView", () => {
     beforeEach(() => {
+        class IO {
+            constructor() {}
+            observe() {}
+            unobserve() {}
+            disconnect() {}
+        }
+        global.IntersectionObserver = IO;
+        global.MutationObserver = IO;
         server.use(
             http.get("/api/datasets/:dataset_id", ({ response }) => {
                 return response(200).json(mockDataset);
             }),
+            http.get("/api/configuration", ({ response }) => response(200).json({})),
+            http.get("/api/plugins", ({ response }) => response(200).json([])),
         );
     });
 
@@ -201,8 +212,8 @@ describe("DatasetView", () => {
         it("shows loading message when dataset is loading", async () => {
             const wrapper = await mountLoadingDatasetView();
             expect(wrapper.find(".loading-message").exists()).toBe(true);
-            expect(wrapper.find(".loading-message").text()).toBe("Loading dataset details...");
-            expect(wrapper.find(".dataset-view").exists()).toBe(false);
+            expect(wrapper.find(".loading-message").text()).toBe("Loading...");
+            expect(wrapper.find(".dataset-view").exists()).toBe(true);
         });
 
         it("renders dataset information", async () => {

client/src/components/Markdown/Sections/Elements/HistoryDatasetDisplay.test.js

@@ -30,6 +30,7 @@ describe("History Tabular Dataset Display", () => {
         extension: "tabular",
         name: "someName",
         state: "ok",
+        peek: "needs a peek",
     };
     const tabularTableDataCounts = tabularMetaData.metadata_columns * tabularMetaData.metadata_data_lines;
 
@@ -58,7 +59,7 @@ describe("History Text Dataset Display", () => {
     let wrapper;
     const datasetId = "otherId";
     const text = { item_data: "some text" };
-    const textMetaData = { extension: "txt", name: "someName", state: "ok" };
+    const textMetaData = { extension: "txt", name: "someName", state: "ok", peek: "needs a peek" };
 
     async function mountTarget() {
         server.resetHandlers();

client/src/components/Workflow/List/WorkflowList.test.ts

@@ -6,19 +6,23 @@ import flushPromises from "flush-promises";
 import { setActivePinia } from "pinia";
 import VueRouter from "vue-router";
 
-import { HttpResponse, useServerMock } from "@/api/client/__mocks__";
+import { loadWorkflows } from "@/api/workflows";
 import { useUserStore } from "@/stores/userStore";
 
 import { generateRandomWorkflowList } from "../testUtils";
 
 import WorkflowList from "./WorkflowList.vue";
 
+jest.mock("@/api/workflows", () => ({
+    loadWorkflows: jest.fn(),
+}));
+
+const mockedLoadWorkflows = loadWorkflows as jest.Mock;
+
 const localVue = getLocalVue();
 localVue.use(VueRouter);
 const router = new VueRouter();
 
-const { server, http } = useServerMock();
-
 const FAKE_USER_ID = "fake_user_id";
 const FAKE_USERNAME = "fake_username";
 const FAKE_USER_EMAIL = "fake_user_email";
@@ -48,23 +52,12 @@ async function mountWorkflowList() {
 
 describe("WorkflowList", () => {
     beforeEach(() => {
-        server.use(
-            http.get("/api/workflows/{workflow_id}/counts", ({ response }) => {
-                return response(200).json({});
-            }),
-        );
-
-        // The use of the tool tip in statelesstag without a real dom is causing issues
         suppressBootstrapVueWarnings();
+        jest.clearAllMocks();
     });
 
     it("render empty workflow list", async () => {
-        server.use(
-            http.get("/api/workflows", ({ response }) => {
-                return response(200).json([]);
-            }),
-        );
-
+        mockedLoadWorkflows.mockResolvedValue({ data: [], totalMatches: 0 });
         const wrapper = await mountWorkflowList();
 
         expect(wrapper.findAll(".workflow-card")).toHaveLength(0);
@@ -73,14 +66,7 @@ describe("WorkflowList", () => {
 
     it("render workflow list", async () => {
         const FAKE_WORKFLOWS = generateRandomWorkflowList(FAKE_USERNAME, 10);
-
-        server.use(
-            http.get("/api/workflows", ({ response }) => {
-                // TODO: We use untyped here because the response is not yet defined in the schema
-                return response.untyped(HttpResponse.json(FAKE_WORKFLOWS));
-            }),
-        );
-
+        mockedLoadWorkflows.mockResolvedValue({ data: FAKE_WORKFLOWS, totalMatches: 10 });
         const wrapper = await mountWorkflowList();
 
         expect(wrapper.findAll(".workflow-card")).toHaveLength(10);
@@ -93,14 +79,7 @@ describe("WorkflowList", () => {
     it("toggle show deleted workflows", async () => {
         const FAKE_WORKFLOWS = generateRandomWorkflowList(FAKE_USERNAME, 10);
         FAKE_WORKFLOWS.forEach((w) => (w.deleted = true));
-
-        server.use(
-            http.get("/api/workflows", ({ response }) => {
-                // TODO: We use untyped here because the response is not yet defined in the schema
-                return response.untyped(HttpResponse.json(FAKE_WORKFLOWS));
-            }),
-        );
-
+        mockedLoadWorkflows.mockResolvedValue({ data: FAKE_WORKFLOWS, totalMatches: 10 });
         const wrapper = await mountWorkflowList();
 
         expect((wrapper.find("#workflow-list-filter input").element as HTMLInputElement).value).toBe("");

client/src/composables/keyedCache.test.ts

@@ -35,7 +35,7 @@ describe("useKeyedCache", () => {
         await flushPromises();
         expect(isLoadingItem.value(id)).toBeFalsy();
         expect(storedItems.value[id]).toEqual(item);
-        expect(fetchItem).toHaveBeenCalledWith(fetchParams);
+        expect(fetchItem).toHaveBeenCalledWith(fetchParams, expect.anything());
     });
 
     it("should not fetch the item if it is already stored", async () => {
@@ -96,7 +96,7 @@ describe("useKeyedCache", () => {
         await flushPromises();
         expect(isLoadingItem.value(id)).toBeFalsy();
         expect(storedItems.value[id]).toEqual(item);
-        expect(fetchItem).toHaveBeenCalledWith(fetchParams);
+        expect(fetchItem).toHaveBeenCalledWith(fetchParams, expect.anything());
         expect(shouldFetch).toHaveBeenCalled();
     });
 
@@ -119,7 +119,7 @@ describe("useKeyedCache", () => {
         expect(isLoadingItem.value(id)).toBeFalsy();
         expect(storedItems.value[id]).toEqual(item);
         expect(fetchItem).toHaveBeenCalledTimes(1);
-        expect(fetchItem).toHaveBeenCalledWith(fetchParams);
+        expect(fetchItem).toHaveBeenCalledWith(fetchParams, expect.anything());
     });
 
     it("should not fetch the item if it is already being fetched, even if shouldFetch returns true", async () => {
@@ -142,7 +142,7 @@ describe("useKeyedCache", () => {
         expect(isLoadingItem.value(id)).toBeFalsy();
         expect(storedItems.value[id]).toEqual(item);
         expect(fetchItem).toHaveBeenCalledTimes(1);
-        expect(fetchItem).toHaveBeenCalledWith(fetchParams);
+        expect(fetchItem).toHaveBeenCalledWith(fetchParams, expect.anything());
         expect(shouldFetch).toHaveBeenCalled();
     });
 
@@ -165,7 +165,7 @@ describe("useKeyedCache", () => {
         await flushPromises();
         expect(isLoadingItem.value(id)).toBeFalsy();
         expect(storedItems.value[id]).toEqual(item);
-        expect(fetchItem).toHaveBeenCalledWith(fetchParams);
+        expect(fetchItem).toHaveBeenCalledWith(fetchParams, expect.anything());
     });
 
     it("should accept a computed for shouldFetch", async () => {
@@ -188,7 +188,26 @@ describe("useKeyedCache", () => {
         await flushPromises();
         expect(isLoadingItem.value(id)).toBeFalsy();
         expect(storedItems.value[id]).toEqual(item);
-        expect(fetchItem).toHaveBeenCalledWith(fetchParams);
+        expect(fetchItem).toHaveBeenCalledWith(fetchParams, expect.anything());
         expect(shouldFetch).toHaveBeenCalled();
     });
+
+    it("should handle fake timers without hanging when advanced manually", async () => {
+        jest.useFakeTimers();
+        const id = "1";
+        const item = { id, name: "Item 1" };
+        fetchItem.mockImplementation(() => {
+            return new Promise((resolve) => {
+                setTimeout(() => resolve(item), 10);
+            });
+        });
+        const { getItemById } = useKeyedCache<ItemData>(fetchItem);
+        getItemById.value(id);
+        getItemById.value(id);
+        getItemById.value(id);
+        await flushPromises();
+        jest.runOnlyPendingTimers();
+        await flushPromises();
+        expect(true).toBe(true);
+    });
 });