@onlineapps/conn-orch-api-mapper 1.0.21 → 1.0.23

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

@@ -1,599 +0,0 @@
-'use strict';
-
-const ApiMapper = require('../../src/ApiMapper');
-const axios = require('axios');
-
-jest.mock('axios');
-jest.mock('@onlineapps/content-resolver', () => {
-  return jest.fn().mockImplementation(() => ({
-    getAsString: jest.fn(async (ref) => {
-      if (typeof ref === 'string') return `resolved:${ref}`;
-      if (ref && ref.content) return ref.content;
-      return 'resolved-descriptor';
-    })
-  }));
-});
-
-describe('ApiMapper Unit Tests @unit', () => {
-  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('operations.json format (type-driven descriptor handling)', () => {
-    it('should store original input schema on parsed operation', () => {
-      const operationsJson = {
-        operations: {
-          'test-file-info': {
-            description: 'Test',
-            endpoint: '/api/test-file-info',
-            method: 'POST',
-            input: {
-              file: { type: 'file', required: true }
-            },
-            output: {
-              ok: { type: 'boolean' }
-            }
-          }
-        }
-      };
-
-      const mapper = new ApiMapper({
-        openApiSpec: operationsJson,
-        serviceUrl: 'http://test-service:3000',
-        logger: mockLogger
-      });
-
-      expect(mapper.operations['test-file-info']).toBeDefined();
-      expect(mapper.operations['test-file-info'].input).toEqual({
-        file: { type: 'file', required: true }
-      });
-    });
-
-    it('should pass through descriptors for input fields typed as file', async () => {
-      const operationsJson = {
-        operations: {
-          'test-file-info': {
-            description: 'Test',
-            endpoint: '/api/test-file-info',
-            method: 'POST',
-            input: {
-              file: { type: 'file', required: true }
-            },
-            output: {
-              ok: { type: 'boolean' }
-            }
-          }
-        }
-      };
-
-      apiMapper = new ApiMapper({
-        openApiSpec: operationsJson,
-        serviceUrl: 'http://test-service:3000',
-        logger: mockLogger
-      });
-
-      // Ensure we do NOT hit axios
-      axios.mockImplementation(async () => ({ status: 200, data: { ok: true } }));
-
-      const descriptor = { _descriptor: true, type: 'file', storage_ref: 'minio://bucket/path' };
-      await apiMapper.callOperation('test-file-info', { file: descriptor }, {});
-
-      expect(axios).toHaveBeenCalledWith(
-        expect.objectContaining({
-          method: 'POST',
-          url: 'http://test-service:3000/api/test-file-info',
-          data: { file: descriptor }
-        })
-      );
-    });
-  });
-
-  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', async () => {
-      const response = {
-        data: { id: '1', name: 'John' },
-        status: 200,
-        headers: {}
-      };
-
-      const result = await apiMapper.transformResponse(response);
-      expect(result).toEqual({ id: '1', name: 'John' });
-    });
-
-    it('should handle null response', async () => {
-      const response = {
-        data: null,
-        status: 204
-      };
-
-      const result = await apiMapper.transformResponse(response);
-      expect(result).toEqual(response);
-    });
-
-    it('should pass through response without data property', async () => {
-      const response = { status: 200 };
-      const result = await 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(
-        expect.objectContaining({
-          method: 'GET',
-          url: 'http://test-service:3000/users/1',
-          params: {}
-        })
-      );
-
-      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' });
-    });
-  });
-
-  describe('_resolveContentDescriptors', () => {
-    it('should return input if not object', async () => {
-      const result = await apiMapper._resolveContentDescriptors(null);
-      expect(result).toBeNull();
-    });
-
-    it('should resolve nested descriptors based on schema types', async () => {
-      const input = {
-        doc: {
-          _descriptor: true,
-          type: 'file',
-          storage_ref: 'minio://workflow/file1'
-        },
-        meta: {
-          title: {
-            _descriptor: true,
-            type: 'inline',
-            content: 'Hello'
-          },
-          items: [
-            {
-              note: {
-                _descriptor: true,
-                type: 'inline',
-                content: 'Note 1'
-              }
-            }
-          ]
-        }
-      };
-
-      const operation = {
-        input: {
-          doc: { type: 'file' },
-          meta: {
-            type: 'object',
-            properties: {
-              title: { type: 'string' },
-              items: {
-                type: 'array',
-                items: {
-                  type: 'object',
-                  properties: {
-                    note: { type: 'string' }
-                  }
-                }
-              }
-            }
-          }
-        }
-      };
-
-      const result = await apiMapper._resolveContentDescriptors(input, operation);
-
-      expect(result.doc).toEqual(input.doc); // file passthrough
-      expect(result.meta.title).toBe('Hello');
-      expect(result.meta.items[0].note).toBe('Note 1');
-    });
-  });
-});