serverless-ircd 0.1.0 → 0.3.0

package/packages/irc-core/tests/message-store.test.ts

@@ -0,0 +1,530 @@
+import { describe, expect, it } from 'vitest';
+import { InMemoryMessageStore, type MessageStore, type StoredMessage } from '../src/ports';
+
+/** Builds a stored message with sensible defaults for tests. */
+function msg(
+  chan: string,
+  msgid: string,
+  text: string,
+  time: number,
+  command: StoredMessage['command'] = 'PRIVMSG',
+): StoredMessage {
+  return {
+    msgid,
+    time,
+    chan: chan.toLowerCase(),
+    command,
+    nick: 'alice',
+    user: 'alice',
+    host: 'example.com',
+    text,
+  };
+}
+
+/** Records 5 chronological messages into the store and returns it. */
+function seededStore(maxPerChannel = 100): InMemoryMessageStore {
+  const store = new InMemoryMessageStore(maxPerChannel);
+  store.record(msg('#foo', 'm1', 'one', 1_000));
+  store.record(msg('#foo', 'm2', 'two', 2_000));
+  store.record(msg('#foo', 'm3', 'three', 3_000));
+  store.record(msg('#foo', 'm4', 'four', 4_000));
+  store.record(msg('#foo', 'm5', 'five', 5_000));
+  return store;
+}
+
+const ids = (ms: StoredMessage[]): string[] => ms.map((m) => m.msgid);
+
+describe('InMemoryMessageStore — record + LATEST', () => {
+  it('implements the MessageStore port', () => {
+    const store: MessageStore = new InMemoryMessageStore();
+    expect(store).toBeDefined();
+  });
+
+  it('returns recorded messages chronologically (oldest first) for LATEST *', () => {
+    const store = seededStore();
+    const out = store.query({ chan: '#foo', direction: 'latest', limit: 50 });
+    expect(ids(out)).toEqual(['m1', 'm2', 'm3', 'm4', 'm5']);
+  });
+
+  it('returns at most `limit` most-recent messages, oldest-first', () => {
+    const store = seededStore();
+    const out = store.query({ chan: '#foo', direction: 'latest', limit: 2 });
+    expect(ids(out)).toEqual(['m4', 'm5']);
+  });
+
+  it('returns fewer than the limit when history is shorter (no error)', () => {
+    const store = seededStore();
+    const out = store.query({ chan: '#foo', direction: 'latest', limit: 50 });
+    expect(out).toHaveLength(5);
+  });
+
+  it('returns an empty array for a channel with no history', () => {
+    const store = new InMemoryMessageStore();
+    const out = store.query({ chan: '#empty', direction: 'latest', limit: 50 });
+    expect(out).toEqual([]);
+  });
+
+  it('returns an empty array when the limit is zero', () => {
+    const store = seededStore();
+    const out = store.query({ chan: '#foo', direction: 'latest', limit: 0 });
+    expect(out).toEqual([]);
+  });
+
+  it('matches channel names case-insensitively', () => {
+    const store = seededStore();
+    const out = store.query({ chan: '#FOO', direction: 'latest', limit: 1 });
+    expect(ids(out)).toEqual(['m5']);
+  });
+
+  it('LATEST with a msgid pivot returns up to that msgid inclusive, newest-first bounded', () => {
+    const store = seededStore();
+    const out = store.query({ chan: '#foo', direction: 'latest', limit: 50, msgid: 'm3' });
+    expect(ids(out)).toEqual(['m1', 'm2', 'm3']);
+  });
+});
+
+describe('InMemoryMessageStore — ring buffer eviction', () => {
+  it('drops the oldest message once the per-channel cap is exceeded', () => {
+    const store = new InMemoryMessageStore(3);
+    store.record(msg('#foo', 'm1', 'one', 1_000));
+    store.record(msg('#foo', 'm2', 'two', 2_000));
+    store.record(msg('#foo', 'm3', 'three', 3_000));
+    store.record(msg('#foo', 'm4', 'four', 4_000));
+    const out = store.query({ chan: '#foo', direction: 'latest', limit: 50 });
+    expect(ids(out)).toEqual(['m2', 'm3', 'm4']);
+  });
+
+  it('keeps every message when count is below the cap', () => {
+    const store = new InMemoryMessageStore(100);
+    store.record(msg('#foo', 'm1', 'one', 1_000));
+    store.record(msg('#foo', 'm2', 'two', 2_000));
+    const out = store.query({ chan: '#foo', direction: 'latest', limit: 50 });
+    expect(out).toHaveLength(2);
+  });
+
+  it('defaults the per-channel cap to 100 when omitted', () => {
+    const store = new InMemoryMessageStore();
+    for (let i = 0; i < 120; i++) {
+      store.record(msg('#foo', `m${i}`, `t${i}`, 1_000 + i));
+    }
+    const out = store.query({ chan: '#foo', direction: 'latest', limit: 200 });
+    // Oldest 20 evicted; the most recent 100 remain.
+    expect(out).toHaveLength(100);
+    expect(out[0]?.msgid).toBe('m20');
+    expect(out[99]?.msgid).toBe('m119');
+  });
+
+  it('evicts per channel independently (other channels are unaffected)', () => {
+    const store = new InMemoryMessageStore(2);
+    store.record(msg('#foo', 'f1', 'one', 1_000));
+    store.record(msg('#bar', 'b1', 'one', 1_000));
+    store.record(msg('#foo', 'f2', 'two', 2_000));
+    store.record(msg('#foo', 'f3', 'three', 3_000)); // evicts f1
+    expect(ids(store.query({ chan: '#foo', direction: 'latest', limit: 10 }))).toEqual([
+      'f2',
+      'f3',
+    ]);
+    expect(ids(store.query({ chan: '#bar', direction: 'latest', limit: 10 }))).toEqual(['b1']);
+  });
+});
+
+describe('InMemoryMessageStore — BEFORE / AFTER / AROUND / BETWEEN', () => {
+  it('BEFORE returns the N messages preceding the pivot, oldest-first', () => {
+    const store = seededStore();
+    const out = store.query({ chan: '#foo', direction: 'before', limit: 2, msgid: 'm4' });
+    expect(ids(out)).toEqual(['m2', 'm3']);
+  });
+
+  it('BEFORE at the start of history returns fewer than the limit with no error', () => {
+    const store = seededStore();
+    const out = store.query({ chan: '#foo', direction: 'before', limit: 10, msgid: 'm1' });
+    expect(out).toEqual([]);
+  });
+
+  it('BEFORE with a limit larger than available returns everything before the pivot', () => {
+    const store = seededStore();
+    const out = store.query({ chan: '#foo', direction: 'before', limit: 50, msgid: 'm3' });
+    expect(ids(out)).toEqual(['m1', 'm2']);
+  });
+
+  it('AFTER returns the N messages following the pivot, oldest-first', () => {
+    const store = seededStore();
+    const out = store.query({ chan: '#foo', direction: 'after', limit: 2, msgid: 'm2' });
+    expect(ids(out)).toEqual(['m3', 'm4']);
+  });
+
+  it('AFTER at the end of history returns an empty slice', () => {
+    const store = seededStore();
+    const out = store.query({ chan: '#foo', direction: 'after', limit: 10, msgid: 'm5' });
+    expect(out).toEqual([]);
+  });
+
+  it('AROUND returns messages spanning the pivot (half before, the pivot, half after)', () => {
+    const store = seededStore();
+    // limit 3 → one before, the pivot, one after
+    const out = store.query({ chan: '#foo', direction: 'around', limit: 3, msgid: 'm3' });
+    expect(ids(out)).toEqual(['m2', 'm3', 'm4']);
+  });
+
+  it('AROUND at the start of history returns the first N including the pivot', () => {
+    const store = seededStore();
+    const out = store.query({ chan: '#foo', direction: 'around', limit: 3, msgid: 'm1' });
+    expect(ids(out)).toEqual(['m1', 'm2', 'm3']);
+  });
+
+  it('BETWEEN returns messages after m1 up to and including m2, oldest-first', () => {
+    const store = seededStore();
+    const out = store.query({
+      chan: '#foo',
+      direction: 'between',
+      limit: 50,
+      msgid: 'm2',
+      msgid2: 'm4',
+    });
+    expect(ids(out)).toEqual(['m3', 'm4']);
+  });
+
+  it('BETWEEN with bounds at the extremes returns the inner slice', () => {
+    const store = seededStore();
+    const out = store.query({
+      chan: '#foo',
+      direction: 'between',
+      limit: 50,
+      msgid: 'm1',
+      msgid2: 'm5',
+    });
+    expect(ids(out)).toEqual(['m2', 'm3', 'm4', 'm5']);
+  });
+});
+
+describe('InMemoryMessageStore — hasMsgid', () => {
+  it('returns true for a recorded msgid in the channel', () => {
+    const store = seededStore();
+    expect(store.hasMsgid('#foo', 'm3')).toBe(true);
+  });
+
+  it('returns false for an unknown msgid', () => {
+    const store = seededStore();
+    expect(store.hasMsgid('#foo', 'nope')).toBe(false);
+  });
+
+  it('returns false when the msgid exists in another channel', () => {
+    const store = new InMemoryMessageStore();
+    store.record(msg('#foo', 'm1', 'one', 1_000));
+    expect(store.hasMsgid('#bar', 'm1')).toBe(false);
+  });
+
+  it('returns false for an evicted (oldest) msgid', () => {
+    const store = new InMemoryMessageStore(2);
+    store.record(msg('#foo', 'm1', 'one', 1_000));
+    store.record(msg('#foo', 'm2', 'two', 2_000));
+    store.record(msg('#foo', 'm3', 'three', 3_000)); // evicts m1
+    expect(store.hasMsgid('#foo', 'm1')).toBe(false);
+    expect(store.hasMsgid('#foo', 'm2')).toBe(true);
+  });
+
+  it('matches channel name case-insensitively', () => {
+    const store = seededStore();
+    expect(store.hasMsgid('#FOO', 'm3')).toBe(true);
+  });
+});
+
+describe('InMemoryMessageStore — targets', () => {
+  it('enumerates channels with activity inside the window, newest first', () => {
+    const store = new InMemoryMessageStore();
+    store.record(msg('#foo', 'f1', 'one', 1_000));
+    store.record(msg('#bar', 'b1', 'one', 5_000));
+    store.record(msg('#foo', 'f2', 'two', 3_000));
+    const out = store.targets(0, 10_000);
+    expect(out).toEqual([
+      { chan: '#bar', time: 5_000 },
+      { chan: '#foo', time: 3_000 },
+    ]);
+  });
+
+  it('excludes channels whose only activity is outside the window', () => {
+    const store = new InMemoryMessageStore();
+    store.record(msg('#foo', 'f1', 'one', 1_000));
+    store.record(msg('#bar', 'b1', 'one', 10_000));
+    const out = store.targets(2_000, 5_000);
+    expect(out).toEqual([]);
+  });
+
+  it('uses the most recent in-window time per channel', () => {
+    const store = new InMemoryMessageStore();
+    store.record(msg('#foo', 'f1', 'one', 1_000));
+    store.record(msg('#foo', 'f2', 'two', 4_000));
+    store.record(msg('#foo', 'f3', 'three', 9_000)); // outside window
+    const out = store.targets(0, 5_000);
+    expect(out).toEqual([{ chan: '#foo', time: 4_000 }]);
+  });
+
+  it('returns an empty array when the store has no messages at all', () => {
+    const store = new InMemoryMessageStore();
+    expect(store.targets(0, 10_000)).toEqual([]);
+  });
+});
+
+describe('InMemoryMessageStore — query guards', () => {
+  it('returns an empty array for a BEFORE/AFTER pivot msgid that does not exist', () => {
+    const store = seededStore();
+    expect(store.query({ chan: '#foo', direction: 'before', limit: 5, msgid: 'missing' })).toEqual(
+      [],
+    );
+    expect(store.query({ chan: '#foo', direction: 'after', limit: 5, msgid: 'missing' })).toEqual(
+      [],
+    );
+  });
+});
+
+describe('InMemoryMessageStore — recent (JOIN playback query)', () => {
+  it('returns the most recent `limit` overall when no marker is supplied', () => {
+    const store = seededStore();
+    const out = store.recent('#foo', undefined, 2);
+    expect(ids(out)).toEqual(['m4', 'm5']);
+  });
+
+  it('returns the most recent messages strictly after the marker, oldest-first', () => {
+    const store = seededStore(); // m1..m5
+    const out = store.recent('#foo', 'm2', 50);
+    expect(ids(out)).toEqual(['m3', 'm4', 'm5']);
+  });
+
+  it('caps the after-marker result at `limit` (most recent wins)', () => {
+    const store = seededStore(); // m1..m5
+    // After m1 there are m2..m5 (4); limit 2 → the most recent two: m4, m5.
+    const out = store.recent('#foo', 'm1', 2);
+    expect(ids(out)).toEqual(['m4', 'm5']);
+  });
+
+  it('returns nothing when the marker is the most recent message (no new activity)', () => {
+    const store = seededStore();
+    expect(store.recent('#foo', 'm5', 50)).toEqual([]);
+  });
+
+  it('falls back to most-recent-overall when the marker was evicted', () => {
+    const store = new InMemoryMessageStore(3); // keeps m3..m5 after seeding m1..m5
+    store.record(msg('#foo', 'm1', 'one', 1_000));
+    store.record(msg('#foo', 'm2', 'two', 2_000));
+    store.record(msg('#foo', 'm3', 'three', 3_000));
+    store.record(msg('#foo', 'm4', 'four', 4_000));
+    store.record(msg('#foo', 'm5', 'five', 5_000));
+    // m1 evicted; marker m1 unknown → replay most recent `limit`.
+    const out = store.recent('#foo', 'm1', 2);
+    expect(ids(out)).toEqual(['m4', 'm5']);
+  });
+
+  it('returns an empty array for a channel with no history', () => {
+    const store = new InMemoryMessageStore();
+    expect(store.recent('#empty', undefined, 50)).toEqual([]);
+  });
+
+  it('returns an empty array when limit is zero', () => {
+    const store = seededStore();
+    expect(store.recent('#foo', undefined, 0)).toEqual([]);
+  });
+
+  it('matches channel name case-insensitively', () => {
+    const store = seededStore();
+    expect(ids(store.recent('#FOO', undefined, 1))).toEqual(['m5']);
+  });
+});
+
+// ============================================================================
+// query() defensive default branch
+// ============================================================================
+
+describe('InMemoryMessageStore — query default branch', () => {
+  it('returns an empty array for an unrecognized direction (defensive)', () => {
+    const store = seededStore();
+    // The HistoryDirection union exhaustively matches the switch; cast through
+    // unknown to exercise the unreachable default branch so it stays a safety
+    // net rather than dead code from coverage's point of view.
+    const result = store.query({
+      chan: '#foo',
+      direction: 'bogus' as unknown as 'latest',
+      limit: 5,
+    });
+    expect(result).toEqual([]);
+  });
+
+  it('returns an empty array when query limit is zero (tail early return)', () => {
+    const store = seededStore();
+    expect(store.query({ chan: '#foo', direction: 'latest', limit: 0 })).toEqual([]);
+  });
+});
+
+// ============================================================================
+// query() edge cases (defensive branches)
+// ============================================================================
+
+describe('InMemoryMessageStore — query defensive branches', () => {
+  it('LATEST with an unknown msgid pivot returns an empty array', () => {
+    const store = seededStore();
+    expect(
+      ids(
+        store.query({
+          chan: '#foo',
+          direction: 'latest',
+          limit: 5,
+          msgid: 'ghost',
+        }),
+      ),
+    ).toEqual([]);
+  });
+
+  it('BEFORE with an undefined msgid returns an empty array', () => {
+    const store = seededStore();
+    expect(
+      store.query({
+        chan: '#foo',
+        direction: 'before',
+        limit: 5,
+        msgid: undefined as unknown as string,
+      }),
+    ).toEqual([]);
+  });
+
+  it('BEFORE with an unknown msgid returns an empty array', () => {
+    const store = seededStore();
+    expect(
+      ids(
+        store.query({
+          chan: '#foo',
+          direction: 'before',
+          limit: 5,
+          msgid: 'ghost',
+        }),
+      ),
+    ).toEqual([]);
+  });
+
+  it('AFTER with an undefined msgid returns an empty array', () => {
+    const store = seededStore();
+    expect(
+      store.query({
+        chan: '#foo',
+        direction: 'after',
+        limit: 5,
+        msgid: undefined as unknown as string,
+      }),
+    ).toEqual([]);
+  });
+
+  it('AFTER with an unknown msgid returns an empty array', () => {
+    const store = seededStore();
+    expect(
+      ids(
+        store.query({
+          chan: '#foo',
+          direction: 'after',
+          limit: 5,
+          msgid: 'ghost',
+        }),
+      ),
+    ).toEqual([]);
+  });
+
+  it('AROUND with an undefined msgid returns an empty array', () => {
+    const store = seededStore();
+    expect(
+      store.query({
+        chan: '#foo',
+        direction: 'around',
+        limit: 5,
+        msgid: undefined as unknown as string,
+      }),
+    ).toEqual([]);
+  });
+
+  it('AROUND with an unknown msgid returns an empty array', () => {
+    const store = seededStore();
+    expect(
+      ids(
+        store.query({
+          chan: '#foo',
+          direction: 'around',
+          limit: 5,
+          msgid: 'ghost',
+        }),
+      ),
+    ).toEqual([]);
+  });
+
+  it('AROUND slides the window right when the pivot is near the start', () => {
+    const store = seededStore();
+    // Pivot at m1, limit 4. Naive centering would start at -1; the slide
+    // pins it to 0. Covers `start + limit > arr.length` is false here, but
+    // the `start < 0 → start = 0` branch fires.
+    expect(
+      ids(
+        store.query({
+          chan: '#foo',
+          direction: 'around',
+          limit: 4,
+          msgid: 'm1',
+        }),
+      ),
+    ).toEqual(['m1', 'm2', 'm3', 'm4']);
+  });
+
+  it('AROUND slides the window left and clamps when limit exceeds the array', () => {
+    // Seed a 2-message channel; AROUND with limit 5 forces both slide rules.
+    const store = new InMemoryMessageStore();
+    store.record(msg('#tiny', 'a1', 'one', 1_000));
+    store.record(msg('#tiny', 'a2', 'two', 2_000));
+    expect(
+      ids(
+        store.query({
+          chan: '#tiny',
+          direction: 'around',
+          limit: 5,
+          msgid: 'a1',
+        }),
+      ),
+    ).toEqual(['a1', 'a2']);
+  });
+
+  it('BETWEEN with undefined lo returns an empty array', () => {
+    const store = seededStore();
+    expect(
+      store.query({
+        chan: '#foo',
+        direction: 'between',
+        limit: 5,
+        msgid: undefined as unknown as string,
+        msgid2: 'm3',
+      }),
+    ).toEqual([]);
+  });
+
+  it('BETWEEN with an unknown bound returns an empty array', () => {
+    const store = seededStore();
+    expect(
+      ids(
+        store.query({
+          chan: '#foo',
+          direction: 'between',
+          limit: 5,
+          msgid: 'ghost',
+          msgid2: 'm3',
+        }),
+      ),
+    ).toEqual([]);
+  });
+
+  it('BETWEEN with lo >= hi returns an empty array', () => {
+    const store = seededStore();
+    expect(
+      ids(
+        store.query({
+          chan: '#foo',
+          direction: 'between',
+          limit: 5,
+          msgid: 'm3',
+          msgid2: 'm1',
+        }),
+      ),
+    ).toEqual([]);
+  });
+});

package/packages/irc-core/tests/parser.test.ts

@@ -1,6 +1,6 @@
 import { describe, expect, it } from 'vitest';
 import type { IrcMessage } from '../src/protocol/messages';
-import { IrcParseError, parse } from '../src/protocol/parser';
+import { IrcParseError, MAX_INPUT_BYTES, parse } from '../src/protocol/parser';
 
 describe('parse — golden vectors', () => {
   it('parses a simple command with a channel and trailing text', () => {
@@ -160,3 +160,46 @@ describe('parse — malformed input', () => {
     expect(() => parse('12 hi')).toThrow(IrcParseError);
   });
 });
+
+describe('parse — RFC 1459 §2.3 input line-length cap', () => {
+  it('accepts a line whose body is exactly 512 bytes (post-CRLF-strip)', () => {
+    // 512 = "PRIVMSG #foo :" (14) + 498 'x' chars = 512-byte body.
+    const body = 'x'.repeat(MAX_INPUT_BYTES - 'PRIVMSG #foo :'.length);
+    const line = `PRIVMSG #foo :${body}`;
+    expect(line.length).toBe(MAX_INPUT_BYTES);
+    const parsed = parse(line);
+    expect(parsed.params).toEqual(['#foo', body]);
+  });
+
+  it('accepts a line whose body is exactly 512 bytes including a trailing CR-LF', () => {
+    const body = 'x'.repeat(MAX_INPUT_BYTES - 'PRIVMSG #foo :'.length);
+    const parsed = parse(`PRIVMSG #foo :${body}\r\n`);
+    expect(parsed.params[1]).toBe(body);
+  });
+
+  it('throws IrcParseError on a line whose body exceeds 512 bytes (post-strip)', () => {
+    const body = 'x'.repeat(MAX_INPUT_BYTES - 'PRIVMSG #foo :'.length + 1);
+    const line = `PRIVMSG #foo :${body}`;
+    expect(line.length).toBe(MAX_INPUT_BYTES + 1);
+    expect(() => parse(line)).toThrow(IrcParseError);
+  });
+
+  it('throws IrcParseError on an over-long line even with tags stripped', () => {
+    const tag = '@time=2024-01-01T00:00:00.000Z ';
+    const body = 'x'.repeat(MAX_INPUT_BYTES - tag.length - 'PRIVMSG #foo :'.length + 1);
+    const line = `${tag}PRIVMSG #foo :${body}`;
+    expect(line.length).toBeGreaterThan(MAX_INPUT_BYTES);
+    expect(() => parse(line)).toThrow(IrcParseError);
+  });
+
+  it('reports the actual byte cap in the error message for diagnostics', () => {
+    const body = 'x'.repeat(MAX_INPUT_BYTES);
+    try {
+      parse(`PRIVMSG #foo :${body}`);
+      expect.fail('expected parse to throw');
+    } catch (err) {
+      expect(err).toBeInstanceOf(IrcParseError);
+      expect((err as Error).message).toMatch(/512/u);
+    }
+  });
+});