From 92ca6d9ab676cf718882ed3cc4825b3d556ef779 Mon Sep 17 00:00:00 2001 From: shamoon <4887959+shamoon@users.noreply.github.com> Date: Wed, 4 Feb 2026 12:50:50 -0800 Subject: [PATCH] test: expand coverage for proxy handlers --- src/utils/proxy/handlers/credentialed.test.js | 130 +++++++++++++- src/utils/proxy/handlers/generic.test.js | 71 ++++++++ src/utils/proxy/handlers/jsonrpc.test.js | 165 +++++++++++++++++- src/utils/proxy/handlers/synology.test.js | 24 +++ 4 files changed, 386 insertions(+), 4 deletions(-) diff --git a/src/utils/proxy/handlers/credentialed.test.js b/src/utils/proxy/handlers/credentialed.test.js index 0f3ef854f..a53400d90 100644 --- a/src/utils/proxy/handlers/credentialed.test.js +++ b/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 }); + }); }); diff --git a/src/utils/proxy/handlers/generic.test.js b/src/utils/proxy/handlers/generic.test.js index 3c9f84081..60f095e24 100644 --- a/src/utils/proxy/handlers/generic.test.js +++ b/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 }); + }); }); diff --git a/src/utils/proxy/handlers/jsonrpc.test.js b/src/utils/proxy/handlers/jsonrpc.test.js index 68263653f..205ac883a 100644 --- a/src/utils/proxy/handlers/jsonrpc.test.js +++ b/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(); + }); }); diff --git a/src/utils/proxy/handlers/synology.test.js b/src/utils/proxy/handlers/synology.test.js index 1d4c8480b..1e35a9bbc 100644 --- a/src/utils/proxy/handlers/synology.test.js +++ b/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" });