serverless-ircd 0.3.0 → 0.5.0

package/packages/aws-adapter/tests/handlers.test.ts

@@ -49,6 +49,11 @@ interface Fixture {
 
 let fx: Fixture | null;
 
+function requireFx(): Fixture {
+  if (!fx) throw new Error('test fixture not initialized');
+  return fx;
+}
+
 async function makeFixture(): Promise<Fixture> {
   if (endpoint === undefined) throw new Error('DYNAMO_ENDPOINT missing');
   const prefix = `h${Date.now()}-${Math.floor(Math.random() * 1e6)}-`;
@@ -91,6 +96,9 @@ async function makeFixture(): Promise<Fixture> {
       motd: MOTD,
       messages: bindMessageStore(SERVER_CONFIG),
       managementApi: mgmt as never,
+      // Bind a REHASH reload source so the $default dispatch path exercises
+      // the configLoader wiring (and an oper's REHASH re-fetches config).
+      configLoader: async () => SERVER_CONFIG,
     },
     cleanup: async () => {
       for (const logical of Object.keys(TABLE_DEFS)) {
@@ -122,12 +130,12 @@ describe.skipIf(!available)('handlers', () => {
     it('returns 200 and persists a Connections row', async () => {
       const res = await dispatch(
         { requestContext: { routeKey: '$connect', connectionId: 'c1' } },
-        fx!.deps,
+        requireFx().deps,
       );
       expect(res.statusCode).toBe(200);
       const probe = new AwsRuntime({
-        dynamo: fx!.client,
-        tables: fx!.tables,
+        dynamo: requireFx().client,
+        tables: requireFx().tables,
         connId: '__probe__',
         handlers: { send: () => {}, disconnect: () => {}, snapshot: () => undefined },
         managementApi: null,
@@ -137,13 +145,37 @@ describe.skipIf(!available)('handlers', () => {
       expect(info?.registration).toBe('pre-registration');
     });
 
+    it('echoes the agreed Sec-WebSocket-Protocol header back on a spec-mode connect', async () => {
+      const res = await dispatch(
+        {
+          requestContext: { routeKey: '$connect', connectionId: 'c-sub' },
+          headers: { 'Sec-WebSocket-Protocol': 'text.ircv3.net' },
+        },
+        requireFx().deps,
+      );
+      expect(res.statusCode).toBe(200);
+      expect(res.headers?.['Sec-WebSocket-Protocol']).toBe('text.ircv3.net');
+    });
+
+    it('omits the Sec-WebSocket-Protocol header on a legacy connect', async () => {
+      const res = await dispatch(
+        { requestContext: { routeKey: '$connect', connectionId: 'c-nosub' } },
+        requireFx().deps,
+      );
+      expect(res.statusCode).toBe(200);
+      expect(res.headers?.['Sec-WebSocket-Protocol']).toBeUndefined();
+    });
+
     it('is idempotent on APIGW retry (same connectionId overwrites)', async () => {
       for (let i = 0; i < 2; i++) {
-        await dispatch({ requestContext: { routeKey: '$connect', connectionId: 'c1' } }, fx!.deps);
+        await dispatch(
+          { requestContext: { routeKey: '$connect', connectionId: 'c1' } },
+          requireFx().deps,
+        );
       }
       const probe = new AwsRuntime({
-        dynamo: fx!.client,
-        tables: fx!.tables,
+        dynamo: requireFx().client,
+        tables: requireFx().tables,
         connId: '__probe__',
         handlers: { send: () => {}, disconnect: () => {}, snapshot: () => undefined },
         managementApi: null,
@@ -153,21 +185,84 @@ describe.skipIf(!available)('handlers', () => {
     });
   });
 
+  // -------------------------------------------------------------------------
+  // $connect admission gate (max-clients cap)
+  // -------------------------------------------------------------------------
+
+  describe('$connect admission gate', () => {
+    it('rejects the connection that exceeds the maxClients cap', async () => {
+      const capped: HandlerDeps = {
+        ...requireFx().deps,
+        serverConfig: { ...SERVER_CONFIG, maxClients: 2 },
+      };
+      const r1 = await dispatch(
+        { requestContext: { routeKey: '$connect', connectionId: 'a1' } },
+        capped,
+      );
+      const r2 = await dispatch(
+        { requestContext: { routeKey: '$connect', connectionId: 'a2' } },
+        capped,
+      );
+      const r3 = await dispatch(
+        { requestContext: { routeKey: '$connect', connectionId: 'a3' } },
+        capped,
+      );
+      expect(r1.statusCode).toBe(200);
+      expect(r2.statusCode).toBe(200);
+      expect(r3.statusCode).toBe(429);
+
+      const probe = new AwsRuntime({
+        dynamo: requireFx().client,
+        tables: requireFx().tables,
+        connId: '__probe__',
+        handlers: { send: () => {}, disconnect: () => {}, snapshot: () => undefined },
+        managementApi: null,
+      });
+      expect((await probe.getConnectionInfo('a1'))?.id).toBe('a1');
+      expect((await probe.getConnectionInfo('a2'))?.id).toBe('a2');
+      // The over-cap connection must NOT be recorded.
+      expect(await probe.getConnectionInfo('a3')).toBeNull();
+    });
+
+    it('admits a connection when the table is below the cap', async () => {
+      const capped: HandlerDeps = {
+        ...requireFx().deps,
+        serverConfig: { ...SERVER_CONFIG, maxClients: 5 },
+      };
+      const res = await dispatch(
+        { requestContext: { routeKey: '$connect', connectionId: 'b1' } },
+        capped,
+      );
+      expect(res.statusCode).toBe(200);
+      const probe = new AwsRuntime({
+        dynamo: requireFx().client,
+        tables: requireFx().tables,
+        connId: '__probe__',
+        handlers: { send: () => {}, disconnect: () => {}, snapshot: () => undefined },
+        managementApi: null,
+      });
+      expect((await probe.getConnectionInfo('b1'))?.id).toBe('b1');
+    });
+  });
+
   // -------------------------------------------------------------------------
   // $disconnect
   // -------------------------------------------------------------------------
 
   describe('$disconnect', () => {
     it('returns 200 and deletes the Connections row', async () => {
-      await dispatch({ requestContext: { routeKey: '$connect', connectionId: 'c1' } }, fx!.deps);
+      await dispatch(
+        { requestContext: { routeKey: '$connect', connectionId: 'c1' } },
+        requireFx().deps,
+      );
       const res = await dispatch(
         { requestContext: { routeKey: '$disconnect', connectionId: 'c1' } },
-        fx!.deps,
+        requireFx().deps,
       );
       expect(res.statusCode).toBe(200);
       const probe = new AwsRuntime({
-        dynamo: fx!.client,
-        tables: fx!.tables,
+        dynamo: requireFx().client,
+        tables: requireFx().tables,
         connId: '__probe__',
         handlers: { send: () => {}, disconnect: () => {}, snapshot: () => undefined },
         managementApi: null,
@@ -178,33 +273,39 @@ describe.skipIf(!available)('handlers', () => {
     it('returns 200 even when the connection was never seen', async () => {
       const res = await dispatch(
         { requestContext: { routeKey: '$disconnect', connectionId: 'never' } },
-        fx!.deps,
+        requireFx().deps,
       );
       expect(res.statusCode).toBe(200);
     });
 
     it('releases the nick on disconnect', async () => {
       // Connect + register alice.
-      await dispatch({ requestContext: { routeKey: '$connect', connectionId: 'c1' } }, fx!.deps);
+      await dispatch(
+        { requestContext: { routeKey: '$connect', connectionId: 'c1' } },
+        requireFx().deps,
+      );
       await dispatch(
         {
           requestContext: { routeKey: '$default', connectionId: 'c1' },
           body: 'NICK alice\r\n',
         },
-        fx!.deps,
+        requireFx().deps,
       );
       await dispatch(
         {
           requestContext: { routeKey: '$default', connectionId: 'c1' },
           body: 'USER alice 0 * :Alice\r\n',
         },
-        fx!.deps,
+        requireFx().deps,
       );
       // Disconnect.
-      await dispatch({ requestContext: { routeKey: '$disconnect', connectionId: 'c1' } }, fx!.deps);
+      await dispatch(
+        { requestContext: { routeKey: '$disconnect', connectionId: 'c1' } },
+        requireFx().deps,
+      );
       const probe = new AwsRuntime({
-        dynamo: fx!.client,
-        tables: fx!.tables,
+        dynamo: requireFx().client,
+        tables: requireFx().tables,
         connId: '__probe__',
         handlers: { send: () => {}, disconnect: () => {}, snapshot: () => undefined },
         managementApi: null,
@@ -224,7 +325,7 @@ describe.skipIf(!available)('handlers', () => {
           requestContext: { routeKey: '$default', connectionId: 'ghost' },
           body: 'PING :tok\r\n',
         },
-        fx!.deps,
+        requireFx().deps,
       );
       expect(res.statusCode).toBe(410);
     });
@@ -234,23 +335,26 @@ describe.skipIf(!available)('handlers', () => {
       const event = {
         requestContext: { routeKey: '$default', connectionId: 'c1' },
       } as never;
-      const res = await dispatch(event, fx!.deps);
+      const res = await dispatch(event, requireFx().deps);
       expect(res.statusCode).toBe(400);
     });
 
     it('runs a NICK + USER frame and emits the welcome block', async () => {
-      await dispatch({ requestContext: { routeKey: '$connect', connectionId: 'c1' } }, fx!.deps);
-      fx!.mgmt.register('c1', () => {});
+      await dispatch(
+        { requestContext: { routeKey: '$connect', connectionId: 'c1' } },
+        requireFx().deps,
+      );
+      requireFx().mgmt.register('c1', () => {});
       await dispatch(
         {
           requestContext: { routeKey: '$default', connectionId: 'c1' },
           body: 'NICK alice\r\nUSER alice 0 * :Alice\r\n',
         },
-        fx!.deps,
+        requireFx().deps,
       );
       const probe = new AwsRuntime({
-        dynamo: fx!.client,
-        tables: fx!.tables,
+        dynamo: requireFx().client,
+        tables: requireFx().tables,
         connId: '__probe__',
         handlers: { send: () => {}, disconnect: () => {}, snapshot: () => undefined },
         managementApi: null,
@@ -261,9 +365,12 @@ describe.skipIf(!available)('handlers', () => {
     });
 
     it('echoes outbound lines back to the caller via the management API', async () => {
-      await dispatch({ requestContext: { routeKey: '$connect', connectionId: 'c1' } }, fx!.deps);
+      await dispatch(
+        { requestContext: { routeKey: '$connect', connectionId: 'c1' } },
+        requireFx().deps,
+      );
       const sink: string[] = [];
-      fx!.mgmt.register('c1', (data) => {
+      requireFx().mgmt.register('c1', (data) => {
         for (const line of data.split('\r\n')) {
           if (line.length > 0) sink.push(line);
         }
@@ -273,31 +380,123 @@ describe.skipIf(!available)('handlers', () => {
           requestContext: { routeKey: '$default', connectionId: 'c1' },
           body: 'PING :tok\r\n',
         },
-        fx!.deps,
+        requireFx().deps,
       );
       expect(sink).toContain('PONG :tok');
     });
 
+    it('delivers each outbound line as its own postToConnection for a spec-mode connection', async () => {
+      await dispatch(
+        {
+          requestContext: { routeKey: '$connect', connectionId: 'spec1' },
+          headers: { 'Sec-WebSocket-Protocol': 'text.ircv3.net' },
+        },
+        requireFx().deps,
+      );
+      const calls: string[] = [];
+      requireFx().mgmt.register('spec1', (data) => {
+        calls.push(data);
+      });
+      // Spec clients send exactly one IRC message per WebSocket frame.
+      await dispatch(
+        {
+          requestContext: { routeKey: '$default', connectionId: 'spec1' },
+          body: 'NICK bob\r\n',
+        },
+        requireFx().deps,
+      );
+      await dispatch(
+        {
+          requestContext: { routeKey: '$default', connectionId: 'spec1' },
+          body: 'USER bob 0 * :Bob\r\n',
+        },
+        requireFx().deps,
+      );
+      // The welcome block is multiple IRC lines; the IRCv3 spec contract
+      // sends exactly one line per WebSocket message (no trailing CRLF).
+      expect(calls.length).toBeGreaterThan(1);
+      for (const data of calls) {
+        expect(data).not.toContain('\r\n');
+      }
+      expect(calls.some((d) => d.includes(' 001 '))).toBe(true);
+    });
+
+    it('delivers one postToConnection per line for a binary.ircv3.net connection', async () => {
+      await dispatch(
+        {
+          requestContext: { routeKey: '$connect', connectionId: 'spec2' },
+          headers: { 'Sec-WebSocket-Protocol': 'binary.ircv3.net' },
+        },
+        requireFx().deps,
+      );
+      const calls: string[] = [];
+      requireFx().mgmt.register('spec2', (data) => {
+        calls.push(data);
+      });
+      await dispatch(
+        {
+          requestContext: { routeKey: '$default', connectionId: 'spec2' },
+          body: 'NICK binbob\r\n',
+        },
+        requireFx().deps,
+      );
+      await dispatch(
+        {
+          requestContext: { routeKey: '$default', connectionId: 'spec2' },
+          body: 'USER binbob 0 * :BinBob\r\n',
+        },
+        requireFx().deps,
+      );
+      expect(calls.length).toBeGreaterThan(1);
+      for (const data of calls) {
+        expect(data).not.toContain('\r\n');
+      }
+    });
+
+    it('batches outbound lines into a single postToConnection for a legacy connection', async () => {
+      await dispatch(
+        { requestContext: { routeKey: '$connect', connectionId: 'leg1' } },
+        requireFx().deps,
+      );
+      const calls: string[] = [];
+      requireFx().mgmt.register('leg1', (data) => {
+        calls.push(data);
+      });
+      await dispatch(
+        {
+          requestContext: { routeKey: '$default', connectionId: 'leg1' },
+          body: 'NICK carol\r\nUSER carol 0 * :Carol\r\n',
+        },
+        requireFx().deps,
+      );
+      expect(calls.length).toBe(1);
+      expect(calls[0]).toContain('\r\n');
+      expect(calls[0]).toContain(' 001 ');
+    });
+
     it('persists joined channels across $default invocations', async () => {
-      await dispatch({ requestContext: { routeKey: '$connect', connectionId: 'c1' } }, fx!.deps);
-      fx!.mgmt.register('c1', () => {});
+      await dispatch(
+        { requestContext: { routeKey: '$connect', connectionId: 'c1' } },
+        requireFx().deps,
+      );
+      requireFx().mgmt.register('c1', () => {});
       await dispatch(
         {
           requestContext: { routeKey: '$default', connectionId: 'c1' },
           body: 'NICK alice\r\nUSER alice 0 * :Alice\r\n',
         },
-        fx!.deps,
+        requireFx().deps,
       );
       await dispatch(
         {
           requestContext: { routeKey: '$default', connectionId: 'c1' },
           body: 'JOIN #persist\r\n',
         },
-        fx!.deps,
+        requireFx().deps,
       );
       const probe = new AwsRuntime({
-        dynamo: fx!.client,
-        tables: fx!.tables,
+        dynamo: requireFx().client,
+        tables: requireFx().tables,
         connId: '__probe__',
         handlers: { send: () => {}, disconnect: () => {}, snapshot: () => undefined },
         managementApi: null,
@@ -308,26 +507,32 @@ describe.skipIf(!available)('handlers', () => {
 
     it('rebuilds an existing channel roster via refreshChannel when a second client JOINs', async () => {
       // First connection registers + JOINs.
-      await dispatch({ requestContext: { routeKey: '$connect', connectionId: 'c1' } }, fx!.deps);
-      fx!.mgmt.register('c1', () => {});
+      await dispatch(
+        { requestContext: { routeKey: '$connect', connectionId: 'c1' } },
+        requireFx().deps,
+      );
+      requireFx().mgmt.register('c1', () => {});
       await dispatch(
         {
           requestContext: { routeKey: '$default', connectionId: 'c1' },
           body: 'NICK alice\r\nUSER alice 0 * :Alice\r\n',
         },
-        fx!.deps,
+        requireFx().deps,
       );
       await dispatch(
         {
           requestContext: { routeKey: '$default', connectionId: 'c1' },
           body: 'JOIN #room\r\n',
         },
-        fx!.deps,
+        requireFx().deps,
       );
       // Second connection registers + JOINs the SAME channel.
-      await dispatch({ requestContext: { routeKey: '$connect', connectionId: 'c2' } }, fx!.deps);
+      await dispatch(
+        { requestContext: { routeKey: '$connect', connectionId: 'c2' } },
+        requireFx().deps,
+      );
       const c2sink: string[] = [];
-      fx!.mgmt.register('c2', (data) => {
+      requireFx().mgmt.register('c2', (data) => {
         for (const line of data.split('\r\n')) {
           if (line.length > 0) c2sink.push(line);
         }
@@ -337,14 +542,14 @@ describe.skipIf(!available)('handlers', () => {
           requestContext: { routeKey: '$default', connectionId: 'c2' },
           body: 'NICK bob\r\nUSER bob 0 * :Bob\r\n',
         },
-        fx!.deps,
+        requireFx().deps,
       );
       await dispatch(
         {
           requestContext: { routeKey: '$default', connectionId: 'c2' },
           body: 'JOIN #room\r\n',
         },
-        fx!.deps,
+        requireFx().deps,
       );
       // The 353 RPL_NAMREPLY c2 receives must list BOTH alice and bob —
       // proving that the actor's `refreshChannel` populated the cache
@@ -356,9 +561,12 @@ describe.skipIf(!available)('handlers', () => {
     });
 
     it('records a PRIVMSG and replays it via CHATHISTORY LATEST in a BATCH', async () => {
-      await dispatch({ requestContext: { routeKey: '$connect', connectionId: 'c1' } }, fx!.deps);
+      await dispatch(
+        { requestContext: { routeKey: '$connect', connectionId: 'c1' } },
+        requireFx().deps,
+      );
       const sink: string[] = [];
-      fx!.mgmt.register('c1', (data) => {
+      requireFx().mgmt.register('c1', (data) => {
         for (const line of data.split('\r\n')) {
           if (line.length > 0) sink.push(line);
         }
@@ -368,7 +576,7 @@ describe.skipIf(!available)('handlers', () => {
           requestContext: { routeKey: '$default', connectionId: 'c1' },
           body: 'CAP REQ :draft/chathistory server-time message-tags batch\r\nNICK aws-alice\r\nUSER aws-alice 0 * :Alice\r\nCAP END\r\nJOIN #aws-chathist\r\n',
         },
-        fx!.deps,
+        requireFx().deps,
       );
       sink.length = 0;
       await dispatch(
@@ -376,7 +584,7 @@ describe.skipIf(!available)('handlers', () => {
           requestContext: { routeKey: '$default', connectionId: 'c1' },
           body: 'PRIVMSG #aws-chathist :hello from aws\r\nCHATHISTORY LATEST #aws-chathist * 10\r\n',
         },
-        fx!.deps,
+        requireFx().deps,
       );
       const batchOpen = sink.find((l) => /^BATCH \+\S+ chathistory #aws-chathist/.test(l));
       expect(batchOpen).toBeDefined();
@@ -385,16 +593,19 @@ describe.skipIf(!available)('handlers', () => {
     });
 
     it('completes SASL PLAIN with 900/903 when an AccountStore is bound', async () => {
-      await dispatch({ requestContext: { routeKey: '$connect', connectionId: 'c1' } }, fx!.deps);
+      await dispatch(
+        { requestContext: { routeKey: '$connect', connectionId: 'c1' } },
+        requireFx().deps,
+      );
       const sink: string[] = [];
-      fx!.mgmt.register('c1', (data) => {
+      requireFx().mgmt.register('c1', (data) => {
         for (const line of data.split('\r\n')) {
           if (line.length > 0) sink.push(line);
         }
       });
       // Swap in a deps with a seeded AccountStore for this dispatch.
       const depsWithAccounts: HandlerDeps = {
-        ...fx!.deps,
+        ...requireFx().deps,
         accounts: new InMemoryAccountStore([{ username: 'aws-sasl', password: 's3cret' }]),
       };
       const payload = Buffer.from('\0aws-sasl\0s3cret', 'utf8').toString('base64');
@@ -411,9 +622,12 @@ describe.skipIf(!available)('handlers', () => {
     });
 
     it('emits 904 when no AccountStore is bound (regression guard)', async () => {
-      await dispatch({ requestContext: { routeKey: '$connect', connectionId: 'c2' } }, fx!.deps);
+      await dispatch(
+        { requestContext: { routeKey: '$connect', connectionId: 'c2' } },
+        requireFx().deps,
+      );
       const sink: string[] = [];
-      fx!.mgmt.register('c2', (data) => {
+      requireFx().mgmt.register('c2', (data) => {
         for (const line of data.split('\r\n')) {
           if (line.length > 0) sink.push(line);
         }
@@ -424,7 +638,7 @@ describe.skipIf(!available)('handlers', () => {
           requestContext: { routeKey: '$default', connectionId: 'c2' },
           body: `CAP REQ :sasl\r\nAUTHENTICATE PLAIN\r\nAUTHENTICATE ${payload}\r\n`,
         },
-        fx!.deps,
+        requireFx().deps,
       );
       expect(sink.some((l) => l.includes(' 904 '))).toBe(true);
     });
@@ -436,6 +650,41 @@ describe.skipIf(!available)('handlers', () => {
       // The 500-branch is covered indirectly by GoneException tests.
       expect(true).toBe(true);
     });
+
+    it('runs an oper REHASH through the bound configLoader and emits 382', async () => {
+      await dispatch(
+        { requestContext: { routeKey: '$connect', connectionId: 'rh1' } },
+        requireFx().deps,
+      );
+      const sink: string[] = [];
+      requireFx().mgmt.register('rh1', (data) => {
+        for (const line of data.split('\r\n')) {
+          if (line.length > 0) sink.push(line);
+        }
+      });
+      // Seed oper creds + a reload source so OPER then REHASH both succeed.
+      const depsWithOper: HandlerDeps = {
+        ...requireFx().deps,
+        serverConfig: { ...SERVER_CONFIG, operCreds: [{ user: 'alice', password: 's3cret' }] },
+        configLoader: async () => ({
+          ...SERVER_CONFIG,
+          operCreds: [{ user: 'alice', password: 'rotated' }],
+        }),
+      };
+      await dispatch(
+        {
+          requestContext: { routeKey: '$default', connectionId: 'rh1' },
+          body: 'NICK alice\r\nUSER alice 0 * :Alice\r\nOPER alice s3cret\r\nREHASH\r\n',
+        },
+        depsWithOper,
+      );
+
+      // 381 (oper) + 382 (rehashing from the Secrets Manager source) emitted.
+      expect(sink.some((l) => l.includes(' 381 '))).toBe(true);
+      expect(sink.some((l) => l.includes(' 382 ') && l.includes('Secrets Manager'))).toBe(true);
+      // Never a 421 for REHASH.
+      expect(sink.some((l) => l.includes(' 421 ') && l.includes('REHASH'))).toBe(false);
+    });
   });
 
   // -------------------------------------------------------------------------
@@ -446,7 +695,7 @@ describe.skipIf(!available)('handlers', () => {
     it('returns 200 (APIGW only forwards the three known routes)', async () => {
       const res = await dispatch(
         { requestContext: { routeKey: '$custom', connectionId: 'c1' } },
-        fx!.deps,
+        requireFx().deps,
       );
       expect(res.statusCode).toBe(200);
     });
@@ -462,7 +711,7 @@ class LocalPostToConnection implements PostToConnection {
   register(connId: string, sink: (data: string) => void): void {
     this.sinks.set(connId, sink);
   }
-  async postToConnection(input: { ConnectionId: string; Data: string }): Promise<{}> {
+  async postToConnection(input: { ConnectionId: string; Data: string }): Promise<unknown> {
     const sink = this.sinks.get(input.ConnectionId);
     if (sink !== undefined) sink(input.Data);
     return {};