Preserve tournament result jobs through lock contention and transient failures, atomically schedule retries before acknowledgement, and publish initial polls after releasing the preparation lock. Fix Redis connection blocking, durability Hash cleanup, duplicate auction request ordering, and scheduled-job promotion. Use native Redis 8.10 stream, lock, counter, and field-expiring cache operations with invalidation fencing. Repair 90 test type errors and add a repeatable API typecheck command. Validation: 704 API tests, 129 web tests, 31 real Redis integration tests, 3 dependency checks, workspace type checks and builds, and changed-file lint.
642 lines
20 KiB
TypeScript
642 lines
20 KiB
TypeScript
import mongoose from 'mongoose';
|
|
import { ConnectionService } from '../global/database/connection.service';
|
|
import { MatchStatsFragmentBuilder } from './match-stats-fragment.builder';
|
|
import { MatchStatsRepository } from './match-stats.repository';
|
|
import { MatchStatsService } from './match-stats.service';
|
|
import { MATCH_STATS_BUILDER_VERSION } from './match-stats.types';
|
|
|
|
describe('MatchStatsService', () => {
|
|
it('deletes an existing fragment when the match is no longer eligible', async () => {
|
|
const matchId = new mongoose.Types.ObjectId();
|
|
const findById = jest.fn().mockReturnValue({
|
|
exec: jest.fn().mockResolvedValue({
|
|
_id: matchId,
|
|
status: 'recruiting',
|
|
result: undefined,
|
|
}),
|
|
});
|
|
const connectionService = {
|
|
getModel: jest.fn().mockImplementation(async (name: string) => {
|
|
if (name === 'match') return { findById };
|
|
if (name === 'competition') return { findOne: () => queryResult(null) };
|
|
if (name === 'riotMatch') return {};
|
|
throw new Error(`Unexpected model: ${name}`);
|
|
}),
|
|
} as unknown as ConnectionService;
|
|
const repository = {
|
|
deleteByMatch: jest.fn().mockResolvedValue(undefined),
|
|
upsert: jest.fn(),
|
|
} as unknown as jest.Mocked<MatchStatsRepository>;
|
|
const service = new MatchStatsService(
|
|
connectionService,
|
|
repository,
|
|
{} as MatchStatsFragmentBuilder,
|
|
{ getMatchTimeline: jest.fn() } as never,
|
|
);
|
|
|
|
await service.buildAndUpsert(matchId);
|
|
|
|
expect(repository.deleteByMatch).toHaveBeenCalledWith(matchId);
|
|
expect(repository.upsert).not.toHaveBeenCalled();
|
|
});
|
|
|
|
it('revision-guards deletion when a Competition reversal leaves zero games', async () => {
|
|
const matchId = new mongoose.Types.ObjectId();
|
|
const communityId = new mongoose.Types.ObjectId();
|
|
const competitionId = new mongoose.Types.ObjectId();
|
|
const match = {
|
|
_id: matchId,
|
|
communityId,
|
|
scheduledAt: new Date('2026-07-12T10:00:00.000Z'),
|
|
status: 'in-progress',
|
|
teams: [],
|
|
result: undefined,
|
|
};
|
|
const competition = {
|
|
_id: competitionId,
|
|
revision: 12,
|
|
projectorVersion: 3,
|
|
teams: [],
|
|
projection: { phase: 'ready', games: [] },
|
|
};
|
|
const connectionService = {
|
|
getModel: jest.fn().mockImplementation(async (name: string) => {
|
|
if (name === 'match') {
|
|
return { findById: () => queryResult(match, false) };
|
|
}
|
|
if (name === 'competition') {
|
|
return { findOne: () => queryResult(competition) };
|
|
}
|
|
if (name === 'riotMatch') return {};
|
|
throw new Error(`Unexpected model: ${name}`);
|
|
}),
|
|
} as unknown as ConnectionService;
|
|
const repository = {
|
|
deleteByMatch: jest.fn().mockResolvedValue(undefined),
|
|
upsert: jest.fn(),
|
|
} as unknown as jest.Mocked<MatchStatsRepository>;
|
|
const service = new MatchStatsService(
|
|
connectionService,
|
|
repository,
|
|
{} as MatchStatsFragmentBuilder,
|
|
{ getMatchTimeline: jest.fn() } as never,
|
|
);
|
|
|
|
await service.buildAndUpsert(matchId, { sourceRevision: 12 });
|
|
|
|
expect(repository.deleteByMatch).toHaveBeenCalledWith(matchId, {
|
|
sourceCompetitionId: competitionId,
|
|
sourceRevision: 12,
|
|
});
|
|
expect(repository.upsert).not.toHaveBeenCalled();
|
|
});
|
|
|
|
it('upserts a fragment for eligible matches', async () => {
|
|
const matchId = new mongoose.Types.ObjectId();
|
|
const communityId = new mongoose.Types.ObjectId();
|
|
const scheduledAt = new Date('2026-05-03T00:00:00.000Z');
|
|
const match = {
|
|
_id: matchId,
|
|
communityId,
|
|
scheduledAt,
|
|
status: 'finished',
|
|
result: { games: [{ riotMatchId: 'KR_1' }] },
|
|
};
|
|
const findById = jest.fn().mockReturnValue({
|
|
exec: jest.fn().mockResolvedValue(match),
|
|
});
|
|
const riotFind = jest.fn().mockReturnValue({
|
|
lean: () => ({
|
|
exec: jest.fn().mockResolvedValue([
|
|
{
|
|
matchId: 'KR_1',
|
|
raw: {},
|
|
timeline: {
|
|
metadata: {
|
|
dataVersion: '2',
|
|
matchId: 'KR_1',
|
|
participants: [],
|
|
},
|
|
info: { frameInterval: 60_000, frames: [] },
|
|
},
|
|
},
|
|
]),
|
|
}),
|
|
});
|
|
const connectionService = {
|
|
getModel: jest.fn().mockImplementation(async (name: string) => {
|
|
if (name === 'match') return { findById };
|
|
if (name === 'competition') return { findOne: () => queryResult(null) };
|
|
if (name === 'riotMatch') return { find: riotFind };
|
|
throw new Error(`Unexpected model: ${name}`);
|
|
}),
|
|
} as unknown as ConnectionService;
|
|
const repository = {
|
|
upsert: jest.fn().mockResolvedValue(undefined),
|
|
deleteByMatch: jest.fn(),
|
|
} as unknown as jest.Mocked<MatchStatsRepository>;
|
|
const builder = {
|
|
buildFragment: jest.fn().mockReturnValue({
|
|
matchCard: { matchId: matchId.toString() },
|
|
records: [],
|
|
gameDetails: [],
|
|
userIds: [],
|
|
championIds: [],
|
|
gameCreationMin: 1_000,
|
|
gameCreationMax: 2_000,
|
|
}),
|
|
} as unknown as jest.Mocked<MatchStatsFragmentBuilder>;
|
|
const service = new MatchStatsService(
|
|
connectionService,
|
|
repository,
|
|
builder,
|
|
{ getMatchTimeline: jest.fn() } as never,
|
|
);
|
|
|
|
await service.buildAndUpsert(matchId);
|
|
|
|
expect(builder.buildFragment).toHaveBeenCalledWith({
|
|
match,
|
|
rawByRiotMatchId: expect.any(Map),
|
|
timelineByRiotMatchId: expect.any(Map),
|
|
});
|
|
expect(
|
|
builder.buildFragment.mock.calls[0][0].timelineByRiotMatchId,
|
|
).toHaveProperty('size', 0);
|
|
expect(repository.upsert).toHaveBeenCalledWith(
|
|
expect.objectContaining({
|
|
matchId,
|
|
communityId,
|
|
scheduledAt,
|
|
gameCreationMin: 1_000,
|
|
gameCreationMax: 2_000,
|
|
builderVersion: MATCH_STATS_BUILDER_VERSION,
|
|
}),
|
|
);
|
|
});
|
|
|
|
it('retries unusable timeline caches and stores a later usable fetch', async () => {
|
|
const matchId = new mongoose.Types.ObjectId();
|
|
const communityId = new mongoose.Types.ObjectId();
|
|
const match = {
|
|
_id: matchId,
|
|
communityId,
|
|
scheduledAt: new Date('2026-05-03T00:00:00.000Z'),
|
|
status: 'finished',
|
|
result: { games: [{ riotMatchId: 'KR_1' }] },
|
|
};
|
|
const emptyTimeline = {
|
|
info: { frameInterval: 60_000, frames: [] },
|
|
};
|
|
const partialTimeline = {
|
|
info: {
|
|
frameInterval: 60_000,
|
|
frames: [{ timestamp: 0, events: [] }],
|
|
},
|
|
};
|
|
const nonPositiveTimeline = {
|
|
info: {
|
|
frameInterval: 0,
|
|
frames: [timelineFrame(120_000)],
|
|
},
|
|
};
|
|
const truncatedTimeline = {
|
|
info: {
|
|
frameInterval: 60_000,
|
|
frames: [timelineFrame()],
|
|
},
|
|
};
|
|
const usableTimeline = {
|
|
metadata: {
|
|
dataVersion: '2',
|
|
matchId: 'KR_1',
|
|
participants: ['puuid-1'],
|
|
},
|
|
info: {
|
|
frameInterval: 60_000,
|
|
frames: [timelineFrame(120_000)],
|
|
},
|
|
};
|
|
const cachedTimelines = [
|
|
emptyTimeline,
|
|
partialTimeline,
|
|
nonPositiveTimeline,
|
|
truncatedTimeline,
|
|
];
|
|
let buildIndex = 0;
|
|
const riotFind = jest.fn().mockImplementation(() => ({
|
|
lean: () => ({
|
|
exec: jest.fn().mockResolvedValue([
|
|
{
|
|
matchId: 'KR_1',
|
|
raw: { info: { gameDuration: 120 } },
|
|
timeline: cachedTimelines[Math.min(buildIndex++, 3)],
|
|
},
|
|
]),
|
|
}),
|
|
}));
|
|
const updateExec = jest.fn().mockResolvedValue(undefined);
|
|
let storedUpdate:
|
|
| {
|
|
filter: unknown;
|
|
update: { $set: { timeline: unknown; timelineFetchedAt: Date } };
|
|
}
|
|
| undefined;
|
|
const updateOne = jest.fn(
|
|
(
|
|
filter: unknown,
|
|
update: { $set: { timeline: unknown; timelineFetchedAt: Date } },
|
|
) => {
|
|
storedUpdate = { filter, update };
|
|
return { exec: updateExec };
|
|
},
|
|
);
|
|
const connectionService = {
|
|
getModel: jest.fn().mockImplementation((name: string) => {
|
|
if (name === 'match') {
|
|
return Promise.resolve({ findById: () => queryResult(match, false) });
|
|
}
|
|
if (name === 'competition') {
|
|
return Promise.resolve({ findOne: () => queryResult(null) });
|
|
}
|
|
if (name === 'riotMatch') {
|
|
return Promise.resolve({ find: riotFind, updateOne });
|
|
}
|
|
if (name === 'community') {
|
|
return Promise.resolve({
|
|
findById: () => ({
|
|
select: () => queryResult({ riotRegion: 'asia' }),
|
|
}),
|
|
});
|
|
}
|
|
return Promise.reject(new Error(`Unexpected model: ${name}`));
|
|
}),
|
|
} as unknown as ConnectionService;
|
|
const repository = {
|
|
upsert: jest.fn().mockResolvedValue(undefined),
|
|
deleteByMatch: jest.fn(),
|
|
deleteLegacyByMatch: jest.fn(),
|
|
} as unknown as jest.Mocked<MatchStatsRepository>;
|
|
type BuildParams = Parameters<
|
|
MatchStatsFragmentBuilder['buildFragment']
|
|
>[0];
|
|
const buildCalls: BuildParams[] = [];
|
|
const builtFragment: ReturnType<
|
|
MatchStatsFragmentBuilder['buildFragment']
|
|
> = {
|
|
matchCard: {
|
|
matchId: matchId.toString(),
|
|
title: '내전',
|
|
scheduledAt: match.scheduledAt.toISOString(),
|
|
status: 'finished',
|
|
gameCount: 1,
|
|
games: [],
|
|
teams: [],
|
|
seriesResults: [],
|
|
},
|
|
records: [],
|
|
gameDetails: [],
|
|
userIds: [],
|
|
championIds: [],
|
|
gameCreationMin: 1_000,
|
|
gameCreationMax: 2_000,
|
|
};
|
|
const buildFragment = jest.fn((params: BuildParams) => {
|
|
buildCalls.push(params);
|
|
return builtFragment;
|
|
});
|
|
const builder = {
|
|
buildFragment,
|
|
} as unknown as jest.Mocked<MatchStatsFragmentBuilder>;
|
|
const getMatchTimeline = jest
|
|
.fn()
|
|
.mockRejectedValueOnce(new Error('temporary Riot failure'))
|
|
.mockRejectedValueOnce(new Error('temporary Riot failure'))
|
|
.mockRejectedValueOnce(new Error('temporary Riot failure'))
|
|
.mockResolvedValueOnce(usableTimeline);
|
|
const service = new MatchStatsService(
|
|
connectionService,
|
|
repository,
|
|
builder,
|
|
{ getMatchTimeline } as never,
|
|
);
|
|
|
|
await service.buildAndUpsert(matchId, { includeTimeline: true });
|
|
await service.buildAndUpsert(matchId, { includeTimeline: true });
|
|
await service.buildAndUpsert(matchId, { includeTimeline: true });
|
|
await service.buildAndUpsert(matchId, { includeTimeline: true });
|
|
|
|
expect(getMatchTimeline).toHaveBeenCalledTimes(4);
|
|
expect(buildFragment).toHaveBeenCalledTimes(4);
|
|
expect(buildCalls[0].timelineByRiotMatchId).toHaveProperty('size', 0);
|
|
expect(buildCalls[1].timelineByRiotMatchId).toHaveProperty('size', 0);
|
|
expect(buildCalls[2].timelineByRiotMatchId?.get('KR_1')).toBeUndefined();
|
|
expect(buildCalls[3].timelineByRiotMatchId?.get('KR_1')).toBe(
|
|
usableTimeline,
|
|
);
|
|
for (const call of buildCalls) {
|
|
expect(call).not.toHaveProperty('timelineLoadAttempted');
|
|
}
|
|
expect(updateOne).toHaveBeenCalledTimes(1);
|
|
expect(storedUpdate?.filter).toEqual({ matchId: 'KR_1' });
|
|
expect(storedUpdate?.update.$set.timeline).toBe(usableTimeline);
|
|
expect(storedUpdate?.update.$set.timelineFetchedAt).toBeInstanceOf(Date);
|
|
expect(updateExec).toHaveBeenCalledTimes(1);
|
|
});
|
|
|
|
it('builds from the Competition projection and records its source revision', async () => {
|
|
const matchId = new mongoose.Types.ObjectId();
|
|
const communityId = new mongoose.Types.ObjectId();
|
|
const competitionId = new mongoose.Types.ObjectId();
|
|
const teamAId = new mongoose.Types.ObjectId();
|
|
const teamBId = new mongoose.Types.ObjectId();
|
|
const userAId = new mongoose.Types.ObjectId();
|
|
const userBId = new mongoose.Types.ObjectId();
|
|
const match = {
|
|
_id: matchId,
|
|
communityId,
|
|
scheduledAt: new Date('2026-07-12T10:00:00.000Z'),
|
|
status: 'in-progress',
|
|
teams: [],
|
|
result: { games: [{ riotMatchId: 'KR_LEGACY_MUST_NOT_BE_USED' }] },
|
|
};
|
|
const competition = {
|
|
_id: competitionId,
|
|
revision: 12,
|
|
projectorVersion: 3,
|
|
teams: [
|
|
{ teamId: teamAId, legacyTeamIndex: 8, displayOrder: 1 },
|
|
{ teamId: teamBId, legacyTeamIndex: 3, displayOrder: 2 },
|
|
],
|
|
projection: {
|
|
phase: 'running',
|
|
games: [
|
|
{
|
|
displayNumber: 4,
|
|
evidence: { type: 'riot', riotMatchId: 'KR_COMPETITION' },
|
|
teams: {
|
|
blue: { teamId: teamAId.toString() },
|
|
red: { teamId: teamBId.toString() },
|
|
},
|
|
winnerTeamId: teamAId.toString(),
|
|
startedAt: '2026-07-12T10:00:00.000Z',
|
|
durationSeconds: 1800,
|
|
participants: [
|
|
participant(userAId, teamAId, 'blue', true),
|
|
participant(userBId, teamBId, 'red', false),
|
|
],
|
|
},
|
|
],
|
|
},
|
|
};
|
|
const riotFind = jest.fn().mockReturnValue({
|
|
lean: () => ({
|
|
exec: jest
|
|
.fn()
|
|
.mockResolvedValue([{ matchId: 'KR_COMPETITION', raw: {} }]),
|
|
}),
|
|
});
|
|
const connectionService = {
|
|
getModel: jest.fn().mockImplementation(async (name: string) => {
|
|
if (name === 'match')
|
|
return { findById: () => queryResult(match, false) };
|
|
if (name === 'competition') {
|
|
return { findOne: () => queryResult(competition) };
|
|
}
|
|
if (name === 'riotMatch') return { find: riotFind };
|
|
throw new Error(`Unexpected model: ${name}`);
|
|
}),
|
|
} as unknown as ConnectionService;
|
|
const repository = {
|
|
upsert: jest.fn().mockResolvedValue(undefined),
|
|
deleteByMatch: jest.fn(),
|
|
} as unknown as jest.Mocked<MatchStatsRepository>;
|
|
const builder = {
|
|
buildFragment: jest.fn().mockReturnValue({
|
|
matchCard: {},
|
|
records: [],
|
|
gameDetails: [],
|
|
userIds: [],
|
|
championIds: [],
|
|
gameCreationMin: 1,
|
|
gameCreationMax: 2,
|
|
}),
|
|
} as unknown as jest.Mocked<MatchStatsFragmentBuilder>;
|
|
const service = new MatchStatsService(
|
|
connectionService,
|
|
repository,
|
|
builder,
|
|
{ getMatchTimeline: jest.fn() } as never,
|
|
);
|
|
|
|
await service.buildAndUpsert(matchId, { sourceRevision: 12 });
|
|
|
|
expect(riotFind).toHaveBeenCalledWith({
|
|
matchId: { $in: ['KR_COMPETITION'] },
|
|
});
|
|
expect(builder.buildFragment).toHaveBeenCalledWith(
|
|
expect.objectContaining({
|
|
match: expect.objectContaining({
|
|
result: expect.objectContaining({
|
|
riotMatchIds: ['KR_COMPETITION'],
|
|
games: [
|
|
expect.objectContaining({
|
|
gameNumber: 4,
|
|
blueTeamIndex: 8,
|
|
redTeamIndex: 3,
|
|
winnerTeamIndex: 8,
|
|
}),
|
|
],
|
|
}),
|
|
}),
|
|
}),
|
|
);
|
|
expect(repository.upsert).toHaveBeenCalledWith(
|
|
expect.objectContaining({
|
|
sourceCompetitionId: competitionId,
|
|
sourceRevision: 12,
|
|
projectorVersion: 3,
|
|
}),
|
|
);
|
|
});
|
|
|
|
it('removes a fragment written after its Competition Match was deleted', async () => {
|
|
const matchId = new mongoose.Types.ObjectId();
|
|
const communityId = new mongoose.Types.ObjectId();
|
|
const competitionId = new mongoose.Types.ObjectId();
|
|
const teamAId = new mongoose.Types.ObjectId();
|
|
const teamBId = new mongoose.Types.ObjectId();
|
|
const match = {
|
|
_id: matchId,
|
|
communityId,
|
|
scheduledAt: new Date('2026-07-12T10:00:00.000Z'),
|
|
status: 'in-progress',
|
|
teams: [],
|
|
result: undefined,
|
|
};
|
|
const competition = {
|
|
_id: competitionId,
|
|
revision: 12,
|
|
projectorVersion: 3,
|
|
teams: [
|
|
{ teamId: teamAId, legacyTeamIndex: 1, displayOrder: 1 },
|
|
{ teamId: teamBId, legacyTeamIndex: 2, displayOrder: 2 },
|
|
],
|
|
projection: {
|
|
phase: 'running',
|
|
games: [
|
|
{
|
|
id: new mongoose.Types.ObjectId(),
|
|
displayNumber: 1,
|
|
evidence: { type: 'legacy', legacyReference: 'legacy:1' },
|
|
teams: {
|
|
blue: { teamId: teamAId.toString() },
|
|
red: { teamId: teamBId.toString() },
|
|
},
|
|
winnerTeamId: teamAId.toString(),
|
|
},
|
|
],
|
|
},
|
|
};
|
|
const findById = jest
|
|
.fn()
|
|
.mockReturnValueOnce(queryResult(match, false))
|
|
.mockReturnValueOnce(queryResult(null, false));
|
|
const findCompetition = jest.fn().mockReturnValue(queryResult(competition));
|
|
const connectionService = {
|
|
getModel: jest.fn().mockImplementation(async (name: string) => {
|
|
if (name === 'match') return { findById };
|
|
if (name === 'competition') return { findOne: findCompetition };
|
|
if (name === 'riotMatch') return {};
|
|
throw new Error(`Unexpected model: ${name}`);
|
|
}),
|
|
} as unknown as ConnectionService;
|
|
const repository = {
|
|
upsert: jest.fn().mockResolvedValue(undefined),
|
|
deleteByMatch: jest.fn().mockResolvedValue(undefined),
|
|
deleteLegacyByMatch: jest.fn(),
|
|
} as unknown as jest.Mocked<MatchStatsRepository>;
|
|
const builder = {
|
|
buildFragment: jest.fn().mockReturnValue({
|
|
matchCard: {},
|
|
records: [],
|
|
gameDetails: [],
|
|
userIds: [],
|
|
championIds: [],
|
|
gameCreationMin: 1,
|
|
gameCreationMax: 2,
|
|
}),
|
|
} as unknown as jest.Mocked<MatchStatsFragmentBuilder>;
|
|
const service = new MatchStatsService(
|
|
connectionService,
|
|
repository,
|
|
builder,
|
|
{ getMatchTimeline: jest.fn() } as never,
|
|
);
|
|
|
|
await service.buildAndUpsert(matchId, { sourceRevision: 12 });
|
|
|
|
expect(repository.upsert).toHaveBeenCalled();
|
|
expect(repository.deleteByMatch).toHaveBeenCalledWith(matchId, {
|
|
sourceCompetitionId: competitionId,
|
|
sourceRevision: 12,
|
|
});
|
|
expect(repository.upsert.mock.invocationCallOrder[0]).toBeLessThan(
|
|
repository.deleteByMatch.mock.invocationCallOrder[0],
|
|
);
|
|
});
|
|
|
|
it('does not rebuild before the requested Competition revision is visible', async () => {
|
|
const matchId = new mongoose.Types.ObjectId();
|
|
const riotFind = jest.fn();
|
|
const connectionService = {
|
|
getModel: jest.fn().mockImplementation(async (name: string) => {
|
|
if (name === 'match') {
|
|
return {
|
|
findById: () =>
|
|
queryResult(
|
|
{
|
|
_id: matchId,
|
|
status: 'in-progress',
|
|
},
|
|
false,
|
|
),
|
|
};
|
|
}
|
|
if (name === 'competition') {
|
|
return {
|
|
findOne: () => queryResult({ revision: 11 }),
|
|
};
|
|
}
|
|
if (name === 'riotMatch') return { find: riotFind };
|
|
throw new Error(`Unexpected model: ${name}`);
|
|
}),
|
|
} as unknown as ConnectionService;
|
|
const repository = {
|
|
upsert: jest.fn(),
|
|
deleteByMatch: jest.fn(),
|
|
} as unknown as jest.Mocked<MatchStatsRepository>;
|
|
const builder = {
|
|
buildFragment: jest.fn(),
|
|
} as unknown as jest.Mocked<MatchStatsFragmentBuilder>;
|
|
const service = new MatchStatsService(
|
|
connectionService,
|
|
repository,
|
|
builder,
|
|
{ getMatchTimeline: jest.fn() } as never,
|
|
);
|
|
|
|
await service.buildAndUpsert(matchId, { sourceRevision: 12 });
|
|
|
|
expect(riotFind).not.toHaveBeenCalled();
|
|
expect(builder.buildFragment).not.toHaveBeenCalled();
|
|
expect(repository.upsert).not.toHaveBeenCalled();
|
|
expect(repository.deleteByMatch).not.toHaveBeenCalled();
|
|
});
|
|
});
|
|
|
|
function participant(
|
|
userId: mongoose.Types.ObjectId,
|
|
teamId: mongoose.Types.ObjectId,
|
|
side: 'blue' | 'red',
|
|
win: boolean,
|
|
) {
|
|
return {
|
|
userId: userId.toString(),
|
|
teamId: teamId.toString(),
|
|
side,
|
|
summonerName: 'player',
|
|
tagLine: 'KR1',
|
|
championId: 1,
|
|
kills: 1,
|
|
deaths: 1,
|
|
assists: 1,
|
|
win,
|
|
};
|
|
}
|
|
|
|
function queryResult<T>(value: T, lean = true) {
|
|
const query = {
|
|
lean: jest.fn(),
|
|
exec: jest.fn().mockResolvedValue(value),
|
|
};
|
|
query.lean.mockReturnValue(query);
|
|
return lean ? query : { exec: query.exec };
|
|
}
|
|
|
|
function timelineFrame(timestamp = 0) {
|
|
return {
|
|
timestamp,
|
|
events: [],
|
|
participantFrames: {
|
|
'1': {
|
|
participantId: 1,
|
|
totalGold: 500,
|
|
xp: 0,
|
|
minionsKilled: 0,
|
|
jungleMinionsKilled: 0,
|
|
},
|
|
},
|
|
};
|
|
}
|