refactor: read text-entry answers through QTIDeclaration.fromXML

_extractAnswers parsed <qti-correct-response> by hand while a separate
helper built the case-sensitivity lookup via QTIDeclaration. Fold both
into one parse: the declaration class now supplies the correct responses
as well as the mapping.

A declaration too malformed for QTIDeclaration to model (e.g. a missing
identifier) now yields no answers rather than falling back to raw DOM
reads, matching how an unsupported base-type is already handled.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

Author: rtibblesbot

contentcuration/contentcuration/frontend/shared/views/QTIEditor/interactions/textEntry/__tests__/parse.spec.js

@@ -95,6 +95,10 @@ describe('_defaultState', () => {
 });
 
 describe('_extractAnswers', () => {
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
   it('returns [] when no declaration is provided', () => {
     expect(_extractAnswers([])).toEqual([]);
   });
@@ -128,11 +132,13 @@ describe('_extractAnswers', () => {
     expect(result[0].id).not.toBe(result[1].id);
   });
 
-  describe('mapping-derived case sensitivity', () => {
-    afterEach(() => {
-      jest.restoreAllMocks();
-    });
+  it('returns [] when the declaration is too malformed to model', () => {
+    const errorSpy = jest.spyOn(console, 'error').mockImplementation(() => {});
+    expect(_extractAnswers([DECLARATION_WITHOUT_IDENTIFIER])).toEqual([]);
+    expect(errorSpy).toHaveBeenCalled();
+  });
 
+  describe('mapping-derived case sensitivity', () => {
     it('reads caseSensitive by map-key, silently ignoring unmatched entries', () => {
       const errorSpy = jest.spyOn(console, 'error').mockImplementation(() => {});
       const result = _extractAnswers([TEXT_ENTRY_DECLARATION_WITH_MAPPING]);
@@ -154,17 +160,12 @@ describe('_extractAnswers', () => {
     });
 
     it('matches a map entry for a blank answer value', () => {
-      // Empty map-key coerces to null (QTI NULL) while the value stays ''; the entry is
-      // case-sensitive="true" so a missed lookup can't slip through the false fallback.
+      // Both the empty map-key and the empty <qti-value> coerce to null (QTI NULL) and
+      // format back to ''; the entry is case-sensitive="true" so a missed lookup can't
+      // slip through the false fallback.
       const result = _extractAnswers([BLANK_VALUE_DECLARATION]);
       expect(result).toEqual([expect.objectContaining({ value: '', caseSensitive: true })]);
     });
-
-    it('keeps the answers when the declaration is too malformed to model', () => {
-      jest.spyOn(console, 'warn').mockImplementation(() => {});
-      const result = _extractAnswers([DECLARATION_WITHOUT_IDENTIFIER]);
-      expect(result).toEqual([expect.objectContaining({ value: 'Paris', caseSensitive: false })]);
-    });
   });
 });
 

contentcuration/contentcuration/frontend/shared/views/QTIEditor/interactions/textEntry/parse.js

@@ -70,34 +70,6 @@ function extractPromptHTML(bodyEl) {
   return clone.innerHTML.trim();
 }
 
-/**
- * Build a value → caseSensitive lookup from a declaration's <qti-mapping>.
- *
- * @param {Element} declEl - The <qti-response-declaration> element
- * @returns {Map<string, boolean>}
- */
-function caseSensitivityByValue(declEl) {
-  let declaration;
-  try {
-    declaration = QTIDeclaration.fromXML(declEl);
-  } catch (err) {
-    // QTIDeclaration validates more strictly than answer extraction needs (a missing
-    // identifier makes it unmodellable), so degrade rather than drop the answers.
-    // eslint-disable-next-line no-console
-    console.warn('[QTI Editor] Could not read <qti-mapping> case sensitivity:', err);
-    return new Map();
-  }
-
-  // Key on the XML string form: map-key is coerced on parse (empty → null under QTI
-  // NULL semantics) while answer values stay raw <qti-value> text.
-  return new Map(
-    (declaration.mapping?.entries ?? []).map(entry => [
-      declaration.formatValue(entry.mapKey),
-      entry.caseSensitive,
-    ]),
-  );
-}
-
 /**
  * Extract correct answer values from the response declaration string.
  * Returns an array of `{ id, value, caseSensitive }` objects, or [] when no
@@ -115,40 +87,40 @@ export function _extractAnswers(responseDeclarations) {
   if (!declXml) return [];
 
   try {
-    const declEl = parseXML(declXml).documentElement;
-    const isFloat = declEl.getAttribute('base-type') === BaseType.FLOAT;
-    const isString = declEl.getAttribute('base-type') === BaseType.STRING;
+    const declaration = QTIDeclaration.fromXML(parseXML(declXml).documentElement);
+    const { baseType, correctResponse } = declaration;
 
-    if (!isFloat && !isString) {
+    if (baseType !== BaseType.FLOAT && baseType !== BaseType.STRING) {
       // eslint-disable-next-line no-console
-      console.error(
-        `[QTI Editor] Unsupported text-entry base-type: ${declEl.getAttribute('base-type')}`,
-      );
+      console.error(`[QTI Editor] Unsupported text-entry base-type: ${baseType}`);
       return [];
     }
 
-    const correctResponseEl = declEl.querySelector('qti-correct-response');
-    if (!correctResponseEl) {
-      if (isFloat) {
+    if (correctResponse === null) {
+      if (baseType === BaseType.FLOAT) {
         // eslint-disable-next-line no-console
         console.error('[QTI Editor] Missing <qti-correct-response> for numeric interaction');
       }
       return [];
     }
 
-    const valueEls = [...correctResponseEl.querySelectorAll('qti-value')];
-    if (valueEls.length === 0) return [];
-
-    const caseSensitivity = isString ? caseSensitivityByValue(declEl) : null;
+    // Case sensitivity is a string-only concept, so numeric answers never read the mapping.
+    const mapEntries = baseType === BaseType.STRING ? (declaration.mapping?.entries ?? []) : [];
+    // Key on the XML string form: both map-key and correct-response values are coerced
+    // on parse (empty → null under QTI NULL semantics), so formatting both back matches
+    // them on equal terms.
+    const caseSensitivity = new Map(
+      mapEntries.map(entry => [declaration.formatValue(entry.mapKey), entry.caseSensitive]),
+    );
 
-    return valueEls.map(el => {
-      const value = el.textContent.trim();
+    return correctResponse.map(value => {
+      const formatted = declaration.formatValue(value);
       return {
         id: generateRandomSlug('answer'),
-        value,
+        value: formatted,
         // An answer with no matching qti-map-entry — including every answer in an
         // item authored before mappings were written — takes the XSD default, false.
-        caseSensitive: caseSensitivity?.get(value) ?? false,
+        caseSensitive: caseSensitivity.get(formatted) ?? false,
       };
     });
   } catch (err) {