SushiMCP

import { describe, it, expect, vi, beforeEach, afterEach } from "vitest"; import { extractDomain, checkDomainAccess, parseFetchTarget, fetchContent, getVersion, type TargetInfo, logger, } from "#lib/index"; import { URL } from "url"; import * as fs from "node:fs/promises"; import * as path from "node:path"; import * as url from "url"; import * as nodeFs from "fs"; import { mockPathResolution, mockFileSystem } from "../../test-utils"; Object.defineProperty(import.meta, "url", { value: "file:///fake/path/src/lib/utils.ts", }); vi.mock("node:fs/promises"); vi.mock("node:fs"); vi.mock("fs"); // Setup mocks mockPathResolution(path); mockFileSystem(fs); mockFileSystem(nodeFs); vi.mock("url", async () => { const actual = await vi.importActual<typeof import("url")>("url"); return { ...actual, fileURLToPath: vi.fn().mockImplementation((url: string | URL) => { if ( url === "file:///fake/path/src/lib/utils.ts" || url === import.meta.url ) { return "/fake/path/src/lib/utils.ts"; } const urlString = typeof url === "string" ? url : url.href; if (urlString.startsWith("file://")) { return urlString.slice(7); } return actual.fileURLToPath(url); }), }; }); vi.mock("path", async () => { const actual = await vi.importActual("path"); return { ...actual, dirname: vi.fn().mockImplementation((p: string) => { if (p === "/fake/path/src/lib/utils.ts") return "/fake/path/src/lib"; if (p === "/fake/path/src/lib") return "/fake/path/src"; if (p === "/fake/path/src") return "/fake/path"; return p; }), join: vi.fn().mockImplementation((...parts: string[]) => parts.join("/")), }; }); describe("extractDomain", () => { it("should extract domain from valid HTTP URL", () => { expect(extractDomain("http://example.com/path")).toBe("example.com"); }); it("should extract domain from valid HTTPS URL", () => { expect(extractDomain("https://sub.example.com/path")).toBe( "sub.example.com" ); }); it("should return null for invalid URL", () => { expect(extractDomain("not-a-url")).toBeNull(); }); it("should return null for non-HTTP/HTTPS protocols", () => { expect(extractDomain("file:///path/to/file")).toBeNull(); }); }); describe("checkDomainAccess", () => { const loggerInfoSpy = vi.spyOn(logger, "info").mockImplementation(() => {}); const originalEnv = process.env; beforeEach(() => { vi.resetAllMocks(); process.env = { ...originalEnv }; }); afterEach(() => { process.env = originalEnv; }); it("should allow access for matching domain", () => { const targetInfo = { type: "remote" as const, url: new URL("https://example.com"), hostname: "example.com", }; const allowedDomains = new Set(["example.com"]); expect(() => checkDomainAccess(targetInfo, allowedDomains)).not.toThrow(); }); it("should allow access when wildcard is present", () => { const targetInfo = { type: "remote" as const, url: new URL("https://any-domain.com"), hostname: "any-domain.com", }; const allowedDomains = new Set(["*"]); expect(() => checkDomainAccess(targetInfo, allowedDomains)).not.toThrow(); }); it("should deny access for non-matching domain", () => { const targetInfo = { type: "remote" as const, url: new URL("https://example.com"), hostname: "example.com", }; const allowedDomains = new Set(["other-domain.com"]); expect(() => checkDomainAccess(targetInfo, allowedDomains)).toThrow( "Access denied: Fetching from domain 'example.com' is not allowed" ); }); it("should allow local file access", () => { const targetInfo = { type: "localPath" as const, resolvedPath: "/path/to/file", originalInput: "/path/to/file", }; const allowedDomains = new Set([]); expect(() => checkDomainAccess(targetInfo, allowedDomains)).not.toThrow(); }); it("should throw for unsupported target type", () => { const targetInfo = { type: "unsupported" as const, reason: "test", originalInput: "test", }; const allowedDomains = new Set([]); expect(() => checkDomainAccess(targetInfo, allowedDomains)).toThrow( "Internal error: Unsupported target type" ); }); it("should log allowed domains", () => { const targetInfo = { type: "remote" as const, url: new URL("https://example.com"), hostname: "example.com", }; const allowedDomains = new Set(["example.com"]); checkDomainAccess(targetInfo, allowedDomains); // Verify the log message contains the expected content expect(loggerInfoSpy).toHaveBeenCalledWith( expect.stringContaining("Domain 'example.com' is allowed.") ); }); }); describe("parseFetchTarget", () => { beforeEach(() => { vi.resetAllMocks(); }); it("should parse HTTP URL", async () => { const result = await parseFetchTarget("http://example.com/path"); expect(result).toEqual({ type: "remote", url: new URL("http://example.com/path"), hostname: "example.com", }); }); it("should parse HTTPS URL", async () => { const result = await parseFetchTarget("https://example.com/path"); expect(result).toEqual({ type: "remote", url: new URL("https://example.com/path"), hostname: "example.com", }); }); it("should handle file URL", async () => { const filePath = "/absolute/path/to/file"; const fileUrl = `file://${filePath}`; const result = await parseFetchTarget(fileUrl); expect(result.type).toBe("unsupported"); const unsupportedResult = result as { type: "unsupported"; reason: string; originalInput: string; }; expect(unsupportedResult.originalInput).toBe(fileUrl); expect(unsupportedResult.reason).toContain( "Failed to convert file: URL to path" ); }); it("should parse local path", async () => { const localPath = "/path/to/file"; vi.mocked(fs.stat).mockResolvedValueOnce({} as any); const result = await parseFetchTarget(localPath); expect(result).toEqual({ type: "localPath", resolvedPath: path.resolve(localPath), originalInput: localPath, }); }); it("should handle non-existent local path", async () => { const localPath = "/non/existent/path"; vi.mocked(fs.stat).mockRejectedValueOnce(new Error("ENOENT")); const result = await parseFetchTarget(localPath); expect(result).toEqual({ type: "unsupported", originalInput: localPath, reason: expect.stringContaining("Path does not exist or is inaccessible"), }); }); it("should handle unsupported URL protocol", async () => { const result = await parseFetchTarget("ftp://example.com"); expect(result).toEqual({ type: "unsupported", originalInput: "ftp://example.com", reason: "Unsupported URL protocol: ftp:", }); }); }); describe("fetchContent", () => { beforeEach(() => { vi.resetAllMocks(); }); it("should fetch remote content", async () => { const mockResponse = { ok: true, text: vi.fn().mockResolvedValue("content"), }; global.fetch = vi.fn().mockResolvedValue(mockResponse as any); const targetInfo = { type: "remote" as const, url: new URL("https://example.com/"), hostname: "example.com", }; const result = await fetchContent(targetInfo); expect(result).toBe("content"); expect(fetch).toHaveBeenCalledWith("https://example.com/"); }); it("should log when fetching remote content", async () => { const mockResponse = { ok: true, text: vi.fn().mockResolvedValue("content"), }; global.fetch = vi.fn().mockResolvedValue(mockResponse as any); const loggerInfoSpy = vi.spyOn(logger, "info"); const targetInfo = { type: "remote" as const, url: new URL("https://example.com/"), hostname: "example.com", }; await fetchContent(targetInfo); // Verify the log message contains the expected fetch URL expect(loggerInfoSpy).toHaveBeenCalledWith( expect.stringContaining("Fetching remote URL: https://example.com/") ); }); it("should handle remote fetch failure", async () => { global.fetch = vi.fn().mockResolvedValueOnce({ ok: false, status: 404, statusText: "Not Found", }); const targetInfo = { type: "remote" as const, url: new URL("https://example.com"), hostname: "example.com", }; await expect(fetchContent(targetInfo)).rejects.toThrow("HTTP error 404"); }); it("should fetch local file content", async () => { vi.mocked(fs.readFile).mockResolvedValueOnce("local content" as any); const targetInfo = { type: "localPath" as const, resolvedPath: "/path/to/file", originalInput: "file.txt", }; const content = await fetchContent(targetInfo); expect(content).toBe("local content"); expect(fs.readFile).toHaveBeenCalledWith("/path/to/file", "utf-8"); }); it("should fetch local file content from file URL", async () => { vi.mocked(fs.readFile).mockResolvedValueOnce("file url content" as any); const loggerInfoSpy = vi.spyOn(logger, "info"); const targetInfo = { type: "localFileUrl" as const, filePath: "/local/file/path", url: new URL("file:///local/file/path"), }; const content = await fetchContent(targetInfo); expect(content).toBe("file url content"); expect(fs.readFile).toHaveBeenCalledWith("/local/file/path", "utf-8"); // Verify the log message contains the expected file path expect(loggerInfoSpy).toHaveBeenCalledWith( expect.stringContaining( "Reading local file path from file: URL: /local/file/path" ) ); }); it("should handle local file read failure", async () => { vi.mocked(fs.readFile).mockRejectedValueOnce(new Error("ENOENT")); const targetInfo = { type: "localPath" as const, resolvedPath: "/path/to/file", originalInput: "/path/to/file", }; await expect(fetchContent(targetInfo)).rejects.toThrow(); }); it("should throw for unsupported target type", async () => { const targetInfo = { type: "unsupported" as const, reason: "Test reason", originalInput: "test", }; await expect(fetchContent(targetInfo)).rejects.toThrow( "Cannot fetch content for unsupported target type: Test reason" ); }); it("should throw on unknown target type (exhaustive check)", async () => { const targetInfo = { type: "unknown", reason: "Unknown type test", originalInput: "test", } as unknown as TargetInfo; await expect(fetchContent(targetInfo)).rejects.toThrow( "Internal error: Unhandled target info type" ); }); }); describe("getVersion", () => { it("verifies the getVersion implementation", () => { const mockReadFileSync = nodeFs.readFileSync; expect(mockReadFileSync).toBeDefined(); const packageJson = JSON.parse(JSON.stringify({ version: "1.2.3" })); expect(packageJson.version).toBe("1.2.3"); const mockUrl = url.fileURLToPath; expect(mockUrl).toBeDefined(); expect(typeof getVersion).toBe("function"); }); }); // Copyright (C) 2025 Christopher White // SPDX-License-Identifier: AGPL-3.0-or-later