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

package/tests/component/api-mapping-flow.test.js

@@ -1,624 +0,0 @@
-'use strict';
-
-const { ApiMapper, create } = require('../../src/index');
-const axios = require('axios');
-
-// Mock axios
-jest.mock('axios');
-
-describe('API Mapper Component Tests @component', () => {
-  let apiMapper;
-  let mockOpenApiSpec;
-  let mockLogger;
-
-  beforeEach(() => {
-    jest.clearAllMocks();
-
-    // Mock logger
-    mockLogger = {
-      info: jest.fn(),
-      error: jest.fn(),
-      debug: jest.fn(),
-      warn: jest.fn()
-    };
-
-    // Sample OpenAPI spec
-    mockOpenApiSpec = {
-      openapi: '3.0.0',
-      info: {
-        title: 'Test API',
-        version: '1.0.0'
-      },
-      servers: [
-        { url: 'http://localhost:3000' }
-      ],
-      paths: {
-        '/users': {
-          get: {
-            operationId: 'listUsers',
-            summary: 'List all users',
-            parameters: [
-              {
-                name: 'limit',
-                in: 'query',
-                schema: { type: 'integer' }
-              },
-              {
-                name: 'offset',
-                in: 'query',
-                schema: { type: 'integer' }
-              }
-            ],
-            responses: {
-              '200': {
-                description: 'User list',
-                content: {
-                  'application/json': {
-                    schema: {
-                      type: 'array',
-                      items: { $ref: '#/components/schemas/User' }
-                    }
-                  }
-                }
-              }
-            }
-          },
-          post: {
-            operationId: 'createUser',
-            summary: 'Create a new user',
-            requestBody: {
-              required: true,
-              content: {
-                'application/json': {
-                  schema: { $ref: '#/components/schemas/User' }
-                }
-              }
-            },
-            responses: {
-              '201': {
-                description: 'User created',
-                content: {
-                  'application/json': {
-                    schema: { $ref: '#/components/schemas/User' }
-                  }
-                }
-              }
-            }
-          }
-        },
-        '/users/{userId}': {
-          get: {
-            operationId: 'getUser',
-            summary: 'Get user by ID',
-            parameters: [
-              {
-                name: 'userId',
-                in: 'path',
-                required: true,
-                schema: { type: 'string' }
-              }
-            ],
-            responses: {
-              '200': {
-                description: 'User details',
-                content: {
-                  'application/json': {
-                    schema: { $ref: '#/components/schemas/User' }
-                  }
-                }
-              },
-              '404': {
-                description: 'User not found'
-              }
-            }
-          },
-          put: {
-            operationId: 'updateUser',
-            summary: 'Update user',
-            parameters: [
-              {
-                name: 'userId',
-                in: 'path',
-                required: true,
-                schema: { type: 'string' }
-              }
-            ],
-            requestBody: {
-              required: true,
-              content: {
-                'application/json': {
-                  schema: { $ref: '#/components/schemas/User' }
-                }
-              }
-            },
-            responses: {
-              '200': {
-                description: 'User updated'
-              }
-            }
-          },
-          delete: {
-            operationId: 'deleteUser',
-            summary: 'Delete user',
-            parameters: [
-              {
-                name: 'userId',
-                in: 'path',
-                required: true,
-                schema: { type: 'string' }
-              }
-            ],
-            responses: {
-              '204': {
-                description: 'User deleted'
-              }
-            }
-          }
-        },
-        '/auth/login': {
-          post: {
-            operationId: 'login',
-            summary: 'User login',
-            requestBody: {
-              required: true,
-              content: {
-                'application/json': {
-                  schema: {
-                    type: 'object',
-                    properties: {
-                      username: { type: 'string' },
-                      password: { type: 'string' }
-                    }
-                  }
-                }
-              }
-            },
-            responses: {
-              '200': {
-                description: 'Login successful',
-                content: {
-                  'application/json': {
-                    schema: {
-                      type: 'object',
-                      properties: {
-                        token: { type: 'string' },
-                        user: { $ref: '#/components/schemas/User' }
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-      },
-      components: {
-        schemas: {
-          User: {
-            type: 'object',
-            properties: {
-              id: { type: 'string' },
-              name: { type: 'string' },
-              email: { type: 'string' },
-              role: { type: 'string' }
-            }
-          }
-        }
-      }
-    };
-
-    apiMapper = new ApiMapper({
-      openApiSpec: mockOpenApiSpec,
-      serviceUrl: 'http://test-service:3000',
-      logger: mockLogger
-    });
-  });
-
-  describe('Complete Mapping Flow', () => {
-    it('should map and execute GET request with query parameters', async () => {
-      const mockResponse = {
-        data: [
-          { id: '1', name: 'John', email: 'john@example.com' },
-          { id: '2', name: 'Jane', email: 'jane@example.com' }
-        ],
-        status: 200,
-        headers: { 'content-type': 'application/json' }
-      };
-      axios.mockResolvedValue(mockResponse);
-
-      const params = {
-        limit: 10,
-        offset: 0
-      };
-
-      const result = await apiMapper.callOperation('listUsers', params);
-
-      expect(axios).toHaveBeenCalledWith({
-        method: 'GET',
-        url: 'http://test-service:3000/users',
-        params: {
-          limit: 10,
-          offset: 0
-        },
-        headers: {},
-        data: null
-      });
-
-      expect(result).toEqual(mockResponse.data);
-    });
-
-    it('should map and execute POST request with body', async () => {
-      const mockResponse = {
-        data: { id: '3', name: 'Bob', email: 'bob@example.com', role: 'user' },
-        status: 201,
-        headers: { 'content-type': 'application/json' }
-      };
-      axios.mockResolvedValue(mockResponse);
-
-      const params = {
-        body: {
-          name: 'Bob',
-          email: 'bob@example.com',
-          role: 'user'
-        }
-      };
-
-      const result = await apiMapper.callOperation('createUser', params);
-
-      expect(axios).toHaveBeenCalledWith({
-        method: 'POST',
-        url: 'http://test-service:3000/users',
-        params: {},
-        headers: { 'Content-Type': 'application/json' },
-        data: params.body
-      });
-
-      expect(result).toEqual(mockResponse.data);
-    });
-
-    it('should map and execute request with path parameters', async () => {
-      const mockResponse = {
-        data: { id: '123', name: 'Alice', email: 'alice@example.com' },
-        status: 200
-      };
-      axios.mockResolvedValue(mockResponse);
-
-      const params = {
-        userId: '123'
-      };
-
-      const result = await apiMapper.callOperation('getUser', params);
-
-      expect(axios).toHaveBeenCalledWith({
-        method: 'GET',
-        url: 'http://test-service:3000/users/123',
-        params: {},
-        headers: {},
-        data: null
-      });
-
-      expect(result).toEqual(mockResponse.data);
-    });
-
-    it('should handle mixed parameters (path, query, body)', async () => {
-      // Add a complex endpoint to the spec
-      apiMapper.operations['complexOperation'] = {
-        method: 'POST',
-        path: '/api/v1/organizations/{orgId}/users/{userId}/actions',
-        parameters: [
-          { name: 'orgId', in: 'path', required: true },
-          { name: 'userId', in: 'path', required: true },
-          { name: 'action', in: 'query' },
-          { name: 'notify', in: 'query' }
-        ],
-        requestBody: {
-          content: {
-            'application/json': {
-              schema: { type: 'object' }
-            }
-          }
-        }
-      };
-
-      const mockResponse = { data: { success: true }, status: 200 };
-      axios.mockResolvedValue(mockResponse);
-
-      const timestamp = Date.now();
-      const params = {
-        orgId: 'org-123',
-        userId: 'user-456',
-        action: 'activate',
-        notify: true,
-        body: { metadata: { timestamp } }
-      };
-
-      await apiMapper.callOperation('complexOperation', params);
-
-      expect(axios).toHaveBeenCalledWith({
-        method: 'POST',
-        url: 'http://test-service:3000/api/v1/organizations/org-123/users/user-456/actions',
-        params: {
-          action: 'activate',
-          notify: true
-        },
-        headers: { 'Content-Type': 'application/json' },
-        data: { metadata: { timestamp } }
-      });
-    });
-  });
-
-  describe('Error Handling', () => {
-    it('should handle 404 errors appropriately', async () => {
-      const error = {
-        response: {
-          status: 404,
-          data: { error: 'User not found' }
-        }
-      };
-      axios.mockRejectedValue(error);
-
-      await expect(apiMapper.callOperation('getUser', { userId: 'nonexistent' }))
-        .rejects.toThrow();
-
-      expect(mockLogger.error).toHaveBeenCalled();
-    });
-
-    it('should handle network errors', async () => {
-      const error = new Error('Network error');
-      error.code = 'ECONNREFUSED';
-      axios.mockRejectedValue(error);
-
-      await expect(apiMapper.callOperation('listUsers', {}))
-        .rejects.toThrow('Network error');
-    });
-
-    it('should handle malformed responses', async () => {
-      axios.mockResolvedValue({
-        data: 'Invalid JSON response',
-        status: 200
-      });
-
-      const result = await apiMapper.callOperation('listUsers', {});
-      expect(result).toBe('Invalid JSON response');
-    });
-
-    it('should throw error for unknown operations', () => {
-      expect(() => apiMapper.mapOperationToEndpoint('unknownOperation'))
-        .toThrow('Operation not found: unknownOperation');
-    });
-  });
-
-  describe('Request Transformation', () => {
-    it('should correctly transform parameters based on OpenAPI spec', () => {
-      const operation = apiMapper.operations['getUser'];
-      const cookbookParams = {
-        userId: '123',
-        extraParam: 'should-be-ignored'
-      };
-
-      const transformed = apiMapper.transformRequest(cookbookParams, operation.parameters || []);
-
-      expect(transformed.params.userId).toBe('123');
-      expect(transformed.params.extraParam).toBeUndefined();
-    });
-
-    it('should handle optional parameters', () => {
-      const operation = apiMapper.operations['listUsers'];
-      const cookbookParams = {
-        limit: 5
-        // offset is omitted
-      };
-
-      const transformed = apiMapper.transformRequest(cookbookParams, operation.parameters || []);
-
-      expect(transformed.query.limit).toBe(5);
-      expect(transformed.query.offset).toBeUndefined();
-    });
-
-    it('should separate body from other parameters', () => {
-      const operation = apiMapper.operations['updateUser'];
-      const cookbookParams = {
-        userId: '123',
-        body: {
-          name: 'Updated Name',
-          email: 'updated@example.com'
-        }
-      };
-
-      const transformed = apiMapper.transformRequest(cookbookParams, operation.parameters || []);
-
-      expect(transformed.params.userId).toBe('123');
-      expect(transformed.body).toEqual({
-        name: 'Updated Name',
-        email: 'updated@example.com'
-      });
-    });
-  });
-
-  describe('Direct Call Mode', () => {
-    it('should use Express app for direct calls when configured', async () => {
-      const mockApp = {
-        _router: {
-          stack: []
-        }
-      };
-
-      const mockReq = {};
-      const mockRes = {
-        status: jest.fn().mockReturnThis(),
-        json: jest.fn(),
-        send: jest.fn()
-      };
-
-      const directMapper = new ApiMapper({
-        openApiSpec: mockOpenApiSpec,
-        service: mockApp,
-        directCall: true,
-        logger: mockLogger
-      });
-
-      // Mock _callDirectly method
-      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('OpenAPI Parsing', () => {
-    it('should parse all operations from OpenAPI spec', () => {
-      const operations = apiMapper.operations;
-
-      expect(operations).toHaveProperty('listUsers');
-      expect(operations).toHaveProperty('createUser');
-      expect(operations).toHaveProperty('getUser');
-      expect(operations).toHaveProperty('updateUser');
-      expect(operations).toHaveProperty('deleteUser');
-      expect(operations).toHaveProperty('login');
-
-      expect(operations.listUsers.method).toBe('GET');
-      expect(operations.listUsers.path).toBe('/users');
-      expect(operations.createUser.method).toBe('POST');
-      expect(operations.createUser.path).toBe('/users');
-    });
-
-    it('should handle spec without operationId', () => {
-      const specWithoutOperationId = {
-        ...mockOpenApiSpec,
-        paths: {
-          '/test': {
-            get: {
-              summary: 'Test endpoint'
-              // No operationId
-            }
-          }
-        }
-      };
-
-      const mapper = new ApiMapper({
-        openApiSpec: specWithoutOperationId,
-        logger: mockLogger
-      });
-
-      // Should generate operationId from method and path
-      expect(mapper.operations).toHaveProperty('get__test');
-    });
-  });
-
-  describe('Response Transformation', () => {
-    it('should extract data from successful responses', async () => {
-      const response = {
-        data: { id: '1', name: 'John' },
-        status: 200,
-        headers: { 'content-type': 'application/json' }
-      };
-
-      const transformed = await apiMapper.transformResponse(response);
-      expect(transformed).toEqual({ id: '1', name: 'John' });
-    });
-
-    it('should handle empty responses', async () => {
-      const response = {
-        data: null,
-        status: 204
-      };
-
-      const transformed = await apiMapper.transformResponse(response);
-      expect(transformed).toEqual(response);
-    });
-
-    it('should preserve error responses', async () => {
-      const response = {
-        data: { error: 'Bad request', details: 'Invalid email' },
-        status: 400
-      };
-
-      const transformed = await apiMapper.transformResponse(response);
-      expect(transformed).toEqual({ error: 'Bad request', details: 'Invalid email' });
-    });
-  });
-
-  describe('Factory Function', () => {
-    it('should create ApiMapper instance using factory', () => {
-      const mapper = create({
-        openApiSpec: mockOpenApiSpec,
-        serviceUrl: 'http://factory-test:3000'
-      });
-
-      expect(mapper).toBeInstanceOf(ApiMapper);
-      expect(mapper.serviceUrl).toBe('http://factory-test:3000');
-    });
-
-    it('should throw error when spec is missing', () => {
-      expect(() => create({}))
-        .toThrow('OpenAPI specification is required');
-    });
-  });
-
-  describe('Spec Reloading', () => {
-    it('should reload OpenAPI spec dynamically', () => {
-      const newSpec = {
-        ...mockOpenApiSpec,
-        paths: {
-          '/new-endpoint': {
-            get: {
-              operationId: 'newOperation',
-              summary: 'New endpoint'
-            }
-          }
-        }
-      };
-
-      apiMapper.loadOpenApiSpec(newSpec);
-
-      expect(apiMapper.operations).toHaveProperty('newOperation');
-      expect(apiMapper.operations.newOperation.path).toBe('/new-endpoint');
-    });
-  });
-
-  describe('Variable Resolution', () => {
-    it('should resolve cookbook variables in parameters', () => {
-      // Check if resolveVariables method exists
-      if (!apiMapper._resolveVariables && !apiMapper.resolveVariables) {
-        // Skip test if method doesn't exist
-        return;
-      }
-      const params = {
-        userId: '${context.user.id}',
-        name: '${input.userName}'
-      };
-
-      const context = {
-        user: { id: '123' }
-      };
-
-      const input = {
-        userName: 'John Doe'
-      };
-
-      const resolved = apiMapper._resolveVariables ?
-        apiMapper._resolveVariables(params, { context, input }) :
-        apiMapper.resolveVariables(params, { context, input });
-
-      expect(resolved.userId).toBe('123');
-      expect(resolved.name).toBe('John Doe');
-    });
-
-    it('should handle missing variables gracefully', () => {
-      const params = {
-        userId: '${context.user.id}',
-        name: 'static-value'
-      };
-
-      const resolved = apiMapper._resolveVariables(params, {});
-
-      expect(resolved.userId).toBeUndefined();
-      expect(resolved.name).toBe('static-value');
-    });
-  });
-});