serverless-ircd 0.4.0 → 0.6.0

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

@@ -8,11 +8,11 @@
 
 import { CreateTableCommand, DeleteTableCommand } from '@aws-sdk/client-dynamodb';
 import {
-  DEFAULT_SERVER_CONFIG,
   InMemoryAccountStore,
   type ParsedServerConfig,
   StaticMotdProvider,
 } from '@serverless-ircd/irc-core';
+import { makeTestServerConfig } from '@serverless-ircd/irc-test-support';
 import { afterEach, beforeEach, describe, expect, it } from 'vitest';
 import { AwsRuntime } from '../src/aws-runtime.js';
 import type { PostToConnection } from '../src/aws-runtime.js';
@@ -30,12 +30,11 @@ import type { TablesConfig } from '../src/tables.js';
 const available = process.env.DDB_AVAILABLE === '1';
 const endpoint = process.env.DYNAMO_ENDPOINT;
 
-const SERVER_CONFIG: ParsedServerConfig = {
-  ...DEFAULT_SERVER_CONFIG,
+const SERVER_CONFIG: ParsedServerConfig = makeTestServerConfig({
   serverName: 'irc.example.com',
   networkName: 'ExampleNet',
   motdLines: ['Welcome to the test IRC server.'],
-};
+});
 
 const MOTD = new StaticMotdProvider(SERVER_CONFIG.motdLines);
 
@@ -96,6 +95,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)) {
@@ -142,6 +144,27 @@ 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(
@@ -361,6 +384,95 @@ describe.skipIf(!available)('handlers', () => {
       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' } },
@@ -537,6 +649,128 @@ 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);
+    });
+
+    it('refreshChannel updates cached state when a channel becomes empty (no topic)', async () => {
+      // After the last member PARTs, the channel snapshot returns 0
+      // members but the meta row persists. The next frame that
+      // references the channel triggers refreshChannel, which must
+      // take the empty-members + existing-cache path without throwing
+      // and leave the cache usable for subsequent joins.
+      await dispatch(
+        { requestContext: { routeKey: '$connect', connectionId: 'e1' } },
+        requireFx().deps,
+      );
+      requireFx().mgmt.register('e1', () => {});
+      await dispatch(
+        {
+          requestContext: { routeKey: '$default', connectionId: 'e1' },
+          body: 'NICK alice\r\nUSER alice 0 * :Alice\r\nJOIN #empty\r\n',
+        },
+        requireFx().deps,
+      );
+      // PART drops the member count to 0 while the meta row survives.
+      await dispatch(
+        {
+          requestContext: { routeKey: '$default', connectionId: 'e1' },
+          body: 'PART #empty\r\n',
+        },
+        requireFx().deps,
+      );
+      // Re-JOIN forces prefetchChannelState → refreshChannel, hitting
+      // the empty-members + existing-cache branch. The JOIN must
+      // succeed (no exception), proving the cache is still consistent.
+      const res = await dispatch(
+        {
+          requestContext: { routeKey: '$default', connectionId: 'e1' },
+          body: 'JOIN #empty\r\n',
+        },
+        requireFx().deps,
+      );
+      expect(res.statusCode).toBe(200);
+    });
+
+    it('refreshChannel preserves an existing topic when the snapshot has one', async () => {
+      // Same shape as the previous test, but a TOPIC is set before the
+      // PART so the snapshot's `topic` field is defined. This exercises
+      // the `if (snap.topic !== undefined) existing.topic = snap.topic`
+      // assignment in the empty-members path. The JOIN reducer does not
+      // emit 332 itself, so we query the topic explicitly via `TOPIC
+      // #chan` (no args) after re-JOIN — a 332 RPL_TOPIC reply proves
+      // the cache retained the topic through the empty refresh.
+      await dispatch(
+        { requestContext: { routeKey: '$connect', connectionId: 't1' } },
+        requireFx().deps,
+      );
+      const sink: string[] = [];
+      requireFx().mgmt.register('t1', (data) => {
+        for (const line of data.split('\r\n')) {
+          if (line.length > 0) sink.push(line);
+        }
+      });
+      await dispatch(
+        {
+          requestContext: { routeKey: '$default', connectionId: 't1' },
+          body: 'NICK alice\r\nUSER alice 0 * :Alice\r\nJOIN #topicchan\r\nTOPIC #topicchan :hello\r\n',
+        },
+        requireFx().deps,
+      );
+      const sinkAfterFirstJoin = sink.length;
+      await dispatch(
+        {
+          requestContext: { routeKey: '$default', connectionId: 't1' },
+          body: 'PART #topicchan\r\n',
+        },
+        requireFx().deps,
+      );
+      // Re-JOIN triggers refreshChannel with snap.topic === 'hello',
+      // assigning existing.topic. The subsequent TOPIC query reads from
+      // the cache and emits 332 RPL_TOPIC.
+      const res = await dispatch(
+        {
+          requestContext: { routeKey: '$default', connectionId: 't1' },
+          body: 'JOIN #topicchan\r\nTOPIC #topicchan\r\n',
+        },
+        requireFx().deps,
+      );
+      expect(res.statusCode).toBe(200);
+      const newReplies = sink.slice(sinkAfterFirstJoin);
+      expect(newReplies.some((l) => l.includes(' 332 ') && l.includes('hello'))).toBe(true);
+    });
   });
 
   // -------------------------------------------------------------------------

package/packages/aws-adapter/tests/message-store.test.ts

@@ -7,7 +7,8 @@
  * store (record → query round-trip) without needing DynamoDB Local.
  */
 
-import { DEFAULT_SERVER_CONFIG, type StoredMessage } from '@serverless-ircd/irc-core';
+import type { StoredMessage } from '@serverless-ircd/irc-core';
+import { makeTestServerConfig } from '@serverless-ircd/irc-test-support';
 import { describe, expect, it } from 'vitest';
 import { bindMessageStore } from '../src/message-store.js';
 
@@ -26,7 +27,7 @@ function sampleMessage(chan: string, text: string): StoredMessage {
 
 describe('bindMessageStore', () => {
   it('returns a store that records and replays a message via LATEST', () => {
-    const store = bindMessageStore(DEFAULT_SERVER_CONFIG);
+    const store = bindMessageStore(makeTestServerConfig());
     store.record(sampleMessage('#aws', 'hello aws'));
 
     const result = store.query({ chan: '#aws', direction: 'latest', limit: 10 });
@@ -35,7 +36,7 @@ describe('bindMessageStore', () => {
   });
 
   it('returns a store scoped per channel (no cross-channel leak)', () => {
-    const store = bindMessageStore(DEFAULT_SERVER_CONFIG);
+    const store = bindMessageStore(makeTestServerConfig());
     store.record(sampleMessage('#a', 'in a'));
     store.record(sampleMessage('#b', 'in b'));
 
@@ -45,8 +46,8 @@ describe('bindMessageStore', () => {
   });
 
   it('returns an independent store instance per call', () => {
-    const a = bindMessageStore(DEFAULT_SERVER_CONFIG);
-    const b = bindMessageStore(DEFAULT_SERVER_CONFIG);
+    const a = bindMessageStore(makeTestServerConfig());
+    const b = bindMessageStore(makeTestServerConfig());
     a.record(sampleMessage('#aws', 'only in a'));
 
     expect(a.query({ chan: '#aws', direction: 'latest', limit: 10 })).toHaveLength(1);

package/packages/aws-adapter/tests/nlb-stream.test.ts

@@ -9,11 +9,8 @@
  */
 
 import { CreateTableCommand, DeleteTableCommand } from '@aws-sdk/client-dynamodb';
-import {
-  DEFAULT_SERVER_CONFIG,
-  type ParsedServerConfig,
-  StaticMotdProvider,
-} from '@serverless-ircd/irc-core';
+import { type ParsedServerConfig, StaticMotdProvider } from '@serverless-ircd/irc-core';
+import { makeTestServerConfig } from '@serverless-ircd/irc-test-support';
 import { afterEach, beforeEach, describe, expect, it } from 'vitest';
 import { AwsRuntime } from '../src/aws-runtime.js';
 import type { PostToConnection } from '../src/aws-runtime.js';
@@ -30,12 +27,11 @@ import type { TablesConfig } from '../src/tables.js';
 const available = process.env.DDB_AVAILABLE === '1';
 const endpoint = process.env.DYNAMO_ENDPOINT;
 
-const SERVER_CONFIG: ParsedServerConfig = {
-  ...DEFAULT_SERVER_CONFIG,
+const SERVER_CONFIG: ParsedServerConfig = makeTestServerConfig({
   serverName: 'irc.example.com',
   networkName: 'ExampleNet',
   motdLines: ['Welcome to the test IRC server.'],
-};
+});
 
 const MOTD = new StaticMotdProvider(SERVER_CONFIG.motdLines);
 
@@ -151,6 +147,8 @@ describe.skipIf(!available)('NLB stream handler — byte framing', () => {
       motd: MOTD,
       messages: bindMessageStore(SERVER_CONFIG),
       managementApi: f.mgmt,
+      // Bind a reload source so the configLoader wiring is exercised.
+      configLoader: async () => SERVER_CONFIG,
     });
     expect(res.statusCode).toBe(200);
 
@@ -459,6 +457,62 @@ describe.skipIf(!available)('NLB stream handler — streaming back', () => {
     });
     expect(bSink.some((l) => l.includes('PRIVMSG #room :hello from alice'))).toBe(true);
   });
+
+  it('refreshChannel tolerates an empty channel snapshot without throwing', async () => {
+    // After the last member PARTs, the channel meta row persists but
+    // queryMembers returns no rows → snap.members.size === 0. The next
+    // frame referencing the channel triggers refreshChannel on the
+    // empty-members + existing-cache path. This test ensures that path
+    // does not throw and the channel remains usable for a re-JOIN.
+    const f = requireFx();
+    const opts = () => ({
+      dynamo: f.client,
+      tables: f.tables,
+      serverConfig: SERVER_CONFIG,
+      motd: MOTD,
+      messages: bindMessageStore(SERVER_CONFIG),
+      managementApi: f.mgmt,
+    });
+    const a = deriveNlbConnectionId('10.0.0.40', '50040');
+    f.mgmt.register(a, () => {});
+    // Register + JOIN + PART → cache populated then snapshot empty.
+    await handleNlbStream(nlbEvent('10.0.0.40', '50040', ''), opts());
+    await handleNlbStream(
+      nlbEvent('10.0.0.40', '50040', 'NICK alice\r\nUSER alice 0 * :Alice\r\nJOIN #nlbempty\r\n'),
+      opts(),
+    );
+    await handleNlbStream(nlbEvent('10.0.0.40', '50040', 'PART #nlbempty\r\n'), opts());
+    // Re-JOIN hits refreshChannel on the empty-members path; must not throw.
+    const res = await handleNlbStream(nlbEvent('10.0.0.40', '50040', 'JOIN #nlbempty\r\n'), opts());
+    expect(res.statusCode).toBe(200);
+  });
+
+  it('falls back to "unknown"/"0" when NLB headers are absent', async () => {
+    // `readHeader` returns undefined when no header key matches. The
+    // caller's `?? 'unknown'` / `?? '0'` fallbacks must apply so the
+    // handler does not crash on a malformed event (defensive).
+    const f = requireFx();
+    const eventWithoutHeaders: NlbStreamEvent = {
+      requestContext: {
+        elb: { targetGroupArn: 'arn:aws:elasticloadbalancing:::targetgroup/test' },
+      },
+      version: '2.0',
+      body: Buffer.from('PING :tok\r\n', 'utf8').toString('base64'),
+      isBase64Encoded: true,
+      headers: { 'some-other-header': 'value' },
+    };
+    const res = await handleNlbStream(eventWithoutHeaders, {
+      dynamo: f.client,
+      tables: f.tables,
+      serverConfig: SERVER_CONFIG,
+      motd: MOTD,
+      messages: bindMessageStore(SERVER_CONFIG),
+      managementApi: f.mgmt,
+    });
+    expect(res.statusCode).toBe(200);
+    // The fallback id (nlb-unknown-0) still received a PONG.
+    expect(res.body).toBeDefined();
+  });
 });
 
 /**