Files
lolympus-tournament-support/apps/api/src/modules/match-history/match-history.query.spec.ts
T

341 lines
11 KiB
TypeScript

import mongoose from 'mongoose';
import { ConnectionService } from '../global/database/connection.service';
import { MatchHistoryService } from './match-history.service';
const SEASON_START = Date.parse('2026-01-01T00:00:00Z');
describe('MatchHistoryService champion filtering', () => {
it('selects a lane before limiting and uses only the requested participant, including legacy individualPosition', async () => {
const { service, scope, find } = createHarness();
const result = await service.getRecentMatches({
...scope,
filters: { rank: 'solo', lane: 'MIDDLE', limit: 20 },
});
expect(result.matches.map((game) => game.matchId)).toEqual([
'KR_3',
'KR_2',
'KR_1',
]);
expect(result.matches.every((game) => game.teamPosition === 'MIDDLE')).toBe(
true,
);
expect(result.matches[0].damageShare).toBe(100);
expect(find.mock.calls[0][0]['raw.info.participants']?.$elemMatch).toEqual({
puuid: 'player',
$or: [
{ teamPosition: 'MIDDLE' },
{ teamPosition: { $in: ['', null] }, individualPosition: 'MIDDLE' },
],
});
});
it('combines champion and lane filtering and rejects invalid lanes', async () => {
const { service, scope } = createHarness();
const result = await service.getRecentMatches({
...scope,
filters: { rank: 'solo', championId: 1, lane: 'MIDDLE', limit: 20 },
});
expect(result.matches).toEqual([]);
await expect(
service.getRecentMatches({ ...scope, filters: { lane: 'unknown' } }),
).rejects.toThrow('Invalid lane');
});
it('counts independent lane windows across the season and caps each at twenty', async () => {
const { service, scope, aggregate } = createHarness();
const result = await service.getRecentMatches({
...scope,
filters: {
rank: 'solo',
lane: 'MIDDLE',
limit: 20,
includePositionCounts: true,
},
});
expect(result.positionCounts).toEqual({
ALL: 20,
TOP: 20,
JUNGLE: 0,
MIDDLE: 3,
BOTTOM: 0,
UTILITY: 0,
});
expect(aggregate.mock.calls[0][0][0]).toEqual({
$match: {
participantPuuids: 'player',
queueId: { $in: [420] },
gameCreation: { $gte: SEASON_START },
},
});
expect(JSON.stringify(aggregate.mock.calls[0][0])).toContain('$$p.puuid');
expect(JSON.stringify(aggregate.mock.calls[0][0])).not.toContain('$limit');
});
it('paginates matching games beyond 120 newer games and excludes opponents using the champion', async () => {
const harness = createHarness();
const filters = { championId: 99, rank: 'solo', limit: 2 };
const first = await harness.service.getRecentMatches({
...harness.scope,
filters,
});
expect(first.matches.map((match) => match.matchId)).toEqual([
'KR_3',
'KR_2',
]);
expect(first.nextCursor).toBe(SEASON_START + 2_000);
expect(first.matches[0].largestMultiKill).toBe(3);
expect(first.matches[0].teams[0].participants[0].tier).toMatchObject({
tier: 'GOLD',
rank: 'II',
});
const second = await harness.service.getRecentMatches({
...harness.scope,
filters: { ...filters, cursor: first.nextCursor! },
});
expect(second.matches.map((match) => match.matchId)).toEqual(['KR_1']);
expect(second.nextCursor).toBeNull();
expect(harness.returnedCounts).toEqual([3, 1]);
expect(harness.find).toHaveBeenLastCalledWith({
participantPuuids: 'player',
queueId: { $in: [420] },
gameCreation: { $gte: SEASON_START, $lt: first.nextCursor },
'raw.info.participants': {
$elemMatch: { puuid: 'player', championId: 99 },
},
});
});
it('summarizes matching games across the former scan boundary', async () => {
const { service, scope, returnedCounts } = createHarness();
const summary = await service.getRecentSummary({
...scope,
filters: { championId: 99, rank: 'solo', limit: 20 },
});
expect(summary).toMatchObject({ windowSize: 3, wins: 3, losses: 0 });
expect(summary.topChampions).toEqual([
expect.objectContaining({ championId: 99, games: 3 }),
]);
expect(returnedCounts).toEqual([3]);
});
it('keeps unfiltered pagination and does not transfer timeline payloads', async () => {
const { service, scope, find, select, returnedCounts } = createHarness();
const result = await service.getRecentMatches({
...scope,
filters: { rank: 'solo', limit: 2 },
});
expect(result.matches.map((match) => match.matchId)).toEqual([
'KR_130',
'KR_129',
]);
expect(result.nextCursor).toBe(SEASON_START + 129_000);
expect(find.mock.calls[0][0]['raw.info.participants']).toBeUndefined();
expect(select).toHaveBeenCalledWith({ timeline: 0 });
expect(returnedCounts).toEqual([3]);
});
});
interface HistoryQuery {
participantPuuids: string;
queueId: { $in: number[] };
gameCreation?: { $gte?: number; $lt?: number };
'raw.info.participants'?: {
$elemMatch: {
puuid: string;
championId?: number;
$or?: Array<{
teamPosition: string | { $in: (string | null)[] };
individualPosition?: string;
}>;
};
};
}
function createHarness() {
const communityId = new mongoose.Types.ObjectId();
const userId = new mongoose.Types.ObjectId();
// In the newer games only the opponent played champion 99.
const rows = [
...Array.from({ length: 127 }, (_, index) => storedMatch(index + 4, 1)),
storedMatch(3, 99),
storedMatch(2, 99),
storedMatch(1, 99),
storedMatch(131, 99, 450), // Wrong queue.
storedMatch(-1, 99), // Before the season.
];
const returnedCounts: number[] = [];
const select = jest.fn();
const find = jest.fn((filter: HistoryQuery) => {
let limit = rows.length;
const query = {
sort: jest.fn().mockReturnThis(),
limit: (value: number) => {
limit = value;
return query;
},
select: (projection: unknown) => {
select(projection);
return query;
},
exec: async () => {
const participant = filter['raw.info.participants']?.$elemMatch;
const result = rows
.filter(
(row) =>
row.participantPuuids.includes(filter.participantPuuids) &&
filter.queueId.$in.includes(row.queueId) &&
(filter.gameCreation?.$gte === undefined ||
row.gameCreation >= filter.gameCreation.$gte) &&
(filter.gameCreation?.$lt === undefined ||
row.gameCreation < filter.gameCreation.$lt) &&
(!participant ||
row.raw.info.participants.some(
(entry) =>
entry.puuid === participant.puuid &&
(participant.championId === undefined ||
entry.championId === participant.championId) &&
(!participant.$or ||
participant.$or.some((condition) =>
typeof condition.teamPosition === 'string'
? entry.teamPosition === condition.teamPosition
: condition.teamPosition.$in.includes(
entry.teamPosition ?? null,
) &&
entry.individualPosition ===
condition.individualPosition,
)),
)),
)
.sort((a, b) => b.gameCreation - a.gameCreation)
.slice(0, limit);
returnedCounts.push(result.length);
return result;
},
};
return query;
});
const aggregate = jest.fn<
{ exec: () => Promise<Array<{ _id: string; count: number }>> },
[unknown[]]
>(() => ({
exec: async () => [
{ _id: 'TOP', count: 127 },
{ _id: 'MIDDLE', count: 3 },
],
}));
const models = {
user: {
find: () => ({
select: () => ({
lean: () => ({
exec: async () => [
{
riotAccounts: [
{
puuid: 'player',
tierHistory: [
{
queueType: 'RANKED_SOLO_5x5',
tier: 'PLATINUM',
recordedAt: new Date(SEASON_START + 4_000),
},
{
queueType: 'RANKED_SOLO_5x5',
tier: 'GOLD',
rank: 'II',
recordedAt: new Date(SEASON_START),
},
],
},
],
},
],
}),
}),
}),
findById: () => ({
exec: async () => ({
_id: userId,
communityId,
riotAccounts: [{ puuid: 'player', isPrimary: true }],
}),
}),
},
community: {
findById: () => ({
exec: async () => ({
_id: communityId,
seasonStartedAt: new Date(SEASON_START),
}),
}),
},
riotMatch: { find, aggregate },
};
const connection = {
getModel: async (name: keyof typeof models) => models[name],
} as unknown as ConnectionService;
return {
service: new MatchHistoryService(connection),
scope: { communityId, userId },
find,
select,
returnedCounts,
aggregate,
};
}
function storedMatch(sequence: number, championId: number, queueId = 420) {
const gameCreation = SEASON_START + sequence * 1_000;
const participant = {
puuid: 'player',
championId,
teamPosition:
sequence === 2 ? undefined : championId === 99 ? 'MIDDLE' : 'TOP',
individualPosition: championId === 99 ? 'MIDDLE' : 'TOP',
teamId: 100,
win: true,
kills: 5,
tripleKills: 1,
deaths: 2,
assists: 3,
totalMinionsKilled: 100,
neutralMinionsKilled: 20,
goldEarned: 10_000,
totalDamageDealtToChampions: 10_000,
totalDamageTaken: 5_000,
perks: { styles: [] },
};
return {
gameCreation,
queueId,
participantPuuids: ['player', 'opponent'],
fetchedAt: new Date(),
raw: {
metadata: { matchId: `KR_${sequence}` },
info: {
gameCreation,
queueId,
gameDuration: 1_800,
participants: [
participant,
{
...participant,
puuid: 'opponent',
teamId: 200,
championId: 99,
teamPosition: 'MIDDLE',
win: false,
},
],
teams: [
{ teamId: 100, win: true },
{ teamId: 200, win: false },
],
},
},
};
}