reslop 0.2.4 → 0.2.6

package/lib/report-test.js

@@ -3,8 +3,10 @@
 const model = require('./report-model.js');
 const npmCommands = require('./npm-commands.js');
 const { isPassingTest } = npmCommands;
+const utilities = require('./utilities.js');
+const { unquote } = utilities;
 
-const { summary, problem, report, userTrace } = model;
+const { summary, problem, report, userTrace, errorKey } = model;
 
 const KNOWN = [
   'message',
@@ -20,8 +22,38 @@ const KNOWN = [
   'location',
   'severity',
   'type',
+  'at',
+  'found',
+  'wanted',
+  'got',
+  'expect',
 ];
 
+const HIDDEN = ['generatedMessage', 'diff'];
+
+const ERROR_HEAD = /^([\w.]*Error)(?: \[([^\]]+)\])?:\s*/;
+
+const exceptionFields = (lines) => {
+  const rows = lines.map((line) => line.replace(/^\s*# ?/, ''));
+  const header = rows.findIndex((line) => ERROR_HEAD.test(line.trim()));
+  const frame = rows.findIndex((line) => /^\s*at\s/.test(line));
+  const start = header < 0 ? 0 : header;
+  const end = frame < 0 ? rows.length : frame;
+  const text = rows
+    .slice(start, end)
+    .map((line) => line.trim())
+    .join('\n');
+  const match = ERROR_HEAD.exec(text);
+  const message = match ? text.slice(match[0].length).trim() : text.trim();
+  const stack = frame < 0 ? '' : rows.slice(frame).join('\n');
+  return [
+    ['message', message],
+    ['name', match ? match[1] : ''],
+    ['code', match ? match[2] || '' : ''],
+    ['stack', stack],
+  ];
+};
+
 const show = (value) => {
   if (value === null || value === undefined) return '';
   if (typeof value === 'string') return value;
@@ -34,7 +66,7 @@ const show = (value) => {
 const extraFrom = (fields) => {
   const extra = [];
   for (const field of fields) {
-    if (KNOWN.includes(field[0])) continue;
+    if (KNOWN.includes(field[0]) || HIDDEN.includes(field[0])) continue;
     const value = show(field[1]);
     if (!value) continue;
     const shown = value.length > 500 ? `${value.slice(0, 500)}…` : value;
@@ -43,41 +75,70 @@ const extraFrom = (fields) => {
   return extra;
 };
 
-const fieldMap = (fields) => {
-  const map = new Map();
-  for (const field of fields) map.set(field[0], field[1]);
-  return map;
-};
-
-const problemFromFields = (name, fields, root) => {
-  const map = fieldMap(fields);
-  const message = show(map.get('error') || map.get('message'));
+const problemFromFields = (name, fields, root, fallback = '') => {
+  const map = new Map(fields);
   const stack = show(map.get('stack'));
-  const location = show(map.get('location'));
-  const trace = userTrace(stack || location, root);
+  const parsed = new Map(exceptionFields(stack.split(/\r?\n/)));
+  const text = show(
+    map.get('error') || map.get('message') || parsed.get('message'),
+  );
+  const header = ERROR_HEAD.exec(text);
+  const message = header ? text.slice(header[0].length).trim() : text;
+  const location = show(map.get('at') || map.get('location'));
   const duration = show(map.get('duration_ms') || map.get('duration'));
-  return problem({
+  const details = {
     name,
     message,
-    trace,
     duration,
-    code: show(map.get('code')),
+    code: show(map.get('code') || (header && header[2]) || parsed.get('code')),
     operator: show(map.get('operator')),
-    expected: show(map.get('expected')),
-    actual: show(map.get('actual')),
+    expected: show(
+      map.get('expected') ?? map.get('wanted') ?? map.get('expect'),
+    ),
+    actual: show(map.get('actual') ?? map.get('found') ?? map.get('got')),
     extra: extraFrom(fields),
-  });
+  };
+  const type = show(
+    map.get('name') || (header && header[1]) || parsed.get('name'),
+  );
+  if (type) details.extra.unshift(['type', type]);
+  const known =
+    message ||
+    stack ||
+    location ||
+    details.operator ||
+    details.code ||
+    details.expected ||
+    details.actual;
+  if (!known) details.message = fallback;
+  const source = show(map.get('at')) || stack || location;
+  const key = errorKey({ ...details, type }, source, root);
+  const trace = userTrace(parsed.get('stack') || stack || location, root);
+  return problem({ ...details, key, trace });
 };
 
-const yamlValue = (raw) => {
-  const text = `${raw ?? ''}`.trim();
-  if (text.length < 2) return text;
-  const open = text[0];
-  const close = text[text.length - 1];
-  const code = open.charCodeAt(0);
-  const quoted = open === close && (code === 34 || code === 39);
-  if (quoted) return text.slice(1, -1);
-  return text;
+const quoted = (value) => value.startsWith('"') || value.startsWith('\x27');
+
+const scalarText = (value) => {
+  if (value.startsWith('"')) {
+    try {
+      return JSON.parse(value.replace(/\r?\n/g, '\\n'));
+    } catch {
+      return unquote(value);
+    }
+  }
+  return unquote(value);
+};
+
+const blockText = (lines) => {
+  let indent = Infinity;
+  for (const line of lines) {
+    if (line.trim()) indent = Math.min(indent, line.match(/^\s*/)[0].length);
+  }
+  return lines
+    .map((line) => line.slice(indent))
+    .join('\n')
+    .trimEnd();
 };
 
 const yamlFields = (lines) => {
@@ -90,70 +151,128 @@ const yamlFields = (lines) => {
       continue;
     }
     const key = match[2];
-    const value = match[3].trim().replace(/,$/, '');
+    let value = match[3].trim().replace(/,$/, '');
     const block = value === '|-' || value === '|' || value === '>';
-    if (!block) {
-      fields.push([key, yamlValue(value)]);
-      index += 1;
+    index += 1;
+    if (key === 'error' && !value) continue;
+    if (quoted(value)) {
+      const quote = value[0];
+      while (
+        index < lines.length &&
+        (value.length < 2 || value.at(-1) !== quote)
+      ) {
+        value = `${value}\n${lines[index]}`;
+        index += 1;
+      }
+      fields.push([key, scalarText(value)]);
       continue;
     }
     const rows = [];
-    index += 1;
-    while (index < lines.length && /^\s+\S/.test(lines[index])) {
-      rows.push(lines[index].trim());
+    const indent = match[1].length;
+    while (index < lines.length) {
+      const line = lines[index];
+      if (line.trim() && line.match(/^\s*/)[0].length <= indent) break;
+      rows.push(lines[index]);
       index += 1;
     }
-    fields.push([key, rows.join('\n')]);
+    if (block || rows.some((line) => line.trim())) {
+      const text = blockText(rows);
+      fields.push([key, block ? text : `${value}\n${text}`.trim()]);
+    } else {
+      fields.push([key, scalarText(value)]);
+    }
   }
   return fields;
 };
 
-const readYaml = (lines, start) => {
-  const body = [];
-  let index = start + 1;
-  for (; index < lines.length; index++) {
-    if (lines[index].trim() === '...') break;
-    body.push(lines[index]);
-  }
-  return { fields: yamlFields(body), next: index + 1 };
+const tapPoint = (line) => {
+  const match = /^\s*(not ok|ok)\b(?:\s+\d+)?(?:\s+-)?(?:\s+(.*))?$/.exec(line);
+  if (!match) return null;
+  const text = match[2] || '';
+  return {
+    passed: match[1] === 'ok',
+    name: text
+      .split(/\s+#/)[0]
+      .replace(/\s*\{\s*$/, '')
+      .trim(),
+    skipped: /#\s*(SKIP|TODO)\b/i.test(text),
+    container: /\{\s*$/.test(text),
+  };
 };
 
-const tapName = (line) => {
-  const match = /^(?:not )?ok\s+\d+\s+-?\s*(.*)$/.exec(line.trim());
-  if (!match) return line.trim();
-  return match[1].trim();
+const STAT_FIELD = {
+  tests: 'tests',
+  pass: 'passed',
+  fail: 'failed',
+  skipped: 'skipped',
+  skip: 'skipped',
+};
+
+const applyStat = (stats, key, value) => {
+  if (key === 'duration_ms') stats.duration = value;
+  const field = Object.hasOwn(STAT_FIELD, key) ? STAT_FIELD[key] : '';
+  if (field) stats[field] = Number(value);
 };
 
 const applyTapComment = (stats, line) => {
   const match = /^#\s+(\w+)\s+(.+)$/.exec(line.trim());
-  if (!match) return;
-  const key = match[1];
-  const value = match[2].trim();
-  if (key === 'tests') stats.tests = Number(value);
-  if (key === 'pass') stats.passed = Number(value);
-  if (key === 'fail') stats.failed = Number(value);
-  if (key === 'skipped' || key === 'skip') stats.skipped = Number(value);
-  if (key === 'duration_ms') stats.duration = value;
+  if (match) applyStat(stats, match[1], match[2].trim());
 };
 
 const isTapLine = (line) => {
   const text = line.trim();
   if (text.startsWith('TAP version')) return true;
-  if (/^(not )?ok\s+\d+\b/.test(text)) return true;
+  if (tapPoint(text)) return true;
   if (/^1\.\.\d+/.test(text)) return true;
   if (text.startsWith('Bail out!')) return true;
   return false;
 };
 
+const tapBoundary = (line) => {
+  if (isTapLine(line) || line.trim() === '}') return true;
+  const stats =
+    /^\s*#\s+(?:Subtest:|(?:tests|pass|fail|skipped|duration_ms)\s+\d)/;
+  return stats.test(line);
+};
+
+const readYaml = (lines, start) => {
+  const body = [];
+  const indent = lines[start].match(/^\s*/)[0].length;
+  let index = start + 1;
+  for (; index < lines.length; index++) {
+    if (lines[index].trim() === '...') break;
+    const lead = lines[index].match(/^\s*/)[0].length;
+    if (lead <= indent && tapBoundary(lines[index])) break;
+    body.push(lines[index]);
+  }
+  const end = lines[index] && lines[index].trim() === '...';
+  return { fields: yamlFields(body), next: end ? index + 1 : index };
+};
+
+const readTapFields = (lines, start) => {
+  const fields = [];
+  const body = [];
+  let index = start;
+  while (index < lines.length && !tapBoundary(lines[index])) {
+    if (lines[index].trim() === '---') {
+      const yaml = readYaml(lines, index);
+      fields.push(...yaml.fields);
+      index = yaml.next;
+    } else {
+      body.push(lines[index]);
+      index += 1;
+    }
+  }
+  if (!fields.length) fields.push(...exceptionFields(body));
+  return { fields, next: index };
+};
+
 const parseTap = (text, root) => {
   const lines = `${text ?? ''}`.split(/\r?\n/);
-  let seen = false;
-  for (const line of lines) {
-    if (isTapLine(line)) seen = true;
-  }
-  if (!seen) return null;
+  if (!lines.some(isTapLine)) return null;
   const stats = summary();
   const problems = [];
+  const counts = { tests: 0, passed: 0, failed: 0, skipped: 0 };
   let index = 0;
   while (index < lines.length) {
     const line = lines[index];
@@ -162,73 +281,67 @@ const parseTap = (text, root) => {
     if (trimmed.startsWith('Bail out!')) {
       problems.push(problem({ name: 'Bail out!', message: trimmed }));
     }
-    const failed = /^not ok\s+\d+\b/.test(trimmed);
-    const passed = /^ok\s+\d+\b/.test(trimmed);
-    if (!failed && !passed) {
+    const point = tapPoint(line);
+    if (!point || point.container) {
       index += 1;
       continue;
     }
-    const name = tapName(trimmed);
-    let fields = [];
-    if (lines[index + 1] && lines[index + 1].trim() === '---') {
-      const yaml = readYaml(lines, index + 1);
-      fields = yaml.fields;
-      index = yaml.next;
+    const body = readTapFields(lines, index + 1);
+    index = body.next;
+    const failure = new Map(body.fields).get('failureType');
+    if (failure === 'subtestsFailed') continue;
+    counts.tests += 1;
+    if (point.skipped) {
+      counts.skipped += 1;
+    } else if (point.passed) {
+      counts.passed += 1;
     } else {
-      index += 1;
+      counts.failed += 1;
+      problems.push(
+        problemFromFields(point.name, body.fields, root, point.name),
+      );
     }
-    if (failed) problems.push(problemFromFields(name, fields, root));
   }
-  return report('test', { summary: stats, problems });
-};
-
-const countStatus = (stats, status) => {
-  if (status === 'passed' || status === 'pass') {
-    stats.passed = (stats.passed || 0) + 1;
-    return;
-  }
-  if (status === 'failed' || status === 'fail' || status === 'timedOut') {
-    stats.failed = (stats.failed || 0) + 1;
-    return;
-  }
-  if (status === 'skipped' || status === 'pending' || status === 'todo') {
-    stats.skipped = (stats.skipped || 0) + 1;
+  for (const key of Object.keys(counts)) {
+    if (stats[key] === null) stats[key] = counts[key];
   }
+  return report('test', { summary: stats, problems });
 };
 
 const nodeEventProblem = (event, root) => {
   const data = event.data || {};
   const details = data.details || {};
   const error = details.error || {};
-  const fields = [];
-  for (const key of Object.keys(error)) fields.push([key, error[key]]);
+  const fields = Object.entries(error);
   if (details.duration_ms !== undefined) {
     fields.push(['duration_ms', details.duration_ms]);
   }
-  const name = data.name || '';
-  return problemFromFields(name, fields, root);
+  return problemFromFields(data.name || '', fields, root);
 };
 
 const parseNodeEvents = (events, root) => {
-  const stats = summary();
   const problems = [];
   let seen = false;
+  let passed = 0;
+  let failed = 0;
+  let skipped = 0;
   for (const event of events) {
     const type = event && event.type;
     if (typeof type !== 'string' || !type.startsWith('test:')) continue;
     seen = true;
-    if (type === 'test:pass') countStatus(stats, 'passed');
+    if (type === 'test:pass') passed += 1;
+    if (type === 'test:skip' || type === 'test:todo') skipped += 1;
     if (type === 'test:fail') {
-      countStatus(stats, 'failed');
+      failed += 1;
       problems.push(nodeEventProblem(event, root));
     }
-    if (type === 'test:skip' || type === 'test:todo') {
-      countStatus(stats, 'skipped');
-    }
   }
   if (!seen) return null;
-  const skipped = stats.skipped || 0;
-  stats.tests = (stats.passed || 0) + (stats.failed || 0) + skipped;
+  const stats = summary();
+  stats.tests = passed + failed + skipped;
+  stats.passed = passed || null;
+  stats.failed = failed || null;
+  stats.skipped = skipped || null;
   return report('test', { summary: stats, problems });
 };
 
@@ -259,6 +372,8 @@ const jestTrace = (text, file, root) => {
   return userTrace(file, root);
 };
 
+const durationText = (value) => (value === undefined ? '' : `${value}`);
+
 const jestProblem = (item, file, root) => {
   const messages = item.failureMessages || [];
   const text = messages.join('\n');
@@ -270,7 +385,7 @@ const jestProblem = (item, file, root) => {
     trace: jestTrace(text, file, root),
     expected: expected ? expected[1] : '',
     actual: received ? received[1] : '',
-    duration: item.duration === undefined ? '' : `${item.duration}`,
+    duration: durationText(item.duration),
   });
 };
 
@@ -298,29 +413,27 @@ const parseJest = (data, root) => {
   return report('test', { summary: stats, problems });
 };
 
+const PLAYWRIGHT_FAILED = ['failed', 'timedOut'];
+
+const playwrightProblem = (spec, result, root) => {
+  const error = result.error || {};
+  return problem({
+    name: spec.title || '',
+    message: error.message || result.status,
+    trace: userTrace(error.stack || '', root),
+    duration: durationText(result.duration),
+  });
+};
+
 const walkPlaywright = (suite, problems, root) => {
-  const specs = suite.specs || [];
-  for (const spec of specs) {
-    const tests = spec.tests || [];
-    for (const item of tests) {
-      const results = item.results || [];
-      for (const result of results) {
-        const status = result.status;
-        if (status !== 'failed' && status !== 'timedOut') continue;
-        const error = result.error || {};
-        problems.push(
-          problem({
-            name: spec.title || '',
-            message: error.message || status,
-            trace: userTrace(error.stack || '', root),
-            duration: result.duration === undefined ? '' : `${result.duration}`,
-          }),
-        );
-      }
+  for (const spec of suite.specs || []) {
+    const results = (spec.tests || []).flatMap((item) => item.results || []);
+    for (const result of results) {
+      if (!PLAYWRIGHT_FAILED.includes(result.status)) continue;
+      problems.push(playwrightProblem(spec, result, root));
     }
   }
-  const children = suite.suites || [];
-  for (const child of children) walkPlaywright(child, problems, root);
+  for (const child of suite.suites || []) walkPlaywright(child, problems, root);
 };
 
 const parsePlaywright = (data, root) => {
@@ -349,12 +462,7 @@ const specStats = (stats, line) => {
   const match = /^[ℹi]\s+(\w+)\s+(.+)$/.exec(line.trim());
   if (!match) return false;
   const key = match[1];
-  const value = match[2].trim();
-  if (key === 'tests') stats.tests = Number(value);
-  if (key === 'pass') stats.passed = Number(value);
-  if (key === 'fail') stats.failed = Number(value);
-  if (key === 'skipped') stats.skipped = Number(value);
-  if (key === 'duration_ms') stats.duration = value;
+  applyStat(stats, key, match[2].trim());
   return key === 'tests' || key === 'pass' || key === 'fail';
 };
 
@@ -391,19 +499,17 @@ const readSpecObject = (lines, start) => {
 
 const pushSpec = (problems, current, root) => {
   if (!current) return;
-  const fields = current.fields;
-  const item = problemFromFields(current.name, fields, root);
-  if (current.message && !item.message) item.message = current.message;
-  const trace = userTrace(current.trace.join('\n'), root);
-  if (trace) item.trace = trace;
-  if (current.expected) item.expected = current.expected;
-  if (current.actual) item.actual = current.actual;
-  problems.push(item);
+  const fields = [...current.fields];
+  if (current.message) fields.push(['error', current.message.trimEnd()]);
+  if (current.trace.length) fields.push(['stack', current.trace.join('\n')]);
+  if (current.expected) fields.push(['expected', current.expected]);
+  if (current.actual) fields.push(['actual', current.actual]);
+  problems.push(problemFromFields(current.name, fields, root));
 };
 
 const takeSpecLine = (current, line) => {
   const text = line.trim();
-  if (/^(AssertionError|Error)\b/.test(text)) {
+  if (/^[\w.]*Error(?: \[[^\]]+\])?:/.test(text)) {
     current.message = text;
     return;
   }
@@ -411,6 +517,9 @@ const takeSpecLine = (current, line) => {
   if (expected) current.expected = expected[1];
   const received = /^Received:\s*(.*)$/.exec(text);
   if (received) current.actual = received[1];
+  if (current.message && !current.trace.length) {
+    current.message = `${current.message}\n${text}`;
+  }
 };
 
 const takeSpecFrame = (lines, index, current) => {
@@ -440,12 +549,8 @@ const dropPreviews = (problems) => {
   for (const item of problems) {
     if (item.name && hasDetail(item)) named.add(item.name);
   }
-  const kept = [];
-  for (const item of problems) {
-    if (item.name && named.has(item.name) && !hasDetail(item)) continue;
-    kept.push(item);
-  }
-  return kept;
+  const isPreview = (item) => named.has(item.name) && !hasDetail(item);
+  return problems.filter((item) => !isPreview(item));
 };
 
 const parseSpec = (text, root) => {
@@ -454,9 +559,19 @@ const parseSpec = (text, root) => {
   const problems = [];
   let current = null;
   let marked = false;
+  let summarized = false;
   let index = 0;
   while (index < lines.length) {
     const line = lines[index];
+    if (specHeader(line)) {
+      pushSpec(problems, current, root);
+      current = null;
+      if (!summarized) problems.length = 0;
+      summarized = true;
+      marked = true;
+      index += 1;
+      continue;
+    }
     if (specStats(stats, line)) marked = true;
     if (isPassingTest(line)) {
       marked = true;