@onlineapps/service-validator-core 1.0.2

package/test/unit/ValidationCore.test.js

@@ -0,0 +1,320 @@
+const ValidationCore = require('../../src/index');
+
+describe('ValidationCore Unit Tests', () => {
+  let validationCore;
+
+  beforeEach(() => {
+    validationCore = new ValidationCore();
+  });
+
+  describe('constructor', () => {
+    it('should initialize with default config', () => {
+      expect(validationCore.config.strictMode).toBe(false);
+      expect(validationCore.config.requiredConnectors).toHaveLength(5);
+    });
+
+    it('should accept custom config', () => {
+      const customCore = new ValidationCore({ strictMode: true });
+      expect(customCore.config.strictMode).toBe(true);
+    });
+
+    it('should initialize all validators', () => {
+      expect(validationCore.validators.openApi).toBeDefined();
+      expect(validationCore.validators.endpoints).toBeDefined();
+      expect(validationCore.validators.connectors).toBeDefined();
+      expect(validationCore.validators.health).toBeDefined();
+    });
+
+    it('should initialize token and certificate managers', () => {
+      expect(validationCore.tokenManager).toBeDefined();
+      expect(validationCore.certificateManager).toBeDefined();
+    });
+  });
+
+  describe('validate', () => {
+    it('should return success for valid service data', async () => {
+      const serviceData = {
+        metadata: {
+          connectors: [
+            'connector-logger',
+            'connector-storage',
+            'connector-registry-client',
+            'connector-mq-client',
+            'connector-cookbook'
+          ]
+        }
+      };
+
+      // Mock validator responses
+      validationCore.validators.connectors.validate = jest.fn().mockResolvedValue({
+        valid: true,
+        warnings: []
+      });
+
+      const result = await validationCore.validate(serviceData);
+      expect(result.success).toBe(true);
+      expect(result.validated).toBe(true);
+      expect(result.errors).toHaveLength(0);
+    });
+
+    it('should handle OpenAPI validation', async () => {
+      const serviceData = {
+        openApiSpec: {
+          openapi: '3.0.0',
+          info: { title: 'Test API', version: '1.0.0' },
+          paths: {}
+        }
+      };
+
+      validationCore.validators.openApi.validate = jest.fn().mockResolvedValue({
+        valid: true,
+        errors: []
+      });
+
+      const result = await validationCore.validate(serviceData);
+      expect(result.checks.openApi).toBeDefined();
+      expect(validationCore.validators.openApi.validate).toHaveBeenCalled();
+    });
+
+    it('should handle endpoint validation', async () => {
+      const serviceData = {
+        endpoints: [
+          { path: '/health', method: 'GET' },
+          { path: '/api/test', method: 'POST' }
+        ]
+      };
+
+      validationCore.validators.endpoints.validate = jest.fn().mockResolvedValue({
+        valid: true,
+        errors: []
+      });
+
+      const result = await validationCore.validate(serviceData);
+      expect(result.checks.endpoints).toBeDefined();
+      expect(validationCore.validators.endpoints.validate).toHaveBeenCalled();
+    });
+
+    it('should handle health validation', async () => {
+      const serviceData = {
+        health: {
+          status: 'healthy',
+          uptime: 12345
+        }
+      };
+
+      validationCore.validators.health.validate = jest.fn().mockResolvedValue({
+        valid: true,
+        warnings: []
+      });
+
+      const result = await validationCore.validate(serviceData);
+      expect(result.checks.health).toBeDefined();
+      expect(validationCore.validators.health.validate).toHaveBeenCalled();
+    });
+
+    it('should collect errors from validators', async () => {
+      const serviceData = {
+        openApiSpec: {}
+      };
+
+      validationCore.validators.openApi.validate = jest.fn().mockResolvedValue({
+        valid: false,
+        errors: ['Invalid OpenAPI spec']
+      });
+
+      const result = await validationCore.validate(serviceData);
+      expect(result.success).toBe(false);
+      expect(result.errors).toContain('Invalid OpenAPI spec');
+    });
+
+    it('should handle validation exceptions', async () => {
+      const serviceData = {
+        openApiSpec: {}
+      };
+
+      validationCore.validators.openApi.validate = jest.fn().mockRejectedValue(
+        new Error('Validation failed')
+      );
+
+      const result = await validationCore.validate(serviceData);
+      expect(result.success).toBe(false);
+      expect(result.errors[0]).toContain('Validation error');
+    });
+
+    it('should handle strict mode for connector warnings', async () => {
+      const strictCore = new ValidationCore({ strictMode: true });
+      const serviceData = {
+        metadata: {
+          connectors: ['connector-logger']
+        }
+      };
+
+      strictCore.validators.connectors.validate = jest.fn().mockResolvedValue({
+        valid: false,
+        warnings: ['Missing required connectors']
+      });
+
+      const result = await strictCore.validate(serviceData);
+      expect(result.errors).toContain('Missing required connectors');
+      expect(result.warnings).toContain('Missing required connectors');
+    });
+  });
+
+  describe('generatePreValidationToken', () => {
+    beforeEach(() => {
+      validationCore.tokenManager.generateToken = jest.fn().mockResolvedValue({
+        token: 'test-token',
+        secret: 'test-secret',
+        tokenId: 'test-id'
+      });
+    });
+
+    it('should generate token for successful validation', async () => {
+      const validationResults = {
+        success: true,
+        validated: true
+      };
+
+      const tokenData = await validationCore.generatePreValidationToken(
+        validationResults,
+        'test-service'
+      );
+
+      expect(tokenData.token).toBe('test-token');
+      expect(tokenData.secret).toBe('test-secret');
+      expect(tokenData.tokenId).toBe('test-id');
+      expect(validationCore.tokenManager.generateToken).toHaveBeenCalledWith({
+        serviceName: 'test-service',
+        validationResults,
+        type: 'pre-validation'
+      });
+    });
+
+    it('should throw error for failed validation', async () => {
+      const validationResults = {
+        success: false,
+        errors: ['Validation failed']
+      };
+
+      await expect(
+        validationCore.generatePreValidationToken(validationResults, 'test-service')
+      ).rejects.toThrow('Cannot generate token for failed validation');
+    });
+  });
+
+  describe('verifyPreValidationToken', () => {
+    it('should verify token', async () => {
+      const mockPayload = {
+        serviceName: 'test-service',
+        type: 'pre-validation'
+      };
+
+      validationCore.tokenManager.verifyToken = jest.fn().mockResolvedValue(mockPayload);
+
+      const result = await validationCore.verifyPreValidationToken('test-token');
+      expect(result).toEqual(mockPayload);
+      expect(validationCore.tokenManager.verifyToken).toHaveBeenCalledWith('test-token', null);
+    });
+  });
+
+  describe('generateCertificate', () => {
+    beforeEach(() => {
+      validationCore.certificateManager.generateCertificate = jest.fn().mockResolvedValue({
+        certificate: 'test-cert',
+        signature: 'test-signature'
+      });
+    });
+
+    it('should generate certificate for successful validation', async () => {
+      const validationResults = {
+        success: true,
+        validated: true
+      };
+
+      const cert = await validationCore.generateCertificate(
+        validationResults,
+        'test-service',
+        '1.0.0'
+      );
+
+      expect(cert).toHaveProperty('certificate');
+      expect(cert).toHaveProperty('signature');
+    });
+
+    it('should throw error for failed validation', async () => {
+      const validationResults = {
+        success: false,
+        errors: ['Validation failed']
+      };
+
+      await expect(
+        validationCore.generateCertificate(validationResults, 'test-service', '1.0.0')
+      ).rejects.toThrow('Cannot generate certificate for failed validation');
+    });
+  });
+
+  describe('verifyCertificate', () => {
+    it('should verify certificate', async () => {
+      validationCore.certificateManager.verifyCertificate = jest.fn().mockResolvedValue(true);
+
+      const result = await validationCore.verifyCertificate({
+        certificate: 'test-cert',
+        signature: 'test-signature'
+      });
+
+      expect(result).toBe(true);
+    });
+  });
+
+  describe('generateFunctionalTests', () => {
+    it('should generate tests from OpenAPI spec', async () => {
+      const openApiSpec = {
+        paths: {
+          '/users': {
+            get: {
+              summary: 'Get users',
+              responses: {
+                '200': { description: 'Success' }
+              }
+            },
+            post: {
+              summary: 'Create user',
+              responses: {
+                '201': { description: 'Created' }
+              }
+            }
+          },
+          '/users/{id}': {
+            get: {
+              summary: 'Get user by ID',
+              parameters: [
+                { name: 'id', in: 'path', required: true }
+              ],
+              responses: {
+                '200': { description: 'Success' }
+              }
+            }
+          }
+        }
+      };
+
+      const tests = await validationCore.generateFunctionalTests(openApiSpec);
+
+      expect(tests).toHaveLength(3);
+      expect(tests[0].method).toBe('GET');
+      expect(tests[0].path).toBe('/users');
+      expect(tests[1].method).toBe('POST');
+      expect(tests[2].parameters).toHaveLength(1);
+    });
+
+    it('should handle empty spec', async () => {
+      const tests = await validationCore.generateFunctionalTests({});
+      expect(tests).toEqual([]);
+    });
+
+    it('should handle null spec', async () => {
+      const tests = await validationCore.generateFunctionalTests(null);
+      expect(tests).toEqual([]);
+    });
+  });
+});