stream/duplex: add tests and docs for duplex.fromWeb and duplex.toWeb

Author: ErickWendel

doc/api/stream.md

@@ -2874,6 +2874,38 @@ added: v17.0.0
   * `signal` {AbortSignal}
 * Returns: {stream.Duplex}
 
+```mjs
+import { Duplex } from 'stream';
+import {
+  ReadableStream,
+  WritableStream
+} from 'stream/web';
+
+const readable = new ReadableStream({
+  start(controller) {
+    controller.enqueue('world');
+  },
+});
+
+const writable = new WritableStream({
+  write(chunk) {
+    console.log('writable', chunk);
+  }
+});
+
+const pair = {
+  readable,
+  writable
+};
+const duplex = Duplex.fromWeb(pair, { encoding: 'utf8', objectMode: true });
+
+duplex.write('hello');
+
+for await (const chunk of duplex) {
+  console.log('readable', chunk);
+}
+```
+
 ### `stream.Duplex.toWeb(streamDuplex)`
 
 <!-- YAML
@@ -2887,6 +2919,28 @@ added: v17.0.0
   * `readable` {ReadableStream}
   * `writable` {WritableStream}
 
+```mjs
+import { Duplex } from 'stream';
+
+const duplex = Duplex({
+  objectMode: true,
+  read() {
+    this.push('world');
+    this.push(null);
+  },
+  write: (chunk, encoding, callback) => {
+    console.log('writable', chunk);
+    callback();
+  }
+});
+
+const { readable, writable } = Duplex.toWeb(duplex);
+writable.getWriter().write('hello');
+
+const { value } = await readable.getReader().read();
+console.log('readable', value);
+```
+
 ### `stream.addAbortSignal(signal, stream)`
 
 <!-- YAML

test/parallel/test-stream-duplex.js

@@ -20,9 +20,10 @@
 // USE OR OTHER DEALINGS IN THE SOFTWARE.
 'use strict';
 
-require('../common');
+const common = require('../common');
 const assert = require('assert');
 const Duplex = require('stream').Duplex;
+const { ReadableStream, WritableStream } = require('stream/web');
 
 const stream = new Duplex({ objectMode: true });
 
@@ -53,3 +54,80 @@ process.on('exit', () => {
   assert.strictEqual(read.val, 1);
   assert.strictEqual(written.val, 2);
 });
+
+// Duplex.fromWeb
+{
+  const dataToRead = Buffer.from('hello');
+  const dataToWrite = Buffer.from('world');
+
+  const stream = new ReadableStream({
+    start(controller) {
+      controller.enqueue(dataToRead);
+    },
+  });
+
+  const writable = new WritableStream({
+    write: common.mustCall((chunk) => {
+      assert.strictEqual(chunk, dataToWrite);
+    })
+  });
+
+  const pair = { readable: stream, writable: writable };
+  const duplex = Duplex.fromWeb(pair);
+
+  duplex.write(dataToWrite);
+  duplex.once('data', common.mustCall((chunk) => {
+    assert.strictEqual(chunk, dataToRead);
+  }));
+}
+
+// Duplex.fromWeb - using utf8 and objectMode
+{
+  const dataToRead = 'hello';
+  const dataToWrite = 'world';
+
+  const stream = new ReadableStream({
+    start(controller) {
+      controller.enqueue(dataToRead);
+    },
+  });
+
+  const writable = new WritableStream({
+    write: common.mustCall((chunk) => {
+      assert.strictEqual(chunk, dataToWrite);
+    })
+  });
+
+  const pair = {
+    readable: stream,
+    writable: writable
+  };
+  const duplex = Duplex.fromWeb(pair, { encoding: 'utf8', objectMode: true });
+
+  duplex.write(dataToWrite);
+  duplex.once('data', common.mustCall((chunk) => {
+    assert.strictEqual(chunk, dataToRead);
+  }));
+}
+// Duplex.toWeb
+{
+  const dataToRead = Buffer.from('hello');
+  const dataToWrite = Buffer.from('world');
+
+  const duplex = Duplex({
+    read() {
+      this.push(dataToRead)
+      this.push(null)
+    },
+    write: common.mustCall((chunk) => {
+      assert.strictEqual(chunk, dataToWrite)
+    })
+  })
+
+  const webDuplex = Duplex.toWeb(duplex);
+  webDuplex.writable.getWriter().write(dataToWrite);
+
+  webDuplex.readable.getReader().read().then(common.mustCall((result) => {
+    assert.deepStrictEqual(Buffer.from(result.value), dataToRead);
+  }));
+}