@esaio/esa-mcp-server 0.2.1 → 0.2.3

package/src/tools/__tests__/helps.test.ts

@@ -1,222 +0,0 @@
-import { describe, expect, it, vi } from "vitest";
-import type { createEsaClient } from "../../api_client/index.js";
-import {
-  getMarkdownSyntaxHelp,
-  getSearchOptionsHelp,
-  HELP_DOCS,
-  searchHelp,
-} from "../helps.js";
-import * as posts from "../posts.js";
-import * as search from "../search.js";
-
-// Mock the posts and search modules
-vi.mock("../posts.js", () => ({
-  getPost: vi.fn(),
-}));
-
-vi.mock("../search.js", async (importOriginal) => {
-  const actual = await importOriginal<typeof import("../search.js")>();
-  return {
-    ...actual,
-    searchPosts: vi.fn(),
-  };
-});
-
-describe("getSearchOptionsHelp", () => {
-  const mockClient = {} as ReturnType<typeof createEsaClient>;
-
-  it("should call getPost with correct parameters for search options documentation", async () => {
-    const mockGetPost = vi.mocked(posts.getPost);
-    mockGetPost.mockResolvedValue({
-      content: [{ type: "text", text: "mocked response" }],
-    });
-
-    const result = await getSearchOptionsHelp(mockClient, {});
-
-    expect(mockGetPost).toHaveBeenCalledWith(mockClient, {
-      teamName: HELP_DOCS.TEAM,
-      postNumber: HELP_DOCS.SEARCH_OPTIONS_POST_ID,
-    });
-
-    expect(result.content[0].text).toBe("mocked response");
-  });
-
-  it("should handle API errors", async () => {
-    const mockGetPost = vi.mocked(posts.getPost);
-    mockGetPost.mockResolvedValue({
-      content: [{ type: "text", text: "Error: Post not found" }],
-    });
-
-    const result = await getSearchOptionsHelp(mockClient, {});
-
-    expect(result.content[0].text).toContain("Error:");
-  });
-
-  it("should handle network errors", async () => {
-    const mockGetPost = vi.mocked(posts.getPost);
-    mockGetPost.mockResolvedValue({
-      content: [{ type: "text", text: "Error: Network connection failed" }],
-    });
-
-    const result = await getSearchOptionsHelp(mockClient, {});
-
-    expect(result.content[0].text).toContain("Network connection failed");
-  });
-
-  it("should handle non-Error exceptions", async () => {
-    const mockGetPost = vi.mocked(posts.getPost);
-    mockGetPost.mockResolvedValue({
-      content: [{ type: "text", text: "Error: Unexpected error" }],
-    });
-
-    const result = await getSearchOptionsHelp(mockClient, {});
-
-    expect(result.content[0].text).toContain("Unexpected error");
-  });
-});
-
-describe("getMarkdownSyntaxHelp", () => {
-  const mockClient = {} as ReturnType<typeof createEsaClient>;
-
-  it("should call getPost with correct parameters for markdown syntax documentation", async () => {
-    const mockGetPost = vi.mocked(posts.getPost);
-    mockGetPost.mockResolvedValue({
-      content: [{ type: "text", text: "markdown syntax help" }],
-    });
-
-    const result = await getMarkdownSyntaxHelp(mockClient, {});
-
-    expect(mockGetPost).toHaveBeenCalledWith(mockClient, {
-      teamName: HELP_DOCS.TEAM,
-      postNumber: HELP_DOCS.MARKDOWN_SYNTAX_POST_ID,
-    });
-
-    expect(result.content[0].text).toBe("markdown syntax help");
-  });
-
-  it("should handle API errors", async () => {
-    const mockGetPost = vi.mocked(posts.getPost);
-    mockGetPost.mockResolvedValue({
-      content: [{ type: "text", text: "Error: Access denied" }],
-    });
-
-    const result = await getMarkdownSyntaxHelp(mockClient, {});
-
-    expect(result.content[0].text).toContain("Error:");
-  });
-
-  it("should handle network errors", async () => {
-    const mockGetPost = vi.mocked(posts.getPost);
-    mockGetPost.mockResolvedValue({
-      content: [{ type: "text", text: "Error: Network connection failed" }],
-    });
-
-    const result = await getMarkdownSyntaxHelp(mockClient, {});
-
-    expect(result.content[0].text).toContain("Network connection failed");
-  });
-
-  it("should handle non-Error exceptions", async () => {
-    const mockGetPost = vi.mocked(posts.getPost);
-    mockGetPost.mockResolvedValue({
-      content: [{ type: "text", text: "Error: Unexpected error" }],
-    });
-
-    const result = await getMarkdownSyntaxHelp(mockClient, {});
-
-    expect(result.content[0].text).toContain("Unexpected error");
-  });
-});
-
-describe("searchHelp", () => {
-  const mockClient = {} as ReturnType<typeof createEsaClient>;
-
-  it("should call searchPosts with docs team and correct parameters", async () => {
-    const mockSearchPosts = vi.mocked(search.searchPosts);
-    mockSearchPosts.mockResolvedValue({
-      content: [{ type: "text", text: "mocked search results" }],
-    });
-
-    await searchHelp(mockClient, {
-      query: "webhook API",
-      page: 2,
-      perPage: 20,
-    });
-
-    expect(mockSearchPosts).toHaveBeenCalledWith(mockClient, {
-      teamName: HELP_DOCS.TEAM,
-      sort: "best_match",
-      query: "webhook API",
-      page: 2,
-      perPage: 20,
-    });
-  });
-
-  it("should call searchPosts with minimal parameters", async () => {
-    const mockSearchPosts = vi.mocked(search.searchPosts);
-    mockSearchPosts.mockResolvedValue({
-      content: [{ type: "text", text: "emoji help results" }],
-    });
-
-    const result = await searchHelp(mockClient, {
-      query: "emoji reaction",
-    });
-
-    expect(mockSearchPosts).toHaveBeenCalledWith(mockClient, {
-      teamName: HELP_DOCS.TEAM,
-      sort: "best_match",
-      query: "emoji reaction",
-      page: undefined,
-      perPage: undefined,
-    });
-
-    expect(result.content[0].text).toBe("emoji help results");
-  });
-
-  it("should handle API errors", async () => {
-    const mockSearchPosts = vi.mocked(search.searchPosts);
-    mockSearchPosts.mockResolvedValue({
-      content: [{ type: "text", text: "Error: Search failed" }],
-    });
-
-    const result = await searchHelp(mockClient, {
-      query: "test query",
-    });
-
-    expect(result.content[0].text).toContain("Error:");
-  });
-
-  it("should handle network errors", async () => {
-    const mockSearchPosts = vi.mocked(search.searchPosts);
-    mockSearchPosts.mockResolvedValue({
-      content: [{ type: "text", text: "Error: Network connection failed" }],
-    });
-
-    const result = await searchHelp(mockClient, {
-      query: "test query",
-    });
-
-    expect(result.content[0].text).toContain("Network connection failed");
-  });
-
-  it("should handle non-Error exceptions", async () => {
-    const mockSearchPosts = vi.mocked(search.searchPosts);
-    mockSearchPosts.mockResolvedValue({
-      content: [{ type: "text", text: "Error: Unexpected error" }],
-    });
-
-    const result = await searchHelp(mockClient, {
-      query: "test query",
-    });
-
-    expect(result.content[0].text).toContain("Unexpected error");
-  });
-});
-
-describe("HELP_DOCS constants", () => {
-  it("should have correct constant values", () => {
-    expect(HELP_DOCS.TEAM).toBe("docs");
-    expect(HELP_DOCS.SEARCH_OPTIONS_POST_ID).toBe(104);
-    expect(HELP_DOCS.MARKDOWN_SYNTAX_POST_ID).toBe(49);
-  });
-});

package/src/tools/__tests__/index.test.ts

@@ -1,48 +0,0 @@
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import type { MockInstance } from "vitest";
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-import type { MCPContext } from "../../context/mcp-context.js";
-import { setupTools } from "../index.js";
-
-describe("setupTools", () => {
-  let server: McpServer;
-  let context: MCPContext;
-  let consoleErrorSpy: MockInstance<typeof console.error>;
-
-  beforeEach(() => {
-    server = new McpServer({
-      name: "test-server",
-      version: "1.0.0",
-    });
-    context = {} as unknown as MCPContext;
-
-    consoleErrorSpy = vi.spyOn(console, "error").mockImplementation(() => {});
-    vi.clearAllMocks();
-  });
-
-  afterEach(() => {
-    consoleErrorSpy.mockRestore();
-  });
-
-  it("should register all 24 tools with correct handlers", () => {
-    const registerToolSpy = vi.spyOn(server, "registerTool");
-
-    setupTools(server, context);
-
-    expect(registerToolSpy).toHaveBeenCalledTimes(24);
-
-    for (let i = 0; i < 24; i++) {
-      const [toolName, schema, handler] = registerToolSpy.mock.calls[i];
-      expect(typeof toolName).toBe("string");
-      expect(toolName).toMatch(/^esa_/); // All tools should start with 'esa_'
-      expect(schema).toBeTypeOf("object"); // Schema verification handled by individual tool tests
-      expect(handler).toBeTypeOf("function"); // Handler functionality tested in specific tool tests
-    }
-  });
-
-  it("should log setup completion message", () => {
-    setupTools(server, context);
-
-    expect(consoleErrorSpy).toHaveBeenCalledWith("Setting up MCP tools...");
-  });
-});

package/src/tools/__tests__/post-actions.test.ts

@@ -1,445 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from "vitest";
-import { createMockPost } from "../../__tests__/fixtures/mock-post.js";
-import type { createEsaClient } from "../../api_client/index.js";
-import { archivePost, duplicatePost, shipPost } from "../post-actions.js";
-import * as postsModule from "../posts.js";
-
-vi.mock("../posts.js", () => ({
-  updatePost: vi.fn(),
-  createPost: vi.fn(),
-}));
-
-describe("archivePost", () => {
-  const mockClient = {
-    GET: vi.fn(),
-  } as unknown as ReturnType<typeof createEsaClient> & {
-    GET: ReturnType<typeof vi.fn>;
-  };
-
-  const mockUpdatePost = vi.mocked(postsModule.updatePost);
-
-  beforeEach(() => {
-    vi.clearAllMocks();
-  });
-
-  it("should call updatePost with Archived category for post without category", async () => {
-    const currentPost = createMockPost({
-      number: 123,
-      category: "",
-    });
-
-    mockClient.GET.mockResolvedValue({
-      data: currentPost,
-      error: undefined,
-      response: {
-        ok: true,
-        status: 200,
-      } as Response,
-    });
-
-    mockUpdatePost.mockResolvedValue({
-      content: [{ type: "text", text: "Updated post" }],
-    });
-
-    await archivePost(mockClient, {
-      teamName: "test-team",
-      postNumber: 123,
-    });
-
-    expect(mockUpdatePost).toHaveBeenCalledWith(mockClient, {
-      teamName: "test-team",
-      postNumber: 123,
-      category: "Archived",
-      message: "Archive post",
-    });
-  });
-
-  it("should call updatePost with Archived/ prefix for post with category", async () => {
-    const currentPost = createMockPost({
-      number: 123,
-      category: "dev/docs",
-    });
-
-    mockClient.GET.mockResolvedValue({
-      data: currentPost,
-      error: undefined,
-      response: {
-        ok: true,
-        status: 200,
-      } as Response,
-    });
-
-    mockUpdatePost.mockResolvedValue({
-      content: [{ type: "text", text: "Updated post" }],
-    });
-
-    await archivePost(mockClient, {
-      teamName: "test-team",
-      postNumber: 123,
-      message: "Custom archive message",
-    });
-
-    expect(mockUpdatePost).toHaveBeenCalledWith(mockClient, {
-      teamName: "test-team",
-      postNumber: 123,
-      category: "Archived/dev/docs",
-      message: "Custom archive message",
-    });
-  });
-
-  it("should return already archived message without calling updatePost", async () => {
-    const currentPost = createMockPost({
-      number: 123,
-      category: "Archived/dev/docs",
-    });
-
-    mockClient.GET.mockResolvedValue({
-      data: currentPost,
-      error: undefined,
-      response: {
-        ok: true,
-        status: 200,
-      } as Response,
-    });
-
-    const result = await archivePost(mockClient, {
-      teamName: "test-team",
-      postNumber: 123,
-    });
-
-    expect(mockUpdatePost).not.toHaveBeenCalled();
-    expect(result.content[0].text).toContain("Post is already archived");
-    expect(result.content[0].text).toContain("Archived/dev/docs");
-  });
-
-  it("should handle GET error", async () => {
-    const mockError = { error: "not_found", message: "Post not found" };
-
-    mockClient.GET.mockResolvedValue({
-      data: undefined,
-      error: mockError,
-      response: {
-        ok: false,
-        status: 404,
-      } as Response,
-    });
-
-    const result = await archivePost(mockClient, {
-      teamName: "test-team",
-      postNumber: 999,
-    });
-
-    expect(result.content[0].text).toContain("not_found");
-    expect(mockUpdatePost).not.toHaveBeenCalled();
-  });
-
-  it("should handle network errors", async () => {
-    const networkError = new Error("Network connection failed");
-
-    mockClient.GET.mockRejectedValue(networkError);
-
-    const result = await archivePost(mockClient, {
-      teamName: "test-team",
-      postNumber: 123,
-    });
-
-    expect(result.content[0].text).toContain("Network connection failed");
-    expect(mockUpdatePost).not.toHaveBeenCalled();
-  });
-
-  it("should handle non-Error exceptions", async () => {
-    mockClient.GET.mockRejectedValue("Unexpected error");
-
-    const result = await archivePost(mockClient, {
-      teamName: "test-team",
-      postNumber: 123,
-    });
-
-    expect(result.content[0].text).toContain("Unexpected error");
-    expect(mockUpdatePost).not.toHaveBeenCalled();
-  });
-
-  it("should throw MissingTeamNameError when teamName is empty", async () => {
-    const result = await archivePost(mockClient, {
-      teamName: "",
-      postNumber: 123,
-    });
-
-    expect(result).toEqual({
-      content: [
-        {
-          type: "text",
-          text: "Error: Missing required parameter 'teamName'. Use esa_get_teams to list available teams, then retry with teamName specified.",
-        },
-      ],
-    });
-
-    expect(mockClient.GET).not.toHaveBeenCalled();
-  });
-});
-
-describe("shipPost", () => {
-  const mockClient = {} as ReturnType<typeof createEsaClient>;
-  const mockUpdatePost = vi.mocked(postsModule.updatePost);
-
-  beforeEach(() => {
-    vi.clearAllMocks();
-  });
-
-  it("should call updatePost with wip: false", async () => {
-    mockUpdatePost.mockResolvedValue({
-      content: [{ type: "text", text: "Updated post" }],
-    });
-
-    await shipPost(mockClient, {
-      teamName: "test-team",
-      postNumber: 123,
-    });
-
-    expect(mockUpdatePost).toHaveBeenCalledWith(mockClient, {
-      teamName: "test-team",
-      postNumber: 123,
-      wip: false,
-      message: "Ship It!",
-    });
-  });
-
-  it("should handle updatePost errors", async () => {
-    mockUpdatePost.mockResolvedValue({
-      content: [{ type: "text", text: "Error: Post not found" }],
-    });
-
-    const result = await shipPost(mockClient, {
-      teamName: "test-team",
-      postNumber: 999,
-    });
-
-    expect(result.content[0].text).toContain("Error:");
-  });
-
-  it("should handle network errors", async () => {
-    const networkError = new Error("Network connection failed");
-    mockUpdatePost.mockRejectedValue(networkError);
-
-    const result = await shipPost(mockClient, {
-      teamName: "test-team",
-      postNumber: 123,
-    });
-
-    expect(result.content[0].text).toContain("Network connection failed");
-  });
-
-  it("should handle non-Error exceptions", async () => {
-    mockUpdatePost.mockRejectedValue("Unexpected error");
-
-    const result = await shipPost(mockClient, {
-      teamName: "test-team",
-      postNumber: 123,
-    });
-
-    expect(result.content[0].text).toContain("Unexpected error");
-  });
-
-  it("should throw MissingTeamNameError when teamName is empty", async () => {
-    const result = await shipPost(mockClient, {
-      teamName: "",
-      postNumber: 123,
-    });
-
-    expect(result).toEqual({
-      content: [
-        {
-          type: "text",
-          text: "Error: Missing required parameter 'teamName'. Use esa_get_teams to list available teams, then retry with teamName specified.",
-        },
-      ],
-    });
-
-    expect(mockUpdatePost).not.toHaveBeenCalled();
-  });
-});
-
-describe("duplicatePost", () => {
-  const mockClient = {
-    GET: vi.fn(),
-    POST: vi.fn(),
-  } as unknown as ReturnType<typeof createEsaClient> & {
-    GET: ReturnType<typeof vi.fn>;
-    POST: ReturnType<typeof vi.fn>;
-  };
-
-  const mockCreatePost = vi.mocked(postsModule.createPost);
-
-  beforeEach(() => {
-    vi.clearAllMocks();
-  });
-
-  it("should call createPost with correct parameters", async () => {
-    const mockPostNew = {
-      name: "docs/api/authentication",
-      body_md: "# Authentication\n\nThis is the authentication guide.",
-    };
-
-    mockClient.GET.mockResolvedValue({
-      data: { post: mockPostNew },
-      error: undefined,
-      response: {
-        ok: true,
-        status: 200,
-      } as Response,
-    });
-
-    mockCreatePost.mockResolvedValue({
-      content: [{ type: "text", text: "Created post" }],
-    });
-
-    await duplicatePost(mockClient, {
-      teamName: "test-team",
-      postNumber: 123,
-    });
-
-    expect(mockClient.GET).toHaveBeenCalledWith(
-      "/v1/teams/{team_name}/posts/new",
-      {
-        params: {
-          path: { team_name: "test-team" },
-          query: {
-            parent_post_id: 123,
-          },
-        },
-      },
-    );
-
-    expect(mockCreatePost).toHaveBeenCalledWith(mockClient, {
-      teamName: "test-team",
-      name: "docs/api/authentication",
-      bodyMd: "# Authentication\n\nThis is the authentication guide.",
-      wip: true,
-    });
-  });
-
-  it("should use targetTeamName when provided", async () => {
-    const mockPostNew = {
-      name: "simple-post",
-      body_md: "This is a simple post.",
-    };
-
-    mockClient.GET.mockResolvedValue({
-      data: { post: mockPostNew },
-      error: undefined,
-      response: {
-        ok: true,
-        status: 200,
-      } as Response,
-    });
-
-    mockCreatePost.mockResolvedValue({
-      content: [{ type: "text", text: "Created post" }],
-    });
-
-    await duplicatePost(mockClient, {
-      teamName: "test-team",
-      postNumber: 456,
-      targetTeamName: "another-team",
-    });
-
-    expect(mockClient.GET).toHaveBeenCalledWith(
-      "/v1/teams/{team_name}/posts/new",
-      {
-        params: {
-          path: { team_name: "test-team" },
-          query: {
-            parent_post_id: 456,
-          },
-        },
-      },
-    );
-
-    expect(mockCreatePost).toHaveBeenCalledWith(mockClient, {
-      teamName: "another-team",
-      name: "simple-post",
-      bodyMd: "This is a simple post.",
-      wip: true,
-    });
-  });
-
-  it("should handle API error", async () => {
-    const mockError = { error: "not_found", message: "Post not found" };
-
-    mockClient.GET.mockResolvedValue({
-      data: undefined,
-      error: mockError,
-      response: {
-        ok: false,
-        status: 404,
-      } as Response,
-    });
-
-    const result = await duplicatePost(mockClient, {
-      teamName: "test-team",
-      postNumber: 999,
-    });
-
-    expect(result.content[0].text).toContain("not_found");
-  });
-
-  it("should handle response not ok", async () => {
-    mockClient.GET.mockResolvedValue({
-      data: undefined,
-      error: undefined,
-      response: {
-        ok: false,
-        status: 500,
-      } as Response,
-    });
-
-    const result = await duplicatePost(mockClient, {
-      teamName: "test-team",
-      postNumber: 789,
-    });
-
-    expect(result.content[0].text).toContain("500");
-  });
-
-  it("should handle network errors", async () => {
-    const networkError = new Error("Network connection failed");
-
-    mockClient.GET.mockRejectedValue(networkError);
-
-    const result = await duplicatePost(mockClient, {
-      teamName: "test-team",
-      postNumber: 123,
-    });
-
-    expect(result.content[0].text).toContain("Network connection failed");
-  });
-
-  it("should handle non-Error exceptions", async () => {
-    mockClient.GET.mockRejectedValue("Unexpected error");
-
-    const result = await duplicatePost(mockClient, {
-      teamName: "test-team",
-      postNumber: 123,
-    });
-
-    expect(result.content[0].text).toContain("Unexpected error");
-  });
-
-  it("should throw MissingTeamNameError when teamName is empty", async () => {
-    const result = await duplicatePost(mockClient, {
-      teamName: "",
-      postNumber: 123,
-    });
-
-    expect(result).toEqual({
-      content: [
-        {
-          type: "text",
-          text: "Error: Missing required parameter 'teamName'. Use esa_get_teams to list available teams, then retry with teamName specified.",
-        },
-      ],
-    });
-
-    expect(mockClient.GET).not.toHaveBeenCalled();
-  });
-});