Support V2 Test Format build

lib/data/command-tuples-at-mode-task-lookup.js

@@ -31,4 +31,28 @@ function createCommandTuplesATModeTaskLookup(commands) {
   return data;
 }
 
-exports.createCommandTuplesATModeTaskLookup = createCommandTuplesATModeTaskLookup;
+function createAtCommandTuplesATSettingsTestIdLookupByPresentationNumber(commands) {
+  return commands.reduce((carry, command) => {
+    const commandTask = carry[command.testId] || {};
+    const commandTaskMode = commandTask[command.target.at.settings || 'defaultMode'] || {};
+    const commandTaskModeAT = commandTaskMode[command.target.at.key] || [];
+    const commandTuples = command.commands.map(({ id, presentationNumber }) => [
+      `${id}|${presentationNumber}`,
+    ]);
+    return {
+      ...carry,
+      [command.testId]: {
+        ...commandTask,
+        [command.target.at.settings || 'defaultMode']: {
+          ...commandTaskMode,
+          [command.target.at.key]: [...commandTaskModeAT, ...commandTuples],
+        },
+      },
+    };
+  }, {});
+}
+
+module.exports = {
+  createCommandTuplesATModeTaskLookup,
+  createAtCommandTuplesATSettingsTestIdLookupByPresentationNumber,
+};

lib/data/parse-command-csv-row.js

@@ -67,4 +67,194 @@ function parseCommandCSVRow(commandRow) {
   };
 }
 
-exports.parseCommandCSVRow = parseCommandCSVRow;
+function flattenObject(obj, parentKey = '') {
+  const flattened = {};
+
+  for (const key in obj) {
+    if (typeof obj[key] === 'object') {
+      const subObject = flattenObject(obj[key], parentKey + key + '.');
+      Object.assign(flattened, subObject);
+    } else {
+      flattened[parentKey + key] = obj[key];
+    }
+  }
+
+  return flattened;
+}
+
+function sanitizeWhitespace(value) {
+  return value.replace(/\s+/g, ' ').trim();
+}
+
+function sanitizeCommand(command) {
+  return {
+    ...command,
+    command: sanitizeWhitespace(command.command),
+  };
+}
+
+function findValueByKey(keyMappings, keyToFindText) {
+  const keyToFind = keyToFindText.replace(/\s+/g, ' ').trim();
+  const keyMap = Object.keys(keyMappings);
+
+  // Need to specially handle VO modifier key combination
+  if (keyToFind === 'vo')
+    return findValuesByKeys(keyMappings, [keyMappings['modifierAliases.vo']])[0];
+
+  if (keyToFind.includes('modifiers.') || keyToFind.includes('keys.')) {
+    const parts = keyToFind.split('.');
+    const keyToCheck = parts[parts.length - 1]; // value after the '.'
+
+    if (keyMappings[keyToFind])
+      return {
+        value: keyMappings[keyToFind],
+        key: keyToCheck,
+      };
+
+    return null;
+  }
+
+  for (const key of keyMap) {
+    const parts = key.split('.');
+    const parentKey = parts[0];
+    const keyToCheck = parts[parts.length - 1]; // value after the '.'
+
+    if (keyToCheck === keyToFind) {
+      if (parentKey === 'modifierAliases') {
+        return findValueByKey(keyMappings, `modifiers.${keyMappings[key]}`);
+      } else if (parentKey === 'keyAliases') {
+        return findValueByKey(keyMappings, `keys.${keyMappings[key]}`);
+      }
+
+      return {
+        value: keyMappings[key],
+        key: keyToCheck,
+      };
+    }
+  }
+
+  // Return null if the key is not found
+  return null;
+}
+
+function findValuesByKeys(commandsMapping, keysToFind = []) {
+  const result = [];
+
+  const patternSepWithReplacement = (keyToFind, pattern, replacement) => {
+    if (keyToFind.includes(pattern)) {
+      let value = '';
+      let validKeys = true;
+      const keys = keyToFind.split(pattern);
+
+      for (const key of keys) {
+        const keyResult = findValueByKey(commandsMapping, key);
+        if (keyResult) value = value ? `${value}${replacement}${keyResult.value}` : keyResult.value;
+        else validKeys = false;
+      }
+      if (validKeys) return { value, key: keyToFind };
+    }
+
+    return null;
+  };
+
+  const patternSepHandler = keyToFind => {
+    let value = '';
+
+    if (keyToFind.includes(' ') && keyToFind.includes('+')) {
+      const keys = keyToFind.split(' ');
+      for (let [index, key] of keys.entries()) {
+        const keyToFindResult = findValueByKey(commandsMapping, key);
+        if (keyToFindResult) keys[index] = keyToFindResult.value;
+        if (key.includes('+')) keys[index] = patternSepWithReplacement(key, '+', '+').value;
+      }
+      value = keys.join(' then ');
+
+      return { value, key: keyToFind };
+    } else if (keyToFind.includes(' ')) return patternSepWithReplacement(keyToFind, ' ', ' then ');
+    else if (keyToFind.includes('+')) return patternSepWithReplacement(keyToFind, '+', '+');
+  };
+
+  for (const keyToFind of keysToFind) {
+    if (keyToFind.includes(' ') || keyToFind.includes('+')) {
+      result.push(patternSepHandler(keyToFind));
+    } else {
+      const keyToFindResult = findValueByKey(commandsMapping, keyToFind);
+      if (keyToFindResult) result.push(keyToFindResult);
+    }
+  }
+
+  return result;
+}
+
+function parseCommandCSVRowV2({ commands }, commandsJson) {
+  const commandsParsed = [];
+  const flattenedCommandsJson = flattenObject(commandsJson);
+
+  function createParsedCommand(command, atTargetInfo) {
+    const commandIds = command.command.split(' ');
+    const commandKVs = findValuesByKeys(flattenedCommandsJson, [command.command]);
+
+    const assertionExceptions = command.assertionExceptions.length
+      ? sanitizeWhitespace(command.assertionExceptions).split(' ')
+      : [];
+
+    const commands = commandKVs.map(e => ({
+      id: e.key,
+      keystroke: e.value,
+      keypresses: e.value.split(' then ').map((e, index) => ({
+        id: commandIds[index],
+        keystroke: e,
+      })),
+      presentationNumber: Number(command.presentationNumber),
+      assertionExceptions,
+    }));
+
+    // Also account for 'modeless' AT configurations with 'defaultMode'
+    const settingsValue = command.settings || 'defaultMode';
+
+    const foundCommandIndex = commandsParsed.findIndex(
+      e =>
+        e.testId === command.testId &&
+        e.target.at.key === atTargetInfo.key &&
+        e.target.at.settings === settingsValue &&
+        (e.commands.length
+          ? e.commands.every(
+              ({ presentationNumber }) =>
+                parseInt(presentationNumber) === parseInt(command.presentationNumber)
+            )
+          : true)
+    );
+
+    // Add new parsed command since none exist
+    if (foundCommandIndex < 0) {
+      commandsParsed.push({
+        testId: command.testId,
+        target: {
+          at: {
+            ...atTargetInfo,
+            settings: settingsValue,
+          },
+        },
+        commands,
+      });
+    } else {
+      commandsParsed[foundCommandIndex].commands.push(...commands);
+    }
+  }
+
+  const generateCommandsParsed = (commands, key) => {
+    for (const command of commands) createParsedCommand(command, { key });
+  };
+
+  commands.forEach(command =>
+    generateCommandsParsed(command.commands.map(sanitizeCommand), command.atKey)
+  );
+
+  return commandsParsed;
+}
+
+module.exports = {
+  parseCommandCSVRow,
+  parseCommandCSVRowV2,
+  flattenObject,
+};

lib/data/parse-support.js

@@ -22,6 +22,8 @@ function parseSupport(supportRaw) {
         ats: [at],
       })),
     ],
+    testPlanStrings: supportRaw.testPlanStrings,
+    references: supportRaw.references,
   };
 }