@kya-os/mcp-i-core 1.2.3-canary.6 → 1.3.0

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

@@ -0,0 +1,797 @@
+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
+  });
+});
+