Module-Rust/client/test/feed.test.js

// ── The feed's sentences ──────────────────────────────────────────────────
//
// `lib/feed.js` is the one part of the client half with real branching in it, and
// it is pure on purpose so that a DOM-less runner can ask all of it. Everything
// here is a claim about what a reader sees for a given frame — which is exactly
// the kind of thing that rots silently, because a wrong killfeed line is still a
// killfeed line.
//
// The fixtures are the frames the bridge plugin actually emits (its
// `DescribeAttacker`, and PROTOCOL.md §8.4), not invented shapes.

import test from 'node:test'
import assert from 'node:assert/strict'
import { createRequire } from 'node:module'

import { describe, FEED_KINDS, FILTERS, kindsFor } from '../src/lib/feed.js'

const row = (kind, frame = {}) => ({ id: 1, kind, t: Date.now(), wipeId: 'w1', steamId: '7656', frame })

test('a player kill names the killer and the victim, in that order', () => {
  const line = describe(row('player.death', {
    name: 'Bob',
    attackerType: 'player',
    attackerName: 'Alice',
    weapon: 'rifle.ak',
    distance: 42.4,
    grid: 'H7',
  }))

  assert.equal(line.tone, 'kill')
  assert.equal(line.actor, 'Alice')
  assert.equal(line.verb, 'killed')
  assert.equal(line.subject, 'Bob')
  assert.match(line.detail, /rifle ak/)
  assert.match(line.detail, /42m/)
  assert.match(line.detail, /H7/)
})

test('the four attacker types are four different sentences', () => {
  // The plugin distinguishes them precisely so a reader does not have to guess
  // from an absent field, and collapsing any two loses something: a fall reported
  // as a kill by nobody is the failure this prevents.
  const victim = { name: 'Bob' }

  const npc = describe(row('player.death', { ...victim, attackerType: 'npc', attackerName: 'scientistnpc_full_any' }))
  assert.equal(npc.actor, 'scientistnpc full any')
  assert.equal(npc.subject, 'Bob')

  const self = describe(row('player.death', { ...victim, attackerType: 'self' }))
  assert.equal(self.actor, 'Bob')
  assert.equal(self.subject, null)
  assert.match(self.verb, /own hand/)

  const environment = describe(row('player.death', { ...victim, attackerType: 'environment' }))
  assert.equal(environment.actor, 'Bob')
  assert.equal(environment.verb, 'died')
  assert.equal(environment.subject, null)

  // `HitInfo` is legitimately null on the environment path, so a death frame with
  // NO attacker type at all is that case — not a missing field to render around.
  const bare = describe(row('player.death', victim))
  assert.equal(bare.verb, 'died')
  assert.equal(bare.subject, null)
})

test('a sleeping victim is said to have been sleeping', () => {
  const line = describe(row('player.death', { name: 'Bob', attackerType: 'player', attackerName: 'Alice', sleeping: true }))
  assert.match(line.detail, /while sleeping/)
})

test('a disconnect with no session length says nothing about one', () => {
  // The plugin OMITS `sessionSec` for a player who was already on when it loaded:
  // an unknown session is not a session of no length. A line reading "after 0s"
  // would be a lie this module invented.
  const unknown = describe(row('player.disconnected', { name: 'Bob', reason: 'Quit' }))
  assert.equal(unknown.detail, 'Quit')

  const known = describe(row('player.disconnected', { name: 'Bob', reason: 'Quit', sessionSec: 3720 }))
  assert.equal(known.detail, 'Quit · after 1h 2m')
})

test('a chat line carries the message as text, never as markup', () => {
  // The message is the one field on this wire whose bytes a player chooses. It
  // comes back as a STRING and is rendered as a React child, which escapes it;
  // this test is here so that a later "render the message with formatting" idea
  // has to delete an explicit assertion rather than quietly change behaviour.
  const line = describe(row('player.chat', { name: 'Bob', message: '<img src=x onerror=alert(1)>', channel: 'Global' }))
  assert.equal(line.verb, '<img src=x onerror=alert(1)>')
  assert.equal(typeof line.verb, 'string')
  // Global is the default channel and saying so on every line is noise; Team is
  // information.
  assert.equal(line.detail, '')
  assert.equal(describe(row('player.chat', { name: 'B', message: 'hi', channel: 'Team' })).detail, 'Team')

  // A chat row is the one line where the actor is a speaker rather than a
  // subject, and "Brannock see you in september" is not a sentence anybody
  // writes. The colon is presentation, so it lives here and not inside the text
  // the player typed.
  assert.equal(line.join, ': ')
  assert.equal(describe(row('player.connected', { name: 'B' })).join, undefined)
})

test('an unknown kind renders as itself rather than vanishing', () => {
  // A later protocol adds kinds, and a module may be older than the game host it
  // is reading. The server's allowlist has already decided the row may be seen;
  // dropping it here would make the page quietly say less than the truth.
  const line = describe(row('player.teleported', { name: 'Bob' }))
  assert.equal(line.verb, 'player.teleported')
  assert.equal(line.tone, 'other')
})

test('the feed never asks for the aggregate kind', () => {
  // `player.tally` is public and is flushed once a minute per active player
  // (§8.6). A feed that included it would be mostly wood counts; it is the
  // leaderboard's input, and that is where it shows up.
  assert.ok(!FEED_KINDS.includes('player.tally'))
  for (const filter of FILTERS) {
    for (const kind of filter.kinds) {
      assert.ok(FEED_KINDS.includes(kind), `filter "${filter.id}" asks for ${kind}, which the feed does not carry`)
    }
  }
})

test('every kind the feed asks for is one the public route will serve', () => {
  // Held against the module's own allowlist rather than against a copy of it: a
  // kind this file asked for and `server/catalogue.js` refuses is a filter that
  // silently returns nothing, which reads as a quiet server.
  //
  // A CommonJS file from the server half, read by an ESM test through
  // `createRequire`. Crossing the two halves is fine HERE and nowhere else:
  // `test/` is not shipped, and `scripts/checkImports.js` governs what is.
  const catalogue = createRequire(import.meta.url)('../../server/catalogue.js')
  for (const kind of FEED_KINDS) {
    assert.ok(catalogue.PUBLIC_KINDS.includes(kind), `the feed asks for ${kind}, which is not public`)
  }
})

test('an unknown filter falls back to everything rather than to nothing', () => {
  assert.deepEqual(kindsFor('nonsense'), FEED_KINDS)
  assert.deepEqual(kindsFor(undefined), FEED_KINDS)
})