Hide_D
4fc20de8d4
은퇴·사망·통일의 저장 순서와 명예의 전당 및 명장일람 판정을 Ref 흐름에 맞춘다. 유산 행동을 인증된 daemon transaction으로 통합하고 중복 지급·고유 아이템·로그·오류 경계를 회귀 테스트한다.
308 lines
13 KiB
TypeScript
308 lines
13 KiB
TypeScript
import { afterAll, beforeAll, describe, expect, it } from 'vitest';
|
|
|
|
import { SystemClock } from '@sammo-ts/common';
|
|
import type { GameSessionTokenPayload } from '@sammo-ts/common/auth/gameToken';
|
|
import {
|
|
createDatabaseTurnHooks,
|
|
DatabaseTurnDaemonCommandQueue,
|
|
EngineStateManager,
|
|
InMemoryTurnStateStore,
|
|
InMemoryTurnWorld,
|
|
loadTurnWorldFromDatabase,
|
|
TurnDaemonLifecycle,
|
|
type TurnGeneral,
|
|
type TurnWorldSnapshot,
|
|
type TurnWorldState,
|
|
} from '@sammo-ts/game-engine';
|
|
import { createTurnDaemonCommandHandler } from '@sammo-ts/game-engine/turn/worldCommandHandler.js';
|
|
import {
|
|
createGamePostgresConnector,
|
|
type GamePrisma,
|
|
type GamePrismaClient,
|
|
type RedisConnector,
|
|
} from '@sammo-ts/infra';
|
|
import type { MapDefinition, ScenarioConfig, ScenarioMeta, TurnSchedule } from '@sammo-ts/logic';
|
|
|
|
import { RedisAccessTokenStore } from '../src/auth/accessTokenStore.js';
|
|
import { InMemoryBattleSimTransport } from '../src/battleSim/inMemoryTransport.js';
|
|
import type { GameApiContext } from '../src/context.js';
|
|
import { DatabaseTurnDaemonTransport } from '../src/daemon/databaseTransport.js';
|
|
import { InMemoryFlushStore } from '../src/auth/flushStore.js';
|
|
import { appRouter } from '../src/router.js';
|
|
|
|
const databaseUrl = process.env.IMMEDIATE_ACTION_DATABASE_URL;
|
|
const integration = describe.skipIf(!databaseUrl);
|
|
const worldId = 992_320;
|
|
const actorId = 7_320;
|
|
const targetId = 7_321;
|
|
const actorNationId = 7_322;
|
|
const targetNationId = 7_323;
|
|
const actorUserId = 'inherit-owner-message-actor';
|
|
const targetUserId = 'inherit-owner-message-target';
|
|
const requestId = 'integration:inherit-owner-message:success';
|
|
const engineRequestId = `${requestId}:inherit.checkOwner:engine:0:inheritanceAction`;
|
|
const schedule: TurnSchedule = { entries: [{ startMinute: 0, tickMinutes: 10 }] };
|
|
const scenarioConfig: ScenarioConfig = {
|
|
stat: { total: 200, min: 10, max: 100, npcTotal: 150, npcMax: 75, npcMin: 10, chiefMin: 70 },
|
|
iconPath: '.',
|
|
map: {},
|
|
const: { inheritCheckOwnerPoint: 1_000 },
|
|
environment: { mapName: 'che', unitSet: 'che' },
|
|
};
|
|
const scenarioMeta: ScenarioMeta = {
|
|
title: '소유자 확인 통합',
|
|
startYear: 200,
|
|
life: null,
|
|
fiction: null,
|
|
history: [],
|
|
ignoreDefaultEvents: false,
|
|
};
|
|
const map: MapDefinition = { id: 'inherit-owner-message', name: scenarioMeta.title, cities: [] };
|
|
const state: TurnWorldState = {
|
|
id: worldId,
|
|
currentYear: 200,
|
|
currentMonth: 4,
|
|
tickSeconds: 600,
|
|
lastTurnTime: new Date('2026-08-19T00:00:00.000Z'),
|
|
meta: { hiddenSeed: 'inherit-owner-message', isunited: 0, scenarioMeta },
|
|
};
|
|
|
|
const general = (overrides: Partial<TurnGeneral>): TurnGeneral => ({
|
|
id: actorId,
|
|
userId: actorUserId,
|
|
name: '확인장수',
|
|
nationId: actorNationId,
|
|
cityId: 1,
|
|
troopId: 0,
|
|
stats: { leadership: 70, strength: 45, intelligence: 85 },
|
|
turnTime: new Date('2026-08-19T00: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, inherit_spent_dyn: 0 },
|
|
inheritancePoints: { previous: 1_500 },
|
|
penalty: {},
|
|
officerLevel: 1,
|
|
experience: 0,
|
|
dedication: 0,
|
|
injury: 0,
|
|
gold: 1_000,
|
|
rice: 1_000,
|
|
crew: 0,
|
|
crewTypeId: 0,
|
|
train: 0,
|
|
atmos: 0,
|
|
age: 30,
|
|
npcState: 0,
|
|
...overrides,
|
|
});
|
|
const actor = general({});
|
|
const target = general({
|
|
id: targetId,
|
|
userId: targetUserId,
|
|
name: '피확인장수',
|
|
nationId: targetNationId,
|
|
meta: { killturn: 24, owner_name: '피확인 계정' },
|
|
inheritancePoints: { previous: 0 },
|
|
});
|
|
const nation = (id: number, name: string, chiefGeneralId: number) => ({
|
|
id,
|
|
name,
|
|
color: id === actorNationId ? '#123456' : '#654321',
|
|
capitalCityId: null,
|
|
chiefGeneralId,
|
|
gold: 0,
|
|
rice: 0,
|
|
power: 0,
|
|
level: 1,
|
|
typeCode: 'che_def',
|
|
meta: {},
|
|
});
|
|
const actorNation = nation(actorNationId, '확인국', actorId);
|
|
const targetNation = nation(targetNationId, '피확인국', targetId);
|
|
const auth: GameSessionTokenPayload = {
|
|
version: 1,
|
|
profile: 'che:inherit-owner-message',
|
|
issuedAt: '2026-08-19T00:00:00.000Z',
|
|
expiresAt: '2026-08-20T00:00:00.000Z',
|
|
sessionId: 'inherit-owner-message-session',
|
|
user: { id: actorUserId, username: actorUserId, displayName: '확인자 계정', roles: ['user'] },
|
|
sanctions: {},
|
|
};
|
|
|
|
const toCreate = (entry: TurnGeneral): GamePrisma.GeneralCreateManyInput => ({
|
|
id: entry.id,
|
|
userId: entry.userId,
|
|
name: entry.name,
|
|
nationId: entry.nationId,
|
|
cityId: entry.cityId,
|
|
npcState: entry.npcState,
|
|
leadership: entry.stats.leadership,
|
|
strength: entry.stats.strength,
|
|
intel: entry.stats.intelligence,
|
|
turnTime: entry.turnTime,
|
|
meta: entry.meta as GamePrisma.InputJsonValue,
|
|
penalty: entry.penalty as GamePrisma.InputJsonValue,
|
|
});
|
|
|
|
integration('inherit owner lookup private messages', () => {
|
|
let db: GamePrismaClient;
|
|
let closeDb: (() => Promise<void>) | undefined;
|
|
|
|
beforeAll(async () => {
|
|
const schema = new URL(databaseUrl!).searchParams.get('schema');
|
|
if (!schema?.endsWith('immediate_action_integration')) throw new Error(`Unsafe schema: ${schema}`);
|
|
const connector = createGamePostgresConnector({ url: databaseUrl! });
|
|
await connector.connect();
|
|
db = connector.prisma;
|
|
closeDb = () => connector.disconnect();
|
|
await db.inputEvent.deleteMany({ where: { requestId: engineRequestId } });
|
|
await db.message.deleteMany({ where: { mailbox: { in: [actorId, targetId] } } });
|
|
await db.inheritanceLog.deleteMany({ where: { userId: actorUserId } });
|
|
await db.inheritancePoint.deleteMany({ where: { userId: { in: [actorUserId, targetUserId] } } });
|
|
await db.rankData.deleteMany({ where: { generalId: { in: [actorId, targetId] } } });
|
|
await db.general.deleteMany({ where: { id: { in: [actorId, targetId] } } });
|
|
await db.nation.deleteMany({ where: { id: { in: [actorNationId, targetNationId] } } });
|
|
await db.worldState.deleteMany({ where: { id: worldId } });
|
|
await db.worldState.create({
|
|
data: {
|
|
id: worldId,
|
|
scenarioCode: 'inherit-owner-message',
|
|
currentYear: 200,
|
|
currentMonth: 4,
|
|
tickSeconds: 600,
|
|
config: JSON.parse(JSON.stringify(scenarioConfig)) as GamePrisma.InputJsonValue,
|
|
meta: state.meta as GamePrisma.InputJsonValue,
|
|
},
|
|
});
|
|
await db.nation.createMany({
|
|
data: [
|
|
{ id: actorNationId, name: actorNation.name, color: actorNation.color, level: 1 },
|
|
{ id: targetNationId, name: targetNation.name, color: targetNation.color, level: 1 },
|
|
],
|
|
});
|
|
await db.general.createMany({ data: [actor, target].map(toCreate) });
|
|
await db.inheritancePoint.create({ data: { userId: actorUserId, key: 'previous', value: 1_500 } });
|
|
await db.rankData.create({
|
|
data: { generalId: actorId, nationId: actorNationId, type: 'inherit_spent_dyn', value: 0 },
|
|
});
|
|
});
|
|
|
|
afterAll(async () => {
|
|
if (db) {
|
|
await db.inputEvent.deleteMany({ where: { requestId: engineRequestId } });
|
|
await db.message.deleteMany({ where: { mailbox: { in: [actorId, targetId] } } });
|
|
await db.inheritanceLog.deleteMany({ where: { userId: actorUserId } });
|
|
await db.inheritancePoint.deleteMany({ where: { userId: { in: [actorUserId, targetUserId] } } });
|
|
await db.rankData.deleteMany({ where: { generalId: { in: [actorId, targetId] } } });
|
|
await db.general.deleteMany({ where: { id: { in: [actorId, targetId] } } });
|
|
await db.nation.deleteMany({ where: { id: { in: [actorNationId, targetNationId] } } });
|
|
await db.worldState.deleteMany({ where: { id: worldId } });
|
|
}
|
|
await closeDb?.();
|
|
});
|
|
|
|
it('commits once and returns the durable result without double charging on the same API retry', async () => {
|
|
const snapshot: TurnWorldSnapshot = {
|
|
generals: [actor, target],
|
|
cities: [],
|
|
nations: [actorNation, targetNation],
|
|
troops: [],
|
|
diplomacy: [],
|
|
events: [],
|
|
initialEvents: [],
|
|
scenarioConfig,
|
|
scenarioMeta,
|
|
map,
|
|
};
|
|
const world = new InMemoryTurnWorld(state, snapshot, { schedule });
|
|
const queue = new DatabaseTurnDaemonCommandQueue(db);
|
|
await queue.initialize();
|
|
const hooks = await createDatabaseTurnHooks(databaseUrl!, world);
|
|
const stateManager = new EngineStateManager();
|
|
stateManager.register('world', {
|
|
capture: () => world.captureState(),
|
|
restore: (value) => world.restoreState(value),
|
|
});
|
|
const lifecycle = new TurnDaemonLifecycle(
|
|
{
|
|
clock: new SystemClock(),
|
|
controlQueue: queue,
|
|
commandResponder: queue,
|
|
getNextTickTime: () => new Date(Date.now() + 3_600_000),
|
|
stateStore: new InMemoryTurnStateStore(world),
|
|
processor: {
|
|
run: async () => {
|
|
throw new Error('scheduled turn must not run in inheritance API integration');
|
|
},
|
|
},
|
|
commandHandler: createTurnDaemonCommandHandler({ world }),
|
|
hooks: hooks.hooks,
|
|
stateManager,
|
|
},
|
|
{ profile: 'inherit-owner-message', defaultBudget: { budgetMs: 100, maxGenerals: 1, catchUpCap: 1 } }
|
|
);
|
|
const redisClient = { get: async () => null, set: async () => null };
|
|
const context: GameApiContext = {
|
|
requestId,
|
|
db,
|
|
redis: redisClient as unknown as RedisConnector['client'],
|
|
turnDaemon: new DatabaseTurnDaemonTransport(db, 10_000),
|
|
battleSim: new InMemoryBattleSimTransport(),
|
|
profile: { id: 'che', scenario: 'inherit-owner-message', name: 'che:inherit-owner-message' },
|
|
uploadDir: 'uploads',
|
|
uploadPath: '/uploads',
|
|
uploadPublicUrl: null,
|
|
auth,
|
|
accessTokenStore: new RedisAccessTokenStore(redisClient, 'che:inherit-owner-message'),
|
|
flushStore: new InMemoryFlushStore(),
|
|
gameTokenSecret: 'test-secret',
|
|
};
|
|
|
|
let loop: Promise<void> | undefined;
|
|
try {
|
|
loop = lifecycle.start();
|
|
const caller = appRouter.createCaller(context);
|
|
const expected = { ok: true, ownerName: '피확인 계정', targetName: '피확인장수' };
|
|
await expect(caller.inherit.checkOwner({ targetGeneralId: targetId })).resolves.toEqual(expected);
|
|
await expect(caller.inherit.checkOwner({ targetGeneralId: targetId })).resolves.toEqual(expected);
|
|
} finally {
|
|
await lifecycle.stop('inherit owner integration finished');
|
|
await loop;
|
|
await hooks.close();
|
|
}
|
|
|
|
await expect(
|
|
db.inheritancePoint.findUniqueOrThrow({ where: { userId_key: { userId: actorUserId, key: 'previous' } } })
|
|
).resolves.toMatchObject({ value: 500 });
|
|
await expect(
|
|
db.rankData.findUniqueOrThrow({
|
|
where: { generalId_type: { generalId: actorId, type: 'inherit_spent_dyn' } },
|
|
})
|
|
).resolves.toMatchObject({ value: 1_000 });
|
|
await expect(db.inheritanceLog.count({ where: { userId: actorUserId } })).resolves.toBe(1);
|
|
const messages = await db.message.findMany({
|
|
where: { mailbox: { in: [actorId, targetId] } },
|
|
orderBy: { id: 'asc' },
|
|
select: { mailbox: true, message: true },
|
|
});
|
|
expect(messages.map(({ mailbox, message }) => [mailbox, (message as { text: string }).text])).toEqual([
|
|
[actorId, '피확인장수의 소유자는 피확인 계정 입니다.'],
|
|
[targetId, '소유자명이 누군가에 의해 확인되었습니다.'],
|
|
]);
|
|
await expect(db.inputEvent.findMany({ where: { requestId: engineRequestId } })).resolves.toEqual([
|
|
expect.objectContaining({ status: 'SUCCEEDED', attempts: 1, actorUserId }),
|
|
]);
|
|
const reloaded = await loadTurnWorldFromDatabase({ databaseUrl: databaseUrl! });
|
|
expect(reloaded.snapshot.generals.find((entry) => entry.id === actorId)).toMatchObject({
|
|
meta: { inherit_spent_dyn: 1_000 },
|
|
inheritancePoints: { previous: 500 },
|
|
});
|
|
}, 30_000);
|
|
});
|