@mndrk/agx 2.0.0 → 2.0.2

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

@@ -1,111 +0,0 @@
-/**
- * @jest-environment node
- *
- * Duplicate-event test: replaying the same event_id must produce exactly one
- * notification row (idempotency via UNIQUE(event_id, user_id, type)).
- */
-
-'use strict';
-
-const fs = require('fs');
-const path = require('path');
-const { tmpDbPath, makeDb, insertTask, insertAuditEvent, loadProjectorWithDb, countRows } = require('./_helpers');
-
-describe('projector duplicate-event test', () => {
-  let dbPath, db;
-
-  beforeEach(() => {
-    dbPath = tmpDbPath();
-    db = makeDb(dbPath);
-    jest.resetModules();
-  });
-
-  afterEach(() => {
-    db.close();
-    fs.rmSync(path.dirname(dbPath), { recursive: true });
-  });
-
-  test('same event_id processed twice yields exactly one notification row', () => {
-    const { projector, cursors } = loadProjectorWithDb(db);
-    const userId = 'user-dup';
-    const taskId = insertTask(db, { userId });
-
-    insertAuditEvent(db, { taskId, userId, action: 'complete' });
-
-    // First processing
-    projector.runOnce();
-    expect(countRows(db, 'notifications')).toBe(1);
-    expect(countRows(db, 'notification_outbox')).toBe(1);
-
-    // Reset cursor to force replay of same event
-    cursors.resetCursor('notification_projector');
-    projector.runOnce();
-
-    expect(countRows(db, 'notifications')).toBe(1); // still exactly one
-    expect(countRows(db, 'notification_outbox')).toBe(1);
-  });
-
-  test('same event replayed 10 times yields exactly one notification', () => {
-    const { projector, cursors } = loadProjectorWithDb(db);
-    const userId = 'user-dup10';
-    const taskId = insertTask(db, { userId });
-
-    insertAuditEvent(db, { taskId, userId, action: 'fail' });
-
-    for (let i = 0; i < 10; i++) {
-      cursors.resetCursor('notification_projector');
-      projector.runOnce();
-    }
-
-    expect(countRows(db, 'notifications')).toBe(1);
-    expect(countRows(db, 'notification_outbox')).toBe(1);
-  });
-
-  test('different event types for same task produce separate notifications', () => {
-    const { projector } = loadProjectorWithDb(db);
-    const userId = 'user-types';
-    const taskId = insertTask(db, { userId });
-
-    // Each action produces a distinct (event_id, user_id, type) tuple
-    insertAuditEvent(db, { taskId, userId, action: 'dispatch' });
-    insertAuditEvent(db, { taskId, userId, action: 'execute' });
-    insertAuditEvent(db, { taskId, userId, action: 'complete' });
-
-    projector.runOnce();
-    expect(countRows(db, 'notifications')).toBe(3);
-  });
-
-  test('duplicate same-type events across different users create per-user rows', () => {
-    const { projector, cursors } = loadProjectorWithDb(db);
-    const taskId1 = insertTask(db, { userId: 'user-a' });
-    const taskId2 = insertTask(db, { userId: 'user-b' });
-
-    insertAuditEvent(db, { taskId: taskId1, userId: 'user-a', action: 'complete' });
-    insertAuditEvent(db, { taskId: taskId2, userId: 'user-b', action: 'complete' });
-
-    projector.runOnce();
-    expect(countRows(db, 'notifications')).toBe(2); // one per user
-
-    // Replay: still exactly 2
-    cursors.resetCursor('notification_projector');
-    projector.runOnce();
-    expect(countRows(db, 'notifications')).toBe(2);
-  });
-
-  test('notification fields are correctly populated on first insert', () => {
-    const { projector } = loadProjectorWithDb(db);
-    const userId = 'user-fields';
-    const taskId = insertTask(db, { userId, title: 'My Task' });
-
-    insertAuditEvent(db, { taskId, userId, action: 'complete' });
-    projector.runOnce();
-
-    const notif = db.prepare('SELECT * FROM notifications').get();
-    expect(notif.user_id).toBe(userId);
-    expect(notif.task_id).toBe(taskId);
-    expect(notif.type).toBe('task.completed');
-    expect(notif.tier).toBe('success');
-    expect(notif.title).toContain('My Task');
-    expect(notif.read_at).toBeNull();
-  });
-});

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

@@ -1,162 +0,0 @@
-/**
- * @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

@@ -1,107 +0,0 @@
-/**
- * @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);
-  });
-});