serverless-ircd 0.1.0

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

@@ -0,0 +1,422 @@
+import { describe, expect, it } from 'vitest';
+import { whoisReducer } from '../../src/commands/whois';
+import { Effect } from '../../src/effects';
+import type { Effect as EffectType, RawLine } from '../../src/effects';
+import { EmptyMotdProvider, FakeClock, SequentialIdFactory } from '../../src/ports';
+import { type ChannelState, createChannel } from '../../src/state/channel';
+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, clock = new FakeClock(10_000)): Ctx {
+  return buildCtx({
+    serverConfig,
+    clock,
+    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 = 'Alice';
+  s.registration = 'registered';
+  return s;
+}
+
+function makeTarget(
+  id: string,
+  nick: string,
+  opts: {
+    user?: string;
+    host?: string;
+    realname?: string;
+    away?: string;
+    oper?: boolean;
+    account?: string;
+    connectedSince?: number;
+    lastSeen?: number;
+  } = {},
+): ConnectionState {
+  const since = opts.connectedSince ?? 1_000;
+  const s = createConnection({
+    id,
+    connectedSince: since,
+    ...(opts.lastSeen !== undefined ? { lastSeen: opts.lastSeen } : {}),
+  });
+  s.nick = nick;
+  s.user = opts.user ?? nick;
+  s.host = opts.host ?? 'target.example.net';
+  s.realname = opts.realname ?? nick;
+  s.registration = 'registered';
+  if (opts.away !== undefined) s.away = opts.away;
+  if (opts.oper !== undefined) s.userModes.oper = opts.oper;
+  if (opts.account !== undefined) s.account = opts.account;
+  return s;
+}
+
+function makeChan(name: string, opts: { secret?: boolean; private?: boolean } = {}): ChannelState {
+  const c = createChannel({ name, nameLower: name.toLowerCase(), createdAt: 0 });
+  if (opts.secret) c.modes.secret = true;
+  if (opts.private) c.modes.private = true;
+  return c;
+}
+
+function addMember(
+  chan: ChannelState,
+  connId: string,
+  nick: string,
+  op = false,
+  voice = false,
+): void {
+  chan.members.set(connId, { conn: connId, nick, op, voice });
+}
+
+const L = (text: string): RawLine => ({ text });
+
+// ============================================================================
+// whoisReducer — happy path
+// ============================================================================
+
+describe('whoisReducer — happy path', () => {
+  it('emits 311/312/317/318 for a registered user with no channels', () => {
+    const requester = makeConn();
+    const ctx = makeCtx(requester, new FakeClock(10_000));
+    const target = makeTarget('c2', 'bob', { connectedSince: 4_000, lastSeen: 8_000 });
+
+    const out = whoisReducer(target, [], { command: 'WHOIS', params: ['bob'] }, ctx);
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [
+        L(':irc.example.com 311 alice bob bob target.example.net * :bob'),
+        L(':irc.example.com 312 alice bob irc.example.com :ExampleNet'),
+        L(':irc.example.com 317 alice bob 2 4 :seconds idle, signon time'),
+      ]),
+      Effect.send('c1', [L(':irc.example.com 318 alice bob :End of /WHOIS list')]),
+    ]);
+  });
+
+  it('emits 319 RPL_WHOISCHANNELS between 317 and 318 when the target is in channels', () => {
+    const requester = makeConn();
+    const ctx = makeCtx(requester);
+    const target = makeTarget('c2', 'bob');
+
+    const pub = makeChan('#foo');
+    addMember(pub, 'c2', 'bob');
+    const pub2 = makeChan('#bar');
+    addMember(pub2, 'c2', 'bob', true);
+
+    const out = whoisReducer(target, [pub, pub2], { command: 'WHOIS', params: ['bob'] }, ctx);
+
+    const send319 = out.effects[1];
+    expect(send319?.tag).toBe('Send');
+    if (send319?.tag === 'Send') {
+      // Channels sorted alphabetically with prefix sigils.
+      expect(send319.lines[0]?.text).toBe(':irc.example.com 319 alice bob :@#bar #foo');
+    }
+  });
+
+  it('emits 330 RPL_WHOISACCOUNT when the target has an account', () => {
+    const requester = makeConn();
+    const ctx = makeCtx(requester);
+    const target = makeTarget('c2', 'bob', { account: 'aliceacct' });
+
+    const out = whoisReducer(target, [], { command: 'WHOIS', params: ['bob'] }, ctx);
+
+    const send = out.effects[0];
+    expect(send?.tag).toBe('Send');
+    if (send?.tag === 'Send') {
+      // 330 appears in the first batch alongside 311/312/317.
+      expect(send.lines.some((l) => l.text.includes(' 330 '))).toBe(true);
+      expect(send.lines.some((l) => l.text.includes(' aliceacct '))).toBe(true);
+    }
+  });
+
+  it('emits 313 RPL_WHOISOPERATOR when the target is an IRC operator', () => {
+    const requester = makeConn();
+    const ctx = makeCtx(requester);
+    const target = makeTarget('c2', 'bob', { oper: true });
+
+    const out = whoisReducer(target, [], { command: 'WHOIS', params: ['bob'] }, ctx);
+
+    const send = out.effects[0];
+    if (send?.tag === 'Send') {
+      expect(send.lines.some((l) => l.text.includes(' 313 '))).toBe(true);
+    }
+  });
+});
+
+// ============================================================================
+// whoisReducer — idle/signon math
+// ============================================================================
+
+describe('whoisReducer — idle and signon', () => {
+  it('reports idle seconds as floor((now - lastSeen) / 1000)', () => {
+    const requester = makeConn();
+    // clock.now = 10_000ms, target.lastSeen = 8_000ms → 2s idle.
+    const ctx = makeCtx(requester, new FakeClock(10_000));
+    const target = makeTarget('c2', 'bob', { connectedSince: 4_000, lastSeen: 8_000 });
+
+    const out = whoisReducer(target, [], { command: 'WHOIS', params: ['bob'] }, ctx);
+
+    const send = out.effects[0];
+    if (send?.tag === 'Send') {
+      const idle = send.lines.find((l) => l.text.includes(' 317 '));
+      expect(idle?.text).toContain(' 317 alice bob 2 4 ');
+    }
+  });
+
+  it('reports signon as floor(connectedSince / 1000)', () => {
+    const requester = makeConn();
+    const ctx = makeCtx(requester);
+    const target = makeTarget('c2', 'bob', { connectedSince: 65_000 });
+
+    const out = whoisReducer(target, [], { command: 'WHOIS', params: ['bob'] }, ctx);
+
+    const send = out.effects[0];
+    if (send?.tag === 'Send') {
+      const idle = send.lines.find((l) => l.text.includes(' 317 '));
+      expect(idle?.text).toContain(' 65 ');
+    }
+  });
+});
+
+// ============================================================================
+// whoisReducer — channel visibility
+// ============================================================================
+
+describe('whoisReducer — channel visibility', () => {
+  it('hides secret (+s) channels the requester is not on', () => {
+    const requester = makeConn();
+    const ctx = makeCtx(requester);
+    const target = makeTarget('c2', 'bob');
+
+    const pub = makeChan('#foo');
+    addMember(pub, 'c2', 'bob');
+    const sec = makeChan('#secret', { secret: true });
+    addMember(sec, 'c2', 'bob');
+
+    const out = whoisReducer(target, [pub, sec], { command: 'WHOIS', params: ['bob'] }, ctx);
+
+    const send319 = out.effects[1];
+    if (send319?.tag === 'Send') {
+      expect(send319.lines[0]?.text).toBe(':irc.example.com 319 alice bob :#foo');
+    }
+  });
+
+  it('shows secret (+s) channels the requester is also on', () => {
+    const requester = makeConn();
+    const ctx = makeCtx(requester);
+    const target = makeTarget('c2', 'bob');
+
+    const sec = makeChan('#secret', { secret: true });
+    addMember(sec, 'c2', 'bob');
+    addMember(sec, 'c1', 'alice');
+
+    const out = whoisReducer(target, [sec], { command: 'WHOIS', params: ['bob'] }, ctx);
+
+    const send319 = out.effects[1];
+    if (send319?.tag === 'Send') {
+      expect(send319.lines[0]?.text).toBe(':irc.example.com 319 alice bob :#secret');
+    }
+  });
+
+  it('hides private (+p) channels the requester is not on', () => {
+    const requester = makeConn();
+    const ctx = makeCtx(requester);
+    const target = makeTarget('c2', 'bob');
+
+    const priv = makeChan('#priv', { private: true });
+    addMember(priv, 'c2', 'bob');
+
+    const out = whoisReducer(target, [priv], { command: 'WHOIS', params: ['bob'] }, ctx);
+
+    // No 319 emitted.
+    const send319 = out.effects[1];
+    expect(send319?.tag).toBe('Send');
+    if (send319?.tag === 'Send') {
+      expect(send319.lines[0]?.text).toContain(' 318 ');
+    }
+  });
+
+  it('prefixes op channels with @ and voiced channels with +', () => {
+    const requester = makeConn();
+    const ctx = makeCtx(requester);
+    const target = makeTarget('c2', 'bob');
+
+    const opChan = makeChan('#op');
+    addMember(opChan, 'c2', 'bob', true);
+    const voiceChan = makeChan('#voice');
+    addMember(voiceChan, 'c2', 'bob', false, true);
+
+    const out = whoisReducer(
+      target,
+      [opChan, voiceChan],
+      { command: 'WHOIS', params: ['bob'] },
+      ctx,
+    );
+
+    const send319 = out.effects[1];
+    if (send319?.tag === 'Send') {
+      expect(send319.lines[0]?.text).toBe(':irc.example.com 319 alice bob :@#op +#voice');
+    }
+  });
+
+  it('emits no 319 when no channels are visible', () => {
+    const requester = makeConn();
+    const ctx = makeCtx(requester);
+    const target = makeTarget('c2', 'bob');
+
+    const out = whoisReducer(target, [], { command: 'WHOIS', params: ['bob'] }, ctx);
+
+    // 318 should be the second effect (no 319 in between).
+    expect(out.effects.length).toBe(2);
+    expect(out.effects[1]?.tag).toBe('Send');
+  });
+
+  it('sorts channels alphabetically regardless of input order', () => {
+    const requester = makeConn();
+    const ctx = makeCtx(requester);
+    const target = makeTarget('c2', 'bob');
+
+    const zed = makeChan('#zed');
+    addMember(zed, 'c2', 'bob');
+    const alpha = makeChan('#alpha');
+    addMember(alpha, 'c2', 'bob');
+
+    const out = whoisReducer(target, [zed, alpha], { command: 'WHOIS', params: ['bob'] }, ctx);
+
+    const send319 = out.effects[1];
+    if (send319?.tag === 'Send') {
+      expect(send319.lines[0]?.text).toBe(':irc.example.com 319 alice bob :#alpha #zed');
+    }
+  });
+
+  it('skips channels where the target is not actually a member', () => {
+    const requester = makeConn();
+    const ctx = makeCtx(requester);
+    const target = makeTarget('c2', 'bob');
+
+    const realChan = makeChan('#real');
+    addMember(realChan, 'c2', 'bob');
+    const ghostChan = makeChan('#ghost');
+    // Target is NOT a member of #ghost.
+
+    const out = whoisReducer(
+      target,
+      [realChan, ghostChan],
+      { command: 'WHOIS', params: ['bob'] },
+      ctx,
+    );
+
+    const send319 = out.effects[1];
+    if (send319?.tag === 'Send') {
+      expect(send319.lines[0]?.text).toBe(':irc.example.com 319 alice bob :#real');
+    }
+  });
+});
+
+// ============================================================================
+// whoisReducer — errors and edge cases
+// ============================================================================
+
+describe('whoisReducer — errors and edge cases', () => {
+  it('emits 401 then 318 for an unknown nick', () => {
+    const requester = makeConn();
+    const ctx = makeCtx(requester);
+
+    const out = whoisReducer(undefined, [], { command: 'WHOIS', params: ['ghost'] }, ctx);
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(':irc.example.com 401 alice ghost :No such nick/channel')]),
+      Effect.send('c1', [L(':irc.example.com 318 alice ghost :End of /WHOIS list')]),
+    ]);
+  });
+
+  it('uses * in replies when the requester has no nick', () => {
+    const requester = createConnection({ id: 'c1', connectedSince: 0 });
+    const ctx = makeCtx(requester);
+    const target = makeTarget('c2', 'bob');
+
+    const out = whoisReducer(target, [], { command: 'WHOIS', params: ['bob'] }, ctx);
+
+    const end = out.effects.at(-1);
+    if (end?.tag === 'Send') {
+      expect(end.lines[0]?.text).toBe(':irc.example.com 318 * bob :End of /WHOIS list');
+    }
+  });
+
+  it('updates the requester lastSeen to ctx.clock.now()', () => {
+    const requester = makeConn();
+    const clock = new FakeClock(7_700);
+    const ctx = makeCtx(requester, clock);
+    const target = makeTarget('c2', 'bob');
+
+    whoisReducer(target, [], { command: 'WHOIS', params: ['bob'] }, ctx);
+
+    expect(requester.lastSeen).toBe(7_700);
+  });
+
+  it('emits 401-less 318 when target is undefined and params are empty', () => {
+    const requester = makeConn();
+    const ctx = makeCtx(requester);
+
+    const out = whoisReducer(undefined, [], { command: 'WHOIS', params: [] }, ctx);
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(':irc.example.com 318 alice :End of /WHOIS list')]),
+    ]);
+  });
+
+  it('uses ? fallbacks when target has missing user/host/realname fields', () => {
+    const requester = makeConn();
+    const ctx = makeCtx(requester);
+    // Construct a target with only nick set (no user/host/realname).
+    const target = createConnection({ id: 'c2', connectedSince: 1_000 });
+    target.nick = 'bob';
+    target.registration = 'registered';
+
+    const out = whoisReducer(target, [], { command: 'WHOIS', params: ['bob'] }, ctx);
+
+    const send = out.effects[0];
+    if (send?.tag === 'Send') {
+      const line311 = send.lines.find((l) => l.text.includes(' 311 '));
+      // nick is bob, user/host fall back to ?, realname falls back to nick.
+      expect(line311?.text).toBe(':irc.example.com 311 alice bob ? ? * :bob');
+    }
+  });
+
+  it('uses * fallback for target nick when target has no nick set', () => {
+    const requester = makeConn();
+    const ctx = makeCtx(requester);
+    // Target ConnectionState with no nick at all (highly defensive path).
+    const target = createConnection({ id: 'c2', connectedSince: 1_000 });
+    target.user = 'bob';
+    target.host = 'h';
+    target.realname = 'Bob';
+    target.registration = 'registered';
+
+    const out = whoisReducer(target, [], { command: 'WHOIS', params: ['bob'] }, ctx);
+
+    const end = out.effects.at(-1);
+    if (end?.tag === 'Send') {
+      // The 318 line middle param falls back to * when target.nick is undefined.
+      expect(end.lines[0]?.text).toBe(':irc.example.com 318 alice * :End of /WHOIS list');
+    }
+  });
+});

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

@@ -0,0 +1,147 @@
+import { describe, expect, it } from 'vitest';
+import { Effect, type EffectTag, type Effect as EffectType, type RawLine } from '../src/effects';
+import type { EffectDispatchResult } from '../src/effects';
+import type { ChannelDelta } from '../src/state/channel';
+
+const line = (text: string): RawLine => ({ text });
+
+describe('Effect constructors', () => {
+  it('Send carries target conn and lines', () => {
+    const e = Effect.send('c1', [line('PONG :tok')]);
+    expect(e).toEqual<EffectType>({ tag: 'Send', to: 'c1', lines: [{ text: 'PONG :tok' }] });
+  });
+
+  it('Broadcast carries channel, lines, and optional except', () => {
+    expect(Effect.broadcast('#foo', [line('hi')])).toEqual<EffectType>({
+      tag: 'Broadcast',
+      chan: '#foo',
+      lines: [{ text: 'hi' }],
+    });
+    expect(Effect.broadcast('#foo', [line('hi')], 'c1')).toEqual<EffectType>({
+      tag: 'Broadcast',
+      chan: '#foo',
+      lines: [{ text: 'hi' }],
+      except: 'c1',
+    });
+  });
+
+  it('Disconnect carries conn and optional reason', () => {
+    expect(Effect.disconnect('c1')).toEqual<EffectType>({ tag: 'Disconnect', conn: 'c1' });
+    expect(Effect.disconnect('c1', 'excess flood')).toEqual<EffectType>({
+      tag: 'Disconnect',
+      conn: 'c1',
+      reason: 'excess flood',
+    });
+  });
+
+  it('ReserveNick carries nick and conn', () => {
+    expect(Effect.reserveNick('alice', 'c1')).toEqual<EffectType>({
+      tag: 'ReserveNick',
+      nick: 'alice',
+      conn: 'c1',
+    });
+  });
+
+  it('ChangeNick carries conn, oldNick, newNick', () => {
+    expect(Effect.changeNick('c1', 'alice', 'bob')).toEqual<EffectType>({
+      tag: 'ChangeNick',
+      conn: 'c1',
+      oldNick: 'alice',
+      newNick: 'bob',
+    });
+  });
+
+  it('ReleaseNick carries nick', () => {
+    expect(Effect.releaseNick('alice')).toEqual<EffectType>({
+      tag: 'ReleaseNick',
+      nick: 'alice',
+    });
+  });
+
+  it('ApplyChannelDelta carries chan and delta', () => {
+    const delta: ChannelDelta = { memberships: [{ type: 'remove', conn: 'c1' }] };
+    expect(Effect.applyChannelDelta('#foo', delta)).toEqual<EffectType>({
+      tag: 'ApplyChannelDelta',
+      chan: '#foo',
+      delta,
+    });
+  });
+
+  it('LookupNick carries nick', () => {
+    expect(Effect.lookupNick('alice')).toEqual<EffectType>({
+      tag: 'LookupNick',
+      nick: 'alice',
+    });
+  });
+
+  it('GetConnectionInfo carries conn', () => {
+    expect(Effect.getConnectionInfo('c1')).toEqual<EffectType>({
+      tag: 'GetConnectionInfo',
+      conn: 'c1',
+    });
+  });
+
+  it('GetChannelSnapshot carries chan', () => {
+    expect(Effect.getChannelSnapshot('#foo')).toEqual<EffectType>({
+      tag: 'GetChannelSnapshot',
+      chan: '#foo',
+    });
+  });
+
+  it('SendToNick carries nick, sender, lines, and optional notFoundLines', () => {
+    expect(Effect.sendToNick('alice', 'c1', [line('hi')])).toEqual<EffectType>({
+      tag: 'SendToNick',
+      nick: 'alice',
+      sender: 'c1',
+      lines: [{ text: 'hi' }],
+    });
+    expect(Effect.sendToNick('alice', 'c1', [line('hi')], [line('401')])).toEqual<EffectType>({
+      tag: 'SendToNick',
+      nick: 'alice',
+      sender: 'c1',
+      lines: [{ text: 'hi' }],
+      notFoundLines: [{ text: '401' }],
+    });
+  });
+});
+
+describe('Effect tag set', () => {
+  // Ensures the Effect union covers every side-effect referenced in PLAN §2.1.
+  const expectedTags: EffectTag[] = [
+    'Send',
+    'Broadcast',
+    'Disconnect',
+    'ReserveNick',
+    'ChangeNick',
+    'ReleaseNick',
+    'ApplyChannelDelta',
+    'LookupNick',
+    'GetConnectionInfo',
+    'GetChannelSnapshot',
+    'SendToNick',
+  ];
+
+  it.each(expectedTags)('exposes a constructor for the %s tag', (tag) => {
+    const constructors: Record<EffectTag, EffectType> = {
+      Send: Effect.send('c', []),
+      Broadcast: Effect.broadcast('#c', []),
+      Disconnect: Effect.disconnect('c'),
+      ReserveNick: Effect.reserveNick('n', 'c'),
+      ChangeNick: Effect.changeNick('c', 'a', 'b'),
+      ReleaseNick: Effect.releaseNick('n'),
+      ApplyChannelDelta: Effect.applyChannelDelta('#c', { memberships: [] }),
+      LookupNick: Effect.lookupNick('n'),
+      GetConnectionInfo: Effect.getConnectionInfo('c'),
+      GetChannelSnapshot: Effect.getChannelSnapshot('#c'),
+      SendToNick: Effect.sendToNick('n', 'c', []),
+    };
+    expect(constructors[tag].tag).toBe(tag);
+  });
+});
+
+describe('EffectDispatchResult', () => {
+  it('is exported as a type alias for per-effect lookup results', () => {
+    const r: EffectDispatchResult = { ok: true };
+    expect(r.ok).toBe(true);
+  });
+});