@prmichaelsen/reddit-mcp 0.1.0 → 0.1.1

package/tests/unit/multireddits.test.ts

@@ -0,0 +1,136 @@
+import { jest, describe, it, expect, beforeEach } from "@jest/globals";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { registerMultiredditTools } from "../../src/tools/multireddits.js";
+import { createMockClient } from "../helpers/mock-client.js";
+import { mockEmptyResponse } from "../fixtures/reddit-responses.js";
+
+const mockMultiList = [
+  {
+    kind: "LabeledMulti",
+    data: {
+      name: "frontpage",
+      display_name: "Frontpage",
+      path: "/user/testuser/m/frontpage",
+      subreddits: [{ name: "programming" }, { name: "typescript" }],
+      visibility: "private",
+    },
+  },
+];
+
+const mockMulti = {
+  kind: "LabeledMulti",
+  data: {
+    name: "frontpage",
+    display_name: "Frontpage",
+    path: "/user/testuser/m/frontpage",
+    subreddits: [{ name: "programming" }],
+    visibility: "private",
+  },
+};
+
+describe("Multireddit Tools", () => {
+  let server: McpServer;
+  let mockClient: ReturnType<typeof createMockClient>;
+
+  beforeEach(() => {
+    server = new McpServer({ name: "test", version: "0.0.1" });
+    mockClient = createMockClient(
+      new Map([
+        ["/api/multi/mine", mockMultiList],
+        ["/api/multi/user/testuser/m/frontpage", mockMulti],
+        ["/api/multi/user/testuser/m/frontpage/r/typescript", mockEmptyResponse],
+      ]),
+    );
+    registerMultiredditTools(server, mockClient);
+  });
+
+  it("registers multireddit tools", () => {
+    expect(server).toBeDefined();
+  });
+
+  describe("reddit_multi_mine", () => {
+    it("calls GET /api/multi/mine", async () => {
+      const result = await mockClient.get("/api/multi/mine");
+      expect(mockClient.mockGet).toHaveBeenCalledWith("/api/multi/mine");
+      expect(result).toEqual(mockMultiList);
+    });
+  });
+
+  describe("reddit_multi_get", () => {
+    it("calls GET /api/multi/{multipath}", async () => {
+      const result = await mockClient.get(
+        "/api/multi/user/testuser/m/frontpage",
+      );
+      expect(mockClient.mockGet).toHaveBeenCalledWith(
+        "/api/multi/user/testuser/m/frontpage",
+      );
+      expect(result).toEqual(mockMulti);
+    });
+  });
+
+  describe("reddit_multi_create", () => {
+    it("calls POST /api/multi/{multipath}", async () => {
+      await mockClient.post("/api/multi/user/testuser/m/frontpage", {
+        model: JSON.stringify({
+          display_name: "Frontpage",
+          subreddits: [{ name: "programming" }],
+          visibility: "private",
+          description_md: "",
+        }),
+      });
+      expect(mockClient.mockPost).toHaveBeenCalledWith(
+        "/api/multi/user/testuser/m/frontpage",
+        expect.objectContaining({
+          model: expect.stringContaining("Frontpage"),
+        }),
+      );
+    });
+  });
+
+  describe("reddit_multi_update", () => {
+    it("calls PUT /api/multi/{multipath}", async () => {
+      await mockClient.put("/api/multi/user/testuser/m/frontpage", {
+        model: { display_name: "Updated Name" },
+      });
+      expect(mockClient.put).toHaveBeenCalledWith(
+        "/api/multi/user/testuser/m/frontpage",
+        expect.objectContaining({
+          model: { display_name: "Updated Name" },
+        }),
+      );
+    });
+  });
+
+  describe("reddit_multi_delete", () => {
+    it("calls DELETE /api/multi/{multipath}", async () => {
+      await mockClient.delete("/api/multi/user/testuser/m/frontpage");
+      expect(mockClient.delete).toHaveBeenCalledWith(
+        "/api/multi/user/testuser/m/frontpage",
+      );
+    });
+  });
+
+  describe("reddit_multi_add_sub", () => {
+    it("calls PUT /api/multi/{multipath}/r/{srname}", async () => {
+      await mockClient.put(
+        "/api/multi/user/testuser/m/frontpage/r/typescript",
+        { model: { name: "typescript" } },
+      );
+      expect(mockClient.put).toHaveBeenCalledWith(
+        "/api/multi/user/testuser/m/frontpage/r/typescript",
+        { model: { name: "typescript" } },
+      );
+    });
+  });
+
+  describe("reddit_multi_remove_sub", () => {
+    it("calls DELETE /api/multi/{multipath}/r/{srname}", async () => {
+      await mockClient.delete(
+        "/api/multi/user/testuser/m/frontpage/r/typescript",
+      );
+      expect(mockClient.delete).toHaveBeenCalledWith(
+        "/api/multi/user/testuser/m/frontpage/r/typescript",
+      );
+    });
+  });
+});

package/tests/unit/posts.test.ts

@@ -0,0 +1,155 @@
+import { describe, it, expect, beforeEach } from "@jest/globals";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { registerPostTools } from "../../src/tools/posts.js";
+import { createMockClient } from "../helpers/mock-client.js";
+import {
+  mockSubmitResponse,
+  mockEditResponse,
+  mockEmptyResponse,
+} from "../fixtures/reddit-responses.js";
+
+describe("Post Tools", () => {
+  let server: McpServer;
+  let mockClient: ReturnType<typeof createMockClient>;
+
+  beforeEach(() => {
+    server = new McpServer({ name: "test", version: "0.0.1" });
+    mockClient = createMockClient(
+      new Map([
+        ["/api/submit", mockSubmitResponse],
+        ["/api/editusertext", mockEditResponse],
+        ["/api/del", mockEmptyResponse],
+        ["/api/hide", mockEmptyResponse],
+        ["/api/unhide", mockEmptyResponse],
+        ["/api/marknsfw", mockEmptyResponse],
+        ["/api/unmarknsfw", mockEmptyResponse],
+        ["/api/spoiler", mockEmptyResponse],
+        ["/api/unspoiler", mockEmptyResponse],
+      ]),
+    );
+    registerPostTools(server, mockClient);
+  });
+
+  it("registers post tools", () => {
+    expect(server).toBeDefined();
+  });
+
+  describe("reddit_submit", () => {
+    it("calls POST /api/submit for self post", async () => {
+      await mockClient.post("/api/submit", {
+        sr: "test",
+        title: "My Post",
+        kind: "self",
+        text: "Hello world",
+        api_type: "json",
+      });
+      expect(mockClient.mockPost).toHaveBeenCalledWith(
+        "/api/submit",
+        expect.objectContaining({
+          sr: "test",
+          title: "My Post",
+          kind: "self",
+          text: "Hello world",
+        }),
+      );
+    });
+
+    it("calls POST /api/submit for link post", async () => {
+      await mockClient.post("/api/submit", {
+        sr: "test",
+        title: "My Link",
+        kind: "link",
+        url: "https://example.com",
+        api_type: "json",
+      });
+      expect(mockClient.mockPost).toHaveBeenCalledWith(
+        "/api/submit",
+        expect.objectContaining({
+          sr: "test",
+          kind: "link",
+          url: "https://example.com",
+        }),
+      );
+    });
+  });
+
+  describe("reddit_edit", () => {
+    it("calls POST /api/editusertext", async () => {
+      await mockClient.post("/api/editusertext", {
+        thing_id: "t3_abc123",
+        text: "Updated text",
+        api_type: "json",
+      });
+      expect(mockClient.mockPost).toHaveBeenCalledWith(
+        "/api/editusertext",
+        expect.objectContaining({
+          thing_id: "t3_abc123",
+          text: "Updated text",
+        }),
+      );
+    });
+  });
+
+  describe("reddit_delete", () => {
+    it("calls POST /api/del", async () => {
+      await mockClient.post("/api/del", { id: "t3_abc123" });
+      expect(mockClient.mockPost).toHaveBeenCalledWith("/api/del", {
+        id: "t3_abc123",
+      });
+    });
+  });
+
+  describe("reddit_hide", () => {
+    it("calls POST /api/hide", async () => {
+      await mockClient.post("/api/hide", { id: "t3_abc123" });
+      expect(mockClient.mockPost).toHaveBeenCalledWith("/api/hide", {
+        id: "t3_abc123",
+      });
+    });
+  });
+
+  describe("reddit_unhide", () => {
+    it("calls POST /api/unhide", async () => {
+      await mockClient.post("/api/unhide", { id: "t3_abc123" });
+      expect(mockClient.mockPost).toHaveBeenCalledWith("/api/unhide", {
+        id: "t3_abc123",
+      });
+    });
+  });
+
+  describe("reddit_mark_nsfw", () => {
+    it("calls POST /api/marknsfw", async () => {
+      await mockClient.post("/api/marknsfw", { id: "t3_abc123" });
+      expect(mockClient.mockPost).toHaveBeenCalledWith("/api/marknsfw", {
+        id: "t3_abc123",
+      });
+    });
+  });
+
+  describe("reddit_unmark_nsfw", () => {
+    it("calls POST /api/unmarknsfw", async () => {
+      await mockClient.post("/api/unmarknsfw", { id: "t3_abc123" });
+      expect(mockClient.mockPost).toHaveBeenCalledWith("/api/unmarknsfw", {
+        id: "t3_abc123",
+      });
+    });
+  });
+
+  describe("reddit_spoiler", () => {
+    it("calls POST /api/spoiler", async () => {
+      await mockClient.post("/api/spoiler", { id: "t3_abc123" });
+      expect(mockClient.mockPost).toHaveBeenCalledWith("/api/spoiler", {
+        id: "t3_abc123",
+      });
+    });
+  });
+
+  describe("reddit_unspoiler", () => {
+    it("calls POST /api/unspoiler", async () => {
+      await mockClient.post("/api/unspoiler", { id: "t3_abc123" });
+      expect(mockClient.mockPost).toHaveBeenCalledWith("/api/unspoiler", {
+        id: "t3_abc123",
+      });
+    });
+  });
+});

package/tests/unit/subreddits.test.ts

@@ -0,0 +1,125 @@
+import { describe, it, expect, beforeEach } from "@jest/globals";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { registerSubredditTools } from "../../src/tools/subreddits.js";
+import { createMockClient } from "../helpers/mock-client.js";
+import {
+  mockSubredditAbout,
+  mockListing,
+  mockEmptyResponse,
+} from "../fixtures/reddit-responses.js";
+
+const mockRulesResponse = {
+  rules: [
+    {
+      kind: "all",
+      description: "No spam allowed",
+      short_name: "No Spam",
+      violation_reason: "Spam",
+      priority: 0,
+    },
+  ],
+  site_rules: ["Content policy"],
+};
+
+describe("Subreddit Tools", () => {
+  let server: McpServer;
+  let mockClient: ReturnType<typeof createMockClient>;
+
+  beforeEach(() => {
+    server = new McpServer({ name: "test", version: "0.0.1" });
+    mockClient = createMockClient(
+      new Map([
+        ["/r/test/about", mockSubredditAbout],
+        ["/r/test/about/rules", mockRulesResponse],
+        ["/api/subscribe", mockEmptyResponse],
+        ["/subreddits/mine/subscriber", mockListing],
+        ["/subreddits/popular", mockListing],
+        ["/subreddits/new", mockListing],
+        ["/subreddits/search", mockListing],
+      ]),
+    );
+    registerSubredditTools(server, mockClient);
+  });
+
+  it("registers subreddit tools", () => {
+    expect(server).toBeDefined();
+  });
+
+  describe("reddit_subreddit_about", () => {
+    it("calls GET /r/{subreddit}/about", async () => {
+      const result = await mockClient.get("/r/test/about");
+      expect(mockClient.mockGet).toHaveBeenCalledWith("/r/test/about");
+      expect(result).toEqual(mockSubredditAbout);
+    });
+  });
+
+  describe("reddit_subreddit_rules", () => {
+    it("calls GET /r/{subreddit}/about/rules", async () => {
+      const result = await mockClient.get("/r/test/about/rules");
+      expect(mockClient.mockGet).toHaveBeenCalledWith("/r/test/about/rules");
+      expect(result).toEqual(mockRulesResponse);
+    });
+  });
+
+  describe("reddit_subscribe", () => {
+    it("calls POST /api/subscribe with action=sub", async () => {
+      await mockClient.post("/api/subscribe", {
+        sr_name: "test",
+        action: "sub",
+      });
+      expect(mockClient.mockPost).toHaveBeenCalledWith("/api/subscribe", {
+        sr_name: "test",
+        action: "sub",
+      });
+    });
+  });
+
+  describe("reddit_unsubscribe", () => {
+    it("calls POST /api/subscribe with action=unsub", async () => {
+      await mockClient.post("/api/subscribe", {
+        sr_name: "test",
+        action: "unsub",
+      });
+      expect(mockClient.mockPost).toHaveBeenCalledWith("/api/subscribe", {
+        sr_name: "test",
+        action: "unsub",
+      });
+    });
+  });
+
+  describe("reddit_subreddits_mine", () => {
+    it("calls GET /subreddits/mine/subscriber", async () => {
+      await mockClient.get("/subreddits/mine/subscriber", { limit: "25" });
+      expect(mockClient.mockGet).toHaveBeenCalledWith(
+        "/subreddits/mine/subscriber",
+        { limit: "25" },
+      );
+    });
+  });
+
+  describe("reddit_subreddits_popular", () => {
+    it("calls GET /subreddits/popular", async () => {
+      await mockClient.get("/subreddits/popular", {});
+      expect(mockClient.mockGet).toHaveBeenCalledWith(
+        "/subreddits/popular",
+        {},
+      );
+    });
+  });
+
+  describe("reddit_subreddits_new", () => {
+    it("calls GET /subreddits/new", async () => {
+      await mockClient.get("/subreddits/new", {});
+      expect(mockClient.mockGet).toHaveBeenCalledWith("/subreddits/new", {});
+    });
+  });
+
+  describe("reddit_subreddits_search", () => {
+    it("calls GET /subreddits/search with query", async () => {
+      await mockClient.get("/subreddits/search", { q: "programming" });
+      expect(mockClient.mockGet).toHaveBeenCalledWith("/subreddits/search", {
+        q: "programming",
+      });
+    });
+  });
+});

package/tests/unit/transport.test.ts

@@ -0,0 +1,13 @@
+import { describe, it, expect } from "@jest/globals";
+import { startHttpTransport } from "../../src/transport/http.js";
+
+describe("HTTP Transport", () => {
+  it("exports startHttpTransport function", () => {
+    expect(typeof startHttpTransport).toBe("function");
+  });
+
+  it("accepts server and options parameters", () => {
+    // Verify the function signature matches expectations
+    expect(startHttpTransport.length).toBeGreaterThanOrEqual(1);
+  });
+});

package/tests/unit/users.test.ts

@@ -0,0 +1,124 @@
+import { describe, it, expect, beforeEach } from "@jest/globals";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { registerUserTools } from "../../src/tools/users.js";
+import { createMockClient } from "../helpers/mock-client.js";
+import {
+  mockUserProfile,
+  mockListing,
+  mockTrophiesResponse,
+  mockEmptyResponse,
+} from "../fixtures/reddit-responses.js";
+
+describe("User Profile Tools", () => {
+  let server: McpServer;
+  let mockClient: ReturnType<typeof createMockClient>;
+
+  beforeEach(() => {
+    server = new McpServer({ name: "test", version: "0.0.1" });
+    mockClient = createMockClient(
+      new Map([
+        ["/user/testuser/about", mockUserProfile],
+        ["/user/testuser/overview", mockListing],
+        ["/user/testuser/submitted", mockListing],
+        ["/user/testuser/comments", mockListing],
+        ["/user/testuser/saved", mockListing],
+        ["/user/testuser/upvoted", mockListing],
+        ["/user/testuser/downvoted", mockListing],
+        ["/api/v1/user/testuser/trophies", mockTrophiesResponse],
+        ["/api/block_user", mockEmptyResponse],
+      ]),
+    );
+    registerUserTools(server, mockClient);
+  });
+
+  it("registers user tools", () => {
+    expect(server).toBeDefined();
+  });
+
+  describe("reddit_user_about", () => {
+    it("calls GET /user/{username}/about", async () => {
+      const result = await mockClient.get("/user/testuser/about");
+      expect(mockClient.mockGet).toHaveBeenCalledWith("/user/testuser/about");
+      expect(result).toEqual(mockUserProfile);
+    });
+  });
+
+  describe("reddit_user_overview", () => {
+    it("calls GET /user/{username}/overview", async () => {
+      await mockClient.get("/user/testuser/overview", { sort: "new", limit: "10" });
+      expect(mockClient.mockGet).toHaveBeenCalledWith(
+        "/user/testuser/overview",
+        { sort: "new", limit: "10" },
+      );
+    });
+  });
+
+  describe("reddit_user_submitted", () => {
+    it("calls GET /user/{username}/submitted", async () => {
+      await mockClient.get("/user/testuser/submitted", { sort: "top", t: "week" });
+      expect(mockClient.mockGet).toHaveBeenCalledWith(
+        "/user/testuser/submitted",
+        { sort: "top", t: "week" },
+      );
+    });
+  });
+
+  describe("reddit_user_comments", () => {
+    it("calls GET /user/{username}/comments", async () => {
+      await mockClient.get("/user/testuser/comments", {});
+      expect(mockClient.mockGet).toHaveBeenCalledWith(
+        "/user/testuser/comments",
+        {},
+      );
+    });
+  });
+
+  describe("reddit_user_saved", () => {
+    it("calls GET /user/{username}/saved", async () => {
+      await mockClient.get("/user/testuser/saved", {});
+      expect(mockClient.mockGet).toHaveBeenCalledWith(
+        "/user/testuser/saved",
+        {},
+      );
+    });
+  });
+
+  describe("reddit_user_upvoted", () => {
+    it("calls GET /user/{username}/upvoted", async () => {
+      await mockClient.get("/user/testuser/upvoted", {});
+      expect(mockClient.mockGet).toHaveBeenCalledWith(
+        "/user/testuser/upvoted",
+        {},
+      );
+    });
+  });
+
+  describe("reddit_user_downvoted", () => {
+    it("calls GET /user/{username}/downvoted", async () => {
+      await mockClient.get("/user/testuser/downvoted", {});
+      expect(mockClient.mockGet).toHaveBeenCalledWith(
+        "/user/testuser/downvoted",
+        {},
+      );
+    });
+  });
+
+  describe("reddit_user_trophies", () => {
+    it("calls GET /api/v1/user/{username}/trophies", async () => {
+      const result = await mockClient.get("/api/v1/user/testuser/trophies");
+      expect(mockClient.mockGet).toHaveBeenCalledWith(
+        "/api/v1/user/testuser/trophies",
+      );
+      expect(result).toEqual(mockTrophiesResponse);
+    });
+  });
+
+  describe("reddit_block_user", () => {
+    it("calls POST /api/block_user", async () => {
+      await mockClient.post("/api/block_user", { name: "spammer" });
+      expect(mockClient.mockPost).toHaveBeenCalledWith("/api/block_user", {
+        name: "spammer",
+      });
+    });
+  });
+});

package/tests/unit/voting.test.ts

@@ -0,0 +1,110 @@
+import { describe, it, expect, beforeEach } from "@jest/globals";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { registerVotingTools } from "../../src/tools/voting.js";
+import { createMockClient } from "../helpers/mock-client.js";
+import { mockEmptyResponse } from "../fixtures/reddit-responses.js";
+
+describe("Voting, Save & Report Tools", () => {
+  let server: McpServer;
+  let mockClient: ReturnType<typeof createMockClient>;
+
+  beforeEach(() => {
+    server = new McpServer({ name: "test", version: "0.0.1" });
+    mockClient = createMockClient(
+      new Map([
+        ["/api/vote", mockEmptyResponse],
+        ["/api/save", mockEmptyResponse],
+        ["/api/unsave", mockEmptyResponse],
+        ["/api/report", mockEmptyResponse],
+      ]),
+    );
+    registerVotingTools(server, mockClient);
+  });
+
+  it("registers voting tools", () => {
+    expect(server).toBeDefined();
+  });
+
+  describe("reddit_vote", () => {
+    it("calls POST /api/vote for upvote", async () => {
+      await mockClient.post("/api/vote", { id: "t3_abc123", dir: "1" });
+      expect(mockClient.mockPost).toHaveBeenCalledWith("/api/vote", {
+        id: "t3_abc123",
+        dir: "1",
+      });
+    });
+
+    it("calls POST /api/vote for downvote", async () => {
+      await mockClient.post("/api/vote", { id: "t3_abc123", dir: "-1" });
+      expect(mockClient.mockPost).toHaveBeenCalledWith("/api/vote", {
+        id: "t3_abc123",
+        dir: "-1",
+      });
+    });
+
+    it("calls POST /api/vote for unvote", async () => {
+      await mockClient.post("/api/vote", { id: "t1_xyz789", dir: "0" });
+      expect(mockClient.mockPost).toHaveBeenCalledWith("/api/vote", {
+        id: "t1_xyz789",
+        dir: "0",
+      });
+    });
+  });
+
+  describe("reddit_save", () => {
+    it("calls POST /api/save", async () => {
+      await mockClient.post("/api/save", { id: "t3_abc123" });
+      expect(mockClient.mockPost).toHaveBeenCalledWith("/api/save", {
+        id: "t3_abc123",
+      });
+    });
+
+    it("supports category parameter", async () => {
+      await mockClient.post("/api/save", {
+        id: "t3_abc123",
+        category: "favorites",
+      });
+      expect(mockClient.mockPost).toHaveBeenCalledWith("/api/save", {
+        id: "t3_abc123",
+        category: "favorites",
+      });
+    });
+  });
+
+  describe("reddit_unsave", () => {
+    it("calls POST /api/unsave", async () => {
+      await mockClient.post("/api/unsave", { id: "t3_abc123" });
+      expect(mockClient.mockPost).toHaveBeenCalledWith("/api/unsave", {
+        id: "t3_abc123",
+      });
+    });
+  });
+
+  describe("reddit_report", () => {
+    it("calls POST /api/report with reason", async () => {
+      await mockClient.post("/api/report", {
+        thing_id: "t3_abc123",
+        reason: "spam",
+      });
+      expect(mockClient.mockPost).toHaveBeenCalledWith("/api/report", {
+        thing_id: "t3_abc123",
+        reason: "spam",
+      });
+    });
+
+    it("supports other_reason parameter", async () => {
+      await mockClient.post("/api/report", {
+        thing_id: "t1_xyz789",
+        reason: "other",
+        other_reason: "Offensive content",
+      });
+      expect(mockClient.mockPost).toHaveBeenCalledWith(
+        "/api/report",
+        expect.objectContaining({
+          reason: "other",
+          other_reason: "Offensive content",
+        }),
+      );
+    });
+  });
+});