testilo 3.2.0 → 3.4.0

package/procs/digest/dp10c/index.js

@@ -0,0 +1,129 @@
+/*
+  index: digester for scoring procedure sp10b.
+  Creator of parameters for substitution into index.html.
+  Usage example: node digest 35k1r-railpass dp10b
+  Arguments:
+    0. report. Scored report.
+    1. query. Object to which this module will add properties.
+*/
+
+// CONSTANTS
+
+  // Newlines with indentations.
+  const joiner = '\n      ';
+  const innerJoiner = '\n        ';
+  const specialMessages = {
+    log: 'This is based on the amount of browser logging during the tests. Browsers usually log messages only when pages contain erroneous code.',
+    preventions: 'This is based on tests that the page did not allow to be run. That impedes accessibility progress and risks interfering with tools that users with disabilities need.',
+    solos: 'This is based on issues reported by unclassified tests. Details are in the report.'
+  };
+
+// FUNCTIONS
+
+// Makes strings HTML-safe.
+const htmlEscape = textOrNumber => textOrNumber
+.toString()
+.replace(/&/g, '&')
+.replace(/</g, '&lt;');
+// Gets a row of the score-summary table.
+const getScoreRow = (component, score) => `<tr><th>${component}</th><td>${score}</td></tr>`;
+// Gets the start of a paragraph about a special score.
+const getSpecialPStart
+= (summary, scoreID) => `<p><span class="componentID">log</span>: Score ${summary[scoreID]}.`;
+// Adds parameters to a query for a digest.
+exports.makeQuery = (report, query) => {
+  // Add an HTML-safe copy of the host report to the query to be appended to the digest.
+  const {script, host, score} = report;
+  const reportJSON = JSON.stringify(report, null, 2);
+  const reportJSONSafe = htmlEscape(reportJSON);
+  query.report = reportJSONSafe;
+  // Add the job data to the query.
+  query.dateISO = report.endTime.slice(0, 10);
+  query.dateSlash = query.dateISO.replace(/-/g, '/');
+  query.scriptID = script.id;
+  if (host && host.what && host.which) {
+    query.org = host.what;
+    query.url = host.which;
+  }
+  else {
+    const firstURLCommand = script.commands.find(command => command.type === 'url');
+    if (firstURLCommand && firstURLCommand.what && firstURLCommand.which) {
+      query.org = script.what;
+      query.url = firstURLCommand.which;
+    }
+    else {
+      console.log('ERROR: host missing or invalid');
+      return;
+    }
+  }
+  const {groupDetails, summary} = score;
+  if (typeof summary.total === 'number') {
+    query.totalScore = summary.total;
+  }
+  else {
+    console.log('ERROR: missing or invalid total score');
+    return;
+  }
+  // Add the total and any special rows of the score-summary table to the query.
+  const scoreRows = [];
+  const specialComponentIDs = ['log', 'preventions', 'solos'];
+  ['total'].concat(specialComponentIDs).forEach(item => {
+    if (summary[item]) {
+      scoreRows.push(getScoreRow(item, summary[item]));
+    }
+  });
+  // Add the group rows of the score-summary table to the query.
+  const {groups} = summary;
+  const groupIDs = Object.keys(groups);
+  groupIDs.sort((a, b) => groups[b] - groups[a]);
+  groupIDs.forEach(groupID => {
+    scoreRows.push(getScoreRow(`group ${groupID}`, groups[groupID]));
+  });
+  query.scoreRows = scoreRows.join(innerJoiner);
+  // If the score has any special components:
+  const scoredSpecialIDs = specialComponentIDs.filter(item => summary[item]);
+  if (scoredSpecialIDs.length) {
+    // Add paragraphs about them for the issue summary to the query.
+    const specialPs = [];
+    scoredSpecialIDs.forEach(id => {
+      specialPs.push(`${getSpecialPStart(summary, id)} ${specialMessages[id]}`);
+    });
+    query.specialSummary = specialPs.join(joiner);
+  }
+  // Otherwise, i.e. if the score has no special components:
+  else {
+    // Add a paragraph stating this for the issue summary to the query.
+    query.specialSummary = '<p>No special issues contributed to the score.</p>'
+  }
+  // If the score has any classified issues as components:
+  if (groupIDs.length) {
+    // Add paragraphs about them for the special summary to the query.
+    const groupSummaryItems = [];
+    groupIDs.forEach(id => {
+      const groupP = `<p><span class="componentID">${id}</span>: Score ${summary.groups[id]}. Issues reported by tests in this category:</p>`;
+      const groupListItems = [];
+      const groupData = groupDetails.groups[id];
+      const packageIDs = Object.keys(groupData);
+      packageIDs.forEach(packageID => {
+        const testIDs = Object.keys(groupData[packageID]);
+        testIDs.forEach(testID => {
+          const testData = groupData[packageID][testID];
+          const listItem = `<li>${testData.issueCount} issues reported by package ${packageID}, test ${testID} (${testData.what})</li>`;
+          groupListItems.push(listItem);
+        });
+      });
+      const groupList = [
+        '<ul>',
+        groupListItems.join('\n  '),
+        '</ul>'
+      ].join(joiner);
+      groupSummaryItems.push(groupP, groupList);
+    });
+    query.groupSummary = groupSummaryItems.join(joiner);
+  }
+  // Otherwise, i.e. if the score has no classified issues as components:
+  else {
+    // Add a paragraph stating this for the group summary to the query.
+    query.groupSummary = '<p>No classified issues contributed to the score.</p>'
+  }
+};

package/procs/score/sp10b.js

@@ -0,0 +1,507 @@
+/*
+  sp10b
+  Testilo score proc 10b
+  Computes scores from Testaro script tp10 and adds them to a report.
+  Usage example: node score 35k1r sp10b
+*/
+
+// ########## IMPORTS
+
+// Module to read and write files.
+const fs = require('fs/promises');
+
+// CONSTANTS
+
+const scoreProcID = 'sp10b';
+// Define the configuration disclosures.
+const logWeights = {
+  count: 0.5,
+  size: 0.01,
+  prohibited: 15,
+  visitTimeout: 10,
+  visitRejection: 10
+};
+const groupWeights = {
+  accessKeyDuplicate: 3,
+  activeEmbedding: 2,
+  allCaps: 1,
+  ariaReferenceBad: 4,
+  autocompleteBad: 2,
+  buttonNoText: 4,
+  childMissing: 3,
+  contrastAA: 3,
+  contrastAAA: 1,
+  duplicateID: 2,
+  eventKeyboard: 3,
+  fieldSetMissing: 2,
+  focusableOperable: 3,
+  focusIndication: 3,
+  h1Missing: 1,
+  headingEmpty: 2,
+  headingStructure: 2,
+  hoverSurprise: 1,
+  iframeNoText: 3,
+  imageInputNoText: 4,
+  imageMapAreaNoText: 3,
+  imageNoText: 4,
+  imageTextRedundant: 1,
+  inconsistentStyles: 1,
+  contrastRisk: 1,
+  labelClash: 2,
+  labelForBadID: 4,
+  languageChange: 2,
+  leadingClipsText: 3,
+  leadingFrozen: 3,
+  linkForcesNewWindow: 2,
+  linkNoText: 4,
+  linkPair: 1,
+  linkTextsSame: 2,
+  linkTitleRedundant: 1,
+  linkUnderlines: 2,
+  menuNavigation: 2,
+  metaBansZoom: 3,
+  nameValue: 3,
+  noLeading: 2,
+  objectNoText: 2,
+  pageLanguage: 3,
+  pageLanguageBad: 3,
+  pageTitle: 3,
+  parentMissing: 3,
+  pseudoHeadingRisk: 1,
+  pseudoLinkRisk: 2,
+  pseudoListRisk: 1,
+  roleBad: 3,
+  roleBadAttribute: 3,
+  roleMissingAttribute: 3,
+  selectFlatRisk: 1,
+  selectNoText: 3,
+  spontaneousMotion: 2,
+  svgImageNoText: 4,
+  tabFocusability: 3,
+  tabNavigation: 2,
+  targetSize: 2,
+  textBeyondLandmarks: 1,
+  visibleBulk: 1,
+  zIndexNotZero: 1
+};
+const soloWeight = 1;
+const countWeights = {
+  absolute: 2,
+  largest: 1,
+  smaller: 0.4
+};
+const preventionWeights = {
+  testaro: 50,
+  other: 100
+};
+const packageDetails = {};
+const groupDetails = {
+  groups: {},
+  solos: {}
+};
+const summary = {
+  total: 0,
+  log: 0,
+  preventions: 0,
+  solos: 0,
+  groups: {}
+};
+const otherPackages = ['aatt', 'alfa', 'axe', 'ibm', 'tenon', 'wave'];
+const preventionScores = {};
+
+// FUNCTIONS
+
+// Adds to the count of issues of a kind discovered by a test package.
+const addDetail = (actWhich, testID, addition = 1) => {
+  if (! packageDetails[actWhich]) {
+    packageDetails[actWhich] = {};
+  }
+  if (! packageDetails[actWhich][testID]) {
+    packageDetails[actWhich][testID] = 0;
+  }
+  packageDetails[actWhich][testID] += addition;
+};
+exports.scorer = async report => {
+  // If there are any acts:
+  const {acts} = report;
+  if (Array.isArray(acts)) {
+    // If any of them are test acts:
+    const testActs = acts.filter(act => act.type === 'test');
+    if (testActs.length) {
+      // For each test act:
+      testActs.forEach(test => {
+        const {which} = test;
+        // Get the issue tally.
+        if (which === 'aatt') {
+          const issues = test.result;
+          if (issues && Array.isArray(issues)) {
+            issues.forEach(issue => {
+              const {type, id} = issue;
+              if (type && id) {
+                const typedID = `${type[0]}:${id}`;
+                addDetail(which, typedID);
+              }
+            });
+          }
+        }
+        else if (which === 'alfa') {
+          const issues = test.result;
+          if (issues && Array.isArray(issues)) {
+            issues.forEach(issue => {
+              const {rule} = issue;
+              if (rule) {
+                const {ruleID} = rule;
+                if (ruleID) {
+                  addDetail(which, ruleID);
+                }
+              }
+            });
+          }
+        }
+        else if (which === 'axe') {
+          const tests = test.result && test.result.items;
+          if (tests && Array.isArray(tests)) {
+            tests.forEach(test => {
+              const {rule, elements} = test;
+              if (rule && Array.isArray(elements) && elements.length) {
+                addDetail(which, rule, elements.length);
+              }
+            });
+          }
+        }
+        else if (which === 'ibm') {
+          const envs = test.result;
+          const {content, url} = envs;
+          if (content && url) {
+            let preferredEnv = 'content';
+            if (
+              content.error
+              || content.totals
+              && content.totals.violation
+              && url.totals
+              && url.totals.violation
+              && url.totals.violation > content.totals.violation
+            ) {
+              preferredEnv = 'url';
+            }
+            const {items} = envs[preferredEnv];
+            if (items && Array.isArray(items) && items.length) {
+              items.forEach(issue => {
+                const {ruleID} = issue;
+                if (ruleID) {
+                  addDetail(which, ruleID);
+                }
+              });
+            }
+          }
+        }
+        else if (which === 'tenon') {
+          const issues = test.result && test.result.data && test.result.data.resultSet;
+          if (issues && Array.isArray(issues) && issues.length) {
+            issues.forEach(issue => {
+              const {tID} = issue;
+              if (tID) {
+                addDetail(which, tID);
+              }
+            })
+          }
+        }
+        else if (which === 'wave') {
+          const issueClasses = test.result && test.result.categories;
+          if (issueClasses) {
+            ['error', 'contrast', 'alert'].forEach(issueClass => {
+              const {items} = issueClasses[issueClass];
+              if (items) {
+                const testIDs = Object.keys(items);
+                if (testIDs.length) {
+                  testIDs.forEach(testID => {
+                    const {count} = items[testID];
+                    if (count) {
+                      addDetail(which, `${issueClass[0]}:${testID}`, count);
+                    }
+                  });
+                }
+              }
+            });
+          }
+        }
+        else if (which === 'bulk') {
+          const count = test.result && test.result.visibleElements;
+          if (typeof count === 'number') {
+            const faultCount = Math.floor(count / 300);
+            addDetail('testaro', which, faultCount);
+          }
+        }
+        else if (which === 'embAc') {
+          const issueCounts = test.result && test.result.totals;
+          if (issueCounts) {
+            const counts = Object.values(issueCounts);
+            const total = counts.reduce((sum, current) => sum + current);
+            addDetail('testaro', which, total);
+          }
+        }
+        else if (which === 'focAll') {
+          const discrepancy = test.result && test.result.discrepancy;
+          if (discrepancy) {
+            addDetail('testaro', which, Math.abs(discrepancy));
+          }
+        }
+        else if (which === 'focInd') {
+          const issueTypes = test.result && test.result.totals && test.result.totals.types;
+          if (issueTypes) {
+            const missingCount = issueTypes.indicatorMissing && issueTypes.indicatorMissing.total;
+            const badCount = issueTypes.nonOutlinePresent && issueTypes.nonOutlinePresent.total;
+            const faultCount = Math.round(missingCount + badCount / 2);
+            if (faultCount) {
+              addDetail('testaro', which, faultCount);
+            }
+          }
+        }
+        else if (which === 'focOp') {
+          const issueTypes = test.result && test.result.totals && test.result.totals.types;
+          if (issueTypes) {
+            const noOpCount = issueTypes.onlyFocusable && issueTypes.onlyFocusable.total;
+            const noFocCount = issueTypes.onlyOperable && issueTypes.onlyOperable.total;
+            const faultCount = Math.round(noFocCount + noOpCount / 2);
+            if (faultCount) {
+              addDetail('testaro', which, faultCount);
+            }
+          }
+        }
+        else if (which === 'hover') {
+          const issues = test.result && test.result.totals;
+          if (issues) {
+            const {triggers, madeVisible, opacityChanged, opacityAffected, unhoverables} = issues;
+            const faultCount = Math.round(
+              1 * triggers
+              + 0.5 * madeVisible
+              + 0.2 * opacityChanged
+              + 0.2 * opacityAffected
+              + 1 * unhoverables
+            );
+            if (faultCount) {
+              addDetail('testaro', which, faultCount);
+            }
+          }
+        }
+        else if (which === 'labClash') {
+          const mislabeledCount = test.result
+          && test.result.totals
+          && test.result.totals.mislabeled;
+          if (mislabeledCount) {
+            addDetail('testaro', which, mislabeledCount);
+          }
+        }
+        else if (which === 'linkUl') {
+          const issues = test.result && test.result.items && test.result.items.notUnderlined;
+          if (issues && issues.length) {
+            addDetail('testaro', which, issues.length);
+          }
+        }
+        else if (which === 'menuNav') {
+          const issueCount = test.result
+          && test.result.totals
+          && test.result.totals.navigations
+          && test.result.totals.navigations.all
+          && test.result.totals.navigations.all.incorrect;
+          if (issueCount && typeof issueCount === 'number') {
+            addDetail('testaro', which, issueCount);
+          }
+        }
+        else if (which === 'motion') {
+          const data = test.result;
+          if (data && data.bytes) {
+            const faultCount = Math.floor(
+              5 * (data.meanLocalRatio - 1)
+              + 2 * (data.maxLocalRatio - 1)
+              + data.globalRatio - 1
+              + data.meanPixelChange / 10000
+              + data.maxPixelChange / 25000
+              + 30 * data.changeFrequency
+            );
+            addDetail('testaro', which, faultCount);
+          }
+        }
+        else if (which === 'radioSet') {
+          const counts = test.result && test.result.totals;
+          const {total, inSet} = counts;
+          if (total && typeof inSet === 'number' && total >= inSet) {
+            addDetail('testaro', which, total - inSet);
+          }
+        }
+        else if (which === 'role') {
+          const issueCount = test.result && test.result.badRoleElements;
+          if (issueCount && typeof issueCount === 'number') {
+            addDetail('testaro', which, issueCount);
+          }
+        }
+        else if (which === 'styleDiff') {
+          const counts = test.result && test.result.totals;
+          if (counts) {
+            // Identify objects having the tag-name totals and style distributions as properties.
+            const tagNameCounts = Object.values(counts);
+            // Identify an array of pairs of counts of excess styles and of nonplurality elements.
+            const faults = tagNameCounts.map(
+              item => {
+                const subtotals = item.subtotals ? item.subtotals : [item.total];
+                return [subtotals.length - 1, item.total - subtotals[0]];
+              }
+            );
+            // Fault count: 2 per excess style + 0.2 per nonplurality element.
+            const faultCount = Math.floor(faults.reduce(
+              (total, currentPair) => total + 2 * currentPair[0] + 0.2 * currentPair[1], 0
+            ));
+            addDetail('testaro', which, faultCount);
+          }
+        }
+        else if (which === 'tabNav') {
+          const issueCount = test.result
+          && test.result.totals
+          && test.result.totals.navigations
+          && test.result.totals.navigations.all
+          && test.result.totals.navigations.all.incorrect;
+          if (issueCount && typeof issueCount === 'number') {
+            addDetail('testaro', which, issueCount);
+          }
+        }
+        else if (which === 'zIndex') {
+          const issueCount = test.result && test.result.totals;
+          if (issueCount && typeof issueCount === 'number') {
+            addDetail('testaro', which, issueCount);
+          }
+        }
+      });
+      // Get the prevention scores and add them to the summary.
+      const actsPrevented = testActs.filter(test => test.result.prevented);
+      actsPrevented.forEach(act => {
+        if (otherPackages.includes(act.which)) {
+          preventionScores[act.which] = preventionWeights.other;
+        }
+        else {
+          preventionScores[`testaro-${act.which}`] = preventionWeights.testaro;
+        }
+      });
+      const preventionScore = Object
+      .values(preventionScores)
+      .reduce((sum, current) => sum + current, 0);
+      summary.preventions = preventionScore;
+      summary.total += preventionScore;
+      // Get data on test groups.
+      const testGroupsJSON = await fs.readFile('scoring/data/testGroups.json', 'utf8');
+      const testGroups = JSON.parse(testGroupsJSON);
+      // Use the data to populate groupDetails.groups.
+      const {tests} = testGroups;
+      const groupPackageIDs = Object.keys(tests);
+      groupPackageIDs.forEach(packageID => {
+        const packageTestIDs = Object.keys(tests[packageID]);
+        packageTestIDs.forEach(testID => {
+          const testData = tests[packageID][testID];
+          const {groupID, what} = testData;
+          if (! groupDetails.groups[groupID]) {
+            groupDetails.groups[groupID] = {};
+          }
+          if (! groupDetails.groups[groupID][packageID]) {
+            groupDetails.groups[groupID][packageID] = {};
+          }
+          groupDetails.groups[testData.groupID][packageID][testID] = {
+            what,
+            issueCount: 0
+          };
+        });
+      })
+      // Get the IDs of the packages whose tests report any issues.
+      const issuePackageIDs = Object.keys(packageDetails);
+      // For each such package:
+      issuePackageIDs.forEach(packageID => {
+        // Get the IDs of the tests in the package that report issues.
+        const issueTestIDs = Object.keys(packageDetails[packageID]);
+        // For each such test:
+        issueTestIDs.forEach(testID => {
+          // Get its group data, if any.
+          const testGroupData = tests[packageID][testID];
+          const issueCount = packageDetails[packageID][testID];
+          // If it is in a group:
+          if (testGroupData) {
+            // Add the issue count to the group details.
+            const {groupID} = testGroupData;
+            groupDetails.groups[groupID][packageID][testID].issueCount = issueCount;
+          }
+          // Otherwise, i.e. if the test is solo:
+          else {
+            // Add the issue count to the solo details.
+            if (! groupDetails.solos[packageID]) {
+              groupDetails.solos[packageID] = {};
+            }
+            groupDetails.solos[packageID][testID] = issueCount;
+          }
+        });
+      });
+      // Delete from the group details groups without any issues.
+      const groupIDs = Object.keys(groupDetails.groups);
+      groupIDs.forEach(groupID => {
+        const groupPackageData = Object.values(groupDetails.groups[groupID]);
+        if (
+          groupPackageData.every(datum => Object.values(datum).every(test => test.issueCount === 0))
+        ) {
+          delete groupDetails.groups[groupID];
+        }
+      });
+      // Get the group scores and add them to the summary.
+      const issueGroupIDs = Object.keys(groupDetails.groups);
+      const {absolute, largest, smaller} = countWeights;
+      issueGroupIDs.forEach(groupID => {
+        const issueCounts = [];
+        const groupPackageData = Object.values(groupDetails.groups[groupID]);
+        groupPackageData.forEach(packageDatum => {
+          const issueCountSum = Object
+          .values(packageDatum)
+          .reduce((sum, current) => sum + current.issueCount, 0);
+          issueCounts.push(issueCountSum);
+        });
+        issueCounts.sort((a, b) => b - a);
+        const groupScore = groupWeights[groupID] * (
+          absolute + largest * issueCounts[0] + smaller * issueCounts.slice(1).reduce(
+            (sum, current) => sum + current, 0
+          )
+        );
+        const roundedScore = Math.round(groupScore);
+        summary.groups[groupID] = roundedScore;
+        summary.total += roundedScore;
+      });
+      // Get the solo scores and add them to the summary.
+      const issueSoloPackageIDs = Object.keys(groupDetails.solos);
+      issueSoloPackageIDs.forEach(packageID => {
+        const testIDs = Object.keys(groupDetails.solos[packageID]);
+        testIDs.forEach(testID => {
+          const issueCount = groupDetails.solos[packageID][testID];
+          const issueScore = Math.round(soloWeight * issueCount);
+          summary.solos += issueScore;
+          summary.total += issueScore;
+        });
+      });
+    }
+  }
+  // Get the log score.
+  logScore = Math.floor(
+    logWeights.count * report.logCount
+    + logWeights.size * report.logSize
+    + logWeights.prohibited * report.prohibitedCount
+    + logWeights.visitTimeout * report.visitTimeoutCount
+    + logWeights.visitRejection * report.visitRejectionCount
+  );
+  summary.log = logScore;
+  summary.total += logScore;
+  // Add the score facts to the report.
+  report.score = {
+    scoreProcID,
+    logWeights,
+    groupWeights,
+    soloWeight,
+    countWeights,
+    preventionWeights,
+    packageDetails,
+    groupDetails,
+    preventionScores,
+    summary
+  };
+};