quic: Adhere to new js linting

Author: martenrichter

test/parallel/test-quic-client-to-server-bidirectional-echo.mjs

@@ -1,7 +1,7 @@
 // Flags: --experimental-quic --no-warnings
 
 import { hasQuic, skip, mustCall } from '../common/index.mjs';
-import { ok, strictEqual } from 'node:assert';
+import assert from 'node:assert';
 import { readKey } from '../common/fixtures.mjs';
 import { KNOWN_BYTES_LONG, uint8concat, equalUint8Arrays } from '../common/quic/test-helpers.mjs';
 import { TransformStream } from 'node:stream/web';
@@ -19,9 +19,9 @@ const certs = readKey('agent1-cert.pem');
 
 const finished = Promise.withResolvers();
 
-const serverEndpoint = await listen(async (serverSession) => {
+const serverEndpoint = await listen(mustCall(async (serverSession) => {
   serverSession.onstream = mustCall(async (stream) => {
-    strictEqual(stream.direction, 'bidi', 'Expects an bidirectional stream');
+    assert.strictEqual(stream.direction, 'bidi');
     stream.closed.catch(() => {
       // ignore
     });
@@ -36,10 +36,10 @@ const serverEndpoint = await listen(async (serverSession) => {
     // ignore the error
   });
   serverSession.close();
-}, { keys, certs });
+}), { keys, certs });
 
 // The server must have an address to connect to after listen resolves.
-ok(serverEndpoint.address !== undefined);
+assert.ok(serverEndpoint.address !== undefined);
 
 const clientSession = await connect(serverEndpoint.address);
 await clientSession.opened;
@@ -50,7 +50,7 @@ const sendStream = await clientSession.createBidirectionalStream({ body: transfo
 sendStream.closed.catch(() => {
   // ignore
 });
-strictEqual(sendStream.direction, 'bidi');
+assert.strictEqual(sendStream.direction, 'bidi');
 const writeToStream = async () => {
   const clientWritable = transformStream.writable;
   const writer = clientWritable.getWriter();
@@ -61,20 +61,20 @@ const writeToStream = async () => {
   await writer.ready;
   await writer.close();
 };
-const readFromStream = async () => {
+const readFromStream = mustCall(async () => {
   const reader = sendStream.readable.getReader();
   const readChunks = [];
   while (true) {
     const { done, value } = await reader.read();
     if (value) {
-      ok(value instanceof Uint8Array, 'Expects value to be a Uint8Array');
+      assert.ok(value instanceof Uint8Array, 'Expects value to be a Uint8Array');
       readChunks.push(value);
     }
     if (done) break;
   }
   // Now compare what we got
   equalUint8Arrays(uint8concat(KNOWN_BYTES_LONG), uint8concat(readChunks));
-};
+});
 
 await Promise.all([writeToStream(), readFromStream()]);
 clientSession.closed.catch((err) => {

test/parallel/test-quic-client-to-server-unidirectional.mjs

@@ -1,7 +1,7 @@
 // Flags: --experimental-quic --no-warnings
 
 import { hasQuic, skip, mustCall } from '../common/index.mjs';
-import { ok, strictEqual } from 'node:assert';
+import assert from 'node:assert';
 import { readKey } from '../common/fixtures.mjs';
 import { KNOWN_BYTES_LONG, uint8concat, equalUint8Arrays } from '../common/quic/test-helpers.mjs';
 import { TransformStream } from 'node:stream/web';
@@ -20,16 +20,16 @@ const certs = readKey('agent1-cert.pem');
 // The opened promise should resolve when the client finished reading
 const serverFinished = Promise.withResolvers();
 
-const serverEndpoint = await listen(async (serverSession) => {
+const serverEndpoint = await listen(mustCall(async (serverSession) => {
   serverSession.onstream = mustCall(async (stream) => {
-    strictEqual(stream.direction, 'uni', 'Expects an unidirectional stream');
+    assert.strictEqual(stream.direction, 'uni');
     const reader = stream.readable.getReader();
     const readChunks = [];
     while (true) {
       const { done, value } = await reader.read();
       // if (readc > 20) throw new Error("after read " + readc);
       if (value) {
-        ok(value instanceof Uint8Array, 'Expects value to be a Uint8Array');
+        assert.ok(value instanceof Uint8Array, 'Expects value to be a Uint8Array');
         readChunks.push(value);
       }
       if (done) break;
@@ -47,10 +47,10 @@ const serverEndpoint = await listen(async (serverSession) => {
     // ignore the error
   });
   serverSession.close();
-}, { keys, certs });
+}), { keys, certs });
 
 // The server must have an address to connect to after listen resolves.
-ok(serverEndpoint.address !== undefined);
+assert.ok(serverEndpoint.address !== undefined);
 
 const clientSession = await connect(serverEndpoint.address);
 await clientSession.opened;
@@ -61,7 +61,7 @@ const sendStream = await clientSession.createUnidirectionalStream({ body: transf
 sendStream.closed.catch(() => {
   // ignore
 });
-strictEqual(sendStream.direction, 'uni');
+assert.strictEqual(sendStream.direction, 'uni');
 const clientWritable = transformStream.writable;
 const writer = clientWritable.getWriter();
 for (const chunk of KNOWN_BYTES_LONG) {

test/parallel/test-quic-server-to-client-bidirectional-echo.mjs

@@ -1,7 +1,7 @@
 // Flags: --experimental-quic --no-warnings
 
 import { hasQuic, skip, mustCall } from '../common/index.mjs';
-import { ok, strictEqual } from 'node:assert';
+import assert from 'node:assert';
 import { readKey } from '../common/fixtures.mjs';
 import { KNOWN_BYTES_LONG, uint8concat, equalUint8Arrays } from '../common/quic/test-helpers.mjs';
 import { TransformStream } from 'node:stream/web';
@@ -19,7 +19,7 @@ const certs = readKey('agent1-cert.pem');
 
 const finished = Promise.withResolvers();
 
-const serverEndpoint = await listen(async (serverSession) => {
+const serverEndpoint = await listen(mustCall(async (serverSession) => {
   await serverSession.opened;
   const transformStream = new TransformStream();
   serverSession.closed.catch((err) => {
@@ -28,7 +28,7 @@ const serverEndpoint = await listen(async (serverSession) => {
   const sendStream = await serverSession.createBidirectionalStream({ body: transformStream.readable });
   // Now compare what we got
 
-  strictEqual(sendStream.direction, 'bidi');
+  assert.strictEqual(sendStream.direction, 'bidi');
   sendStream.closed.catch(() => {
     // ignore
   });
@@ -42,33 +42,33 @@ const serverEndpoint = await listen(async (serverSession) => {
     await writer.ready;
     await writer.close();
   };
-  const readFromStream = async () => {
+  const readFromStream = mustCall(async () => {
     const reader = sendStream.readable.getReader();
     const readChunks = [];
     while (true) {
       const { done, value } = await reader.read();
       if (value) {
-        ok(value instanceof Uint8Array, 'Expects value to be a Uint8Array');
+        assert.ok(value instanceof Uint8Array, 'Expects value to be a Uint8Array');
         readChunks.push(value);
       }
       if (done) break;
     }
     equalUint8Arrays(uint8concat(KNOWN_BYTES_LONG), uint8concat(readChunks));
-  };
+  });
   await Promise.all([writeToStream(), readFromStream()]);
   serverSession.close();
   finished.resolve();
-}, { keys, certs });
+}), { keys, certs });
 
 // The server must have an address to connect to after listen resolves.
-ok(serverEndpoint.address !== undefined);
+assert.ok(serverEndpoint.address !== undefined);
 
 const clientSession = await connect(serverEndpoint.address);
 await clientSession.opened;
 
 
 clientSession.onstream = mustCall(async (stream) => {
-  strictEqual(stream.direction, 'bidi', 'Expects an bidirectional stream');
+  assert.strictEqual(stream.direction, 'bidi');
   stream.closed.catch(() => {
     // ignore
   });

test/parallel/test-quic-server-to-client-unidirectional.mjs

@@ -1,7 +1,7 @@
 // Flags: --experimental-quic --no-warnings
 
 import { hasQuic, skip, mustCall } from '../common/index.mjs';
-import { ok, strictEqual } from 'node:assert';
+import assert from 'node:assert';
 import { readKey } from '../common/fixtures.mjs';
 import { KNOWN_BYTES_LONG, uint8concat, equalUint8Arrays } from '../common/quic/test-helpers.mjs';
 import { TransformStream } from 'node:stream/web';
@@ -21,14 +21,14 @@ const certs = readKey('agent1-cert.pem');
 const clientFinished = Promise.withResolvers();
 
 
-const serverEndpoint = await listen(async (serverSession) => {
+const serverEndpoint = await listen(mustCall(async (serverSession) => {
   await serverSession.opened;
   const transformStream = new TransformStream();
   const sendStream = await serverSession.createUnidirectionalStream({ body: transformStream.readable });
   sendStream.closed.catch(() => {
     // ignore
   });
-  strictEqual(sendStream.direction, 'uni');
+  assert.strictEqual(sendStream.direction, 'uni');
   const serverWritable = transformStream.writable;
   const writer = serverWritable.getWriter();
   for (const chunk of KNOWN_BYTES_LONG) {
@@ -41,21 +41,21 @@ const serverEndpoint = await listen(async (serverSession) => {
     // ignore the error
   });
   serverSession.close();
-}, { keys, certs });
+}), { keys, certs });
 
 // The server must have an address to connect to after listen resolves.
-ok(serverEndpoint.address !== undefined);
+assert.ok(serverEndpoint.address !== undefined);
 
 const clientSession = await connect(serverEndpoint.address);
 
 clientSession.onstream = mustCall(async (stream) => {
-  strictEqual(stream.direction, 'uni', 'Expects an unidirectional stream');
+  assert.strictEqual(stream.direction, 'uni');
   const reader = stream.readable.getReader();
   const readChunks = [];
   while (true) {
     const { done, value } = await reader.read();
     if (value) {
-      ok(value instanceof Uint8Array, 'Expects value to be a Uint8Array');
+      assert.ok(value instanceof Uint8Array, 'Expects value to be a Uint8Array');
       readChunks.push(value);
     }
     if (done) break;