serverless-ircd 0.4.0 → 0.5.0

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

@@ -0,0 +1,282 @@
+import { describe, expect, it } from 'vitest';
+import { traceReducer } from '../../src/commands/trace';
+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(conn: ConnectionState, clock = new FakeClock(5_000)): Ctx {
+  return buildCtx({
+    serverConfig,
+    clock,
+    ids: new SequentialIdFactory(),
+    motd: EmptyMotdProvider,
+    connection: conn,
+  });
+}
+
+function makeConn(id = 'c1', nick = 'alice', oper = false): ConnectionState {
+  const s = createConnection({ id, connectedSince: 0 });
+  s.nick = nick;
+  s.user = nick;
+  s.host = 'example.com';
+  s.realname = 'Alice';
+  s.registration = 'registered';
+  s.userModes.oper = oper;
+  return s;
+}
+
+function makeTarget(
+  id: string,
+  nick: string,
+  opts: { oper?: boolean; invisible?: boolean } = {},
+): ConnectionState {
+  const s = createConnection({ id, connectedSince: 0 });
+  s.nick = nick;
+  s.user = nick;
+  s.host = 'example.com';
+  s.realname = 'Real Name';
+  s.registration = 'registered';
+  if (opts.oper !== undefined) s.userModes.oper = opts.oper;
+  if (opts.invisible !== undefined) s.userModes.invisible = opts.invisible;
+  return s;
+}
+
+const L = (text: string): RawLine => ({ text });
+
+const trace = (target?: string) =>
+  ({
+    command: 'TRACE',
+    params: target === undefined ? [] : [target],
+    tags: {},
+  }) as const;
+
+// ============================================================================
+// traceReducer — no target
+// ============================================================================
+
+describe('traceReducer — no target', () => {
+  it('emits the 262 terminator with no middle when there is no target', () => {
+    const requester = makeConn();
+    const ctx = makeCtx(requester);
+
+    const out = traceReducer(undefined, trace(), ctx);
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(':irc.example.com 262 alice :End of TRACE')]),
+    ]);
+  });
+
+  it('omits any 200/204/205 detail line when there is no target', () => {
+    const requester = makeConn();
+    const ctx = makeCtx(requester);
+
+    const out = traceReducer(undefined, trace(), ctx);
+
+    const text = out.effects
+      .map((e) => (e.tag === 'Send' ? e.lines.map((l) => l.text).join('|') : ''))
+      .join('|');
+    expect(text).not.toContain(' 200 ');
+    expect(text).not.toContain(' 204 ');
+    expect(text).not.toContain(' 205 ');
+  });
+
+  it('updates the requester lastSeen to ctx.clock.now()', () => {
+    const requester = makeConn();
+    expect(requester.lastSeen).toBe(0);
+    const ctx = makeCtx(requester);
+
+    traceReducer(undefined, trace(), ctx);
+
+    expect(requester.lastSeen).toBe(5_000);
+  });
+
+  it('uses "*" as the nick when the requester has none', () => {
+    const requester = createConnection({ id: 'c1', connectedSince: 0 });
+    const ctx = makeCtx(requester);
+
+    const out = traceReducer(undefined, trace(), ctx);
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(':irc.example.com 262 * :End of TRACE')]),
+    ]);
+  });
+});
+
+// ============================================================================
+// traceReducer — non-oper detail suppression
+// ============================================================================
+
+describe('traceReducer — non-oper suppression', () => {
+  it('emits only the 262 terminator for a non-oper TRACE <nick> (no leak)', () => {
+    const requester = makeConn('c1', 'alice', false);
+    const ctx = makeCtx(requester);
+    const target = makeTarget('c2', 'bob');
+
+    const out = traceReducer(target, trace('bob'), ctx);
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(':irc.example.com 262 alice bob :End of TRACE')]),
+    ]);
+  });
+
+  it('does not emit a 205 detail line for a non-oper requester', () => {
+    const requester = makeConn('c1', 'alice', false);
+    const ctx = makeCtx(requester);
+    const target = makeTarget('c2', 'bob');
+
+    const out = traceReducer(target, trace('bob'), ctx);
+
+    const text = out.effects
+      .map((e) => (e.tag === 'Send' ? e.lines.map((l) => l.text).join('|') : ''))
+      .join('|');
+    expect(text).not.toContain(' 205 ');
+    expect(text).not.toContain(' 204 ');
+  });
+});
+
+// ============================================================================
+// traceReducer — oper detail
+// ============================================================================
+
+describe('traceReducer — oper detail', () => {
+  it('emits a 205 RPL_TRACEUSER line for an oper tracing a normal user', () => {
+    const requester = makeConn('c1', 'alice', true);
+    const ctx = makeCtx(requester);
+    const target = makeTarget('c2', 'bob');
+
+    const out = traceReducer(target, trace('bob'), ctx);
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(':irc.example.com 205 alice User 0 bob bob example.com')]),
+      Effect.send('c1', [L(':irc.example.com 262 alice bob :End of TRACE')]),
+    ]);
+  });
+
+  it('emits a 204 RPL_TRACEOPERATOR line for an oper tracing another oper', () => {
+    const requester = makeConn('c1', 'alice', true);
+    const ctx = makeCtx(requester);
+    const target = makeTarget('c2', 'bob', { oper: true });
+
+    const out = traceReducer(target, trace('bob'), ctx);
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(':irc.example.com 204 alice Oper 0 bob bob example.com')]),
+      Effect.send('c1', [L(':irc.example.com 262 alice bob :End of TRACE')]),
+    ]);
+  });
+
+  it('uses "*" nick fallbacks in 204/205 lines for an oper without a nick', () => {
+    const requester = createConnection({ id: 'c1', connectedSince: 0 });
+    requester.userModes.oper = true;
+    const ctx = makeCtx(requester);
+    const target = makeTarget('c2', 'bob');
+
+    const out = traceReducer(target, trace('bob'), ctx);
+
+    expect(out.effects[0]).toEqual<EffectType>(
+      Effect.send('c1', [L(':irc.example.com 205 * User 0 bob bob example.com')]),
+    );
+  });
+
+  it('uses "?" / "*" fallbacks in 205 line when target lacks user/host/nick', () => {
+    const requester = makeConn('c1', 'alice', true);
+    const ctx = makeCtx(requester);
+    const target = createConnection({ id: 'c2', connectedSince: 0 });
+    target.registration = 'registered';
+
+    const out = traceReducer(target, trace('ghost'), ctx);
+
+    expect(out.effects[0]).toEqual<EffectType>(
+      Effect.send('c1', [L(':irc.example.com 205 alice User 0 * ? ?')]),
+    );
+  });
+});
+
+// ============================================================================
+// traceReducer — +i invisible filtering
+// ============================================================================
+
+describe('traceReducer — +i invisible filtering', () => {
+  it('omits detail for an invisible target a non-oper does not share a channel with', () => {
+    const requester = makeConn('c1', 'alice', false);
+    const ctx = makeCtx(requester);
+    const target = makeTarget('c2', 'bob', { invisible: true });
+
+    const out = traceReducer(target, trace('bob'), ctx);
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(':irc.example.com 262 alice bob :End of TRACE')]),
+    ]);
+  });
+
+  it('shows a 205 line for an invisible target when the requester is an oper (oper bypasses +i)', () => {
+    const requester = makeConn('c1', 'alice', true);
+    const ctx = makeCtx(requester);
+    const target = makeTarget('c2', 'bob', { invisible: true });
+
+    const out = traceReducer(target, trace('bob'), ctx);
+
+    expect(out.effects[0]).toEqual<EffectType>(
+      Effect.send('c1', [L(':irc.example.com 205 alice User 0 bob bob example.com')]),
+    );
+  });
+});
+
+// ============================================================================
+// traceReducer — remote server target
+// ============================================================================
+
+describe('traceReducer — remote server target', () => {
+  it('emits 402 ERR_NOSUCHSERVER when the actor flags a non-local server target', () => {
+    const requester = makeConn('c1', 'alice', true);
+    const ctx = makeCtx(requester);
+
+    const out = traceReducer(undefined, trace('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 "*" nick in 402 when the requester has none', () => {
+    const requester = createConnection({ id: 'c1', connectedSince: 0 });
+    const ctx = makeCtx(requester);
+
+    const out = traceReducer(undefined, trace('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')]),
+    ]);
+  });
+});
+
+// ============================================================================
+// traceReducer — unknown nick (actor could not resolve)
+// ============================================================================
+
+describe('traceReducer — unknown nick', () => {
+  it('emits 262 with the requested nick when target resolves to undefined', () => {
+    const requester = makeConn('c1', 'alice', true);
+    const ctx = makeCtx(requester);
+
+    const out = traceReducer(undefined, trace('ghost'), ctx);
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(':irc.example.com 262 alice ghost :End of TRACE')]),
+    ]);
+  });
+});

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

@@ -0,0 +1,231 @@
+import { describe, expect, it } from 'vitest';
+import { wallopsReducer } from '../../src/commands/wallops';
+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(conn: ConnectionState, clock = new FakeClock(5_000)): Ctx {
+  return buildCtx({
+    serverConfig,
+    clock,
+    ids: new SequentialIdFactory(),
+    motd: EmptyMotdProvider,
+    connection: conn,
+  });
+}
+
+function makeOper(id = 'c1', nick = 'alice'): ConnectionState {
+  const s = createConnection({ id, connectedSince: 0 });
+  s.nick = nick;
+  s.user = nick;
+  s.host = 'example.com';
+  s.realname = 'Alice';
+  s.registration = 'registered';
+  s.userModes.oper = true;
+  return s;
+}
+
+const L = (text: string): RawLine => ({ text });
+
+const wallops = (message?: string) =>
+  ({
+    command: 'WALLOPS',
+    params: message === undefined ? [] : [message],
+    tags: {},
+  }) as const;
+
+describe('wallopsReducer — oper happy path', () => {
+  it('emits a global BroadcastWallops effect carrying the oper source prefix', () => {
+    const oper = makeOper();
+    const ctx = makeCtx(oper);
+
+    const out = wallopsReducer(oper, wallops('hello'), ctx);
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.broadcastWallops([L(':alice!alice@example.com WALLOPS :hello')], 'c1'),
+    ]);
+  });
+
+  it('passes the message text through verbatim (multi-word)', () => {
+    const oper = makeOper();
+    const ctx = makeCtx(oper);
+
+    const out = wallopsReducer(oper, wallops('restart in 5 minutes'), ctx);
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.broadcastWallops([L(':alice!alice@example.com WALLOPS :restart in 5 minutes')], 'c1'),
+    ]);
+  });
+
+  it('defaults except to the sender (skip-self, NOTICE/PRIVMSG semantics)', () => {
+    const oper = makeOper();
+    const ctx = makeCtx(oper);
+
+    const out = wallopsReducer(oper, wallops('hi'), ctx);
+
+    expect(out.effects[0]?.tag).toBe('BroadcastWallops');
+    // except is the oper's own connection id, so the runtime never echoes
+    // the wallops back to its originator.
+    expect((out.effects[0] as { except?: string }).except).toBe('c1');
+  });
+
+  it('updates the oper lastSeen to ctx.clock.now()', () => {
+    const oper = makeOper();
+    expect(oper.lastSeen).toBe(0);
+    const ctx = makeCtx(oper);
+
+    wallopsReducer(oper, wallops('hi'), ctx);
+
+    expect(oper.lastSeen).toBe(5_000);
+  });
+
+  it('returns the same state reference unchanged', () => {
+    const oper = makeOper();
+    const ctx = makeCtx(oper);
+
+    const out = wallopsReducer(oper, wallops('hi'), ctx);
+
+    expect(out.state).toBe(oper);
+  });
+
+  it('falls back to the bare nick when the hostmask is incomplete (no user/host)', () => {
+    const oper = createConnection({ id: 'c1', connectedSince: 0 });
+    oper.nick = 'alice';
+    oper.registration = 'registered';
+    oper.userModes.oper = true;
+    const ctx = makeCtx(oper);
+
+    const out = wallopsReducer(oper, wallops('hi'), ctx);
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.broadcastWallops([L(':alice WALLOPS :hi')], 'c1'),
+    ]);
+  });
+
+  it('falls back to "*" when the oper has neither nick nor hostmask (defensive)', () => {
+    const oper = createConnection({ id: 'c1', connectedSince: 0 });
+    oper.registration = 'registered';
+    oper.userModes.oper = true;
+    const ctx = makeCtx(oper);
+
+    const out = wallopsReducer(oper, wallops('hi'), ctx);
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.broadcastWallops([L(':* WALLOPS :hi')], 'c1'),
+    ]);
+  });
+});
+
+describe('wallopsReducer — non-oper (481 ERR_NOPRIVILEGES)', () => {
+  it('emits 481 when the sender is not an oper', () => {
+    const oper = makeOper();
+    oper.userModes.oper = false;
+    const ctx = makeCtx(oper);
+
+    const out = wallopsReducer(oper, wallops('hi'), ctx);
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [
+        L(":irc.example.com 481 alice :Permission Denied - You're not an IRC operator"),
+      ]),
+    ]);
+  });
+
+  it('does not emit a BroadcastWallops when the sender is not an oper', () => {
+    const oper = makeOper();
+    oper.userModes.oper = false;
+    const ctx = makeCtx(oper);
+
+    const out = wallopsReducer(oper, wallops('hi'), ctx);
+
+    expect(out.effects.some((e) => e.tag === 'BroadcastWallops')).toBe(false);
+  });
+
+  it('gates before param validation: a non-oper with no message still gets 481', () => {
+    const oper = makeOper();
+    oper.userModes.oper = false;
+    const ctx = makeCtx(oper);
+
+    const out = wallopsReducer(oper, wallops(), ctx);
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [
+        L(":irc.example.com 481 alice :Permission Denied - You're not an IRC operator"),
+      ]),
+    ]);
+  });
+
+  it('uses "*" as the nick in 481 when the connection has no nick', () => {
+    const oper = createConnection({ id: 'c1', connectedSince: 0 });
+    oper.userModes.oper = false;
+    const ctx = makeCtx(oper);
+
+    const out = wallopsReducer(oper, wallops('hi'), ctx);
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [
+        L(":irc.example.com 481 * :Permission Denied - You're not an IRC operator"),
+      ]),
+    ]);
+  });
+});
+
+describe('wallopsReducer — empty message (412 ERR_NOTEXTTOSEND)', () => {
+  it('emits 412 when no message parameter is supplied', () => {
+    const oper = makeOper();
+    const ctx = makeCtx(oper);
+
+    const out = wallopsReducer(oper, wallops(), ctx);
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(':irc.example.com 412 alice :No text to send')]),
+    ]);
+  });
+
+  it('emits 412 when the message is the empty string', () => {
+    const oper = makeOper();
+    const ctx = makeCtx(oper);
+
+    const out = wallopsReducer(oper, wallops(''), ctx);
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(':irc.example.com 412 alice :No text to send')]),
+    ]);
+  });
+
+  it('does not broadcast when the message is empty', () => {
+    const oper = makeOper();
+    const ctx = makeCtx(oper);
+
+    const out = wallopsReducer(oper, wallops(''), ctx);
+
+    expect(out.effects.some((e) => e.tag === 'BroadcastWallops')).toBe(false);
+  });
+
+  it('uses "*" as the nick in 412 when the connection has no nick', () => {
+    const oper = createConnection({ id: 'c1', connectedSince: 0 });
+    oper.registration = 'registered';
+    oper.userModes.oper = true;
+    const ctx = makeCtx(oper);
+
+    const out = wallopsReducer(oper, wallops(''), ctx);
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(':irc.example.com 412 * :No text to send')]),
+    ]);
+  });
+});

package/packages/irc-core/tests/dropped-s2s-and-obsolete-verbs.test.ts

@@ -0,0 +1,90 @@
+/**
+ * Regression guards for the formally-dropped S2S and obsolete RFC 2812 verbs.
+ *
+ * - S2S drop: `CONNECT` / `SQUIT` / `LINKS` are server-to-server commands.
+ *   S2S is an explicit PLAN non-goal (`PLAN.md` §1), so the three verbs are
+ *   formally dropped (they still return `421 ERR_UNKNOWNCOMMAND` — that is
+ *   the correct response for an unimplemented command). Their reserved
+ *   numerics (`RPL_LINKS`, `RPL_ENDOFLINKS`, `ERR_CANTKILLSERVER`) are removed
+ *   here.
+ *
+ * - Obsolete-verb drop: `SERVICE` / `SUMMON` / `USERS` are RFC 2812 verbs
+ *   that were never widely implemented and are effectively dead. They are
+ *   formally dropped (also still `421`). Their reserved numerics
+ *   (`RPL_YOURESERVICE`, `ERR_NOSUCHSERVICE`, `ERR_SUMMONDISABLED`,
+ *   `ERR_USERSDISABLED`) are removed here.
+ *
+ * Because the drop is "remove the numeric, keep the 421", there is no runtime
+ * behaviour to assert — these are source-level / registry-level regression
+ * guards that prevent the numerics (and the "deferred verb" framing) from
+ * creeping back in.
+ */
+
+import { describe, expect, it } from 'vitest';
+import { Numerics, numericToName } from '../src/protocol/numerics';
+import numericsSource from '../src/protocol/numerics.ts?raw';
+
+describe('dropped S2S verbs (CONNECT / SQUIT / LINKS)', () => {
+  // S2S is a PLAN non-goal; the three verbs are formally dropped. Their
+  // reserved numerics are removed from the registry.
+  const droppedS2SNumerics = ['RPL_LINKS', 'RPL_ENDOFLINKS', 'ERR_CANTKILLSERVER'] as const;
+
+  it.each(droppedS2SNumerics)('numerics.ts source no longer defines %s', (name) => {
+    expect(numericsSource).not.toContain(`${name}:`);
+  });
+
+  it.each(droppedS2SNumerics)('Numerics runtime object has no %s key', (name) => {
+    expect((Numerics as Record<string, unknown>)[name]).toBeUndefined();
+  });
+
+  it('numericToName no longer resolves the dropped S2S codes (364, 365, 483)', () => {
+    expect(numericToName.get(364)).toBeUndefined();
+    expect(numericToName.get(365)).toBeUndefined();
+    expect(numericToName.get(483)).toBeUndefined();
+  });
+
+  it('numerics.ts source documents the S2S drop', () => {
+    // The drop must be explained where the numerics used to live, so the
+    // absence is not mistaken for a gap.
+    expect(numericsSource).toMatch(/S2S/);
+    expect(numericsSource).toMatch(/PLAN non-goal/);
+  });
+
+  it('ERR_NOSUCHSERVER (402) is retained (used by LUSERS/STATS/TRACE)', () => {
+    // 402 stays because the implemented query verbs use it for remote-server
+    // gating.
+    expect(Numerics.ERR_NOSUCHSERVER).toBe(402);
+    expect(numericToName.get(402)).toBe('ERR_NOSUCHSERVER');
+  });
+});
+
+describe('dropped obsolete RFC 2812 verbs (SERVICE / SUMMON / USERS)', () => {
+  // RFC 2812 obsolete verbs, never widely implemented. Formally dropped;
+  // their reserved numerics are removed from the registry.
+  const droppedObsoleteNumerics = [
+    'RPL_YOURESERVICE',
+    'ERR_NOSUCHSERVICE',
+    'ERR_SUMMONDISABLED',
+    'ERR_USERSDISABLED',
+  ] as const;
+
+  it.each(droppedObsoleteNumerics)('numerics.ts source no longer defines %s', (name) => {
+    expect(numericsSource).not.toContain(`${name}:`);
+  });
+
+  it.each(droppedObsoleteNumerics)('Numerics runtime object has no %s key', (name) => {
+    expect((Numerics as Record<string, unknown>)[name]).toBeUndefined();
+  });
+
+  it('numericToName no longer resolves the dropped obsolete codes (383, 408, 445, 446)', () => {
+    expect(numericToName.get(383)).toBeUndefined();
+    expect(numericToName.get(408)).toBeUndefined();
+    expect(numericToName.get(445)).toBeUndefined();
+    expect(numericToName.get(446)).toBeUndefined();
+  });
+
+  it('numerics.ts source documents the obsolete-verb drop', () => {
+    expect(numericsSource).toMatch(/RFC 2812/);
+    expect(numericsSource).toMatch(/obsolete/);
+  });
+});

package/packages/irc-core/tests/effects.test.ts

@@ -82,6 +82,18 @@ describe('Effect constructors', () => {
       notFoundLines: [{ text: '401' }],
     });
   });
+
+  it('BroadcastWallops carries lines and optional except', () => {
+    expect(Effect.broadcastWallops([line(':a WALLOPS :hi')])).toEqual<EffectType>({
+      tag: 'BroadcastWallops',
+      lines: [{ text: ':a WALLOPS :hi' }],
+    });
+    expect(Effect.broadcastWallops([line(':a WALLOPS :hi')], 'c1')).toEqual<EffectType>({
+      tag: 'BroadcastWallops',
+      lines: [{ text: ':a WALLOPS :hi' }],
+      except: 'c1',
+    });
+  });
 });
 
 describe('Effect tag set', () => {
@@ -95,6 +107,7 @@ describe('Effect tag set', () => {
     'ReleaseNick',
     'ApplyChannelDelta',
     'SendToNick',
+    'BroadcastWallops',
   ];
 
   it.each(expectedTags)('exposes a constructor for the %s tag', (tag) => {
@@ -107,6 +120,7 @@ describe('Effect tag set', () => {
       ReleaseNick: Effect.releaseNick('n'),
       ApplyChannelDelta: Effect.applyChannelDelta('#c', { memberships: [] }),
       SendToNick: Effect.sendToNick('n', 'c', []),
+      BroadcastWallops: Effect.broadcastWallops([]),
     };
     expect(constructors[tag].tag).toBe(tag);
   });