serverless-ircd 0.1.0 → 0.3.0

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

@@ -0,0 +1,249 @@
+/**
+ * Pure unit tests for `src/serialize.ts`.
+ *
+ * No DynamoDB calls — these tests assert the irc-core → marshalled-row
+ * transforms are correct and round-trip-safe. The DynamoDB-backed
+ * runtime tests live in `aws-runtime.test.ts`.
+ */
+
+import {
+  type ChannelState,
+  type ConnectionState,
+  createChannel,
+  createConnection,
+} from '@serverless-ircd/irc-core';
+import { describe, expect, it } from 'vitest';
+import {
+  marshalChannelMember,
+  marshalChannelMeta,
+  marshalConnection,
+  marshalNick,
+  unmarshalChannelMember,
+  unmarshalChannelMeta,
+  unmarshalConnection,
+  unmarshalNick,
+} from '../src/serialize.js';
+
+describe('marshalConnection / unmarshalConnection', () => {
+  it('round-trips a pre-registration connection with no optional fields', () => {
+    const state = createConnection({ id: 'c1', connectedSince: 100 });
+    const row = marshalConnection(state, 100);
+    const restored = unmarshalConnection(row);
+    expectRestoredConnection(restored, state);
+    expect(row.idleSince).toBe(100);
+    expect(row.version).toBe(1);
+  });
+
+  it('round-trips a fully-registered connection with every optional field set', () => {
+    const state = createConnection({ id: 'c1', connectedSince: 100 });
+    state.nick = 'Alice';
+    state.user = 'alice';
+    state.host = 'example.com';
+    state.realname = 'Alice In Chains';
+    state.passAttempt = 'hunter2';
+    state.account = 'alice-acct';
+    state.away = 'back later';
+    state.saslMech = 'PLAIN';
+    state.saslBuffer = 'partial';
+    state.caps.add('echo-message');
+    state.caps.add('batch');
+    state.joinedChannels.add('#foo');
+    state.joinedChannels.add('#bar');
+    state.userModes.invisible = true;
+
+    const row = marshalConnection(state, 999);
+    const restored = unmarshalConnection(row);
+    expectRestoredConnection(restored, state);
+    expect(row.idleSince).toBe(999);
+  });
+
+  it('stores caps as an array and joinedChannels as a Set (for atomic ADD/DELETE)', () => {
+    const state = createConnection({ id: 'c1', connectedSince: 0 });
+    state.caps.add('echo-message');
+    state.joinedChannels.add('#chan');
+    const row = marshalConnection(state, 0);
+    expect(Array.isArray(row.caps)).toBe(true);
+    expect(row.joinedChannels).toBeInstanceOf(Set);
+    expect((row.joinedChannels as Set<string>).has('#chan')).toBe(true);
+  });
+
+  it('omits joinedChannels from the marshalled row when the set is empty (DynamoDB rejects empty sets)', () => {
+    const state = createConnection({ id: 'c1', connectedSince: 0 });
+    const row = marshalConnection(state, 0);
+    expect(row.joinedChannels).toBeUndefined();
+  });
+
+  it('round-trips a connection whose joinedChannels started empty (attribute absent → empty Set)', () => {
+    const state = createConnection({ id: 'c1', connectedSince: 0 });
+    const row = marshalConnection(state, 0);
+    const restored = unmarshalConnection(row);
+    expect(restored.joinedChannels).toBeInstanceOf(Set);
+    expect(restored.joinedChannels.size).toBe(0);
+  });
+
+  it('rejects a row whose version is newer than the supported schema', () => {
+    const state = createConnection({ id: 'c1', connectedSince: 0 });
+    const row = marshalConnection(state, 0);
+    const future = { ...row, version: 9999 };
+    expect(() => unmarshalConnection(future)).toThrow(/newer than supported/u);
+  });
+
+  it('preserves the connection id as the row primary key', () => {
+    const state = createConnection({ id: 'c-fixed', connectedSince: 0 });
+    const row = marshalConnection(state, 0);
+    expect(row.connectionId).toBe('c-fixed');
+  });
+});
+
+describe('marshalNick / unmarshalNick', () => {
+  it('round-trips a nick reservation row', () => {
+    const row = marshalNick('Alice', 'c1', 123);
+    expect(row.nickLower).toBe('alice');
+    expect(row.nick).toBe('Alice');
+    expect(row.connectionId).toBe('c1');
+    expect(row.reservedAt).toBe(123);
+    expect(unmarshalNick(row)).toEqual({ nick: 'Alice', connectionId: 'c1' });
+  });
+
+  it('lowercases the PK but preserves display case', () => {
+    const row = marshalNick('BoB', 'c2', 0);
+    expect(row.nickLower).toBe('bob');
+    expect(row.nick).toBe('BoB');
+  });
+});
+
+describe('marshalChannelMeta / unmarshalChannelMeta', () => {
+  it('round-trips an empty channel with no topic', () => {
+    const chan = createChannel({
+      name: '#Foo',
+      nameLower: '#foo',
+      createdAt: 42,
+    });
+    const row = marshalChannelMeta(chan);
+    expect(row.channelName).toBe('#foo');
+    expect(row.displayName).toBe('#Foo');
+    expect(row.topicText).toBeUndefined();
+    const members = new Map();
+    const restored = unmarshalChannelMeta(row, members);
+    expectChannelEqual(restored, chan);
+  });
+
+  it('round-trips a channel with topic, modes, banMasks, and pendingInvites', () => {
+    const chan = createChannel({
+      name: '#Foo',
+      nameLower: '#foo',
+      createdAt: 1,
+    });
+    chan.topic = { text: 'welcome', setter: 'alice', setAt: 100 };
+    chan.modes.inviteOnly = true;
+    chan.modes.topicLock = true;
+    chan.modes.key = 'sekret';
+    chan.modes.limit = 25;
+    chan.banMasks.add('*!bad@*');
+    chan.pendingInvites.add('bob');
+
+    const row = marshalChannelMeta(chan);
+    expect(row.topicText).toBe('welcome');
+    expect(row.topicSetter).toBe('alice');
+    expect(row.topicSetAt).toBe(100);
+    expect(row.modes.inviteOnly).toBe(true);
+    expect(row.modes.key).toBe('sekret');
+    expect(row.modes.limit).toBe(25);
+    expect(row.banMasks).toEqual(['*!bad@*']);
+    expect(row.pendingInvites).toEqual(['bob']);
+
+    const restored = unmarshalChannelMeta(row, new Map());
+    expectChannelEqual(restored, chan);
+  });
+
+  it('serializes banMasks and pendingInvites as arrays', () => {
+    const chan = createChannel({ name: '#x', nameLower: '#x', createdAt: 0 });
+    chan.banMasks.add('a');
+    chan.banMasks.add('b');
+    chan.pendingInvites.add('x');
+    const row = marshalChannelMeta(chan);
+    expect(Array.isArray(row.banMasks)).toBe(true);
+    expect(Array.isArray(row.pendingInvites)).toBe(true);
+  });
+
+  it('omits topic fields when the channel has no topic', () => {
+    const chan = createChannel({ name: '#x', nameLower: '#x', createdAt: 0 });
+    const row = marshalChannelMeta(chan);
+    expect(row.topicText).toBeUndefined();
+    expect(row.topicSetter).toBeUndefined();
+    expect(row.topicSetAt).toBeUndefined();
+  });
+
+  it('rehydrates members from the supplied map', () => {
+    const chan = createChannel({ name: '#x', nameLower: '#x', createdAt: 0 });
+    const row = marshalChannelMeta(chan);
+    const members = new Map([['c1', { conn: 'c1', nick: 'alice', op: true, voice: false }]]);
+    const restored = unmarshalChannelMeta(row, members);
+    expect(restored.members.get('c1')).toEqual({
+      conn: 'c1',
+      nick: 'alice',
+      op: true,
+      voice: false,
+    });
+  });
+});
+
+describe('marshalChannelMember / unmarshalChannelMember', () => {
+  it('round-trips a roster entry', () => {
+    const entry = { conn: 'c1', nick: 'alice', op: true, voice: false };
+    const row = marshalChannelMember('#foo', entry);
+    expect(row.channelName).toBe('#foo');
+    expect(row.connectionId).toBe('c1');
+    expect(row.nick).toBe('alice');
+    expect(row.op).toBe(true);
+    expect(row.voice).toBe(false);
+    expect(unmarshalChannelMember(row)).toEqual(entry);
+  });
+
+  it('preserves op/voice=false without coercing to undefined', () => {
+    const entry = { conn: 'c1', nick: 'alice', op: false, voice: false };
+    const row = marshalChannelMember('#foo', entry);
+    expect(row.op).toBe(false);
+    expect(row.voice).toBe(false);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function expectRestoredConnection(restored: ConnectionState, original: ConnectionState): void {
+  expect(restored.id).toBe(original.id);
+  expect(restored.registration).toBe(original.registration);
+  expect(restored.capNegotiating).toBe(original.capNegotiating);
+  expect(restored.caps).toEqual(original.caps);
+  expect(restored.joinedChannels).toEqual(original.joinedChannels);
+  expect(restored.userModes).toEqual(original.userModes);
+  expect(restored.lastSeen).toBe(original.lastSeen);
+  expect(restored.connectedSince).toBe(original.connectedSince);
+  expect(restored.nick).toBe(original.nick);
+  expect(restored.user).toBe(original.user);
+  expect(restored.host).toBe(original.host);
+  expect(restored.realname).toBe(original.realname);
+  expect(restored.passAttempt).toBe(original.passAttempt);
+  expect(restored.account).toBe(original.account);
+  expect(restored.away).toBe(original.away);
+  expect(restored.saslMech).toBe(original.saslMech);
+  expect(restored.saslBuffer).toBe(original.saslBuffer);
+  // Sets must be re-hydrated as Sets, not arrays.
+  expect(restored.caps).toBeInstanceOf(Set);
+  expect(restored.joinedChannels).toBeInstanceOf(Set);
+}
+
+function expectChannelEqual(restored: ChannelState, original: ChannelState): void {
+  expect(restored.name).toBe(original.name);
+  expect(restored.nameLower).toBe(original.nameLower);
+  expect(restored.modes).toEqual(original.modes);
+  expect(restored.banMasks).toEqual(original.banMasks);
+  expect(restored.pendingInvites).toEqual(original.pendingInvites);
+  expect(restored.createdAt).toBe(original.createdAt);
+  expect(restored.topic).toEqual(original.topic);
+  expect(restored.banMasks).toBeInstanceOf(Set);
+  expect(restored.pendingInvites).toBeInstanceOf(Set);
+  expect(restored.members).toBeInstanceOf(Map);
+}

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

@@ -0,0 +1,48 @@
+/**
+ * Smoke test for the global-setup: confirms the DynamoDB Local endpoint
+ * responds to a real SDK call when `DDB_AVAILABLE=1`, and that the test
+ * suite is skipped gracefully otherwise.
+ */
+
+import {
+  CreateTableCommand,
+  DeleteTableCommand,
+  DescribeTableCommand,
+} from '@aws-sdk/client-dynamodb';
+import type { DynamoDBDocumentClient } from '@aws-sdk/lib-dynamodb';
+import { describe, expect, it } from 'vitest';
+import { createDynamoDocumentClient } from '../src/index.js';
+
+const available = process.env.DDB_AVAILABLE === '1';
+const endpoint = process.env.DYNAMO_ENDPOINT;
+
+describe.skipIf(!available)('DynamoDB Local endpoint', () => {
+  it('accepts CreateTable + DescribeTable round-trip', async () => {
+    if (endpoint === undefined) {
+      throw new Error('DDB_AVAILABLE=1 but DYNAMO_ENDPOINT is unset');
+    }
+    const client = createDynamoDocumentClient({ endpoint });
+    const tableName = `aws-adapter-smoke-${Date.now()}`;
+    await client.send(
+      new CreateTableCommand({
+        TableName: tableName,
+        AttributeDefinitions: [{ AttributeName: 'pk', AttributeType: 'S' }],
+        KeySchema: [{ AttributeName: 'pk', KeyType: 'HASH' }],
+        BillingMode: 'PAY_PER_REQUEST',
+      }),
+    );
+    const described = await client.send(new DescribeTableCommand({ TableName: tableName }));
+    expect(described.Table?.TableName).toBe(tableName);
+    await client.send(new DeleteTableCommand({ TableName: tableName }));
+  });
+});
+
+describe.skipIf(available)('DynamoDB Local unavailable', () => {
+  it('skips the integration suite', () => {
+    expect(process.env.DDB_AVAILABLE ?? '0').toBe('0');
+  });
+});
+
+// Reference the type so TS doesn't complain about unused import on skip paths.
+export type { DynamoDBDocumentClient } from '@aws-sdk/lib-dynamodb';
+void (null as unknown as DynamoDBDocumentClient);