feat: NPC와 국방 정책 변경을 감사 버전으로 저장

2026-09-16 04:48:58 +00:00
parent 10f3f0ebc6
commit d549cbf887
19 changed files with 803 additions and 98 deletions
@@ -0,0 +1,112 @@
+import { afterAll, beforeAll, describe, expect, it } from 'vitest';
+import { createGamePostgresConnector, type GamePrismaClient } from '@sammo-ts/infra';
+import { persistAuditPolicies } from '../src/playAudit/policyPersistence.js';
+import type { PendingAuditPolicy } from '../src/playAudit/policy.js';
+const databaseUrl = process.env.INPUT_EVENT_DATABASE_URL;
+const integration = describe.skipIf(!databaseUrl);
+const serverId = 'policy-persistence-fixture';
+const requestId = 'policy-persistence-request';
+integration('immutable policy persistence', () => {
+    let db: GamePrismaClient;
+    let close: () => Promise<void>;
+    beforeAll(async () => {
+        const connector = createGamePostgresConnector({ url: databaseUrl! });
+        await connector.connect();
+        db = connector.prisma;
+        close = () => connector.disconnect();
+        await db.playAuditPolicy.deleteMany({ where: { serverId } });
+        await db.inputEvent.deleteMany({ where: { requestId } });
+    });
+    afterAll(async () => {
+        await db.playAuditPolicy.deleteMany({ where: { serverId } });
+        await db.inputEvent.deleteMany({ where: { requestId } });
+        await db.nation.deleteMany({ where: { id: 999915 } });
+        await close();
+    });
+    it('rolls back policy and state together, binds durable sequence, and rejects conflicting replay', async () => {
+        const input = await db.inputEvent.create({
+            data: {
+                requestId,
+                target: 'ENGINE',
+                eventType: 'setNationSetting',
+                actorUserId: 'audit-owner',
+                status: 'PROCESSING',
+            },
+        });
+        const context = { requestId, sequence: input.sequence, actorUserId: 'audit-owner' };
+        const baseline: PendingAuditPolicy = {
+            schemaVersion: 1,
+            id: `${serverId}:1`,
+            serverId,
+            nationId: 999915,
+            area: 'DEFENCE',
+            revision: 1,
+            previousId: null,
+            source: 'BASELINE',
+            year: 190,
+            month: 1,
+            tick: 1,
+            requestId: null,
+            ordinal: 1,
+            actor: null,
+            before: null,
+            after: { scout: 0 },
+        };
+        const change: PendingAuditPolicy = {
+            ...baseline,
+            id: `${serverId}:2`,
+            revision: 2,
+            previousId: baseline.id,
+            source: 'CHANGE',
+            requestId,
+            ordinal: 2,
+            actor: {
+                userId: 'audit-owner',
+                generalId: 1,
+                name: '기록 군주',
+                nationId: 999915,
+                officerLevel: 12,
+                npcState: 0,
+                permission: 4,
+            },
+            before: { scout: 0 },
+            after: { scout: 1 },
+        };
+        await expect(
+            db.$transaction(async (tx) => {
+                await tx.nation.create({ data: { id: 999915, name: '정책국', color: '#ffffff', meta: { scout: 1 } } });
+                await persistAuditPolicies(tx, [baseline, change], context);
+                await tx.inputEvent.update({ where: { requestId }, data: { status: 'SUCCEEDED' } });
+                throw new Error('policy rollback');
+            })
+        ).rejects.toThrow('policy rollback');
+        expect(await db.playAuditPolicy.count({ where: { serverId } })).toBe(0);
+        expect(await db.nation.findUnique({ where: { id: 999915 } })).toBeNull();
+        expect((await db.inputEvent.findUniqueOrThrow({ where: { requestId } })).status).toBe('PROCESSING');
+        await db.$transaction(async (tx) => {
+            await tx.nation.create({ data: { id: 999915, name: '정책국', color: '#ffffff', meta: { scout: 1 } } });
+            await persistAuditPolicies(tx, [baseline, change], context);
+            await tx.inputEvent.update({ where: { requestId }, data: { status: 'SUCCEEDED' } });
+        });
+        await db.$transaction((tx) => persistAuditPolicies(tx, [baseline, change], context));
+        const rows = await db.playAuditPolicy.findMany({ where: { serverId }, orderBy: { revision: 'asc' } });
+        expect(rows).toHaveLength(2);
+        expect(rows[0]).toMatchObject({ inputSequence: null, actor: null });
+        expect(rows[1]).toMatchObject({
+            inputSequence: input.sequence,
+            requestId,
+            before: { scout: 0 },
+            after: { scout: 1 },
+        });
+        await expect(
+            db.$transaction((tx) => persistAuditPolicies(tx, [{ ...change, after: { scout: 0 } }], context))
+        ).rejects.toThrow('replay payload conflict');
+        await expect(
+            db.$transaction((tx) => persistAuditPolicies(tx, [change], { ...context, actorUserId: 'other' }))
+        ).rejects.toThrow('actor/request mismatch');
+        await expect(db.$transaction((tx) => persistAuditPolicies(tx, [change]))).rejects.toThrow(
+            'input event context missing'
+        );
+        expect((await db.playAuditPolicy.findUniqueOrThrow({ where: { id: change.id } })).after).toEqual({ scout: 1 });
+    });
+});