447 lines
18 KiB
TypeScript
447 lines
18 KiB
TypeScript
import { createGamePostgresConnector } from '@sammo-ts/infra';
|
|
import { describe, expect, test } from 'vitest';
|
|
import { resolveDatabaseUrl } from '../src/scenario/databaseUrl.js';
|
|
import { loadScenarioDefinitionById } from '../src/scenario/scenarioLoader.js';
|
|
import { seedScenarioToDatabase } from '../src/scenario/scenarioSeeder.js';
|
|
|
|
const scenarioId = 1010;
|
|
const schema = process.env.POSTGRES_SCHEMA ?? 'public';
|
|
process.env.POSTGRES_SCHEMA = schema;
|
|
const databaseUrl = await resolveDatabaseUrl({ schema });
|
|
|
|
type ScenarioSeederPrismaClient = {
|
|
$queryRawUnsafe(query: string): Promise<unknown>;
|
|
nation: {
|
|
count(): Promise<number>;
|
|
};
|
|
city: {
|
|
count(): Promise<number>;
|
|
findUnique(args: { where: { id: number } }): Promise<{
|
|
population: number;
|
|
agriculture: number;
|
|
commerce: number;
|
|
security: number;
|
|
trust: number;
|
|
defence: number;
|
|
wall: number;
|
|
} | null>;
|
|
};
|
|
general: {
|
|
count(): Promise<number>;
|
|
findFirst(): Promise<{ age: number; startAge: number; meta: unknown } | null>;
|
|
};
|
|
selectPoolEntry: {
|
|
count(): Promise<number>;
|
|
findFirst(args: {
|
|
orderBy: { id: 'asc' | 'desc' };
|
|
}): Promise<{ uniqueName: string; info: unknown } | null>;
|
|
};
|
|
diplomacy: {
|
|
count(): Promise<number>;
|
|
findFirst(args: {
|
|
where: { srcNationId: number; destNationId: number };
|
|
}): Promise<{ stateCode: number; term: number } | null>;
|
|
};
|
|
event: {
|
|
count(): Promise<number>;
|
|
};
|
|
worldState: {
|
|
findFirst(): Promise<{
|
|
config: unknown;
|
|
meta: unknown;
|
|
tickSeconds: number;
|
|
currentYear: number;
|
|
currentMonth: number;
|
|
} | null>;
|
|
};
|
|
gameHistory: {
|
|
findUnique(args: { where: { serverId: string } }): Promise<{ env: unknown } | null>;
|
|
deleteMany(args: { where: { serverId: string } }): Promise<{ count: number }>;
|
|
};
|
|
};
|
|
|
|
const requiredTables = ['world_state', 'nation', 'city', 'general', 'diplomacy', 'troop', 'event'];
|
|
|
|
const hasRequiredTables = async (prisma: ScenarioSeederPrismaClient, schemaName: string): Promise<boolean> => {
|
|
for (const table of requiredTables) {
|
|
const result = (await prisma.$queryRawUnsafe(
|
|
`SELECT to_regclass('${schemaName}.${table}')::text as regclass`
|
|
)) as Array<{ regclass: string | null }>;
|
|
if (!Array.isArray(result) || result.length === 0 || result[0]?.regclass === null) {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
};
|
|
|
|
const canConnectToDatabase = async (url: string): Promise<boolean> => {
|
|
const connector = createGamePostgresConnector({ url });
|
|
try {
|
|
await connector.connect();
|
|
const prisma = connector.prisma as unknown as ScenarioSeederPrismaClient;
|
|
await prisma.$queryRawUnsafe('SELECT 1');
|
|
if (!(await hasRequiredTables(prisma, schema))) {
|
|
return false;
|
|
}
|
|
return true;
|
|
} catch {
|
|
return false;
|
|
} finally {
|
|
await connector.disconnect();
|
|
}
|
|
};
|
|
|
|
const canRun = await canConnectToDatabase(databaseUrl);
|
|
const describeDb = describe.runIf(canRun);
|
|
|
|
describeDb('scenario database seed', () => {
|
|
test('writes scenario data into tables', async () => {
|
|
const { seed } = await seedScenarioToDatabase({
|
|
scenarioId,
|
|
databaseUrl,
|
|
});
|
|
|
|
const connector = createGamePostgresConnector({ url: databaseUrl });
|
|
await connector.connect();
|
|
try {
|
|
const prisma = connector.prisma as unknown as ScenarioSeederPrismaClient;
|
|
const [nationCount, cityCount, generalCount, diplomacyCount, eventCount] = await Promise.all([
|
|
prisma.nation.count(),
|
|
prisma.city.count(),
|
|
prisma.general.count(),
|
|
prisma.diplomacy.count(),
|
|
prisma.event.count(),
|
|
]);
|
|
|
|
expect(nationCount).toBe(seed.nations.length);
|
|
expect(cityCount).toBe(seed.cities.length);
|
|
expect(generalCount).toBe(seed.generals.length);
|
|
expect(diplomacyCount).toBe(seed.nations.length * Math.max(0, seed.nations.length - 1));
|
|
expect(eventCount).toBe(seed.events.length);
|
|
expect(generalCount).toBeGreaterThan(0);
|
|
const seededGeneral = await prisma.general.findFirst();
|
|
expect(seededGeneral?.startAge).toBe(seededGeneral?.age);
|
|
expect(seededGeneral?.meta).toEqual(
|
|
expect.objectContaining({
|
|
specage: expect.any(Number),
|
|
specage2: expect.any(Number),
|
|
})
|
|
);
|
|
|
|
const freeCity = seed.cities.find((city) => city.nationId === 0);
|
|
const occupiedCity = seed.cities.find((city) => city.nationId !== 0);
|
|
expect(freeCity).toMatchObject({
|
|
population: freeCity ? Math.round(freeCity.populationMax * 0.7) : undefined,
|
|
agriculture: freeCity ? Math.round(freeCity.agricultureMax * 0.7) : undefined,
|
|
commerce: freeCity ? Math.round(freeCity.commerceMax * 0.7) : undefined,
|
|
security: freeCity ? Math.round(freeCity.securityMax * 0.7) : undefined,
|
|
trust: 80,
|
|
});
|
|
expect(occupiedCity).toMatchObject({
|
|
population: occupiedCity ? Math.round(occupiedCity.populationMax * 0.7) : undefined,
|
|
defence: occupiedCity ? Math.round(occupiedCity.defenceMax * 0.7) : undefined,
|
|
wall: occupiedCity ? Math.round(occupiedCity.wallMax * 0.7) : undefined,
|
|
trust: 80,
|
|
});
|
|
for (const city of [freeCity, occupiedCity]) {
|
|
expect(city).toBeDefined();
|
|
if (!city) {
|
|
continue;
|
|
}
|
|
expect(await prisma.city.findUnique({ where: { id: city.id } })).toMatchObject({
|
|
population: city.population,
|
|
agriculture: city.agriculture,
|
|
commerce: city.commerce,
|
|
security: city.security,
|
|
trust: city.trust,
|
|
defence: city.defence,
|
|
wall: city.wall,
|
|
});
|
|
}
|
|
|
|
if (seed.diplomacy.length > 0) {
|
|
const sample = seed.diplomacy[0];
|
|
const row = await prisma.diplomacy.findFirst({
|
|
where: {
|
|
srcNationId: sample.fromNationId,
|
|
destNationId: sample.toNationId,
|
|
},
|
|
});
|
|
expect(row).not.toBeNull();
|
|
if (row) {
|
|
expect(row.stateCode).toBe(sample.state);
|
|
expect(row.term).toBe(sample.durationMonths);
|
|
}
|
|
const reverse = await prisma.diplomacy.findFirst({
|
|
where: {
|
|
srcNationId: sample.toNationId,
|
|
destNationId: sample.fromNationId,
|
|
},
|
|
});
|
|
expect(reverse).not.toBeNull();
|
|
if (reverse) {
|
|
expect(reverse.stateCode).toBe(sample.state);
|
|
expect(reverse.term).toBe(sample.durationMonths);
|
|
}
|
|
}
|
|
} finally {
|
|
await connector.disconnect();
|
|
}
|
|
});
|
|
|
|
test('applies install options to world state', async () => {
|
|
const scenario = await loadScenarioDefinitionById(scenarioId);
|
|
const { seed } = await seedScenarioToDatabase({
|
|
scenarioId,
|
|
databaseUrl,
|
|
now: new Date('2030-01-01T00:00:00Z'),
|
|
installOptions: {
|
|
turnTermMinutes: 60,
|
|
sync: false,
|
|
fiction: 1,
|
|
extend: false,
|
|
blockGeneralCreate: 2,
|
|
npcMode: 0,
|
|
showImgLevel: 3,
|
|
tournamentTrig: true,
|
|
joinMode: 'full',
|
|
autorunUser: {
|
|
limitMinutes: 60,
|
|
options: {
|
|
develop: true,
|
|
},
|
|
},
|
|
},
|
|
});
|
|
|
|
// Future-born entries are converted to delayed events, so the raw
|
|
// scenario array length is not the installed general count.
|
|
expect(seed.generals.length).toBeGreaterThan(0);
|
|
expect(seed.generals.length).toBeLessThan(
|
|
scenario.generals.length + scenario.generalsNeutral.length + scenario.generalsEx.length
|
|
);
|
|
|
|
const connector = createGamePostgresConnector({ url: databaseUrl });
|
|
await connector.connect();
|
|
try {
|
|
const prisma = connector.prisma as unknown as ScenarioSeederPrismaClient;
|
|
const worldState = await prisma.worldState.findFirst();
|
|
expect(worldState).not.toBeNull();
|
|
if (!worldState) {
|
|
return;
|
|
}
|
|
expect(worldState.tickSeconds).toBe(3600);
|
|
expect(worldState.currentMonth).toBe(1);
|
|
|
|
const config = (worldState.config ?? {}) as Record<string, unknown>;
|
|
expect(config.extendedGeneral).toBe(false);
|
|
expect(config.joinMode).toBe('full');
|
|
|
|
const meta = (worldState.meta ?? {}) as Record<string, unknown>;
|
|
const autorun = (meta.autorun_user ?? {}) as Record<string, unknown>;
|
|
const autorunOptions = (autorun.options ?? {}) as Record<string, unknown>;
|
|
expect(autorunOptions.develop).toBe(true);
|
|
} finally {
|
|
await connector.disconnect();
|
|
}
|
|
});
|
|
|
|
test('persists a tracked scenario effect in the world configuration', async () => {
|
|
await seedScenarioToDatabase({
|
|
scenarioId: 906,
|
|
databaseUrl,
|
|
});
|
|
|
|
const connector = createGamePostgresConnector({ url: databaseUrl });
|
|
await connector.connect();
|
|
try {
|
|
const prisma = connector.prisma as unknown as ScenarioSeederPrismaClient;
|
|
const worldState = await prisma.worldState.findFirst();
|
|
const config = (worldState?.config ?? {}) as Record<string, unknown>;
|
|
const environment = (config.environment ?? {}) as Record<string, unknown>;
|
|
expect(environment.scenarioEffect).toBe('event_StrongAttacker');
|
|
} finally {
|
|
await connector.disconnect();
|
|
}
|
|
});
|
|
|
|
test('seeds the exact scenario 903 UnderS30 selection pool', async () => {
|
|
await seedScenarioToDatabase({
|
|
scenarioId: 903,
|
|
databaseUrl,
|
|
});
|
|
|
|
const connector = createGamePostgresConnector({ url: databaseUrl });
|
|
await connector.connect();
|
|
try {
|
|
const prisma = connector.prisma as unknown as ScenarioSeederPrismaClient;
|
|
expect(await prisma.selectPoolEntry.count()).toBe(1844);
|
|
expect(await prisma.selectPoolEntry.findFirst({ orderBy: { id: 'asc' } })).toMatchObject({
|
|
uniqueName: '⑨탈곡기',
|
|
info: {
|
|
generalName: '⑨탈곡기',
|
|
specialDomestic: 'che_event_징병',
|
|
},
|
|
});
|
|
expect(await prisma.selectPoolEntry.findFirst({ orderBy: { id: 'desc' } })).toMatchObject({
|
|
uniqueName: '④야부키 나코',
|
|
});
|
|
} finally {
|
|
await connector.disconnect();
|
|
}
|
|
});
|
|
|
|
test('clears general lifecycle rows before reusing general ids on reseed', async () => {
|
|
await seedScenarioToDatabase({
|
|
scenarioId: 903,
|
|
databaseUrl,
|
|
});
|
|
|
|
const connector = createGamePostgresConnector({ url: databaseUrl });
|
|
await connector.connect();
|
|
try {
|
|
const prisma = connector.prisma;
|
|
const generalId = 990_903;
|
|
const createSelectedGeneral = async (): Promise<void> => {
|
|
await prisma.general.create({
|
|
data: {
|
|
id: generalId,
|
|
userId: 'scenario-reseed-user',
|
|
name: '재설치선택장수',
|
|
turnTime: new Date('2026-07-30T12:00:00.000Z'),
|
|
},
|
|
});
|
|
};
|
|
const createLifecycleRows = async (): Promise<void> => {
|
|
await prisma.generalTurn.create({
|
|
data: {
|
|
generalId,
|
|
turnIdx: 0,
|
|
actionCode: '휴식',
|
|
},
|
|
});
|
|
await prisma.generalTurnRevision.create({
|
|
data: {
|
|
generalId,
|
|
revision: 7,
|
|
},
|
|
});
|
|
await prisma.rankData.create({
|
|
data: {
|
|
nationId: 0,
|
|
generalId,
|
|
type: 'experience',
|
|
value: 123,
|
|
},
|
|
});
|
|
await prisma.generalAccessLog.create({
|
|
data: {
|
|
generalId,
|
|
userId: 'scenario-reseed-user',
|
|
},
|
|
});
|
|
};
|
|
const expectLifecycleRows = async (count: number): Promise<void> => {
|
|
await expect(
|
|
Promise.all([
|
|
prisma.generalTurn.count({ where: { generalId } }),
|
|
prisma.generalTurnRevision.count({ where: { generalId } }),
|
|
prisma.rankData.count({ where: { generalId } }),
|
|
prisma.generalAccessLog.count({ where: { generalId } }),
|
|
])
|
|
).resolves.toEqual([count, count, count, count]);
|
|
};
|
|
|
|
await createSelectedGeneral();
|
|
await createLifecycleRows();
|
|
await expectLifecycleRows(1);
|
|
|
|
await seedScenarioToDatabase({
|
|
scenarioId: 903,
|
|
databaseUrl,
|
|
});
|
|
await expectLifecycleRows(0);
|
|
await expect(prisma.general.findUnique({ where: { id: generalId } })).resolves.toBeNull();
|
|
|
|
await createSelectedGeneral();
|
|
await createLifecycleRows();
|
|
await expectLifecycleRows(1);
|
|
|
|
await seedScenarioToDatabase({
|
|
scenarioId: 903,
|
|
databaseUrl,
|
|
});
|
|
await expectLifecycleRows(0);
|
|
} finally {
|
|
await connector.disconnect();
|
|
}
|
|
});
|
|
|
|
test('persists a private hidden seed without copying it into game history', async () => {
|
|
const envName = 'INTEGRATION_WORLD_SEED';
|
|
const originalSeed = process.env[envName];
|
|
const serverId = 'scenario-seeder-hidden-seed-test';
|
|
const connector = createGamePostgresConnector({ url: databaseUrl });
|
|
try {
|
|
process.env[envName] = 'scenario-seeder-explicit-hidden-seed';
|
|
await seedScenarioToDatabase({
|
|
scenarioId: 903,
|
|
databaseUrl,
|
|
installOptions: { serverId },
|
|
});
|
|
|
|
await connector.connect();
|
|
const prisma = connector.prisma as unknown as ScenarioSeederPrismaClient;
|
|
const explicitWorld = await prisma.worldState.findFirst();
|
|
expect(explicitWorld?.meta).toMatchObject({
|
|
hiddenSeed: 'scenario-seeder-explicit-hidden-seed',
|
|
});
|
|
const explicitHistory = await prisma.gameHistory.findUnique({ where: { serverId } });
|
|
expect((explicitHistory?.env as { meta?: Record<string, unknown> })?.meta).not.toHaveProperty(
|
|
'hiddenSeed'
|
|
);
|
|
|
|
delete process.env[envName];
|
|
await seedScenarioToDatabase({
|
|
scenarioId: 903,
|
|
databaseUrl,
|
|
installOptions: { serverId },
|
|
});
|
|
const randomWorld = await prisma.worldState.findFirst();
|
|
const randomSeed = (randomWorld?.meta as Record<string, unknown>)?.hiddenSeed;
|
|
expect(randomSeed).toMatch(/^[0-9a-f]{32}$/);
|
|
expect(randomSeed).not.toBe('scenario-seeder-explicit-hidden-seed');
|
|
const randomHistory = await prisma.gameHistory.findUnique({ where: { serverId } });
|
|
expect((randomHistory?.env as { meta?: Record<string, unknown> })?.meta).not.toHaveProperty(
|
|
'hiddenSeed'
|
|
);
|
|
await prisma.gameHistory.deleteMany({ where: { serverId } });
|
|
} finally {
|
|
if (originalSeed === undefined) {
|
|
delete process.env[envName];
|
|
} else {
|
|
process.env[envName] = originalSeed;
|
|
}
|
|
await connector.disconnect();
|
|
}
|
|
});
|
|
});
|
|
|
|
describe('tracked scenario composition', () => {
|
|
test('loads the shared event and buyable unique extensions', async () => {
|
|
const standard = await loadScenarioDefinitionById(1010);
|
|
const expanded = await loadScenarioDefinitionById(2141);
|
|
const mixedConst = await loadScenarioDefinitionById(2904);
|
|
|
|
expect(standard.events).toHaveLength(1);
|
|
expect(standard.initialEvents).toHaveLength(1);
|
|
expect(expanded.events).toHaveLength(7);
|
|
expect(expanded.initialEvents).toHaveLength(1);
|
|
expect(expanded.config.const.availableSpecialWar).toHaveLength(20);
|
|
expect(Object.keys(expanded.config.const.allItems as object)).toEqual(['horse', 'weapon', 'book', 'item']);
|
|
expect(mixedConst.config.const.scenarioEffect).toBe('event_StrongAttacker');
|
|
expect(mixedConst.config.const.availableSpecialWar).toEqual(expanded.config.const.availableSpecialWar);
|
|
expect(mixedConst.config.const.allItems).toEqual(expanded.config.const.allItems);
|
|
});
|
|
});
|