serverless-ircd 0.5.0 → 0.7.0

package/packages/aws-adapter/tests/account-store-dynamo.test.ts

@@ -10,7 +10,8 @@
  */
 
 import { CreateTableCommand, DeleteTableCommand } from '@aws-sdk/client-dynamodb';
-import { DEFAULT_SERVER_CONFIG } from '@serverless-ircd/irc-core';
+import { PutCommand } from '@aws-sdk/lib-dynamodb';
+import { makeTestServerConfig } from '@serverless-ircd/irc-test-support';
 import { afterEach, beforeEach, describe, expect, it } from 'vitest';
 import {
   loadDynamoAccountStore,
@@ -126,6 +127,48 @@ describe.skipIf(!available)('Accounts table round-trip', () => {
       false,
     );
   });
+
+  it('silently skips rows with missing or wrong-typed credential fields', async () => {
+    // The scan path must tolerate partially-malformed rows (legacy seeds,
+    // schema drift) without throwing — it just skips them. Each branch of
+    // the per-field `typeof === 'string'` guard is exercised by writing a
+    // row where exactly one non-key field has the wrong type. (The
+    // `account` field is the partition key, so DynamoDB itself enforces
+    // its type at write time and the false branch is not exercisable
+    // through the SDK; that branch is a defensive guard against
+    // synthetically-shaped Scan results.)
+    const client = requireFx().client;
+    const table = requireFx().tableName;
+    // Well-formed row — must survive.
+    await putAccountCredential(client, table, 'good', 's3cret');
+    // Row with non-string `algorithm`.
+    await client.send(
+      new PutCommand({
+        TableName: table,
+        Item: { account: 'noalgo', algorithm: 7, salt: 's', hash: 'h' },
+      }),
+    );
+    // Row with non-string `salt`.
+    await client.send(
+      new PutCommand({
+        TableName: table,
+        Item: { account: 'nosalt', algorithm: 'SCRYPT-SHA-256', salt: false, hash: 'h' },
+      }),
+    );
+    // Row with non-string `hash`.
+    await client.send(
+      new PutCommand({
+        TableName: table,
+        Item: { account: 'nohash', algorithm: 'SCRYPT-SHA-256', salt: 's', hash: null },
+      }),
+    );
+    const store = await loadDynamoAccountStore(client, table);
+    expect(store).toBeDefined();
+    expect(store?.size).toBe(1);
+    expect(store?.verify('PLAIN', { kind: 'PLAIN', username: 'good', password: 's3cret' }).ok).toBe(
+      true,
+    );
+  });
 });
 
 describe.skipIf(!available)('resolveAccountStore precedence', () => {
@@ -139,10 +182,9 @@ describe.skipIf(!available)('resolveAccountStore precedence', () => {
 
   it('returns a DynamoAccountStore when the table has rows (table wins)', async () => {
     await putAccountCredential(requireFx().client, requireFx().tableName, 'alice', 'table-secret');
-    const cfgWithSasl = {
-      ...DEFAULT_SERVER_CONFIG,
+    const cfgWithSasl = makeTestServerConfig({
       saslAccounts: [{ username: 'envuser', password: 'env-secret' }],
-    };
+    });
     const store = await resolveAccountStore(requireFx().client, requireFx().tableName, cfgWithSasl);
     expect(store).toBeDefined();
     // Table account verifies; config account does NOT (table is authoritative).
@@ -155,10 +197,9 @@ describe.skipIf(!available)('resolveAccountStore precedence', () => {
   });
 
   it('falls back to the config-seeded store when the table is empty', async () => {
-    const cfgWithSasl = {
-      ...DEFAULT_SERVER_CONFIG,
+    const cfgWithSasl = makeTestServerConfig({
       saslAccounts: [{ username: 'envuser', password: 'env-secret' }],
-    };
+    });
     const store = await resolveAccountStore(requireFx().client, requireFx().tableName, cfgWithSasl);
     expect(store).toBeDefined();
     expect(
@@ -170,7 +211,7 @@ describe.skipIf(!available)('resolveAccountStore precedence', () => {
     const store = await resolveAccountStore(
       requireFx().client,
       requireFx().tableName,
-      DEFAULT_SERVER_CONFIG,
+      makeTestServerConfig(),
     );
     expect(store).toBeUndefined();
   });

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

@@ -1,9 +1,6 @@
 import { DynamoDBDocumentClient, PutCommand, ScanCommand } from '@aws-sdk/lib-dynamodb';
-import {
-  DEFAULT_SERVER_CONFIG,
-  type ParsedServerConfig,
-  type SaslPayload,
-} from '@serverless-ircd/irc-core';
+import type { ParsedServerConfig, SaslPayload } from '@serverless-ircd/irc-core';
+import { makeTestServerConfig } from '@serverless-ircd/irc-test-support';
 import { mockClient } from 'aws-sdk-client-mock';
 import { describe, expect, it } from 'vitest';
 import {
@@ -21,7 +18,7 @@ function plainPayload(username: string, password: string): SaslPayload {
 
 /** Builds a minimal parsed config with the supplied saslAccounts. */
 function configWith(accounts: Array<{ username: string; password: string }>): ParsedServerConfig {
-  return { ...DEFAULT_SERVER_CONFIG, saslAccounts: accounts };
+  return makeTestServerConfig({ saslAccounts: accounts });
 }
 
 // ---------------------------------------------------------------------------
@@ -184,7 +181,7 @@ describe('resolveAccountStore', () => {
       'Accounts',
       fallback === undefined
         ? undefined
-        : { ...DEFAULT_SERVER_CONFIG, saslAccounts: [{ username: 'envuser', password: 'env-pw' }] },
+        : makeTestServerConfig({ saslAccounts: [{ username: 'envuser', password: 'env-pw' }] }),
     );
     expect(store).toBeDefined();
     expect(store?.verify('PLAIN', plainPayload('alice', 's3cret')).ok).toBe(true);

package/packages/aws-adapter/tests/aws-harness.ts

@@ -53,8 +53,11 @@ const endpoint = process.env.DYNAMO_ENDPOINT;
 
 /**
  * Factory entry — appends to a suite's FACTORIES array to opt the scenarios
- * into the AWS matrix. Returns a no-op factory when DynamoDB Local is
- * unavailable so `describe.skipIf` short-circuits before any test runs.
+ * into the AWS matrix. The whole describe block is gated by
+ * `describe.skipIf(process.env.DDB_AVAILABLE !== '1')` at the call site
+ * (see `aws-integration.test.ts`), so no scenarios run when DynamoDB
+ * Local is unavailable. This factory itself assumes DDB is up; its
+ * `create()` throws if `DYNAMO_ENDPOINT` was never set.
  */
 export const awsHarnessFactory: IrcHarnessFactory = Object.freeze({
   name: 'aws+ws',

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

@@ -6,12 +6,16 @@
  * a fresh {@link AwsHarness} which mints uniquely-prefixed DynamoDB
  * tables against the global-setup's endpoint.
  *
- * Gated on `process.env.DDB_AVAILABLE`: the suite is skipped when
- * DynamoDB Local cannot be booted (no Docker, no Java). When available,
- * every scenario MUST pass — that is the acceptance criterion.
+ * Gated on `process.env.DDB_AVAILABLE`: the whole suite is skipped via
+ * `describe.skipIf` when DynamoDB Local cannot be booted (no Docker, no
+ * Java). When available, every scenario MUST pass — that is the
+ * acceptance criterion.
  */
 
 import { runIrcScenarios } from '@serverless-ircd/irc-test-support';
+import { describe } from 'vitest';
 import { awsHarnessFactory } from './aws-harness.js';
 
-runIrcScenarios([awsHarnessFactory]);
+describe.skipIf(process.env.DDB_AVAILABLE !== '1')('aws integration scenarios', () => {
+  runIrcScenarios([awsHarnessFactory]);
+});

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

@@ -399,6 +399,85 @@ describe.skipIf(!available)('AwsRuntime', () => {
     });
   });
 
+  // -------------------------------------------------------------------------
+  // broadcastWallops — Scan-based fan-out to every +w connection
+  // -------------------------------------------------------------------------
+
+  describe('broadcastWallops', () => {
+    it('delivers to every +w connection and skips the except id', async () => {
+      const receivedA: string[] = [];
+      const receivedB: string[] = [];
+      const stateA = createConnection({ id: 'w-a', connectedSince: 0 });
+      stateA.userModes.wallops = true;
+      const stateB = createConnection({ id: 'w-b', connectedSince: 0 });
+      stateB.userModes.wallops = true;
+
+      const mgmt = new LocalPostToConnection();
+      mgmt.register('w-a', (data) => {
+        for (const line of data.split('\r\n')) {
+          if (line.length > 0) receivedA.push(line);
+        }
+      });
+      mgmt.register('w-b', (data) => {
+        for (const line of data.split('\r\n')) {
+          if (line.length > 0) receivedB.push(line);
+        }
+      });
+
+      const rtA = makeRuntime('w-a', handlersSink(receivedA, stateA), undefined, mgmt);
+      const rtB = makeRuntime('w-b', handlersSink(receivedB, stateB), undefined, mgmt);
+
+      await rtA.persistConnectionState(stateA);
+      await rtB.persistConnectionState(stateB);
+
+      // Caller 'w-a' is excepted; only 'w-b' should receive the line.
+      await rtA.broadcastWallops([{ text: ':oper NOTICE * :hello' }], 'w-a');
+      expect(receivedA).toEqual([]);
+      expect(receivedB).toEqual([':oper NOTICE * :hello']);
+    });
+
+    it('delivers to the bound connection via in-process handlers when not excepted', async () => {
+      // The bound connection's own +w delivery goes through handlers.send,
+      // not APIGW. With no `except`, the bound conn is also a recipient.
+      const received: string[] = [];
+      const state = createConnection({ id: 'self', connectedSince: 0 });
+      state.userModes.wallops = true;
+      const rt = makeRuntime('self', handlersSink(received, state), undefined, null);
+      await rt.persistConnectionState(state);
+      await rt.broadcastWallops([{ text: ':oper NOTICE * :hi' }]);
+      expect(received).toEqual([':oper NOTICE * :hi']);
+    });
+  });
+
+  // -------------------------------------------------------------------------
+  // Nick registry — error propagation
+  // -------------------------------------------------------------------------
+
+  describe('reserveNick error propagation', () => {
+    it('rethrows non-conditional errors from the PutCommand', async () => {
+      // A non-ConditionalCheckFailedException error must propagate rather
+      // than be treated as a nick collision. We force a real DynamoDB
+      // error by sending the reserveNick PutCommand against a table that
+      // does not exist (deleted mid-flight), which yields a
+      // ResourceNotFoundException.
+      const rt = makeRuntime('c1', noopHandlers());
+      // Drop the Nicks table out from under the runtime.
+      await fx.client.send(new DeleteTableCommand({ TableName: fx.tables.Nicks }));
+      await expect(rt.reserveNick('Ghost', 'c1')).rejects.toThrow(
+        /ResourceNotFoundException|non-existent table/,
+      );
+      // Recreate the table so afterEach cleanup does not fail on a missing table.
+      await fx.client.send(
+        new CreateTableCommand({
+          TableName: fx.tables.Nicks,
+          AttributeDefinitions: [{ AttributeName: 'nickLower', AttributeType: 'S' }],
+          KeySchema: [{ AttributeName: 'nickLower', KeyType: 'HASH' }],
+          BillingMode: 'PAY_PER_REQUEST',
+        }),
+      );
+    });
+  });
+
   // -------------------------------------------------------------------------
   // listChannels + getChannelConnections
   // -------------------------------------------------------------------------

package/packages/aws-adapter/tests/config-loader.test.ts

@@ -90,6 +90,15 @@ describe('buildLambdaConfigInput', () => {
     );
   });
 
+  it('passes an overflowing numeric CREATED_AT through verbatim (not Infinity)', () => {
+    // A purely-numeric string that overflows Number.MAX_VALUE renders as
+    // `Infinity`, which is not a finite epoch-ms. The parser must fall
+    // back to returning the raw string rather than emitting `Infinity`
+    // into the config (which would serialize as `null` in JSON).
+    const huge = '9'.repeat(400);
+    expect(buildLambdaConfigInput({ CREATED_AT: huge }).createdAt).toBe(huge);
+  });
+
   it('omits serverVersion/createdAt when their env vars are unset', () => {
     const out = buildLambdaConfigInput({});
     expect('serverVersion' in out).toBe(false);
@@ -154,8 +163,8 @@ describe('loadServerConfigFromLambdaEnv', () => {
     expect(typeof cfg.nickLen).toBe('number');
   });
 
-  it('throws when SERVER_NAME is missing', () => {
-    expect(() => loadServerConfigFromLambdaEnv({})).toThrow();
+  it('throws a readable error naming serverName when SERVER_NAME is missing', () => {
+    expect(() => loadServerConfigFromLambdaEnv({})).toThrowError(/serverName/u);
   });
 
   it('round-trips MOTD lines into ParsedServerConfig', () => {

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

@@ -8,7 +8,7 @@
  */
 
 import { type DynamoDBDocumentClient, PutCommand, ScanCommand } from '@aws-sdk/lib-dynamodb';
-import { DEFAULT_SERVER_CONFIG } from '@serverless-ircd/irc-core';
+import { makeTestServerConfig } from '@serverless-ircd/irc-test-support';
 import { describe, expect, it } from 'vitest';
 import { handleConnect } from '../src/handlers/connect.js';
 import type { MarshalledConnection } from '../src/serialize.js';
@@ -66,7 +66,7 @@ describe('handleConnect admission plumbing', () => {
       tables: TABLES,
       connectionId: 'c-paged',
       now: 42,
-      serverConfig: { ...DEFAULT_SERVER_CONFIG, maxClients: 5 },
+      serverConfig: makeTestServerConfig({ maxClients: 5 }),
     });
     expect(outcome).toEqual({ admitted: true, subprotocol: null });
     expect(stub.puts).toBe(1);
@@ -78,7 +78,7 @@ describe('handleConnect admission plumbing', () => {
       dynamo: stub.dynamo,
       tables: TABLES,
       connectionId: 'c-full',
-      serverConfig: { ...DEFAULT_SERVER_CONFIG, maxClients: 5 },
+      serverConfig: makeTestServerConfig({ maxClients: 5 }),
     });
     expect(outcome).toEqual({ admitted: false, statusCode: 429, reason: 'server full' });
     expect(stub.puts).toBe(0);
@@ -94,7 +94,7 @@ describe('handleConnect — IRCv3 WebSocket subprotocol negotiation', () => {
       connectionId: 'c-binary',
       now: 42,
       secWebSocketProtocol: 'binary.ircv3.net',
-      serverConfig: { ...DEFAULT_SERVER_CONFIG, maxClients: 5 },
+      serverConfig: makeTestServerConfig({ maxClients: 5 }),
     });
     expect(outcome).toEqual({ admitted: true, subprotocol: 'binary.ircv3.net' });
     expect(stub.puts).toBe(1);
@@ -110,7 +110,7 @@ describe('handleConnect — IRCv3 WebSocket subprotocol negotiation', () => {
       connectionId: 'c-text',
       now: 42,
       secWebSocketProtocol: 'text.ircv3.net',
-      serverConfig: { ...DEFAULT_SERVER_CONFIG, maxClients: 5 },
+      serverConfig: makeTestServerConfig({ maxClients: 5 }),
     });
     expect(outcome).toEqual({ admitted: true, subprotocol: 'text.ircv3.net' });
     const item = stub.lastPutItem as MarshalledConnection | undefined;
@@ -125,7 +125,7 @@ describe('handleConnect — IRCv3 WebSocket subprotocol negotiation', () => {
       connectionId: 'c-pref',
       now: 42,
       secWebSocketProtocol: 'text.ircv3.net, binary.ircv3.net',
-      serverConfig: { ...DEFAULT_SERVER_CONFIG, maxClients: 5 },
+      serverConfig: makeTestServerConfig({ maxClients: 5 }),
     });
     expect(outcome).toEqual({ admitted: true, subprotocol: 'text.ircv3.net' });
   });
@@ -137,7 +137,7 @@ describe('handleConnect — IRCv3 WebSocket subprotocol negotiation', () => {
       tables: TABLES,
       connectionId: 'c-legacy',
       now: 42,
-      serverConfig: { ...DEFAULT_SERVER_CONFIG, maxClients: 5 },
+      serverConfig: makeTestServerConfig({ maxClients: 5 }),
     });
     expect(outcome).toEqual({ admitted: true, subprotocol: null });
     const item = stub.lastPutItem as MarshalledConnection | undefined;
@@ -152,7 +152,7 @@ describe('handleConnect — IRCv3 WebSocket subprotocol negotiation', () => {
       connectionId: 'c-unsupported',
       now: 42,
       secWebSocketProtocol: 'chat, superchat.v2',
-      serverConfig: { ...DEFAULT_SERVER_CONFIG, maxClients: 5 },
+      serverConfig: makeTestServerConfig({ maxClients: 5 }),
     });
     expect(outcome).toEqual({ admitted: true, subprotocol: null });
     const item = stub.lastPutItem as MarshalledConnection | undefined;
@@ -166,7 +166,7 @@ describe('handleConnect — IRCv3 WebSocket subprotocol negotiation', () => {
       tables: TABLES,
       connectionId: 'c-full',
       secWebSocketProtocol: 'binary.ircv3.net',
-      serverConfig: { ...DEFAULT_SERVER_CONFIG, maxClients: 5 },
+      serverConfig: makeTestServerConfig({ maxClients: 5 }),
     });
     expect(outcome).toEqual({ admitted: false, statusCode: 429, reason: 'server full' });
     expect(stub.puts).toBe(0);

package/packages/aws-adapter/tests/disconnect-fanout.test.ts

@@ -12,12 +12,12 @@ import { GoneException } from '@aws-sdk/client-apigatewaymanagementapi';
 import { CreateTableCommand, DeleteTableCommand } from '@aws-sdk/client-dynamodb';
 import { PutCommand } from '@aws-sdk/lib-dynamodb';
 import {
-  DEFAULT_SERVER_CONFIG,
   type Nick,
   type ParsedServerConfig,
   StaticMotdProvider,
   createConnection,
 } from '@serverless-ircd/irc-core';
+import { makeTestServerConfig } from '@serverless-ircd/irc-test-support';
 import { afterEach, beforeEach, describe, expect, it } from 'vitest';
 import { AwsRuntime, type PostToConnection, cleanupConnection } from '../src/aws-runtime.js';
 import { TABLE_DEFS } from '../src/cdk-table-defs.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: [],
-};
+});
 
 interface Fixture {
   tables: TablesConfig;

package/packages/aws-adapter/tests/global-setup.ts

@@ -2,20 +2,32 @@
  * Vitest `globalSetup` — boots a DynamoDB Local instance once per test run
  * and exposes its endpoint via `process.env.DYNAMO_ENDPOINT`.
  *
- * Strategy (in priority order):
+ * Strategy selection:
  *
- *   1. **testcontainers** — preferred, matches CI. Spins up the canonical
- *      `amazon/dynamodb-local` Docker image. Requires Docker.
- *   2. **DynamoDB Local ZIP + Java** — development fallback for hosts
- *      with Java (e.g. dev laptops without Docker Desktop). Downloads
- *      the official AWS ZIP once into a per-user cache dir, runs it
- *      with `-inMemory` so per-run state is isolated by port.
+ *   - `DDB_LOCAL_STRATEGY=zip`   → only the Java ZIP fallback (skips the
+ *     testcontainers probe). Canonical CI path on the self-hosted Gitea
+ *     runner, which has a JRE installed via `setup-java` but no
+ *     privileged container / `docker.sock` mount for Ryuk.
+ *   - `DDB_LOCAL_STRATEGY=docker` → only testcontainers.
+ *   - unset / `auto` (default) → try testcontainers first, then ZIP.
+ *     Matches developer laptops where either backend may be available.
+ *
+ * Strategies (in priority order under `auto`):
+ *
+ *   1. **testcontainers** — preferred. Spins up the canonical
+ *      `amazon/dynamodb-local` Docker image. Requires Docker with a
+ *      working Ryuk reaper (privileged runner or `docker.sock` mount).
+ *   2. **DynamoDB Local ZIP + Java** — development/CI fallback for hosts
+ *      with Java (e.g. the CI runner image with a JRE, or dev laptops
+ *      without Docker Desktop). Downloads the official AWS ZIP once
+ *      into a per-user cache dir, runs it with `-inMemory` so per-run
+ *      state is isolated by port.
  *   3. **Skip** — sets `process.env.DDB_AVAILABLE = '0'`; integration
  *      tests gate themselves on this via `describe.skipIf`.
  *
  * The skip path keeps the suite green in environments that legitimately
  * can't run DynamoDB Local (no Docker, no Java). The acceptance criterion
- * is "all 31 scenarios pass when DDB is available", not "every dev box
+ * is "all scenarios pass when DDB is available", not "every dev box
  * runs them".
  */
 
@@ -51,34 +63,47 @@ interface DdbHandle {
 }
 
 export default async function globalSetup(): Promise<(() => Promise<void>) | undefined> {
+  const strategy = (process.env.DDB_LOCAL_STRATEGY ?? 'auto').toLowerCase();
+  // Strategy pin: skip the unused probe to avoid a multi-second timeout
+  // on hosts that lack the capability. CI pins `zip`; local dev defaults
+  // to `auto` so a Docker Desktop install still gets testcontainers.
+  const wantDocker = strategy === 'auto' || strategy === 'docker';
+  const wantZip = strategy === 'auto' || strategy === 'zip';
+
   // Strategy 1: testcontainers (Docker).
-  try {
-    const handle = await tryTestcontainers();
-    if (handle !== null) {
-      process.env.DDB_AVAILABLE = '1';
-      process.env.DYNAMO_ENDPOINT = handle.endpoint;
-      console.warn(`[aws-adapter global-setup] DynamoDB Local via Docker at ${handle.endpoint}`);
-      return async () => {
-        await handle.stop();
-      };
+  if (wantDocker) {
+    try {
+      const handle = await tryTestcontainers();
+      if (handle !== null) {
+        process.env.DDB_AVAILABLE = '1';
+        process.env.DYNAMO_ENDPOINT = handle.endpoint;
+        console.warn(`[aws-adapter global-setup] DynamoDB Local via Docker at ${handle.endpoint}`);
+        return async () => {
+          await handle.stop();
+        };
+      }
+    } catch (err: unknown) {
+      console.warn('[aws-adapter global-setup] testcontainers unavailable:', renderErr(err));
     }
-  } catch (err: unknown) {
-    console.warn('[aws-adapter global-setup] testcontainers unavailable:', renderErr(err));
   }
 
   // Strategy 2: local ZIP + Java.
-  try {
-    const handle = await tryZip();
-    if (handle !== null) {
-      process.env.DDB_AVAILABLE = '1';
-      process.env.DYNAMO_ENDPOINT = handle.endpoint;
-      console.warn(`[aws-adapter global-setup] DynamoDB Local via Java ZIP at ${handle.endpoint}`);
-      return async () => {
-        await handle.stop();
-      };
+  if (wantZip) {
+    try {
+      const handle = await tryZip();
+      if (handle !== null) {
+        process.env.DDB_AVAILABLE = '1';
+        process.env.DYNAMO_ENDPOINT = handle.endpoint;
+        console.warn(
+          `[aws-adapter global-setup] DynamoDB Local via Java ZIP at ${handle.endpoint}`,
+        );
+        return async () => {
+          await handle.stop();
+        };
+      }
+    } catch (err: unknown) {
+      console.warn('[aws-adapter global-setup] ZIP fallback unavailable:', renderErr(err));
     }
-  } catch (err: unknown) {
-    console.warn('[aws-adapter global-setup] ZIP fallback unavailable:', renderErr(err));
   }
 
   // Strategy 3: skip.

package/packages/aws-adapter/tests/gone-exception.test.ts

@@ -11,12 +11,8 @@
 import { GoneException } from '@aws-sdk/client-apigatewaymanagementapi';
 import { CreateTableCommand, DeleteTableCommand } from '@aws-sdk/client-dynamodb';
 import { PutCommand } from '@aws-sdk/lib-dynamodb';
-import {
-  DEFAULT_SERVER_CONFIG,
-  type Nick,
-  type ParsedServerConfig,
-  createConnection,
-} from '@serverless-ircd/irc-core';
+import { type Nick, type ParsedServerConfig, createConnection } from '@serverless-ircd/irc-core';
+import { makeTestServerConfig } from '@serverless-ircd/irc-test-support';
 import { afterEach, beforeEach, describe, expect, it } from 'vitest';
 import { AwsRuntime, type PostToConnection, cleanupConnection } from '../src/aws-runtime.js';
 import { TABLE_DEFS } from '../src/cdk-table-defs.js';
@@ -27,12 +23,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: [],
-};
+});
 
 interface Fixture {
   tables: TablesConfig;

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);
 
@@ -685,6 +684,93 @@ describe.skipIf(!available)('handlers', () => {
       // 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);
+    });
   });
 
   // -------------------------------------------------------------------------