@conform-ed/contracts 0.0.3

package/test/qti-v3_0_1.test.ts

@@ -0,0 +1,576 @@
+import { expect, test } from "bun:test";
+import {
+  Qti301DerivedZodTemplates,
+  QtiAccessForAllPnpDocumentSchema,
+  QtiAsiProfileDocumentSchema,
+  QtiAssessmentItemDocumentSchema,
+  QtiAssessmentResultDocumentSchema,
+  QtiAssessmentSectionDocumentSchema,
+  QtiAssessmentStimulusDocumentSchema,
+  QtiAssessmentTestDocumentSchema,
+  QtiMetadataDocumentSchema,
+  QtiOutcomeDeclarationDocumentSchema,
+  QtiOutcomeProcessingDocumentSchema,
+  QtiResponseProcessingDocumentSchema,
+  QtiUsageDataDocumentSchema,
+  QtiXmlExtensionNodeSchema,
+} from "../src";
+
+test("QtiMetadataDocumentSchema parses a minimal metadata document", () => {
+  const parsed = QtiMetadataDocumentSchema.safeParse({
+    qtiMetadata: {
+      itemTemplate: false,
+      interactionType: ["choiceInteraction"],
+      scoringMode: ["responseprocessing"],
+    },
+  });
+
+  expect(parsed.success).toBe(true);
+});
+
+test("QtiAccessForAllPnpDocumentSchema parses a minimal preferences document", () => {
+  const parsed = QtiAccessForAllPnpDocumentSchema.safeParse({
+    accessForAllPnp: {
+      languageOfInterface: [{ xmlLang: "en" }],
+      magnification: {
+        allContent: { zoomAmount: 1.5 },
+      },
+      dictionaryOnScreen: true,
+    },
+  });
+
+  expect(parsed.success).toBe(true);
+});
+
+test("QtiAssessmentResultDocumentSchema parses a minimal result report", () => {
+  const parsed = QtiAssessmentResultDocumentSchema.safeParse({
+    assessmentResult: {
+      context: {
+        sessionIdentifiers: [
+          {
+            sourceId: "https://example.test/delivery",
+            identifier: "session-1",
+          },
+        ],
+      },
+      itemResults: [
+        {
+          identifier: "ITEM1",
+          datestamp: "2026-05-27T12:00:00Z",
+          sessionStatus: "final",
+          responseVariables: [
+            {
+              identifier: "RESPONSE",
+              cardinality: "single",
+              baseType: "identifier",
+              candidateResponse: {
+                values: [{ value: "A" }],
+              },
+              scoreStatus: "scored",
+              answeredStatus: "answered",
+            },
+          ],
+          outcomeVariables: [
+            {
+              identifier: "SCORE",
+              cardinality: "single",
+              baseType: "float",
+              values: [{ value: "1.0" }],
+            },
+          ],
+        },
+      ],
+    },
+  });
+
+  expect(parsed.success).toBe(true);
+});
+
+test("QtiAssessmentResultDocumentSchema rejects record response values without field identifiers", () => {
+  const parsed = QtiAssessmentResultDocumentSchema.safeParse({
+    assessmentResult: {
+      context: {},
+      itemResults: [
+        {
+          identifier: "ITEM1",
+          datestamp: "2026-05-27T12:00:00Z",
+          sessionStatus: "final",
+          responseVariables: [
+            {
+              identifier: "RESPONSE",
+              cardinality: "record",
+              candidateResponse: {
+                values: [{ value: "A" }],
+              },
+            },
+          ],
+        },
+      ],
+    },
+  });
+
+  expect(parsed.success).toBe(false);
+});
+
+test("QtiAssessmentResultDocumentSchema rejects record outcomes with baseType", () => {
+  const parsed = QtiAssessmentResultDocumentSchema.safeParse({
+    assessmentResult: {
+      context: {},
+      testResult: {
+        identifier: "TEST1",
+        datestamp: "2026-05-27T12:00:00Z",
+        outcomeVariables: [
+          {
+            identifier: "SCORE_BREAKDOWN",
+            cardinality: "record",
+            baseType: "float",
+            values: [{ value: "1.0", fieldIdentifier: "PART_A" }],
+          },
+        ],
+      },
+    },
+  });
+
+  expect(parsed.success).toBe(false);
+});
+
+test("QtiUsageDataDocumentSchema parses ordinary and categorized statistics", () => {
+  const parsed = QtiUsageDataDocumentSchema.safeParse({
+    usageData: {
+      glossary: "https://example.test/glossary",
+      statistics: [
+        {
+          kind: "ordinaryStatistic",
+          name: "P_VALUE",
+          context: "https://example.test/context/FORM_A",
+          caseCount: 12345,
+          stdError: 0.01,
+          lastUpdated: "2026-05-28",
+          targetObjects: [
+            {
+              identifier: "ITEM-1",
+              objectType: "item",
+            },
+          ],
+          value: {
+            value: "0.65",
+          },
+        },
+        {
+          kind: "categorizedStatistic",
+          name: "SCORE_CONVERSION",
+          context: "https://example.test/context/FORM_A",
+          targetObjects: [
+            {
+              identifier: "TEST-1",
+              objectType: "test",
+            },
+          ],
+          mapping: {
+            lowerBound: 0,
+            upperBound: 2,
+            mapEntries: [
+              { mapKey: "0", mappedValue: 100 },
+              { mapKey: "1", mappedValue: 200 },
+              { mapKey: "2", mappedValue: 300 },
+            ],
+          },
+        },
+      ],
+    },
+  });
+
+  expect(parsed.success).toBe(true);
+});
+
+test("QtiUsageDataDocumentSchema rejects invalid objectType and mapping bounds", () => {
+  const parsed = QtiUsageDataDocumentSchema.safeParse({
+    usageData: {
+      statistics: [
+        {
+          kind: "categorizedStatistic",
+          name: "SCORE_CONVERSION",
+          context: "https://example.test/context/FORM_A",
+          targetObjects: [
+            {
+              identifier: "TEST-1",
+              objectType: "testPart",
+            },
+          ],
+          mapping: {
+            lowerBound: 10,
+            upperBound: 1,
+            mapEntries: [{ mapKey: "A", mappedValue: 1 }],
+          },
+        },
+      ],
+    },
+  });
+
+  expect(parsed.success).toBe(false);
+});
+
+test("QtiResponseProcessingDocumentSchema parses typed processing operators", () => {
+  const parsed = QtiResponseProcessingDocumentSchema.safeParse({
+    responseProcessing: {
+      rules: [
+        {
+          kind: "setOutcomeValue",
+          identifier: "SCORE",
+          expression: {
+            kind: "integerDivide",
+            children: [
+              { kind: "baseValue", baseType: "integer", value: "6" },
+              { kind: "baseValue", baseType: "integer", value: "2" },
+            ],
+          },
+        },
+        {
+          kind: "setOutcomeValue",
+          identifier: "MATCH",
+          expression: {
+            kind: "substring",
+            caseSensitive: false,
+            children: [
+              { kind: "baseValue", baseType: "string", value: "alpha" },
+              { kind: "baseValue", baseType: "string", value: "alphabet" },
+            ],
+          },
+        },
+        {
+          kind: "setOutcomeValue",
+          identifier: "ROUNDED",
+          expression: {
+            kind: "equalRounded",
+            figures: 2,
+            children: [
+              { kind: "baseValue", baseType: "float", value: "1.23" },
+              { kind: "baseValue", baseType: "float", value: "1.2301" },
+            ],
+          },
+        },
+      ],
+    },
+  });
+
+  expect(parsed.success).toBe(true);
+});
+
+test("QtiOutcomeProcessingDocumentSchema parses typed aggregate operators", () => {
+  const parsed = QtiOutcomeProcessingDocumentSchema.safeParse({
+    outcomeProcessing: {
+      rules: [
+        {
+          kind: "setOutcomeValue",
+          identifier: "MEAN_SCORE",
+          expression: {
+            kind: "statsOperator",
+            name: "mean",
+            children: [
+              {
+                kind: "testVariables",
+                variableIdentifier: "SCORE",
+                baseType: "float",
+                includeCategory: ["scorable"],
+              },
+            ],
+          },
+        },
+        {
+          kind: "setOutcomeValue",
+          identifier: "NUM_CORRECT",
+          expression: {
+            kind: "numberCorrect",
+            sectionIdentifier: "SECTION1",
+          },
+        },
+        {
+          kind: "setOutcomeValue",
+          identifier: "MAX_SCORE",
+          expression: {
+            kind: "outcomeMaximum",
+            outcomeIdentifier: "SCORE",
+            includeCategory: ["scorable"],
+          },
+        },
+      ],
+    },
+  });
+
+  expect(parsed.success).toBe(true);
+});
+
+test("QtiResponseProcessingDocumentSchema rejects invalid operator parameters", () => {
+  const parsed = QtiResponseProcessingDocumentSchema.safeParse({
+    responseProcessing: {
+      rules: [
+        {
+          kind: "setOutcomeValue",
+          identifier: "INDEXED",
+          expression: {
+            kind: "index",
+            n: 0,
+            children: [{ kind: "variable", identifier: "RESPONSE" }],
+          },
+        },
+        {
+          kind: "setOutcomeValue",
+          identifier: "ROUNDED",
+          expression: {
+            kind: "roundTo",
+            roundingMode: "decimalPlaces",
+            figures: 0,
+            children: [{ kind: "baseValue", baseType: "float", value: "1.234" }],
+          },
+        },
+      ],
+    },
+  });
+
+  expect(parsed.success).toBe(false);
+});
+
+test("QtiOutcomeProcessingDocumentSchema rejects invalid operator arity and ranges", () => {
+  const parsed = QtiOutcomeProcessingDocumentSchema.safeParse({
+    outcomeProcessing: {
+      rules: [
+        {
+          kind: "setOutcomeValue",
+          identifier: "ANGLE",
+          expression: {
+            kind: "mathOperator",
+            name: "atan2",
+            children: [{ kind: "baseValue", baseType: "float", value: "1.0" }],
+          },
+        },
+        {
+          kind: "setOutcomeValue",
+          identifier: "WINDOW",
+          expression: {
+            kind: "anyN",
+            min: 2,
+            max: 1,
+            children: [{ kind: "baseValue", baseType: "boolean", value: "true" }],
+          },
+        },
+      ],
+    },
+  });
+
+  expect(parsed.success).toBe(false);
+});
+
+test("QtiAssessmentSectionDocumentSchema parses a minimal standalone section", () => {
+  const parsed = QtiAssessmentSectionDocumentSchema.safeParse({
+    assessmentSection: {
+      identifier: "SECTION1",
+      title: "Standalone Section",
+      visible: true,
+      children: [
+        {
+          identifier: "ITEMREF1",
+          href: "items/item1.xml",
+        },
+      ],
+    },
+  });
+
+  expect(parsed.success).toBe(true);
+});
+
+test("QtiAssessmentStimulusDocumentSchema parses a minimal stimulus", () => {
+  const parsed = QtiAssessmentStimulusDocumentSchema.safeParse({
+    assessmentStimulus: {
+      identifier: "STIM1",
+      title: "Shared Stimulus",
+      stimulusBody: {
+        content: ["Read the passage before answering the questions."],
+      },
+    },
+  });
+
+  expect(parsed.success).toBe(true);
+});
+
+test("QtiOutcomeDeclarationDocumentSchema parses a minimal outcome declaration", () => {
+  const parsed = QtiOutcomeDeclarationDocumentSchema.safeParse({
+    outcomeDeclaration: {
+      identifier: "SCORE",
+      cardinality: "single",
+      baseType: "float",
+    },
+  });
+
+  expect(parsed.success).toBe(true);
+});
+
+test("QtiAsiProfileDocumentSchema accepts resource-specific QTI documents", () => {
+  const parsed = QtiAsiProfileDocumentSchema.safeParse({
+    responseProcessing: {
+      rules: [
+        {
+          kind: "setOutcomeValue",
+          identifier: "SCORE",
+          expression: {
+            kind: "baseValue",
+            baseType: "float",
+            value: "1.0",
+          },
+        },
+      ],
+    },
+  });
+
+  expect(parsed.success).toBe(true);
+});
+
+test("QtiAssessmentItemDocumentSchema parses a minimal choice item", () => {
+  const parsed = QtiAssessmentItemDocumentSchema.safeParse({
+    assessmentItem: {
+      identifier: "ITEM1",
+      title: "Sample Item",
+      timeDependent: false,
+      responseDeclarations: [
+        {
+          identifier: "RESPONSE",
+          cardinality: "single",
+          baseType: "identifier",
+        },
+      ],
+      outcomeDeclarations: [
+        {
+          identifier: "SCORE",
+          cardinality: "single",
+          baseType: "float",
+        },
+      ],
+      itemBody: {
+        content: [
+          {
+            kind: "choiceInteraction",
+            responseIdentifier: "RESPONSE",
+            simpleChoices: [
+              {
+                kind: "simpleChoice",
+                identifier: "A",
+                content: ["Choice A"],
+              },
+              {
+                kind: "simpleChoice",
+                identifier: "B",
+                content: ["Choice B"],
+              },
+            ],
+          },
+        ],
+      },
+      responseProcessing: {
+        rules: [
+          {
+            kind: "setOutcomeValue",
+            identifier: "SCORE",
+            expression: {
+              kind: "baseValue",
+              baseType: "float",
+              value: "1.0",
+            },
+          },
+        ],
+      },
+    },
+  });
+
+  expect(parsed.success).toBe(true);
+});
+
+test("QtiAssessmentItemDocumentSchema rejects incompatible response declarations", () => {
+  const parsed = QtiAssessmentItemDocumentSchema.safeParse({
+    assessmentItem: {
+      identifier: "ITEM2",
+      title: "Invalid Item",
+      timeDependent: false,
+      responseDeclarations: [
+        {
+          identifier: "RESPONSE",
+          cardinality: "single",
+          baseType: "string",
+        },
+      ],
+      outcomeDeclarations: [
+        {
+          identifier: "SCORE",
+          cardinality: "single",
+          baseType: "float",
+        },
+      ],
+      itemBody: {
+        content: [
+          {
+            kind: "choiceInteraction",
+            responseIdentifier: "RESPONSE",
+            simpleChoices: [
+              { kind: "simpleChoice", identifier: "A", content: ["A"] },
+              { kind: "simpleChoice", identifier: "B", content: ["B"] },
+            ],
+          },
+        ],
+      },
+    },
+  });
+
+  expect(parsed.success).toBe(false);
+});
+
+test("QtiAssessmentTestDocumentSchema parses a minimal test document", () => {
+  const parsed = QtiAssessmentTestDocumentSchema.safeParse({
+    assessmentTest: {
+      identifier: "TEST1",
+      title: "Sample Test",
+      outcomeDeclarations: [
+        {
+          identifier: "SCORE",
+          cardinality: "single",
+          baseType: "float",
+        },
+      ],
+      testParts: [
+        {
+          identifier: "PART1",
+          navigationMode: "linear",
+          submissionMode: "individual",
+          children: [
+            {
+              identifier: "SECTION1",
+              title: "Section 1",
+              visible: true,
+              children: [
+                {
+                  identifier: "ITEMREF1",
+                  href: "items/item1.xml",
+                },
+              ],
+            },
+          ],
+        },
+      ],
+    },
+  });
+
+  expect(parsed.success).toBe(true);
+});
+
+test("Qti301DerivedZodTemplates exposes expected document templates", () => {
+  expect(Qti301DerivedZodTemplates.qtiAssessmentItemDocument).toBe(QtiAssessmentItemDocumentSchema);
+  expect(Qti301DerivedZodTemplates.qtiAssessmentResultDocument).toBe(QtiAssessmentResultDocumentSchema);
+  expect(Qti301DerivedZodTemplates.qtiUsageDataDocument).toBe(QtiUsageDataDocumentSchema);
+});
+
+test("QTI barrel exports prefixed XML extension node helpers", () => {
+  const parsed = QtiXmlExtensionNodeSchema.safeParse({
+    namespace: "urn:test",
+    name: "custom",
+    value: "x",
+  });
+
+  expect(parsed.success).toBe(true);
+});

package/test/schema-examples.test.ts

@@ -0,0 +1,101 @@
+import { expect, test } from "bun:test";
+import { readFileSync } from "node:fs";
+import { resolve } from "node:path";
+import { AdapterProfileSchema } from "../src/adapter";
+import { RunnerConfigSchema } from "../src/config";
+import { RequirementTraceSchema, RunMetadataSchema, RunnerSummarySchema } from "../src/summary";
+
+function readJson(path: string): unknown {
+  return JSON.parse(readFileSync(path, "utf8"));
+}
+
+test("example configs parse with RunnerConfigSchema", () => {
+  const root = resolve(import.meta.dir, "..", "..", "..");
+  const configs = [
+    resolve(root, "examples/configs/lrs.basic.json"),
+    resolve(root, "examples/configs/cmi5.oracle.json"),
+    resolve(root, "examples/configs/lti13.core-launch.json"),
+  ];
+
+  for (const file of configs) {
+    const parsed = RunnerConfigSchema.safeParse(readJson(file));
+    expect(parsed.success).toBe(true);
+  }
+});
+
+test("summary sample shape validates", () => {
+  const parsed = RunnerSummarySchema.safeParse({
+    contractVersion: "1.0.0",
+    runner: {
+      suite: "cmi5",
+      version: "0.1.0",
+      profileVersion: "1.0.0",
+      target: "all",
+    },
+    startedAt: "2026-05-24T12:00:00.000Z",
+    finishedAt: "2026-05-24T12:00:01.000Z",
+    durationMs: 1000,
+    result: {
+      status: "passed",
+      passed: 0,
+      failed: 0,
+      skipped: 0,
+    },
+    artifacts: {
+      summaryFile: "summary.json",
+      junitFile: "junit.xml",
+      requirementTraceFile: "requirement-trace.json",
+      runMetadataFile: "run-metadata.json",
+    },
+  });
+
+  expect(parsed.success).toBe(true);
+});
+
+test("requirement trace sample shape validates", () => {
+  const parsed = RequirementTraceSchema.safeParse({
+    contractVersion: "1.0.0",
+    runId: "run-001",
+    requirements: {
+      "9.3.1.0-2": {
+        status: "passed",
+        evidence: ["launch statement present"],
+      },
+    },
+  });
+
+  expect(parsed.success).toBe(true);
+});
+
+test("run metadata sample shape validates", () => {
+  const parsed = RunMetadataSchema.safeParse({
+    runId: "run-001",
+    startedAt: "2026-05-24T12:00:00.000Z",
+    finishedAt: "2026-05-24T12:00:01.000Z",
+    image: {
+      reference: "ghcr.io/conform-ed/cmi5-runner:v0.1.0-rc.1",
+      digest: "sha256:abc123",
+      source: "https://github.com/conform-ed/conform-ed",
+    },
+    standards: {
+      suiteSourceRevision: "catapult-lts-806c0b",
+      requirementsRevision: "requirements-v1",
+      profileVersion: "1.0.0",
+    },
+    runner: {
+      version: "0.1.0",
+      revision: "abcdef123456",
+    },
+  });
+
+  expect(parsed.success).toBe(true);
+});
+
+test("adapter profile sample shape validates", () => {
+  const root = resolve(import.meta.dir, "..", "..", "..");
+  const parsed = AdapterProfileSchema.safeParse(
+    readJson(resolve(root, "examples/profiles/cmi5.http.adapter-profile.json")),
+  );
+
+  expect(parsed.success).toBe(true);
+});