quic: Fix linting

Author: martenrichter

src/dataqueue/queue.cc

@@ -1423,14 +1423,17 @@ bool DataQueueFeeder::HasInstance(Environment* env, Local<Value> object) {
   return GetConstructorTemplate(env)->HasInstance(object);
 }
 
-Local<FunctionTemplate> DataQueueFeeder::GetConstructorTemplate(Environment* env) {
+Local<FunctionTemplate> DataQueueFeeder::GetConstructorTemplate(
+  Environment* env
+) {
   Local<FunctionTemplate> tmpl = env->data_queue_feeder_constructor_template();
   if (tmpl.IsEmpty()) {
     Isolate* isolate = env->isolate();
-    tmpl = NewFunctionTemplate(isolate, DataQueueFeeder::New); // second argument was nullptr
+    tmpl = NewFunctionTemplate(isolate, DataQueueFeeder::New);
     tmpl->InstanceTemplate()->SetInternalFieldCount(
         BaseObject::kInternalFieldCount);
-    tmpl->SetClassName(FIXED_ONE_BYTE_STRING(env->isolate(), "DataQueueFeeder"));
+    tmpl->SetClassName(FIXED_ONE_BYTE_STRING(env->isolate(),
+      "DataQueueFeeder"));
     tmpl->Inherit(AsyncWrap::GetConstructorTemplate(env));
     env->set_data_queue_feeder_constructor_template(tmpl);
     SetProtoMethod(isolate, tmpl, "error", Error);
@@ -1468,7 +1471,11 @@ void DataQueueFeeder::RegisterExternalReferences(
 
 }  // namespace node
 
-NODE_BINDING_CONTEXT_AWARE_INTERNAL(dataqueuefeeder,
-                                    node::DataQueueFeeder::CreatePerContextProperties)
-NODE_BINDING_PER_ISOLATE_INIT(dataqueuefeeder, node::DataQueueFeeder::CreatePerIsolateProperties)
-NODE_BINDING_EXTERNAL_REFERENCE(dataqueuefeeder, node::DataQueueFeeder::RegisterExternalReferences)
+NODE_BINDING_CONTEXT_AWARE_INTERNAL(
+  dataqueuefeeder,
+  node::DataQueueFeeder::CreatePerContextProperties
+)
+NODE_BINDING_PER_ISOLATE_INIT(dataqueuefeeder,
+  node::DataQueueFeeder::CreatePerIsolateProperties)
+NODE_BINDING_EXTERNAL_REFERENCE(dataqueuefeeder,
+  node::DataQueueFeeder::RegisterExternalReferences)

src/env_properties.h

@@ -394,7 +394,7 @@
   V(contextify_wrapper_template, v8::ObjectTemplate)                           \
   V(cpu_usage_template, v8::DictionaryTemplate)                                \
   V(crypto_key_object_handle_constructor, v8::FunctionTemplate)                \
-  V(data_queue_feeder_constructor_template, v8::FunctionTemplate)                           \
+  V(data_queue_feeder_constructor_template, v8::FunctionTemplate)              \
   V(env_proxy_template, v8::ObjectTemplate)                                    \
   V(env_proxy_ctor_template, v8::FunctionTemplate)                             \
   V(ephemeral_key_template, v8::DictionaryTemplate)                            \

src/node_binding.cc

@@ -47,7 +47,7 @@
   V(constants)                                                                 \
   V(contextify)                                                                \
   V(credentials)                                                               \
-  V(dataqueuefeeder)                                                            \
+  V(dataqueuefeeder)                                                           \
   V(encoding_binding)                                                          \
   V(errors)                                                                    \
   V(fs)                                                                        \

test/common/quic/test-helpers.mjs

@@ -1,9 +1,9 @@
-import assert from "node:assert";
+import assert from 'node:assert';
 // start demo data
 // taken from @fails-components/webtransport tests
 // by the original author
 function createBytesChunk(length) {
-  assert(length % 4 === 0);
+  assert.strictEqual(length % 4, 0);
   const workArray = new Array(length / 2);
   for (let i = 0; i < length / 4; i++) {
     workArray[2 * i + 1] = length % 0xffff;
@@ -48,8 +48,18 @@ export function uint8concat(arrays) {
 }
 
 export function equalUint8Arrays(arr1, arr2) {
-  assert.ok(arr1.byteLength === arr2.byteLength, "Array content differs in length " + arr1.byteLength + " vs. " + arr2.byteLength);
+  assert.ok(arr1.byteLength === arr2.byteLength,
+            'Array content differs in length ' +
+            arr1.byteLength +
+            ' vs. ' +
+            arr2.byteLength);
   for (let i = 0; i < arr1.byteLength; i++) {
-    assert.ok(arr1[i] === arr2[i], "Array content differs at " + i + " arr1: " + arr1[i] + " arr2: " + arr2[i]);
+    assert.ok(arr1[i] === arr2[i],
+              'Array content differs at ' +
+              i +
+              ' arr1: ' +
+              arr1[i] +
+              ' arr2: ' +
+              arr2[i]);
   }
 }

test/parallel/test-dataqueuefeeder.mjs

@@ -1,4 +1,5 @@
 // Flags: --expose-internals --no-warnings
+import {} from '../common/index.mjs';
 import {
   rejects,
 } from 'node:assert';

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

@@ -0,0 +1,84 @@
+// Flags: --experimental-quic --no-warnings
+
+import { hasQuic, skip, mustCall } from '../common/index.mjs';
+import { ok, strictEqual, deepStrictEqual } from 'node:assert';
+import { readKey } from '../common/fixtures.mjs';
+import { KNOWN_BYTES_LONG, uint8concat } from '../common/quic/test-helpers.mjs';
+import { TransformStream } from 'node:stream/web';
+
+if (!hasQuic) {
+  skip('QUIC is not enabled');
+}
+
+// Import after the hasQuic check
+const { listen, connect } = await import('node:quic');
+const { createPrivateKey } = await import('node:crypto');
+
+const keys = createPrivateKey(readKey('agent1-key.pem'));
+const certs = readKey('agent1-cert.pem');
+
+const finished = Promise.withResolvers();
+
+const serverEndpoint = await listen(async (serverSession) => {
+  serverSession.onstream = mustCall(async (stream) => {
+    strictEqual(stream.direction, 'bidi', 'Expects an bidirectional stream');
+    stream.closed.catch(() => {
+      // ignore
+    });
+    const serverTransformStream = new TransformStream();
+    stream.setOutbound(serverTransformStream.readable);
+    await stream.readable.pipeTo(serverTransformStream.writable);
+
+  }, 1);
+
+  await finished.promise;
+  serverSession.closed.catch((err) => {
+    // ignore the error
+  });
+  serverSession.close();
+}, { keys, certs });
+
+// The server must have an address to connect to after listen resolves.
+ok(serverEndpoint.address !== undefined);
+
+const clientSession = await connect(serverEndpoint.address);
+await clientSession.opened;
+
+
+const transformStream = new TransformStream();
+const sendStream = await clientSession.createBidirectionalStream({ body: transformStream.readable });
+sendStream.closed.catch(() => {
+  // ignore
+});
+strictEqual(sendStream.direction, 'bidi');
+const writeToStream = async () => {
+  const clientWritable = transformStream.writable;
+  const writer = clientWritable.getWriter();
+  for (const chunk of KNOWN_BYTES_LONG) {
+    await writer.ready;
+    await writer.write(chunk);
+  }
+  await writer.ready;
+  await writer.close();
+};
+const readFromStream = 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');
+      readChunks.push(value);
+    }
+    if (done) break;
+  }
+  // Now compare what we got
+  deepStrictEqual(uint8concat(KNOWN_BYTES_LONG), uint8concat(readChunks));
+};
+
+await Promise.all([writeToStream(), readFromStream()]);
+clientSession.closed.catch((err) => {
+  // ignore the error
+});
+clientSession.close();
+finished.resolve();