147 lines
8.2 KiB
TypeScript
147 lines
8.2 KiB
TypeScript
import test from "node:test";
|
|
import assert from "node:assert/strict";
|
|
import { QuestionnaireEngine } from "../src/lib/questionnaire/questionnaire-engine";
|
|
import { SaveEventRecorder, type SaveEvent } from "../src/lib/persistence/save-events";
|
|
import type { SaveRequest } from "../src/lib/persistence/types";
|
|
import example from "../src/demo/example-questionnaire.json";
|
|
import { serializeAnswers } from "../src/lib/persistence/typed-answers";
|
|
import { parseResumeDraft } from "../src/lib/questionnaire/resume-draft";
|
|
|
|
test("typed changes and resume drafts round-trip dates, falsy values, arrays and uploads", async () => {
|
|
const definition = {
|
|
schemaVersion: 1, id: "typed", version: "1", title: "Typed answers",
|
|
pages: [{ id: "first", title: "First", fields: [
|
|
{ id: "dateOfBirth", type: "date", label: "Date of birth" },
|
|
{ id: "consent", type: "boolean", label: "Consent" },
|
|
{ id: "count", type: "number", label: "Count" },
|
|
{ id: "notes", type: "text", label: "Notes" },
|
|
{ id: "choices", type: "multiselect", label: "Choices", options: [{ value: "a", label: "A" }] },
|
|
{ id: "attachment", type: "files", label: "Attachment" },
|
|
] }],
|
|
};
|
|
const engine = new QuestionnaireEngine(definition);
|
|
const answers = {
|
|
dateOfBirth: "1992-03-04", consent: false, count: 0, notes: null, choices: ["a"],
|
|
attachment: [{ uploadId: "upload-1", name: "proof.pdf", size: 10, type: "application/pdf" }],
|
|
};
|
|
const typed = serializeAnswers(engine, answers);
|
|
assert.deepEqual(typed.dateOfBirth, { type: "date", value: "1992-03-04" });
|
|
assert.deepEqual(parseResumeDraft(JSON.stringify({ answers: typed }), engine.definition).answers, answers);
|
|
const calls: SaveRequest[] = [];
|
|
const recorder = new SaveEventRecorder(engine, () => {}, {}, 0, undefined, request => {
|
|
calls.push(request); return { revision: request.revision + 1 };
|
|
});
|
|
await recorder.save(engine.createSession(answers), Object.keys(answers), "Continue", "first");
|
|
assert.deepEqual(calls[0].changes, typed);
|
|
assert.throws(() => parseResumeDraft(JSON.stringify({ answers: { dateOfBirth: { type: "text", value: "1992-03-04" } } }), engine.definition), /expected type date/);
|
|
assert.throws(() => parseResumeDraft(JSON.stringify({ answers: { dateOfBirth: { type: "date" } } }), engine.definition), /needs a value/);
|
|
assert.throws(() => parseResumeDraft(JSON.stringify({ answers: { consent: { type: "boolean", value: "yes" } } }), engine.definition), /valid boolean/);
|
|
});
|
|
|
|
test("file saves reject missing upload IDs and preserve real host references", async () => {
|
|
const fileEngine = new QuestionnaireEngine({
|
|
schemaVersion: 1, id: "uploads", version: "1", title: "Uploads",
|
|
pages: [{ id: "files", title: "Files", fields: [{ type: "files", label: "Attachment", id: "attachment" }] }]
|
|
});
|
|
const calls: SaveRequest[] = [];
|
|
const recorder = new SaveEventRecorder(fileEngine, () => {}, {}, 0, undefined, request => {
|
|
calls.push(request); return { revision: 1 };
|
|
});
|
|
const metadata = { name: "evidence.pdf", size: 10, type: "application/pdf" };
|
|
assert.equal(await recorder.filesSelected("attachment", [metadata], "files", fileEngine.createSession({ attachment: [metadata] })), false);
|
|
assert.equal(calls.length, 0);
|
|
const uploaded = { ...metadata, uploadId: "host-upload-123" };
|
|
const session = fileEngine.createSession({ attachment: [uploaded] });
|
|
assert.equal(await recorder.filesSelected("attachment", [uploaded], "files", session), true);
|
|
assert.equal(calls[0].kind, "changes");
|
|
assert.deepEqual(calls[0].changes?.attachment, { type: "files", value: [uploaded] });
|
|
assert.deepEqual(session.getEffectiveAnswers().attachment, [uploaded]);
|
|
});
|
|
|
|
test("failed changes retry and queued saves use the acknowledged revision", async () => {
|
|
const engine = new QuestionnaireEngine(example);
|
|
const calls: SaveRequest[] = [];
|
|
const events: SaveEvent[] = [];
|
|
let fail = true;
|
|
const recorder = new SaveEventRecorder(engine, event => events.push(event), {}, 4, undefined, async request => {
|
|
calls.push(request);
|
|
if (fail) { fail = false; throw new Error("Offline"); }
|
|
return { revision: request.revision + 1 };
|
|
});
|
|
const session = engine.createSession({ fullName: "Alex" });
|
|
assert.equal(await recorder.save(session, ["fullName"], "blur", "registration"), false);
|
|
const retry = recorder.save(session, ["fullName"], "Continue", "registration");
|
|
const next = recorder.savePosition("registration", "attending");
|
|
assert.equal(await retry, true);
|
|
await next;
|
|
assert.deepEqual(calls[0].changes, calls[1].changes);
|
|
assert.deepEqual(calls.map(call => call.revision), [4, 4, 5]);
|
|
assert.deepEqual(events.map(event => event.status), ["Blocked", "Saved", "Saved"]);
|
|
});
|
|
|
|
test("save promises wait for the host and duplicate queued answers are deduplicated", async () => {
|
|
const engine = new QuestionnaireEngine(example);
|
|
let finish!: () => void;
|
|
const gate = new Promise<void>(resolve => { finish = resolve; });
|
|
let calls = 0;
|
|
const events: SaveEvent[] = [];
|
|
const recorder = new SaveEventRecorder(engine, event => events.push(event), {}, 0, undefined, async () => {
|
|
calls++; await gate; return { revision: 1 };
|
|
});
|
|
const session = engine.createSession({ fullName: "Alex" });
|
|
const first = recorder.save(session, ["fullName"], "blur", "registration");
|
|
const second = recorder.save(session, ["fullName"], "blur", "registration");
|
|
await Promise.resolve();
|
|
assert.equal(events.length, 0);
|
|
finish();
|
|
assert.equal(await first, true);
|
|
assert.equal(await second, true);
|
|
assert.equal(calls, 1);
|
|
});
|
|
|
|
test("in-memory changes never claim server persistence or advance revisions", async () => {
|
|
const engine = new QuestionnaireEngine(example);
|
|
const events: SaveEvent[] = [];
|
|
const recorder = new SaveEventRecorder(engine, event => events.push(event));
|
|
await recorder.save(engine.createSession({ fullName: "Alex" }), ["fullName"], "blur", "registration");
|
|
await recorder.savePosition("registration", "attending");
|
|
assert.ok(events.every(event => event.status === "Changed" && event.data?.revision === 0));
|
|
});
|
|
|
|
test("answer and focus requests have separate payloads and share acknowledged revisions", async () => {
|
|
const engine = new QuestionnaireEngine(example);
|
|
const calls: SaveRequest[] = [];
|
|
const events: SaveEvent[] = [];
|
|
const recorder = new SaveEventRecorder(engine, event => events.push(event), {}, 4, undefined, request => {
|
|
calls.push(request);
|
|
return { revision: request.revision + 1 };
|
|
});
|
|
await recorder.savePosition("registration", "fullName");
|
|
await recorder.save(engine.createSession({ fullName: "Alex" }), ["fullName"], "Question blur", "registration", false, "fullName");
|
|
await recorder.savePosition("registration", "attending");
|
|
await recorder.savePosition("registration", "attending");
|
|
assert.deepEqual(calls, [
|
|
{ kind: "focus", resume: { nodeId: "registration", questionId: "fullName" }, revision: 4, trigger: "Question focus" },
|
|
{ kind: "changes", changes: { fullName: { type: "text", value: "Alex" } }, revision: 5, trigger: "Question blur" },
|
|
{ kind: "focus", resume: { nodeId: "registration", questionId: "attending" }, revision: 6, trigger: "Question focus" },
|
|
]);
|
|
assert.deepEqual(events.map(event => event.kind), ["focus", "changes", "focus"]);
|
|
});
|
|
|
|
test("failed focus after an answer save retries only the unacknowledged position", async () => {
|
|
const engine = new QuestionnaireEngine(example);
|
|
const calls: SaveRequest[] = [];
|
|
const events: SaveEvent[] = [];
|
|
let failFocus = true;
|
|
const recorder = new SaveEventRecorder(engine, event => events.push(event), {}, 0, undefined, request => {
|
|
calls.push(request);
|
|
if (request.kind === "focus" && failFocus) { failFocus = false; throw new Error("Offline"); }
|
|
return { revision: request.revision + 1 };
|
|
});
|
|
const session = engine.createSession({ fullName: "Alex" });
|
|
assert.equal(await recorder.save(session, ["fullName"], "Continue", "registration", false, "attending"), false);
|
|
assert.equal(await recorder.save(session, ["fullName"], "Continue", "registration", false, "attending"), true);
|
|
assert.deepEqual(calls.map(call => [call.kind, call.revision]), [["changes", 0], ["focus", 1], ["focus", 1]]);
|
|
assert.deepEqual(events.map(event => [event.kind, event.status]), [["changes", "Saved"], ["focus", "Blocked"], ["focus", "Saved"]]);
|
|
});
|