@selesai/code 0.8.4 → 0.8.6

package/dist/extensions/question/tests/batch.test.ts

@@ -1,75 +1,113 @@
-import test from "node:test";
-import assert from "node:assert/strict";
+import { describe, expect, it } from "vitest";
 
 import { buildQuestionAnswers, prepareQuestions, saveDraftQuestion } from "../batch.ts";
 import type { DraftQuestionState } from "../types.ts";
 
-test("prepareQuestions: normalizes typed questions and generated ids", () => {
-	const result = prepareQuestions([
-		{ type: "select", question: "Pick a color", options: [{ value: "red", label: "Red" }, { value: "blue", label: "Blue" }] },
-		{ type: "text", id: "notes", label: "Notes", question: "Anything else?" },
-	]);
-	assert.ok("questions" in result);
-	if (!("questions" in result)) return;
-	assert.deepEqual(result.questions, [
-		{
-			id: "q1",
-			label: "Q1",
-			question: "Pick a color",
-			context: undefined,
+describe("question batch helpers", () => {
+	it("prepareQuestions: normalizes typed questions and generated ids", () => {
+		const result = prepareQuestions([
+			{ type: "select", question: "Pick a color", options: [{ value: "red", label: "Red" }, { value: "blue", label: "Blue" }] },
+			{ type: "text", id: "notes", label: "Notes", question: "Anything else?" },
+		]);
+		expect("questions" in result).toBe(true);
+		if (!("questions" in result)) return;
+		expect(result.questions).toEqual([
+			{
+				id: "q1",
+				label: "Q1",
+				question: "Pick a color",
+				context: undefined,
+				type: "select",
+				options: [
+					{ value: "red", label: "Red", description: undefined },
+					{ value: "blue", label: "Blue", description: undefined },
+				],
+				allowOther: false,
+			},
+			{
+				id: "notes",
+				label: "Notes",
+				question: "Anything else?",
+				context: undefined,
+				type: "text",
+				options: [],
+				allowOther: false,
+			},
+		]);
+	});
+
+	it("prepareQuestions: rejects empty batches, generated-id collisions, and duplicate option values", () => {
+		expect(prepareQuestions([])).toEqual({ error: "questions must contain at least one question." });
+		expect((prepareQuestions([
+			{ type: "text", id: "q2", question: "One" },
+			{ type: "text", question: "Two" },
+		]) as { error: string }).error).toMatch(/duplicate id: q2/);
+		expect((prepareQuestions([{
 			type: "select",
-			options: [
-				{ value: "red", label: "Red", description: undefined },
-				{ value: "blue", label: "Blue", description: undefined },
-			],
-			allowOther: false,
-		},
-		{
-			id: "notes",
-			label: "Notes",
-			question: "Anything else?",
-			context: undefined,
-			type: "text",
-			options: [],
+			question: "Choose",
+			options: [{ value: "same", label: "A" }, { value: "same", label: "B" }],
+		}]) as { error: string }).error).toMatch(/duplicate value: same/);
+	});
+
+	it("prepareQuestions: rejects missing question, bad type, empty options, and bad option fields", () => {
+		expect((prepareQuestions([{ type: "text" }]) as { error: string }).error).toMatch(/non-empty question/);
+		expect((prepareQuestions([{ type: "radio", question: "X", options: [{ value: "a", label: "A" }] }]) as { error: string }).error).toMatch(/type must be select, multiselect, or text/);
+		expect((prepareQuestions([{ type: "select", question: "X", options: [] }]) as { error: string }).error).toMatch(/at least one option/);
+		expect((prepareQuestions([{ type: "select", question: "X", options: [{ value: "", label: "A" }] }]) as { error: string }).error).toMatch(/value and label must be non-empty/);
+		expect((prepareQuestions([{ type: "select", question: "X", options: [{ value: "a", label: "" }] }]) as { error: string }).error).toMatch(/value and label must be non-empty/);
+	});
+
+	it("prepareQuestions: trims id/label/context and defaults allowOther", () => {
+		const result = prepareQuestions([
+			{ type: "multiselect", id: "  m1  ", label: "  Multi  ", question: "  Pick many  ", context: "  ctx  ", options: [{ value: "a", label: "A", description: "  desc  " }] },
+		]);
+		expect("questions" in result).toBe(true);
+		if (!("questions" in result)) return;
+		expect(result.questions[0]).toEqual({
+			id: "m1",
+			label: "Multi",
+			question: "Pick many",
+			context: "ctx",
+			type: "multiselect",
+			options: [{ value: "a", label: "A", description: "desc" }],
 			allowOther: false,
-		},
-	]);
-});
+		});
+	});
 
-test("prepareQuestions: rejects empty batches, generated-id collisions, and duplicate option values", () => {
-	assert.deepEqual(prepareQuestions([]), { error: "questions must contain at least one question." });
-	assert.match((prepareQuestions([
-		{ type: "text", id: "q2", question: "One" },
-		{ type: "text", question: "Two" },
-	]) as { error: string }).error, /duplicate id: q2/);
-	assert.match((prepareQuestions([{
-		type: "select",
-		question: "Choose",
-		options: [{ value: "same", label: "A" }, { value: "same", label: "B" }],
-	}]) as { error: string }).error, /duplicate value: same/);
-});
+	it("saveDraftQuestion: clearing an answer while navigating back leaves it unanswered", () => {
+		const states = new Map<string, DraftQuestionState>([["q1", { status: "answered", response: { kind: "text", text: "old" } }]]);
+		saveDraftQuestion(states, "q1", null, false);
+		expect(states.has("q1")).toBe(false);
+	});
 
-test("saveDraftQuestion: clearing an answer while navigating back leaves it unanswered", () => {
-	const states = new Map<string, DraftQuestionState>([["q1", { status: "answered", response: { kind: "text", text: "old" } }]]);
-	saveDraftQuestion(states, "q1", null, false);
-	assert.equal(states.has("q1"), false);
-});
+	it("saveDraftQuestion: blank answer with markBlankSkipped marks skipped", () => {
+		const states = new Map<string, DraftQuestionState>();
+		saveDraftQuestion(states, "q1", null, true);
+		expect(states.get("q1")).toEqual({ status: "skipped" });
+	});
+
+	it("saveDraftQuestion: response marks answered", () => {
+		const states = new Map<string, DraftQuestionState>();
+		saveDraftQuestion(states, "q1", { kind: "text", text: "answer" }, true);
+		expect(states.get("q1")).toEqual({ status: "answered", response: { kind: "text", text: "answer" } });
+	});
 
-test("buildQuestionAnswers: preserves answered, skipped, and unvisited states", () => {
-	const prepared = prepareQuestions([
-		{ type: "text", id: "a", question: "A" },
-		{ type: "text", id: "b", question: "B" },
-		{ type: "text", id: "c", question: "C" },
-	]);
-	assert.ok("questions" in prepared);
-	if (!("questions" in prepared)) return;
-	const states = new Map<string, DraftQuestionState>([
-		["a", { status: "answered", response: { kind: "text", text: "answer" } }],
-		["b", { status: "skipped" }],
-	]);
-	assert.deepEqual(buildQuestionAnswers(prepared.questions, states), [
-		{ id: "a", status: "answered", response: { kind: "text", text: "answer" } },
-		{ id: "b", status: "skipped" },
-		{ id: "c", status: "unanswered" },
-	]);
+	it("buildQuestionAnswers: preserves answered, skipped, and unvisited states", () => {
+		const prepared = prepareQuestions([
+			{ type: "text", id: "a", question: "A" },
+			{ type: "text", id: "b", question: "B" },
+			{ type: "text", id: "c", question: "C" },
+		]);
+		expect("questions" in prepared).toBe(true);
+		if (!("questions" in prepared)) return;
+		const states = new Map<string, DraftQuestionState>([
+			["a", { status: "answered", response: { kind: "text", text: "answer" } }],
+			["b", { status: "skipped" }],
+		]);
+		expect(buildQuestionAnswers(prepared.questions, states)).toEqual([
+			{ id: "a", status: "answered", response: { kind: "text", text: "answer" } },
+			{ id: "b", status: "skipped" },
+			{ id: "c", status: "unanswered" },
+		]);
+	});
 });

package/dist/extensions/question/tests/helpers.test.ts

@@ -1,53 +1,86 @@
-import test from "node:test";
-import assert from "node:assert/strict";
+import { describe, expect, it } from "vitest";
 
 import {
 	createSelectionResponse,
 	createTextResponse,
 	formatQuestionResponse,
 	formatResponseSummary,
+	formatOptionsForMessage,
 	oneLine,
 	previewText,
+	trimText,
 } from "../helpers.ts";
 import type { PreparedQuestion } from "../types.ts";
 
-test("createTextResponse trims edges and rejects blank text", () => {
-	assert.equal(createTextResponse("  "), null);
-	assert.deepEqual(createTextResponse("  hello\nworld  "), { kind: "text", text: "hello\nworld" });
-});
+describe("question helpers", () => {
+	it("trimText trims and returns undefined for blank", () => {
+		expect(trimText("  ")).toBeUndefined();
+		expect(trimText(undefined)).toBeUndefined();
+		expect(trimText(null)).toBeUndefined();
+		expect(trimText("  hello  ")).toBe("hello");
+	});
 
-test("createSelectionResponse supports values plus Other and rejects empty", () => {
-	assert.equal(createSelectionResponse([], "  "), null);
-	assert.deepEqual(createSelectionResponse([" a ", "b"], " other "), {
-		kind: "selection",
-		values: ["a", "b"],
-		otherText: "other",
+	it("createTextResponse trims edges and rejects blank text", () => {
+		expect(createTextResponse("  ")).toBeNull();
+		expect(createTextResponse(undefined)).toBeNull();
+		expect(createTextResponse("  hello\nworld  ")).toEqual({ kind: "text", text: "hello\nworld" });
 	});
-});
 
-test("formatResponseSummary returns machine values", () => {
-	assert.equal(formatResponseSummary({ kind: "selection", values: ["a", "b"], otherText: "c" }), "a, b, c");
-	assert.equal(formatResponseSummary({ kind: "text", text: "hello" }), "hello");
-});
+	it("createSelectionResponse supports values plus Other and rejects empty", () => {
+		expect(createSelectionResponse([], "  ")).toBeNull();
+		expect(createSelectionResponse([], undefined)).toBeNull();
+		expect(createSelectionResponse([" a ", "b"], " other ")).toEqual({
+			kind: "selection",
+			values: ["a", "b"],
+			otherText: "other",
+		});
+		expect(createSelectionResponse(["a"], undefined)).toEqual({ kind: "selection", values: ["a"] });
+	});
 
-test("formatQuestionResponse maps stable values to labels", () => {
-	const question: PreparedQuestion = {
-		id: "q1",
-		label: "Q1",
-		question: "Pick",
-		type: "multiselect",
-		options: [{ value: "a", label: "Alpha" }, { value: "b", label: "Beta" }],
-		allowOther: true,
-	};
-	assert.equal(formatQuestionResponse(question, { kind: "selection", values: ["b"], otherText: "Gamma" }), "Beta, Other: Gamma");
-});
+	it("formatResponseSummary returns machine values", () => {
+		expect(formatResponseSummary({ kind: "selection", values: ["a", "b"], otherText: "c" })).toBe("a, b, c");
+		expect(formatResponseSummary({ kind: "selection", values: ["a"] })).toBe("a");
+		expect(formatResponseSummary({ kind: "text", text: "hello" })).toBe("hello");
+	});
 
-test("previewText bounds multiline summaries", () => {
-	assert.equal(previewText("one\ntwo\nthree", 160, 2), "one\ntwo…");
-	assert.equal(previewText("a".repeat(200), 10, 2), `${"a".repeat(9)}…`);
-});
+	it("formatQuestionResponse maps stable values to labels", () => {
+		const question: PreparedQuestion = {
+			id: "q1",
+			label: "Q1",
+			question: "Pick",
+			type: "multiselect",
+			options: [{ value: "a", label: "Alpha" }, { value: "b", label: "Beta" }],
+			allowOther: true,
+		};
+		expect(formatQuestionResponse(question, { kind: "selection", values: ["b"], otherText: "Gamma" })).toBe("Beta, Other: Gamma");
+		expect(formatQuestionResponse(question, { kind: "selection", values: ["unknown"] })).toBe("unknown");
+		expect(formatQuestionResponse(question, { kind: "text", text: "plain" })).toBe("plain");
+	});
+
+	it("formatOptionsForMessage numbers options with descriptions", () => {
+		expect(formatOptionsForMessage([
+			{ value: "a", label: "Alpha" },
+			{ value: "b", label: "Beta", description: "the beta" },
+		])).toBe("1. Alpha\n2. Beta — the beta");
+	});
+
+	it("previewText bounds multiline summaries", () => {
+		expect(previewText("one\ntwo\nthree", 160, 2)).toBe("one\ntwo…");
+		expect(previewText("a".repeat(200), 10, 2)).toBe(`${"a".repeat(9)}…`);
+		expect(previewText("short", 160, 2)).toBe("short");
+		expect(previewText("", 160, 2)).toBe("");
+	});
+
+	it("oneLine collapses whitespace and truncates", () => {
+		expect(oneLine("  hello   world  ")).toBe("hello world");
+		expect(oneLine("a".repeat(20), 10)).toBe(`${"a".repeat(9)}…`);
+		expect(oneLine(undefined)).toBe("");
+		expect(oneLine(42)).toBe("42");
+	});
 
-test("oneLine collapses whitespace and truncates", () => {
-	assert.equal(oneLine("  hello   world  "), "hello world");
-	assert.equal(oneLine("a".repeat(20), 10), `${"a".repeat(9)}…`);
+	it("previewText handles single-line and exact-boundary text", () => {
+		expect(previewText("one line", 160, 2)).toBe("one line");
+		expect(previewText("a".repeat(10), 10, 2)).toBe("a".repeat(10));
+		expect(previewText("a".repeat(11), 10, 2)).toBe(`${"a".repeat(9)}…`);
+	});
 });