373 lines
17 KiB
TypeScript
373 lines
17 KiB
TypeScript
import { afterAll, beforeAll, expect, it } from 'vitest';
|
|
import fastify from 'fastify';
|
|
import { fastifyTRPCPlugin } from '@trpc/server/adapters/fastify';
|
|
import { asRecord } from '@sammo-ts/common';
|
|
import { createGamePostgresConnector, createRedisConnector, GamePrisma } from '@sammo-ts/infra';
|
|
import { createTurnDaemonRuntime, seedScenarioToDatabase, type TurnDaemonRuntime } from '@sammo-ts/game-engine';
|
|
import { appRouter } from '../src/router.js';
|
|
import { DatabaseTurnDaemonTransport } from '../src/daemon/databaseTransport.js';
|
|
import { RedisAccessTokenStore } from '../src/auth/accessTokenStore.js';
|
|
import { InMemoryFlushStore } from '../src/auth/flushStore.js';
|
|
import type { GameApiContext } from '../src/context.js';
|
|
|
|
const databaseUrl = process.env.NPC_POLICY_DATABASE_URL;
|
|
const integration = it.skipIf(!databaseUrl || !process.env.REDIS_URL);
|
|
const connector = databaseUrl ? createGamePostgresConnector({ url: databaseUrl }) : null;
|
|
const redis = process.env.REDIS_URL ? createRedisConnector({ url: process.env.REDIS_URL }) : null;
|
|
let runtime: TurnDaemonRuntime | undefined;
|
|
let loop: Promise<void> | undefined;
|
|
const profile = `npc-policy:${databaseUrl ? new URL(databaseUrl).searchParams.get('schema') : 'fixture'}`;
|
|
const baseTime = new Date('0185-01-01T00:00:00Z');
|
|
|
|
beforeAll(async () => {
|
|
if (!databaseUrl) return;
|
|
if (!new URL(databaseUrl).searchParams.get('schema')?.endsWith('_npc_policy_fixture'))
|
|
throw new Error('Dedicated NPC policy fixture schema required');
|
|
await connector!.connect();
|
|
await redis!.connect();
|
|
});
|
|
afterAll(async () => {
|
|
if (loop) {
|
|
await runtime?.lifecycle.stop();
|
|
await loop;
|
|
}
|
|
await runtime?.close();
|
|
await connector?.disconnect();
|
|
await redis?.disconnect();
|
|
});
|
|
|
|
integration(
|
|
'HTTP user edits survive daemon restart and real NPC turns, with readable actor and before/after history',
|
|
async () => {
|
|
const db = connector!.prisma;
|
|
await db.playAuditPolicy.deleteMany({
|
|
where: {
|
|
OR: [
|
|
{ serverId: 'npc-policy-lifecycle' },
|
|
{ id: { in: ['c'.repeat(64), 'd'.repeat(64), 'e'.repeat(64)] } },
|
|
],
|
|
},
|
|
});
|
|
await db.playAuditMonth.deleteMany({ where: { serverId: 'npc-policy-lifecycle' } });
|
|
await db.playAuditDecisionChunk.deleteMany({ where: { decision: { serverId: 'npc-policy-lifecycle' } } });
|
|
await db.playAuditDecision.deleteMany({ where: { serverId: 'npc-policy-lifecycle' } });
|
|
await db.playAuditDiplomacyEvent.deleteMany({ where: { serverId: 'npc-policy-lifecycle' } });
|
|
await db.inputEvent.deleteMany({ where: { requestId: { startsWith: 'npc-policy-http-' } } });
|
|
await seedScenarioToDatabase({
|
|
scenarioId: 903,
|
|
databaseUrl: databaseUrl!,
|
|
now: new Date(),
|
|
installOptions: {
|
|
openAt: new Date(Date.now() + 86_400_000),
|
|
turnTermMinutes: 5,
|
|
npcMode: 2,
|
|
showImgLevel: 3,
|
|
serverId: 'npc-policy-lifecycle',
|
|
season: 1,
|
|
},
|
|
});
|
|
await db.generalTurn.deleteMany();
|
|
await db.nationTurn.deleteMany();
|
|
await db.general.deleteMany();
|
|
await db.nation.deleteMany();
|
|
await db.diplomacy.deleteMany();
|
|
// 185년 고정 fixture에 180년 시나리오의 지연 등장 이벤트를 이월하지 않는다.
|
|
// 일반턴·월간 재정/도시 갱신은 실제 runtime handler를 그대로 실행한다.
|
|
await db.event.deleteMany();
|
|
const city = await db.city.findFirstOrThrow({ orderBy: { id: 'asc' } });
|
|
const world = await db.worldState.findFirstOrThrow();
|
|
await db.worldState.update({
|
|
where: { id: world.id },
|
|
data: {
|
|
currentYear: 185,
|
|
currentMonth: 1,
|
|
clockBaseTime: baseTime,
|
|
clockTick: 0n,
|
|
lastTurnTick: 0n,
|
|
clockPhase: 'RUNNING',
|
|
clockMode: 'realtime',
|
|
clockWallAnchor: new Date(),
|
|
config: { ...asRecord(world.config), tournamentTrig: false },
|
|
},
|
|
});
|
|
await db.nation.create({
|
|
data: {
|
|
id: 1,
|
|
name: '정책국',
|
|
color: '#ffffff',
|
|
level: 3,
|
|
chiefGeneralId: 1,
|
|
capitalCityId: city.id,
|
|
gold: 100_000,
|
|
rice: 100_000,
|
|
tech: 3000,
|
|
meta: {},
|
|
},
|
|
});
|
|
await db.city.updateMany({ data: { nationId: 0 } });
|
|
await db.city.update({
|
|
where: { id: city.id },
|
|
data: {
|
|
nationId: 1,
|
|
population: 100_000,
|
|
populationMax: 200_000,
|
|
supplyState: 1,
|
|
frontState: 1,
|
|
meta: { trust: 80, trade: 100 },
|
|
},
|
|
});
|
|
await db.general.createMany({
|
|
data: [
|
|
{
|
|
id: 1,
|
|
userId: 'npc-policy-owner',
|
|
name: '정책군주',
|
|
nationId: 1,
|
|
cityId: city.id,
|
|
officerLevel: 12,
|
|
npcState: 0,
|
|
turnTime: new Date('0185-02-01Z'),
|
|
turnTick: 100_000_000n,
|
|
meta: { belong: 5, killturn: 24 },
|
|
},
|
|
{
|
|
id: 2,
|
|
name: '징병검증장',
|
|
nationId: 1,
|
|
cityId: city.id,
|
|
officerLevel: 5,
|
|
npcState: 2,
|
|
leadership: 80,
|
|
strength: 80,
|
|
intel: 30,
|
|
gold: 100_000,
|
|
rice: 100_000,
|
|
crew: 0,
|
|
turnTime: baseTime,
|
|
turnTick: 0n,
|
|
meta: { killturn: 24, armType: 1, dex1: 1000 },
|
|
},
|
|
],
|
|
});
|
|
const transport = new DatabaseTurnDaemonTransport(db, 10_000);
|
|
const auth: NonNullable<GameApiContext['auth']> = {
|
|
version: 1,
|
|
profile,
|
|
sessionId: 'fixture-session',
|
|
issuedAt: new Date().toISOString(),
|
|
expiresAt: '2999-01-01T00:00:00Z',
|
|
user: { id: 'npc-policy-owner', username: 'fixture', displayName: 'fixture', roles: [] },
|
|
sanctions: {},
|
|
};
|
|
const app = fastify();
|
|
let request = 0;
|
|
await app.register(fastifyTRPCPlugin, {
|
|
prefix: '/che/api/trpc',
|
|
trpcOptions: {
|
|
router: appRouter,
|
|
createContext: ({
|
|
req,
|
|
}: {
|
|
req: { headers: Record<string, string | string[] | undefined> };
|
|
}): GameApiContext => ({
|
|
db,
|
|
redis: redis!.client,
|
|
profile: { id: 'hwe', scenario: '903', name: profile },
|
|
auth: req.headers['x-session-token'] === 'fixture-session' ? auth : null,
|
|
requestId: `npc-policy-http-${++request}`,
|
|
turnDaemon: transport,
|
|
accessTokenStore: new RedisAccessTokenStore(redis!.client, profile),
|
|
flushStore: new InMemoryFlushStore(),
|
|
battleSim: {} as GameApiContext['battleSim'],
|
|
uploadDir: '/tmp',
|
|
uploadPath: '/uploads',
|
|
uploadPublicUrl: null,
|
|
gameTokenSecret: 'fixture-only',
|
|
}),
|
|
},
|
|
});
|
|
const actions: Array<{ kind: string; actionKey: string; generalId: number; completed?: boolean }> = [];
|
|
const start = async () => {
|
|
const instance = await createTurnDaemonRuntime({
|
|
profile,
|
|
databaseUrl: databaseUrl!,
|
|
enableLeaseHeartbeat: false,
|
|
onActionResolved: (action) => actions.push(action),
|
|
});
|
|
// 자연 진행은 정지하고, 사용자 command와 명시한 due 턴만 처리한다.
|
|
instance.lifecycle.pause('NPC policy fixture');
|
|
return instance;
|
|
};
|
|
const call = async (endpoint: string, input: unknown, mutation = false) => {
|
|
const response = await app.inject({
|
|
method: mutation ? 'POST' : 'GET',
|
|
url: `/che/api/trpc/npc.${endpoint}${mutation ? '' : `?input=${encodeURIComponent(JSON.stringify(input))}`}`,
|
|
headers: {
|
|
'x-session-token': 'fixture-session',
|
|
...(mutation ? { 'content-type': 'application/json' } : {}),
|
|
},
|
|
...(mutation ? { payload: JSON.stringify(input) } : {}),
|
|
});
|
|
expect(response.statusCode, response.body).toBe(200);
|
|
return response.json<{ result: { data: unknown } }>().result.data;
|
|
};
|
|
const configuration = (value: unknown) => {
|
|
const data = asRecord(value);
|
|
return {
|
|
values: data.currentNationPolicy,
|
|
nation: data.currentNationPriority,
|
|
general: data.currentGeneralActionPriority,
|
|
setters: data.lastSetters,
|
|
};
|
|
};
|
|
try {
|
|
runtime = await start();
|
|
loop = runtime.lifecycle.start();
|
|
// 발령과 징병을 목록에서 빼면 실제 턴에서도 수행하지 않아야 한다.
|
|
await call('setNationPriority', ['NPC포상'], true);
|
|
await call('setGeneralPriority', ['출병', '일반내정'], true);
|
|
await call(
|
|
'setNationPolicy',
|
|
{ minWarCrew: 2000, minNPCRecruitCityPopulation: 30000, safeRecruitCityPopulationRatio: 0 },
|
|
true
|
|
);
|
|
const withoutRecruitment = await call('getPolicy', {});
|
|
expect(withoutRecruitment).toMatchObject({
|
|
currentNationPriority: ['NPC포상'],
|
|
currentGeneralActionPriority: ['출병', '일반내정'],
|
|
});
|
|
await runtime.lifecycle.stop();
|
|
await loop;
|
|
loop = undefined;
|
|
await runtime.close();
|
|
runtime = await start();
|
|
expect(configuration(await call('getPolicy', {}))).toEqual(configuration(withoutRecruitment));
|
|
let result = await runtime.processor.run(baseTime, { budgetMs: 10_000, maxGenerals: 1, catchUpCap: 1 });
|
|
expect(result.processedGenerals).toBe(1);
|
|
expect(runtime.world.getGeneralById(2)!.crew).toBe(0);
|
|
expect(actions).toContainEqual(expect.objectContaining({ generalId: 2, kind: 'nation' }));
|
|
expect(
|
|
actions.filter((action) => action.generalId === 2).some((action) => action.actionKey === 'che_징병')
|
|
).toBe(false);
|
|
await runtime.hooks!.flushChanges!(result);
|
|
const nationDecision = await db.playAuditDecision.findFirstOrThrow({
|
|
where: { generalId: 2, phase: 'nation' },
|
|
include: { chunks: { orderBy: { ordinal: 'asc' } } },
|
|
});
|
|
const procedures = nationDecision.chunks.flatMap((chunk) =>
|
|
Array.isArray(chunk.steps)
|
|
? chunk.steps
|
|
.map(asRecord)
|
|
.filter((step) => step.kind === 'PROCEDURE_START')
|
|
.map((step) => step.procedure)
|
|
: []
|
|
);
|
|
expect(procedures).toEqual(['NPC포상']);
|
|
expect(configuration(await call('getPolicy', {}))).toEqual(configuration(withoutRecruitment));
|
|
// 같은 장수·자원으로 징병 우선순위를 맨 앞에 저장한 뒤 다시 시작한다.
|
|
loop = runtime.lifecycle.start();
|
|
await call('setGeneralPriority', ['징병', '출병', '일반내정'], true);
|
|
const saved = await call('getPolicy', {});
|
|
await runtime.lifecycle.stop();
|
|
await loop;
|
|
loop = undefined;
|
|
await runtime.close();
|
|
runtime = await start();
|
|
expect(configuration(await call('getPolicy', {}))).toEqual(configuration(saved));
|
|
const beforeMeta = asRecord(runtime.world.getNationById(1)!.meta);
|
|
// 실제 due 턴과 command를 실행한다. 전방의 중립 도시가 전쟁 상태를 만든다.
|
|
actions.length = 0;
|
|
result = await runtime.processor.run(runtime.world.getGeneralById(2)!.turnTime, {
|
|
budgetMs: 10_000,
|
|
maxGenerals: 1,
|
|
catchUpCap: 1,
|
|
});
|
|
expect(result.processedGenerals).toBe(1);
|
|
expect(runtime.world.getGeneralById(2)!.crew).toBeGreaterThan(0);
|
|
expect(actions).toContainEqual(
|
|
expect.objectContaining({ generalId: 2, actionKey: 'che_징병', completed: true })
|
|
);
|
|
await runtime.hooks!.flushChanges!(result);
|
|
expect((await db.general.findUniqueOrThrow({ where: { id: 2 } })).crew).toBeGreaterThan(0);
|
|
expect(asRecord(runtime.world.getNationById(1)!.meta).npc_nation_policy).toEqual(
|
|
beforeMeta.npc_nation_policy
|
|
);
|
|
expect(configuration(await call('getPolicy', {}))).toEqual(configuration(saved));
|
|
// 병력이 소진되고 도시 인구가 정책 하한 미만이면 징병을 거른다.
|
|
runtime.world.updateGeneral(2, { crew: 0 });
|
|
runtime.world.updateCity(city.id, { population: 30_100 });
|
|
actions.length = 0;
|
|
result = await runtime.processor.run(runtime.world.getGeneralById(2)!.turnTime, {
|
|
budgetMs: 10_000,
|
|
maxGenerals: 1,
|
|
catchUpCap: 1,
|
|
});
|
|
expect(result.processedGenerals).toBe(1);
|
|
expect(runtime.world.getGeneralById(2)!.crew).toBe(0);
|
|
expect(actions.some((action) => action.actionKey === 'che_징병')).toBe(false);
|
|
await runtime.hooks!.flushChanges!(result);
|
|
expect(configuration(await call('getPolicy', {}))).toEqual(configuration(saved));
|
|
// 이후의 개인턴/월간 갱신도 정책을 덮어쓰면 안 된다.
|
|
const target = new Date(runtime.world.getGeneralById(2)!.turnTime.getTime() + 30 * 60_000);
|
|
result = await runtime.processor.run(target, { budgetMs: 10_000, maxGenerals: 100, catchUpCap: 12 });
|
|
expect(result.processedGenerals).toBeGreaterThan(1);
|
|
await runtime.hooks!.flushChanges!(result);
|
|
expect(await call('getPolicy', {})).toMatchObject({
|
|
currentNationPriority: ['NPC포상'],
|
|
currentGeneralActionPriority: ['징병', '출병', '일반내정'],
|
|
currentNationPolicy: { minWarCrew: 2000, minNPCRecruitCityPopulation: 30000 },
|
|
});
|
|
expect(runtime.world.getState().meta.playAuditGap).toBeUndefined();
|
|
const history = await call('policyHistory', { area: 'NPC_NATION_PRIORITY' });
|
|
expect(history).toMatchObject({
|
|
items: [
|
|
expect.objectContaining({ source: 'CHANGE', actor: expect.objectContaining({ name: '정책군주' }) }),
|
|
expect.anything(),
|
|
],
|
|
});
|
|
const row = await db.playAuditPolicy.findFirstOrThrow({
|
|
where: { nationId: 1, area: 'NPC_NATION_PRIORITY', source: 'CHANGE' },
|
|
});
|
|
expect(await call('policyVersion', { id: row.id })).toMatchObject({
|
|
actor: { name: '정책군주' },
|
|
fields: [{ key: 'priority', beforeJson: 'null', afterJson: '["NPC포상"]', changed: true }],
|
|
});
|
|
expect(row.inputSequence).not.toBeNull();
|
|
expect((await db.inputEvent.findUniqueOrThrow({ where: { sequence: row.inputSequence! } })).status).toBe(
|
|
'SUCCEEDED'
|
|
);
|
|
// 외국/이전 기수/국방 정책 ID를 알아도 자국 NPC 정책으로 조회할 수 없다.
|
|
for (const [id, patch] of [
|
|
['c'.repeat(64), { nationId: 2 }],
|
|
['d'.repeat(64), { serverId: 'previous-season' }],
|
|
['e'.repeat(64), { area: 'DEFENCE' }],
|
|
] as const) {
|
|
await db.playAuditPolicy.create({
|
|
data: {
|
|
...row,
|
|
id,
|
|
...patch,
|
|
actor: row.actor ?? GamePrisma.DbNull,
|
|
before: row.before ?? GamePrisma.DbNull,
|
|
after: row.after ?? GamePrisma.JsonNull,
|
|
},
|
|
});
|
|
const response = await app.inject({
|
|
url: `/che/api/trpc/npc.policyVersion?input=${encodeURIComponent(JSON.stringify({ id }))}`,
|
|
headers: { 'x-session-token': 'fixture-session' },
|
|
});
|
|
expect(response.statusCode).toBe(404);
|
|
}
|
|
await db.general.update({ where: { id: 1 }, data: { penalty: { noChief: true } } });
|
|
const denied = await app.inject({
|
|
url: `/che/api/trpc/npc.policyHistory?input=${encodeURIComponent(JSON.stringify({ area: 'NPC_VALUES' }))}`,
|
|
headers: { 'x-session-token': 'fixture-session' },
|
|
});
|
|
expect(denied.statusCode).toBe(403);
|
|
} finally {
|
|
await app.close();
|
|
}
|
|
},
|
|
90_000
|
|
);
|