Files
Netcatty/electron/capabilities/services/sessionService.test.cjs
T
GOUKI9999 b496b00d2f feat: bounded recovery for scoped disconnected sessions (#3935)
Contributor GOUKI9999 session_reconnect/session_recover. Maintainer gate fix: do not report ready while still offline/connecting (pending instead); connected keeps advisory shellReady; regenerate capability tool specs. Unit tests 12/12. Electron smoke PASS (SSH shell path). Residual P2 hung-worker readiness left timeout-bounded. No release.
2026-10-29 19:32:02 -07:00

173 lines
7.5 KiB
JavaScript

"use strict";
const test = require("node:test");
const assert = require("node:assert/strict");
const { createSessionService } = require("./sessionService.cjs");
test('automatic recovery shares the single-reconnect budget and stops after three failed connections', async () => {
let time = 0;
let attempts = 0;
const service = createSessionService({ now: () => time, sleep: async ms => { time += ms; },
validateReconnect: () => ({ ok: true }),
inspectRecovery: async () => ({ ok: true, status: 'disconnected', reconnectAllowed: true }),
invokeSessionAgent: async () => { attempts++; return { ok: true, started: true }; } });
const result = await service.recover({ sessionId: 'failed' });
assert.equal(result.code, 'RECONNECT_LIMIT');
assert.equal(attempts, 3);
assert.ok(time >= 7000 && time < 20000);
assert.equal((await service.reconnect({ sessionId: 'failed', chatSessionId: 'another' })).code, 'RECONNECT_LIMIT');
});
test("reconnect fails closed without scoped authorization", async () => {
let calls = 0;
const service = createSessionService({ invokeSessionAgent: async () => { calls++; } });
assert.equal((await service.reconnect({ sessionId: "s" })).ok, false);
assert.equal(calls, 0);
});
test("reconnect bounds attempts across chats, uses backoff and resets only after observed connection", async () => {
let now = 0;
let calls = 0;
let connected = false;
const service = createSessionService({
now: () => now,
validateReconnect: () => ({ ok: true, connected }),
invokeSessionAgent: async () => { calls++; return { ok: true, started: true, status: "reconnecting" }; },
});
const params = { sessionId: "s", chatSessionId: "first" };
assert.equal((await service.reconnect(params)).started, true);
assert.equal((await service.reconnect(params)).code, "RECONNECT_BACKOFF");
now = 2000;
assert.equal((await service.reconnect({ ...params, chatSessionId: "second" })).started, true);
assert.equal((await service.reconnect(params)).retryAfterMs, 5000);
now = 7000;
assert.equal((await service.reconnect(params)).started, true);
now = 200000;
assert.equal((await service.reconnect(params)).code, "RECONNECT_LIMIT");
connected = true;
assert.equal((await service.reconnect(params)).status, "connected");
assert.equal(calls, 3);
connected = false;
assert.equal((await service.reconnect(params)).started, true);
});
test("reconnect coalesces concurrent requests but revalidates every caller", async () => {
let finish;
let permitted = true;
let calls = 0;
const service = createSessionService({
validateReconnect: () => permitted ? { ok: true } : { ok: false, error: "scope revoked" },
invokeSessionAgent: () => { calls++; return new Promise(resolve => { finish = resolve; }); },
});
const first = service.reconnect({ sessionId: "s" });
assert.equal((await service.reconnect({ sessionId: "s" })).status, "reconnecting");
permitted = false;
assert.equal((await service.reconnect({ sessionId: "s" })).error, "scope revoked");
finish({ ok: true, started: true });
assert.equal((await first).error, "scope revoked");
assert.equal(calls, 1);
});
test("unavailable renderer does not consume attempts and execution guard runs before dispatch", async () => {
let calls = 0;
const service = createSessionService({
validateReconnect: () => ({ ok: true }),
invokeSessionAgent: async () => { calls++; return { ok: false, started: false, code: "RECONNECT_UNAVAILABLE" }; },
});
await assert.rejects(service.reconnect({ sessionId: "s" }, { beforeExecute: () => { throw Error("cancelled"); } }), /cancelled/);
for (let i = 0; i < 4; i++) assert.equal((await service.reconnect({ sessionId: "s" })).code, "RECONNECT_UNAVAILABLE");
assert.equal(calls, 4);
});
test("elapsed recovery budget cannot be reset by waiting or changing chat", async () => {
let now = 0;
const service = createSessionService({ now: () => now, validateReconnect: () => ({ ok: true }),
invokeSessionAgent: async () => ({ ok: true, started: true }) });
await service.reconnect({ sessionId: "s" });
now = 120000;
assert.equal((await service.reconnect({ sessionId: "s", chatSessionId: "another" })).code, "RECONNECT_LIMIT");
});
test("unknown dispatch outcomes consume budget but observed success resets it", async () => {
let now = 0;
let fail = true;
const service = createSessionService({ now: () => now, validateReconnect: () => ({ ok: true }),
invokeSessionAgent: async () => { if (fail) throw Error('reply lost'); return { ok: true, started: true }; } });
await assert.rejects(service.reconnect({ sessionId: 's' }), /reply lost/);
assert.equal((await service.reconnect({ sessionId: 's' })).code, 'RECONNECT_BACKOFF');
now = 120000;
assert.equal((await service.reconnect({ sessionId: 's' })).code, 'RECONNECT_LIMIT');
service.forgetReconnect('s');
fail = false;
assert.equal((await service.reconnect({ sessionId: 's' })).started, true);
});
test("closeTracked uses the same lifecycle while bypassing user-scope validation", async () => {
const events = [];
const service = createSessionService({
validateClose: () => ({ ok: false, error: "scope was cleaned" }),
beforeClose: async () => events.push("before"),
invokeSessionAgent: async () => ({ ok: true, status: "closed" }),
onClosed: async () => events.push("closed"),
afterClose: async (_params, outcome) => events.push(outcome.closed ? "success" : "failed"),
});
const manualResult = await service.close({ sessionId: "session-1" });
assert.equal(manualResult.ok, false);
assert.deepEqual(events, []);
const idleResult = await service.closeTracked({ sessionId: "session-1" });
assert.equal(idleResult.ok, true);
assert.deepEqual(events, ["before", "closed", "success"]);
});
test("failed closes report the outcome so idle tracking can resume", async () => {
let outcome = null;
const service = createSessionService({
invokeSessionAgent: async () => ({ ok: false, error: "renderer unavailable" }),
afterClose: async (_params, value) => {
outcome = value;
},
});
const result = await service.closeTracked({ sessionId: "session-1" });
assert.equal(result.ok, false);
assert.equal(outcome.closed, false);
assert.equal(outcome.notFound, false);
assert.deepEqual(outcome.result, result);
});
test("already-missing sessions are distinguished from retryable close failures", async () => {
let outcome = null;
const service = createSessionService({
invokeSessionAgent: async () => ({ ok: false, error: 'Session "gone" was not found.' }),
afterClose: async (_params, value) => {
outcome = value;
},
});
const result = await service.closeTracked({ sessionId: "gone" });
assert.equal(result.ok, false);
assert.equal(outcome.closed, false);
assert.equal(outcome.notFound, true);
});
test("close rechecks its execution guard after cleanup and preserves failed-close lifecycle", async () => {
const { createAiPrivacyService } = require("../../shared/aiPrivacyService.cjs");
const privacy = createAiPrivacyService();
privacy.checkSession("chat");
let invokeCount = 0;
let outcome;
const service = createSessionService({
beforeClose: async () => { privacy.configure({ enabled: true }); },
invokeSessionAgent: async () => { invokeCount++; return { ok: true }; },
afterClose: async (_params, value) => { outcome = value; },
});
await assert.rejects(service.close({ sessionId: "session-1" }, {
beforeExecute: () => privacy.restore("chat", []),
}), /start a new chat/);
assert.equal(invokeCount, 0);
assert.equal(outcome.closed, false);
assert.equal(outcome.notFound, false);
});