702 lines
38 KiB
TypeScript
702 lines
38 KiB
TypeScript
import { mkdtemp, rm } from 'node:fs/promises'
|
||
import { tmpdir } from 'node:os'
|
||
import path from 'node:path'
|
||
import { afterAll, describe, expect, it } from 'vitest'
|
||
import { eq } from 'drizzle-orm'
|
||
import { openGameDb, type GameDb } from '@/lib/db/client'
|
||
import * as schema from '@/lib/db/schema'
|
||
import { generateStartingCrew, rollCrewMember, startingCrewRng } from './crew'
|
||
import { MIN_AVAILABLE } from './missions'
|
||
import { BASE_CAPACITY, BASE_LEVEL, SHIP_TYPES } from './ship-costs'
|
||
import { TECHS } from './tech'
|
||
import { SCHEMA_VERSION, getCrewState, getSystemState, explorePlanet, getWorldState, jumpToSystem, resolveJumpTask, resolveExploreTask, runTurn, type WorldState } from './save'
|
||
import type { Task } from './tasks'
|
||
import { bodyRng, explorationRng, generatePlanets, rollExploration } from './world'
|
||
|
||
const dirs: string[] = []
|
||
|
||
async function freshFile(): Promise<{ db: GameDb; file: string }> {
|
||
const dir = await mkdtemp(path.join(tmpdir(), 'sw-save-test-'))
|
||
dirs.push(dir)
|
||
const file = path.join(dir, 'test.db')
|
||
return { db: await openGameDb(file), file }
|
||
}
|
||
|
||
afterAll(async () => {
|
||
for (const d of dirs) await rm(d, { recursive: true, force: true })
|
||
})
|
||
|
||
function currentOf(world: WorldState): WorldState['systems'][number] {
|
||
const current = world.systems.filter((s) => s.current)
|
||
expect(current).toHaveLength(1)
|
||
return current[0]
|
||
}
|
||
|
||
describe('ensureSave / getWorldState', () => {
|
||
it('auto-initializes a save on first read: start + 6 neighbours, turn 0, new_game event', async () => {
|
||
const { db } = await freshFile()
|
||
const world = await getWorldState(db)
|
||
|
||
expect(world.turn).toBe(0)
|
||
expect(world.systems).toHaveLength(7)
|
||
expect(currentOf(world).discovered).toBe(true)
|
||
expect(world.systems.filter((s) => !s.discovered)).toHaveLength(6)
|
||
expect(world.edges).toHaveLength(12) // start↔each neighbour + ring cycle
|
||
|
||
const ids = new Set(world.systems.map((s) => s.id))
|
||
for (const [a, b] of world.edges) {
|
||
expect(ids.has(a)).toBe(true)
|
||
expect(ids.has(b)).toBe(true)
|
||
}
|
||
|
||
const rows = db.raw.exec('SELECT type, turn FROM events ORDER BY id')
|
||
expect(rows[0].values).toEqual([['new_game', 0]])
|
||
})
|
||
|
||
it('is idempotent — a second read does not regenerate the world', async () => {
|
||
const { db } = await freshFile()
|
||
const first = await getWorldState(db)
|
||
const second = await getWorldState(db)
|
||
expect(second).toEqual(first)
|
||
})
|
||
})
|
||
|
||
describe('jumpToSystem validation', () => {
|
||
it('rejects unknown systems with 404 and jumping to the current system with 409', async () => {
|
||
const { db } = await freshFile()
|
||
const world = await getWorldState(db)
|
||
const start = currentOf(world)
|
||
|
||
await expect(jumpToSystem(db, 999_999)).rejects.toMatchObject({ status: 404 })
|
||
await expect(jumpToSystem(db, start.id)).rejects.toMatchObject({ status: 409 })
|
||
|
||
const after = await getWorldState(db)
|
||
expect(after.turn).toBe(0) // rejected jumps mutate nothing
|
||
expect(currentOf(after).id).toBe(start.id)
|
||
})
|
||
|
||
it('rejects non-adjacent systems with 409 and leaves state untouched', async () => {
|
||
const { db } = await freshFile()
|
||
const w0 = await getWorldState(db)
|
||
const start = currentOf(w0)
|
||
|
||
// Every initial neighbour is adjacent to the start, so jump once first.
|
||
const n0 = w0.systems.find((s) => !s.current)!
|
||
await jumpToSystem(db, n0.id)
|
||
const w1 = await getWorldState(db)
|
||
expect(currentOf(w1).id).toBe(n0.id)
|
||
|
||
// A system with no route to the current one (ring members two steps away qualify).
|
||
const adjacent = new Set(
|
||
w1.edges.filter(([a, b]) => a === n0.id || b === n0.id).flatMap(([a, b]) => [a, b]),
|
||
)
|
||
const far = w1.systems.find((s) => !adjacent.has(s.id))!
|
||
|
||
await expect(jumpToSystem(db, far.id)).rejects.toMatchObject({ status: 409 })
|
||
const after = await getWorldState(db)
|
||
expect(after.turn).toBe(1)
|
||
expect(currentOf(after).id).toBe(n0.id)
|
||
})
|
||
})
|
||
|
||
describe('jumpToSystem success path', () => {
|
||
it('sets current, increments turn, discovers the target and grows the chart', async () => {
|
||
const { db } = await freshFile()
|
||
const w0 = await getWorldState(db)
|
||
const start = currentOf(w0)
|
||
const target = w0.systems.find((s) => !s.current)! // all initial neighbours are adjacent to the start
|
||
|
||
const after = await jumpToSystem(db, target.id)
|
||
|
||
expect(after.turn).toBe(1)
|
||
expect(currentOf(after).id).toBe(target.id)
|
||
expect(after.systems.find((s) => s.id === target.id)!.discovered).toBe(true)
|
||
|
||
// Expansion: 4 new undiscovered neighbours around the target, each routed to it.
|
||
const fresh = after.systems.filter((s) => !w0.systems.some((p) => p.id === s.id))
|
||
expect(fresh).toHaveLength(4)
|
||
expect(fresh.every((s) => !s.discovered)).toBe(true)
|
||
for (const n of fresh) {
|
||
expect(after.edges.some(([a, b]) => (a === target.id && b === n.id) || (a === n.id && b === target.id))).toBe(true)
|
||
}
|
||
|
||
const rows = db.raw.exec('SELECT type, turn FROM events ORDER BY id')
|
||
expect(rows[0].values).toEqual([['new_game', 0], ['jump', 1]])
|
||
})
|
||
|
||
it('persists the current system and turn across a DB reopen (container restart)', async () => {
|
||
const { db, file } = await freshFile()
|
||
const w0 = await getWorldState(db)
|
||
const target = w0.systems.find((s) => !s.current)!
|
||
const after = await jumpToSystem(db, target.id)
|
||
|
||
const reopened = await openGameDb(file) // a new process would see the same file
|
||
const again = await getWorldState(reopened)
|
||
|
||
expect(again.turn).toBe(after.turn)
|
||
expect(currentOf(again).id).toBe(target.id)
|
||
expect(again.systems).toHaveLength(after.systems.length)
|
||
})
|
||
})
|
||
|
||
describe('getSystemState', () => {
|
||
it('generates bodies for every system on new game; moons nest under a parent planet only', async () => {
|
||
const { db } = await freshFile()
|
||
const state = await getSystemState(db)
|
||
|
||
// Current (start) system: 2–5 planets, all unexplored yet.
|
||
const planetRows = state.planets.filter((p) => p.parent === null)
|
||
expect(planetRows.length).toBeGreaterThanOrEqual(2)
|
||
expect(planetRows.length).toBeLessThanOrEqual(5)
|
||
const planetIds = new Set(planetRows.map((p) => p.id))
|
||
for (const row of state.planets) {
|
||
if (row.parent !== null) expect(planetIds.has(row.parent)).toBe(true) // moons hang off a planet in the same system
|
||
expect(row.explored).toBe(false)
|
||
}
|
||
|
||
// Every one of the 7 fresh-save systems got bodies.
|
||
const counts = db.raw.exec('SELECT system_id, COUNT(*) FROM planets GROUP BY system_id')
|
||
expect(counts[0].values).toHaveLength(7)
|
||
for (const [, n] of counts[0].values) expect(Number(n)).toBeGreaterThanOrEqual(2)
|
||
|
||
expect(state.inventory).toEqual([]) // nothing found before any scan
|
||
expect(state.turn).toBe(0)
|
||
})
|
||
})
|
||
|
||
describe('explorePlanet', () => {
|
||
it('rejects unknown planets with 404 and already-explored ones with 409, mutating nothing on failure', async () => {
|
||
const { db } = await freshFile()
|
||
const state = await getSystemState(db)
|
||
const target = state.planets[0]
|
||
|
||
await expect(explorePlanet(db, 999_999)).rejects.toMatchObject({ status: 404 })
|
||
await explorePlanet(db, target.id)
|
||
await expect(explorePlanet(db, target.id)).rejects.toMatchObject({ status: 409 })
|
||
|
||
const after = await getSystemState(db)
|
||
expect(after.turn).toBe(1) // only the successful scan costs a turn
|
||
expect(after.planets.find((p) => p.id === target.id)?.explored).toBe(true)
|
||
})
|
||
|
||
it('marks explored, bumps the turn, lands finds in inventory and writes an event', async () => {
|
||
const { db } = await freshFile()
|
||
const state = await getSystemState(db)
|
||
const target = state.planets[0]
|
||
|
||
const result = await explorePlanet(db, target.id)
|
||
|
||
expect(result.turn).toBe(1)
|
||
// Fresh save: inventory is exactly this scan's haul.
|
||
for (const item of result.outcome) {
|
||
expect(result.inventory.find((i) => i.kind === item.kind && i.name === item.name)?.qty).toBe(item.qty)
|
||
}
|
||
expect(result.inventory.length).toBe(result.outcome.length)
|
||
|
||
const rows = db.raw.exec('SELECT type, turn FROM events ORDER BY id')
|
||
expect(rows[0].values).toEqual([['new_game', 0], ['explore', 1]])
|
||
})
|
||
|
||
it('is deterministic per save+planet and accumulates qty across scans (known seed)', async () => {
|
||
// Hand-built save with a known seed so every outcome is recomputable offline.
|
||
const { db } = await freshFile()
|
||
const [save] = await db.db.insert(schema.saves).values({ seed: '42', turn: 0, createdAt: new Date().toISOString() }).returning()
|
||
const [sys] = await db.db
|
||
.insert(schema.solarSystems)
|
||
.values({ saveId: save.id, name: 'Test System', x: 50, y: 50, discovered: true, isCurrent: true })
|
||
.returning({ id: schema.solarSystems.id })
|
||
|
||
const planetIds: number[] = []
|
||
for (const body of generatePlanets(bodyRng('42', sys.id))) {
|
||
const [p] = await db.db
|
||
.insert(schema.planets)
|
||
.values({ systemId: sys.id, parentId: null, name: body.name, type: body.type, hazard: body.hazard })
|
||
.returning({ id: schema.planets.id })
|
||
planetIds.push(p.id)
|
||
}
|
||
|
||
const expected = planetIds.map((id) => rollExploration(explorationRng('42', id)))
|
||
for (let i = 0; i < planetIds.length; i++) {
|
||
const result = await explorePlanet(db, planetIds[i])
|
||
expect(result.outcome).toEqual(expected[i]) // same save+planet → same haul
|
||
}
|
||
|
||
// Inventory accumulates: qty per kind+name equals the sum over all scans.
|
||
const totals = new Map<string, number>()
|
||
for (const items of expected) {
|
||
for (const it of items) totals.set(`${it.kind}|${it.name}`, (totals.get(`${it.kind}|${it.name}`) ?? 0) + it.qty)
|
||
}
|
||
const state = await getSystemState(db)
|
||
expect(state.inventory.length).toBe(totals.size)
|
||
for (const item of state.inventory) {
|
||
expect(item.qty).toBe(totals.get(`${item.kind}|${item.name}`))
|
||
}
|
||
expect(state.turn).toBe(planetIds.length) // one turn per scan
|
||
})
|
||
})
|
||
|
||
describe('getCrewState', () => {
|
||
it('seeds a starting crew of 2–3 members derived from the save seed', async () => {
|
||
const { db } = await freshFile()
|
||
const crew = await getCrewState(db) // ensureSave runs inside, so this also seeds the crew
|
||
|
||
expect(crew.length).toBeGreaterThanOrEqual(2)
|
||
expect(crew.length).toBeLessThanOrEqual(3)
|
||
for (const member of crew) {
|
||
expect(member.origin).toBe('STARTING CREW')
|
||
expect(member.name.trim()).not.toBe('')
|
||
expect(member.role.trim()).not.toBe('')
|
||
expect(member.traitGood.trim()).not.toBe('')
|
||
expect(member.traitBad.trim()).not.toBe('')
|
||
}
|
||
|
||
// The roster is exactly the pure generation for this save's seed.
|
||
const [save] = await db.db.select().from(schema.saves)
|
||
const expected = generateStartingCrew(startingCrewRng(save.seed))
|
||
expect(crew.map((c) => c.name)).toEqual(expected.map((m) => m.name))
|
||
expect(crew.map((c) => c.role)).toEqual(expected.map((m) => m.role))
|
||
expect(crew.map((c) => [c.traitGood, c.traitBad])).toEqual(expected.map((m) => [m.traitGood, m.traitBad]))
|
||
})
|
||
})
|
||
|
||
describe('explorePlanet crew finds', () => {
|
||
it('lands a found member in the roster with the planet+system origin and never joins twice (known seed)', async () => {
|
||
// Hand-built save with a known seed so the crew roll is recomputable offline.
|
||
const { db } = await freshFile()
|
||
const [save] = await db.db.insert(schema.saves).values({ seed: '42', turn: 0, createdAt: new Date().toISOString() }).returning()
|
||
const [sys] = await db.db
|
||
.insert(schema.solarSystems)
|
||
.values({ saveId: save.id, name: 'Test System', x: 50, y: 50, discovered: true, isCurrent: true })
|
||
.returning({ id: schema.solarSystems.id })
|
||
|
||
// Find a small planet id whose exploration roll finds crew (deterministic — recomputed here,
|
||
// mirroring save.ts: the item haul draws first, then the crew roll on the same stream).
|
||
let crewPlanetId = -1
|
||
for (let id = 1; id <= 50 && crewPlanetId === -1; id++) {
|
||
const rng = explorationRng('42', id)
|
||
rollExploration(rng)
|
||
if (rollCrewMember(rng, new Set<string>())) crewPlanetId = id
|
||
}
|
||
expect(crewPlanetId).toBeGreaterThan(0)
|
||
|
||
const planetName = `P${crewPlanetId}`
|
||
for (let i = 1; i <= crewPlanetId; i++) {
|
||
await db.db.insert(schema.planets).values({ systemId: sys.id, parentId: null, name: `P${i}`, type: 'ROCKY', hazard: false })
|
||
}
|
||
|
||
const before = await getCrewState(db) // empty — this save was hand-built, no starting crew seeded
|
||
const result = await explorePlanet(db, crewPlanetId)
|
||
|
||
expect(result.crewFound).not.toBeNull()
|
||
const expectedRng = explorationRng('42', crewPlanetId)
|
||
rollExploration(expectedRng) // consume the item haul draws first, exactly as save.ts does
|
||
const expectedMember = rollCrewMember(expectedRng, new Set<string>())! // same save+planet → same member
|
||
expect(result.crewFound!.name).toBe(expectedMember.name)
|
||
expect(result.crewFound!.role).toBe(expectedMember.role)
|
||
expect([result.crewFound!.traitGood, result.crewFound!.traitBad]).toEqual([expectedMember.traitGood, expectedMember.traitBad])
|
||
expect(result.crewFound!.origin).toBe(`${planetName}, Test System`)
|
||
|
||
const after = await getCrewState(db)
|
||
expect(after.length).toBe(before.length + 1) // exactly one join
|
||
expect(after.find((c) => c.id === result.crewFound!.id)).toMatchObject({ name: expectedMember.name, origin: `${planetName}, Test System` })
|
||
|
||
// The body is already explored → a second scan is rejected and no duplicate joins.
|
||
await expect(explorePlanet(db, crewPlanetId)).rejects.toMatchObject({ status: 409 })
|
||
expect((await getCrewState(db)).length).toBe(before.length + 1)
|
||
})
|
||
})
|
||
|
||
// --- A/B: resolvers vs the legacy immediate actions (Task 4a) -------------------------
|
||
//
|
||
// Each test builds the identical deterministic fixture in two fresh files (seed '42',
|
||
// stamped save → no backfill; ids line up across worlds) and compares their full state:
|
||
// A = the legacy immediate action (validates, costs a turn, applies the effect);
|
||
// B = the queued shape — the tick has advanced the turn (Task 4b) and the resolver
|
||
// applies the effect (ship/research rows deduct the cost up front, as queueTask did at
|
||
// queue time — Task 3). snapshot() normalizes every game table (wall-clock columns
|
||
// excluded), so the two end states must be byte-identical.
|
||
const T0 = '2026-10-01T00:00:00.000Z'
|
||
|
||
async function buildWorldFixture(db: GameDb, outpostDiscovered = false): Promise<{ sys1: number; p0: number; p1: number }> {
|
||
const [save] = await db.db.insert(schema.saves).values({ seed: '42', turn: 0, createdAt: T0, schemaVersion: SCHEMA_VERSION }).returning()
|
||
const [s0] = await db.db.insert(schema.solarSystems).values({ saveId: save.id, name: 'Origin', x: 50, y: 50, discovered: true, isCurrent: true }).returning({ id: schema.solarSystems.id })
|
||
const [s1] = await db.db.insert(schema.solarSystems).values({ saveId: save.id, name: 'Outpost', x: 55, y: 50, discovered: outpostDiscovered }).returning({ id: schema.solarSystems.id })
|
||
await db.db.insert(schema.jumpRoutes).values({ fromSystem: s0.id, toSystem: s1.id })
|
||
await db.db.insert(schema.jumpRoutes).values({ fromSystem: s1.id, toSystem: s0.id })
|
||
const [p0] = await db.db.insert(schema.planets).values({ systemId: s0.id, parentId: null, name: 'Alder', type: 'ROCKY', hazard: false }).returning({ id: schema.planets.id })
|
||
const [p1] = await db.db.insert(schema.planets).values({ systemId: s1.id, parentId: null, name: 'Basalt', type: 'GAS', hazard: false }).returning({ id: schema.planets.id })
|
||
return { sys1: s1.id, p0: p0.id, p1: p1.id }
|
||
}
|
||
|
||
// The resolvers only read `type` + `payload` — tests mint stand-in rows with zeroed
|
||
// identity fields, the same way the public functions' delegation does.
|
||
const task = (type: 'JUMP' | 'EXPLORE', payload: object): Task =>
|
||
({ id: 0, saveId: 0, type, payload: JSON.stringify(payload), leadCrewId: 0, helpers: [], duration: 0, remaining: 0, status: 'ACTIVE', queuedAtTurn: 0 })
|
||
|
||
async function snapshot(db: GameDb): Promise<string> {
|
||
const [saves, systems, routes, planets, inventory, crew, ship, tech, missions, events] = await Promise.all([
|
||
db.db.select({ id: schema.saves.id, seed: schema.saves.seed, turn: schema.saves.turn, schemaVersion: schema.saves.schemaVersion }).from(schema.saves),
|
||
db.db.select().from(schema.solarSystems),
|
||
db.db.select().from(schema.jumpRoutes),
|
||
db.db.select().from(schema.planets),
|
||
db.db.select().from(schema.inventoryItems),
|
||
db.db.select().from(schema.crew),
|
||
db.db.select().from(schema.shipSystems),
|
||
db.db.select().from(schema.tech),
|
||
db.db.select().from(schema.missions),
|
||
db.db.select({ id: schema.events.id, turn: schema.events.turn, type: schema.events.type, message: schema.events.message }).from(schema.events),
|
||
])
|
||
return JSON.stringify({ saves, systems, routes, planets, inventory, crew, ship, tech, missions, events })
|
||
}
|
||
|
||
describe('resolveJumpTask (A/B against jumpToSystem)', () => {
|
||
it('undiscovered target: lands exactly what jumpToSystem lands — move, discover, ring, event', async () => {
|
||
const { db: a } = await freshFile()
|
||
const { db: b } = await freshFile()
|
||
const fa = await buildWorldFixture(a)
|
||
const fb = await buildWorldFixture(b)
|
||
|
||
await jumpToSystem(a, fa.sys1) // legacy: validates, +1 turn, effect, event at turn 1
|
||
await b.db.update(schema.saves).set({ turn: 1 }).where(eq(schema.saves.id, 1)) // the tick's job (Task 4b)
|
||
await resolveJumpTask(b, task('JUMP', { systemId: fb.sys1, hops: 1 }))
|
||
|
||
expect(await snapshot(b)).toEqual(await snapshot(a))
|
||
})
|
||
|
||
it('discovered target: no ring — still byte-identical to jumpToSystem', async () => {
|
||
const { db: a } = await freshFile()
|
||
const { db: b } = await freshFile()
|
||
const fa = await buildWorldFixture(a, true)
|
||
const fb = await buildWorldFixture(b, true)
|
||
|
||
await jumpToSystem(a, fa.sys1)
|
||
await b.db.update(schema.saves).set({ turn: 1 }).where(eq(schema.saves.id, 1))
|
||
await resolveJumpTask(b, task('JUMP', { systemId: fb.sys1, hops: 1 }))
|
||
|
||
expect(await snapshot(b)).toEqual(await snapshot(a))
|
||
expect(await b.db.select().from(schema.solarSystems)).toHaveLength(2) // no ring added
|
||
})
|
||
|
||
it('guards: 404 unknown system, 409 already-current', async () => {
|
||
const { db } = await freshFile()
|
||
const f = await buildWorldFixture(db)
|
||
await db.db.update(schema.saves).set({ turn: 1 }).where(eq(schema.saves.id, 1))
|
||
|
||
await expect(resolveJumpTask(db, task('JUMP', { systemId: 999, hops: 1 }))).rejects.toMatchObject({ status: 404, message: 'Unknown system 999' })
|
||
await db.db.update(schema.solarSystems).set({ isCurrent: false }).where(eq(schema.solarSystems.id, 1))
|
||
await db.db.update(schema.solarSystems).set({ isCurrent: true }).where(eq(schema.solarSystems.id, f.sys1))
|
||
await expect(resolveJumpTask(db, task('JUMP', { systemId: f.sys1, hops: 1 }))).rejects.toMatchObject({ status: 409, message: 'Already at this system' })
|
||
})
|
||
})
|
||
|
||
describe('resolveExploreTask (A/B against explorePlanet)', () => {
|
||
it('planet in the current system: lands exactly what explorePlanet lands — haul, explored, event', async () => {
|
||
const { db: a } = await freshFile()
|
||
const { db: b } = await freshFile()
|
||
const fa = await buildWorldFixture(a)
|
||
const fb = await buildWorldFixture(b)
|
||
|
||
await explorePlanet(a, fa.p0)
|
||
await b.db.update(schema.saves).set({ turn: 1 }).where(eq(schema.saves.id, 1))
|
||
await resolveExploreTask(b, task('EXPLORE', { planetId: fb.p0 }))
|
||
|
||
expect(await snapshot(b)).toEqual(await snapshot(a))
|
||
})
|
||
|
||
it('payload planet wins over the current system — the ship stays put (elsewhere semantics)', async () => {
|
||
const { db: a } = await freshFile()
|
||
const { db: b } = await freshFile()
|
||
const fa = await buildWorldFixture(a)
|
||
const fb = await buildWorldFixture(b)
|
||
|
||
await explorePlanet(a, fa.p1) // the current function already scans any planet, not just the current system's
|
||
await b.db.update(schema.saves).set({ turn: 1 }).where(eq(schema.saves.id, 1))
|
||
await resolveExploreTask(b, task('EXPLORE', { planetId: fb.p1 }))
|
||
|
||
expect(await snapshot(b)).toEqual(await snapshot(a))
|
||
|
||
const sysB = await b.db.select().from(schema.solarSystems)
|
||
expect(sysB.filter((s) => s.isCurrent).map((s) => s.name)).toEqual(['Origin']) // the ship never moved
|
||
expect(sysB.find((s) => s.name === 'Outpost')!.discovered).toBe(false) // a scan never discovers a system
|
||
|
||
const ev = (await b.db.select({ turn: schema.events.turn, type: schema.events.type, message: schema.events.message }).from(schema.events)).find((e) => e.type === 'explore')!
|
||
expect(ev.turn).toBe(1)
|
||
// Exact existing format, recomputed the way save.ts computes it: haul first, crew roll on the same stream.
|
||
const rng = explorationRng('42', fb.p1)
|
||
const haul = rollExploration(rng)
|
||
const member = rollCrewMember(rng, new Set<string>())
|
||
const foundText = haul.length > 0 ? haul.map((i) => `${i.qty}× ${i.name}`).join(', ') : 'nothing'
|
||
expect(ev.message).toBe(`Explored Basalt — found ${foundText}${member ? ` — ${member.name} joined the crew` : ''}`)
|
||
})
|
||
|
||
it('guards: 404 unknown planet, 409 already explored (double-resolution safe)', async () => {
|
||
const { db } = await freshFile()
|
||
const f = await buildWorldFixture(db)
|
||
await db.db.update(schema.saves).set({ turn: 1 }).where(eq(schema.saves.id, 1))
|
||
|
||
await expect(resolveExploreTask(db, task('EXPLORE', { planetId: 999 }))).rejects.toMatchObject({ status: 404, message: 'Unknown planet 999' })
|
||
await resolveExploreTask(db, task('EXPLORE', { planetId: f.p1 }))
|
||
await expect(resolveExploreTask(db, task('EXPLORE', { planetId: f.p1 }))).rejects.toMatchObject({ status: 409, message: 'Basalt was already explored' })
|
||
})
|
||
})
|
||
|
||
// --- runTurn: the DB-side tick (POST /api/turn — Task 5 wires the route) -----------------
|
||
//
|
||
// The route→save pattern: ensureSave first, unscoped single-player reads, persist last.
|
||
// The tick (tickTurn) owns the turn increment and the queue math; the 4a resolvers own the
|
||
// effects and the mission hooks (their contract — invoked here, at the tick's new turn,
|
||
// before the final persist); this function owns the table writes.
|
||
describe('runTurn (tick on the DB)', () => {
|
||
// buildWorldFixture (the 4a block above) seeds the save (seed '42', stamped — no
|
||
// backfill) + Origin (s0, id 1, current) / Outpost (s1) + Alder (p0, in s0) /
|
||
// Basalt (p1, in s1) + the route pair — but no crew or tasks; the tick needs both, so
|
||
// this block adds its own rows.
|
||
async function addCrew(db: GameDb, count: number): Promise<number[]> {
|
||
const [save] = await db.db.select().from(schema.saves).limit(1)
|
||
const ids: number[] = []
|
||
for (let i = 0; i < count; i++) {
|
||
const [row] = await db.db.insert(schema.crew).values({ saveId: save.id, name: `CREW ${i + 1}`, role: 'PILOT', traitGood: 'QUICK HANDS', traitBad: 'OVERCAUTIOUS', origin: 'STARTING CREW' }).returning({ id: schema.crew.id })
|
||
ids.push(row.id)
|
||
}
|
||
return ids
|
||
}
|
||
|
||
async function insertTaskRow(db: GameDb, over: { type: string; payload: object; leadCrewId: number; helpers: number[]; duration: number; remaining: number; status: string; queuedAtTurn: number }): Promise<number> {
|
||
const [save] = await db.db.select().from(schema.saves).limit(1)
|
||
const [row] = await db.db.insert(schema.tasks).values({ saveId: save.id, type: over.type, payload: JSON.stringify(over.payload), leadCrewId: over.leadCrewId, helpers: JSON.stringify(over.helpers), duration: over.duration, remaining: over.remaining, status: over.status, queuedAtTurn: over.queuedAtTurn }).returning({ id: schema.tasks.id })
|
||
return row.id
|
||
}
|
||
|
||
it('free skip: an empty queue costs exactly one turn and touches nothing else (Review Focus 4)', async () => {
|
||
const { db } = await freshFile()
|
||
await buildWorldFixture(db)
|
||
const count = (t: typeof schema.solarSystems | typeof schema.planets | typeof schema.inventoryItems | typeof schema.missions | typeof schema.events | typeof schema.tasks) => db.db.select().from(t).then((rows) => rows.length)
|
||
const before = {
|
||
systems: await count(schema.solarSystems),
|
||
planets: await count(schema.planets),
|
||
inventory: await count(schema.inventoryItems),
|
||
missions: await count(schema.missions),
|
||
events: await count(schema.events),
|
||
}
|
||
|
||
const r = await runTurn(db)
|
||
expect(r.turn).toBe(1)
|
||
expect(r.tasks).toEqual([])
|
||
expect(r.completed).toEqual([])
|
||
|
||
const [save] = await db.db.select().from(schema.saves).limit(1)
|
||
expect(save.turn).toBe(1) // the tick is the increment — the only write of the call
|
||
expect(await count(schema.solarSystems)).toBe(before.systems)
|
||
expect(await count(schema.planets)).toBe(before.planets)
|
||
expect(await count(schema.inventoryItems)).toBe(before.inventory)
|
||
expect(await count(schema.missions)).toBe(before.missions) // no top-up without a resolution
|
||
expect(await count(schema.events)).toBe(before.events) // no event for a skip
|
||
expect(await count(schema.tasks)).toBe(0)
|
||
})
|
||
|
||
it('a resolved JUMP completes the matching DELIVER mission, grants the reward, and tops the board up — the 4a hooks, at the tick\'s new turn', async () => {
|
||
const { db } = await freshFile()
|
||
const f = await buildWorldFixture(db) // s0 current; s1 'Outpost' undiscovered
|
||
const [c1] = await addCrew(db, 1)
|
||
const jumpId = await insertTaskRow(db, { type: 'JUMP', payload: { systemId: f.sys1, hops: 1 }, leadCrewId: c1, helpers: [], duration: 2, remaining: 1, status: 'ACTIVE', queuedAtTurn: 4 })
|
||
const [save] = await db.db.select().from(schema.saves).limit(1)
|
||
await db.db.update(schema.saves).set({ turn: 5 }).where(eq(schema.saves.id, save.id))
|
||
const [mission] = await db.db.insert(schema.missions).values({ saveId: save.id, type: 'DELIVER', description: 'Jump to Outpost', targetSystemId: f.sys1, progressTarget: 1, rewardKind: 'resource', rewardQty: 2, state: 'ACTIVE' }).returning({ id: schema.missions.id })
|
||
|
||
const r = await runTurn(db)
|
||
expect(r.turn).toBe(6)
|
||
expect(r.completed.map((t) => t.id)).toEqual([jumpId])
|
||
expect((await db.db.select().from(schema.tasks)).find((t) => t.id === jumpId)!.status).toBe('DONE')
|
||
|
||
// the mission resolved at the new turn: DONE + reward in the hold + both events at turn 6
|
||
expect((await db.db.select().from(schema.missions)).find((m) => m.id === mission.id)).toMatchObject({ state: 'DONE', progress: 1 })
|
||
expect(await db.db.select().from(schema.inventoryItems)).toEqual([{ id: expect.any(Number), saveId: save.id, kind: 'resource', name: 'MISSION REWARD', qty: 2 }])
|
||
const events = (await db.db.select().from(schema.events)).map((e) => [e.turn, e.type] as const)
|
||
expect(events).toHaveLength(2)
|
||
expect(events).toContainEqual([6, 'jump'])
|
||
expect(events).toContainEqual([6, 'mission'])
|
||
|
||
// the board is topped up after the arrival (the 4a jump-resolver hook) to exactly the floor
|
||
const available = (await db.db.select({ state: schema.missions.state }).from(schema.missions)).filter((m) => m.state === 'AVAILABLE').length
|
||
expect(available).toBe(MIN_AVAILABLE)
|
||
|
||
// the effect half: the ship is at the payload system
|
||
expect((await db.db.select().from(schema.solarSystems)).find((s) => s.id === f.sys1)!.isCurrent).toBe(true)
|
||
})
|
||
|
||
it('a JUMP and an EXPLORE both resolving on one tick: the explore effect lands on its payload planet, not the newly arrived system (Review Focus 3)', async () => {
|
||
const { db } = await freshFile()
|
||
const f = await buildWorldFixture(db) // p0 'Alder' in s0 (Origin); p1 'Basalt' in s1 (Outpost)
|
||
const [c1, c2] = await addCrew(db, 2)
|
||
await insertTaskRow(db, { type: 'EXPLORE', payload: { planetId: f.p0 }, leadCrewId: c1, helpers: [], duration: 1, remaining: 1, status: 'ACTIVE', queuedAtTurn: 3 })
|
||
await insertTaskRow(db, { type: 'JUMP', payload: { systemId: f.sys1, hops: 1 }, leadCrewId: c2, helpers: [], duration: 1, remaining: 1, status: 'ACTIVE', queuedAtTurn: 3 })
|
||
const [save] = await db.db.select().from(schema.saves).limit(1)
|
||
await db.db.update(schema.saves).set({ turn: 4 }).where(eq(schema.saves.id, save.id))
|
||
|
||
const r = await runTurn(db)
|
||
expect(r.completed.map((t) => t.type)).toEqual(['EXPLORE', 'JUMP']) // both this tick — the resolvers are payload-targeted (4a), so resolution order cannot change what lands
|
||
|
||
const planets = await db.db.select().from(schema.planets)
|
||
expect(planets.find((p) => p.id === f.p0)!.explored).toBe(true) // the payload planet — in the OLD system
|
||
expect(planets.find((p) => p.id === f.p1)!.explored).toBe(false) // nothing in the new system
|
||
expect((await db.db.select().from(schema.solarSystems)).find((s) => s.id === f.sys1)!.isCurrent).toBe(true) // the jump still landed
|
||
// the haul is the payload planet's deterministic stream (seed '42', p0) — never the new system's
|
||
expect((await db.db.select().from(schema.inventoryItems)).map((i) => ({ kind: i.kind, name: i.name, qty: i.qty }))).toEqual(rollExploration(explorationRng('42', f.p0)))
|
||
// the ~18% crew roll rides the same stream — at most one member joins (PR C pins the stream)
|
||
expect((await db.db.select().from(schema.crew)).length).toBeGreaterThanOrEqual(2)
|
||
})
|
||
|
||
it('a resolver guard failure fails just that task — the turn still lands, the sibling still resolves, no event for the failure', async () => {
|
||
const { db } = await freshFile()
|
||
const f = await buildWorldFixture(db)
|
||
const [c1, c2] = await addCrew(db, 2)
|
||
const badJumpId = await insertTaskRow(db, { type: 'JUMP', payload: { systemId: 999, hops: 1 }, leadCrewId: c1, helpers: [], duration: 1, remaining: 1, status: 'ACTIVE', queuedAtTurn: 3 })
|
||
const exploreId = await insertTaskRow(db, { type: 'EXPLORE', payload: { planetId: f.p0 }, leadCrewId: c2, helpers: [], duration: 1, remaining: 1, status: 'ACTIVE', queuedAtTurn: 3 })
|
||
const [save] = await db.db.select().from(schema.saves).limit(1)
|
||
await db.db.update(schema.saves).set({ turn: 4 }).where(eq(schema.saves.id, save.id))
|
||
|
||
const r = await runTurn(db) // must not throw — the 4a guard throw is a failure signal, not an error
|
||
expect(r.turn).toBe(5)
|
||
expect(r.completed.map((t) => t.id)).toEqual([badJumpId, exploreId]) // both reported; only the sibling's effect lands
|
||
expect((await db.db.select().from(schema.tasks)).find((t) => t.id === badJumpId)!.status).toBe('DONE') // failed task: done — the turn is spent, the crew freed
|
||
expect((await db.db.select().from(schema.planets)).find((p) => p.id === f.p0)!.explored).toBe(true) // the sibling resolved
|
||
const types = (await db.db.select().from(schema.events)).map((e) => e.type)
|
||
expect(types.filter((t) => t === 'jump')).toHaveLength(0) // the 404 guard threw before the jump effect/event
|
||
expect(types.filter((t) => t === 'explore')).toHaveLength(1)
|
||
expect((await db.db.select().from(schema.solarSystems)).filter((s) => s.isCurrent).map((s) => s.id)).toEqual([1]) // the ship did not move
|
||
})
|
||
})
|
||
|
||
describe('backfill (old saves)', () => {
|
||
// Planets/moons of one system in insertion order, nested by parent — ids are excluded so a
|
||
// regenerated set compares equal to the original even though autoincrement moved on.
|
||
function bodyShape(rows: { id: number; name: string; type: string; hazard: boolean; parentId: number | null }[]) {
|
||
return rows
|
||
.filter((r) => r.parentId === null)
|
||
.map((p) => ({ name: p.name, type: p.type, hazard: p.hazard, moons: rows.filter((m) => m.parentId === p.id).map((m) => [m.name, m.type, m.hazard]) }))
|
||
}
|
||
|
||
it('upgrades a v1 save (no bodies, no crew) in place — deterministic and idempotent', async () => {
|
||
const { db } = await freshFile()
|
||
await getWorldState(db) // new game: everything seeded at the current version
|
||
|
||
const systems = await db.db.select().from(schema.solarSystems)
|
||
const rowsFor = (systemId: number) => db.db.select().from(schema.planets).where(eq(schema.planets.systemId, systemId))
|
||
const beforeBodies: Record<number, unknown> = {}
|
||
for (const s of systems) {
|
||
const rows = await rowsFor(s.id)
|
||
beforeBodies[s.id] = bodyShape(rows.sort((a, b) => a.id - b.id))
|
||
}
|
||
const crewOf = (rows: { id: number; name: string; role: string; traitGood: string; traitBad: string; origin: string }[]) =>
|
||
rows.map((c) => ({ name: c.name, role: c.role, traitGood: c.traitGood, traitBad: c.traitBad, origin: c.origin })) // ids excluded — re-seed moves autoincrement on
|
||
const beforeCrew = crewOf(await db.db.select().from(schema.crew))
|
||
const shipOf = (rows: { id: number; type: string; level: number; capacity: number }[]) =>
|
||
rows.map((s) => ({ type: s.type, level: s.level, capacity: s.capacity })).sort((a, b) => a.type.localeCompare(b.type)) // ids excluded — re-seed moves autoincrement on
|
||
const beforeShip = shipOf(await db.db.select().from(schema.shipSystems))
|
||
const techShape = (rows: { id: number; slug: string; name: string; costKind: string; costQty: number; prerequisites: string; effect: string; researched: boolean }[]) =>
|
||
rows.map((t) => ({ slug: t.slug, name: t.name, costKind: t.costKind, costQty: t.costQty, prerequisites: t.prerequisites, effect: t.effect, researched: t.researched })).sort((a, b) => a.slug.localeCompare(b.slug))
|
||
const beforeTech = techShape(await db.db.select().from(schema.tech))
|
||
|
||
// Simulate a save created by pre-v0.5 code: no bodies, no crew, no ship, no tech, no version stamp (NULL).
|
||
await db.db.delete(schema.planets)
|
||
await db.db.delete(schema.crew)
|
||
await db.db.delete(schema.shipSystems)
|
||
await db.db.delete(schema.tech)
|
||
await db.db.update(schema.saves).set({ schemaVersion: null })
|
||
|
||
const world = await getWorldState(db) // ensureSave → backfill runs
|
||
expect(world.systems).toHaveLength(7)
|
||
|
||
for (const s of systems) {
|
||
const rows = await rowsFor(s.id)
|
||
expect(bodyShape(rows.sort((a, b) => a.id - b.id))).toEqual(beforeBodies[s.id]) // identical to fresh generation
|
||
}
|
||
expect(crewOf(await db.db.select().from(schema.crew))).toEqual(beforeCrew)
|
||
expect(shipOf(await db.db.select().from(schema.shipSystems))).toEqual(beforeShip)
|
||
expect(techShape(await db.db.select().from(schema.tech))).toEqual(beforeTech)
|
||
|
||
const [save] = await db.db.select().from(schema.saves)
|
||
expect(save.schemaVersion).toBe(SCHEMA_VERSION)
|
||
|
||
// Idempotent: a second pass changes nothing.
|
||
const planetCount = (await db.db.select().from(schema.planets)).length
|
||
await getWorldState(db)
|
||
expect((await db.db.select().from(schema.planets)).length).toBe(planetCount)
|
||
expect((await db.db.select().from(schema.crew)).length).toBe(beforeCrew.length)
|
||
expect(shipOf(await db.db.select().from(schema.shipSystems))).toEqual(beforeShip)
|
||
expect(techShape(await db.db.select().from(schema.tech))).toEqual(beforeTech)
|
||
for (const s of systems) {
|
||
const rows = await rowsFor(s.id)
|
||
expect(bodyShape(rows.sort((a, b) => a.id - b.id))).toEqual(beforeBodies[s.id])
|
||
}
|
||
})
|
||
|
||
it('leaves an up-to-date save untouched', async () => {
|
||
const { db } = await freshFile()
|
||
await getWorldState(db)
|
||
const planetCount = (await db.db.select().from(schema.planets)).length
|
||
const [save] = await db.db.select().from(schema.saves)
|
||
expect(save.schemaVersion).toBe(SCHEMA_VERSION)
|
||
|
||
await getWorldState(db) // second read: no backfill work to do
|
||
expect((await db.db.select().from(schema.planets)).length).toBe(planetCount)
|
||
})
|
||
|
||
it('v7: a v6-stamped save gets an empty tasks table without touching state; idempotent across restart', async () => {
|
||
const { db, file } = await freshFile()
|
||
const world = await getWorldState(db) // fresh game, stamped at the current version
|
||
const crewBefore = await db.db.select().from(schema.crew)
|
||
const invBefore = await db.db.select().from(schema.inventoryItems)
|
||
|
||
await db.db.update(schema.saves).set({ schemaVersion: 6 }) // simulate a save stamped by v0.9.12
|
||
const world2 = await getWorldState(db) // ensureSave → backfill v6 → v7
|
||
|
||
expect(world2).toEqual(world) // turn, systems, edges — untouched (Review Focus 1)
|
||
expect((await db.db.select().from(schema.saves))[0].schemaVersion).toBe(7)
|
||
expect(await db.db.select().from(schema.crew)).toEqual(crewBefore)
|
||
expect(await db.db.select().from(schema.inventoryItems)).toEqual(invBefore)
|
||
const tables = db.raw.exec("SELECT name FROM sqlite_master WHERE type = 'table'")
|
||
expect(tables[0].values.map((v) => v[0])).toContain('tasks')
|
||
expect(Number(db.raw.exec('SELECT COUNT(*) FROM tasks')[0]?.values[0][0] ?? 0)).toBe(0) // empty queue after upgrade
|
||
|
||
const reopened = await openGameDb(file) // restart: the backfill must be a no-op
|
||
await getWorldState(reopened)
|
||
expect((await reopened.db.select().from(schema.saves))[0].schemaVersion).toBe(7)
|
||
expect(Number(reopened.raw.exec('SELECT COUNT(*) FROM tasks')[0]?.values[0][0] ?? 0)).toBe(0)
|
||
})
|
||
|
||
it('seeds the starting ship on a new game: core types built at base values, WEAPONS unbuilt', async () => {
|
||
const { db } = await freshFile()
|
||
await getWorldState(db)
|
||
const rows = (await db.db.select().from(schema.shipSystems)).sort((a, b) => a.type.localeCompare(b.type))
|
||
expect(rows).toHaveLength(SHIP_TYPES.length)
|
||
for (const def of SHIP_TYPES) {
|
||
const row = rows.find((r) => r.type === def.type)!
|
||
if (def.builtAtStart) {
|
||
expect({ level: row.level, capacity: row.capacity }).toEqual({ level: BASE_LEVEL, capacity: BASE_CAPACITY })
|
||
} else {
|
||
expect(row.level).toBe(0) // unbuilt until a BUILD action
|
||
expect(row.capacity).toBe(0)
|
||
}
|
||
}
|
||
})
|
||
|
||
it('seeds the tech tree on a new game: one row per known tech, none researched', async () => {
|
||
const { db } = await freshFile()
|
||
await getWorldState(db)
|
||
const rows = (await db.db.select().from(schema.tech)).sort((a, b) => a.slug.localeCompare(b.slug))
|
||
expect(rows).toHaveLength(TECHS.length)
|
||
for (const def of TECHS) {
|
||
const row = rows.find((r) => r.slug === def.slug)!
|
||
expect({ name: row.name, costKind: row.costKind, costQty: row.costQty, prerequisites: row.prerequisites, effect: row.effect }).toEqual({
|
||
name: def.name,
|
||
costKind: def.costKind,
|
||
costQty: def.costQty,
|
||
prerequisites: def.prereqs.join(','),
|
||
effect: def.effect,
|
||
})
|
||
expect(row.researched).toBe(false) // nothing is researched at the start
|
||
}
|
||
})
|
||
})
|