@onlineapps/service-validator-core 1.0.2

package/src/validators/healthValidator.js

@@ -0,0 +1,191 @@
+class HealthValidator {
+  /**
+   * Validates health check endpoint configuration
+   * @param {string|object} health - Health endpoint path or configuration
+   * @returns {Promise<object>} Validation result
+   */
+  async validate(health) {
+    const result = {
+      valid: true,
+      errors: [],
+      warnings: [],
+      info: {}
+    };
+
+    try {
+      if (!health) {
+        result.valid = false;
+        result.errors.push('Health check endpoint is required');
+        return result;
+      }
+
+      // Handle different health formats
+      if (typeof health === 'string') {
+        // Simple path string
+        if (!health.startsWith('/')) {
+          result.errors.push(`Health endpoint path "${health}" must start with /`);
+          result.valid = false;
+        }
+        result.info.endpoint = health;
+        result.info.type = 'simple';
+      } else if (typeof health === 'object') {
+        // Complex health configuration
+        if (!health.endpoint && !health.path) {
+          result.errors.push('Health configuration must have endpoint or path');
+          result.valid = false;
+        }
+
+        const endpoint = health.endpoint || health.path;
+        if (endpoint && !endpoint.startsWith('/')) {
+          result.errors.push(`Health endpoint path "${endpoint}" must start with /`);
+          result.valid = false;
+        }
+
+        result.info.endpoint = endpoint;
+        result.info.type = 'configured';
+
+        // Validate interval if present
+        if (health.interval !== undefined) {
+          if (typeof health.interval !== 'number' || health.interval <= 0) {
+            result.warnings.push('Health check interval should be a positive number');
+          } else {
+            result.info.interval = health.interval;
+          }
+        }
+
+        // Validate timeout if present
+        if (health.timeout !== undefined) {
+          if (typeof health.timeout !== 'number' || health.timeout <= 0) {
+            result.warnings.push('Health check timeout should be a positive number');
+          } else {
+            result.info.timeout = health.timeout;
+          }
+        }
+
+        // Validate retries if present
+        if (health.retries !== undefined) {
+          if (typeof health.retries !== 'number' || health.retries < 0) {
+            result.warnings.push('Health check retries should be a non-negative number');
+          } else {
+            result.info.retries = health.retries;
+          }
+        }
+
+        // Check for custom health checks
+        if (health.checks && Array.isArray(health.checks)) {
+          result.info.customChecks = health.checks.length;
+
+          health.checks.forEach((check, index) => {
+            if (!check.name) {
+              result.warnings.push(`Health check[${index}] should have a name`);
+            }
+            if (!check.type) {
+              result.warnings.push(`Health check[${index}] should have a type`);
+            }
+          });
+        }
+
+        // Validate expected response
+        if (health.expectedResponse) {
+          if (health.expectedResponse.status && typeof health.expectedResponse.status !== 'number') {
+            result.warnings.push('Expected response status should be a number');
+          }
+          result.info.expectedResponse = health.expectedResponse;
+        }
+      } else {
+        result.valid = false;
+        result.errors.push('Health configuration must be a string or object');
+      }
+
+      // Additional recommendations
+      if (result.valid && !result.info.interval) {
+        result.warnings.push('Consider setting a health check interval');
+      }
+
+      if (result.valid && !result.info.timeout) {
+        result.warnings.push('Consider setting a health check timeout');
+      }
+
+    } catch (error) {
+      result.valid = false;
+      result.errors.push(`Health validation error: ${error.message}`);
+    }
+
+    return result;
+  }
+
+  /**
+   * Generate health check configuration
+   * @param {string} endpoint - Health endpoint path
+   * @param {object} options - Additional options
+   * @returns {object} Health configuration
+   */
+  generateHealthConfig(endpoint, options = {}) {
+    return {
+      endpoint: endpoint || '/health',
+      interval: options.interval || 30000, // 30 seconds
+      timeout: options.timeout || 5000, // 5 seconds
+      retries: options.retries || 3,
+      expectedResponse: {
+        status: 200,
+        body: options.expectedBody || { status: 'ok' }
+      },
+      checks: options.checks || [
+        {
+          name: 'database',
+          type: 'connectivity',
+          critical: true
+        },
+        {
+          name: 'memory',
+          type: 'resource',
+          critical: false
+        }
+      ]
+    };
+  }
+
+  /**
+   * Validate health response
+   * @param {object} response - Health check response
+   * @param {object} expected - Expected response configuration
+   * @returns {object} Validation result
+   */
+  validateResponse(response, expected = {}) {
+    const result = {
+      valid: true,
+      errors: [],
+      warnings: []
+    };
+
+    // Check status code
+    if (expected.status) {
+      if (response.status !== expected.status) {
+        result.valid = false;
+        result.errors.push(`Expected status ${expected.status}, got ${response.status}`);
+      }
+    }
+
+    // Check response body
+    if (expected.body) {
+      if (!response.body) {
+        result.valid = false;
+        result.errors.push('Missing response body');
+      } else if (expected.body.status && response.body.status !== expected.body.status) {
+        result.valid = false;
+        result.errors.push(`Expected status "${expected.body.status}", got "${response.body.status}"`);
+      }
+    }
+
+    // Check response time
+    if (response.responseTime && expected.maxResponseTime) {
+      if (response.responseTime > expected.maxResponseTime) {
+        result.warnings.push(`Response time ${response.responseTime}ms exceeds recommended ${expected.maxResponseTime}ms`);
+      }
+    }
+
+    return result;
+  }
+}
+
+module.exports = HealthValidator;

package/src/validators/openApiValidator.js

@@ -0,0 +1,145 @@
+class OpenApiValidator {
+  /**
+   * Validates OpenAPI specification
+   * @param {object} spec - OpenAPI specification
+   * @returns {Promise<object>} Validation result
+   */
+  async validate(spec) {
+    const result = {
+      valid: true,
+      errors: [],
+      warnings: [],
+      info: {}
+    };
+
+    try {
+      // Check for OpenAPI or Swagger version
+      if (!spec.openapi && !spec.swagger) {
+        result.valid = false;
+        result.errors.push('Invalid OpenAPI format: missing openapi or swagger version field');
+      } else {
+        result.info.version = spec.openapi || spec.swagger;
+      }
+
+      // Validate info section
+      if (!spec.info) {
+        result.valid = false;
+        result.errors.push('Missing required "info" section in OpenAPI spec');
+      } else {
+        if (!spec.info.title) {
+          result.errors.push('Missing required "info.title" in OpenAPI spec');
+        }
+        if (!spec.info.version) {
+          result.errors.push('Missing required "info.version" in OpenAPI spec');
+        }
+        result.info.apiTitle = spec.info.title;
+        result.info.apiVersion = spec.info.version;
+      }
+
+      // Validate paths
+      if (!spec.paths || Object.keys(spec.paths).length === 0) {
+        result.valid = false;
+        result.errors.push('OpenAPI spec must define at least one path');
+      } else {
+        result.info.pathCount = Object.keys(spec.paths).length;
+        const pathValidation = this.validatePaths(spec.paths);
+        result.errors.push(...pathValidation.errors);
+        result.warnings.push(...pathValidation.warnings);
+        result.info.operations = pathValidation.operations;
+      }
+
+      // Check for servers/host
+      if (spec.openapi && !spec.servers) {
+        result.warnings.push('OpenAPI 3.0 spec should define servers');
+      } else if (spec.swagger && !spec.host) {
+        result.warnings.push('Swagger 2.0 spec should define host');
+      }
+
+      if (result.errors.length > 0) {
+        result.valid = false;
+      }
+
+    } catch (error) {
+      result.valid = false;
+      result.errors.push(`OpenAPI validation error: ${error.message}`);
+    }
+
+    return result;
+  }
+
+  /**
+   * Validate paths section
+   * @param {object} paths - Paths object from OpenAPI spec
+   * @returns {object} Validation result
+   */
+  validatePaths(paths) {
+    const result = {
+      errors: [],
+      warnings: [],
+      operations: 0
+    };
+
+    const allowedMethods = ['get', 'post', 'put', 'patch', 'delete', 'head', 'options'];
+
+    for (const [pathName, pathDef] of Object.entries(paths)) {
+      // Path must start with /
+      if (!pathName.startsWith('/')) {
+        result.errors.push(`Path "${pathName}" must start with /`);
+      }
+
+      // Check for valid HTTP methods
+      const methods = Object.keys(pathDef).filter(m => 
+        allowedMethods.includes(m.toLowerCase())
+      );
+
+      if (methods.length === 0) {
+        result.errors.push(`Path "${pathName}" has no valid HTTP methods`);
+      }
+
+      // Validate each operation
+      for (const method of methods) {
+        result.operations++;
+        const operation = pathDef[method];
+        
+        // Check for responses
+        if (!operation.responses) {
+          result.errors.push(`Operation ${method.toUpperCase()} ${pathName} missing responses`);
+        } else if (Object.keys(operation.responses).length === 0) {
+          result.errors.push(`Operation ${method.toUpperCase()} ${pathName} has empty responses`);
+        }
+
+        // Check for summary or description
+        if (!operation.summary && !operation.description) {
+          result.warnings.push(`Operation ${method.toUpperCase()} ${pathName} should have summary or description`);
+        }
+
+        // Check for operationId
+        if (!operation.operationId) {
+          result.warnings.push(`Operation ${method.toUpperCase()} ${pathName} should have operationId`);
+        }
+      }
+    }
+
+    return result;
+  }
+
+  /**
+   * Check if spec is compatible with OpenAPI 3.0
+   * @param {object} spec - OpenAPI specification
+   * @returns {boolean} Compatibility check result
+   */
+  isOpenApi3(spec) {
+    return spec.openapi && spec.openapi.startsWith('3.');
+  }
+
+  /**
+   * Check if spec is compatible with Swagger 2.0
+   * @param {object} spec - OpenAPI specification
+   * @returns {boolean} Compatibility check result
+   */
+  isSwagger2(spec) {
+    return spec.swagger && spec.swagger === '2.0';
+  }
+}
+
+module.exports = OpenApiValidator;

package/test/component/validation-flow.test.js

@@ -0,0 +1,353 @@
+const ValidationCore = require('../../src/index');
+
+describe('Validation Flow Component Tests', () => {
+  let validationCore;
+
+  beforeEach(() => {
+    validationCore = new ValidationCore();
+  });
+
+  describe('Complete validation workflow', () => {
+    it('should perform full validation and generate token', async () => {
+      const serviceData = {
+        openApiSpec: {
+          openapi: '3.0.0',
+          info: { title: 'Test API', version: '1.0.0' },
+          paths: {
+            '/health': {
+              get: {
+                summary: 'Health check',
+                responses: { '200': { description: 'OK' } }
+              }
+            }
+          }
+        },
+        endpoints: [
+          { path: '/health', method: 'GET', handler: 'healthHandler' }
+        ],
+        metadata: {
+          serviceName: 'test-service',
+          version: '1.0.0',
+          connectors: [
+            'connector-logger',
+            'connector-storage',
+            'connector-registry-client',
+            'connector-mq-client',
+            'connector-cookbook'
+          ]
+        },
+        health: {
+          status: 'healthy',
+          uptime: 12345,
+          checks: {
+            database: 'ok',
+            redis: 'ok'
+          }
+        }
+      };
+
+      // Mock validators to return success
+      jest.spyOn(validationCore.validators.openApi, 'validate').mockResolvedValue({
+        valid: true,
+        errors: []
+      });
+      jest.spyOn(validationCore.validators.endpoints, 'validate').mockResolvedValue({
+        valid: true,
+        errors: []
+      });
+      jest.spyOn(validationCore.validators.connectors, 'validate').mockResolvedValue({
+        valid: true,
+        warnings: []
+      });
+      jest.spyOn(validationCore.validators.health, 'validate').mockResolvedValue({
+        valid: true,
+        warnings: []
+      });
+
+      // Mock token generation
+      jest.spyOn(validationCore.tokenManager, 'generateToken').mockResolvedValue(
+        'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.test'
+      );
+
+      // Perform validation
+      const validationResults = await validationCore.validate(serviceData);
+
+      expect(validationResults.success).toBe(true);
+      expect(validationResults.validated).toBe(true);
+      expect(validationResults.checks).toHaveProperty('openApi');
+      expect(validationResults.checks).toHaveProperty('endpoints');
+      expect(validationResults.checks).toHaveProperty('connectors');
+      expect(validationResults.checks).toHaveProperty('health');
+
+      // Generate pre-validation token
+      const token = await validationCore.generatePreValidationToken(
+        validationResults,
+        serviceData.metadata.serviceName
+      );
+
+      expect(token).toBeDefined();
+      expect(typeof token).toBe('string');
+    });
+
+    it('should handle partial validation with warnings', async () => {
+      const serviceData = {
+        metadata: {
+          serviceName: 'partial-service',
+          version: '1.0.0',
+          connectors: ['connector-logger'] // Missing some connectors
+        },
+        health: {
+          status: 'degraded',
+          uptime: 100
+        }
+      };
+
+      // Mock validators
+      jest.spyOn(validationCore.validators.connectors, 'validate').mockResolvedValue({
+        valid: false,
+        warnings: ['Missing required connector: connector-storage']
+      });
+      jest.spyOn(validationCore.validators.health, 'validate').mockResolvedValue({
+        valid: true,
+        warnings: ['Service status is degraded']
+      });
+
+      const validationResults = await validationCore.validate(serviceData);
+
+      expect(validationResults.success).toBe(true); // Warnings don't fail validation in non-strict mode
+      expect(validationResults.warnings).toHaveLength(1);
+      expect(validationResults.warnings).toContain('Missing required connector: connector-storage');
+    });
+
+    it('should fail validation with errors in strict mode', async () => {
+      const strictCore = new ValidationCore({ strictMode: true });
+
+      const serviceData = {
+        metadata: {
+          serviceName: 'strict-service',
+          connectors: [] // No connectors
+        }
+      };
+
+      jest.spyOn(strictCore.validators.connectors, 'validate').mockResolvedValue({
+        valid: false,
+        warnings: ['No connectors found']
+      });
+
+      const validationResults = await strictCore.validate(serviceData);
+
+      expect(validationResults.success).toBe(false);
+      expect(validationResults.errors).toContain('No connectors found');
+    });
+  });
+
+  describe('Certificate generation workflow', () => {
+    it('should validate and generate certificate', async () => {
+      const serviceData = {
+        metadata: {
+          serviceName: 'certified-service',
+          version: '2.0.0',
+          connectors: [
+            'connector-logger',
+            'connector-storage',
+            'connector-registry-client',
+            'connector-mq-client',
+            'connector-cookbook'
+          ]
+        }
+      };
+
+      // Mock successful validation
+      jest.spyOn(validationCore.validators.connectors, 'validate').mockResolvedValue({
+        valid: true,
+        warnings: []
+      });
+
+      // Mock certificate generation
+      const mockCertificate = {
+        certificate: {
+          serviceName: 'certified-service',
+          version: '2.0.0',
+          issuedAt: new Date().toISOString(),
+          expiresAt: new Date(Date.now() + 30 * 24 * 60 * 60 * 1000).toISOString()
+        },
+        signature: 'mock-signature-xyz'
+      };
+
+      jest.spyOn(validationCore.certificateManager, 'generateCertificate')
+        .mockResolvedValue(mockCertificate);
+
+      // Validate
+      const validationResults = await validationCore.validate(serviceData);
+      expect(validationResults.success).toBe(true);
+
+      // Generate certificate
+      const certificate = await validationCore.generateCertificate(
+        validationResults,
+        serviceData.metadata.serviceName,
+        serviceData.metadata.version
+      );
+
+      expect(certificate).toEqual(mockCertificate);
+      expect(certificate.certificate.serviceName).toBe('certified-service');
+      expect(certificate.certificate.version).toBe('2.0.0');
+    });
+
+    it('should verify certificate after generation', async () => {
+      const mockCertificate = {
+        certificate: {
+          serviceName: 'test-service',
+          version: '1.0.0',
+          issuedAt: new Date().toISOString()
+        },
+        signature: 'valid-signature'
+      };
+
+      jest.spyOn(validationCore.certificateManager, 'verifyCertificate')
+        .mockResolvedValue(true);
+
+      const isValid = await validationCore.verifyCertificate(mockCertificate);
+      expect(isValid).toBe(true);
+    });
+  });
+
+  describe('Token verification workflow', () => {
+    it('should verify and decode pre-validation token', async () => {
+      const mockTokenPayload = {
+        serviceName: 'test-service',
+        type: 'pre-validation',
+        validationResults: {
+          success: true,
+          validated: true
+        },
+        iat: Math.floor(Date.now() / 1000),
+        exp: Math.floor(Date.now() / 1000) + 86400 // 24 hours
+      };
+
+      jest.spyOn(validationCore.tokenManager, 'verifyToken')
+        .mockResolvedValue(mockTokenPayload);
+
+      const payload = await validationCore.verifyPreValidationToken('mock-token');
+
+      expect(payload).toEqual(mockTokenPayload);
+      expect(payload.serviceName).toBe('test-service');
+      expect(payload.type).toBe('pre-validation');
+    });
+
+    it('should handle invalid token', async () => {
+      jest.spyOn(validationCore.tokenManager, 'verifyToken')
+        .mockRejectedValue(new Error('Invalid token'));
+
+      await expect(
+        validationCore.verifyPreValidationToken('invalid-token')
+      ).rejects.toThrow('Invalid token');
+    });
+  });
+
+  describe('Test generation from OpenAPI', () => {
+    it('should generate comprehensive test suite', async () => {
+      const openApiSpec = {
+        openapi: '3.0.0',
+        info: { title: 'Test API', version: '1.0.0' },
+        paths: {
+          '/users': {
+            get: {
+              summary: 'List users',
+              parameters: [
+                { name: 'page', in: 'query', required: false },
+                { name: 'limit', in: 'query', required: false }
+              ],
+              responses: {
+                '200': { description: 'User list' },
+                '401': { description: 'Unauthorized' }
+              }
+            },
+            post: {
+              summary: 'Create user',
+              requestBody: {
+                required: true,
+                content: {
+                  'application/json': {
+                    schema: {
+                      type: 'object',
+                      required: ['name', 'email'],
+                      properties: {
+                        name: { type: 'string' },
+                        email: { type: 'string', format: 'email' }
+                      }
+                    }
+                  }
+                }
+              },
+              responses: {
+                '201': { description: 'User created' },
+                '400': { description: 'Bad request' }
+              }
+            }
+          },
+          '/users/{id}': {
+            get: {
+              summary: 'Get user',
+              parameters: [
+                { name: 'id', in: 'path', required: true }
+              ],
+              responses: {
+                '200': { description: 'User details' },
+                '404': { description: 'Not found' }
+              }
+            },
+            put: {
+              summary: 'Update user',
+              parameters: [
+                { name: 'id', in: 'path', required: true }
+              ],
+              requestBody: {
+                required: true,
+                content: {
+                  'application/json': {
+                    schema: { type: 'object' }
+                  }
+                }
+              },
+              responses: {
+                '200': { description: 'Updated' }
+              }
+            },
+            delete: {
+              summary: 'Delete user',
+              parameters: [
+                { name: 'id', in: 'path', required: true }
+              ],
+              responses: {
+                '204': { description: 'Deleted' }
+              }
+            }
+          }
+        }
+      };
+
+      const tests = await validationCore.generateFunctionalTests(openApiSpec);
+
+      expect(tests).toHaveLength(5);
+
+      // Check GET /users test
+      const listUsersTest = tests.find(t => t.path === '/users' && t.method === 'GET');
+      expect(listUsersTest).toBeDefined();
+      expect(listUsersTest.parameters).toHaveLength(2);
+      expect(listUsersTest.expectedResponses).toContain('200');
+      expect(listUsersTest.expectedResponses).toContain('401');
+
+      // Check POST /users test
+      const createUserTest = tests.find(t => t.path === '/users' && t.method === 'POST');
+      expect(createUserTest).toBeDefined();
+      expect(createUserTest.requestBody).toBeDefined();
+      expect(createUserTest.expectedSuccessResponse).toBe('201');
+
+      // Check parameterized endpoints
+      const getUserTest = tests.find(t => t.path === '/users/{id}' && t.method === 'GET');
+      expect(getUserTest).toBeDefined();
+      expect(getUserTest.parameters).toHaveLength(1);
+      expect(getUserTest.parameters[0].name).toBe('id');
+    });
+  });
+});