461 lines
17 KiB
TypeScript
461 lines
17 KiB
TypeScript
import { afterAll, beforeAll, describe, expect, it } from 'vitest';
|
|
|
|
import type { TurnDaemonCommand, TurnDaemonCommandResult } from '@sammo-ts/common';
|
|
import { createGamePostgresConnector, type GamePrisma, type GamePrismaClient } from '@sammo-ts/infra';
|
|
import type { MapDefinition, ScenarioConfig, ScenarioMeta, TurnSchedule } from '@sammo-ts/logic';
|
|
|
|
import { createDatabaseTurnHooks, type DatabaseTurnHooks } from '../src/turn/databaseHooks.js';
|
|
import { EngineStateManager } from '../src/turn/engineStateManager.js';
|
|
import { InMemoryTurnWorld } from '../src/turn/inMemoryWorld.js';
|
|
import type { TurnGeneral, TurnWorldSnapshot, TurnWorldState } from '../src/turn/types.js';
|
|
import { createTurnDaemonCommandHandler } from '../src/turn/worldCommandHandler.js';
|
|
import { loadTurnWorldFromDatabase } from '../src/turn/worldLoader.js';
|
|
|
|
const databaseUrl = process.env.IMMEDIATE_ACTION_DATABASE_URL;
|
|
const integration = describe.skipIf(!databaseUrl);
|
|
const worldId = 991_741;
|
|
const targetGeneralId = 991_741;
|
|
const npcGeneralId = 991_742;
|
|
const foreignGeneralId = 991_743;
|
|
const rollbackRequestId = 'integration:engine:account-icon:rollback';
|
|
const actorMismatchRequestId = 'integration:engine:account-icon:actor-mismatch';
|
|
const successRequestId = 'integration:engine:account-icon:success';
|
|
const noGeneralRequestId = 'integration:engine:account-icon:no-general';
|
|
const rollbackConstraint = 'account_icon_rollback_test';
|
|
const targetUserId = 'account-icon-target-user';
|
|
const npcUserId = 'account-icon-npc-user';
|
|
const foreignUserId = 'account-icon-foreign-user';
|
|
const initialPicture = 'account-icon-old.jpg';
|
|
const initialImageServer = 0;
|
|
const nextPicture = 'account-icon-new.png';
|
|
const nextImageServer = 1;
|
|
const rollbackRevision = '2026-07-31T09:05:00.000Z';
|
|
const successRevision = '2026-07-31T09:10:00.000Z';
|
|
const schedule: TurnSchedule = { entries: [{ startMinute: 0, tickMinutes: 10 }] };
|
|
|
|
const assertDedicatedDatabase = (rawUrl: string): void => {
|
|
const schema = new URL(rawUrl).searchParams.get('schema');
|
|
if (!schema?.endsWith('immediate_action_integration')) {
|
|
throw new Error(`Refusing to mutate non-dedicated schema: ${schema ?? '(missing)'}`);
|
|
}
|
|
};
|
|
|
|
const scenarioConfig: ScenarioConfig = {
|
|
stat: { total: 300, min: 10, max: 100, npcTotal: 150, npcMax: 50, npcMin: 10, chiefMin: 65 },
|
|
iconPath: '',
|
|
map: {},
|
|
const: {},
|
|
environment: {
|
|
mapName: 'che',
|
|
unitSet: 'che',
|
|
},
|
|
};
|
|
|
|
const scenarioMeta: ScenarioMeta = {
|
|
title: '계정 아이콘 영속성 통합',
|
|
startYear: 190,
|
|
life: null,
|
|
fiction: null,
|
|
history: [],
|
|
ignoreDefaultEvents: false,
|
|
};
|
|
|
|
const map: MapDefinition = {
|
|
id: 'account-icon-integration',
|
|
name: '계정 아이콘 영속성 통합',
|
|
cities: [],
|
|
};
|
|
|
|
const state: TurnWorldState = {
|
|
id: worldId,
|
|
currentYear: 190,
|
|
currentMonth: 1,
|
|
tickSeconds: 600,
|
|
lastTurnTime: new Date('2026-07-31T09:00:00.000Z'),
|
|
meta: {
|
|
killturn: 24,
|
|
lastTurnTime: '2026-07-31T09:00:00.000Z',
|
|
scenarioMeta,
|
|
},
|
|
};
|
|
|
|
const buildGeneral = (overrides: Partial<TurnGeneral>): TurnGeneral => ({
|
|
id: targetGeneralId,
|
|
userId: targetUserId,
|
|
name: '아이콘통합장수',
|
|
nationId: 0,
|
|
cityId: 0,
|
|
troopId: 0,
|
|
stats: { leadership: 50, strength: 50, intelligence: 50 },
|
|
turnTime: new Date('2026-07-31T09:10:00.000Z'),
|
|
recentWarTime: null,
|
|
role: {
|
|
items: { horse: null, weapon: null, book: null, item: null },
|
|
personality: null,
|
|
specialDomestic: null,
|
|
specialWar: null,
|
|
},
|
|
triggerState: { flags: {}, counters: {}, modifiers: {}, meta: {} },
|
|
meta: { killturn: 24, preserved: 'yes' },
|
|
penalty: {},
|
|
officerLevel: 0,
|
|
experience: 0,
|
|
dedication: 0,
|
|
injury: 0,
|
|
gold: 1_000,
|
|
rice: 1_000,
|
|
crew: 0,
|
|
crewTypeId: 0,
|
|
train: 0,
|
|
atmos: 0,
|
|
age: 20,
|
|
npcState: 0,
|
|
picture: initialPicture,
|
|
imageServer: initialImageServer,
|
|
...overrides,
|
|
});
|
|
|
|
const targetGeneral = buildGeneral({});
|
|
const npcGeneral = buildGeneral({
|
|
id: npcGeneralId,
|
|
userId: npcUserId,
|
|
name: '빙의NPC',
|
|
npcState: 1,
|
|
});
|
|
const foreignGeneral = buildGeneral({
|
|
id: foreignGeneralId,
|
|
userId: foreignUserId,
|
|
name: '타사용자장수',
|
|
});
|
|
const generals = [targetGeneral, npcGeneral, foreignGeneral];
|
|
|
|
const buildCommand = (
|
|
requestId: string,
|
|
userId: string,
|
|
iconRevision: string,
|
|
picture = nextPicture,
|
|
imageServer = nextImageServer
|
|
): Extract<TurnDaemonCommand, { type: 'adjustGeneralIcon' }> => ({
|
|
type: 'adjustGeneralIcon',
|
|
requestId,
|
|
userId,
|
|
picture,
|
|
imageServer,
|
|
iconRevision,
|
|
});
|
|
|
|
const toGeneralCreate = (general: TurnGeneral): GamePrisma.GeneralCreateManyInput => ({
|
|
id: general.id,
|
|
userId: general.userId,
|
|
name: general.name,
|
|
nationId: general.nationId,
|
|
cityId: general.cityId,
|
|
troopId: general.troopId,
|
|
npcState: general.npcState,
|
|
leadership: general.stats.leadership,
|
|
strength: general.stats.strength,
|
|
intel: general.stats.intelligence,
|
|
officerLevel: general.officerLevel,
|
|
experience: general.experience,
|
|
dedication: general.dedication,
|
|
injury: general.injury,
|
|
gold: general.gold,
|
|
rice: general.rice,
|
|
crew: general.crew,
|
|
crewTypeId: general.crewTypeId,
|
|
train: general.train,
|
|
atmos: general.atmos,
|
|
turnTime: general.turnTime,
|
|
recentWarTime: general.recentWarTime,
|
|
age: general.age,
|
|
picture: general.picture,
|
|
imageServer: general.imageServer,
|
|
meta: general.meta as GamePrisma.InputJsonValue,
|
|
penalty: general.penalty as GamePrisma.InputJsonValue,
|
|
});
|
|
|
|
integration('adjustGeneralIcon PostgreSQL persistence', () => {
|
|
let db: GamePrismaClient;
|
|
let disconnect: (() => Promise<void>) | undefined;
|
|
let hooks: DatabaseTurnHooks | undefined;
|
|
|
|
beforeAll(async () => {
|
|
assertDedicatedDatabase(databaseUrl!);
|
|
const connector = createGamePostgresConnector({ url: databaseUrl! });
|
|
await connector.connect();
|
|
db = connector.prisma;
|
|
disconnect = () => connector.disconnect();
|
|
|
|
await db.$executeRawUnsafe(`ALTER TABLE input_event DROP CONSTRAINT IF EXISTS ${rollbackConstraint}`);
|
|
await db.inputEvent.deleteMany({
|
|
where: {
|
|
requestId: {
|
|
in: [rollbackRequestId, actorMismatchRequestId, successRequestId, noGeneralRequestId],
|
|
},
|
|
},
|
|
});
|
|
await db.rankData.deleteMany({
|
|
where: { generalId: { in: generals.map((general) => general.id) } },
|
|
});
|
|
await db.general.deleteMany({
|
|
where: { id: { in: generals.map((general) => general.id) } },
|
|
});
|
|
await db.worldState.deleteMany({ where: { id: worldId } });
|
|
|
|
await db.worldState.create({
|
|
data: {
|
|
id: worldId,
|
|
scenarioCode: 'account-icon-integration',
|
|
currentYear: state.currentYear,
|
|
currentMonth: state.currentMonth,
|
|
tickSeconds: state.tickSeconds,
|
|
config: JSON.parse(JSON.stringify(scenarioConfig)) as GamePrisma.InputJsonValue,
|
|
meta: state.meta as GamePrisma.InputJsonValue,
|
|
},
|
|
});
|
|
await db.general.createMany({
|
|
data: generals.map(toGeneralCreate),
|
|
});
|
|
});
|
|
|
|
afterAll(async () => {
|
|
await hooks?.close();
|
|
if (!db) {
|
|
await disconnect?.();
|
|
return;
|
|
}
|
|
await db.$executeRawUnsafe(`ALTER TABLE input_event DROP CONSTRAINT IF EXISTS ${rollbackConstraint}`);
|
|
await db.inputEvent.deleteMany({
|
|
where: {
|
|
requestId: {
|
|
in: [rollbackRequestId, actorMismatchRequestId, successRequestId, noGeneralRequestId],
|
|
},
|
|
},
|
|
});
|
|
await db.rankData.deleteMany({
|
|
where: { generalId: { in: generals.map((general) => general.id) } },
|
|
});
|
|
await db.general.deleteMany({
|
|
where: { id: { in: generals.map((general) => general.id) } },
|
|
});
|
|
await db.worldState.deleteMany({ where: { id: worldId } });
|
|
await disconnect?.();
|
|
});
|
|
|
|
it('commits the authenticated human icon with input_event and rolls both back on failure', async () => {
|
|
const snapshot: TurnWorldSnapshot = {
|
|
generals,
|
|
cities: [],
|
|
nations: [],
|
|
troops: [],
|
|
diplomacy: [],
|
|
events: [],
|
|
initialEvents: [],
|
|
scenarioConfig,
|
|
scenarioMeta,
|
|
map,
|
|
};
|
|
const world = new InMemoryTurnWorld(state, snapshot, { schedule });
|
|
const handler = createTurnDaemonCommandHandler({ world });
|
|
hooks = await createDatabaseTurnHooks(databaseUrl!, world);
|
|
const stateManager = new EngineStateManager();
|
|
stateManager.register('world', {
|
|
capture: () => world.captureState(),
|
|
restore: (captured) => world.restoreState(captured),
|
|
});
|
|
const execute = async (
|
|
command: Extract<TurnDaemonCommand, { type: 'adjustGeneralIcon' }>
|
|
): Promise<TurnDaemonCommandResult> => {
|
|
if (!hooks?.hooks.executeCommand || !command.requestId) {
|
|
throw new Error('Database command execution hook is unavailable.');
|
|
}
|
|
return stateManager.transaction(() =>
|
|
hooks!.hooks.executeCommand!(command.requestId!, async (context) => {
|
|
const result = await handler.handle(command, context);
|
|
if (!result) {
|
|
throw new Error('adjustGeneralIcon command was not handled.');
|
|
}
|
|
return result;
|
|
})
|
|
);
|
|
};
|
|
const createInputEvent = async (
|
|
command: Extract<TurnDaemonCommand, { type: 'adjustGeneralIcon' }>,
|
|
actorUserId = command.userId
|
|
): Promise<void> => {
|
|
await db.inputEvent.create({
|
|
data: {
|
|
requestId: command.requestId!,
|
|
target: 'ENGINE',
|
|
eventType: command.type,
|
|
actorUserId,
|
|
status: 'PROCESSING',
|
|
lockedBy: 'account-icon-integration-worker',
|
|
leaseUntil: new Date('2026-07-31T09:30:00.000Z'),
|
|
attempts: 1,
|
|
payload: command as GamePrisma.InputJsonValue,
|
|
},
|
|
});
|
|
};
|
|
|
|
const rollbackCommand = buildCommand(rollbackRequestId, targetUserId, rollbackRevision, 'must-rollback.png', 7);
|
|
await createInputEvent(rollbackCommand);
|
|
await db.$executeRawUnsafe(`
|
|
ALTER TABLE input_event
|
|
ADD CONSTRAINT ${rollbackConstraint}
|
|
CHECK (request_id <> '${rollbackRequestId}' OR status <> 'SUCCEEDED')
|
|
`);
|
|
await expect(execute(rollbackCommand)).rejects.toThrow(`violates check constraint "${rollbackConstraint}"`);
|
|
expect(world.getGeneralById(targetGeneralId)).toMatchObject({
|
|
picture: initialPicture,
|
|
imageServer: initialImageServer,
|
|
meta: { killturn: 24, preserved: 'yes' },
|
|
});
|
|
await expect(db.general.findUniqueOrThrow({ where: { id: targetGeneralId } })).resolves.toMatchObject({
|
|
picture: initialPicture,
|
|
imageServer: initialImageServer,
|
|
meta: { killturn: 24, preserved: 'yes' },
|
|
});
|
|
await expect(
|
|
db.inputEvent.findUniqueOrThrow({ where: { requestId: rollbackRequestId } })
|
|
).resolves.toMatchObject({
|
|
status: 'PROCESSING',
|
|
result: null,
|
|
lockedBy: 'account-icon-integration-worker',
|
|
});
|
|
await db.$executeRawUnsafe(`ALTER TABLE input_event DROP CONSTRAINT ${rollbackConstraint}`);
|
|
|
|
const actorMismatchCommand = buildCommand(
|
|
actorMismatchRequestId,
|
|
targetUserId,
|
|
rollbackRevision,
|
|
'actor-mismatch.png',
|
|
8
|
|
);
|
|
await createInputEvent(actorMismatchCommand, foreignUserId);
|
|
await expect(execute(actorMismatchCommand)).rejects.toThrow('actor does not match');
|
|
expect(world.getGeneralById(targetGeneralId)).toMatchObject({
|
|
picture: initialPicture,
|
|
imageServer: initialImageServer,
|
|
});
|
|
await expect(db.general.findUniqueOrThrow({ where: { id: targetGeneralId } })).resolves.toMatchObject({
|
|
picture: initialPicture,
|
|
imageServer: initialImageServer,
|
|
});
|
|
await expect(
|
|
db.inputEvent.findUniqueOrThrow({ where: { requestId: actorMismatchRequestId } })
|
|
).resolves.toMatchObject({
|
|
status: 'PROCESSING',
|
|
result: null,
|
|
});
|
|
|
|
const successCommand = buildCommand(successRequestId, targetUserId, successRevision);
|
|
await createInputEvent(successCommand);
|
|
await expect(execute(successCommand)).resolves.toEqual({
|
|
type: 'adjustGeneralIcon',
|
|
ok: true,
|
|
generalId: targetGeneralId,
|
|
updated: true,
|
|
});
|
|
expect(world.getGeneralById(targetGeneralId)).toMatchObject({
|
|
picture: nextPicture,
|
|
imageServer: nextImageServer,
|
|
meta: {
|
|
killturn: 24,
|
|
preserved: 'yes',
|
|
accountIconUpdatedAt: successRevision,
|
|
},
|
|
});
|
|
expect(world.getGeneralById(npcGeneralId)).toMatchObject({
|
|
picture: initialPicture,
|
|
imageServer: initialImageServer,
|
|
});
|
|
expect(world.getGeneralById(foreignGeneralId)).toMatchObject({
|
|
picture: initialPicture,
|
|
imageServer: initialImageServer,
|
|
});
|
|
await expect(db.general.findUniqueOrThrow({ where: { id: targetGeneralId } })).resolves.toMatchObject({
|
|
picture: nextPicture,
|
|
imageServer: nextImageServer,
|
|
meta: {
|
|
killturn: 24,
|
|
preserved: 'yes',
|
|
accountIconUpdatedAt: successRevision,
|
|
},
|
|
});
|
|
await expect(db.general.findUniqueOrThrow({ where: { id: npcGeneralId } })).resolves.toMatchObject({
|
|
picture: initialPicture,
|
|
imageServer: initialImageServer,
|
|
});
|
|
await expect(db.general.findUniqueOrThrow({ where: { id: foreignGeneralId } })).resolves.toMatchObject({
|
|
picture: initialPicture,
|
|
imageServer: initialImageServer,
|
|
});
|
|
await expect(
|
|
db.inputEvent.findUniqueOrThrow({ where: { requestId: successRequestId } })
|
|
).resolves.toMatchObject({
|
|
status: 'SUCCEEDED',
|
|
result: {
|
|
type: 'adjustGeneralIcon',
|
|
ok: true,
|
|
generalId: targetGeneralId,
|
|
updated: true,
|
|
},
|
|
error: null,
|
|
lockedBy: null,
|
|
leaseUntil: null,
|
|
completedAt: expect.any(Date),
|
|
});
|
|
|
|
const noGeneralCommand = buildCommand(noGeneralRequestId, npcUserId, successRevision, 'npc-must-stay.png', 9);
|
|
await createInputEvent(noGeneralCommand);
|
|
await expect(execute(noGeneralCommand)).resolves.toEqual({
|
|
type: 'adjustGeneralIcon',
|
|
ok: true,
|
|
generalId: null,
|
|
updated: false,
|
|
});
|
|
expect(world.getGeneralById(npcGeneralId)).toMatchObject({
|
|
picture: initialPicture,
|
|
imageServer: initialImageServer,
|
|
});
|
|
await expect(db.general.findUniqueOrThrow({ where: { id: npcGeneralId } })).resolves.toMatchObject({
|
|
picture: initialPicture,
|
|
imageServer: initialImageServer,
|
|
meta: { killturn: 24, preserved: 'yes' },
|
|
});
|
|
await expect(
|
|
db.inputEvent.findUniqueOrThrow({ where: { requestId: noGeneralRequestId } })
|
|
).resolves.toMatchObject({
|
|
status: 'SUCCEEDED',
|
|
result: {
|
|
type: 'adjustGeneralIcon',
|
|
ok: true,
|
|
generalId: null,
|
|
updated: false,
|
|
},
|
|
});
|
|
|
|
const reloaded = await loadTurnWorldFromDatabase({ databaseUrl: databaseUrl! });
|
|
expect(reloaded.snapshot.generals.find((entry) => entry.id === targetGeneralId)).toMatchObject({
|
|
picture: nextPicture,
|
|
imageServer: nextImageServer,
|
|
meta: {
|
|
killturn: 24,
|
|
preserved: 'yes',
|
|
accountIconUpdatedAt: successRevision,
|
|
},
|
|
});
|
|
expect(reloaded.snapshot.generals.find((entry) => entry.id === npcGeneralId)).toMatchObject({
|
|
picture: initialPicture,
|
|
imageServer: initialImageServer,
|
|
npcState: 1,
|
|
});
|
|
expect(reloaded.snapshot.generals.find((entry) => entry.id === foreignGeneralId)).toMatchObject({
|
|
picture: initialPicture,
|
|
imageServer: initialImageServer,
|
|
userId: foreignUserId,
|
|
});
|
|
});
|
|
});
|