255 lines
9.3 KiB
TypeScript
255 lines
9.3 KiB
TypeScript
import { describe, expect, it, vi } from 'vitest';
|
|
|
|
import type { GamePrismaClient } from '@sammo-ts/infra';
|
|
import { InMemoryTurnWorld } from '../src/turn/inMemoryWorld.js';
|
|
import { applyRuntimeClockShift } from '../src/turn/runtimeClockShift.js';
|
|
import type { TurnGeneral, TurnWorldSnapshot, TurnWorldState } from '../src/turn/types.js';
|
|
|
|
const buildGeneral = (id: number, turnTime: string): TurnGeneral =>
|
|
({
|
|
id,
|
|
name: `General_${id}`,
|
|
nationId: 1,
|
|
cityId: 1,
|
|
troopId: 0,
|
|
stats: { leadership: 50, strength: 50, intelligence: 50 },
|
|
turnTime: new Date(turnTime),
|
|
role: {
|
|
items: { horse: null, weapon: null, book: null, item: null },
|
|
personality: null,
|
|
specialDomestic: null,
|
|
specialWar: null,
|
|
},
|
|
triggerState: { flags: {}, counters: {}, modifiers: {}, meta: {} },
|
|
meta: { killturn: 24 },
|
|
officerLevel: 5,
|
|
experience: 0,
|
|
dedication: 0,
|
|
injury: 0,
|
|
gold: 1000,
|
|
rice: 1000,
|
|
crew: 0,
|
|
crewTypeId: 0,
|
|
train: 0,
|
|
atmos: 0,
|
|
age: 30,
|
|
npcState: 0,
|
|
}) as TurnGeneral;
|
|
|
|
const buildWorld = (): InMemoryTurnWorld => {
|
|
const state: TurnWorldState = {
|
|
id: 1,
|
|
currentYear: 190,
|
|
currentMonth: 1,
|
|
tickSeconds: 600,
|
|
lastTurnTime: new Date('2026-07-30T10:00:00.000Z'),
|
|
meta: {
|
|
lastTurnTime: '2026-07-30T10:00:00.000Z',
|
|
turntime: '2026-07-30 10:00:00.123456',
|
|
starttime: '2026-07-01 00:00:00',
|
|
tnmt_time: '2026-07-30 11:30:00',
|
|
untouched: 'keep',
|
|
},
|
|
};
|
|
const snapshot: TurnWorldSnapshot = {
|
|
generals: [buildGeneral(1, '2026-07-30T10:10:00.000Z'), buildGeneral(2, '2026-07-30T10:20:00.000Z')],
|
|
cities: [],
|
|
nations: [],
|
|
troops: [],
|
|
diplomacy: [],
|
|
events: [],
|
|
initialEvents: [],
|
|
map: {
|
|
id: 'test',
|
|
name: 'test',
|
|
cities: [],
|
|
defaults: { trust: 50, trade: 100, supplyState: 1, frontState: 0 },
|
|
},
|
|
scenarioConfig: {
|
|
stat: { total: 300, min: 10, max: 100, npcTotal: 150, npcMax: 50, npcMin: 10, chiefMin: 70 },
|
|
iconPath: '',
|
|
map: {},
|
|
const: {},
|
|
environment: { mapName: 'test', unitSet: 'default' },
|
|
},
|
|
};
|
|
return new InMemoryTurnWorld(state, snapshot, {
|
|
schedule: { entries: [{ startMinute: 0, tickMinutes: 10 }] },
|
|
});
|
|
};
|
|
|
|
describe('runtime clock shift', () => {
|
|
it.each([
|
|
['accelerates', -15, '2026-07-30T09:45:00.000Z', '2026-07-30T09:55:00.000Z'],
|
|
['delays', 15, '2026-07-30T10:15:00.000Z', '2026-07-30T10:25:00.000Z'],
|
|
] as const)('%s the world, every general, checkpoint, and pending auction together', (_, delta, last, general) => {
|
|
const world = buildWorld();
|
|
world.setCheckpoint({ turnTime: '2026-07-30T10:10:00.000Z', generalId: 1, year: 190, month: 1 });
|
|
world.queueNeutralAuction({
|
|
registrationKey: 'test',
|
|
type: 'BUY_RICE',
|
|
targetCode: 'rice',
|
|
hostGeneralId: 0,
|
|
hostName: '상인',
|
|
detail: {},
|
|
closeAt: new Date('2026-07-30T12:00:00.000Z'),
|
|
});
|
|
|
|
const result = world.shiftSchedule(delta);
|
|
|
|
expect(result).toEqual({ shiftedGenerals: 2, lastTurnTime: last });
|
|
expect(world.getState()).toMatchObject({
|
|
currentYear: 190,
|
|
currentMonth: 1,
|
|
lastTurnTime: new Date(last),
|
|
meta: {
|
|
lastTurnTime: last,
|
|
untouched: 'keep',
|
|
},
|
|
});
|
|
expect(world.getGeneralById(1)?.turnTime.toISOString()).toBe(general);
|
|
expect(world.getCheckpoint()?.turnTime).toBe(general);
|
|
const pendingCloseAt = world.peekDirtyState().pendingNeutralAuctions[0]?.closeAt;
|
|
expect(pendingCloseAt?.toISOString()).toBe(
|
|
new Date(new Date('2026-07-30T12:00:00.000Z').getTime() + delta * 60_000).toISOString()
|
|
);
|
|
expect(world.peekDirtyState().generals.map((entry) => entry.id)).toEqual([1, 2]);
|
|
});
|
|
|
|
it.each([0, 1.5, Number.NaN])('rejects an invalid shift without mutation: %s', (delta) => {
|
|
const world = buildWorld();
|
|
expect(() => world.shiftSchedule(delta)).toThrow();
|
|
expect(world.getState().lastTurnTime.toISOString()).toBe('2026-07-30T10:00:00.000Z');
|
|
expect(world.peekDirtyState().generals).toEqual([]);
|
|
});
|
|
|
|
it('keeps legacy wall-clock metadata independent from the process timezone', () => {
|
|
const world = buildWorld();
|
|
|
|
world.shiftSchedule(-15);
|
|
|
|
expect(world.getState().meta).toMatchObject({
|
|
turntime: '2026-07-30 09:45:00.123456',
|
|
starttime: '2026-06-30 23:45:00',
|
|
tnmt_time: '2026-07-30 11:15:00',
|
|
});
|
|
});
|
|
});
|
|
|
|
describe('runtime clock shift projection', () => {
|
|
it('waits for the durable engine event and applies Redis projections idempotently', async () => {
|
|
const actionId = '68f1f0e4-3b95-4aeb-9925-c7e93caf1ba7';
|
|
let eventStatus: 'PENDING' | 'SUCCEEDED' = 'PENDING';
|
|
let created = false;
|
|
const inputEventCreate = vi.fn(async () => {
|
|
if (created) {
|
|
throw { code: 'P2002' };
|
|
}
|
|
created = true;
|
|
return {};
|
|
});
|
|
const db = {
|
|
inputEvent: {
|
|
create: inputEventCreate,
|
|
findUniqueOrThrow: vi.fn(async () =>
|
|
eventStatus === 'PENDING'
|
|
? {
|
|
eventType: 'shiftSchedule',
|
|
payload: {
|
|
type: 'shiftSchedule',
|
|
actionId,
|
|
deltaMinutes: -15,
|
|
},
|
|
status: 'PENDING',
|
|
result: null,
|
|
error: null,
|
|
}
|
|
: {
|
|
eventType: 'shiftSchedule',
|
|
payload: {
|
|
type: 'shiftSchedule',
|
|
actionId,
|
|
deltaMinutes: -15,
|
|
},
|
|
status: 'SUCCEEDED',
|
|
result: {
|
|
type: 'shiftSchedule',
|
|
ok: true,
|
|
actionId,
|
|
deltaMinutes: -15,
|
|
lastTurnTime: '2026-07-30T09:45:00.000Z',
|
|
shiftedGenerals: 2,
|
|
shiftedAuctions: 1,
|
|
},
|
|
error: null,
|
|
}
|
|
),
|
|
},
|
|
auction: {
|
|
findMany: vi.fn(async () => [{ id: 7, closeAt: new Date('2026-07-30T11:45:00.000Z') }]),
|
|
},
|
|
} as unknown as GamePrismaClient;
|
|
const values = new Map<string, string>([
|
|
[
|
|
'sammo:hwe:default:tournament:state',
|
|
JSON.stringify({
|
|
stage: 1,
|
|
nextAt: '2026-07-30T12:00:00.000Z',
|
|
bettingCloseAt: '2026-07-30T11:30:00.000Z',
|
|
}),
|
|
],
|
|
]);
|
|
const zAdd = vi.fn(async () => 1);
|
|
const redis = {
|
|
get: async (key: string) => values.get(key) ?? null,
|
|
set: async (
|
|
key: string,
|
|
value: string,
|
|
options?: {
|
|
NX?: boolean;
|
|
PX?: number;
|
|
}
|
|
) => {
|
|
if (options?.NX && values.has(key)) {
|
|
return null;
|
|
}
|
|
values.set(key, value);
|
|
return 'OK';
|
|
},
|
|
del: async (key: string) => (values.delete(key) ? 1 : 0),
|
|
zAdd,
|
|
};
|
|
const action = {
|
|
id: actionId,
|
|
profileName: 'hwe:default',
|
|
action: 'ACCELERATE',
|
|
durationMinutes: 15,
|
|
};
|
|
|
|
await expect(applyRuntimeClockShift({ action, profileName: 'hwe:default', db, redis })).resolves.toMatchObject({
|
|
status: 'REQUESTED',
|
|
});
|
|
expect(zAdd).not.toHaveBeenCalled();
|
|
|
|
eventStatus = 'SUCCEEDED';
|
|
await expect(applyRuntimeClockShift({ action, profileName: 'hwe:default', db, redis })).resolves.toMatchObject({
|
|
status: 'APPLIED',
|
|
});
|
|
await expect(applyRuntimeClockShift({ action, profileName: 'hwe:default', db, redis })).resolves.toMatchObject({
|
|
status: 'APPLIED',
|
|
});
|
|
|
|
const tournament = JSON.parse(values.get('sammo:hwe:default:tournament:state') ?? '{}') as Record<
|
|
string,
|
|
unknown
|
|
>;
|
|
expect(tournament).toMatchObject({
|
|
nextAt: '2026-07-30T11:45:00.000Z',
|
|
bettingCloseAt: '2026-07-30T11:15:00.000Z',
|
|
runtimeClockShiftActionIds: [actionId],
|
|
});
|
|
expect(zAdd).toHaveBeenCalledTimes(2);
|
|
expect(inputEventCreate).toHaveBeenCalledTimes(3);
|
|
});
|
|
});
|