fix: add some tests

Author: craigyu

frontend/src/__test__/components/Dashboard/OpeningSubmissionTrend.test.tsx

@@ -97,4 +97,50 @@ describe("OpeningSubmissionTrend Component", () => {
 
     await waitFor(() => expect(screen.getByTestId("grouped-bar-chart")).toBeInTheDocument());
   });
+
+  it("should update year and refetch data", async () => {
+    (fetchOpeningsOrgUnits as vi.Mock).mockResolvedValueOnce([
+      { code: "DAS", description: "District A" },
+    ]);
+    (fetchUserSubmissionTrends as vi.Mock).mockResolvedValue([]);
+
+    const { getByLabelText, getByText } = await renderWithProviders();
+
+    // Wait for dropdowns to appear
+    await waitFor(() => {
+      expect(getByText("Opening submission year")).toBeInTheDocument();
+    });
+
+    const yearDropdownInput = getByLabelText("Opening submission year", {
+      selector: 'input',
+    });
+
+    // Simulate input value change
+    fireEvent.change(yearDropdownInput, { target: { value: "2022" } });
+
+    // Verify it still renders correctly after interaction
+    expect(getByText("Opening submission per year")).toBeInTheDocument();
+  });
+
+  it("should update org units and trigger data fetch", async () => {
+    (fetchOpeningsOrgUnits as vi.Mock).mockResolvedValueOnce([
+      { code: "DAS", description: "District A" },
+    ]);
+    (fetchUserSubmissionTrends as vi.Mock).mockResolvedValue([]); // allow refetch
+
+    const { getByText, getAllByRole } = await renderWithProviders();
+
+    await waitFor(() => expect(getByText("District")).toBeInTheDocument());
+
+    const dropdowns = getAllByRole("combobox");
+    expect(dropdowns.length).toBeGreaterThan(0);
+  });
+
+  it("should show loading spinner when fetching", async () => {
+    (fetchUserSubmissionTrends as vi.Mock).mockImplementation(() => new Promise(() => { }));
+    const { container } = await renderWithProviders();
+
+    const spinner = container.querySelector(".trend-loading-spinner");
+    expect(spinner).toBeInTheDocument();
+  });
 });

frontend/src/__test__/components/SilvicultureSearch/utils.test.tsx

@@ -0,0 +1,91 @@
+import { describe, it, expect } from "vitest";
+import { hasAnyActiveFilters } from "../../../components/SilvicultureSearch/OpeningSearch/utils";
+import { OpeningSearchFilterType } from "../../../components/SilvicultureSearch/OpeningSearch/definitions";
+import CodeDescriptionDto from "../../../types/CodeDescriptionType";
+
+describe("hasAnyActiveFilters", () => {
+  const mockCodeDesc = (code: string, desc: string): CodeDescriptionDto => ({
+    code,
+    description: desc,
+  });
+
+  it("should return false when all filters are empty or undefined", () => {
+    const filters: OpeningSearchFilterType = {};
+    expect(hasAnyActiveFilters(filters)).toBe(false);
+  });
+
+  it("should return false when only dateType is set", () => {
+    const filters: OpeningSearchFilterType = {
+      dateType: { code: "update", description: "Update" },
+    };
+    expect(hasAnyActiveFilters(filters)).toBe(false);
+  });
+
+  it("should return true if an array filter has values", () => {
+    const filters: OpeningSearchFilterType = {
+      orgUnit: [mockCodeDesc("DAS", "District A")],
+    };
+    expect(hasAnyActiveFilters(filters)).toBe(true);
+  });
+
+  it("should return true if a string filter has non-empty value", () => {
+    const filters: OpeningSearchFilterType = {
+      mainSearchTerm: "test search",
+    };
+    expect(hasAnyActiveFilters(filters)).toBe(true);
+  });
+
+  it("should return false if string filter is empty or whitespace", () => {
+    expect(hasAnyActiveFilters({ mainSearchTerm: "" })).toBe(false);
+    expect(hasAnyActiveFilters({ mainSearchTerm: "   " })).toBe(false);
+  });
+
+  it("should return true if a boolean filter is true", () => {
+    expect(hasAnyActiveFilters({ myOpenings: true })).toBe(true);
+    expect(hasAnyActiveFilters({ submittedToFrpa: true })).toBe(true);
+  });
+
+  it("should return false if boolean is false or undefined", () => {
+    expect(hasAnyActiveFilters({ myOpenings: false })).toBe(false);
+    expect(hasAnyActiveFilters({ submittedToFrpa: false })).toBe(false);
+  });
+
+  it("should return true if a date string is set", () => {
+    const filters: OpeningSearchFilterType = {
+      updateDateStart: "2024-01-01",
+    };
+    expect(hasAnyActiveFilters(filters)).toBe(true);
+  });
+
+  it("should return true if a number filter is present", () => {
+    const filters: OpeningSearchFilterType = {
+      page: 1,
+    };
+    expect(hasAnyActiveFilters(filters)).toBe(true);
+  });
+
+  it("should return true if multiple filters are present", () => {
+    const filters: OpeningSearchFilterType = {
+      statusList: [mockCodeDesc("APP", "Approved")],
+      mainSearchTerm: "waldo",
+      cuttingPermitId: "WA-001",
+      myOpenings: true,
+      dateType: { code: "update", description: "Update" },
+    };
+    expect(hasAnyActiveFilters(filters)).toBe(true);
+  });
+
+  it("should return false if all filters are explicitly empty", () => {
+    const filters: OpeningSearchFilterType = {
+      mainSearchTerm: "",
+      statusList: [],
+      orgUnit: [],
+      myOpenings: false,
+      submittedToFrpa: false,
+      disturbanceDateStart: "",
+      updateDateEnd: "",
+      dateType: { code: "update", description: "Update" },
+    };
+    expect(hasAnyActiveFilters(filters)).toBe(false);
+  });
+});

frontend/src/__test__/utils/UrlUtils.test.ts

@@ -0,0 +1,72 @@
+import { describe, it, expect } from "vitest";
+import { buildQueryString } from "../../utils/UrlUtils";
+
+describe("buildQueryString", () => {
+  it("should build query string from flat key-value pairs", () => {
+    const params = {
+      page: 1,
+      search: "tree",
+      active: true,
+    };
+
+    const query = buildQueryString(params);
+    expect(query).toBe("page=1&search=tree&active=true");
+  });
+
+  it("should omit keys with undefined or null values", () => {
+    const params = {
+      search: "forest",
+      sort: undefined,
+      filter: null,
+    };
+
+    const query = buildQueryString(params);
+    expect(query).toBe("search=forest");
+  });
+
+  it("should convert arrays into comma-separated strings", () => {
+    const params = {
+      orgUnit: ["A", "B", "C"],
+      status: ["Open", "Closed"],
+    };
+
+    const query = buildQueryString(params);
+    expect(query).toBe("orgUnit=A%2CB%2CC&status=Open%2CClosed");
+  });
+
+  it("should skip empty arrays", () => {
+    const params = {
+      orgUnit: [],
+      region: "North",
+    };
+
+    const query = buildQueryString(params);
+    expect(query).toBe("region=North");
+  });
+
+  it("should handle mixed types and skip empty or falsy fields properly", () => {
+    const params = {
+      page: 1,
+      dateType: "Update",
+      updateDateStart: "2024-03-01",
+      updateDateEnd: "2024-03-10",
+      tags: [],
+      extra: null,
+      debug: undefined,
+    };
+
+    const query = buildQueryString(params);
+    expect(query).toBe("page=1&dateType=Update&updateDateStart=2024-03-01&updateDateEnd=2024-03-10");
+  });
+
+  it("should return empty string if all values are null/undefined/empty arrays", () => {
+    const params = {
+      foo: undefined,
+      bar: null,
+      list: [],
+    };
+
+    const query = buildQueryString(params);
+    expect(query).toBe("");
+  });
+});