517 lines
20 KiB
TypeScript
517 lines
20 KiB
TypeScript
import { afterAll, beforeAll, describe, expect, it } from 'vitest';
|
|
|
|
import { RANK_DATA_TYPES } from '@sammo-ts/common';
|
|
import type { GameSessionTokenPayload } from '@sammo-ts/common/auth/gameToken';
|
|
import { createTurnDaemonRuntime, seedScenarioToDatabase, type TurnDaemonRuntime } from '@sammo-ts/game-engine';
|
|
import {
|
|
createGamePostgresConnector,
|
|
type GamePrisma,
|
|
type GamePrismaClient,
|
|
type RedisConnector,
|
|
} from '@sammo-ts/infra';
|
|
|
|
import { RedisAccessTokenStore } from '../src/auth/accessTokenStore.js';
|
|
import { InMemoryFlushStore } from '../src/auth/flushStore.js';
|
|
import { InMemoryBattleSimTransport } from '../src/battleSim/inMemoryTransport.js';
|
|
import type { GameApiContext } from '../src/context.js';
|
|
import { DatabaseTurnDaemonTransport } from '../src/daemon/databaseTransport.js';
|
|
import type { TurnDaemonTransport } from '../src/daemon/transport.js';
|
|
import { appRouter } from '../src/router.js';
|
|
|
|
const databaseUrl = process.env.CREATE_GENERAL_DATABASE_URL;
|
|
const integration = describe.skipIf(!databaseUrl);
|
|
const profile = 'hwe:2';
|
|
const userId = 'create-general-integration-user';
|
|
const failureUserId = 'create-general-integration-failure-user';
|
|
const rejectedUserId = 'create-general-integration-rejected-user';
|
|
const schemaName = databaseUrl ? (new URL(databaseUrl).searchParams.get('schema') ?? '') : '';
|
|
|
|
const assertDedicatedDatabase = (rawUrl: string): void => {
|
|
const schema = new URL(rawUrl).searchParams.get('schema');
|
|
if (!schema?.endsWith('create_general_integration')) {
|
|
throw new Error(`Refusing to mutate non-dedicated schema: ${schema ?? '(missing)'}`);
|
|
}
|
|
if (!/^[a-z0-9_]+$/.test(schema)) {
|
|
throw new Error(`Refusing unsafe schema name: ${schema}`);
|
|
}
|
|
};
|
|
|
|
const buildAuth = (id: string, displayName: string, legacyMemberNo: number): GameSessionTokenPayload => ({
|
|
version: 1,
|
|
profile,
|
|
issuedAt: '2026-07-30T00:00:00.000Z',
|
|
expiresAt: '2026-08-30T00:00:00.000Z',
|
|
sessionId: `create-general-${id}`,
|
|
user: {
|
|
id,
|
|
username: id,
|
|
displayName,
|
|
roles: ['user'],
|
|
legacyMemberNo,
|
|
picture: 'custom-owner.webp',
|
|
imageServer: 2,
|
|
canUseGeneralPicture: true,
|
|
},
|
|
sanctions: {
|
|
legacyPenalty: {
|
|
any: {
|
|
ban: { expire: 4_102_444_800, value: 1 },
|
|
expired: { expire: 1, value: 9 },
|
|
},
|
|
hwe: {
|
|
ban: { expire: 4_102_444_800, value: 2 },
|
|
chat: { expire: 4_102_444_800, value: 3 },
|
|
},
|
|
},
|
|
},
|
|
});
|
|
|
|
integration('generic general creation through the durable turn daemon', () => {
|
|
let db: GamePrismaClient;
|
|
let closeDb: (() => Promise<void>) | undefined;
|
|
let runtime: TurnDaemonRuntime | undefined;
|
|
let daemonLoop: Promise<void> | undefined;
|
|
let turnDaemon: TurnDaemonTransport;
|
|
|
|
const buildContext = (requestId: string, auth: GameSessionTokenPayload): GameApiContext => {
|
|
const redisClient = {
|
|
get: async () => null,
|
|
set: async () => null,
|
|
};
|
|
return {
|
|
requestId,
|
|
db,
|
|
redis: redisClient as unknown as RedisConnector['client'],
|
|
turnDaemon,
|
|
battleSim: new InMemoryBattleSimTransport(),
|
|
profile: { id: 'hwe', scenario: '2', name: profile },
|
|
uploadDir: 'uploads',
|
|
uploadPath: '/uploads',
|
|
uploadPublicUrl: null,
|
|
auth,
|
|
accessTokenStore: new RedisAccessTokenStore(redisClient, profile),
|
|
flushStore: new InMemoryFlushStore(),
|
|
gameTokenSecret: 'create-general-test-secret',
|
|
};
|
|
};
|
|
|
|
const stopRuntime = async (reason: string): Promise<void> => {
|
|
if (!runtime) {
|
|
return;
|
|
}
|
|
await runtime.lifecycle.stop(reason);
|
|
await daemonLoop;
|
|
await runtime.close();
|
|
runtime = undefined;
|
|
daemonLoop = undefined;
|
|
};
|
|
|
|
const startRuntime = async (ownerId: string): Promise<void> => {
|
|
runtime = await createTurnDaemonRuntime({
|
|
profile,
|
|
databaseUrl: databaseUrl!,
|
|
enableDatabaseFlush: true,
|
|
enableLeaseHeartbeat: false,
|
|
leaseOwnerId: ownerId,
|
|
});
|
|
turnDaemon = new DatabaseTurnDaemonTransport(db, 10_000);
|
|
daemonLoop = runtime.lifecycle.start();
|
|
await expect(turnDaemon.requestStatus(10_000)).resolves.toMatchObject({
|
|
state: expect.any(String),
|
|
});
|
|
};
|
|
|
|
beforeAll(async () => {
|
|
assertDedicatedDatabase(databaseUrl!);
|
|
const previousSeed = process.env.INTEGRATION_WORLD_SEED;
|
|
process.env.INTEGRATION_WORLD_SEED = 'create-general-integration-seed';
|
|
try {
|
|
await seedScenarioToDatabase({
|
|
scenarioId: 2,
|
|
databaseUrl: databaseUrl!,
|
|
now: new Date('2099-07-30T12:00:00.000Z'),
|
|
installOptions: {
|
|
turnTermMinutes: 5,
|
|
npcMode: 0,
|
|
showImgLevel: 3,
|
|
serverId: profile,
|
|
season: 1,
|
|
},
|
|
});
|
|
} finally {
|
|
if (previousSeed === undefined) {
|
|
delete process.env.INTEGRATION_WORLD_SEED;
|
|
} else {
|
|
process.env.INTEGRATION_WORLD_SEED = previousSeed;
|
|
}
|
|
}
|
|
|
|
const connector = createGamePostgresConnector({ url: databaseUrl! });
|
|
await connector.connect();
|
|
db = connector.prisma;
|
|
closeDb = () => connector.disconnect();
|
|
await db.inputEvent.deleteMany();
|
|
await db.logEntry.deleteMany();
|
|
await db.inheritanceLog.deleteMany({
|
|
where: { userId: { in: [userId, failureUserId] } },
|
|
});
|
|
await db.oldGeneral.deleteMany({
|
|
where: { serverId: { startsWith: 'create-general-old-' } },
|
|
});
|
|
await db.gameHistory.deleteMany({
|
|
where: { serverId: { startsWith: 'create-general-old-' } },
|
|
});
|
|
await db.gameHistory.createMany({
|
|
data: [1, 2, 3, 4].map((index) => ({
|
|
serverId: `create-general-old-${index}`,
|
|
date: new Date(`2026-0${5 - index}-01T00:00:00.000Z`),
|
|
winnerNation: 1,
|
|
map: 'miniche_b',
|
|
season: 1,
|
|
scenario: 2,
|
|
scenarioName: '통합 과거기',
|
|
env: {},
|
|
})),
|
|
});
|
|
await db.oldGeneral.create({
|
|
data: {
|
|
serverId: 'create-general-old-4',
|
|
generalNo: 1,
|
|
owner: userId,
|
|
name: '과거장수',
|
|
lastYearMonth: 18001,
|
|
turnTime: new Date('2026-01-01T00:00:00.000Z'),
|
|
data: {},
|
|
},
|
|
});
|
|
for (const ownerUserId of [userId, failureUserId]) {
|
|
await db.inheritancePoint.upsert({
|
|
where: {
|
|
userId_key: { userId: ownerUserId, key: 'previous' },
|
|
},
|
|
update: { value: 10_000 },
|
|
create: {
|
|
userId: ownerUserId,
|
|
key: 'previous',
|
|
value: 10_000,
|
|
},
|
|
});
|
|
}
|
|
for (const [key, value] of [
|
|
['active_action', 250.9],
|
|
['combat', 100.8],
|
|
] as const) {
|
|
await db.inheritancePoint.upsert({
|
|
where: { userId_key: { userId, key } },
|
|
update: { value },
|
|
create: { userId, key, value },
|
|
});
|
|
}
|
|
await startRuntime('create-general-integration-daemon');
|
|
}, 60_000);
|
|
|
|
afterAll(async () => {
|
|
await stopRuntime('create-general integration complete');
|
|
await closeDb?.();
|
|
}, 30_000);
|
|
|
|
it('commits one complete ref-shaped general and survives a daemon reload', async () => {
|
|
const auth = buildAuth(userId, '생성사용자', 4242);
|
|
const config = await appRouter.createCaller(buildContext('create-general-config', auth)).join.getConfig();
|
|
expect(config.personalities.map(({ key }) => key)).not.toContain('che_은둔');
|
|
expect(config.inherit.turnTimeZones[1]).toBe('00:05.000 ~ 00:09.999');
|
|
const city = await db.city.findFirstOrThrow({ orderBy: { id: 'asc' } });
|
|
const clientRequestId = '11111111-1111-4111-8111-111111111111';
|
|
const input = {
|
|
name: '일/반-장수#',
|
|
leadership: 55,
|
|
strength: 55,
|
|
intel: 55,
|
|
pic: true,
|
|
character: 'che_안전' as const,
|
|
clientRequestId,
|
|
inheritTurntimeZone: 7,
|
|
inheritCity: city.id,
|
|
inheritBonusStat: [2, 1, 1] as [number, number, number],
|
|
};
|
|
|
|
const first = await appRouter
|
|
.createCaller(buildContext('create-general-http-a', auth))
|
|
.join.createGeneral(input);
|
|
const retried = await appRouter
|
|
.createCaller(buildContext('create-general-http-b', auth))
|
|
.join.createGeneral(input);
|
|
expect(retried).toEqual(first);
|
|
|
|
const created = await db.general.findUniqueOrThrow({
|
|
where: { id: first.generalId },
|
|
});
|
|
expect(created).toMatchObject({
|
|
userId,
|
|
name: '일반장수',
|
|
nationId: 0,
|
|
cityId: city.id,
|
|
npcState: 0,
|
|
leadership: 57,
|
|
strength: 56,
|
|
intel: 56,
|
|
bornYear: 180,
|
|
deadYear: 300,
|
|
picture: 'custom-owner.webp',
|
|
imageServer: 2,
|
|
crewTypeId: 1100,
|
|
personalCode: 'che_안전',
|
|
penalty: {
|
|
ban: 2,
|
|
chat: 3,
|
|
},
|
|
});
|
|
expect(created.affinity).toBeGreaterThanOrEqual(1);
|
|
expect(created.affinity).toBeLessThanOrEqual(150);
|
|
expect(created.meta).toMatchObject({
|
|
createdBy: 'join',
|
|
ownerName: '생성사용자',
|
|
killturn: 6,
|
|
inherit_spent_dyn: 4500,
|
|
});
|
|
const createdAccess = await db.generalAccessLog.findUniqueOrThrow({ where: { generalId: created.id } });
|
|
if (!createdAccess.lastRefresh) {
|
|
throw new Error('created general must have an initial access timestamp');
|
|
}
|
|
expect(
|
|
new Date((created.meta as Record<string, unknown>).prestart_delete_after as string).getTime() -
|
|
createdAccess.lastRefresh.getTime()
|
|
).toBe(2 * 5 * 60 * 1_000);
|
|
expect(runtime!.world.getGeneralById(created.id)).toMatchObject({
|
|
id: created.id,
|
|
userId,
|
|
name: created.name,
|
|
cityId: city.id,
|
|
inheritancePoints: {
|
|
previous: 7351,
|
|
},
|
|
});
|
|
expect(await db.general.count({ where: { userId } })).toBe(1);
|
|
expect(await db.generalTurn.count({ where: { generalId: created.id } })).toBe(30);
|
|
expect(await db.generalTurnRevision.count({ where: { generalId: created.id } })).toBe(1);
|
|
expect(await db.rankData.count({ where: { generalId: created.id } })).toBe(RANK_DATA_TYPES.length);
|
|
expect(
|
|
await db.rankData.findUniqueOrThrow({
|
|
where: {
|
|
generalId_type: {
|
|
generalId: created.id,
|
|
type: 'inherit_spent_dyn',
|
|
},
|
|
},
|
|
})
|
|
).toMatchObject({ nationId: 0, value: 4500 });
|
|
const access = await db.generalAccessLog.findUniqueOrThrow({
|
|
where: { generalId: created.id },
|
|
});
|
|
expect(access).toMatchObject({ userId });
|
|
expect(
|
|
await db.inheritancePoint.findUniqueOrThrow({
|
|
where: { userId_key: { userId, key: 'previous' } },
|
|
})
|
|
).toMatchObject({ value: 7351 });
|
|
expect(await db.inheritancePoint.count({ where: { userId } })).toBe(1);
|
|
expect(await db.inheritanceLog.count({ where: { userId } })).toBe(9);
|
|
expect(
|
|
await db.inheritanceLog.findFirst({
|
|
where: {
|
|
userId,
|
|
text: '신규/복귀 생성으로 포인트 1500 지급',
|
|
},
|
|
})
|
|
).not.toBeNull();
|
|
const event = await db.inputEvent.findUniqueOrThrow({
|
|
where: { requestId: `join-create:${userId}:${clientRequestId}` },
|
|
});
|
|
expect(event).toMatchObject({
|
|
target: 'ENGINE',
|
|
status: 'SUCCEEDED',
|
|
attempts: 1,
|
|
actorUserId: userId,
|
|
});
|
|
expect(access.lastRefresh?.getTime()).toBe(event.createdAt.getTime());
|
|
const turnGridOffsetSeconds =
|
|
((created.turnTime.getTime() - runtime!.world.getState().lastTurnTime.getTime()) / 1000 + 300) % 300;
|
|
expect(turnGridOffsetSeconds).toBeGreaterThanOrEqual(35);
|
|
expect(turnGridOffsetSeconds).toBeLessThan(40);
|
|
|
|
await stopRuntime('verify generic join reload');
|
|
await startRuntime('create-general-integration-reloaded-daemon');
|
|
expect(runtime!.world.getGeneralById(created.id)).toMatchObject({
|
|
id: created.id,
|
|
userId,
|
|
name: created.name,
|
|
cityId: city.id,
|
|
inheritancePoints: {
|
|
previous: 7351,
|
|
},
|
|
});
|
|
|
|
await expect(
|
|
appRouter.createCaller(buildContext('create-general-conflict', auth)).join.createGeneral({
|
|
...input,
|
|
name: '다른장수',
|
|
})
|
|
).rejects.toMatchObject({ code: 'CONFLICT' });
|
|
expect(await db.general.count({ where: { userId } })).toBe(1);
|
|
}, 45_000);
|
|
|
|
it('rejects an unaffordable inheritance before consuming allocator state', async () => {
|
|
const auth = buildAuth(rejectedUserId, '거절사용자', 4444);
|
|
const requestUuid = '33333333-3333-4333-8333-333333333333';
|
|
const requestId = `join-create:${rejectedUserId}:${requestUuid}`;
|
|
const runtimeMetaBefore = runtime!.world.getState().meta;
|
|
const persistedMetaBefore = (await db.worldState.findFirstOrThrow()).meta;
|
|
|
|
await expect(
|
|
appRouter.createCaller(buildContext('create-general-rejected-http', auth)).join.createGeneral({
|
|
name: '포인트부족',
|
|
leadership: 55,
|
|
strength: 55,
|
|
intel: 55,
|
|
pic: false,
|
|
character: 'che_안전',
|
|
inheritSpecial: 'che_무쌍',
|
|
clientRequestId: requestUuid,
|
|
})
|
|
).rejects.toMatchObject({
|
|
code: 'BAD_REQUEST',
|
|
message: '유산 포인트가 부족합니다. 다시 가입해주세요!',
|
|
});
|
|
|
|
expect(await db.general.count({ where: { userId: rejectedUserId } })).toBe(0);
|
|
expect(runtime!.world.getState().meta).toEqual(runtimeMetaBefore);
|
|
expect((await db.worldState.findFirstOrThrow()).meta).toEqual(persistedMetaBefore);
|
|
await expect(db.inputEvent.findUniqueOrThrow({ where: { requestId } })).resolves.toMatchObject({
|
|
target: 'ENGINE',
|
|
status: 'SUCCEEDED',
|
|
attempts: 1,
|
|
actorUserId: rejectedUserId,
|
|
result: {
|
|
type: 'joinCreateGeneral',
|
|
ok: false,
|
|
code: 'BAD_REQUEST',
|
|
},
|
|
});
|
|
}, 30_000);
|
|
|
|
it('rolls back a hard failure and retries the ENGINE event exactly once', async () => {
|
|
const auth = buildAuth(failureUserId, '실패사용자', 4343);
|
|
const requestUuid = '22222222-2222-4222-8222-222222222222';
|
|
const requestId = `join-create:${failureUserId}:${requestUuid}`;
|
|
const triggerName = 'create_general_fail_first_log';
|
|
const functionName = 'create_general_fail_first_log_fn';
|
|
|
|
await db.$executeRawUnsafe(`
|
|
CREATE OR REPLACE FUNCTION "${schemaName}"."${functionName}"()
|
|
RETURNS trigger AS $$
|
|
BEGIN
|
|
IF NEW.meta ->> 'ownerUserId' = '${failureUserId}'
|
|
AND EXISTS (
|
|
SELECT 1
|
|
FROM "${schemaName}"."input_event"
|
|
WHERE "request_id" = '${requestId}'
|
|
AND "status" = 'PROCESSING'
|
|
AND "attempts" = 1
|
|
)
|
|
THEN
|
|
RAISE EXCEPTION 'injected first generic join log failure';
|
|
END IF;
|
|
RETURN NEW;
|
|
END;
|
|
$$ LANGUAGE plpgsql
|
|
`);
|
|
await db.$executeRawUnsafe(`
|
|
CREATE TRIGGER "${triggerName}"
|
|
BEFORE INSERT ON "${schemaName}"."log_entry"
|
|
FOR EACH ROW EXECUTE FUNCTION "${schemaName}"."${functionName}"()
|
|
`);
|
|
|
|
try {
|
|
await expect(
|
|
appRouter.createCaller(buildContext('create-general-failure-http', auth)).join.createGeneral({
|
|
name: '재시장수',
|
|
leadership: 55,
|
|
strength: 55,
|
|
intel: 55,
|
|
pic: false,
|
|
character: 'Random',
|
|
clientRequestId: requestUuid,
|
|
})
|
|
).resolves.toMatchObject({ ok: true, generalId: expect.any(Number) });
|
|
} finally {
|
|
await db.$executeRawUnsafe(`DROP TRIGGER IF EXISTS "${triggerName}" ON "${schemaName}"."log_entry"`);
|
|
await db.$executeRawUnsafe(`DROP FUNCTION IF EXISTS "${schemaName}"."${functionName}"()`);
|
|
}
|
|
|
|
const created = await db.general.findFirstOrThrow({
|
|
where: { userId: failureUserId },
|
|
});
|
|
expect(runtime!.world.getGeneralById(created.id)).toMatchObject({
|
|
id: created.id,
|
|
userId: failureUserId,
|
|
name: created.name,
|
|
});
|
|
expect(await db.general.count({ where: { userId: failureUserId } })).toBe(1);
|
|
expect(await db.generalTurn.count({ where: { generalId: created.id } })).toBe(30);
|
|
expect(await db.rankData.count({ where: { generalId: created.id } })).toBe(RANK_DATA_TYPES.length);
|
|
await expect(db.inputEvent.findUniqueOrThrow({ where: { requestId } })).resolves.toMatchObject({
|
|
status: 'SUCCEEDED',
|
|
attempts: 2,
|
|
actorUserId: failureUserId,
|
|
error: null,
|
|
});
|
|
}, 45_000);
|
|
|
|
it('rejects a forged ENGINE event whose actor does not own the command', async () => {
|
|
const requestId = 'join-create:forged-owner:forged-request';
|
|
await db.inputEvent.create({
|
|
data: {
|
|
requestId,
|
|
target: 'ENGINE',
|
|
eventType: 'joinCreateGeneral',
|
|
actorUserId: 'different-actor',
|
|
payload: {
|
|
type: 'joinCreateGeneral',
|
|
requestId,
|
|
userId: 'forged-owner',
|
|
ownerDisplayName: '위조사용자',
|
|
seedOwnerIdentity: 4545,
|
|
name: '위조장수',
|
|
leadership: 55,
|
|
strength: 55,
|
|
intel: 55,
|
|
pic: false,
|
|
character: 'che_안전',
|
|
profileId: 'hwe',
|
|
} as GamePrisma.InputJsonValue,
|
|
},
|
|
});
|
|
|
|
const deadline = Date.now() + 5_000;
|
|
let event = await db.inputEvent.findUniqueOrThrow({
|
|
where: { requestId },
|
|
});
|
|
while (event.status !== 'FAILED' && Date.now() < deadline) {
|
|
await new Promise((resolve) => setTimeout(resolve, 25));
|
|
event = await db.inputEvent.findUniqueOrThrow({
|
|
where: { requestId },
|
|
});
|
|
}
|
|
expect(event).toMatchObject({
|
|
status: 'FAILED',
|
|
actorUserId: 'different-actor',
|
|
attempts: 3,
|
|
error: expect.stringContaining('actor does not match'),
|
|
});
|
|
expect(await db.general.count({ where: { userId: 'forged-owner' } })).toBe(0);
|
|
expect(runtime!.world.listGenerals()).not.toEqual(
|
|
expect.arrayContaining([expect.objectContaining({ userId: 'forged-owner' })])
|
|
);
|
|
}, 10_000);
|
|
});
|