wip: test for two sets of servers and clients sharing sockets

* Related #14

[ci skip]

Author: tegefaulkes

tests/concurrency.test.ts

@@ -1,6 +1,7 @@
 import type * as events from '@/events';
 import type QUICStream from '@/QUICStream';
 import type { Crypto, Host, Port } from '@';
+import type { TlsConfig } from '@/config';
 import { fc, testProp } from '@fast-check/jest';
 import Logger, { formatting, LogLevel, StreamHandler } from '@matrixai/logger';
 import QUICServer from '@/QUICServer';
@@ -133,7 +134,7 @@ describe('Concurrency tests', () => {
     fc.array(streamArb, { size: 'small', minLength }).noShrink();
   const connectionArb = fc
     .record({
-      streams: streamsArb(),
+      streams: streamsArb(1),
       startDelay: fc.integer({ min: 0, max: 50 }),
       endDelay: fc.integer({ min: 0, max: 50 }),
     })
@@ -257,7 +258,7 @@ describe('Concurrency tests', () => {
     },
     { numRuns: 3 },
   );
-  testProp.only(
+  testProp(
     'Multiple clients sharing a socket',
     [tlsConfigWithCaArb, connectionsArb, streamsArb(3)],
     async (tlsConfigProm, clientDatas, serverStreams) => {
@@ -376,8 +377,216 @@ describe('Concurrency tests', () => {
           )}`,
         );
       }
+      await socket.stop();
       logger.info('TEST FULLY DONE!');
     },
     { numRuns: 3 },
   );
+  const spawnServer = async ({
+    socket,
+    port,
+    cleanUpHoldProm,
+    tlsConfig,
+    serverStreams,
+  }: {
+    socket: QUICSocket | undefined;
+    port: Port | undefined;
+    cleanUpHoldProm: Promise<void>;
+    tlsConfig: TlsConfig;
+    serverStreams: Array<StreamData>;
+  }) => {
+    const server = new QUICServer({
+      crypto,
+      socket,
+      logger: logger.getChild(QUICServer.name),
+      config: {
+        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;
+            await Promise.race([
+              Promise.all(serverStreamProms),
+              sleep(1000).then(() => {
+                throw Error('Streams hanging');
+              }),
+            ]);
+          } 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,
+    });
+    try {
+      await cleanUpHoldProm;
+      await Promise.all(connProms);
+    } finally {
+      await server.stop({ force: true });
+      logger.info(
+        `server result ${JSON.stringify(await Promise.allSettled(connProms))}`,
+      );
+    }
+  };
+  jest.setTimeout(100000);
+  testProp.only(
+    'Multiple clients sharing a socket with a server',
+    [
+      tlsConfigWithCaArb,
+      tlsConfigWithCaArb,
+      connectionsArb,
+      connectionsArb,
+      streamsArb(3),
+      streamsArb(3),
+    ],
+    async (
+      tlsConfigProm1,
+      tlsConfigProm2,
+      clientDatas1,
+      clientDatas2,
+      serverStreams1,
+      serverStreams2,
+    ) => {
+      const tlsConfig1 = await tlsConfigProm1;
+      const tlsConfig2 = await tlsConfigProm2;
+      const cleanUpHoldProm = promise<void>();
+      // Creating socket
+      const socket1 = new QUICSocket({
+        crypto,
+        logger: logger.getChild('socket'),
+      });
+      const socket2 = new QUICSocket({
+        crypto,
+        logger: logger.getChild('socket'),
+      });
+      await socket1.start({
+        host: '127.0.0.1' as Host,
+      });
+      await socket2.start({
+        host: '127.0.0.1' as Host,
+      });
+
+      const serverProm1 = spawnServer({
+        cleanUpHoldProm: cleanUpHoldProm.p,
+        port: undefined,
+        serverStreams: serverStreams1,
+        socket: socket1,
+        tlsConfig: tlsConfig1.tlsConfig,
+      });
+      const serverProm2 = spawnServer({
+        cleanUpHoldProm: cleanUpHoldProm.p,
+        port: undefined,
+        serverStreams: serverStreams2,
+        socket: socket2,
+        tlsConfig: tlsConfig2.tlsConfig,
+      });
+
+      // Creating client activity
+      logger.info('STARTING CLIENTS');
+      const clientProms1: Array<Promise<void>> = [];
+      const clientProms2: Array<Promise<void>> = [];
+      for (const clientData of clientDatas1) {
+        const clientProm = sleep(clientData.startDelay)
+          .then(() => {
+            logger.info('STARTING CLIENT');
+            return QUICClient.createQUICClient({
+              host: '127.0.0.1' as Host,
+              port: socket2.port,
+              socket: socket1,
+              crypto,
+              logger: logger.getChild(QUICClient.name),
+              config: {
+                verifyPeer: false,
+              },
+            });
+          })
+          .then((client) => {
+            return handleClientProm(client, clientData);
+          });
+        clientProms1.push(clientProm);
+      }
+      for (const clientData of clientDatas2) {
+        const clientProm = sleep(clientData.startDelay)
+          .then(() => {
+            logger.info('STARTING CLIENT');
+            return QUICClient.createQUICClient({
+              host: '127.0.0.1' as Host,
+              port: socket1.port,
+              socket: socket2,
+              crypto,
+              logger: logger.getChild(QUICClient.name),
+              config: {
+                verifyPeer: false,
+              },
+            });
+          })
+          .then((client) => {
+            return handleClientProm(client, clientData);
+          });
+        clientProms2.push(clientProm);
+      }
+      // Wait for running activity to finish, should complete without error
+      logger.info('STARTING TEST');
+      try {
+        await (async () => {
+          await Promise.all([
+            Promise.all(clientProms1),
+            Promise.all(clientProms2),
+          ]);
+          // Allow for streams to be negotiated
+          await sleep(200);
+          cleanUpHoldProm.resolveP();
+          await serverProm1;
+          await serverProm2;
+        })();
+      } 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([
+              ...clientProms1,
+              ...clientProms2,
+              serverProm1,
+              serverProm2,
+            ]),
+          )}`,
+        );
+      }
+      await socket1.stop();
+      await socket2.stop();
+      logger.info('TEST FULLY DONE!');
+    },
+    { numRuns: 1 },
+  );
 });