test: expand coverage for proxy handlers

src/utils/proxy/handlers/credentialed.test.js

@@ -1,8 +1,11 @@
-import { describe, expect, it, vi } from "vitest";
+import { beforeEach, describe, expect, it, vi } from "vitest";
 
 const { httpProxy } = vi.hoisted(() => ({ httpProxy: vi.fn() }));
 const { validateWidgetData } = vi.hoisted(() => ({ validateWidgetData: vi.fn(() => true) }));
 const { getServiceWidget } = vi.hoisted(() => ({ getServiceWidget: vi.fn() }));
+const { getSettings } = vi.hoisted(() => ({
+  getSettings: vi.fn(() => ({ providers: { finnhub: "finnhub-token" } })),
+}));
 
 vi.mock("utils/logger", () => ({
   default: () => ({
@@ -14,12 +17,17 @@ vi.mock("utils/logger", () => ({
 vi.mock("utils/proxy/http", () => ({ httpProxy }));
 vi.mock("utils/proxy/validate-widget-data", () => ({ default: validateWidgetData }));
 vi.mock("utils/config/service-helpers", () => ({ default: getServiceWidget }));
+vi.mock("utils/config/config", () => ({ getSettings }));
 
 // Keep the widget registry minimal so the test doesn't import the whole widget graph.
 vi.mock("widgets/widgets", () => ({
   default: {
     linkwarden: { api: "{url}/api/v1/{endpoint}" },
     nextcloud: { api: "{url}/ocs/v2.php/apps/serverinfo/api/v1/{endpoint}" },
+    truenas: { api: "{url}/api/v2.0/{endpoint}" },
+    proxmoxbackupserver: { api: "{url}/api2/json/{endpoint}" },
+    checkmk: { api: "{url}/{endpoint}" },
+    stocks: { api: "{url}/{endpoint}" },
   },
 }));
 
@@ -51,6 +59,11 @@ function createMockRes() {
 }
 
 describe("utils/proxy/handlers/credentialed", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    validateWidgetData.mockReturnValue(true);
+  });
+
   it("uses Bearer auth for linkwarden widgets", async () => {
     getServiceWidget.mockResolvedValue({ type: "linkwarden", url: "http://example", key: "token" });
     httpProxy.mockResolvedValue([200, "application/json", { ok: true }]);
@@ -80,4 +93,119 @@ describe("utils/proxy/handlers/credentialed", () => {
     expect(params.headers["NC-Token"]).toBe("nc-token");
     expect(params.headers.Authorization).toBeUndefined();
   });
+
+  it("uses basic auth for truenas when key is not provided", async () => {
+    getServiceWidget.mockResolvedValue({ type: "truenas", url: "http://nas", username: "u", password: "p" });
+    httpProxy.mockResolvedValue([200, "application/json", { ok: true }]);
+
+    const req = { method: "GET", query: { group: "g", service: "s", endpoint: "system/info", index: 0 } };
+    const res = createMockRes();
+
+    await credentialedProxyHandler(req, res);
+
+    const [, params] = httpProxy.mock.calls.at(-1);
+    expect(params.headers.Authorization).toMatch(/^Basic /);
+  });
+
+  it("sets PBSAPIToken auth and removes content-type for proxmoxbackupserver", async () => {
+    getServiceWidget.mockResolvedValue({
+      type: "proxmoxbackupserver",
+      url: "http://pbs",
+      username: "u",
+      password: "p",
+    });
+    httpProxy.mockResolvedValue([200, "application/json", { ok: true }]);
+
+    const req = { method: "GET", query: { group: "g", service: "s", endpoint: "nodes", index: 0 } };
+    const res = createMockRes();
+
+    await credentialedProxyHandler(req, res);
+
+    const [, params] = httpProxy.mock.calls.at(-1);
+    expect(params.headers["Content-Type"]).toBeUndefined();
+    expect(params.headers.Authorization).toBe("PBSAPIToken=u:p");
+  });
+
+  it("uses checkmk's Bearer username password auth format", async () => {
+    getServiceWidget.mockResolvedValue({ type: "checkmk", url: "http://checkmk", username: "u", password: "p" });
+    httpProxy.mockResolvedValue([200, "application/json", { ok: true }]);
+
+    const req = {
+      method: "GET",
+      query: { group: "g", service: "s", endpoint: "domain-types/host_config/collections/all", index: 0 },
+    };
+    const res = createMockRes();
+
+    await credentialedProxyHandler(req, res);
+
+    const [, params] = httpProxy.mock.calls.at(-1);
+    expect(params.headers.Accept).toBe("application/json");
+    expect(params.headers.Authorization).toBe("Bearer u p");
+  });
+
+  it("injects the configured finnhub provider token for stocks widgets", async () => {
+    getServiceWidget.mockResolvedValue({ type: "stocks", url: "http://stocks", provider: "finnhub" });
+    httpProxy.mockResolvedValue([200, "application/json", { ok: true }]);
+
+    const req = { method: "GET", query: { group: "g", service: "s", endpoint: "quote", index: 0 } };
+    const res = createMockRes();
+
+    await credentialedProxyHandler(req, res);
+
+    const [, params] = httpProxy.mock.calls.at(-1);
+    expect(params.headers["X-Finnhub-Token"]).toBe("finnhub-token");
+  });
+
+  it("sanitizes embedded query params when a downstream error contains a url", async () => {
+    getServiceWidget.mockResolvedValue({ type: "linkwarden", url: "http://example", key: "token" });
+    httpProxy.mockResolvedValue([500, "application/json", { error: { message: "oops", url: "http://bad" } }]);
+
+    const req = { method: "GET", query: { group: "g", service: "s", endpoint: "collections?apikey=secret", index: 0 } };
+    const res = createMockRes();
+
+    await credentialedProxyHandler(req, res);
+
+    expect(res.statusCode).toBe(500);
+    expect(res.body.error.url).toContain("apikey=***");
+  });
+
+  it("ends the response for 204/304 statuses", async () => {
+    getServiceWidget.mockResolvedValue({ type: "linkwarden", url: "http://example", key: "token" });
+    httpProxy.mockResolvedValue([204, "application/json", Buffer.from("")]);
+
+    const req = { method: "GET", query: { group: "g", service: "s", endpoint: "collections", index: 0 } };
+    const res = createMockRes();
+
+    await credentialedProxyHandler(req, res);
+
+    expect(res.statusCode).toBe(204);
+  });
+
+  it("returns invalid data errors as 500 when validation fails on 200 responses", async () => {
+    validateWidgetData.mockReturnValueOnce(false);
+    getServiceWidget.mockResolvedValue({ type: "linkwarden", url: "http://example", key: "token" });
+    httpProxy.mockResolvedValue([200, "application/json", { ok: true }]);
+
+    const req = { method: "GET", query: { group: "g", service: "s", endpoint: "collections", index: 0 } };
+    const res = createMockRes();
+
+    await credentialedProxyHandler(req, res);
+
+    expect(res.statusCode).toBe(500);
+    expect(res.body.error.message).toBe("Invalid data");
+    expect(res.body.error.url).toContain("http://example/api/v1/collections");
+  });
+
+  it("applies the response mapping function when provided", async () => {
+    getServiceWidget.mockResolvedValue({ type: "linkwarden", url: "http://example", key: "token" });
+    httpProxy.mockResolvedValue([200, "application/json", { ok: true, value: 1 }]);
+
+    const req = { method: "GET", query: { group: "g", service: "s", endpoint: "collections", index: 0 } };
+    const res = createMockRes();
+
+    await credentialedProxyHandler(req, res, (data) => ({ ok: data.ok, v: data.value }));
+
+    expect(res.statusCode).toBe(200);
+    expect(res.body).toEqual({ ok: true, v: 1 });
+  });
 });

src/utils/proxy/handlers/generic.test.js

@@ -114,4 +114,75 @@ describe("utils/proxy/handlers/generic", () => {
     expect(res.statusCode).toBe(200);
     expect(res.body.error.message).toBe("Invalid data");
   });
+
+  it("uses string requestBody as-is and prefers req.body over widget.requestBody", async () => {
+    getServiceWidget.mockResolvedValue({
+      type: "testservice",
+      url: "http://example",
+      requestBody: '{"a":1}',
+    });
+    httpProxy.mockResolvedValueOnce([200, "application/json", Buffer.from("ok")]);
+
+    const req = {
+      method: "POST",
+      body: "override-body",
+      query: { group: "g", service: "svc", endpoint: "api", index: "0" },
+    };
+    const res = createMockRes();
+
+    await genericProxyHandler(req, res);
+
+    expect(httpProxy).toHaveBeenCalledTimes(1);
+    expect(httpProxy.mock.calls[0][1].body).toBe("override-body");
+  });
+
+  it("ends the response for 204/304 statuses", async () => {
+    getServiceWidget.mockResolvedValue({
+      type: "testservice",
+      url: "http://example",
+    });
+    httpProxy.mockResolvedValueOnce([204, "application/json", Buffer.from("")]);
+
+    const req = { method: "GET", query: { group: "g", service: "svc", endpoint: "api", index: "0" } };
+    const res = createMockRes();
+
+    await genericProxyHandler(req, res);
+
+    expect(res.statusCode).toBe(204);
+    expect(res.end).toHaveBeenCalled();
+  });
+
+  it("returns an HTTP Error object for status>=400 and stringifies buffer data", async () => {
+    getServiceWidget.mockResolvedValue({
+      type: "testservice",
+      url: "http://example",
+    });
+    httpProxy.mockResolvedValueOnce([500, "application/json", Buffer.from("fail")]);
+
+    const req = { method: "GET", query: { group: "g", service: "svc", endpoint: "api?apikey=secret", index: "0" } };
+    const res = createMockRes();
+
+    await genericProxyHandler(req, res);
+
+    expect(res.statusCode).toBe(500);
+    expect(res.body.error.message).toBe("HTTP Error");
+    expect(res.body.error.url).toContain("apikey=***");
+    expect(res.body.error.data).toBe("fail");
+  });
+
+  it("applies the response mapping function when provided", async () => {
+    getServiceWidget.mockResolvedValue({
+      type: "testservice",
+      url: "http://example",
+    });
+    httpProxy.mockResolvedValueOnce([200, "application/json", { ok: true }]);
+
+    const req = { method: "GET", query: { group: "g", service: "svc", endpoint: "api", index: "0" } };
+    const res = createMockRes();
+
+    await genericProxyHandler(req, res, (data) => ({ mapped: data.ok }));
+
+    expect(res.statusCode).toBe(200);
+    expect(res.body).toEqual({ mapped: true });
+  });
 });

src/utils/proxy/handlers/jsonrpc.test.js

@@ -1,7 +1,10 @@
 import { beforeEach, describe, expect, it, vi } from "vitest";
 
-const { httpProxy, logger } = vi.hoisted(() => ({
+import createMockRes from "test-utils/create-mock-res";
+
+const { httpProxy, getServiceWidget, logger } = vi.hoisted(() => ({
   httpProxy: vi.fn(),
+  getServiceWidget: vi.fn(),
   logger: { debug: vi.fn(), warn: vi.fn() },
 }));
 
@@ -12,14 +15,33 @@ vi.mock("utils/proxy/http", () => ({
   httpProxy,
 }));
 
-import { sendJsonRpcRequest } from "./jsonrpc";
+vi.mock("utils/config/service-helpers", () => ({
+  default: getServiceWidget,
+}));
 
-describe("utils/proxy/handlers/jsonrpc", () => {
+vi.mock("widgets/widgets", () => ({
+  default: {
+    rpcwidget: {
+      api: "{url}/jsonrpc",
+      mappings: {
+        list: { endpoint: "test.method", params: [1, 2] },
+      },
+    },
+    missingapi: {
+      mappings: {
+        list: { endpoint: "test.method", params: [1, 2] },
+      },
+    },
+  },
+}));
+
+describe("utils/proxy/handlers/jsonrpc sendJsonRpcRequest", () => {
   beforeEach(() => {
     vi.clearAllMocks();
   });
 
   it("sends a JSON-RPC request and returns the response", async () => {
+    const { sendJsonRpcRequest } = await import("./jsonrpc");
     httpProxy.mockImplementationOnce(async (_url, params) => {
       const req = JSON.parse(params.body);
       return [
@@ -42,6 +64,7 @@ describe("utils/proxy/handlers/jsonrpc", () => {
   });
 
   it("maps JSON-RPC error responses into a result=null error object", async () => {
+    const { sendJsonRpcRequest } = await import("./jsonrpc");
     httpProxy.mockImplementationOnce(async (_url, params) => {
       const req = JSON.parse(params.body);
       return [
@@ -57,4 +80,140 @@ describe("utils/proxy/handlers/jsonrpc", () => {
     expect(JSON.parse(data)).toEqual({ result: null, error: { code: 123, message: "bad" } });
     expect(httpProxy.mock.calls[0][1].headers.Authorization).toBe("Bearer token");
   });
+
+  it("prefers Bearer auth when both basic credentials and a key are provided", async () => {
+    const { sendJsonRpcRequest } = await import("./jsonrpc");
+    httpProxy.mockImplementationOnce(async (_url, params) => {
+      const req = JSON.parse(params.body);
+      return [
+        200,
+        "application/json",
+        Buffer.from(JSON.stringify({ jsonrpc: "2.0", id: req.id, result: { ok: true } })),
+      ];
+    });
+
+    const [, , data] = await sendJsonRpcRequest("http://rpc", "test.method", null, {
+      username: "u",
+      password: "p",
+      key: "token",
+    });
+
+    expect(JSON.parse(data)).toEqual({ ok: true });
+    expect(httpProxy.mock.calls[0][1].headers.Authorization).toBe("Bearer token");
+  });
+
+  it("maps transport/parse failures into a JSON-RPC style error response", async () => {
+    const { sendJsonRpcRequest } = await import("./jsonrpc");
+    httpProxy.mockResolvedValueOnce([200, "application/json", Buffer.from("not-json")]);
+
+    const [status, , data] = await sendJsonRpcRequest("http://rpc", "test.method", null, { key: "token" });
+
+    expect(status).toBe(200);
+    expect(JSON.parse(data)).toEqual({
+      result: null,
+      error: { code: expect.any(Number), message: expect.any(String) },
+    });
+    expect(logger.debug).toHaveBeenCalled();
+  });
+
+  it("normalizes id=null responses so the client can still receive a result", async () => {
+    const { sendJsonRpcRequest } = await import("./jsonrpc");
+    httpProxy.mockImplementationOnce(async (_url, params) => {
+      const req = JSON.parse(params.body);
+      expect(req.id).toBe(1);
+      return [200, "application/json", Buffer.from(JSON.stringify({ jsonrpc: "2.0", id: null, result: { ok: true } }))];
+    });
+
+    const [status, , data] = await sendJsonRpcRequest("http://rpc", "test.method", null, { key: "token" });
+
+    expect(status).toBe(200);
+    expect(JSON.parse(data)).toEqual({ ok: true });
+  });
+});
+
+describe("utils/proxy/handlers/jsonrpc proxy handler", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it("looks up the widget, applies mappings, and returns JSON-RPC data", async () => {
+    const { default: jsonrpcProxyHandler } = await import("./jsonrpc");
+
+    getServiceWidget.mockResolvedValue({ type: "rpcwidget", url: "http://rpc", key: "token" });
+    httpProxy.mockImplementationOnce(async (_url, params) => {
+      const req = JSON.parse(params.body);
+      return [
+        200,
+        "application/json",
+        Buffer.from(JSON.stringify({ jsonrpc: "2.0", id: req.id, result: { method: req.method, params: req.params } })),
+      ];
+    });
+
+    const req = { method: "GET", query: { group: "g", service: "s", endpoint: "test.method", index: 0 } };
+    const res = createMockRes();
+
+    await jsonrpcProxyHandler(req, res);
+
+    expect(res.statusCode).toBe(200);
+    const json = JSON.parse(res.body);
+    expect(json).toEqual({ method: "test.method", params: [1, 2] });
+  });
+
+  it("returns 403 when the widget does not support API calls", async () => {
+    const { default: jsonrpcProxyHandler } = await import("./jsonrpc");
+
+    getServiceWidget.mockResolvedValue({ type: "missingapi", url: "http://rpc" });
+    const req = { method: "GET", query: { group: "g", service: "s", endpoint: "test.method", index: 0 } };
+    const res = createMockRes();
+
+    await jsonrpcProxyHandler(req, res);
+
+    expect(res.statusCode).toBe(403);
+    expect(res.body).toEqual({ error: "Service does not support API calls" });
+  });
+
+  it("returns 400 for invalid requests without group/service", async () => {
+    const { default: jsonrpcProxyHandler } = await import("./jsonrpc");
+
+    const req = { method: "GET", query: { endpoint: "test.method" } };
+    const res = createMockRes();
+
+    await jsonrpcProxyHandler(req, res);
+
+    expect(res.statusCode).toBe(400);
+    expect(res.body).toEqual({ error: "Invalid proxy service type" });
+  });
+});
+
+describe("utils/proxy/handlers/jsonrpc unexpected errors", () => {
+  it("returns 500 when the JSON-RPC client throws a non-JSONRPCErrorException", async () => {
+    vi.resetModules();
+    vi.doMock("json-rpc-2.0", () => {
+      class JSONRPCErrorException extends Error {
+        constructor(message, code) {
+          super(message);
+          this.code = code;
+        }
+      }
+
+      class JSONRPCClient {
+        constructor() {}
+
+        receive() {}
+
+        async request() {
+          throw new Error("boom");
+        }
+      }
+
+      return { JSONRPCClient, JSONRPCErrorException };
+    });
+
+    const { sendJsonRpcRequest } = await import("./jsonrpc");
+    const [status, , data] = await sendJsonRpcRequest("http://rpc", "test.method", null, { key: "token" });
+
+    expect(status).toBe(500);
+    expect(JSON.parse(data)).toEqual({ result: null, error: { code: 2, message: "Error: boom" } });
+    expect(logger.warn).toHaveBeenCalled();
+  });
 });

src/utils/proxy/handlers/synology.test.js

@@ -49,6 +49,16 @@ describe("utils/proxy/handlers/synology", () => {
     cache._reset();
   });
 
+  it("returns 400 when group/service are missing", async () => {
+    const req = { query: { endpoint: "download", index: "0" } };
+    const res = createMockRes();
+
+    await synologyProxyHandler(req, res);
+
+    expect(res.statusCode).toBe(400);
+    expect(res.body).toEqual({ error: "Invalid proxy service type" });
+  });
+
   it("calls the mapped API when api info is available and success is true", async () => {
     getServiceWidget.mockResolvedValue({ type: "synology", url: "http://nas", username: "u", password: "p" });
 
@@ -77,6 +87,20 @@ describe("utils/proxy/handlers/synology", () => {
     expect(JSON.parse(res.body.toString()).data.ok).toBe(true);
   });
 
+  it("returns 400 when the API name is unrecognized", async () => {
+    getServiceWidget.mockResolvedValue({ type: "synology", url: "http://nas", username: "u", password: "p" });
+
+    httpProxy.mockResolvedValueOnce([200, "application/json", Buffer.from(JSON.stringify({ data: {} }))]);
+
+    const req = { query: { group: "g", service: "svc", endpoint: "download", index: "0" } };
+    const res = createMockRes();
+
+    await synologyProxyHandler(req, res);
+
+    expect(res.statusCode).toBe(400);
+    expect(res.body).toEqual({ error: "Unrecognized API name: SYNO.DownloadStation2.Task" });
+  });
+
   it("attempts login and retries when the initial response is unsuccessful", async () => {
     getServiceWidget.mockResolvedValue({ type: "synology", url: "http://nas", username: "u", password: "p" });