@onlineapps/conn-orch-validator 2.0.0

package/tests/unit/ServiceValidator.test.js

@@ -0,0 +1,429 @@
+'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');
+    });
+  });
+});