Deno support

[germanysources]

It would be great, when ava can run deno (https://deno.land/) modules after ESM-modules are fully implemented. When testing a deno-project we could use all features (watch-mode, hooks, concurrency, snapshots).
My idea was to use deno as new runner-process and node for the surrounding (reporting, snapshots ...).

[novemberborn]

It'd be interesting, yes. I can see a way to launch a deno instance as a child process, but how would we provide AVA's test() and assertion interface, and communicate with AVA?

How does this relate to ESM modules?

What are the differences between the two platforms in terms of the built-in API?

[germanysources]

how would we provide AVA's test() and assertion interface, and communicate with AVA?

The goal must be here, that all the code executed in the worker threads including the test-interface is Deno-executable, i think.

How does this relate to ESM modules?

Deno just supports ESM modules for now. Commonjs-modules are not supported.

What are the differences between the two platforms in terms of the built-in API?

Deno prodives a browser-compatibility API (fetch-calls, workers, websocket). There is a node-compatibility API (https://deno.land/std@0.95.0/node), which covers the node-API partly. The childProcess.fork doesn't seem to be part of it.

[novemberborn]

Sounds like it may be, just about, doable then. The challenge might be that AVA's internals are in no way organized enough to be runtime agnostic. In order for us to support this officially we need to be in a place where the implementation is reliable, so a change for Node.js doesn't break Deno compatibility and vice versa. This will likely take a lot of effort.

[clshortfuse]

Poor man's test wrapper:

/** @typedef {import('ava').TestFn} AvaTestFn */

// @ts-ignore Custom cast
export default await (async () => {
  if ('Deno' in globalThis) {
    const denoAsserts = await import('https://deno.land/std@0.178.0/testing/asserts.ts');
    /**
     *
     * @param {string} title
     * @param {import('ava').ImplementationFn<any, any>} implementation
     */
    // eslint-disable-next-line no-inner-declarations
    function test(title, implementation) {
      Deno.test(title, async (t) => {
        /** @type {import('ava').ExecutionContext} T */
        const wrapper = {
          assert: denoAsserts.assertStrictEquals,
          deepEqual: denoAsserts.assertEquals,
          // like
          fail: denoAsserts.fail,
          false(actual, message) {
            denoAsserts.assertStrictEquals(actual, false, message);
            return true;
          },
          falsy(actual, message) {
            denoAsserts.assertStrictEquals(!actual, true, message);
            return true;
          },
          is: denoAsserts.assertStrictEquals,
          not(actual, expected) {
            denoAsserts.assertStrictEquals(!Object.is(actual, expected), true);
          },
          notDeepEqual: denoAsserts.assertNotEquals,
          notRegex: denoAsserts.notMatch,
          notThrows(fn, message) {
            try {
              fn();
            } catch {
              this.fail(message);
            }
          },
          async notThrowsAsync(fn, message) {
            try {
              await fn();
            } catch {
              this.fail(message);
            }
          },
          pass(message) {
            denoAsserts.assert(true, message);
          },
          regex: denoAsserts.assertMatch,
          // snapshot
          throws: denoAsserts.assertThrows,
          async throwsAsync(fn, expectations, message) {
            try {
              await fn();
              this.fail(message);
            } catch (e) {
              this.throws(() => { throw e; }, expectations, message);
            }
          },
          true(actual, message) {
            denoAsserts.assertStrictEquals(actual, true, message);
          },
          truthy(actual, message) {
            denoAsserts.assert(actual, message);
          },
          log: console.debug,
        };
        await implementation(wrapper);
      });
    }
    return test;
  }
  if ('window' in globalThis) {
    // TODO: Tap into browser-based tester
    return null;
  }
  // Node
  const ava = await import('ava');
  return ava.default;
})();

Instead of import test from 'ava, I have each file call import test from './tester.js'; ava doesn't seem to mind since it will will resolve the expected tester eventually because of the IIFE top-level await. If somebody wants to build a better wrapper, this should help get started. I don't know how to ensure a test is ran though. I'd imagine I'd wrap each function and see if any of them were poked.