refactor: import historical results as competition facts

This commit is contained in:
dahyeon committed 2026-07-12 20:08:29 +00:00
1 parent 6aa2cb9009
commit 7db97c540b
4 files changed
+1222 -77

No files matched your search

@@ -0,0 +1,716 @@
/* eslint-disable @typescript-eslint/no-unsafe-assignment, @typescript-eslint/require-await, @typescript-eslint/unbound-method */
import { readFileSync } from 'node:fs';
import mongoose from 'mongoose';
import type { CompetitionBootstrapService } from '../competition/competition-bootstrap.service';
import type { CompetitionCommandService } from '../competition/competition-command.service';
import type { MatchStatsService } from '../community-stats/match-stats.service';
import type { CommunityStatsService } from '../community-stats/community-stats.service';
import type { ConnectionService } from '../global/database/connection.service';
import type { DistributedLockService } from '../global/redis/distributed-lock.service';
import type { RedisService } from '../global/redis/redis.service';
import type { RiotMatchService } from '../riot/riot-match.service';
import type { RiotMatchDto } from '../riot/riot.types';
import { LegacyImportService } from './legacy-import.service';
import type { LegacyUserSnapshot, UserByPuuidMap } from './match-builder.util';
import type { LegacyImportMemberJob } from './legacy-import.types';
const ServiceConstructor = LegacyImportService as unknown as new (
...dependencies: unknown[]
) => LegacyImportService;
describe('Legacy import Competition result cutover', () => {
it('has no production Match.result writer', () => {
const source = readFileSync(
require.resolve('./legacy-import.service'),
'utf8',
);
expect(source).not.toMatch(/\b(?:match|update)\.result\s*=/u);
expect(source).not.toMatch(/\bresult\s*:\s*\{\s*winnerTeamIndex/u);
});
it('creates a paired Competition and accepts Riot evidence without writing Match.result', async () => {
const fixture = createImportFixture();
const competitionFactModel = {
exists: jest.fn().mockResolvedValue(null),
};
const matchModel = {
findOneAndUpdate: jest.fn().mockReturnValue(execResult(fixture.match)),
updateOne: jest.fn().mockReturnValue(execResult({ modifiedCount: 1 })),
};
const connectionService = {
getModel: jest.fn(async (name: string) => {
if (name === 'competitionFact') return competitionFactModel;
if (name === 'match') return matchModel;
throw new Error(`Unexpected model ${name}`);
}),
} as unknown as ConnectionService;
const bootstrapService = {
bootstrap: jest.fn().mockResolvedValue(fixture.competition),
} as unknown as jest.Mocked<CompetitionBootstrapService>;
const commandService = {
acceptGame: jest.fn().mockResolvedValue({
competition: {
...fixture.competition,
revision: 1,
phase: 'completed',
},
commandId: 'command-1',
revision: 1,
replayed: false,
}),
} as unknown as jest.Mocked<CompetitionCommandService>;
const matchStatsService = {
buildAndUpsert: jest.fn().mockResolvedValue(undefined),
} as unknown as jest.Mocked<MatchStatsService>;
const service = createService({
connectionService,
matchStatsService,
bootstrapService,
commandService,
runWithLock: async (_options, operation) => operation(),
});
jest
.spyOn(
service as unknown as {
ensureRiotMatchPersisted: (
riotMatchId: string,
region: string,
) => Promise<RiotMatchDto>;
},
'ensureRiotMatchPersisted',
)
.mockResolvedValue(fixture.detail);
const outcome = await importSingleMatch(
service,
fixture.detail.metadata.matchId,
fixture.job,
fixture.userByPuuid,
);
expect(outcome).toBe('imported');
expect(matchModel.findOneAndUpdate).toHaveBeenCalledWith(
{ _id: expect.any(mongoose.Types.ObjectId) },
{
$setOnInsert: expect.not.objectContaining({
result: expect.anything(),
doubleElimination: expect.anything(),
}),
},
expect.objectContaining({ upsert: true, returnDocument: 'after' }),
);
expect(bootstrapService.bootstrap).toHaveBeenCalledWith(
expect.objectContaining({
gameMode: 'pair',
gameCount: 1,
teams: expect.arrayContaining([
expect.objectContaining({ teamIndex: 1 }),
expect.objectContaining({ teamIndex: 2 }),
]),
}),
);
expect(commandService.acceptGame).toHaveBeenCalledWith(
expect.objectContaining({
competitionId: fixture.competition._id.toString(),
expectedRevision: 0,
evidence: expect.objectContaining({
type: 'riot',
riotMatchId: fixture.detail.metadata.matchId,
payloadHash: expect.stringMatching(/^[a-f0-9]{64}$/u),
}),
mapping: expect.objectContaining({
blueTeamId: fixture.blueTeamId.toString(),
redTeamId: fixture.redTeamId.toString(),
winnerTeamId: fixture.blueTeamId.toString(),
algorithmVersion: 'roster-overlap-v1',
mappingVersion: 1,
confidence: 1,
diagnostics: {
trustedOverlap: 10,
normalOverlap: 10,
reversedOverlap: 0,
},
participantAssignments: expect.any(Array),
snapshot: expect.any(Object),
}),
}),
);
expect(matchModel.updateOne).toHaveBeenCalledWith(
{ _id: fixture.match._id },
{ $set: { status: 'finished' } },
);
expect(matchStatsService.buildAndUpsert).toHaveBeenCalledWith(
fixture.match._id,
{ sourceRevision: 1 },
);
});
it('detects duplicates from accepted Competition fact evidence before fetching Riot data', async () => {
const fixture = createImportFixture();
const competitionFactModel = {
exists: jest
.fn()
.mockResolvedValue({ _id: new mongoose.Types.ObjectId() }),
};
const connectionService = {
getModel: jest.fn(async (name: string) => {
if (name === 'competitionFact') return competitionFactModel;
throw new Error(`Unexpected model ${name}`);
}),
} as unknown as ConnectionService;
const service = createService({
connectionService,
runWithLock: async (_options, operation) => operation(),
});
const ensureRiotMatchPersisted = jest
.spyOn(
service as unknown as {
ensureRiotMatchPersisted: () => Promise<RiotMatchDto>;
},
'ensureRiotMatchPersisted',
)
.mockResolvedValue(fixture.detail);
const outcome = await importSingleMatch(
service,
fixture.detail.metadata.matchId,
fixture.job,
fixture.userByPuuid,
);
expect(outcome).toBe('duplicate');
expect(competitionFactModel.exists).toHaveBeenCalledWith({
type: 'game-accepted',
'evidence.type': 'riot',
'evidence.riotMatchId': fixture.detail.metadata.matchId,
});
expect(ensureRiotMatchPersisted).not.toHaveBeenCalled();
});
it('lists new legacy imports from Competition projection when Match.result is absent', async () => {
const fixture = createImportFixture();
const canonicalCompetition = {
...fixture.competition,
revision: 1,
phase: 'completed',
projection: {
phase: 'completed',
series: [
{
...fixture.competition.projection.series[0],
status: 'completed',
entries: [
{
slot: 'A',
teamId: fixture.blueTeamId,
gameWins: 1,
},
{ slot: 'B', teamId: fixture.redTeamId, gameWins: 0 },
],
outcome: {
type: 'played',
winnerTeamId: fixture.blueTeamId,
loserTeamId: fixture.redTeamId,
},
},
],
gameSlots: [],
games: [
{
seriesId: fixture.competition.projection.series[0].seriesId,
winnerTeamId: fixture.blueTeamId,
evidence: {
type: 'riot',
riotMatchId: fixture.detail.metadata.matchId,
},
participants: fixture.match.participants.map(({ userId }) => ({
userId,
})),
},
],
},
};
const matchModel = {
find: jest.fn().mockReturnValue({
sort: jest.fn().mockReturnValue({
limit: jest.fn().mockReturnValue(execResult([fixture.match])),
}),
}),
};
const competitionModel = {
find: jest.fn().mockReturnValue({
lean: jest.fn().mockReturnValue(execResult([canonicalCompetition])),
}),
};
const riotMatchModel = {
find: jest.fn().mockReturnValue({
lean: jest.fn().mockReturnValue(
execResult([
{
matchId: fixture.detail.metadata.matchId,
raw: fixture.detail,
},
]),
),
}),
};
const connectionService = {
getModel: jest.fn((name: string) => {
if (name === 'match') return Promise.resolve(matchModel);
if (name === 'competition') return Promise.resolve(competitionModel);
if (name === 'riotMatch') return Promise.resolve(riotMatchModel);
return Promise.reject(new Error(`Unexpected model ${name}`));
}),
} as unknown as ConnectionService;
const service = createService({ connectionService });
jest
.spyOn(
service as unknown as {
buildUserByPuuidMap: () => Promise<UserByPuuidMap>;
},
'buildUserByPuuidMap',
)
.mockResolvedValue(fixture.userByPuuid);
const page = await service.listLegacyMatches({
communityId: fixture.match.communityId,
});
expect(page.matches).toEqual([
expect.objectContaining({
matchId: fixture.match._id.toString(),
riotMatchId: fixture.detail.metadata.matchId,
memberCount: 10,
externalCount: 0,
teamAIndex: 1,
teamBIndex: 2,
teamAWins: 1,
teamBWins: 0,
winnerTeamIndex: 1,
}),
]);
});
it('cascades admin deletion through Competition facts and read models', async () => {
const fixture = createImportFixture();
const competitionFactModel = deleteManyModel();
const competitionOutboxModel = deleteManyModel();
const assignmentModel = deleteManyModel();
const competitionModel = {
...deleteManyModel(),
find: jest.fn().mockReturnValue({
select: jest.fn().mockReturnValue({
lean: jest
.fn()
.mockReturnValue(execResult([{ _id: fixture.competition._id }])),
}),
}),
};
const matchModel = {
find: jest.fn().mockReturnValue({
select: jest
.fn()
.mockReturnValue(execResult([{ _id: fixture.match._id }])),
}),
deleteMany: jest.fn().mockReturnValue(execResult({ deletedCount: 1 })),
};
const connectionService = {
getModel: jest.fn((name: string) => {
const models: Record<string, unknown> = {
match: matchModel,
competition: competitionModel,
competitionFact: competitionFactModel,
competitionOutbox: competitionOutboxModel,
tournamentCodeAssignment: assignmentModel,
};
const model = models[name];
return model
? Promise.resolve(model)
: Promise.reject(new Error(`Unexpected model ${name}`));
}),
} as unknown as ConnectionService;
const matchStatsService = {
removeByMatches: jest.fn().mockResolvedValue(undefined),
} as unknown as jest.Mocked<MatchStatsService>;
const communityStatsService = {
invalidateCommunity: jest.fn().mockResolvedValue(undefined),
} as unknown as jest.Mocked<CommunityStatsService>;
const service = createService({
connectionService,
matchStatsService,
communityStatsService,
});
const result = await service.bulkDeleteLegacyMatches({
communityId: fixture.match.communityId,
body: { matchIds: [fixture.match._id.toString()] },
});
expect(result).toEqual({ deleted: 1 });
for (const model of [
competitionFactModel,
competitionOutboxModel,
assignmentModel,
]) {
expect(model.deleteMany).toHaveBeenCalledWith({
competitionId: { $in: [fixture.competition._id] },
});
}
expect(competitionModel.deleteMany).toHaveBeenCalledWith({
_id: { $in: [fixture.competition._id] },
});
expect(matchStatsService.removeByMatches).toHaveBeenCalledWith([
fixture.match._id,
]);
});
it('rebuilds a historical legacy Match into Competition facts without rewriting Match.result', async () => {
const fixture = createImportFixture();
const historicalMatch = {
...fixture.match,
legacyImported: true,
result: {
riotMatchIds: [fixture.detail.metadata.matchId],
games: [
{
riotMatchId: fixture.detail.metadata.matchId,
participants: [],
},
],
seriesResults: [],
},
};
const matchModel = {
find: jest.fn().mockReturnValue(execResult([historicalMatch])),
updateOne: jest.fn().mockReturnValue(execResult({ modifiedCount: 1 })),
};
const competitionModel = {
find: jest.fn().mockReturnValue({
lean: jest.fn().mockReturnValue(execResult([])),
}),
};
const riotMatchModel = {
find: jest.fn().mockReturnValue({
lean: jest.fn().mockReturnValue(
execResult([
{
matchId: fixture.detail.metadata.matchId,
raw: fixture.detail,
},
]),
),
}),
};
const connectionService = {
getModel: jest.fn(async (name: string) => {
if (name === 'match') return matchModel;
if (name === 'competition') return competitionModel;
if (name === 'riotMatch') return riotMatchModel;
throw new Error(`Unexpected model ${name}`);
}),
} as unknown as ConnectionService;
const bootstrapService = {
bootstrap: jest.fn().mockResolvedValue(fixture.competition),
} as unknown as jest.Mocked<CompetitionBootstrapService>;
const commandService = {
acceptGame: jest.fn().mockResolvedValue({
competition: {
...fixture.competition,
revision: 1,
phase: 'completed',
},
commandId: 'command-1',
revision: 1,
replayed: false,
}),
} as unknown as jest.Mocked<CompetitionCommandService>;
const matchStatsService = {
buildAndUpsert: jest.fn().mockResolvedValue(undefined),
} as unknown as jest.Mocked<MatchStatsService>;
const service = createService({
connectionService,
matchStatsService,
bootstrapService,
commandService,
});
jest
.spyOn(
service as unknown as {
buildUserByPuuidMap: () => Promise<UserByPuuidMap>;
},
'buildUserByPuuidMap',
)
.mockResolvedValue(fixture.userByPuuid);
const result = await service.rebuildLegacyMatches({
communityId: fixture.match.communityId,
});
expect(result).toMatchObject({ scanned: 1, rebuilt: 1 });
for (const [, update] of matchModel.updateOne.mock.calls) {
expect(update).toEqual(
expect.objectContaining({
$set: expect.not.objectContaining({ result: expect.anything() }),
}),
);
}
expect(bootstrapService.bootstrap).toHaveBeenCalledTimes(1);
expect(commandService.acceptGame).toHaveBeenCalledWith(
expect.objectContaining({
actor: { type: 'system' },
evidence: expect.objectContaining({
type: 'riot',
riotMatchId: fixture.detail.metadata.matchId,
}),
}),
);
expect(matchStatsService.buildAndUpsert).toHaveBeenCalledWith(
fixture.match._id,
{ sourceRevision: 1 },
);
});
});
function createService(
options: {
connectionService?: ConnectionService;
communityStatsService?: CommunityStatsService;
matchStatsService?: MatchStatsService;
bootstrapService?: CompetitionBootstrapService;
commandService?: CompetitionCommandService;
runWithLock?: (
options: Record<string, unknown>,
operation: () => Promise<unknown>,
) => Promise<unknown>;
} = {},
): LegacyImportService {
const distributedLockService = {
runWithLock:
options.runWithLock ??
(async (
_options: Record<string, unknown>,
operation: () => Promise<unknown>,
) => operation()),
} as unknown as DistributedLockService;
return new ServiceConstructor(
options.connectionService ?? ({} as ConnectionService),
{} as RedisService,
{} as RiotMatchService,
options.communityStatsService ??
({
invalidateCommunity: jest.fn().mockResolvedValue(undefined),
} as unknown as CommunityStatsService),
options.matchStatsService ?? ({} as MatchStatsService),
distributedLockService,
options.bootstrapService ?? ({} as CompetitionBootstrapService),
options.commandService ?? ({} as CompetitionCommandService),
);
}
async function importSingleMatch(
service: LegacyImportService,
riotMatchId: string,
job: LegacyImportMemberJob,
userByPuuid: UserByPuuidMap,
): Promise<string> {
return (
service as unknown as {
importSingleMatch: (
riotMatchId: string,
job: LegacyImportMemberJob,
userByPuuid: UserByPuuidMap,
) => Promise<string>;
}
).importSingleMatch(riotMatchId, job, userByPuuid);
}
function createImportFixture() {
const communityId = new mongoose.Types.ObjectId();
const triggeredBy = new mongoose.Types.ObjectId();
const matchId = new mongoose.Types.ObjectId();
const competitionId = new mongoose.Types.ObjectId();
const seriesId = new mongoose.Types.ObjectId();
const gameSlotId = new mongoose.Types.ObjectId();
const blueTeamId = new mongoose.Types.ObjectId();
const redTeamId = new mongoose.Types.ObjectId();
const users = Array.from({ length: 10 }, (_, index) => ({
userId: new mongoose.Types.ObjectId(),
puuid: `puuid-${index + 1}`,
}));
const userByPuuid: UserByPuuidMap = new Map(
users.map(({ userId, puuid }, index) => [
puuid,
{
userId,
account: {
puuid,
gameName: `player-${index + 1}`,
tagLine: 'KR1',
profileIconId: index + 1,
tiers: [],
isPrimary: true,
},
displayName: `player-${index + 1}`,
preferredPositions: [],
} as LegacyUserSnapshot,
]),
);
const participants = users.map(({ puuid }, index) => ({
puuid,
participantId: index + 1,
teamId: index < 5 ? 100 : 200,
championId: index + 1,
teamPosition: ['TOP', 'JUNGLE', 'MIDDLE', 'BOTTOM', 'UTILITY'][index % 5],
kills: index < 5 ? 10 : 2,
deaths: index < 5 ? 2 : 10,
assists: index < 5 ? 8 : 3,
win: index < 5,
}));
const detail = {
metadata: {
dataVersion: '2',
matchId: 'KR_legacy_1',
participants: users.map(({ puuid }) => puuid),
},
info: {
gameCreation: Date.parse('2026-07-12T10:00:00.000Z'),
gameEndTimestamp: Date.parse('2026-07-12T10:30:00.000Z'),
gameDuration: 1_800,
mapId: 11,
tournamentCode: 'LEGACY-CODE',
participants,
teams: [
{ teamId: 100, win: true },
{ teamId: 200, win: false },
],
},
} as unknown as RiotMatchDto;
const match = {
_id: matchId,
communityId,
title: 'legacy',
description: 'Legacy import (자동 생성)',
mapId: 11,
status: 'team-built',
scheduledAt: new Date(detail.info.gameCreation),
maxParticipants: 10,
gameCount: 1,
gameMode: 'pair',
tournamentCodeIds: [],
gameSchedule: [],
teamBuiltAt: new Date(detail.info.gameCreation),
hostUserId: triggeredBy,
participants: users.map(({ userId, puuid }, index) => ({
userId,
puuid,
gameName: `player-${index + 1}`,
tagLine: 'KR1',
profileIconId: index + 1,
preferredPositions: [],
joinedAt: new Date(detail.info.gameCreation),
})),
teams: [
{
teamIndex: 1,
name: '1팀',
members: users.slice(0, 5).map(({ userId }, index) => ({
userId,
assignedPosition: ['TOP', 'JGL', 'MID', 'ADC', 'SUP'][index],
})),
},
{
teamIndex: 2,
name: '2팀',
members: users.slice(5).map(({ userId }, index) => ({
userId,
assignedPosition: ['TOP', 'JGL', 'MID', 'ADC', 'SUP'][index],
})),
},
],
prizes: [],
notices: [],
schedule: [],
};
const competition = {
_id: competitionId,
matchId,
communityId,
revision: 0,
phase: 'ready',
teams: [
{
teamId: blueTeamId,
legacyTeamIndex: 1,
displayOrder: 1,
seedNumber: 1,
name: '1팀',
members: users.slice(0, 5).map(({ userId }) => ({ userId })),
},
{
teamId: redTeamId,
legacyTeamIndex: 2,
displayOrder: 2,
seedNumber: 2,
name: '2팀',
members: users.slice(5).map(({ userId }) => ({ userId })),
},
],
projection: {
phase: 'ready',
series: [
{
seriesId,
status: 'ready',
entries: [
{ slot: 'A', teamId: blueTeamId, gameWins: 0 },
{ slot: 'B', teamId: redTeamId, gameWins: 0 },
],
},
],
gameSlots: [
{
id: gameSlotId,
seriesId,
ordinal: 1,
displayNumber: 1,
status: 'ready',
},
],
games: [],
},
};
const job: LegacyImportMemberJob = {
kind: 'legacy-import-member',
jobId: 'member-job-1',
parentJobId: 'legacy-job-1',
communityId: communityId.toString(),
userId: users[0].userId.toString(),
puuid: users[0].puuid,
startTime: 1,
endTime: 2,
triggeredBy: triggeredBy.toString(),
region: 'asia',
};
return {
detail,
match,
competition,
blueTeamId,
redTeamId,
job,
userByPuuid,
};
}
function execResult<T>(value: T) {
return { exec: jest.fn().mockResolvedValue(value) };
}
function deleteManyModel() {
return {
deleteMany: jest
.fn()
.mockReturnValue(execResult({ acknowledged: true, deletedCount: 1 })),
};
}