560 lines
22 KiB
TypeScript
560 lines
22 KiB
TypeScript
import { execFileSync } from 'node:child_process';
|
|
import fs from 'node:fs';
|
|
import path from 'node:path';
|
|
|
|
import { afterAll, beforeAll, describe, expect, it } from 'vitest';
|
|
import type { GameSessionTokenPayload } from '@sammo-ts/common/auth/gameToken';
|
|
import { InMemoryFlushStore } from '@sammo-ts/game-api/auth/flushStore.js';
|
|
import { RedisAccessTokenStore } from '@sammo-ts/game-api/auth/accessTokenStore.js';
|
|
import { InMemoryBattleSimTransport } from '@sammo-ts/game-api/battleSim/inMemoryTransport.js';
|
|
import type { GameApiContext } from '@sammo-ts/game-api/context.js';
|
|
import { InMemoryTurnDaemonTransport } from '@sammo-ts/game-api/daemon/inMemoryTransport.js';
|
|
import { appRouter } from '@sammo-ts/game-api/router.js';
|
|
import { createDatabaseTurnHooks } from '@sammo-ts/game-engine/turn/databaseHooks.js';
|
|
import { InMemoryTurnWorld } from '@sammo-ts/game-engine/turn/inMemoryWorld.js';
|
|
import {
|
|
createFinishNationBettingHandler,
|
|
createOpenNationBettingHandler,
|
|
} from '@sammo-ts/game-engine/turn/monthlyNationBettingAction.js';
|
|
import { createMonthlyEventHandler } from '@sammo-ts/game-engine/turn/monthlyEventHandler.js';
|
|
import type {
|
|
TurnEvent,
|
|
TurnGeneral,
|
|
TurnWorldSnapshot,
|
|
TurnWorldState,
|
|
} from '@sammo-ts/game-engine/turn/types.js';
|
|
import {
|
|
createGamePostgresConnector,
|
|
type GamePrismaClient,
|
|
type RedisConnector,
|
|
} from '@sammo-ts/infra';
|
|
import type { City, Nation } from '@sammo-ts/logic';
|
|
|
|
import { findTurnDifferentialWorkspaceRoot } from '../src/turn-differential/referenceSnapshot.js';
|
|
|
|
const databaseUrl = process.env.INPUT_EVENT_DATABASE_URL;
|
|
const workspaceRoot =
|
|
process.env.TURN_DIFFERENTIAL_WORKSPACE_ROOT ?? findTurnDifferentialWorkspaceRoot(process.cwd());
|
|
const integration = describe.skipIf(!databaseUrl);
|
|
const nationIds = [990_091, 990_092] as const;
|
|
const cityIds = [990_091, 990_092] as const;
|
|
const generalIds = [9_991, 9_992] as const;
|
|
const userIds = ['monthly-betting-api-user-1', 'monthly-betting-api-user-2'] as const;
|
|
const bettingId = 990_091;
|
|
const sourceEventId = 990_091;
|
|
const finishEventId = 990_093;
|
|
|
|
type ReferenceBettingLifecycle = {
|
|
phases: {
|
|
afterOpen: {
|
|
candidateNationIds: number[];
|
|
systemBonus: number;
|
|
finishEventCount: number;
|
|
historyLogs: string[];
|
|
};
|
|
afterBets: {
|
|
bets: Array<{
|
|
generalId: number;
|
|
ownerId: number | null;
|
|
selectionKey: string;
|
|
amount: number;
|
|
}>;
|
|
inheritancePrevious: number[];
|
|
spentRank: number[];
|
|
};
|
|
afterFinish: {
|
|
result: boolean;
|
|
finished: boolean;
|
|
winner: number[];
|
|
inheritancePrevious: number[];
|
|
earnedRank: number[];
|
|
historyLogs: string[];
|
|
};
|
|
};
|
|
};
|
|
|
|
const runReferenceLifecycle = (): ReferenceBettingLifecycle | null => {
|
|
if (process.env.TURN_DIFFERENTIAL_REFERENCE !== '1' || !workspaceRoot) {
|
|
return null;
|
|
}
|
|
const stackDirectory = path.join(workspaceRoot, 'docker_compose_files/reference');
|
|
const runnerScript =
|
|
process.env.MONTHLY_BETTING_LIFECYCLE_RUNNER_SCRIPT ??
|
|
path.join(workspaceRoot, 'ref/sam/hwe/compare/monthly_event_trace.php');
|
|
const fixturePath =
|
|
process.env.MONTHLY_BETTING_LIFECYCLE_FIXTURE ??
|
|
path.join(path.dirname(runnerScript), 'fixtures/monthly_nation_betting_lifecycle.json');
|
|
const stdout = execFileSync('./scripts/run-turn-differential-case.sh', ['-'], {
|
|
cwd: stackDirectory,
|
|
input: fs.readFileSync(fixturePath, 'utf8'),
|
|
encoding: 'utf8',
|
|
stdio: ['pipe', 'pipe', 'pipe'],
|
|
env: {
|
|
...process.env,
|
|
COMPOSE_PROJECT_NAME: 'sam-rebuild-reference',
|
|
TURN_DIFFERENTIAL_RUNNER_SCRIPT: runnerScript,
|
|
TURN_DIFFERENTIAL_COMPARE_DIR: path.dirname(runnerScript),
|
|
},
|
|
});
|
|
return JSON.parse(stdout) as ReferenceBettingLifecycle;
|
|
};
|
|
|
|
const buildNation = (id: number, power: number): Nation => ({
|
|
id,
|
|
name: id === nationIds[0] ? '위' : '촉',
|
|
color: id === nationIds[0] ? '#111111' : '#222222',
|
|
capitalCityId: id,
|
|
chiefGeneralId: id,
|
|
gold: id === nationIds[0] ? 1_000 : 3_000,
|
|
rice: id === nationIds[0] ? 2_000 : 4_000,
|
|
power,
|
|
level: 2,
|
|
typeCode: id === nationIds[0] ? 'che_유가' : 'che_병가',
|
|
meta: { tech: id === nationIds[0] ? 100 : 200 },
|
|
});
|
|
|
|
const buildCity = (id: number, nationId: number): City => ({
|
|
id,
|
|
name: id === cityIds[0] ? '허창' : '성도',
|
|
nationId,
|
|
level: 3,
|
|
state: 0,
|
|
population: 1_000,
|
|
populationMax: 2_000,
|
|
agriculture: 1_000,
|
|
agricultureMax: 2_000,
|
|
commerce: 1_000,
|
|
commerceMax: 2_000,
|
|
security: 1_000,
|
|
securityMax: 2_000,
|
|
supplyState: 1,
|
|
frontState: 0,
|
|
defence: 1_000,
|
|
defenceMax: 2_000,
|
|
wall: 1_000,
|
|
wallMax: 2_000,
|
|
meta: { region: 1, trust: 50, trade: 100 },
|
|
});
|
|
|
|
const buildGeneral = (id: number, userId: string, nationId: number): TurnGeneral => ({
|
|
id,
|
|
userId,
|
|
name: id === generalIds[0] ? '장수1' : '장수2',
|
|
nationId,
|
|
cityId: nationId,
|
|
troopId: 0,
|
|
stats: { leadership: 50, strength: 50, intelligence: 50 },
|
|
experience: 0,
|
|
dedication: 0,
|
|
officerLevel: 1,
|
|
role: {
|
|
personality: null,
|
|
specialDomestic: null,
|
|
specialWar: null,
|
|
items: { horse: null, weapon: null, book: null, item: null },
|
|
},
|
|
injury: 0,
|
|
gold: 0,
|
|
rice: 0,
|
|
crew: 0,
|
|
crewTypeId: 1_100,
|
|
train: 0,
|
|
atmos: 0,
|
|
age: 30,
|
|
npcState: 0,
|
|
bornYear: 170,
|
|
deadYear: 250,
|
|
affinity: 1,
|
|
picture: 'default.jpg',
|
|
triggerState: { flags: {}, counters: {}, modifiers: {}, meta: {} },
|
|
lastTurn: { command: '휴식' },
|
|
turnTime: new Date('0200-01-01T00:00:00.000Z'),
|
|
meta: { killturn: 1_000 },
|
|
});
|
|
|
|
const buildAuth = (index: 0 | 1): GameSessionTokenPayload => ({
|
|
version: 1,
|
|
profile: 'che:2',
|
|
issuedAt: '2026-07-27T00:00:00.000Z',
|
|
expiresAt: '2026-07-28T00:00:00.000Z',
|
|
sessionId: `monthly-betting-api-session-${index + 1}`,
|
|
user: {
|
|
id: userIds[index],
|
|
username: `bettor-${index + 1}`,
|
|
displayName: `Bettor ${index + 1}`,
|
|
roles: ['user'],
|
|
},
|
|
sanctions: {},
|
|
});
|
|
|
|
const event: TurnEvent = {
|
|
id: sourceEventId,
|
|
targetCode: 'month',
|
|
priority: 1_000,
|
|
condition: true,
|
|
action: [['OpenNationBetting', 1, 100]],
|
|
meta: {},
|
|
};
|
|
|
|
integration('monthly nation betting API lifecycle', () => {
|
|
let db: GamePrismaClient;
|
|
let closeDb: (() => Promise<void>) | undefined;
|
|
|
|
const buildContext = (index: 0 | 1): GameApiContext => {
|
|
const redisClient = {
|
|
get: async () => null,
|
|
set: async () => null,
|
|
};
|
|
return {
|
|
requestId: `monthly-betting-api-${index + 1}`,
|
|
db,
|
|
redis: redisClient as unknown as RedisConnector['client'],
|
|
turnDaemon: new InMemoryTurnDaemonTransport(),
|
|
battleSim: new InMemoryBattleSimTransport(),
|
|
profile: { id: 'che', scenario: '2', name: 'che:2' },
|
|
uploadDir: 'uploads',
|
|
uploadPath: '/uploads',
|
|
uploadPublicUrl: null,
|
|
auth: buildAuth(index),
|
|
accessTokenStore: new RedisAccessTokenStore(redisClient, 'che:2'),
|
|
flushStore: new InMemoryFlushStore(),
|
|
gameTokenSecret: 'test-secret',
|
|
};
|
|
};
|
|
|
|
const cleanFixture = async () => {
|
|
await db.inputEvent.deleteMany({ where: { actorUserId: { in: [...userIds] } } });
|
|
await db.event.deleteMany({ where: { id: { in: [sourceEventId, sourceEventId + 1, finishEventId] } } });
|
|
await db.nationBetting.deleteMany({ where: { id: bettingId } });
|
|
await db.rankData.deleteMany({ where: { generalId: { in: [...generalIds] } } });
|
|
await db.inheritanceLog.deleteMany({ where: { userId: { in: [...userIds] } } });
|
|
await db.inheritancePoint.deleteMany({ where: { userId: { in: [...userIds] } } });
|
|
await db.message.deleteMany({ where: { mailbox: { in: [...generalIds] } } });
|
|
await db.logEntry.deleteMany({
|
|
where: {
|
|
OR: [
|
|
{ text: { contains: '천하통일 후보를 점치는' } },
|
|
{ text: { contains: '천통국 예상 내기의 결과' } },
|
|
],
|
|
},
|
|
});
|
|
await db.diplomacy.deleteMany({
|
|
where: {
|
|
OR: [{ srcNationId: { in: [...nationIds] } }, { destNationId: { in: [...nationIds] } }],
|
|
},
|
|
});
|
|
await db.general.deleteMany({ where: { id: { in: [...generalIds] } } });
|
|
await db.city.deleteMany({ where: { id: { in: [...cityIds] } } });
|
|
await db.nation.deleteMany({ where: { id: { in: [...nationIds] } } });
|
|
await db.worldState.deleteMany({ where: { scenarioCode: 'monthly-nation-betting-api-lifecycle' } });
|
|
};
|
|
|
|
beforeAll(async () => {
|
|
const connector = createGamePostgresConnector({ url: databaseUrl! });
|
|
await connector.connect();
|
|
db = connector.prisma;
|
|
closeDb = () => connector.disconnect();
|
|
await cleanFixture();
|
|
});
|
|
|
|
afterAll(async () => {
|
|
await cleanFixture();
|
|
await closeDb?.();
|
|
});
|
|
|
|
it('opens in the engine, accepts session-owned API bets, and settles in the next monthly event', async () => {
|
|
const reference = runReferenceLifecycle();
|
|
const nations = [buildNation(nationIds[0], 100), buildNation(nationIds[1], 300)];
|
|
const cities = [buildCity(cityIds[0], nationIds[0]), buildCity(cityIds[1], nationIds[1])];
|
|
const generals = [
|
|
buildGeneral(generalIds[0], userIds[0], nationIds[0]),
|
|
buildGeneral(generalIds[1], userIds[1], nationIds[1]),
|
|
];
|
|
await db.nation.createMany({
|
|
data: nations.map((nation) => ({
|
|
id: nation.id,
|
|
name: nation.name,
|
|
color: nation.color,
|
|
capitalCityId: nation.capitalCityId,
|
|
chiefGeneralId: nation.chiefGeneralId,
|
|
gold: nation.gold,
|
|
rice: nation.rice,
|
|
tech: nation.id === nationIds[0] ? 100 : 200,
|
|
level: nation.level,
|
|
typeCode: nation.typeCode,
|
|
meta: {},
|
|
})),
|
|
});
|
|
await db.city.createMany({
|
|
data: cities.map((city) => ({
|
|
id: city.id,
|
|
name: city.name,
|
|
level: city.level,
|
|
nationId: city.nationId,
|
|
population: city.population,
|
|
populationMax: city.populationMax,
|
|
agriculture: city.agriculture,
|
|
agricultureMax: city.agricultureMax,
|
|
commerce: city.commerce,
|
|
commerceMax: city.commerceMax,
|
|
security: city.security,
|
|
securityMax: city.securityMax,
|
|
trust: 50,
|
|
trade: 100,
|
|
defence: city.defence,
|
|
defenceMax: city.defenceMax,
|
|
wall: city.wall,
|
|
wallMax: city.wallMax,
|
|
region: 1,
|
|
meta: {},
|
|
})),
|
|
});
|
|
await db.general.createMany({
|
|
data: generals.map((general) => ({
|
|
id: general.id,
|
|
userId: general.userId,
|
|
name: general.name,
|
|
nationId: general.nationId,
|
|
cityId: general.cityId,
|
|
npcState: general.npcState,
|
|
leadership: general.stats.leadership,
|
|
strength: general.stats.strength,
|
|
intel: general.stats.intelligence,
|
|
officerLevel: general.officerLevel,
|
|
turnTime: general.turnTime,
|
|
meta: general.meta,
|
|
})),
|
|
});
|
|
await db.inheritancePoint.createMany({
|
|
data: userIds.map((userId) => ({ userId, key: 'previous', value: 1_000 })),
|
|
});
|
|
const row = await db.worldState.create({
|
|
data: {
|
|
scenarioCode: 'monthly-nation-betting-api-lifecycle',
|
|
currentYear: 199,
|
|
currentMonth: 12,
|
|
tickSeconds: 600,
|
|
config: {},
|
|
meta: { lastBettingId: bettingId - 1 },
|
|
},
|
|
});
|
|
const state: TurnWorldState = {
|
|
id: row.id,
|
|
currentYear: 199,
|
|
currentMonth: 12,
|
|
tickSeconds: 600,
|
|
lastTurnTime: new Date('2026-07-27T00:00:00.000Z'),
|
|
meta: { lastBettingId: bettingId - 1 },
|
|
};
|
|
const scenarioConfig: TurnWorldSnapshot['scenarioConfig'] = {
|
|
stat: { total: 300, min: 10, max: 100, npcTotal: 150, npcMax: 75, npcMin: 10, chiefMin: 70 },
|
|
iconPath: '.',
|
|
map: {},
|
|
const: {},
|
|
environment: { mapName: 'test', unitSet: 'default' },
|
|
};
|
|
let world: InMemoryTurnWorld | null = null;
|
|
const open = createOpenNationBettingHandler({ getWorld: () => world });
|
|
const finish = createFinishNationBettingHandler({ getWorld: () => world });
|
|
world = new InMemoryTurnWorld(
|
|
state,
|
|
{
|
|
scenarioConfig,
|
|
map: { id: 'test', name: 'test', cities: [] },
|
|
generals,
|
|
cities,
|
|
nations,
|
|
troops: [],
|
|
diplomacy: [],
|
|
events: [event],
|
|
initialEvents: [],
|
|
},
|
|
{
|
|
schedule: { entries: [{ startMinute: 0, tickMinutes: 10 }] },
|
|
calendarHandler: createMonthlyEventHandler({
|
|
getWorld: () => world,
|
|
startYear: 190,
|
|
actions: new Map([
|
|
['OpenNationBetting', open],
|
|
['FinishNationBetting', finish],
|
|
]),
|
|
}),
|
|
}
|
|
);
|
|
const hooks = await createDatabaseTurnHooks(databaseUrl!, world);
|
|
|
|
try {
|
|
await world.advanceMonth(new Date('0200-01-01T00:00:00.000Z'));
|
|
await hooks.hooks.flushChanges?.({
|
|
lastTurnTime: state.lastTurnTime.toISOString(),
|
|
processedGenerals: 0,
|
|
processedTurns: 1,
|
|
durationMs: 0,
|
|
partial: false,
|
|
});
|
|
|
|
const opened = await db.nationBetting.findUniqueOrThrow({ where: { id: bettingId } });
|
|
const candidates = Array.isArray(opened.candidates) ? opened.candidates : [];
|
|
const candidateNationIds = candidates.flatMap((candidate) => {
|
|
if (!candidate || typeof candidate !== 'object' || !('aux' in candidate)) {
|
|
return [];
|
|
}
|
|
const aux = candidate.aux;
|
|
return aux && typeof aux === 'object' && 'nation' in aux && typeof aux.nation === 'number'
|
|
? [aux.nation]
|
|
: [];
|
|
});
|
|
const openHistory = await db.logEntry.findMany({
|
|
where: { text: { contains: '천하통일 후보를 점치는' } },
|
|
orderBy: { id: 'asc' },
|
|
select: { text: true },
|
|
});
|
|
const createdFinishEvent = await db.event.findUniqueOrThrow({
|
|
where: { id: sourceEventId + 1 },
|
|
select: { action: true },
|
|
});
|
|
expect(createdFinishEvent.action).toEqual([
|
|
['FinishNationBetting', bettingId],
|
|
['DeleteEvent'],
|
|
]);
|
|
expect({
|
|
candidateNationIds,
|
|
systemBonus: (
|
|
await db.nationBet.findFirstOrThrow({
|
|
where: { bettingId, generalId: 0 },
|
|
select: { amount: true },
|
|
})
|
|
).amount,
|
|
finishEventCount: 1,
|
|
historyLogs: openHistory.map((entry) => entry.text),
|
|
}).toEqual({
|
|
candidateNationIds: [nationIds[1], nationIds[0]],
|
|
systemBonus: reference?.phases.afterOpen.systemBonus ?? 100,
|
|
finishEventCount: reference?.phases.afterOpen.finishEventCount ?? 1,
|
|
historyLogs:
|
|
reference?.phases.afterOpen.historyLogs ??
|
|
[
|
|
'<C>●</>200년 1월:<B><b>【내기】</b></>천하통일 후보를 점치는 <C>내기</>가 진행중입니다! 호사가의 참여를 기다립니다!',
|
|
],
|
|
});
|
|
|
|
await expect(
|
|
appRouter.createCaller(buildContext(0)).betting.bet({
|
|
bettingId,
|
|
bettingType: [1],
|
|
amount: 100,
|
|
})
|
|
).resolves.toEqual({ result: true });
|
|
await expect(
|
|
appRouter.createCaller(buildContext(1)).betting.bet({
|
|
bettingId,
|
|
bettingType: [0],
|
|
amount: 100,
|
|
})
|
|
).resolves.toEqual({ result: true });
|
|
|
|
const bets = await db.nationBet.findMany({
|
|
where: { bettingId },
|
|
orderBy: { generalId: 'asc' },
|
|
select: { generalId: true, userId: true, selectionKey: true, amount: true },
|
|
});
|
|
const afterBets = {
|
|
selections: bets.map((bet) => ({ selectionKey: bet.selectionKey, amount: bet.amount })),
|
|
inheritancePrevious: await Promise.all(
|
|
userIds.map(async (userId) => {
|
|
const point = await db.inheritancePoint.findUniqueOrThrow({
|
|
where: { userId_key: { userId, key: 'previous' } },
|
|
});
|
|
return point.value;
|
|
})
|
|
),
|
|
spentRank: await Promise.all(
|
|
generalIds.map(async (generalId) => {
|
|
const rank = await db.rankData.findUniqueOrThrow({
|
|
where: { generalId_type: { generalId, type: 'inherit_spent_dyn' } },
|
|
});
|
|
return rank.value;
|
|
})
|
|
),
|
|
};
|
|
expect(afterBets).toEqual({
|
|
selections: (reference?.phases.afterBets.bets ?? [
|
|
{ selectionKey: '[-1]', amount: 100 },
|
|
{ selectionKey: '[1]', amount: 100 },
|
|
{ selectionKey: '[0]', amount: 100 },
|
|
]).map((bet) => ({ selectionKey: bet.selectionKey, amount: bet.amount })),
|
|
inheritancePrevious: reference?.phases.afterBets.inheritancePrevious ?? [900, 900],
|
|
spentRank: reference?.phases.afterBets.spentRank ?? [100, 100],
|
|
});
|
|
|
|
world.updateNation(nationIds[0], { level: 0 });
|
|
expect(world.removeEvent(sourceEventId)).toBe(true);
|
|
expect(
|
|
world.addEvent({
|
|
id: finishEventId,
|
|
targetCode: 'month',
|
|
priority: 1_000,
|
|
condition: true,
|
|
action: [['FinishNationBetting', bettingId]],
|
|
meta: {},
|
|
})
|
|
).toBe(true);
|
|
await world.advanceMonth(new Date('0200-02-01T00:00:00.000Z'));
|
|
await hooks.hooks.flushChanges?.({
|
|
lastTurnTime: state.lastTurnTime.toISOString(),
|
|
processedGenerals: 0,
|
|
processedTurns: 1,
|
|
durationMs: 0,
|
|
partial: false,
|
|
});
|
|
|
|
const settled = await db.nationBetting.findUniqueOrThrow({ where: { id: bettingId } });
|
|
const finishHistory = await db.logEntry.findMany({
|
|
where: {
|
|
OR: [
|
|
{ text: { contains: '천하통일 후보를 점치는' } },
|
|
{ text: { contains: '천통국 예상 내기의 결과' } },
|
|
],
|
|
},
|
|
orderBy: { id: 'asc' },
|
|
select: { text: true },
|
|
});
|
|
const afterFinish = {
|
|
finished: settled.finished,
|
|
winner: settled.winner,
|
|
inheritancePrevious: await Promise.all(
|
|
userIds.map(async (userId) => {
|
|
const point = await db.inheritancePoint.findUniqueOrThrow({
|
|
where: { userId_key: { userId, key: 'previous' } },
|
|
});
|
|
return point.value;
|
|
})
|
|
),
|
|
earnedRank: await Promise.all(
|
|
generalIds.map(async (generalId) => {
|
|
const rank = await db.rankData.findUnique({
|
|
where: { generalId_type: { generalId, type: 'inherit_earned_act' } },
|
|
});
|
|
return rank?.value ?? 0;
|
|
})
|
|
),
|
|
historyLogs: finishHistory.map((entry) => entry.text),
|
|
};
|
|
expect(afterFinish).toEqual({
|
|
finished: reference?.phases.afterFinish.finished ?? true,
|
|
winner: reference?.phases.afterFinish.winner ?? [0],
|
|
inheritancePrevious: reference?.phases.afterFinish.inheritancePrevious ?? [900, 1_200],
|
|
earnedRank: reference?.phases.afterFinish.earnedRank ?? [0, 300],
|
|
historyLogs:
|
|
reference?.phases.afterFinish.historyLogs ??
|
|
[
|
|
'<C>●</>200년 1월:<B><b>【내기】</b></>천하통일 후보를 점치는 <C>내기</>가 진행중입니다! 호사가의 참여를 기다립니다!',
|
|
'<C>●</>200년 2월:<B><b>【내기】</b></> 200년 1월에 열렸던 천통국 예상 내기의 결과가 나왔습니다!',
|
|
],
|
|
});
|
|
} finally {
|
|
await hooks.close();
|
|
}
|
|
});
|
|
});
|