lint

Author: Mert Can Altin

test/parallel/test-async-wrap-pop-id-during-load.js

@@ -11,7 +11,7 @@ test('async function stack overflow test', async (t) => {
       fn();
       throw new Error();
     }
-    await (async function () { await fn(); })();
+    await (async function() { await fn(); })();
   }
 
   const ret = spawnSync(

test/parallel/test-c-ares.js

@@ -21,6 +21,8 @@
 
 'use strict';
 
+require('../common');
+
 const { test } = require('node:test');
 const assert = require('node:assert');
 const dns = require('node:dns');

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

@@ -23,7 +23,7 @@ async function checkAggregateError(op) {
   try {
     const filePath = await createFile();
     Object.defineProperty(FileHandle.prototype, 'fd', {
-      get: function () {
+      get: function() {
         // Close is set by using a setter,
         // so it needs to be set on the instance.
         const originalClose = this.close;

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

@@ -23,7 +23,7 @@ async function checkCloseError(op) {
   try {
     const filePath = await createFile();
     Object.defineProperty(FileHandle.prototype, 'fd', {
-      get: function () {
+      get: function() {
         // Close is set by using a setter,
         // so it needs to be set on the instance.
         const originalClose = this.close;

test/parallel/test-webcrypto-cryptokey-workers.js

@@ -3,12 +3,13 @@
 // This test ensures that CryptoKey instances can be correctly
 // sent to a Worker via postMessage.
 
-const { test } = require('node:test');
+const common = require('../common');
 const assert = require('node:assert');
+const { test } = require('node:test');
 const { subtle } = globalThis.crypto;
 const { once } = require('node:events');
 const { Worker, parentPort } = require('node:worker_threads');
-const common = require('../common');
+
 
 // Skip the test if crypto is not available
 if (!common.hasCrypto) common.skip('missing crypto');

test/parallel/test-webcrypto-export-import-rsa.js

@@ -1,7 +1,8 @@
 'use strict';
 
+require('../common');
+
 const assert = require('assert');
-const crypto = require('crypto');
 const { subtle } = globalThis.crypto;
 
 const sizes = [1024, 2048, 4096];
@@ -365,7 +366,7 @@ async function testImportJwk({ name, publicUsages, privateUsages }, size, hash,
 
   const [
     publicKey,
-    privateKey
+    privateKey,
   ] = await Promise.all([
     subtle.importKey(
       'jwk',

test/parallel/test-webcrypto-sign-verify-ecdsa.js

@@ -1,10 +1,11 @@
 'use strict';
 
+const common = require('../common');
+
 const { test } = require('node:test');
-const assert = require('node:assert');
 const { subtle } = globalThis.crypto;
+const assert = require('node:assert');
 
-const common = require('../common');
 if (!common.hasCrypto) common.skip('missing crypto');
 
 const vectors = require('../fixtures/crypto/ecdsa')();

test/parallel/test-webcrypto-sign-verify-eddsa.js

@@ -1,31 +1,42 @@
 'use strict';
 
+const common = require('../common');
+const assert = require('node:assert');
 const { test } = require('node:test');
-const assert = require('assert');
 const { subtle } = globalThis.crypto;
 
-const common = require('../common');
 if (!common.hasCrypto) common.skip('missing crypto');
 
 const vectors = require('../fixtures/crypto/eddsa')();
 
 // Test function for verification
-async function testVerify({ name, publicKeyBuffer, privateKeyBuffer, signature, data }) {
-  const [
-    publicKey,
-    noVerifyPublicKey,
-    privateKey,
-    hmacKey,
-    rsaKeys,
-    ecKeys,
-  ] = await Promise.all([
-    subtle.importKey('spki', publicKeyBuffer, { name }, false, ['verify']),
-    subtle.importKey('spki', publicKeyBuffer, { name }, false, []), // No usages for this key
-    subtle.importKey('pkcs8', privateKeyBuffer, { name }, false, ['sign']),
-    subtle.generateKey({ name: 'HMAC', hash: 'SHA-256' }, false, ['sign']),
-    subtle.generateKey({ name: 'RSA-PSS', modulusLength: 1024, publicExponent: new Uint8Array([1, 0, 1]), hash: 'SHA-256' }, false, ['sign']),
-    subtle.generateKey({ name: 'ECDSA', namedCurve: 'P-256' }, false, ['sign']),
-  ]);
+async function testVerify({
+  name,
+  publicKeyBuffer,
+  privateKeyBuffer,
+  signature,
+  data,
+}) {
+  const [publicKey, noVerifyPublicKey, privateKey, hmacKey, rsaKeys, ecKeys] =
+    await Promise.all([
+      subtle.importKey('spki', publicKeyBuffer, { name }, false, ['verify']),
+      subtle.importKey('spki', publicKeyBuffer, { name }, false, []), // No usages for this key
+      subtle.importKey('pkcs8', privateKeyBuffer, { name }, false, ['sign']),
+      subtle.generateKey({ name: 'HMAC', hash: 'SHA-256' }, false, ['sign']),
+      subtle.generateKey(
+        {
+          name: 'RSA-PSS',
+          modulusLength: 1024,
+          publicExponent: new Uint8Array([1, 0, 1]),
+          hash: 'SHA-256',
+        },
+        false,
+        ['sign'],
+      ),
+      subtle.generateKey({ name: 'ECDSA', namedCurve: 'P-256' }, false, [
+        'sign',
+      ]),
+    ]);
 
   // Test valid verification
   assert(await subtle.verify({ name }, publicKey, signature, data));
@@ -40,49 +51,69 @@ async function testVerify({ name, publicKeyBuffer, privateKeyBuffer, signature,
 
   // Test failure with wrong key or algorithm
   await assert.rejects(subtle.verify({ name }, privateKey, signature, data), {
-    message: /Unable to use this key to verify/
+    message: /Unable to use this key to verify/,
   });
 
-  await assert.rejects(subtle.verify({ name }, noVerifyPublicKey, signature, data), {
-    message: /Unable to use this key to verify/
-  });
+  await assert.rejects(
+    subtle.verify({ name }, noVerifyPublicKey, signature, data),
+    {
+      message: /Unable to use this key to verify/,
+    },
+  );
 
   await assert.rejects(subtle.verify({ name }, hmacKey, signature, data), {
-    message: /Unable to use this key to verify/
+    message: /Unable to use this key to verify/,
   });
 
-  await assert.rejects(subtle.verify({ name }, rsaKeys.publicKey, signature, data), {
-    message: /Unable to use this key to verify/
-  });
+  await assert.rejects(
+    subtle.verify({ name }, rsaKeys.publicKey, signature, data),
+    {
+      message: /Unable to use this key to verify/,
+    },
+  );
 
-  await assert.rejects(subtle.verify({ name }, ecKeys.publicKey, signature, data), {
-    message: /Unable to use this key to verify/
-  });
+  await assert.rejects(
+    subtle.verify({ name }, ecKeys.publicKey, signature, data),
+    {
+      message: /Unable to use this key to verify/,
+    },
+  );
 
   // Test failure when signature or data is altered
   const alteredSig = Buffer.from(signature);
   alteredSig[0] = 255 - alteredSig[0];
   assert(!(await subtle.verify({ name }, publicKey, alteredSig, data)));
-  assert(!(await subtle.verify({ name }, publicKey, alteredSig.slice(1), data)));
+  assert(
+    !(await subtle.verify({ name }, publicKey, alteredSig.slice(1), data)),
+  );
 
   const alteredData = Buffer.from(data);
   alteredData[0] = 255 - alteredData[0];
   assert(!(await subtle.verify({ name }, publicKey, signature, alteredData)));
 }
 
 // Test function for signing
-async function testSign({ name, publicKeyBuffer, privateKeyBuffer, signature, data }) {
-  const [
-    publicKey,
-    privateKey,
-    hmacKey,
-    rsaKeys,
-    ecKeys,
-  ] = await Promise.all([
+async function testSign({
+  name,
+  publicKeyBuffer,
+  privateKeyBuffer,
+  signature,
+  data,
+}) {
+  const [publicKey, privateKey, hmacKey, rsaKeys, ecKeys] = await Promise.all([
     subtle.importKey('spki', publicKeyBuffer, { name }, false, ['verify']),
     subtle.importKey('pkcs8', privateKeyBuffer, { name }, false, ['sign']),
     subtle.generateKey({ name: 'HMAC', hash: 'SHA-256' }, false, ['sign']),
-    subtle.generateKey({ name: 'RSA-PSS', modulusLength: 1024, publicExponent: new Uint8Array([1, 0, 1]), hash: 'SHA-256' }, false, ['sign']),
+    subtle.generateKey(
+      {
+        name: 'RSA-PSS',
+        modulusLength: 1024,
+        publicExponent: new Uint8Array([1, 0, 1]),
+        hash: 'SHA-256',
+      },
+      false,
+      ['sign'],
+    ),
     subtle.generateKey({ name: 'ECDSA', namedCurve: 'P-256' }, false, ['sign']),
   ]);
 
@@ -98,19 +129,19 @@ async function testSign({ name, publicKeyBuffer, privateKeyBuffer, signature, da
 
   // Test failure with wrong key or algorithm
   await assert.rejects(subtle.sign({ name }, publicKey, data), {
-    message: /Unable to use this key to sign/
+    message: /Unable to use this key to sign/,
   });
 
   await assert.rejects(subtle.sign({ name }, hmacKey, data), {
-    message: /Unable to use this key to sign/
+    message: /Unable to use this key to sign/,
   });
 
   await assert.rejects(subtle.sign({ name }, rsaKeys.privateKey, data), {
-    message: /Unable to use this key to sign/
+    message: /Unable to use this key to sign/,
   });
 
   await assert.rejects(subtle.sign({ name }, ecKeys.privateKey, data), {
-    message: /Unable to use this key to sign/
+    message: /Unable to use this key to sign/,
   });
 }
 
@@ -128,19 +159,54 @@ vectors.forEach((vector) => {
 test('Ed448 context', async () => {
   const vector = vectors.find(({ name }) => name === 'Ed448');
   const [privateKey, publicKey] = await Promise.all([
-    subtle.importKey('pkcs8', vector.privateKeyBuffer, { name: 'Ed448' }, false, ['sign']),
-    subtle.importKey('spki', vector.publicKeyBuffer, { name: 'Ed448' }, false, ['verify']),
+    subtle.importKey(
+      'pkcs8',
+      vector.privateKeyBuffer,
+      { name: 'Ed448' },
+      false,
+      ['sign'],
+    ),
+    subtle.importKey('spki', vector.publicKeyBuffer, { name: 'Ed448' }, false, [
+      'verify',
+    ]),
   ]);
 
-  const sig = await subtle.sign({ name: 'Ed448', context: Buffer.alloc(0) }, privateKey, vector.data);
+  const sig = await subtle.sign(
+    { name: 'Ed448', context: Buffer.alloc(0) },
+    privateKey,
+    vector.data,
+  );
   assert.deepStrictEqual(Buffer.from(sig), vector.signature);
-  assert.strictEqual(await subtle.verify({ name: 'Ed448', context: Buffer.alloc(0) }, publicKey, sig, vector.data), true);
-
-  await assert.rejects(subtle.sign({ name: 'Ed448', context: Buffer.alloc(1) }, privateKey, vector.data), {
-    message: /Non zero-length context is not yet supported/
-  });
-
-  await assert.rejects(subtle.verify({ name: 'Ed448', context: Buffer.alloc(1) }, publicKey, sig, vector.data), {
-    message: /Non zero-length context is not yet supported/
-  });
+  assert.strictEqual(
+    await subtle.verify(
+      { name: 'Ed448', context: Buffer.alloc(0) },
+      publicKey,
+      sig,
+      vector.data,
+    ),
+    true,
+  );
+
+  await assert.rejects(
+    subtle.sign(
+      { name: 'Ed448', context: Buffer.alloc(1) },
+      privateKey,
+      vector.data,
+    ),
+    {
+      message: /Non zero-length context is not yet supported/,
+    },
+  );
+
+  await assert.rejects(
+    subtle.verify(
+      { name: 'Ed448', context: Buffer.alloc(1) },
+      publicKey,
+      sig,
+      vector.data,
+    ),
+    {
+      message: /Non zero-length context is not yet supported/,
+    },
+  );
 });

test/parallel/test-worker-heapdump-failure.js

@@ -1,9 +1,11 @@
 'use strict';
+
+const common = require('../common');
+
 const { test } = require('node:test');
-const assert = require('node:assert');
 const { Worker } = require('node:worker_threads');
 const { once } = require('node:events');
-const common = require('../common');
+const assert = require('node:assert');
 
 // Test for ERR_WORKER_NOT_RUNNING when calling getHeapSnapshot on a worker that's not running
 test('Worker heap snapshot tests', async (t) => {