@langwatch/mcp-server 2.1.0 → 2.2.0

package/src/__tests__/datasets.integration.test.ts

@@ -1,620 +0,0 @@
-import { createServer, type Server } from "http";
-import { afterAll, beforeAll, beforeEach, describe, expect, it } from "vitest";
-import { initConfig } from "../config.js";
-
-// --- Canned responses for dataset API endpoints ---
-
-const CANNED_DATASETS_LIST = {
-  data: [
-    {
-      id: "ds_abc123",
-      name: "User Feedback",
-      slug: "user-feedback",
-      columnTypes: [
-        { name: "input", type: "string" },
-        { name: "output", type: "string" },
-      ],
-      recordCount: 25,
-      createdAt: "2025-01-01T00:00:00.000Z",
-      updatedAt: "2025-01-02T00:00:00.000Z",
-    },
-    {
-      id: "ds_def456",
-      name: "Training Data",
-      slug: "training-data",
-      columnTypes: [{ name: "prompt", type: "string" }],
-      recordCount: 100,
-      createdAt: "2025-01-03T00:00:00.000Z",
-      updatedAt: "2025-01-04T00:00:00.000Z",
-    },
-  ],
-  pagination: { total: 2, page: 1, limit: 50, totalPages: 1 },
-};
-
-const CANNED_DATASETS_EMPTY = {
-  data: [],
-  pagination: { total: 0, page: 1, limit: 50, totalPages: 0 },
-};
-
-const CANNED_DATASET_DETAIL = {
-  id: "ds_abc123",
-  name: "My Dataset",
-  slug: "my-dataset",
-  columnTypes: [
-    { name: "input", type: "string" },
-    { name: "output", type: "string" },
-  ],
-  createdAt: "2025-01-01T00:00:00.000Z",
-  updatedAt: "2025-01-02T00:00:00.000Z",
-  data: [
-    { id: "rec-1", entry: { input: "hello", output: "world" } },
-    { id: "rec-2", entry: { input: "foo", output: "bar" } },
-  ],
-};
-
-const CANNED_DATASET_CREATED = {
-  id: "ds_new789",
-  name: "Test Data",
-  slug: "test-data",
-  columnTypes: [
-    { name: "input", type: "string" },
-    { name: "output", type: "string" },
-  ],
-  createdAt: "2025-01-01T00:00:00.000Z",
-  updatedAt: "2025-01-01T00:00:00.000Z",
-};
-
-const CANNED_DATASET_CREATED_EMPTY = {
-  id: "ds_new790",
-  name: "Empty Schema",
-  slug: "empty-schema",
-  columnTypes: [],
-  createdAt: "2025-01-01T00:00:00.000Z",
-  updatedAt: "2025-01-01T00:00:00.000Z",
-};
-
-const CANNED_DATASET_UPDATED = {
-  id: "ds_abc123",
-  name: "New Name",
-  slug: "new-name",
-  columnTypes: [
-    { name: "input", type: "string" },
-    { name: "output", type: "string" },
-  ],
-  createdAt: "2025-01-01T00:00:00.000Z",
-  updatedAt: "2025-01-05T00:00:00.000Z",
-};
-
-const CANNED_DATASET_UPDATED_COLUMNS = {
-  id: "ds_abc123",
-  name: "My Dataset",
-  slug: "my-dataset",
-  columnTypes: [{ name: "question", type: "string" }],
-  createdAt: "2025-01-01T00:00:00.000Z",
-  updatedAt: "2025-01-05T00:00:00.000Z",
-};
-
-const CANNED_DATASET_ARCHIVED = {
-  id: "ds_abc123",
-  archived: true,
-};
-
-const CANNED_RECORDS_CREATED = {
-  data: [
-    { id: "rec-new-1", entry: { input: "hello", output: "world" } },
-    { id: "rec-new-2", entry: { input: "foo", output: "bar" } },
-  ],
-};
-
-const CANNED_RECORD_UPDATED = {
-  id: "rec-123",
-  entry: { input: "updated" },
-};
-
-const CANNED_RECORDS_DELETED = {
-  deletedCount: 2,
-};
-
-// --- Mock HTTP Server ---
-
-let emptyListMode = false;
-
-function createMockServer(): Server {
-  return createServer((req, res) => {
-    const authToken = req.headers["x-auth-token"];
-    if (authToken !== "test-integration-key") {
-      res.writeHead(401, { "Content-Type": "application/json" });
-      res.end(JSON.stringify({ message: "Invalid auth token." }));
-      return;
-    }
-
-    let body = "";
-    req.on("data", (chunk: string) => (body += chunk));
-    req.on("end", () => {
-      const url = req.url ?? "";
-      res.setHeader("Content-Type", "application/json");
-
-      // GET /api/dataset - list datasets
-      if (url.match(/^\/api\/dataset(\?|$)/) && req.method === "GET") {
-        if (emptyListMode) {
-          res.writeHead(200);
-          res.end(JSON.stringify(CANNED_DATASETS_EMPTY));
-        } else {
-          res.writeHead(200);
-          res.end(JSON.stringify(CANNED_DATASETS_LIST));
-        }
-      }
-      // GET /api/dataset/my-dataset - get dataset detail
-      else if (
-        url.match(/^\/api\/dataset\/my-dataset(\?|$)/) &&
-        req.method === "GET"
-      ) {
-        res.writeHead(200);
-        res.end(JSON.stringify(CANNED_DATASET_DETAIL));
-      }
-      // GET /api/dataset/does-not-exist - not found
-      else if (
-        url.match(/^\/api\/dataset\/does-not-exist(\?|$)/) &&
-        req.method === "GET"
-      ) {
-        res.writeHead(404);
-        res.end(JSON.stringify({ message: "Dataset not found" }));
-      }
-      // POST /api/dataset - create dataset
-      else if (url === "/api/dataset" && req.method === "POST") {
-        const parsed = JSON.parse(body);
-        if (
-          parsed.columnTypes &&
-          Array.isArray(parsed.columnTypes) &&
-          parsed.columnTypes.length > 0
-        ) {
-          res.writeHead(201);
-          res.end(JSON.stringify(CANNED_DATASET_CREATED));
-        } else {
-          res.writeHead(201);
-          res.end(JSON.stringify(CANNED_DATASET_CREATED_EMPTY));
-        }
-      }
-      // PATCH /api/dataset/old-name - update dataset name
-      else if (
-        url.match(/^\/api\/dataset\/old-name$/) &&
-        req.method === "PATCH"
-      ) {
-        res.writeHead(200);
-        res.end(JSON.stringify(CANNED_DATASET_UPDATED));
-      }
-      // PATCH /api/dataset/my-dataset - update dataset columns
-      else if (
-        url.match(/^\/api\/dataset\/my-dataset$/) &&
-        req.method === "PATCH"
-      ) {
-        res.writeHead(200);
-        res.end(JSON.stringify(CANNED_DATASET_UPDATED_COLUMNS));
-      }
-      // PATCH /api/dataset/ghost - not found
-      else if (
-        url.match(/^\/api\/dataset\/ghost$/) &&
-        req.method === "PATCH"
-      ) {
-        res.writeHead(404);
-        res.end(JSON.stringify({ message: "Dataset not found" }));
-      }
-      // DELETE /api/dataset/to-delete - archive dataset
-      else if (
-        url.match(/^\/api\/dataset\/to-delete$/) &&
-        req.method === "DELETE"
-      ) {
-        res.writeHead(200);
-        res.end(JSON.stringify(CANNED_DATASET_ARCHIVED));
-      }
-      // DELETE /api/dataset/ghost - not found
-      else if (
-        url.match(/^\/api\/dataset\/ghost$/) &&
-        req.method === "DELETE"
-      ) {
-        res.writeHead(404);
-        res.end(JSON.stringify({ message: "Dataset not found" }));
-      }
-      // POST /api/dataset/my-dataset/records - create records
-      else if (
-        url.match(/^\/api\/dataset\/my-dataset\/records$/) &&
-        req.method === "POST"
-      ) {
-        res.writeHead(201);
-        res.end(JSON.stringify(CANNED_RECORDS_CREATED));
-      }
-      // POST /api/dataset/ghost/records - not found
-      else if (
-        url.match(/^\/api\/dataset\/ghost\/records$/) &&
-        req.method === "POST"
-      ) {
-        res.writeHead(404);
-        res.end(JSON.stringify({ message: "Dataset not found" }));
-      }
-      // PATCH /api/dataset/my-dataset/records/rec-123 - update record
-      else if (
-        url.match(/^\/api\/dataset\/my-dataset\/records\/rec-123$/) &&
-        req.method === "PATCH"
-      ) {
-        res.writeHead(200);
-        res.end(JSON.stringify(CANNED_RECORD_UPDATED));
-      }
-      // PATCH /api/dataset/ghost/records/rec-1 - not found
-      else if (
-        url.match(/^\/api\/dataset\/ghost\/records\//) &&
-        req.method === "PATCH"
-      ) {
-        res.writeHead(404);
-        res.end(JSON.stringify({ message: "Dataset not found" }));
-      }
-      // DELETE /api/dataset/my-dataset/records - delete records
-      else if (
-        url.match(/^\/api\/dataset\/my-dataset\/records$/) &&
-        req.method === "DELETE"
-      ) {
-        res.writeHead(200);
-        res.end(JSON.stringify(CANNED_RECORDS_DELETED));
-      }
-      // DELETE /api/dataset/ghost/records - not found
-      else if (
-        url.match(/^\/api\/dataset\/ghost\/records$/) &&
-        req.method === "DELETE"
-      ) {
-        res.writeHead(404);
-        res.end(JSON.stringify({ message: "Dataset not found" }));
-      } else {
-        res.writeHead(404);
-        res.end(
-          JSON.stringify({ message: `Not found: ${req.method} ${url}` }),
-        );
-      }
-    });
-  });
-}
-
-// --- Integration Tests ---
-
-describe("MCP dataset tools integration", () => {
-  let server: Server;
-  let port: number;
-
-  beforeEach(() => {
-    emptyListMode = false;
-  });
-
-  beforeAll(async () => {
-    server = createMockServer();
-    await new Promise<void>((resolve) => {
-      server.listen(0, () => {
-        const addr = server.address();
-        port = typeof addr === "object" && addr ? addr.port : 0;
-        initConfig({
-          apiKey: "test-integration-key",
-          endpoint: `http://localhost:${port}`,
-        });
-        resolve();
-      });
-    });
-  });
-
-  afterAll(async () => {
-    await new Promise<void>((resolve) => server.close(() => resolve()));
-  });
-
-  // ── List Datasets ──────────────────────────────────────────────
-
-  describe("platform_list_datasets", () => {
-    describe("when the project has datasets", () => {
-      /** @scenario "List datasets returns a formatted summary of all datasets" */
-      it("returns a formatted list showing both datasets with their names, slugs, and record counts", async () => {
-        const { handleListDatasets } = await import(
-          "../tools/list-datasets.js"
-        );
-        const result = await handleListDatasets();
-        expect(result).toContain("User Feedback");
-        expect(result).toContain("Training Data");
-        expect(result).toContain("user-feedback");
-        expect(result).toContain("training-data");
-        expect(result).toContain("25");
-        expect(result).toContain("100");
-      });
-    });
-
-    describe("when the project has no datasets", () => {
-      /** @scenario "List datasets returns a helpful message when none exist" */
-      it("returns a helpful message indicating no datasets were found", async () => {
-        emptyListMode = true;
-        const { handleListDatasets } = await import(
-          "../tools/list-datasets.js"
-        );
-        const result = await handleListDatasets();
-        expect(result).toContain("No datasets found");
-      });
-
-      it("suggests using platform_create_dataset", async () => {
-        emptyListMode = true;
-        const { handleListDatasets } = await import(
-          "../tools/list-datasets.js"
-        );
-        const result = await handleListDatasets();
-        expect(result).toContain("platform_create_dataset");
-      });
-    });
-
-    describe("when format is json", () => {
-      it("returns parseable JSON containing all datasets and total", async () => {
-        const { handleListDatasets } = await import(
-          "../tools/list-datasets.js"
-        );
-        const result = await handleListDatasets({ format: "json" });
-        const parsed = JSON.parse(result);
-        expect(parsed.data).toEqual(CANNED_DATASETS_LIST.data);
-        expect(parsed.total).toBe(CANNED_DATASETS_LIST.pagination.total);
-      });
-    });
-  });
-
-  // ── Get Dataset ────────────────────────────────────────────────
-
-  describe("platform_get_dataset", () => {
-    describe("when the dataset exists", () => {
-      /** @scenario "Get dataset by slug returns metadata and a preview of records" */
-      it("returns the dataset name, slug, and column definitions", async () => {
-        const { handleGetDataset } = await import(
-          "../tools/get-dataset.js"
-        );
-        const result = await handleGetDataset({ slugOrId: "my-dataset" });
-        expect(result).toContain("My Dataset");
-        expect(result).toContain("my-dataset");
-        expect(result).toContain("input");
-        expect(result).toContain("output");
-      });
-
-      it("returns a preview of records", async () => {
-        const { handleGetDataset } = await import(
-          "../tools/get-dataset.js"
-        );
-        const result = await handleGetDataset({ slugOrId: "my-dataset" });
-        expect(result).toContain("hello");
-        expect(result).toContain("world");
-      });
-    });
-
-    describe("when format is json", () => {
-      it("returns parseable JSON matching the API response", async () => {
-        const { handleGetDataset } = await import(
-          "../tools/get-dataset.js"
-        );
-        const result = await handleGetDataset({ slugOrId: "my-dataset", format: "json" });
-        expect(JSON.parse(result)).toEqual(CANNED_DATASET_DETAIL);
-      });
-    });
-
-    describe("when the dataset does not exist", () => {
-      /** @scenario "Get dataset with non-existent slug returns an error" */
-      it("propagates the 404 error", async () => {
-        const { handleGetDataset } = await import(
-          "../tools/get-dataset.js"
-        );
-        await expect(
-          handleGetDataset({ slugOrId: "does-not-exist" }),
-        ).rejects.toThrow("404");
-      });
-    });
-  });
-
-  // ── Create Dataset ─────────────────────────────────────────────
-
-  describe("platform_create_dataset", () => {
-    describe("when creating with name and columns", () => {
-      /** @scenario "Create a dataset with name and columns" */
-      it("returns confirmation including the generated slug", async () => {
-        const { handleCreateDataset } = await import(
-          "../tools/create-dataset.js"
-        );
-        const result = await handleCreateDataset({
-          name: "Test Data",
-          columnTypes: [
-            { name: "input", type: "string" },
-            { name: "output", type: "string" },
-          ],
-        });
-        expect(result).toContain("test-data");
-        expect(result).toContain("created");
-      });
-    });
-
-    describe("when creating with only a name", () => {
-      /** @scenario "Create a dataset with only a name and no columns" */
-      it("returns confirmation including the slug", async () => {
-        const { handleCreateDataset } = await import(
-          "../tools/create-dataset.js"
-        );
-        const result = await handleCreateDataset({
-          name: "Empty Schema",
-        });
-        expect(result).toContain("empty-schema");
-        expect(result).toContain("created");
-      });
-    });
-  });
-
-  // ── Update Dataset ─────────────────────────────────────────────
-
-  describe("platform_update_dataset", () => {
-    describe("when updating the dataset name", () => {
-      /** @scenario "Update a dataset name" */
-      it("returns confirmation reflecting the new name", async () => {
-        const { handleUpdateDataset } = await import(
-          "../tools/update-dataset.js"
-        );
-        const result = await handleUpdateDataset({
-          slugOrId: "old-name",
-          name: "New Name",
-        });
-        expect(result).toContain("New Name");
-        expect(result).toContain("updated");
-      });
-    });
-
-    describe("when updating dataset column types", () => {
-      /** @scenario "Update a dataset column types" */
-      it("returns confirmation reflecting the new columns", async () => {
-        const { handleUpdateDataset } = await import(
-          "../tools/update-dataset.js"
-        );
-        const result = await handleUpdateDataset({
-          slugOrId: "my-dataset",
-          columnTypes: [{ name: "question", type: "string" }],
-        });
-        expect(result).toContain("question");
-        expect(result).toContain("updated");
-      });
-    });
-
-    describe("when the dataset does not exist", () => {
-      /** @scenario "Update a non-existent dataset returns an error" */
-      it("propagates the 404 error", async () => {
-        const { handleUpdateDataset } = await import(
-          "../tools/update-dataset.js"
-        );
-        await expect(
-          handleUpdateDataset({ slugOrId: "ghost", name: "Whatever" }),
-        ).rejects.toThrow("404");
-      });
-    });
-  });
-
-  // ── Delete Dataset ─────────────────────────────────────────────
-
-  describe("platform_delete_dataset", () => {
-    describe("when the dataset exists", () => {
-      /** @scenario "Delete a dataset archives it" */
-      it("returns confirmation that the dataset was deleted", async () => {
-        const { handleDeleteDataset } = await import(
-          "../tools/delete-dataset.js"
-        );
-        const result = await handleDeleteDataset({ slugOrId: "to-delete" });
-        expect(result).toContain("deleted");
-      });
-    });
-
-    describe("when the dataset does not exist", () => {
-      /** @scenario "Delete a non-existent dataset returns an error" */
-      it("propagates the 404 error", async () => {
-        const { handleDeleteDataset } = await import(
-          "../tools/delete-dataset.js"
-        );
-        await expect(
-          handleDeleteDataset({ slugOrId: "ghost" }),
-        ).rejects.toThrow("404");
-      });
-    });
-  });
-
-  // ── Create Records ─────────────────────────────────────────────
-
-  describe("platform_create_dataset_records", () => {
-    describe("when the dataset exists", () => {
-      /** @scenario "Add records to a dataset" */
-      it("returns confirmation with the count of records created", async () => {
-        const { handleCreateDatasetRecords } = await import(
-          "../tools/create-dataset-records.js"
-        );
-        const result = await handleCreateDatasetRecords({
-          slugOrId: "my-dataset",
-          entries: [
-            { input: "hello", output: "world" },
-            { input: "foo", output: "bar" },
-          ],
-        });
-        expect(result).toContain("2");
-        expect(result).toContain("created");
-      });
-    });
-
-    describe("when the dataset does not exist", () => {
-      /** @scenario "Add records to a non-existent dataset returns an error" */
-      it("propagates the 404 error", async () => {
-        const { handleCreateDatasetRecords } = await import(
-          "../tools/create-dataset-records.js"
-        );
-        await expect(
-          handleCreateDatasetRecords({
-            slugOrId: "ghost",
-            entries: [{ input: "hello" }],
-          }),
-        ).rejects.toThrow("404");
-      });
-    });
-  });
-
-  // ── Update Record ──────────────────────────────────────────────
-
-  describe("platform_update_dataset_record", () => {
-    describe("when the record exists", () => {
-      /** @scenario "Update a single record entry" */
-      it("returns confirmation that the record was updated", async () => {
-        const { handleUpdateDatasetRecord } = await import(
-          "../tools/update-dataset-record.js"
-        );
-        const result = await handleUpdateDatasetRecord({
-          slugOrId: "my-dataset",
-          recordId: "rec-123",
-          entry: { input: "updated" },
-        });
-        expect(result).toContain("updated");
-      });
-    });
-
-    describe("when the dataset does not exist", () => {
-      /** @scenario "Update a record in a non-existent dataset returns an error" */
-      it("propagates the 404 error", async () => {
-        const { handleUpdateDatasetRecord } = await import(
-          "../tools/update-dataset-record.js"
-        );
-        await expect(
-          handleUpdateDatasetRecord({
-            slugOrId: "ghost",
-            recordId: "rec-1",
-            entry: { input: "x" },
-          }),
-        ).rejects.toThrow("404");
-      });
-    });
-  });
-
-  // ── Delete Records ─────────────────────────────────────────────
-
-  describe("platform_delete_dataset_records", () => {
-    describe("when the dataset exists", () => {
-      /** @scenario "Delete records by IDs" */
-      it("returns confirmation with the count of records deleted", async () => {
-        const { handleDeleteDatasetRecords } = await import(
-          "../tools/delete-dataset-records.js"
-        );
-        const result = await handleDeleteDatasetRecords({
-          slugOrId: "my-dataset",
-          recordIds: ["rec-1", "rec-2"],
-        });
-        expect(result).toContain("2");
-        expect(result).toContain("deleted");
-      });
-    });
-
-    describe("when the dataset does not exist", () => {
-      /** @scenario "Delete records from a non-existent dataset returns an error" */
-      it("propagates the 404 error", async () => {
-        const { handleDeleteDatasetRecords } = await import(
-          "../tools/delete-dataset-records.js"
-        );
-        await expect(
-          handleDeleteDatasetRecords({
-            slugOrId: "ghost",
-            recordIds: ["rec-1"],
-          }),
-        ).rejects.toThrow("404");
-      });
-    });
-  });
-});