@kya-os/mcp-i-core 1.3.12 → 1.3.14

package/src/compliance/__tests__/schema-verifier.test.ts

@@ -1,797 +0,0 @@
-import { describe, it, expect, beforeEach, vi, Mock } from "vitest";
-import {
-  SchemaVerifier,
-  createSchemaVerifier,
-  type SchemaMetadata,
-  type SchemaComplianceReport,
-  type FullComplianceReport,
-} from "../schema-verifier.js";
-
-// Mock global fetch
-global.fetch = vi.fn() as Mock;
-
-describe("SchemaVerifier", () => {
-  let verifier: SchemaVerifier;
-  let mockFetch: Mock;
-
-  const mockSchemaMetadata: SchemaMetadata = {
-    id: "test-schema",
-    url: "https://schemas.kya-os.ai/test-schema.json",
-    version: "1.0.0",
-    type: "TestSchema",
-    description: "Test schema for unit tests",
-  };
-
-  beforeEach(() => {
-    vi.clearAllMocks();
-    verifier = new SchemaVerifier();
-    mockFetch = global.fetch as Mock;
-  });
-
-  describe("constructor", () => {
-    it("should create verifier with default options", () => {
-      const defaultVerifier = new SchemaVerifier();
-      expect(defaultVerifier).toBeInstanceOf(SchemaVerifier);
-    });
-
-    it("should create verifier with custom schemasBaseUrl", () => {
-      const customVerifier = new SchemaVerifier({
-        schemasBaseUrl: "https://custom-schemas.example.com",
-      });
-      expect(customVerifier).toBeInstanceOf(SchemaVerifier);
-    });
-  });
-
-  describe("createSchemaVerifier", () => {
-    it("should create a verifier instance", () => {
-      const verifier = createSchemaVerifier();
-      expect(verifier).toBeInstanceOf(SchemaVerifier);
-    });
-
-    it("should pass options to verifier", () => {
-      const options = { schemasBaseUrl: "https://custom.example.com" };
-      const verifier = createSchemaVerifier(options);
-      expect(verifier).toBeInstanceOf(SchemaVerifier);
-    });
-  });
-
-  describe("verifySchema", () => {
-    it("should return compliant report for valid implementation", async () => {
-      const mockSchema = {
-        type: "object",
-        properties: {
-          name: { type: "string" },
-          age: { type: "integer" },
-        },
-        required: ["name"],
-      };
-
-      const validImplementation = {
-        name: "Test",
-        age: 25,
-      };
-
-      mockFetch.mockResolvedValue({
-        ok: true,
-        json: async () => mockSchema,
-      });
-
-      const result = await verifier.verifySchema(
-        mockSchemaMetadata,
-        validImplementation
-      );
-
-      expect(result.compliant).toBe(true);
-      expect(result.compliancePercentage).toBeGreaterThanOrEqual(95);
-      expect(result.schema).toEqual(mockSchemaMetadata);
-      expect(result.issues).toHaveLength(0);
-      expect(result.timestamp).toBeGreaterThan(0);
-    });
-
-    it("should return non-compliant report for missing required fields", async () => {
-      const mockSchema = {
-        type: "object",
-        properties: {
-          name: { type: "string" },
-          email: { type: "string" },
-        },
-        required: ["name", "email"],
-      };
-
-      const invalidImplementation = {
-        name: "Test",
-        // Missing email
-      };
-
-      mockFetch.mockResolvedValue({
-        ok: true,
-        json: async () => mockSchema,
-      });
-
-      const result = await verifier.verifySchema(
-        mockSchemaMetadata,
-        invalidImplementation
-      );
-
-      expect(result.compliant).toBe(false);
-      expect(result.compliancePercentage).toBeLessThan(100);
-      expect(result.issues.length).toBeGreaterThan(0);
-      expect(result.issues.some((i) => i.includes("email"))).toBe(true);
-    });
-
-    it("should return non-compliant report for type mismatches", async () => {
-      const mockSchema = {
-        type: "object",
-        properties: {
-          age: { type: "integer" },
-        },
-        required: ["age"],
-      };
-
-      const invalidImplementation = {
-        age: "not-a-number", // Should be integer
-      };
-
-      mockFetch.mockResolvedValue({
-        ok: true,
-        json: async () => mockSchema,
-      });
-
-      const result = await verifier.verifySchema(
-        mockSchemaMetadata,
-        invalidImplementation
-      );
-
-      expect(result.compliant).toBe(false);
-      expect(result.issues.length).toBeGreaterThan(0);
-    });
-
-    it("should handle schema fetch errors gracefully", async () => {
-      mockFetch.mockRejectedValue(new Error("Network error"));
-
-      const result = await verifier.verifySchema(
-        mockSchemaMetadata,
-        { any: "data" }
-      );
-
-      expect(result.compliant).toBe(false);
-      expect(result.compliancePercentage).toBe(0);
-      expect(result.issues.length).toBeGreaterThan(0);
-      expect(result.issues[0]).toContain("Failed to fetch schema");
-    });
-
-    it("should handle HTTP errors when fetching schema", async () => {
-      mockFetch.mockResolvedValue({
-        ok: false,
-        status: 404,
-        statusText: "Not Found",
-      });
-
-      const result = await verifier.verifySchema(
-        mockSchemaMetadata,
-        { any: "data" }
-      );
-
-      expect(result.compliant).toBe(false);
-      expect(result.issues.length).toBeGreaterThan(0);
-      expect(result.issues[0]).toContain("Failed to fetch schema");
-    });
-
-    it("should cache fetched schemas", async () => {
-      const mockSchema = {
-        type: "object",
-        properties: {
-          name: { type: "string" },
-        },
-        required: ["name"],
-      };
-
-      mockFetch.mockResolvedValue({
-        ok: true,
-        json: async () => mockSchema,
-      });
-
-      // First call
-      await verifier.verifySchema(mockSchemaMetadata, { name: "Test" });
-
-      // Second call - should use cache
-      await verifier.verifySchema(mockSchemaMetadata, { name: "Test2" });
-
-      // Fetch should only be called once (cached on second call)
-      expect(mockFetch).toHaveBeenCalledTimes(1);
-    });
-
-    it("should handle array validation", async () => {
-      const mockSchema = {
-        type: "object",
-        properties: {
-          items: {
-            type: "array",
-            items: { type: "string" },
-            minItems: 1,
-          },
-        },
-        required: ["items"],
-      };
-
-      const validImplementation = {
-        items: ["a", "b", "c"],
-      };
-
-      mockFetch.mockResolvedValue({
-        ok: true,
-        json: async () => mockSchema,
-      });
-
-      const result = await verifier.verifySchema(
-        mockSchemaMetadata,
-        validImplementation
-      );
-
-      expect(result.compliant).toBe(true);
-    });
-
-    it("should handle nested object validation", async () => {
-      const mockSchema = {
-        type: "object",
-        properties: {
-          user: {
-            type: "object",
-            properties: {
-              name: { type: "string" },
-              age: { type: "integer" },
-            },
-            required: ["name"],
-          },
-        },
-        required: ["user"],
-      };
-
-      const validImplementation = {
-        user: {
-          name: "John",
-          age: 30,
-        },
-      };
-
-      mockFetch.mockResolvedValue({
-        ok: true,
-        json: async () => mockSchema,
-      });
-
-      const result = await verifier.verifySchema(
-        mockSchemaMetadata,
-        validImplementation
-      );
-
-      expect(result.compliant).toBe(true);
-    });
-
-    it("should handle $ref resolution", async () => {
-      const mockSchema = {
-        type: "object",
-        properties: {
-          name: { $ref: "#/definitions/Name" },
-        },
-        required: ["name"],
-        definitions: {
-          Name: {
-            type: "string",
-            minLength: 1,
-          },
-        },
-      };
-
-      const validImplementation = {
-        name: "Test",
-      };
-
-      mockFetch.mockResolvedValue({
-        ok: true,
-        json: async () => mockSchema,
-      });
-
-      const result = await verifier.verifySchema(
-        mockSchemaMetadata,
-        validImplementation
-      );
-
-      expect(result.compliant).toBe(true);
-    });
-
-    it("should handle oneOf validation", async () => {
-      const mockSchema = {
-        type: "object",
-        properties: {
-          value: {
-            oneOf: [
-              { type: "string" },
-              { type: "integer" },
-            ],
-          },
-        },
-        required: ["value"],
-      };
-
-      const validImplementation = {
-        value: "test",
-      };
-
-      mockFetch.mockResolvedValue({
-        ok: true,
-        json: async () => mockSchema,
-      });
-
-      const result = await verifier.verifySchema(
-        mockSchemaMetadata,
-        validImplementation
-      );
-
-      expect(result.compliant).toBe(true);
-    });
-
-    it("should handle anyOf validation", async () => {
-      const mockSchema = {
-        type: "object",
-        properties: {
-          value: {
-            anyOf: [
-              { type: "string" },
-              { type: "number" },
-            ],
-          },
-        },
-        required: ["value"],
-      };
-
-      const validImplementation = {
-        value: 42,
-      };
-
-      mockFetch.mockResolvedValue({
-        ok: true,
-        json: async () => mockSchema,
-      });
-
-      const result = await verifier.verifySchema(
-        mockSchemaMetadata,
-        validImplementation
-      );
-
-      expect(result.compliant).toBe(true);
-    });
-
-    it("should handle allOf validation", async () => {
-      const mockSchema = {
-        type: "object",
-        properties: {
-          value: {
-            allOf: [
-              { type: "string" },
-              { minLength: 3 },
-            ],
-          },
-        },
-        required: ["value"],
-      };
-
-      const validImplementation = {
-        value: "test",
-      };
-
-      mockFetch.mockResolvedValue({
-        ok: true,
-        json: async () => mockSchema,
-      });
-
-      const result = await verifier.verifySchema(
-        mockSchemaMetadata,
-        validImplementation
-      );
-
-      expect(result.compliant).toBe(true);
-    });
-
-    it("should handle enum validation", async () => {
-      const mockSchema = {
-        type: "object",
-        properties: {
-          status: {
-            type: "string",
-            enum: ["active", "inactive", "pending"],
-          },
-        },
-        required: ["status"],
-      };
-
-      const validImplementation = {
-        status: "active",
-      };
-
-      mockFetch.mockResolvedValue({
-        ok: true,
-        json: async () => mockSchema,
-      });
-
-      const result = await verifier.verifySchema(
-        mockSchemaMetadata,
-        validImplementation
-      );
-
-      expect(result.compliant).toBe(true);
-    });
-
-    it("should handle const validation", async () => {
-      const mockSchema = {
-        type: "object",
-        properties: {
-          version: {
-            const: "1.0.0",
-          },
-        },
-        required: ["version"],
-      };
-
-      const validImplementation = {
-        version: "1.0.0",
-      };
-
-      mockFetch.mockResolvedValue({
-        ok: true,
-        json: async () => mockSchema,
-      });
-
-      const result = await verifier.verifySchema(
-        mockSchemaMetadata,
-        validImplementation
-      );
-
-      expect(result.compliant).toBe(true);
-    });
-
-    it("should handle pattern validation for strings", async () => {
-      const mockSchema = {
-        type: "object",
-        properties: {
-          email: {
-            type: "string",
-            pattern: "^[a-z]+@[a-z]+\\.[a-z]+$",
-          },
-        },
-        required: ["email"],
-      };
-
-      const validImplementation = {
-        email: "test@example.com",
-      };
-
-      mockFetch.mockResolvedValue({
-        ok: true,
-        json: async () => mockSchema,
-      });
-
-      const result = await verifier.verifySchema(
-        mockSchemaMetadata,
-        validImplementation
-      );
-
-      expect(result.compliant).toBe(true);
-    });
-
-    it("should calculate compliance percentage correctly", async () => {
-      const mockSchema = {
-        type: "object",
-        properties: {
-          field1: { type: "string" },
-          field2: { type: "string" },
-          field3: { type: "string" },
-        },
-        required: ["field1", "field2", "field3"],
-      };
-
-      const partialImplementation = {
-        field1: "value1",
-        // Missing field2 and field3
-      };
-
-      mockFetch.mockResolvedValue({
-        ok: true,
-        json: async () => mockSchema,
-      });
-
-      const result = await verifier.verifySchema(
-        mockSchemaMetadata,
-        partialImplementation
-      );
-
-      // Should be approximately 33% (1 out of 3 required fields)
-      expect(result.compliancePercentage).toBeCloseTo(33.33, 1);
-    });
-  });
-
-  describe("verifyAll", () => {
-    it("should verify all schemas and return full report", async () => {
-      const schemas: SchemaMetadata[] = [
-        {
-          id: "schema1",
-          url: "https://schemas.kya-os.ai/schema1.json",
-          version: "1.0.0",
-          type: "Schema1",
-        },
-        {
-          id: "schema2",
-          url: "https://schemas.kya-os.ai/schema2.json",
-          version: "1.0.0",
-          type: "Schema2",
-        },
-      ];
-
-      const implementations = new Map<string, any>([
-        ["schema1", { name: "Test1" }],
-        ["schema2", { name: "Test2" }],
-      ]);
-
-      const mockSchema = {
-        type: "object",
-        properties: {
-          name: { type: "string" },
-        },
-        required: ["name"],
-      };
-
-      mockFetch.mockResolvedValue({
-        ok: true,
-        json: async () => mockSchema,
-      });
-
-      const result = await verifier.verifyAll(schemas, implementations);
-
-      expect(result.totalSchemas).toBe(2);
-      expect(result.compliantSchemas).toBeGreaterThanOrEqual(0);
-      expect(result.schemaReports).toHaveLength(2);
-      expect(result.timestamp).toBeGreaterThan(0);
-    });
-
-    it("should handle missing implementations", async () => {
-      const schemas: SchemaMetadata[] = [
-        {
-          id: "schema1",
-          url: "https://schemas.kya-os.ai/schema1.json",
-          version: "1.0.0",
-          type: "Schema1",
-        },
-      ];
-
-      const implementations = new Map<string, any>(); // Empty map
-
-      const result = await verifier.verifyAll(schemas, implementations);
-
-      expect(result.criticalIssues.length).toBeGreaterThan(0);
-      expect(result.criticalIssues[0]).toContain("No implementation found");
-    });
-
-    it("should calculate overall compliance correctly", async () => {
-      const schemas: SchemaMetadata[] = [
-        {
-          id: "schema1",
-          url: "https://schemas.kya-os.ai/schema1.json",
-          version: "1.0.0",
-          type: "Schema1",
-        },
-        {
-          id: "schema2",
-          url: "https://schemas.kya-os.ai/schema2.json",
-          version: "1.0.0",
-          type: "Schema2",
-        },
-      ];
-
-      const implementations = new Map<string, any>([
-        ["schema1", { name: "Test1" }],
-        ["schema2", { name: "Test2" }],
-      ]);
-
-      const mockSchema = {
-        type: "object",
-        properties: {
-          name: { type: "string" },
-        },
-        required: ["name"],
-      };
-
-      mockFetch.mockResolvedValue({
-        ok: true,
-        json: async () => mockSchema,
-      });
-
-      const result = await verifier.verifyAll(schemas, implementations);
-
-      // If both are compliant, should be 100%
-      // If one is compliant, should be 50%
-      expect(result.overallCompliance).toBeGreaterThanOrEqual(0);
-      expect(result.overallCompliance).toBeLessThanOrEqual(100);
-    });
-  });
-
-  describe("generateReport", () => {
-    it("should generate formatted report string", async () => {
-      const mockSchema = {
-        type: "object",
-        properties: {
-          name: { type: "string" },
-        },
-        required: ["name"],
-      };
-
-      mockFetch.mockResolvedValue({
-        ok: true,
-        json: async () => mockSchema,
-      });
-
-      const report = await verifier.verifySchema(
-        mockSchemaMetadata,
-        { name: "Test" }
-      );
-
-      const reportString = verifier.generateReport(report);
-
-      expect(reportString).toContain("SCHEMA COMPLIANCE REPORT");
-      expect(reportString).toContain(mockSchemaMetadata.id);
-      expect(reportString).toContain("COMPLIANT");
-    });
-
-    it("should include issues in report", async () => {
-      const mockSchema = {
-        type: "object",
-        properties: {
-          name: { type: "string" },
-        },
-        required: ["name"],
-      };
-
-      mockFetch.mockResolvedValue({
-        ok: true,
-        json: async () => mockSchema,
-      });
-
-      const report = await verifier.verifySchema(
-        mockSchemaMetadata,
-        {} // Missing required field
-      );
-
-      const reportString = verifier.generateReport(report);
-
-      expect(reportString).toContain("ISSUES");
-    });
-  });
-
-  describe("generateFullReport", () => {
-    it("should generate full compliance report", async () => {
-      const schemas: SchemaMetadata[] = [
-        {
-          id: "schema1",
-          url: "https://schemas.kya-os.ai/schema1.json",
-          version: "1.0.0",
-          type: "Schema1",
-        },
-      ];
-
-      const implementations = new Map<string, any>([
-        ["schema1", { name: "Test" }],
-      ]);
-
-      const mockSchema = {
-        type: "object",
-        properties: {
-          name: { type: "string" },
-        },
-        required: ["name"],
-      };
-
-      mockFetch.mockResolvedValue({
-        ok: true,
-        json: async () => mockSchema,
-      });
-
-      const fullReport = await verifier.verifyAll(schemas, implementations);
-      const reportString = verifier.generateFullReport(fullReport);
-
-      expect(reportString).toContain("FULL SCHEMA COMPLIANCE REPORT");
-      expect(reportString).toContain("Total Schemas");
-      expect(reportString).toContain("Overall Compliance");
-    });
-
-    it("should include critical issues in full report", async () => {
-      const schemas: SchemaMetadata[] = [
-        {
-          id: "schema1",
-          url: "https://schemas.kya-os.ai/schema1.json",
-          version: "1.0.0",
-          type: "Schema1",
-        },
-      ];
-
-      const implementations = new Map<string, any>(); // Empty
-
-      const fullReport = await verifier.verifyAll(schemas, implementations);
-      const reportString = verifier.generateFullReport(fullReport);
-
-      expect(reportString).toContain("CRITICAL ISSUES");
-    });
-  });
-
-  describe("edge cases", () => {
-    it("should handle empty object", async () => {
-      const mockSchema = {
-        type: "object",
-        properties: {},
-        required: [],
-      };
-
-      mockFetch.mockResolvedValue({
-        ok: true,
-        json: async () => mockSchema,
-      });
-
-      const result = await verifier.verifySchema(
-        mockSchemaMetadata,
-        {}
-      );
-
-      expect(result.compliant).toBe(true);
-      expect(result.compliancePercentage).toBe(100);
-    });
-
-    it("should handle null values", async () => {
-      const mockSchema = {
-        type: "object",
-        properties: {
-          value: { type: ["string", "null"] },
-        },
-        required: ["value"],
-      };
-
-      mockFetch.mockResolvedValue({
-        ok: true,
-        json: async () => mockSchema,
-      });
-
-      const result = await verifier.verifySchema(
-        mockSchemaMetadata,
-        { value: null }
-      );
-
-      // Should handle null as valid if schema allows it
-      expect(result).toBeDefined();
-    });
-
-    it("should handle empty arrays", async () => {
-      const mockSchema = {
-        type: "object",
-        properties: {
-          items: {
-            type: "array",
-            items: { type: "string" },
-          },
-        },
-        required: ["items"],
-      };
-
-      mockFetch.mockResolvedValue({
-        ok: true,
-        json: async () => mockSchema,
-      });
-
-      const result = await verifier.verifySchema(
-        mockSchemaMetadata,
-        { items: [] }
-      );
-
-      expect(result).toBeDefined();
-    });
-
-    // Note: minItems validation is complex and depends on array validation flow
-    // Covered by general array validation tests above
-  });
-});
-