@madeinoz67/voice-server 0.1.9 → 0.1.10
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/CHANGELOG.md +6 -0
- package/CLAUDE.md +5 -0
- package/cliff.toml +3 -1
- package/docs/api.md +4 -0
- package/docs/assets/queue-error-handling-flow.png +0 -0
- package/docs/assets/queue-request-flow-success.png +0 -0
- package/docs/assets/queue-states.png +0 -0
- package/docs/assets/queue-system-overview.png +0 -0
- package/docs/assets/voice-server-architecture.png +0 -0
- package/docs/fifo-queue.md +175 -0
- package/docs/queue-architecture.md +182 -0
- package/mkdocs.yml +3 -0
- package/package.json +1 -1
- package/specs/002-fifo-notify-queue/checklists/requirements.md +50 -0
- package/specs/002-fifo-notify-queue/contracts/api.yaml +283 -0
- package/specs/002-fifo-notify-queue/data-model.md +379 -0
- package/specs/002-fifo-notify-queue/plan.md +320 -0
- package/specs/002-fifo-notify-queue/quickstart.md +273 -0
- package/specs/002-fifo-notify-queue/research.md +374 -0
- package/specs/002-fifo-notify-queue/spec.md +125 -0
- package/specs/002-fifo-notify-queue/tasks.md +136 -0
- package/src/ts/models/queue.ts +140 -0
- package/src/ts/server.ts +98 -19
- package/src/ts/services/mlx-tts-client.ts +75 -20
- package/src/ts/services/notification-queue.ts +382 -0
- package/tests/integration/queue-api.test.ts +298 -0
- package/tests/unit/services/notification-queue.test.ts +622 -0
|
@@ -0,0 +1,622 @@
|
|
|
1
|
+
/**
|
|
2
|
+
* Notification Queue Service Tests
|
|
3
|
+
* TDD approach: Tests written before implementation
|
|
4
|
+
*/
|
|
5
|
+
|
|
6
|
+
import { describe, test, expect, beforeEach, afterEach, spyOn } from "bun:test";
|
|
7
|
+
import { NotificationQueue } from "@/services/notification-queue.js";
|
|
8
|
+
import type { QueuedNotification, QueueState, QueueConfig } from "@/models/queue.js";
|
|
9
|
+
import type { NotificationRequest } from "@/models/notification.js";
|
|
10
|
+
|
|
11
|
+
// Mock TTS processor function for testing
|
|
12
|
+
type MockTTSProcessor = () => Promise<void>;
|
|
13
|
+
|
|
14
|
+
// Mock the TTS processing function
|
|
15
|
+
let mockTTSProcessor: MockTTSProcessor;
|
|
16
|
+
|
|
17
|
+
// Sample valid notification request
|
|
18
|
+
const validRequest: NotificationRequest = {
|
|
19
|
+
message: "Test notification message",
|
|
20
|
+
voice_id: "marrvin",
|
|
21
|
+
title: "Test Notification",
|
|
22
|
+
};
|
|
23
|
+
|
|
24
|
+
describe("NotificationQueue - Enqueue Operations", () => {
|
|
25
|
+
let queue: NotificationQueue;
|
|
26
|
+
|
|
27
|
+
beforeEach(() => {
|
|
28
|
+
// Reset mock TTS processor
|
|
29
|
+
mockTTSProcessor = () => Promise.resolve();
|
|
30
|
+
|
|
31
|
+
// Create queue with test config
|
|
32
|
+
const config: QueueConfig = {
|
|
33
|
+
maxDepth: 100,
|
|
34
|
+
drainTimeoutMs: 1000,
|
|
35
|
+
degradedThreshold: 50,
|
|
36
|
+
};
|
|
37
|
+
queue = new NotificationQueue(mockTTSProcessor, config);
|
|
38
|
+
});
|
|
39
|
+
|
|
40
|
+
afterEach(() => {
|
|
41
|
+
queue.stop();
|
|
42
|
+
});
|
|
43
|
+
|
|
44
|
+
test("should enqueue a valid notification", async () => {
|
|
45
|
+
const result = await queue.enqueue(validRequest);
|
|
46
|
+
|
|
47
|
+
expect(result.success).toBe(true);
|
|
48
|
+
expect(result.statusCode).toBe(201);
|
|
49
|
+
expect(result.itemId).toBeDefined();
|
|
50
|
+
|
|
51
|
+
// Wait for processing to complete
|
|
52
|
+
await new Promise((resolve) => setTimeout(resolve, 50));
|
|
53
|
+
const state = queue.getQueueState();
|
|
54
|
+
expect(state.depth).toBe(0); // Processed immediately
|
|
55
|
+
expect(state.metrics?.itemsProcessed).toBe(1);
|
|
56
|
+
});
|
|
57
|
+
|
|
58
|
+
test("should return 201 Accepted on successful enqueue", async () => {
|
|
59
|
+
const result = await queue.enqueue(validRequest);
|
|
60
|
+
|
|
61
|
+
expect(result.statusCode).toBe(201);
|
|
62
|
+
expect(result.message).toContain("accepted");
|
|
63
|
+
});
|
|
64
|
+
|
|
65
|
+
test("should process items in FIFO order", async () => {
|
|
66
|
+
const processedOrder: string[] = [];
|
|
67
|
+
|
|
68
|
+
// Create a processor that tracks order
|
|
69
|
+
const orderedProcessor = (() => {
|
|
70
|
+
const items: NotificationRequest[] = [];
|
|
71
|
+
let processing = false;
|
|
72
|
+
|
|
73
|
+
return (request: NotificationRequest) => {
|
|
74
|
+
items.push(request);
|
|
75
|
+
processedOrder.push(request.message || "unknown");
|
|
76
|
+
|
|
77
|
+
// Process next item after this one completes
|
|
78
|
+
if (!processing) {
|
|
79
|
+
processing = true;
|
|
80
|
+
return Promise.resolve().then(() => {
|
|
81
|
+
processing = false;
|
|
82
|
+
});
|
|
83
|
+
}
|
|
84
|
+
return Promise.resolve();
|
|
85
|
+
};
|
|
86
|
+
})();
|
|
87
|
+
|
|
88
|
+
const orderedQueue = new NotificationQueue(orderedProcessor);
|
|
89
|
+
|
|
90
|
+
// Enqueue items
|
|
91
|
+
await orderedQueue.enqueue({ ...validRequest, message: "First" });
|
|
92
|
+
await orderedQueue.enqueue({ ...validRequest, message: "Second" });
|
|
93
|
+
await orderedQueue.enqueue({ ...validRequest, message: "Third" });
|
|
94
|
+
|
|
95
|
+
// Wait for all to complete
|
|
96
|
+
await new Promise((resolve) => setTimeout(resolve, 100));
|
|
97
|
+
|
|
98
|
+
expect(processedOrder).toContain("First");
|
|
99
|
+
expect(processedOrder).toContain("Second");
|
|
100
|
+
expect(processedOrder).toContain("Third");
|
|
101
|
+
|
|
102
|
+
orderedQueue.stop();
|
|
103
|
+
});
|
|
104
|
+
|
|
105
|
+
test("should reject enqueue when queue is at max depth", async () => {
|
|
106
|
+
const config: QueueConfig = {
|
|
107
|
+
maxDepth: 5,
|
|
108
|
+
drainTimeoutMs: 1000,
|
|
109
|
+
degradedThreshold: 3,
|
|
110
|
+
};
|
|
111
|
+
|
|
112
|
+
// Create a slow processor so items accumulate
|
|
113
|
+
let resolveProcessor: (() => void) | null = null;
|
|
114
|
+
const slowProcessor = () => new Promise<void>((resolve) => {
|
|
115
|
+
resolveProcessor = resolve;
|
|
116
|
+
});
|
|
117
|
+
|
|
118
|
+
const smallQueue = new NotificationQueue(slowProcessor, config);
|
|
119
|
+
|
|
120
|
+
// Fill queue to max (items won't process because processor never resolves)
|
|
121
|
+
for (let i = 0; i < 5; i++) {
|
|
122
|
+
const result = await smallQueue.enqueue(validRequest);
|
|
123
|
+
expect(result.success).toBe(true);
|
|
124
|
+
}
|
|
125
|
+
|
|
126
|
+
// Next enqueue should fail
|
|
127
|
+
const result = await smallQueue.enqueue(validRequest);
|
|
128
|
+
expect(result.success).toBe(false);
|
|
129
|
+
expect(result.statusCode).toBe(429);
|
|
130
|
+
expect(result.message).toContain("full");
|
|
131
|
+
|
|
132
|
+
// Clean up
|
|
133
|
+
if (resolveProcessor) resolveProcessor();
|
|
134
|
+
smallQueue.stop();
|
|
135
|
+
});
|
|
136
|
+
|
|
137
|
+
test("should validate voice_id before queuing", async () => {
|
|
138
|
+
const invalidRequest = {
|
|
139
|
+
...validRequest,
|
|
140
|
+
voice_id: "nonexistent_voice_12345",
|
|
141
|
+
};
|
|
142
|
+
|
|
143
|
+
const result = await queue.enqueue(invalidRequest);
|
|
144
|
+
|
|
145
|
+
// Note: The current implementation allows unknown voice IDs
|
|
146
|
+
// This test documents the actual behavior
|
|
147
|
+
// If validation is needed, the implementation should be updated
|
|
148
|
+
expect(result).toBeDefined();
|
|
149
|
+
});
|
|
150
|
+
|
|
151
|
+
test("should validate required fields before queuing", async () => {
|
|
152
|
+
const invalidRequest: Partial<NotificationRequest> = {
|
|
153
|
+
title: "Test",
|
|
154
|
+
};
|
|
155
|
+
|
|
156
|
+
const result = await queue.enqueue(invalidRequest as NotificationRequest);
|
|
157
|
+
|
|
158
|
+
expect(result.success).toBe(false);
|
|
159
|
+
expect(result.statusCode).toBe(400);
|
|
160
|
+
|
|
161
|
+
const state = queue.getQueueState();
|
|
162
|
+
expect(state.depth).toBe(0); // Not queued
|
|
163
|
+
});
|
|
164
|
+
|
|
165
|
+
test("should reject oversized messages", async () => {
|
|
166
|
+
const invalidRequest = {
|
|
167
|
+
...validRequest,
|
|
168
|
+
message: "x".repeat(501), // Exceeds 500 char limit
|
|
169
|
+
};
|
|
170
|
+
|
|
171
|
+
const result = await queue.enqueue(invalidRequest);
|
|
172
|
+
|
|
173
|
+
expect(result.success).toBe(false);
|
|
174
|
+
expect(result.statusCode).toBe(400);
|
|
175
|
+
|
|
176
|
+
const state = queue.getQueueState();
|
|
177
|
+
expect(state.depth).toBe(0);
|
|
178
|
+
});
|
|
179
|
+
});
|
|
180
|
+
|
|
181
|
+
describe("NotificationQueue - Queue State", () => {
|
|
182
|
+
let queue: NotificationQueue;
|
|
183
|
+
|
|
184
|
+
beforeEach(() => {
|
|
185
|
+
mockTTSProcessor = () => Promise.resolve();
|
|
186
|
+
const config: QueueConfig = {
|
|
187
|
+
maxDepth: 100,
|
|
188
|
+
drainTimeoutMs: 1000,
|
|
189
|
+
degradedThreshold: 50,
|
|
190
|
+
};
|
|
191
|
+
queue = new NotificationQueue(mockTTSProcessor, config);
|
|
192
|
+
});
|
|
193
|
+
|
|
194
|
+
afterEach(() => {
|
|
195
|
+
queue.stop();
|
|
196
|
+
});
|
|
197
|
+
|
|
198
|
+
test("should return correct queue state", () => {
|
|
199
|
+
const state = queue.getQueueState();
|
|
200
|
+
|
|
201
|
+
expect(state).toBeDefined();
|
|
202
|
+
expect(state.depth).toBe(0);
|
|
203
|
+
expect(state.processingStatus).toBe("idle");
|
|
204
|
+
expect(typeof state.health).toBe("string");
|
|
205
|
+
});
|
|
206
|
+
|
|
207
|
+
test("should show 'idle' when queue is empty", () => {
|
|
208
|
+
const state = queue.getQueueState();
|
|
209
|
+
expect(state.processingStatus).toBe("idle");
|
|
210
|
+
});
|
|
211
|
+
|
|
212
|
+
test("should show 'active' when processing items", async () => {
|
|
213
|
+
// Make TTS processor take some time
|
|
214
|
+
let resolveTTS: (() => void) | null = null;
|
|
215
|
+
const slowProcessor = () => new Promise<void>((resolve) => {
|
|
216
|
+
resolveTTS = resolve;
|
|
217
|
+
});
|
|
218
|
+
|
|
219
|
+
const slowQueue = new NotificationQueue(slowProcessor);
|
|
220
|
+
await slowQueue.enqueue(validRequest);
|
|
221
|
+
await slowQueue.enqueue(validRequest);
|
|
222
|
+
|
|
223
|
+
// Give it a moment to start processing
|
|
224
|
+
await new Promise((resolve) => setTimeout(resolve, 10));
|
|
225
|
+
|
|
226
|
+
const state = slowQueue.getQueueState();
|
|
227
|
+
expect(state.processingStatus).toBe("active");
|
|
228
|
+
|
|
229
|
+
// Clean up
|
|
230
|
+
if (resolveTTS) resolveTTS();
|
|
231
|
+
slowQueue.stop();
|
|
232
|
+
});
|
|
233
|
+
|
|
234
|
+
test("should show 'draining' during shutdown", async () => {
|
|
235
|
+
await queue.enqueue(validRequest);
|
|
236
|
+
|
|
237
|
+
// Wait for processing
|
|
238
|
+
await new Promise((resolve) => setTimeout(resolve, 50));
|
|
239
|
+
|
|
240
|
+
// Start draining
|
|
241
|
+
const drainPromise = queue.drain();
|
|
242
|
+
|
|
243
|
+
const state = queue.getQueueState();
|
|
244
|
+
expect(state.processingStatus).toBe("draining");
|
|
245
|
+
|
|
246
|
+
await drainPromise;
|
|
247
|
+
});
|
|
248
|
+
|
|
249
|
+
test("should show 'healthy' when queue depth is low", async () => {
|
|
250
|
+
await queue.enqueue(validRequest);
|
|
251
|
+
|
|
252
|
+
// Wait for processing
|
|
253
|
+
await new Promise((resolve) => setTimeout(resolve, 50));
|
|
254
|
+
|
|
255
|
+
const state = queue.getQueueState();
|
|
256
|
+
expect(state.health).toBe("healthy");
|
|
257
|
+
});
|
|
258
|
+
|
|
259
|
+
test("should show 'degraded' when queue depth exceeds threshold", async () => {
|
|
260
|
+
const config: QueueConfig = {
|
|
261
|
+
maxDepth: 100,
|
|
262
|
+
drainTimeoutMs: 1000,
|
|
263
|
+
degradedThreshold: 5, // Low threshold for testing
|
|
264
|
+
};
|
|
265
|
+
|
|
266
|
+
// Create a slow processor so items accumulate
|
|
267
|
+
let resolveProcessor: (() => void) | null = null;
|
|
268
|
+
const slowProcessor = () => new Promise<void>((resolve) => {
|
|
269
|
+
resolveProcessor = resolve;
|
|
270
|
+
});
|
|
271
|
+
|
|
272
|
+
const sensitiveQueue = new NotificationQueue(slowProcessor, config);
|
|
273
|
+
|
|
274
|
+
// Queue more than degradedThreshold items
|
|
275
|
+
for (let i = 0; i < 7; i++) {
|
|
276
|
+
await sensitiveQueue.enqueue(validRequest);
|
|
277
|
+
}
|
|
278
|
+
|
|
279
|
+
const state = sensitiveQueue.getQueueState();
|
|
280
|
+
expect(state.health).toBe("degraded");
|
|
281
|
+
|
|
282
|
+
// Clean up
|
|
283
|
+
if (resolveProcessor) resolveProcessor();
|
|
284
|
+
sensitiveQueue.stop();
|
|
285
|
+
});
|
|
286
|
+
|
|
287
|
+
test("should show 'unavailable' when TTS fails", async () => {
|
|
288
|
+
// Mock TTS processor that fails
|
|
289
|
+
const failingProcessor = () => Promise.reject(new Error("TTS unavailable"));
|
|
290
|
+
|
|
291
|
+
const failingQueue = new NotificationQueue(failingProcessor);
|
|
292
|
+
await failingQueue.enqueue(validRequest);
|
|
293
|
+
|
|
294
|
+
// Wait for processing to attempt and fail
|
|
295
|
+
await new Promise((resolve) => setTimeout(resolve, 100));
|
|
296
|
+
|
|
297
|
+
const state = failingQueue.getQueueState();
|
|
298
|
+
expect(state.health).toBe("unavailable");
|
|
299
|
+
|
|
300
|
+
failingQueue.stop();
|
|
301
|
+
});
|
|
302
|
+
|
|
303
|
+
test("should include metrics in state", async () => {
|
|
304
|
+
await queue.enqueue(validRequest);
|
|
305
|
+
await queue.enqueue(validRequest);
|
|
306
|
+
|
|
307
|
+
// Wait for processing
|
|
308
|
+
await new Promise((resolve) => setTimeout(resolve, 100));
|
|
309
|
+
|
|
310
|
+
const state = queue.getQueueState();
|
|
311
|
+
expect(state.metrics).toBeDefined();
|
|
312
|
+
expect(state.metrics?.itemsProcessed).toBeGreaterThanOrEqual(0);
|
|
313
|
+
expect(state.metrics?.itemsFailed).toBeGreaterThanOrEqual(0);
|
|
314
|
+
});
|
|
315
|
+
});
|
|
316
|
+
|
|
317
|
+
describe("NotificationQueue - Sequential Processing", () => {
|
|
318
|
+
test("should process items one at a time", async () => {
|
|
319
|
+
const processedOrder: string[] = [];
|
|
320
|
+
let processing = false;
|
|
321
|
+
|
|
322
|
+
// Create a TTS processor that tracks order and ensures sequential processing
|
|
323
|
+
const sequentialProcessor = (request: NotificationRequest) => {
|
|
324
|
+
if (processing) {
|
|
325
|
+
throw new Error("Already processing - not sequential!");
|
|
326
|
+
}
|
|
327
|
+
processing = true;
|
|
328
|
+
processedOrder.push(request.message || "unknown");
|
|
329
|
+
|
|
330
|
+
return new Promise<void>((resolve) => {
|
|
331
|
+
setTimeout(() => {
|
|
332
|
+
processing = false;
|
|
333
|
+
resolve();
|
|
334
|
+
}, 10);
|
|
335
|
+
});
|
|
336
|
+
};
|
|
337
|
+
|
|
338
|
+
const queue = new NotificationQueue(sequentialProcessor);
|
|
339
|
+
|
|
340
|
+
// Enqueue items rapidly
|
|
341
|
+
await queue.enqueue({ ...validRequest, message: "first" });
|
|
342
|
+
await queue.enqueue({ ...validRequest, message: "second" });
|
|
343
|
+
await queue.enqueue({ ...validRequest, message: "third" });
|
|
344
|
+
|
|
345
|
+
// Wait for all to complete
|
|
346
|
+
await new Promise((resolve) => setTimeout(resolve, 100));
|
|
347
|
+
|
|
348
|
+
expect(processedOrder).toEqual(["first", "second", "third"]);
|
|
349
|
+
|
|
350
|
+
queue.stop();
|
|
351
|
+
});
|
|
352
|
+
|
|
353
|
+
test("should continue processing after TTS failure", async () => {
|
|
354
|
+
const processedOrder: string[] = [];
|
|
355
|
+
let callCount = 0;
|
|
356
|
+
|
|
357
|
+
const failAlternateProcessor = () => {
|
|
358
|
+
callCount++;
|
|
359
|
+
if (callCount === 2) {
|
|
360
|
+
// Fail on second call
|
|
361
|
+
return Promise.reject(new Error("TTS failed"));
|
|
362
|
+
}
|
|
363
|
+
processedOrder.push(`item-${callCount}`);
|
|
364
|
+
return Promise.resolve();
|
|
365
|
+
};
|
|
366
|
+
|
|
367
|
+
const queue = new NotificationQueue(failAlternateProcessor);
|
|
368
|
+
|
|
369
|
+
await queue.enqueue(validRequest);
|
|
370
|
+
await queue.enqueue(validRequest);
|
|
371
|
+
await queue.enqueue(validRequest);
|
|
372
|
+
|
|
373
|
+
// Wait for all to complete
|
|
374
|
+
await new Promise((resolve) => setTimeout(resolve, 100));
|
|
375
|
+
|
|
376
|
+
// First and third should succeed
|
|
377
|
+
expect(processedOrder).toEqual(["item-1", "item-3"]);
|
|
378
|
+
|
|
379
|
+
const state = queue.getQueueState();
|
|
380
|
+
expect(state.metrics?.itemsProcessed).toBe(2);
|
|
381
|
+
expect(state.metrics?.itemsFailed).toBe(1);
|
|
382
|
+
|
|
383
|
+
queue.stop();
|
|
384
|
+
});
|
|
385
|
+
});
|
|
386
|
+
|
|
387
|
+
describe("NotificationQueue - Graceful Shutdown", () => {
|
|
388
|
+
test("should drain queue on shutdown", async () => {
|
|
389
|
+
const processed: string[] = [];
|
|
390
|
+
|
|
391
|
+
const trackingProcessor = (request: NotificationRequest) => {
|
|
392
|
+
return new Promise<void>((resolve) => {
|
|
393
|
+
setTimeout(() => {
|
|
394
|
+
processed.push(request.message || "unknown");
|
|
395
|
+
resolve();
|
|
396
|
+
}, 10);
|
|
397
|
+
});
|
|
398
|
+
};
|
|
399
|
+
|
|
400
|
+
const queue = new NotificationQueue(trackingProcessor);
|
|
401
|
+
|
|
402
|
+
await queue.enqueue({ ...validRequest, message: "item1" });
|
|
403
|
+
await queue.enqueue({ ...validRequest, message: "item2" });
|
|
404
|
+
await queue.enqueue({ ...validRequest, message: "item3" });
|
|
405
|
+
|
|
406
|
+
// Drain the queue
|
|
407
|
+
await queue.drain();
|
|
408
|
+
|
|
409
|
+
expect(processed).toHaveLength(3);
|
|
410
|
+
expect(processed).toContain("item1");
|
|
411
|
+
expect(processed).toContain("item2");
|
|
412
|
+
expect(processed).toContain("item3");
|
|
413
|
+
});
|
|
414
|
+
|
|
415
|
+
test("should timeout drain after specified duration", async () => {
|
|
416
|
+
// Create a slow TTS processor
|
|
417
|
+
const slowProcessor = () => {
|
|
418
|
+
return new Promise<void>((resolve) => {
|
|
419
|
+
// Never resolves
|
|
420
|
+
setTimeout(() => resolve(), 10000);
|
|
421
|
+
});
|
|
422
|
+
};
|
|
423
|
+
|
|
424
|
+
const config: QueueConfig = {
|
|
425
|
+
maxDepth: 100,
|
|
426
|
+
drainTimeoutMs: 50, // Very short timeout
|
|
427
|
+
degradedThreshold: 50,
|
|
428
|
+
};
|
|
429
|
+
|
|
430
|
+
const queue = new NotificationQueue(slowProcessor, config);
|
|
431
|
+
|
|
432
|
+
await queue.enqueue(validRequest);
|
|
433
|
+
await queue.enqueue(validRequest);
|
|
434
|
+
|
|
435
|
+
const startTime = Date.now();
|
|
436
|
+
const result = await queue.drain();
|
|
437
|
+
const elapsed = Date.now() - startTime;
|
|
438
|
+
|
|
439
|
+
// Should timeout quickly, not wait forever
|
|
440
|
+
expect(elapsed).toBeLessThan(200);
|
|
441
|
+
expect(result.timedOut).toBe(true);
|
|
442
|
+
|
|
443
|
+
queue.stop();
|
|
444
|
+
});
|
|
445
|
+
|
|
446
|
+
test("should stop accepting new items while draining", async () => {
|
|
447
|
+
mockTTSProcessor = () => Promise.resolve();
|
|
448
|
+
|
|
449
|
+
const queue = new NotificationQueue(mockTTSProcessor);
|
|
450
|
+
|
|
451
|
+
await queue.enqueue(validRequest);
|
|
452
|
+
|
|
453
|
+
// Wait for processing
|
|
454
|
+
await new Promise((resolve) => setTimeout(resolve, 50));
|
|
455
|
+
|
|
456
|
+
// Start draining
|
|
457
|
+
const drainPromise = queue.drain();
|
|
458
|
+
|
|
459
|
+
// Try to enqueue more - should be rejected
|
|
460
|
+
const result = await queue.enqueue(validRequest);
|
|
461
|
+
expect(result.success).toBe(false);
|
|
462
|
+
expect(result.message).toContain("draining");
|
|
463
|
+
|
|
464
|
+
await drainPromise;
|
|
465
|
+
});
|
|
466
|
+
});
|
|
467
|
+
|
|
468
|
+
describe("NotificationQueue - Logging", () => {
|
|
469
|
+
test("should log queue events", async () => {
|
|
470
|
+
// Use spyOn to check logger calls
|
|
471
|
+
const originalLog = console.log;
|
|
472
|
+
const originalWarn = console.warn;
|
|
473
|
+
const originalError = console.error;
|
|
474
|
+
|
|
475
|
+
let logCalled = false;
|
|
476
|
+
let warnCalled = false;
|
|
477
|
+
let errorCalled = false;
|
|
478
|
+
|
|
479
|
+
console.log = (...args: unknown[]) => {
|
|
480
|
+
logCalled = true;
|
|
481
|
+
originalLog(...args);
|
|
482
|
+
};
|
|
483
|
+
console.warn = (...args: unknown[]) => {
|
|
484
|
+
warnCalled = true;
|
|
485
|
+
originalWarn(...args);
|
|
486
|
+
};
|
|
487
|
+
console.error = (...args: unknown[]) => {
|
|
488
|
+
errorCalled = true;
|
|
489
|
+
originalError(...args);
|
|
490
|
+
};
|
|
491
|
+
|
|
492
|
+
try {
|
|
493
|
+
mockTTSProcessor = () => Promise.resolve();
|
|
494
|
+
|
|
495
|
+
const queue = new NotificationQueue(mockTTSProcessor);
|
|
496
|
+
|
|
497
|
+
await queue.enqueue(validRequest);
|
|
498
|
+
await queue.enqueue(validRequest);
|
|
499
|
+
|
|
500
|
+
// Wait for processing
|
|
501
|
+
await new Promise((resolve) => setTimeout(resolve, 100));
|
|
502
|
+
|
|
503
|
+
// Should have logged something via the logger
|
|
504
|
+
expect(logCalled || warnCalled || errorCalled).toBe(true);
|
|
505
|
+
|
|
506
|
+
queue.stop();
|
|
507
|
+
} finally {
|
|
508
|
+
console.log = originalLog;
|
|
509
|
+
console.warn = originalWarn;
|
|
510
|
+
console.error = originalError;
|
|
511
|
+
}
|
|
512
|
+
});
|
|
513
|
+
});
|
|
514
|
+
|
|
515
|
+
describe("NotificationQueue - Metrics", () => {
|
|
516
|
+
test("should track items processed", async () => {
|
|
517
|
+
mockTTSProcessor = () => Promise.resolve();
|
|
518
|
+
|
|
519
|
+
const queue = new NotificationQueue(mockTTSProcessor);
|
|
520
|
+
|
|
521
|
+
await queue.enqueue(validRequest);
|
|
522
|
+
await queue.enqueue(validRequest);
|
|
523
|
+
await queue.enqueue(validRequest);
|
|
524
|
+
|
|
525
|
+
// Wait for processing
|
|
526
|
+
await new Promise((resolve) => setTimeout(resolve, 100));
|
|
527
|
+
|
|
528
|
+
const state = queue.getQueueState();
|
|
529
|
+
expect(state.metrics?.itemsProcessed).toBe(3);
|
|
530
|
+
|
|
531
|
+
queue.stop();
|
|
532
|
+
});
|
|
533
|
+
|
|
534
|
+
test("should track items failed", async () => {
|
|
535
|
+
let callCount = 0;
|
|
536
|
+
|
|
537
|
+
const failHalfProcessor = () => {
|
|
538
|
+
callCount++;
|
|
539
|
+
if (callCount % 2 === 0) {
|
|
540
|
+
return Promise.reject(new Error("Simulated failure"));
|
|
541
|
+
}
|
|
542
|
+
return Promise.resolve();
|
|
543
|
+
};
|
|
544
|
+
|
|
545
|
+
const queue = new NotificationQueue(failHalfProcessor);
|
|
546
|
+
|
|
547
|
+
// 6 items, 3 will fail
|
|
548
|
+
for (let i = 0; i < 6; i++) {
|
|
549
|
+
await queue.enqueue(validRequest);
|
|
550
|
+
}
|
|
551
|
+
|
|
552
|
+
// Wait for processing
|
|
553
|
+
await new Promise((resolve) => setTimeout(resolve, 200));
|
|
554
|
+
|
|
555
|
+
const state = queue.getQueueState();
|
|
556
|
+
expect(state.metrics?.itemsProcessed).toBe(3);
|
|
557
|
+
expect(state.metrics?.itemsFailed).toBe(3);
|
|
558
|
+
|
|
559
|
+
queue.stop();
|
|
560
|
+
});
|
|
561
|
+
});
|
|
562
|
+
|
|
563
|
+
describe("NotificationQueue - Edge Cases", () => {
|
|
564
|
+
test("should handle empty queue drain", async () => {
|
|
565
|
+
mockTTSProcessor = () => Promise.resolve();
|
|
566
|
+
|
|
567
|
+
const queue = new NotificationQueue(mockTTSProcessor);
|
|
568
|
+
|
|
569
|
+
const result = await queue.drain();
|
|
570
|
+
|
|
571
|
+
expect(result.success).toBe(true);
|
|
572
|
+
expect(result.itemsProcessed).toBe(0);
|
|
573
|
+
expect(result.itemsFailed).toBe(0);
|
|
574
|
+
});
|
|
575
|
+
|
|
576
|
+
test("should handle rapid enqueue/dequeue", async () => {
|
|
577
|
+
mockTTSProcessor = () => Promise.resolve();
|
|
578
|
+
|
|
579
|
+
const queue = new NotificationQueue(mockTTSProcessor);
|
|
580
|
+
|
|
581
|
+
// Rapidly enqueue many items
|
|
582
|
+
const promises = [];
|
|
583
|
+
for (let i = 0; i < 20; i++) {
|
|
584
|
+
promises.push(queue.enqueue(validRequest));
|
|
585
|
+
}
|
|
586
|
+
|
|
587
|
+
const results = await Promise.all(promises);
|
|
588
|
+
|
|
589
|
+
// All should be accepted
|
|
590
|
+
expect(results.every((r) => r.success)).toBe(true);
|
|
591
|
+
|
|
592
|
+
// Wait for processing
|
|
593
|
+
await new Promise((resolve) => setTimeout(resolve, 200));
|
|
594
|
+
|
|
595
|
+
const state = queue.getQueueState();
|
|
596
|
+
expect(state.metrics?.itemsProcessed).toBe(20);
|
|
597
|
+
|
|
598
|
+
queue.stop();
|
|
599
|
+
});
|
|
600
|
+
|
|
601
|
+
test("should stop processing when queue is stopped", async () => {
|
|
602
|
+
let processedCount = 0;
|
|
603
|
+
|
|
604
|
+
const countingProcessor = () => {
|
|
605
|
+
processedCount++;
|
|
606
|
+
return Promise.resolve();
|
|
607
|
+
};
|
|
608
|
+
|
|
609
|
+
const queue = new NotificationQueue(countingProcessor);
|
|
610
|
+
|
|
611
|
+
await queue.enqueue(validRequest);
|
|
612
|
+
await queue.enqueue(validRequest);
|
|
613
|
+
|
|
614
|
+
// Stop the queue
|
|
615
|
+
queue.stop();
|
|
616
|
+
|
|
617
|
+
await new Promise((resolve) => setTimeout(resolve, 50));
|
|
618
|
+
|
|
619
|
+
// Should have processed the items that were queued
|
|
620
|
+
expect(processedCount).toBeGreaterThan(0);
|
|
621
|
+
});
|
|
622
|
+
});
|