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) })