serverless-ircd 0.1.0

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

@@ -0,0 +1,316 @@
+import { describe, expect, it } from 'vitest';
+import { kickReducer } from '../../src/commands/kick';
+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 });
+
+// ============================================================================
+// kickReducer — success path
+// ============================================================================
+
+describe('kickReducer — success', () => {
+  it('broadcasts KICK with reason to the channel and removes the target from the roster', () => {
+    const chan = makeChan('#foo');
+    addMember(chan, 'c1', 'alice', true);
+    addMember(chan, 'c2', 'bob', false);
+    const conn = makeConn('c1', 'alice');
+    const ctx = makeCtx(conn);
+
+    const out = kickReducer(
+      chan,
+      { command: 'KICK', params: ['#foo', 'bob', 'trolling'], tags: {} },
+      ctx,
+    );
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.broadcast('#foo', [L(':alice!alice@example.com KICK #foo bob :trolling')]),
+      Effect.applyChannelDelta('#foo', { memberships: [{ type: 'remove', conn: 'c2' }] }),
+    ]);
+    expect(out.state.members.has('c2')).toBe(false);
+    expect(out.state.members.has('c1')).toBe(true);
+  });
+
+  it('broadcasts KICK without a trailing reason when none is supplied', () => {
+    const chan = makeChan('#foo');
+    addMember(chan, 'c1', 'alice', true);
+    addMember(chan, 'c2', 'bob');
+    const conn = makeConn('c1', 'alice');
+    const ctx = makeCtx(conn);
+
+    const out = kickReducer(chan, { command: 'KICK', params: ['#foo', 'bob'], tags: {} }, ctx);
+
+    expect(out.effects).toContainEqual<EffectType>(
+      Effect.broadcast('#foo', [L(':alice!alice@example.com KICK #foo bob')]),
+    );
+  });
+
+  it('treats an empty reason param the same as no reason param', () => {
+    const chan = makeChan('#foo');
+    addMember(chan, 'c1', 'alice', true);
+    addMember(chan, 'c2', 'bob');
+    const conn = makeConn('c1', 'alice');
+    const ctx = makeCtx(conn);
+
+    const out = kickReducer(chan, { command: 'KICK', params: ['#foo', 'bob', ''], tags: {} }, ctx);
+
+    expect(out.effects).toContainEqual<EffectType>(
+      Effect.broadcast('#foo', [L(':alice!alice@example.com KICK #foo bob')]),
+    );
+  });
+
+  it('includes the target in the KICK broadcast (no except)', () => {
+    const chan = makeChan('#foo');
+    addMember(chan, 'c1', 'alice', true);
+    addMember(chan, 'c2', 'bob');
+    const conn = makeConn('c1', 'alice');
+    const ctx = makeCtx(conn);
+
+    const out = kickReducer(chan, { command: 'KICK', params: ['#foo', 'bob'], tags: {} }, ctx);
+
+    const broadcast = out.effects.find(
+      (e): e is Extract<EffectType, { tag: 'Broadcast' }> => e.tag === 'Broadcast',
+    );
+    expect(broadcast?.except).toBeUndefined();
+  });
+
+  it('resolves the target case-insensitively by nick', () => {
+    const chan = makeChan('#foo');
+    addMember(chan, 'c1', 'alice', true);
+    addMember(chan, 'c2', 'Bob');
+    const conn = makeConn('c1', 'alice');
+    const ctx = makeCtx(conn);
+
+    const out = kickReducer(chan, { command: 'KICK', params: ['#foo', 'BOB'], tags: {} }, ctx);
+
+    expect(out.state.members.has('c2')).toBe(false);
+    expect(out.effects).toContainEqual<EffectType>(
+      Effect.applyChannelDelta('#foo', { memberships: [{ type: 'remove', conn: 'c2' }] }),
+    );
+  });
+
+  it('updates the kicker lastSeen to ctx.clock.now()', () => {
+    const chan = makeChan('#foo');
+    addMember(chan, 'c1', 'alice', true);
+    addMember(chan, 'c2', 'bob');
+    const conn = makeConn('c1', 'alice');
+    const clock = new FakeClock(7_500);
+    const ctx = makeCtx(conn, clock);
+
+    kickReducer(chan, { command: 'KICK', params: ['#foo', 'bob'], tags: {} }, ctx);
+
+    expect(conn.lastSeen).toBe(7_500);
+  });
+
+  it('returns the same state reference (mutation permitted, no copy)', () => {
+    const chan = makeChan('#foo');
+    addMember(chan, 'c1', 'alice', true);
+    addMember(chan, 'c2', 'bob');
+    const conn = makeConn('c1', 'alice');
+    const ctx = makeCtx(conn);
+
+    const out = kickReducer(chan, { command: 'KICK', params: ['#foo', 'bob'], tags: {} }, ctx);
+
+    expect(out.state).toBe(chan);
+  });
+
+  it('falls back to ? as the KICK source when the kicker has no nick (defensive)', () => {
+    const chan = makeChan('#foo');
+    addMember(chan, 'c1', '?', true);
+    addMember(chan, 'c2', 'bob');
+    const conn = createConnection({ id: 'c1', connectedSince: 0 });
+    const ctx = makeCtx(conn);
+
+    const out = kickReducer(chan, { command: 'KICK', params: ['#foo', 'bob'], tags: {} }, ctx);
+
+    expect(out.effects).toContainEqual<EffectType>(
+      Effect.broadcast('#foo', [L(':? KICK #foo bob')]),
+    );
+  });
+});
+
+// ============================================================================
+// kickReducer — rejections
+// ============================================================================
+
+describe('kickReducer — rejections', () => {
+  it('emits 461 ERR_NEEDMOREPARAMS when no channel is supplied', () => {
+    const chan = makeChan('#foo');
+    addMember(chan, 'c1', 'alice', true);
+    addMember(chan, 'c2', 'bob');
+    const conn = makeConn('c1', 'alice');
+    const ctx = makeCtx(conn);
+
+    const out = kickReducer(chan, { command: 'KICK', params: [], tags: {} }, ctx);
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(':irc.example.com 461 alice KICK :Not enough parameters')]),
+    ]);
+    expect(out.state.members.has('c2')).toBe(true);
+  });
+
+  it('emits 461 ERR_NEEDMOREPARAMS when no target is supplied', () => {
+    const chan = makeChan('#foo');
+    addMember(chan, 'c1', 'alice', true);
+    addMember(chan, 'c2', 'bob');
+    const conn = makeConn('c1', 'alice');
+    const ctx = makeCtx(conn);
+
+    const out = kickReducer(chan, { command: 'KICK', params: ['#foo'], tags: {} }, ctx);
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(':irc.example.com 461 alice KICK :Not enough parameters')]),
+    ]);
+    expect(out.state.members.has('c2')).toBe(true);
+  });
+
+  it('emits 403 ERR_NOSUCHCHANNEL for a channel name without a valid prefix', () => {
+    const chan = makeChan('foo');
+    const conn = makeConn('c1', 'alice');
+    const ctx = makeCtx(conn);
+
+    const out = kickReducer(chan, { command: 'KICK', params: ['foo', 'bob'], 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('c1', 'alice');
+    const ctx = makeCtx(conn);
+
+    const out = kickReducer(chan, { command: 'KICK', params: ['#foo,bar', 'bob'], 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('c1', 'alice');
+    const ctx = makeCtx(conn);
+
+    const out = kickReducer(chan, { command: 'KICK', params: ['', 'bob'], 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('c1', 'alice');
+    const ctx = makeCtx(conn);
+
+    const out = kickReducer(chan, { command: 'KICK', params: [longName, 'bob'], 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 kicker is not on the channel', () => {
+    const chan = makeChan('#foo');
+    addMember(chan, 'c2', 'bob');
+    const conn = makeConn('c1', 'alice');
+    const ctx = makeCtx(conn);
+
+    const out = kickReducer(chan, { command: 'KICK', params: ['#foo', 'bob'], 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('c2')).toBe(true);
+  });
+
+  it('emits 482 ERR_CHANOPRIVSNEEDED when the kicker is on the channel but not an op', () => {
+    const chan = makeChan('#foo');
+    addMember(chan, 'c1', 'alice', false);
+    addMember(chan, 'c2', 'bob', false);
+    const conn = makeConn('c1', 'alice');
+    const ctx = makeCtx(conn);
+
+    const out = kickReducer(chan, { command: 'KICK', params: ['#foo', 'bob'], tags: {} }, ctx);
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(":irc.example.com 482 alice #foo :You're not channel operator")]),
+    ]);
+    expect(out.state.members.has('c2')).toBe(true);
+  });
+
+  it('emits 441 ERR_USERNOTINCHANNEL when the target is not on the channel', () => {
+    const chan = makeChan('#foo');
+    addMember(chan, 'c1', 'alice', true);
+    const conn = makeConn('c1', 'alice');
+    const ctx = makeCtx(conn);
+
+    const out = kickReducer(chan, { command: 'KICK', params: ['#foo', 'ghost'], tags: {} }, ctx);
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(':irc.example.com 441 alice ghost #foo :They are not on that channel')]),
+    ]);
+  });
+
+  it('uses * in numeric replies when the connection has no nick (defensive)', () => {
+    const chan = makeChan('#foo');
+    addMember(chan, 'c1', '?', true);
+    addMember(chan, 'c2', 'bob');
+    const conn = createConnection({ id: 'c1', connectedSince: 0 });
+    const ctx = makeCtx(conn);
+
+    const out = kickReducer(chan, { command: 'KICK', params: [], tags: {} }, ctx);
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(':irc.example.com 461 * KICK :Not enough parameters')]),
+    ]);
+  });
+});