kamilkrzywda
c77e81c45b
CI / build + unit + e2e (pull_request) Successful in 2m33s
Adds the sea ability: a fixed set of 12 named sea zones with sole-control semantics, contest-by-higher-military, and a deterministic per-turn +1 military/+1 economy bonus for each claimed zone. Durable (owns GameState.seaZones), additive migration, stub-inert (e2e unaffected). Fixes #65 Design note: Gitea #65 sketched a free-form 'naval' layer; the implemented approved design is this richer 'sea' layer with a fixed zone set.
448 lines
18 KiB
TypeScript
448 lines
18 KiB
TypeScript
// Unit tests for the DISASTERS & PANDEMICS ability (v0.41.0, #63) — the
|
|
// modular, turn-transient LLM-ability that applies a deterministic
|
|
// (type, severity) stat dip to a nation or a single region. This is the
|
|
// ability's own test file (the registry's cross-cutting guarantees — order,
|
|
// distinct fields, the system/user goldens — are covered by
|
|
// ./registry.test.ts). The stub never proposes a disaster, so the apply path
|
|
// is exercised here, not by the e2e suite.
|
|
|
|
import { describe, expect, it } from 'vitest';
|
|
|
|
import type { AbilityCtx } from './types';
|
|
import {
|
|
DISASTER_EFFECTS,
|
|
DISASTER_SEVERITIES,
|
|
DISASTER_TYPES,
|
|
applyDisasterEvent,
|
|
disasters,
|
|
isDisasterSeverity,
|
|
isDisasterType,
|
|
validateDisasterEvents,
|
|
} from './disasters';
|
|
|
|
import type { DisasterEvent, DisastersOps } from '../../shared/protocol';
|
|
import type { GameState, Nation, NationStats, RegionStats } from '../../shared/types';
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// Fixture helpers
|
|
// ---------------------------------------------------------------------------
|
|
|
|
/** Build a NationStats from the four canonical indices (military, economy, stability, population). */
|
|
function NS(military: number, economy: number, stability: number, population: number): NationStats {
|
|
return { military, economy, stability, population };
|
|
}
|
|
|
|
/** Build a RegionStats from the four canonical indices. */
|
|
function RS(military: number, economy: number, stability: number, population: number): RegionStats {
|
|
return { military, economy, stability, population };
|
|
}
|
|
|
|
/** A minimal nation: the given id/name/stats/region-key territory, neutral relations. */
|
|
function mkNation(id: string, name: string, stats: NationStats, territory: string[]): Nation {
|
|
return { id, name, type: 'major', stats, territory, relations: {} };
|
|
}
|
|
|
|
/**
|
|
* A minimal GameState carrying the given nations (keyed by id) and per-region
|
|
* stats. Every other required field is at its fresh-game baseline, so a test
|
|
* can focus purely on the disaster dip.
|
|
*/
|
|
function mkState(
|
|
nations: Record<string, Nation>,
|
|
regionStats: Record<string, RegionStats>,
|
|
): GameState {
|
|
return {
|
|
id: 'g1',
|
|
presetId: 'test',
|
|
presetTitle: 'Test',
|
|
playerNationId: Object.keys(nations)[0] ?? 'uk',
|
|
turn: 1,
|
|
date: '1939-09-01',
|
|
nations,
|
|
events: [],
|
|
pending: [],
|
|
version: 1,
|
|
unowned: [],
|
|
pendingNationOps: [],
|
|
markers: [],
|
|
regionStats,
|
|
wars: [],
|
|
trades: [],
|
|
embargoes: [],
|
|
industry: [],
|
|
// (v0.43.0, #65) no sea-zone control on a fresh state.
|
|
seaZones: [],
|
|
};
|
|
}
|
|
|
|
/** A minimal AbilityCtx for the ability's `apply` (no manifests loaded). */
|
|
function mkCtx(state: GameState, validRegionKeys?: ReadonlySet<string>): AbilityCtx {
|
|
return {
|
|
previous: state,
|
|
actingTurn: state.turn,
|
|
...(validRegionKeys ? { validRegionKeys } : {}),
|
|
};
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// Type / severity constants + predicates
|
|
// ---------------------------------------------------------------------------
|
|
|
|
describe('DISASTER_TYPES / DISASTER_SEVERITIES', () => {
|
|
it('exposes exactly the seven types and three severities', () => {
|
|
expect([...DISASTER_TYPES]).toEqual([
|
|
'earthquake',
|
|
'flood',
|
|
'volcanic',
|
|
'wildfire',
|
|
'famine',
|
|
'plague',
|
|
'epidemic',
|
|
]);
|
|
expect([...DISASTER_SEVERITIES]).toEqual(['minor', 'moderate', 'severe']);
|
|
});
|
|
|
|
it('every (type, severity) pair dips at least one stat, never population', () => {
|
|
for (const t of DISASTER_TYPES) {
|
|
for (const s of DISASTER_SEVERITIES) {
|
|
const dips = DISASTER_EFFECTS[t][s];
|
|
expect(dips).toBeDefined();
|
|
const keys = Object.keys(dips);
|
|
expect(keys.length).toBeGreaterThan(0);
|
|
expect(keys).not.toContain('population');
|
|
for (const k of keys) expect(dips[k as keyof typeof dips]).toBeLessThan(0);
|
|
}
|
|
}
|
|
});
|
|
});
|
|
|
|
describe('isDisasterType / isDisasterSeverity', () => {
|
|
it('accepts each known type and rejects unknown / non-strings', () => {
|
|
for (const t of DISASTER_TYPES) expect(isDisasterType(t)).toBe(true);
|
|
expect(isDisasterType('tsunami')).toBe(false);
|
|
expect(isDisasterType('Earthquake')).toBe(false); // case-sensitive
|
|
expect(isDisasterType('')).toBe(false);
|
|
expect(isDisasterType(42)).toBe(false);
|
|
expect(isDisasterType(null)).toBe(false);
|
|
expect(isDisasterType(undefined)).toBe(false);
|
|
});
|
|
|
|
it('accepts each known severity and rejects unknown / non-strings', () => {
|
|
for (const s of DISASTER_SEVERITIES) expect(isDisasterSeverity(s)).toBe(true);
|
|
expect(isDisasterSeverity('extreme')).toBe(false);
|
|
expect(isDisasterSeverity('Minor')).toBe(false); // case-sensitive
|
|
expect(isDisasterSeverity('')).toBe(false);
|
|
expect(isDisasterSeverity(3)).toBe(false);
|
|
expect(isDisasterSeverity(undefined)).toBe(false);
|
|
});
|
|
});
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// validateDisasterEvents
|
|
// ---------------------------------------------------------------------------
|
|
|
|
describe('validateDisasterEvents', () => {
|
|
const valid: DisasterEvent = { type: 'earthquake', target: 'uk', severity: 'severe' };
|
|
|
|
it('accepts the { events: [...] } shape', () => {
|
|
expect(validateDisasterEvents({ events: [valid] })).toEqual([valid]);
|
|
});
|
|
|
|
it('accepts a bare array (lenient about the wrapper)', () => {
|
|
expect(validateDisasterEvents([valid])).toEqual([valid]);
|
|
});
|
|
|
|
it('drops an event with an unknown type, keeping the valid one', () => {
|
|
const out = validateDisasterEvents({
|
|
events: [
|
|
{ type: 'tsunami', target: 'uk', severity: 'minor' },
|
|
valid,
|
|
],
|
|
});
|
|
expect(out).toEqual([valid]);
|
|
});
|
|
|
|
it('drops an event with a missing type', () => {
|
|
const out = validateDisasterEvents({
|
|
events: [{ target: 'uk', severity: 'minor' }, valid],
|
|
});
|
|
expect(out).toEqual([valid]);
|
|
});
|
|
|
|
it('drops an event with an unknown severity, keeping the valid one', () => {
|
|
const out = validateDisasterEvents({
|
|
events: [
|
|
{ type: 'plague', target: 'uk', severity: 'extreme' },
|
|
valid,
|
|
],
|
|
});
|
|
expect(out).toEqual([valid]);
|
|
});
|
|
|
|
it('drops an event with a missing severity', () => {
|
|
const out = validateDisasterEvents({
|
|
events: [{ type: 'plague', target: 'uk' }, valid],
|
|
});
|
|
expect(out).toEqual([valid]);
|
|
});
|
|
|
|
it('drops an event with an empty / whitespace target', () => {
|
|
const out = validateDisasterEvents({
|
|
events: [
|
|
{ type: 'plague', target: ' ', severity: 'minor' },
|
|
{ type: 'plague', target: '', severity: 'minor' },
|
|
valid,
|
|
],
|
|
});
|
|
expect(out).toEqual([valid]);
|
|
});
|
|
|
|
it('caps a non-empty detail at 300 chars and keeps a short one', () => {
|
|
const long = 'x'.repeat(500);
|
|
const out = validateDisasterEvents({
|
|
events: [
|
|
{ type: 'plague', target: 'uk', severity: 'minor', detail: long },
|
|
{ type: 'flood', target: 'de', severity: 'minor', detail: 'a short note' },
|
|
],
|
|
});
|
|
expect(out).toEqual([
|
|
{ type: 'plague', target: 'uk', severity: 'minor', detail: 'x'.repeat(300) },
|
|
{ type: 'flood', target: 'de', severity: 'minor', detail: 'a short note' },
|
|
]);
|
|
});
|
|
|
|
it('omits the detail key entirely when detail is empty / missing', () => {
|
|
const out = validateDisasterEvents({
|
|
events: [
|
|
{ type: 'flood', target: 'uk', severity: 'minor', detail: '' },
|
|
{ type: 'flood', target: 'de', severity: 'minor' },
|
|
],
|
|
});
|
|
expect(out).toEqual([
|
|
{ type: 'flood', target: 'uk', severity: 'minor' },
|
|
{ type: 'flood', target: 'de', severity: 'minor' },
|
|
]);
|
|
expect(out[0]).not.toHaveProperty('detail');
|
|
});
|
|
|
|
it('drops non-object event entries', () => {
|
|
const out = validateDisasterEvents({ events: ['not-an-object', 7, null, valid] });
|
|
expect(out).toEqual([valid]);
|
|
});
|
|
|
|
it('yields { events: [] } (here, []) for a missing / malformed top-level value', () => {
|
|
expect(validateDisasterEvents(undefined)).toEqual([]);
|
|
expect(validateDisasterEvents(null)).toEqual([]);
|
|
expect(validateDisasterEvents('nope')).toEqual([]);
|
|
expect(validateDisasterEvents(5)).toEqual([]);
|
|
expect(validateDisasterEvents({})).toEqual([]);
|
|
expect(validateDisasterEvents({ events: 'not-an-array' })).toEqual([]);
|
|
});
|
|
});
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// applyDisasterEvent — the deterministic dip
|
|
// ---------------------------------------------------------------------------
|
|
|
|
describe('applyDisasterEvent', () => {
|
|
it('a nation target: dips the nation AND every region it owns, then re-derives (identical values pass through)', () => {
|
|
// uk owns three identical regions; all stats identical → the re-derived
|
|
// aggregate equals the dipped values exactly.
|
|
const state = mkState(
|
|
{ uk: mkNation('uk', 'UK', NS(50, 50, 50, 50), ['g1', 'g2', 'g3']) },
|
|
{ g1: RS(50, 50, 50, 50), g2: RS(50, 50, 50, 50), g3: RS(50, 50, 50, 50) },
|
|
);
|
|
applyDisasterEvent(state, { type: 'earthquake', target: 'uk', severity: 'moderate' });
|
|
// earthquake moderate = stability -4, economy -4 (military / population untouched)
|
|
expect(state.nations.uk.stats).toEqual(NS(50, 46, 46, 50));
|
|
for (const k of ['g1', 'g2', 'g3']) expect(state.regionStats[k]).toEqual(RS(50, 46, 46, 50));
|
|
});
|
|
|
|
it('a region target: dips ONLY the named region (the sibling region is untouched)', () => {
|
|
// uk owns g1 and g2 (identical). Target the region key g1 → only g1 dips.
|
|
const state = mkState(
|
|
{ uk: mkNation('uk', 'UK', NS(50, 50, 50, 50), ['g1', 'g2']) },
|
|
{ g1: RS(50, 50, 50, 50), g2: RS(50, 50, 50, 50) },
|
|
);
|
|
applyDisasterEvent(state, { type: 'wildfire', target: 'g1', severity: 'severe' });
|
|
// wildfire severe = economy -7 only
|
|
expect(state.regionStats.g1).toEqual(RS(50, 43, 50, 50));
|
|
expect(state.regionStats.g2).toEqual(RS(50, 50, 50, 50)); // untouched
|
|
// re-derive (equal weights, min-biased median) → the nation takes the dipped value
|
|
expect(state.nations.uk.stats).toEqual(NS(50, 43, 50, 50));
|
|
});
|
|
|
|
it('a region target resolved by a validKeys-gated key hits its sole owner', () => {
|
|
const state = mkState(
|
|
{ uk: mkNation('uk', 'UK', NS(50, 50, 50, 50), ['g1']) },
|
|
{ g1: RS(50, 50, 50, 50) },
|
|
);
|
|
applyDisasterEvent(
|
|
state,
|
|
{ type: 'famine', target: 'g1', severity: 'moderate' },
|
|
undefined,
|
|
new Set(['g1']),
|
|
);
|
|
// famine moderate = economy -4, stability -4
|
|
expect(state.regionStats.g1).toEqual(RS(50, 46, 46, 50));
|
|
expect(state.nations.uk.stats).toEqual(NS(50, 46, 46, 50));
|
|
});
|
|
|
|
it('clamps every dip at 0 (never negative)', () => {
|
|
// low stability + military; a severe plague (stability -9, military -6) floors both.
|
|
const state = mkState(
|
|
{ uk: mkNation('uk', 'UK', NS(3, 50, 3, 50), ['g1']) },
|
|
{ g1: RS(3, 50, 3, 50) },
|
|
);
|
|
applyDisasterEvent(state, { type: 'plague', target: 'uk', severity: 'severe' });
|
|
expect(state.nations.uk.stats).toEqual(NS(0, 50, 0, 50));
|
|
expect(state.regionStats.g1).toEqual(RS(0, 50, 0, 50));
|
|
});
|
|
|
|
it('a 0-owner region is untargetable (the event is dropped, nothing dips)', () => {
|
|
// 'x1' is owned by nobody; no validKeys supplied, so the owners check drops it.
|
|
const state = mkState(
|
|
{ uk: mkNation('uk', 'UK', NS(50, 50, 50, 50), ['g1']) },
|
|
{ g1: RS(50, 50, 50, 50) },
|
|
);
|
|
applyDisasterEvent(state, { type: 'plague', target: 'x1', severity: 'severe' });
|
|
expect(state.nations.uk.stats).toEqual(NS(50, 50, 50, 50)); // untouched
|
|
expect(state.regionStats.g1).toEqual(RS(50, 50, 50, 50));
|
|
});
|
|
|
|
it('a region with 2+ owners is untargetable (the event is dropped, neither dips)', () => {
|
|
// corrupt double-ownership of 'y1'
|
|
const state = mkState(
|
|
{
|
|
uk: mkNation('uk', 'UK', NS(50, 50, 50, 50), ['y1']),
|
|
de: mkNation('de', 'DE', NS(60, 60, 60, 60), ['y1']),
|
|
},
|
|
{ y1: RS(50, 50, 50, 50) },
|
|
);
|
|
applyDisasterEvent(state, { type: 'plague', target: 'y1', severity: 'severe' });
|
|
expect(state.nations.uk.stats).toEqual(NS(50, 50, 50, 50)); // untouched
|
|
expect(state.nations.de.stats).toEqual(NS(60, 60, 60, 60)); // untouched
|
|
});
|
|
|
|
it('an unknown region key (gated by validKeys) is dropped', () => {
|
|
const state = mkState(
|
|
{ uk: mkNation('uk', 'UK', NS(50, 50, 50, 50), ['g1']) },
|
|
{ g1: RS(50, 50, 50, 50) },
|
|
);
|
|
// 'zzz' is not in the manifest → dropped before the owners check.
|
|
applyDisasterEvent(state, { type: 'plague', target: 'zzz', severity: 'severe' }, undefined, new Set(['g1']));
|
|
expect(state.nations.uk.stats).toEqual(NS(50, 50, 50, 50));
|
|
});
|
|
|
|
it('an unknown nation reference is dropped (no throw, no dip)', () => {
|
|
const state = mkState(
|
|
{ uk: mkNation('uk', 'UK', NS(50, 50, 50, 50), ['g1']) },
|
|
{ g1: RS(50, 50, 50, 50) },
|
|
);
|
|
applyDisasterEvent(state, { type: 'plague', target: 'ghost', severity: 'severe' });
|
|
expect(state.nations.uk.stats).toEqual(NS(50, 50, 50, 50));
|
|
expect(state.regionStats.g1).toEqual(RS(50, 50, 50, 50));
|
|
});
|
|
|
|
it('an ambiguous nation reference (two share the name) is dropped', () => {
|
|
const state = mkState(
|
|
{
|
|
a: mkNation('a', 'Same', NS(50, 50, 50, 50), ['g1']),
|
|
b: mkNation('b', 'Same', NS(70, 70, 70, 70), ['d1']),
|
|
},
|
|
{ g1: RS(50, 50, 50, 50), d1: RS(70, 70, 70, 70) },
|
|
);
|
|
applyDisasterEvent(state, { type: 'plague', target: 'Same', severity: 'severe' });
|
|
expect(state.nations.a.stats).toEqual(NS(50, 50, 50, 50)); // untouched
|
|
expect(state.nations.b.stats).toEqual(NS(70, 70, 70, 70)); // untouched
|
|
});
|
|
|
|
it('resolves a nation by (case-insensitive) name, not just id', () => {
|
|
const state = mkState(
|
|
{ uk: mkNation('uk', 'United Kingdom', NS(50, 50, 50, 50), ['g1']) },
|
|
{ g1: RS(50, 50, 50, 50) },
|
|
);
|
|
applyDisasterEvent(state, { type: 'epidemic', target: 'united kingdom', severity: 'moderate' });
|
|
// epidemic moderate = stability -4, military -2
|
|
expect(state.nations.uk.stats).toEqual(NS(48, 50, 46, 50));
|
|
expect(state.regionStats.g1).toEqual(RS(48, 50, 46, 50));
|
|
});
|
|
|
|
it('a 0-region nation keeps its directly-dipped stats (no re-derive to zero)', () => {
|
|
const iso = mkNation('iso', 'Iso', NS(50, 50, 50, 50), []);
|
|
const state = mkState({ iso }, {});
|
|
applyDisasterEvent(state, { type: 'epidemic', target: 'iso', severity: 'moderate' });
|
|
// epidemic moderate = stability -4, military -2 — the direct dip persists
|
|
expect(state.nations.iso.stats).toEqual(NS(48, 50, 46, 50));
|
|
expect(state.regionStats).toEqual({});
|
|
});
|
|
|
|
it('a region with no regionStats entry is skipped (the nation still dips + re-derives from its other regions)', () => {
|
|
// uk owns g1 (has stats) and g2 (no entry). Target the nation → the dip
|
|
// mirrors to g1 only (g2 has no entry to dip); re-derive uses g1 alone.
|
|
const state = mkState(
|
|
{ uk: mkNation('uk', 'UK', NS(50, 50, 50, 50), ['g1', 'g2']) },
|
|
{ g1: RS(50, 50, 50, 50) },
|
|
);
|
|
applyDisasterEvent(state, { type: 'earthquake', target: 'uk', severity: 'moderate' });
|
|
expect(state.regionStats.g1).toEqual(RS(50, 46, 46, 50));
|
|
expect(state.regionStats).not.toHaveProperty('g2'); // never created
|
|
expect(state.nations.uk.stats).toEqual(NS(50, 46, 46, 50));
|
|
});
|
|
});
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// The Ability object
|
|
// ---------------------------------------------------------------------------
|
|
|
|
describe('disasters (Ability)', () => {
|
|
it('owns the "disasters" field and declares NO durable state fields (turn-transient)', () => {
|
|
expect(disasters.field).toBe('disasters');
|
|
expect(disasters.stateFields).toBeUndefined();
|
|
});
|
|
|
|
it('default() and stub() are fresh, empty { events: [] } values', () => {
|
|
expect(disasters.default()).toEqual({ events: [] });
|
|
expect(disasters.stub()).toEqual({ events: [] });
|
|
// fresh on every call (never a shared mutable reference)
|
|
expect(disasters.default()).not.toBe(disasters.default());
|
|
expect(disasters.default().events).not.toBe(disasters.default().events);
|
|
expect(disasters.stub()).not.toBe(disasters.stub());
|
|
});
|
|
|
|
it('isMeaningful is true iff there is at least one event', () => {
|
|
expect(disasters.isMeaningful({ events: [] })).toBe(false);
|
|
expect(disasters.isMeaningful({ events: [{ type: 'plague', target: 'uk', severity: 'minor' }] })).toBe(
|
|
true,
|
|
);
|
|
});
|
|
|
|
it('payload() is always empty (the layer is turn-transient)', () => {
|
|
const state = mkState(
|
|
{ uk: mkNation('uk', 'UK', NS(50, 50, 50, 50), ['g1']) },
|
|
{ g1: RS(50, 50, 50, 50) },
|
|
);
|
|
expect(disasters.payload({ state })).toEqual({});
|
|
});
|
|
|
|
it('validate() wraps the low-level validator into the { events } field shape', () => {
|
|
const valid = { type: 'flood', target: 'uk', severity: 'minor' } as DisasterEvent;
|
|
expect(disasters.validate({ events: [valid] })).toEqual({ events: [valid] });
|
|
expect(disasters.validate(undefined)).toEqual({ events: [] });
|
|
expect(disasters.validate([valid])).toEqual({ events: [valid] }); // bare array leniency
|
|
});
|
|
|
|
it('apply() wires ctx.geoOf + ctx.validRegionKeys through to the dip', () => {
|
|
const state = mkState(
|
|
{ uk: mkNation('uk', 'UK', NS(50, 50, 50, 50), ['g1']) },
|
|
{ g1: RS(50, 50, 50, 50) },
|
|
);
|
|
const ctx = mkCtx(state, new Set(['g1']));
|
|
const data: DisastersOps = { events: [{ type: 'volcanic', target: 'g1', severity: 'moderate' }] };
|
|
disasters.apply(state, data, ctx);
|
|
// volcanic moderate = economy -4, stability -3
|
|
expect(state.regionStats.g1).toEqual(RS(50, 46, 47, 50));
|
|
expect(state.nations.uk.stats).toEqual(NS(50, 46, 47, 50));
|
|
});
|
|
});
|