serverless-ircd 0.1.0

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

@@ -0,0 +1,665 @@
+import { describe, expect, it } from 'vitest';
+import {
+  isChannelTarget,
+  noticeChannelReducer,
+  noticeUserReducer,
+  privmsgChannelReducer,
+  privmsgUserReducer,
+} from '../../src/commands/privmsg';
+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(1_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 = nick.charAt(0).toUpperCase() + nick.slice(1);
+  s.registration = 'registered';
+  return s;
+}
+
+function makeChan(name = '#foo'): ChannelState {
+  return createChannel({ name, nameLower: name.toLowerCase(), createdAt: 0 });
+}
+
+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 });
+
+// ============================================================================
+// isChannelTarget
+// ============================================================================
+
+describe('isChannelTarget', () => {
+  it('returns true for a # channel name', () => {
+    expect(isChannelTarget('#foo')).toBe(true);
+  });
+
+  it('returns true for a & channel name', () => {
+    expect(isChannelTarget('&foo')).toBe(true);
+  });
+
+  it('returns false for a nick name', () => {
+    expect(isChannelTarget('alice')).toBe(false);
+  });
+
+  it('returns false for an empty string', () => {
+    expect(isChannelTarget('')).toBe(false);
+  });
+
+  it('returns false for a name with a space', () => {
+    expect(isChannelTarget('foo bar')).toBe(false);
+  });
+});
+
+// ============================================================================
+// privmsgChannelReducer — success path
+// ============================================================================
+
+describe('privmsgChannelReducer — success', () => {
+  it('broadcasts PRIVMSG to all channel members except the sender', () => {
+    const chan = makeChan('#foo');
+    addMember(chan, 'c1', 'alice');
+    addMember(chan, 'c2', 'bob');
+    addMember(chan, 'c3', 'carol');
+    const conn = makeConn();
+    const ctx = makeCtx(conn);
+
+    const out = privmsgChannelReducer(
+      chan,
+      { command: 'PRIVMSG', params: ['#foo', 'hello world'], tags: {} },
+      ctx,
+    );
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.broadcast('#foo', [L(':alice!alice@example.com PRIVMSG #foo :hello world')], 'c1'),
+    ]);
+  });
+
+  it('broadcasts a multi-word trailing parameter verbatim', () => {
+    const chan = makeChan('#foo');
+    addMember(chan, 'c1', 'alice');
+    const conn = makeConn();
+    const ctx = makeCtx(conn);
+
+    const out = privmsgChannelReducer(
+      chan,
+      { command: 'PRIVMSG', params: ['#foo', 'hi there everyone'], tags: {} },
+      ctx,
+    );
+
+    expect(out.effects).toContainEqual<EffectType>(
+      Effect.broadcast(
+        '#foo',
+        [L(':alice!alice@example.com PRIVMSG #foo :hi there everyone')],
+        'c1',
+      ),
+    );
+  });
+
+  it('allows a non-member to message the channel when +n is not set (default)', () => {
+    const chan = makeChan('#foo');
+    addMember(chan, 'c2', 'bob');
+    const conn = makeConn();
+    const ctx = makeCtx(conn);
+
+    const out = privmsgChannelReducer(
+      chan,
+      { command: 'PRIVMSG', params: ['#foo', 'hi'], tags: {} },
+      ctx,
+    );
+
+    expect(out.effects).toHaveLength(1);
+    expect(out.effects[0]?.tag).toBe('Broadcast');
+  });
+
+  it('allows a voiced non-op to message a +m channel', () => {
+    const chan = makeChan('#foo');
+    chan.modes.moderated = true;
+    addMember(chan, 'c1', 'alice', false, true);
+    const conn = makeConn();
+    const ctx = makeCtx(conn);
+
+    const out = privmsgChannelReducer(
+      chan,
+      { command: 'PRIVMSG', params: ['#foo', 'hi'], tags: {} },
+      ctx,
+    );
+
+    expect(out.effects).toHaveLength(1);
+    expect(out.effects[0]?.tag).toBe('Broadcast');
+  });
+
+  it('allows an op to message a +m channel even without voice', () => {
+    const chan = makeChan('#foo');
+    chan.modes.moderated = true;
+    addMember(chan, 'c1', 'alice', true, false);
+    const conn = makeConn();
+    const ctx = makeCtx(conn);
+
+    const out = privmsgChannelReducer(
+      chan,
+      { command: 'PRIVMSG', params: ['#foo', 'hi'], tags: {} },
+      ctx,
+    );
+
+    expect(out.effects).toHaveLength(1);
+    expect(out.effects[0]?.tag).toBe('Broadcast');
+  });
+
+  it('updates the connection lastSeen to ctx.clock.now()', () => {
+    const chan = makeChan('#foo');
+    addMember(chan, 'c1', 'alice');
+    const conn = makeConn();
+    const clock = new FakeClock(8_800);
+    const ctx = makeCtx(conn, clock);
+
+    privmsgChannelReducer(chan, { command: 'PRIVMSG', params: ['#foo', 'hi'], tags: {} }, ctx);
+
+    expect(conn.lastSeen).toBe(8_800);
+  });
+
+  it('returns the same state reference (no mutation to channel state)', () => {
+    const chan = makeChan('#foo');
+    addMember(chan, 'c1', 'alice');
+    const conn = makeConn();
+    const ctx = makeCtx(conn);
+
+    const out = privmsgChannelReducer(
+      chan,
+      { command: 'PRIVMSG', params: ['#foo', 'hi'], tags: {} },
+      ctx,
+    );
+
+    expect(out.state).toBe(chan);
+  });
+});
+
+// ============================================================================
+// privmsgChannelReducer — rejections
+// ============================================================================
+
+describe('privmsgChannelReducer — rejections', () => {
+  it('emits 411 ERR_NORECIPIENT when no target is supplied', () => {
+    const chan = makeChan('#foo');
+    addMember(chan, 'c1', 'alice');
+    const conn = makeConn();
+    const ctx = makeCtx(conn);
+
+    const out = privmsgChannelReducer(chan, { command: 'PRIVMSG', params: [], tags: {} }, ctx);
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(':irc.example.com 411 alice :No recipient given (PRIVMSG)')]),
+    ]);
+  });
+
+  it('emits 412 ERR_NOTEXTTOSEND when no text is supplied', () => {
+    const chan = makeChan('#foo');
+    addMember(chan, 'c1', 'alice');
+    const conn = makeConn();
+    const ctx = makeCtx(conn);
+
+    const out = privmsgChannelReducer(
+      chan,
+      { command: 'PRIVMSG', params: ['#foo'], tags: {} },
+      ctx,
+    );
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(':irc.example.com 412 alice :No text to send')]),
+    ]);
+  });
+
+  it('emits 412 ERR_NOTEXTTOSEND when the text param is empty', () => {
+    const chan = makeChan('#foo');
+    addMember(chan, 'c1', 'alice');
+    const conn = makeConn();
+    const ctx = makeCtx(conn);
+
+    const out = privmsgChannelReducer(
+      chan,
+      { command: 'PRIVMSG', params: ['#foo', ''], tags: {} },
+      ctx,
+    );
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(':irc.example.com 412 alice :No text to send')]),
+    ]);
+  });
+
+  it('emits 404 ERR_CANNOTSENDTOCHAN when a non-member sends to a +n channel', () => {
+    const chan = makeChan('#foo');
+    chan.modes.noExternal = true;
+    addMember(chan, 'c2', 'bob');
+    const conn = makeConn();
+    const ctx = makeCtx(conn);
+
+    const out = privmsgChannelReducer(
+      chan,
+      { command: 'PRIVMSG', params: ['#foo', 'hi'], tags: {} },
+      ctx,
+    );
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(':irc.example.com 404 alice #foo :Cannot send to channel')]),
+    ]);
+  });
+
+  it('emits 404 ERR_CANNOTSENDTOCHAN when a non-voiced non-op sends to a +m channel', () => {
+    const chan = makeChan('#foo');
+    chan.modes.moderated = true;
+    addMember(chan, 'c1', 'alice', false, false);
+    const conn = makeConn();
+    const ctx = makeCtx(conn);
+
+    const out = privmsgChannelReducer(
+      chan,
+      { command: 'PRIVMSG', params: ['#foo', 'hi'], tags: {} },
+      ctx,
+    );
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(':irc.example.com 404 alice #foo :Cannot send to channel')]),
+    ]);
+  });
+
+  it('emits 404 ERR_CANNOTSENDTOCHAN when +m is set and the sender is not a member at all', () => {
+    const chan = makeChan('#foo');
+    chan.modes.moderated = true;
+    // +n NOT set, so the +n check passes; the +m check then rejects a non-member.
+    addMember(chan, 'c2', 'bob', true, false);
+    const conn = makeConn();
+    const ctx = makeCtx(conn);
+
+    const out = privmsgChannelReducer(
+      chan,
+      { command: 'PRIVMSG', params: ['#foo', 'hi'], tags: {} },
+      ctx,
+    );
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(':irc.example.com 404 alice #foo :Cannot send to channel')]),
+    ]);
+  });
+
+  it('emits 404 ERR_CANNOTSENDTOCHAN when a banned member sends to the channel', () => {
+    const chan = makeChan('#foo');
+    chan.banMasks.add('*!*@example.com');
+    addMember(chan, 'c1', 'alice');
+    const conn = makeConn();
+    const ctx = makeCtx(conn);
+
+    const out = privmsgChannelReducer(
+      chan,
+      { command: 'PRIVMSG', params: ['#foo', 'hi'], tags: {} },
+      ctx,
+    );
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(':irc.example.com 404 alice #foo :Cannot send to channel')]),
+    ]);
+  });
+
+  it('honors the ? wildcard in ban masks when checking the sender hostmask', () => {
+    const chan = makeChan('#foo');
+    // Five `?` match the 5-char user segment `alice` in alice!alice@example.com.
+    chan.banMasks.add('alice!?????@example.com');
+    addMember(chan, 'c1', 'alice');
+    const conn = makeConn();
+    const ctx = makeCtx(conn);
+
+    const out = privmsgChannelReducer(
+      chan,
+      { command: 'PRIVMSG', params: ['#foo', 'hi'], tags: {} },
+      ctx,
+    );
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(':irc.example.com 404 alice #foo :Cannot send to channel')]),
+    ]);
+  });
+
+  it('proceeds with the broadcast when the ban list is non-empty but no mask matches', () => {
+    const chan = makeChan('#foo');
+    chan.banMasks.add('*!*@baddomain.example');
+    chan.banMasks.add('evil!*@*');
+    addMember(chan, 'c1', 'alice');
+    const conn = makeConn();
+    const ctx = makeCtx(conn);
+
+    const out = privmsgChannelReducer(
+      chan,
+      { command: 'PRIVMSG', params: ['#foo', 'hi'], tags: {} },
+      ctx,
+    );
+
+    expect(out.effects).toHaveLength(1);
+    expect(out.effects[0]?.tag).toBe('Broadcast');
+  });
+
+  it('uses * in numeric replies when the connection has no nick (defensive)', () => {
+    const chan = makeChan('#foo');
+    addMember(chan, 'c1', 'alice');
+    const conn = createConnection({ id: 'c1', connectedSince: 0 });
+    const ctx = makeCtx(conn);
+
+    const out = privmsgChannelReducer(
+      chan,
+      { command: 'PRIVMSG', params: ['#foo'], tags: {} },
+      ctx,
+    );
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(':irc.example.com 412 * :No text to send')]),
+    ]);
+  });
+
+  it('falls back to ? as the PRIVMSG source when the connection has no nick (defensive)', () => {
+    const chan = makeChan('#foo');
+    // +n not set so a non-member can send; sender has no nick at all.
+    addMember(chan, 'c2', 'bob');
+    const conn = createConnection({ id: 'c1', connectedSince: 0 });
+    const ctx = makeCtx(conn);
+
+    const out = privmsgChannelReducer(
+      chan,
+      { command: 'PRIVMSG', params: ['#foo', 'hi'], tags: {} },
+      ctx,
+    );
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.broadcast('#foo', [L(':? PRIVMSG #foo :hi')], 'c1'),
+    ]);
+  });
+});
+
+// ============================================================================
+// noticeChannelReducer
+// ============================================================================
+
+describe('noticeChannelReducer', () => {
+  it('broadcasts NOTICE to all channel members except the sender', () => {
+    const chan = makeChan('#foo');
+    addMember(chan, 'c1', 'alice');
+    addMember(chan, 'c2', 'bob');
+    const conn = makeConn();
+    const ctx = makeCtx(conn);
+
+    const out = noticeChannelReducer(
+      chan,
+      { command: 'NOTICE', params: ['#foo', 'psst'], tags: {} },
+      ctx,
+    );
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.broadcast('#foo', [L(':alice!alice@example.com NOTICE #foo :psst')], 'c1'),
+    ]);
+  });
+
+  it('MUST NOT produce any numeric reply when target is missing (RFC-critical)', () => {
+    const chan = makeChan('#foo');
+    addMember(chan, 'c1', 'alice');
+    const conn = makeConn();
+    const ctx = makeCtx(conn);
+
+    const out = noticeChannelReducer(chan, { command: 'NOTICE', params: [], tags: {} }, ctx);
+
+    expect(out.effects).toEqual([]);
+  });
+
+  it('MUST NOT produce any numeric reply when text is missing (RFC-critical)', () => {
+    const chan = makeChan('#foo');
+    addMember(chan, 'c1', 'alice');
+    const conn = makeConn();
+    const ctx = makeCtx(conn);
+
+    const out = noticeChannelReducer(chan, { command: 'NOTICE', params: ['#foo'], tags: {} }, ctx);
+
+    expect(out.effects).toEqual([]);
+  });
+
+  it('MUST NOT produce any numeric reply when banned (RFC-critical)', () => {
+    const chan = makeChan('#foo');
+    chan.banMasks.add('*!*@example.com');
+    addMember(chan, 'c1', 'alice');
+    const conn = makeConn();
+    const ctx = makeCtx(conn);
+
+    const out = noticeChannelReducer(
+      chan,
+      { command: 'NOTICE', params: ['#foo', 'hi'], tags: {} },
+      ctx,
+    );
+
+    expect(out.effects).toEqual([]);
+  });
+
+  it('MUST NOT produce any numeric reply when rejected by +n (RFC-critical)', () => {
+    const chan = makeChan('#foo');
+    chan.modes.noExternal = true;
+    addMember(chan, 'c2', 'bob');
+    const conn = makeConn();
+    const ctx = makeCtx(conn);
+
+    const out = noticeChannelReducer(
+      chan,
+      { command: 'NOTICE', params: ['#foo', 'hi'], tags: {} },
+      ctx,
+    );
+
+    expect(out.effects).toEqual([]);
+  });
+
+  it('MUST NOT produce any numeric reply when rejected by +m (RFC-critical)', () => {
+    const chan = makeChan('#foo');
+    chan.modes.moderated = true;
+    addMember(chan, 'c1', 'alice', false, false);
+    const conn = makeConn();
+    const ctx = makeCtx(conn);
+
+    const out = noticeChannelReducer(
+      chan,
+      { command: 'NOTICE', params: ['#foo', 'hi'], tags: {} },
+      ctx,
+    );
+
+    expect(out.effects).toEqual([]);
+  });
+
+  it('still broadcasts when the sender is an op of a +m channel', () => {
+    const chan = makeChan('#foo');
+    chan.modes.moderated = true;
+    addMember(chan, 'c1', 'alice', true, false);
+    const conn = makeConn();
+    const ctx = makeCtx(conn);
+
+    const out = noticeChannelReducer(
+      chan,
+      { command: 'NOTICE', params: ['#foo', 'hi'], tags: {} },
+      ctx,
+    );
+
+    expect(out.effects).toHaveLength(1);
+    expect(out.effects[0]?.tag).toBe('Broadcast');
+  });
+
+  it('proceeds with the broadcast when the ban list is non-empty but no mask matches', () => {
+    const chan = makeChan('#foo');
+    chan.banMasks.add('*!*@baddomain.example');
+    chan.banMasks.add('evil!*@*');
+    addMember(chan, 'c1', 'alice');
+    const conn = makeConn();
+    const ctx = makeCtx(conn);
+
+    const out = noticeChannelReducer(
+      chan,
+      { command: 'NOTICE', params: ['#foo', 'hi'], tags: {} },
+      ctx,
+    );
+
+    expect(out.effects).toHaveLength(1);
+    expect(out.effects[0]?.tag).toBe('Broadcast');
+  });
+});
+
+// ============================================================================
+// privmsgUserReducer
+// ============================================================================
+
+describe('privmsgUserReducer', () => {
+  it('emits a SendToNick effect for a private PRIVMSG to an online user', () => {
+    const conn = makeConn();
+    const ctx = makeCtx(conn);
+
+    const out = privmsgUserReducer(
+      conn,
+      { command: 'PRIVMSG', params: ['bob', 'hi bob'], tags: {} },
+      ctx,
+    );
+
+    // PRIVMSG always carries the 401 fallback — the dispatch layer decides
+    // whether to send it based on the lookup result.
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.sendToNick(
+        'bob',
+        'c1',
+        [L(':alice!alice@example.com PRIVMSG bob :hi bob')],
+        [L(':irc.example.com 401 alice bob :No such nick/channel')],
+      ),
+    ]);
+  });
+
+  it('emits 411 ERR_NORECIPIENT when no target is supplied', () => {
+    const conn = makeConn();
+    const ctx = makeCtx(conn);
+
+    const out = privmsgUserReducer(conn, { command: 'PRIVMSG', params: [], tags: {} }, ctx);
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(':irc.example.com 411 alice :No recipient given (PRIVMSG)')]),
+    ]);
+  });
+
+  it('emits 412 ERR_NOTEXTTOSEND when no text is supplied', () => {
+    const conn = makeConn();
+    const ctx = makeCtx(conn);
+
+    const out = privmsgUserReducer(conn, { command: 'PRIVMSG', params: ['bob'], tags: {} }, ctx);
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(':irc.example.com 412 alice :No text to send')]),
+    ]);
+  });
+
+  it('updates lastSeen to ctx.clock.now()', () => {
+    const conn = makeConn();
+    const clock = new FakeClock(12_000);
+    const ctx = makeCtx(conn, clock);
+
+    privmsgUserReducer(conn, { command: 'PRIVMSG', params: ['bob', 'hi'], tags: {} }, ctx);
+
+    expect(conn.lastSeen).toBe(12_000);
+  });
+
+  it('returns the same state reference (mutation permitted, no copy)', () => {
+    const conn = makeConn();
+    const ctx = makeCtx(conn);
+
+    const out = privmsgUserReducer(
+      conn,
+      { command: 'PRIVMSG', params: ['bob', 'hi'], tags: {} },
+      ctx,
+    );
+
+    expect(out.state).toBe(conn);
+  });
+});
+
+// ============================================================================
+// noticeUserReducer
+// ============================================================================
+
+describe('noticeUserReducer', () => {
+  it('emits a SendToNick effect for a private NOTICE to an online user', () => {
+    const conn = makeConn();
+    const ctx = makeCtx(conn);
+
+    const out = noticeUserReducer(
+      conn,
+      { command: 'NOTICE', params: ['bob', 'psst'], tags: {} },
+      ctx,
+    );
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.sendToNick('bob', 'c1', [L(':alice!alice@example.com NOTICE bob :psst')]),
+    ]);
+  });
+
+  it('MUST NOT emit any not-found reply for an offline recipient (RFC-critical)', () => {
+    const conn = makeConn();
+    const ctx = makeCtx(conn);
+
+    const out = noticeUserReducer(
+      conn,
+      { command: 'NOTICE', params: ['nobody', 'hi'], tags: {} },
+      ctx,
+    );
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.sendToNick('nobody', 'c1', [L(':alice!alice@example.com NOTICE nobody :hi')]),
+    ]);
+  });
+
+  it('MUST NOT produce any numeric reply when target is missing (RFC-critical)', () => {
+    const conn = makeConn();
+    const ctx = makeCtx(conn);
+
+    const out = noticeUserReducer(conn, { command: 'NOTICE', params: [], tags: {} }, ctx);
+
+    expect(out.effects).toEqual([]);
+  });
+
+  it('MUST NOT produce any numeric reply when text is missing (RFC-critical)', () => {
+    const conn = makeConn();
+    const ctx = makeCtx(conn);
+
+    const out = noticeUserReducer(conn, { command: 'NOTICE', params: ['bob'], tags: {} }, ctx);
+
+    expect(out.effects).toEqual([]);
+  });
+});