serverless-ircd 0.4.0 → 0.6.0

package/packages/irc-core/tests/commands/multiline.test.ts

@@ -0,0 +1,428 @@
+import { describe, expect, it } from 'vitest';
+import {
+  DEFAULT_MULTILINE_MAX_BYTES,
+  MULTILINE_CAP,
+  type MultilineEntry,
+  buildMultilineFanout,
+  finalizeMultilineBatch,
+  joinMultiline,
+  multilineByteLength,
+  multilineCapValue,
+  recordMultilineMessage,
+} from '../../src/commands/multiline';
+import { Effect } from '../../src/effects';
+import type { Effect as EffectType, RawLine } from '../../src/effects';
+import {
+  EmptyMotdProvider,
+  FakeClock,
+  InMemoryMessageStore,
+  SequentialIdFactory,
+} from '../../src/ports';
+import { type ConnectionState, createConnection } from '../../src/state/connection';
+import { type Ctx, type ServerConfig, buildCtx } from '../../src/types';
+
+const serverConfig: ServerConfig = {
+  serverName: 'irc.example.com',
+  networkName: 'ExampleNet',
+  maxChannelsPerUser: 30,
+  maxTargetsPerCommand: 10,
+  maxListEntries: 50,
+  nickLen: 30,
+  channelLen: 50,
+  topicLen: 390,
+  quitMessage: 'Client Quit',
+};
+
+function makeCtx(conn: ConnectionState): Ctx {
+  return buildCtx({
+    serverConfig,
+    clock: new FakeClock(1_000),
+    ids: new SequentialIdFactory(),
+    motd: EmptyMotdProvider,
+    connection: conn,
+  });
+}
+
+function makeConn(id = 'c1', nick = 'alice'): ConnectionState {
+  const s = createConnection({ id, connectedSince: 0 });
+  s.nick = nick;
+  s.user = nick;
+  s.host = 'example.com';
+  s.realname = nick.charAt(0).toUpperCase() + nick.slice(1);
+  s.registration = 'registered';
+  return s;
+}
+
+const L = (text: string): RawLine => ({ text });
+
+function entries(...texts: string[]): MultilineEntry[] {
+  return texts.map((t) => ({ text: t }));
+}
+
+// ============================================================================
+// finalizeMultilineBatch — legacy fanout (joined single PRIVMSG)
+// ============================================================================
+
+describe('finalizeMultilineBatch — legacy fanout', () => {
+  it('delivers a 2-line batch as a single joined PRIVMSG to legacy peers', () => {
+    const conn = makeConn();
+    const ctx = makeCtx(conn);
+
+    const out = finalizeMultilineBatch(
+      '#foo',
+      'PRIVMSG',
+      entries('line one', 'line two'),
+      DEFAULT_MULTILINE_MAX_BYTES,
+      ctx,
+    );
+
+    expect(out.ok).toBe(true);
+    if (!out.ok) return;
+    // The broadcast to legacy peers carries the joined PRIVMSG with the
+    // +draft/multiline client tag, split so multiline-capable peers receive
+    // the batched form (capLines) instead.
+    const broadcast = out.effects.find(
+      (e): e is Extract<EffectType, { tag: 'Broadcast' }> => e.tag === 'Broadcast',
+    );
+    expect(broadcast).toBeDefined();
+    expect(broadcast?.chan).toBe('#foo');
+    expect(broadcast?.except).toBe('c1');
+    expect(broadcast?.cap).toBe(MULTILINE_CAP);
+    expect(broadcast?.lines).toEqual<RawLine[]>([
+      L('@+draft/multiline :alice!alice@example.com PRIVMSG #foo :line one\nline two'),
+    ]);
+  });
+
+  it('falls back to "?" as the sender prefix when the connection has no nick', () => {
+    // The actor never routes BATCH for an unregistered connection, but the
+    // pure reducer defends the hostmask invariant regardless.
+    const conn = createConnection({ id: 'c1', connectedSince: 0 });
+    const ctx = makeCtx(conn);
+
+    const out = finalizeMultilineBatch(
+      '#foo',
+      'PRIVMSG',
+      entries('hi'),
+      DEFAULT_MULTILINE_MAX_BYTES,
+      ctx,
+    );
+
+    expect(out.ok).toBe(true);
+    if (!out.ok) return;
+    const broadcast = out.effects.find(
+      (e): e is Extract<EffectType, { tag: 'Broadcast' }> => e.tag === 'Broadcast',
+    );
+    expect(broadcast?.lines[0]?.text).toBe('@+draft/multiline :? PRIVMSG #foo :hi');
+  });
+});
+
+// ============================================================================
+// finalizeMultilineBatch — cap-peer batched replay
+// ============================================================================
+
+describe('finalizeMultilineBatch — multiline-capable peers', () => {
+  it('replays the batch as BATCH +id draft/multiline <target> to cap-enabled peers', () => {
+    const conn = makeConn();
+    const ctx = makeCtx(conn);
+
+    const out = finalizeMultilineBatch(
+      '#foo',
+      'PRIVMSG',
+      entries('line one', 'line two'),
+      DEFAULT_MULTILINE_MAX_BYTES,
+      ctx,
+    );
+
+    expect(out.ok).toBe(true);
+    if (!out.ok) return;
+    const broadcast = out.effects.find(
+      (e): e is Extract<EffectType, { tag: 'Broadcast' }> => e.tag === 'Broadcast',
+    );
+    // capLines carry the BATCH framing with one inner PRIVMSG per original line.
+    expect(broadcast?.capLines).toEqual<RawLine[]>([
+      L('BATCH +batch-0 draft/multiline #foo'),
+      L(':alice!alice@example.com PRIVMSG #foo :line one'),
+      L(':alice!alice@example.com PRIVMSG #foo :line two'),
+      L('BATCH -batch-0'),
+    ]);
+  });
+
+  it('preserves the inner-line order in the replayed batch', () => {
+    const conn = makeConn();
+    const ctx = makeCtx(conn);
+
+    const out = finalizeMultilineBatch(
+      '#foo',
+      'PRIVMSG',
+      entries('a', 'b', 'c', 'd'),
+      DEFAULT_MULTILINE_MAX_BYTES,
+      ctx,
+    );
+
+    expect(out.ok).toBe(true);
+    if (!out.ok) return;
+    const broadcast = out.effects.find(
+      (e): e is Extract<EffectType, { tag: 'Broadcast' }> => e.tag === 'Broadcast',
+    );
+    const innerTexts = broadcast?.capLines
+      ?.filter((line) => line.text.startsWith(':'))
+      .map((line) => line.text);
+    expect(innerTexts).toEqual([
+      ':alice!alice@example.com PRIVMSG #foo :a',
+      ':alice!alice@example.com PRIVMSG #foo :b',
+      ':alice!alice@example.com PRIVMSG #foo :c',
+      ':alice!alice@example.com PRIVMSG #foo :d',
+    ]);
+  });
+
+  it('relays NOTICE inner lines as NOTICE (not PRIVMSG) in the batched replay', () => {
+    const conn = makeConn();
+    const ctx = makeCtx(conn);
+
+    const out = finalizeMultilineBatch(
+      '#foo',
+      'NOTICE',
+      entries('notice one', 'notice two'),
+      DEFAULT_MULTILINE_MAX_BYTES,
+      ctx,
+    );
+
+    expect(out.ok).toBe(true);
+    if (!out.ok) return;
+    const broadcast = out.effects.find(
+      (e): e is Extract<EffectType, { tag: 'Broadcast' }> => e.tag === 'Broadcast',
+    );
+    expect(broadcast?.lines[0]?.text).toBe(
+      '@+draft/multiline :alice!alice@example.com NOTICE #foo :notice one\nnotice two',
+    );
+    expect(broadcast?.capLines?.[1]?.text).toBe(':alice!alice@example.com NOTICE #foo :notice one');
+  });
+});
+
+// ============================================================================
+// finalizeMultilineBatch — byte-budget enforcement (FAIL)
+// ============================================================================
+
+describe('finalizeMultilineBatch — byte budget', () => {
+  it('rejects an over-budget batch with FAIL and relays nothing', () => {
+    const conn = makeConn();
+    const ctx = makeCtx(conn);
+    // Two 5-char lines => joined bytes = 5 + 1 + 5 = 11. Cap at 10 => over.
+    const es = entries('hello', 'world');
+
+    const out = finalizeMultilineBatch('#foo', 'PRIVMSG', es, 10, ctx);
+
+    expect(out.ok).toBe(false);
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [
+        L(
+          ':irc.example.com FAIL BATCH MULTILINE_MAX_BYTES #foo :Multi-line batch exceeds the 10 byte limit',
+        ),
+      ]),
+    ]);
+    // No broadcast effect on rejection.
+    expect(out.effects.some((e) => e.tag === 'Broadcast')).toBe(false);
+  });
+
+  it('accepts a batch whose joined size exactly equals the budget', () => {
+    const conn = makeConn();
+    const ctx = makeCtx(conn);
+    // "hello\nworld" => 5 + 1 + 5 = 11 bytes. Cap at 11 => boundary OK.
+    const es = entries('hello', 'world');
+
+    const out = finalizeMultilineBatch('#foo', 'PRIVMSG', es, 11, ctx);
+
+    expect(out.ok).toBe(true);
+  });
+
+  it('accounts for multi-byte UTF-8 characters when measuring the budget', () => {
+    const conn = makeConn();
+    const ctx = makeCtx(conn);
+    // 'é' is 2 UTF-8 bytes; 'éé' = 4 bytes. Two such lines => 4 + 1 + 4 = 9.
+    const es = entries('éé', 'éé');
+
+    // Cap at 8 => the 9-byte joined content is over budget.
+    const over = finalizeMultilineBatch('#foo', 'PRIVMSG', es, 8, ctx);
+    expect(over.ok).toBe(false);
+
+    // Cap at 9 => exactly at budget, accepted.
+    const exact = finalizeMultilineBatch('#foo', 'PRIVMSG', es, 9, ctx);
+    expect(exact.ok).toBe(true);
+  });
+
+  it('returns success with no effects for an empty batch', () => {
+    const conn = makeConn();
+    const ctx = makeCtx(conn);
+
+    const out = finalizeMultilineBatch('#foo', 'PRIVMSG', [], DEFAULT_MULTILINE_MAX_BYTES, ctx);
+
+    expect(out.ok).toBe(true);
+    expect(out.effects).toEqual<EffectType[]>([]);
+  });
+});
+
+// ============================================================================
+// joinMultiline — concatenation helper
+// ============================================================================
+
+describe('joinMultiline', () => {
+  it('joins entry texts with a newline separator', () => {
+    expect(joinMultiline(entries('a', 'b', 'c'))).toBe('a\nb\nc');
+  });
+
+  it('returns the single text unchanged when there is one entry', () => {
+    expect(joinMultiline(entries('only'))).toBe('only');
+  });
+
+  it('returns the empty string for an empty entry list', () => {
+    expect(joinMultiline([])).toBe('');
+  });
+});
+
+// ============================================================================
+// multilineByteLength — byte-budget accounting helper
+// ============================================================================
+
+describe('multilineByteLength', () => {
+  it('sums entry lengths plus one byte per newline separator', () => {
+    // "hello" + "\n" + "world" => 5 + 1 + 5 = 11
+    expect(multilineByteLength(entries('hello', 'world'))).toBe(11);
+  });
+
+  it('returns the single entry byte length with no separator for one entry', () => {
+    expect(multilineByteLength(entries('hello'))).toBe(5);
+  });
+
+  it('returns 0 for an empty entry list', () => {
+    expect(multilineByteLength([])).toBe(0);
+  });
+
+  it('counts multi-byte UTF-8 sequences by bytes, not code units', () => {
+    // '€' is 3 UTF-8 bytes; two '€' entries => 3 + 1 + 3 = 7
+    expect(multilineByteLength(entries('€', '€'))).toBe(7);
+  });
+});
+
+// ============================================================================
+// multilineCapValue — cap value builder
+// ============================================================================
+
+describe('multilineCapValue', () => {
+  it('returns the byte budget as a string', () => {
+    expect(multilineCapValue(4096)).toBe('4096');
+  });
+
+  it('reflects an overridden budget', () => {
+    expect(multilineCapValue(8192)).toBe('8192');
+  });
+});
+
+// ============================================================================
+// buildMultilineFanout — pure wire-line builder (shared by channel + nick paths)
+// ============================================================================
+
+describe('buildMultilineFanout', () => {
+  it('builds the tagged joined line with the +draft/multiline client tag', () => {
+    const f = buildMultilineFanout(
+      '#foo',
+      'PRIVMSG',
+      entries('a', 'b'),
+      'alice!alice@example.com',
+      'b1',
+    );
+    expect(f.taggedJoined).toEqual<RawLine>(
+      L('@+draft/multiline :alice!alice@example.com PRIVMSG #foo :a\nb'),
+    );
+  });
+
+  it('builds the bare joined line with no tag prefix', () => {
+    const f = buildMultilineFanout(
+      '#foo',
+      'PRIVMSG',
+      entries('a', 'b'),
+      'alice!alice@example.com',
+      'b1',
+    );
+    expect(f.bareJoined).toEqual<RawLine>(L(':alice!alice@example.com PRIVMSG #foo :a\nb'));
+  });
+
+  it('builds the batched replay as a BATCH frame with one inner line per entry', () => {
+    const f = buildMultilineFanout(
+      'bob',
+      'PRIVMSG',
+      entries('one', 'two'),
+      'alice!alice@example.com',
+      'bx9',
+    );
+    expect(f.batchedReplay).toEqual<RawLine[]>([
+      L('BATCH +bx9 draft/multiline bob'),
+      L(':alice!alice@example.com PRIVMSG bob :one'),
+      L(':alice!alice@example.com PRIVMSG bob :two'),
+      L('BATCH -bx9'),
+    ]);
+  });
+
+  it('exposes the joined text for chathistory recording', () => {
+    const f = buildMultilineFanout('#foo', 'NOTICE', entries('x', 'y'), 'a!a@a', 'b1');
+    expect(f.joined).toBe('x\ny');
+  });
+
+  it('preserves the command (NOTICE) across all wire variants', () => {
+    const f = buildMultilineFanout('#foo', 'NOTICE', entries('hi'), 'a!a@a', 'b1');
+    expect(f.taggedJoined.text).toContain(' NOTICE #foo :hi');
+    expect(f.bareJoined.text).toContain(' NOTICE #foo :hi');
+    expect(f.batchedReplay[1]?.text).toContain(' NOTICE #foo :hi');
+  });
+});
+
+// ============================================================================
+// recordMultilineMessage — chathistory recording helper
+// ============================================================================
+
+describe('recordMultilineMessage', () => {
+  function makeCtxWithStore(conn: ConnectionState, store: InMemoryMessageStore): Ctx {
+    return buildCtx({
+      serverConfig,
+      clock: new FakeClock(5_000),
+      ids: new SequentialIdFactory(),
+      motd: EmptyMotdProvider,
+      connection: conn,
+      messages: store,
+    });
+  }
+
+  it('records one entry carrying the joined body, msgid, and +draft/multiline tag', () => {
+    const conn = makeConn();
+    const store = new InMemoryMessageStore();
+    const ctx = makeCtxWithStore(conn, store);
+
+    recordMultilineMessage(ctx, '#Foo', 'PRIVMSG', 'one\ntwo', 'mid-xyz');
+
+    const recorded = store.query({ chan: '#foo', direction: 'latest', limit: 10 });
+    expect(recorded).toHaveLength(1);
+    expect(recorded[0]?.msgid).toBe('mid-xyz');
+    expect(recorded[0]?.text).toBe('one\ntwo');
+    expect(recorded[0]?.command).toBe('PRIVMSG');
+    expect(recorded[0]?.chan).toBe('#foo');
+    expect(recorded[0]?.nick).toBe('alice');
+    expect(recorded[0]?.clientTags).toEqual(['+draft/multiline']);
+  });
+
+  it('is a no-op when no MessageStore is bound (ctx.messages undefined)', () => {
+    const conn = makeConn();
+    const ctx = makeCtx(conn);
+
+    expect(() => recordMultilineMessage(ctx, '#foo', 'PRIVMSG', 'hi', 'm1')).not.toThrow();
+  });
+
+  it('records with "?" as the nick when the connection has no nick', () => {
+    const conn = createConnection({ id: 'c1', connectedSince: 0 });
+    const store = new InMemoryMessageStore();
+    const ctx = makeCtxWithStore(conn, store);
+
+    recordMultilineMessage(ctx, '#foo', 'PRIVMSG', 'hi', 'm1');
+
+    const recorded = store.query({ chan: '#foo', direction: 'latest', limit: 10 });
+    expect(recorded[0]?.nick).toBe('?');
+  });
+});

package/packages/irc-core/tests/commands/pre-away.test.ts

@@ -0,0 +1,241 @@
+import { describe, expect, it } from 'vitest';
+import {
+  PRE_AWAY_CAP,
+  clearPersistedAway,
+  nowAwayLine,
+  persistAway,
+  replayPersistedAway,
+} from '../../src/commands/pre-away';
+import {
+  EmptyMotdProvider,
+  FakeClock,
+  InMemoryAwayStore,
+  SequentialIdFactory,
+} from '../../src/ports';
+import { type ConnectionState, createConnection } from '../../src/state/connection';
+import { type Ctx, type ServerConfig, buildCtx } from '../../src/types';
+
+const serverConfig: ServerConfig = {
+  serverName: 'irc.example.com',
+  networkName: 'ExampleNet',
+  maxChannelsPerUser: 30,
+  maxTargetsPerCommand: 10,
+  maxListEntries: 50,
+  nickLen: 30,
+  channelLen: 50,
+  topicLen: 390,
+  quitMessage: 'Client Quit',
+};
+
+function makeConn(id = 'c1', account?: string): ConnectionState {
+  const s = createConnection({ id, connectedSince: 0 });
+  s.nick = 'alice';
+  s.user = 'alice';
+  s.host = 'example.com';
+  s.registration = 'registered';
+  if (account !== undefined) s.account = account;
+  return s;
+}
+
+function makeCtx(conn: ConnectionState, away?: InMemoryAwayStore): Ctx {
+  return buildCtx({
+    serverConfig,
+    clock: new FakeClock(1_000),
+    ids: new SequentialIdFactory(),
+    motd: EmptyMotdProvider,
+    connection: conn,
+    ...(away !== undefined ? { away } : {}),
+  });
+}
+
+// ============================================================================
+// constants
+// ============================================================================
+
+describe('pre-away constants', () => {
+  it('exposes the draft/pre-away cap name', () => {
+    expect(PRE_AWAY_CAP).toBe('draft/pre-away');
+  });
+});
+
+// ============================================================================
+// nowAwayLine
+// ============================================================================
+
+describe('nowAwayLine', () => {
+  it('builds the 306 RPL_NOWAWAY line addressed to the connection nick', () => {
+    const conn = makeConn('c1');
+    const line = nowAwayLine(conn, 'irc.example.com');
+    expect(line.text).toBe(':irc.example.com 306 alice :You have been marked as being away');
+  });
+
+  it('zero-pads the numeric to three digits', () => {
+    const conn = makeConn('c1');
+    const line = nowAwayLine(conn, 'irc.example.com');
+    // 306 is already 3 digits, so no padding needed; this just guards the
+    // padStart call against regression for the eventual "no-away" reply.
+    expect(line.text).toContain(' 306 ');
+  });
+
+  it('falls back to * when the connection has no nick', () => {
+    const conn = createConnection({ id: 'c1', connectedSince: 0 });
+    const line = nowAwayLine(conn, 'irc.example.com');
+    expect(line.text).toBe(':irc.example.com 306 * :You have been marked as being away');
+  });
+});
+
+// ============================================================================
+// persistAway
+// ============================================================================
+
+describe('persistAway', () => {
+  it('writes the reason to the store keyed by account', () => {
+    const store = new InMemoryAwayStore();
+    const ctx = makeCtx(makeConn('c1', 'alice'), store);
+
+    persistAway(ctx, 'brb');
+
+    expect(store.get('alice')).toBe('brb');
+  });
+
+  it('also sets the connection in-memory away reason', () => {
+    const store = new InMemoryAwayStore();
+    const conn = makeConn('c1', 'alice');
+    const ctx = makeCtx(conn, store);
+
+    persistAway(ctx, 'brb');
+
+    expect(conn.away).toBe('brb');
+  });
+
+  it('overwrites a previously stored reason for the same account', () => {
+    const store = new InMemoryAwayStore();
+    const ctx = makeCtx(makeConn('c1', 'alice'), store);
+
+    persistAway(ctx, 'brb');
+    persistAway(ctx, 'lunch');
+
+    expect(store.get('alice')).toBe('lunch');
+  });
+
+  it('still sets the in-memory reason when no AwayStore is bound', () => {
+    const conn = makeConn('c1', 'alice');
+    const ctx = makeCtx(conn); // no store
+
+    persistAway(ctx, 'brb');
+
+    expect(conn.away).toBe('brb');
+  });
+
+  it('is a no-op on the store when the connection has no account', () => {
+    const store = new InMemoryAwayStore();
+    const conn = makeConn('c1'); // no account
+    const ctx = makeCtx(conn, store);
+
+    persistAway(ctx, 'brb');
+
+    expect(store.get('alice')).toBeUndefined();
+    // In-memory reason still set so the connection's own session tracks it.
+    expect(conn.away).toBe('brb');
+  });
+});
+
+// ============================================================================
+// clearPersistedAway
+// ============================================================================
+
+describe('clearPersistedAway', () => {
+  it('removes the stored reason for the account', () => {
+    const store = new InMemoryAwayStore();
+    store.set('alice', 'brb');
+    const ctx = makeCtx(makeConn('c1', 'alice'), store);
+
+    clearPersistedAway(ctx);
+
+    expect(store.get('alice')).toBeUndefined();
+  });
+
+  it('also clears the connection in-memory away reason', () => {
+    const store = new InMemoryAwayStore();
+    store.set('alice', 'brb');
+    const conn = makeConn('c1', 'alice');
+    conn.away = 'brb';
+    const ctx = makeCtx(conn, store);
+
+    clearPersistedAway(ctx);
+
+    expect(conn.away).toBeUndefined();
+  });
+
+  it('is a no-op on the store when no AwayStore is bound but still clears in-memory', () => {
+    const conn = makeConn('c1', 'alice');
+    conn.away = 'brb';
+    const ctx = makeCtx(conn); // no store
+
+    clearPersistedAway(ctx);
+
+    expect(conn.away).toBeUndefined();
+  });
+
+  it('is a no-op on the store when the connection has no account', () => {
+    const store = new InMemoryAwayStore();
+    store.set('alice', 'brb');
+    const conn = makeConn('c1'); // no account
+    conn.away = 'brb';
+    const ctx = makeCtx(conn, store);
+
+    clearPersistedAway(ctx);
+
+    // Store entry survives because the connection is unidentified.
+    expect(store.get('alice')).toBe('brb');
+    // In-memory is still cleared so the session's view is consistent.
+    expect(conn.away).toBeUndefined();
+  });
+});
+
+// ============================================================================
+// replayPersistedAway
+// ============================================================================
+
+describe('replayPersistedAway', () => {
+  it('sets the connection away reason from the persisted value', () => {
+    const store = new InMemoryAwayStore();
+    store.set('alice', 'brb');
+    const conn = makeConn();
+
+    replayPersistedAway(conn, store, 'alice');
+
+    expect(conn.away).toBe('brb');
+  });
+
+  it('leaves the connection away reason untouched when no entry exists', () => {
+    const store = new InMemoryAwayStore();
+    const conn = makeConn();
+
+    replayPersistedAway(conn, store, 'alice');
+
+    expect(conn.away).toBeUndefined();
+  });
+
+  it('does not overwrite an away reason the session has already set', () => {
+    const store = new InMemoryAwayStore();
+    store.set('alice', 'stored');
+    const conn = makeConn();
+    conn.away = 'session';
+
+    replayPersistedAway(conn, store, 'alice');
+
+    // The session's own value wins — the user may have re-set AWAY this session.
+    expect(conn.away).toBe('session');
+  });
+
+  it('looks up the account case-insensitively', () => {
+    const store = new InMemoryAwayStore();
+    store.set('Alice', 'brb');
+    const conn = makeConn();
+
+    replayPersistedAway(conn, store, 'alice');
+
+    expect(conn.away).toBe('brb');
+  });
+});