test: refine mutable Web Stream adapter coverage

Remove overlapping override coverage. Verify object-mode writes settle
independently of native callbacks. Exercise the Writable.toWeb(Duplex)
path and keep native HTTP validation coverage.

Assisted-by: Codex
Signed-off-by: seungwoo <zoozoo1302@gmail.com>

Author: seungwoo505

test/parallel/test-webstreams-adapters-writable-buffer-sources.js

@@ -119,39 +119,6 @@ suite('underlying Writable', () => {
       assert.deepStrictEqual(consumed, Buffer.from([1, 2, 3, 4]));
     });
 
-    test('copies mutable chunks when write() is overridden', async () => {
-      let consumed;
-      let received;
-      let notifyConsumed;
-      const consumedPromise = new Promise((resolve) => {
-        notifyConsumed = resolve;
-      });
-      const writable = new Writable({
-        write(chunk, encoding, callback) {
-          callback();
-        },
-      });
-      writable.on('error', common.mustNotCall());
-      const writer = Writable.toWeb(writable).getWriter();
-      writable.write = common.mustCall((chunk) => {
-        received = chunk;
-        setImmediate(() => {
-          consumed = Buffer.from(chunk);
-          notifyConsumed();
-        });
-        return true;
-      });
-      const input = new Uint8Array([1, 2, 3, 4]);
-
-      await writer.write(input);
-      input.fill(9);
-      await consumedPromise;
-      await writer.close();
-
-      assert.notStrictEqual(received.buffer, input.buffer);
-      assert.deepStrictEqual(consumed, Buffer.from([1, 2, 3, 4]));
-    });
-
     test('does not trust a patched Writable.prototype.write', async () => {
       const originalWrite = Writable.prototype.write;
       let consumed;
@@ -302,24 +269,31 @@ suite('underlying Writable', () => {
     for (const ctor of ctors) {
       test(`passes through ${ctor.name} chunks`, async () => {
         const buffer = new ctor(4);
+        let finishWrite;
         const writable = new Writable({
           objectMode: true,
           write: common.mustCall((chunk, encoding, callback) => {
             assert(chunk instanceof ctor);
             assert.strictEqual(chunk, buffer);
-            callback();
+            finishWrite = callback;
           }),
         });
         writable.on('error', common.mustNotCall());
         const writer = Writable.toWeb(writable).getWriter();
-        await writer.write(buffer);
+        const writePromise = writer.write(buffer);
+        try {
+          await completesWithin(writePromise);
+        } finally {
+          finishWrite();
+        }
+        await writer.close();
       });
     }
   });
 });
 
 suite('underlying ServerResponse', () => {
-  test('rejects invalid view types before cloning', async () => {
+  test('rejects invalid view types', async () => {
     const response = createServerResponse();
     const writer = Writable.toWeb(response).getWriter();
 
@@ -411,7 +385,8 @@ suite('underlying Duplex', () => {
              },
            });
            duplex.on('error', common.mustNotCall());
-           const writer = Duplex.toWeb(duplex).writable.getWriter();
+           const writer = Writable.toWeb(duplex).getWriter();
+           duplex.resume();
            const input = new Uint8Array([1, 2, 3, 4]);
 
            await writer.write(input);
@@ -431,20 +406,27 @@ suite('underlying Duplex', () => {
     for (const ctor of ctors) {
       test(`passes through ${ctor.name} chunks`, async () => {
         const buffer = new ctor(4);
+        let finishWrite;
         const duplex = new Duplex({
           writableObjectMode: true,
           write: common.mustCall((chunk, encoding, callback) => {
             assert(chunk instanceof ctor);
             assert.strictEqual(chunk, buffer);
-            callback();
+            finishWrite = callback;
           }),
           read() {
             this.push(null);
           },
         });
         duplex.on('error', common.mustNotCall());
         const writer = Duplex.toWeb(duplex).writable.getWriter();
-        await writer.write(buffer);
+        const writePromise = writer.write(buffer);
+        try {
+          await completesWithin(writePromise);
+        } finally {
+          finishWrite();
+        }
+        await writer.close();
       });
     }
   });