agentic-orchestrator 0.1.2 → 0.1.4

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

@@ -0,0 +1,388 @@
+import { describe, expect, it, vi } from 'vitest';
+import {
+  NotifierService,
+  SlackNotifierChannel,
+  WebhookNotifierChannel,
+  createNotifierService,
+  type NotificationConfig,
+  type NotificationPayload
+} from '../src/application/services/notifier-service.js';
+
+describe('NotifierService', () => {
+  it('GIVEN_notifications_disabled_WHEN_notify_called_THEN_no_channels_invoked', async () => {
+    const config: NotificationConfig = {
+      enabled: false,
+      channels: {
+        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 }));
+
+    await service.notify('gate_failed', { feature_id: 'feat_a', message: 'Gate failed' });
+
+    expect(fetchSpy).not.toHaveBeenCalled();
+    fetchSpy.mockRestore();
+  });
+
+  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 config: NotificationConfig = {
+      enabled: true,
+      channels: {
+        slack: { enabled: true, webhook: 'https://hooks.slack.com/test', channel: '#alerts' }
+      }
+    };
+    const service = new NotifierService(config);
+
+    await service.notify('gate_failed', { feature_id: 'feat_b', message: 'Gate check failed' });
+
+    expect(fetchSpy).toHaveBeenCalledWith(
+      'https://hooks.slack.com/test',
+      expect.objectContaining({
+        method: 'POST',
+        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 config: NotificationConfig = {
+      enabled: true,
+      channels: {
+        slack: { enabled: true, webhook: 'https://hooks.slack.com/test', channel: '#alerts' }
+      }
+    };
+    const service = new NotifierService(config);
+
+    await service.notify('gate_failed', { feature_id: 'feat_c', message: 'First' });
+    await service.notify('gate_failed', { feature_id: 'feat_c', message: 'Second' });
+
+    // Only the first call should trigger a fetch
+    expect(fetchSpy).toHaveBeenCalledTimes(1);
+    fetchSpy.mockRestore();
+  });
+
+  it('GIVEN_channel_throws_WHEN_notify_called_THEN_error_not_propagated', async () => {
+    const config: NotificationConfig = {
+      enabled: true,
+      channels: {
+        slack: { enabled: true, webhook: 'https://hooks.slack.com/test', channel: '#alerts' }
+      }
+    };
+
+    const fetchSpy = vi.spyOn(globalThis, 'fetch').mockRejectedValue(new Error('network error'));
+    const stderrSpy = vi.spyOn(process.stderr, 'write').mockImplementation(() => true);
+
+    const service = new NotifierService(config);
+
+    // Should not throw even when channel fails
+    await expect(
+      service.notify('gate_failed', { feature_id: 'feat_d', message: 'Failure' })
+    ).resolves.toBeUndefined();
+
+    expect(stderrSpy).toHaveBeenCalled();
+    fetchSpy.mockRestore();
+    stderrSpy.mockRestore();
+  });
+
+  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 config: NotificationConfig = {
+      enabled: true,
+      channels: {
+        slack: { enabled: true, webhook: 'https://hooks.slack.com/test', channel: '#alerts' },
+        webhook: { enabled: true, url: 'https://example.com/hook' }
+      },
+      routing: {
+        critical: ['slack', 'webhook'],
+        warning: ['slack'],
+        info: ['slack']
+      }
+    };
+    const service = new NotifierService(config);
+
+    await service.notify('collision_detected', { feature_id: 'feat_e', message: 'Collision!' });
+
+    // Both slack and webhook should be called (critical priority → all enabled channels per routing)
+    expect(fetchSpy).toHaveBeenCalledTimes(2);
+    const urls = fetchSpy.mock.calls.map((call) => call[0] as string);
+    expect(urls).toContain('https://hooks.slack.com/test');
+    expect(urls).toContain('https://example.com/hook');
+    fetchSpy.mockRestore();
+  });
+
+  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 channel = new SlackNotifierChannel('https://hooks.slack.com/test', '#test');
+
+      await channel.send({
+        event: 'gate_failed',
+        priority: 'critical',
+        feature_id: 'feat_x',
+        message: 'Test message',
+        timestamp: new Date().toISOString()
+      });
+
+      expect(fetchSpy).toHaveBeenCalledWith(
+        'https://hooks.slack.com/test',
+        expect.objectContaining({ method: 'POST' })
+      );
+      fetchSpy.mockRestore();
+    });
+  });
+
+  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 channel = new WebhookNotifierChannel('https://example.com/notify');
+
+      const payload: NotificationPayload = {
+        event: 'feature_merged',
+        priority: 'info',
+        feature_id: 'feat_y',
+        message: 'Merged',
+        timestamp: new Date().toISOString()
+      };
+      await channel.send(payload);
+
+      expect(fetchSpy).toHaveBeenCalledWith(
+        'https://example.com/notify',
+        expect.objectContaining({
+          method: 'POST',
+          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 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');
+
+      fetchSpy.mockRestore();
+    });
+  });
+
+  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 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');
+
+      fetchSpy.mockRestore();
+    });
+  });
+
+  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 }));
+      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 service = createNotifierService({
+        notifications: {
+          enabled: true,
+          channels: {
+            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();
+      fetchSpy.mockRestore();
+    });
+  });
+});
+
+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 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();
+    } finally {
+      Object.defineProperty(process, 'platform', { value: originalPlatform, configurable: true });
+    }
+  });
+});
+
+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 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' }
+    });
+    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 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' }
+    });
+    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 channel = new SlackNotifierChannel('https://hooks.slack.com/test', '#test');
+    const longValue = 'x'.repeat(1000);
+    await channel.send({
+      event: 'gate_failed',
+      priority: 'critical',
+      message: 'Long details',
+      timestamp: new Date().toISOString(),
+      details: { data: longValue }
+    });
+    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 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()
+    });
+    const body = JSON.parse((fetchSpy.mock.calls[0][1]).body as string);
+    expect(body.text).not.toContain('`');
+    fetchSpy.mockRestore();
+  });
+});
+
+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 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();
+    } 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 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();
+    } finally {
+      Object.defineProperty(process, 'platform', { value: originalPlatform, configurable: true });
+    }
+  });
+});
+
+describe('createNotifierService AOP_DASHBOARD_URL branch', () => {
+  it('GIVEN_AOP_DASHBOARD_URL_set_WHEN_createNotifierService_called_THEN_uses_env_url', () => {
+    const originalUrl = process.env.AOP_DASHBOARD_URL;
+    process.env.AOP_DASHBOARD_URL = 'https://custom-dashboard.example.com';
+    try {
+      const service = createNotifierService({
+        notifications: {
+          enabled: true,
+          channels: {
+            slack: { enabled: true, webhook: 'https://hooks.slack.com/test', channel: '#aop' }
+          }
+        }
+      });
+      expect(service).toBeDefined();
+    } finally {
+      if (originalUrl === undefined) {
+        delete process.env.AOP_DASHBOARD_URL;
+      } else {
+        process.env.AOP_DASHBOARD_URL = originalUrl;
+      }
+    }
+  });
+});
+
+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 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();
+    } finally {
+      Object.defineProperty(process, 'platform', { value: originalPlatform, configurable: true });
+    }
+  });
+});