gentle-pi 3.3.0 → 3.4.0

package/tests/questionnaire-schema.test.ts

@@ -0,0 +1,274 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { Value } from "typebox/value";
+import {
+	CUSTOM_ROW_LABEL,
+	MAX_HEADER_LENGTH,
+	MAX_LABEL_LENGTH,
+	MAX_OPTIONS,
+	MAX_QUESTIONS,
+	MIN_OPTIONS,
+	QuestionParamsSchema,
+	type OptionData,
+	type QuestionParams,
+} from "../lib/questionnaire/schema.ts";
+import { validateQuestionnaire, type QuestionnaireError } from "../lib/questionnaire/validate.ts";
+
+const H = "Header";
+const option = (label: string, preview?: string): OptionData =>
+	preview === undefined ? { label, description: `${label} description` } : { label, description: `${label} description`, preview };
+
+const question = (
+	text: string,
+	options: OptionData[],
+	overrides: { header?: string; multiSelect?: boolean } = {},
+) => ({
+	question: text,
+	header: overrides.header ?? H,
+	options,
+	...(overrides.multiSelect === undefined ? {} : { multiSelect: overrides.multiSelect }),
+});
+
+const params = (questions: ReturnType<typeof question>[]): QuestionParams => ({ questions });
+const valid = (): ReturnType<typeof question>[] => [question("First?", [option("Alpha"), option("Beta")])];
+
+interface Case {
+	name: string;
+	input: ReturnType<typeof params>;
+	expected: QuestionnaireError | undefined;
+}
+
+function makeCases(): Case[] {
+	return [
+		{ name: "accepts a minimal valid questionnaire", input: params(valid()), expected: undefined },
+		{
+			name: "accepts exactly one question with two options",
+			input: params([question("Solo?", [option("A"), option("B")])]),
+			expected: undefined,
+		},
+		{
+			name: "accepts exactly four questions and four options",
+			input: params([
+				question("Q1", [option("A1"), option("B1"), option("C1"), option("D1")]),
+				question("Q2", [option("A2"), option("B2")]),
+				question("Q3", [option("A3"), option("B3")]),
+				question("Q4", [option("A4"), option("B4")]),
+			]),
+			expected: undefined,
+		},
+		{
+			name: "accepts a header at the 16 character limit",
+			input: params([question("Long header?", [option("A"), option("B")], { header: "x".repeat(MAX_HEADER_LENGTH) })]),
+			expected: undefined,
+		},
+		{
+			name: "accepts a label at the 60 character limit",
+			input: params([question("Long label?", [option("y".repeat(MAX_LABEL_LENGTH)), option("B")])]),
+			expected: undefined,
+		},
+		{
+			name: "rejects an empty question list",
+			input: params([]),
+			expected: { code: "no_questions", message: "At least one question is required." },
+		},
+		{
+			name: "rejects a question with empty options",
+			input: params([question("Empty?", [])]),
+			expected: {
+				code: "empty_options",
+				message: "Question 1 must declare at least one option.",
+				questionIndex: 0,
+			},
+		},
+		{
+			name: "rejects a single option below the minimum",
+			input: params([question("One?", [option("Only")])]),
+			expected: {
+				code: "option_count",
+				message: "Question 1 must have between 2 and 4 options, received 1.",
+				questionIndex: 0,
+				count: 1,
+			},
+		},
+		{
+			name: "rejects five options above the maximum",
+			input: params([question("Five?", [option("A"), option("B"), option("C"), option("D"), option("E")])]),
+			expected: {
+				code: "option_count",
+				message: "Question 1 must have between 2 and 4 options, received 5.",
+				questionIndex: 0,
+				count: 5,
+			},
+		},
+		{
+			name: "rejects more than four questions",
+			input: params([
+				question("Q1", [option("A1"), option("B1")]),
+				question("Q2", [option("A2"), option("B2")]),
+				question("Q3", [option("A3"), option("B3")]),
+				question("Q4", [option("A4"), option("B4")]),
+				question("Q5", [option("A5"), option("B5")]),
+			]),
+			expected: {
+				code: "too_many_questions",
+				message: "A questionnaire accepts at most 4 questions, received 5.",
+				count: 5,
+			},
+		},
+		{
+			name: "rejects duplicate question text",
+			input: params([
+				question("Same?", [option("A1"), option("B1")]),
+				question("Same?", [option("A2"), option("B2")]),
+			]),
+			expected: {
+				code: "duplicate_question",
+				message: "Question 2 duplicates an earlier question text.",
+				questionIndex: 1,
+			},
+		},
+		{
+			name: "rejects a duplicate option label within one question",
+			input: params([question("Dupe?", [option("Alpha"), option("Alpha")])]),
+			expected: {
+				code: "duplicate_option_label",
+				message: 'Question 1 option 2 duplicates the label "Alpha".',
+				questionIndex: 0,
+				optionIndex: 1,
+				label: "Alpha",
+			},
+		},
+		{
+			name: "rejects a label over the 60 character limit",
+			input: params([question("Too long?", [option("z".repeat(MAX_LABEL_LENGTH + 1)), option("B")])]),
+			expected: {
+				code: "label_too_long",
+				message: "Question 1 option 1 label exceeds 60 characters.",
+				questionIndex: 0,
+				optionIndex: 0,
+				length: MAX_LABEL_LENGTH + 1,
+			},
+		},
+		{
+			name: "rejects a header over the 16 character limit",
+			input: params([question("Header too long?", [option("A"), option("B")], { header: "x".repeat(MAX_HEADER_LENGTH + 1) })]),
+			expected: {
+				code: "header_too_long",
+				message: "Question 1 header exceeds 16 characters.",
+				questionIndex: 0,
+				length: MAX_HEADER_LENGTH + 1,
+			},
+		},
+		{
+			name: "rejects the reserved Other label",
+			input: params([question("Reserved?", [option("Other"), option("B")])]),
+			expected: {
+				code: "reserved_label",
+				message: 'Question 1 option 1 uses the reserved label "Other".',
+				questionIndex: 0,
+				optionIndex: 0,
+				label: "Other",
+			},
+		},
+		{
+			name: "rejects the reserved custom-row label",
+			input: params([question("Reserved?", [option(CUSTOM_ROW_LABEL), option("B")])]),
+			expected: {
+				code: "reserved_label",
+				message: `Question 1 option 1 uses the reserved label "${CUSTOM_ROW_LABEL}".`,
+				questionIndex: 0,
+				optionIndex: 0,
+				label: CUSTOM_ROW_LABEL,
+			},
+		},
+		{
+			name: "does not treat a reserved label with different casing as reserved",
+			input: params([question("Case?", [option("other"), option("type something.")])]),
+			expected: undefined,
+		},
+		{
+			name: "reports a duplicated question before its duplicated option label",
+			input: params([
+				question("Same?", [option("A"), option("B")]),
+				question("Same?", [option("A"), option("B")]),
+			]),
+			expected: {
+				code: "duplicate_question",
+				message: "Question 2 duplicates an earlier question text.",
+				questionIndex: 1,
+			},
+		},
+	];
+}
+
+test("validateQuestionnaire reports the first violation for each guard", () => {
+	for (const testCase of makeCases()) {
+		const actual = validateQuestionnaire(testCase.input);
+		assert.deepEqual(actual, testCase.expected, testCase.name);
+	}
+});
+
+test("schema constants expose the documented limits", () => {
+	assert.equal(MAX_QUESTIONS, 4);
+	assert.equal(MIN_OPTIONS, 2);
+	assert.equal(MAX_OPTIONS, 4);
+	assert.equal(MAX_HEADER_LENGTH, 16);
+	assert.equal(MAX_LABEL_LENGTH, 60);
+	assert.equal(CUSTOM_ROW_LABEL, "Type something.");
+});
+
+test("QuestionParamsSchema pins the questionnaire parameter shape", () => {
+	const root = QuestionParamsSchema as unknown as {
+		additionalProperties?: boolean;
+		properties?: {
+			questions?: {
+				minItems?: number;
+				maxItems?: number;
+				items?: {
+					additionalProperties?: boolean;
+					properties?: Record<string, unknown>;
+					required?: string[];
+				};
+			};
+		};
+	};
+	const questions = root.properties?.questions;
+	const questionSchema = questions?.items;
+	const questionProperties = questionSchema?.properties ?? {};
+
+	assert.equal(root.additionalProperties, false);
+	assert.equal(questions?.minItems, 1);
+	assert.equal(questions?.maxItems, MAX_QUESTIONS);
+	assert.equal(questionSchema?.additionalProperties, false);
+	assert.deepEqual([...(questionSchema?.required ?? [])].sort(), ["header", "options", "question"]);
+	assert.deepEqual(Object.keys(questionProperties).sort(), ["header", "multiSelect", "options", "question"]);
+});
+
+test("schema rejects malformed questionnaire parameters", () => {
+	const validParams = params(valid());
+	assert.equal(Value.Check(QuestionParamsSchema, validParams), true);
+
+	const invalidCases: Array<[string, unknown]> = [
+		["missing questions", {}],
+		["empty questions", { questions: [] }],
+		["five questions", params([
+			question("Q1", [option("A1"), option("B1")]),
+			question("Q2", [option("A2"), option("B2")]),
+			question("Q3", [option("A3"), option("B3")]),
+			question("Q4", [option("A4"), option("B4")]),
+			question("Q5", [option("A5"), option("B5")]),
+		])],
+		["one option", params([question("One?", [option("Only")])])],
+		["label over the limit", params([question("Long?", [option("z".repeat(MAX_LABEL_LENGTH + 1)), option("B")])])],
+		["header over the limit", params([question("Long?", [option("A"), option("B")], { header: "x".repeat(MAX_HEADER_LENGTH + 1) })])],
+		["unknown root property", { questions: valid(), extra: true }],
+	];
+	for (const [name, subject] of invalidCases) {
+		assert.equal(Value.Check(QuestionParamsSchema, subject), false, name);
+	}
+});
+
+test("schema accepts multiSelect and preview as optional fields", () => {
+	const withOptionals = params([question("Options?", [option("A", "Preview A"), option("B")], { multiSelect: true })]);
+	assert.equal(Value.Check(QuestionParamsSchema, withOptionals), true);
+});