feat(ui): migrate discovery search and recovery

2026-10-13 00:49:24 +02:00
parent bfa0ab62f8
commit 34a4d6dc6b
15 changed files with 4049 additions and 56 deletions
@@ -1,6 +1,6 @@
 import React from "react";
 import "@testing-library/jest-dom";
-import { fireEvent, render, screen, waitFor } from "@testing-library/react";
+import { act, fireEvent, render, screen, waitFor, within } from "@testing-library/react";
 import { MemoryRouter } from "react-router-dom";
 import { api } from "./api";
 import { ConfirmProvider } from "./confirm";
@@ -19,7 +19,7 @@ function searchResponse(data: any[]) {
  mockedApi.get.mockImplementation((url) => Promise.resolve({ data: String(url).endsWith("saved-searches") ? [] : data } as any));
 }

-beforeEach(() => { window.localStorage.clear(); searchResponse([]); });
+beforeEach(() => { jest.resetAllMocks(); window.localStorage.clear(); searchResponse([]); });
 afterEach(() => jest.clearAllMocks());

 test("shows honest source metadata and offers the existing reviewed save flow", async () => {
@@ -69,7 +69,7 @@ test("sorts returned vacancies by title", async () => {
  await screen.findByText("2 vacancies found");
  fireEvent.mouseDown(screen.getByRole("combobox", { name: "Sort results" }));
  fireEvent.click(await screen.findByRole("option", { name: "Title A–Z" }));
-  expect(screen.getAllByRole("heading", { level: 6 }).map((element) => element.textContent)).toEqual(["Analyst", "Zoologist"]);
+  expect(screen.getAllByRole("heading", { level: 3 }).map((element) => element.textContent)).toEqual(["Analyst", "Zoologist"]);
 });

 test("renders the discovery workflow in Norwegian Bokmål", async () => {
@@ -155,3 +155,201 @@ test.each([null, { message: "not a list" }, [{ id: 7 }]])("rejects malformed sav
  expect(screen.queryByText("No saved searches yet.")).not.toBeInTheDocument();
  expect(screen.getByRole("button", { name: "Retry" })).toBeInTheDocument();
 });
+
+const savedSearch = { id: 7, name: "Backend Oslo", query: "backend", location: "Oslo", isActive: true, resultCount: 1, dismissedCount: 0 };
+const discoveredJob = { id: "new-1", title: "Platform Engineer", url: "https://example.test/new-1", source: "nav", countryCode: "NO" };
+
+function savedRun(saved = savedSearch, job = discoveredJob) {
+  return { data: { search: saved, jobs: [{ job, isNew: true, isDismissed: false }] } };
+}
+
+function savedFixture(saved = [savedSearch], jobs: any[] = []) {
+  mockedApi.get.mockImplementation((url) => Promise.resolve({ data: String(url).endsWith("saved-searches") ? saved : jobs } as any));
+}
+
+function deferred<T>() {
+  let resolve!: (value: T) => void;
+  let reject!: (reason: unknown) => void;
+  const promise = new Promise<T>((yes, no) => { resolve = yes; reject = no; });
+  return { promise, resolve, reject };
+}
+
+test("a manual search after saved-search results has no dismiss action belonging to the saved search", async () => {
+  savedFixture([savedSearch], [{ ...discoveredJob, id: "manual-1", title: "Manual vacancy" }]);
+  mockedApi.post.mockResolvedValueOnce(savedRun() as any);
+  renderPage();
+  fireEvent.click(await screen.findByRole("button", { name: "Check for new jobs" }));
+  await screen.findByText("Platform Engineer");
+  expect(screen.getByRole("button", { name: "Dismiss" })).toBeInTheDocument();
+  fireEvent.change(screen.getByLabelText("Role or company"), { target: { value: "manual query" } });
+  fireEvent.click(screen.getByRole("button", { name: "Search NAV" }));
+  await screen.findByText("Manual vacancy");
+  expect(screen.queryByRole("button", { name: "Dismiss" })).not.toBeInTheDocument();
+  expect(mockedApi.get).toHaveBeenCalledWith("/job-discovery/search", { params: { q: "manual query", location: "Oslo" } });
+  expect(mockedApi.patch).not.toHaveBeenCalled();
+});
+
+test("starting saved search B hides saved search A's results and actions while the B response is held", async () => {
+  const second = { ...savedSearch, id: 8, name: "Data Bergen", query: "data", location: "Bergen" };
+  const read = deferred<any>();
+  savedFixture([savedSearch, second]);
+  mockedApi.post.mockResolvedValueOnce(savedRun() as any).mockImplementationOnce(() => read.promise);
+  renderPage();
+  fireEvent.click((await screen.findAllByRole("button", { name: "Check for new jobs" }))[0]);
+  await screen.findByText("Platform Engineer");
+  fireEvent.click(screen.getAllByRole("button", { name: "Check for new jobs" })[1]);
+  expect(mockedApi.post).toHaveBeenLastCalledWith("/job-discovery/saved-searches/8/run");
+  expect(screen.queryByText("Platform Engineer")).not.toBeInTheDocument();
+  expect(screen.queryByRole("button", { name: "Dismiss" })).not.toBeInTheDocument();
+  expect(screen.getByLabelText("Role or company")).toHaveValue("data");
+  expect(screen.getByLabelText("Municipality")).toHaveValue("Bergen");
+  expect(screen.getAllByRole("button", { name: "Check for new jobs" }).every((button) => (button as HTMLButtonElement).disabled)).toBe(true);
+  await act(async () => { read.resolve(savedRun(second, { ...discoveredJob, id: "b-1", title: "Data Engineer" })); });
+  expect(await screen.findByText("Data Engineer")).toBeInTheDocument();
+  expect(mockedApi.post).toHaveBeenCalledTimes(2);
+  expect(mockedApi.patch).not.toHaveBeenCalled();
+});
+
+test("retrying a failed saved-search run repeats that saved ID instead of running a manual query", async () => {
+  const retry = deferred<any>();
+  savedFixture();
+  mockedApi.post.mockRejectedValueOnce(new Error("synthetic NAV unavailable")).mockImplementationOnce(() => retry.promise);
+  renderPage();
+  fireEvent.click(await screen.findByRole("button", { name: "Check for new jobs" }));
+  const retryButton = await screen.findByRole("button", { name: "Retry" });
+  fireEvent.change(screen.getByLabelText("Role or company"), { target: { value: "unsubmitted edited query" } });
+  fireEvent.change(screen.getByLabelText("Municipality"), { target: { value: "unsubmitted Bergen" } });
+  fireEvent.click(retryButton);
+  await waitFor(() => expect(mockedApi.post).toHaveBeenCalledTimes(2));
+  expect(mockedApi.post.mock.calls.map(([url]) => url)).toEqual(["/job-discovery/saved-searches/7/run", "/job-discovery/saved-searches/7/run"]);
+  expect(mockedApi.get.mock.calls.some(([url]) => url === "/job-discovery/search")).toBe(false);
+  expect(screen.getByLabelText("Role or company")).toHaveValue("unsubmitted edited query");
+  expect(screen.getByLabelText("Municipality")).toHaveValue("unsubmitted Bergen");
+  expect(screen.queryByRole("button", { name: "Dismiss" })).not.toBeInTheDocument();
+  await act(async () => { retry.resolve(savedRun()); });
+  expect(await screen.findByText("Platform Engineer")).toBeInTheDocument();
+  expect(screen.getByRole("button", { name: "Dismiss" })).toBeInTheDocument();
+  expect(screen.getByLabelText("Role or company")).toHaveValue("unsubmitted edited query");
+  expect(screen.getByLabelText("Municipality")).toHaveValue("unsubmitted Bergen");
+});
+
+test("failed saved-search creation retains its draft and recovers only through the save action", async () => {
+  mockedApi.post.mockRejectedValueOnce(new Error("synthetic save failure")).mockResolvedValueOnce({ data: { ...savedSearch, name: "My search", query: "developer", location: "Bergen" } } as any);
+  renderPage();
+  await screen.findByText("No saved searches yet.");
+  fireEvent.change(screen.getByLabelText("Role or company"), { target: { value: "developer" } });
+  fireEvent.change(screen.getByLabelText("Municipality"), { target: { value: "Bergen" } });
+  fireEvent.change(screen.getByLabelText("Search name"), { target: { value: "My search" } });
+  fireEvent.click(screen.getByRole("button", { name: "Save search" }));
+  expect(await screen.findByText("The search could not be saved.")).toBeInTheDocument();
+  expect(screen.queryByRole("button", { name: "Retry" })).not.toBeInTheDocument();
+  expect(screen.getByLabelText("Search name")).toHaveValue("My search");
+  expect(screen.getByLabelText("Role or company")).toHaveValue("developer");
+  expect(screen.getByLabelText("Municipality")).toHaveValue("Bergen");
+  expect(mockedApi.post).toHaveBeenCalledTimes(1);
+  fireEvent.click(screen.getByRole("button", { name: "Save search" }));
+  expect(await screen.findByText("My search")).toBeInTheDocument();
+  expect(mockedApi.post).toHaveBeenCalledTimes(2);
+  expect(mockedApi.post).toHaveBeenLastCalledWith("/job-discovery/saved-searches", { name: "My search", query: "developer", location: "Bergen" });
+  expect(mockedApi.get).toHaveBeenCalledTimes(1);
+});
+
+test("a failed alert toggle retains its checked state and recovers through that same toggle without manual search retry", async () => {
+  savedFixture();
+  mockedApi.patch.mockRejectedValueOnce(new Error("synthetic alerts failure")).mockResolvedValueOnce({ data: { ...savedSearch, isActive: false } } as any);
+  renderPage();
+  const toggle = await screen.findByRole("switch", { name: "Automatic alerts" });
+  fireEvent.click(toggle);
+  expect(await screen.findByText("The alert setting could not be updated. Try again.")).toBeInTheDocument();
+  expect(toggle).toBeChecked();
+  expect(screen.queryByRole("button", { name: "Retry" })).not.toBeInTheDocument();
+  expect(mockedApi.patch).toHaveBeenCalledTimes(1);
+  fireEvent.click(toggle);
+  await waitFor(() => expect(toggle).not.toBeChecked());
+  expect(mockedApi.patch).toHaveBeenCalledTimes(2);
+  expect(mockedApi.patch).toHaveBeenLastCalledWith("/job-discovery/saved-searches/7", { isActive: false });
+  expect(mockedApi.get).toHaveBeenCalledTimes(1);
+});
+
+test("failed saved-search deletion preserves the search and requires another explicit confirmation to recover", async () => {
+  savedFixture();
+  mockedApi.delete.mockRejectedValueOnce(new Error("synthetic delete failure")).mockResolvedValueOnce({ data: null } as any);
+  renderPage();
+  fireEvent.click(await screen.findByRole("button", { name: "Delete" }));
+  let dialog = await screen.findByRole("dialog", { name: "Delete saved search?" });
+  fireEvent.click(within(dialog).getByRole("button", { name: "Delete" }));
+  expect(await screen.findByText("The saved search could not be deleted.")).toBeInTheDocument();
+  await waitFor(() => expect(screen.queryByRole("dialog")).not.toBeInTheDocument());
+  expect(screen.getByText("Backend Oslo")).toBeInTheDocument();
+  expect(screen.queryByRole("button", { name: "Retry" })).not.toBeInTheDocument();
+  expect(mockedApi.delete).toHaveBeenCalledTimes(1);
+  fireEvent.click(screen.getByRole("button", { name: "Delete" }));
+  dialog = await screen.findByRole("dialog", { name: "Delete saved search?" });
+  fireEvent.click(within(dialog).getByRole("button", { name: "Delete" }));
+  await waitFor(() => expect(screen.queryByText("Backend Oslo")).not.toBeInTheDocument());
+  expect(mockedApi.delete).toHaveBeenCalledTimes(2);
+  expect(mockedApi.delete).toHaveBeenLastCalledWith("/job-discovery/saved-searches/7");
+  expect(mockedApi.get).toHaveBeenCalledTimes(1);
+});
+
+test("failed dismissal retains the vacancy and recovers only through that same result's dismiss action", async () => {
+  savedFixture();
+  mockedApi.post.mockResolvedValueOnce(savedRun() as any);
+  mockedApi.patch.mockRejectedValueOnce(new Error("synthetic dismiss failure")).mockResolvedValueOnce({ data: null } as any);
+  renderPage();
+  fireEvent.click(await screen.findByRole("button", { name: "Check for new jobs" }));
+  await screen.findByText("Platform Engineer");
+  fireEvent.click(screen.getByRole("button", { name: "Dismiss" }));
+  expect(await screen.findByText("The vacancy could not be dismissed.")).toBeInTheDocument();
+  expect(screen.getByText("Platform Engineer")).toBeInTheDocument();
+  expect(screen.queryByRole("button", { name: "Retry" })).not.toBeInTheDocument();
+  expect(mockedApi.patch).toHaveBeenCalledTimes(1);
+  fireEvent.click(screen.getByRole("button", { name: "Dismiss" }));
+  await waitFor(() => expect(screen.queryByText("Platform Engineer")).not.toBeInTheDocument());
+  expect(mockedApi.patch).toHaveBeenCalledTimes(2);
+  expect(mockedApi.patch).toHaveBeenLastCalledWith("/job-discovery/saved-searches/7/results/new-1/dismiss", { isDismissed: true });
+  expect(mockedApi.get).toHaveBeenCalledTimes(1);
+});
+
+test("a held saved-search creation locks its request snapshot and prevents a second start while preserving a failed draft", async () => {
+  const write = deferred<any>();
+  mockedApi.post.mockImplementationOnce(() => write.promise);
+  renderPage();
+  await screen.findByText("No saved searches yet.");
+  fireEvent.change(screen.getByLabelText("Role or company"), { target: { value: "  developer  " } });
+  fireEvent.change(screen.getByLabelText("Municipality"), { target: { value: "  Bergen  " } });
+  fireEvent.change(screen.getByLabelText("Search name"), { target: { value: "  Review my search  " } });
+  const save = screen.getByRole("button", { name: "Save search" });
+  fireEvent.click(save);
+  expect(mockedApi.post).toHaveBeenCalledWith("/job-discovery/saved-searches", { name: "Review my search", query: "developer", location: "Bergen" });
+  expect(save).toBeDisabled();
+  expect(screen.getByLabelText("Role or company")).toBeDisabled();
+  expect(screen.getByLabelText("Municipality")).toBeDisabled();
+  expect(screen.getByLabelText("Search name")).toBeDisabled();
+  fireEvent.click(save);
+  expect(mockedApi.post).toHaveBeenCalledTimes(1);
+  await act(async () => { write.reject(new Error("synthetic save failure")); });
+  expect(await screen.findByText("The search could not be saved.")).toBeInTheDocument();
+  expect(screen.getByLabelText("Role or company")).toHaveValue("  developer  ");
+  expect(screen.getByLabelText("Municipality")).toHaveValue("  Bergen  ");
+  expect(screen.getByLabelText("Search name")).toHaveValue("  Review my search  ");
+  expect(save).toBeEnabled();
+  expect(mockedApi.post).toHaveBeenCalledTimes(1);
+});
+
+test("a saved-run failure follows the current language without refetching or replaying the request", async () => {
+  savedFixture();
+  mockedApi.post.mockRejectedValueOnce(new Error("synthetic NAV unavailable"));
+  renderPage();
+  fireEvent.click(await screen.findByRole("button", { name: "Check for new jobs" }));
+  expect(await screen.findByText("NAV job discovery is temporarily unavailable.")).toBeInTheDocument();
+  act(() => { window.dispatchEvent(new StorageEvent("storage", { key: "uiLanguage", newValue: "nb" })); });
+  expect(screen.getByText("NAVs jobbsøk er midlertidig utilgjengelig.")).toBeInTheDocument();
+  expect(screen.queryByText("NAV job discovery is temporarily unavailable.")).not.toBeInTheDocument();
+  expect(screen.getByLabelText("Rolle eller bedrift")).toHaveValue("backend");
+  expect(screen.getByLabelText("Kommune")).toHaveValue("Oslo");
+  expect(mockedApi.get).toHaveBeenCalledTimes(1);
+  expect(mockedApi.post).toHaveBeenCalledTimes(1);
+  expect(mockedApi.patch).not.toHaveBeenCalled();
+  expect(mockedApi.delete).not.toHaveBeenCalled();
+});