@onlineapps/conn-orch-orchestrator 1.0.0

package/test/component/orchestrator.component.test.js

@@ -0,0 +1,378 @@
+'use strict';
+
+/**
+ * Component tests for Orchestrator
+ * Tests orchestrator with real internal components but mocked external services
+ */
+
+const WorkflowOrchestrator = require('../../src/WorkflowOrchestrator');
+
+describe('Orchestrator - Component Tests', () => {
+  let orchestrator;
+  let mqClientStub;
+  let registryClientStub;
+  let apiMapperStub;
+
+  beforeEach(() => {
+    // Create stubbed versions of external dependencies
+    // that simulate real behavior
+    mqClientStub = {
+      connected: true,
+      queues: new Map(),
+
+      publish: jest.fn(async (message, options) => {
+        // Simulate message publishing
+        const queueName = options.queue || 'default';
+        if (!mqClientStub.queues.has(queueName)) {
+          mqClientStub.queues.set(queueName, []);
+        }
+        mqClientStub.queues.get(queueName).push(message);
+        return { published: true };
+      }),
+
+      consume: jest.fn(async (handler, options) => {
+        // Store handler for later invocation
+        mqClientStub.handler = handler;
+        return { consuming: true };
+      }),
+
+      isConnected: () => mqClientStub.connected
+    };
+
+    registryClientStub = {
+      services: new Map([
+        ['test-service', {
+          name: 'test-service',
+          url: 'http://localhost:3000',
+          openapi: {
+            openapi: '3.0.0',
+            paths: {
+              '/test': {
+                post: {
+                  operationId: 'testOp',
+                  requestBody: {
+                    content: {
+                      'application/json': {
+                        schema: { type: 'object' }
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }],
+        ['invoice-service', {
+          name: 'invoice-service',
+          url: 'http://localhost:3001',
+          openapi: {}
+        }]
+      ]),
+
+      getService: jest.fn(async (serviceName) => {
+        return registryClientStub.services.get(serviceName);
+      }),
+
+      getAllServices: jest.fn(async () => {
+        return Array.from(registryClientStub.services.values());
+      })
+    };
+
+    apiMapperStub = {
+      operations: new Map(),
+
+      callOperation: jest.fn(async (operationId, input, context) => {
+        // Simulate successful API call
+        return {
+          status: 200,
+          data: {
+            operationId,
+            input,
+            result: `Processed ${operationId}`
+          }
+        };
+      }),
+
+      parseOpenApi: jest.fn((spec) => {
+        // Extract operations from OpenAPI spec
+        const operations = {};
+        if (spec.paths) {
+          Object.entries(spec.paths).forEach(([path, methods]) => {
+            Object.entries(methods).forEach(([method, op]) => {
+              if (op.operationId) {
+                operations[op.operationId] = { path, method, ...op };
+              }
+            });
+          });
+        }
+        return operations;
+      })
+    };
+
+    // Create orchestrator with component stubs
+    orchestrator = new WorkflowOrchestrator({
+      mqClient: mqClientStub,
+      registryClient: registryClientStub,
+      apiMapper: apiMapperStub,
+      cookbook: {
+        validateCookbook: jest.fn(),
+        CookbookExecutor: class {
+          execute() {
+            return Promise.resolve({ results: {} });
+          }
+        }
+      },
+      logger: {
+        info: jest.fn(),
+        error: jest.fn(),
+        warn: jest.fn(),
+        debug: jest.fn()
+      }
+    });
+  });
+
+  describe('Workflow Processing', () => {
+    it('should process a complete workflow with multiple steps', async () => {
+      const workflow = {
+        workflow_id: 'wf-test-123',
+        current_step: {
+          id: 'step1',
+          service: 'test-service',
+          operation: 'testOp',
+          input: { value: 100 },
+          output: 'step1Result'
+        },
+        next_steps: [
+          {
+            id: 'step2',
+            service: 'invoice-service',
+            operation: 'createInvoice',
+            input: {
+              amount: '{{step1Result.value}}'
+            }
+          }
+        ],
+        context: {
+          variables: { customerId: 'cust-123' },
+          results: {}
+        }
+      };
+
+      // Process first step
+      const result = await orchestrator.processWorkflowMessage(workflow, 'test-service');
+
+      expect(result).toBeDefined();
+      expect(apiMapperStub.callOperation).toHaveBeenCalledWith(
+        'testOp',
+        { value: 100 },
+        expect.any(Object)
+      );
+
+      // Verify message was routed to next service
+      if (workflow.next_steps && workflow.next_steps.length > 0) {
+        expect(mqClientStub.publish).toHaveBeenCalledWith(
+          expect.objectContaining({
+            workflow_id: 'wf-test-123',
+            current_step: expect.objectContaining({
+              service: 'invoice-service'
+            })
+          }),
+          expect.objectContaining({
+            queue: 'invoice-service.workflow'
+          })
+        );
+      }
+    });
+
+    it('should handle parallel step execution', async () => {
+      const workflow = {
+        workflow_id: 'wf-parallel-123',
+        current_step: {
+          id: 'fork',
+          type: 'parallel',
+          steps: [
+            {
+              id: 'parallel1',
+              service: 'test-service',
+              operation: 'op1'
+            },
+            {
+              id: 'parallel2',
+              service: 'test-service',
+              operation: 'op2'
+            }
+          ]
+        },
+        context: {}
+      };
+
+      await orchestrator.processWorkflowMessage(workflow, 'test-service');
+
+      // Both operations should be called
+      expect(apiMapperStub.callOperation).toHaveBeenCalledTimes(2);
+    });
+
+    it('should handle conditional routing', async () => {
+      const workflow = {
+        workflow_id: 'wf-conditional-123',
+        current_step: {
+          id: 'decision',
+          service: 'test-service',
+          operation: 'checkCondition',
+          input: { threshold: 50 },
+          output: 'decision'
+        },
+        next_steps: [
+          {
+            id: 'highPath',
+            condition: '{{decision.value}} > 50',
+            service: 'invoice-service',
+            operation: 'highValue'
+          },
+          {
+            id: 'lowPath',
+            condition: '{{decision.value}} <= 50',
+            service: 'invoice-service',
+            operation: 'lowValue'
+          }
+        ],
+        context: {}
+      };
+
+      // Mock API response
+      apiMapperStub.callOperation.mockResolvedValueOnce({
+        status: 200,
+        data: { value: 75 }
+      });
+
+      await orchestrator.processWorkflowMessage(workflow, 'test-service');
+
+      // Should route to high value path
+      expect(mqClientStub.publish).toHaveBeenCalledWith(
+        expect.objectContaining({
+          current_step: expect.objectContaining({
+            operation: 'highValue'
+          })
+        }),
+        expect.any(Object)
+      );
+    });
+  });
+
+  describe('Error Handling', () => {
+    it('should handle service unavailable gracefully', async () => {
+      registryClientStub.getService.mockResolvedValueOnce(null);
+
+      const workflow = {
+        workflow_id: 'wf-error-123',
+        current_step: {
+          service: 'unknown-service',
+          operation: 'test'
+        }
+      };
+
+      await expect(
+        orchestrator.processWorkflowMessage(workflow, 'unknown-service')
+      ).rejects.toThrow();
+    });
+
+    it('should handle API call failures', async () => {
+      apiMapperStub.callOperation.mockRejectedValueOnce(
+        new Error('Connection refused')
+      );
+
+      const workflow = {
+        workflow_id: 'wf-api-error-123',
+        current_step: {
+          service: 'test-service',
+          operation: 'failingOp'
+        }
+      };
+
+      await expect(
+        orchestrator.processWorkflowMessage(workflow, 'test-service')
+      ).rejects.toThrow('Connection refused');
+    });
+
+    it('should handle malformed workflows', async () => {
+      const malformedWorkflow = {
+        // Missing required fields
+        workflow_id: 'wf-malformed-123'
+      };
+
+      await expect(
+        orchestrator.processWorkflowMessage(malformedWorkflow, 'test-service')
+      ).rejects.toThrow();
+    });
+  });
+
+  describe('Context Management', () => {
+    it('should maintain context across steps', async () => {
+      const workflow = {
+        workflow_id: 'wf-context-123',
+        current_step: {
+          id: 'step1',
+          service: 'test-service',
+          operation: 'addContext',
+          input: { newData: 'test' },
+          output: 'contextData'
+        },
+        context: {
+          variables: { existing: 'data' },
+          results: {}
+        }
+      };
+
+      await orchestrator.processWorkflowMessage(workflow, 'test-service');
+
+      // Context should be preserved in routed message
+      expect(mqClientStub.publish).toHaveBeenCalledWith(
+        expect.objectContaining({
+          context: expect.objectContaining({
+            variables: expect.objectContaining({
+              existing: 'data'
+            })
+          })
+        }),
+        expect.any(Object)
+      );
+    });
+
+    it('should accumulate results in context', async () => {
+      const workflow = {
+        workflow_id: 'wf-results-123',
+        current_step: {
+          id: 'step2',
+          service: 'test-service',
+          operation: 'process',
+          output: 'step2Result'
+        },
+        context: {
+          results: {
+            step1Result: { previous: 'data' }
+          }
+        }
+      };
+
+      apiMapperStub.callOperation.mockResolvedValueOnce({
+        status: 200,
+        data: { new: 'result' }
+      });
+
+      await orchestrator.processWorkflowMessage(workflow, 'test-service');
+
+      // Results should accumulate
+      expect(mqClientStub.publish).toHaveBeenCalledWith(
+        expect.objectContaining({
+          context: expect.objectContaining({
+            results: expect.objectContaining({
+              step1Result: { previous: 'data' },
+              step2Result: { new: 'result' }
+            })
+          })
+        }),
+        expect.any(Object)
+      );
+    });
+  });
+});

package/test/integration/orchestrator.integration.test.js

@@ -0,0 +1,313 @@
+'use strict';
+
+/**
+ * Integration tests for Orchestrator
+ * Tests orchestrator with real external services (when available)
+ */
+
+const WorkflowOrchestrator = require('../../src');
+const MQConnector = require('@onlineapps/conn-infra-mq');
+const RegistryConnector = require('@onlineapps/conn-orch-registry');
+const ApiMapperConnector = require('@onlineapps/conn-orch-api-mapper');
+const CookbookConnector = require('@onlineapps/conn-orch-cookbook');
+
+// Skip integration tests if external services are not available
+const SKIP_INTEGRATION = process.env.SKIP_INTEGRATION === 'true';
+const RABBITMQ_URL = process.env.RABBITMQ_URL || 'amqp://localhost:5672';
+const REGISTRY_URL = process.env.REGISTRY_URL || 'http://localhost:4000';
+
+describe('Orchestrator - Integration Tests', () => {
+  if (SKIP_INTEGRATION) {
+    it.skip('Skipping integration tests (SKIP_INTEGRATION=true)', () => {});
+    return;
+  }
+
+  let orchestrator;
+  let mqClient;
+  let registryClient;
+
+  beforeAll(async () => {
+    // Setup real connections
+    try {
+      mqClient = new MQConnector({
+        url: RABBITMQ_URL,
+        serviceName: 'test-orchestrator'
+      });
+      await mqClient.connect();
+
+      registryClient = new RegistryConnector.ServiceRegistryClient({
+        registryUrl: REGISTRY_URL
+      });
+
+      // Register test service
+      await registryClient.register({
+        name: 'test-orchestrator',
+        url: 'http://localhost:9999',
+        openapi: {
+          openapi: '3.0.0',
+          info: { title: 'Test Service', version: '1.0.0' },
+          paths: {
+            '/echo': {
+              post: {
+                operationId: 'echo',
+                requestBody: {
+                  content: {
+                    'application/json': {
+                      schema: { type: 'object' }
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      });
+    } catch (error) {
+      console.warn('Failed to setup integration test environment:', error.message);
+      console.warn('Skipping integration tests');
+      return;
+    }
+  });
+
+  afterAll(async () => {
+    // Cleanup
+    if (orchestrator) {
+      await orchestrator.shutdown();
+    }
+    if (registryClient) {
+      await registryClient.unregister('test-orchestrator');
+    }
+    if (mqClient) {
+      await mqClient.disconnect();
+    }
+  });
+
+  beforeEach(() => {
+    const apiMapper = ApiMapperConnector.create({
+      openApiSpec: {
+        openapi: '3.0.0',
+        paths: {
+          '/echo': {
+            post: {
+              operationId: 'echo'
+            }
+          }
+        }
+      },
+      serviceUrl: 'http://localhost:9999'
+    });
+
+    orchestrator = WorkflowOrchestrator.create({
+      mqClient,
+      registryClient,
+      apiMapper,
+      cookbook: CookbookConnector,
+      logger: {
+        info: jest.fn(),
+        error: jest.fn(),
+        warn: jest.fn(),
+        debug: jest.fn()
+      }
+    });
+  });
+
+  describe('End-to-End Workflow Execution', () => {
+    it('should execute a simple workflow end-to-end', async () => {
+      const workflow = {
+        workflow_id: 'int-test-' + Date.now(),
+        current_step: {
+          id: 'step1',
+          service: 'test-orchestrator',
+          operation: 'echo',
+          input: { message: 'Hello Integration Test' },
+          output: 'echoResult'
+        },
+        context: {
+          variables: {},
+          results: {}
+        }
+      };
+
+      // Mock the actual HTTP call since we don't have a real service
+      orchestrator.apiMapper.callOperation = jest.fn().mockResolvedValue({
+        status: 200,
+        data: { echoed: 'Hello Integration Test' }
+      });
+
+      const result = await orchestrator.processWorkflowMessage(
+        workflow,
+        'test-orchestrator'
+      );
+
+      expect(result).toBeDefined();
+      expect(result.data).toHaveProperty('echoed');
+    });
+
+    it('should handle message routing through RabbitMQ', async () => {
+      const testQueue = 'test.integration.queue';
+
+      // Setup consumer
+      let receivedMessage = null;
+      await mqClient.consume(
+        (message) => {
+          receivedMessage = message;
+          return Promise.resolve();
+        },
+        { queue: testQueue }
+      );
+
+      // Send message through orchestrator
+      const workflow = {
+        workflow_id: 'route-test-' + Date.now(),
+        current_step: {
+          id: 'route',
+          service: 'test-orchestrator',
+          operation: 'echo',
+          input: { test: 'data' }
+        },
+        next_steps: [
+          {
+            id: 'next',
+            service: 'next-service',
+            operation: 'process'
+          }
+        ],
+        context: {}
+      };
+
+      // Mock the API call
+      orchestrator.apiMapper.callOperation = jest.fn().mockResolvedValue({
+        status: 200,
+        data: { processed: true }
+      });
+
+      // Override routing to use test queue
+      orchestrator.routeToNextStep = async (workflowId, step, context) => {
+        await mqClient.publish(
+          { workflow_id: workflowId, current_step: step, context },
+          { queue: testQueue }
+        );
+      };
+
+      await orchestrator.processWorkflowMessage(workflow, 'test-orchestrator');
+
+      // Wait for message to be received
+      await new Promise(resolve => setTimeout(resolve, 100));
+
+      expect(receivedMessage).toBeTruthy();
+      expect(receivedMessage.workflow_id).toBe(workflow.workflow_id);
+    });
+
+    it('should interact with registry for service discovery', async () => {
+      // Get service info from registry
+      const serviceInfo = await registryClient.getService('test-orchestrator');
+
+      expect(serviceInfo).toBeDefined();
+      expect(serviceInfo.name).toBe('test-orchestrator');
+      expect(serviceInfo.openapi).toBeDefined();
+    });
+  });
+
+  describe('Fault Tolerance', () => {
+    it('should handle temporary network failures', async () => {
+      // Simulate network failure
+      orchestrator.apiMapper.callOperation = jest.fn()
+        .mockRejectedValueOnce(new Error('ECONNREFUSED'))
+        .mockResolvedValueOnce({ status: 200, data: { ok: true } });
+
+      const workflow = {
+        workflow_id: 'retry-test-' + Date.now(),
+        current_step: {
+          service: 'test-orchestrator',
+          operation: 'echo',
+          retry: { max: 3, delay: 100 }
+        }
+      };
+
+      // With retry logic (if implemented)
+      const result = await orchestrator.processWorkflowMessage(
+        workflow,
+        'test-orchestrator'
+      ).catch(e => e);
+
+      // Should eventually succeed or fail after retries
+      expect(orchestrator.apiMapper.callOperation).toHaveBeenCalled();
+    });
+
+    it('should handle message acknowledgment correctly', async () => {
+      const workflow = {
+        workflow_id: 'ack-test-' + Date.now(),
+        current_step: {
+          service: 'test-orchestrator',
+          operation: 'echo'
+        }
+      };
+
+      orchestrator.apiMapper.callOperation = jest.fn()
+        .mockResolvedValue({ status: 200, data: {} });
+
+      await orchestrator.processWorkflowMessage(workflow, 'test-orchestrator');
+
+      // Message should be processed without errors
+      expect(orchestrator.apiMapper.callOperation).toHaveBeenCalled();
+    });
+  });
+
+  describe('Performance', () => {
+    it('should handle multiple concurrent workflows', async () => {
+      const workflows = Array.from({ length: 10 }, (_, i) => ({
+        workflow_id: `perf-test-${Date.now()}-${i}`,
+        current_step: {
+          service: 'test-orchestrator',
+          operation: 'echo',
+          input: { index: i }
+        }
+      }));
+
+      orchestrator.apiMapper.callOperation = jest.fn()
+        .mockResolvedValue({ status: 200, data: {} });
+
+      const startTime = Date.now();
+
+      await Promise.all(
+        workflows.map(w =>
+          orchestrator.processWorkflowMessage(w, 'test-orchestrator')
+        )
+      );
+
+      const duration = Date.now() - startTime;
+
+      expect(orchestrator.apiMapper.callOperation).toHaveBeenCalledTimes(10);
+      expect(duration).toBeLessThan(5000); // Should complete within 5 seconds
+    });
+
+    it('should not leak memory during long-running operations', async () => {
+      const initialMemory = process.memoryUsage().heapUsed;
+
+      // Process many workflows
+      for (let i = 0; i < 100; i++) {
+        const workflow = {
+          workflow_id: `mem-test-${i}`,
+          current_step: {
+            service: 'test-orchestrator',
+            operation: 'echo',
+            input: { data: 'x'.repeat(1000) } // 1KB of data
+          }
+        };
+
+        orchestrator.apiMapper.callOperation = jest.fn()
+          .mockResolvedValue({ status: 200, data: {} });
+
+        await orchestrator.processWorkflowMessage(workflow, 'test-orchestrator');
+      }
+
+      global.gc && global.gc(); // Force garbage collection if available
+
+      const finalMemory = process.memoryUsage().heapUsed;
+      const memoryGrowth = finalMemory - initialMemory;
+
+      // Memory growth should be reasonable (< 50MB)
+      expect(memoryGrowth).toBeLessThan(50 * 1024 * 1024);
+    });
+  });
+});