test: migrate tests to use node:test module for better test structure for FS

test/parallel/test-filehandle-close.js

@@ -2,16 +2,18 @@
 const common = require('../common');
 const assert = require('assert');
 const fs = require('fs');
+const { test } = require('node:test');
 
-// Test that using FileHandle.close to close an already-closed fd fails
-// with EBADF.
-
-(async function() {
+test('FileHandle.close should fail with EBADF when closing an already closed fd', async () => {
   const fh = await fs.promises.open(__filename);
   fs.closeSync(fh.fd);
 
-  await assert.rejects(() => fh.close(), {
-    code: 'EBADF',
-    syscall: 'close'
-  });
-})().then(common.mustCall());
+  // Test that closing an already closed fd results in EBADF
+  await assert.rejects(
+    () => fh.close(),
+    {
+      code: 'EBADF',
+      syscall: 'close'
+    }
+  );
+}).then(common.mustCall());

test/parallel/test-fs-promises-file-handle-aggregate-errors.js

@@ -4,23 +4,15 @@
 const common = require('../common');
 const tmpdir = require('../common/tmpdir');
 
-// The following tests validate aggregate errors are thrown correctly
-// when both an operation and close throw.
+const { test } = require('node:test');
+const { readFile, writeFile, truncate, lchmod } = require('node:fs/promises');
+const { FileHandle } = require('internal/fs/promises');
 
-const {
-  readFile,
-  writeFile,
-  truncate,
-  lchmod,
-} = require('fs/promises');
-const {
-  FileHandle,
-} = require('internal/fs/promises');
-
-const assert = require('assert');
+const assert = require('node:assert');
 const originalFd = Object.getOwnPropertyDescriptor(FileHandle.prototype, 'fd');
 
 let count = 0;
+
 async function createFile() {
   const filePath = tmpdir.resolve(`aggregate_errors_${++count}.txt`);
   await writeFile(filePath, 'content');
@@ -45,27 +37,35 @@ async function checkAggregateError(op) {
         const opError = new Error('INTERNAL_ERROR');
         opError.code = 123;
         throw opError;
-      }
+      },
     });
 
-    await assert.rejects(op(filePath), common.mustCall((err) => {
+    // Perform the operation and check the aggregate error
+    await assert.rejects(op(filePath), (err) => {
       assert.strictEqual(err.name, 'AggregateError');
       assert.strictEqual(err.code, 123);
       assert.strictEqual(err.errors.length, 2);
+
+      // Check the individual errors
       assert.strictEqual(err.errors[0].message, 'INTERNAL_ERROR');
+      assert.strictEqual(err.errors[0].code, 123);
+
       assert.strictEqual(err.errors[1].message, 'CLOSE_ERROR');
+      assert.strictEqual(err.errors[1].code, 456);
+
       return true;
-    }));
+    });
   } finally {
     Object.defineProperty(FileHandle.prototype, 'fd', originalFd);
   }
 }
-(async function() {
+
+test('Test aggregate errors for file operations', async () => {
   tmpdir.refresh();
   await checkAggregateError((filePath) => truncate(filePath));
   await checkAggregateError((filePath) => readFile(filePath));
   await checkAggregateError((filePath) => writeFile(filePath, '123'));
   if (common.isMacOS) {
     await checkAggregateError((filePath) => lchmod(filePath, 0o777));
   }
-})().then(common.mustCall());
+});

test/parallel/test-fs-promises-file-handle-close-errors.js

@@ -4,23 +4,15 @@
 const common = require('../common');
 const tmpdir = require('../common/tmpdir');
 
-// The following tests validate aggregate errors are thrown correctly
-// when both an operation and close throw.
+const { test } = require('node:test');
+const { readFile, writeFile, truncate, lchmod } = require('fs/promises');
+const { FileHandle } = require('internal/fs/promises');
 
-const {
-  readFile,
-  writeFile,
-  truncate,
-  lchmod,
-} = require('fs/promises');
-const {
-  FileHandle,
-} = require('internal/fs/promises');
-
-const assert = require('assert');
+const assert = require('node:assert');
 const originalFd = Object.getOwnPropertyDescriptor(FileHandle.prototype, 'fd');
 
 let count = 0;
+
 async function createFile() {
   const filePath = tmpdir.resolve(`close_errors_${++count}.txt`);
   await writeFile(filePath, 'content');
@@ -43,7 +35,7 @@ async function checkCloseError(op) {
           throw closeError;
         };
         return originalFd.get.call(this);
-      }
+      },
     });
 
     await assert.rejects(op(filePath), {
@@ -55,12 +47,13 @@ async function checkCloseError(op) {
     Object.defineProperty(FileHandle.prototype, 'fd', originalFd);
   }
 }
-(async function() {
+
+test('File operations with close errors', async () => {
   tmpdir.refresh();
   await checkCloseError((filePath) => truncate(filePath));
   await checkCloseError((filePath) => readFile(filePath));
   await checkCloseError((filePath) => writeFile(filePath, '123'));
   if (common.isMacOS) {
     await checkCloseError((filePath) => lchmod(filePath, 0o777));
   }
-})().then(common.mustCall());
+}).then(common.mustCall());