Add digest streams suite; migrate existing DigestStream tests

Author: jasnell

src/tests/streams/digest/BUILD.bazel

@@ -0,0 +1,18 @@
+load("//:build/wd_test.bzl", "wd_test")
+
+# The digest streams suite runs the same test modules under two configs:
+# digest-cpp against the C++ implementation, digest-ts against the
+# TypeScript implementation.
+
+digest_suite_srcs = glob(["*.js"]) + ["digest-modules.capnp"]
+
+wd_test(
+    src = "digest-cpp.wd-test",
+    data = digest_suite_srcs,
+)
+
+wd_test(
+    src = "digest-ts.wd-test",
+    args = ["--experimental"],
+    data = digest_suite_srcs,
+)

src/tests/streams/digest/api-surface.js

@@ -0,0 +1,81 @@
+// Copyright (c) 2026 Cloudflare, Inc.
+// Licensed under the Apache 2.0 license found in the LICENSE file or at:
+//     https://opensource.org/licenses/Apache-2.0
+
+// Object shape of crypto.DigestStream: a subclass of the global
+// WritableStream in both implementations, with brand-checked accessors.
+// Divergence: TypeScript uses a genuine `class extends`, so the
+// CONSTRUCTOR's prototype is the WritableStream function itself; the C++
+// jsg inheritance wires the instance prototype chain but not the static
+// constructor chain.
+
+import { strictEqual, notStrictEqual, ok, throws } from 'node:assert';
+import { usingTsImpl } from 'which-impl';
+
+export const isRealWritableStreamSubclass = {
+  test() {
+    const stream = new crypto.DigestStream('md5');
+    ok(stream instanceof WritableStream);
+    strictEqual(
+      Object.getPrototypeOf(crypto.DigestStream.prototype),
+      WritableStream.prototype
+    );
+    if (usingTsImpl) {
+      strictEqual(Object.getPrototypeOf(crypto.DigestStream), WritableStream);
+    } else {
+      notStrictEqual(
+        Object.getPrototypeOf(crypto.DigestStream),
+        WritableStream
+      );
+    }
+    // Inherited members must be reachable, not shadowed.
+    strictEqual(typeof stream.getWriter, 'function');
+    strictEqual(stream.locked, false);
+  },
+};
+
+export const toStringTagBranding = {
+  test() {
+    strictEqual(
+      Object.prototype.toString.call(new crypto.DigestStream('md5')),
+      '[object DigestStream]'
+    );
+  },
+};
+
+export const accessorsAreBrandChecked = {
+  test() {
+    // Brand checks, not instanceof checks: a plain object with the right
+    // prototype is still rejected.
+    const fake = Object.create(crypto.DigestStream.prototype);
+    throws(() => fake.digest, { name: 'TypeError' });
+    throws(() => fake.bytesWritten, { name: 'TypeError' });
+    throws(() => fake[Symbol.dispose](), { name: 'TypeError' });
+
+    const desc = Object.getOwnPropertyDescriptor(
+      crypto.DigestStream.prototype,
+      'digest'
+    );
+    strictEqual(typeof desc.get, 'function');
+    strictEqual(desc.set, undefined);
+  },
+};
+
+export const constructorIsSubclassable = {
+  async test() {
+    class MyDigest extends crypto.DigestStream {
+      constructor() {
+        super('md5');
+        this.tag = 'mine';
+      }
+    }
+    const stream = new MyDigest();
+    strictEqual(stream.tag, 'mine');
+    ok(stream instanceof crypto.DigestStream);
+    ok(stream instanceof WritableStream);
+    const writer = stream.getWriter();
+    await writer.write('hello');
+    await writer.close();
+    strictEqual((await stream.digest).byteLength, 16);
+  },
+};

src/tests/streams/digest/buffer-lifecycle.js

@@ -0,0 +1,63 @@
+// Copyright (c) 2026 Cloudflare, Inc.
+// Licensed under the Apache 2.0 license found in the LICENSE file or at:
+//     https://opensource.org/licenses/Apache-2.0
+
+// Input buffer lifecycle: the hash update runs inside write(), so the
+// chunk's bytes are consumed before the write settles — mutation after the
+// write cannot change the digest, and the chunk is never retained.
+
+import { deepStrictEqual } from 'node:assert';
+import { digestOf } from 'digest-vectors';
+
+export const mutationAfterWriteIsInvisible = {
+  async test() {
+    const buf = new Uint8Array([1, 2, 3, 4]);
+    const stream = new crypto.DigestStream('crc32');
+    const writer = stream.getWriter();
+    await writer.write(buf);
+    buf.fill(0xff);
+    await writer.close();
+    deepStrictEqual(
+      new Uint8Array(await stream.digest),
+      await digestOf('crc32', new Uint8Array([1, 2, 3, 4]))
+    );
+  },
+};
+
+export const detachAfterWriteIsInvisible = {
+  async test() {
+    const buf = new Uint8Array([1, 2, 3, 4]);
+    const stream = new crypto.DigestStream('crc32');
+    const writer = stream.getWriter();
+    await writer.write(buf);
+    buf.buffer.transfer();
+    await writer.close();
+    deepStrictEqual(
+      new Uint8Array(await stream.digest),
+      await digestOf('crc32', new Uint8Array([1, 2, 3, 4]))
+    );
+  },
+};
+
+export const lyingMetadataNeverConsulted = {
+  async test() {
+    // Buffer metadata comes from internal slots; shadowing own getters are
+    // never invoked.
+    const view = new TextEncoder().encode('real');
+    for (const key of ['byteLength', 'byteOffset', 'buffer']) {
+      Object.defineProperty(view, key, {
+        get() {
+          throw new Error(`${key} getter must not be called`);
+        },
+      });
+    }
+    const stream = new crypto.DigestStream('md5');
+    const writer = stream.getWriter();
+    await writer.write(view);
+    await writer.close();
+    deepStrictEqual(
+      new Uint8Array(await stream.digest),
+      await digestOf('md5', 'real')
+    );
+  },
+};

src/tests/streams/digest/chunk-types.js

@@ -0,0 +1,65 @@
+// Copyright (c) 2026 Cloudflare, Inc.
+// Licensed under the Apache 2.0 license found in the LICENSE file or at:
+//     https://opensource.org/licenses/Apache-2.0
+
+// Chunk validation: ArrayBuffer, any ArrayBufferView (offsets honored),
+// and strings are accepted; everything else — including a bare
+// SharedArrayBuffer — rejects with the same TypeError in both
+// implementations. Views onto SharedArrayBuffers are accepted.
+
+import { strictEqual, deepStrictEqual, rejects } from 'node:assert';
+
+const badChunkMsg =
+  'DigestStream is a byte stream but received an object ' +
+  'of non-ArrayBuffer/ArrayBufferView/string type on its writable side.';
+
+export const rejectsNonByteChunks = {
+  async test() {
+    for (const bad of [123, null, undefined, {}, [], true, Symbol.iterator]) {
+      const stream = new crypto.DigestStream('md5');
+      const writer = stream.getWriter();
+      await rejects(writer.write(bad), { message: badChunkMsg });
+    }
+  },
+};
+
+export const sharedArrayBufferHandling = {
+  async test() {
+    {
+      const stream = new crypto.DigestStream('md5');
+      const writer = stream.getWriter();
+      await rejects(writer.write(new SharedArrayBuffer(8)), {
+        message: badChunkMsg,
+      });
+    }
+    {
+      const stream = new crypto.DigestStream('md5');
+      const writer = stream.getWriter();
+      await writer.write(new Uint8Array(new SharedArrayBuffer(4)));
+      await writer.close();
+      await stream.digest;
+      strictEqual(stream.bytesWritten, 4n);
+    }
+  },
+};
+
+export const dataViewRespectsOffset = {
+  async test() {
+    const backing = new Uint8Array([9, 9, 1, 2, 3, 4, 9, 9]);
+    const stream = new crypto.DigestStream('crc32');
+    const writer = stream.getWriter();
+    await writer.write(new DataView(backing.buffer, 2, 4));
+    await writer.close();
+
+    const reference = new crypto.DigestStream('crc32');
+    const refWriter = reference.getWriter();
+    await refWriter.write(new Uint8Array([1, 2, 3, 4]));
+    await refWriter.close();
+
+    deepStrictEqual(
+      new Uint8Array(await stream.digest),
+      new Uint8Array(await reference.digest)
+    );
+    strictEqual(stream.bytesWritten, 4n);
+  },
+};

src/tests/streams/digest/construction.js

@@ -0,0 +1,138 @@
+// Copyright (c) 2026 Cloudflare, Inc.
+// Licensed under the Apache 2.0 license found in the LICENSE file or at:
+//     https://opensource.org/licenses/Apache-2.0
+
+// Constructor arguments: algorithm names (string or {name} object, matched
+// case-insensitively over the whole name) and the options bag.
+
+import { strictEqual, deepStrictEqual, throws } from 'node:assert';
+import { digestOf } from 'digest-vectors';
+
+export const algorithmNamesAreCaseInsensitive = {
+  async test() {
+    const variants = {
+      crc32: ['crc32', 'CRC32', 'Crc32', 'cRc32'],
+      crc32c: ['crc32c', 'CRC32C', 'Crc32c', 'crc32C', 'cRc32C'],
+      crc64nvme: ['crc64nvme', 'CRC64NVME', 'Crc64Nvme', 'crc64NVME'],
+      md5: ['md5', 'MD5', 'Md5'],
+      'sha-256': ['sha-256', 'SHA-256', 'Sha-256'],
+    };
+    for (const [canonical, names] of Object.entries(variants)) {
+      const expected = await digestOf(canonical, 'hello');
+      for (const name of names) {
+        deepStrictEqual(
+          await digestOf(name, 'hello'),
+          expected,
+          `${name} should select the same algorithm as ${canonical}`
+        );
+      }
+    }
+  },
+};
+
+export const crcNamesStillRequireAnExactSpelling = {
+  test() {
+    // Case-insensitivity must not turn a nonsense name into a match: the
+    // comparison is over the whole name.
+    for (const name of [
+      'crc',
+      'crc3',
+      'crc322',
+      'crc32d',
+      ' crc32',
+      'crc32 ',
+      'crc-32',
+      'crc64',
+      'crc64nvm',
+      'crc64nvmex',
+      'nvme',
+    ]) {
+      throws(
+        () => new crypto.DigestStream(name),
+        { name: 'NotSupportedError' },
+        `${JSON.stringify(name)} should not be a valid algorithm`
+      );
+    }
+  },
+};
+
+export const unknownAlgorithmThrowsSynchronously = {
+  test() {
+    throws(() => new crypto.DigestStream('foo'));
+    throws(() => new crypto.DigestStream(''));
+    // A missing name coerces to "undefined" and then fails the lookup.
+    throws(() => new crypto.DigestStream({}));
+    throws(() => new crypto.DigestStream(null));
+    throws(() => new crypto.DigestStream(undefined));
+  },
+};
+
+export const algorithmAsObject = {
+  async test() {
+    const check = new Uint8Array([
+      93, 65, 64, 42, 188, 75, 42, 118, 185, 113, 157, 145, 16, 23, 197, 146,
+    ]);
+    deepStrictEqual(await digestOf({ name: 'md5' }, 'hello'), check);
+  },
+};
+
+export const allAlgorithms = {
+  async test() {
+    const sizes = {
+      md5: 16,
+      'SHA-1': 20,
+      'SHA-256': 32,
+      'SHA-384': 48,
+      'SHA-512': 64,
+      crc32: 4,
+      crc32c: 4,
+      crc64nvme: 8,
+    };
+    for (const [name, size] of Object.entries(sizes)) {
+      strictEqual(
+        (await digestOf(name, 'abc')).byteLength,
+        size,
+        `${name} digest size`
+      );
+    }
+  },
+};
+
+// The option bag follows Web IDL dictionary rules: undefined and null are an
+// empty bag, any object is read for its fields, and a primitive is a
+// TypeError. Arrays and functions count as objects.
+export const optionBagAcceptsObjectsAndRejectsPrimitives = {
+  test() {
+    for (const options of [undefined, null, {}, [], () => {}, new Date()]) {
+      const stream = new crypto.DigestStream('md5', options);
+      stream[Symbol.dispose]();
+    }
+    for (const options of [0, 1, '', 'x', true, false, 1n, Symbol.iterator]) {
+      throws(
+        () => new crypto.DigestStream('md5', options),
+        {
+          name: 'TypeError',
+          message:
+            "Failed to construct 'DigestStream': constructor parameter 2 is " +
+            "not of type 'Options'.",
+        },
+        `should reject primitive option bag: ${String(options)}`
+      );
+    }
+  },
+};
+
+// Argument type-checking happens before the algorithm name is looked up.
+export const argumentTypesAreCheckedBeforeAlgorithmLookup = {
+  test() {
+    throws(() => new crypto.DigestStream('foo', 0), {
+      name: 'TypeError',
+      message:
+        "Failed to construct 'DigestStream': constructor parameter 2 is not " +
+        "of type 'Options'.",
+    });
+    throws(() => new crypto.DigestStream('foo', { toWellFormed: true }), {
+      name: 'NotSupportedError',
+    });
+  },
+};