serverless-ircd 0.1.0 → 0.3.0

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

@@ -0,0 +1,213 @@
+/**
+ * Unit tests for `loadServerConfigFromLambdaEnv` and `buildLambdaConfigInput`.
+ *
+ * Pure-function tests; no DynamoDB / Lambda runtime needed.
+ */
+
+import { describe, expect, it } from 'vitest';
+import {
+  type LambdaConfigEnv,
+  buildLambdaConfigInput,
+  loadServerConfigFromLambdaEnv,
+} from '../src/config-loader.js';
+
+describe('buildLambdaConfigInput', () => {
+  it('passes SERVER_NAME and NETWORK_NAME through', () => {
+    const out = buildLambdaConfigInput({ SERVER_NAME: 'irc.x', NETWORK_NAME: 'NetX' });
+    expect(out.serverName).toBe('irc.x');
+    expect(out.networkName).toBe('NetX');
+  });
+
+  it('splits MOTD on newlines into motdLines', () => {
+    const out = buildLambdaConfigInput({ MOTD: 'first\nsecond' });
+    expect(out.motdLines).toEqual(['first', 'second']);
+  });
+
+  it('omits motdLines when MOTD is empty', () => {
+    const out = buildLambdaConfigInput({ MOTD: '' });
+    expect('motdLines' in out).toBe(false);
+  });
+
+  it('omits motdLines when MOTD is undefined', () => {
+    const out = buildLambdaConfigInput({});
+    expect('motdLines' in out).toBe(false);
+  });
+
+  it('parses MAX_CLIENTS as int', () => {
+    expect(buildLambdaConfigInput({ MAX_CLIENTS: '42' }).maxClients).toBe(42);
+  });
+
+  it('passes CHANNEL_PREFIXES through', () => {
+    expect(buildLambdaConfigInput({ CHANNEL_PREFIXES: '#&' }).channelPrefixes).toBe('#&');
+  });
+
+  it('builds operCreds when OPER_USER alone is set', () => {
+    const out = buildLambdaConfigInput({ OPER_USER: 'alice' });
+    expect(out.operCreds).toEqual([{ user: 'alice', password: '' }]);
+  });
+
+  it('builds operCreds when OPER_PASSWORD alone is set', () => {
+    const out = buildLambdaConfigInput({ OPER_PASSWORD: 'pw' });
+    expect(out.operCreds).toEqual([{ user: '', password: 'pw' }]);
+  });
+
+  it('omits operCreds when neither OPER_* is set', () => {
+    expect('operCreds' in buildLambdaConfigInput({})).toBe(false);
+  });
+
+  it('parses all numeric knobs', () => {
+    const out = buildLambdaConfigInput({
+      MAX_CHANNELS_PER_USER: '5',
+      MAX_TARGETS_PER_COMMAND: '3',
+      NICK_LEN: '9',
+      CHANNEL_LEN: '12',
+      TOPIC_LEN: '100',
+      MAX_LIST_ENTRIES: '7',
+    });
+    expect(out.maxChannelsPerUser).toBe(5);
+    expect(out.maxTargetsPerCommand).toBe(3);
+    expect(out.nickLen).toBe(9);
+    expect(out.channelLen).toBe(12);
+    expect(out.topicLen).toBe(100);
+    expect(out.maxListEntries).toBe(7);
+  });
+
+  it('passes QUIT_MESSAGE through', () => {
+    expect(buildLambdaConfigInput({ QUIT_MESSAGE: 'bye' }).quitMessage).toBe('bye');
+  });
+
+  it('parses SASL_ACCOUNTS newline-delimited username:password pairs', () => {
+    const out = buildLambdaConfigInput({ SASL_ACCOUNTS: 'alice:secret\nbob:b-pass' });
+    expect(out.saslAccounts).toEqual([
+      { username: 'alice', password: 'secret' },
+      { username: 'bob', password: 'b-pass' },
+    ]);
+  });
+
+  it('omits saslAccounts when SASL_ACCOUNTS is empty', () => {
+    expect('saslAccounts' in buildLambdaConfigInput({ SASL_ACCOUNTS: '' })).toBe(false);
+  });
+
+  it('omits saslAccounts when SASL_ACCOUNTS is undefined', () => {
+    expect('saslAccounts' in buildLambdaConfigInput({})).toBe(false);
+  });
+
+  it('skips blank lines in SASL_ACCOUNTS (trailing newline tolerance)', () => {
+    const out = buildLambdaConfigInput({ SASL_ACCOUNTS: 'alice:secret\n\n   \n' });
+    expect(out.saslAccounts).toEqual([{ username: 'alice', password: 'secret' }]);
+  });
+
+  it('skips SASL_ACCOUNTS entries with no colon separator', () => {
+    const out = buildLambdaConfigInput({ SASL_ACCOUNTS: 'nopass\nalice:secret' });
+    expect(out.saslAccounts).toEqual([{ username: 'alice', password: 'secret' }]);
+  });
+
+  it('skips SASL_ACCOUNTS entries with an empty username (leading colon)', () => {
+    const out = buildLambdaConfigInput({ SASL_ACCOUNTS: ':onlypass\nalice:secret' });
+    expect(out.saslAccounts).toEqual([{ username: 'alice', password: 'secret' }]);
+  });
+
+  it('skips SASL_ACCOUNTS entries with an empty password', () => {
+    const out = buildLambdaConfigInput({ SASL_ACCOUNTS: 'alice:\nbob:real' });
+    expect(out.saslAccounts).toEqual([{ username: 'bob', password: 'real' }]);
+  });
+
+  it('trims whole SASL_ACCOUNTS lines but preserves fields around the colon', () => {
+    // Only the line is trimmed; whitespace adjacent to ':' is kept (so a
+    // stray space does not silently change the stored username/password).
+    const out = buildLambdaConfigInput({ SASL_ACCOUNTS: '  alice:secret  ' });
+    expect(out.saslAccounts).toEqual([{ username: 'alice', password: 'secret' }]);
+  });
+});
+
+describe('loadServerConfigFromLambdaEnv', () => {
+  it('parses a minimal valid env', () => {
+    const env: LambdaConfigEnv = { SERVER_NAME: 'irc.test', NETWORK_NAME: 'TestNet' };
+    const cfg = loadServerConfigFromLambdaEnv(env);
+    expect(cfg.serverName).toBe('irc.test');
+    expect(cfg.networkName).toBe('TestNet');
+  });
+
+  it('applies schema defaults for unspecified numeric knobs', () => {
+    const cfg = loadServerConfigFromLambdaEnv({ SERVER_NAME: 's', NETWORK_NAME: 'n' });
+    expect(typeof cfg.maxClients).toBe('number');
+    expect(typeof cfg.nickLen).toBe('number');
+  });
+
+  it('throws when SERVER_NAME is missing', () => {
+    expect(() => loadServerConfigFromLambdaEnv({})).toThrow();
+  });
+
+  it('round-trips MOTD lines into ParsedServerConfig', () => {
+    const cfg = loadServerConfigFromLambdaEnv({
+      SERVER_NAME: 's',
+      NETWORK_NAME: 'n',
+      MOTD: 'a\nb',
+    });
+    expect(cfg.motdLines).toEqual(['a', 'b']);
+  });
+
+  it('round-trips the CDK default MOTD (newline-joined) into exactly two motdLines', () => {
+    const cdkDefaultMotd =
+      'Welcome to the ServerlessIRCd deployment.\nThis server runs on AWS Lambda.';
+    const cfg = loadServerConfigFromLambdaEnv({
+      SERVER_NAME: 's',
+      NETWORK_NAME: 'n',
+      MOTD: cdkDefaultMotd,
+    });
+    expect(cfg.motdLines).toHaveLength(2);
+    expect(cfg.motdLines).toEqual([
+      'Welcome to the ServerlessIRCd deployment.',
+      'This server runs on AWS Lambda.',
+    ]);
+  });
+
+  it('treats a comma as part of a line, not a line delimiter', () => {
+    const cfg = loadServerConfigFromLambdaEnv({
+      SERVER_NAME: 's',
+      NETWORK_NAME: 'n',
+      MOTD: 'first line, still first line',
+    });
+    expect(cfg.motdLines).toEqual(['first line, still first line']);
+    expect(cfg.motdLines).toHaveLength(1);
+  });
+
+  it('honours CHANNEL_PREFIXES override', () => {
+    const cfg = loadServerConfigFromLambdaEnv({
+      SERVER_NAME: 's',
+      NETWORK_NAME: 'n',
+      CHANNEL_PREFIXES: '&',
+    });
+    expect(cfg.channelPrefixes).toBe('&');
+  });
+
+  it('honours MAX_CLIENTS override', () => {
+    const cfg = loadServerConfigFromLambdaEnv({
+      SERVER_NAME: 's',
+      NETWORK_NAME: 'n',
+      MAX_CLIENTS: '5000',
+    });
+    expect(cfg.maxClients).toBe(5000);
+  });
+
+  it('honours QUIT_MESSAGE override', () => {
+    const cfg = loadServerConfigFromLambdaEnv({
+      SERVER_NAME: 's',
+      NETWORK_NAME: 'n',
+      QUIT_MESSAGE: 'goodbye',
+    });
+    expect(cfg.quitMessage).toBe('goodbye');
+  });
+
+  it('round-trips SASL_ACCOUNTS into cfg.saslAccounts end-to-end', () => {
+    const cfg = loadServerConfigFromLambdaEnv({
+      SERVER_NAME: 's',
+      NETWORK_NAME: 'n',
+      SASL_ACCOUNTS: 'alice:secret\nbob:b-pass',
+    });
+    expect(cfg.saslAccounts).toEqual([
+      { username: 'alice', password: 'secret' },
+      { username: 'bob', password: 'b-pass' },
+    ]);
+  });
+});

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

@@ -0,0 +1,336 @@
+/**
+ * Integration tests for QUIT fanout on `$disconnect` (and on the
+ * `GoneException` cleanup path).
+ *
+ * Verifies that when connection A tears down, every peer sharing a
+ * channel with A receives the canonical `:A QUIT :reason` line via
+ * `managementApi.postToConnection`, and that a gone peer during fanout
+ * triggers lazy cleanup instead of crashing.
+ */
+
+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 { afterEach, beforeEach, describe, expect, it } from 'vitest';
+import { AwsRuntime, cleanupConnection, type PostToConnection } from '../src/aws-runtime.js';
+import { handleDisconnect } from '../src/handlers/disconnect.js';
+import {
+  type HandlerDeps,
+  __resetHandlerCacheForTests,
+  dispatch,
+} from '../src/handlers/index.js';
+import { TABLE_DEFS } from '../src/cdk-table-defs.js';
+import { createDynamoDocumentClient } from '../src/dynamo.js';
+import { marshalChannelMember, marshalConnection, marshalNick } from '../src/serialize.js';
+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,
+  serverName: 'irc.example.com',
+  networkName: 'ExampleNet',
+  motdLines: [],
+};
+
+interface Fixture {
+  tables: TablesConfig;
+  client: ReturnType<typeof createDynamoDocumentClient>;
+  cleanup: () => Promise<void>;
+}
+
+let fx: Fixture | null;
+
+async function makeFixture(): Promise<Fixture> {
+  if (endpoint === undefined) throw new Error('DYNAMO_ENDPOINT missing');
+  const prefix = `q${Date.now()}-${Math.floor(Math.random() * 1e6)}-`;
+  const tables = Object.fromEntries(
+    Object.keys(TABLE_DEFS).map((name) => [name, `${prefix}${name}`]),
+  ) as TablesConfig;
+  const client = createDynamoDocumentClient({ endpoint });
+  for (const [logical, props] of Object.entries(TABLE_DEFS)) {
+    const pkName = props.partitionKey?.name;
+    const skName = props.sortKey?.name;
+    if (pkName === undefined) throw new Error(`table ${logical} missing partitionKey`);
+    const attributeDefinitions: Array<{ AttributeName: string; AttributeType: 'S' }> = [
+      { AttributeName: pkName, AttributeType: 'S' },
+    ];
+    const keySchema: Array<{ AttributeName: string; KeyType: 'HASH' | 'RANGE' }> = [
+      { AttributeName: pkName, KeyType: 'HASH' },
+    ];
+    if (skName !== undefined) {
+      attributeDefinitions.push({ AttributeName: skName, AttributeType: 'S' });
+      keySchema.push({ AttributeName: skName, KeyType: 'RANGE' });
+    }
+    await client.send(
+      new CreateTableCommand({
+        TableName: `${prefix}${logical}`,
+        AttributeDefinitions: attributeDefinitions,
+        KeySchema: keySchema,
+        BillingMode: 'PAY_PER_REQUEST',
+      }),
+    );
+  }
+  return {
+    tables,
+    client,
+    cleanup: async () => {
+      for (const logical of Object.keys(TABLE_DEFS)) {
+        try {
+          await client.send(new DeleteTableCommand({ TableName: `${prefix}${logical}` }));
+        } catch {
+          // best-effort
+        }
+      }
+    },
+  };
+}
+
+/** Seed a registered connection with nick/user/host and a channel membership. */
+async function seedConnection(
+  client: ReturnType<typeof createDynamoDocumentClient>,
+  tables: TablesConfig,
+  connId: string,
+  nick: string,
+  channel: string,
+): Promise<void> {
+  const now = Date.now();
+  const state = createConnection({ id: connId, connectedSince: now });
+  state.registration = 'registered';
+  state.nick = nick as Nick;
+  state.user = nick;
+  state.host = 'x';
+  state.realname = nick;
+  state.joinedChannels = new Set([channel as never]);
+  state.lastSeen = now;
+  await client.send(
+    new PutCommand({ TableName: tables.Connections, Item: marshalConnection(state, now) }),
+  );
+  await client.send(
+    new PutCommand({
+      TableName: tables.Nicks,
+      Item: marshalNick(nick as Nick, connId, now),
+    }),
+  );
+  await client.send(
+    new PutCommand({
+      TableName: tables.ChannelMembers,
+      Item: marshalChannelMember(channel, {
+        conn: connId,
+        nick: nick as Nick,
+        op: false,
+        voice: false,
+      }),
+    }),
+  );
+}
+
+/** Records every `postToConnection` call keyed by ConnectionId. */
+class RecordingPostToConnection implements PostToConnection {
+  readonly sent = new Map<string, string[]>();
+  private readonly gone = new Set<string>();
+  private readonly errorPeers = new Map<string, Error>();
+  async postToConnection(input: { ConnectionId: string; Data: string }): Promise<unknown> {
+    const custom = this.errorPeers.get(input.ConnectionId);
+    if (custom !== undefined) throw custom;
+    if (this.gone.has(input.ConnectionId)) {
+      throw new GoneException({ $metadata: {}, message: 'Gone' });
+    }
+    const list = this.sent.get(input.ConnectionId) ?? [];
+    for (const line of input.Data.split('\r\n')) {
+      if (line.length > 0) list.push(line);
+    }
+    this.sent.set(input.ConnectionId, list);
+    return {};
+  }
+  markGone(connId: string): void {
+    this.gone.add(connId);
+  }
+  markError(connId: string, err: Error): void {
+    this.errorPeers.set(connId, err);
+  }
+}
+
+function probe(
+  client: ReturnType<typeof createDynamoDocumentClient>,
+  tables: TablesConfig,
+): AwsRuntime {
+  return new AwsRuntime({
+    dynamo: client,
+    tables,
+    connId: '__probe__',
+    handlers: { send: () => {}, disconnect: () => {}, snapshot: () => undefined },
+    managementApi: null,
+  });
+}
+
+describe.skipIf(!available)('$disconnect QUIT fanout', () => {
+  beforeEach(async () => {
+    fx = await makeFixture();
+  });
+  afterEach(async () => {
+    if (fx) await fx.cleanup();
+    fx = null;
+  });
+
+  it('handleDisconnect fans the QUIT line out to every other channel member', async () => {
+    await seedConnection(fx!.client, fx!.tables, 'a', 'alice', '#room');
+    await seedConnection(fx!.client, fx!.tables, 'b', 'bob', '#room');
+
+    const mgmt = new RecordingPostToConnection();
+    await handleDisconnect({
+      dynamo: fx!.client,
+      tables: fx!.tables,
+      connectionId: 'a',
+      managementApi: mgmt,
+    });
+
+    // Peer b received the QUIT line for alice.
+    const bobReceived = mgmt.sent.get('b') ?? [];
+    expect(bobReceived).toContain(':alice!alice@x QUIT :Client Quit');
+    // The disconnecting connection never receives its own QUIT.
+    expect(mgmt.sent.has('a')).toBe(false);
+  });
+
+  it('handleDisconnect without a managementApi performs no fanout but still cleans up', async () => {
+    await seedConnection(fx!.client, fx!.tables, 'a', 'alice', '#room');
+    await handleDisconnect({
+      dynamo: fx!.client,
+      tables: fx!.tables,
+      connectionId: 'a',
+      managementApi: null,
+    });
+    const p = probe(fx!.client, fx!.tables);
+    expect(await p.getConnectionInfo('a')).toBeNull();
+    expect(await p.lookupNick('alice' as Nick)).toBeNull();
+  });
+
+  it('a never-registered connection disconnects without fanout (no nick)', async () => {
+    const mgmt = new RecordingPostToConnection();
+    await handleDisconnect({
+      dynamo: fx!.client,
+      tables: fx!.tables,
+      connectionId: 'nobody',
+      managementApi: mgmt,
+    });
+    expect(mgmt.sent.size).toBe(0);
+  });
+
+  it('fanout to a gone peer triggers lazy cleanup instead of crashing', async () => {
+    await seedConnection(fx!.client, fx!.tables, 'a', 'alice', '#room');
+    await seedConnection(fx!.client, fx!.tables, 'b', 'bob', '#room');
+
+    const mgmt = new RecordingPostToConnection();
+    mgmt.markGone('b');
+
+    await expect(
+      handleDisconnect({
+        dynamo: fx!.client,
+        tables: fx!.tables,
+        connectionId: 'a',
+        managementApi: mgmt,
+      }),
+    ).resolves.toBeUndefined();
+
+    // The gone peer b was lazily cleaned up (Connection row removed).
+    const p = probe(fx!.client, fx!.tables);
+    expect(await p.getConnectionInfo('b')).toBeNull();
+  });
+
+  it('cleanupConnection directly broadcasts QUIT when given a managementApi', async () => {
+    await seedConnection(fx!.client, fx!.tables, 'a', 'alice', '#room');
+    await seedConnection(fx!.client, fx!.tables, 'b', 'bob', '#room');
+
+    const mgmt = new RecordingPostToConnection();
+    await cleanupConnection(fx!.client, fx!.tables, 'a', mgmt);
+
+    const bobReceived = mgmt.sent.get('b') ?? [];
+    expect(bobReceived).toContain(':alice!alice@x QUIT :Client Quit');
+    const p = probe(fx!.client, fx!.tables);
+    expect(await p.getConnectionInfo('a')).toBeNull();
+  });
+
+  it('the $disconnect dispatch route fans QUIT out to peers via the management API', async () => {
+    const deps: HandlerDeps = {
+      dynamo: fx!.client,
+      tables: fx!.tables,
+      serverConfig: SERVER_CONFIG,
+      motd: new StaticMotdProvider([]),
+      messages: { record() {}, query: () => Promise.resolve([]) } as never,
+      managementApi: null,
+    };
+    // Register alice + bob into the same channel via $default frames.
+    const mgmt = new RecordingPostToConnection();
+    deps.managementApi = mgmt as never;
+    await dispatch({ requestContext: { routeKey: '$connect', connectionId: 'a' } }, deps);
+    await dispatch({ requestContext: { routeKey: '$connect', connectionId: 'b' } }, deps);
+    await dispatch(
+      { requestContext: { routeKey: '$default', connectionId: 'a' }, body: 'NICK alice\r\nUSER alice 0 * :Alice\r\nJOIN #room\r\n' },
+      deps,
+    );
+    await dispatch(
+      { requestContext: { routeKey: '$default', connectionId: 'b' }, body: 'NICK bob\r\nUSER bob 0 * :Bob\r\nJOIN #room\r\n' },
+      deps,
+    );
+    mgmt.sent.clear();
+
+    // alice disconnects.
+    await dispatch({ requestContext: { routeKey: '$disconnect', connectionId: 'a' } }, deps);
+
+    const bobReceived = mgmt.sent.get('b') ?? [];
+    expect(bobReceived.some((l) => /^:alice!alice\S* QUIT :/.test(l))).toBe(true);
+  });
+
+  it('the send() GoneException cleanup path also broadcasts QUIT to the gone peer\'s channels', async () => {
+    // alice and carol share #room; bob shares a different channel with carol.
+    await seedConnection(fx!.client, fx!.tables, 'alice', 'alice', '#room');
+    await seedConnection(fx!.client, fx!.tables, 'carol', 'carol', '#room');
+
+    // A management double where alice is "gone" (raises GoneException).
+    const mgmt = new RecordingPostToConnection();
+    mgmt.markGone('alice');
+
+    const runtime = new AwsRuntime({
+      dynamo: fx!.client,
+      tables: fx!.tables,
+      connId: 'carol',
+      handlers: { send: () => {}, disconnect: () => {}, snapshot: () => undefined },
+      managementApi: mgmt,
+    });
+
+    // carol sends to alice → GoneException → cleanupConnection(alice)
+    // → alice's QUIT fans out to carol (the other #room member).
+    await runtime.send('alice', [{ text: ':carol!carol@x PRIVMSG alice :hi' } as never]);
+
+    const carolReceived = mgmt.sent.get('carol') ?? [];
+    expect(carolReceived.some((l) => l.startsWith(':alice!alice@x QUIT :'))).toBe(true);
+    // alice was cleaned up.
+    const p = probe(fx!.client, fx!.tables);
+    expect(await p.getConnectionInfo('alice')).toBeNull();
+  });
+
+  it('fanout to a peer that throws a non-Gone error rethrows (no silent swallow)', async () => {
+    await seedConnection(fx!.client, fx!.tables, 'a', 'alice', '#room');
+    await seedConnection(fx!.client, fx!.tables, 'b', 'bob', '#room');
+
+    const mgmt = new RecordingPostToConnection();
+    mgmt.markError('b', new Error('transient network failure'));
+
+    await expect(
+      handleDisconnect({
+        dynamo: fx!.client,
+        tables: fx!.tables,
+        connectionId: 'a',
+        managementApi: mgmt,
+      }),
+    ).rejects.toThrow('transient network failure');
+  });
+});

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

@@ -0,0 +1,57 @@
+/**
+ * Unit tests for `createDynamoDocumentClient`.
+ *
+ * The factory is intentionally tiny; these tests exercise every branch
+ * (with/without endpoint, with/without region, env fallback) without
+ * actually sending a command.
+ */
+
+import { describe, expect, it } from 'vitest';
+import { createDynamoDocumentClient } from '../src/dynamo.js';
+
+describe('createDynamoDocumentClient', () => {
+  it('builds a client with an explicit endpoint', () => {
+    const c = createDynamoDocumentClient({ endpoint: 'http://localhost:8000' });
+    expect(c).toBeDefined();
+    expect(typeof c.send).toBe('function');
+  });
+
+  it('builds a client with explicit endpoint + region', () => {
+    const c = createDynamoDocumentClient({
+      endpoint: 'http://localhost:8000',
+      region: 'us-west-2',
+    });
+    expect(c).toBeDefined();
+  });
+
+  it('builds a client with region only (no endpoint)', () => {
+    const c = createDynamoDocumentClient({ region: 'eu-west-1' });
+    expect(c).toBeDefined();
+  });
+
+  it('falls back to AWS_REGION env when neither arg is supplied', () => {
+    const prev = process.env.AWS_REGION;
+    process.env.AWS_REGION = 'ap-southeast-2';
+    try {
+      const c = createDynamoDocumentClient({});
+      expect(c).toBeDefined();
+    } finally {
+      if (prev === undefined) {
+        Reflect.deleteProperty(process.env, 'AWS_REGION');
+      } else {
+        process.env.AWS_REGION = prev;
+      }
+    }
+  });
+
+  it('falls back to us-east-1 when nothing is supplied', () => {
+    const prev = process.env.AWS_REGION;
+    Reflect.deleteProperty(process.env, 'AWS_REGION');
+    try {
+      const c = createDynamoDocumentClient({});
+      expect(c).toBeDefined();
+    } finally {
+      if (prev !== undefined) process.env.AWS_REGION = prev;
+    }
+  });
+});