mindsim 0.1.6 → 0.1.8

package/tests/service-json.test.ts

@@ -0,0 +1,567 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import * as configModule from "../src/config";
+import { isBrowserEnvironment, isNodeEnvironment, MindSim } from "../src/index";
+import type { MindsimServiceJson } from "../src/types";
+
+// =============================================================================
+// Test Data
+// =============================================================================
+
+const VALID_SERVICE_JSON: MindsimServiceJson = {
+  type: "mindsim_service_account",
+  version: "1",
+  project_id: "test-app",
+  project_name: "Test App",
+  environment: "production",
+  client_email: "test-app@mindsim.reasoner.com",
+  client_id: "550e8400-e29b-41d4-a716-446655440000",
+  api_key: "ms_prod_testkey123456789",
+  api_base_url: "https://api.reasoner.com/api/mindsim",
+  scopes: ["minds:read", "simulate:run"],
+  app_metadata: {
+    app_id: "550e8400-e29b-41d4-a716-446655440001",
+    workspace_id: "550e8400-e29b-41d4-a716-446655440002",
+    mindsim_org_id: "550e8400-e29b-41d4-a716-446655440003",
+    use_case: "internal-workflow",
+  },
+  created_at: "2025-12-21T00:00:00.000Z",
+};
+
+// =============================================================================
+// Mock Setup
+// =============================================================================
+
+// Mock the config module to control loadApiKey and loadServiceJson
+vi.mock("../src/config", async (importOriginal) => {
+  const actual = await importOriginal<typeof configModule>();
+  return {
+    ...actual,
+    loadApiKey: vi.fn(),
+    loadServiceJson: vi.fn(),
+  };
+});
+
+// Mock version check to prevent network calls
+vi.mock("../src/version", () => ({
+  checkForUpdates: vi.fn().mockResolvedValue(undefined),
+  getPackageVersion: vi.fn().mockReturnValue("1.0.0-test"),
+}));
+
+// =============================================================================
+// Environment Detection Tests
+// =============================================================================
+
+describe("Environment Detection", () => {
+  describe("isNodeEnvironment()", () => {
+    it("should return true in Node.js environment", () => {
+      // In the test environment (Node.js), this should be true
+      expect(isNodeEnvironment()).toBe(true);
+    });
+
+    it("should check for process.versions.node", () => {
+      // Verify the function checks the right property
+      expect(typeof process.versions.node).toBe("string");
+      expect(isNodeEnvironment()).toBe(true);
+    });
+  });
+
+  describe("isBrowserEnvironment()", () => {
+    it("should return false in Node.js environment", () => {
+      // In Node.js test environment, there's no window/document
+      expect(isBrowserEnvironment()).toBe(false);
+    });
+  });
+});
+
+// =============================================================================
+// MindSim Constructor with Service JSON Tests
+// =============================================================================
+
+describe("MindSim Constructor with Service JSON", () => {
+  beforeEach(() => {
+    vi.resetModules();
+    vi.mocked(configModule.loadApiKey).mockReturnValue(null);
+    vi.mocked(configModule.loadServiceJson).mockReturnValue(null);
+  });
+
+  afterEach(() => {
+    vi.unstubAllEnvs();
+  });
+
+  describe("serviceJson via constructor options", () => {
+    it("should accept valid serviceJson passed via options", () => {
+      const mindsim = new MindSim(undefined, { serviceJson: VALID_SERVICE_JSON });
+      expect(mindsim).toBeInstanceOf(MindSim);
+      expect(mindsim.getServiceJson()).toEqual(VALID_SERVICE_JSON);
+    });
+
+    it("should use api_key from serviceJson", () => {
+      const mindsim = new MindSim(undefined, { serviceJson: VALID_SERVICE_JSON });
+      expect(mindsim).toBeInstanceOf(MindSim);
+      // The constructor should have used the api_key from service JSON
+      expect(mindsim.getAuthMethod()).toBe("service_json");
+    });
+
+    it("should set authMethod to service_json", () => {
+      const mindsim = new MindSim(undefined, { serviceJson: VALID_SERVICE_JSON });
+      expect(mindsim.getAuthMethod()).toBe("service_json");
+    });
+
+    it("should throw on invalid serviceJson", () => {
+      const invalidServiceJson = {
+        ...VALID_SERVICE_JSON,
+        type: "invalid_type" as const, // Invalid type
+      };
+
+      expect(() => {
+        new MindSim(undefined, { serviceJson: invalidServiceJson as MindsimServiceJson });
+      }).toThrow("Invalid serviceJson");
+    });
+
+    it("should throw with detailed validation errors", () => {
+      const invalidServiceJson = {
+        ...VALID_SERVICE_JSON,
+        client_id: "not-a-uuid", // Invalid UUID
+      };
+
+      expect(() => {
+        new MindSim(undefined, { serviceJson: invalidServiceJson as MindsimServiceJson });
+      }).toThrow("client_id");
+    });
+
+    it("should validate email format in serviceJson", () => {
+      const invalidServiceJson = {
+        ...VALID_SERVICE_JSON,
+        client_email: "invalid-email", // Missing @ and domain
+      };
+
+      expect(() => {
+        new MindSim(undefined, { serviceJson: invalidServiceJson as MindsimServiceJson });
+      }).toThrow("client_email");
+    });
+
+    it("should validate api_base_url as HTTPS", () => {
+      const invalidServiceJson = {
+        ...VALID_SERVICE_JSON,
+        api_base_url: "http://insecure.com", // HTTP instead of HTTPS
+      };
+
+      expect(() => {
+        new MindSim(undefined, { serviceJson: invalidServiceJson as MindsimServiceJson });
+      }).toThrow("api_base_url");
+    });
+
+    it("should validate scopes array", () => {
+      const invalidServiceJson = {
+        ...VALID_SERVICE_JSON,
+        scopes: ["minds:read", "invalid:scope"] as any[], // Invalid scope
+      };
+
+      expect(() => {
+        new MindSim(undefined, { serviceJson: invalidServiceJson as MindsimServiceJson });
+      }).toThrow("scopes");
+    });
+
+    it("should use api_base_url from serviceJson", () => {
+      const customServiceJson = {
+        ...VALID_SERVICE_JSON,
+        api_base_url: "https://custom.api.example.com/v1",
+      };
+
+      const mindsim = new MindSim(undefined, { serviceJson: customServiceJson });
+      expect(mindsim).toBeInstanceOf(MindSim);
+      // The client should be configured with the custom base URL
+    });
+  });
+
+  describe("serviceJson via environment (loadServiceJson)", () => {
+    it("should load serviceJson from environment when no constructor args", () => {
+      vi.mocked(configModule.loadServiceJson).mockReturnValue(VALID_SERVICE_JSON);
+
+      const mindsim = new MindSim();
+      expect(mindsim).toBeInstanceOf(MindSim);
+      expect(mindsim.getServiceJson()).toEqual(VALID_SERVICE_JSON);
+      expect(mindsim.getAuthMethod()).toBe("service_json");
+    });
+
+    it("should use api_key from loaded serviceJson", () => {
+      vi.mocked(configModule.loadServiceJson).mockReturnValue(VALID_SERVICE_JSON);
+
+      const mindsim = new MindSim();
+      expect(mindsim.isUsingServiceJsonAuth()).toBe(true);
+    });
+  });
+
+  describe("credential priority", () => {
+    it("should prioritize constructor apiKey over serviceJson option", () => {
+      const mindsim = new MindSim("direct-api-key", { serviceJson: VALID_SERVICE_JSON });
+
+      expect(mindsim.getAuthMethod()).toBe("api_key_constructor");
+      expect(mindsim.getServiceJson()).toBeNull();
+      expect(mindsim.isUsingServiceJsonAuth()).toBe(false);
+    });
+
+    it("should prioritize constructor apiKey over environment serviceJson", () => {
+      vi.mocked(configModule.loadServiceJson).mockReturnValue(VALID_SERVICE_JSON);
+
+      const mindsim = new MindSim("direct-api-key");
+
+      expect(mindsim.getAuthMethod()).toBe("api_key_constructor");
+      expect(mindsim.isUsingServiceJsonAuth()).toBe(false);
+    });
+
+    it("should prioritize constructor serviceJson over environment serviceJson", () => {
+      const envServiceJson = {
+        ...VALID_SERVICE_JSON,
+        project_id: "env-app",
+        api_key: "ms_prod_env_key",
+      };
+
+      const constructorServiceJson = {
+        ...VALID_SERVICE_JSON,
+        project_id: "constructor-app",
+        api_key: "ms_prod_constructor_key",
+      };
+
+      vi.mocked(configModule.loadServiceJson).mockReturnValue(envServiceJson);
+
+      const mindsim = new MindSim(undefined, { serviceJson: constructorServiceJson });
+
+      expect(mindsim.getServiceJson()?.project_id).toBe("constructor-app");
+    });
+
+    it("should fallback to loadApiKey if no serviceJson", () => {
+      vi.mocked(configModule.loadApiKey).mockReturnValue("env-api-key");
+
+      const mindsim = new MindSim();
+
+      expect(mindsim).toBeInstanceOf(MindSim);
+      expect(mindsim.isUsingServiceJsonAuth()).toBe(false);
+    });
+  });
+
+  describe("custom apiBaseUrl option", () => {
+    it("should override serviceJson api_base_url when explicitly provided", () => {
+      const mindsim = new MindSim(undefined, {
+        serviceJson: VALID_SERVICE_JSON,
+        apiBaseUrl: "https://override.api.com/v2",
+      });
+
+      expect(mindsim).toBeInstanceOf(MindSim);
+      // The apiBaseUrl option should take precedence over serviceJson.api_base_url
+    });
+
+    it("should use serviceJson api_base_url when no explicit override", () => {
+      const mindsim = new MindSim(undefined, {
+        serviceJson: VALID_SERVICE_JSON,
+      });
+
+      expect(mindsim).toBeInstanceOf(MindSim);
+      // Should use VALID_SERVICE_JSON.api_base_url
+    });
+  });
+});
+
+// =============================================================================
+// Auth Method Detection Tests
+// =============================================================================
+
+describe("Auth Method Detection", () => {
+  beforeEach(() => {
+    vi.resetModules();
+    vi.mocked(configModule.loadApiKey).mockReturnValue(null);
+    vi.mocked(configModule.loadServiceJson).mockReturnValue(null);
+  });
+
+  afterEach(() => {
+    vi.unstubAllEnvs();
+  });
+
+  describe("getAuthMethod()", () => {
+    it("should return api_key_constructor when apiKey passed to constructor", () => {
+      const mindsim = new MindSim("test-key");
+      expect(mindsim.getAuthMethod()).toBe("api_key_constructor");
+    });
+
+    it("should return service_json when using serviceJson", () => {
+      const mindsim = new MindSim(undefined, { serviceJson: VALID_SERVICE_JSON });
+      expect(mindsim.getAuthMethod()).toBe("service_json");
+    });
+
+    it("should return api_key_env when MINDSIM_API_KEY is set", () => {
+      vi.stubEnv("MINDSIM_API_KEY", "env-key");
+      vi.mocked(configModule.loadApiKey).mockReturnValue("env-key");
+
+      const mindsim = new MindSim();
+      expect(mindsim.getAuthMethod()).toBe("api_key_env");
+    });
+
+    it("should return config_file when using config file", () => {
+      vi.mocked(configModule.loadApiKey).mockReturnValue("config-file-key");
+
+      const mindsim = new MindSim();
+      expect(mindsim.getAuthMethod()).toBe("config_file");
+    });
+  });
+
+  describe("isUsingServiceJsonAuth()", () => {
+    it("should return true when using serviceJson", () => {
+      const mindsim = new MindSim(undefined, { serviceJson: VALID_SERVICE_JSON });
+      expect(mindsim.isUsingServiceJsonAuth()).toBe(true);
+    });
+
+    it("should return false when using direct apiKey", () => {
+      const mindsim = new MindSim("test-key");
+      expect(mindsim.isUsingServiceJsonAuth()).toBe(false);
+    });
+
+    it("should return false when using env apiKey", () => {
+      vi.mocked(configModule.loadApiKey).mockReturnValue("env-key");
+      const mindsim = new MindSim();
+      expect(mindsim.isUsingServiceJsonAuth()).toBe(false);
+    });
+  });
+
+  describe("getAuthInfo()", () => {
+    it("should return complete auth info for serviceJson auth", () => {
+      const mindsim = new MindSim(undefined, { serviceJson: VALID_SERVICE_JSON });
+      const authInfo = mindsim.getAuthInfo();
+
+      expect(authInfo).toEqual({
+        method: "service_json",
+        isServiceJson: true,
+        projectId: VALID_SERVICE_JSON.project_id,
+        projectName: VALID_SERVICE_JSON.project_name,
+        environment: VALID_SERVICE_JSON.environment,
+      });
+    });
+
+    it("should return null project info for non-serviceJson auth", () => {
+      const mindsim = new MindSim("test-key");
+      const authInfo = mindsim.getAuthInfo();
+
+      expect(authInfo).toEqual({
+        method: "api_key_constructor",
+        isServiceJson: false,
+        projectId: null,
+        projectName: null,
+        environment: null,
+      });
+    });
+
+    it("should not expose the API key", () => {
+      const mindsim = new MindSim(undefined, { serviceJson: VALID_SERVICE_JSON });
+      const authInfo = mindsim.getAuthInfo();
+
+      // Ensure no api_key in the returned object
+      expect(authInfo).not.toHaveProperty("apiKey");
+      expect(authInfo).not.toHaveProperty("api_key");
+      expect(JSON.stringify(authInfo)).not.toContain(VALID_SERVICE_JSON.api_key);
+    });
+  });
+});
+
+// =============================================================================
+// Service JSON Getter Tests
+// =============================================================================
+
+describe("getServiceJson()", () => {
+  beforeEach(() => {
+    vi.resetModules();
+    vi.mocked(configModule.loadApiKey).mockReturnValue(null);
+    vi.mocked(configModule.loadServiceJson).mockReturnValue(null);
+  });
+
+  afterEach(() => {
+    vi.unstubAllEnvs();
+  });
+
+  it("should return the loaded serviceJson", () => {
+    const mindsim = new MindSim(undefined, { serviceJson: VALID_SERVICE_JSON });
+    expect(mindsim.getServiceJson()).toEqual(VALID_SERVICE_JSON);
+  });
+
+  it("should return null when not using serviceJson", () => {
+    const mindsim = new MindSim("test-key");
+    expect(mindsim.getServiceJson()).toBeNull();
+  });
+
+  it("should return the full serviceJson object with all fields", () => {
+    const mindsim = new MindSim(undefined, { serviceJson: VALID_SERVICE_JSON });
+    const serviceJson = mindsim.getServiceJson();
+
+    expect(serviceJson).toHaveProperty("type", "mindsim_service_account");
+    expect(serviceJson).toHaveProperty("version");
+    expect(serviceJson).toHaveProperty("project_id");
+    expect(serviceJson).toHaveProperty("project_name");
+    expect(serviceJson).toHaveProperty("environment", "production");
+    expect(serviceJson).toHaveProperty("client_email");
+    expect(serviceJson).toHaveProperty("client_id");
+    expect(serviceJson).toHaveProperty("api_key");
+    expect(serviceJson).toHaveProperty("api_base_url");
+    expect(serviceJson).toHaveProperty("scopes");
+    expect(serviceJson).toHaveProperty("app_metadata");
+    expect(serviceJson).toHaveProperty("created_at");
+  });
+
+  it("should return serviceJson with app_metadata containing all required fields", () => {
+    const mindsim = new MindSim(undefined, { serviceJson: VALID_SERVICE_JSON });
+    const serviceJson = mindsim.getServiceJson();
+
+    expect(serviceJson?.app_metadata).toHaveProperty("app_id");
+    expect(serviceJson?.app_metadata).toHaveProperty("workspace_id");
+    expect(serviceJson?.app_metadata).toHaveProperty("mindsim_org_id");
+    expect(serviceJson?.app_metadata).toHaveProperty("use_case");
+  });
+});
+
+// =============================================================================
+// Error Handling Tests
+// =============================================================================
+
+describe("Error Handling", () => {
+  beforeEach(() => {
+    vi.resetModules();
+    vi.mocked(configModule.loadApiKey).mockReturnValue(null);
+    vi.mocked(configModule.loadServiceJson).mockReturnValue(null);
+  });
+
+  afterEach(() => {
+    vi.unstubAllEnvs();
+  });
+
+  it("should throw helpful error when no credentials found", () => {
+    expect(() => {
+      new MindSim();
+    }).toThrow("API Key not found");
+  });
+
+  it("should mention serviceJson in error message", () => {
+    expect(() => {
+      new MindSim();
+    }).toThrow(/MINDSIM_SERVICE_JSON/);
+  });
+
+  it("should throw for serviceJson with missing required fields", () => {
+    const incompleteServiceJson = {
+      type: "mindsim_service_account" as const,
+      // Missing most required fields
+    };
+
+    expect(() => {
+      new MindSim(undefined, { serviceJson: incompleteServiceJson as MindsimServiceJson });
+    }).toThrow("Invalid serviceJson");
+  });
+
+  it("should throw for serviceJson with wrong type", () => {
+    const wrongTypeServiceJson = {
+      ...VALID_SERVICE_JSON,
+      type: "google_service_account" as const, // Wrong type
+    };
+
+    expect(() => {
+      new MindSim(undefined, { serviceJson: wrongTypeServiceJson as MindsimServiceJson });
+    }).toThrow();
+  });
+});
+
+// =============================================================================
+// Optional Fields Tests
+// =============================================================================
+
+describe("Optional Service JSON Fields", () => {
+  beforeEach(() => {
+    vi.resetModules();
+    vi.mocked(configModule.loadApiKey).mockReturnValue(null);
+    vi.mocked(configModule.loadServiceJson).mockReturnValue(null);
+  });
+
+  afterEach(() => {
+    vi.unstubAllEnvs();
+  });
+
+  it("should accept serviceJson with expires_at", () => {
+    const serviceJsonWithExpiry = {
+      ...VALID_SERVICE_JSON,
+      expires_at: "2026-12-21T00:00:00.000Z",
+    };
+
+    const mindsim = new MindSim(undefined, { serviceJson: serviceJsonWithExpiry });
+    expect(mindsim.getServiceJson()?.expires_at).toBe("2026-12-21T00:00:00.000Z");
+  });
+
+  it("should accept serviceJson with issued_at", () => {
+    const serviceJsonWithIssuedAt = {
+      ...VALID_SERVICE_JSON,
+      issued_at: "2025-12-21T00:00:00.000Z",
+    };
+
+    const mindsim = new MindSim(undefined, { serviceJson: serviceJsonWithIssuedAt });
+    expect(mindsim.getServiceJson()?.issued_at).toBe("2025-12-21T00:00:00.000Z");
+  });
+
+  it("should accept serviceJson without optional fields", () => {
+    // VALID_SERVICE_JSON doesn't have expires_at or issued_at
+    const mindsim = new MindSim(undefined, { serviceJson: VALID_SERVICE_JSON });
+    expect(mindsim.getServiceJson()?.expires_at).toBeUndefined();
+    expect(mindsim.getServiceJson()?.issued_at).toBeUndefined();
+  });
+});
+
+// =============================================================================
+// Type Safety Tests
+// =============================================================================
+
+describe("Type Safety", () => {
+  beforeEach(() => {
+    vi.resetModules();
+    vi.mocked(configModule.loadApiKey).mockReturnValue(null);
+    vi.mocked(configModule.loadServiceJson).mockReturnValue(null);
+  });
+
+  afterEach(() => {
+    vi.unstubAllEnvs();
+  });
+
+  it("should accept all valid scopes", () => {
+    const allScopes: MindsimServiceJson["scopes"] = [
+      "minds:read",
+      "minds:write",
+      "simulate:run",
+      "simulate:read",
+      "users:read",
+      "users:write",
+      "org:admin",
+    ];
+
+    const serviceJsonWithAllScopes = {
+      ...VALID_SERVICE_JSON,
+      scopes: allScopes,
+    };
+
+    const mindsim = new MindSim(undefined, { serviceJson: serviceJsonWithAllScopes });
+    expect(mindsim.getServiceJson()?.scopes).toEqual(allScopes);
+  });
+
+  it("should accept all valid use_case values", () => {
+    const useCases = ["internal-workflow", "customer-facing", "agentic-ai"] as const;
+
+    for (const useCase of useCases) {
+      const serviceJson = {
+        ...VALID_SERVICE_JSON,
+        app_metadata: {
+          ...VALID_SERVICE_JSON.app_metadata,
+          use_case: useCase,
+        },
+      };
+
+      const mindsim = new MindSim(undefined, { serviceJson });
+      expect(mindsim.getServiceJson()?.app_metadata.use_case).toBe(useCase);
+    }
+  });
+
+  it("should enforce environment as production", () => {
+    const mindsim = new MindSim(undefined, { serviceJson: VALID_SERVICE_JSON });
+    expect(mindsim.getServiceJson()?.environment).toBe("production");
+  });
+});