703 lines
21 KiB
TypeScript
703 lines
21 KiB
TypeScript
import mongoose from 'mongoose';
|
|
import { ConnectionService } from '../global/database/connection.service';
|
|
import { CommunityStatsCacheService } from './community-stats-cache.service';
|
|
import { CommunityStatsService } from './community-stats.service';
|
|
import type {
|
|
InternalMatchCardView,
|
|
InternalMatchDetailResponse,
|
|
} from './community-stats.types';
|
|
import { MatchStatsRepository } from './match-stats.repository';
|
|
import { MatchStatsService } from './match-stats.service';
|
|
import {
|
|
MATCH_STATS_BUILDER_VERSION,
|
|
type InternalGameDetail,
|
|
type InternalRecord,
|
|
} from './match-stats.types';
|
|
|
|
function objectives() {
|
|
return {
|
|
tower: 1,
|
|
dragon: 0,
|
|
inhibitor: 0,
|
|
baron: 0,
|
|
riftHerald: 0,
|
|
voidGrub: 0,
|
|
elderDragon: 0,
|
|
};
|
|
}
|
|
|
|
function record(matchId: mongoose.Types.ObjectId): InternalRecord {
|
|
return {
|
|
matchId: matchId.toString(),
|
|
title: '내전',
|
|
scheduledAt: new Date('2026-06-18T12:00:00.000Z'),
|
|
gameNumber: 1,
|
|
riotMatchId: 'KR_1',
|
|
gameCreation: 1_000,
|
|
gameDuration: 1_800,
|
|
userId: new mongoose.Types.ObjectId().toString(),
|
|
summonerName: 'Player',
|
|
tagLine: 'KR1',
|
|
profileIconId: 1,
|
|
teamIndex: 1,
|
|
side: 'blue',
|
|
championId: 266,
|
|
championLevel: 15,
|
|
teamPosition: 'TOP',
|
|
kills: 5,
|
|
deaths: 1,
|
|
assists: 7,
|
|
win: true,
|
|
cs: 200,
|
|
csPerMin: 6.7,
|
|
gold: 12_000,
|
|
gpm: 400,
|
|
damageDealtToChampions: 18_000,
|
|
damageTaken: 20_000,
|
|
damageShare: 30,
|
|
killParticipation: 60,
|
|
visionScore: 18,
|
|
controlWardsBought: 1,
|
|
wardsPlaced: 8,
|
|
wardsKilled: 2,
|
|
firstBloodKill: false,
|
|
firstBloodAssist: false,
|
|
items: [1054, 3071, 0, 0, 0, 0],
|
|
trinket: 3340,
|
|
summonerSpells: [4, 12],
|
|
perks: {
|
|
primaryStyle: 8000,
|
|
subStyle: 8400,
|
|
keystone: 8010,
|
|
selectedPerkIds: [8010, 9111, 9105, 8299, 8444, 8451],
|
|
styles: [
|
|
{ styleId: 8000, perkIds: [8010, 9111, 9105, 8299] },
|
|
{ styleId: 8400, perkIds: [8444, 8451] },
|
|
],
|
|
statPerks: { defense: 5001, flex: 5008, offense: 5005 },
|
|
},
|
|
itemBuild: [{ timestamp: 10, itemId: 1054, type: 'purchased' }],
|
|
skillBuild: [{ timestamp: 11, skillSlot: 1, level: 1 }],
|
|
rating: 8.5,
|
|
};
|
|
}
|
|
|
|
describe('CommunityStatsService', () => {
|
|
it('ignores detail caches missing unified events or containing invalid checkpoints', async () => {
|
|
const communityId = new mongoose.Types.ObjectId();
|
|
const matchId = new mongoose.Types.ObjectId();
|
|
const match: InternalMatchCardView = {
|
|
matchId: matchId.toString(),
|
|
title: '내전',
|
|
scheduledAt: '2026-06-18T12:00:00.000Z',
|
|
status: 'finished',
|
|
gameCount: 1,
|
|
games: [],
|
|
teams: [],
|
|
seriesResults: [],
|
|
};
|
|
const participant = record(matchId);
|
|
Object.assign(participant, {
|
|
participantId: 1,
|
|
checkpoints: {
|
|
at10: {
|
|
timestamp: 590,
|
|
gold: 5_200,
|
|
cs: 90,
|
|
xp: 4_200,
|
|
kills: 1,
|
|
deaths: 1,
|
|
assists: 1,
|
|
},
|
|
},
|
|
});
|
|
const gameDetail: InternalGameDetail = {
|
|
gameNumber: 1,
|
|
riotMatchId: 'KR_1',
|
|
gameCreation: 1_000,
|
|
gameDuration: 1_800,
|
|
winnerSide: 'blue',
|
|
timelineLoaded: true,
|
|
timeline: [
|
|
{
|
|
timestamp: 0,
|
|
blue: { gold: 500, xp: 0 },
|
|
red: { gold: 500, xp: 0 },
|
|
goldDiff: 0,
|
|
xpDiff: 0,
|
|
},
|
|
],
|
|
objectiveEvents: [],
|
|
teams: [
|
|
{
|
|
teamIndex: 1,
|
|
side: 'blue',
|
|
win: true,
|
|
objectives: objectives(),
|
|
bans: [],
|
|
participants: [participant],
|
|
},
|
|
],
|
|
};
|
|
Object.assign(gameDetail, {
|
|
timelineEvents: [
|
|
{
|
|
timestamp: 300,
|
|
side: 'blue',
|
|
type: 'championKill',
|
|
killerParticipantId: 1,
|
|
victimParticipantId: 2,
|
|
assistingParticipantIds: [],
|
|
},
|
|
],
|
|
});
|
|
const otherwiseCompleteCachedGame = {
|
|
gameNumber: 1,
|
|
riotMatchId: 'KR_1',
|
|
gameCreation: 1_000,
|
|
gameDuration: 1_800,
|
|
timeline: [],
|
|
objectiveEvents: [],
|
|
teams: [
|
|
{
|
|
teamIndex: 1,
|
|
side: 'blue' as const,
|
|
win: true,
|
|
objectives: objectives(),
|
|
bans: [],
|
|
participants: [
|
|
{
|
|
summonerName: 'Cached Player',
|
|
tagLine: 'KR1',
|
|
itemBuild: [],
|
|
skillBuild: [],
|
|
},
|
|
],
|
|
},
|
|
],
|
|
};
|
|
const missingTimelineEventsCache = {
|
|
match,
|
|
games: [otherwiseCompleteCachedGame],
|
|
} as unknown as InternalMatchDetailResponse;
|
|
const invalidCheckpointCache = {
|
|
match,
|
|
games: [
|
|
{
|
|
...otherwiseCompleteCachedGame,
|
|
timelineEvents: [],
|
|
teams: otherwiseCompleteCachedGame.teams.map((team) => ({
|
|
...team,
|
|
participants: team.participants.map((cachedParticipant) => ({
|
|
...cachedParticipant,
|
|
participantId: 1,
|
|
checkpoints: {
|
|
at10: {
|
|
timestamp: '590',
|
|
gold: 5_200,
|
|
cs: 90,
|
|
xp: 4_200,
|
|
kills: 1,
|
|
deaths: 1,
|
|
assists: 1,
|
|
},
|
|
},
|
|
})),
|
|
})),
|
|
},
|
|
],
|
|
} as unknown as InternalMatchDetailResponse;
|
|
const setDetail = jest.fn().mockResolvedValue(undefined);
|
|
const cacheService = {
|
|
get: jest
|
|
.fn()
|
|
.mockResolvedValueOnce(missingTimelineEventsCache)
|
|
.mockResolvedValueOnce(invalidCheckpointCache),
|
|
setDetail,
|
|
} as unknown as jest.Mocked<CommunityStatsCacheService>;
|
|
const matchStatsService = {
|
|
buildAndUpsert: jest.fn().mockResolvedValue(undefined),
|
|
} as unknown as jest.Mocked<MatchStatsService>;
|
|
const service = new CommunityStatsService(
|
|
{} as ConnectionService,
|
|
cacheService,
|
|
{} as MatchStatsRepository,
|
|
matchStatsService,
|
|
);
|
|
(service as unknown as { buildBaseDataset: jest.Mock }).buildBaseDataset =
|
|
jest.fn().mockResolvedValue({
|
|
season: {
|
|
id: 'all',
|
|
label: '전체',
|
|
startTime: null,
|
|
endTime: null,
|
|
},
|
|
matches: [match],
|
|
records: [participant],
|
|
detailsByMatchId: new Map([[matchId.toString(), [gameDetail]]]),
|
|
});
|
|
|
|
const missingEventsResponse = await service.getMatchDetail({
|
|
communityId,
|
|
matchId,
|
|
});
|
|
const invalidCheckpointResponse = await service.getMatchDetail({
|
|
communityId,
|
|
matchId,
|
|
});
|
|
|
|
expect(missingEventsResponse.games[0].timeline).toHaveLength(1);
|
|
expect(invalidCheckpointResponse.games[0].timeline).toHaveLength(1);
|
|
expect(invalidCheckpointResponse.games[0]).toMatchObject({
|
|
timelineEvents: [
|
|
{
|
|
timestamp: 300,
|
|
side: 'blue',
|
|
type: 'championKill',
|
|
},
|
|
],
|
|
});
|
|
expect(
|
|
invalidCheckpointResponse.games[0].teams[0].participants[0],
|
|
).toMatchObject({
|
|
participantId: 1,
|
|
checkpoints: {
|
|
at10: {
|
|
timestamp: 590,
|
|
gold: 5_200,
|
|
cs: 90,
|
|
xp: 4_200,
|
|
kills: 1,
|
|
deaths: 1,
|
|
assists: 1,
|
|
},
|
|
},
|
|
itemBuild: [{ timestamp: 10, itemId: 1054, type: 'purchased' }],
|
|
perks: {
|
|
selectedPerkIds: [8010, 9111, 9105, 8299, 8444, 8451],
|
|
},
|
|
});
|
|
expect(matchStatsService.buildAndUpsert).not.toHaveBeenCalled();
|
|
expect(setDetail).toHaveBeenCalledTimes(2);
|
|
expect(setDetail).toHaveBeenNthCalledWith(
|
|
2,
|
|
expect.stringContaining(':r4:'),
|
|
invalidCheckpointResponse,
|
|
);
|
|
});
|
|
|
|
it('backs off failed timeline hydration and retries after the short cache expires', async () => {
|
|
const communityId = new mongoose.Types.ObjectId();
|
|
const matchId = new mongoose.Types.ObjectId();
|
|
const match: InternalMatchCardView = {
|
|
matchId: matchId.toString(),
|
|
title: '내전',
|
|
scheduledAt: '2026-06-18T12:00:00.000Z',
|
|
status: 'finished',
|
|
gameCount: 1,
|
|
games: [],
|
|
teams: [],
|
|
seriesResults: [],
|
|
};
|
|
const participant = record(matchId);
|
|
const gameDetail: InternalGameDetail = {
|
|
gameNumber: 1,
|
|
riotMatchId: 'KR_1',
|
|
gameCreation: 1_000,
|
|
gameDuration: 1_800,
|
|
winnerSide: 'blue',
|
|
timelineLoaded: false,
|
|
timeline: [],
|
|
objectiveEvents: [],
|
|
timelineEvents: [],
|
|
teams: [
|
|
{
|
|
teamIndex: 1,
|
|
side: 'blue',
|
|
win: true,
|
|
objectives: objectives(),
|
|
bans: [],
|
|
participants: [participant],
|
|
},
|
|
],
|
|
};
|
|
const dataset = (timelineLoaded: boolean) => ({
|
|
season: {
|
|
id: 'all',
|
|
label: '전체',
|
|
startTime: null,
|
|
endTime: null,
|
|
},
|
|
matches: [match],
|
|
records: [participant],
|
|
detailsByMatchId: new Map([
|
|
[matchId.toString(), [{ ...gameDetail, timelineLoaded }]],
|
|
]),
|
|
});
|
|
let cachedResponse: InternalMatchDetailResponse | null = null;
|
|
const set = jest
|
|
.fn()
|
|
.mockImplementation(
|
|
(_key: string, value: InternalMatchDetailResponse) => {
|
|
cachedResponse = value;
|
|
return Promise.resolve();
|
|
},
|
|
);
|
|
const setDetail = jest
|
|
.fn()
|
|
.mockImplementation(
|
|
(_key: string, value: InternalMatchDetailResponse) => {
|
|
cachedResponse = value;
|
|
return Promise.resolve();
|
|
},
|
|
);
|
|
const cacheService = {
|
|
get: jest.fn().mockImplementation(() => Promise.resolve(cachedResponse)),
|
|
set,
|
|
setDetail,
|
|
} as unknown as jest.Mocked<CommunityStatsCacheService>;
|
|
const buildAndUpsert = jest.fn().mockResolvedValue(undefined);
|
|
const service = new CommunityStatsService(
|
|
{} as ConnectionService,
|
|
cacheService,
|
|
{} as MatchStatsRepository,
|
|
{ buildAndUpsert } as unknown as MatchStatsService,
|
|
);
|
|
(service as unknown as { buildBaseDataset: jest.Mock }).buildBaseDataset =
|
|
jest
|
|
.fn()
|
|
.mockResolvedValueOnce(dataset(false))
|
|
.mockResolvedValueOnce(dataset(false))
|
|
.mockResolvedValueOnce(dataset(false))
|
|
.mockResolvedValueOnce(dataset(true));
|
|
|
|
const fallback = await service.getMatchDetail({ communityId, matchId });
|
|
const backedOff = await service.getMatchDetail({ communityId, matchId });
|
|
|
|
expect(backedOff).toBe(fallback);
|
|
expect(buildAndUpsert).toHaveBeenCalledTimes(1);
|
|
expect(set).toHaveBeenCalledWith(
|
|
expect.stringContaining(':r4:'),
|
|
fallback,
|
|
60,
|
|
);
|
|
expect(setDetail).not.toHaveBeenCalled();
|
|
|
|
cachedResponse = null;
|
|
const recovered = await service.getMatchDetail({ communityId, matchId });
|
|
|
|
expect(buildAndUpsert).toHaveBeenCalledTimes(2);
|
|
expect(setDetail).toHaveBeenCalledTimes(1);
|
|
expect(setDetail).toHaveBeenCalledWith(
|
|
expect.stringContaining(':r4:'),
|
|
recovered,
|
|
);
|
|
});
|
|
|
|
it('coalesces concurrent internal match detail cache misses', async () => {
|
|
const communityId = new mongoose.Types.ObjectId();
|
|
const matchId = new mongoose.Types.ObjectId();
|
|
const match: InternalMatchCardView = {
|
|
matchId: matchId.toString(),
|
|
title: '내전',
|
|
scheduledAt: '2026-06-18T12:00:00.000Z',
|
|
status: 'finished',
|
|
gameCount: 1,
|
|
games: [],
|
|
teams: [],
|
|
seriesResults: [],
|
|
};
|
|
const participant = record(matchId);
|
|
const dataset = {
|
|
season: {
|
|
id: 'all',
|
|
label: '전체',
|
|
startTime: null,
|
|
endTime: null,
|
|
},
|
|
matches: [match],
|
|
records: [participant],
|
|
detailsByMatchId: new Map([
|
|
[
|
|
matchId.toString(),
|
|
[
|
|
{
|
|
gameNumber: 1,
|
|
riotMatchId: 'KR_1',
|
|
gameCreation: 1_000,
|
|
gameDuration: 1_800,
|
|
winnerSide: 'blue' as const,
|
|
timelineLoaded: true,
|
|
timeline: [],
|
|
objectiveEvents: [],
|
|
timelineEvents: [],
|
|
teams: [
|
|
{
|
|
teamIndex: 1,
|
|
side: 'blue' as const,
|
|
win: true,
|
|
objectives: objectives(),
|
|
bans: [],
|
|
participants: [participant],
|
|
},
|
|
],
|
|
},
|
|
],
|
|
],
|
|
]),
|
|
};
|
|
let resolveDataset: ((value: typeof dataset) => void) | undefined;
|
|
const datasetPromise = new Promise<typeof dataset>((resolve) => {
|
|
resolveDataset = resolve;
|
|
});
|
|
const setDetail = jest.fn().mockResolvedValue(undefined);
|
|
const cacheService = {
|
|
get: jest.fn().mockResolvedValue(null),
|
|
setDetail,
|
|
} as unknown as jest.Mocked<CommunityStatsCacheService>;
|
|
const service = new CommunityStatsService(
|
|
{} as ConnectionService,
|
|
cacheService,
|
|
{} as MatchStatsRepository,
|
|
{} as MatchStatsService,
|
|
);
|
|
const buildBaseDataset = jest.fn().mockReturnValue(datasetPromise);
|
|
(service as unknown as { buildBaseDataset: jest.Mock }).buildBaseDataset =
|
|
buildBaseDataset;
|
|
|
|
const first = service.getMatchDetail({ communityId, matchId });
|
|
const second = service.getMatchDetail({ communityId, matchId });
|
|
await Promise.resolve();
|
|
resolveDataset?.(dataset);
|
|
const [firstResponse, secondResponse] = await Promise.all([first, second]);
|
|
|
|
expect(firstResponse).toBe(secondResponse);
|
|
expect(buildBaseDataset).toHaveBeenCalledTimes(1);
|
|
expect(setDetail).toHaveBeenCalledTimes(1);
|
|
});
|
|
|
|
it('includes internal match route fields in user internal history matches', async () => {
|
|
const communityId = new mongoose.Types.ObjectId();
|
|
const matchId = new mongoose.Types.ObjectId();
|
|
const userId = new mongoose.Types.ObjectId();
|
|
const participant = record(matchId);
|
|
participant.userId = userId.toString();
|
|
participant.gameNumber = 2;
|
|
participant.riotMatchId = 'KR_1234';
|
|
|
|
const cacheService = {
|
|
get: jest.fn().mockResolvedValue(null),
|
|
set: jest.fn().mockResolvedValue(undefined),
|
|
} as unknown as jest.Mocked<CommunityStatsCacheService>;
|
|
const matchStatsRepository = {
|
|
findUserRecordFragments: jest
|
|
.fn()
|
|
.mockResolvedValue([{ matchId, records: [participant] }]),
|
|
findDetailsByMatches: jest
|
|
.fn()
|
|
.mockResolvedValue([{ matchId, gameDetails: [] }]),
|
|
} as unknown as jest.Mocked<MatchStatsRepository>;
|
|
const service = new CommunityStatsService(
|
|
{} as ConnectionService,
|
|
cacheService,
|
|
matchStatsRepository,
|
|
{} as MatchStatsService,
|
|
);
|
|
(service as unknown as { resolveContext: jest.Mock }).resolveContext = jest
|
|
.fn()
|
|
.mockResolvedValue({
|
|
community: {},
|
|
season: {
|
|
id: 'all',
|
|
label: '전체',
|
|
startedAt: null,
|
|
endedAt: null,
|
|
},
|
|
from: null,
|
|
to: null,
|
|
});
|
|
const buildBaseDataset = jest.spyOn(
|
|
service as unknown as { buildBaseDataset: jest.Mock },
|
|
'buildBaseDataset',
|
|
);
|
|
|
|
const response = await service.getUserInternalHistory({
|
|
communityId,
|
|
userId,
|
|
filters: { limit: 5 },
|
|
});
|
|
|
|
expect(response.matches[0]).toMatchObject({
|
|
matchId: 'KR_1234',
|
|
internalMatchId: matchId.toString(),
|
|
gameNumber: 2,
|
|
queueLabel: '내전',
|
|
});
|
|
expect(matchStatsRepository.findUserRecordFragments).toHaveBeenCalledWith({
|
|
communityId,
|
|
userId,
|
|
fromGameCreation: undefined,
|
|
toGameCreation: undefined,
|
|
limit: 300,
|
|
});
|
|
expect(
|
|
matchStatsRepository.findDetailsByMatches.mock.calls[0][0].matchIds.map(
|
|
(id) => id.toString(),
|
|
),
|
|
).toEqual([matchId.toString()]);
|
|
expect(buildBaseDataset).not.toHaveBeenCalled();
|
|
expect(cacheService.set).toHaveBeenCalledWith(
|
|
expect.stringContaining(`userInternal:v3:${userId.toString()}`),
|
|
response,
|
|
);
|
|
});
|
|
|
|
it('coalesces concurrent user internal history cache misses', async () => {
|
|
const communityId = new mongoose.Types.ObjectId();
|
|
const matchId = new mongoose.Types.ObjectId();
|
|
const userId = new mongoose.Types.ObjectId();
|
|
const participant = record(matchId);
|
|
participant.userId = userId.toString();
|
|
|
|
let resolveFragments:
|
|
| ((
|
|
fragments: Array<{
|
|
matchId: mongoose.Types.ObjectId;
|
|
records: InternalRecord[];
|
|
}>,
|
|
) => void)
|
|
| undefined;
|
|
const fragmentsPromise = new Promise<
|
|
Array<{ matchId: mongoose.Types.ObjectId; records: InternalRecord[] }>
|
|
>((resolve) => {
|
|
resolveFragments = resolve;
|
|
});
|
|
const cacheService = {
|
|
get: jest.fn().mockResolvedValue(null),
|
|
set: jest.fn().mockResolvedValue(undefined),
|
|
} as unknown as jest.Mocked<CommunityStatsCacheService>;
|
|
const matchStatsRepository = {
|
|
findUserRecordFragments: jest.fn().mockReturnValue(fragmentsPromise),
|
|
findDetailsByMatches: jest.fn().mockResolvedValue([]),
|
|
} as unknown as jest.Mocked<MatchStatsRepository>;
|
|
const service = new CommunityStatsService(
|
|
{} as ConnectionService,
|
|
cacheService,
|
|
matchStatsRepository,
|
|
{} as MatchStatsService,
|
|
);
|
|
(service as unknown as { resolveContext: jest.Mock }).resolveContext = jest
|
|
.fn()
|
|
.mockResolvedValue({
|
|
community: {},
|
|
season: {
|
|
id: 'all',
|
|
label: '전체',
|
|
startedAt: null,
|
|
endedAt: null,
|
|
},
|
|
from: null,
|
|
to: null,
|
|
});
|
|
|
|
const first = service.getUserInternalHistory({
|
|
communityId,
|
|
userId,
|
|
filters: { limit: 5 },
|
|
});
|
|
const second = service.getUserInternalHistory({
|
|
communityId,
|
|
userId,
|
|
filters: { limit: 5 },
|
|
});
|
|
await Promise.resolve();
|
|
resolveFragments?.([{ matchId, records: [participant] }]);
|
|
const [firstResponse, secondResponse] = await Promise.all([first, second]);
|
|
|
|
expect(firstResponse).toBe(secondResponse);
|
|
expect(matchStatsRepository.findUserRecordFragments).toHaveBeenCalledTimes(
|
|
1,
|
|
);
|
|
expect(cacheService.set).toHaveBeenCalledTimes(1);
|
|
});
|
|
|
|
it('self-heals Competition fragments when their source revision is stale', async () => {
|
|
const communityId = new mongoose.Types.ObjectId();
|
|
const matchId = new mongoose.Types.ObjectId();
|
|
const competitionId = new mongoose.Types.ObjectId();
|
|
const matches = [{ _id: matchId, competitionId }];
|
|
const MatchModel = {
|
|
find: jest.fn().mockReturnValue({
|
|
sort: jest.fn().mockReturnValue({
|
|
limit: jest.fn().mockReturnValue({
|
|
select: jest.fn().mockReturnValue({
|
|
exec: jest.fn().mockResolvedValue(matches),
|
|
}),
|
|
}),
|
|
}),
|
|
}),
|
|
};
|
|
const CompetitionModel = {
|
|
find: jest.fn().mockReturnValue({
|
|
select: jest.fn().mockReturnValue({
|
|
lean: jest.fn().mockReturnValue({
|
|
exec: jest.fn().mockResolvedValue([
|
|
{
|
|
_id: competitionId,
|
|
revision: 7,
|
|
projectorVersion: 3,
|
|
},
|
|
]),
|
|
}),
|
|
}),
|
|
}),
|
|
};
|
|
const connectionService = {
|
|
getModel: jest.fn().mockImplementation((name: string) => {
|
|
if (name === 'match') return Promise.resolve(MatchModel);
|
|
if (name === 'competition') return Promise.resolve(CompetitionModel);
|
|
throw new Error(`Unexpected model ${name}`);
|
|
}),
|
|
} as unknown as ConnectionService;
|
|
const matchStatsRepository = {
|
|
findByCommunity: jest.fn().mockResolvedValue([
|
|
{
|
|
matchId,
|
|
builderVersion: MATCH_STATS_BUILDER_VERSION,
|
|
sourceCompetitionId: competitionId,
|
|
sourceRevision: 6,
|
|
projectorVersion: 3,
|
|
},
|
|
]),
|
|
} as unknown as jest.Mocked<MatchStatsRepository>;
|
|
const matchStatsService = {
|
|
buildAndUpsert: jest.fn().mockResolvedValue(undefined),
|
|
} as unknown as jest.Mocked<MatchStatsService>;
|
|
const service = new CommunityStatsService(
|
|
connectionService,
|
|
{} as CommunityStatsCacheService,
|
|
matchStatsRepository,
|
|
matchStatsService,
|
|
);
|
|
|
|
const rebuilt = await (
|
|
service as unknown as {
|
|
rebuildMissingOrStaleFragments(
|
|
communityId: mongoose.Types.ObjectId,
|
|
): Promise<number>;
|
|
}
|
|
).rebuildMissingOrStaleFragments(communityId);
|
|
|
|
expect(MatchModel.find).toHaveBeenCalledWith({
|
|
communityId,
|
|
status: { $in: ['finished', 'in-progress'] },
|
|
$or: [
|
|
{ competitionId: { $exists: true } },
|
|
{ 'result.games.0': { $exists: true } },
|
|
],
|
|
});
|
|
expect(matchStatsService.buildAndUpsert).toHaveBeenCalledWith(matchId);
|
|
expect(rebuilt).toBe(1);
|
|
});
|
|
});
|