@onlineapps/conn-orch-validator 2.0.5 → 2.0.7

package/tests/unit/ServiceValidator.test.js

@@ -1,429 +0,0 @@
-'use strict';
-
-const ServiceValidator = require('../../src/ServiceValidator');
-const MockRegistry = require('../../src/mocks/MockRegistry');
-const axios = require('axios');
-
-jest.mock('axios');
-
-describe('ServiceValidator @unit', () => {
-  let validator;
-  let registry;
-
-  beforeEach(() => {
-    validator = new ServiceValidator();
-    registry = new MockRegistry();
-    axios.mockClear();
-  });
-
-  describe('Test Value Generation', () => {
-    it('should generate string values', () => {
-      expect(validator.generateTestValue({ type: 'string' })).toBe('test');
-      expect(validator.generateTestValue({ type: 'string', example: 'custom' })).toBe('custom');
-      expect(validator.generateTestValue({ type: 'string', enum: ['opt1', 'opt2'] })).toBe('opt1');
-    });
-
-    it('should generate formatted strings', () => {
-      expect(validator.generateTestValue({ type: 'string', format: 'email' })).toBe('test@example.com');
-      expect(validator.generateTestValue({ type: 'string', format: 'date' })).toBe('2024-01-01');
-      expect(validator.generateTestValue({ type: 'string', format: 'date-time' })).toBe('2024-01-01T00:00:00Z');
-      expect(validator.generateTestValue({ type: 'string', format: 'uuid' }))
-        .toBe('123e4567-e89b-12d3-a456-426614174000');
-    });
-
-    it('should generate number values', () => {
-      expect(validator.generateTestValue({ type: 'number' })).toBe(1);
-      expect(validator.generateTestValue({ type: 'integer' })).toBe(1);
-      expect(validator.generateTestValue({ type: 'number', minimum: 10 })).toBe(10);
-      expect(validator.generateTestValue({ type: 'number', maximum: 100 })).toBe(100);
-      expect(validator.generateTestValue({ type: 'number', example: 42 })).toBe(42);
-    });
-
-    it('should generate boolean values', () => {
-      expect(validator.generateTestValue({ type: 'boolean' })).toBe(true);
-      expect(validator.generateTestValue({ type: 'boolean', example: false })).toBe(false);
-    });
-
-    it('should generate array values', () => {
-      const result = validator.generateTestValue({
-        type: 'array',
-        items: { type: 'string' }
-      });
-      expect(Array.isArray(result)).toBe(true);
-      expect(result).toEqual(['test']);
-    });
-
-    it('should generate object values', () => {
-      const schema = {
-        type: 'object',
-        properties: {
-          name: { type: 'string' },
-          age: { type: 'number' }
-        },
-        required: ['name']
-      };
-      
-      const result = validator.generateTestValue(schema);
-      expect(result).toHaveProperty('name', 'test');
-      // Age might or might not be included (random)
-    });
-
-    it('should handle null schema', () => {
-      expect(validator.generateTestValue(null)).toBeNull();
-      expect(validator.generateTestValue(undefined)).toBeNull();
-    });
-  });
-
-  describe('Request Building', () => {
-    const operation = {
-      parameters: [
-        { name: 'id', in: 'path', schema: { type: 'string' }, required: true },
-        { name: 'filter', in: 'query', schema: { type: 'string' } },
-        { name: 'x-api-key', in: 'header', schema: { type: 'string' } }
-      ],
-      requestBody: {
-        content: {
-          'application/json': {
-            schema: {
-              type: 'object',
-              properties: { data: { type: 'string' } }
-            }
-          }
-        }
-      }
-    };
-
-    it('should build request with path parameters', () => {
-      const request = validator.buildTestRequest('/users/{id}', 'get', operation);
-      expect(request.path).toBe('/users/test');
-    });
-
-    it('should build request with query parameters', () => {
-      const request = validator.buildTestRequest('/users', 'get', operation);
-      // Query params are optional and added randomly
-      expect(request.query).toBeDefined();
-    });
-
-    it('should build request with headers', () => {
-      const request = validator.buildTestRequest('/users', 'get', operation);
-      expect(request.headers).toBeDefined();
-    });
-
-    it('should build request with body', () => {
-      const request = validator.buildTestRequest('/users', 'post', operation);
-      expect(request.headers['Content-Type']).toBe('application/json');
-      expect(request.body).toHaveProperty('data');
-    });
-
-    it('should handle operations without parameters', () => {
-      const request = validator.buildTestRequest('/users', 'get', {});
-      expect(request.path).toBe('/users');
-      expect(request.query).toEqual({});
-      expect(request.headers).toEqual({});
-      expect(request.body).toBeNull();
-    });
-  });
-
-  describe('Endpoint Testing', () => {
-    const operation = {
-      operationId: 'getUser',
-      responses: {
-        '200': {
-          content: {
-            'application/json': {
-              schema: {
-                type: 'object',
-                properties: {
-                  id: { type: 'string' },
-                  name: { type: 'string' }
-                },
-                required: ['id', 'name']
-              }
-            }
-          }
-        }
-      }
-    };
-
-    it('should test endpoint successfully', async () => {
-      axios.mockResolvedValue({
-        status: 200,
-        headers: {},
-        data: { id: '123', name: 'Test' }
-      });
-
-      const result = await validator.testEndpoint(
-        'http://localhost:3000',
-        '/users',
-        'get',
-        operation
-      );
-
-      expect(result.valid).toBe(true);
-      expect(result.path).toBe('/users');
-      expect(result.method).toBe('GET');
-      expect(result.operationId).toBe('getUser');
-      expect(result.response.status).toBe(200);
-    });
-
-    it('should handle endpoint errors', async () => {
-      axios.mockRejectedValue(new Error('Connection refused'));
-
-      const result = await validator.testEndpoint(
-        'http://localhost:3000',
-        '/users',
-        'get',
-        operation
-      );
-
-      expect(result.valid).toBe(false);
-      expect(result.errors).toContain('Failed to call endpoint: Connection refused');
-    });
-
-    it('should validate response against schema', async () => {
-      axios.mockResolvedValue({
-        status: 200,
-        headers: {},
-        data: { invalid: 'response' }
-      });
-
-      const result = await validator.testEndpoint(
-        'http://localhost:3000',
-        '/users',
-        'get',
-        operation
-      );
-
-      expect(result.valid).toBe(false);
-      expect(result.errors[0]).toContain('Response validation failed');
-    });
-
-    it('should handle unexpected status codes', async () => {
-      axios.mockResolvedValue({
-        status: 404,
-        headers: {},
-        data: { error: 'Not found' }
-      });
-
-      const result = await validator.testEndpoint(
-        'http://localhost:3000',
-        '/users',
-        'get',
-        operation
-      );
-
-      expect(result.valid).toBe(false);
-      expect(result.errors).toContain('Unexpected status code: 404');
-    });
-  });
-
-  describe('Service Validation', () => {
-    const openApiSpec = {
-      paths: {
-        '/users': {
-          get: {
-            operationId: 'getUsers',
-            responses: {
-              '200': {
-                content: {
-                  'application/json': {
-                    schema: { type: 'array' }
-                  }
-                }
-              }
-            }
-          },
-          post: {
-            operationId: 'createUser',
-            responses: {
-              '201': {
-                content: {
-                  'application/json': {
-                    schema: { type: 'object' }
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-    };
-
-    it('should validate service with all endpoints passing', async () => {
-      // Return different responses based on method
-      axios.mockImplementation((config) => {
-        if (config.method === 'GET') {
-          return Promise.resolve({
-            status: 200,
-            headers: {},
-            data: []
-          });
-        } else if (config.method === 'POST') {
-          return Promise.resolve({
-            status: 201,
-            headers: {},
-            data: {}
-          });
-        }
-      });
-
-      const results = await validator.validateService(
-        'http://localhost:3000',
-        openApiSpec
-      );
-
-      expect(results.valid).toBe(true);
-      expect(results.errors).toHaveLength(0);
-      expect(results.testedEndpoints).toHaveLength(2);
-      expect(results.coverage).toBe(100);
-    });
-
-    it('should mark service invalid if any endpoint fails', async () => {
-      axios
-        .mockResolvedValueOnce({ status: 200, headers: {}, data: [] })
-        .mockRejectedValueOnce(new Error('Failed'));
-
-      const results = await validator.validateService(
-        'http://localhost:3000',
-        openApiSpec
-      );
-
-      expect(results.valid).toBe(false);
-      expect(results.errors.length).toBeGreaterThan(0);
-    });
-
-    it('should handle spec without paths', async () => {
-      const results = await validator.validateService(
-        'http://localhost:3000',
-        {}
-      );
-
-      expect(results.valid).toBe(false);
-      expect(results.errors).toContain('No paths defined in OpenAPI spec');
-    });
-  });
-
-  describe('Cookbook Validation', () => {
-    beforeEach(async () => {
-      await registry.register({
-        name: 'service1',
-        openapi: {
-          paths: {
-            '/test': {
-              get: { operationId: 'testOp' }
-            }
-          }
-        }
-      });
-    });
-
-    it('should validate cookbook with valid steps', async () => {
-      const cookbook = {
-        steps: [
-          {
-            id: 'step1',
-            type: 'task',
-            service: 'service1',
-            operation: 'testOp'
-          }
-        ]
-      };
-
-      const results = await validator.validateCookbook(cookbook, registry);
-      
-      expect(results.valid).toBe(true);
-      expect(results.errors).toHaveLength(0);
-      expect(results.validatedSteps).toHaveLength(1);
-    });
-
-    it('should detect missing step fields', async () => {
-      const cookbook = {
-        steps: [
-          { type: 'task' }, // Missing id and service
-          { id: 'step2' }  // Missing type
-        ]
-      };
-
-      const results = await validator.validateCookbook(cookbook, registry);
-      
-      expect(results.valid).toBe(false);
-      expect(results.errors.length).toBeGreaterThan(0);
-    });
-
-    it('should validate foreach steps', async () => {
-      const cookbook = {
-        steps: [
-          {
-            id: 'foreach1',
-            type: 'foreach',
-            items: '$api_input.items',
-            body: { id: 'body', type: 'task', service: 'service1' }
-          }
-        ]
-      };
-
-      const results = await validator.validateCookbook(cookbook, registry);
-      expect(results.valid).toBe(true);
-    });
-
-    it('should validate switch steps', async () => {
-      const cookbook = {
-        steps: [
-          {
-            id: 'switch1',
-            type: 'switch',
-            condition: '$api_input.type',
-            cases: [
-              { value: 'a', step: { id: 's1', type: 'task', service: 'service1' } }
-            ]
-          }
-        ]
-      };
-
-      const results = await validator.validateCookbook(cookbook, registry);
-      expect(results.valid).toBe(true);
-    });
-
-    it('should detect non-existent service', async () => {
-      const cookbook = {
-        steps: [
-          {
-            id: 'step1',
-            type: 'task',
-            service: 'non-existent'
-          }
-        ]
-      };
-
-      const results = await validator.validateCookbook(cookbook, registry);
-      
-      expect(results.valid).toBe(false);
-      expect(results.errors).toContain('Service not found: non-existent');
-    });
-
-    it('should detect non-existent operation', async () => {
-      const cookbook = {
-        steps: [
-          {
-            id: 'step1',
-            type: 'task',
-            service: 'service1',
-            operation: 'nonExistentOp'
-          }
-        ]
-      };
-
-      const results = await validator.validateCookbook(cookbook, registry);
-      
-      expect(results.valid).toBe(false);
-      expect(results.errors).toContain('Operation not found: nonExistentOp');
-    });
-
-    it('should handle cookbook without steps', async () => {
-      const results = await validator.validateCookbook({}, registry);
-      
-      expect(results.valid).toBe(false);
-      expect(results.errors).toContain('Cookbook must have steps array');
-    });
-  });
-});