test: enable multi-global WPTs

Signed-off-by: Filip Skokan <panva.ip@gmail.com>
Co-authored-by: Aviv Keller <me@aviv.sh>
Signed-off-by: Aviv Keller <me@aviv.sh>

Author: panva

test/common/wpt.js

@@ -8,11 +8,11 @@ const path = require('path');
 const events = require('events');
 const os = require('os');
 const { inspect } = require('util');
+const { pathToFileURL } = require('url');
 const { Worker } = require('worker_threads');
 const { fork } = require('child_process');
 
 const workerPath = path.join(__dirname, 'wpt/worker.js');
-const kRunWorkerGlobals = false;
 
 function getBrowserProperties() {
   const { node: version } = process.versions; // e.g. 18.13.0, 20.0.0-nightly202302078e6e215481
@@ -190,6 +190,24 @@ class ResourceLoader {
       fixtures.path('wpt', base, url);
   }
 
+  /**
+   * Map a URL that a test would have fetched from the WPT server (an
+   * absolute path, or a path relative to the test file) to a file: URL
+   * into the fixtures directory. URLs that already have a scheme (data:,
+   * blob:, http:, ...) are returned unchanged.
+   * @param {string} from the path of the file loading this resource,
+   *   relative to the WPT folder.
+   * @param {string|URL} url the url of the resource being loaded.
+   * @returns {string}
+   */
+  mapServerURL(from, url) {
+    url = `${url}`;
+    if (/^[a-zA-Z][a-zA-Z0-9+.-]*:|^\/\//.test(url)) {
+      return url;
+    }
+    return pathToFileURL(this.toRealFilePath(from, url)).href;
+  }
+
   /**
    * Load a resource in test/fixtures/wpt specified with a URL
    * @param {string} from the path of the file loading this resource,
@@ -805,7 +823,11 @@ class WPTRunner {
     this.resource = new ResourceLoader(path);
     this.concurrency = concurrency;
 
-    this.flags = [];
+    // Since we need to prepare the Web Worker APIs
+    // in the harness that runs on all WPT workers,
+    // we enable the API globally. This has no practical
+    // effect on the non-web-worker tests, however.
+    this.flags = ['--experimental-web-worker'];
     this.globalThisInitScripts = [];
     this.initScript = null;
 
@@ -832,7 +854,7 @@ class WPTRunner {
    * @param {string[]} flags
    */
   setFlags(flags) {
-    this.flags = flags;
+    this.flags = this.flags.concat(flags);
   }
 
   /**
@@ -919,22 +941,33 @@ class WPTRunner {
       const absolutePath = spec.getAbsolutePath();
       const relativePath = spec.getRelativePath();
       const harnessPath = fixtures.path('wpt', 'resources', 'testharness.js');
-      // Scripts specified with the `// META: script=` header
-      const scriptsToRun = meta.script?.map((script) => {
+      // *.worker.js tests are dedicated worker tests by definition. Each
+      // dedicated worker variant generated from a multi-global (*.any.js)
+      // test also runs inside an actual Web Worker. Refs:
+      // https://web-platform-tests.org/writing-tests/testharness.html#multi-global-tests
+      const isAnyTest = spec.isAnyTest();
+      const isWebWorkerTest = spec.isWebWorkerTest();
+
+      // Scripts specified with the `// META: script=` header. For tests
+      // that run inside a Web Worker they are imported by the worker
+      // instead.
+      const scriptsToRun = isWebWorkerTest ? [] : meta.script?.map((script) => {
         const obj = {
           filename: this.resource.toRealFilePath(relativePath, script),
           code: this.resource.read(relativePath, script),
         };
         this.scriptsModifier?.(obj);
         return obj;
       }) ?? [];
-      // The actual test
-      const obj = {
-        code: content,
-        filename: absolutePath,
-      };
-      this.scriptsModifier?.(obj);
-      scriptsToRun.push(obj);
+      if (!isWebWorkerTest) {
+        // The actual test
+        const obj = {
+          code: content,
+          filename: absolutePath,
+        };
+        this.scriptsModifier?.(obj);
+        scriptsToRun.push(obj);
+      }
 
       run(async () => {
         this.inProgress.add(spec);
@@ -950,6 +983,17 @@ class WPTRunner {
             filename: harnessPath,
           },
           scriptsToRun,
+          // Set when the test runs inside an actual Web Worker.
+          webWorker: isWebWorkerTest ? {
+            path: absolutePath,
+            isAnyTest,
+            initScript: this.initScript,
+            variant: spec.variant,
+            scripts: meta.script?.map(
+              (script) => this.resource.toRealFilePath(relativePath, script),
+            ) ?? [],
+            skippedTests: spec.skippedTests,
+          } : undefined,
           needsGc: !!meta.script?.find((script) => script === '/common/gc.js'),
           skippedTests: spec.skippedTests,
         }, {
@@ -1222,10 +1266,6 @@ class WPTRunner {
     this.skippedSpecCount = 0;
     const arg = process.argv[2];
     for (const spec of this.specs) {
-      if (!kRunWorkerGlobals && spec.isWebWorkerTest()) {
-        continue;
-      }
-
       if (arg) {
         if (spec.isSelectedBy(arg)) {
           queue.push(spec);
@@ -1248,13 +1288,11 @@ class WPTRunner {
     }
 
     // If the tests are run as `node test/wpt/test-something.js subset.any.js`,
-    // only `subset.any.js` (all enabled variants and globals) will be run by
-    // the runner.
+    // only `subset.any.js` (all variants and globals) will be run by the runner.
     // If the tests are run as `node test/wpt/test-something.js 'subset.any.js?1-10'`,
     // only the `?1-10` variant of `subset.any.js` will be run by the runner.
     // A test path as printed with the results, e.g.
-    // `'dir/subset.any.worker.html?1-10'`, runs exactly that one when its
-    // global is enabled.
+    // `'dir/subset.any.worker.html?1-10'`, runs exactly that one.
     if (arg && queue.length === 0) {
       throw new Error(`${arg} not found!`);
     }

test/common/wpt/webworker.js

@@ -0,0 +1,129 @@
+'use strict';
+
+// Runs a WPT test file inside a Web Worker
+// Refs: https://web-platform-tests.org/writing-tests/testharness.html
+
+const { pathToFileURL } = require('url');
+const {
+  runInThisContext,
+  constants: { USE_MAIN_CONTEXT_DEFAULT_LOADER },
+} = require('vm');
+
+globalThis.onmessage = ({ data }) => {
+  // Let the test install its own handler.
+  globalThis.onmessage = null;
+
+  const { ResourceLoader } = require(data.wptRunner);
+  const resource = new ResourceLoader(data.wptPath);
+
+  globalThis.fetch = function fetch(file) {
+    return resource.readAsFetch(data.testRelativePath, file);
+  };
+
+  // Pretend the worker was served from the URL the WPT server would have
+  // used
+  const fakePath = (data.isAnyTest ?
+    data.testRelativePath.replace(/\.any\.js$/, '.any.worker.js') :
+    data.testRelativePath).replace(/\\/g, '/');
+  const fakeURL = new URL(`/${fakePath}${data.variant}`, 'http://wpt');
+  // eslint-disable-next-line no-undef
+  const fakeLocation = { __proto__: WorkerLocation.prototype };
+  for (const key of ['href', 'origin', 'protocol', 'host', 'hostname',
+                     'port', 'pathname', 'search', 'hash']) {
+    Object.defineProperty(fakeLocation, key, {
+      value: fakeURL[key],
+      enumerable: true,
+    });
+  }
+  Object.defineProperty(fakeLocation, 'toString', {
+    value: function toString() { return fakeURL.href; },
+    enumerable: true,
+  });
+  Object.defineProperty(globalThis, 'location', {
+    value: fakeLocation,
+    enumerable: true,
+    configurable: true,
+  });
+
+  const testharnessPath =
+    pathToFileURL(resource.toRealFilePath(data.testRelativePath,
+                                          '/resources/testharness.js')).href;
+
+  // If there are skip patterns, wrap the test functions to prevent
+  // execution of matching tests. This must happen after testharness.js is
+  // loaded but before the test scripts run.
+  function applySkips() {
+    if (!data.skippedTests?.length) {
+      return;
+    }
+    function isSkipped(name) {
+      for (const matcher of data.skippedTests) {
+        if (typeof matcher === 'string') {
+          if (name === matcher) return true;
+        } else if (matcher.test(name)) {
+          return true;
+        }
+      }
+      return false;
+    }
+    for (const fn of ['test', 'async_test', 'promise_test']) {
+      const original = globalThis[fn];
+      globalThis[fn] = function(func, name, ...rest) {
+        if (typeof name === 'string' && isSkipped(name)) {
+          // eslint-disable-next-line no-undef
+          postMessage({ type: 'skip', name });
+          return;
+        }
+        return original.call(this, func, name, ...rest);
+      };
+    }
+  }
+
+  // Tests fetch scripts and nested worker scripts from the WPT server; map
+  // those URLs into the fixtures directory.
+  const realImportScripts = globalThis.importScripts;
+  globalThis.importScripts = function importScripts(...urls) {
+    const mapped = urls.map(
+      (url) => resource.mapServerURL(data.testRelativePath, url));
+    const result = realImportScripts.apply(this, mapped);
+    if (mapped.includes(testharnessPath)) {
+      applySkips();
+    }
+    return result;
+  };
+  const RealWorker = globalThis.Worker;
+  globalThis.Worker = class Worker extends RealWorker {
+    constructor(url, options) {
+      super(resource.mapServerURL(data.testRelativePath, url), options);
+    }
+  };
+
+  if (data.isAnyTest) {
+    // Emulate the generated .any.worker.js wrapper script.
+    // Refs: https://github.com/web-platform-tests/wpt/blob/master/tools/serve/serve.py
+    globalThis.GLOBAL = {
+      isWindow() { return false; },
+      isWorker() { return true; },
+      isShadowRealm() { return false; },
+    };
+  }
+
+  if (data.initScript) {
+    runInThisContext(data.initScript, {
+      importModuleDynamically: USE_MAIN_CONTEXT_DEFAULT_LOADER,
+    });
+  }
+
+  if (data.isAnyTest) {
+    globalThis.importScripts('/resources/testharness.js');
+    for (const script of data.scripts) {
+      globalThis.importScripts(pathToFileURL(script).href);
+    }
+    globalThis.importScripts(pathToFileURL(data.path).href);
+    // eslint-disable-next-line no-undef
+    done();
+  } else {
+    // *.worker.js tests import testharness.js and call done() themselves.
+    globalThis.importScripts(pathToFileURL(data.path).href);
+  }
+};

test/common/wpt/worker.js

@@ -1,5 +1,7 @@
 'use strict';
 
+const path = require('path');
+const { pathToFileURL } = require('url');
 const {
   runInNewContext,
   runInThisContext,
@@ -38,6 +40,15 @@ function run(workerData) {
   const { ResourceLoader } = require(workerData.wptRunner);
   const resource = new ResourceLoader(workerData.wptPath);
 
+  // Tests create workers with URLs the WPT server would have served them
+  // from; map them into the fixtures directory.
+  const RealWorker = globalThis.Worker;
+  globalThis.Worker = class Worker extends RealWorker {
+    constructor(url, options) {
+      super(resource.mapServerURL(workerData.testRelativePath, url), options);
+    }
+  };
+
   if (workerData.needsGc) {
     // See https://github.com/nodejs/node/issues/16595#issuecomment-340288680
     setFlagsFromString('--expose-gc');
@@ -131,4 +142,44 @@ function run(workerData) {
       importModuleDynamically: USE_MAIN_CONTEXT_DEFAULT_LOADER,
     });
   }
+
+  if (workerData.webWorker) {
+    const worker = new RealWorker(
+      pathToFileURL(path.join(__dirname, 'webworker.js')));
+    worker.postMessage({
+      wptRunner: workerData.wptRunner,
+      wptPath: workerData.wptPath,
+      testRelativePath: workerData.testRelativePath,
+      ...workerData.webWorker,
+    });
+
+    let completed = false;
+    worker.addEventListener('message', (event) => {
+      if (event.data?.type === 'complete') {
+        completed = true;
+      }
+      // Skipped subtests never register with the testharness inside the
+      // worker; the runner is notified about them directly.
+      if (event.data?.type === 'skip') {
+        send({ type: 'skip', name: event.data.name });
+      }
+    });
+    worker.addEventListener('error', (event) => {
+      if (completed) {
+        return;
+      }
+      clearTimeout(timeout);
+      send({
+        type: 'completion',
+        status: {
+          status: 1,
+          message: event.message,
+          stack: event.error?.stack,
+        },
+      });
+    });
+
+    // eslint-disable-next-line no-undef
+    fetch_tests_from_worker(worker);
+  }
 }

test/fixtures/web-worker/wpt-error-after-result.js

@@ -0,0 +1,12 @@
+'use strict';
+
+// Throw only once a result has been reported, so the harness has to surface
+// the error rather than treat the test file as already done.
+add_result_callback(() => {
+  setTimeout(() => {
+    throw new Error('probe error after first result');
+  }, 0);
+});
+
+test(() => {}, 'reported before error');
+async_test(() => {}, 'waiting for error');

test/parallel/test-common-wpt-backends.js

@@ -14,7 +14,7 @@ const { backends } = require('../common/wpt');
 
 const harnessPath = fixtures.path('wpt', 'resources', 'testharness.js');
 const specPath = fixtures.path('wpt-backends-spec.js');
-const execArgv = [];
+const execArgv = ['--experimental-web-worker'];
 
 function payload(throws) {
   return {