feat: unit tests for security/utility functions (isPrivateIP, isTransientError, markdown, escapeHtml)

src/__tests__/db-utils.test.ts

@@ -0,0 +1,36 @@
+import { describe, it, expect } from "vitest";
+import { isTransientError } from "../utils/errors.js";
+
+describe("isTransientError", () => {
+  describe("transient error codes", () => {
+    for (const code of ["ECONNRESET", "ECONNREFUSED", "EPIPE", "ETIMEDOUT", "CONNECTION_LOST", "57P01", "57P02", "57P03", "08006", "08003", "08001"]) {
+      it(`detects code ${code}`, () => {
+        expect(isTransientError({ code })).toBe(true);
+      });
+    }
+  });
+
+  describe("message-based matches", () => {
+    it("detects 'no available server'", () => expect(isTransientError(new Error("no available server found"))).toBe(true));
+    it("detects 'connection terminated'", () => expect(isTransientError(new Error("connection terminated unexpectedly"))).toBe(true));
+    it("detects 'connection refused'", () => expect(isTransientError(new Error("connection refused by host"))).toBe(true));
+    it("detects 'server closed the connection'", () => expect(isTransientError(new Error("server closed the connection"))).toBe(true));
+    it("detects 'timeout expired'", () => expect(isTransientError(new Error("timeout expired waiting"))).toBe(true));
+  });
+
+  describe("non-transient errors", () => {
+    it("rejects generic error", () => expect(isTransientError(new Error("something broke"))).toBe(false));
+    it("rejects SQL syntax error", () => expect(isTransientError({ code: "42601", message: "syntax error" })).toBe(false));
+  });
+
+  describe("null/undefined input", () => {
+    it("returns false for null", () => expect(isTransientError(null)).toBe(false));
+    it("returns false for undefined", () => expect(isTransientError(undefined)).toBe(false));
+  });
+
+  describe("partial error objects", () => {
+    it("handles error with code but no message", () => expect(isTransientError({ code: "ECONNRESET" })).toBe(true));
+    it("handles error with message but no code", () => expect(isTransientError({ message: "connection terminated" })).toBe(true));
+    it("rejects error with unrelated code and no message", () => expect(isTransientError({ code: "UNKNOWN" })).toBe(false));
+  });
+});

src/__tests__/html-utils.test.ts

@@ -0,0 +1,18 @@
+import { describe, it, expect } from "vitest";
+import { escapeHtml } from "../utils/html.js";
+
+describe("escapeHtml", () => {
+  it("escapes &", () => expect(escapeHtml("a&b")).toBe("a&b"));
+  it("escapes <", () => expect(escapeHtml("a<b")).toBe("a&lt;b"));
+  it("escapes >", () => expect(escapeHtml("a>b")).toBe("a&gt;b"));
+  it('escapes "', () => expect(escapeHtml('a"b')).toBe("a&quot;b"));
+  it("escapes '", () => expect(escapeHtml("a'b")).toBe("a&#39;b"));
+  it("passes through normal text", () => expect(escapeHtml("hello world")).toBe("hello world"));
+  it("handles empty string", () => expect(escapeHtml("")).toBe(""));
+  it("escapes all special chars together", () => {
+    expect(escapeHtml(`&<>"'`)).toBe("&amp;&lt;&gt;&quot;&#39;");
+  });
+  it("double-escapes already-escaped entities", () => {
+    expect(escapeHtml("&amp;")).toBe("&amp;amp;");
+  });
+});

src/__tests__/markdown.test.ts

@@ -0,0 +1,50 @@
+import { describe, it, expect } from "vitest";
+import { markdownToHtml, wrapHtml } from "../services/markdown.js";
+
+describe("markdownToHtml", () => {
+  it("converts headings", () => {
+    expect(markdownToHtml("# Hello")).toContain("<h1>Hello</h1>");
+  });
+  it("converts bold", () => {
+    expect(markdownToHtml("**bold**")).toContain("<strong>bold</strong>");
+  });
+  it("converts italic", () => {
+    expect(markdownToHtml("*italic*")).toContain("<em>italic</em>");
+  });
+  it("converts links", () => {
+    expect(markdownToHtml("[link](http://x.com)")).toContain('<a href="http://x.com">link</a>');
+  });
+  it("converts code blocks", () => {
+    expect(markdownToHtml("```\ncode\n```")).toContain("<code>");
+  });
+  it("handles empty string", () => {
+    const result = markdownToHtml("");
+    expect(result).toContain("<!DOCTYPE html>");
+  });
+  it("applies custom CSS", () => {
+    const result = markdownToHtml("# Hi", "body{color:red}");
+    expect(result).toContain("body{color:red}");
+  });
+  it("uses default CSS when none provided", () => {
+    const result = markdownToHtml("# Hi");
+    expect(result).toContain("font-family");
+  });
+});
+
+describe("wrapHtml", () => {
+  it("wraps body in HTML document structure", () => {
+    const result = wrapHtml("<p>test</p>");
+    expect(result).toContain("<!DOCTYPE html>");
+    expect(result).toContain("<body><p>test</p></body>");
+  });
+  it("applies custom CSS", () => {
+    expect(wrapHtml("<p>x</p>", "h1{color:blue}")).toContain("h1{color:blue}");
+  });
+  it("uses default CSS when none provided", () => {
+    expect(wrapHtml("<p>x</p>")).toContain("font-family");
+  });
+  it("handles empty string body", () => {
+    const result = wrapHtml("");
+    expect(result).toContain("<body></body>");
+  });
+});

src/__tests__/network.test.ts

@@ -0,0 +1,54 @@
+import { describe, it, expect } from "vitest";
+import { isPrivateIP } from "../utils/network.js";
+
+describe("isPrivateIP", () => {
+  describe("IPv4 private ranges", () => {
+    it("detects 10.x.x.x as private", () => {
+      expect(isPrivateIP("10.0.0.1")).toBe(true);
+      expect(isPrivateIP("10.255.255.255")).toBe(true);
+    });
+    it("detects 172.16-31.x.x as private", () => {
+      expect(isPrivateIP("172.16.0.1")).toBe(true);
+      expect(isPrivateIP("172.31.255.255")).toBe(true);
+    });
+    it("detects 192.168.x.x as private", () => {
+      expect(isPrivateIP("192.168.0.1")).toBe(true);
+      expect(isPrivateIP("192.168.255.255")).toBe(true);
+    });
+    it("detects 127.x.x.x (loopback) as private", () => {
+      expect(isPrivateIP("127.0.0.1")).toBe(true);
+      expect(isPrivateIP("127.255.255.255")).toBe(true);
+    });
+    it("detects 0.0.0.0 as private", () => {
+      expect(isPrivateIP("0.0.0.0")).toBe(true);
+    });
+    it("detects 169.254.x.x (link-local) as private", () => {
+      expect(isPrivateIP("169.254.1.1")).toBe(true);
+    });
+  });
+
+  describe("IPv4 public addresses", () => {
+    it("allows 8.8.8.8", () => expect(isPrivateIP("8.8.8.8")).toBe(false));
+    it("allows 1.1.1.1", () => expect(isPrivateIP("1.1.1.1")).toBe(false));
+    it("allows 172.15.0.1 (just below range)", () => expect(isPrivateIP("172.15.0.1")).toBe(false));
+    it("allows 172.32.0.1 (just above range)", () => expect(isPrivateIP("172.32.0.1")).toBe(false));
+  });
+
+  describe("IPv6", () => {
+    it("detects ::1 (loopback) as private", () => expect(isPrivateIP("::1")).toBe(true));
+    it("detects :: (unspecified) as private", () => expect(isPrivateIP("::")).toBe(true));
+    it("detects fe80::1 (link-local) as private", () => expect(isPrivateIP("fe80::1")).toBe(true));
+    it("detects fc00::1 (unique local) as private", () => expect(isPrivateIP("fc00::1")).toBe(true));
+    it("detects fd00::1 (unique local) as private", () => expect(isPrivateIP("fd00::1")).toBe(true));
+  });
+
+  describe("IPv4-mapped IPv6", () => {
+    it("detects ::ffff:10.0.0.1 as private", () => expect(isPrivateIP("::ffff:10.0.0.1")).toBe(true));
+    it("allows ::ffff:8.8.8.8 as public", () => expect(isPrivateIP("::ffff:8.8.8.8")).toBe(false));
+  });
+
+  describe("edge cases", () => {
+    it("returns false for empty string", () => expect(isPrivateIP("")).toBe(false));
+    it("returns false for random text", () => expect(isPrivateIP("not-an-ip")).toBe(false));
+  });
+});