@prmichaelsen/reddit-mcp 0.1.0 → 0.1.1

package/tests/unit/account.test.ts

@@ -0,0 +1,95 @@
+import { describe, it, expect, beforeEach } from "@jest/globals";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { registerAccountTools } from "../../src/tools/account.js";
+import { createMockClient } from "../helpers/mock-client.js";
+import {
+  mockMeResponse,
+  mockKarmaResponse,
+  mockPrefsResponse,
+  mockTrophiesResponse,
+  mockFriendsResponse,
+  mockBlockedResponse,
+} from "../fixtures/reddit-responses.js";
+
+describe("Account Tools", () => {
+  let server: McpServer;
+  let mockClient: ReturnType<typeof createMockClient>;
+
+  beforeEach(() => {
+    server = new McpServer({ name: "test", version: "0.0.1" });
+    mockClient = createMockClient(
+      new Map([
+        ["/api/v1/me", mockMeResponse],
+        ["/api/v1/me/karma", mockKarmaResponse],
+        ["/api/v1/me/prefs", mockPrefsResponse],
+        ["/api/v1/me/trophies", mockTrophiesResponse],
+        ["/prefs/friends", mockFriendsResponse],
+        ["/prefs/blocked", mockBlockedResponse],
+      ]),
+    );
+    registerAccountTools(server, mockClient);
+  });
+
+  it("registers account tools", () => {
+    expect(server).toBeDefined();
+  });
+
+  describe("reddit_me", () => {
+    it("calls GET /api/v1/me", async () => {
+      const result = await mockClient.get("/api/v1/me");
+      expect(mockClient.mockGet).toHaveBeenCalledWith("/api/v1/me");
+      expect(result).toEqual(mockMeResponse);
+    });
+  });
+
+  describe("reddit_me_karma", () => {
+    it("calls GET /api/v1/me/karma", async () => {
+      const result = await mockClient.get("/api/v1/me/karma");
+      expect(mockClient.mockGet).toHaveBeenCalledWith("/api/v1/me/karma");
+      expect(result).toEqual(mockKarmaResponse);
+    });
+  });
+
+  describe("reddit_me_prefs", () => {
+    it("calls GET /api/v1/me/prefs", async () => {
+      const result = await mockClient.get("/api/v1/me/prefs");
+      expect(mockClient.mockGet).toHaveBeenCalledWith("/api/v1/me/prefs");
+      expect(result).toEqual(mockPrefsResponse);
+    });
+  });
+
+  describe("reddit_me_prefs_update", () => {
+    it("calls PATCH /api/v1/me/prefs with prefs object", async () => {
+      const prefs = { over_18: true, hide_downs: true };
+      await mockClient.patch("/api/v1/me/prefs", prefs);
+      expect(mockClient.patch).toHaveBeenCalledWith(
+        "/api/v1/me/prefs",
+        prefs,
+      );
+    });
+  });
+
+  describe("reddit_me_trophies", () => {
+    it("calls GET /api/v1/me/trophies", async () => {
+      const result = await mockClient.get("/api/v1/me/trophies");
+      expect(mockClient.mockGet).toHaveBeenCalledWith("/api/v1/me/trophies");
+      expect(result).toEqual(mockTrophiesResponse);
+    });
+  });
+
+  describe("reddit_me_friends", () => {
+    it("calls GET /prefs/friends", async () => {
+      const result = await mockClient.get("/prefs/friends");
+      expect(mockClient.mockGet).toHaveBeenCalledWith("/prefs/friends");
+      expect(result).toEqual(mockFriendsResponse);
+    });
+  });
+
+  describe("reddit_me_blocked", () => {
+    it("calls GET /prefs/blocked", async () => {
+      const result = await mockClient.get("/prefs/blocked");
+      expect(mockClient.mockGet).toHaveBeenCalledWith("/prefs/blocked");
+      expect(result).toEqual(mockBlockedResponse);
+    });
+  });
+});

package/tests/unit/comments.test.ts

@@ -0,0 +1,92 @@
+import { describe, it, expect, beforeEach } from "@jest/globals";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { registerCommentTools } from "../../src/tools/comments.js";
+import { createMockClient } from "../helpers/mock-client.js";
+import {
+  mockCommentResponse,
+  mockMoreChildrenResponse,
+} from "../fixtures/reddit-responses.js";
+
+describe("Comment Tools", () => {
+  let server: McpServer;
+  let mockClient: ReturnType<typeof createMockClient>;
+
+  beforeEach(() => {
+    server = new McpServer({ name: "test", version: "0.0.1" });
+    mockClient = createMockClient(
+      new Map([
+        ["/api/comment", mockCommentResponse],
+        ["/api/morechildren", mockMoreChildrenResponse],
+      ]),
+    );
+    registerCommentTools(server, mockClient);
+  });
+
+  it("registers comment tools", () => {
+    expect(server).toBeDefined();
+  });
+
+  describe("reddit_comment", () => {
+    it("calls POST /api/comment for top-level comment", async () => {
+      await mockClient.post("/api/comment", {
+        parent: "t3_abc123",
+        text: "Great post!",
+        api_type: "json",
+      });
+      expect(mockClient.mockPost).toHaveBeenCalledWith(
+        "/api/comment",
+        expect.objectContaining({
+          parent: "t3_abc123",
+          text: "Great post!",
+        }),
+      );
+    });
+
+    it("calls POST /api/comment for reply", async () => {
+      await mockClient.post("/api/comment", {
+        parent: "t1_xyz789",
+        text: "I agree!",
+        api_type: "json",
+      });
+      expect(mockClient.mockPost).toHaveBeenCalledWith(
+        "/api/comment",
+        expect.objectContaining({
+          parent: "t1_xyz789",
+          text: "I agree!",
+        }),
+      );
+    });
+  });
+
+  describe("reddit_more_children", () => {
+    it("calls GET /api/morechildren", async () => {
+      await mockClient.get("/api/morechildren", {
+        link_id: "t3_abc123",
+        children: "comment1,comment2,comment3",
+        api_type: "json",
+      });
+      expect(mockClient.mockGet).toHaveBeenCalledWith(
+        "/api/morechildren",
+        expect.objectContaining({
+          link_id: "t3_abc123",
+          children: "comment1,comment2,comment3",
+        }),
+      );
+    });
+
+    it("supports sort parameter", async () => {
+      await mockClient.get("/api/morechildren", {
+        link_id: "t3_abc123",
+        children: "c1",
+        sort: "top",
+        api_type: "json",
+      });
+      expect(mockClient.mockGet).toHaveBeenCalledWith(
+        "/api/morechildren",
+        expect.objectContaining({
+          sort: "top",
+        }),
+      );
+    });
+  });
+});

package/tests/unit/flair.test.ts

@@ -0,0 +1,101 @@
+import { describe, it, expect, beforeEach } from "@jest/globals";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { registerFlairTools } from "../../src/tools/flair.js";
+import { createMockClient } from "../helpers/mock-client.js";
+import { mockEmptyResponse } from "../fixtures/reddit-responses.js";
+
+const mockFlairTemplates = [
+  {
+    type: "richtext",
+    text_editable: false,
+    allowable_content: "all",
+    text: "Discussion",
+    id: "flair_abc123",
+    css_class: "discussion",
+    text_color: "dark",
+    background_color: "#edeff1",
+  },
+  {
+    type: "richtext",
+    text_editable: true,
+    allowable_content: "all",
+    text: "Question",
+    id: "flair_xyz789",
+    css_class: "question",
+    text_color: "light",
+    background_color: "#0079d3",
+  },
+];
+
+describe("Flair 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/api/link_flair_v2", mockFlairTemplates],
+        ["/r/test/api/user_flair_v2", mockFlairTemplates],
+        ["/r/test/api/selectflair", mockEmptyResponse],
+      ]),
+    );
+    registerFlairTools(server, mockClient);
+  });
+
+  it("registers flair tools", () => {
+    expect(server).toBeDefined();
+  });
+
+  describe("reddit_link_flair", () => {
+    it("calls GET /r/{subreddit}/api/link_flair_v2", async () => {
+      const result = await mockClient.get("/r/test/api/link_flair_v2");
+      expect(mockClient.mockGet).toHaveBeenCalledWith(
+        "/r/test/api/link_flair_v2",
+      );
+      expect(result).toEqual(mockFlairTemplates);
+    });
+  });
+
+  describe("reddit_user_flair", () => {
+    it("calls GET /r/{subreddit}/api/user_flair_v2", async () => {
+      const result = await mockClient.get("/r/test/api/user_flair_v2");
+      expect(mockClient.mockGet).toHaveBeenCalledWith(
+        "/r/test/api/user_flair_v2",
+      );
+      expect(result).toEqual(mockFlairTemplates);
+    });
+  });
+
+  describe("reddit_select_flair", () => {
+    it("calls POST /r/{subreddit}/api/selectflair for link flair", async () => {
+      await mockClient.post("/r/test/api/selectflair", {
+        flair_template_id: "flair_abc123",
+        link: "t3_abc123",
+      });
+      expect(mockClient.mockPost).toHaveBeenCalledWith(
+        "/r/test/api/selectflair",
+        expect.objectContaining({
+          flair_template_id: "flair_abc123",
+          link: "t3_abc123",
+        }),
+      );
+    });
+
+    it("calls POST /r/{subreddit}/api/selectflair for user flair", async () => {
+      await mockClient.post("/r/test/api/selectflair", {
+        flair_template_id: "flair_xyz789",
+        name: "testuser",
+        text: "Custom Text",
+      });
+      expect(mockClient.mockPost).toHaveBeenCalledWith(
+        "/r/test/api/selectflair",
+        expect.objectContaining({
+          flair_template_id: "flair_xyz789",
+          name: "testuser",
+          text: "Custom Text",
+        }),
+      );
+    });
+  });
+});

package/tests/unit/messages.test.ts

@@ -0,0 +1,106 @@
+import { describe, it, expect, beforeEach } from "@jest/globals";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { registerMessageTools } from "../../src/tools/messages.js";
+import { createMockClient } from "../helpers/mock-client.js";
+import {
+  mockMessageListing,
+  mockComposeResponse,
+  mockEmptyResponse,
+} from "../fixtures/reddit-responses.js";
+
+describe("Private Message Tools", () => {
+  let server: McpServer;
+  let mockClient: ReturnType<typeof createMockClient>;
+
+  beforeEach(() => {
+    server = new McpServer({ name: "test", version: "0.0.1" });
+    mockClient = createMockClient(
+      new Map([
+        ["/message/inbox", mockMessageListing],
+        ["/message/unread", mockMessageListing],
+        ["/message/sent", mockMessageListing],
+        ["/api/compose", mockComposeResponse],
+        ["/api/read_message", mockEmptyResponse],
+        ["/api/unread_message", mockEmptyResponse],
+        ["/api/del_msg", mockEmptyResponse],
+      ]),
+    );
+    registerMessageTools(server, mockClient);
+  });
+
+  it("registers message tools", () => {
+    expect(server).toBeDefined();
+  });
+
+  describe("reddit_inbox", () => {
+    it("calls GET /message/inbox", async () => {
+      const result = await mockClient.get("/message/inbox", { limit: "10" });
+      expect(mockClient.mockGet).toHaveBeenCalledWith("/message/inbox", {
+        limit: "10",
+      });
+      expect(result).toEqual(mockMessageListing);
+    });
+  });
+
+  describe("reddit_unread", () => {
+    it("calls GET /message/unread", async () => {
+      const result = await mockClient.get("/message/unread");
+      expect(mockClient.mockGet).toHaveBeenCalledWith("/message/unread");
+      expect(result).toEqual(mockMessageListing);
+    });
+  });
+
+  describe("reddit_sent", () => {
+    it("calls GET /message/sent", async () => {
+      await mockClient.get("/message/sent");
+      expect(mockClient.mockGet).toHaveBeenCalledWith("/message/sent");
+    });
+  });
+
+  describe("reddit_compose", () => {
+    it("calls POST /api/compose", async () => {
+      await mockClient.post("/api/compose", {
+        to: "otheruser",
+        subject: "Hello",
+        text: "Hi there!",
+        api_type: "json",
+      });
+      expect(mockClient.mockPost).toHaveBeenCalledWith(
+        "/api/compose",
+        expect.objectContaining({
+          to: "otheruser",
+          subject: "Hello",
+          text: "Hi there!",
+        }),
+      );
+    });
+  });
+
+  describe("reddit_read_message", () => {
+    it("calls POST /api/read_message", async () => {
+      await mockClient.post("/api/read_message", { id: "t4_msg1" });
+      expect(mockClient.mockPost).toHaveBeenCalledWith("/api/read_message", {
+        id: "t4_msg1",
+      });
+    });
+  });
+
+  describe("reddit_unread_message", () => {
+    it("calls POST /api/unread_message", async () => {
+      await mockClient.post("/api/unread_message", { id: "t4_msg1" });
+      expect(mockClient.mockPost).toHaveBeenCalledWith(
+        "/api/unread_message",
+        { id: "t4_msg1" },
+      );
+    });
+  });
+
+  describe("reddit_del_msg", () => {
+    it("calls POST /api/del_msg", async () => {
+      await mockClient.post("/api/del_msg", { id: "t4_msg1" });
+      expect(mockClient.mockPost).toHaveBeenCalledWith("/api/del_msg", {
+        id: "t4_msg1",
+      });
+    });
+  });
+});

package/tests/unit/moderation.test.ts

@@ -0,0 +1,243 @@
+import { describe, it, expect, beforeEach } from "@jest/globals";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { registerModerationTools } from "../../src/tools/moderation.js";
+import { createMockClient } from "../helpers/mock-client.js";
+import { mockListing, mockEmptyResponse } from "../fixtures/reddit-responses.js";
+
+const mockUserList = {
+  kind: "UserList",
+  data: {
+    children: [
+      { name: "mod1", date: 1700000000, id: "t2_mod1" },
+    ],
+  },
+};
+
+const mockModlogResponse = {
+  kind: "Listing",
+  data: {
+    after: null,
+    children: [
+      {
+        kind: "modaction",
+        data: {
+          id: "ModAction_abc",
+          mod: "mod1",
+          action: "removelink",
+          target_fullname: "t3_abc123",
+          created_utc: 1710000000,
+        },
+      },
+    ],
+  },
+};
+
+describe("Moderation Tools", () => {
+  let server: McpServer;
+  let mockClient: ReturnType<typeof createMockClient>;
+
+  beforeEach(() => {
+    server = new McpServer({ name: "test", version: "0.0.1" });
+    mockClient = createMockClient(
+      new Map([
+        ["/api/approve", mockEmptyResponse],
+        ["/api/remove", mockEmptyResponse],
+        ["/api/distinguish", mockEmptyResponse],
+        ["/api/ignore_reports", mockEmptyResponse],
+        ["/api/unignore_reports", mockEmptyResponse],
+        ["/api/lock", mockEmptyResponse],
+        ["/api/unlock", mockEmptyResponse],
+        ["/r/test/about/modqueue", mockListing],
+        ["/r/test/about/reports", mockListing],
+        ["/r/test/about/spam", mockListing],
+        ["/r/test/about/edited", mockListing],
+        ["/r/test/about/log", mockModlogResponse],
+        ["/r/test/about/moderators", mockUserList],
+        ["/r/test/about/contributors", mockUserList],
+        ["/r/test/about/banned", mockUserList],
+        ["/r/test/about/muted", mockUserList],
+      ]),
+    );
+    registerModerationTools(server, mockClient);
+  });
+
+  it("registers moderation tools", () => {
+    expect(server).toBeDefined();
+  });
+
+  // === Mod Action Tools ===
+
+  describe("reddit_approve", () => {
+    it("calls POST /api/approve", async () => {
+      await mockClient.post("/api/approve", { id: "t3_abc123" });
+      expect(mockClient.mockPost).toHaveBeenCalledWith("/api/approve", {
+        id: "t3_abc123",
+      });
+    });
+  });
+
+  describe("reddit_remove", () => {
+    it("calls POST /api/remove", async () => {
+      await mockClient.post("/api/remove", { id: "t3_abc123" });
+      expect(mockClient.mockPost).toHaveBeenCalledWith("/api/remove", {
+        id: "t3_abc123",
+      });
+    });
+
+    it("supports spam flag", async () => {
+      await mockClient.post("/api/remove", { id: "t3_abc123", spam: "true" });
+      expect(mockClient.mockPost).toHaveBeenCalledWith("/api/remove", {
+        id: "t3_abc123",
+        spam: "true",
+      });
+    });
+  });
+
+  describe("reddit_distinguish", () => {
+    it("calls POST /api/distinguish", async () => {
+      await mockClient.post("/api/distinguish", {
+        id: "t1_xyz789",
+        how: "yes",
+      });
+      expect(mockClient.mockPost).toHaveBeenCalledWith("/api/distinguish", {
+        id: "t1_xyz789",
+        how: "yes",
+      });
+    });
+  });
+
+  describe("reddit_ignore_reports", () => {
+    it("calls POST /api/ignore_reports", async () => {
+      await mockClient.post("/api/ignore_reports", { id: "t3_abc123" });
+      expect(mockClient.mockPost).toHaveBeenCalledWith("/api/ignore_reports", {
+        id: "t3_abc123",
+      });
+    });
+  });
+
+  describe("reddit_unignore_reports", () => {
+    it("calls POST /api/unignore_reports", async () => {
+      await mockClient.post("/api/unignore_reports", { id: "t3_abc123" });
+      expect(mockClient.mockPost).toHaveBeenCalledWith(
+        "/api/unignore_reports",
+        { id: "t3_abc123" },
+      );
+    });
+  });
+
+  describe("reddit_lock", () => {
+    it("calls POST /api/lock", async () => {
+      await mockClient.post("/api/lock", { id: "t3_abc123" });
+      expect(mockClient.mockPost).toHaveBeenCalledWith("/api/lock", {
+        id: "t3_abc123",
+      });
+    });
+  });
+
+  describe("reddit_unlock", () => {
+    it("calls POST /api/unlock", async () => {
+      await mockClient.post("/api/unlock", { id: "t3_abc123" });
+      expect(mockClient.mockPost).toHaveBeenCalledWith("/api/unlock", {
+        id: "t3_abc123",
+      });
+    });
+  });
+
+  // === Mod Listing Tools ===
+
+  describe("reddit_modqueue", () => {
+    it("calls GET /r/{subreddit}/about/modqueue", async () => {
+      await mockClient.get("/r/test/about/modqueue", { limit: "10" });
+      expect(mockClient.mockGet).toHaveBeenCalledWith(
+        "/r/test/about/modqueue",
+        { limit: "10" },
+      );
+    });
+  });
+
+  describe("reddit_reports", () => {
+    it("calls GET /r/{subreddit}/about/reports", async () => {
+      await mockClient.get("/r/test/about/reports", {});
+      expect(mockClient.mockGet).toHaveBeenCalledWith(
+        "/r/test/about/reports",
+        {},
+      );
+    });
+  });
+
+  describe("reddit_spam", () => {
+    it("calls GET /r/{subreddit}/about/spam", async () => {
+      await mockClient.get("/r/test/about/spam", {});
+      expect(mockClient.mockGet).toHaveBeenCalledWith(
+        "/r/test/about/spam",
+        {},
+      );
+    });
+  });
+
+  describe("reddit_edited", () => {
+    it("calls GET /r/{subreddit}/about/edited", async () => {
+      await mockClient.get("/r/test/about/edited", {});
+      expect(mockClient.mockGet).toHaveBeenCalledWith(
+        "/r/test/about/edited",
+        {},
+      );
+    });
+  });
+
+  describe("reddit_modlog", () => {
+    it("calls GET /r/{subreddit}/about/log", async () => {
+      const result = await mockClient.get("/r/test/about/log", {
+        type: "removelink",
+        mod: "mod1",
+      });
+      expect(mockClient.mockGet).toHaveBeenCalledWith("/r/test/about/log", {
+        type: "removelink",
+        mod: "mod1",
+      });
+      expect(result).toEqual(mockModlogResponse);
+    });
+  });
+
+  // === Mod Management Tools ===
+
+  describe("reddit_moderators", () => {
+    it("calls GET /r/{subreddit}/about/moderators", async () => {
+      const result = await mockClient.get("/r/test/about/moderators");
+      expect(mockClient.mockGet).toHaveBeenCalledWith(
+        "/r/test/about/moderators",
+      );
+      expect(result).toEqual(mockUserList);
+    });
+  });
+
+  describe("reddit_contributors", () => {
+    it("calls GET /r/{subreddit}/about/contributors", async () => {
+      await mockClient.get("/r/test/about/contributors", { limit: "25" });
+      expect(mockClient.mockGet).toHaveBeenCalledWith(
+        "/r/test/about/contributors",
+        { limit: "25" },
+      );
+    });
+  });
+
+  describe("reddit_banned", () => {
+    it("calls GET /r/{subreddit}/about/banned", async () => {
+      await mockClient.get("/r/test/about/banned", {});
+      expect(mockClient.mockGet).toHaveBeenCalledWith(
+        "/r/test/about/banned",
+        {},
+      );
+    });
+  });
+
+  describe("reddit_muted", () => {
+    it("calls GET /r/{subreddit}/about/muted", async () => {
+      await mockClient.get("/r/test/about/muted", {});
+      expect(mockClient.mockGet).toHaveBeenCalledWith(
+        "/r/test/about/muted",
+        {},
+      );
+    });
+  });
+});