Files
commander/backend/test/source.test.ts
2026-10-29 15:21:05 +01:00

195 lines
7.0 KiB
TypeScript

import assert from 'node:assert/strict'
import { mkdtemp, rm } from 'node:fs/promises'
import { tmpdir } from 'node:os'
import { join } from 'node:path'
import test from 'node:test'
import type { Card } from '../src/cards.js'
import { formatCard } from '../src/effects/format.js'
import {
compileImplementation,
deleteOverride,
readAllOverrides,
readOverride,
writeOverride,
} from '../src/effects/implementations.js'
import { parseCardSource, SourceParseError } from '../src/effects/source.js'
const CARD: Card = {
oracle_id: '00000000-0000-4000-8000-000000000001',
name: 'Test Card',
layout: 'normal',
cmc: 1,
type_line: 'Creature — Human',
colors: [],
color_identity: [],
keywords: [],
}
const SOURCE = `export default [
triggered(when.enters(self), [
modal(1, 1, [
[
exile(target(permanents.withType('creature').other().ownedBy('you'))),
schedule('next_end_step', [returnToBattlefield(previousTarget)]),
],
]),
]),
staticAbility([
grantAbility(each(permanents.withType('land').enchanted()), triggered(when.upkeep(you), [
pay([manaCost('{W}{W}')]),
ifThen(ifYouDo(), [gainLife(you, 1)]),
], { optional: true })),
]),
]`
test('card source round-trips through the compiler and formatter', () => {
const compiled = compileImplementation(CARD, SOURCE)
assert.equal(compiled.manual, true)
assert.equal(compiled.status, 'supported')
assert.equal(compiled.typeLine, CARD.type_line)
const rendered = formatCard(compiled)
assert.match(rendered, /export default card\('Creature — Human', \[/)
const reparsed = compileImplementation(CARD, rendered)
assert.equal(formatCard(reparsed), rendered)
assert.equal(reparsed.typeLine, CARD.type_line)
assert.equal(reparsed.abilities.length, 2)
const [triggered] = reparsed.abilities
assert.equal(triggered.kind, 'triggered')
if (triggered.kind !== 'triggered') return
assert.equal(triggered.effects[0].op, 'modal')
if (triggered.effects[0].op !== 'modal') return
assert.equal(triggered.effects[0].modes[0][1].op, 'schedule')
const staticAbility = reparsed.abilities[1]
assert.equal(staticAbility.kind, 'static')
if (staticAbility.kind !== 'static') return
assert.equal(staticAbility.effects[0].op, 'grant_ability')
if (staticAbility.effects[0].op !== 'grant_ability') return
assert.equal(staticAbility.effects[0].ability.kind, 'triggered')
})
test('card source declares the card type line for the engine', () => {
const compiled = compileImplementation(CARD, `export default card('Artifact Creature — Golem', [keyword('Vigilance')])`)
assert.equal(compiled.typeLine, 'Artifact Creature — Golem')
assert.match(formatCard(compiled), /export default card\('Artifact Creature — Golem', \[/)
})
test('multi-face card source declares one type line per face', () => {
const faces: Card = {
...CARD,
layout: 'transform',
card_faces: [
{ name: 'Front', type_line: 'Sorcery', colors: [] },
{ name: 'Back', type_line: 'Creature — Human', colors: [] },
],
}
const source = `export default faces(
face('Front', 'Instant', [spell([draw(you, 2)])]),
face('Back', 'Creature — Human', [keyword('Flying')]),
)`
const compiled = compileImplementation(faces, source)
assert.deepEqual(compiled.faces?.map(face => face.typeLine), ['Instant', 'Creature — Human'])
const rendered = formatCard(compiled)
assert.equal(formatCard(compileImplementation(faces, rendered)), rendered)
})
test('effect lists accept callbacks in place of arrays', () => {
const CALLBACK_SOURCE = `export default [
triggered(when.enters(self), () => draw(you, 1)),
triggered(when.dies(self), () => {
draw(you, 1)
gainLife(you, 1);
}),
staticAbility(() => staticPump(each(creatures.youControl()), 1, 1)),
spell([
modal(1, 1, [
() => draw(you, 2),
() => { gainLife(you, 3) },
]),
]),
]`
const compiled = compileImplementation(CARD, CALLBACK_SOURCE)
assert.equal(compiled.status, 'supported')
const [enters, dies, staticAbility, spell] = compiled.abilities
assert.equal(enters.kind, 'triggered')
if (enters.kind !== 'triggered') return
assert.deepEqual(enters.effects.map(effect => effect.op), ['draw'])
assert.equal(dies.kind, 'triggered')
if (dies.kind !== 'triggered') return
assert.deepEqual(dies.effects.map(effect => effect.op), ['draw', 'life'])
assert.equal(staticAbility.kind, 'static')
if (staticAbility.kind !== 'static') return
assert.deepEqual(staticAbility.effects.map(effect => effect.op), ['pump'])
assert.equal(spell.kind, 'spell')
if (spell.kind !== 'spell') return
assert.equal(spell.effects[0].op, 'modal')
if (spell.effects[0].op !== 'modal') return
assert.deepEqual(spell.effects[0].modes.map(mode => mode.map(effect => effect.op)), [['draw'], ['life']])
})
test('invalid source reports its line', () => {
assert.throws(
() => parseCardSource('export default [\n draw(you)\n]'),
(error: unknown) => error instanceof SourceParseError && error.line === 2,
)
})
test('unknown AST discriminants are rejected', () => {
assert.throws(
() => parseCardSource("export default [spell([{ op: 'nope' }])]"),
(error: unknown) => error instanceof SourceParseError && /expected an effect/.test(error.message),
)
assert.throws(
() => parseCardSource("export default [{ kind: 'nope' }]"),
(error: unknown) => error instanceof SourceParseError && /expected an ability/.test(error.message),
)
assert.throws(
() => parseCardSource("export default [triggered(when.nope(self), [])]"),
(error: unknown) => error instanceof SourceParseError,
)
})
test('manual implementations persist one file per card', async (t) => {
const dir = await mkdtemp(join(tmpdir(), 'commander-overrides-'))
const previous = process.env.CARD_OVERRIDES_DIR
process.env.CARD_OVERRIDES_DIR = dir
t.after(async () => {
if (previous === undefined) delete process.env.CARD_OVERRIDES_DIR
else process.env.CARD_OVERRIDES_DIR = previous
await rm(dir, { recursive: true, force: true })
})
await writeOverride(CARD.oracle_id, SOURCE)
const stored = await readOverride(CARD.oracle_id)
assert.equal(stored?.source, `${SOURCE}\n`)
assert.equal((await readAllOverrides()).get(CARD.oracle_id), `${SOURCE}\n`)
const compiled = compileImplementation(CARD, stored!.source)
assert.equal(compiled.manual, true)
assert.equal(compiled.status, 'supported')
await deleteOverride(CARD.oracle_id)
assert.equal(await readOverride(CARD.oracle_id), undefined)
})
test('entersTapped accepts an unlessCost builder and round-trips', () => {
const source = `export default [
staticAbility([entersTapped(self, { unlessCost: payLife(2) })]),
]`
const compiled = compileImplementation(CARD, source)
assert.equal(compiled.status, 'supported')
const rendered = formatCard(compiled)
assert.match(rendered, /entersTapped\(self, \{ unlessCost: payLife\(2\) \}\)/)
const reparsed = compileImplementation(CARD, rendered)
assert.deepEqual(reparsed.abilities, compiled.abilities)
})