@onlineapps/service-validator-core 1.0.2

package/test/integration/real-validation.test.js

@@ -0,0 +1,548 @@
+const ValidationCore = require('../../src/index');
+const fs = require('fs').promises;
+const path = require('path');
+
+describe('ValidationCore Integration Tests', () => {
+  let validationCore;
+
+  beforeEach(() => {
+    validationCore = new ValidationCore();
+  });
+
+  describe('Real service validation', () => {
+    it('should validate a complete service configuration', async () => {
+      const serviceData = {
+        openApiSpec: {
+          openapi: '3.0.0',
+          info: {
+            title: 'Hello Service API',
+            version: '1.0.0',
+            description: 'Simple hello/goodbye service'
+          },
+          servers: [
+            { url: 'http://localhost:3000', description: 'Local development' }
+          ],
+          paths: {
+            '/health': {
+              get: {
+                summary: 'Health check',
+                tags: ['Health'],
+                responses: {
+                  '200': {
+                    description: 'Service is healthy',
+                    content: {
+                      'application/json': {
+                        schema: {
+                          type: 'object',
+                          properties: {
+                            status: { type: 'string' },
+                            timestamp: { type: 'string' },
+                            uptime: { type: 'number' },
+                            version: { type: 'string' }
+                          }
+                        }
+                      }
+                    }
+                  }
+                }
+              }
+            },
+            '/api/hello': {
+              post: {
+                summary: 'Say hello',
+                tags: ['Greetings'],
+                requestBody: {
+                  required: true,
+                  content: {
+                    'application/json': {
+                      schema: {
+                        type: 'object',
+                        required: ['name'],
+                        properties: {
+                          name: { type: 'string', minLength: 1 },
+                          language: {
+                            type: 'string',
+                            enum: ['en', 'es', 'fr', 'de'],
+                            default: 'en'
+                          }
+                        }
+                      }
+                    }
+                  }
+                },
+                responses: {
+                  '200': {
+                    description: 'Greeting response',
+                    content: {
+                      'application/json': {
+                        schema: {
+                          type: 'object',
+                          properties: {
+                            message: { type: 'string' },
+                            timestamp: { type: 'string' },
+                            language: { type: 'string' }
+                          }
+                        }
+                      }
+                    }
+                  },
+                  '400': {
+                    description: 'Bad request'
+                  }
+                }
+              }
+            },
+            '/api/goodbye': {
+              post: {
+                summary: 'Say goodbye',
+                tags: ['Greetings'],
+                requestBody: {
+                  required: true,
+                  content: {
+                    'application/json': {
+                      schema: {
+                        type: 'object',
+                        required: ['name'],
+                        properties: {
+                          name: { type: 'string', minLength: 1 }
+                        }
+                      }
+                    }
+                  }
+                },
+                responses: {
+                  '200': {
+                    description: 'Goodbye response',
+                    content: {
+                      'application/json': {
+                        schema: {
+                          type: 'object',
+                          properties: {
+                            message: { type: 'string' },
+                            timestamp: { type: 'string' }
+                          }
+                        }
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          },
+          components: {
+            schemas: {
+              Error: {
+                type: 'object',
+                properties: {
+                  error: { type: 'string' },
+                  message: { type: 'string' },
+                  timestamp: { type: 'string' }
+                }
+              }
+            }
+          }
+        },
+        endpoints: [
+          { path: '/health', method: 'GET', handler: 'healthController.check' },
+          { path: '/api/hello', method: 'POST', handler: 'greetingController.hello' },
+          { path: '/api/goodbye', method: 'POST', handler: 'greetingController.goodbye' }
+        ],
+        metadata: {
+          serviceName: 'hello-service',
+          version: '1.0.0',
+          description: 'Hello/Goodbye microservice',
+          connectors: [
+            'connector-logger',
+            'connector-storage',
+            'connector-registry-client',
+            'connector-mq-client',
+            'connector-cookbook',
+            'connector-hub'
+          ],
+          dependencies: {
+            '@onlineapps/connector-logger': '^1.0.0',
+            '@onlineapps/connector-storage': '^1.0.0',
+            '@onlineapps/connector-registry-client': '^1.1.0',
+            '@onlineapps/connector-mq-client': '^1.1.0',
+            '@onlineapps/connector-cookbook': '^1.1.0',
+            '@onlineapps/connector-hub': '^1.0.0'
+          }
+        },
+        health: {
+          status: 'healthy',
+          uptime: 3600,
+          version: '1.0.0',
+          checks: {
+            rabbitmq: 'connected',
+            registry: 'registered',
+            redis: 'connected'
+          },
+          metrics: {
+            requestsTotal: 150,
+            requestsPerMinute: 10,
+            errorRate: 0.01,
+            avgResponseTime: 45
+          }
+        }
+      };
+
+      const result = await validationCore.validate(serviceData);
+
+      expect(result.success).toBe(true);
+      expect(result.validated).toBe(true);
+      expect(result.errors).toHaveLength(0);
+      expect(result.checks.openApi).toBeDefined();
+      expect(result.checks.endpoints).toBeDefined();
+      expect(result.checks.connectors).toBeDefined();
+      expect(result.checks.health).toBeDefined();
+    });
+
+    it('should detect missing required connectors', async () => {
+      const serviceData = {
+        metadata: {
+          serviceName: 'incomplete-service',
+          version: '1.0.0',
+          connectors: [
+            'connector-logger',
+            'connector-hub'
+            // Missing: storage, registry-client, mq-client, cookbook
+          ]
+        }
+      };
+
+      const result = await validationCore.validate(serviceData);
+
+      expect(result.validated).toBe(true);
+      expect(result.warnings.length).toBeGreaterThan(0);
+      // Check for specific missing connectors
+      const warningsStr = result.warnings.join(' ');
+      expect(warningsStr).toMatch(/storage|registry|mq|cookbook/i);
+    });
+
+    it('should validate in strict mode', async () => {
+      const strictCore = new ValidationCore({ strictMode: true });
+
+      const serviceData = {
+        metadata: {
+          serviceName: 'strict-service',
+          version: '1.0.0',
+          connectors: ['connector-logger'] // Missing most required connectors
+        }
+      };
+
+      const result = await strictCore.validate(serviceData);
+
+      expect(result.success).toBe(false); // Should fail in strict mode
+      expect(result.errors.length).toBeGreaterThan(0);
+    });
+  });
+
+  describe('Token and certificate operations', () => {
+    it('should complete full validation-token-certificate flow', async () => {
+      const serviceData = {
+        metadata: {
+          serviceName: 'token-test-service',
+          version: '2.0.0',
+          connectors: [
+            'connector-logger',
+            'connector-storage',
+            'connector-registry-client',
+            'connector-mq-client',
+            'connector-cookbook'
+          ]
+        }
+      };
+
+      // Step 1: Validate
+      const validationResults = await validationCore.validate(serviceData);
+      expect(validationResults.success).toBe(true);
+
+      // Step 2: Generate pre-validation token
+      const tokenData = await validationCore.generatePreValidationToken(
+        validationResults,
+        serviceData.metadata.serviceName
+      );
+      expect(tokenData).toBeDefined();
+      expect(tokenData.token).toBeDefined();
+      expect(typeof tokenData.token).toBe('string');
+      expect(tokenData.secret).toBeDefined();
+      expect(typeof tokenData.secret).toBe('string');
+
+      // Step 3: Verify token
+      const tokenPayload = await validationCore.verifyPreValidationToken(tokenData.token, tokenData.secret);
+      expect(tokenPayload.serviceName).toBe('token-test-service');
+      expect(tokenPayload.type).toBe('pre-validation');
+
+      // Step 4: Generate certificate
+      const certificate = await validationCore.generateCertificate(
+        validationResults,
+        serviceData.metadata.serviceName,
+        serviceData.metadata.version
+      );
+      expect(certificate).toBeDefined();
+      expect(certificate.subject.serviceName).toBe('token-test-service');
+      expect(certificate.subject.serviceVersion).toBe('2.0.0');
+
+      // Step 5: Certificate structure validation (verification would fail without proper fingerprint)
+      expect(certificate.id).toBeDefined();
+      expect(certificate.signature).toBeDefined();
+      expect(certificate.issuer).toBeDefined();
+    });
+
+    it('should reject invalid tokens', async () => {
+      await expect(
+        validationCore.verifyPreValidationToken('invalid.token.here')
+      ).rejects.toThrow();
+    });
+
+    it('should reject certificate generation for failed validation', async () => {
+      const failedValidation = {
+        success: false,
+        errors: ['Validation failed'],
+        validated: true
+      };
+
+      await expect(
+        validationCore.generateCertificate(failedValidation, 'service', '1.0.0')
+      ).rejects.toThrow('Cannot generate certificate for failed validation');
+    });
+  });
+
+  describe('Functional test generation', () => {
+    it('should generate comprehensive tests from OpenAPI spec', async () => {
+      const complexSpec = {
+        openapi: '3.0.0',
+        info: { title: 'Complex API', version: '1.0.0' },
+        paths: {
+          '/users': {
+            get: {
+              summary: 'List all users',
+              parameters: [
+                { name: 'page', in: 'query', schema: { type: 'integer' } },
+                { name: 'limit', in: 'query', schema: { type: 'integer' } },
+                { name: 'sort', in: 'query', schema: { type: 'string', enum: ['asc', 'desc'] } }
+              ],
+              responses: {
+                '200': { description: 'Success' },
+                '401': { description: 'Unauthorized' }
+              }
+            },
+            post: {
+              summary: 'Create new user',
+              requestBody: {
+                required: true,
+                content: {
+                  'application/json': {
+                    schema: {
+                      type: 'object',
+                      required: ['email', 'password'],
+                      properties: {
+                        email: { type: 'string', format: 'email' },
+                        password: { type: 'string', minLength: 8 },
+                        name: { type: 'string' }
+                      }
+                    }
+                  }
+                }
+              },
+              responses: {
+                '201': { description: 'Created' },
+                '400': { description: 'Bad request' },
+                '409': { description: 'Conflict' }
+              }
+            }
+          },
+          '/users/{id}': {
+            parameters: [
+              { name: 'id', in: 'path', required: true, schema: { type: 'string' } }
+            ],
+            get: {
+              summary: 'Get user by ID',
+              responses: {
+                '200': { description: 'Success' },
+                '404': { description: 'Not found' }
+              }
+            },
+            put: {
+              summary: 'Update user',
+              requestBody: {
+                required: true,
+                content: {
+                  'application/json': {
+                    schema: {
+                      type: 'object',
+                      properties: {
+                        email: { type: 'string', format: 'email' },
+                        name: { type: 'string' }
+                      }
+                    }
+                  }
+                }
+              },
+              responses: {
+                '200': { description: 'Updated' },
+                '400': { description: 'Bad request' },
+                '404': { description: 'Not found' }
+              }
+            },
+            delete: {
+              summary: 'Delete user',
+              responses: {
+                '204': { description: 'No content' },
+                '404': { description: 'Not found' }
+              }
+            }
+          },
+          '/users/{id}/avatar': {
+            post: {
+              summary: 'Upload avatar',
+              parameters: [
+                { name: 'id', in: 'path', required: true, schema: { type: 'string' } }
+              ],
+              requestBody: {
+                required: true,
+                content: {
+                  'multipart/form-data': {
+                    schema: {
+                      type: 'object',
+                      properties: {
+                        file: { type: 'string', format: 'binary' }
+                      }
+                    }
+                  }
+                }
+              },
+              responses: {
+                '200': { description: 'Success' }
+              }
+            }
+          }
+        }
+      };
+
+      const tests = await validationCore.generateFunctionalTests(complexSpec);
+
+      expect(tests).toHaveLength(6);
+
+      // Verify test structure
+      tests.forEach(test => {
+        expect(test).toHaveProperty('name');
+        expect(test).toHaveProperty('method');
+        expect(test).toHaveProperty('path');
+        expect(test).toHaveProperty('expectedResponses');
+        expect(test.expectedResponses.length).toBeGreaterThan(0);
+      });
+
+      // Check specific tests
+      const createUserTest = tests.find(t => t.path === '/users' && t.method === 'POST');
+      expect(createUserTest).toBeDefined();
+      expect(createUserTest.requestBody).toBeDefined();
+      expect(createUserTest.expectedSuccessResponse).toBe('201');
+
+      const uploadAvatarTest = tests.find(t => t.path === '/users/{id}/avatar');
+      expect(uploadAvatarTest).toBeDefined();
+      expect(uploadAvatarTest.parameters).toHaveLength(1);
+
+      // Check parameterized paths
+      const userByIdTests = tests.filter(t => t.path === '/users/{id}');
+      expect(userByIdTests.length).toBe(3); // GET, PUT, DELETE
+    });
+
+    it('should handle edge cases in test generation', async () => {
+      const edgeCaseSpec = {
+        paths: {
+          '/webhook': {
+            post: {
+              summary: 'Webhook endpoint',
+              responses: {
+                '200': { description: 'OK' }
+              }
+            },
+            options: { // Should be ignored
+              summary: 'OPTIONS request',
+              responses: {
+                '200': { description: 'OK' }
+              }
+            }
+          }
+        }
+      };
+
+      const tests = await validationCore.generateFunctionalTests(edgeCaseSpec);
+
+      expect(tests).toHaveLength(1); // Only POST, not OPTIONS
+      expect(tests[0].method).toBe('POST');
+    });
+  });
+
+  describe('Performance tests', () => {
+    it('should handle large OpenAPI specs efficiently', async () => {
+      const largeSpec = {
+        openapi: '3.0.0',
+        info: { title: 'Large API', version: '1.0.0' },
+        paths: {}
+      };
+
+      // Generate 100 endpoints
+      for (let i = 0; i < 100; i++) {
+        largeSpec.paths[`/resource${i}`] = {
+          get: { summary: `Get resource ${i}`, responses: { '200': { description: 'OK' } } },
+          post: { summary: `Create resource ${i}`, responses: { '201': { description: 'Created' } } }
+        };
+      }
+
+      const startTime = Date.now();
+      const tests = await validationCore.generateFunctionalTests(largeSpec);
+      const duration = Date.now() - startTime;
+
+      expect(tests).toHaveLength(200); // 100 resources * 2 methods
+      expect(duration).toBeLessThan(1000); // Should complete within 1 second
+    });
+
+    it('should validate complex service data efficiently', async () => {
+      const complexData = {
+        openApiSpec: {
+          openapi: '3.0.0',
+          info: { title: 'Test', version: '1.0.0' },
+          paths: {
+            '/test': {
+              get: { responses: { '200': { description: 'OK' } } }
+            }
+          }
+        },
+        endpoints: Array.from({ length: 50 }, (_, i) => ({
+          path: `/endpoint${i}`,
+          method: 'GET',
+          handler: `handler${i}`
+        })),
+        metadata: {
+          serviceName: 'perf-test',
+          version: '1.0.0',
+          connectors: [
+            'connector-logger',
+            'connector-storage',
+            'connector-registry-client',
+            'connector-mq-client',
+            'connector-cookbook'
+          ]
+        },
+        health: {
+          status: 'healthy',
+          uptime: 1000000,
+          checks: {
+            db: 'ok',
+            cache: 'ok',
+            queue: 'ok'
+          }
+        }
+      };
+
+      const startTime = Date.now();
+      const result = await validationCore.validate(complexData);
+      const duration = Date.now() - startTime;
+
+      expect(result.validated).toBe(true);
+      expect(duration).toBeLessThan(500); // Should complete within 500ms
+    });
+  });
+});