serverless-ircd 0.3.0 → 0.5.0

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

@@ -0,0 +1,368 @@
+import { describe, expect, it } from 'vitest';
+import { lusersReducer } from '../../src/commands/lusers';
+import { Effect } from '../../src/effects';
+import type { Effect as EffectType, RawLine } from '../../src/effects';
+import {
+  EmptyMotdProvider,
+  FakeClock,
+  SequentialIdFactory,
+  type ServerStatsSnapshot,
+} from '../../src/ports';
+import { 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(connId = 'c1', nick = 'alice', clock = new FakeClock(5_000)): Ctx {
+  const conn = createConnection({ id: connId, connectedSince: 0 });
+  conn.nick = nick;
+  conn.user = nick;
+  conn.host = 'example.com';
+  conn.realname = 'Alice';
+  conn.registration = 'registered';
+  return buildCtx({
+    serverConfig,
+    clock,
+    ids: new SequentialIdFactory(),
+    motd: EmptyMotdProvider,
+    connection: conn,
+  });
+}
+
+const L = (text: string): RawLine => ({ text });
+
+const lusers = (...params: string[]) =>
+  ({
+    command: 'LUSERS',
+    params,
+    tags: {},
+  }) as const;
+
+const snap = (overrides: Partial<ServerStatsSnapshot> = {}): ServerStatsSnapshot => ({
+  users: 2,
+  invisible: 1,
+  opers: 0,
+  unknownConnections: 0,
+  channels: 0,
+  servers: 1,
+  localConns: 3,
+  globalConns: 3,
+  maxLocalConns: 5,
+  maxGlobalConns: 5,
+  uptimeStartedAt: 1_000,
+  ...overrides,
+});
+
+// ============================================================================
+// lusersReducer — 251–255 baseline
+// ============================================================================
+
+describe('lusersReducer — 251–255 baseline', () => {
+  it('emits 251 RPL_LUSERCLIENT with the visible/invisible/server counts', () => {
+    const ctx = makeCtx();
+
+    const out = lusersReducer(snap(), lusers(), ctx);
+
+    expect(out.effects).toContainEqual<EffectType>(
+      Effect.send('c1', [
+        L(':irc.example.com 251 alice :There are 2 users and 1 invisible on 1 servers'),
+      ]),
+    );
+  });
+
+  it('emits 255 RPL_LUSERME with the local client/server counts', () => {
+    const ctx = makeCtx();
+
+    const out = lusersReducer(snap(), lusers(), ctx);
+
+    expect(out.effects).toContainEqual<EffectType>(
+      Effect.send('c1', [L(':irc.example.com 255 alice :I have 3 clients and 1 servers')]),
+    );
+  });
+
+  it('updates the requester lastSeen to ctx.clock.now()', () => {
+    const ctx = makeCtx();
+    expect(ctx.connection.lastSeen).toBe(0);
+
+    lusersReducer(snap(), lusers(), ctx);
+
+    expect(ctx.connection.lastSeen).toBe(5_000);
+  });
+
+  it('uses "*" as the nick when the requester has none', () => {
+    const conn = createConnection({ id: 'c1', connectedSince: 0 });
+    conn.registration = 'registered';
+    const ctx = buildCtx({
+      serverConfig,
+      clock: new FakeClock(5_000),
+      ids: new SequentialIdFactory(),
+      motd: EmptyMotdProvider,
+      connection: conn,
+    });
+
+    const out = lusersReducer(snap(), lusers(), ctx);
+
+    expect(out.effects).toContainEqual<EffectType>(
+      Effect.send('c1', [
+        L(':irc.example.com 251 * :There are 2 users and 1 invisible on 1 servers'),
+      ]),
+    );
+  });
+});
+
+// ============================================================================
+// lusersReducer — non-zero omission (RFC: only emit 252/253/254 when non-zero)
+// ============================================================================
+
+describe('lusersReducer — non-zero omission', () => {
+  it('emits 252 RPL_LUSEROP when opers is non-zero', () => {
+    const ctx = makeCtx();
+
+    const out = lusersReducer(snap({ opers: 2 }), lusers(), ctx);
+
+    expect(out.effects).toContainEqual<EffectType>(
+      Effect.send('c1', [L(':irc.example.com 252 alice 2 :operator(s) online')]),
+    );
+  });
+
+  it('omits 252 when opers is zero', () => {
+    const ctx = makeCtx();
+
+    const out = lusersReducer(snap({ opers: 0 }), lusers(), ctx);
+
+    const text = out.effects
+      .map((e) => (e.tag === 'Send' ? e.lines.map((l) => l.text).join('|') : ''))
+      .join('|');
+    expect(text).not.toContain(' 252 ');
+  });
+
+  it('emits 253 RPL_LUSERUNKNOWN when unknownConnections is non-zero', () => {
+    const ctx = makeCtx();
+
+    const out = lusersReducer(snap({ unknownConnections: 4 }), lusers(), ctx);
+
+    expect(out.effects).toContainEqual<EffectType>(
+      Effect.send('c1', [L(':irc.example.com 253 alice 4 :unknown connection(s)')]),
+    );
+  });
+
+  it('omits 253 when unknownConnections is zero', () => {
+    const ctx = makeCtx();
+
+    const out = lusersReducer(snap({ unknownConnections: 0 }), lusers(), ctx);
+
+    const text = out.effects
+      .map((e) => (e.tag === 'Send' ? e.lines.map((l) => l.text).join('|') : ''))
+      .join('|');
+    expect(text).not.toContain(' 253 ');
+  });
+
+  it('emits 254 RPL_LUSERCHANNELS when channels is non-zero', () => {
+    const ctx = makeCtx();
+
+    const out = lusersReducer(snap({ channels: 7 }), lusers(), ctx);
+
+    expect(out.effects).toContainEqual<EffectType>(
+      Effect.send('c1', [L(':irc.example.com 254 alice 7 :channel(s) formed')]),
+    );
+  });
+
+  it('omits 254 when channels is zero', () => {
+    const ctx = makeCtx();
+
+    const out = lusersReducer(snap({ channels: 0 }), lusers(), ctx);
+
+    const text = out.effects
+      .map((e) => (e.tag === 'Send' ? e.lines.map((l) => l.text).join('|') : ''))
+      .join('|');
+    expect(text).not.toContain(' 254 ');
+  });
+});
+
+// ============================================================================
+// lusersReducer — 265/266 local/global context
+// ============================================================================
+
+describe('lusersReducer — 265/266 local/global', () => {
+  it('emits 265 RPL_LOCALUSERS with the current and max local counts', () => {
+    const ctx = makeCtx();
+
+    const out = lusersReducer(snap({ localConns: 3, maxLocalConns: 5 }), lusers(), ctx);
+
+    expect(out.effects).toContainEqual<EffectType>(
+      Effect.send('c1', [L(':irc.example.com 265 alice 3 5 :Current local users 3, max 5')]),
+    );
+  });
+
+  it('emits 266 RPL_GLOBALUSERS with the current and max global counts', () => {
+    const ctx = makeCtx();
+
+    const out = lusersReducer(snap({ globalConns: 3, maxGlobalConns: 5 }), lusers(), ctx);
+
+    expect(out.effects).toContainEqual<EffectType>(
+      Effect.send('c1', [L(':irc.example.com 266 alice 3 5 :Current global users 3, max 5')]),
+    );
+  });
+
+  it('always emits 265 and 266 (modern clients rely on them for the user list count)', () => {
+    const ctx = makeCtx();
+
+    const out = lusersReducer(snap(), lusers(), ctx);
+
+    const text = out.effects
+      .map((e) => (e.tag === 'Send' ? e.lines.map((l) => l.text).join('|') : ''))
+      .join('|');
+    expect(text).toContain(' 265 ');
+    expect(text).toContain(' 266 ');
+  });
+});
+
+// ============================================================================
+// lusersReducer — empty deployment
+// ============================================================================
+
+describe('lusersReducer — empty deployment', () => {
+  it('still emits 251 and 255 reporting zero counts', () => {
+    const ctx = makeCtx();
+    const empty: ServerStatsSnapshot = {
+      users: 0,
+      invisible: 0,
+      opers: 0,
+      unknownConnections: 0,
+      channels: 0,
+      servers: 1,
+      localConns: 0,
+      globalConns: 0,
+      maxLocalConns: 0,
+      maxGlobalConns: 0,
+      uptimeStartedAt: 1_000,
+    };
+
+    const out = lusersReducer(empty, lusers(), ctx);
+
+    expect(out.effects).toContainEqual<EffectType>(
+      Effect.send('c1', [
+        L(':irc.example.com 251 alice :There are 0 users and 0 invisible on 1 servers'),
+      ]),
+    );
+    expect(out.effects).toContainEqual<EffectType>(
+      Effect.send('c1', [L(':irc.example.com 255 alice :I have 0 clients and 1 servers')]),
+    );
+  });
+});
+
+// ============================================================================
+// lusersReducer — remote server target
+// ============================================================================
+
+describe('lusersReducer — remote server target', () => {
+  it('emits 402 ERR_NOSUCHSERVER when the actor flags a non-local server target', () => {
+    const ctx = makeCtx();
+
+    const out = lusersReducer(snap(), lusers('remote.example.org'), ctx, 'remote.example.org');
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(':irc.example.com 402 alice remote.example.org :No such server')]),
+    ]);
+  });
+
+  it('uses "*" as the nick in 402 when the requester has none', () => {
+    const conn = createConnection({ id: 'c1', connectedSince: 0 });
+    conn.registration = 'registered';
+    const ctx = buildCtx({
+      serverConfig,
+      clock: new FakeClock(5_000),
+      ids: new SequentialIdFactory(),
+      motd: EmptyMotdProvider,
+      connection: conn,
+    });
+
+    const out = lusersReducer(snap(), lusers('remote.example.org'), ctx, 'remote.example.org');
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(':irc.example.com 402 * remote.example.org :No such server')]),
+    ]);
+  });
+
+  it('does not emit 402 when no serverTarget is flagged', () => {
+    const ctx = makeCtx();
+
+    const out = lusersReducer(snap(), lusers(), ctx);
+
+    const text = out.effects
+      .map((e) => (e.tag === 'Send' ? e.lines.map((l) => l.text).join('|') : ''))
+      .join('|');
+    expect(text).not.toContain(' 402 ');
+  });
+});
+
+// ============================================================================
+// lusersReducer — ordering
+// ============================================================================
+
+describe('lusersReducer — ordering', () => {
+  it('emits numerics in ascending code order (251, 252, 253, 254, 255, 265, 266)', () => {
+    const ctx = makeCtx();
+    const populated = snap({
+      opers: 1,
+      unknownConnections: 1,
+      channels: 1,
+    });
+
+    const out = lusersReducer(populated, lusers(), ctx);
+
+    const codes: number[] = [];
+    for (const e of out.effects) {
+      if (e.tag !== 'Send') continue;
+      for (const line of e.lines) {
+        const m = line.text.match(/\s(\d{3})\s/);
+        if (m) codes.push(Number(m[1]));
+      }
+    }
+    expect(codes).toEqual([251, 252, 253, 254, 255, 265, 266]);
+  });
+});
+
+// ============================================================================
+// lusersReducer — "*" nick fallback for count/usage lines
+// ============================================================================
+
+describe('lusersReducer — "*" nick fallback for count/usage lines', () => {
+  it('uses "*" in 252/253/254/265/266 when the requester has no nick', () => {
+    const conn = createConnection({ id: 'c1', connectedSince: 0 });
+    conn.registration = 'registered';
+    const ctx = buildCtx({
+      serverConfig,
+      clock: new FakeClock(5_000),
+      ids: new SequentialIdFactory(),
+      motd: EmptyMotdProvider,
+      connection: conn,
+    });
+
+    const out = lusersReducer(
+      snap({ opers: 1, unknownConnections: 1, channels: 1 }),
+      lusers(),
+      ctx,
+    );
+
+    const text = out.effects
+      .map((e) => (e.tag === 'Send' ? e.lines.map((l) => l.text).join('|') : ''))
+      .join('|');
+    // Every emitted numeric uses "*" as the requester nick.
+    expect(text).toContain(' 252 * 1 ');
+    expect(text).toContain(' 253 * 1 ');
+    expect(text).toContain(' 254 * 1 ');
+    expect(text).toContain(' 265 * 3 5 ');
+    expect(text).toContain(' 266 * 3 5 ');
+  });
+});

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

@@ -200,6 +200,36 @@ describe('channelModeReducer — prefix modes', () => {
     ]);
   });
 
+  it('+oo <nick1> <nick2> grants op to both members in one combined delta', () => {
+    // Exercises the already-initialized branch of `pushMembershipChange`:
+    // the second membership push reuses the `delta.memberships` array the
+    // first one created.
+    const chan = makeChan('#foo');
+    addMember(chan, 'c1', 'alice', true);
+    addMember(chan, 'c2', 'bob');
+    addMember(chan, 'c3', 'carol');
+    const conn = makeConn();
+    const ctx = makeCtx(conn);
+
+    const out = channelModeReducer(
+      chan,
+      { command: 'MODE', params: ['#foo', '+oo', 'bob', 'carol'], tags: {} },
+      ctx,
+    );
+
+    expect(chan.members.get('c2')?.op).toBe(true);
+    expect(chan.members.get('c3')?.op).toBe(true);
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.applyChannelDelta('#foo', {
+        memberships: [
+          { type: 'add', conn: 'c2', nick: 'bob', op: true, voice: false },
+          { type: 'add', conn: 'c3', nick: 'carol', op: true, voice: false },
+        ],
+      }),
+      Effect.broadcast('#foo', [L(':alice!alice@example.com MODE #foo +oo bob carol')]),
+    ]);
+  });
+
   it('-o <nick> removes op from the named member', () => {
     const chan = makeChan('#foo');
     addMember(chan, 'c1', 'alice', true);
@@ -483,6 +513,33 @@ describe('channelModeReducer — ban masks', () => {
     ]);
   });
 
+  it('+bb <mask1> <mask2> adds both masks in one combined delta', () => {
+    // Exercises the already-initialized branch of `pushBanMaskChange`: the
+    // second ban push reuses the `delta.banMaskChanges` array the first one
+    // created.
+    const chan = makeChan('#foo');
+    addMember(chan, 'c1', 'alice', true);
+    const conn = makeConn();
+    const ctx = makeCtx(conn);
+
+    const out = channelModeReducer(
+      chan,
+      { command: 'MODE', params: ['#foo', '+bb', 'bob!*@*', 'carol!*@*'], tags: {} },
+      ctx,
+    );
+
+    expect([...chan.banMasks]).toEqual(['bob!*@*', 'carol!*@*']);
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.applyChannelDelta('#foo', {
+        banMaskChanges: [
+          { type: 'add', mask: 'bob!*@*' },
+          { type: 'add', mask: 'carol!*@*' },
+        ],
+      }),
+      Effect.broadcast('#foo', [L(':alice!alice@example.com MODE #foo +bb bob!*@* carol!*@*')]),
+    ]);
+  });
+
   it('-b <mask> removes from the ban list', () => {
     const chan = makeChan('#foo');
     chan.banMasks.add('bob!*@*');

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

@@ -2,7 +2,12 @@ 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 {
+  EmptyMotdProvider,
+  FakeClock,
+  InMemoryNickHistoryStore,
+  SequentialIdFactory,
+} from '../../src/ports';
 import { type ConnectionState, createConnection } from '../../src/state/connection';
 import { type Ctx, type ServerConfig, buildCtx } from '../../src/types';
 
@@ -18,13 +23,18 @@ const serverConfig: ServerConfig = {
   quitMessage: 'Client Quit',
 };
 
-function makeCtx(state: ConnectionState, clock = new FakeClock(1_000)): Ctx {
+function makeCtx(
+  state: ConnectionState,
+  clock = new FakeClock(1_000),
+  history?: InMemoryNickHistoryStore,
+): Ctx {
   return buildCtx({
     serverConfig,
     clock,
     ids: new SequentialIdFactory(),
     motd: EmptyMotdProvider,
     connection: state,
+    ...(history !== undefined ? { history } : {}),
   });
 }
 
@@ -217,4 +227,61 @@ describe('quitReducer', () => {
       Effect.disconnect('c1'),
     ]);
   });
+
+  it('records a nick-history entry when ctx.history is bound', () => {
+    const state = makeRegisteredState();
+    const clock = new FakeClock(5_000);
+    const history = new InMemoryNickHistoryStore(clock);
+    const ctx = makeCtx(state, clock, history);
+
+    quitReducer(state, { command: 'QUIT', params: ['bye'], tags: {} }, ctx);
+
+    const entries = history.query('alice', 10);
+    expect(entries).toHaveLength(1);
+    expect(entries[0]?.nick).toBe('alice');
+    expect(entries[0]?.connId).toBe('c1');
+    expect(entries[0]?.username).toBe('alice');
+    expect(entries[0]?.hostname).toBe('example.com');
+    expect(entries[0]?.realname).toBe('Alice');
+    expect(entries[0]?.signoffTime).toBe(5_000);
+  });
+
+  it('does not record history when no store is bound (ctx.history undefined)', () => {
+    const state = makeRegisteredState();
+    const ctx = makeCtx(state);
+
+    const out = quitReducer(state, { command: 'QUIT', params: [], tags: {} }, ctx);
+
+    expect(out.effects).toContainEqual<EffectType>(Effect.disconnect('c1'));
+    // No crash; the no-store path is a graceful no-op.
+  });
+
+  it('does not record history when the connection was never registered', () => {
+    const state = createConnection({ id: 'c1', connectedSince: 0 });
+    const clock = new FakeClock(5_000);
+    const history = new InMemoryNickHistoryStore(clock);
+    const ctx = makeCtx(state, clock, history);
+
+    quitReducer(state, { command: 'QUIT', params: [], tags: {} }, ctx);
+
+    expect(history.query('ghost', 10)).toEqual([]);
+  });
+
+  it('records a history entry with only nick/connId when user/host/realname are absent', () => {
+    const state = createConnection({ id: 'c1', connectedSince: 0 });
+    state.nick = 'alice';
+    state.registration = 'registered';
+    const clock = new FakeClock(5_000);
+    const history = new InMemoryNickHistoryStore(clock);
+    const ctx = makeCtx(state, clock, history);
+
+    quitReducer(state, { command: 'QUIT', params: [], tags: {} }, ctx);
+
+    const entries = history.query('alice', 10);
+    expect(entries).toHaveLength(1);
+    expect(entries[0]?.nick).toBe('alice');
+    expect(entries[0]?.username).toBeUndefined();
+    expect(entries[0]?.hostname).toBeUndefined();
+    expect(entries[0]?.realname).toBeUndefined();
+  });
 });