Feature: feeds widget (#7170)

src/widgets/feed/proxy.test.js

@@ -0,0 +1,183 @@
+import cache from "memory-cache";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+import createMockRes from "test-utils/create-mock-res";
+
+const { httpProxy, getServiceWidget, logger } = vi.hoisted(() => ({
+  httpProxy: vi.fn(),
+  getServiceWidget: vi.fn(),
+  logger: {
+    debug: vi.fn(),
+  },
+}));
+
+vi.mock("utils/logger", () => ({
+  default: () => logger,
+}));
+
+vi.mock("utils/config/service-helpers", () => ({
+  default: getServiceWidget,
+}));
+
+vi.mock("utils/proxy/http", () => ({
+  httpProxy,
+}));
+
+import feedProxyHandler from "./proxy";
+
+const items = Array.from(
+  { length: 7 },
+  (_, i) => `<item><title>Item ${i}</title><link>https://example.com/${i}</link>
+    <media:thumbnail url="https://example.com/${i}.jpg" /></item>`,
+).join("");
+const feed = `<rss xmlns:media="http://search.yahoo.com/mrss/"><channel>${items}</channel></rss>`;
+
+const req = { query: { group: "g", service: "svc", index: "0" } };
+
+describe("widgets/feed/proxy", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    cache.clear();
+  });
+
+  it("returns 400 when the url is missing or invalid", async () => {
+    getServiceWidget.mockResolvedValueOnce({ type: "feed" });
+    let res = createMockRes();
+    await feedProxyHandler(req, res);
+    expect(res.statusCode).toBe(400);
+    expect(res.body).toEqual({ error: "Missing feed URL" });
+
+    getServiceWidget.mockResolvedValueOnce({ type: "feed", url: "nope" });
+    res = createMockRes();
+    await feedProxyHandler(req, res);
+    expect(res.statusCode).toBe(400);
+    expect(res.body).toEqual({ error: "Invalid feed URL" });
+
+    getServiceWidget.mockResolvedValueOnce({ type: "feed", url: "file:///etc/passwd" });
+    res = createMockRes();
+    await feedProxyHandler(req, res);
+    expect(res.statusCode).toBe(400);
+    expect(res.body).toEqual({ error: "Invalid feed URL" });
+    expect(httpProxy).not.toHaveBeenCalled();
+  });
+
+  it("returns the first 5 items by default", async () => {
+    getServiceWidget.mockResolvedValue({ type: "feed", url: "https://example.com/feed.xml" });
+    httpProxy.mockResolvedValueOnce([200, "application/rss+xml", Buffer.from(feed)]);
+
+    const res = createMockRes();
+    await feedProxyHandler(req, res);
+
+    expect(httpProxy.mock.calls[0][0].href).toBe("https://example.com/feed.xml");
+    expect(res.statusCode).toBe(200);
+    expect(res.body.items).toHaveLength(5);
+    expect(res.body.items[0]).toEqual({
+      title: "Item 0",
+      link: "https://example.com/0",
+      date: null,
+      image: "https://example.com/0.jpg",
+    });
+  });
+
+  it.each([-1, 0, "abc"])("falls back to 5 items for maxItems %j", async (maxItems) => {
+    getServiceWidget.mockResolvedValue({ type: "feed", url: "https://example.com/feed.xml", maxItems });
+    httpProxy.mockResolvedValueOnce([200, "application/rss+xml", Buffer.from(feed)]);
+
+    const res = createMockRes();
+    await feedProxyHandler(req, res);
+
+    expect(res.body.items).toHaveLength(5);
+  });
+
+  it("respects maxItems and drops images when disabled", async () => {
+    getServiceWidget.mockResolvedValue({
+      type: "feed",
+      url: "https://example.com/feed.xml",
+      maxItems: "2",
+      images: false,
+    });
+    httpProxy.mockResolvedValueOnce([200, "application/rss+xml", Buffer.from(feed)]);
+
+    const res = createMockRes();
+    await feedProxyHandler(req, res);
+
+    expect(res.body.items).toEqual([
+      { title: "Item 0", link: "https://example.com/0", date: null },
+      { title: "Item 1", link: "https://example.com/1", date: null },
+    ]);
+  });
+
+  it("passes through http errors without leaking the url", async () => {
+    getServiceWidget.mockResolvedValue({ type: "feed", url: "https://example.com/feed.xml?token=secret" });
+    httpProxy.mockResolvedValueOnce([404, "text/html", Buffer.from("Not found")]);
+
+    const res = createMockRes();
+    await feedProxyHandler(req, res);
+
+    expect(res.statusCode).toBe(404);
+    expect(res.body).toEqual({ error: { message: "HTTP Error", url: "example.com (see logs for details)" } });
+  });
+
+  it("never includes any part of the configured url in the response", async () => {
+    getServiceWidget.mockResolvedValue({
+      type: "feed",
+      url: "https://user:hunter2@nas.lan/feeds/s3cr3t/rss.xml?token=abc123",
+    });
+    const relative = `<rss><channel>
+      <item><title>Path</title><link>item/1</link><enclosure url="img.jpg" type="image/jpeg" /></item>
+      <item><title>Root</title><link>/x</link></item>
+      <item><title>Fragment</title><link>#top</link></item>
+    </channel></rss>`;
+    httpProxy.mockResolvedValueOnce([200, "application/rss+xml", Buffer.from(relative)]);
+
+    const res = createMockRes();
+    await feedProxyHandler(req, res);
+
+    expect(res.body.items.map((item) => item.link)).toEqual([null, null, null]);
+    expect(JSON.stringify(res.body)).not.toMatch(/user|hunter2|nas\.lan|s3cr3t|token|abc123/);
+  });
+
+  it("returns 500 for unparseable feeds", async () => {
+    getServiceWidget.mockResolvedValue({ type: "feed", url: "https://example.com/feed.xml" });
+    httpProxy.mockResolvedValueOnce([200, "text/html", Buffer.from("<html></html>")]);
+
+    const res = createMockRes();
+    await feedProxyHandler(req, res);
+
+    expect(res.statusCode).toBe(500);
+    expect(res.body).toEqual({ error: { message: "Invalid feed", url: "example.com (see logs for details)" } });
+  });
+
+  it("shares one cached fetch across widgets with different options", async () => {
+    getServiceWidget
+      .mockResolvedValueOnce({ type: "feed", url: "https://example.com/feed.xml", maxItems: 1 })
+      .mockResolvedValueOnce({ type: "feed", url: "https://example.com/feed.xml", images: false });
+    httpProxy.mockResolvedValue([200, "application/rss+xml", Buffer.from(feed)]);
+
+    const first = createMockRes();
+    await feedProxyHandler(req, first);
+    const second = createMockRes();
+    await feedProxyHandler(req, second);
+
+    expect(httpProxy).toHaveBeenCalledTimes(1);
+    expect(first.body.items).toHaveLength(1);
+    expect(second.body.items).toHaveLength(5);
+    expect(second.body.items[0].image).toBeUndefined();
+  });
+
+  it("does not cache failures", async () => {
+    getServiceWidget.mockResolvedValue({ type: "feed", url: "https://example.com/feed.xml" });
+    httpProxy
+      .mockResolvedValueOnce([404, "text/html", Buffer.from("Not found")])
+      .mockResolvedValueOnce([200, "application/rss+xml", Buffer.from(feed)]);
+
+    const failed = createMockRes();
+    await feedProxyHandler(req, failed);
+    const recovered = createMockRes();
+    await feedProxyHandler(req, recovered);
+
+    expect(failed.statusCode).toBe(404);
+    expect(recovered.statusCode).toBe(200);
+    expect(httpProxy).toHaveBeenCalledTimes(2);
+  });
+});