atproto-room / test / label-base.test.mjs

// LabelBase — thin label-ops intent layer over an injected KV log (mock StateBase). Runtime-agnostic,
// no Bare/autobase needed (exactly like RepoBase). Run: node test/label-base.test.mjs
import { LabelBase, LABEL_NS } from '../lib/label-base.js'

const assert = (c, m) => { if (!c) { console.error('FAIL:', m); process.exit(1) } console.log('  ok -', m) }

// mock StateBase: a Map with async set/del/get/list(prefix)
function mockSb () {
  const m = new Map()
  return {
    async set (k, v) { m.set(k, v) },
    async del (k) { m.delete(k) },
    async get (k) { return m.has(k) ? m.get(k) : null },
    async list (prefix) { const o = {}; for (const [k, v] of m) if (k.startsWith(prefix)) o[k] = v; return o },
    _raw: m
  }
}

const sb = mockSb()
const lb = new LabelBase(sb, { src: 'did:plc:communitylabeler' })
const U1 = 'at://did:plc:a/app.bsky.feed.post/1'
const U2 = 'at://did:plc:a/app.bsky.feed.post/2'

await lb.label(U1, 'spam', { cts: '2026-07-01T00:00:00.000Z' })
await lb.label(U2, 'nsfw', { cts: '2026-07-02T00:00:00.000Z' })

let active = await lb.active()
assert(active.length === 2, 'two active label intents')
assert((await lb.labelsFor(U1)).some((l) => l.val === 'spam'), 'labelsFor(U1) -> spam')

// key namespacing
assert(sb._raw.has(LABEL_NS + '\x00' + U1 + '\x00' + 'spam'), 'intent stored under the label\\x00uri\\x00val key')

// negation: retract U1/spam
await lb.negate(U1, 'spam', { cts: '2026-07-05T00:00:00.000Z' })
active = await lb.active()
assert(active.length === 1 && active[0].uri === U2, 'negation removes U1/spam from active')
assert((await lb.intents()).length === 2, 'negated intent still present in intents() (signer emits neg)')
assert((await lb.intents()).some((i) => i.uri === U1 && i.neg === true), 'the U1/spam intent carries neg:true')

// reserved control keys (StateBase lease/members) are NOT surfaced as label intents
await sb.set('__lease__', { holder: 'mod-a', epoch: 1 })
await sb.set('__members__', { 'mod-a': 1 })
assert((await lb.intents()).length === 2, 'reserved __lease__/__members__ keys are excluded from intents')

// two mods labelling the same (uri,val) is idempotent (one key, LWW)
await lb.label(U2, 'nsfw', { cts: '2026-07-09T00:00:00.000Z' })
assert((await lb.active()).length === 1, 'same (uri,val) from another writer is one label (idempotent key)')

// guards
let threw = false; try { new LabelBase(sb, {}) } catch { threw = true }
assert(threw, 'constructor requires src (the labeler DID)')
threw = false; try { await lb.label('', 'x') } catch { threw = true }
assert(threw, 'label requires uri + val')

// ensure: the idempotent write a PROJECTOR needs (roster → member badges, re-run on every roster change).
// An unchanged state writes NOTHING and keeps its cts — a re-written cts is a NEW signed label in the
// content-keyed __label__ log, so a projector re-asserting its whole set would grow the log every pass.
{
  const s = mockSb()
  const e = new LabelBase(s, { src: 'did:plc:l' })
  let writes = 0
  const set = s.set; s.set = async (k, v) => { writes++; return set(k, v) }
  const D = 'did:plc:member'
  const a = await e.ensure(D, 'loser-club-member', { cts: '2026-10-13T00:00:00.000Z' })
  assert(a.changed === true && writes === 1, 'ensure: a new label is written')
  const b = await e.ensure(D, 'loser-club-member', { cts: '2026-10-14T00:00:00.000Z' })
  assert(b.changed === false && writes === 1, 'ensure: the same state again writes nothing')
  assert(b.intent.cts === '2026-10-13T00:00:00.000Z', 'ensure: and keeps the original cts')
  const c = await e.ensure(D, 'loser-club-member', { neg: true, cts: '2026-10-15T00:00:00.000Z' })
  assert(c.changed === true && c.intent.neg === true && writes === 2, 'ensure: a negation is a change')
  const d = await e.ensure(D, 'loser-club-member', { neg: true })
  assert(d.changed === false && writes === 2, 'ensure: negating an already-negated label writes nothing')
  const f = await e.ensure('did:plc:never', 'loser-club-member', { neg: true })
  assert(f.changed === false && f.intent === null && writes === 2, 'ensure: negating a label that never existed writes nothing')
}

console.log('\nLABEL-BASE OK: label/negate intents over an injected KV log; active vs intents; reserved-key exclusion')