serverless-ircd 0.6.0 → 0.7.0

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

@@ -34,6 +34,21 @@ describe('wrapBatch — framing', () => {
     expect(out).toEqual<RawLine[]>([]);
   });
 
+  it('returns an empty BatchFrame carrying the framing metadata when lines is empty', () => {
+    // Empty batches are spec-forbidden and silently elided, but the returned
+    // array still advertises the id/type/start/body/end surface so callers
+    // can read the framing shape without a special-case branch.
+    const empty = wrapBatch([], 'ref7', 'chathistory', '#foo');
+    expect(empty).toHaveLength(0);
+    expect(empty.id).toBe('ref7');
+    expect(empty.type).toBe('chathistory');
+    expect(empty.start).toEqual({ text: '' });
+    expect(empty.body).toEqual([]);
+    expect(empty.end).toEqual({ text: '' });
+    // Non-enumerable props must not leak into JSON serialization.
+    expect(JSON.stringify(empty)).toBe('[]');
+  });
+
   it('preserves the order of the inner lines', () => {
     const lines = [L('one'), L('two'), L('three'), L('four')];
     const out = wrapBatch(lines, 'x', 'test');

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

@@ -162,6 +162,19 @@ describe('numericToName', () => {
   it('returns undefined for an unregistered code', () => {
     expect(numericToName.get(600)).toBeUndefined();
   });
+
+  it('round-trips every entry in the Numerics registry (reverse-lookup parity)', () => {
+    // Pin the map-construction arrow function: every [name, code] pair in
+    // the forward table MUST appear inverted in numericToName. A mutated
+    // mapper (e.g. `() => undefined`) would leave the reverse table empty
+    // or fail to construct, which this exhaustive check catches.
+    const entries = Object.entries(Numerics) as ReadonlyArray<[NumericCode, number]>;
+    expect(entries.length).toBeGreaterThan(0);
+    for (const [name, code] of entries) {
+      expect(numericToName.get(code)).toBe(name);
+    }
+    expect(numericToName.size).toBe(entries.length);
+  });
 });
 
 describe('isNumericCommand', () => {

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

@@ -133,31 +133,58 @@ describe('parse — framing tolerance', () => {
   it('strips a lone trailing LF', () => {
     expect(parse('PING :tok\n').params).toEqual(['tok']);
   });
+
+  it('preserves CR/LF that appears inside the trailing param', () => {
+    // The CR/LF strip regex is anchored to the END of the line only; a CR/LF
+    // embedded in a trailing param must survive into the parsed value.
+    expect(parse('PRIVMSG #foo :a\rb').params[1]).toBe('a\rb');
+    expect(parse('PRIVMSG #foo :a\nb').params[1]).toBe('a\nb');
+  });
 });
 
 describe('parse — malformed input', () => {
+  // Each case asserts both the error class AND the diagnostic message text.
+  // The message assertion is what pins the failure to the *correct* guard:
+  // several guards fall through to a sibling throw of the same class, so a
+  // bare `toThrow(IrcParseError)` would miss removed/disabled guards.
+
   it('throws IrcParseError on empty input', () => {
     expect(() => parse('')).toThrow(IrcParseError);
+    expect(() => parse('')).toThrow('empty message');
   });
 
   it('throws IrcParseError on whitespace-only input', () => {
     expect(() => parse('   ')).toThrow(IrcParseError);
+    expect(() => parse('   ')).toThrow('invalid command token');
   });
 
   it('throws IrcParseError when only a source prefix is present', () => {
     expect(() => parse(':nick!user@host')).toThrow(IrcParseError);
+    expect(() => parse(':nick!user@host')).toThrow('source prefix with no command');
   });
 
   it('throws IrcParseError when a source is followed by no command', () => {
     expect(() => parse(':irc.example.com   ')).toThrow(IrcParseError);
+    expect(() => parse(':irc.example.com   ')).toThrow('missing command');
   });
 
   it('throws IrcParseError when a tag section has no body', () => {
     expect(() => parse('@time=now')).toThrow(IrcParseError);
+    expect(() => parse('@time=now')).toThrow('tag section with no message body');
   });
 
   it('throws IrcParseError on an invalid command token', () => {
     expect(() => parse('12 hi')).toThrow(IrcParseError);
+    expect(() => parse('12 hi')).toThrow('invalid command token');
+  });
+
+  it('sets the error `name` to "IrcParseError" for instanceof-equivalent checks', () => {
+    try {
+      parse('');
+      expect.fail('expected parse to throw');
+    } catch (err) {
+      expect((err as Error).name).toBe('IrcParseError');
+    }
   });
 });
 
@@ -203,3 +230,85 @@ describe('parse — RFC 1459 §2.3 input line-length cap', () => {
     }
   });
 });
+
+describe('parse — command token grammar (anchored regex)', () => {
+  // COMMAND_RE is anchored at both ends (^...$). A command token must be
+  // EITHER all letters OR exactly three digits — mixed alphanumerics are a
+  // protocol violation. These tests pin both anchors: removing ^ or $
+  // would let the partial-match mutations through.
+
+  it('rejects a command token with trailing digits (end anchor)', () => {
+    expect(() => parse('PRIVMSG123 #foo :hi')).toThrow(IrcParseError);
+  });
+
+  it('rejects a command token with leading digits (start anchor)', () => {
+    expect(() => parse('123PRIVMSG #foo :hi')).toThrow(IrcParseError);
+  });
+
+  it('rejects a two-digit numeric command (length pin)', () => {
+    expect(() => parse('12 #foo')).toThrow(IrcParseError);
+  });
+});
+
+describe('parse — source prefix shape (strict property presence)', () => {
+  // `user` and `host` must be ABSENT (not merely `undefined`) when the
+  // source has no `!user` / `@host` component. `toEqual` ignores
+  // undefined-valued properties, so these mutants would survive a normal
+  // equality check; `toStrictEqual` does not.
+
+  it('omits user AND host from a bare-servername source', () => {
+    expect(parse(':irc.example.com NOTICE * :hi').source).toStrictEqual({
+      name: 'irc.example.com',
+    });
+  });
+
+  it('omits host from a nick!user source (no @host)', () => {
+    expect(parse(':nick!user PRIVMSG #foo :hi').source).toStrictEqual({
+      name: 'nick',
+      user: 'user',
+    });
+  });
+
+  it('omits user from a nick@host source (no !user)', () => {
+    expect(parse(':nick@host PRIVMSG #foo :hi').source).toStrictEqual({
+      name: 'nick',
+      host: 'host',
+    });
+  });
+
+  it('does not set a source property on a source-less message', () => {
+    const msg = parse('PRIVMSG #foo :hi');
+    expect('source' in msg).toBe(false);
+  });
+});
+
+describe('parse — middle parameter whitespace collapsing', () => {
+  it('drops empty params produced by runs of spaces between middles', () => {
+    // The split-then-filter pipeline removes the empty strings that
+    // consecutive spaces generate. Removing the filter (or mutating the
+    // predicate to a tautology) would leak '' entries here.
+    expect(parse(':nick JOIN #a  #b').params).toEqual(['#a', '#b']);
+    expect(parse(':nick JOIN  #a   #b ').params).toEqual(['#a', '#b']);
+  });
+});
+
+describe('unescapeTagValue — boundary conditions', () => {
+  // Imported indirectly through parse() tag values; these pin the loop
+  // bounds so off-by-one mutations on the backslash lookahead can't survive.
+
+  it('keeps a lone trailing backslash verbatim', () => {
+    // `\` at the end with no following char must not read past the end of
+    // the string and must be emitted literally.
+    expect(parse('@a=foo\\ PRIVMSG #foo :hi').tags.a).toBe('foo\\');
+    expect(parse('@a=\\ PRIVMSG #foo :hi').tags.a).toBe('\\');
+  });
+
+  it('handles a tag value that is only a backslash', () => {
+    expect(parse('@a=\\ PRIVMSG #foo :hi').tags.a).toBe('\\');
+  });
+
+  it('decodes a trailing escape sequence with no following character partially', () => {
+    // A complete `\\` pair decodes to a single backslash.
+    expect(parse('@a=x\\\\ PRIVMSG #foo :hi').tags.a).toBe('x\\');
+  });
+});

package/packages/irc-server/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@serverless-ircd/irc-server",
-  "version": "0.6.0",
+  "version": "0.7.0",
   "private": true,
   "description": "Orchestration layer: IrcRuntime port, dispatch interpreter, ConnectionActor",
   "license": "BSD-3-Clause",

package/packages/irc-test-support/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@serverless-ircd/irc-test-support",
-  "version": "0.6.0",
+  "version": "0.7.0",
   "private": true,
   "description": "Shared IRC scenario runner + harness seam used by every adapter's integration suite",
   "license": "BSD-3-Clause",

package/packages/irc-test-support/src/scenarios.ts

@@ -48,6 +48,21 @@ export function runIrcScenarios(factories: readonly IrcHarnessFactory[]): void {
     return undefined;
   }
 
+  /**
+   * Numeric error codes that PRIVMSG/NOTICE rejection paths would emit
+   * (401 nick-target only). RFC: NOTICE MUST NOT generate any of these.
+   * Used by the NOTICE scenario so a late-arriving MOTD/welcome numeric
+   * (e.g. 376) on a slow transport does not false-positive the check.
+   */
+  const NOTICE_ERROR_CODES: ReadonlySet<string> = new Set([
+    '401', // ERR_NOSUCHNICK
+    '403', // ERR_NOSUCHCHANNEL
+    '404', // ERR_CANNOTSENDTOCHAN
+    '411', // ERR_NORECIPIENT
+    '412', // ERR_NOTEXTTOSEND
+    '442', // ERR_NOTONCHANNEL
+  ]);
+
   /**
    * Synchronization helper: alice (already in #chan) waits until she sees
    * bob's JOIN broadcast. By the time this resolves, the runtime has also
@@ -442,8 +457,15 @@ export function runIrcScenarios(factories: readonly IrcHarnessFactory[]): void {
         bob.received.length = 0;
         await alice.send('NOTICE #notice :quiet note');
         await bob.waitForLine((l) => l.includes('NOTICE #notice :quiet note'));
-        const numericAfterNotice = alice.received.some((l) => numericOf(l) !== undefined);
-        expect(numericAfterNotice).toBe(false);
+        // RFC: NOTICE MUST NOT generate an error reply. Check only the
+        // NOTICE-relevant error numerics — not any numeric — so a delayed
+        // MOTD/welcome line draining through a slow transport (e.g. the CF
+        // WebSocket pool under load) does not false-positive the assertion.
+        const noticeErrors = alice.received.filter((l) => {
+          const code = numericOf(l);
+          return code !== undefined && NOTICE_ERROR_CODES.has(code);
+        });
+        expect(noticeErrors).toEqual([]);
         await harness.close();
       });
 

package/tools/ci-hardening/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@serverless-ircd/ci-hardening",
-  "version": "0.6.0",
+  "version": "0.7.0",
   "private": true,
   "description": "CI hardening helpers: coverage-gate config validator + mutation-testing driver for irc-core",
   "license": "BSD-3-Clause",

package/tools/load-test/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@serverless-ircd/load-test",
-  "version": "0.6.0",
+  "version": "0.7.0",
   "private": true,
   "description": "Synthetic WebSocket IRC client farm for load testing ServerlessIRCd (concurrency, latency p50/p95/p99, drop rate)",
   "license": "BSD-3-Clause",

package/tools/tcp-ws-forwarder/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@serverless-ircd/tcp-ws-forwarder",
-  "version": "0.6.0",
+  "version": "0.7.0",
   "private": true,
   "description": "Local TCP to ws/wss forwarder so standard IRC clients can reach the WebSocket-only ServerlessIRCd transport",
   "license": "BSD-3-Clause",