joshandClaude Opus 4.7
d21e8187ff
The raw hex dump showed Plutonium T5's `status` reply is a 9-column
format, not the 5-column shape the parser assumed:
num score ping guid name lastmsg address qport rate
--- ----- ---- ------- ---------------- ------- --------------------- ----- -----
0 3040 36 2741626 JoshWright^7 0 68.235.46.100:28960 -14733 25000
Three bugs in the old regex: it required 16+ hex chars for guid (T5
uses 7-digit decimal IDs), it expected name to run to end-of-line
(4 trailing columns get glued on), and it left Plutonium color codes
(^0..^9) in the rendered name.
Rewrote parsePlayerRoster to detect column boundaries from the header
line word positions instead — column N runs from word N's start to
word N+1's start, matching how CoD's status output actually lays out
(values borrow the padding between adjacent columns). Same code path
handles the old 5-column format and the T5 9-column format cleanly.
stripColorCodes() removes ^\d sequences from names in both dialects.
PlayerRoster component only appends `…` when the guid is actually
long enough to need truncation.
Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>
226 lines
8.2 KiB
TypeScript
226 lines
8.2 KiB
TypeScript
import { describe, expect, it } from 'vitest';
|
|
import {
|
|
parseInfoLine,
|
|
parsePlayerCount,
|
|
parsePlayerRoster,
|
|
parseStatusHeader,
|
|
formatRawReply
|
|
} from '../../src/lib/server/integrations/rcon.js';
|
|
|
|
describe('parsePlayerCount', () => {
|
|
it('counts rows after --- --- separator (status dialect)', () => {
|
|
const body = [
|
|
'print',
|
|
'map: mp_kino',
|
|
'num score ping guid name',
|
|
'--- ----- ---- -------- ----',
|
|
' 0 12 45 abc123def456 joe',
|
|
' 1 0 72 xyz789abc123 jill',
|
|
' 2 999 30 111222333444 kade'
|
|
].join('\n');
|
|
expect(parsePlayerCount(body)).toBe(3);
|
|
});
|
|
|
|
it('returns 0 when the scoreboard has no rows', () => {
|
|
const body = [
|
|
'print',
|
|
'map: mp_ascension',
|
|
'num score ping guid name',
|
|
'--- ----- ---- -------- ----',
|
|
''
|
|
].join('\n');
|
|
expect(parsePlayerCount(body)).toBe(0);
|
|
});
|
|
|
|
it('counts non-blank lines after the info line (statusResponse dialect)', () => {
|
|
const body = [
|
|
'statusResponse',
|
|
'\\mapname\\mp_kino\\g_gametype\\zom\\sv_maxclients\\4',
|
|
'10 45 "joe"',
|
|
'0 72 "jill"'
|
|
].join('\n');
|
|
expect(parsePlayerCount(body)).toBe(2);
|
|
});
|
|
|
|
it('returns null on malformed payloads with no separator or info line', () => {
|
|
expect(parsePlayerCount('nonsense body\nno structure here')).toBeNull();
|
|
});
|
|
});
|
|
|
|
describe('parseInfoLine', () => {
|
|
it('splits \\key\\value pairs from an info string', () => {
|
|
const body = [
|
|
'statusResponse',
|
|
'\\mapname\\mp_kino\\g_gametype\\zom\\sv_maxclients\\4'
|
|
].join('\n');
|
|
const info = parseInfoLine(body);
|
|
expect(info.mapname).toBe('mp_kino');
|
|
expect(info.g_gametype).toBe('zom');
|
|
expect(info.sv_maxclients).toBe('4');
|
|
});
|
|
|
|
it('returns empty object when no info line is present', () => {
|
|
expect(parseInfoLine('nothing here')).toEqual({});
|
|
});
|
|
});
|
|
|
|
describe('parsePlayerRoster', () => {
|
|
it('extracts num/score/ping/guid/name from print dialect', () => {
|
|
const body = [
|
|
'print',
|
|
'map: mp_kino',
|
|
'num score ping guid name',
|
|
'--- ----- ---- -------- ----',
|
|
' 0 12 45 aaaaaaaabbbbbbbbccccccccdddddddd joe',
|
|
' 1 0 72 11112222333344445555666677778888 jill h.',
|
|
' 2 999 128 abcdef0123456789abcdef0123456789 Toaster'
|
|
].join('\n');
|
|
const roster = parsePlayerRoster(body);
|
|
expect(roster).toHaveLength(3);
|
|
expect(roster[0]).toEqual({
|
|
num: 0,
|
|
score: 12,
|
|
ping: 45,
|
|
guid: 'aaaaaaaabbbbbbbbccccccccdddddddd',
|
|
name: 'joe'
|
|
});
|
|
// Names with spaces stay intact
|
|
expect(roster[1].name).toBe('jill h.');
|
|
expect(roster[2].ping).toBe(128);
|
|
});
|
|
|
|
it('extracts score/ping/quoted-name from statusResponse dialect', () => {
|
|
const body = [
|
|
'statusResponse',
|
|
'\\mapname\\mp_kino\\g_gametype\\zclassic',
|
|
'10 45 "joe"',
|
|
'0 72 "jill h."'
|
|
].join('\n');
|
|
const roster = parsePlayerRoster(body);
|
|
expect(roster).toHaveLength(2);
|
|
expect(roster[0]).toEqual({
|
|
num: null,
|
|
score: 10,
|
|
ping: 45,
|
|
guid: null,
|
|
name: 'joe'
|
|
});
|
|
expect(roster[1].name).toBe('jill h.');
|
|
});
|
|
|
|
it('returns empty array when no rows are present', () => {
|
|
const empty = [
|
|
'print',
|
|
'map: mp_ascension',
|
|
'num score ping guid name',
|
|
'--- ----- ---- -------- ----'
|
|
].join('\n');
|
|
expect(parsePlayerRoster(empty)).toEqual([]);
|
|
expect(parsePlayerRoster('nonsense')).toEqual([]);
|
|
});
|
|
|
|
it('parses Plutonium T5 9-column status with numeric GUID + color-coded name', () => {
|
|
// Verbatim shape from a real T5 status reply — 7-digit GUID (not hex),
|
|
// 4 trailing columns after name (lastmsg, address, qport, rate),
|
|
// and Plutonium color code (^7) in the name.
|
|
const body = [
|
|
'print',
|
|
'map: zombie_cosmodrome',
|
|
'num score ping guid name lastmsg address qport rate',
|
|
'--- ----- ---- ------- ---------------- ------- -------------------------- ----- -----',
|
|
' 0 3040 36 2741626 JoshWright^7 0 68.235.46.100:28960 -14733 25000'
|
|
].join('\n');
|
|
const roster = parsePlayerRoster(body);
|
|
expect(roster).toHaveLength(1);
|
|
expect(roster[0]).toEqual({
|
|
num: 0,
|
|
score: 3040,
|
|
ping: 36,
|
|
guid: '2741626',
|
|
name: 'JoshWright' // ^7 stripped
|
|
});
|
|
});
|
|
|
|
it('preserves multi-word names in the 9-column format', () => {
|
|
const body = [
|
|
'print',
|
|
'map: mp_kino',
|
|
'num score ping guid name lastmsg address qport rate',
|
|
'--- ----- ---- ------- ---------------- ------- --------------------- ----- -----',
|
|
' 1 500 48 8675309 Jenny Two Names 0 10.0.0.5:28960 -12345 25000'
|
|
].join('\n');
|
|
const roster = parsePlayerRoster(body);
|
|
expect(roster).toHaveLength(1);
|
|
expect(roster[0].name).toBe('Jenny Two Names');
|
|
});
|
|
|
|
it('strips color codes from statusResponse-dialect names too', () => {
|
|
const body = [
|
|
'statusResponse',
|
|
'\\mapname\\mp_kino\\g_gametype\\zclassic',
|
|
'10 45 "^1Red^7Player"'
|
|
].join('\n');
|
|
const roster = parsePlayerRoster(body);
|
|
expect(roster[0].name).toBe('RedPlayer');
|
|
});
|
|
});
|
|
|
|
describe('parseStatusHeader', () => {
|
|
it('extracts key:value header lines from a Plutonium status body', () => {
|
|
const body = [
|
|
'print',
|
|
'map: mp_kino',
|
|
'num score ping guid name',
|
|
'--- ----- ---- -------- ----',
|
|
' 0 12 45 abc123def456 joe'
|
|
].join('\n');
|
|
const h = parseStatusHeader(body);
|
|
expect(h.map).toBe('mp_kino');
|
|
// Header keys stop at the scoreboard — guids/names must not leak in.
|
|
expect(h.abc123def456).toBeUndefined();
|
|
});
|
|
|
|
it('handles builds that include gametype or other dvars in the header', () => {
|
|
const body = [
|
|
'print',
|
|
'map: mp_ascension',
|
|
'gametype: zclassic',
|
|
'sv_maxclients: 4',
|
|
'--- --- ---',
|
|
''
|
|
].join('\n');
|
|
const h = parseStatusHeader(body);
|
|
expect(h.map).toBe('mp_ascension');
|
|
expect(h.gametype).toBe('zclassic');
|
|
expect(h.sv_maxclients).toBe('4');
|
|
});
|
|
|
|
it('returns empty object for a statusResponse (no colon header)', () => {
|
|
const body = [
|
|
'statusResponse',
|
|
'\\mapname\\mp_kino\\g_gametype\\zclassic',
|
|
'10 45 "joe"'
|
|
].join('\n');
|
|
expect(parseStatusHeader(body)).toEqual({});
|
|
});
|
|
});
|
|
|
|
describe('formatRawReply', () => {
|
|
it('renders a small buffer as hex + printable ASCII with an offset', () => {
|
|
const buf = Buffer.from([0xff, 0xff, 0xff, 0xff, 0x70, 0x72, 0x69, 0x6e, 0x74, 0x0a]);
|
|
const out = formatRawReply(buf);
|
|
expect(out).toContain('0000');
|
|
expect(out).toContain('ff ff ff ff 70 72 69 6e 74 0a');
|
|
// Non-printable prefix bytes render as `.`; the printable tail spells "print".
|
|
expect(out).toContain('....print.');
|
|
});
|
|
|
|
it('splits into 16-byte rows and truncates past the limit', () => {
|
|
const buf = Buffer.alloc(600, 0x41); // "A" repeated
|
|
const out = formatRawReply(buf);
|
|
const lines = out.split('\n');
|
|
expect(lines.length).toBeGreaterThan(1);
|
|
expect(lines[lines.length - 1]).toMatch(/more bytes/);
|
|
});
|
|
});
|