serverless-ircd 0.1.0

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

@@ -0,0 +1,220 @@
+import { describe, expect, it } from 'vitest';
+import { quitReducer } from '../../src/commands/quit';
+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 makeRegisteredState(): ConnectionState {
+  const state = createConnection({ id: 'c1', connectedSince: 0 });
+  state.registration = 'registered';
+  state.nick = 'alice';
+  state.user = 'alice';
+  state.host = 'example.com';
+  state.realname = 'Alice';
+  return state;
+}
+
+const L = (text: string): RawLine => ({ text });
+
+describe('quitReducer', () => {
+  it('broadcasts QUIT to every joined channel', () => {
+    const state = makeRegisteredState();
+    state.joinedChannels.add('#foo');
+    state.joinedChannels.add('#bar');
+    const ctx = makeCtx(state);
+
+    const out = quitReducer(state, { command: 'QUIT', params: [], tags: {} }, ctx);
+
+    const broadcastChans = out.effects
+      .filter((e): e is Extract<EffectType, { tag: 'Broadcast' }> => e.tag === 'Broadcast')
+      .map((e) => e.chan);
+    expect(broadcastChans).toEqual(['#foo', '#bar']);
+  });
+
+  it('uses the client-provided reason in the broadcast line', () => {
+    const state = makeRegisteredState();
+    state.joinedChannels.add('#foo');
+    const ctx = makeCtx(state);
+
+    const out = quitReducer(state, { command: 'QUIT', params: ['bye all'], tags: {} }, ctx);
+
+    expect(out.effects).toEqual<EffectType[]>(
+      expect.arrayContaining([
+        Effect.broadcast('#foo', [L(':alice!alice@example.com QUIT :bye all')], 'c1'),
+      ]),
+    );
+  });
+
+  it('falls back to serverConfig.quitMessage when no reason is supplied', () => {
+    const state = makeRegisteredState();
+    state.joinedChannels.add('#foo');
+    const ctx = makeCtx(state);
+
+    const out = quitReducer(state, { command: 'QUIT', params: [], tags: {} }, ctx);
+
+    expect(out.effects).toEqual<EffectType[]>(
+      expect.arrayContaining([
+        Effect.broadcast('#foo', [L(':alice!alice@example.com QUIT :Client Quit')], 'c1'),
+      ]),
+    );
+  });
+
+  it('treats an empty reason param the same as no reason param', () => {
+    const state = makeRegisteredState();
+    state.joinedChannels.add('#foo');
+    const ctx = makeCtx(state);
+
+    const out = quitReducer(state, { command: 'QUIT', params: [''], tags: {} }, ctx);
+
+    expect(out.effects).toEqual<EffectType[]>(
+      expect.arrayContaining([
+        Effect.broadcast('#foo', [L(':alice!alice@example.com QUIT :Client Quit')], 'c1'),
+      ]),
+    );
+  });
+
+  it('excludes the quitting connection from the broadcast', () => {
+    const state = makeRegisteredState();
+    state.joinedChannels.add('#foo');
+    const ctx = makeCtx(state);
+
+    const out = quitReducer(state, { command: 'QUIT', params: [], tags: {} }, ctx);
+
+    const broadcasts = out.effects.filter(
+      (e): e is Extract<EffectType, { tag: 'Broadcast' }> => e.tag === 'Broadcast',
+    );
+    expect(broadcasts).toHaveLength(1);
+    const only = broadcasts[0];
+    if (only === undefined) throw new Error('expected exactly one Broadcast effect');
+    expect(only.except).toBe('c1');
+  });
+
+  it('emits an ApplyChannelDelta removing the connection from each joined channel', () => {
+    const state = makeRegisteredState();
+    state.joinedChannels.add('#foo');
+    state.joinedChannels.add('#bar');
+    const ctx = makeCtx(state);
+
+    const out = quitReducer(state, { command: 'QUIT', params: [], tags: {} }, ctx);
+
+    expect(out.effects).toEqual<EffectType[]>(
+      expect.arrayContaining([
+        Effect.applyChannelDelta('#foo', { memberships: [{ type: 'remove', conn: 'c1' }] }),
+        Effect.applyChannelDelta('#bar', { memberships: [{ type: 'remove', conn: 'c1' }] }),
+      ]),
+    );
+  });
+
+  it('releases the reserved nick', () => {
+    const state = makeRegisteredState();
+    const ctx = makeCtx(state);
+
+    const out = quitReducer(state, { command: 'QUIT', params: [], tags: {} }, ctx);
+
+    expect(out.effects).toContainEqual<EffectType>(Effect.releaseNick('alice'));
+  });
+
+  it('emits a Disconnect for the connection', () => {
+    const state = makeRegisteredState();
+    const ctx = makeCtx(state);
+
+    const out = quitReducer(state, { command: 'QUIT', params: ['bye'], tags: {} }, ctx);
+
+    expect(out.effects).toContainEqual<EffectType>(Effect.disconnect('c1'));
+  });
+
+  it('still emits ReleaseNick and Disconnect when the connection joined no channels', () => {
+    const state = makeRegisteredState();
+    const ctx = makeCtx(state);
+
+    const out = quitReducer(state, { command: 'QUIT', params: [], tags: {} }, ctx);
+
+    const tags = out.effects.map((e) => e.tag);
+    expect(tags).not.toContain('Broadcast');
+    expect(tags).not.toContain('ApplyChannelDelta');
+    expect(tags).toContain('ReleaseNick');
+    expect(tags).toContain('Disconnect');
+  });
+
+  it('emits no Broadcast, no ApplyChannelDelta, and no ReleaseNick when unregistered', () => {
+    const state = createConnection({ id: 'c1', connectedSince: 0 });
+    const ctx = makeCtx(state);
+
+    const out = quitReducer(state, { command: 'QUIT', params: [], tags: {} }, ctx);
+
+    const tags = out.effects.map((e) => e.tag);
+    expect(tags).not.toContain('Broadcast');
+    expect(tags).not.toContain('ApplyChannelDelta');
+    expect(tags).not.toContain('ReleaseNick');
+  });
+
+  it('emits exactly one Disconnect when the connection was never registered', () => {
+    const state = createConnection({ id: 'c1', connectedSince: 0 });
+    const ctx = makeCtx(state);
+
+    const out = quitReducer(state, { command: 'QUIT', params: [], tags: {} }, ctx);
+
+    expect(out.effects).toEqual<EffectType[]>([Effect.disconnect('c1')]);
+  });
+
+  it('updates lastSeen to ctx.clock.now()', () => {
+    const state = makeRegisteredState();
+    const clock = new FakeClock(5_000);
+    const ctx = makeCtx(state, clock);
+
+    const out = quitReducer(state, { command: 'QUIT', params: [], tags: {} }, ctx);
+
+    expect(out.state.lastSeen).toBe(5_000);
+  });
+
+  it('returns the same state reference (mutation permitted, no copy)', () => {
+    const state = makeRegisteredState();
+    const ctx = makeCtx(state);
+
+    const out = quitReducer(state, { command: 'QUIT', params: [], tags: {} }, ctx);
+
+    expect(out.state).toBe(state);
+  });
+
+  it('emits effects in a deterministic order: broadcasts, deltas, release, disconnect', () => {
+    const state = makeRegisteredState();
+    state.joinedChannels.add('#foo');
+    state.joinedChannels.add('#bar');
+    const ctx = makeCtx(state);
+
+    const out = quitReducer(state, { command: 'QUIT', params: ['gone'], tags: {} }, ctx);
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.broadcast('#foo', [L(':alice!alice@example.com QUIT :gone')], 'c1'),
+      Effect.broadcast('#bar', [L(':alice!alice@example.com QUIT :gone')], 'c1'),
+      Effect.applyChannelDelta('#foo', { memberships: [{ type: 'remove', conn: 'c1' }] }),
+      Effect.applyChannelDelta('#bar', { memberships: [{ type: 'remove', conn: 'c1' }] }),
+      Effect.releaseNick('alice'),
+      Effect.disconnect('c1'),
+    ]);
+  });
+});