serverless-ircd 0.3.0 → 0.4.0

package/packages/irc-core/tests/commands/server-info.test.ts

@@ -0,0 +1,274 @@
+import { describe, expect, it } from 'vitest';
+import {
+  adminReducer,
+  infoReducer,
+  timeReducer,
+  versionReducer,
+} from '../../src/commands/server-info';
+import { DEFAULT_SERVER_VERSION } from '../../src/config';
+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 baseServerConfig: 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, clockMs = 5_000): Ctx {
+  return buildCtx({
+    serverConfig: baseServerConfig,
+    clock: new FakeClock(clockMs),
+    ids: new SequentialIdFactory(),
+    motd: EmptyMotdProvider,
+    connection: state,
+  });
+}
+
+function makeState(): ConnectionState {
+  const s = createConnection({ id: 'c1', connectedSince: 0 });
+  s.nick = 'alice';
+  s.user = 'alice';
+  s.host = 'example.com';
+  s.realname = 'Alice';
+  s.registration = 'registered';
+  return s;
+}
+
+const L = (text: string): RawLine => ({ text });
+
+const version = (server?: string) =>
+  ({ command: 'VERSION', params: server === undefined ? [] : [server], tags: {} }) as const;
+
+const time = (server?: string) =>
+  ({ command: 'TIME', params: server === undefined ? [] : [server], tags: {} }) as const;
+
+const admin = (server?: string) =>
+  ({ command: 'ADMIN', params: server === undefined ? [] : [server], tags: {} }) as const;
+
+const info = (server?: string) =>
+  ({ command: 'INFO', params: server === undefined ? [] : [server], tags: {} }) as const;
+
+// ---------------------------------------------------------------------------
+// VERSION
+// ---------------------------------------------------------------------------
+
+describe('versionReducer', () => {
+  it('emits 351 RPL_VERSION with the server version and name', () => {
+    const state = makeState();
+    const ctx = makeCtx(state);
+
+    const out = versionReducer(state, version(), ctx);
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [
+        L(`:irc.example.com 351 alice ${DEFAULT_SERVER_VERSION} irc.example.com :ExampleNet`),
+      ]),
+    ]);
+  });
+
+  it('updates lastSeen to ctx.clock.now()', () => {
+    const state = makeState();
+    const ctx = makeCtx(state, 9_999);
+
+    versionReducer(state, version(), ctx);
+
+    expect(state.lastSeen).toBe(9_999);
+  });
+
+  it('uses * as nick placeholder for unregistered connections', () => {
+    const state = createConnection({ id: 'c1', connectedSince: 0 });
+    const ctx = makeCtx(state);
+
+    const out = versionReducer(state, version(), ctx);
+
+    expect(out.effects[0]).toEqual<EffectType>(
+      Effect.send('c1', [
+        L(`:irc.example.com 351 * ${DEFAULT_SERVER_VERSION} irc.example.com :ExampleNet`),
+      ]),
+    );
+  });
+
+  it('ignores the optional server target parameter (single-server deployment)', () => {
+    const state = makeState();
+    const ctx = makeCtx(state);
+
+    const out = versionReducer(state, version('other.server'), ctx);
+
+    expect(out.effects[0]).toEqual<EffectType>(
+      Effect.send('c1', [
+        L(`:irc.example.com 351 alice ${DEFAULT_SERVER_VERSION} irc.example.com :ExampleNet`),
+      ]),
+    );
+  });
+
+  it('returns the same state reference', () => {
+    const state = makeState();
+    const ctx = makeCtx(state);
+
+    const out = versionReducer(state, version(), ctx);
+
+    expect(out.state).toBe(state);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// TIME
+// ---------------------------------------------------------------------------
+
+describe('timeReducer', () => {
+  it('emits 391 RPL_TIME with a human-readable timestamp from the clock', () => {
+    const state = makeState();
+    const ctx = makeCtx(state, 1_700_000_000_000);
+
+    const out = timeReducer(state, time(), ctx);
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [
+        L(':irc.example.com 391 alice irc.example.com :2023-11-14T22:13:20.000Z'),
+      ]),
+    ]);
+  });
+
+  it('updates lastSeen to ctx.clock.now()', () => {
+    const state = makeState();
+    const ctx = makeCtx(state, 42_000);
+
+    timeReducer(state, time(), ctx);
+
+    expect(state.lastSeen).toBe(42_000);
+  });
+
+  it('uses * as nick placeholder for unregistered connections', () => {
+    const state = createConnection({ id: 'c1', connectedSince: 0 });
+    const ctx = makeCtx(state, 1_700_000_000_000);
+
+    const out = timeReducer(state, time(), ctx);
+
+    expect(out.effects[0]).toEqual<EffectType>(
+      Effect.send('c1', [L(':irc.example.com 391 * irc.example.com :2023-11-14T22:13:20.000Z')]),
+    );
+  });
+
+  it('ignores the optional server target parameter', () => {
+    const state = makeState();
+    const ctx = makeCtx(state, 1_700_000_000_000);
+
+    const out = timeReducer(state, time('elsewhere'), ctx);
+
+    expect(out.effects[0]).toEqual<EffectType>(
+      Effect.send('c1', [
+        L(':irc.example.com 391 alice irc.example.com :2023-11-14T22:13:20.000Z'),
+      ]),
+    );
+  });
+});
+
+// ---------------------------------------------------------------------------
+// ADMIN
+// ---------------------------------------------------------------------------
+
+describe('adminReducer', () => {
+  it('emits 256 RPL_ADMINME with the server name', () => {
+    const state = makeState();
+    const ctx = makeCtx(state);
+
+    const out = adminReducer(state, admin(), ctx);
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(':irc.example.com 256 alice irc.example.com :Administrative info')]),
+    ]);
+  });
+
+  it('updates lastSeen to ctx.clock.now()', () => {
+    const state = makeState();
+    const ctx = makeCtx(state, 7_777);
+
+    adminReducer(state, admin(), ctx);
+
+    expect(state.lastSeen).toBe(7_777);
+  });
+
+  it('uses * as nick placeholder for unregistered connections', () => {
+    const state = createConnection({ id: 'c1', connectedSince: 0 });
+    const ctx = makeCtx(state);
+
+    const out = adminReducer(state, admin(), ctx);
+
+    expect(out.effects[0]).toEqual<EffectType>(
+      Effect.send('c1', [L(':irc.example.com 256 * irc.example.com :Administrative info')]),
+    );
+  });
+
+  it('ignores the optional server target parameter', () => {
+    const state = makeState();
+    const ctx = makeCtx(state);
+
+    const out = adminReducer(state, admin('foo'), ctx);
+
+    expect(out.effects[0]).toEqual<EffectType>(
+      Effect.send('c1', [L(':irc.example.com 256 alice irc.example.com :Administrative info')]),
+    );
+  });
+});
+
+// ---------------------------------------------------------------------------
+// INFO
+// ---------------------------------------------------------------------------
+
+describe('infoReducer', () => {
+  it('emits 371 RPL_INFO lines followed by 374 RPL_ENDOFINFO', () => {
+    const state = makeState();
+    const ctx = makeCtx(state);
+
+    const out = infoReducer(state, info(), ctx);
+
+    const lines = (out.effects[0] as { lines: RawLine[] }).lines;
+    expect(lines[0]).toEqual(
+      L(`:irc.example.com 371 alice :ServerlessIRCd - version ${DEFAULT_SERVER_VERSION}`),
+    );
+    expect(lines[1]).toEqual(L(':irc.example.com 371 alice :Running on network ExampleNet'));
+    expect(lines[lines.length - 1]).toEqual(L(':irc.example.com 374 alice :End of INFO list'));
+  });
+
+  it('includes at least one 371 line and the 374 terminator', () => {
+    const state = makeState();
+    const ctx = makeCtx(state);
+
+    const out = infoReducer(state, info(), ctx);
+
+    const texts = (out.effects[0] as { lines: RawLine[] }).lines.map((l) => l.text);
+    const rpl371Count = texts.filter((t) => / 371 /.test(t)).length;
+    const rpl374Count = texts.filter((t) => / 374 /.test(t)).length;
+    expect(rpl371Count).toBeGreaterThanOrEqual(1);
+    expect(rpl374Count).toBe(1);
+  });
+
+  it('updates lastSeen to ctx.clock.now()', () => {
+    const state = makeState();
+    const ctx = makeCtx(state, 3_333);
+
+    infoReducer(state, info(), ctx);
+
+    expect(state.lastSeen).toBe(3_333);
+  });
+
+  it('uses * as nick placeholder for unregistered connections', () => {
+    const state = createConnection({ id: 'c1', connectedSince: 0 });
+    const ctx = makeCtx(state);
+
+    const out = infoReducer(state, info(), ctx);
+
+    const texts = (out.effects[0] as { lines: RawLine[] }).lines.map((l) => l.text);
+    expect(texts.every((t) => t.includes(' * '))).toBe(true);
+  });
+});

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

@@ -102,11 +102,7 @@ describe('tagmsgChannelReducer — success', () => {
     const conn = makeConn();
     const ctx = makeCtx(conn);
 
-    const out = tagmsgChannelReducer(
-      chan,
-      { command: 'TAGMSG', params: ['#foo'], tags: {} },
-      ctx,
-    );
+    const out = tagmsgChannelReducer(chan, { command: 'TAGMSG', params: ['#foo'], tags: {} }, ctx);
 
     expect(out.effects).toEqual<EffectType[]>([
       Effect.broadcast('#foo', [L(':alice!alice@example.com TAGMSG #foo')], 'c1', 'message-tags'),
@@ -516,11 +512,7 @@ describe('tagmsgChannelReducer — defensive hostmask', () => {
     conn.caps.add('message-tags');
     const ctx = makeCtx(conn);
 
-    const out = tagmsgChannelReducer(
-      chan,
-      { command: 'TAGMSG', params: ['#foo'], tags: {} },
-      ctx,
-    );
+    const out = tagmsgChannelReducer(chan, { command: 'TAGMSG', params: ['#foo'], tags: {} }, ctx);
 
     const broadcast = out.effects[0];
     expect(broadcast?.tag).toBe('Broadcast');
@@ -535,11 +527,7 @@ describe('tagmsgChannelReducer — defensive hostmask', () => {
     conn.caps.add('message-tags');
     const ctx = makeCtx(conn);
 
-    const out = tagmsgChannelReducer(
-      chan,
-      { command: 'TAGMSG', params: ['#foo'], tags: {} },
-      ctx,
-    );
+    const out = tagmsgChannelReducer(chan, { command: 'TAGMSG', params: ['#foo'], tags: {} }, ctx);
 
     const broadcast = out.effects[0];
     expect(broadcast?.tag).toBe('Broadcast');
@@ -564,11 +552,7 @@ describe('tagmsgUserReducer', () => {
     );
 
     expect(out.effects).toEqual<EffectType[]>([
-      Effect.sendToNick(
-        'bob',
-        'c1',
-        [L('@+typing=active :alice!alice@example.com TAGMSG bob')],
-      ),
+      Effect.sendToNick('bob', 'c1', [L('@+typing=active :alice!alice@example.com TAGMSG bob')]),
     ]);
   });
 
@@ -583,11 +567,9 @@ describe('tagmsgUserReducer', () => {
     );
 
     expect(out.effects).toEqual<EffectType[]>([
-      Effect.sendToNick(
-        'nobody',
-        'c1',
-        [L('@+typing=active :alice!alice@example.com TAGMSG nobody')],
-      ),
+      Effect.sendToNick('nobody', 'c1', [
+        L('@+typing=active :alice!alice@example.com TAGMSG nobody'),
+      ]),
     ]);
   });
 
@@ -642,11 +624,7 @@ describe('tagmsgUserReducer', () => {
     const conn = makeConn();
     const ctx = makeCtx(conn);
 
-    const out = tagmsgUserReducer(
-      conn,
-      { command: 'TAGMSG', params: ['bob'], tags: {} },
-      ctx,
-    );
+    const out = tagmsgUserReducer(conn, { command: 'TAGMSG', params: ['bob'], tags: {} }, ctx);
 
     expect(out.effects).toEqual<EffectType[]>([
       Effect.sendToNick('bob', 'c1', [L(':alice!alice@example.com TAGMSG bob')]),
@@ -667,11 +645,7 @@ describe('tagmsgUserReducer', () => {
     const conn = makeConn();
     const ctx = makeCtx(conn);
 
-    const out = tagmsgUserReducer(
-      conn,
-      { command: 'TAGMSG', params: ['bob'], tags: {} },
-      ctx,
-    );
+    const out = tagmsgUserReducer(conn, { command: 'TAGMSG', params: ['bob'], tags: {} }, ctx);
 
     expect(out.state).toBe(conn);
   });

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

@@ -0,0 +1,264 @@
+import { describe, expect, it } from 'vitest';
+import { formatUserhostReply, userhostReducer } from '../../src/commands/userhost';
+import { Effect } from '../../src/effects';
+import type { Effect as EffectType, RawLine } from '../../src/effects';
+import { EmptyMotdProvider, FakeClock, SequentialIdFactory } from '../../src/ports';
+import {
+  type ConnSnapshot,
+  type ConnectionState,
+  createConnection,
+  toSnapshot,
+} from '../../src/state/connection';
+import { type Ctx, type ServerConfig, buildCtx } from '../../src/types';
+
+const baseServerConfig: 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): Ctx {
+  return buildCtx({
+    serverConfig: baseServerConfig,
+    clock: new FakeClock(5_000),
+    ids: new SequentialIdFactory(),
+    motd: EmptyMotdProvider,
+    connection: state,
+  });
+}
+
+function makeState(): ConnectionState {
+  const s = createConnection({ id: 'c1', connectedSince: 0 });
+  s.nick = 'alice';
+  s.user = 'alice';
+  s.host = 'example.com';
+  s.realname = 'Alice';
+  s.registration = 'registered';
+  return s;
+}
+
+function makeSnapshot(
+  nick: string,
+  user: string,
+  host: string,
+  opts?: { away?: string; oper?: boolean },
+): ConnSnapshot {
+  const s = createConnection({ id: `c-${nick}`, connectedSince: 0 });
+  s.nick = nick;
+  s.user = user;
+  s.host = host;
+  s.registration = 'registered';
+  if (opts?.away !== undefined) s.away = opts.away;
+  if (opts?.oper) s.userModes.oper = true;
+  return toSnapshot(s);
+}
+
+const L = (text: string): RawLine => ({ text });
+
+const userhost = (...nicks: string[]) =>
+  ({ command: 'USERHOST', params: nicks, tags: {} }) as const;
+
+describe('userhostReducer', () => {
+  it('emits 302 RPL_USERHOST with the resolved hostmask for one nick', () => {
+    const state = makeState();
+    const ctx = makeCtx(state);
+    const resolved = new Map([['bob', makeSnapshot('bob', 'bobuser', 'bobhost')]]);
+
+    const out = userhostReducer(resolved, userhost('bob'), ctx);
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(':irc.example.com 302 alice :bob=+bobuser@bobhost')]),
+    ]);
+  });
+
+  it('includes multiple replies space-separated in one 302 line', () => {
+    const state = makeState();
+    const ctx = makeCtx(state);
+    const resolved = new Map([
+      ['bob', makeSnapshot('bob', 'bobuser', 'bobhost')],
+      ['carol', makeSnapshot('carol', 'caroluser', 'carolhost')],
+    ]);
+
+    const out = userhostReducer(resolved, userhost('bob', 'carol'), ctx);
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [
+        L(':irc.example.com 302 alice :bob=+bobuser@bobhost carol=+caroluser@carolhost'),
+      ]),
+    ]);
+  });
+
+  it('marks away users with - instead of +', () => {
+    const state = makeState();
+    const ctx = makeCtx(state);
+    const resolved = new Map([
+      ['bob', makeSnapshot('bob', 'bobuser', 'bobhost', { away: 'gone' })],
+    ]);
+
+    const out = userhostReducer(resolved, userhost('bob'), ctx);
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(':irc.example.com 302 alice :bob=-bobuser@bobhost')]),
+    ]);
+  });
+
+  it('prefixes oper users with *', () => {
+    const state = makeState();
+    const ctx = makeCtx(state);
+    const resolved = new Map([['bob', makeSnapshot('bob', 'bobuser', 'bobhost', { oper: true })]]);
+
+    const out = userhostReducer(resolved, userhost('bob'), ctx);
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(':irc.example.com 302 alice :bob*=+bobuser@bobhost')]),
+    ]);
+  });
+
+  it('omits nicks that are offline (null in the resolved map)', () => {
+    const state = makeState();
+    const ctx = makeCtx(state);
+    const resolved = new Map<string, ConnSnapshot | null>([
+      ['bob', makeSnapshot('bob', 'bobuser', 'bobhost')],
+      ['ghost', null],
+    ]);
+
+    const out = userhostReducer(resolved, userhost('bob', 'ghost'), ctx);
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(':irc.example.com 302 alice :bob=+bobuser@bobhost')]),
+    ]);
+  });
+
+  it('emits an empty trailing when no requested nicks are online', () => {
+    const state = makeState();
+    const ctx = makeCtx(state);
+    const resolved = new Map<string, ConnSnapshot | null>([['ghost', null]]);
+
+    const out = userhostReducer(resolved, userhost('ghost'), ctx);
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(':irc.example.com 302 alice :')]),
+    ]);
+  });
+
+  it('emits an empty trailing when no nicks are requested', () => {
+    const state = makeState();
+    const ctx = makeCtx(state);
+    const resolved = new Map<string, ConnSnapshot | null>();
+
+    const out = userhostReducer(resolved, userhost(), ctx);
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(':irc.example.com 302 alice :')]),
+    ]);
+  });
+
+  it('uses * as nick placeholder for unregistered connections', () => {
+    const state = createConnection({ id: 'c1', connectedSince: 0 });
+    const ctx = makeCtx(state);
+    const resolved = new Map([['bob', makeSnapshot('bob', 'bobuser', 'bobhost')]]);
+
+    const out = userhostReducer(resolved, userhost('bob'), ctx);
+
+    expect(out.effects[0]).toEqual<EffectType>(
+      Effect.send('c1', [L(':irc.example.com 302 * :bob=+bobuser@bobhost')]),
+    );
+  });
+
+  it('updates lastSeen to ctx.clock.now()', () => {
+    const state = makeState();
+    const ctx = makeCtx(state);
+
+    userhostReducer(new Map(), userhost('bob'), ctx);
+
+    expect(state.lastSeen).toBe(5_000);
+  });
+
+  it('returns the same state reference', () => {
+    const state = makeState();
+    const ctx = makeCtx(state);
+
+    const out = userhostReducer(new Map(), userhost(), ctx);
+
+    expect(out.state).toBe(state);
+  });
+
+  it('respects the max-targets cap (caps the number of queried nicks)', () => {
+    const state = makeState();
+    const config: ServerConfig = { ...baseServerConfig, maxTargetsPerCommand: 2 };
+    const ctx = buildCtx({
+      serverConfig: config,
+      clock: new FakeClock(5_000),
+      ids: new SequentialIdFactory(),
+      motd: EmptyMotdProvider,
+      connection: state,
+    });
+    const resolved = new Map([
+      ['bob', makeSnapshot('bob', 'bu', 'bh')],
+      ['carol', makeSnapshot('carol', 'cu', 'ch')],
+      ['dave', makeSnapshot('dave', 'du', 'dh')],
+    ]);
+
+    const out = userhostReducer(resolved, userhost('bob', 'carol', 'dave'), ctx);
+
+    const text = (out.effects[0] as { lines: RawLine[] }).lines[0]?.text;
+    // Only the first two nicks should appear; the third is beyond the cap.
+    expect(text).not.toContain('dave');
+    expect(text).toContain('bob');
+    expect(text).toContain('carol');
+  });
+
+  it('skips an empty-string nick in the parameter list', () => {
+    const state = makeState();
+    const ctx = makeCtx(state);
+    const resolved = new Map([['bob', makeSnapshot('bob', 'bobuser', 'bobhost')]]);
+
+    const out = userhostReducer(resolved, userhost('', 'bob'), ctx);
+
+    const text = (out.effects[0] as { lines: RawLine[] }).lines[0]?.text;
+    expect(text).toContain('bob=+bobuser@bobhost');
+  });
+
+  it('omits a resolved snapshot that is missing required fields (host absent)', () => {
+    const state = makeState();
+    const ctx = makeCtx(state);
+    const incomplete = makeSnapshot('bob', 'bobuser', 'bobhost');
+    (incomplete as { host: string | undefined }).host = undefined;
+    const resolved = new Map<string, ConnSnapshot | null>([
+      ['bob', incomplete],
+      ['carol', makeSnapshot('carol', 'caroluser', 'carolhost')],
+    ]);
+
+    const out = userhostReducer(resolved, userhost('bob', 'carol'), ctx);
+
+    const text = (out.effects[0] as { lines: RawLine[] }).lines[0]?.text;
+    expect(text).not.toContain('bob');
+    expect(text).toContain('carol=+caroluser@carolhost');
+  });
+});
+
+describe('formatUserhostReply', () => {
+  it('returns null when the snapshot is missing a nick', () => {
+    const snap = makeSnapshot('bob', 'bu', 'bh');
+    (snap as { nick: string | undefined }).nick = undefined;
+    expect(formatUserhostReply(snap)).toBeNull();
+  });
+
+  it('returns null when the snapshot is missing a user', () => {
+    const snap = makeSnapshot('bob', 'bu', 'bh');
+    (snap as { user: string | undefined }).user = undefined;
+    expect(formatUserhostReply(snap)).toBeNull();
+  });
+
+  it('returns null when the snapshot is missing a host', () => {
+    const snap = makeSnapshot('bob', 'bu', 'bh');
+    (snap as { host: string | undefined }).host = undefined;
+    expect(formatUserhostReply(snap)).toBeNull();
+  });
+});