Files
lolympus-tournament-support/apps/api/src/modules/auction/redis/auction-redis-state-reader.service.spec.ts
T

201 lines
5.9 KiB
TypeScript

import { AuctionRedisService } from './auction-redis.service';
import { AuctionRedisStateReaderService } from './auction-redis-state-reader.service';
function makeService(commandReplies: unknown[], currentServerTimestampMS = 1000) {
const sendCommand = jest
.fn()
.mockImplementation(() => Promise.resolve(commandReplies.shift()));
const auctionRedisService = {
getCurrentRedisTimestampMS: jest
.fn()
.mockResolvedValue(currentServerTimestampMS),
raw: jest.fn().mockReturnValue({ sendCommand }),
} as unknown as jest.Mocked<AuctionRedisService>;
return {
auctionRedisService,
sendCommand,
service: new AuctionRedisStateReaderService(auctionRedisService),
};
}
describe('AuctionRedisStateReaderService', () => {
it('reads live state identity', async () => {
const { service, sendCommand } = makeService([['life-1', '7']]);
await expect(service.readLiveStateIdentity('match-1')).resolves.toEqual({
auctionLifecycleId: 'life-1',
revision: 7,
});
expect(sendCommand).toHaveBeenCalledWith([
'HMGET',
'auction:match-1:liveAuctionState',
'auctionLifecycleId',
'revision',
]);
});
it('returns null when live state identity is missing', async () => {
const { service } = makeService([[null, null]]);
await expect(service.readLiveStateIdentity('match-1')).resolves.toBeNull();
});
it('reads bid context from the live state hot path fields', async () => {
const { service, sendCommand } = makeService([
['bidding', 'life-1', 'player-1', 'captain-2'],
]);
await expect(service.readBidContext('match-1', 2)).resolves.toEqual({
auctionLifecycleId: 'life-1',
bidderTeamCaptainUserId: 'captain-2',
currentBidRoundPlayerUserId: 'player-1',
phase: 'bidding',
});
expect(sendCommand).toHaveBeenCalledTimes(1);
expect(sendCommand).toHaveBeenCalledWith([
'HMGET',
'auction:match-1:liveAuctionState',
'phase',
'auctionLifecycleId',
'currentBidRoundPlayerUserId',
'team:2:captainUserId',
]);
});
it('falls back to structure state when bid context has no live captain field', async () => {
const { service, sendCommand } = makeService([
['bidding', 'life-1', 'player-1', null],
'{"auctionTeams":[{"teamIndex":2,"captainUserId":"captain-2"}]}',
]);
await expect(service.readBidContext('match-1', 2)).resolves.toEqual({
auctionLifecycleId: 'life-1',
bidderTeamCaptainUserId: 'captain-2',
currentBidRoundPlayerUserId: 'player-1',
phase: 'bidding',
});
expect(sendCommand).toHaveBeenNthCalledWith(2, [
'GET',
'auction:match-1:auctionStructureState',
]);
});
it('assembles a public auction view from Redis state', async () => {
const { service, sendCommand } = makeService([
[
'auctionLifecycleId',
'life-1',
'phase',
'expiring',
'revision',
'8',
'currentHighestBidPointAmount',
'100',
'currentHighestBidderTeamIndex',
'2',
'team:2:remainingBidPointAmount',
'900',
'bidRoundExpiryDecision',
'sold',
],
'{"auctionTeams":[{"teamIndex":1}]}',
['{"bidPointAmount":100,"bidderTeamIndex":2}'],
]);
const view = await service.readAuctionStateView('match-1', {
shouldForceAuctionStateResync: true,
});
expect(view).toMatchObject({
auctionBidHistory: [{ bidPointAmount: 100, bidderTeamIndex: 2 }],
auctionLifecycleId: 'life-1',
auctionTeams: [{ teamIndex: 1 }],
canPlaceBidInCurrentBidRound: false,
currentHighestBidderTeamIndex: 2,
currentHighestBidPointAmount: 100,
currentServerTimestampMS: 1000,
isAuctionStateTransitionInProgress: true,
phase: 'bidding',
revision: 8,
shouldForceAuctionStateResync: true,
});
expect(view).not.toHaveProperty('team:2:remainingBidPointAmount');
expect(view).not.toHaveProperty('bidRoundExpiryDecision');
expect(sendCommand).toHaveBeenNthCalledWith(1, [
'HGETALL',
'auction:match-1:liveAuctionState',
]);
expect(sendCommand).toHaveBeenNthCalledWith(2, [
'GET',
'auction:match-1:auctionStructureState',
]);
expect(sendCommand).toHaveBeenNthCalledWith(3, [
'LRANGE',
'auction:match-1:auctionBidHistory',
'0',
'-1',
]);
});
it('assembles state when HGETALL returns an object', async () => {
const { service } = makeService([
{
auctionLifecycleId: 'life-1',
phase: 'presenting',
revision: '3',
},
'{"auctionTeams":[]}',
[],
]);
await expect(service.readAuctionStateView('match-1')).resolves.toMatchObject({
auctionLifecycleId: 'life-1',
auctionTeams: [],
phase: 'presenting',
revision: 3,
});
});
it('can expose internal live fields for server-side expiry completion', async () => {
const { service } = makeService([
{
auctionLifecycleId: 'life-1',
bidRoundExpiryDecision: 'sold',
phase: 'expiring',
revision: '4',
'team:1:remainingBidPointAmount': '900',
},
'{"auctionTeams":[]}',
[],
]);
await expect(
service.readAuctionStateView('match-1', {
includeInternalLiveStateFields: true,
}),
).resolves.toMatchObject({
bidRoundExpiryDecision: 'sold',
redisInternalPhase: 'expiring',
'team:1:remainingBidPointAmount': '900',
});
});
it('returns null when live or structure state is absent', async () => {
await expect(
makeService([[], '{"auctionTeams":[]}', []]).service.readAuctionStateView(
'match-1',
),
).resolves.toBeNull();
await expect(
makeService([
{ auctionLifecycleId: 'life-1', phase: 'presenting', revision: '1' },
null,
[],
]).service.readAuctionStateView('match-1'),
).resolves.toBeNull();
});
});