427 lines
17 KiB
TypeScript
427 lines
17 KiB
TypeScript
import { describe, expect, it, vi } from 'vitest';
|
|
import fastify from 'fastify';
|
|
import { fastifyTRPCPlugin } from '@trpc/server/adapters/fastify';
|
|
|
|
import type { GameSessionTokenPayload } from '@sammo-ts/common/auth/gameToken';
|
|
import type { RedisConnector } from '@sammo-ts/infra';
|
|
|
|
import { RedisAccessTokenStore } from '../src/auth/accessTokenStore.js';
|
|
import { InMemoryFlushStore } from '../src/auth/flushStore.js';
|
|
import type { DatabaseClient, GameApiContext, GeneralRow } from '../src/context.js';
|
|
import type { TurnDaemonTransport } from '../src/daemon/transport.js';
|
|
import { appRouter } from '../src/router.js';
|
|
|
|
const baseGeneral: GeneralRow = {
|
|
id: 22,
|
|
userId: 'user-22',
|
|
name: '정책담당',
|
|
nationId: 1,
|
|
cityId: 1,
|
|
troopId: 0,
|
|
npcState: 0,
|
|
affinity: null,
|
|
bornYear: 180,
|
|
deadYear: 300,
|
|
picture: 'default.jpg',
|
|
imageServer: 0,
|
|
leadership: 70,
|
|
strength: 70,
|
|
intel: 70,
|
|
injury: 0,
|
|
experience: 0,
|
|
dedication: 0,
|
|
officerLevel: 12,
|
|
gold: 1_000,
|
|
rice: 1_000,
|
|
crew: 0,
|
|
crewTypeId: 0,
|
|
train: 0,
|
|
atmos: 0,
|
|
weaponCode: 'None',
|
|
bookCode: 'None',
|
|
horseCode: 'None',
|
|
itemCode: 'None',
|
|
turnTime: new Date('2026-01-01T00:00:00.000Z'),
|
|
recentWarTime: null,
|
|
age: 20,
|
|
startAge: 20,
|
|
personalCode: 'None',
|
|
specialCode: 'None',
|
|
special2Code: 'None',
|
|
lastTurn: {},
|
|
meta: { belong: 5, permission: 'normal' },
|
|
penalty: {},
|
|
createdAt: new Date('2026-01-01T00:00:00.000Z'),
|
|
updatedAt: new Date('2026-01-01T00:00:00.000Z'),
|
|
};
|
|
|
|
const auth: GameSessionTokenPayload = {
|
|
version: 1,
|
|
profile: 'che:default',
|
|
issuedAt: '2026-01-01T00:00:00.000Z',
|
|
expiresAt: '2026-01-02T00:00:00.000Z',
|
|
sessionId: 'session-22',
|
|
user: { id: 'user-22', username: 'tester', displayName: 'Tester', roles: [] },
|
|
sanctions: {},
|
|
};
|
|
|
|
const baseNation = {
|
|
id: 1,
|
|
name: '위',
|
|
level: 3,
|
|
tech: 3_000,
|
|
meta: {
|
|
_updatedAt: '2026-01-01T00:00:00.000Z',
|
|
npc_nation_policy: {
|
|
values: { reqNationRice: 456 },
|
|
priority: ['천도', '천도'],
|
|
},
|
|
npc_general_policy: {
|
|
priority: ['출병', '일반내정', '출병'],
|
|
},
|
|
},
|
|
};
|
|
|
|
const baseWorld = {
|
|
config: {
|
|
stat: { max: 80, npcMax: 75 },
|
|
environment: { unitSet: 'basic' },
|
|
const: { develCost: 100 },
|
|
},
|
|
meta: {
|
|
npc_nation_policy: { values: { reqNationGold: 123 } },
|
|
npc_general_policy: {},
|
|
},
|
|
};
|
|
|
|
const createContext = (
|
|
options: {
|
|
me?: GeneralRow;
|
|
nation?: typeof baseNation;
|
|
world?: {
|
|
config: typeof baseWorld.config;
|
|
meta: Record<string, unknown>;
|
|
currentYear?: number;
|
|
currentMonth?: number;
|
|
};
|
|
requestCommand?: ReturnType<typeof vi.fn>;
|
|
troopRows?: Array<{ troopLeaderId: number }>;
|
|
cityRows?: Array<{ id: number }>;
|
|
historyRows?: Array<Record<string, unknown>>;
|
|
} = {}
|
|
): { context: GameApiContext; findFirst: ReturnType<typeof vi.fn>; requestCommand: ReturnType<typeof vi.fn> } => {
|
|
const requestCommand =
|
|
options.requestCommand ??
|
|
vi.fn(async () => ({
|
|
type: 'setNpcPolicy',
|
|
ok: true,
|
|
nationId: 1,
|
|
updatedAt: '2026-01-01T00:01:00.000Z',
|
|
}));
|
|
const findFirst = vi.fn(async () => options.me ?? baseGeneral);
|
|
const db = {
|
|
general: { findFirst },
|
|
nation: { findUnique: vi.fn(async () => options.nation ?? baseNation) },
|
|
worldState: { findFirst: vi.fn(async () => options.world ?? baseWorld) },
|
|
troop: { findMany: vi.fn(async () => options.troopRows ?? [{ troopLeaderId: 101 }]) },
|
|
city: { findMany: vi.fn(async () => options.cityRows ?? [{ id: 1 }, { id: 2 }]) },
|
|
playAuditPolicy: {
|
|
findMany: vi.fn(async () => options.historyRows ?? []),
|
|
findFirst: vi.fn(async () => options.historyRows?.[0] ?? null),
|
|
},
|
|
$transaction: async <T>(read: (tx: object) => Promise<T>): Promise<T> => read(db),
|
|
};
|
|
const redisClient = { get: async () => null, set: async () => null };
|
|
return {
|
|
context: {
|
|
db: db as unknown as DatabaseClient,
|
|
redis: {} as RedisConnector['client'],
|
|
turnDaemon: { requestCommand } as unknown as TurnDaemonTransport,
|
|
battleSim: {} as GameApiContext['battleSim'],
|
|
profile: { id: 'che', scenario: 'default', name: 'che:default' },
|
|
auth,
|
|
uploadDir: 'uploads',
|
|
uploadPath: '/uploads',
|
|
uploadPublicUrl: null,
|
|
accessTokenStore: new RedisAccessTokenStore(redisClient, 'che:default'),
|
|
flushStore: new InMemoryFlushStore(),
|
|
gameTokenSecret: 'test-secret',
|
|
},
|
|
findFirst,
|
|
requestCommand,
|
|
};
|
|
};
|
|
|
|
describe('NPC policy router', () => {
|
|
const historyRow = {
|
|
id: 'a'.repeat(64),
|
|
schemaVersion: 1,
|
|
nationId: 1,
|
|
area: 'NPC_NATION_PRIORITY',
|
|
revision: 2,
|
|
previousId: 'b'.repeat(64),
|
|
source: 'CHANGE',
|
|
year: 185,
|
|
month: 1,
|
|
createdAt: new Date('2026-01-01Z'),
|
|
actor: {
|
|
userId: 'private-user',
|
|
generalId: 22,
|
|
name: '정책담당',
|
|
nationId: 1,
|
|
officerLevel: 12,
|
|
npcState: 0,
|
|
permission: 4,
|
|
},
|
|
before: { priority: ['NPC전방발령', 'NPC포상'] },
|
|
after: { priority: ['NPC포상'] },
|
|
};
|
|
const historyContext = (options: Parameters<typeof createContext>[0] = {}) =>
|
|
createContext({
|
|
...options,
|
|
world: {
|
|
...baseWorld,
|
|
currentYear: 185,
|
|
currentMonth: 1,
|
|
meta: { ...baseWorld.meta, serverId: 'current-season' },
|
|
},
|
|
historyRows: options.historyRows ?? [historyRow],
|
|
});
|
|
|
|
it('lets an ordinary nation reader inspect the actor and changes without admin request/account fields', async () => {
|
|
const fixture = historyContext({ me: { ...baseGeneral, officerLevel: 2 } });
|
|
const caller = appRouter.createCaller(fixture.context);
|
|
const page = await caller.npc.policyHistory({ area: 'NPC_NATION_PRIORITY', limit: 1 });
|
|
expect(page.items[0]).toMatchObject({ actor: { name: '정책담당' }, revision: 2 });
|
|
const detail = await caller.npc.policyVersion({ id: historyRow.id });
|
|
expect(detail.fields).toEqual([
|
|
{ key: 'priority', beforeJson: '["NPC전방발령","NPC포상"]', afterJson: '["NPC포상"]', changed: true },
|
|
]);
|
|
expect(JSON.stringify(detail)).not.toMatch(/private-user|permission|requestId|inputSequence/);
|
|
});
|
|
|
|
it.each([
|
|
{ nationId: 0 },
|
|
{ officerLevel: 0 },
|
|
{ officerLevel: 1, meta: { belong: 0 } },
|
|
{ penalty: { noChief: true } },
|
|
])('denies history when current nation read permission is missing: %j', async (patch) => {
|
|
const fixture = historyContext({ me: { ...baseGeneral, ...patch } });
|
|
await expect(
|
|
appRouter.createCaller(fixture.context).npc.policyHistory({ area: 'NPC_VALUES' })
|
|
).rejects.toBeDefined();
|
|
});
|
|
|
|
it('scopes cursor and version lookups to the authenticated nation and current season', async () => {
|
|
const fixture = historyContext();
|
|
const caller = appRouter.createCaller(fixture.context);
|
|
await caller.npc.policyHistory({ area: 'NPC_VALUES', cursor: 7, limit: 1 });
|
|
const tx = await fixture.context.db.$transaction!(async (db) => db);
|
|
expect(tx.playAuditPolicy.findMany).toHaveBeenCalledWith(
|
|
expect.objectContaining({
|
|
where: { serverId: 'current-season', nationId: 1, area: 'NPC_VALUES', revision: { lt: 7 } },
|
|
take: 2,
|
|
})
|
|
);
|
|
await caller.npc.policyVersion({ id: historyRow.id });
|
|
expect(tx.playAuditPolicy.findFirst).toHaveBeenCalledWith(
|
|
expect.objectContaining({
|
|
where: {
|
|
id: historyRow.id,
|
|
serverId: 'current-season',
|
|
nationId: 1,
|
|
area: { in: ['NPC_VALUES', 'NPC_NATION_PRIORITY', 'NPC_GENERAL_PRIORITY'] },
|
|
},
|
|
})
|
|
);
|
|
await expect(caller.npc.policyHistory({ area: 'NPC_VALUES', limit: 51 })).rejects.toMatchObject({
|
|
code: 'BAD_REQUEST',
|
|
});
|
|
await expect(caller.npc.policyVersion({ id: 'bad' })).rejects.toMatchObject({ code: 'BAD_REQUEST' });
|
|
});
|
|
|
|
it('requires authentication and rejects caller-supplied nation or defence history over HTTP', async () => {
|
|
const fixture = historyContext();
|
|
const app = fastify();
|
|
await app.register(fastifyTRPCPlugin, {
|
|
prefix: '/che/api/trpc',
|
|
trpcOptions: {
|
|
router: appRouter,
|
|
createContext: ({ req }: { req: { headers: Record<string, string | string[] | undefined> } }) => ({
|
|
...fixture.context,
|
|
auth: req.headers['x-session-token'] === 'fixture-session' ? auth : null,
|
|
}),
|
|
},
|
|
});
|
|
try {
|
|
const query = (input: object, authenticated = true) =>
|
|
app.inject({
|
|
url: `/che/api/trpc/npc.policyHistory?input=${encodeURIComponent(JSON.stringify(input))}`,
|
|
headers: authenticated ? { 'x-session-token': 'fixture-session' } : {},
|
|
});
|
|
expect((await query({ area: 'NPC_VALUES' }, false)).statusCode).toBe(401);
|
|
expect((await query({ area: 'NPC_VALUES' })).statusCode).toBe(200);
|
|
expect((await query({ area: 'DEFENCE' })).statusCode).toBe(400);
|
|
expect((await query({ area: 'NPC_VALUES', nationId: 2 })).statusCode).toBe(400);
|
|
} finally {
|
|
await app.close();
|
|
}
|
|
});
|
|
|
|
it('denies sanctioned sessions before reading history', async () => {
|
|
const fixture = historyContext();
|
|
fixture.context.auth = { ...auth, sanctions: { suspendedUntil: '2999-01-01T00:00:00Z' } };
|
|
await expect(
|
|
appRouter.createCaller(fixture.context).npc.policyHistory({ area: 'NPC_VALUES' })
|
|
).rejects.toMatchObject({ code: 'FORBIDDEN' });
|
|
expect(fixture.findFirst).not.toHaveBeenCalled();
|
|
});
|
|
|
|
it('paginates revisions without exposing a missing or unavailable version', async () => {
|
|
const fixture = historyContext({ historyRows: [historyRow, { ...historyRow, revision: 1 }] });
|
|
const page = await appRouter
|
|
.createCaller(fixture.context)
|
|
.npc.policyHistory({ area: 'NPC_NATION_PRIORITY', limit: 1 });
|
|
expect(page.items).toHaveLength(1);
|
|
expect(page.nextCursor).toBe(2);
|
|
const missing = historyContext({ historyRows: [] });
|
|
await expect(
|
|
appRouter.createCaller(missing.context).npc.policyVersion({ id: historyRow.id })
|
|
).rejects.toMatchObject({ code: 'NOT_FOUND' });
|
|
const noIdentity = createContext();
|
|
await expect(
|
|
appRouter.createCaller(noIdentity.context).npc.policyHistory({ area: 'NPC_VALUES' })
|
|
).resolves.toMatchObject({ coverage: 'IDENTITY_MISSING', items: [], nextCursor: null });
|
|
});
|
|
it('loads server and nation overrides while calculating legacy zero-value hints from nation tech', async () => {
|
|
const fixture = createContext();
|
|
const result = await appRouter.createCaller(fixture.context).npc.getPolicy();
|
|
|
|
expect(fixture.findFirst).toHaveBeenCalledWith({ where: { userId: 'user-22' } });
|
|
expect(result.currentNationPolicy).toMatchObject({ reqNationGold: 123, reqNationRice: 456 });
|
|
expect(result.currentNationPriority).toEqual(['천도', '천도']);
|
|
expect(result.currentGeneralActionPriority).toEqual(['출병', '일반내정', '출병']);
|
|
expect(result.zeroPolicy).toMatchObject({
|
|
reqNationGold: 10_000,
|
|
reqNationRice: 12_000,
|
|
reqNPCDevelGold: 3_000,
|
|
reqNPCWarGold: 3_900,
|
|
reqNPCWarRice: 3_900,
|
|
reqHumanWarUrgentGold: 6_300,
|
|
reqHumanWarUrgentRice: 6_300,
|
|
reqHumanWarRecommandGold: 12_600,
|
|
reqHumanWarRecommandRice: 12_600,
|
|
});
|
|
});
|
|
|
|
it('uses the live world development cost instead of the scenario snapshot', async () => {
|
|
const fixture = createContext({
|
|
world: {
|
|
...baseWorld,
|
|
config: { ...baseWorld.config, const: { develCost: 100 } },
|
|
meta: { ...baseWorld.meta, develcost: 42 } as typeof baseWorld.meta & { develcost: number },
|
|
},
|
|
});
|
|
|
|
const result = await appRouter.createCaller(fixture.context).npc.getPolicy();
|
|
|
|
expect(result.zeroPolicy.reqNPCDevelGold).toBe(1_260);
|
|
});
|
|
|
|
it('lets a secret-level reader load the page while mapping authoritative ENGINE rejection', async () => {
|
|
const reader = { ...baseGeneral, officerLevel: 2 };
|
|
const requestCommand = vi.fn(async () => ({
|
|
type: 'setNpcPolicy' as const,
|
|
ok: false as const,
|
|
code: 'FORBIDDEN' as const,
|
|
reason: '권한이 부족합니다.',
|
|
nationId: 1,
|
|
}));
|
|
const fixture = createContext({ me: reader, requestCommand });
|
|
const caller = appRouter.createCaller(fixture.context);
|
|
|
|
await expect(caller.npc.getPolicy()).resolves.toMatchObject({ permissionLevel: 1 });
|
|
await expect(caller.npc.setNationPriority(['천도'])).rejects.toMatchObject({ code: 'FORBIDDEN' });
|
|
expect(fixture.requestCommand).toHaveBeenCalledOnce();
|
|
});
|
|
|
|
it.each([
|
|
['군주', { ...baseGeneral, officerLevel: 12 }],
|
|
['감찰권자', { ...baseGeneral, officerLevel: 1, meta: { belong: 0, permission: 'auditor' } }],
|
|
['외교권자', { ...baseGeneral, officerLevel: 1, meta: { belong: 0, permission: 'ambassador' } }],
|
|
])('%s dispatches actor-bound policy intent to the daemon', async (_label, me) => {
|
|
const fixture = createContext({ me });
|
|
await expect(appRouter.createCaller(fixture.context).npc.setNationPriority(['천도', '천도'])).resolves.toEqual({
|
|
ok: true,
|
|
});
|
|
expect(fixture.requestCommand).toHaveBeenCalledWith({
|
|
type: 'setNpcPolicy',
|
|
userId: 'user-22',
|
|
generalId: 22,
|
|
nationId: 1,
|
|
expectedUpdatedAt: '2026-01-01T00:00:00.000Z',
|
|
mutation: { kind: 'nationPriority', priority: ['천도', '천도'] },
|
|
});
|
|
});
|
|
|
|
it('forwards raw policy intent so ENGINE can validate current troop and city state atomically', async () => {
|
|
const fixture = createContext();
|
|
const caller = appRouter.createCaller(fixture.context);
|
|
|
|
await caller.npc.setNationPolicy({
|
|
reqNationGold: -100,
|
|
safeRecruitCityPopulationRatio: -0.5,
|
|
CombatForce: { 101: [1, 2] },
|
|
});
|
|
expect(fixture.requestCommand).toHaveBeenCalledWith(
|
|
expect.objectContaining({
|
|
type: 'setNpcPolicy',
|
|
mutation: {
|
|
kind: 'nationPolicy',
|
|
values: {
|
|
reqNationGold: -100,
|
|
safeRecruitCityPopulationRatio: -0.5,
|
|
CombatForce: { 101: [1, 2] },
|
|
},
|
|
},
|
|
})
|
|
);
|
|
});
|
|
|
|
it('preserves duplicate priority entries in the dispatched intent', async () => {
|
|
const fixture = createContext();
|
|
const caller = appRouter.createCaller(fixture.context);
|
|
|
|
await caller.npc.setGeneralPriority(['출병', '출병', '일반내정']);
|
|
expect(fixture.requestCommand).toHaveBeenCalledWith(
|
|
expect.objectContaining({
|
|
mutation: { kind: 'generalPriority', priority: ['출병', '출병', '일반내정'] },
|
|
})
|
|
);
|
|
});
|
|
|
|
it('blocks nationless, penalized, and stale writers without changing lifecycle state directly', async () => {
|
|
const nationless = createContext({ me: { ...baseGeneral, nationId: 0, officerLevel: 0 } });
|
|
await expect(appRouter.createCaller(nationless.context).npc.getPolicy()).rejects.toMatchObject({
|
|
code: 'PRECONDITION_FAILED',
|
|
});
|
|
|
|
const penalized = createContext({ me: { ...baseGeneral, penalty: { noChief: true } } });
|
|
await expect(appRouter.createCaller(penalized.context).npc.getPolicy()).rejects.toMatchObject({
|
|
code: 'FORBIDDEN',
|
|
});
|
|
|
|
const staleCommand = vi.fn(async () => ({
|
|
type: 'setNpcPolicy',
|
|
ok: false,
|
|
code: 'CONFLICT',
|
|
nationId: 1,
|
|
reason: '다른 사용자가 정책을 변경했습니다.',
|
|
}));
|
|
const stale = createContext({ requestCommand: staleCommand });
|
|
await expect(appRouter.createCaller(stale.context).npc.setNationPriority(['천도'])).rejects.toMatchObject({
|
|
code: 'CONFLICT',
|
|
});
|
|
});
|
|
});
|