@onlineapps/service-wrapper 2.0.21 → 2.0.23

package/tests/component/ServiceWrapper.component.test.js

@@ -1,407 +0,0 @@
-'use strict';
-
-/**
- * Component tests for ServiceWrapper
- * These tests verify integration with actual connectors
- * and help us identify what needs to be implemented
- */
-
-const ServiceWrapper = require('../../src/ServiceWrapper');
-const express = require('express');
-
-describe('ServiceWrapper Component Tests @component', () => {
-  let wrapper;
-  let app;
-  let server;
-  const TEST_PORT = 3456;
-
-  beforeAll(() => {
-    // Create a real Express app for testing
-    app = express();
-    app.use(express.json());
-
-    // Add test endpoints
-    app.get('/api/health', (req, res) => {
-      res.json({ status: 'healthy' });
-    });
-
-    app.get('/api/test/:id', (req, res) => {
-      res.json({
-        id: req.params.id,
-        message: 'Test response'
-      });
-    });
-
-    app.post('/api/test', (req, res) => {
-      res.status(201).json({
-        created: true,
-        data: req.body
-      });
-    });
-
-    // Start the server
-    server = app.listen(TEST_PORT);
-  });
-
-  afterAll((done) => {
-    if (server) {
-      server.close(done);
-    }
-  });
-
-  afterEach(async () => {
-    if (wrapper && wrapper.isRunning) {
-      await wrapper.stop();
-    }
-  });
-
-  describe('Basic Integration', () => {
-    test('should fail gracefully when connectors are not available', async () => {
-      // This test helps us identify what connectors need to be implemented
-      const openApiSpec = {
-        openapi: '3.0.0',
-        info: {
-          title: 'Test Service',
-          version: '1.0.0'
-        },
-        paths: {
-          '/api/test/{id}': {
-            get: {
-              operationId: 'getTest',
-              parameters: [
-                {
-                  name: 'id',
-                  in: 'path',
-                  required: true,
-                  schema: { type: 'string' }
-                }
-              ]
-            }
-          }
-        }
-      };
-
-      wrapper = new ServiceWrapper({
-        service: app,
-        serviceName: 'test-service',
-        openApiSpec,
-        config: {
-          port: TEST_PORT
-        }
-      });
-
-      try {
-        await wrapper.start();
-        // If this succeeds, connectors are properly mocked
-        expect(wrapper.isRunning).toBe(true);
-      } catch (error) {
-        // This will tell us which connector is missing
-        console.log('Missing connector:', error.message);
-        expect(error.message).toMatch(/Cannot find module|is not a constructor/);
-      }
-    });
-  });
-
-  describe('Connector Requirements', () => {
-    // These tests document what each connector needs to provide
-
-    test('MQ Connector requirements', () => {
-      const MQConnectorAPI = {
-        constructor: ['config'],
-        methods: [
-          'connect',
-          'disconnect',
-          'isConnected',
-          'consume',
-          'publish'
-        ],
-        expectedBehavior: {
-          connect: 'returns Promise<void>',
-          disconnect: 'returns Promise<void>',
-          isConnected: 'returns boolean',
-          consume: 'accepts (handler, options) returns Promise<void>',
-          publish: 'accepts (queue, message) returns Promise<void>'
-        }
-      };
-
-      // Document the API
-      expect(MQConnectorAPI.methods).toContain('connect');
-      expect(MQConnectorAPI.methods).toContain('consume');
-    });
-
-    test('Registry Connector requirements', () => {
-      const RegistryConnectorAPI = {
-        ServiceRegistryClient: {
-          constructor: ['config'],
-          methods: [
-            'register',
-            'unregister',
-            'sendHeartbeat',
-            'isConnected'
-          ],
-          expectedBehavior: {
-            register: 'accepts (serviceInfo) returns Promise<void>',
-            unregister: 'accepts (serviceName) returns Promise<void>',
-            sendHeartbeat: 'accepts (serviceName) returns Promise<void>',
-            isConnected: 'returns boolean'
-          }
-        }
-      };
-
-      expect(RegistryConnectorAPI.ServiceRegistryClient.methods).toContain('register');
-    });
-
-    test('Orchestrator Connector requirements', () => {
-      const OrchestratorConnectorAPI = {
-        create: 'factory function',
-        WorkflowOrchestrator: {
-          constructor: ['config with mqClient, registryClient, apiMapper, cookbook'],
-          methods: [
-            'processWorkflowMessage'
-          ],
-          expectedBehavior: {
-            processWorkflowMessage: 'accepts (message, serviceName) returns Promise<result>'
-          }
-        }
-      };
-
-      expect(OrchestratorConnectorAPI.create).toBe('factory function');
-    });
-
-    test('API Mapper Connector requirements', () => {
-      const ApiMapperConnectorAPI = {
-        create: 'factory function',
-        ApiMapper: {
-          constructor: ['config with openApiSpec, serviceUrl'],
-          methods: [
-            'callOperation',
-            'mapOperationToEndpoint',
-            'transformRequest',
-            'transformResponse'
-          ]
-        }
-      };
-
-      expect(ApiMapperConnectorAPI.create).toBe('factory function');
-    });
-
-    test('Cookbook Connector requirements', () => {
-      const CookbookConnectorAPI = {
-        staticMethods: [
-          'validateCookbook',
-          'createRouter'
-        ],
-        classes: {
-          CookbookExecutor: 'for control flow execution',
-          CookbookGenerator: 'for generating cookbooks from OpenAPI',
-          ResponseMapper: 'for response transformation'
-        }
-      };
-
-      expect(CookbookConnectorAPI.staticMethods).toContain('validateCookbook');
-      expect(Object.keys(CookbookConnectorAPI.classes)).toContain('CookbookExecutor');
-    });
-  });
-
-  describe('Workflow Processing Flow', () => {
-    // This test documents the expected flow through connectors
-
-    test('should document the complete message flow', () => {
-      const messageFlow = [
-        {
-          step: 1,
-          description: 'Message arrives via MQ',
-          connector: 'MQConnector',
-          method: 'consume callback'
-        },
-        {
-          step: 2,
-          description: 'ServiceWrapper delegates to Orchestrator',
-          connector: 'OrchestratorConnector',
-          method: 'processWorkflowMessage'
-        },
-        {
-          step: 3,
-          description: 'Orchestrator validates cookbook',
-          connector: 'CookbookConnector',
-          method: 'validateCookbook'
-        },
-        {
-          step: 4,
-          description: 'Orchestrator checks cache (if available)',
-          connector: 'CacheConnector',
-          method: 'get'
-        },
-        {
-          step: 5,
-          description: 'Orchestrator calls service API',
-          connector: 'ApiMapperConnector',
-          method: 'callOperation'
-        },
-        {
-          step: 6,
-          description: 'Orchestrator stores result in cache',
-          connector: 'CacheConnector',
-          method: 'set'
-        },
-        {
-          step: 7,
-          description: 'Orchestrator routes to next step',
-          connector: 'MQConnector or CookbookRouter',
-          method: 'publish or routeToService'
-        }
-      ];
-
-      // Verify flow makes sense
-      expect(messageFlow).toHaveLength(7);
-      expect(messageFlow[0].connector).toBe('MQConnector');
-      expect(messageFlow[messageFlow.length - 1].description).toContain('routes to next');
-    });
-  });
-
-  describe('Error Handling Flow', () => {
-    test('should document error handling chain', () => {
-      const errorFlow = [
-        {
-          scenario: 'Message processing fails',
-          handler: 'OrchestratorConnector',
-          action: 'Catches error'
-        },
-        {
-          scenario: 'Error handler available',
-          handler: 'ErrorHandlerConnector',
-          action: 'handleError method'
-        },
-        {
-          scenario: 'No error handler',
-          handler: 'CookbookRouter',
-          action: 'routeToDLQ method'
-        },
-        {
-          scenario: 'Transient error',
-          handler: 'RetryHandler in Orchestrator',
-          action: 'Exponential backoff retry'
-        },
-        {
-          scenario: 'Service unavailable',
-          handler: 'CircuitBreaker in ApiMapper',
-          action: 'Circuit opens, fast fail'
-        }
-      ];
-
-      expect(errorFlow).toHaveLength(5);
-      expect(errorFlow.some(e => e.action.includes('DLQ'))).toBe(true);
-    });
-  });
-
-  describe('Missing Connector Detection', () => {
-    // These tests help identify what still needs to be implemented
-
-    test('should identify conn-base-cache is missing', () => {
-      try {
-        require('@onlineapps/conn-base-cache');
-        expect(true).toBe(false); // Should not reach here
-      } catch (error) {
-        expect(error.code).toBe('MODULE_NOT_FOUND');
-        console.log('TODO: Implement conn-base-cache connector');
-      }
-    });
-
-    test('should identify conn-infra-error-handler is missing', () => {
-      try {
-        require('@onlineapps/conn-infra-error-handler');
-        expect(true).toBe(false); // Should not reach here
-      } catch (error) {
-        expect(error.code).toBe('MODULE_NOT_FOUND');
-        console.log('TODO: Implement conn-infra-error-handler connector');
-      }
-    });
-
-    test('should verify cookbook connector exports', () => {
-      try {
-        const cookbook = require('@onlineapps/conn-orch-cookbook');
-
-        // Check required exports
-        const requiredExports = [
-          'validateCookbook',
-          'createRouter',
-          'CookbookExecutor',
-          'CookbookGenerator',
-          'ResponseMapper'
-        ];
-
-        const missingExports = requiredExports.filter(exp => !cookbook[exp]);
-
-        if (missingExports.length > 0) {
-          console.log('TODO: Cookbook connector missing exports:', missingExports);
-        }
-
-        expect(missingExports).toEqual([]);
-      } catch (error) {
-        console.log('TODO: Fix cookbook connector imports');
-        expect(error.code).toBe('MODULE_NOT_FOUND');
-      }
-    });
-  });
-});
-
-describe('Integration Test Helpers', () => {
-  // Helper functions for integration testing
-
-  test('should provide test utilities', () => {
-    const testUtils = {
-      createMockWorkflowMessage: (overrides = {}) => ({
-        workflow_id: 'test-wf-123',
-        cookbook: {
-          steps: [
-            {
-              id: 'step1',
-              type: 'task',
-              service: 'test-service',
-              operation: 'getTest',
-              input: { id: '123' }
-            }
-          ]
-        },
-        current_step: 'step1',
-        context: {},
-        ...overrides
-      }),
-
-      createMockOpenApiSpec: (paths = {}) => ({
-        openapi: '3.0.0',
-        info: {
-          title: 'Test Service',
-          version: '1.0.0'
-        },
-        paths: {
-          '/api/health': {
-            get: {
-              operationId: 'healthCheck',
-              responses: { '200': { description: 'OK' } }
-            }
-          },
-          ...paths
-        }
-      }),
-
-      waitForCondition: async (conditionFn, timeout = 5000) => {
-        const start = Date.now();
-        while (Date.now() - start < timeout) {
-          if (conditionFn()) {
-            return true;
-          }
-          await new Promise(resolve => setTimeout(resolve, 100));
-        }
-        throw new Error('Timeout waiting for condition');
-      }
-    };
-
-    // Test that utilities work
-    const message = testUtils.createMockWorkflowMessage();
-    expect(message.workflow_id).toBe('test-wf-123');
-
-    const spec = testUtils.createMockOpenApiSpec();
-    expect(spec.paths['/api/health']).toBeDefined();
-  });
-});

package/tests/component/connector-integration.test.js

@@ -1,293 +0,0 @@
-'use strict';
-
-/**
- * Integration tests for actual connectors
- * These tests verify that connectors work together correctly
- * Run these after implementing each connector
- */
-
-describe('Connector Integration Tests @component', () => {
-  describe('Orchestrator Connector', () => {
-    test.skip('should integrate with real Orchestrator connector', async () => {
-      // Enable this test after conn-orch-orchestrator is fully implemented
-      const OrchestratorConnector = require('@onlineapps/conn-orch-orchestrator');
-      const orchestrator = OrchestratorConnector.create({
-        mqClient: {}, // Mock or real MQ client
-        registryClient: {}, // Mock or real registry
-        apiMapper: {}, // Mock or real API mapper
-        cookbook: {}, // Mock or real cookbook
-        logger: console
-      });
-
-      expect(orchestrator).toBeDefined();
-      expect(orchestrator.processWorkflowMessage).toBeDefined();
-    });
-
-    test('should verify WorkflowOrchestrator API', () => {
-      // Document expected API
-      const expectedAPI = {
-        constructor: {
-          required: ['mqClient', 'registryClient', 'apiMapper', 'cookbook'],
-          optional: ['cache', 'errorHandler', 'logger', 'defaultTimeout']
-        },
-        publicMethods: [
-          'processWorkflowMessage',
-          'generateCookbook',
-          'transformResponse'
-        ],
-        privateMethods: [
-          '_executeStep',
-          '_executeTaskStep',
-          '_executeControlFlowStep',
-          '_routeToNextStep',
-          '_completeWorkflow',
-          '_getCacheKey'
-        ]
-      };
-
-      // This documents what we expect from the orchestrator
-      expect(expectedAPI.publicMethods).toContain('processWorkflowMessage');
-    });
-  });
-
-  describe('API Mapper Connector', () => {
-    test.skip('should integrate with real API Mapper connector', async () => {
-      // Enable this test after conn-orch-api-mapper is fully implemented
-      const ApiMapperConnector = require('@onlineapps/conn-orch-api-mapper');
-      const apiMapper = ApiMapperConnector.create({
-        openApiSpec: {
-          openapi: '3.0.0',
-          paths: {}
-        },
-        serviceUrl: 'http://localhost:3000',
-        logger: console
-      });
-
-      expect(apiMapper).toBeDefined();
-      expect(apiMapper.callOperation).toBeDefined();
-    });
-
-    test('should verify ApiMapper API', () => {
-      const expectedAPI = {
-        constructor: {
-          required: ['openApiSpec'],
-          optional: ['serviceUrl', 'service', 'directCall', 'logger', 'port']
-        },
-        publicMethods: [
-          'loadOpenApiSpec',
-          'mapOperationToEndpoint',
-          'transformRequest',
-          'transformResponse',
-          'callOperation'
-        ],
-        privateMethods: [
-          '_parseOpenApiSpec',
-          '_resolveVariables',
-          '_getValueFromPath',
-          '_buildRequest',
-          '_callDirectly',
-          '_callViaHttp'
-        ]
-      };
-
-      expect(expectedAPI.publicMethods).toContain('callOperation');
-    });
-  });
-
-  describe('Cookbook Connector', () => {
-    test('should identify missing exports in cookbook connector', () => {
-      // This test helps us know what to fix in cookbook connector
-      const requiredExports = {
-        functions: [
-          'validateCookbook',
-          'createRouter'
-        ],
-        classes: [
-          'CookbookExecutor',
-          'CookbookGenerator',
-          'ResponseMapper'
-        ]
-      };
-
-      console.log('Cookbook connector must export:');
-      console.log('Functions:', requiredExports.functions);
-      console.log('Classes:', requiredExports.classes);
-
-      // Document the expected behavior
-      const expectedBehaviors = {
-        validateCookbook: 'Validates cookbook JSON structure, throws on error',
-        createRouter: 'Creates router instance with MQ and registry clients',
-        CookbookExecutor: 'Executes control flow steps (foreach, switch, etc)',
-        CookbookGenerator: 'Generates cookbook from OpenAPI spec',
-        ResponseMapper: 'Maps/transforms API responses'
-      };
-
-      expect(Object.keys(expectedBehaviors)).toHaveLength(5);
-    });
-  });
-
-  describe('Missing Connectors', () => {
-    test('conn-base-cache requirements', () => {
-      const cacheConnectorAPI = {
-        purpose: 'Redis caching with namespace isolation',
-        methods: {
-          'get(key)': 'Returns cached value or null',
-          'set(key, value, options)': 'Stores value with optional TTL',
-          'delete(key)': 'Removes cached value',
-          'clear(pattern)': 'Clears keys matching pattern',
-          'exists(key)': 'Checks if key exists'
-        },
-        configuration: {
-          redis: 'Redis connection string or options',
-          namespace: 'Cache key prefix for isolation',
-          ttl: 'Default TTL in seconds',
-          serialization: 'JSON by default'
-        }
-      };
-
-      console.log('TODO: Implement conn-base-cache with:', cacheConnectorAPI);
-      expect(Object.keys(cacheConnectorAPI.methods)).toHaveLength(5);
-    });
-
-    test('conn-infra-error-handler requirements', () => {
-      const errorHandlerAPI = {
-        purpose: 'Unified error handling with strategies',
-        methods: {
-          'handleError(error, context)': 'Main error handling method',
-          'categorizeError(error)': 'Determines error type',
-          'shouldRetry(error)': 'Decides if error is retryable',
-          'formatError(error)': 'Standardizes error format',
-          'logError(error, level)': 'Structured error logging'
-        },
-        errorTypes: {
-          'TransientError': 'Temporary, retryable',
-          'BusinessError': 'Domain logic error',
-          'ValidationError': 'Input validation failed',
-          'SystemError': 'Infrastructure failure',
-          'FatalError': 'Non-recoverable'
-        },
-        strategies: {
-          'retry': 'Exponential backoff retry',
-          'dlq': 'Send to dead letter queue',
-          'alert': 'Trigger monitoring alert',
-          'fallback': 'Use fallback value',
-          'circuit-break': 'Open circuit breaker'
-        }
-      };
-
-      console.log('TODO: Implement conn-infra-error-handler with:', errorHandlerAPI);
-      expect(Object.keys(errorHandlerAPI.errorTypes)).toHaveLength(5);
-    });
-  });
-
-  describe('End-to-End Message Flow', () => {
-    test('should document complete message processing flow', async () => {
-      // This test documents the complete flow
-      const messageFlow = `
-        1. Message arrives at RabbitMQ queue 'service.workflow'
-        2. MQConnector receives message via consume callback
-        3. ServiceWrapper passes message to Orchestrator.processWorkflowMessage()
-        4. Orchestrator validates cookbook structure with CookbookConnector
-        5. Orchestrator finds current step in cookbook
-        6. Orchestrator checks if step is for this service
-        7. If cache available, check cache for result
-        8. If not cached, execute step:
-           - Task step: ApiMapper.callOperation()
-           - Control flow: CookbookExecutor.executeStep()
-        9. Store result in cache if available
-        10. Update workflow context with result
-        11. Determine next step
-        12. Route to next step or complete workflow
-      `;
-
-      console.log('Message Processing Flow:', messageFlow);
-      expect(messageFlow).toContain('Orchestrator');
-    });
-  });
-
-  describe('Performance Benchmarks', () => {
-    test('should define performance targets', () => {
-      const performanceTargets = {
-        messageProcessing: {
-          p50: 10, // ms
-          p95: 50,
-          p99: 100
-        },
-        startupTime: {
-          target: 1000, // ms
-          includes: [
-            'MQ connection',
-            'Registry registration',
-            'Orchestrator initialization'
-          ]
-        },
-        memoryUsage: {
-          baseline: 50, // MB
-          perMessage: 0.5 // MB
-        },
-        throughput: {
-          messagesPerSecond: 100,
-          withPrefetch: 10
-        }
-      };
-
-      console.log('Performance targets:', performanceTargets);
-      expect(performanceTargets.messageProcessing.p50).toBeLessThan(20);
-    });
-  });
-});
-
-describe('Test Utilities', () => {
-  test('should provide connector test helpers', () => {
-    const testHelpers = {
-      /**
-       * Create a test wrapper with all mocked dependencies
-       */
-      createTestWrapper: (overrides = {}) => {
-        const ServiceWrapper = require('../../src/ServiceWrapper');
-        return new ServiceWrapper({
-          service: overrides.service || jest.fn(),
-          serviceName: overrides.serviceName || 'test-service',
-          openApiSpec: overrides.openApiSpec || {
-            openapi: '3.0.0',
-            paths: {}
-          },
-          config: overrides.config || {}
-        });
-      },
-
-      /**
-       * Wait for message to be processed
-       */
-      waitForMessage: async (wrapper, timeout = 1000) => {
-        const start = Date.now();
-        while (Date.now() - start < timeout) {
-          if (wrapper.orchestrator?.processedMessages?.length > 0) {
-            return true;
-          }
-          await new Promise(r => setTimeout(r, 10));
-        }
-        return false;
-      },
-
-      /**
-       * Create mock Express app with test endpoints
-       */
-      createMockApp: () => {
-        const express = require('express');
-        const app = express();
-        app.use(express.json());
-
-        app.get('/api/health', (req, res) => {
-          res.json({ status: 'healthy' });
-        });
-
-        return app;
-      }
-    };
-
-    // Test the helpers work
-    const wrapper = testHelpers.createTestWrapper();
-    expect(wrapper.serviceName).toBe('test-service');
-  });
-});