Flight-Ops/app/api/state/route.test.ts

import fs from 'node:fs/promises';
import os from 'node:os';
import path from 'node:path';
import { afterAll, beforeAll, describe, expect, it } from 'vitest';
import { loadAirportsGeoJson } from '@/lib/airports';
import { haversineKm } from '@/lib/geo';
import { FUEL_PRICE_PER_L, PLANE_TYPES, SELL_FRACTION } from '@/lib/game/catalog';
import { createSession, hashPassword } from '@/lib/auth';
import * as schema from '@/lib/db/schema';
import { getGameDb } from '@/lib/db/client';
import { GET } from './route';

let dir: string;
let sessionId: string;

beforeAll(async () => {
  // Point the app's DB singleton at a throwaway file so this test never
  // touches ./db/flight.db. getGameDb() reads the env var on first call, and
  // vitest gives each test file its own module registry (fresh singleton).
  dir = await fs.mkdtemp(path.join(os.tmpdir(), 'flight-state-'));
  process.env.FLIGHT_DB_PATH = path.join(dir, 'state.db');
  // v1.1.0 (ISS-107): /api/state is session-guarded — mint a session for the seeded admin user
  // (no password needed: createSession only inserts into sessions; the guard joins players on
  // username → the 'local' row).
  sessionId = await createSession(await getGameDb(), 'admin-kamilkrzywda');
});

const req = () => new Request('http://localhost/api/state', { headers: { 'X-Flight-Session': sessionId } });

afterAll(async () => {
  delete process.env.FLIGHT_DB_PATH;
  await fs.rm(dir, { recursive: true, force: true });
});

describe('GET /api/state', () => {
  it('returns 200 with the full snapshot shape', async () => {
    const res = await GET(req());
    expect(res.status).toBe(200);
    expect(res.headers.get('content-type')).toContain('application/json');

    const body = (await res.json()) as Record<string, unknown>;
    expect(Object.keys(body).sort()).toEqual([
      'account',
      'catalog',
      'fuelPricePerL',
      'packages',
      'planes',
      'sellFraction',
      'simState',
    ]);

    const account = body.account as { cash: number; reputation: number };
    expect(typeof account.cash).toBe('number');
    expect(typeof account.reputation).toBe('number');

    const sim = body.simState as { clockMs: number }; // ISS-117: time controls are gone — clock only
    expect(typeof sim.clockMs).toBe('number');

    const planes = body.planes as Array<Record<string, unknown>>;
    expect(planes.length).toBeGreaterThanOrEqual(1);
    for (const key of ['id', 'model', 'status', 'fuel', 'maxFuel', 'locationIcao', 'locationName', 'destIcao', 'destName', 'lat', 'lon']) {
      expect(planes[0], `plane.${key}`).toHaveProperty(key);
    }
    expect(typeof planes[0].locationName).toBe('string');
    // The seeded starter is grounded — no flight destination yet.
    expect(planes[0].destIcao).toBeNull();
    expect(planes[0].destName).toBeNull();

    const packages = body.packages as Array<Record<string, unknown>>;
    expect(packages.length).toBeGreaterThan(0);
    for (const key of ['id', 'originIcao', 'destIcao', 'reward', 'cargoType', 'weightKg', 'distanceKm', 'deadlineSimTime', 'status']) {
      expect(packages[0], `package.${key}`).toHaveProperty(key);
    }

    // v0.48.0 (ISS-095): distanceKm is computed server-side — it must equal the haversine of the
    // fixture airports' coordinates for every package in the snapshot.
    const fc = await loadAirportsGeoJson();
    const coords = new Map(fc.features.map((f) => [f.properties.icao, f.properties]));
    for (const pkg of packages) {
      const from = coords.get(String(pkg.originIcao));
      const to = coords.get(String(pkg.destIcao));
      if (!from || !to) continue; // missing coord → 0 fallback (cannot happen with the committed dataset)
      expect(pkg.distanceKm, `package ${String(pkg.id)} distance`).toBeCloseTo(haversineKm(from.lat, from.lon, to.lat, to.lon), 6);
    }
  });

  it('is stable across repeated calls (same seeded DB)', async () => {
    const a = ((await GET(req())).json()) as Promise<{ account: { cash: number } }>;
    const b = ((await GET(req())).json()) as Promise<{ account: { cash: number } }>;
    expect((await b).account.cash).toBe((await a).account.cash);
  });

  it('exposes the catalog + economy constants matching lib/game/catalog.ts (v0.10.0)', async () => {
    const body = ((await GET(req())).json()) as Promise<{
      catalog: Array<Record<string, unknown>>;
      fuelPricePerL: number;
      sellFraction: number;
    }>;
    const snap = await body;

    // One entry per PLANE_TYPES model, values copied straight from the catalog.
    expect(snap.catalog.map((e) => e.model).sort()).toEqual(Object.keys(PLANE_TYPES).sort());
    for (const [model, type] of Object.entries(PLANE_TYPES)) {
      const entry = snap.catalog.find((e) => e.model === model)!;
      expect(entry.label).toBe(type.name);
      expect(entry.price).toBe(type.price);
      expect(entry.maxFuel).toBe(type.maxFuel);
      expect(entry.burnPerKm).toBe(type.burnPerKm);
      expect(entry.speedKmh).toBe(type.speedKmh);
      expect(entry.maxPayloadKg).toBe(type.maxPayloadKg); // v0.27.0 payload kg (ATR 72-600: 4800)
    }

    // Economy constants — the single source of truth stays lib/game/catalog.ts.
    expect(snap.fuelPricePerL).toBe(FUEL_PRICE_PER_L);
    expect(snap.sellFraction).toBe(SELL_FRACTION);
  });

  it('returns the SESSION player\'s economy in account, not the local one (v1.3.0, ISS-110)', async () => {
    const inst = await getGameDb();
    // A second account with a distinct economy — rows minted like /api/register does.
    const id = 'test-player-b';
    await inst.db.insert(schema.users).values({
      id, username: 'e2e-owner-b', passwordHash: hashPassword('unused'), admin: false, createdAt: Date.now(),
    });
    await inst.db.insert(schema.players).values({
      id, provider: 'local', username: 'e2e-owner-b', cash: 12_345.67, reputation: 42.5,
    });
    const sid = await createSession(inst, id);

    const res = await GET(new Request('http://localhost/api/state', { headers: { 'X-Flight-Session': sid } }));
    expect(res.status).toBe(200);
    const body = (await res.json()) as { account: { cash: number; reputation: number } };
    expect(body.account.cash).toBeCloseTo(12_345.67, 9); // the session player's row…
    expect(body.account.reputation).toBeCloseTo(42.5, 9); // …not the seeded local account
  });
});