serverless-ircd 0.4.0 → 0.6.0

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

@@ -12,6 +12,7 @@ import {
   type Clock,
   type ConnectionState,
   type RawLine,
+  type ServerConfig,
   createConnection,
 } from '@serverless-ircd/irc-core';
 import { afterEach, beforeEach, describe, expect, it } from 'vitest';
@@ -398,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
   // -------------------------------------------------------------------------
@@ -652,3 +732,63 @@ function handlersSink(sink: string[], snapshot?: ConnectionState): AwsRuntimeHan
     snapshot: () => snapshot,
   };
 }
+
+// ---------------------------------------------------------------------------
+// reloadConfig (REHASH) — no DynamoDB access, so this group runs unconditionally.
+// ---------------------------------------------------------------------------
+
+describe('AwsRuntime — reloadConfig (REHASH)', () => {
+  const baseConfig: ServerConfig = {
+    serverName: 'irc.example.com',
+    networkName: 'ExampleNet',
+    maxChannelsPerUser: 30,
+    maxTargetsPerCommand: 10,
+    maxListEntries: 50,
+    nickLen: 30,
+    channelLen: 50,
+    topicLen: 390,
+    quitMessage: 'Client Quit',
+  };
+
+  function makeReloadRuntime(loader?: () => Promise<ServerConfig>): AwsRuntime {
+    return new AwsRuntime({
+      // reloadConfig never touches DynamoDB; a default client + empty tables
+      // suffice for the no-IO reload path.
+      dynamo: createDynamoDocumentClient({}),
+      tables: {} as TablesConfig,
+      connId: 'c1',
+      handlers: noopHandlers(),
+      managementApi: null,
+      ...(loader !== undefined ? { configLoader: loader } : {}),
+    });
+  }
+
+  it('re-invokes the bound loader and returns the fresh config', async () => {
+    let password = 'old';
+    const rt = makeReloadRuntime(async () => ({
+      ...baseConfig,
+      operCreds: [{ user: 'admin', password }],
+    }));
+
+    const first = await rt.reloadConfig();
+    expect(first.operCreds).toEqual([{ user: 'admin', password: 'old' }]);
+
+    password = 'rotated';
+    const second = await rt.reloadConfig();
+    expect(second.operCreds).toEqual([{ user: 'admin', password: 'rotated' }]);
+  });
+
+  it('propagates a loader rejection so the actor applies the graceful 382', async () => {
+    const rt = makeReloadRuntime(async () => {
+      throw new Error('Secrets Manager unreachable');
+    });
+
+    await expect(rt.reloadConfig()).rejects.toThrow('Secrets Manager unreachable');
+  });
+
+  it('rejects when no loader was bound at construction', async () => {
+    const rt = makeReloadRuntime();
+
+    await expect(rt.reloadConfig()).rejects.toThrow('no config loader bound');
+  });
+});

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,9 +8,10 @@
  */
 
 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';
 import type { TablesConfig } from '../src/tables.js';
 
 const TABLES: TablesConfig = {
@@ -24,12 +25,15 @@ const TABLES: TablesConfig = {
 interface Stub {
   dynamo: DynamoDBDocumentClient;
   puts: number;
+  /** Most recently PutCommand Item (undefined when no put happened). */
+  lastPutItem: Record<string, unknown> | undefined;
 }
 
 /** Builds a stub client that serves the supplied `Scan` pages in order. */
 function makeStub(pages: Array<Record<string, unknown>>): Stub {
   let scanIdx = 0;
   const calls = { puts: 0 };
+  let lastPutItem: Record<string, unknown> | undefined;
   const dynamo = {
     send: async (cmd: unknown) => {
       if (cmd instanceof ScanCommand) {
@@ -37,6 +41,7 @@ function makeStub(pages: Array<Record<string, unknown>>): Stub {
       }
       if (cmd instanceof PutCommand) {
         calls.puts++;
+        lastPutItem = cmd.input.Item as Record<string, unknown> | undefined;
         return {};
       }
       throw new Error('unexpected command');
@@ -47,6 +52,9 @@ function makeStub(pages: Array<Record<string, unknown>>): Stub {
     get puts() {
       return calls.puts;
     },
+    get lastPutItem() {
+      return lastPutItem;
+    },
   };
 }
 
@@ -58,9 +66,9 @@ 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 });
+    expect(outcome).toEqual({ admitted: true, subprotocol: null });
     expect(stub.puts).toBe(1);
   });
 
@@ -70,7 +78,95 @@ 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);
+  });
+});
+
+describe('handleConnect — IRCv3 WebSocket subprotocol negotiation', () => {
+  it('selects binary.ircv3.net, echoes it, and persists a spec-binary mode row', async () => {
+    const stub = makeStub([{ Count: 0 }]);
+    const outcome = await handleConnect({
+      dynamo: stub.dynamo,
+      tables: TABLES,
+      connectionId: 'c-binary',
+      now: 42,
+      secWebSocketProtocol: 'binary.ircv3.net',
+      serverConfig: makeTestServerConfig({ maxClients: 5 }),
+    });
+    expect(outcome).toEqual({ admitted: true, subprotocol: 'binary.ircv3.net' });
+    expect(stub.puts).toBe(1);
+    const item = stub.lastPutItem as MarshalledConnection | undefined;
+    expect(item?.wsMode).toBe('spec-binary');
+  });
+
+  it('selects text.ircv3.net and persists a spec-text mode row', async () => {
+    const stub = makeStub([{ Count: 0 }]);
+    const outcome = await handleConnect({
+      dynamo: stub.dynamo,
+      tables: TABLES,
+      connectionId: 'c-text',
+      now: 42,
+      secWebSocketProtocol: 'text.ircv3.net',
+      serverConfig: makeTestServerConfig({ maxClients: 5 }),
+    });
+    expect(outcome).toEqual({ admitted: true, subprotocol: 'text.ircv3.net' });
+    const item = stub.lastPutItem as MarshalledConnection | undefined;
+    expect(item?.wsMode).toBe('spec-text');
+  });
+
+  it('honours client-preference order when both subprotocols are offered', async () => {
+    const stub = makeStub([{ Count: 0 }]);
+    const outcome = await handleConnect({
+      dynamo: stub.dynamo,
+      tables: TABLES,
+      connectionId: 'c-pref',
+      now: 42,
+      secWebSocketProtocol: 'text.ircv3.net, binary.ircv3.net',
+      serverConfig: makeTestServerConfig({ maxClients: 5 }),
+    });
+    expect(outcome).toEqual({ admitted: true, subprotocol: 'text.ircv3.net' });
+  });
+
+  it('falls back to legacy (null subprotocol, no mode column) when no offer is present', async () => {
+    const stub = makeStub([{ Count: 0 }]);
+    const outcome = await handleConnect({
+      dynamo: stub.dynamo,
+      tables: TABLES,
+      connectionId: 'c-legacy',
+      now: 42,
+      serverConfig: makeTestServerConfig({ maxClients: 5 }),
+    });
+    expect(outcome).toEqual({ admitted: true, subprotocol: null });
+    const item = stub.lastPutItem as MarshalledConnection | undefined;
+    expect(item?.wsMode).toBeUndefined();
+  });
+
+  it('falls back to legacy when only unsupported subprotocols are offered', async () => {
+    const stub = makeStub([{ Count: 0 }]);
+    const outcome = await handleConnect({
+      dynamo: stub.dynamo,
+      tables: TABLES,
+      connectionId: 'c-unsupported',
+      now: 42,
+      secWebSocketProtocol: 'chat, superchat.v2',
+      serverConfig: makeTestServerConfig({ maxClients: 5 }),
+    });
+    expect(outcome).toEqual({ admitted: true, subprotocol: null });
+    const item = stub.lastPutItem as MarshalledConnection | undefined;
+    expect(item?.wsMode).toBeUndefined();
+  });
+
+  it('does not negotiate a subprotocol when the admission gate rejects', async () => {
+    const stub = makeStub([{ Count: 5 }]);
+    const outcome = await handleConnect({
+      dynamo: stub.dynamo,
+      tables: TABLES,
+      connectionId: 'c-full',
+      secWebSocketProtocol: 'binary.ircv3.net',
+      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;