wip: test for clients sharing a socket

* Related #14

[ci skip]

Author: tegefaulkes

tests/concurrency.test.ts

@@ -6,6 +6,7 @@ import Logger, { formatting, LogLevel, StreamHandler } from '@matrixai/logger';
 import QUICServer from '@/QUICServer';
 import { promise } from '@/utils';
 import QUICClient from '@/QUICClient';
+import QUICSocket from '@/QUICSocket';
 import { tlsConfigWithCaArb } from './tlsUtils';
 import { sleep } from './utils';
 import * as testsUtils from './utils';
@@ -138,7 +139,7 @@ describe('Concurrency tests', () => {
     })
     .noShrink() as fc.Arbitrary<ConnectionData>;
   const connectionsArb = fc
-    .array(connectionArb, { minLength: 1, size: 'small' })
+    .array(connectionArb, { minLength: 2, size: 'small' })
     .noShrink() as fc.Arbitrary<Array<ConnectionData>>;
 
   testProp(
@@ -242,7 +243,6 @@ describe('Concurrency tests', () => {
         })();
       } catch (e) {
         logger.error(`test failed with ${e.message}`);
-        console.error(e);
         throw e;
       } finally {
         logger.info('STARTING TEST FINALLY');
@@ -255,6 +255,129 @@ describe('Concurrency tests', () => {
       }
       logger.info('TEST FULLY DONE!');
     },
-    { numRuns: 3, timeout: 50000 },
+    { numRuns: 3 },
+  );
+  testProp.only(
+    'Multiple clients sharing a socket',
+    [tlsConfigWithCaArb, connectionsArb, streamsArb(3)],
+    async (tlsConfigProm, clientDatas, serverStreams) => {
+      const tlsConfig = await tlsConfigProm;
+      const cleanUpHoldProm = promise<void>();
+      const serverProm = (async () => {
+        const server = new QUICServer({
+          crypto,
+          logger: logger.getChild(QUICServer.name),
+          config: {
+            tlsConfig: tlsConfig.tlsConfig,
+            verifyPeer: false,
+          },
+        });
+        const connProms: Array<Promise<void>> = [];
+        server.addEventListener(
+          'connection',
+          async (e: events.QUICServerConnectionEvent) => {
+            const conn = e.detail;
+            const connProm = (async () => {
+              const serverStreamProms: Array<Promise<void>> = [];
+              conn.addEventListener(
+                'stream',
+                (streamEvent: events.QUICConnectionStreamEvent) => {
+                  const stream = streamEvent.detail;
+                  const streamData =
+                    serverStreams[
+                      serverStreamProms.length % serverStreams.length
+                    ];
+                  serverStreamProms.push(handleStreamProm(stream, streamData));
+                },
+              );
+              try {
+                await cleanUpHoldProm.p;
+                await Promise.all(serverStreamProms);
+              } finally {
+                await conn.destroy({ force: true });
+                logger.info(
+                  `server conn result ${JSON.stringify(
+                    await Promise.allSettled(serverStreamProms),
+                  )}`,
+                );
+              }
+            })();
+            connProms.push(connProm);
+          },
+        );
+        await sleep(100);
+        await server.start({
+          host: '127.0.0.1' as Host,
+          port: 55556 as Port,
+        });
+        try {
+          await cleanUpHoldProm.p;
+          await Promise.all(connProms);
+        } finally {
+          await server.stop({ force: true });
+          logger.info(
+            `server result ${JSON.stringify(
+              await Promise.allSettled(connProms),
+            )}`,
+          );
+        }
+      })();
+      // Creating socket
+      const socket = new QUICSocket({
+        crypto,
+        logger: logger.getChild('socket'),
+      });
+      await socket.start({
+        host: '127.0.0.1' as Host,
+      });
+
+      // Creating client activity
+      logger.info('STARTING CLIENTS');
+      const clientProms: Array<Promise<void>> = [];
+      for (const clientData of clientDatas) {
+        const clientProm = sleep(clientData.startDelay)
+          .then(() => {
+            logger.info('STARTING CLIENT');
+            return QUICClient.createQUICClient({
+              host: '127.0.0.1' as Host,
+              port: 55556 as Port,
+              socket,
+              crypto,
+              logger: logger.getChild(QUICClient.name),
+              config: {
+                verifyPeer: false,
+              },
+            });
+          })
+          .then((client) => {
+            return handleClientProm(client, clientData);
+          });
+        clientProms.push(clientProm);
+      }
+      // Wait for running activity to finish, should complete without error
+      logger.info('STARTING TEST');
+      try {
+        await (async () => {
+          await Promise.all(clientProms);
+          // Allow for streams to be negotiated
+          await sleep(200);
+          cleanUpHoldProm.resolveP();
+          await serverProm;
+        })();
+      } catch (e) {
+        logger.error(`test failed with ${e.message}`);
+        throw e;
+      } finally {
+        logger.info('STARTING TEST FINALLY');
+        cleanUpHoldProm.resolveP();
+        logger.info(
+          `test result ${JSON.stringify(
+            await Promise.allSettled([...clientProms, serverProm]),
+          )}`,
+        );
+      }
+      logger.info('TEST FULLY DONE!');
+    },
+    { numRuns: 3 },
   );
 });