803 lines
23 KiB
JavaScript
803 lines
23 KiB
JavaScript
/**
|
|
* Tests for NotificationService - Multi-channel notification orchestration
|
|
*
|
|
* Tests cover:
|
|
* - Channel initialization based on config
|
|
* - Event routing with default channels
|
|
* - Priority-based behavior (retry, all channels)
|
|
* - Convenience methods for specific notification types
|
|
* - Error handling and aggregation
|
|
*/
|
|
|
|
import { describe, it, expect, vi, beforeEach } from 'vitest';
|
|
import {
|
|
NotificationService,
|
|
NOTIFICATION_EVENTS,
|
|
PRIORITY_BEHAVIOR,
|
|
} from '../../../src/modules/bmm/lib/notifications/notification-service.js';
|
|
|
|
// Mock the notifier modules
|
|
vi.mock('../../../src/modules/bmm/lib/notifications/github-notifier.js', () => ({
|
|
GitHubNotifier: vi.fn().mockImplementation(() => ({
|
|
send: vi.fn().mockResolvedValue({ success: true, channel: 'github' }),
|
|
})),
|
|
}));
|
|
|
|
vi.mock('../../../src/modules/bmm/lib/notifications/slack-notifier.js', () => ({
|
|
SlackNotifier: vi.fn().mockImplementation(() => ({
|
|
send: vi.fn().mockResolvedValue({ success: true, channel: 'slack' }),
|
|
})),
|
|
}));
|
|
|
|
vi.mock('../../../src/modules/bmm/lib/notifications/email-notifier.js', () => ({
|
|
EmailNotifier: vi.fn().mockImplementation(() => ({
|
|
send: vi.fn().mockResolvedValue({ success: true, channel: 'email' }),
|
|
})),
|
|
}));
|
|
|
|
describe('NotificationService', () => {
|
|
// ============ Constants Tests ============
|
|
|
|
describe('NOTIFICATION_EVENTS', () => {
|
|
it('should define all event types', () => {
|
|
const expectedEvents = [
|
|
'feedback_round_opened',
|
|
'feedback_submitted',
|
|
'synthesis_complete',
|
|
'signoff_requested',
|
|
'signoff_received',
|
|
'document_approved',
|
|
'document_blocked',
|
|
'reminder',
|
|
'deadline_extended',
|
|
];
|
|
|
|
for (const event of expectedEvents) {
|
|
expect(NOTIFICATION_EVENTS[event]).toBeDefined();
|
|
expect(NOTIFICATION_EVENTS[event].description).toBeTruthy();
|
|
expect(NOTIFICATION_EVENTS[event].defaultChannels).toBeInstanceOf(Array);
|
|
expect(NOTIFICATION_EVENTS[event].priority).toBeTruthy();
|
|
}
|
|
});
|
|
|
|
it('should have appropriate priorities for different events', () => {
|
|
expect(NOTIFICATION_EVENTS.document_blocked.priority).toBe('urgent');
|
|
expect(NOTIFICATION_EVENTS.signoff_requested.priority).toBe('high');
|
|
expect(NOTIFICATION_EVENTS.feedback_submitted.priority).toBe('normal');
|
|
expect(NOTIFICATION_EVENTS.deadline_extended.priority).toBe('low');
|
|
});
|
|
|
|
it('should include all channels for important events', () => {
|
|
expect(NOTIFICATION_EVENTS.feedback_round_opened.defaultChannels).toContain('github');
|
|
expect(NOTIFICATION_EVENTS.feedback_round_opened.defaultChannels).toContain('slack');
|
|
expect(NOTIFICATION_EVENTS.feedback_round_opened.defaultChannels).toContain('email');
|
|
});
|
|
|
|
it('should have minimal channels for low-priority events', () => {
|
|
expect(NOTIFICATION_EVENTS.deadline_extended.defaultChannels).toEqual(['github']);
|
|
});
|
|
});
|
|
|
|
describe('PRIORITY_BEHAVIOR', () => {
|
|
it('should define all priority levels', () => {
|
|
expect(PRIORITY_BEHAVIOR.urgent).toBeDefined();
|
|
expect(PRIORITY_BEHAVIOR.high).toBeDefined();
|
|
expect(PRIORITY_BEHAVIOR.normal).toBeDefined();
|
|
expect(PRIORITY_BEHAVIOR.low).toBeDefined();
|
|
});
|
|
|
|
it('should have retry settings based on priority', () => {
|
|
expect(PRIORITY_BEHAVIOR.urgent.retryOnFailure).toBe(true);
|
|
expect(PRIORITY_BEHAVIOR.urgent.maxRetries).toBe(3);
|
|
|
|
expect(PRIORITY_BEHAVIOR.high.retryOnFailure).toBe(true);
|
|
expect(PRIORITY_BEHAVIOR.high.maxRetries).toBe(2);
|
|
|
|
expect(PRIORITY_BEHAVIOR.normal.retryOnFailure).toBe(false);
|
|
expect(PRIORITY_BEHAVIOR.normal.maxRetries).toBe(1);
|
|
|
|
expect(PRIORITY_BEHAVIOR.low.retryOnFailure).toBe(false);
|
|
});
|
|
|
|
it('should use all channels for urgent priority', () => {
|
|
expect(PRIORITY_BEHAVIOR.urgent.allChannels).toBe(true);
|
|
expect(PRIORITY_BEHAVIOR.high.allChannels).toBe(false);
|
|
expect(PRIORITY_BEHAVIOR.normal.allChannels).toBe(false);
|
|
});
|
|
});
|
|
|
|
// ============ Constructor Tests ============
|
|
|
|
describe('constructor', () => {
|
|
it('should always initialize GitHub channel', () => {
|
|
const service = new NotificationService({
|
|
github: { owner: 'test', repo: 'test' },
|
|
});
|
|
|
|
expect(service.channels.github).toBeDefined();
|
|
expect(service.isChannelAvailable('github')).toBe(true);
|
|
});
|
|
|
|
it('should initialize Slack when enabled with webhook', () => {
|
|
const service = new NotificationService({
|
|
github: { owner: 'test', repo: 'test' },
|
|
slack: {
|
|
enabled: true,
|
|
webhookUrl: 'https://hooks.slack.com/xxx',
|
|
},
|
|
});
|
|
|
|
expect(service.channels.slack).toBeDefined();
|
|
expect(service.isChannelAvailable('slack')).toBe(true);
|
|
});
|
|
|
|
it('should not initialize Slack without webhook', () => {
|
|
const service = new NotificationService({
|
|
github: { owner: 'test', repo: 'test' },
|
|
slack: { enabled: true }, // No webhookUrl
|
|
});
|
|
|
|
expect(service.channels.slack).toBeUndefined();
|
|
expect(service.isChannelAvailable('slack')).toBe(false);
|
|
});
|
|
|
|
it('should initialize Email when enabled with SMTP', () => {
|
|
const service = new NotificationService({
|
|
github: { owner: 'test', repo: 'test' },
|
|
email: {
|
|
enabled: true,
|
|
smtp: { host: 'localhost' },
|
|
},
|
|
});
|
|
|
|
expect(service.channels.email).toBeDefined();
|
|
expect(service.isChannelAvailable('email')).toBe(true);
|
|
});
|
|
|
|
it('should initialize Email when enabled with API key', () => {
|
|
const service = new NotificationService({
|
|
github: { owner: 'test', repo: 'test' },
|
|
email: {
|
|
enabled: true,
|
|
apiKey: 'SG.xxx',
|
|
},
|
|
});
|
|
|
|
expect(service.channels.email).toBeDefined();
|
|
});
|
|
|
|
it('should not initialize Email without config', () => {
|
|
const service = new NotificationService({
|
|
github: { owner: 'test', repo: 'test' },
|
|
email: { enabled: true }, // No smtp or apiKey
|
|
});
|
|
|
|
expect(service.channels.email).toBeUndefined();
|
|
});
|
|
});
|
|
|
|
// ============ getAvailableChannels Tests ============
|
|
|
|
describe('getAvailableChannels', () => {
|
|
it('should return only GitHub when minimal config', () => {
|
|
const service = new NotificationService({
|
|
github: { owner: 'test', repo: 'test' },
|
|
});
|
|
|
|
expect(service.getAvailableChannels()).toEqual(['github']);
|
|
});
|
|
|
|
it('should return all channels when fully configured', () => {
|
|
const service = new NotificationService({
|
|
github: { owner: 'test', repo: 'test' },
|
|
slack: { enabled: true, webhookUrl: 'https://xxx' },
|
|
email: { enabled: true, smtp: { host: 'localhost' } },
|
|
});
|
|
|
|
const channels = service.getAvailableChannels();
|
|
expect(channels).toContain('github');
|
|
expect(channels).toContain('slack');
|
|
expect(channels).toContain('email');
|
|
});
|
|
});
|
|
|
|
// ============ notify Tests ============
|
|
|
|
describe('notify', () => {
|
|
let service;
|
|
let mockGithubSend;
|
|
let mockSlackSend;
|
|
let mockEmailSend;
|
|
|
|
beforeEach(() => {
|
|
mockGithubSend = vi.fn().mockResolvedValue({ success: true, channel: 'github' });
|
|
mockSlackSend = vi.fn().mockResolvedValue({ success: true, channel: 'slack' });
|
|
mockEmailSend = vi.fn().mockResolvedValue({ success: true, channel: 'email' });
|
|
|
|
service = new NotificationService({
|
|
github: { owner: 'test', repo: 'test' },
|
|
slack: { enabled: true, webhookUrl: 'https://xxx' },
|
|
email: { enabled: true, smtp: { host: 'localhost' } },
|
|
});
|
|
|
|
service.channels.github.send = mockGithubSend;
|
|
service.channels.slack.send = mockSlackSend;
|
|
service.channels.email.send = mockEmailSend;
|
|
});
|
|
|
|
it('should throw for unknown event type', async () => {
|
|
await expect(service.notify('unknown_event', {})).rejects.toThrow('Unknown notification event type: unknown_event');
|
|
});
|
|
|
|
it('should send to default channels for event', async () => {
|
|
await service.notify('feedback_round_opened', {
|
|
document_type: 'prd',
|
|
document_key: 'test',
|
|
});
|
|
|
|
expect(mockGithubSend).toHaveBeenCalled();
|
|
expect(mockSlackSend).toHaveBeenCalled();
|
|
expect(mockEmailSend).toHaveBeenCalled();
|
|
});
|
|
|
|
it('should filter to available channels only', async () => {
|
|
// Service with only GitHub
|
|
const minimalService = new NotificationService({
|
|
github: { owner: 'test', repo: 'test' },
|
|
});
|
|
minimalService.channels.github.send = mockGithubSend;
|
|
|
|
await minimalService.notify('feedback_round_opened', {});
|
|
|
|
expect(mockGithubSend).toHaveBeenCalled();
|
|
expect(mockSlackSend).not.toHaveBeenCalled();
|
|
expect(mockEmailSend).not.toHaveBeenCalled();
|
|
});
|
|
|
|
it('should always include GitHub as baseline', async () => {
|
|
await service.notify(
|
|
'feedback_submitted',
|
|
{
|
|
document_type: 'prd',
|
|
document_key: 'test',
|
|
},
|
|
{ channels: ['slack'] },
|
|
); // Explicitly only slack
|
|
|
|
// GitHub should still be included
|
|
expect(mockGithubSend).toHaveBeenCalled();
|
|
expect(mockSlackSend).toHaveBeenCalled();
|
|
});
|
|
|
|
it('should use all channels for urgent priority', async () => {
|
|
await service.notify('document_blocked', {
|
|
document_type: 'prd',
|
|
document_key: 'test',
|
|
user: 'security',
|
|
reason: 'Blocked',
|
|
});
|
|
|
|
// document_blocked is urgent, should use all available channels
|
|
expect(mockGithubSend).toHaveBeenCalled();
|
|
expect(mockSlackSend).toHaveBeenCalled();
|
|
expect(mockEmailSend).toHaveBeenCalled();
|
|
});
|
|
|
|
it('should respect custom channels option', async () => {
|
|
await service.notify(
|
|
'deadline_extended',
|
|
{
|
|
document_type: 'prd',
|
|
document_key: 'test',
|
|
},
|
|
{ channels: ['github', 'slack'] },
|
|
);
|
|
|
|
expect(mockGithubSend).toHaveBeenCalled();
|
|
expect(mockSlackSend).toHaveBeenCalled();
|
|
expect(mockEmailSend).not.toHaveBeenCalled();
|
|
});
|
|
|
|
it('should aggregate results from all channels', async () => {
|
|
const result = await service.notify('signoff_requested', {
|
|
document_type: 'prd',
|
|
document_key: 'test',
|
|
});
|
|
|
|
expect(result.success).toBe(true);
|
|
expect(result.eventType).toBe('signoff_requested');
|
|
expect(result.results.github).toBeDefined();
|
|
expect(result.results.slack).toBeDefined();
|
|
expect(result.results.email).toBeDefined();
|
|
});
|
|
|
|
it('should report success if any channel succeeds', async () => {
|
|
mockGithubSend.mockResolvedValue({ success: true, channel: 'github' });
|
|
mockSlackSend.mockResolvedValue({ success: false, channel: 'slack', error: 'Failed' });
|
|
mockEmailSend.mockResolvedValue({ success: false, channel: 'email', error: 'Failed' });
|
|
|
|
const result = await service.notify('feedback_round_opened', {});
|
|
|
|
expect(result.success).toBe(true);
|
|
});
|
|
|
|
it('should report failure if all channels fail', async () => {
|
|
mockGithubSend.mockResolvedValue({ success: false, error: 'Failed' });
|
|
mockSlackSend.mockResolvedValue({ success: false, error: 'Failed' });
|
|
mockEmailSend.mockResolvedValue({ success: false, error: 'Failed' });
|
|
|
|
const result = await service.notify('feedback_round_opened', {});
|
|
|
|
expect(result.success).toBe(false);
|
|
});
|
|
});
|
|
|
|
// ============ sendReminder Tests ============
|
|
|
|
describe('sendReminder', () => {
|
|
let service;
|
|
let notifySpy;
|
|
|
|
beforeEach(() => {
|
|
service = new NotificationService({
|
|
github: { owner: 'test', repo: 'test' },
|
|
});
|
|
|
|
notifySpy = vi.spyOn(service, 'notify').mockResolvedValue({ success: true });
|
|
});
|
|
|
|
it('should format users as mentions', async () => {
|
|
await service.sendReminder('prd', 'user-auth', ['alice', 'bob'], {
|
|
action_needed: 'feedback',
|
|
deadline: '2026-01-15',
|
|
});
|
|
|
|
expect(notifySpy).toHaveBeenCalledWith(
|
|
'reminder',
|
|
expect.objectContaining({
|
|
mentions: '@alice @bob',
|
|
users: ['alice', 'bob'],
|
|
document_type: 'prd',
|
|
document_key: 'user-auth',
|
|
}),
|
|
);
|
|
});
|
|
});
|
|
|
|
// ============ notifyFeedbackRoundOpened Tests ============
|
|
|
|
describe('notifyFeedbackRoundOpened', () => {
|
|
let service;
|
|
let notifySpy;
|
|
|
|
beforeEach(() => {
|
|
service = new NotificationService({
|
|
github: { owner: 'test', repo: 'test' },
|
|
});
|
|
|
|
notifySpy = vi.spyOn(service, 'notify').mockResolvedValue({ success: true });
|
|
});
|
|
|
|
it('should format document data correctly', async () => {
|
|
await service.notifyFeedbackRoundOpened(
|
|
{
|
|
type: 'prd',
|
|
key: 'user-auth',
|
|
title: 'User Authentication',
|
|
version: 1,
|
|
url: 'https://example.com/doc',
|
|
reviewIssue: 100,
|
|
},
|
|
['alice', 'bob', 'charlie'],
|
|
'2026-01-15',
|
|
);
|
|
|
|
expect(notifySpy).toHaveBeenCalledWith(
|
|
'feedback_round_opened',
|
|
expect.objectContaining({
|
|
document_type: 'prd',
|
|
document_key: 'user-auth',
|
|
title: 'User Authentication',
|
|
version: 1,
|
|
deadline: '2026-01-15',
|
|
stakeholder_count: 3,
|
|
mentions: '@alice @bob @charlie',
|
|
users: ['alice', 'bob', 'charlie'],
|
|
document_url: 'https://example.com/doc',
|
|
review_issue: 100,
|
|
}),
|
|
);
|
|
});
|
|
});
|
|
|
|
// ============ notifyFeedbackSubmitted Tests ============
|
|
|
|
describe('notifyFeedbackSubmitted', () => {
|
|
let service;
|
|
let notifySpy;
|
|
|
|
beforeEach(() => {
|
|
service = new NotificationService({
|
|
github: { owner: 'test', repo: 'test' },
|
|
});
|
|
|
|
notifySpy = vi.spyOn(service, 'notify').mockResolvedValue({ success: true });
|
|
});
|
|
|
|
it('should format feedback data correctly', async () => {
|
|
await service.notifyFeedbackSubmitted(
|
|
{
|
|
submittedBy: 'security',
|
|
type: 'concern',
|
|
section: 'FR-3',
|
|
summary: 'Security vulnerability identified',
|
|
issueNumber: 42,
|
|
url: 'https://example.com/issues/42',
|
|
},
|
|
{
|
|
type: 'prd',
|
|
key: 'payments',
|
|
owner: 'product-owner',
|
|
reviewIssue: 100,
|
|
},
|
|
);
|
|
|
|
expect(notifySpy).toHaveBeenCalledWith(
|
|
'feedback_submitted',
|
|
expect.objectContaining({
|
|
document_type: 'prd',
|
|
document_key: 'payments',
|
|
user: 'security',
|
|
feedback_type: 'concern',
|
|
section: 'FR-3',
|
|
feedback_issue: 42,
|
|
}),
|
|
expect.objectContaining({
|
|
notifyOnly: ['product-owner'],
|
|
}),
|
|
);
|
|
});
|
|
});
|
|
|
|
// ============ notifySynthesisComplete Tests ============
|
|
|
|
describe('notifySynthesisComplete', () => {
|
|
let service;
|
|
let notifySpy;
|
|
|
|
beforeEach(() => {
|
|
service = new NotificationService({
|
|
github: { owner: 'test', repo: 'test' },
|
|
});
|
|
|
|
notifySpy = vi.spyOn(service, 'notify').mockResolvedValue({ success: true });
|
|
});
|
|
|
|
it('should format synthesis data correctly', async () => {
|
|
await service.notifySynthesisComplete(
|
|
{
|
|
type: 'prd',
|
|
key: 'user-auth',
|
|
url: 'https://example.com/doc',
|
|
reviewIssue: 100,
|
|
},
|
|
{
|
|
oldVersion: 1,
|
|
newVersion: 2,
|
|
feedbackCount: 12,
|
|
conflictsResolved: 3,
|
|
summary: 'Incorporated security feedback and clarified auth flow',
|
|
},
|
|
);
|
|
|
|
expect(notifySpy).toHaveBeenCalledWith(
|
|
'synthesis_complete',
|
|
expect.objectContaining({
|
|
document_type: 'prd',
|
|
document_key: 'user-auth',
|
|
old_version: 1,
|
|
new_version: 2,
|
|
feedback_count: 12,
|
|
conflicts_resolved: 3,
|
|
summary: expect.stringContaining('security feedback'),
|
|
}),
|
|
);
|
|
});
|
|
});
|
|
|
|
// ============ notifySignoffRequested Tests ============
|
|
|
|
describe('notifySignoffRequested', () => {
|
|
let service;
|
|
let notifySpy;
|
|
|
|
beforeEach(() => {
|
|
service = new NotificationService({
|
|
github: { owner: 'test', repo: 'test' },
|
|
});
|
|
|
|
notifySpy = vi.spyOn(service, 'notify').mockResolvedValue({ success: true });
|
|
});
|
|
|
|
it('should format signoff request correctly', async () => {
|
|
await service.notifySignoffRequested(
|
|
{
|
|
type: 'prd',
|
|
key: 'payments',
|
|
title: 'Payments V2',
|
|
version: 2,
|
|
url: 'https://example.com/doc',
|
|
signoffUrl: 'https://example.com/signoff',
|
|
reviewIssue: 200,
|
|
},
|
|
['alice', 'bob', 'charlie'],
|
|
'2026-01-20',
|
|
{ minimum_approvals: 2 },
|
|
);
|
|
|
|
expect(notifySpy).toHaveBeenCalledWith(
|
|
'signoff_requested',
|
|
expect.objectContaining({
|
|
document_type: 'prd',
|
|
document_key: 'payments',
|
|
title: 'Payments V2',
|
|
version: 2,
|
|
deadline: '2026-01-20',
|
|
approvals_needed: 2,
|
|
mentions: '@alice @bob @charlie',
|
|
users: ['alice', 'bob', 'charlie'],
|
|
}),
|
|
);
|
|
});
|
|
|
|
it('should calculate approvals_needed from stakeholder count when not specified', async () => {
|
|
await service.notifySignoffRequested(
|
|
{
|
|
type: 'prd',
|
|
key: 'test',
|
|
title: 'Test',
|
|
version: 1,
|
|
},
|
|
['a', 'b', 'c', 'd', 'e'],
|
|
'2026-01-20',
|
|
{}, // No minimum_approvals
|
|
);
|
|
|
|
expect(notifySpy).toHaveBeenCalledWith(
|
|
'signoff_requested',
|
|
expect.objectContaining({
|
|
approvals_needed: 3, // ceil(5 * 0.5) = 3
|
|
}),
|
|
);
|
|
});
|
|
});
|
|
|
|
// ============ notifySignoffReceived Tests ============
|
|
|
|
describe('notifySignoffReceived', () => {
|
|
let service;
|
|
let notifySpy;
|
|
|
|
beforeEach(() => {
|
|
service = new NotificationService({
|
|
github: { owner: 'test', repo: 'test' },
|
|
});
|
|
|
|
notifySpy = vi.spyOn(service, 'notify').mockResolvedValue({ success: true });
|
|
});
|
|
|
|
it('should format approved signoff correctly', async () => {
|
|
await service.notifySignoffReceived(
|
|
{
|
|
user: 'alice',
|
|
decision: 'approved',
|
|
note: null,
|
|
},
|
|
{
|
|
type: 'prd',
|
|
key: 'test',
|
|
reviewIssue: 100,
|
|
reviewUrl: 'https://example.com/issues/100',
|
|
},
|
|
{ current: 2, total: 3 },
|
|
);
|
|
|
|
expect(notifySpy).toHaveBeenCalledWith(
|
|
'signoff_received',
|
|
expect.objectContaining({
|
|
document_type: 'prd',
|
|
document_key: 'test',
|
|
user: 'alice',
|
|
decision: 'approved',
|
|
emoji: '✅',
|
|
progress_current: 2,
|
|
progress_total: 3,
|
|
}),
|
|
);
|
|
});
|
|
|
|
it('should format blocked signoff with correct emoji', async () => {
|
|
await service.notifySignoffReceived(
|
|
{
|
|
user: 'security',
|
|
decision: 'blocked',
|
|
note: 'Security concern',
|
|
},
|
|
{
|
|
type: 'prd',
|
|
key: 'test',
|
|
reviewIssue: 100,
|
|
},
|
|
{ current: 1, total: 3 },
|
|
);
|
|
|
|
expect(notifySpy).toHaveBeenCalledWith(
|
|
'signoff_received',
|
|
expect.objectContaining({
|
|
decision: 'blocked',
|
|
emoji: '🚫',
|
|
note: 'Security concern',
|
|
}),
|
|
);
|
|
});
|
|
|
|
it('should format approved-with-note signoff correctly', async () => {
|
|
await service.notifySignoffReceived(
|
|
{
|
|
user: 'bob',
|
|
decision: 'approved-with-note',
|
|
note: 'Minor concern',
|
|
},
|
|
{
|
|
type: 'prd',
|
|
key: 'test',
|
|
reviewIssue: 100,
|
|
},
|
|
{ current: 2, total: 3 },
|
|
);
|
|
|
|
expect(notifySpy).toHaveBeenCalledWith(
|
|
'signoff_received',
|
|
expect.objectContaining({
|
|
emoji: '✅📝',
|
|
note: 'Minor concern',
|
|
}),
|
|
);
|
|
});
|
|
});
|
|
|
|
// ============ notifyDocumentApproved Tests ============
|
|
|
|
describe('notifyDocumentApproved', () => {
|
|
let service;
|
|
let notifySpy;
|
|
|
|
beforeEach(() => {
|
|
service = new NotificationService({
|
|
github: { owner: 'test', repo: 'test' },
|
|
});
|
|
|
|
notifySpy = vi.spyOn(service, 'notify').mockResolvedValue({ success: true });
|
|
});
|
|
|
|
it('should format approval data correctly', async () => {
|
|
await service.notifyDocumentApproved(
|
|
{
|
|
type: 'prd',
|
|
key: 'user-auth',
|
|
title: 'User Authentication',
|
|
version: 2,
|
|
url: 'https://example.com/doc',
|
|
},
|
|
3,
|
|
3,
|
|
);
|
|
|
|
expect(notifySpy).toHaveBeenCalledWith(
|
|
'document_approved',
|
|
expect.objectContaining({
|
|
document_type: 'prd',
|
|
document_key: 'user-auth',
|
|
title: 'User Authentication',
|
|
version: 2,
|
|
approval_count: 3,
|
|
stakeholder_count: 3,
|
|
document_url: 'https://example.com/doc',
|
|
}),
|
|
);
|
|
});
|
|
});
|
|
|
|
// ============ notifyDocumentBlocked Tests ============
|
|
|
|
describe('notifyDocumentBlocked', () => {
|
|
let service;
|
|
let notifySpy;
|
|
|
|
beforeEach(() => {
|
|
service = new NotificationService({
|
|
github: { owner: 'test', repo: 'test' },
|
|
});
|
|
|
|
notifySpy = vi.spyOn(service, 'notify').mockResolvedValue({ success: true });
|
|
});
|
|
|
|
it('should format block data correctly', async () => {
|
|
await service.notifyDocumentBlocked(
|
|
{
|
|
type: 'prd',
|
|
key: 'payments',
|
|
},
|
|
{
|
|
user: 'legal',
|
|
reason: 'GDPR compliance review required',
|
|
feedbackIssue: 42,
|
|
feedbackUrl: 'https://example.com/issues/42',
|
|
},
|
|
);
|
|
|
|
expect(notifySpy).toHaveBeenCalledWith(
|
|
'document_blocked',
|
|
expect.objectContaining({
|
|
document_type: 'prd',
|
|
document_key: 'payments',
|
|
user: 'legal',
|
|
reason: 'GDPR compliance review required',
|
|
feedback_issue: 42,
|
|
feedback_url: 'https://example.com/issues/42',
|
|
}),
|
|
);
|
|
});
|
|
});
|
|
|
|
// ============ Retry Logic Tests ============
|
|
|
|
describe('retry logic', () => {
|
|
let service;
|
|
let mockGithubSend;
|
|
|
|
beforeEach(() => {
|
|
mockGithubSend = vi.fn();
|
|
|
|
service = new NotificationService({
|
|
github: { owner: 'test', repo: 'test' },
|
|
});
|
|
|
|
service.channels.github.send = mockGithubSend;
|
|
});
|
|
|
|
it('should retry on failure for urgent priority', async () => {
|
|
let attempts = 0;
|
|
mockGithubSend.mockImplementation(() => {
|
|
attempts++;
|
|
if (attempts < 3) {
|
|
return Promise.resolve({ success: false, error: 'Temporary failure' });
|
|
}
|
|
return Promise.resolve({ success: true, channel: 'github' });
|
|
});
|
|
|
|
const result = await service.notify('document_blocked', {
|
|
document_type: 'prd',
|
|
document_key: 'test',
|
|
user: 'blocker',
|
|
reason: 'Issue',
|
|
});
|
|
|
|
expect(result.success).toBe(true);
|
|
expect(mockGithubSend).toHaveBeenCalledTimes(3);
|
|
}, 10000);
|
|
|
|
it('should not retry for normal priority', async () => {
|
|
mockGithubSend.mockResolvedValue({ success: false, error: 'Failed' });
|
|
|
|
const result = await service.notify('deadline_extended', {
|
|
document_type: 'prd',
|
|
document_key: 'test',
|
|
});
|
|
|
|
expect(result.results.github.success).toBe(false);
|
|
expect(mockGithubSend).toHaveBeenCalledTimes(1);
|
|
});
|
|
});
|
|
});
|