serverless-ircd 0.1.0

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

@@ -0,0 +1,265 @@
+import { describe, expect, it } from 'vitest';
+import { partReducer } from '../../src/commands/part';
+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 });
+}
+
+/** Adds a member to the channel roster. */
+function addMember(chan: ChannelState, connId: string, nick: string, op = false): void {
+  chan.members.set(connId, { conn: connId, nick, op, voice: false });
+}
+
+const L = (text: string): RawLine => ({ text });
+
+// ============================================================================
+// partReducer — success path
+// ============================================================================
+
+describe('partReducer — success', () => {
+  it('broadcasts PART with reason to the channel and removes the parter from the roster', () => {
+    const chan = makeChan('#foo');
+    addMember(chan, 'c1', 'alice');
+    addMember(chan, 'c2', 'bob');
+    const conn = makeConn();
+    conn.joinedChannels.add('#foo');
+    const ctx = makeCtx(conn);
+
+    const out = partReducer(chan, { command: 'PART', params: ['#foo', 'leaving'], tags: {} }, ctx);
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.broadcast('#foo', [L(':alice!alice@example.com PART #foo :leaving')]),
+      Effect.applyChannelDelta('#foo', { memberships: [{ type: 'remove', conn: 'c1' }] }),
+    ]);
+    expect(out.state.members.has('c1')).toBe(false);
+  });
+
+  it('broadcasts PART without a trailing reason when none is supplied', () => {
+    const chan = makeChan('#foo');
+    addMember(chan, 'c1', 'alice');
+    const conn = makeConn();
+    conn.joinedChannels.add('#foo');
+    const ctx = makeCtx(conn);
+
+    const out = partReducer(chan, { command: 'PART', params: ['#foo'], tags: {} }, ctx);
+
+    expect(out.effects).toContainEqual<EffectType>(
+      Effect.broadcast('#foo', [L(':alice!alice@example.com PART #foo')]),
+    );
+  });
+
+  it('treats an empty reason param the same as no reason param', () => {
+    const chan = makeChan('#foo');
+    addMember(chan, 'c1', 'alice');
+    const conn = makeConn();
+    conn.joinedChannels.add('#foo');
+    const ctx = makeCtx(conn);
+
+    const out = partReducer(chan, { command: 'PART', params: ['#foo', ''], tags: {} }, ctx);
+
+    expect(out.effects).toContainEqual<EffectType>(
+      Effect.broadcast('#foo', [L(':alice!alice@example.com PART #foo')]),
+    );
+  });
+
+  it('includes the parting connection in the broadcast (no except)', () => {
+    const chan = makeChan('#foo');
+    addMember(chan, 'c1', 'alice');
+    const conn = makeConn();
+    conn.joinedChannels.add('#foo');
+    const ctx = makeCtx(conn);
+
+    const out = partReducer(chan, { command: 'PART', params: ['#foo'], tags: {} }, ctx);
+
+    const broadcast = out.effects.find(
+      (e): e is Extract<EffectType, { tag: 'Broadcast' }> => e.tag === 'Broadcast',
+    );
+    expect(broadcast?.except).toBeUndefined();
+  });
+
+  it('removes the channel from the connection joinedChannels set (cross-authority mutation)', () => {
+    const chan = makeChan('#foo');
+    addMember(chan, 'c1', 'alice');
+    const conn = makeConn();
+    conn.joinedChannels.add('#foo');
+    conn.joinedChannels.add('#bar');
+    const ctx = makeCtx(conn);
+
+    partReducer(chan, { command: 'PART', params: ['#foo'], tags: {} }, ctx);
+
+    expect(conn.joinedChannels.has('#foo')).toBe(false);
+    expect(conn.joinedChannels.has('#bar')).toBe(true);
+  });
+
+  it('updates the connection lastSeen to ctx.clock.now()', () => {
+    const chan = makeChan('#foo');
+    addMember(chan, 'c1', 'alice');
+    const conn = makeConn();
+    conn.joinedChannels.add('#foo');
+    const clock = new FakeClock(7_500);
+    const ctx = makeCtx(conn, clock);
+
+    const out = partReducer(chan, { command: 'PART', params: ['#foo'], tags: {} }, ctx);
+
+    expect(out.state).toBe(chan);
+    expect(conn.lastSeen).toBe(7_500);
+  });
+
+  it('returns the same state reference (mutation permitted, no copy)', () => {
+    const chan = makeChan('#foo');
+    addMember(chan, 'c1', 'alice');
+    const conn = makeConn();
+    conn.joinedChannels.add('#foo');
+    const ctx = makeCtx(conn);
+
+    const out = partReducer(chan, { command: 'PART', params: ['#foo'], tags: {} }, ctx);
+
+    expect(out.state).toBe(chan);
+  });
+
+  it('falls back to ? as the PART source when the connection has no nick (defensive)', () => {
+    const chan = makeChan('#foo');
+    // Roster entry with a stale nick but the connection itself has no nick.
+    addMember(chan, 'c1', '?');
+    const conn = createConnection({ id: 'c1', connectedSince: 0 });
+    const ctx = makeCtx(conn);
+
+    const out = partReducer(chan, { command: 'PART', params: ['#foo'], tags: {} }, ctx);
+
+    expect(out.effects).toContainEqual<EffectType>(Effect.broadcast('#foo', [L(':? PART #foo')]));
+  });
+});
+
+// ============================================================================
+// partReducer — rejections
+// ============================================================================
+
+describe('partReducer — rejections', () => {
+  it('emits 461 ERR_NEEDMOREPARAMS when no channel is supplied', () => {
+    const chan = makeChan('#foo');
+    addMember(chan, 'c1', 'alice');
+    const conn = makeConn();
+    conn.joinedChannels.add('#foo');
+    const ctx = makeCtx(conn);
+
+    const out = partReducer(chan, { command: 'PART', params: [], tags: {} }, ctx);
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(':irc.example.com 461 alice PART :Not enough parameters')]),
+    ]);
+    expect(out.state.members.has('c1')).toBe(true);
+  });
+
+  it('emits 403 ERR_NOSUCHCHANNEL for a channel name without a valid prefix', () => {
+    const chan = makeChan('foo');
+    const conn = makeConn();
+    const ctx = makeCtx(conn);
+
+    const out = partReducer(chan, { command: 'PART', params: ['foo'], tags: {} }, ctx);
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(':irc.example.com 403 alice foo :No such channel')]),
+    ]);
+  });
+
+  it('emits 403 ERR_NOSUCHCHANNEL for a channel name containing a comma', () => {
+    const chan = makeChan('#foo');
+    const conn = makeConn();
+    const ctx = makeCtx(conn);
+
+    const out = partReducer(chan, { command: 'PART', params: ['#foo,bar'], tags: {} }, ctx);
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(':irc.example.com 403 alice #foo,bar :No such channel')]),
+    ]);
+  });
+
+  it('emits 403 ERR_NOSUCHCHANNEL for an empty channel name', () => {
+    const chan = makeChan('#foo');
+    const conn = makeConn();
+    const ctx = makeCtx(conn);
+
+    const out = partReducer(chan, { command: 'PART', params: [''], tags: {} }, ctx);
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(':irc.example.com 403 alice  :No such channel')]),
+    ]);
+  });
+
+  it('emits 403 ERR_NOSUCHCHANNEL for a channel name exceeding the length cap', () => {
+    const longName = `#${'a'.repeat(50)}`;
+    const chan = makeChan(longName);
+    const conn = makeConn();
+    const ctx = makeCtx(conn);
+
+    const out = partReducer(chan, { command: 'PART', params: [longName], tags: {} }, ctx);
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(`:irc.example.com 403 alice ${longName} :No such channel`)]),
+    ]);
+  });
+
+  it('emits 442 ERR_NOTONCHANNEL when the connection is not on the channel', () => {
+    const chan = makeChan('#foo');
+    addMember(chan, 'c2', 'bob');
+    const conn = makeConn();
+    const ctx = makeCtx(conn);
+
+    const out = partReducer(chan, { command: 'PART', params: ['#foo'], tags: {} }, ctx);
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(":irc.example.com 442 alice #foo :You're not on that channel")]),
+    ]);
+    expect(out.state.members.has('c1')).toBe(false);
+  });
+
+  it('uses * in numeric replies when the connection has no nick (defensive)', () => {
+    const chan = makeChan('#foo');
+    const conn = createConnection({ id: 'c1', connectedSince: 0 });
+    const ctx = makeCtx(conn);
+
+    const out = partReducer(chan, { command: 'PART', params: [], tags: {} }, ctx);
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(':irc.example.com 461 * PART :Not enough parameters')]),
+    ]);
+  });
+});

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

@@ -0,0 +1,144 @@
+import { describe, expect, it } from 'vitest';
+import { pingReducer, pongReducer } from '../../src/commands/ping';
+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 });
+}
+
+const L = (text: string): RawLine => ({ text });
+
+describe('pingReducer', () => {
+  it('replies with PONG echoing the trailing token', () => {
+    const state = makeState();
+    const ctx = makeCtx(state);
+    const out = pingReducer(state, { command: 'PING', params: ['tok'], tags: {} }, ctx);
+    expect(out.effects).toEqual<EffectType[]>([Effect.send('c1', [L('PONG :tok')])]);
+  });
+
+  it('still replies with a bare PONG when no token is provided', () => {
+    const state = makeState();
+    const ctx = makeCtx(state);
+    const out = pingReducer(state, { command: 'PING', params: [], tags: {} }, ctx);
+    expect(out.effects).toEqual<EffectType[]>([Effect.send('c1', [L('PONG')])]);
+  });
+
+  it('echoes an empty trailing token as a dangling-colon PONG', () => {
+    const state = makeState();
+    const ctx = makeCtx(state);
+    const out = pingReducer(state, { command: 'PING', params: [''], tags: {} }, ctx);
+    expect(out.effects).toEqual<EffectType[]>([Effect.send('c1', [L('PONG :')])]);
+  });
+
+  it('accepts a lower-case command token', () => {
+    const state = makeState();
+    const ctx = makeCtx(state);
+    const out = pingReducer(state, { command: 'ping', params: ['tok'], tags: {} }, ctx);
+    expect(out.effects).toEqual<EffectType[]>([Effect.send('c1', [L('PONG :tok')])]);
+  });
+
+  it('accepts a mixed-case command token', () => {
+    const state = makeState();
+    const ctx = makeCtx(state);
+    const out = pingReducer(state, { command: 'PiNg', params: ['tok'], tags: {} }, ctx);
+    expect(out.effects).toEqual<EffectType[]>([Effect.send('c1', [L('PONG :tok')])]);
+  });
+
+  it('updates connection lastSeen to ctx.clock.now()', () => {
+    const state = makeState();
+    expect(state.lastSeen).toBe(0);
+    const clock = new FakeClock(5_000);
+    const ctx = makeCtx(state, clock);
+    const out = pingReducer(state, { command: 'PING', params: ['tok'], tags: {} }, ctx);
+    expect(out.state.lastSeen).toBe(5_000);
+  });
+
+  it('does not mutate any connection field other than lastSeen', () => {
+    const state = makeState();
+    state.nick = 'alice';
+    state.user = 'alice';
+    state.host = 'h';
+    state.realname = 'Alice';
+    state.caps.add('server-time');
+    state.joinedChannels.add('#foo');
+    state.userModes.invisible = true;
+    state.registration = 'registered';
+
+    const ctx = makeCtx(state);
+    const out = pingReducer(state, { command: 'PING', params: ['tok'], tags: {} }, ctx);
+
+    expect(out.state.id).toBe('c1');
+    expect(out.state.nick).toBe('alice');
+    expect(out.state.user).toBe('alice');
+    expect(out.state.host).toBe('h');
+    expect(out.state.realname).toBe('Alice');
+    expect(out.state.caps).toEqual(new Set(['server-time']));
+    expect(out.state.joinedChannels).toEqual(new Set(['#foo']));
+    expect(out.state.userModes.invisible).toBe(true);
+    expect(out.state.registration).toBe('registered');
+    expect(out.state.connectedSince).toBe(0);
+  });
+
+  it('returns the same state reference (mutation permitted, no copy)', () => {
+    const state = makeState();
+    const ctx = makeCtx(state);
+    const out = pingReducer(state, { command: 'PING', params: ['tok'], tags: {} }, ctx);
+    expect(out.state).toBe(state);
+  });
+});
+
+describe('pongReducer', () => {
+  // PONG is the client's reply to a server-initiated PING. The reducer does
+  // not emit any reply; it only refreshes lastSeen. Idle / PING bookkeeping
+  // (deciding when to send the next server-initiated PING, or when to drop a
+  // silent connection) is the runtime's responsibility.
+
+  it('emits no effects', () => {
+    const state = makeState();
+    const ctx = makeCtx(state);
+    const out = pongReducer(state, { command: 'PONG', params: ['tok'], tags: {} }, ctx);
+    expect(out.effects).toEqual([]);
+  });
+
+  it('updates connection lastSeen to ctx.clock.now()', () => {
+    const state = makeState();
+    const clock = new FakeClock(7_000);
+    const ctx = makeCtx(state, clock);
+    const out = pongReducer(state, { command: 'PONG', params: ['tok'], tags: {} }, ctx);
+    expect(out.state.lastSeen).toBe(7_000);
+  });
+
+  it('accepts a PONG with no token', () => {
+    const state = makeState();
+    const ctx = makeCtx(state);
+    const out = pongReducer(state, { command: 'PONG', params: [], tags: {} }, ctx);
+    expect(out.effects).toEqual([]);
+    expect(out.state.lastSeen).toBe(1_000);
+  });
+});