serverless-ircd 0.1.0

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

@@ -0,0 +1,599 @@
+import { describe, expect, it } from 'vitest';
+import { generateIsupport } from '../../src/commands/isupport';
+import {
+  buildWelcomeLines,
+  emitWelcomeIfReady,
+  isValidNick,
+  nickReducer,
+  passReducer,
+  userReducer,
+} from '../../src/commands/registration';
+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(state: ConnectionState, clock = new FakeClock(1_000)): Ctx {
+  return buildCtx({
+    serverConfig,
+    clock,
+    ids: new SequentialIdFactory(),
+    motd: EmptyMotdProvider,
+    connection: state,
+  });
+}
+
+function makeState(): ConnectionState {
+  return createConnection({ id: 'c1', connectedSince: 0 });
+}
+
+/** Convenience: a fully-registered-ready state with nick + user already set. */
+function registeredState(): ConnectionState {
+  const s = makeState();
+  s.nick = 'alice';
+  s.user = 'alice';
+  s.host = 'example.com';
+  s.realname = 'Alice';
+  s.registration = 'registered';
+  return s;
+}
+
+const L = (text: string): RawLine => ({ text });
+
+/** Builds the expected welcome block for the given nick/user/host. */
+function expectedWelcome(nick: string, user: string, host: string | undefined): RawLine[] {
+  const sv = 'irc.example.com';
+  const hostmask = host !== undefined ? `${nick}!${user}@${host}` : `${nick}!${user}`;
+  const prefix = `:${sv}`;
+  const isupport = generateIsupport(
+    {
+      serverName: sv,
+      networkName: 'ExampleNet',
+      maxChannelsPerUser: 30,
+      maxTargetsPerCommand: 10,
+      maxListEntries: 50,
+      nickLen: 30,
+      channelLen: 50,
+      topicLen: 390,
+      quitMessage: 'Client Quit',
+    },
+    new Set<string>(),
+    nick,
+  );
+  return [
+    L(`${prefix} 001 ${nick} :Welcome to the ExampleNet IRC Network, ${hostmask}`),
+    L(`${prefix} 002 ${nick} :Your host is ${sv}, running version 0.1.0`),
+    L(`${prefix} 003 ${nick} :This server was created in Phase 1`),
+    L(`${prefix} 004 ${nick} ${sv} 0.1.0 iosw biklmnstp`),
+    ...isupport,
+    L(`${prefix} 375 ${nick} :- ${sv} Message of the day -`),
+    L(`${prefix} 372 ${nick} :- MOTD placeholder`),
+    L(`${prefix} 376 ${nick} :End of MOTD command`),
+  ];
+}
+
+// ============================================================================
+// isValidNick
+// ============================================================================
+
+describe('isValidNick', () => {
+  it('accepts a simple alpha nick', () => {
+    expect(isValidNick('alice', 30)).toBe(true);
+  });
+
+  it('accepts a single-letter nick', () => {
+    expect(isValidNick('a', 30)).toBe(true);
+  });
+
+  it('accepts digits after the first char', () => {
+    expect(isValidNick('a1b2', 30)).toBe(true);
+  });
+
+  it('accepts underscores', () => {
+    expect(isValidNick('a_b', 30)).toBe(true);
+  });
+
+  it('accepts hyphens', () => {
+    expect(isValidNick('a-b', 30)).toBe(true);
+  });
+
+  it('accepts square brackets', () => {
+    expect(isValidNick('a[b]c', 30)).toBe(true);
+  });
+
+  it('accepts backslash', () => {
+    expect(isValidNick('a\\b', 30)).toBe(true);
+  });
+
+  it('accepts backtick', () => {
+    expect(isValidNick('a`b', 30)).toBe(true);
+  });
+
+  it('accepts caret', () => {
+    expect(isValidNick('a^b', 30)).toBe(true);
+  });
+
+  it('accepts curly braces', () => {
+    expect(isValidNick('a{b}c', 30)).toBe(true);
+  });
+
+  it('accepts pipe', () => {
+    expect(isValidNick('a|b', 30)).toBe(true);
+  });
+
+  it('accepts uppercase letters', () => {
+    expect(isValidNick('Alice', 30)).toBe(true);
+  });
+
+  it('rejects a digit-first nick', () => {
+    expect(isValidNick('1alice', 30)).toBe(false);
+  });
+
+  it('rejects a hyphen-first nick', () => {
+    expect(isValidNick('-alice', 30)).toBe(false);
+  });
+
+  it('rejects an underscore-first nick', () => {
+    expect(isValidNick('_alice', 30)).toBe(false);
+  });
+
+  it('rejects an empty string', () => {
+    expect(isValidNick('', 30)).toBe(false);
+  });
+
+  it('rejects spaces', () => {
+    expect(isValidNick('a b', 30)).toBe(false);
+  });
+
+  it('rejects exclamation marks', () => {
+    expect(isValidNick('a!b', 30)).toBe(false);
+  });
+
+  it('rejects dots', () => {
+    expect(isValidNick('a.b', 30)).toBe(false);
+  });
+
+  it('rejects a nick exceeding the length cap', () => {
+    expect(isValidNick('a'.repeat(31), 30)).toBe(false);
+  });
+
+  it('accepts a nick at exactly the length cap', () => {
+    expect(isValidNick(`a${'b'.repeat(29)}`, 30)).toBe(true);
+  });
+});
+
+// ============================================================================
+// nickReducer
+// ============================================================================
+
+describe('nickReducer', () => {
+  it('reserves the nick and transitions to registering when user is not set', () => {
+    const state = makeState();
+    const ctx = makeCtx(state);
+    const out = nickReducer(state, { command: 'NICK', params: ['alice'], tags: {} }, ctx);
+    expect(out.state.nick).toBe('alice');
+    expect(out.state.registration).toBe('registering');
+    expect(out.effects).toEqual<EffectType[]>([Effect.reserveNick('alice', 'c1')]);
+  });
+
+  it('completes registration when NICK arrives after USER', () => {
+    const state = makeState();
+    state.user = 'alice';
+    state.realname = 'Alice';
+    state.registration = 'registering';
+    const ctx = makeCtx(state);
+    const out = nickReducer(state, { command: 'NICK', params: ['alice'], tags: {} }, ctx);
+    expect(out.state.nick).toBe('alice');
+    expect(out.state.registration).toBe('registered');
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.reserveNick('alice', 'c1'),
+      Effect.send('c1', expectedWelcome('alice', 'alice', undefined)),
+    ]);
+  });
+
+  it('completes registration with full hostmask when host is set', () => {
+    const state = makeState();
+    state.user = 'alice';
+    state.realname = 'Alice';
+    state.host = 'example.com';
+    state.registration = 'registering';
+    const ctx = makeCtx(state);
+    const out = nickReducer(state, { command: 'NICK', params: ['alice'], tags: {} }, ctx);
+    expect(out.effects).toContainEqual(
+      Effect.send('c1', expectedWelcome('alice', 'alice', 'example.com')),
+    );
+  });
+
+  it('emits 431 when no nickname is supplied', () => {
+    const state = makeState();
+    const ctx = makeCtx(state);
+    const out = nickReducer(state, { command: 'NICK', params: [], tags: {} }, ctx);
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(':irc.example.com 431 * :No nickname given')]),
+    ]);
+    expect(out.state.nick).toBeUndefined();
+    expect(out.state.registration).toBe('pre-registration');
+  });
+
+  it('emits 432 for a digit-first nick', () => {
+    const state = makeState();
+    const ctx = makeCtx(state);
+    const out = nickReducer(state, { command: 'NICK', params: ['1alice'], tags: {} }, ctx);
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(':irc.example.com 432 * 1alice :Erroneous nickname')]),
+    ]);
+    expect(out.state.nick).toBeUndefined();
+  });
+
+  it('emits 432 for a nick containing an invalid char', () => {
+    const state = makeState();
+    const ctx = makeCtx(state);
+    const out = nickReducer(state, { command: 'NICK', params: ['al!ce'], tags: {} }, ctx);
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(':irc.example.com 432 * al!ce :Erroneous nickname')]),
+    ]);
+  });
+
+  it('emits 432 for an overlong nick', () => {
+    const state = makeState();
+    const ctx = makeCtx(state);
+    const longNick = `a${'b'.repeat(30)}`;
+    const out = nickReducer(state, { command: 'NICK', params: [longNick], tags: {} }, ctx);
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(`:irc.example.com 432 * ${longNick} :Erroneous nickname`)]),
+    ]);
+  });
+
+  it('uses the current nick (not *) in the 432 reply when partially registered', () => {
+    const state = makeState();
+    state.nick = 'alice';
+    state.registration = 'registering';
+    const ctx = makeCtx(state);
+    const out = nickReducer(state, { command: 'NICK', params: ['1bad'], tags: {} }, ctx);
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(':irc.example.com 432 alice 1bad :Erroneous nickname')]),
+    ]);
+  });
+
+  it('emits ChangeNick and echoes back on post-registration nick change', () => {
+    const state = registeredState();
+    const ctx = makeCtx(state);
+    const out = nickReducer(state, { command: 'NICK', params: ['bob'], tags: {} }, ctx);
+    expect(out.state.nick).toBe('bob');
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.changeNick('c1', 'alice', 'bob'),
+      Effect.send('c1', [L(':alice!alice@example.com NICK bob')]),
+    ]);
+    expect(out.state.registration).toBe('registered');
+  });
+
+  it('echoes back with partial hostmask when host is absent on nick change', () => {
+    const state = makeState();
+    state.nick = 'alice';
+    state.user = 'alice';
+    state.realname = 'Alice';
+    state.registration = 'registered';
+    const ctx = makeCtx(state);
+    const out = nickReducer(state, { command: 'NICK', params: ['bob'], tags: {} }, ctx);
+    expect(out.effects).toContainEqual(Effect.send('c1', [L(':alice!alice NICK bob')]));
+  });
+
+  it('still validates grammar on post-registration nick change', () => {
+    const state = registeredState();
+    const ctx = makeCtx(state);
+    const out = nickReducer(state, { command: 'NICK', params: ['1bad'], tags: {} }, ctx);
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(':irc.example.com 432 alice 1bad :Erroneous nickname')]),
+    ]);
+    expect(out.state.nick).toBe('alice');
+  });
+
+  it('still emits 431 on post-registration nick change with no param', () => {
+    const state = registeredState();
+    const ctx = makeCtx(state);
+    const out = nickReducer(state, { command: 'NICK', params: [], tags: {} }, ctx);
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(':irc.example.com 431 alice :No nickname given')]),
+    ]);
+  });
+
+  it('returns state unchanged when registered state has no nick (invariant violation)', () => {
+    const state = makeState();
+    state.registration = 'registered';
+    const ctx = makeCtx(state);
+    const out = nickReducer(state, { command: 'NICK', params: ['bob'], tags: {} }, ctx);
+    expect(out.effects).toEqual([]);
+    expect(out.state.nick).toBeUndefined();
+  });
+});
+
+// ============================================================================
+// userReducer
+// ============================================================================
+
+describe('userReducer', () => {
+  it('stores user and realname and transitions to registering when nick is not set', () => {
+    const state = makeState();
+    const ctx = makeCtx(state);
+    const out = userReducer(
+      state,
+      { command: 'USER', params: ['alice', '0', '*', 'Alice'], tags: {} },
+      ctx,
+    );
+    expect(out.state.user).toBe('alice');
+    expect(out.state.realname).toBe('Alice');
+    expect(out.state.registration).toBe('registering');
+    expect(out.effects).toEqual([]);
+  });
+
+  it('completes registration when USER arrives after NICK', () => {
+    const state = makeState();
+    state.nick = 'alice';
+    state.registration = 'registering';
+    const ctx = makeCtx(state);
+    const out = userReducer(
+      state,
+      { command: 'USER', params: ['alice', '0', '*', 'Alice'], tags: {} },
+      ctx,
+    );
+    expect(out.state.user).toBe('alice');
+    expect(out.state.realname).toBe('Alice');
+    expect(out.state.registration).toBe('registered');
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', expectedWelcome('alice', 'alice', undefined)),
+    ]);
+  });
+
+  it('includes the host in the welcome hostmask when set', () => {
+    const state = makeState();
+    state.nick = 'alice';
+    state.host = 'example.com';
+    state.registration = 'registering';
+    const ctx = makeCtx(state);
+    const out = userReducer(
+      state,
+      { command: 'USER', params: ['alice', '0', '*', 'Alice'], tags: {} },
+      ctx,
+    );
+    expect(out.effects).toContainEqual(
+      Effect.send('c1', expectedWelcome('alice', 'alice', 'example.com')),
+    );
+  });
+
+  it('emits 461 when fewer than four params are supplied', () => {
+    const state = makeState();
+    const ctx = makeCtx(state);
+    const out = userReducer(state, { command: 'USER', params: ['alice', '0'], tags: {} }, ctx);
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(':irc.example.com 461 * USER :Not enough parameters')]),
+    ]);
+    expect(out.state.user).toBeUndefined();
+    expect(out.state.registration).toBe('pre-registration');
+  });
+
+  it('emits 461 when no params are supplied', () => {
+    const state = makeState();
+    const ctx = makeCtx(state);
+    const out = userReducer(state, { command: 'USER', params: [], tags: {} }, ctx);
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(':irc.example.com 461 * USER :Not enough parameters')]),
+    ]);
+  });
+
+  it('emits 462 when already registered', () => {
+    const state = registeredState();
+    const ctx = makeCtx(state);
+    const out = userReducer(
+      state,
+      { command: 'USER', params: ['bob', '0', '*', 'Bob'], tags: {} },
+      ctx,
+    );
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(':irc.example.com 462 alice :You may not reregister')]),
+    ]);
+    expect(out.state.user).toBe('alice');
+  });
+
+  it('uses the current nick in the 461 reply when partially registered', () => {
+    const state = makeState();
+    state.nick = 'alice';
+    state.registration = 'registering';
+    const ctx = makeCtx(state);
+    const out = userReducer(state, { command: 'USER', params: ['a'], tags: {} }, ctx);
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(':irc.example.com 461 alice USER :Not enough parameters')]),
+    ]);
+  });
+
+  it('stores a realname containing spaces from the trailing param', () => {
+    const state = makeState();
+    state.nick = 'alice';
+    state.registration = 'registering';
+    const ctx = makeCtx(state);
+    const out = userReducer(
+      state,
+      { command: 'USER', params: ['alice', '0', '*', 'Alice Wonderland'], tags: {} },
+      ctx,
+    );
+    expect(out.state.realname).toBe('Alice Wonderland');
+  });
+});
+
+// ============================================================================
+// passReducer
+// ============================================================================
+
+describe('passReducer', () => {
+  it('stashes the password attempt with no effects when pre-registration', () => {
+    const state = makeState();
+    const ctx = makeCtx(state);
+    const out = passReducer(state, { command: 'PASS', params: ['secret'], tags: {} }, ctx);
+    expect(out.state.passAttempt).toBe('secret');
+    expect(out.effects).toEqual([]);
+    expect(out.state.registration).toBe('pre-registration');
+  });
+
+  it('does not validate the password (enforcement lives in the actor layer)', () => {
+    const state = makeState();
+    const ctx = makeCtx(state);
+    const out = passReducer(state, { command: 'PASS', params: ['wrong-password'], tags: {} }, ctx);
+    expect(out.state.passAttempt).toBe('wrong-password');
+    expect(out.effects).toEqual([]);
+  });
+
+  it('overwrites a previous passAttempt on repeated PASS', () => {
+    const state = makeState();
+    state.passAttempt = 'first';
+    const ctx = makeCtx(state);
+    const out = passReducer(state, { command: 'PASS', params: ['second'], tags: {} }, ctx);
+    expect(out.state.passAttempt).toBe('second');
+  });
+
+  it('emits 461 when no password is supplied', () => {
+    const state = makeState();
+    const ctx = makeCtx(state);
+    const out = passReducer(state, { command: 'PASS', params: [], tags: {} }, ctx);
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(':irc.example.com 461 * PASS :Not enough parameters')]),
+    ]);
+    expect(out.state.passAttempt).toBeUndefined();
+  });
+
+  it('emits 462 when already registered', () => {
+    const state = registeredState();
+    const ctx = makeCtx(state);
+    const out = passReducer(state, { command: 'PASS', params: ['secret'], tags: {} }, ctx);
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(':irc.example.com 462 alice :You may not reregister')]),
+    ]);
+    expect(out.state.passAttempt).toBeUndefined();
+  });
+});
+
+// ============================================================================
+// buildWelcomeLines
+// ============================================================================
+
+describe('buildWelcomeLines', () => {
+  it('produces the welcome block in the correct numeric order', () => {
+    const state = makeState();
+    state.nick = 'alice';
+    state.user = 'alice';
+    state.host = 'example.com';
+    const lines = buildWelcomeLines(state, makeCtx(state));
+    // 8 base lines (001-004, one or more 005, 375, 372, 376).
+    expect(lines.length).toBeGreaterThanOrEqual(8);
+    const codes = lines.map((l) => l.text.split(' ')[1]);
+    // First four numerics in fixed order; 005 (>=1); final three in order.
+    expect(codes.slice(0, 4)).toEqual(['001', '002', '003', '004']);
+    expect(codes[4]).toBe('005');
+    expect(codes.at(-3)).toBe('375');
+    expect(codes.at(-2)).toBe('372');
+    expect(codes.at(-1)).toBe('376');
+  });
+
+  it('prefixes every line with the server source', () => {
+    const state = makeState();
+    state.nick = 'alice';
+    state.user = 'alice';
+    const lines = buildWelcomeLines(state, makeCtx(state));
+    for (const line of lines) {
+      expect(line.text.startsWith(':irc.example.com ')).toBe(true);
+    }
+  });
+
+  it('builds the 001 hostmask from nick!user@host', () => {
+    const state = makeState();
+    state.nick = 'alice';
+    state.user = 'alice';
+    state.host = 'example.com';
+    const lines = buildWelcomeLines(state, makeCtx(state));
+    const welcome = lines[0];
+    expect(welcome).toEqual(
+      L(
+        ':irc.example.com 001 alice :Welcome to the ExampleNet IRC Network, alice!alice@example.com',
+      ),
+    );
+  });
+
+  it('builds the 001 hostmask without @host when host is absent', () => {
+    const state = makeState();
+    state.nick = 'alice';
+    state.user = 'alice';
+    const lines = buildWelcomeLines(state, makeCtx(state));
+    const welcome = lines[0];
+    expect(welcome).toEqual(
+      L(':irc.example.com 001 alice :Welcome to the ExampleNet IRC Network, alice!alice'),
+    );
+  });
+
+  it('matches the full expected welcome block for a complete connection', () => {
+    const state = makeState();
+    state.nick = 'alice';
+    state.user = 'alice';
+    state.host = 'example.com';
+    const lines = buildWelcomeLines(state, makeCtx(state));
+    expect(lines).toEqual(expectedWelcome('alice', 'alice', 'example.com'));
+  });
+
+  it('returns an empty array when nick is absent (defensive)', () => {
+    const state = makeState();
+    const lines = buildWelcomeLines(state, makeCtx(state));
+    expect(lines).toEqual([]);
+  });
+});
+
+// ============================================================================
+// emitWelcomeIfReady
+// ============================================================================
+
+describe('emitWelcomeIfReady', () => {
+  it('returns a Send effect and transitions to registered when nick and user are set', () => {
+    const state = makeState();
+    state.nick = 'alice';
+    state.user = 'alice';
+    const ctx = makeCtx(state);
+    const effect = emitWelcomeIfReady(state, ctx);
+    expect(effect).toEqual(Effect.send('c1', expectedWelcome('alice', 'alice', undefined)));
+    expect(state.registration).toBe('registered');
+  });
+
+  it('returns null and does not transition when nick is missing', () => {
+    const state = makeState();
+    state.user = 'alice';
+    const ctx = makeCtx(state);
+    const effect = emitWelcomeIfReady(state, ctx);
+    expect(effect).toBeNull();
+    expect(state.registration).toBe('pre-registration');
+  });
+
+  it('returns null and does not transition when user is missing', () => {
+    const state = makeState();
+    state.nick = 'alice';
+    const ctx = makeCtx(state);
+    const effect = emitWelcomeIfReady(state, ctx);
+    expect(effect).toBeNull();
+    expect(state.registration).toBe('pre-registration');
+  });
+
+  it('returns null when already registered', () => {
+    const state = registeredState();
+    const ctx = makeCtx(state);
+    const effect = emitWelcomeIfReady(state, ctx);
+    expect(effect).toBeNull();
+    expect(state.registration).toBe('registered');
+  });
+});