serverless-ircd 0.3.0 → 0.5.0

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

@@ -0,0 +1,264 @@
+import { describe, expect, it } from 'vitest';
+import { formatUserhostReply, userhostReducer } from '../../src/commands/userhost';
+import { Effect } from '../../src/effects';
+import type { Effect as EffectType, RawLine } from '../../src/effects';
+import { EmptyMotdProvider, FakeClock, SequentialIdFactory } from '../../src/ports';
+import {
+  type ConnSnapshot,
+  type ConnectionState,
+  createConnection,
+  toSnapshot,
+} from '../../src/state/connection';
+import { type Ctx, type ServerConfig, buildCtx } from '../../src/types';
+
+const baseServerConfig: ServerConfig = {
+  serverName: 'irc.example.com',
+  networkName: 'ExampleNet',
+  maxChannelsPerUser: 30,
+  maxTargetsPerCommand: 10,
+  maxListEntries: 50,
+  nickLen: 30,
+  channelLen: 50,
+  topicLen: 390,
+  quitMessage: 'Client Quit',
+};
+
+function makeCtx(state: ConnectionState): Ctx {
+  return buildCtx({
+    serverConfig: baseServerConfig,
+    clock: new FakeClock(5_000),
+    ids: new SequentialIdFactory(),
+    motd: EmptyMotdProvider,
+    connection: state,
+  });
+}
+
+function makeState(): ConnectionState {
+  const s = createConnection({ id: 'c1', connectedSince: 0 });
+  s.nick = 'alice';
+  s.user = 'alice';
+  s.host = 'example.com';
+  s.realname = 'Alice';
+  s.registration = 'registered';
+  return s;
+}
+
+function makeSnapshot(
+  nick: string,
+  user: string,
+  host: string,
+  opts?: { away?: string; oper?: boolean },
+): ConnSnapshot {
+  const s = createConnection({ id: `c-${nick}`, connectedSince: 0 });
+  s.nick = nick;
+  s.user = user;
+  s.host = host;
+  s.registration = 'registered';
+  if (opts?.away !== undefined) s.away = opts.away;
+  if (opts?.oper) s.userModes.oper = true;
+  return toSnapshot(s);
+}
+
+const L = (text: string): RawLine => ({ text });
+
+const userhost = (...nicks: string[]) =>
+  ({ command: 'USERHOST', params: nicks, tags: {} }) as const;
+
+describe('userhostReducer', () => {
+  it('emits 302 RPL_USERHOST with the resolved hostmask for one nick', () => {
+    const state = makeState();
+    const ctx = makeCtx(state);
+    const resolved = new Map([['bob', makeSnapshot('bob', 'bobuser', 'bobhost')]]);
+
+    const out = userhostReducer(resolved, userhost('bob'), ctx);
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(':irc.example.com 302 alice :bob=+bobuser@bobhost')]),
+    ]);
+  });
+
+  it('includes multiple replies space-separated in one 302 line', () => {
+    const state = makeState();
+    const ctx = makeCtx(state);
+    const resolved = new Map([
+      ['bob', makeSnapshot('bob', 'bobuser', 'bobhost')],
+      ['carol', makeSnapshot('carol', 'caroluser', 'carolhost')],
+    ]);
+
+    const out = userhostReducer(resolved, userhost('bob', 'carol'), ctx);
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [
+        L(':irc.example.com 302 alice :bob=+bobuser@bobhost carol=+caroluser@carolhost'),
+      ]),
+    ]);
+  });
+
+  it('marks away users with - instead of +', () => {
+    const state = makeState();
+    const ctx = makeCtx(state);
+    const resolved = new Map([
+      ['bob', makeSnapshot('bob', 'bobuser', 'bobhost', { away: 'gone' })],
+    ]);
+
+    const out = userhostReducer(resolved, userhost('bob'), ctx);
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(':irc.example.com 302 alice :bob=-bobuser@bobhost')]),
+    ]);
+  });
+
+  it('prefixes oper users with *', () => {
+    const state = makeState();
+    const ctx = makeCtx(state);
+    const resolved = new Map([['bob', makeSnapshot('bob', 'bobuser', 'bobhost', { oper: true })]]);
+
+    const out = userhostReducer(resolved, userhost('bob'), ctx);
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(':irc.example.com 302 alice :bob*=+bobuser@bobhost')]),
+    ]);
+  });
+
+  it('omits nicks that are offline (null in the resolved map)', () => {
+    const state = makeState();
+    const ctx = makeCtx(state);
+    const resolved = new Map<string, ConnSnapshot | null>([
+      ['bob', makeSnapshot('bob', 'bobuser', 'bobhost')],
+      ['ghost', null],
+    ]);
+
+    const out = userhostReducer(resolved, userhost('bob', 'ghost'), ctx);
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(':irc.example.com 302 alice :bob=+bobuser@bobhost')]),
+    ]);
+  });
+
+  it('emits an empty trailing when no requested nicks are online', () => {
+    const state = makeState();
+    const ctx = makeCtx(state);
+    const resolved = new Map<string, ConnSnapshot | null>([['ghost', null]]);
+
+    const out = userhostReducer(resolved, userhost('ghost'), ctx);
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(':irc.example.com 302 alice :')]),
+    ]);
+  });
+
+  it('emits an empty trailing when no nicks are requested', () => {
+    const state = makeState();
+    const ctx = makeCtx(state);
+    const resolved = new Map<string, ConnSnapshot | null>();
+
+    const out = userhostReducer(resolved, userhost(), ctx);
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(':irc.example.com 302 alice :')]),
+    ]);
+  });
+
+  it('uses * as nick placeholder for unregistered connections', () => {
+    const state = createConnection({ id: 'c1', connectedSince: 0 });
+    const ctx = makeCtx(state);
+    const resolved = new Map([['bob', makeSnapshot('bob', 'bobuser', 'bobhost')]]);
+
+    const out = userhostReducer(resolved, userhost('bob'), ctx);
+
+    expect(out.effects[0]).toEqual<EffectType>(
+      Effect.send('c1', [L(':irc.example.com 302 * :bob=+bobuser@bobhost')]),
+    );
+  });
+
+  it('updates lastSeen to ctx.clock.now()', () => {
+    const state = makeState();
+    const ctx = makeCtx(state);
+
+    userhostReducer(new Map(), userhost('bob'), ctx);
+
+    expect(state.lastSeen).toBe(5_000);
+  });
+
+  it('returns the same state reference', () => {
+    const state = makeState();
+    const ctx = makeCtx(state);
+
+    const out = userhostReducer(new Map(), userhost(), ctx);
+
+    expect(out.state).toBe(state);
+  });
+
+  it('respects the max-targets cap (caps the number of queried nicks)', () => {
+    const state = makeState();
+    const config: ServerConfig = { ...baseServerConfig, maxTargetsPerCommand: 2 };
+    const ctx = buildCtx({
+      serverConfig: config,
+      clock: new FakeClock(5_000),
+      ids: new SequentialIdFactory(),
+      motd: EmptyMotdProvider,
+      connection: state,
+    });
+    const resolved = new Map([
+      ['bob', makeSnapshot('bob', 'bu', 'bh')],
+      ['carol', makeSnapshot('carol', 'cu', 'ch')],
+      ['dave', makeSnapshot('dave', 'du', 'dh')],
+    ]);
+
+    const out = userhostReducer(resolved, userhost('bob', 'carol', 'dave'), ctx);
+
+    const text = (out.effects[0] as { lines: RawLine[] }).lines[0]?.text;
+    // Only the first two nicks should appear; the third is beyond the cap.
+    expect(text).not.toContain('dave');
+    expect(text).toContain('bob');
+    expect(text).toContain('carol');
+  });
+
+  it('skips an empty-string nick in the parameter list', () => {
+    const state = makeState();
+    const ctx = makeCtx(state);
+    const resolved = new Map([['bob', makeSnapshot('bob', 'bobuser', 'bobhost')]]);
+
+    const out = userhostReducer(resolved, userhost('', 'bob'), ctx);
+
+    const text = (out.effects[0] as { lines: RawLine[] }).lines[0]?.text;
+    expect(text).toContain('bob=+bobuser@bobhost');
+  });
+
+  it('omits a resolved snapshot that is missing required fields (host absent)', () => {
+    const state = makeState();
+    const ctx = makeCtx(state);
+    const incomplete = makeSnapshot('bob', 'bobuser', 'bobhost');
+    (incomplete as { host: string | undefined }).host = undefined;
+    const resolved = new Map<string, ConnSnapshot | null>([
+      ['bob', incomplete],
+      ['carol', makeSnapshot('carol', 'caroluser', 'carolhost')],
+    ]);
+
+    const out = userhostReducer(resolved, userhost('bob', 'carol'), ctx);
+
+    const text = (out.effects[0] as { lines: RawLine[] }).lines[0]?.text;
+    expect(text).not.toContain('bob');
+    expect(text).toContain('carol=+caroluser@carolhost');
+  });
+});
+
+describe('formatUserhostReply', () => {
+  it('returns null when the snapshot is missing a nick', () => {
+    const snap = makeSnapshot('bob', 'bu', 'bh');
+    (snap as { nick: string | undefined }).nick = undefined;
+    expect(formatUserhostReply(snap)).toBeNull();
+  });
+
+  it('returns null when the snapshot is missing a user', () => {
+    const snap = makeSnapshot('bob', 'bu', 'bh');
+    (snap as { user: string | undefined }).user = undefined;
+    expect(formatUserhostReply(snap)).toBeNull();
+  });
+
+  it('returns null when the snapshot is missing a host', () => {
+    const snap = makeSnapshot('bob', 'bu', 'bh');
+    (snap as { host: string | undefined }).host = undefined;
+    expect(formatUserhostReply(snap)).toBeNull();
+  });
+});

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

@@ -0,0 +1,231 @@
+import { describe, expect, it } from 'vitest';
+import { wallopsReducer } from '../../src/commands/wallops';
+import { Effect } from '../../src/effects';
+import type { Effect as EffectType, RawLine } from '../../src/effects';
+import { EmptyMotdProvider, FakeClock, 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, clock = new FakeClock(5_000)): Ctx {
+  return buildCtx({
+    serverConfig,
+    clock,
+    ids: new SequentialIdFactory(),
+    motd: EmptyMotdProvider,
+    connection: conn,
+  });
+}
+
+function makeOper(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';
+  s.userModes.oper = true;
+  return s;
+}
+
+const L = (text: string): RawLine => ({ text });
+
+const wallops = (message?: string) =>
+  ({
+    command: 'WALLOPS',
+    params: message === undefined ? [] : [message],
+    tags: {},
+  }) as const;
+
+describe('wallopsReducer — oper happy path', () => {
+  it('emits a global BroadcastWallops effect carrying the oper source prefix', () => {
+    const oper = makeOper();
+    const ctx = makeCtx(oper);
+
+    const out = wallopsReducer(oper, wallops('hello'), ctx);
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.broadcastWallops([L(':alice!alice@example.com WALLOPS :hello')], 'c1'),
+    ]);
+  });
+
+  it('passes the message text through verbatim (multi-word)', () => {
+    const oper = makeOper();
+    const ctx = makeCtx(oper);
+
+    const out = wallopsReducer(oper, wallops('restart in 5 minutes'), ctx);
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.broadcastWallops([L(':alice!alice@example.com WALLOPS :restart in 5 minutes')], 'c1'),
+    ]);
+  });
+
+  it('defaults except to the sender (skip-self, NOTICE/PRIVMSG semantics)', () => {
+    const oper = makeOper();
+    const ctx = makeCtx(oper);
+
+    const out = wallopsReducer(oper, wallops('hi'), ctx);
+
+    expect(out.effects[0]?.tag).toBe('BroadcastWallops');
+    // except is the oper's own connection id, so the runtime never echoes
+    // the wallops back to its originator.
+    expect((out.effects[0] as { except?: string }).except).toBe('c1');
+  });
+
+  it('updates the oper lastSeen to ctx.clock.now()', () => {
+    const oper = makeOper();
+    expect(oper.lastSeen).toBe(0);
+    const ctx = makeCtx(oper);
+
+    wallopsReducer(oper, wallops('hi'), ctx);
+
+    expect(oper.lastSeen).toBe(5_000);
+  });
+
+  it('returns the same state reference unchanged', () => {
+    const oper = makeOper();
+    const ctx = makeCtx(oper);
+
+    const out = wallopsReducer(oper, wallops('hi'), ctx);
+
+    expect(out.state).toBe(oper);
+  });
+
+  it('falls back to the bare nick when the hostmask is incomplete (no user/host)', () => {
+    const oper = createConnection({ id: 'c1', connectedSince: 0 });
+    oper.nick = 'alice';
+    oper.registration = 'registered';
+    oper.userModes.oper = true;
+    const ctx = makeCtx(oper);
+
+    const out = wallopsReducer(oper, wallops('hi'), ctx);
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.broadcastWallops([L(':alice WALLOPS :hi')], 'c1'),
+    ]);
+  });
+
+  it('falls back to "*" when the oper has neither nick nor hostmask (defensive)', () => {
+    const oper = createConnection({ id: 'c1', connectedSince: 0 });
+    oper.registration = 'registered';
+    oper.userModes.oper = true;
+    const ctx = makeCtx(oper);
+
+    const out = wallopsReducer(oper, wallops('hi'), ctx);
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.broadcastWallops([L(':* WALLOPS :hi')], 'c1'),
+    ]);
+  });
+});
+
+describe('wallopsReducer — non-oper (481 ERR_NOPRIVILEGES)', () => {
+  it('emits 481 when the sender is not an oper', () => {
+    const oper = makeOper();
+    oper.userModes.oper = false;
+    const ctx = makeCtx(oper);
+
+    const out = wallopsReducer(oper, wallops('hi'), ctx);
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [
+        L(":irc.example.com 481 alice :Permission Denied - You're not an IRC operator"),
+      ]),
+    ]);
+  });
+
+  it('does not emit a BroadcastWallops when the sender is not an oper', () => {
+    const oper = makeOper();
+    oper.userModes.oper = false;
+    const ctx = makeCtx(oper);
+
+    const out = wallopsReducer(oper, wallops('hi'), ctx);
+
+    expect(out.effects.some((e) => e.tag === 'BroadcastWallops')).toBe(false);
+  });
+
+  it('gates before param validation: a non-oper with no message still gets 481', () => {
+    const oper = makeOper();
+    oper.userModes.oper = false;
+    const ctx = makeCtx(oper);
+
+    const out = wallopsReducer(oper, wallops(), ctx);
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [
+        L(":irc.example.com 481 alice :Permission Denied - You're not an IRC operator"),
+      ]),
+    ]);
+  });
+
+  it('uses "*" as the nick in 481 when the connection has no nick', () => {
+    const oper = createConnection({ id: 'c1', connectedSince: 0 });
+    oper.userModes.oper = false;
+    const ctx = makeCtx(oper);
+
+    const out = wallopsReducer(oper, wallops('hi'), ctx);
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [
+        L(":irc.example.com 481 * :Permission Denied - You're not an IRC operator"),
+      ]),
+    ]);
+  });
+});
+
+describe('wallopsReducer — empty message (412 ERR_NOTEXTTOSEND)', () => {
+  it('emits 412 when no message parameter is supplied', () => {
+    const oper = makeOper();
+    const ctx = makeCtx(oper);
+
+    const out = wallopsReducer(oper, wallops(), ctx);
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(':irc.example.com 412 alice :No text to send')]),
+    ]);
+  });
+
+  it('emits 412 when the message is the empty string', () => {
+    const oper = makeOper();
+    const ctx = makeCtx(oper);
+
+    const out = wallopsReducer(oper, wallops(''), ctx);
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(':irc.example.com 412 alice :No text to send')]),
+    ]);
+  });
+
+  it('does not broadcast when the message is empty', () => {
+    const oper = makeOper();
+    const ctx = makeCtx(oper);
+
+    const out = wallopsReducer(oper, wallops(''), ctx);
+
+    expect(out.effects.some((e) => e.tag === 'BroadcastWallops')).toBe(false);
+  });
+
+  it('uses "*" as the nick in 412 when the connection has no nick', () => {
+    const oper = createConnection({ id: 'c1', connectedSince: 0 });
+    oper.registration = 'registered';
+    oper.userModes.oper = true;
+    const ctx = makeCtx(oper);
+
+    const out = wallopsReducer(oper, wallops(''), ctx);
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(':irc.example.com 412 * :No text to send')]),
+    ]);
+  });
+});