@axiom-lattice/gateway 3.0.2 → 3.0.4

package/src/__tests__/data-query.test.ts

@@ -1,77 +0,0 @@
-import { describe, it, expect, beforeEach, jest } from "@jest/globals";
-import { FastifyRequest, FastifyReply } from "fastify";
-import { executeDataQuery } from "../controllers/data-query";
-
-// Mock @axiom-lattice/core
-jest.mock("@axiom-lattice/core", () => ({
-  getStoreLattice: jest.fn(),
-  metricsServerManager: {
-    hasServer: jest.fn(),
-    registerServer: jest.fn(),
-  },
-  SemanticMetricsClient: jest.fn(),
-}));
-
-describe("Data Query Controller", () => {
-  let mockRequest: Partial<FastifyRequest>;
-  let mockReply: Partial<FastifyReply>;
-
-  beforeEach(() => {
-    mockRequest = {
-      headers: { "x-tenant-id": "test-tenant" },
-      body: {},
-    };
-    mockReply = {
-      code: jest.fn().mockReturnThis(),
-    };
-  });
-
-  describe("Request validation", () => {
-    it("should return 400 if neither serverKey nor datasourceId is provided", async () => {
-      mockRequest.body = {};
-      
-      const result = await executeDataQuery(
-        mockRequest as FastifyRequest,
-        mockReply as FastifyReply
-      );
-
-      expect(mockReply.code).toHaveBeenCalledWith(400);
-      expect(result.success).toBe(false);
-      expect(result.message).toContain("serverKey or datasourceId");
-    });
-
-    it("should return 400 if neither metrics nor customSql is provided", async () => {
-      mockRequest.body = {
-        serverKey: "test-server",
-        datasourceId: "1",
-      };
-
-      const result = await executeDataQuery(
-        mockRequest as FastifyRequest,
-        mockReply as FastifyReply
-      );
-
-      expect(mockReply.code).toHaveBeenCalledWith(400);
-      expect(result.success).toBe(false);
-      expect(result.message).toContain("metrics (for semantic query) or customSql (for SQL query)");
-    });
-
-    it("should return 400 if both metrics and customSql are provided", async () => {
-      mockRequest.body = {
-        serverKey: "test-server",
-        datasourceId: "1",
-        metrics: ["test_metric"],
-        customSql: "SELECT * FROM test",
-      };
-
-      const result = await executeDataQuery(
-        mockRequest as FastifyRequest,
-        mockReply as FastifyReply
-      );
-
-      expect(mockReply.code).toHaveBeenCalledWith(400);
-      expect(result.success).toBe(false);
-      expect(result.message).toContain("Cannot provide both");
-    });
-  });
-});

package/src/__tests__/sandbox-provider-registration.test.ts

@@ -1,74 +0,0 @@
-import { beforeEach, describe, expect, it, jest } from "@jest/globals";
-
-const mockCreateSandboxProvider = jest.fn();
-const mockRegisterSandboxLattice = jest.fn();
-const mockHasSandboxLattice = jest.fn();
-const mockAppListen = jest.fn();
-const mockAppClose = jest.fn();
-const mockProcessExit = jest.spyOn(process, "exit").mockImplementation((() => undefined) as never);
-
-jest.mock("../routes", () => ({
-  registerLatticeRoutes: jest.fn(),
-}));
-
-jest.mock("@axiom-lattice/core", () => ({
-  createSandboxProvider: mockCreateSandboxProvider,
-  registerLoggerLattice: jest.fn(),
-  getLoggerLattice: jest.fn(() => ({
-    client: {
-      info: jest.fn(),
-      warn: jest.fn(),
-      error: jest.fn(),
-    },
-    updateContext: jest.fn(),
-  })),
-  loggerLatticeManager: {
-    hasLattice: jest.fn(() => false),
-    removeLattice: jest.fn(),
-  },
-  sandboxLatticeManager: {
-    hasLattice: mockHasSandboxLattice,
-    registerLattice: mockRegisterSandboxLattice,
-  },
-  sqlDatabaseManager: {
-    setConfigStore: jest.fn(),
-  },
-  getStoreLattice: jest.fn(() => {
-    throw new Error("database store unavailable in test");
-  }),
-  agentInstanceManager: {
-    restore: jest.fn().mockResolvedValue({ restored: 0, errors: 0 }),
-  },
-}));
-
-describe("gateway sandbox provider registration", () => {
-  beforeEach(() => {
-    jest.resetModules();
-    jest.clearAllMocks();
-    mockHasSandboxLattice.mockReturnValue(false);
-    mockCreateSandboxProvider.mockReturnValue({ provider: "mock" });
-    process.env.SANDBOX_PROVIDER_TYPE = "microsandbox-remote";
-    process.env.MICROSANDBOX_SERVICE_BASE_URL = "http://sandbox-host:4002";
-  });
-
-  it("uses microsandbox-remote when configured", async () => {
-    const { LatticeGateway } = await import("../index");
-
-    jest.spyOn(LatticeGateway.app, "listen").mockImplementation(mockAppListen);
-    jest.spyOn(LatticeGateway.app, "close").mockImplementation(mockAppClose);
-
-    await LatticeGateway.startAsHttpEndpoint({ port: 0 });
-
-    expect(mockCreateSandboxProvider).toHaveBeenCalledWith(
-      expect.objectContaining({
-        type: "microsandbox-remote",
-        microsandboxServiceBaseURL: "http://sandbox-host:4002",
-      })
-    );
-    expect(mockRegisterSandboxLattice).toHaveBeenCalledWith("default", {
-      provider: "mock",
-    });
-
-    await LatticeGateway.app.close();
-  });
-});

package/src/__tests__/setup.ts

@@ -1,5 +0,0 @@
-// 全局测试设置文件
-// 这个文件会在所有测试运行前执行
-
-// 设置Node.js环境变量
-process.env.NODE_ENV = "test";

package/src/__tests__/workspace.test.ts

@@ -1,400 +0,0 @@
-/**
- * WorkspaceController Tenant Isolation Tests
- *
- * Tests to verify that file operations in WorkspaceController
- * properly use tenant-specific paths.
- */
-
-import { describe, it, expect, beforeEach, jest } from "@jest/globals";
-import type { FastifyRequest, FastifyReply } from "fastify";
-
-// Mock store lattice
-const mockGetWorkspaceById = jest.fn();
-const mockGetAllWorkspaces = jest.fn();
-const mockCreateWorkspace = jest.fn();
-const mockUpdateWorkspace = jest.fn();
-const mockDeleteWorkspace = jest.fn();
-const mockGetProjectsByWorkspace = jest.fn();
-const mockCreateProject = jest.fn();
-const mockGetProjectById = jest.fn();
-const mockUpdateProject = jest.fn();
-const mockDeleteProject = jest.fn();
-const mockGetVolumeBackendForPath = jest.fn().mockResolvedValue(null);
-
-const mockStoreLattice = {
-  store: {
-    getAllWorkspaces: mockGetAllWorkspaces,
-    createWorkspace: mockCreateWorkspace,
-    getWorkspaceById: mockGetWorkspaceById,
-    updateWorkspace: mockUpdateWorkspace,
-    deleteWorkspace: mockDeleteWorkspace,
-    getProjectsByWorkspace: mockGetProjectsByWorkspace,
-    createProject: mockCreateProject,
-    getProjectById: mockGetProjectById,
-    updateProject: mockUpdateProject,
-    deleteProject: mockDeleteProject,
-  },
-};
-
-const mockSandbox = {
-  file: {
-    uploadFile: jest.fn(),
-    downloadFile: jest.fn(),
-    readFile: jest.fn(),
-  },
-};
-
-// Mock the dependencies
-jest.mock("@axiom-lattice/core", () => ({
-  ...jest.requireActual("@axiom-lattice/core"),
-  getStoreLattice: jest.fn().mockReturnValue(mockStoreLattice),
-  SandboxFilesystem: jest.fn().mockImplementation(() => ({
-    lsInfo: jest.fn(),
-    read: jest.fn(),
-  })),
-  FilesystemBackend: jest.fn().mockImplementation(() => ({
-    lsInfo: jest.fn().mockResolvedValue([]),
-    read: jest.fn(),
-  })),
-  getSandBoxManager: jest.fn(() => ({
-    getVolumeBackendForPath: mockGetVolumeBackendForPath,
-    getSandboxFromConfig: jest.fn().mockResolvedValue(mockSandbox),
-  })),
-}));
-
-// Import after mocks are set up
-import { WorkspaceController } from "../controllers/workspace";
-
-describe("WorkspaceController - Tenant Isolation", () => {
-  let controller: WorkspaceController;
-  const mockTenantId = "test-tenant-123";
-  const mockWorkspaceId = "workspace-456";
-  const mockProjectId = "project-789";
-
-  // Helper to create mock request with tenant
-  const createMockRequest = (overrides: any = {}) => ({
-    params: { workspaceId: mockWorkspaceId, projectId: mockProjectId },
-    query: {},
-    headers: { "x-tenant-id": mockTenantId },
-    ...overrides,
-  }) as unknown as FastifyRequest;
-
-  beforeEach(async () => {
-    jest.clearAllMocks();
-    mockGetProjectById.mockReset();
-    mockGetProjectById.mockResolvedValue(undefined);
-    mockGetVolumeBackendForPath.mockResolvedValue(null);
-    const { FilesystemBackend } = await import("@axiom-lattice/core");
-    (FilesystemBackend as jest.Mock).mockImplementation(() => ({
-      lsInfo: jest.fn().mockResolvedValue([]),
-      read: jest.fn(),
-    }));
-    controller = new WorkspaceController();
-  });
-
-  describe("getBackend path construction", () => {
-    it("should use tenant-specific path for filesystem storage", async () => {
-      const { FilesystemBackend } = await import("@axiom-lattice/core");
-      
-      const mockWorkspace = {
-        id: mockWorkspaceId,
-        tenantId: mockTenantId,
-        storageType: "filesystem",
-      };
-
-      mockGetWorkspaceById.mockResolvedValue(mockWorkspace);
-
-      // Access private method for testing
-      const getBackend = (controller as any).getBackend.bind(controller);
-      await getBackend(mockTenantId, mockWorkspaceId, mockProjectId);
-
-      // Verify FilesystemBackend was called with tenant-specific path
-      expect(FilesystemBackend).toHaveBeenCalledWith({
-        rootDir: `/lattice_store/tenants/${mockTenantId}/workspaces/${mockWorkspaceId}/${mockProjectId}`,
-        virtualMode: true,
-      });
-    });
-
-    it("should use tenant-specific path for sandbox storage", async () => {
-      const { getSandBoxManager } = await import("@axiom-lattice/core");
-
-      const mockWorkspace = {
-        id: mockWorkspaceId,
-        tenantId: mockTenantId,
-        storageType: "sandbox",
-      };
-
-      mockGetWorkspaceById.mockResolvedValue(mockWorkspace);
-
-      const getBackend = (controller as any).getBackend.bind(controller);
-      await getBackend(mockTenantId, mockWorkspaceId, mockProjectId);
-
-      // Verify getSandBoxManager was called (uses default key, sandbox manager is not tenant-specific)
-      expect(getSandBoxManager).toHaveBeenCalled();
-    });
-
-    it("should pass tenantId to workspace store lookup", async () => {
-      const mockWorkspace = {
-        id: mockWorkspaceId,
-        tenantId: mockTenantId,
-        storageType: "filesystem",
-      };
-
-      mockGetWorkspaceById.mockResolvedValue(mockWorkspace);
-
-      const getBackend = (controller as any).getBackend.bind(controller);
-      await getBackend(mockTenantId, mockWorkspaceId, mockProjectId);
-
-      // Verify workspace lookup used correct tenantId
-      expect(mockGetWorkspaceById).toHaveBeenCalledWith(mockTenantId, mockWorkspaceId);
-    });
-  });
-
-  describe("listPath tenant isolation", () => {
-    it("should extract tenantId from request headers", async () => {
-      const { FilesystemBackend } = await import("@axiom-lattice/core");
-      
-      const mockWorkspace = {
-        id: mockWorkspaceId,
-        tenantId: mockTenantId,
-        storageType: "filesystem",
-      };
-
-      mockGetWorkspaceById.mockResolvedValue(mockWorkspace);
-
-      const request = createMockRequest();
-      await controller.listPath(request);
-
-      // Verify tenant-specific path was used
-      expect(FilesystemBackend).toHaveBeenCalledWith({
-        rootDir: `/lattice_store/tenants/${mockTenantId}/workspaces/${mockWorkspaceId}/${mockProjectId}`,
-        virtualMode: true,
-      });
-    });
-
-    it("should use different paths for different tenants", async () => {
-      const { FilesystemBackend } = await import("@axiom-lattice/core");
-      
-      const tenantA = "tenant-a";
-      const tenantB = "tenant-b";
-
-      const mockWorkspaceA = {
-        id: mockWorkspaceId,
-        tenantId: tenantA,
-        storageType: "filesystem",
-      };
-
-      const mockWorkspaceB = {
-        id: mockWorkspaceId,
-        tenantId: tenantB,
-        storageType: "filesystem",
-      };
-
-      // First call with tenant A
-      mockGetWorkspaceById.mockResolvedValue(mockWorkspaceA);
-      await controller.listPath(createMockRequest({ headers: { "x-tenant-id": tenantA } }));
-
-      expect(FilesystemBackend).toHaveBeenCalledWith({
-        rootDir: `/lattice_store/tenants/${tenantA}/workspaces/${mockWorkspaceId}/${mockProjectId}`,
-        virtualMode: true,
-      });
-
-      // Second call with tenant B
-      mockGetWorkspaceById.mockResolvedValue(mockWorkspaceB);
-      await controller.listPath(createMockRequest({ headers: { "x-tenant-id": tenantB } }));
-
-      expect(FilesystemBackend).toHaveBeenCalledWith({
-        rootDir: `/lattice_store/tenants/${tenantB}/workspaces/${mockWorkspaceId}/${mockProjectId}`,
-        virtualMode: true,
-      });
-    });
-  });
-
-  describe("readFile tenant isolation", () => {
-    it("should use tenant-specific backend for reading files", async () => {
-      const { FilesystemBackend } = await import("@axiom-lattice/core");
-      
-      const mockWorkspace = {
-        id: mockWorkspaceId,
-        tenantId: mockTenantId,
-        storageType: "filesystem",
-      };
-
-      mockGetWorkspaceById.mockResolvedValue(mockWorkspace);
-
-      const request = createMockRequest({
-        query: { path: "/test.txt", offset: 0, limit: 100 },
-      });
-      await controller.readFile(request);
-
-      // Verify tenant-specific path was used
-      expect(FilesystemBackend).toHaveBeenCalledWith({
-        rootDir: `/lattice_store/tenants/${mockTenantId}/workspaces/${mockWorkspaceId}/${mockProjectId}`,
-        virtualMode: true,
-      });
-    });
-  });
-
-  describe("sandbox storage path passthrough", () => {
-    const mockWorkspaceSandbox = {
-      id: mockWorkspaceId,
-      tenantId: mockTenantId,
-      storageType: "sandbox",
-    };
-
-    it("uploadFile should pass path directly to sandbox without baseDir prefix", async () => {
-      mockGetWorkspaceById.mockResolvedValue(mockWorkspaceSandbox);
-
-      // Mock Fastify multipart file
-      const mockFileData = {
-        toBuffer: jest.fn().mockResolvedValue(Buffer.from("test content")),
-        filename: "test.txt",
-        fields: {
-          path: { value: "~/project" },
-        },
-      };
-
-      const request = createMockRequest({
-        file: jest.fn().mockResolvedValue(mockFileData),
-      });
-      const reply = {
-        status: jest.fn().mockReturnThis(),
-        send: jest.fn().mockReturnThis(),
-      } as unknown as FastifyReply;
-
-      await controller.uploadFile(request, reply);
-
-      // Should use frontend-provided path directly, not /tenants/... baseDir
-      expect(mockSandbox.file.uploadFile).toHaveBeenCalledWith({
-        file: "~/project/test.txt",
-        data: expect.any(Buffer),
-      });
-    });
-
-    it("uploadFile should allow ~ in path validation", async () => {
-      mockGetWorkspaceById.mockResolvedValue(mockWorkspaceSandbox);
-
-      const mockFileData = {
-        toBuffer: jest.fn().mockResolvedValue(Buffer.from("test content")),
-        filename: "test.txt",
-        fields: {
-          path: { value: "/project/docs" },
-        },
-      };
-
-      const request = createMockRequest({
-        file: jest.fn().mockResolvedValue(mockFileData),
-      });
-      const reply = {
-        status: jest.fn().mockReturnThis(),
-        send: jest.fn().mockReturnThis(),
-      } as unknown as FastifyReply;
-
-      await controller.uploadFile(request, reply);
-
-      // Should succeed with ~ in path
-      expect(mockSandbox.file.uploadFile).toHaveBeenCalledWith({
-        file: "/project/docs/test.txt",
-        data: expect.any(Buffer),
-      });
-    });
-
-    it("downloadFile should pass path directly to sandbox without baseDir prefix", async () => {
-      mockGetWorkspaceById.mockResolvedValue(mockWorkspaceSandbox);
-      mockSandbox.file.downloadFile.mockResolvedValue(Buffer.from("content"));
-
-      const request = createMockRequest({
-        query: { path: "/agent/AGENTS.md" },
-      });
-      const reply = {
-        status: jest.fn().mockReturnThis(),
-        type: jest.fn().mockReturnThis(),
-        header: jest.fn().mockReturnThis(),
-        send: jest.fn().mockReturnThis(),
-      } as unknown as FastifyReply;
-
-      await controller.downloadFile(request, reply);
-
-      expect(mockSandbox.file.downloadFile).toHaveBeenCalledWith({
-        file: "/agent/AGENTS.md",
-      });
-    });
-
-    it("viewFile should pass path directly to sandbox without baseDir prefix", async () => {
-      mockGetWorkspaceById.mockResolvedValue(mockWorkspaceSandbox);
-      mockSandbox.file.downloadFile.mockResolvedValue(Buffer.from("content"));
-
-      const request = createMockRequest({
-        query: { path: "/project/index.html" },
-      });
-      const reply = {
-        status: jest.fn().mockReturnThis(),
-        type: jest.fn().mockReturnThis(),
-        header: jest.fn().mockReturnThis(),
-        send: jest.fn().mockReturnThis(),
-      } as unknown as FastifyReply;
-
-      await controller.viewFile(request, reply);
-
-      expect(mockSandbox.file.downloadFile).toHaveBeenCalledWith({
-        file: "/project/index.html",
-      });
-    });
-  });
-
-  describe("filesystem storage ~/ path passthrough", () => {
-    it("readFile should pass ~/ paths to the filesystem backend unchanged", async () => {
-      const { FilesystemBackend } = await import("@axiom-lattice/core");
-
-      const backendRead = jest.fn().mockResolvedValue("1: hello");
-      (FilesystemBackend as jest.Mock).mockImplementation(() => ({
-        lsInfo: jest.fn(),
-        read: backendRead,
-      }));
-
-      mockGetWorkspaceById.mockResolvedValue({
-        id: mockWorkspaceId,
-        tenantId: mockTenantId,
-        storageType: "filesystem",
-      });
-
-      const request = createMockRequest({
-        query: { path: "/project/test.txt", offset: 0, limit: 50 },
-      });
-
-      await controller.readFile(request);
-
-      expect(backendRead).toHaveBeenCalledWith("/project/test.txt", 0, 50);
-    });
-  });
-
-  describe("getTenantId helper", () => {
-    it("should extract tenantId from user context when available", () => {
-      const request = {
-        user: { tenantId: "user-context-tenant" },
-        headers: {},
-      } as unknown as FastifyRequest;
-
-      const tenantId = (controller as any).getTenantId(request);
-      expect(tenantId).toBe("user-context-tenant");
-    });
-
-    it("should fallback to x-tenant-id header when no user context", () => {
-      const request = {
-        headers: { "x-tenant-id": "header-tenant" },
-      } as unknown as FastifyRequest;
-
-      const tenantId = (controller as any).getTenantId(request);
-      expect(tenantId).toBe("header-tenant");
-    });
-
-    it("should use default tenant when no context or header", () => {
-      const request = {
-        headers: {},
-      } as unknown as FastifyRequest;
-
-      const tenantId = (controller as any).getTenantId(request);
-      expect(tenantId).toBe("default");
-    });
-  });
-});

package/src/channels/__tests__/routes.test.ts

@@ -1,50 +0,0 @@
-import fastify from "fastify";
-import { registerChannelRoutes } from "../routes";
-
-describe("registerChannelRoutes", () => {
-  it("skips registration when no dependencies are provided", async () => {
-    const app = fastify();
-    registerChannelRoutes(app);
-
-    const response = await app.inject({
-      method: "POST",
-      url: "/api/channels/lark/installations/install-1/events",
-      payload: {},
-    });
-
-    expect(response.statusCode).toBe(404);
-
-    await app.close();
-  });
-
-  it("registers the lark route when dependencies are provided", async () => {
-    const app = fastify();
-    registerChannelRoutes(app, {
-      router: {
-        dispatch: jest.fn().mockResolvedValue({ success: true }),
-      } as any,
-      installationStore: {
-        getInstallationById: jest.fn().mockResolvedValue({
-          id: "install-1",
-          tenantId: "tenant-a",
-          channel: "lark",
-          config: { appId: "cli_app_1", appSecret: "secret" },
-          enabled: true,
-          rejectWhenNoBinding: false,
-          createdAt: new Date(),
-          updatedAt: new Date(),
-        }),
-      } as any,
-    });
-
-    const response = await app.inject({
-      method: "POST",
-      url: "/api/channels/lark/installations/install-1/events",
-      payload: {},
-    });
-
-    expect(response.statusCode).toBe(200);
-
-    await app.close();
-  });
-});