agentic-orchestrator 0.1.6 → 0.1.7

package/apps/control-plane/test/notifier-service.spec.ts

@@ -5,7 +5,7 @@ import {
   WebhookNotifierChannel,
   createNotifierService,
   type NotificationConfig,
-  type NotificationPayload
+  type NotificationPayload,
 } from '../src/application/services/notifier-service.js';
 
 describe('NotifierService', () => {
@@ -13,13 +13,15 @@ describe('NotifierService', () => {
     const config: NotificationConfig = {
       enabled: false,
       channels: {
-        slack: { enabled: true, webhook: 'https://hooks.slack.com/test', channel: '#test' }
-      }
+        slack: { enabled: true, webhook: 'https://hooks.slack.com/test', channel: '#test' },
+      },
     };
     const service = new NotifierService(config);
 
     // Override channels via a subclass approach — use spy on fetch instead
-    const fetchSpy = vi.spyOn(globalThis, 'fetch').mockResolvedValue(new Response('ok', { status: 200 }));
+    const fetchSpy = vi
+      .spyOn(globalThis, 'fetch')
+      .mockResolvedValue(new Response('ok', { status: 200 }));
 
     await service.notify('gate_failed', { feature_id: 'feat_a', message: 'Gate failed' });
 
@@ -28,13 +30,15 @@ describe('NotifierService', () => {
   });
 
   it('GIVEN_slack_channel_enabled_WHEN_gate_failed_THEN_slack_notified', async () => {
-    const fetchSpy = vi.spyOn(globalThis, 'fetch').mockResolvedValue(new Response('ok', { status: 200 }));
+    const fetchSpy = vi
+      .spyOn(globalThis, 'fetch')
+      .mockResolvedValue(new Response('ok', { status: 200 }));
 
     const config: NotificationConfig = {
       enabled: true,
       channels: {
-        slack: { enabled: true, webhook: 'https://hooks.slack.com/test', channel: '#alerts' }
-      }
+        slack: { enabled: true, webhook: 'https://hooks.slack.com/test', channel: '#alerts' },
+      },
     };
     const service = new NotifierService(config);
 
@@ -44,20 +48,22 @@ describe('NotifierService', () => {
       'https://hooks.slack.com/test',
       expect.objectContaining({
         method: 'POST',
-        headers: expect.objectContaining({ 'Content-Type': 'application/json' })
-      })
+        headers: expect.objectContaining({ 'Content-Type': 'application/json' }),
+      }),
     );
     fetchSpy.mockRestore();
   });
 
   it('GIVEN_same_event_within_throttle_window_WHEN_notify_twice_THEN_second_suppressed', async () => {
-    const fetchSpy = vi.spyOn(globalThis, 'fetch').mockResolvedValue(new Response('ok', { status: 200 }));
+    const fetchSpy = vi
+      .spyOn(globalThis, 'fetch')
+      .mockResolvedValue(new Response('ok', { status: 200 }));
 
     const config: NotificationConfig = {
       enabled: true,
       channels: {
-        slack: { enabled: true, webhook: 'https://hooks.slack.com/test', channel: '#alerts' }
-      }
+        slack: { enabled: true, webhook: 'https://hooks.slack.com/test', channel: '#alerts' },
+      },
     };
     const service = new NotifierService(config);
 
@@ -73,8 +79,8 @@ describe('NotifierService', () => {
     const config: NotificationConfig = {
       enabled: true,
       channels: {
-        slack: { enabled: true, webhook: 'https://hooks.slack.com/test', channel: '#alerts' }
-      }
+        slack: { enabled: true, webhook: 'https://hooks.slack.com/test', channel: '#alerts' },
+      },
     };
 
     const fetchSpy = vi.spyOn(globalThis, 'fetch').mockRejectedValue(new Error('network error'));
@@ -84,7 +90,7 @@ describe('NotifierService', () => {
 
     // Should not throw even when channel fails
     await expect(
-      service.notify('gate_failed', { feature_id: 'feat_d', message: 'Failure' })
+      service.notify('gate_failed', { feature_id: 'feat_d', message: 'Failure' }),
     ).resolves.toBeUndefined();
 
     expect(stderrSpy).toHaveBeenCalled();
@@ -93,19 +99,21 @@ describe('NotifierService', () => {
   });
 
   it('GIVEN_critical_priority_WHEN_notify_THEN_all_enabled_channels_receive', async () => {
-    const fetchSpy = vi.spyOn(globalThis, 'fetch').mockResolvedValue(new Response('ok', { status: 200 }));
+    const fetchSpy = vi
+      .spyOn(globalThis, 'fetch')
+      .mockResolvedValue(new Response('ok', { status: 200 }));
 
     const config: NotificationConfig = {
       enabled: true,
       channels: {
         slack: { enabled: true, webhook: 'https://hooks.slack.com/test', channel: '#alerts' },
-        webhook: { enabled: true, url: 'https://example.com/hook' }
+        webhook: { enabled: true, url: 'https://example.com/hook' },
       },
       routing: {
         critical: ['slack', 'webhook'],
         warning: ['slack'],
-        info: ['slack']
-      }
+        info: ['slack'],
+      },
     };
     const service = new NotifierService(config);
 
@@ -121,7 +129,9 @@ describe('NotifierService', () => {
 
   describe('SlackNotifierChannel', () => {
     it('GIVEN_valid_webhook_WHEN_send_called_THEN_posts_to_webhook', async () => {
-      const fetchSpy = vi.spyOn(globalThis, 'fetch').mockResolvedValue(new Response('ok', { status: 200 }));
+      const fetchSpy = vi
+        .spyOn(globalThis, 'fetch')
+        .mockResolvedValue(new Response('ok', { status: 200 }));
       const channel = new SlackNotifierChannel('https://hooks.slack.com/test', '#test');
 
       await channel.send({
@@ -129,12 +139,12 @@ describe('NotifierService', () => {
         priority: 'critical',
         feature_id: 'feat_x',
         message: 'Test message',
-        timestamp: new Date().toISOString()
+        timestamp: new Date().toISOString(),
       });
 
       expect(fetchSpy).toHaveBeenCalledWith(
         'https://hooks.slack.com/test',
-        expect.objectContaining({ method: 'POST' })
+        expect.objectContaining({ method: 'POST' }),
       );
       fetchSpy.mockRestore();
     });
@@ -142,7 +152,9 @@ describe('NotifierService', () => {
 
   describe('WebhookNotifierChannel', () => {
     it('GIVEN_valid_url_WHEN_send_called_THEN_posts_full_payload', async () => {
-      const fetchSpy = vi.spyOn(globalThis, 'fetch').mockResolvedValue(new Response('ok', { status: 200 }));
+      const fetchSpy = vi
+        .spyOn(globalThis, 'fetch')
+        .mockResolvedValue(new Response('ok', { status: 200 }));
       const channel = new WebhookNotifierChannel('https://example.com/notify');
 
       const payload: NotificationPayload = {
@@ -150,7 +162,7 @@ describe('NotifierService', () => {
         priority: 'info',
         feature_id: 'feat_y',
         message: 'Merged',
-        timestamp: new Date().toISOString()
+        timestamp: new Date().toISOString(),
       };
       await channel.send(payload);
 
@@ -158,22 +170,26 @@ describe('NotifierService', () => {
         'https://example.com/notify',
         expect.objectContaining({
           method: 'POST',
-          body: expect.stringContaining('feature_merged')
-        })
+          body: expect.stringContaining('feature_merged'),
+        }),
       );
       fetchSpy.mockRestore();
     });
 
     it('GIVEN_non_ok_response_WHEN_send_called_THEN_throws_error', async () => {
-      const fetchSpy = vi.spyOn(globalThis, 'fetch').mockResolvedValue(new Response('bad', { status: 500 }));
+      const fetchSpy = vi
+        .spyOn(globalThis, 'fetch')
+        .mockResolvedValue(new Response('bad', { status: 500 }));
       const channel = new WebhookNotifierChannel('https://example.com/notify');
 
-      await expect(channel.send({
-        event: 'gate_failed',
-        priority: 'critical',
-        message: 'Test',
-        timestamp: new Date().toISOString()
-      })).rejects.toThrow('Webhook returned 500');
+      await expect(
+        channel.send({
+          event: 'gate_failed',
+          priority: 'critical',
+          message: 'Test',
+          timestamp: new Date().toISOString(),
+        }),
+      ).rejects.toThrow('Webhook returned 500');
 
       fetchSpy.mockRestore();
     });
@@ -181,15 +197,19 @@ describe('NotifierService', () => {
 
   describe('SlackNotifierChannel non-ok response', () => {
     it('GIVEN_non_ok_response_WHEN_send_called_THEN_throws_error', async () => {
-      const fetchSpy = vi.spyOn(globalThis, 'fetch').mockResolvedValue(new Response('bad', { status: 403 }));
+      const fetchSpy = vi
+        .spyOn(globalThis, 'fetch')
+        .mockResolvedValue(new Response('bad', { status: 403 }));
       const channel = new SlackNotifierChannel('https://hooks.slack.com/test', '#alerts');
 
-      await expect(channel.send({
-        event: 'gate_failed',
-        priority: 'critical',
-        message: 'Test',
-        timestamp: new Date().toISOString()
-      })).rejects.toThrow('Slack webhook returned 403');
+      await expect(
+        channel.send({
+          event: 'gate_failed',
+          priority: 'critical',
+          message: 'Test',
+          timestamp: new Date().toISOString(),
+        }),
+      ).rejects.toThrow('Slack webhook returned 403');
 
       fetchSpy.mockRestore();
     });
@@ -198,21 +218,25 @@ describe('NotifierService', () => {
   describe('createNotifierService factory', () => {
     it('GIVEN_no_notifications_key_WHEN_createNotifierService_called_THEN_returns_disabled_service', async () => {
       const service = createNotifierService({});
-      const fetchSpy = vi.spyOn(globalThis, 'fetch').mockResolvedValue(new Response('ok', { status: 200 }));
+      const fetchSpy = vi
+        .spyOn(globalThis, 'fetch')
+        .mockResolvedValue(new Response('ok', { status: 200 }));
       await service.notify('gate_failed', { message: 'test' });
       expect(fetchSpy).not.toHaveBeenCalled();
       fetchSpy.mockRestore();
     });
 
     it('GIVEN_notifications_object_WHEN_createNotifierService_called_THEN_returns_configured_service', async () => {
-      const fetchSpy = vi.spyOn(globalThis, 'fetch').mockResolvedValue(new Response('ok', { status: 200 }));
+      const fetchSpy = vi
+        .spyOn(globalThis, 'fetch')
+        .mockResolvedValue(new Response('ok', { status: 200 }));
       const service = createNotifierService({
         notifications: {
           enabled: true,
           channels: {
-            slack: { enabled: true, webhook: 'https://hooks.slack.com/test', channel: '#aop' }
-          }
-        }
+            slack: { enabled: true, webhook: 'https://hooks.slack.com/test', channel: '#aop' },
+          },
+        },
       });
       await service.notify('gate_failed', { feature_id: 'feat_z', message: 'Gate failed' });
       expect(fetchSpy).toHaveBeenCalled();
@@ -223,18 +247,21 @@ describe('NotifierService', () => {
 
 describe('DesktopNotifierChannel darwin branch', () => {
   it('GIVEN_darwin_platform_WHEN_send_called_THEN_silently_handles_osascript_failure', async () => {
-    const { DesktopNotifierChannel } = await import('../src/application/services/notifier-service.js');
+    const { DesktopNotifierChannel } =
+      await import('../src/application/services/notifier-service.js');
     const originalPlatform = process.platform;
     Object.defineProperty(process, 'platform', { value: 'darwin', configurable: true });
     try {
       const channel = new DesktopNotifierChannel();
-      await expect(channel.send({
-        event: 'gate_failed',
-        priority: 'critical',
-        feature_id: 'feat_darwin',
-        message: 'darwin test',
-        timestamp: new Date().toISOString()
-      })).resolves.toBeUndefined();
+      await expect(
+        channel.send({
+          event: 'gate_failed',
+          priority: 'critical',
+          feature_id: 'feat_darwin',
+          message: 'darwin test',
+          timestamp: new Date().toISOString(),
+        }),
+      ).resolves.toBeUndefined();
     } finally {
       Object.defineProperty(process, 'platform', { value: originalPlatform, configurable: true });
     }
@@ -243,37 +270,43 @@ describe('DesktopNotifierChannel darwin branch', () => {
 
 describe('SlackNotifierChannel dashboard URL branches', () => {
   it('GIVEN_dashboard_feature_url_in_details_WHEN_send_called_THEN_appends_dashboard_link', async () => {
-    const fetchSpy = vi.spyOn(globalThis, 'fetch').mockResolvedValue(new Response('ok', { status: 200 }));
+    const fetchSpy = vi
+      .spyOn(globalThis, 'fetch')
+      .mockResolvedValue(new Response('ok', { status: 200 }));
     const channel = new SlackNotifierChannel('https://hooks.slack.com/test', '#test');
     await channel.send({
       event: 'gate_failed',
       priority: 'critical',
       message: 'Test',
       timestamp: new Date().toISOString(),
-      details: { dashboard_feature_url: 'http://localhost:3000/features/feat1' }
+      details: { dashboard_feature_url: 'http://localhost:3000/features/feat1' },
     });
-    const body = JSON.parse((fetchSpy.mock.calls[0][1]).body as string);
+    const body = JSON.parse(fetchSpy.mock.calls[0][1].body as string);
     expect(body.text).toContain('Dashboard:');
     fetchSpy.mockRestore();
   });
 
   it('GIVEN_dashboard_url_in_details_WHEN_send_called_THEN_falls_back_to_dashboard_url', async () => {
-    const fetchSpy = vi.spyOn(globalThis, 'fetch').mockResolvedValue(new Response('ok', { status: 200 }));
+    const fetchSpy = vi
+      .spyOn(globalThis, 'fetch')
+      .mockResolvedValue(new Response('ok', { status: 200 }));
     const channel = new SlackNotifierChannel('https://hooks.slack.com/test', '#test');
     await channel.send({
       event: 'gate_failed',
       priority: 'critical',
       message: 'Test2',
       timestamp: new Date().toISOString(),
-      details: { dashboard_url: 'http://localhost:3000' }
+      details: { dashboard_url: 'http://localhost:3000' },
     });
-    const body = JSON.parse((fetchSpy.mock.calls[0][1]).body as string);
+    const body = JSON.parse(fetchSpy.mock.calls[0][1].body as string);
     expect(body.text).toContain('Dashboard:');
     fetchSpy.mockRestore();
   });
 
   it('GIVEN_long_details_json_WHEN_send_called_THEN_truncates_to_800_chars', async () => {
-    const fetchSpy = vi.spyOn(globalThis, 'fetch').mockResolvedValue(new Response('ok', { status: 200 }));
+    const fetchSpy = vi
+      .spyOn(globalThis, 'fetch')
+      .mockResolvedValue(new Response('ok', { status: 200 }));
     const channel = new SlackNotifierChannel('https://hooks.slack.com/test', '#test');
     const longValue = 'x'.repeat(1000);
     await channel.send({
@@ -281,23 +314,25 @@ describe('SlackNotifierChannel dashboard URL branches', () => {
       priority: 'critical',
       message: 'Long details',
       timestamp: new Date().toISOString(),
-      details: { data: longValue }
+      details: { data: longValue },
     });
-    const body = JSON.parse((fetchSpy.mock.calls[0][1]).body as string);
+    const body = JSON.parse(fetchSpy.mock.calls[0][1].body as string);
     expect(body.text).toContain('…');
     fetchSpy.mockRestore();
   });
 
   it('GIVEN_no_feature_id_WHEN_send_called_THEN_message_without_backtick_feature', async () => {
-    const fetchSpy = vi.spyOn(globalThis, 'fetch').mockResolvedValue(new Response('ok', { status: 200 }));
+    const fetchSpy = vi
+      .spyOn(globalThis, 'fetch')
+      .mockResolvedValue(new Response('ok', { status: 200 }));
     const channel = new SlackNotifierChannel('https://hooks.slack.com/test', '#test');
     await channel.send({
       event: 'feature_merged',
       priority: 'info',
       message: 'No feature id',
-      timestamp: new Date().toISOString()
+      timestamp: new Date().toISOString(),
     });
-    const body = JSON.parse((fetchSpy.mock.calls[0][1]).body as string);
+    const body = JSON.parse(fetchSpy.mock.calls[0][1].body as string);
     expect(body.text).not.toContain('`');
     fetchSpy.mockRestore();
   });
@@ -305,38 +340,44 @@ describe('SlackNotifierChannel dashboard URL branches', () => {
 
 describe('DesktopNotifierChannel additional coverage', () => {
   it('GIVEN_linux_platform_and_successful_execFile_WHEN_send_called_THEN_resolves_without_error', async () => {
-    const { DesktopNotifierChannel } = await import('../src/application/services/notifier-service.js');
+    const { DesktopNotifierChannel } =
+      await import('../src/application/services/notifier-service.js');
     const originalPlatform = process.platform;
     Object.defineProperty(process, 'platform', { value: 'linux', configurable: true });
     try {
       const channel = new DesktopNotifierChannel();
       // notify-send may not be installed; the channel silently catches errors
-      await expect(channel.send({
-        event: 'gate_failed',
-        priority: 'critical',
-        feature_id: undefined,
-        message: 'linux test without feature id',
-        timestamp: new Date().toISOString()
-      })).resolves.toBeUndefined();
+      await expect(
+        channel.send({
+          event: 'gate_failed',
+          priority: 'critical',
+          feature_id: undefined,
+          message: 'linux test without feature id',
+          timestamp: new Date().toISOString(),
+        }),
+      ).resolves.toBeUndefined();
     } finally {
       Object.defineProperty(process, 'platform', { value: originalPlatform, configurable: true });
     }
   });
 
   it('GIVEN_darwin_platform_and_successful_osascript_WHEN_send_called_THEN_resolves_without_error', async () => {
-    const { DesktopNotifierChannel } = await import('../src/application/services/notifier-service.js');
+    const { DesktopNotifierChannel } =
+      await import('../src/application/services/notifier-service.js');
     const originalPlatform = process.platform;
     Object.defineProperty(process, 'platform', { value: 'darwin', configurable: true });
     try {
       const channel = new DesktopNotifierChannel();
       // osascript may not be available; channel silently catches errors
-      await expect(channel.send({
-        event: 'ready_to_merge',
-        priority: 'info',
-        feature_id: undefined,
-        message: 'darwin test without feature id',
-        timestamp: new Date().toISOString()
-      })).resolves.toBeUndefined();
+      await expect(
+        channel.send({
+          event: 'ready_to_merge',
+          priority: 'info',
+          feature_id: undefined,
+          message: 'darwin test without feature id',
+          timestamp: new Date().toISOString(),
+        }),
+      ).resolves.toBeUndefined();
     } finally {
       Object.defineProperty(process, 'platform', { value: originalPlatform, configurable: true });
     }
@@ -352,9 +393,9 @@ describe('createNotifierService AOP_DASHBOARD_URL branch', () => {
         notifications: {
           enabled: true,
           channels: {
-            slack: { enabled: true, webhook: 'https://hooks.slack.com/test', channel: '#aop' }
-          }
-        }
+            slack: { enabled: true, webhook: 'https://hooks.slack.com/test', channel: '#aop' },
+          },
+        },
       });
       expect(service).toBeDefined();
     } finally {
@@ -369,18 +410,21 @@ describe('createNotifierService AOP_DASHBOARD_URL branch', () => {
 
 describe('DesktopNotifierChannel other platform branch', () => {
   it('GIVEN_win32_platform_WHEN_send_called_THEN_silently_skips', async () => {
-    const { DesktopNotifierChannel } = await import('../src/application/services/notifier-service.js');
+    const { DesktopNotifierChannel } =
+      await import('../src/application/services/notifier-service.js');
     const originalPlatform = process.platform;
     Object.defineProperty(process, 'platform', { value: 'win32', configurable: true });
     try {
       const channel = new DesktopNotifierChannel();
-      await expect(channel.send({
-        event: 'gate_failed',
-        priority: 'critical',
-        feature_id: 'feat_win',
-        message: 'win32 test',
-        timestamp: new Date().toISOString()
-      })).resolves.toBeUndefined();
+      await expect(
+        channel.send({
+          event: 'gate_failed',
+          priority: 'critical',
+          feature_id: 'feat_win',
+          message: 'win32 test',
+          timestamp: new Date().toISOString(),
+        }),
+      ).resolves.toBeUndefined();
     } finally {
       Object.defineProperty(process, 'platform', { value: originalPlatform, configurable: true });
     }