diff --git a/test/es-module/test-esm-loader-hooks.mjs b/test/es-module/test-esm-loader-hooks.mjs
index fc08eee84fb415..c73fa0cdfd5bdc 100644
--- a/test/es-module/test-esm-loader-hooks.mjs
+++ b/test/es-module/test-esm-loader-hooks.mjs
@@ -451,149 +451,155 @@ describe('Loader hooks', { concurrency: true }, () => {
     assert.strictEqual(signal, null);
   });
 
-  it('should invoke `initialize` correctly', async () => {
-    const { code, signal, stdout, stderr } = await spawnPromisified(execPath, [
-      '--no-warnings',
-      '--experimental-loader',
-      fixtures.fileURL('es-module-loaders/hooks-initialize.mjs'),
-      '--input-type=module',
-      '--eval',
-      'import os from "node:os";',
-    ]);
+  describe('initialize hook', () => {
+    it('should invoke `initialize` correctly', async () => {
+      const { code, signal, stdout, stderr } = await spawnPromisified(execPath, [
+        '--no-warnings',
+        '--experimental-loader',
+        fixtures.fileURL('es-module-loaders/hooks-initialize.mjs'),
+        '--input-type=module',
+        '--eval',
+        'import os from "node:os";',
+      ]);
 
-    assert.strictEqual(stderr, '');
-    assert.deepStrictEqual(stdout.split('\n'), ['hooks initialize 1', '']);
-    assert.strictEqual(code, 0);
-    assert.strictEqual(signal, null);
-  });
+      assert.strictEqual(stderr, '');
+      assert.deepStrictEqual(stdout.split('\n'), ['hooks initialize 1', '']);
+      assert.strictEqual(code, 0);
+      assert.strictEqual(signal, null);
+    });
 
-  it('should allow communicating with loader via `register` ports', async () => {
-    const { code, signal, stdout, stderr } = await spawnPromisified(execPath, [
-      '--no-warnings',
-      '--input-type=module',
-      '--eval',
-      `
-        import {MessageChannel} from 'node:worker_threads';
-        import {register} from 'node:module';
-        import {once} from 'node:events';
-        const {port1, port2} = new MessageChannel();
-        port1.on('message', (msg) => {
-          console.log('message', msg);
-        });
-        const result = register(
-          ${JSON.stringify(fixtures.fileURL('es-module-loaders/hooks-initialize-port.mjs'))},
-          {data: port2, transferList: [port2]},
-        );
-        console.log('register', result);
-
-        const timeout = setTimeout(() => {}, 2**31 - 1); // to keep the process alive.
-        await Promise.all([
-          once(port1, 'message').then(() => once(port1, 'message')),
-          import('node:os'),
-        ]);
-        clearTimeout(timeout);
-        port1.close();
-      `,
-    ]);
+    it('should allow communicating with loader via `register` ports', async () => {
+      const { code, signal, stdout, stderr } = await spawnPromisified(execPath, [
+        '--no-warnings',
+        '--input-type=module',
+        '--eval',
+        `
+          import {MessageChannel} from 'node:worker_threads';
+          import {register} from 'node:module';
+          import {once} from 'node:events';
+          const {port1, port2} = new MessageChannel();
+          port1.on('message', (msg) => {
+            console.log('message', msg);
+          });
+          const result = register(
+            ${JSON.stringify(fixtures.fileURL('es-module-loaders/hooks-initialize-port.mjs'))},
+            {data: port2, transferList: [port2]},
+          );
+          console.log('register', result);
+
+          const timeout = setTimeout(() => {}, 2**31 - 1); // to keep the process alive.
+          await Promise.all([
+            once(port1, 'message').then(() => once(port1, 'message')),
+            import('node:os'),
+          ]);
+          clearTimeout(timeout);
+          port1.close();
+        `,
+      ]);
 
-    assert.strictEqual(stderr, '');
-    assert.deepStrictEqual(stdout.split('\n'), [ 'register undefined',
-                                                 'message initialize',
-                                                 'message resolve node:os',
-                                                 '' ]);
+      assert.strictEqual(stderr, '');
+      assert.deepStrictEqual(stdout.split('\n'), [
+        'register undefined',
+        'message initialize',
+        'message resolve node:os',
+        '',
+      ]);
 
-    assert.strictEqual(code, 0);
-    assert.strictEqual(signal, null);
-  });
+      assert.strictEqual(code, 0);
+      assert.strictEqual(signal, null);
+    });
 
-  it('should have `register` work with cjs', async () => {
-    const { code, signal, stdout, stderr } = await spawnPromisified(execPath, [
-      '--no-warnings',
-      '--input-type=commonjs',
-      '--eval',
-      `
-        'use strict';
-        const {register} = require('node:module');
-        register(
-          ${JSON.stringify(fixtures.fileURL('es-module-loaders/hooks-initialize.mjs'))},
-        );
-        register(
-          ${JSON.stringify(fixtures.fileURL('es-module-loaders/loader-load-foo-or-42.mjs'))},
-        );
-
-        import('node:os').then((result) => {
-          console.log(JSON.stringify(result));
-        });
-      `,
-    ]);
+    it('should have `register` work with cjs', async () => {
+      const { code, signal, stdout, stderr } = await spawnPromisified(execPath, [
+        '--no-warnings',
+        '--input-type=commonjs',
+        '--eval',
+        `
+          'use strict';
+          const {register} = require('node:module');
+          register(
+            ${JSON.stringify(fixtures.fileURL('es-module-loaders/hooks-initialize.mjs'))},
+          );
+          register(
+            ${JSON.stringify(fixtures.fileURL('es-module-loaders/loader-load-foo-or-42.mjs'))},
+          );
+
+          import('node:os').then((result) => {
+            console.log(JSON.stringify(result));
+          });
+        `,
+      ]);
 
-    assert.strictEqual(stderr, '');
-    assert.deepStrictEqual(stdout.split('\n').sort(), ['hooks initialize 1', '{"default":"foo"}', ''].sort());
+      assert.strictEqual(stderr, '');
+      assert.deepStrictEqual(stdout.split('\n').sort(), ['hooks initialize 1', '{"default":"foo"}', ''].sort());
 
-    assert.strictEqual(code, 0);
-    assert.strictEqual(signal, null);
-  });
+      assert.strictEqual(code, 0);
+      assert.strictEqual(signal, null);
+    });
 
-  it('`register` should work with `require`', async () => {
-    const { code, signal, stdout, stderr } = await spawnPromisified(execPath, [
-      '--no-warnings',
-      '--require',
-      fixtures.path('es-module-loaders/register-loader.cjs'),
-      '--input-type=module',
-      '--eval',
-      'import "node:os";',
-    ]);
+    it('`register` should work with `require`', async () => {
+      const { code, signal, stdout, stderr } = await spawnPromisified(execPath, [
+        '--no-warnings',
+        '--require',
+        fixtures.path('es-module-loaders/register-loader.cjs'),
+        '--input-type=module',
+        '--eval',
+        'import "node:os";',
+      ]);
 
-    assert.strictEqual(stderr, '');
-    assert.deepStrictEqual(stdout.split('\n'), ['resolve passthru', 'resolve passthru', '']);
-    assert.strictEqual(code, 0);
-    assert.strictEqual(signal, null);
-  });
+      assert.strictEqual(stderr, '');
+      assert.deepStrictEqual(stdout.split('\n'), ['resolve passthru', 'resolve passthru', '']);
+      assert.strictEqual(code, 0);
+      assert.strictEqual(signal, null);
+    });
 
-  it('`register` should work with `import`', async () => {
-    const { code, signal, stdout, stderr } = await spawnPromisified(execPath, [
-      '--no-warnings',
-      '--import',
-      fixtures.fileURL('es-module-loaders/register-loader.mjs'),
-      '--input-type=module',
-      '--eval',
-      `
-        import 'node:os';
-      `,
-    ]);
+    it('`register` should work with `import`', async () => {
+      const { code, signal, stdout, stderr } = await spawnPromisified(execPath, [
+        '--no-warnings',
+        '--import',
+        fixtures.fileURL('es-module-loaders/register-loader.mjs'),
+        '--input-type=module',
+        '--eval',
+        `
+          import 'node:os';
+        `,
+      ]);
 
-    assert.strictEqual(stderr, '');
-    assert.deepStrictEqual(stdout.split('\n'), ['resolve passthru', '']);
-    assert.strictEqual(code, 0);
-    assert.strictEqual(signal, null);
-  });
+      assert.strictEqual(stderr, '');
+      assert.deepStrictEqual(stdout.split('\n'), ['resolve passthru', '']);
+      assert.strictEqual(code, 0);
+      assert.strictEqual(signal, null);
+    });
 
-  it('should execute `initialize` in sequence', async () => {
-    const { code, signal, stdout, stderr } = await spawnPromisified(execPath, [
-      '--no-warnings',
-      '--input-type=module',
-      '--eval',
-      `
-        import {register} from 'node:module';
-        console.log('result 1', register(
-          ${JSON.stringify(fixtures.fileURL('es-module-loaders/hooks-initialize.mjs'))}
-        ));
-        console.log('result 2', register(
-          ${JSON.stringify(fixtures.fileURL('es-module-loaders/hooks-initialize.mjs'))}
-        ));
-
-        await import('node:os');
-      `,
-    ]);
+    it('should execute `initialize` in sequence', async () => {
+      const { code, signal, stdout, stderr } = await spawnPromisified(execPath, [
+        '--no-warnings',
+        '--input-type=module',
+        '--eval',
+        `
+          import {register} from 'node:module';
+          console.log('result 1', register(
+            ${JSON.stringify(fixtures.fileURL('es-module-loaders/hooks-initialize.mjs'))}
+          ));
+          console.log('result 2', register(
+            ${JSON.stringify(fixtures.fileURL('es-module-loaders/hooks-initialize.mjs'))}
+          ));
+
+          await import('node:os');
+        `,
+      ]);
 
-    assert.strictEqual(stderr, '');
-    assert.deepStrictEqual(stdout.split('\n'), [ 'hooks initialize 1',
-                                                 'result 1 undefined',
-                                                 'hooks initialize 2',
-                                                 'result 2 undefined',
-                                                 '' ]);
-    assert.strictEqual(code, 0);
-    assert.strictEqual(signal, null);
+      assert.strictEqual(stderr, '');
+      assert.deepStrictEqual(stdout.split('\n'), [
+        'hooks initialize 1',
+        'result 1 undefined',
+        'hooks initialize 2',
+        'result 2 undefined',
+        '',
+      ]);
+      assert.strictEqual(code, 0);
+      assert.strictEqual(signal, null);
+    });
   });
 
   it('should use CJS loader to respond to require.resolve calls by default', async () => {