@mndrk/agx 2.0.0-next.9 → 2.0.0

package/cloud-runtime/standalone/Projects/Agents/agx-cloud/tests/projector/flood.test.js

@@ -0,0 +1,162 @@
+/**
+ * @jest-environment node
+ *
+ * Flood test: send 10k events rapidly across multiple users/tasks and assert:
+ *   - All notifications are accounted for (no missed events)
+ *   - No race conditions (exactly-once via DB unique key)
+ *   - Cursor advances correctly through all batches
+ *   - Per-user unread cap is enforced
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { tmpDbPath, makeDb, insertTask, insertAuditEvent, loadProjectorWithDb, countRows } = require('./_helpers');
+
+const BATCH_SIZE = 100; // must match projector constant
+
+describe('projector flood test', () => {
+  let dbPath, db;
+
+  beforeEach(() => {
+    dbPath = tmpDbPath();
+    db = makeDb(dbPath);
+    jest.resetModules();
+  });
+
+  afterEach(() => {
+    db.close();
+    fs.rmSync(path.dirname(dbPath), { recursive: true });
+  });
+
+  test('10k events across multiple tasks are all processed without loss', () => {
+    const { projector, cursors } = loadProjectorWithDb(db);
+    const EVENT_COUNT = 10_000;
+    const USER_COUNT = 5;
+    const TASKS_PER_USER = 4;
+    const actions = ['complete', 'fail', 'dispatch', 'execute', 'reject'];
+
+    // Create tasks
+    const taskMatrix = [];
+    for (let u = 0; u < USER_COUNT; u++) {
+      const userId = `flood-user-${u}`;
+      const userTasks = [];
+      for (let t = 0; t < TASKS_PER_USER; t++) {
+        userTasks.push(insertTask(db, { userId, title: `Task u${u}t${t}` }));
+      }
+      taskMatrix.push({ userId, tasks: userTasks });
+    }
+
+    // Insert all events
+    const eventIds = [];
+    for (let i = 0; i < EVENT_COUNT; i++) {
+      const { userId, tasks } = taskMatrix[i % USER_COUNT];
+      const taskId = tasks[i % TASKS_PER_USER];
+      const action = actions[i % actions.length];
+      eventIds.push(insertAuditEvent(db, { taskId, userId, action }));
+    }
+
+    // Process in batches (ceil(10000/100) = 100 runOnce calls)
+    const batchCount = Math.ceil(EVENT_COUNT / BATCH_SIZE);
+    for (let b = 0; b < batchCount; b++) {
+      projector.runOnce();
+    }
+
+    const notifCount = countRows(db, 'notifications');
+    const outboxCount = countRows(db, 'notification_outbox');
+
+    // Every notification must have an outbox entry
+    expect(outboxCount).toBe(notifCount);
+
+    // Notifications ≤ events (dedup may reduce count, debounce may suppress some)
+    expect(notifCount).toBeGreaterThan(0);
+    expect(notifCount).toBeLessThanOrEqual(EVENT_COUNT);
+
+    // Cursor should be at or past all events
+    const finalCursor = cursors.readCursor('notification_projector');
+    expect(finalCursor).toBeGreaterThan(0);
+
+    // No more events to process after full run
+    const extra = projector.runOnce();
+    expect(extra).toBe(0);
+  }, 30_000); // 30s timeout for 10k events
+
+  test('flood replay produces no additional notifications', () => {
+    const { projector, cursors } = loadProjectorWithDb(db);
+    const EVENT_COUNT = 1000;
+    const userId = 'replay-user';
+    const taskId = insertTask(db, { userId });
+    const actions = ['complete', 'fail', 'dispatch', 'execute', 'reject'];
+
+    for (let i = 0; i < EVENT_COUNT; i++) {
+      insertAuditEvent(db, { taskId, userId, action: actions[i % actions.length] });
+    }
+
+    // Full processing
+    const batches = Math.ceil(EVENT_COUNT / BATCH_SIZE);
+    for (let b = 0; b < batches; b++) projector.runOnce();
+
+    const originalCount = countRows(db, 'notifications');
+    expect(originalCount).toBeGreaterThan(0);
+
+    // Full replay
+    cursors.resetCursor('notification_projector');
+    for (let b = 0; b < batches; b++) projector.runOnce();
+
+    // Count must not change after full replay
+    expect(countRows(db, 'notifications')).toBe(originalCount);
+    expect(countRows(db, 'notification_outbox')).toBe(originalCount);
+  }, 15_000);
+
+  test('per-user unread cap is enforced during flood', () => {
+    const { projector } = loadProjectorWithDb(db);
+    const MAX_UNREAD = 500;
+    const EVENT_COUNT = 600; // exceed the cap
+    const userId = 'cap-user';
+
+    // Create enough tasks to avoid same-event_id dedup
+    const tasks = [];
+    for (let i = 0; i < 10; i++) {
+      tasks.push(insertTask(db, { userId, title: `Cap Task ${i}` }));
+    }
+
+    for (let i = 0; i < EVENT_COUNT; i++) {
+      insertAuditEvent(db, { taskId: tasks[i % tasks.length], userId, action: 'complete' });
+    }
+
+    const batches = Math.ceil(EVENT_COUNT / BATCH_SIZE);
+    for (let b = 0; b < batches; b++) projector.runOnce();
+
+    const unread = db.prepare(
+      'SELECT COUNT(*) AS n FROM notifications WHERE user_id = ? AND read_at IS NULL'
+    ).get(userId).n;
+
+    // Cap enforced: at most MAX_UNREAD unread per user
+    expect(unread).toBeLessThanOrEqual(MAX_UNREAD);
+  }, 15_000);
+
+  test('outbox notification_id references are always valid', () => {
+    const { projector } = loadProjectorWithDb(db);
+    const EVENT_COUNT = 500;
+    const userId = 'fk-user';
+    const taskId = insertTask(db, { userId });
+    const actions = ['complete', 'fail', 'dispatch'];
+
+    for (let i = 0; i < EVENT_COUNT; i++) {
+      insertAuditEvent(db, { taskId, userId, action: actions[i % actions.length] });
+    }
+
+    const batches = Math.ceil(EVENT_COUNT / BATCH_SIZE);
+    for (let b = 0; b < batches; b++) projector.runOnce();
+
+    // All outbox rows must reference valid notification ids
+    const orphans = db.prepare(`
+      SELECT COUNT(*) AS n FROM notification_outbox o
+      LEFT JOIN notifications n ON n.id = o.notification_id
+      WHERE n.id IS NULL
+    `).get().n;
+
+    expect(orphans).toBe(0);
+  }, 15_000);
+});

package/cloud-runtime/standalone/Projects/Agents/agx-cloud/tests/projector/replay.test.js

@@ -0,0 +1,107 @@
+/**
+ * @jest-environment node
+ *
+ * Replay test: feed the full event history through the projector twice
+ * (cursor reset between runs) and assert zero duplicate notifications.
+ */
+
+'use strict';
+
+const fs = require('fs');
+const { tmpDbPath, makeDb, insertTask, insertAuditEvent, loadProjectorWithDb, countRows } = require('./_helpers');
+
+describe('projector replay test', () => {
+  let dbPath, db;
+
+  beforeEach(() => {
+    dbPath = tmpDbPath();
+    db = makeDb(dbPath);
+    jest.resetModules();
+  });
+
+  afterEach(() => {
+    db.close();
+    fs.rmSync(require('path').dirname(dbPath), { recursive: true });
+  });
+
+  test('replay of 100 complete events produces no duplicate notifications', () => {
+    const { projector, cursors } = loadProjectorWithDb(db);
+    const userId = 'user-replay';
+    const taskId = insertTask(db, { userId, title: 'Replay Task' });
+
+    for (let i = 0; i < 100; i++) {
+      insertAuditEvent(db, { taskId, userId, action: 'complete' });
+    }
+
+    // First pass — process all 100 events
+    projector.runOnce();
+    const after100 = countRows(db, 'notifications');
+    expect(after100).toBe(100);
+
+    const outboxAfter100 = countRows(db, 'notification_outbox');
+    expect(outboxAfter100).toBe(100);
+
+    // Reset cursor to force full replay
+    cursors.resetCursor('notification_projector');
+
+    // Second pass (replay batch 1 of up to 100)
+    projector.runOnce();
+    const afterReplay1 = countRows(db, 'notifications');
+    expect(afterReplay1).toBe(100); // no new rows — all were duplicates
+
+    // Third pass (replay remainder — none in this case, but ensures cursor is idempotent)
+    projector.runOnce();
+    const afterReplay2 = countRows(db, 'notifications');
+    expect(afterReplay2).toBe(100);
+  });
+
+  test('replay of mixed-action events produces no duplicates', () => {
+    const { projector, cursors } = loadProjectorWithDb(db);
+    const actions = ['complete', 'fail', 'dispatch', 'execute', 'reject'];
+    const userId = 'user-mixed';
+    const taskId = insertTask(db, { userId, title: 'Mixed Task' });
+
+    // 50 events, varied actions
+    for (let i = 0; i < 50; i++) {
+      insertAuditEvent(db, { taskId, userId, action: actions[i % actions.length] });
+    }
+
+    projector.runOnce();
+    const firstCount = countRows(db, 'notifications');
+
+    // Full replay
+    cursors.resetCursor('notification_projector');
+    projector.runOnce();
+    const replayCount = countRows(db, 'notifications');
+
+    expect(replayCount).toBe(firstCount); // exact same count after replay
+  });
+
+  test('cursor advances past processed events and does not re-process on next call', () => {
+    const { projector, cursors } = loadProjectorWithDb(db);
+    const userId = 'user-cursor';
+    const taskId = insertTask(db, { userId });
+
+    for (let i = 0; i < 10; i++) {
+      insertAuditEvent(db, { taskId, userId, action: 'complete' });
+    }
+
+    projector.runOnce(); // process 10
+    const cursor1 = cursors.readCursor('notification_projector');
+    expect(cursor1).toBeGreaterThan(0);
+
+    projector.runOnce(); // nothing new — cursor stays put
+    const cursor2 = cursors.readCursor('notification_projector');
+    expect(cursor2).toBe(cursor1); // cursor unchanged when no new events
+
+    // Add 5 more
+    for (let i = 0; i < 5; i++) {
+      insertAuditEvent(db, { taskId, userId, action: 'fail' });
+    }
+    projector.runOnce();
+    const cursor3 = cursors.readCursor('notification_projector');
+    expect(cursor3).toBeGreaterThan(cursor2); // advanced past new events
+
+    expect(countRows(db, 'notifications')).toBe(15);
+  });
+});