serverless-ircd 0.3.0 → 0.5.0

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

@@ -0,0 +1,166 @@
+import { describe, expect, it } from 'vitest';
+import { isonReducer } from '../../src/commands/ison';
+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 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;
+}
+
+const L = (text: string): RawLine => ({ text });
+
+const ison = (...nicks: string[]) => ({ command: 'ISON', params: nicks, tags: {} }) as const;
+
+/** Builds an online map from display-case nicks (auto-folds the key). */
+const onlineMap = (...nicks: string[]): Map<string, string> =>
+  new Map(nicks.map((n) => [n.toLowerCase(), n]));
+
+describe('isonReducer', () => {
+  it('emits 303 RPL_ISON with the online nicks from the requested set', () => {
+    const state = makeState();
+    const ctx = makeCtx(state);
+
+    const out = isonReducer(onlineMap('bob', 'carol'), ison('bob', 'carol', 'dave'), ctx);
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(':irc.example.com 303 alice :bob carol')]),
+    ]);
+  });
+
+  it('only includes nicks that are online', () => {
+    const state = makeState();
+    const ctx = makeCtx(state);
+
+    const out = isonReducer(onlineMap('bob'), ison('bob', 'carol', 'dave'), ctx);
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(':irc.example.com 303 alice :bob')]),
+    ]);
+  });
+
+  it('emits an empty trailing when no requested nicks are online', () => {
+    const state = makeState();
+    const ctx = makeCtx(state);
+
+    const out = isonReducer(new Map(), ison('nobody'), ctx);
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(':irc.example.com 303 alice :')]),
+    ]);
+  });
+
+  it('preserves the registered display spelling from the online map', () => {
+    const state = makeState();
+    const ctx = makeCtx(state);
+
+    const out = isonReducer(onlineMap('Bob'), ison('Bob'), ctx);
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(':irc.example.com 303 alice :Bob')]),
+    ]);
+  });
+
+  it('matches case-insensitively (rfc1459 case-mapping)', () => {
+    const state = makeState();
+    const ctx = makeCtx(state);
+
+    const out = isonReducer(onlineMap('bob'), ison('BOB'), ctx);
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(':irc.example.com 303 alice :bob')]),
+    ]);
+  });
+
+  it('reports the registered spelling even when requested with different case', () => {
+    const state = makeState();
+    const ctx = makeCtx(state);
+
+    const out = isonReducer(onlineMap('Bob'), ison('BOB'), ctx);
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(':irc.example.com 303 alice :Bob')]),
+    ]);
+  });
+
+  it('uses * as nick placeholder for unregistered connections', () => {
+    const state = createConnection({ id: 'c1', connectedSince: 0 });
+    const ctx = makeCtx(state);
+
+    const out = isonReducer(onlineMap('bob'), ison('bob'), ctx);
+
+    expect(out.effects[0]).toEqual<EffectType>(
+      Effect.send('c1', [L(':irc.example.com 303 * :bob')]),
+    );
+  });
+
+  it('updates lastSeen to ctx.clock.now()', () => {
+    const state = makeState();
+    const ctx = makeCtx(state);
+
+    isonReducer(new Map(), ison('bob'), ctx);
+
+    expect(state.lastSeen).toBe(5_000);
+  });
+
+  it('returns the same state reference', () => {
+    const state = makeState();
+    const ctx = makeCtx(state);
+
+    const out = isonReducer(new Map(), ison(), ctx);
+
+    expect(out.state).toBe(state);
+  });
+
+  it('handles no-nick argument (empty request)', () => {
+    const state = makeState();
+    const ctx = makeCtx(state);
+
+    const out = isonReducer(onlineMap('bob'), ison(), ctx);
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(':irc.example.com 303 alice :')]),
+    ]);
+  });
+
+  it('skips empty-string params in the nick list', () => {
+    const state = makeState();
+    const ctx = makeCtx(state);
+
+    const out = isonReducer(onlineMap('bob'), ison('', 'bob'), ctx);
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(':irc.example.com 303 alice :bob')]),
+    ]);
+  });
+});

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

@@ -0,0 +1,243 @@
+import { describe, expect, it } from 'vitest';
+import { killReducer } from '../../src/commands/kill';
+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;
+}
+
+function makeTarget(id = 'c2', nick = 'bob'): ConnectionState {
+  const s = createConnection({ id, connectedSince: 0 });
+  s.nick = nick;
+  s.user = nick;
+  s.host = 'example.com';
+  s.realname = 'Bob';
+  s.registration = 'registered';
+  return s;
+}
+
+const L = (text: string): RawLine => ({ text });
+
+const kill = (nick?: string, comment?: string) =>
+  ({
+    command: 'KILL',
+    params: nick === undefined ? [] : comment === undefined ? [nick] : [nick, comment],
+    tags: {},
+  }) as const;
+
+describe('killReducer — oper happy path', () => {
+  it('emits a Disconnect effect for the target with a kill-formatted reason', () => {
+    const oper = makeOper();
+    const target = makeTarget();
+    const ctx = makeCtx(oper);
+
+    const out = killReducer(target, kill('bob', 'flooding'), ctx);
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.disconnect('c2', 'Killed (alice (flooding))'),
+    ]);
+  });
+
+  it('uses the oper display nick in the reason, not the target nick', () => {
+    const oper = makeOper('c1', 'theOper');
+    const target = makeTarget('c2', 'bob');
+    const ctx = makeCtx(oper);
+
+    const out = killReducer(target, kill('bob', 'bye'), ctx);
+
+    expect(out.effects).toEqual<EffectType[]>([Effect.disconnect('c2', 'Killed (theOper (bye))')]);
+  });
+
+  it('formats multi-word comments verbatim inside the inner parens', () => {
+    const oper = makeOper();
+    const target = makeTarget();
+    const ctx = makeCtx(oper);
+
+    const out = killReducer(target, kill('bob', 'stop flooding the channel'), ctx);
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.disconnect('c2', 'Killed (alice (stop flooding the channel))'),
+    ]);
+  });
+
+  it('updates the oper lastSeen to ctx.clock.now()', () => {
+    const oper = makeOper();
+    expect(oper.lastSeen).toBe(0);
+    const ctx = makeCtx(oper);
+
+    killReducer(makeTarget(), kill('bob', 'flooding'), ctx);
+
+    expect(oper.lastSeen).toBe(5_000);
+  });
+
+  it('falls back to "*" for the oper nick in the reason when the oper has none', () => {
+    const oper = createConnection({ id: 'c1', connectedSince: 0 });
+    oper.userModes.oper = true;
+    const target = makeTarget();
+    const ctx = makeCtx(oper);
+
+    const out = killReducer(target, kill('bob', 'x'), ctx);
+
+    expect(out.effects).toEqual<EffectType[]>([Effect.disconnect('c2', 'Killed (* (x))')]);
+  });
+});
+
+describe('killReducer — self-kill (RFC-permitted)', () => {
+  it('allows an oper to KILL themselves, disconnecting their own connection', () => {
+    const oper = makeOper('c1', 'alice');
+    const ctx = makeCtx(oper);
+
+    const out = killReducer(oper, kill('alice', 'self-terminate'), ctx);
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.disconnect('c1', 'Killed (alice (self-terminate))'),
+    ]);
+  });
+});
+
+describe('killReducer — non-oper (481 ERR_NOPRIVILEGES)', () => {
+  it('emits 481 when the sender is not an oper', () => {
+    const oper = makeOper();
+    oper.userModes.oper = false;
+    const target = makeTarget();
+    const ctx = makeCtx(oper);
+
+    const out = killReducer(target, kill('bob', 'flooding'), 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 disconnect the target when the sender is not an oper', () => {
+    const oper = makeOper();
+    oper.userModes.oper = false;
+    const target = makeTarget();
+    const ctx = makeCtx(oper);
+
+    const out = killReducer(target, kill('bob', 'flooding'), ctx);
+
+    expect(out.effects.some((e) => e.tag === 'Disconnect')).toBe(false);
+  });
+
+  it('gates before param validation: a non-oper with missing params still gets 481', () => {
+    const oper = makeOper();
+    oper.userModes.oper = false;
+    const ctx = makeCtx(oper);
+
+    const out = killReducer(undefined, kill(), 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 = killReducer(undefined, kill('bob', 'x'), ctx);
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [
+        L(":irc.example.com 481 * :Permission Denied - You're not an IRC operator"),
+      ]),
+    ]);
+  });
+});
+
+describe('killReducer — missing parameters (461 ERR_NEEDMOREPARAMS)', () => {
+  it('emits 461 when no parameters are supplied', () => {
+    const oper = makeOper();
+    const ctx = makeCtx(oper);
+
+    const out = killReducer(undefined, kill(), ctx);
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(':irc.example.com 461 alice KILL :Not enough parameters')]),
+    ]);
+  });
+
+  it('emits 461 when only the nick is supplied (no comment)', () => {
+    const oper = makeOper();
+    const ctx = makeCtx(oper);
+
+    const out = killReducer(makeTarget(), kill('bob'), ctx);
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(':irc.example.com 461 alice KILL :Not enough parameters')]),
+    ]);
+  });
+
+  it('uses "*" as the nick in 461 when the connection has no nick', () => {
+    const oper = createConnection({ id: 'c1', connectedSince: 0 });
+    oper.userModes.oper = true;
+    const ctx = makeCtx(oper);
+
+    const out = killReducer(undefined, kill('bob'), ctx);
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(':irc.example.com 461 * KILL :Not enough parameters')]),
+    ]);
+  });
+});
+
+describe('killReducer — unknown nick (401 ERR_NOSUCHNICK)', () => {
+  it('emits 401 when the target resolves to undefined', () => {
+    const oper = makeOper();
+    const ctx = makeCtx(oper);
+
+    const out = killReducer(undefined, kill('ghost', 'flooding'), ctx);
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(':irc.example.com 401 alice ghost :No such nick/channel')]),
+    ]);
+  });
+
+  it('does not emit a Disconnect when the target is unknown', () => {
+    const oper = makeOper();
+    const ctx = makeCtx(oper);
+
+    const out = killReducer(undefined, kill('ghost', 'flooding'), ctx);
+
+    expect(out.effects.some((e) => e.tag === 'Disconnect')).toBe(false);
+  });
+});