@onlineapps/conn-orch-api-mapper 1.0.0

package/test/unit/ApiMapper.unit.test.js

@@ -0,0 +1,461 @@
+'use strict';
+
+const ApiMapper = require('../../src/ApiMapper');
+const axios = require('axios');
+
+jest.mock('axios');
+
+describe('ApiMapper Unit Tests', () => {
+  let apiMapper;
+  let mockLogger;
+  let mockOpenApiSpec;
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+
+    mockLogger = {
+      info: jest.fn(),
+      error: jest.fn(),
+      debug: jest.fn(),
+      warn: jest.fn()
+    };
+
+    mockOpenApiSpec = {
+      openapi: '3.0.0',
+      info: { title: 'Test API', version: '1.0.0' },
+      servers: [{ url: 'http://localhost:3000' }],
+      paths: {
+        '/users/{userId}': {
+          get: {
+            operationId: 'getUser',
+            parameters: [
+              { name: 'userId', in: 'path', required: true, schema: { type: 'string' } }
+            ]
+          },
+          put: {
+            operationId: 'updateUser',
+            parameters: [
+              { name: 'userId', in: 'path', required: true }
+            ],
+            requestBody: {
+              content: {
+                'application/json': {
+                  schema: { type: 'object' }
+                }
+              }
+            }
+          }
+        },
+        '/users': {
+          get: {
+            operationId: 'listUsers',
+            parameters: [
+              { name: 'limit', in: 'query', schema: { type: 'integer' } },
+              { name: 'offset', in: 'query', schema: { type: 'integer' } }
+            ]
+          },
+          post: {
+            operationId: 'createUser',
+            requestBody: {
+              required: true,
+              content: {
+                'application/json': {
+                  schema: { type: 'object' }
+                }
+              }
+            }
+          }
+        }
+      }
+    };
+
+    apiMapper = new ApiMapper({
+      openApiSpec: mockOpenApiSpec,
+      serviceUrl: 'http://test-service:3000',
+      logger: mockLogger
+    });
+  });
+
+  describe('Constructor', () => {
+    it('should create instance with required config', () => {
+      expect(apiMapper).toBeInstanceOf(ApiMapper);
+      expect(apiMapper.serviceUrl).toBe('http://test-service:3000');
+      expect(apiMapper.openApiSpec).toEqual(mockOpenApiSpec);
+    });
+
+    it('should throw error without OpenAPI spec', () => {
+      expect(() => new ApiMapper({})).toThrow('OpenAPI specification is required');
+    });
+
+    it('should use default service URL if not provided', () => {
+      const mapper = new ApiMapper({
+        openApiSpec: mockOpenApiSpec
+      });
+      expect(mapper.serviceUrl).toBe('http://localhost:3000');
+    });
+
+    it('should parse operations from OpenAPI spec', () => {
+      expect(apiMapper.operations).toBeDefined();
+      expect(apiMapper.operations['getUser']).toBeDefined();
+      expect(apiMapper.operations['updateUser']).toBeDefined();
+      expect(apiMapper.operations['listUsers']).toBeDefined();
+      expect(apiMapper.operations['createUser']).toBeDefined();
+    });
+  });
+
+  describe('_parseOpenApiSpec', () => {
+    it('should extract operations with correct details', () => {
+      const operations = apiMapper._parseOpenApiSpec(mockOpenApiSpec);
+
+      expect(operations['getUser']).toEqual({
+        method: 'GET',
+        path: '/users/{userId}',
+        parameters: mockOpenApiSpec.paths['/users/{userId}'].get.parameters,
+        requestBody: undefined,
+        responses: undefined,
+        summary: undefined,
+        description: undefined
+      });
+
+      expect(operations['createUser']).toEqual({
+        method: 'POST',
+        path: '/users',
+        parameters: [],
+        requestBody: mockOpenApiSpec.paths['/users'].post.requestBody,
+        responses: undefined,
+        summary: undefined,
+        description: undefined
+      });
+    });
+
+    it('should generate operation ID if missing', () => {
+      const specWithoutId = {
+        paths: {
+          '/test': {
+            get: {
+              // No operationId
+              parameters: []
+            }
+          }
+        }
+      };
+
+      const operations = apiMapper._parseOpenApiSpec(specWithoutId);
+      expect(operations['get__test']).toBeDefined();
+    });
+
+    it('should handle empty spec', () => {
+      const operations = apiMapper._parseOpenApiSpec({});
+      expect(operations).toEqual({});
+    });
+  });
+
+  describe('mapOperationToEndpoint', () => {
+    it('should return operation details for valid operation', () => {
+      const endpoint = apiMapper.mapOperationToEndpoint('getUser');
+
+      expect(endpoint).toEqual({
+        method: 'GET',
+        path: '/users/{userId}',
+        parameters: expect.any(Array),
+        requestBody: undefined,
+        responses: undefined,
+        summary: undefined,
+        description: undefined
+      });
+    });
+
+    it('should throw error for unknown operation', () => {
+      expect(() => apiMapper.mapOperationToEndpoint('unknownOp'))
+        .toThrow('Operation not found: unknownOp');
+    });
+  });
+
+  describe('transformRequest', () => {
+    it('should separate parameters by type', () => {
+      const params = [
+        { name: 'userId', in: 'path' },
+        { name: 'limit', in: 'query' },
+        { name: 'auth', in: 'header' }
+      ];
+
+      const input = {
+        userId: '123',
+        limit: 10,
+        auth: 'Bearer token'
+      };
+
+      const result = apiMapper.transformRequest(input, params);
+
+      expect(result.params.userId).toBe('123');
+      expect(result.query.limit).toBe(10);
+      expect(result.headers.auth).toBe('Bearer token');
+    });
+
+    it('should handle missing optional parameters', () => {
+      const params = [
+        { name: 'required', in: 'query', required: true },
+        { name: 'optional', in: 'query' }
+      ];
+
+      const result = apiMapper.transformRequest({ required: 'value' }, params);
+
+      expect(result.query.required).toBe('value');
+      expect(result.query.optional).toBeUndefined();
+    });
+
+    it('should throw for missing required parameters', () => {
+      const params = [
+        { name: 'required', in: 'path', required: true }
+      ];
+
+      expect(() => apiMapper.transformRequest({}, params))
+        .toThrow('Required parameter missing: required');
+    });
+
+    it('should extract body from input', () => {
+      const input = {
+        userId: '123',
+        body: {
+          name: 'John',
+          email: 'john@example.com'
+        }
+      };
+
+      const params = [{ name: 'userId', in: 'path' }];
+      const result = apiMapper.transformRequest(input, params);
+
+      expect(result.body).toEqual({
+        name: 'John',
+        email: 'john@example.com'
+      });
+    });
+  });
+
+  describe('transformResponse', () => {
+    it('should extract data from response', () => {
+      const response = {
+        data: { id: '1', name: 'John' },
+        status: 200,
+        headers: {}
+      };
+
+      const result = apiMapper.transformResponse(response);
+      expect(result).toEqual({ id: '1', name: 'John' });
+    });
+
+    it('should handle null response', () => {
+      const response = {
+        data: null,
+        status: 204
+      };
+
+      const result = apiMapper.transformResponse(response);
+      expect(result).toEqual(response);
+    });
+
+    it('should pass through response without data property', () => {
+      const response = { status: 200 };
+      const result = apiMapper.transformResponse(response);
+      expect(result).toEqual(response);
+    });
+  });
+
+  describe('_buildRequest', () => {
+    it('should build request with path parameters', () => {
+      const operation = {
+        method: 'GET',
+        path: '/users/{userId}',
+        parameters: [
+          { name: 'userId', in: 'path' }
+        ]
+      };
+
+      const input = { userId: '123' };
+      const request = apiMapper._buildRequest(operation, input);
+
+      expect(request.method).toBe('GET');
+      expect(request.url).toBe('http://test-service:3000/users/123');
+    });
+
+    it('should add query parameters', () => {
+      const operation = {
+        method: 'GET',
+        path: '/users',
+        parameters: [
+          { name: 'limit', in: 'query' },
+          { name: 'offset', in: 'query' }
+        ]
+      };
+
+      const input = { limit: 10, offset: 20 };
+      const request = apiMapper._buildRequest(operation, input);
+
+      expect(request.params).toEqual({ limit: 10, offset: 20 });
+    });
+
+    it('should add headers', () => {
+      const operation = {
+        method: 'GET',
+        path: '/users',
+        parameters: [
+          { name: 'X-API-Key', in: 'header' }
+        ]
+      };
+
+      const input = { 'X-API-Key': 'secret' };
+      const request = apiMapper._buildRequest(operation, input);
+
+      expect(request.headers['X-API-Key']).toBe('secret');
+    });
+
+    it('should add request body', () => {
+      const operation = {
+        method: 'POST',
+        path: '/users',
+        parameters: [],
+        requestBody: {
+          content: {
+            'application/json': {}
+          }
+        }
+      };
+
+      const input = {
+        body: { name: 'John', email: 'john@example.com' }
+      };
+      const request = apiMapper._buildRequest(operation, input);
+
+      expect(request.data).toEqual(input.body);
+      expect(request.headers['Content-Type']).toBe('application/json');
+    });
+  });
+
+  describe('_resolveVariables', () => {
+    it('should resolve simple variables', () => {
+      const input = {
+        userId: '${context.user.id}',
+        name: 'static'
+      };
+
+      const context = {
+        context: {
+          user: { id: '123' }
+        }
+      };
+
+      const result = apiMapper._resolveVariables(input, context);
+      expect(result.userId).toBe('123');
+      expect(result.name).toBe('static');
+    });
+
+    it('should handle missing context gracefully', () => {
+      const input = {
+        userId: '${context.user.id}'
+      };
+
+      const result = apiMapper._resolveVariables(input, {});
+      expect(result.userId).toBeUndefined();
+    });
+
+    it('should resolve nested objects', () => {
+      const input = {
+        user: {
+          id: '${context.userId}',
+          name: '${input.userName}'
+        }
+      };
+
+      const context = {
+        context: { userId: '123' },
+        input: { userName: 'John' }
+      };
+
+      const result = apiMapper._resolveVariables(input, context);
+      expect(result.user.id).toBe('123');
+      expect(result.user.name).toBe('John');
+    });
+  });
+
+  describe('callOperation', () => {
+    it('should execute operation successfully', async () => {
+      const mockResponse = {
+        data: { id: '1', name: 'John' },
+        status: 200
+      };
+      axios.mockResolvedValue(mockResponse);
+
+      const result = await apiMapper.callOperation('getUser', { userId: '1' });
+
+      expect(axios).toHaveBeenCalledWith({
+        method: 'GET',
+        url: 'http://test-service:3000/users/1',
+        params: {},
+        headers: {},
+        data: null
+      });
+
+      expect(result).toEqual({ id: '1', name: 'John' });
+    });
+
+    it('should handle operation errors', async () => {
+      const error = new Error('Network error');
+      axios.mockRejectedValue(error);
+
+      await expect(apiMapper.callOperation('getUser', { userId: '1' }))
+        .rejects.toThrow('Network error');
+
+      expect(mockLogger.error).toHaveBeenCalledWith(
+        'API call failed for getUser',
+        expect.any(Object)
+      );
+    });
+
+    it('should throw for unknown operation', async () => {
+      await expect(apiMapper.callOperation('unknownOp', {}))
+        .rejects.toThrow('Operation not found: unknownOp');
+    });
+  });
+
+  describe('loadOpenApiSpec', () => {
+    it('should reload spec and update operations', () => {
+      const newSpec = {
+        paths: {
+          '/new': {
+            get: {
+              operationId: 'newOp'
+            }
+          }
+        }
+      };
+
+      apiMapper.loadOpenApiSpec(newSpec);
+
+      expect(apiMapper.openApiSpec).toEqual(newSpec);
+      expect(apiMapper.operations['newOp']).toBeDefined();
+      expect(apiMapper.operations['getUser']).toBeUndefined();
+    });
+  });
+
+  describe('Direct Call Mode', () => {
+    it('should use direct call when configured', async () => {
+      const mockApp = {};
+      const directMapper = new ApiMapper({
+        openApiSpec: mockOpenApiSpec,
+        service: mockApp,
+        directCall: true,
+        logger: mockLogger
+      });
+
+      directMapper._callDirectly = jest.fn().mockResolvedValue({
+        data: { id: '1' },
+        status: 200
+      });
+
+      const result = await directMapper.callOperation('getUser', { userId: '1' });
+
+      expect(directMapper._callDirectly).toHaveBeenCalled();
+      expect(result).toEqual({ id: '1' });
+    });
+  });
+});