tests

libs/core/handler-registry/test/registry-comprehensive.test.ts

@@ -19,17 +19,16 @@ describe('HandlerRegistry Comprehensive Tests', () => {
       const metadata: HandlerMetadata = {
         name: 'TestHandler',
         service: 'test-service',
-        operations: {
-          processData: {
+        operations: [
+          {
             name: 'processData',
-            batch: false,
+            method: 'processData',
           },
-          batchProcess: {
+          {
             name: 'batchProcess',
-            batch: true,
-            batchSize: 10,
+            method: 'batchProcess',
           },
-        },
+        ],
       };
 
       registry.registerMetadata(metadata);
@@ -42,17 +41,17 @@ describe('HandlerRegistry Comprehensive Tests', () => {
       const metadata1: HandlerMetadata = {
         name: 'TestHandler',
         service: 'service1',
-        operations: {
-          op1: { name: 'op1', batch: false },
-        },
+        operations: [
+          { name: 'op1', method: 'op1' },
+        ],
       };
 
       const metadata2: HandlerMetadata = {
         name: 'TestHandler',
         service: 'service2',
-        operations: {
-          op2: { name: 'op2', batch: false },
-        },
+        operations: [
+          { name: 'op2', method: 'op2' },
+        ],
       };
 
       registry.registerMetadata(metadata1);
@@ -66,11 +65,14 @@ describe('HandlerRegistry Comprehensive Tests', () => {
   describe('registerConfiguration', () => {
     it('should register handler configuration separately', () => {
       const config: HandlerConfiguration = {
-        processData: async (data: any) => ({ processed: data }),
-        batchProcess: async (items: any[]) => items.map(i => ({ processed: i })),
+        name: 'TestHandler',
+        operations: {
+          processData: async (data: unknown) => ({ processed: data }),
+          batchProcess: async (items: unknown[]) => items.map(i => ({ processed: i })),
+        },
       };
 
-      registry.registerConfiguration('TestHandler', config);
+      registry.registerConfiguration(config);
       
       const retrieved = registry.getConfiguration('TestHandler');
       expect(retrieved).toEqual(config);
@@ -78,13 +80,16 @@ describe('HandlerRegistry Comprehensive Tests', () => {
 
     it('should handle async operations', async () => {
       const config: HandlerConfiguration = {
-        asyncOp: async (data: any) => {
-          await new Promise(resolve => setTimeout(resolve, 10));
-          return { result: data };
+        name: 'AsyncHandler',
+        operations: {
+          asyncOp: async (data: unknown) => {
+            await new Promise(resolve => setTimeout(resolve, 10));
+            return { result: data };
+          },
         },
       };
 
-      registry.registerConfiguration('AsyncHandler', config);
+      registry.registerConfiguration(config);
       
       const operation = registry.getOperation('AsyncHandler', 'asyncOp');
       expect(operation).toBeDefined();
@@ -99,9 +104,9 @@ describe('HandlerRegistry Comprehensive Tests', () => {
       const metadata: HandlerMetadata = {
         name: 'MetaHandler',
         service: 'meta-service',
-        operations: {
-          metaOp: { name: 'metaOp', batch: false },
-        },
+        operations: [
+          { name: 'metaOp', method: 'metaOp' },
+        ],
       };
 
       registry.registerMetadata(metadata);
@@ -118,32 +123,38 @@ describe('HandlerRegistry Comprehensive Tests', () => {
 
   describe('getServiceHandlers', () => {
     it('should return handlers for a specific service', () => {
-      registry.register({
-        metadata: {
-          name: 'Handler1',
-          service: 'service-a',
-          operations: {},
-        },
-        configuration: {},
-      });
+      const metadata1: HandlerMetadata = {
+        name: 'Handler1',
+        service: 'service-a',
+        operations: [],
+      };
+      const config1: HandlerConfiguration = {
+        name: 'Handler1',
+        operations: {},
+      };
+      registry.register(metadata1, config1);
 
-      registry.register({
-        metadata: {
-          name: 'Handler2',
-          service: 'service-a',
-          operations: {},
-        },
-        configuration: {},
-      });
+      const metadata2: HandlerMetadata = {
+        name: 'Handler2',
+        service: 'service-a',
+        operations: [],
+      };
+      const config2: HandlerConfiguration = {
+        name: 'Handler2',
+        operations: {},
+      };
+      registry.register(metadata2, config2);
 
-      registry.register({
-        metadata: {
-          name: 'Handler3',
-          service: 'service-b',
-          operations: {},
-        },
-        configuration: {},
-      });
+      const metadata3: HandlerMetadata = {
+        name: 'Handler3',
+        service: 'service-b',
+        operations: [],
+      };
+      const config3: HandlerConfiguration = {
+        name: 'Handler3',
+        operations: {},
+      };
+      registry.register(metadata3, config3);
 
       const serviceAHandlers = registry.getServiceHandlers('service-a');
       expect(serviceAHandlers).toHaveLength(2);
@@ -163,13 +174,15 @@ describe('HandlerRegistry Comprehensive Tests', () => {
 
   describe('setHandlerService and getHandlerService', () => {
     it('should set and get handler service ownership', () => {
-      registry.register({
-        metadata: {
-          name: 'ServiceHandler',
-          operations: {},
-        },
-        configuration: {},
-      });
+      const metadata: HandlerMetadata = {
+        name: 'ServiceHandler',
+        operations: [],
+      };
+      const config: HandlerConfiguration = {
+        name: 'ServiceHandler',
+        operations: {},
+      };
+      registry.register(metadata, config);
 
       registry.setHandlerService('ServiceHandler', 'my-service');
       
@@ -178,14 +191,16 @@ describe('HandlerRegistry Comprehensive Tests', () => {
     });
 
     it('should overwrite existing service ownership', () => {
-      registry.register({
-        metadata: {
-          name: 'ServiceHandler',
-          service: 'initial-service',
-          operations: {},
-        },
-        configuration: {},
-      });
+      const metadata: HandlerMetadata = {
+        name: 'ServiceHandler',
+        service: 'initial-service',
+        operations: [],
+      };
+      const config: HandlerConfiguration = {
+        name: 'ServiceHandler',
+        operations: {},
+      };
+      registry.register(metadata, config);
 
       registry.setHandlerService('ServiceHandler', 'new-service');
       
@@ -203,44 +218,62 @@ describe('HandlerRegistry Comprehensive Tests', () => {
     it('should return scheduled jobs for a handler', () => {
       const schedules: ScheduleMetadata[] = [
         {
-          operationName: 'dailyJob',
-          schedule: '0 0 * * *',
-          options: { timezone: 'UTC' },
+          operation: 'dailyJob',
+          cronPattern: '0 0 * * *',
+          priority: 1,
         },
         {
-          operationName: 'hourlyJob',
-          schedule: '0 * * * *',
+          operation: 'hourlyJob',
+          cronPattern: '0 * * * *',
         },
       ];
 
-      registry.register({
-        metadata: {
-          name: 'ScheduledHandler',
-          operations: {
-            dailyJob: { name: 'dailyJob', batch: false },
-            hourlyJob: { name: 'hourlyJob', batch: false },
-          },
-          schedules,
-        },
-        configuration: {
+      const metadata: HandlerMetadata = {
+        name: 'ScheduledHandler',
+        operations: [
+          { name: 'dailyJob', method: 'dailyJob' },
+          { name: 'hourlyJob', method: 'hourlyJob' },
+        ],
+        schedules,
+      };
+      const config: HandlerConfiguration = {
+        name: 'ScheduledHandler',
+        operations: {
           dailyJob: async () => ({ result: 'daily' }),
           hourlyJob: async () => ({ result: 'hourly' }),
         },
-      });
+        scheduledJobs: [
+          {
+            type: 'dailyJob',
+            operation: 'dailyJob',
+            cronPattern: '0 0 * * *',
+            priority: 1,
+          },
+          {
+            type: 'hourlyJob',
+            operation: 'hourlyJob',
+            cronPattern: '0 * * * *',
+          },
+        ],
+      };
+      registry.register(metadata, config);
 
       const jobs = registry.getScheduledJobs('ScheduledHandler');
       expect(jobs).toHaveLength(2);
-      expect(jobs).toEqual(schedules);
+      expect(jobs[0].type).toBe('dailyJob');
+      expect(jobs[1].type).toBe('hourlyJob');
     });
 
     it('should return empty array for handler without schedules', () => {
-      registry.register({
-        metadata: {
-          name: 'NoScheduleHandler',
-          operations: {},
-        },
-        configuration: {},
-      });
+      const metadata: HandlerMetadata = {
+        name: 'NoScheduleHandler',
+        operations: [],
+      };
+      const config: HandlerConfiguration = {
+        name: 'NoScheduleHandler',
+        operations: {},
+      };
+      registry.register(metadata, config);
 
       const jobs = registry.getScheduledJobs('NoScheduleHandler');
       expect(jobs).toEqual([]);
@@ -255,125 +288,132 @@ describe('HandlerRegistry Comprehensive Tests', () => {
   describe('getStats', () => {
     it('should return registry statistics', () => {
       // Register handlers with various configurations
-      registry.register({
-        metadata: {
-          name: 'Handler1',
-          service: 'service-a',
-          operations: {
-            op1: { name: 'op1', batch: false },
-            op2: { name: 'op2', batch: true, batchSize: 5 },
-          },
-          schedules: [
-            { operationName: 'op1', schedule: '0 0 * * *' },
-          ],
-        },
-        configuration: {
+      const metadata1: HandlerMetadata = {
+        name: 'Handler1',
+        service: 'service-a',
+        operations: [
+          { name: 'op1', method: 'op1' },
+          { name: 'op2', method: 'op2' },
+        ],
+        schedules: [
+          { operation: 'op1', cronPattern: '0 0 * * *' },
+        ],
+      };
+      const config1: HandlerConfiguration = {
+        name: 'Handler1',
+        operations: {
           op1: async () => ({}),
           op2: async () => ({}),
         },
-      });
+      };
+      registry.register(metadata1, config1);
 
-      registry.register({
-        metadata: {
-          name: 'Handler2',
-          service: 'service-b',
-          operations: {
-            op3: { name: 'op3', batch: false },
-          },
-        },
-        configuration: {
+      const metadata2: HandlerMetadata = {
+        name: 'Handler2',
+        service: 'service-b',
+        operations: [
+          { name: 'op3', method: 'op3' },
+        ],
+      };
+      const config2: HandlerConfiguration = {
+        name: 'Handler2',
+        operations: {
           op3: async () => ({}),
         },
-      });
+      };
+      registry.register(metadata2, config2);
 
       const stats = registry.getStats();
       
-      expect(stats.totalHandlers).toBe(2);
-      expect(stats.totalOperations).toBe(3);
-      expect(stats.batchOperations).toBe(1);
-      expect(stats.scheduledOperations).toBe(1);
-      expect(stats.handlersByService).toEqual({
-        'service-a': 1,
-        'service-b': 1,
-      });
+      expect(stats.handlers).toBe(2);
+      expect(stats.operations).toBe(3);
+      expect(stats.scheduledJobs).toBe(1);
+      expect(stats.services).toBe(2);
     });
 
     it('should return zero stats for empty registry', () => {
       const stats = registry.getStats();
       
-      expect(stats.totalHandlers).toBe(0);
-      expect(stats.totalOperations).toBe(0);
-      expect(stats.batchOperations).toBe(0);
-      expect(stats.scheduledOperations).toBe(0);
-      expect(stats.handlersByService).toEqual({});
+      expect(stats.handlers).toBe(0);
+      expect(stats.operations).toBe(0);
+      expect(stats.scheduledJobs).toBe(0);
+      expect(stats.services).toBe(0);
     });
   });
 
   describe('clear', () => {
     it('should clear all registrations', () => {
-      registry.register({
-        metadata: {
-          name: 'Handler1',
-          operations: {},
-        },
-        configuration: {},
-      });
+      const metadata1: HandlerMetadata = {
+        name: 'Handler1',
+        operations: [],
+      };
+      const config1: HandlerConfiguration = {
+        name: 'Handler1',
+        operations: {},
+      };
+      registry.register(metadata1, config1);
 
-      registry.register({
-        metadata: {
-          name: 'Handler2',
-          operations: {},
-        },
-        configuration: {},
-      });
+      const metadata2: HandlerMetadata = {
+        name: 'Handler2',
+        operations: [],
+      };
+      const config2: HandlerConfiguration = {
+        name: 'Handler2',
+        operations: {},
+      };
+      registry.register(metadata2, config2);
 
       expect(registry.getHandlerNames()).toHaveLength(2);
       
       registry.clear();
       
       expect(registry.getHandlerNames()).toHaveLength(0);
-      expect(registry.getAllMetadata()).toEqual([]);
-      expect(registry.getStats().totalHandlers).toBe(0);
+      expect(registry.getAllMetadata().size).toBe(0);
+      expect(registry.getStats().handlers).toBe(0);
     });
   });
 
   describe('export and import', () => {
     it('should export and import registry data', () => {
       // Setup initial registry
-      registry.register({
-        metadata: {
-          name: 'ExportHandler1',
-          service: 'export-service',
-          operations: {
-            exportOp: { name: 'exportOp', batch: false },
-          },
-          schedules: [
-            { operationName: 'exportOp', schedule: '0 0 * * *' },
-          ],
-        },
-        configuration: {
+      const metadata1: HandlerMetadata = {
+        name: 'ExportHandler1',
+        service: 'export-service',
+        operations: [
+          { name: 'exportOp', method: 'exportOp' },
+        ],
+        schedules: [
+          { operation: 'exportOp', cronPattern: '0 0 * * *' },
+        ],
+      };
+      const config1: HandlerConfiguration = {
+        name: 'ExportHandler1',
+        operations: {
           exportOp: async () => ({ exported: true }),
         },
-      });
+      };
+      registry.register(metadata1, config1);
 
-      registry.register({
-        metadata: {
-          name: 'ExportHandler2',
-          operations: {
-            anotherOp: { name: 'anotherOp', batch: true, batchSize: 10 },
-          },
-        },
-        configuration: {
+      const metadata2: HandlerMetadata = {
+        name: 'ExportHandler2',
+        operations: [
+          { name: 'anotherOp', method: 'anotherOp' },
+        ],
+      };
+      const config2: HandlerConfiguration = {
+        name: 'ExportHandler2',
+        operations: {
           anotherOp: async () => ({ another: true }),
         },
-      });
+      };
+      registry.register(metadata2, config2);
 
       // Export data
       const exportedData = registry.export();
       
       expect(exportedData.handlers).toHaveLength(2);
-      expect(exportedData.version).toBe('1.0');
-      expect(exportedData.exportedAt).toBeInstanceOf(Date);
+      expect(exportedData.configurations).toHaveLength(2);
+      expect(exportedData.services).toHaveLength(1); // Only ExportHandler1 has a service
       
       // Clear and verify empty
       registry.clear();
@@ -392,15 +432,15 @@ describe('HandlerRegistry Comprehensive Tests', () => {
       expect(handler1?.schedules).toHaveLength(1);
       
       const handler2 = registry.getMetadata('ExportHandler2');
-      expect(handler2?.operations.anotherOp.batch).toBe(true);
-      expect(handler2?.operations.anotherOp.batchSize).toBe(10);
+      expect(handler2?.operations).toHaveLength(1);
+      expect(handler2?.operations[0].name).toBe('anotherOp');
     });
 
     it('should handle import with empty data', () => {
       const emptyData = {
-        version: '1.0',
-        exportedAt: new Date(),
         handlers: [],
+        configurations: [],
+        services: [],
       };
 
       registry.import(emptyData);
@@ -411,17 +451,19 @@ describe('HandlerRegistry Comprehensive Tests', () => {
     it('should preserve configurations during export/import', async () => {
       const testData = { value: 42 };
       
-      registry.register({
-        metadata: {
-          name: 'ConfigHandler',
-          operations: {
-            configOp: { name: 'configOp', batch: false },
-          },
-        },
-        configuration: {
+      const metadata: HandlerMetadata = {
+        name: 'ConfigHandler',
+        operations: [
+          { name: 'configOp', method: 'configOp' },
+        ],
+      };
+      const config: HandlerConfiguration = {
+        name: 'ConfigHandler',
+        operations: {
           configOp: async (data: any) => ({ processed: data.value * 2 }),
         },
-      });
+      };
+      registry.register(metadata, config);
 
       // Test operation before export
       const opBefore = registry.getOperation('ConfigHandler', 'configOp');
@@ -433,58 +475,62 @@ describe('HandlerRegistry Comprehensive Tests', () => {
       registry.clear();
       registry.import(exported);
       
-      // Test operation after import - configurations are lost in export
+      // Test operation after import - configurations are preserved
       const opAfter = registry.getOperation('ConfigHandler', 'configOp');
-      expect(opAfter).toBeUndefined(); // Configurations don't persist
+      expect(opAfter).toBeDefined();
+      const resultAfter = await opAfter!(testData);
+      expect(resultAfter).toEqual({ processed: 84 });
     });
   });
 
   describe('edge cases', () => {
     it('should handle empty operations object', () => {
-      registry.register({
-        metadata: {
-          name: 'EmptyHandler',
-          operations: {},
-        },
-        configuration: {},
-      });
+      const metadata: HandlerMetadata = {
+        name: 'EmptyHandler',
+        operations: [],
+      };
+      const config: HandlerConfiguration = {
+        name: 'EmptyHandler',
+        operations: {},
+      };
+      registry.register(metadata, config);
 
-      const metadata = registry.getMetadata('EmptyHandler');
-      expect(metadata?.operations).toEqual({});
+      const retrieved = registry.getMetadata('EmptyHandler');
+      expect(retrieved?.operations).toEqual([]);
       
       const stats = registry.getStats();
-      expect(stats.totalOperations).toBe(0);
+      expect(stats.operations).toBe(0);
     });
 
     it('should handle handlers with many operations', () => {
-      const operations: Record<string, OperationMetadata> = {};
-      const configuration: HandlerConfiguration = {};
+      const operations: OperationMetadata[] = [];
+      const operationHandlers: Record<string, JobHandler> = {};
       
       // Create 50 operations
       for (let i = 0; i < 50; i++) {
         const opName = `operation${i}`;
-        operations[opName] = {
+        operations.push({
           name: opName,
-          batch: i % 2 === 0,
-          batchSize: i % 2 === 0 ? i * 2 : undefined,
-        };
-        configuration[opName] = async () => ({ index: i });
+          method: opName,
+        });
+        operationHandlers[opName] = (async () => ({ index: i })) as JobHandler;
       }
 
-      registry.register({
-        metadata: {
-          name: 'ManyOpsHandler',
-          operations,
-        },
-        configuration,
-      });
+      const metadata: HandlerMetadata = {
+        name: 'ManyOpsHandler',
+        operations,
+      };
+      const config: HandlerConfiguration = {
+        name: 'ManyOpsHandler',
+        operations: operationHandlers,
+      };
+      registry.register(metadata, config);
 
-      const metadata = registry.getMetadata('ManyOpsHandler');
-      expect(Object.keys(metadata!.operations)).toHaveLength(50);
+      const retrieved = registry.getMetadata('ManyOpsHandler');
+      expect(retrieved!.operations).toHaveLength(50);
       
       const stats = registry.getStats();
-      expect(stats.totalOperations).toBe(50);
-      expect(stats.batchOperations).toBe(25); // Half are batch operations
+      expect(stats.operations).toBe(50);
     });
 
     it('should handle concurrent registrations', async () => {
@@ -494,17 +540,19 @@ describe('HandlerRegistry Comprehensive Tests', () => {
       for (let i = 0; i < 10; i++) {
         promises.push(
           Promise.resolve().then(() => {
-            registry.register({
-              metadata: {
-                name: `ConcurrentHandler${i}`,
-                operations: {
-                  op: { name: 'op', batch: false },
-                },
-              },
-              configuration: {
+            const metadata: HandlerMetadata = {
+              name: `ConcurrentHandler${i}`,
+              operations: [
+                { name: 'op', method: 'op' },
+              ],
+            };
+            const config: HandlerConfiguration = {
+              name: `ConcurrentHandler${i}`,
+              operations: {
                 op: async () => ({ handler: i }),
               },
-            });
+            };
+            registry.register(metadata, config);
           })
         );
       }