mirror of
https://github.com/binaricat/Netcatty.git
synced 2026-11-16 20:11:08 +00:00
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.
173 lines
7.5 KiB
JavaScript
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);
|
|
});
|