test_runner: use v8.serialize instead of TAP

Author: MoLow

doc/api/cli.md

@@ -2319,7 +2319,8 @@ on unsupported platforms will not be fixed.
 ### `NODE_TEST_CONTEXT=value`
 
 If `value` equals `'child'`, test reporter options will be overridden and test
-output will be sent to stdout in the TAP format.
+output will be sent to stdout in the TAP format. If any other value is provided,
+Node.js makes no guarantees about the reporter format used or its stability.
 
 ### `NODE_TLS_REJECT_UNAUTHORIZED=value`
 

lib/internal/error_serdes.js

@@ -13,6 +13,7 @@ const {
  ObjectGetOwnPropertyNames,
  ObjectGetPrototypeOf,
  ObjectKeys,
+ ObjectPrototypeHasOwnProperty,
  ObjectPrototypeToString,
  RangeError,
  ReferenceError,
@@ -52,7 +53,7 @@ function TryGetAllProperties(object, target = object) {
  // Continue regardless of error.
  }
  }
- if ('value' in descriptor && typeof descriptor.value !== 'function') {
+ if ('value' in descriptor && typeof descriptor.value !== 'function' && typeof descriptor.value !== 'symbol') {
  delete descriptor.get;
  delete descriptor.set;
  all[key] = descriptor;
@@ -104,6 +105,8 @@ function serializeError(error) {
  if (errorConstructorNames.has(name)) {
  const serialized = serialize({
  constructor: name,
+ cause: ObjectPrototypeHasOwnProperty(error, 'cause') ? serializeError(error.cause) : null,
+ hasCause: ObjectPrototypeHasOwnProperty(error, 'cause'),
  properties: TryGetAllProperties(error),
  });
  return Buffer.concat([Buffer.from([kSerializedError]), serialized]);
@@ -128,13 +131,20 @@ function deserializeError(error) {
  if (!deserialize) deserialize = require('v8').deserialize;
  switch (error[0]) {
  case kSerializedError: {
- const { constructor, properties } = deserialize(error.subarray(1));
+ const { constructor, properties, cause, hasCause } = deserialize(error.subarray(1));
  const ctor = errors[constructor];
  ObjectDefineProperty(properties, SymbolToStringTag, {
  __proto__: null,
- value: { value: 'Error', configurable: true },
+ value: { __proto__: null, value: 'Error', configurable: true },
  enumerable: true,
  });
+ if (hasCause) {
+ ObjectDefineProperty(properties, 'cause', {
+ __proto__: null,
+ value: { __proto__: null, value: deserializeError(cause), configurable: true },
+ enumerable: true,
+ });
+ }
  return ObjectCreate(ctor.prototype, properties);
  }
  case kSerializedObject:

lib/internal/test_runner/reporter/v8.js

@@ -0,0 +1,36 @@
+'use strict';
+
+const { DefaultSerializer } = require('v8');
+const { Buffer } = require('buffer');
+const { serializeError } = require('internal/error_serdes');
+
+
+module.exports = async function* v8Reporter(source) {
+ const serializer = new DefaultSerializer();
+
+ for await (const item of source) {
+ const originalError = item.data.details?.error;
+ if (originalError) {
+ item.data.details.error = serializeError(originalError);
+ }
+ // Add 4 bytes, to later populate with message length
+ serializer.writeRawBytes(Buffer.allocUnsafe(4));
+ serializer.writeHeader();
+ serializer.writeValue(item);
+
+ if (originalError) {
+ item.data.details.error = originalError;
+ }
+
+ const serializedMessage = serializer.releaseBuffer();
+ const serializedMessageLength = serializedMessage.length - 4;
+
+ serializedMessage.set([
+ serializedMessageLength >> 24 & 0xFF,
+ serializedMessageLength >> 16 & 0xFF,
+ serializedMessageLength >> 8 & 0xFF,
+ serializedMessageLength & 0xFF,
+ ], 0);
+ yield serializedMessage;
+ }
+};

lib/internal/test_runner/runner.js

@@ -12,22 +12,25 @@ const {
  ArrayPrototypeSort,
  ObjectAssign,
  PromisePrototypeThen,
- SafePromiseAll,
  SafePromiseAllReturnVoid,
  SafePromiseAllSettledReturnVoid,
  PromiseResolve,
  SafeMap,
  SafeSet,
+ String,
  StringPrototypeIndexOf,
  StringPrototypeSlice,
  StringPrototypeStartsWith,
+ TypedArrayPrototypeSubarray,
 } = primordials;
 
 const { spawn } = require('child_process');
 const { readdirSync, statSync } = require('fs');
-const { finished } = require('internal/streams/end-of-stream');
+const { DefaultDeserializer, DefaultSerializer } = require('v8');
 // TODO(aduh95): switch to internal/readline/interface when backporting to Node.js 16.x is no longer a concern.
 const { createInterface } = require('readline');
+const { deserializeError } = require('internal/error_serdes');
+const { Buffer } = require('buffer');
 const { FilesWatcher } = require('internal/watch_mode/files_watcher');
 const console = require('internal/console/global');
 const {
@@ -40,6 +43,7 @@ const { validateArray, validateBoolean, validateFunction } = require('internal/v
 const { getInspectPort, isUsingInspector, isInspectorMessage } = require('internal/util/inspector');
 const { isRegExp } = require('internal/util/types');
 const { kEmptyObject } = require('internal/util');
+const { kEmitMessage } = require('internal/test_runner/tests_stream');
 const { createTestTree } = require('internal/test_runner/harness');
 const {
  kAborted,
@@ -49,9 +53,6 @@ const {
  kTestTimeoutFailure,
  Test,
 } = require('internal/test_runner/test');
-const { TapParser } = require('internal/test_runner/tap_parser');
-const { YAMLToJs } = require('internal/test_runner/yaml_to_js');
-const { TokenKind } = require('internal/test_runner/tap_lexer');
 
 const {
  convertStringToRegExp,
@@ -153,92 +154,62 @@ function getRunArgs({ path, inspectPort, testNamePatterns }) {
  return argv;
 }
 
+const serializer = new DefaultSerializer();
+serializer.writeHeader();
+const v8Header = serializer.releaseBuffer();
+const v8HeaderAndSize = 4 + v8Header.length;
+
 class FileTest extends Test {
  #buffer = [];
+ #messageBuffer = [];
+ #messageBufferSize = 0;
  #reportedChildren = 0;
  failedSubtests = false;
  #skipReporting() {
  return this.#reportedChildren > 0 && (!this.error || this.error.failureType === kSubtestsFailed);
  }
- #checkNestedComment({ comment }) {
+ #checkNestedComment(comment) {
  const firstSpaceIndex = StringPrototypeIndexOf(comment, ' ');
  if (firstSpaceIndex === -1) return false;
  const secondSpaceIndex = StringPrototypeIndexOf(comment, ' ', firstSpaceIndex + 1);
  return secondSpaceIndex === -1 &&
  ArrayPrototypeIncludes(kDiagnosticsFilterArgs, StringPrototypeSlice(comment, 0, firstSpaceIndex));
  }
- #handleReportItem({ kind, node, comments, nesting = 0 }) {
- if (comments) {
- ArrayPrototypeForEach(comments, (comment) => this.reporter.diagnostic(nesting, this.name, comment));
- }
- switch (kind) {
- case TokenKind.TAP_VERSION:
- // TODO(manekinekko): handle TAP version coming from the parser.
- // this.reporter.version(node.version);
- break;
-
- case TokenKind.TAP_PLAN:
- if (nesting === 0 && this.#skipReporting()) {
- break;
- }
- this.reporter.plan(nesting, this.name, node.end - node.start + 1);
- break;
-
- case TokenKind.TAP_SUBTEST_POINT:
- this.reporter.start(nesting, this.name, node.name);
- break;
-
- case TokenKind.TAP_TEST_POINT: {
-
- const { todo, skip, pass } = node.status;
-
- let directive;
-
- if (skip) {
- directive = this.reporter.getSkip(node.reason || true);
- } else if (todo) {
- directive = this.reporter.getTodo(node.reason || true);
- } else {
- directive = kEmptyObject;
- }
-
- const diagnostics = YAMLToJs(node.diagnostics);
- const cancelled = kCanceledTests.has(diagnostics.error?.failureType);
- const testNumber = nesting === 0 ? (this.root.harness.counters.topLevel + 1) : node.id;
- const method = pass ? 'ok' : 'fail';
- this.reporter[method](nesting, this.name, testNumber, node.description, diagnostics, directive);
- countCompletedTest({
- name: node.description,
- finished: true,
- skipped: skip,
- isTodo: todo,
- passed: pass,
- cancelled,
- nesting,
- reportedType: diagnostics.type,
- }, this.root.harness);
- break;
-
+ #handleReportItem(item) {
+ const isTopLevel = item.data.nesting === 0;
+ if (isTopLevel) {
+ if (item.type === 'test:plan' && this.#skipReporting()) {
+ return;
  }
- case TokenKind.COMMENT:
- if (nesting === 0 && this.#checkNestedComment(node)) {
- // Ignore file top level diagnostics
- break;
- }
- this.reporter.diagnostic(nesting, this.name, node.comment);
- break;
-
- case TokenKind.UNKNOWN:
- this.reporter.diagnostic(nesting, this.name, node.value);
- break;
+ if (item.type === 'test:diagnostic' && this.#checkNestedComment(item.data.message)) {
+ return;
+ }
+ }
+ if (item.data.details?.error) {
+ item.data.details.error = deserializeError(item.data.details.error);
  }
+ if (item.type === 'test:pass' || item.type === 'test:fail') {
+ item.data.testNumber = isTopLevel ? (this.root.harness.counters.topLevel + 1) : item.data.testNumber;
+ countCompletedTest({
+ __proto__: null,
+ name: item.data.name,
+ finished: true,
+ skipped: item.data.skip !== undefined,
+ isTodo: item.data.todo !== undefined,
+ passed: item.type === 'test:pass',
+ cancelled: kCanceledTests.has(item.data.details?.error?.failureType),
+ nesting: item.data.nesting,
+ reportedType: item.data.details?.type,
+ }, this.root.harness);
+ }
+ this.reporter[kEmitMessage](item.type, item.data);
  }
- #accumulateReportItem({ kind, node, comments, nesting = 0 }) {
- if (kind !== TokenKind.TAP_TEST_POINT) {
+ #accumulateReportItem(item) {
+ if (item.type !== 'test:pass' && item.type !== 'test:fail') {
  return;
  }
  this.#reportedChildren++;
- if (nesting === 0 && !node.status.pass) {
+ if (item.data.nesting === 0 && item.type === 'test:fail') {
  this.failedSubtests = true;
  }
  }
@@ -248,14 +219,65 @@ class FileTest extends Test {
  this.#buffer = [];
  }
  }
- addToReport(ast) {
- this.#accumulateReportItem(ast);
+ addToReport(item) {
+ this.#accumulateReportItem(item);
  if (!this.isClearToSend()) {
- ArrayPrototypePush(this.#buffer, ast);
+ ArrayPrototypePush(this.#buffer, item);
  return;
  }
  this.#drainBuffer();
- this.#handleReportItem(ast);
+ this.#handleReportItem(item);
+ }
+ parseMessage(readData) {
+ if (readData.length === 0) return;
+
+ ArrayPrototypePush(this.#messageBuffer, readData);
+ this.#messageBufferSize += readData.length;
+
+ // Index 0 should always be present because we just pushed data into it.
+ let messageBufferHead = this.#messageBuffer[0];
+
+ while (messageBufferHead.length >= 4) {
+ const isSerializedMessage = messageBufferHead.length >= v8HeaderAndSize &&
+ v8Header.compare(messageBufferHead, 4, v8HeaderAndSize) === 0;
+ if (!isSerializedMessage) {
+ const message = Buffer.concat(this.#messageBuffer, this.#messageBufferSize);
+ this.#messageBufferSize = 0;
+ this.#messageBuffer = [];
+ this.addToReport({
+ __proto__: null,
+ type: 'test:diagnostic',
+ data: { __proto__: null, nesting: 0, file: this.name, message: String(message) },
+ });
+ return;
+ }
+
+ // We call `readUInt32BE` manually here, because this is faster than first converting
+ // it to a buffer and using `readUInt32BE` on that.
+ const fullMessageSize = (
+ messageBufferHead[0] << 24 |
+ messageBufferHead[1] << 16 |
+ messageBufferHead[2] << 8 |
+ messageBufferHead[3]
+ ) + 4;
+
+ if (this.#messageBufferSize < fullMessageSize) break;
+
+ const concatenatedBuffer = this.#messageBuffer.length === 1 ?
+ this.#messageBuffer[0] : Buffer.concat(this.#messageBuffer, this.#messageBufferSize);
+
+ const deserializer = new DefaultDeserializer(
+ TypedArrayPrototypeSubarray(concatenatedBuffer, 4, fullMessageSize),
+ );
+
+ messageBufferHead = TypedArrayPrototypeSubarray(concatenatedBuffer, fullMessageSize);
+ this.#messageBufferSize = messageBufferHead.length;
+ this.#messageBuffer = this.#messageBufferSize !== 0 ? [messageBufferHead] : [];
+
+ deserializer.readHeader();
+ const item = deserializer.readValue();
+ this.addToReport(item);
+ }
  }
  reportStarted() {}
  report() {
@@ -275,7 +297,7 @@ function runTestFile(path, root, inspectPort, filesWatcher, testNamePatterns) {
  const subtest = root.createSubtest(FileTest, path, async (t) => {
  const args = getRunArgs({ path, inspectPort, testNamePatterns });
  const stdio = ['pipe', 'pipe', 'pipe'];
- const env = { ...process.env, NODE_TEST_CONTEXT: 'child' };
+ const env = { ...process.env, NODE_TEST_CONTEXT: 'child-v8' };
  if (filesWatcher) {
  stdio.push('ipc');
  env.WATCH_REPORT_DEPENDENCIES = '1';
@@ -292,6 +314,10 @@ function runTestFile(path, root, inspectPort, filesWatcher, testNamePatterns) {
  err = error;
  });
 
+ child.stdout.on('data', (data) => {
+ subtest.parseMessage(data);
+ });
+
  const rl = createInterface({ input: child.stderr });
  rl.on('line', (line) => {
  if (isInspectorMessage(line)) {
@@ -303,26 +329,14 @@ function runTestFile(path, root, inspectPort, filesWatcher, testNamePatterns) {
  // surface stderr lines as TAP diagnostics to improve the DX. Inject
  // each line into the test output as an unknown token as if it came
  // from the TAP parser.
- const node = {
- kind: TokenKind.UNKNOWN,
- node: {
- value: line,
- },
- };
-
- subtest.addToReport(node);
- });
-
- const parser = new TapParser();
-
- child.stdout.pipe(parser).on('data', (ast) => {
- subtest.addToReport(ast);
+ subtest.addToReport({
+ __proto__: null,
+ type: 'test:diagnostic',
+ data: { __proto__: null, nesting: 0, file: path, message: line },
+ });
  });
 
- const { 0: { 0: code, 1: signal } } = await SafePromiseAll([
- once(child, 'exit', { signal: t.signal }),
- finished(parser, { signal: t.signal }),
- ]);
+ const { 0: code, 1: signal } = await once(child, 'exit', { signal: t.signal });
 
  runningProcesses.delete(path);
  runningSubtests.delete(path);