serverless-ircd 0.6.0 → 0.8.0

package/packages/irc-core/tests/message-store.test.ts

@@ -528,3 +528,66 @@ describe('InMemoryMessageStore — query defensive branches', () => {
     ).toEqual([]);
   });
 });
+
+// ============================================================================
+// findAtOrBefore / getMsg — timestamp<->msgid translation for draft/read-marker
+// MARKREAD support. findAtOrBefore resolves a client-supplied server-time
+// timestamp to the most recent retained message at or before it; getMsg
+// resolves a stored marker msgid back to its message (for the echo + the
+// monotonicity check).
+// ============================================================================
+describe('InMemoryMessageStore — findAtOrBefore (timestamp -> message)', () => {
+  it('returns the message whose time equals the timestamp exactly', () => {
+    const store = seededStore(); // m1..m5 at 1_000..5_000
+    expect(store.findAtOrBefore('#foo', 3_000)?.msgid).toBe('m3');
+  });
+
+  it('returns the most recent message at or before an in-between timestamp', () => {
+    const store = seededStore();
+    // 3_500 is between m3 (3_000) and m4 (4_000); the marker resolves to m3.
+    expect(store.findAtOrBefore('#foo', 3_500)?.msgid).toBe('m3');
+  });
+
+  it('returns the newest message when the timestamp is at/after the last', () => {
+    const store = seededStore();
+    expect(store.findAtOrBefore('#foo', 9_999)?.msgid).toBe('m5');
+  });
+
+  it('returns undefined when the timestamp predates every retained message', () => {
+    const store = seededStore();
+    expect(store.findAtOrBefore('#foo', 500)).toBeUndefined();
+  });
+
+  it('returns undefined for a channel with no retained messages', () => {
+    const store = new InMemoryMessageStore();
+    expect(store.findAtOrBefore('#ghost', 1_000)).toBeUndefined();
+  });
+
+  it('folds the channel name case-insensitively', () => {
+    const store = seededStore();
+    expect(store.findAtOrBefore('#FOO', 2_000)?.msgid).toBe('m2');
+  });
+});
+
+describe('InMemoryMessageStore — getMsg (msgid -> message)', () => {
+  it('returns the message for a retained msgid', () => {
+    const store = seededStore();
+    expect(store.getMsg('#foo', 'm3')?.text).toBe('three');
+  });
+
+  it('returns undefined for an unknown msgid', () => {
+    const store = seededStore();
+    expect(store.getMsg('#foo', 'ghost')).toBeUndefined();
+  });
+
+  it('returns undefined for an evicted (no-longer-retained) msgid', () => {
+    const store = seededStore(3); // keeps m3..m5, evicts m1..m2
+    expect(store.getMsg('#foo', 'm1')).toBeUndefined();
+    expect(store.getMsg('#foo', 'm4')?.msgid).toBe('m4');
+  });
+
+  it('folds the channel name case-insensitively', () => {
+    const store = seededStore();
+    expect(store.getMsg('#FoO', 'm2')?.msgid).toBe('m2');
+  });
+});

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\\');
+  });
+});