test: fix linting and remove unnecessary space changes

to make the changes clear, remove unnecessary space changes

Fixes: #60815

Author: y-okt

test/es-module/test-esm-detect-ambiguous.mjs

@@ -264,16 +264,16 @@ describe('Module syntax detection', { concurrency: !process.env.TEST_PARALLEL },
     });
 
     it('still throws on `await` in an ordinary sync function', async () => {
-         const { stdout, stderr, code, signal } = await spawnPromisified(process.execPath, [
-           '--eval',
-           'function fn() { await Promise.resolve(); } fn();',
-         ]);
+      const { stdout, stderr, code, signal } = await spawnPromisified(process.execPath, [
+        '--eval',
+        'function fn() { await Promise.resolve(); } fn();',
+      ]);
 
-         assert.match(stderr, /SyntaxError: await is only valid in async function/);
-         assert.strictEqual(stdout, '');
-         assert.strictEqual(code, 1);
-         assert.strictEqual(signal, null);
-       });
+      assert.match(stderr, /SyntaxError: await is only valid in async function/);
+      assert.strictEqual(stdout, '');
+      assert.strictEqual(code, 1);
+      assert.strictEqual(signal, null);
+    });
 
     it('throws on undefined `require` when top-level `await` triggers ESM parsing', async () => {
       const { stdout, stderr, code, signal } = await spawnPromisified(process.execPath, [
@@ -315,16 +315,16 @@ describe('Module syntax detection', { concurrency: !process.env.TEST_PARALLEL },
     });
 
     it('still throws on double `const` declaration not at the top level', async () => {
-         const { stdout, stderr, code, signal } = await spawnPromisified(process.execPath, [
-           '--eval',
-           'function fn() { const require = 1; const require = 2; } fn();',
-         ]);
-
-         assert.match(stderr, /SyntaxError: Identifier 'require' has already been declared/);
-         assert.strictEqual(stdout, '');
-         assert.strictEqual(code, 1);
-         assert.strictEqual(signal, null);
-       });
+      const { stdout, stderr, code, signal } = await spawnPromisified(process.execPath, [
+        '--eval',
+        'function fn() { const require = 1; const require = 2; } fn();',
+      ]);
+
+      assert.match(stderr, /SyntaxError: Identifier 'require' has already been declared/);
+      assert.strictEqual(stdout, '');
+      assert.strictEqual(code, 1);
+      assert.strictEqual(signal, null);
+    });
   });
 
   describe('warn about typeless packages for .js files with ESM syntax', { concurrency: true }, () => {

test/es-module/test-esm-import-meta-main-eval.mjs

@@ -100,39 +100,35 @@ assert.strictEqual(importedModuleIsMain, false, 'import.meta.main should evaluat
     });
   });
 
-  it('should evaluate true in worker instantiated with module source by evaluated script',
-     onlyWithAmaro,
-     async () => {
-       const result = await spawnPromisified(
-         process.execPath,
-         ['--input-type=module-typescript',
-          '--disable-warning=ExperimentalWarning',
-          '--eval',
-          wrapScriptInEvalWorker(importMetaMainTSScript)],
-       );
-       assert.deepStrictEqual(result, {
-         stderr: '',
-         stdout: '',
-         code: 0,
-         signal: null,
-       });
-     });
-
-  it('should evaluate true in worker instantiated with `data:` URL by evaluated script',
-     onlyWithAmaro,
-     async () => {
-       const result = await spawnPromisified(
-         process.execPath,
-         ['--input-type=module',
-          '--input-type=module-typescript',
-          '--disable-warning=ExperimentalWarning',
-          '--eval', wrapScriptInUrlWorker(importMetaMainTSScript)],
-       );
-       assert.deepStrictEqual(result, {
-         stderr: '',
-         stdout: '',
-         code: 0,
-         signal: null,
-       });
-     });
+  it('should evaluate true in worker instantiated with module source by evaluated script', onlyWithAmaro, async () => {
+    const result = await spawnPromisified(
+      process.execPath,
+      ['--input-type=module-typescript',
+       '--disable-warning=ExperimentalWarning',
+       '--eval',
+       wrapScriptInEvalWorker(importMetaMainTSScript)],
+    );
+    assert.deepStrictEqual(result, {
+      stderr: '',
+      stdout: '',
+      code: 0,
+      signal: null,
+    });
+  });
+
+  it('should evaluate true in worker instantiated with `data:` URL by evaluated script', onlyWithAmaro, async () => {
+    const result = await spawnPromisified(
+      process.execPath,
+      ['--input-type=module',
+       '--input-type=module-typescript',
+       '--disable-warning=ExperimentalWarning',
+       '--eval', wrapScriptInUrlWorker(importMetaMainTSScript)],
+    );
+    assert.deepStrictEqual(result, {
+      stderr: '',
+      stdout: '',
+      code: 0,
+      signal: null,
+    });
+  });
 });

test/es-module/test-esm-tla-syntax-errors-not-recognized-as-tla-error.mjs

@@ -50,29 +50,29 @@ describe('unusual top-level await syntax errors', () => {
   });
 
   it('should throw the error for unrelated syntax errors', async () => {
-       const expression = 'foo bar';
-       const wrapperExpressions = [
-         [`function callSyntaxError() {}; callSyntaxError(${expression});`, /missing \) after argument list/],
-         [`if (${expression}) {}`, /Unexpected identifier/],
-         [`{ key: ${expression} }`, /Unexpected identifier/],
-         [`[${expression}]`, /Unexpected identifier/],
-         [`(${expression})`, /Unexpected identifier/],
-         [`const ${expression} = 1;`, /Missing initializer in const declaration/],
-         [`console.log('PI: ' Math.PI);`, /missing \) after argument list/],
-         [`callAwait(await "" "");`, /missing \) after argument list/],
-       ];
+    const expression = 'foo bar';
+    const wrapperExpressions = [
+      [`function callSyntaxError() {}; callSyntaxError(${expression});`, /missing \) after argument list/],
+      [`if (${expression}) {}`, /Unexpected identifier/],
+      [`{ key: ${expression} }`, /Unexpected identifier/],
+      [`[${expression}]`, /Unexpected identifier/],
+      [`(${expression})`, /Unexpected identifier/],
+      [`const ${expression} = 1;`, /Missing initializer in const declaration/],
+      [`console.log('PI: ' Math.PI);`, /missing \) after argument list/],
+      [`callAwait(await "" "");`, /missing \) after argument list/],
+    ];
 
-       for (const [wrapperExpression, error] of wrapperExpressions) {
-         const { code, signal, stdout, stderr } = await spawnPromisified(process.execPath, [
-           '--eval',
-           `
-          ${wrapperExpression}
-          `,
-         ]);
-         assert.match(stderr, error);
-         assert.strictEqual(stdout, '');
-         assert.strictEqual(code, 1);
-         assert.strictEqual(signal, null);
-       }
-     });
+    for (const [wrapperExpression, error] of wrapperExpressions) {
+      const { code, signal, stdout, stderr } = await spawnPromisified(process.execPath, [
+        '--eval',
+        `
+      ${wrapperExpression}
+      `,
+      ]);
+      assert.match(stderr, error);
+      assert.strictEqual(stdout, '');
+      assert.strictEqual(code, 1);
+      assert.strictEqual(signal, null);
+    }
+  });
 });

test/parallel/test-compile-cache-typescript-esm.js

@@ -2,10 +2,7 @@
 
 // This tests NODE_COMPILE_CACHE works for ESM with types.
 
-const common = require('../common');
-if (!process.config.variables.node_use_amaro) {
-  common.skip('Requires Amaro');
-}
+require('../common');
 const { spawnSyncAndAssert } = require('../common/child_process');
 const assert = require('assert');
 const tmpdir = require('../common/tmpdir');

test/parallel/test-runner-global-setup-teardown.mjs

@@ -258,37 +258,35 @@ async function runTest(
                 'Teardown should not run after setup fails');
     });
 
-    it('should run TypeScript globalSetup and globalTeardown functions',
-       onlyWithAmaro,
-       async () => {
-         const setupFlagPath = tmpdir.resolve('setup-executed-ts.tmp');
-         const teardownFlagPath = tmpdir.resolve('teardown-executed-ts.tmp');
+    it('should run TypeScript globalSetup and globalTeardown functions', onlyWithAmaro, async () => {
+      const setupFlagPath = tmpdir.resolve('setup-executed-ts.tmp');
+      const teardownFlagPath = tmpdir.resolve('teardown-executed-ts.tmp');
 
-         const { stdout, stderr } = await runTest({
-           isolation,
-           globalSetupFile: 'basic-setup-teardown.ts',
-           env: {
-             SETUP_FLAG_PATH: setupFlagPath,
-             TEARDOWN_FLAG_PATH: teardownFlagPath
-           },
-           additionalFlags: ['--no-warnings'],
-           runnerEnabled
-         });
+      const { stdout, stderr } = await runTest({
+        isolation,
+        globalSetupFile: 'basic-setup-teardown.ts',
+        env: {
+          SETUP_FLAG_PATH: setupFlagPath,
+          TEARDOWN_FLAG_PATH: teardownFlagPath
+        },
+        additionalFlags: ['--no-warnings'],
+        runnerEnabled
+      });
 
-         assert.match(stdout, /pass 2/);
-         assert.match(stdout, /fail 0/);
-         assert.match(stdout, /Global setup executed/);
-         assert.match(stdout, /Global teardown executed/);
-         assert.strictEqual(stderr.length, 0);
-
-         // After all tests complete, the teardown should have run
-         assert.ok(fs.existsSync(teardownFlagPath), 'Teardown flag file should exist');
-         const content = fs.readFileSync(teardownFlagPath, 'utf8');
-         assert.strictEqual(content, 'Teardown was executed');
-
-         // Setup flag should have been removed by teardown
-         assert.ok(!fs.existsSync(setupFlagPath), 'Setup flag file should have been removed');
-       });
+      assert.match(stdout, /pass 2/);
+      assert.match(stdout, /fail 0/);
+      assert.match(stdout, /Global setup executed/);
+      assert.match(stdout, /Global teardown executed/);
+      assert.strictEqual(stderr.length, 0);
+
+      // After all tests complete, the teardown should have run
+      assert.ok(fs.existsSync(teardownFlagPath), 'Teardown flag file should exist');
+      const content = fs.readFileSync(teardownFlagPath, 'utf8');
+      assert.strictEqual(content, 'Teardown was executed');
+
+      // Setup flag should have been removed by teardown
+      assert.ok(!fs.existsSync(setupFlagPath), 'Setup flag file should have been removed');
+    });
 
     it('should run ESM globalSetup and globalTeardown functions', async () => {
       const setupFlagPath = tmpdir.resolve('setup-executed-esm.tmp');

test/parallel/test-runner-run-global-hooks.mjs

@@ -1,4 +1,4 @@
-import { mustCall, mustCallAtLeast, skip } from '../common/index.mjs';
+import { mustCall, mustCallAtLeast } from '../common/index.mjs';
 import * as fixtures from '../common/fixtures.mjs';
 import { describe, it, beforeEach, run } from 'node:test';
 import assert from 'node:assert';
@@ -8,9 +8,7 @@ import path from 'node:path';
 import { spawn } from 'node:child_process';
 import { once } from 'node:events';
 
-if (!process.config.variables.node_use_amaro) {
-  skip('Requires Amaro');
-}
+const onlyWithAmaro = { skip: !process.config.variables.node_use_amaro };
 
 const testFixtures = fixtures.path('test-runner', 'global-setup-teardown');
 const runnerFixture = fixtures.path('test-runner', 'test-runner-global-hooks.mjs');
@@ -166,31 +164,29 @@ describe('require(\'node:test\').run with global hooks', { concurrency: false },
         assert.strictEqual(content, 'Setup part, Teardown part');
       });
 
-      it('should run TypeScript globalSetup and globalTeardown functions',
-         onlyWithAmaro,
-         async () => {
-           const setupFlagPath = tmpdir.resolve('setup-executed-ts.tmp');
-           const teardownFlagPath = tmpdir.resolve('teardown-executed-ts.tmp');
-
-           const { results } = await runTestWithGlobalHooks({
-             globalSetupFile: 'basic-setup-teardown.ts',
-             runnerEnv: {
-               SETUP_FLAG_PATH: setupFlagPath,
-               TEARDOWN_FLAG_PATH: teardownFlagPath
-             },
-             isolation
-           });
-
-           assert.strictEqual(results.passed, 2);
-           assert.strictEqual(results.failed, 0);
-           // After all tests complete, the teardown should have run
-           assert.ok(fs.existsSync(teardownFlagPath), 'Teardown flag file should exist');
-           const content = fs.readFileSync(teardownFlagPath, 'utf8');
-           assert.strictEqual(content, 'Teardown was executed');
-
-           // Setup flag should have been removed by teardown
-           assert.ok(!fs.existsSync(setupFlagPath), 'Setup flag file should have been removed');
-         });
+      it('should run TypeScript globalSetup and globalTeardown functions', onlyWithAmaro, async () => {
+        const setupFlagPath = tmpdir.resolve('setup-executed-ts.tmp');
+        const teardownFlagPath = tmpdir.resolve('teardown-executed-ts.tmp');
+
+        const { results } = await runTestWithGlobalHooks({
+          globalSetupFile: 'basic-setup-teardown.ts',
+          runnerEnv: {
+            SETUP_FLAG_PATH: setupFlagPath,
+            TEARDOWN_FLAG_PATH: teardownFlagPath
+          },
+          isolation
+        });
+
+        assert.strictEqual(results.passed, 2);
+        assert.strictEqual(results.failed, 0);
+        // After all tests complete, the teardown should have run
+        assert.ok(fs.existsSync(teardownFlagPath), 'Teardown flag file should exist');
+        const content = fs.readFileSync(teardownFlagPath, 'utf8');
+        assert.strictEqual(content, 'Teardown was executed');
+
+        // Setup flag should have been removed by teardown
+        assert.ok(!fs.existsSync(setupFlagPath), 'Setup flag file should have been removed');
+      });
 
       it('should run ESM globalSetup and globalTeardown functions', async () => {
         const setupFlagPath = tmpdir.resolve('setup-executed-esm.tmp');