vcluster-yaml-mcp-server 0.1.0

package/src/snippet-validator.test.js

@@ -0,0 +1,366 @@
+/**
+ * Integration tests for snippet validator
+ * Tests with real vCluster schema and edge cases
+ */
+
+import { describe, it, expect, beforeAll } from 'vitest';
+import {
+  validateSnippet,
+  detectSchemaSection,
+  extractSubSchema,
+  clearCache,
+  getCacheStats
+} from './snippet-validator.js';
+import { githubClient } from './github.js';
+
+describe('Snippet Validator Integration Tests', () => {
+  let fullSchema;
+  const version = 'v0.20.0';
+
+  beforeAll(async () => {
+    // Fetch real vCluster schema from GitHub
+    const schemaContent = await githubClient.getFileContent(
+      'chart/values.schema.json',
+      version
+    );
+    fullSchema = JSON.parse(schemaContent);
+  });
+
+  describe('detectSchemaSection', () => {
+    it('should detect top-level section from snippet', () => {
+      const snippet = { controlPlane: { distro: { k3s: { enabled: true } } } };
+      const section = detectSchemaSection(snippet, fullSchema);
+      expect(section).toBe('controlPlane');
+    });
+
+    it('should detect section from nested properties', () => {
+      const snippet = { enabled: true, host: 'test.com' };
+      // This might match multiple sections or return null if ambiguous
+      const section = detectSchemaSection(snippet, fullSchema);
+      // Since this is ambiguous, it's ok if it returns null
+      // The important thing is it doesn't crash
+      expect(section).toBeDefined();
+    });
+
+    it('should return null for unrecognizable snippet', () => {
+      const snippet = { invalidKey: 'value' };
+      const section = detectSchemaSection(snippet, fullSchema);
+      expect(section).toBeNull();
+    });
+
+    it('should handle empty snippet', () => {
+      const snippet = {};
+      const section = detectSchemaSection(snippet, fullSchema);
+      expect(section).toBeNull();
+    });
+  });
+
+  describe('extractSubSchema', () => {
+    it('should extract top-level section schema', () => {
+      const subSchema = extractSubSchema(fullSchema, 'controlPlane');
+      expect(subSchema).not.toBeNull();
+      // Schema may have $ref or direct properties
+      expect(subSchema).toBeDefined();
+      expect(typeof subSchema).toBe('object');
+    });
+
+    it('should extract nested section schema', () => {
+      const subSchema = extractSubSchema(fullSchema, 'controlPlane.distro');
+      // Nested schema extraction may not work with $ref
+      // This is ok as long as top-level extraction works
+      expect(subSchema).toBeDefined();
+    });
+
+    it('should return null for invalid section', () => {
+      const subSchema = extractSubSchema(fullSchema, 'invalidSection');
+      expect(subSchema).toBeNull();
+    });
+  });
+
+  describe('validateSnippet - Real vCluster Scenarios', () => {
+    it('Scenario 1: Valid controlPlane ingress config', () => {
+      const snippet = `
+controlPlane:
+  ingress:
+    enabled: true
+    host: "my-vcluster.example.com"
+`;
+      const result = validateSnippet(snippet, fullSchema, version);
+
+      expect(result.syntax_valid).toBe(true);
+      expect(result.section).toBe('controlPlane');
+    });
+
+    it('Scenario 2: Valid sync toHost config', () => {
+      const snippet = `
+sync:
+  toHost:
+    services:
+      enabled: true
+    pods:
+      enabled: false
+`;
+      const result = validateSnippet(snippet, fullSchema, version);
+
+      expect(result.syntax_valid).toBe(true);
+      expect(result.section).toBe('sync');
+    });
+
+    it('Scenario 3: Invalid type - enabled as string', () => {
+      const snippet = `
+controlPlane:
+  distro:
+    k3s:
+      enabled: "yes"
+`;
+      const result = validateSnippet(snippet, fullSchema, version);
+
+      expect(result.syntax_valid).toBe(true);
+      expect(result.valid).toBe(false);
+      expect(result.errors).toBeDefined();
+      expect(result.errors.length).toBeGreaterThan(0);
+      expect(result.errors[0].message).toContain('boolean');
+    });
+
+    it('Scenario 4: Deep nesting - k3s config', () => {
+      const snippet = `
+controlPlane:
+  distro:
+    k3s:
+      enabled: true
+      image:
+        tag: "v1.28.0"
+`;
+      const result = validateSnippet(snippet, fullSchema, version);
+
+      expect(result.syntax_valid).toBe(true);
+      expect(result.section).toBe('controlPlane');
+    });
+
+    it('Scenario 5: YAML syntax error', () => {
+      const snippet = `
+invalid yaml:
+  - not properly: formatted
+    missing colon
+`;
+      const result = validateSnippet(snippet, fullSchema, version);
+
+      expect(result.syntax_valid).toBe(false);
+      expect(result.syntax_error).toBeDefined();
+    });
+
+    it('Scenario 6: Partial snippet without section key', () => {
+      const snippet = `
+enabled: true
+host: "test.com"
+`;
+      const result = validateSnippet(snippet, fullSchema, version, 'controlPlane');
+
+      expect(result.syntax_valid).toBe(true);
+      // Should validate against the hinted section
+      expect(result.section).toBe('controlPlane');
+    });
+
+    it('Scenario 7: Invalid section hint', () => {
+      const snippet = `
+enabled: true
+`;
+      const result = validateSnippet(snippet, fullSchema, version, 'invalidSection');
+
+      expect(result.valid).toBe(false);
+      expect(result.error).toContain('not found');
+    });
+
+    it('Scenario 8: Empty snippet', () => {
+      const snippet = ``;
+      const result = validateSnippet(snippet, fullSchema, version);
+
+      expect(result.valid).toBe(false);
+    });
+
+    it('Scenario 9: Ambiguous snippet - could match multiple sections', () => {
+      const snippet = `
+enabled: true
+`;
+      // Without hint, should try to detect automatically
+      const result = validateSnippet(snippet, fullSchema, version);
+
+      // Either succeeds with detected section or fails asking for hint
+      if (!result.valid && result.error) {
+        expect(result.error).toContain('Could not detect schema section');
+      } else {
+        expect(result.section).toBeDefined();
+      }
+    });
+
+    it('Scenario 10: Additional properties not in schema', () => {
+      const snippet = `
+controlPlane:
+  customField: "value"
+`;
+      const result = validateSnippet(snippet, fullSchema, version);
+
+      // AJV with strict:false should allow additional properties
+      // or flag them depending on schema's additionalProperties setting
+      expect(result.syntax_valid).toBe(true);
+    });
+  });
+
+  describe('Validator Cache', () => {
+    it('should cache compiled validators', () => {
+      clearCache();
+
+      const snippet = `
+controlPlane:
+  distro:
+    k3s:
+      enabled: true
+`;
+
+      // First call - should compile and cache
+      const result1 = validateSnippet(snippet, fullSchema, version);
+      const stats1 = getCacheStats();
+      expect(stats1.size).toBeGreaterThan(0);
+
+      // Second call - should use cache
+      const result2 = validateSnippet(snippet, fullSchema, version);
+      const stats2 = getCacheStats();
+
+      expect(result1.valid).toBe(result2.valid);
+      expect(stats2.size).toBe(stats1.size);
+    });
+
+    it('should clear cache on version change', () => {
+      clearCache();
+
+      const snippet = `
+controlPlane:
+  distro:
+    k3s:
+      enabled: true
+`;
+
+      // Validate with version 1
+      validateSnippet(snippet, fullSchema, 'v1.0.0');
+      const stats1 = getCacheStats();
+      expect(stats1.version).toBe('v1.0.0');
+
+      // Validate with version 2 - should clear cache
+      validateSnippet(snippet, fullSchema, 'v2.0.0');
+      const stats2 = getCacheStats();
+      expect(stats2.version).toBe('v2.0.0');
+      expect(stats2.size).toBeGreaterThan(0);
+    });
+
+    it('should respect max cache size', () => {
+      clearCache();
+
+      // Create 21 different snippets to exceed cache size (20)
+      for (let i = 0; i < 21; i++) {
+        const snippet = `
+section${i}:
+  enabled: true
+`;
+        // Use different section hints to create different cache entries
+        validateSnippet(snippet, fullSchema, version, 'controlPlane');
+      }
+
+      const stats = getCacheStats();
+      expect(stats.size).toBeLessThanOrEqual(20);
+    });
+  });
+
+  describe('Error Messages', () => {
+    it('should include snippet context in errors', () => {
+      const snippet = `
+controlPlane:
+  distro:
+    k3s:
+      enabled: "not a boolean"
+`;
+
+      const result = validateSnippet(snippet, fullSchema, version);
+
+      expect(result.valid).toBe(false);
+      expect(result.errors).toBeDefined();
+      expect(result.errors[0].context).toContain('controlPlane');
+      expect(result.errors[0].path).toBeDefined();
+    });
+
+    it('should provide helpful error summary', () => {
+      const snippet = `
+controlPlane:
+  distro:
+    k3s:
+      enabled: "invalid"
+`;
+
+      const result = validateSnippet(snippet, fullSchema, version);
+
+      expect(result.valid).toBe(false);
+      expect(result.summary).toBeDefined();
+      expect(result.summary).toContain('error');
+    });
+  });
+
+  describe('Edge Cases', () => {
+    it('should handle snippet with arrays', () => {
+      const snippet = `
+sync:
+  toHost:
+    services:
+      enabled: true
+`;
+
+      const result = validateSnippet(snippet, fullSchema, version);
+      expect(result.syntax_valid).toBe(true);
+    });
+
+    it('should handle snippet with null values', () => {
+      const snippet = `
+controlPlane:
+  distro:
+    k3s:
+      enabled: true
+      extraArgs: null
+`;
+
+      const result = validateSnippet(snippet, fullSchema, version);
+      expect(result.syntax_valid).toBe(true);
+    });
+
+    it('should handle deeply nested paths', () => {
+      const snippet = `
+controlPlane:
+  distro:
+    k3s:
+      enabled: true
+`;
+
+      const result = validateSnippet(snippet, fullSchema, version);
+      expect(result.syntax_valid).toBe(true);
+      expect(result.section).toBe('controlPlane');
+    });
+
+    it('should handle multiple top-level sections', () => {
+      const snippet = `
+controlPlane:
+  distro:
+    k3s:
+      enabled: true
+sync:
+  toHost:
+    services:
+      enabled: true
+`;
+
+      const result = validateSnippet(snippet, fullSchema, version);
+
+      // Should detect first section or fail gracefully
+      expect(result.syntax_valid).toBe(true);
+      if (result.valid) {
+        expect(result.section).toBeDefined();
+      }
+    });
+  });
+});