Skip to content

The open-source app everyone uses to manage agents at work

test(plugins): assert runtime delivery by event identity (#16871)

Nicky Leach4d8770f6dde5
diff --git a/server/src/__tests__/agent-runtime-hooks.test.ts b/server/src/__tests__/agent-runtime-hooks.test.ts
index 3fba2a9575..10a93c5ae6 100644
--- a/server/src/__tests__/agent-runtime-hooks.test.ts
+++ b/server/src/__tests__/agent-runtime-hooks.test.ts
@@ -12,6 +12,7 @@ import { pluginAgentRuntimeState } from "../services/plugin-agent-runtime-state.
import { pluginLifecycleInbox } from "../services/plugin-lifecycle-inbox.js";
import { registerPluginLifecycleDelivery } from "../services/plugin-lifecycle-delivery.js";
import { createDeliveryWorkCoordinator } from "../services/delivery-work-coordinator.js";
+import { idleWorkSnapshot } from "../services/task-admission.js";
import { resolveManagedInstructionsRoot } from "../services/agent-instructions.js";
import { agentFileStore } from "../services/agent-file-store.js";
import { agentInstructionRevisionService } from "../services/agent-instruction-revisions.js";
@@ -199,6 +200,13 @@ describeDatabase("agent runtime synchronization hooks", () => {
it("wakes delivery after a commit on an independent database client, without polling", async () => {
const other = createDb(database.connectionString);
+ const initialCount = (await events()).length;
+ const notifications: string[] = [];
+ const listen = db.$client.listen.bind(db.$client);
+ vi.spyOn(db.$client, "listen").mockImplementation((channel, onnotify, onlisten) => listen(channel, payload => {
+ notifications.push(payload);
+ onnotify(payload);
+ }, onlisten));
const call = vi.fn(async (_plugin, _method, event) => ({ eventId: event.id, status: "acknowledged" }));
const coordinator = createDeliveryWorkCoordinator({ owner: db, canRun: () => true, onError: error => { throw error; } });
const delivery = registerPluginLifecycleDelivery(coordinator, db, { call, isRunning: () => true, onConfigApplied: () => () => {} } as never, new EventEmitter() as never);
@@ -206,15 +214,27 @@ describeDatabase("agent runtime synchronization hooks", () => {
await delivery.ready;
await vi.waitFor(() => expect(call).toHaveBeenCalled(), { timeout: 5000 });
const delivered = () => call.mock.calls.filter(call => call[2].companyId === companyId);
- const initialCount = (await events()).length;
- await vi.waitFor(() => expect(delivered()).toHaveLength(initialCount), { timeout: 5000 });
- const before = delivered().length;
+ await vi.waitFor(async () => expect((await events()).length).toBeGreaterThan(initialCount), { timeout: 5000 });
+ await vi.waitFor(async () => expect(await pluginLifecycleInbox(db, pluginId).list(companyId)).toHaveLength(0), { timeout: 5000 });
+ const waitForIdle = () => vi.waitFor(() => {
+ expect(idleWorkSnapshot().active).toBe(0);
+ expect(coordinator.nextWakeAt()).toBeNull();
+ }, { timeout: 5000 });
+ await waitForIdle();
+ await other.execute(sql`SELECT pg_notify('paperclip_plugin_lifecycle', 'startup-drained')`);
+ await vi.waitFor(() => expect(notifications).toContain("startup-drained"), { timeout: 5000 });
+ await waitForIdle();
+ let committedEventId: string | undefined;
await other.transaction(async tx => {
await tx.update(agents).set({ name: "Independent writer" }).where(eq(agents.id, agentId));
- expect(delivered()).toHaveLength(before);
+ const [event] = await tx.select({ id: resourceLifecycleEvents.id }).from(resourceLifecycleEvents)
+ .where(and(eq(resourceLifecycleEvents.companyId, companyId), eq(resourceLifecycleEvents.resourceType, "agent_runtime"), eq(resourceLifecycleEvents.resourceId, agentId)))
+ .orderBy(sql`${resourceLifecycleEvents.id} DESC`).limit(1);
+ committedEventId = String(event.id);
+ expect(delivered().map(call => call[2].id)).not.toContain(committedEventId);
});
- await vi.waitFor(() => expect(delivered().length).toBeGreaterThan(before), { timeout: 5000 });
- expect(delivered().at(-1)![2]).toMatchObject({ companyId, resourceId: agentId, resourceType: "agent_runtime" });
+ await vi.waitFor(() => expect(delivered().map(call => call[2].id)).toContain(committedEventId), { timeout: 5000 });
+ expect(delivered().find(call => call[2].id === committedEventId)![2]).toMatchObject({ companyId, resourceId: agentId, resourceType: "agent_runtime" });
} finally { delivery.dispose(); await coordinator.stop(); await other.$client.end(); }
});
it("recovers work committed during real listener connection loss without another write", async () => {