stream: test explicit resource management implicitly

Author: LiviaMedeiros

test/parallel/test-stream-duplex-destroy.js

@@ -271,7 +271,7 @@ const assert = require('assert');
 }
 
 {
-  // Check Symbol.asyncDispose
+  // Check Symbol.asyncDispose explicitly
   const duplex = new Duplex({
     write(chunk, enc, cb) { cb(); },
     read() {},
@@ -284,3 +284,17 @@ const assert = require('assert');
   duplex.on('close', common.mustCall());
   duplex[Symbol.asyncDispose]().then(common.mustCall());
 }
+
+(async () => {
+  // Check Symbol.asyncDispose implicitly
+  await using duplex = new Duplex({
+    write(chunk, enc, cb) { cb(); },
+    read() {},
+  });
+  let count = 0;
+  duplex.on('error', common.mustCall((e) => {
+    assert.strictEqual(count++, 0); // Ensure not called twice
+    assert.strictEqual(e.name, 'AbortError');
+  }));
+  duplex.on('close', common.mustCall());
+})().then(common.mustCall(), common.mustNotCall());

test/parallel/test-stream-readable-dispose.js

@@ -21,3 +21,18 @@ const assert = require('assert');
     assert.strictEqual(read.destroyed, true);
   }));
 }
+
+(async () => {
+  await using read = new Readable({
+    read() {}
+  });
+  read.resume();
+
+  read.on('end', common.mustNotCall('no end event'));
+  read.on('close', common.mustCall());
+  read.on('error', common.mustCall(function(err) {
+    assert.strictEqual(err.name, 'AbortError');
+    assert.strictEqual(this.errored.name, 'AbortError');
+    assert.strictEqual(this.destroyed, true);
+  }));
+})().then(common.mustCall(), common.mustNotCall());

test/parallel/test-stream-transform-destroy.js

@@ -152,3 +152,13 @@ const assert = require('assert');
   transform.on('close', common.mustCall());
   transform[Symbol.asyncDispose]().then(common.mustCall());
 }
+
+(async () => {
+  await using transform = new Transform({
+    transform(chunk, enc, cb) {}
+  });
+  transform.on('error', common.mustCall((err) => {
+    assert.strictEqual(err.name, 'AbortError');
+  }));
+  transform.on('close', common.mustCall());
+})().then(common.mustCall(), common.mustNotCall());

test/parallel/test-stream-writable-destroy.js

@@ -499,3 +499,16 @@ const assert = require('assert');
   }));
   write[Symbol.asyncDispose]().then(common.mustCall());
 }
+
+(async () => {
+  await using write = new Writable({
+    write(chunk, enc, cb) { cb(); }
+  });
+
+  write.on('error', common.mustCall(function(e) {
+    assert.strictEqual(e.name, 'AbortError');
+    assert.strictEqual(this.destroyed, true);
+  }));
+  write.on('close', common.mustCall());
+  write.on('finish', common.mustNotCall('no finish event'));
+})().then(common.mustCall(), common.mustNotCall());