serverless-ircd 0.7.0 → 0.8.0

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

@@ -2,7 +2,13 @@ import { describe, expect, it } from 'vitest';
 import { channelModeReducer, userModeReducer } from '../../src/commands/mode';
 import { Effect } from '../../src/effects';
 import type { Effect as EffectType, RawLine } from '../../src/effects';
-import { EmptyMotdProvider, FakeClock, SequentialIdFactory } from '../../src/ports';
+import {
+  EmptyMotdProvider,
+  FakeClock,
+  InMemoryServicesStore,
+  SequentialIdFactory,
+  type ServicesStore,
+} 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';
@@ -19,13 +25,18 @@ const serverConfig: ServerConfig = {
   quitMessage: 'Client Quit',
 };
 
-function makeCtx(conn: ConnectionState, clock = new FakeClock(1_000)): Ctx {
+function makeCtx(
+  conn: ConnectionState,
+  clock = new FakeClock(1_000),
+  services?: ServicesStore,
+): Ctx {
   return buildCtx({
     serverConfig,
     clock,
     ids: new SequentialIdFactory(),
     motd: EmptyMotdProvider,
     connection: conn,
+    ...(services !== undefined ? { services } : {}),
   });
 }
 
@@ -1175,3 +1186,371 @@ describe('userModeReducer — read-only mode `S` (TLS connected)', () => {
     expect(texts).toContainEqual(L(':irc.example.com 501 alice :Unknown MODE flag'));
   });
 });
+
+// ============================================================================
+// userModeReducer — read-only mode `r` (registered / identified via services)
+// ============================================================================
+
+describe('userModeReducer — read-only mode `r` (registered)', () => {
+  it('emits 221 with +r when the connection has the registered user mode set', () => {
+    const conn = makeConn();
+    conn.userModes.registered = true;
+    const ctx = makeCtx(conn);
+
+    const out = userModeReducer(conn, { command: 'MODE', params: ['alice'], tags: {} }, ctx);
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(':irc.example.com 221 alice +r')]),
+    ]);
+  });
+
+  it('emits 221 with +ir when invisible and registered are both set', () => {
+    const conn = makeConn();
+    conn.userModes.invisible = true;
+    conn.userModes.registered = true;
+    const ctx = makeCtx(conn);
+
+    const out = userModeReducer(conn, { command: 'MODE', params: ['alice'], tags: {} }, ctx);
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(':irc.example.com 221 alice +ir')]),
+    ]);
+  });
+
+  it('emits 221 with +rS when both registered and tls are set', () => {
+    const conn = makeConn();
+    conn.userModes.registered = true;
+    conn.userModes.tls = true;
+    const ctx = makeCtx(conn);
+
+    const out = userModeReducer(conn, { command: 'MODE', params: ['alice'], tags: {} }, ctx);
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(':irc.example.com 221 alice +rS')]),
+    ]);
+  });
+
+  it('rejects MODE nick +r with 501 ERR_UMODEUNKNOWNFLAG (read-only, services-only)', () => {
+    const conn = makeConn();
+    const ctx = makeCtx(conn);
+
+    const out = userModeReducer(conn, { command: 'MODE', params: ['alice', '+r'], tags: {} }, ctx);
+
+    expect(conn.userModes.registered).toBe(false);
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(':irc.example.com 501 alice :Unknown MODE flag')]),
+    ]);
+  });
+
+  it('rejects MODE nick -r with 501 even when registered is set', () => {
+    const conn = makeConn();
+    conn.userModes.registered = true;
+    const ctx = makeCtx(conn);
+
+    const out = userModeReducer(conn, { command: 'MODE', params: ['alice', '-r'], tags: {} }, ctx);
+
+    expect(conn.userModes.registered).toBe(true);
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(':irc.example.com 501 alice :Unknown MODE flag')]),
+    ]);
+  });
+});
+
+// ============================================================================
+// channelModeReducer — services-only modes r/R/M (reject via MODE)
+// ============================================================================
+
+describe('channelModeReducer — services-only channel modes (+r/+R/+M)', () => {
+  it('rejects MODE #chan +r with 472 (ChanServ-only)', () => {
+    const chan = makeChan('#foo');
+    addMember(chan, 'c1', 'alice', true);
+    const conn = makeConn();
+    const ctx = makeCtx(conn);
+
+    const out = channelModeReducer(
+      chan,
+      { command: 'MODE', params: ['#foo', '+r'], tags: {} },
+      ctx,
+    );
+
+    expect(chan.modes.registered).toBe(false);
+    const texts = out.effects.flatMap((e) => (e.tag === 'Send' ? e.lines.map((l) => l.text) : []));
+    expect(texts).toContain(':irc.example.com 472 alice r :is unknown mode char to me');
+  });
+
+  it('rejects MODE #chan -r with 472 (ChanServ-only)', () => {
+    const chan = makeChan('#foo');
+    chan.modes.registered = true;
+    addMember(chan, 'c1', 'alice', true);
+    const conn = makeConn();
+    const ctx = makeCtx(conn);
+
+    const out = channelModeReducer(
+      chan,
+      { command: 'MODE', params: ['#foo', '-r'], tags: {} },
+      ctx,
+    );
+
+    expect(chan.modes.registered).toBe(true);
+    const texts = out.effects.flatMap((e) => (e.tag === 'Send' ? e.lines.map((l) => l.text) : []));
+    expect(texts).toContain(':irc.example.com 472 alice r :is unknown mode char to me');
+  });
+
+  it('rejects MODE #chan +R with 472 (ChanServ-only)', () => {
+    const chan = makeChan('#foo');
+    addMember(chan, 'c1', 'alice', true);
+    const conn = makeConn();
+    const ctx = makeCtx(conn);
+
+    channelModeReducer(chan, { command: 'MODE', params: ['#foo', '+R'], tags: {} }, ctx);
+
+    expect(chan.modes.blockUnidentified).toBe(false);
+  });
+
+  it('rejects MODE #chan +M with 472 (ChanServ-only)', () => {
+    const chan = makeChan('#foo');
+    addMember(chan, 'c1', 'alice', true);
+    const conn = makeConn();
+    const ctx = makeCtx(conn);
+
+    channelModeReducer(chan, { command: 'MODE', params: ['#foo', '+M'], tags: {} }, ctx);
+
+    expect(chan.modes.moderatedIdent).toBe(false);
+  });
+
+  it('surfaces +r/+R/+M in the 324 read reply when ChanServ set them', () => {
+    const chan = makeChan('#foo');
+    chan.modes.registered = true;
+    chan.modes.blockUnidentified = true;
+    chan.modes.moderatedIdent = true;
+    addMember(chan, 'c1', 'alice');
+    const conn = makeConn();
+    const ctx = makeCtx(conn);
+
+    const out = channelModeReducer(chan, { command: 'MODE', params: ['#foo'], tags: {} }, ctx);
+
+    const texts = out.effects.flatMap((e) => (e.tag === 'Send' ? e.lines.map((l) => l.text) : []));
+    // Modes appear in canonical order: i t n m s p r R M
+    expect(texts).toContain(':irc.example.com 324 alice #foo +rRM');
+  });
+});
+
+// ============================================================================
+// channelModeReducer — ChanServ MLOCK reapplication
+// ============================================================================
+
+describe('channelModeReducer — MLOCK reapplication', () => {
+  it('reapplies a locked boolean mode an op tried to unset (+n)', () => {
+    const services = new InMemoryServicesStore({ clock: new FakeClock(1_000) });
+    services.registerNick('alice', 'pw', 'a@e');
+    services.registerChannel('#foo', 'alice');
+    services.setChannelMlock('#foo', '+n');
+    const chan = makeChan('#foo');
+    chan.modes.noExternal = true;
+    addMember(chan, 'c1', 'alice', true);
+    const conn = makeConn();
+    const ctx = makeCtx(conn, new FakeClock(1_000), services);
+
+    const out = channelModeReducer(
+      chan,
+      { command: 'MODE', params: ['#foo', '-n'], tags: {} },
+      ctx,
+    );
+
+    // The op's -n applies, but ChanServ reapplies +n afterwards.
+    expect(chan.modes.noExternal).toBe(true);
+    // The op's -n broadcast goes out, then ChanServ's +n reapply broadcast.
+    const broadcasts = out.effects.filter((e) => e.tag === 'Broadcast');
+    expect(broadcasts.length).toBe(2);
+    const applyDeltas = out.effects.filter((e) => e.tag === 'ApplyChannelDelta');
+    // The second ApplyChannelDelta carries the +n reapply.
+    const reapply = applyDeltas[1];
+    if (reapply?.tag === 'ApplyChannelDelta') {
+      expect(reapply.delta.modeChanges).toContainEqual({ mode: 'noExternal', set: true });
+    } else {
+      expect.fail('expected a second ApplyChannelDelta for the MLOCK reapply');
+    }
+  });
+
+  it('does not reapply modes that are not locked', () => {
+    const services = new InMemoryServicesStore({ clock: new FakeClock(1_000) });
+    services.registerNick('alice', 'pw', 'a@e');
+    services.registerChannel('#foo', 'alice');
+    services.setChannelMlock('#foo', '+n');
+    const chan = makeChan('#foo');
+    chan.modes.noExternal = true;
+    chan.modes.topicLock = true;
+    addMember(chan, 'c1', 'alice', true);
+    const conn = makeConn();
+    const ctx = makeCtx(conn, new FakeClock(1_000), services);
+
+    const out = channelModeReducer(
+      chan,
+      { command: 'MODE', params: ['#foo', '-t'], tags: {} },
+      ctx,
+    );
+
+    // -t is not in MLOCK, so no reapply.
+    expect(chan.modes.topicLock).toBe(false);
+    expect(out.effects.filter((e) => e.tag === 'Broadcast')).toHaveLength(1);
+  });
+
+  it('does not reapply when no services store is bound', () => {
+    const chan = makeChan('#foo');
+    chan.modes.noExternal = true;
+    addMember(chan, 'c1', 'alice', true);
+    const conn = makeConn();
+    const ctx = makeCtx(conn);
+
+    const out = channelModeReducer(
+      chan,
+      { command: 'MODE', params: ['#foo', '-n'], tags: {} },
+      ctx,
+    );
+
+    expect(chan.modes.noExternal).toBe(false);
+    expect(out.effects.filter((e) => e.tag === 'Broadcast')).toHaveLength(1);
+  });
+
+  it('does not reapply when the channel is not registered', () => {
+    const services = new InMemoryServicesStore({ clock: new FakeClock(1_000) });
+    const chan = makeChan('#foo');
+    chan.modes.noExternal = true;
+    addMember(chan, 'c1', 'alice', true);
+    const conn = makeConn();
+    const ctx = makeCtx(conn, new FakeClock(1_000), services);
+
+    const out = channelModeReducer(
+      chan,
+      { command: 'MODE', params: ['#foo', '-n'], tags: {} },
+      ctx,
+    );
+
+    expect(chan.modes.noExternal).toBe(false);
+    expect(out.effects.filter((e) => e.tag === 'Broadcast')).toHaveLength(1);
+  });
+
+  it('does not reapply when MLOCK is empty', () => {
+    const services = new InMemoryServicesStore({ clock: new FakeClock(1_000) });
+    services.registerNick('alice', 'pw', 'a@e');
+    services.registerChannel('#foo', 'alice');
+    // MLOCK is empty by default.
+    const chan = makeChan('#foo');
+    chan.modes.noExternal = true;
+    addMember(chan, 'c1', 'alice', true);
+    const conn = makeConn();
+    const ctx = makeCtx(conn, new FakeClock(1_000), services);
+
+    const out = channelModeReducer(
+      chan,
+      { command: 'MODE', params: ['#foo', '-n'], tags: {} },
+      ctx,
+    );
+
+    expect(chan.modes.noExternal).toBe(false);
+    expect(out.effects.filter((e) => e.tag === 'Broadcast')).toHaveLength(1);
+  });
+
+  it('reapplies multiple locked modes unset in a single MODE', () => {
+    const services = new InMemoryServicesStore({ clock: new FakeClock(1_000) });
+    services.registerNick('alice', 'pw', 'a@e');
+    services.registerChannel('#foo', 'alice');
+    services.setChannelMlock('#foo', '+nt');
+    const chan = makeChan('#foo');
+    chan.modes.noExternal = true;
+    chan.modes.topicLock = true;
+    addMember(chan, 'c1', 'alice', true);
+    const conn = makeConn();
+    const ctx = makeCtx(conn, new FakeClock(1_000), services);
+
+    const out = channelModeReducer(
+      chan,
+      { command: 'MODE', params: ['#foo', '-tn'], tags: {} },
+      ctx,
+    );
+
+    expect(chan.modes.noExternal).toBe(true);
+    expect(chan.modes.topicLock).toBe(true);
+    // Op broadcast + ChanServ reapply broadcast.
+    expect(out.effects.filter((e) => e.tag === 'Broadcast')).toHaveLength(2);
+  });
+
+  it('MLOCK reapplies services-only modes (+r) that an op somehow tried to unset', () => {
+    // Even though MODE rejects +r/-r at the parser, MLOCK should defend the
+    // registered mode if it ever appears in a MODE delta (defense in depth).
+    const services = new InMemoryServicesStore({ clock: new FakeClock(1_000) });
+    services.registerNick('alice', 'pw', 'a@e');
+    services.registerChannel('#foo', 'alice');
+    services.setChannelMlock('#foo', '+r');
+    const chan = makeChan('#foo');
+    chan.modes.registered = true;
+    addMember(chan, 'c1', 'alice', true);
+    const conn = makeConn();
+    const ctx = makeCtx(conn, new FakeClock(1_000), services);
+
+    // The op's MODE -r will reject at the parser; no broadcast goes out.
+    // The MLOCK reapply path is exercised against any other applied ops in
+    // the same modestring — here combined with -t (which IS unset).
+    chan.modes.topicLock = true;
+    const out = channelModeReducer(
+      chan,
+      { command: 'MODE', params: ['#foo', '-t'], tags: {} },
+      ctx,
+    );
+
+    // -t applies, +r stays (no -r was applied), no MLOCK breach on r → no
+    // reapply of r. Verified by the absence of a second broadcast.
+    expect(chan.modes.topicLock).toBe(false);
+    expect(chan.modes.registered).toBe(true);
+    expect(out.effects.filter((e) => e.tag === 'Broadcast')).toHaveLength(1);
+  });
+
+  it('does not reapply when MLOCK has no positive letters (e.g. `-n` only)', () => {
+    const services = new InMemoryServicesStore({ clock: new FakeClock(1_000) });
+    services.registerNick('alice', 'pw', 'a@e');
+    services.registerChannel('#foo', 'alice');
+    // MLOCK with only a negative section.
+    services.setChannelMlock('#foo', '-n');
+    const chan = makeChan('#foo');
+    chan.modes.noExternal = true;
+    addMember(chan, 'c1', 'alice', true);
+    const conn = makeConn();
+    const ctx = makeCtx(conn, new FakeClock(1_000), services);
+
+    const out = channelModeReducer(
+      chan,
+      { command: 'MODE', params: ['#foo', '-n'], tags: {} },
+      ctx,
+    );
+
+    expect(chan.modes.noExternal).toBe(false);
+    expect(out.effects.filter((e) => e.tag === 'Broadcast')).toHaveLength(1);
+  });
+
+  it('skips MLOCK letters that are not boolean modes (e.g. k/l/o/v/b)', () => {
+    const services = new InMemoryServicesStore({ clock: new FakeClock(1_000) });
+    services.registerNick('alice', 'pw', 'a@e');
+    services.registerChannel('#foo', 'alice');
+    // MLOCK carries o/v/b/k/l letters; the reapply loop must skip them
+    // without throwing. We pair with a +n lock so we can still observe one
+    // reapply, which doubles as proof the loop ran.
+    services.setChannelMlock('#foo', '+novbkl');
+    const chan = makeChan('#foo');
+    chan.modes.noExternal = true;
+    addMember(chan, 'c1', 'alice', true);
+    const conn = makeConn();
+    const ctx = makeCtx(conn, new FakeClock(1_000), services);
+
+    const out = channelModeReducer(
+      chan,
+      { command: 'MODE', params: ['#foo', '-n'], tags: {} },
+      ctx,
+    );
+
+    // The op unset +n; ChanServ reapplies it. The other letters are
+    // skipped silently (they are not boolean modes the reapply path
+    // toggles).
+    expect(chan.modes.noExternal).toBe(true);
+    expect(out.effects.filter((e) => e.tag === 'Broadcast')).toHaveLength(2);
+  });
+});