Chore: homepage tests (#6278)

src/widgets/openmediavault/component.test.jsx

@@ -0,0 +1,38 @@
+// @vitest-environment jsdom
+
+import { render, screen } from "@testing-library/react";
+import { describe, expect, it, vi } from "vitest";
+
+const { ServicesGetStatus, SmartGetList, DownloaderGetDownloadList } = vi.hoisted(() => ({
+  ServicesGetStatus: vi.fn(() => <div data-testid="services.getStatus" />),
+  SmartGetList: vi.fn(() => <div data-testid="smart.getListBg" />),
+  DownloaderGetDownloadList: vi.fn(() => <div data-testid="downloader.getDownloadList" />),
+}));
+
+vi.mock("./methods/services_get_status", () => ({ default: ServicesGetStatus }));
+vi.mock("./methods/smart_get_list", () => ({ default: SmartGetList }));
+vi.mock("./methods/downloader_get_downloadlist", () => ({ default: DownloaderGetDownloadList }));
+
+import Component from "./component";
+
+describe("widgets/openmediavault/component", () => {
+  it("routes services.getStatus method to ServicesGetStatus", () => {
+    render(<Component service={{ widget: { type: "openmediavault", method: "services.getStatus" } }} />);
+    expect(screen.getByTestId("services.getStatus")).toBeInTheDocument();
+  });
+
+  it("routes smart.getListBg method to SmartGetList", () => {
+    render(<Component service={{ widget: { type: "openmediavault", method: "smart.getListBg" } }} />);
+    expect(screen.getByTestId("smart.getListBg")).toBeInTheDocument();
+  });
+
+  it("routes downloader.getDownloadList method to DownloaderGetDownloadList", () => {
+    render(<Component service={{ widget: { type: "openmediavault", method: "downloader.getDownloadList" } }} />);
+    expect(screen.getByTestId("downloader.getDownloadList")).toBeInTheDocument();
+  });
+
+  it("returns null for unknown methods", () => {
+    const { container } = render(<Component service={{ widget: { type: "openmediavault", method: "nope" } }} />);
+    expect(container.firstChild).toBeNull();
+  });
+});

src/widgets/openmediavault/methods/downloader_get_downloadlist.test.jsx

@@ -0,0 +1,42 @@
+// @vitest-environment jsdom
+
+import { screen } from "@testing-library/react";
+import { describe, expect, it, vi } from "vitest";
+
+import { renderWithProviders } from "test-utils/render-with-providers";
+
+const { useWidgetAPI } = vi.hoisted(() => ({
+  useWidgetAPI: vi.fn(),
+}));
+
+vi.mock("utils/proxy/use-widget-api", () => ({ default: useWidgetAPI }));
+
+import Component from "./downloader_get_downloadlist";
+
+describe("widgets/openmediavault/methods/downloader_get_downloadlist", () => {
+  it("renders '-' values when data is missing", () => {
+    useWidgetAPI.mockReturnValue({ data: undefined, error: undefined });
+
+    renderWithProviders(<Component service={{ widget: { type: "openmediavault" } }} />, {
+      settings: { hideErrors: false },
+    });
+
+    expect(screen.getByText("openmediavault.downloading")).toBeInTheDocument();
+    expect(screen.getByText("openmediavault.total")).toBeInTheDocument();
+    expect(screen.getAllByText("-").length).toBeGreaterThan(0);
+  });
+
+  it("counts downloading and total items", () => {
+    useWidgetAPI.mockReturnValue({
+      data: { response: { data: [{ downloading: true }, { downloading: false }, { downloading: true }] } },
+      error: undefined,
+    });
+
+    renderWithProviders(<Component service={{ widget: { type: "openmediavault" } }} />, {
+      settings: { hideErrors: false },
+    });
+
+    expect(screen.getByText("2")).toBeInTheDocument();
+    expect(screen.getByText("3")).toBeInTheDocument();
+  });
+});

src/widgets/openmediavault/methods/services_get_status.test.jsx

@@ -0,0 +1,35 @@
+// @vitest-environment jsdom
+
+import { screen } from "@testing-library/react";
+import { describe, expect, it, vi } from "vitest";
+
+import { renderWithProviders } from "test-utils/render-with-providers";
+
+const { useWidgetAPI } = vi.hoisted(() => ({
+  useWidgetAPI: vi.fn(),
+}));
+
+vi.mock("utils/proxy/use-widget-api", () => ({ default: useWidgetAPI }));
+
+import Component from "./services_get_status";
+
+describe("widgets/openmediavault/methods/services_get_status", () => {
+  it("counts running/stopped/total services", () => {
+    useWidgetAPI.mockReturnValue({
+      data: { response: { data: [{ running: true }, { running: false }, { running: true }] } },
+      error: undefined,
+    });
+
+    renderWithProviders(<Component service={{ widget: { type: "openmediavault" } }} />, {
+      settings: { hideErrors: false },
+    });
+
+    expect(screen.getByText("openmediavault.running")).toBeInTheDocument();
+    expect(screen.getByText("openmediavault.stopped")).toBeInTheDocument();
+    expect(screen.getByText("openmediavault.total")).toBeInTheDocument();
+
+    expect(screen.getByText("2")).toBeInTheDocument();
+    expect(screen.getByText("1")).toBeInTheDocument();
+    expect(screen.getByText("3")).toBeInTheDocument();
+  });
+});

src/widgets/openmediavault/methods/smart_get_list.test.jsx

@@ -0,0 +1,41 @@
+// @vitest-environment jsdom
+
+import { screen } from "@testing-library/react";
+import { describe, expect, it, vi } from "vitest";
+
+import { renderWithProviders } from "test-utils/render-with-providers";
+
+const { useWidgetAPI } = vi.hoisted(() => ({
+  useWidgetAPI: vi.fn(),
+}));
+
+vi.mock("utils/proxy/use-widget-api", () => ({ default: useWidgetAPI }));
+
+import Component from "./smart_get_list";
+
+describe("widgets/openmediavault/methods/smart_get_list", () => {
+  it("counts passed/failed monitored disks", () => {
+    useWidgetAPI.mockReturnValue({
+      data: {
+        response: {
+          output: JSON.stringify({
+            data: [
+              { monitor: true, overallstatus: "GOOD" },
+              { monitor: true, overallstatus: "BAD" },
+              { monitor: false, overallstatus: "BAD" },
+            ],
+          }),
+        },
+      },
+      error: undefined,
+    });
+
+    renderWithProviders(<Component service={{ widget: { type: "openmediavault" } }} />, {
+      settings: { hideErrors: false },
+    });
+
+    expect(screen.getByText("openmediavault.passed")).toBeInTheDocument();
+    expect(screen.getByText("openmediavault.failed")).toBeInTheDocument();
+    expect(screen.getAllByText("1")).toHaveLength(2);
+  });
+});

src/widgets/openmediavault/proxy.js

@@ -125,7 +125,7 @@ export default async function proxyHandler(req, res) {
     if (success) {
       addCookieToJar(url, lResp.headers);
     } else {
-      res.status(lResp.status).json({ error: { message: `HTTP Error ${lResp.status}`, url, data: lResp.data } });
+      return res.status(lResp.status).json({ error: { message: `HTTP Error ${lResp.status}`, url, data: lResp.data } });
     }
 
     logger.debug("Retrying OpenMediaVault request after login.");

src/widgets/openmediavault/proxy.test.js

@@ -0,0 +1,291 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+import createMockRes from "test-utils/create-mock-res";
+
+const { httpProxy, getServiceWidget, cookieJar, logger } = vi.hoisted(() => ({
+  httpProxy: vi.fn(),
+  getServiceWidget: vi.fn(),
+  cookieJar: {
+    addCookieToJar: vi.fn(),
+    setCookieHeader: vi.fn(),
+  },
+  logger: {
+    debug: vi.fn(),
+    error: vi.fn(),
+  },
+}));
+
+vi.mock("utils/logger", () => ({
+  default: () => logger,
+}));
+vi.mock("utils/config/service-helpers", () => ({
+  default: getServiceWidget,
+}));
+vi.mock("utils/proxy/http", () => ({
+  httpProxy,
+}));
+vi.mock("utils/proxy/cookie-jar", () => cookieJar);
+vi.mock("widgets/widgets", () => ({
+  default: {
+    openmediavault: {
+      api: "{url}/rpc.php",
+    },
+  },
+}));
+
+import openmediavaultProxyHandler from "./proxy";
+
+describe("widgets/openmediavault/proxy", () => {
+  beforeEach(() => {
+    httpProxy.mockReset();
+    getServiceWidget.mockReset();
+    vi.clearAllMocks();
+  });
+
+  it("returns 400 when the query is missing group or service", async () => {
+    const req = { query: { service: "svc", index: "0" } };
+    const res = createMockRes();
+
+    await openmediavaultProxyHandler(req, res);
+
+    expect(res.statusCode).toBe(400);
+    expect(res.body).toEqual({ error: "Invalid proxy service type" });
+    expect(getServiceWidget).not.toHaveBeenCalled();
+  });
+
+  it("returns 400 when the widget cannot be resolved", async () => {
+    getServiceWidget.mockResolvedValue(null);
+
+    const req = { query: { group: "g", service: "svc", index: "0" } };
+    const res = createMockRes();
+
+    await openmediavaultProxyHandler(req, res);
+
+    expect(res.statusCode).toBe(400);
+    expect(res.body).toEqual({ error: "Invalid proxy service type" });
+  });
+
+  it("returns 403 when the service type does not support RPC", async () => {
+    getServiceWidget.mockResolvedValue({
+      type: "not-openmediavault",
+      url: "http://omv",
+      username: "u",
+      password: "p",
+      method: "foo.bar",
+    });
+
+    const req = { query: { group: "g", service: "svc", index: "0" } };
+    const res = createMockRes();
+
+    await openmediavaultProxyHandler(req, res);
+
+    expect(res.statusCode).toBe(403);
+    expect(res.body).toEqual({ error: "Service does not support RPC calls" });
+    expect(httpProxy).not.toHaveBeenCalled();
+  });
+
+  it("returns an HTTP error when the RPC call fails", async () => {
+    getServiceWidget.mockResolvedValue({
+      type: "openmediavault",
+      url: "http://omv",
+      username: "u",
+      password: "p",
+      method: "foo.bar",
+    });
+
+    httpProxy.mockResolvedValueOnce([500, "application/json", Buffer.from("nope"), {}]);
+
+    const req = { query: { group: "g", service: "svc", index: "0" } };
+    const res = createMockRes();
+
+    await openmediavaultProxyHandler(req, res);
+
+    expect(res.statusCode).toBe(500);
+    expect(res.body).toEqual(
+      expect.objectContaining({
+        error: expect.objectContaining({
+          message: "HTTP Error 500",
+          url: expect.any(URL),
+          data: expect.any(Buffer),
+        }),
+      }),
+    );
+  });
+
+  it("logs in after a 401 and retries the RPC call", async () => {
+    getServiceWidget.mockResolvedValue({
+      type: "openmediavault",
+      url: "http://omv",
+      username: "u",
+      password: "p",
+      method: "foo.bar",
+    });
+
+    httpProxy
+      // initial rpc unauthorized
+      .mockResolvedValueOnce([401, "application/json", Buffer.from(JSON.stringify({ response: {} })), {}])
+      // login rpc
+      .mockResolvedValueOnce([
+        200,
+        "application/json",
+        Buffer.from(JSON.stringify({ response: { authenticated: true } })),
+        { "set-cookie": ["sid=1"] },
+      ])
+      // retry rpc
+      .mockResolvedValueOnce([200, "application/json", Buffer.from(JSON.stringify({ response: { ok: true } })), {}]);
+
+    const req = { query: { group: "g", service: "svc", index: "0" } };
+    const res = createMockRes();
+
+    await openmediavaultProxyHandler(req, res);
+
+    expect(cookieJar.setCookieHeader).toHaveBeenCalled();
+    expect(cookieJar.addCookieToJar).toHaveBeenCalled();
+    expect(res.statusCode).toBe(200);
+    expect(res.body).toEqual(Buffer.from(JSON.stringify({ response: { ok: true } })));
+  });
+
+  it("returns after a failed login attempt (non-200 response)", async () => {
+    getServiceWidget.mockResolvedValue({
+      type: "openmediavault",
+      url: "http://omv",
+      username: "u",
+      password: "p",
+      method: "foo.bar",
+    });
+
+    httpProxy
+      // initial rpc unauthorized
+      .mockResolvedValueOnce([401, "application/json", Buffer.from(JSON.stringify({ response: {} })), {}])
+      // login rpc fails
+      .mockResolvedValueOnce([500, "application/json", Buffer.from("nope"), {}]);
+
+    const req = { query: { group: "g", service: "svc", index: "0" } };
+    const res = createMockRes();
+
+    await openmediavaultProxyHandler(req, res);
+
+    expect(res.statusCode).toBe(500);
+    expect(res.body).toEqual(
+      expect.objectContaining({
+        error: expect.objectContaining({
+          message: "HTTP Error 500",
+        }),
+      }),
+    );
+    expect(cookieJar.addCookieToJar).not.toHaveBeenCalled();
+    expect(httpProxy).toHaveBeenCalledTimes(2);
+  });
+
+  it("returns after a failed login attempt (not authenticated)", async () => {
+    getServiceWidget.mockResolvedValue({
+      type: "openmediavault",
+      url: "http://omv",
+      username: "u",
+      password: "p",
+      method: "foo.bar",
+    });
+
+    httpProxy
+      // initial rpc unauthorized
+      .mockResolvedValueOnce([401, "application/json", Buffer.from(JSON.stringify({ response: {} })), {}])
+      // login rpc returns authenticated false
+      .mockResolvedValueOnce([
+        200,
+        "application/json",
+        Buffer.from(JSON.stringify({ response: { authenticated: false } })),
+        {},
+      ]);
+
+    const req = { query: { group: "g", service: "svc", index: "0" } };
+    const res = createMockRes();
+
+    await openmediavaultProxyHandler(req, res);
+
+    expect(res.statusCode).toBe(401);
+    expect(res.body).toEqual(
+      expect.objectContaining({
+        error: expect.objectContaining({
+          message: "HTTP Error 401",
+        }),
+      }),
+    );
+    expect(cookieJar.addCookieToJar).not.toHaveBeenCalled();
+    expect(httpProxy).toHaveBeenCalledTimes(2);
+  });
+
+  it("handles background methods by polling for output", async () => {
+    getServiceWidget.mockResolvedValue({
+      type: "openmediavault",
+      url: "http://omv",
+      username: "u",
+      password: "p",
+      method: "foo.barBg",
+    });
+
+    httpProxy
+      // initial rpc returns filename for Bg output
+      .mockResolvedValueOnce([200, "application/json", Buffer.from(JSON.stringify({ response: "bg-1" })), {}])
+      // exec.getOutput returns ready output
+      .mockResolvedValueOnce([
+        200,
+        "application/json",
+        Buffer.from(JSON.stringify({ response: { running: false, outputPending: false, pos: 0, output: "ok" } })),
+        {},
+      ]);
+
+    const req = { query: { group: "g", service: "svc", index: "0" } };
+    const res = createMockRes();
+
+    await openmediavaultProxyHandler(req, res);
+
+    expect(res.statusCode).toBe(200);
+    expect(res.body).toEqual(
+      Buffer.from(JSON.stringify({ response: { running: false, outputPending: false, pos: 0, output: "ok" } })),
+    );
+  });
+
+  it("polls until background output is ready", async () => {
+    vi.useFakeTimers();
+
+    getServiceWidget.mockResolvedValue({
+      type: "openmediavault",
+      url: "http://omv",
+      username: "u",
+      password: "p",
+      method: "foo.barBg",
+    });
+
+    httpProxy
+      // initial rpc returns filename for Bg output
+      .mockResolvedValueOnce([200, "application/json", Buffer.from(JSON.stringify({ response: "bg-2" })), {}])
+      // running: true -> triggers poll sleep and retry
+      .mockResolvedValueOnce([
+        200,
+        "application/json",
+        Buffer.from(JSON.stringify({ response: { running: true, outputPending: true, pos: 1 } })),
+        {},
+      ])
+      // second poll completes
+      .mockResolvedValueOnce([
+        200,
+        "application/json",
+        Buffer.from(JSON.stringify({ response: { running: false, outputPending: false, pos: 2, output: "done" } })),
+        {},
+      ]);
+
+    const req = { query: { group: "g", service: "svc", index: "0" } };
+    const res = createMockRes();
+
+    const promise = openmediavaultProxyHandler(req, res);
+    await vi.runAllTimersAsync();
+    await promise;
+
+    expect(res.statusCode).toBe(200);
+    expect(res.body).toEqual(
+      Buffer.from(JSON.stringify({ response: { running: false, outputPending: false, pos: 2, output: "done" } })),
+    );
+
+    vi.useRealTimers();
+  });
+});

src/widgets/openmediavault/widget.test.js

@@ -0,0 +1,11 @@
+import { describe, it } from "vitest";
+
+import { expectWidgetConfigShape } from "test-utils/widget-config";
+
+import widget from "./widget";
+
+describe("openmediavault widget config", () => {
+  it("exports a valid widget config", () => {
+    expectWidgetConfigShape(widget);
+  });
+});