Files
lolympus-tournament-support/apps/api/src/modules/auction/auction-deadline.scheduler.spec.ts
T

224 lines
7.1 KiB
TypeScript

import { AuctionRedisService } from './redis/auction-redis.service';
import { AuctionDeadlineScheduler } from './auction-deadline.scheduler';
import { AuctionRedisCommandService } from './redis/auction-redis-command.service';
import { AuctionService } from './auction.service';
import { AuctionEventBusService } from './auction-event-bus.service';
function makeScheduler(params: {
dueReply?: unknown;
leaderLockAcquired?: boolean;
expireReply?: unknown;
completedState?: unknown;
currentRedisTimestampMS?: number;
}) {
const sendCommand = jest.fn().mockResolvedValue(params.dueReply ?? []);
const redis = {
acquireTokenLock: jest
.fn()
.mockResolvedValue(params.leaderLockAcquired ?? true),
getCurrentRedisTimestampMS: jest
.fn()
.mockResolvedValue(params.currentRedisTimestampMS ?? 1000),
releaseTokenLock: jest.fn().mockResolvedValue(true),
raw: jest.fn().mockReturnValue({ sendCommand }),
} as unknown as jest.Mocked<AuctionRedisService>;
const redisCommand = {
expirePrepare: jest.fn().mockResolvedValue(
params.expireReply ?? {
auctionStateTransitionId: 'expire-1',
bidRoundExpiryDecision: 'passed',
currentServerTimestampMS: 1000,
ok: true,
revision: 2,
},
),
} as unknown as jest.Mocked<AuctionRedisCommandService>;
const auctionService = {
completePreparedExpiry: jest
.fn()
.mockResolvedValue(params.completedState ?? { phase: 'passed' }),
} as unknown as jest.Mocked<AuctionService>;
const eventBus = {
broadcastState: jest.fn(),
} as unknown as jest.Mocked<AuctionEventBusService>;
return {
auctionService,
eventBus,
redis,
redisCommand,
scheduler: new AuctionDeadlineScheduler(
redis,
redisCommand,
auctionService,
eventBus,
),
sendCommand,
};
}
describe('AuctionDeadlineScheduler', () => {
afterEach(() => {
jest.restoreAllMocks();
});
it('starts and clears the deadline tick timer', () => {
const setIntervalSpy = jest.spyOn(global, 'setInterval');
const clearIntervalSpy = jest.spyOn(global, 'clearInterval');
const { scheduler } = makeScheduler({});
scheduler.onModuleInit();
scheduler.onModuleDestroy();
expect(setIntervalSpy).toHaveBeenCalledWith(expect.any(Function), 1000);
expect(clearIntervalSpy).toHaveBeenCalledTimes(1);
});
it('processes a deadline tick only while holding the Redis leader lock', async () => {
const { redis, scheduler } = makeScheduler({});
const processDueBidRoundDeadlinesSpy = jest
.spyOn(scheduler, 'processDueBidRoundDeadlines')
.mockResolvedValue({ completed: 0, prepared: 0, skipped: 0 });
await (
scheduler as unknown as { safeTick: () => Promise<void> }
).safeTick();
const leaderLockToken = redis.acquireTokenLock.mock.calls[0]?.[1];
expect(redis.acquireTokenLock).toHaveBeenCalledWith(
'auction:bidRoundDeadlineScheduler:leader',
expect.any(String),
2500,
);
expect(processDueBidRoundDeadlinesSpy).toHaveBeenCalledWith(20);
expect(redis.releaseTokenLock).toHaveBeenCalledWith(
'auction:bidRoundDeadlineScheduler:leader',
leaderLockToken,
);
});
it('skips deadline tick work when another instance holds the leader lock', async () => {
const { redis, scheduler } = makeScheduler({ leaderLockAcquired: false });
const processDueBidRoundDeadlinesSpy = jest
.spyOn(scheduler, 'processDueBidRoundDeadlines')
.mockResolvedValue({ completed: 0, prepared: 0, skipped: 0 });
await (
scheduler as unknown as { safeTick: () => Promise<void> }
).safeTick();
expect(processDueBidRoundDeadlinesSpy).not.toHaveBeenCalled();
expect(redis.releaseTokenLock).not.toHaveBeenCalled();
});
it('reads due match ids from the Redis deadline queue with a batch limit', async () => {
const { redis, scheduler } = makeScheduler({
dueReply: ['match-1', 'match-2'],
});
await expect(scheduler.readDueMatchIds(1_000, 2)).resolves.toEqual([
'match-1',
'match-2',
]);
expect(redis.raw().sendCommand).toHaveBeenCalledWith([
'ZRANGEBYSCORE',
'auction:bidRoundDeadlineQueue',
'-inf',
'1000',
'LIMIT',
'0',
'2',
]);
});
it('prepares and completes due auction deadlines', async () => {
const matchId = '665f2f01f1f1f1f1f1f1f1f1';
const completedState = { phase: 'passed', revision: 3 };
const { auctionService, eventBus, redisCommand, scheduler } = makeScheduler(
{
dueReply: [matchId],
completedState,
},
);
await expect(scheduler.processDueBidRoundDeadlines(10)).resolves.toEqual({
completed: 1,
prepared: 1,
skipped: 0,
});
expect(redisCommand.expirePrepare).toHaveBeenCalledWith(
matchId,
expect.objectContaining({
bidRoundExpiryRetryDelayMS: 3000,
matchId,
}),
);
expect(auctionService.completePreparedExpiry).toHaveBeenCalledTimes(1);
// 만료 확정 결과는 즉시 1차 broadcast돼야 한다(클라가 입찰 라운드에 멈춰
// 후속 액션에서 CONFLICT가 반복되는 것을 막는 핵심 동작).
expect(eventBus.broadcastState).toHaveBeenCalledWith(
matchId,
completedState,
);
});
it('skips noop expiry preparations', async () => {
const { auctionService, eventBus, scheduler } = makeScheduler({
dueReply: ['665f2f01f1f1f1f1f1f1f1f1'],
expireReply: {
code: 'NOT_DUE',
currentServerTimestampMS: 1000,
noop: true,
},
});
await expect(scheduler.processDueBidRoundDeadlines(10)).resolves.toEqual({
completed: 0,
prepared: 0,
skipped: 1,
});
expect(auctionService.completePreparedExpiry).not.toHaveBeenCalled();
expect(eventBus.broadcastState).not.toHaveBeenCalled();
});
it('removes invalid deadline queue members', async () => {
const { scheduler, sendCommand } = makeScheduler({
dueReply: ['not-a-match-id'],
});
await expect(scheduler.processDueBidRoundDeadlines(10)).resolves.toEqual({
completed: 0,
prepared: 0,
skipped: 1,
});
expect(sendCommand).toHaveBeenLastCalledWith([
'ZREM',
'auction:bidRoundDeadlineQueue',
'not-a-match-id',
]);
});
it('continues processing later deadline items after one item fails', async () => {
const matchIds = ['665f2f01f1f1f1f1f1f1f1f1', '665f2f02f1f1f1f1f1f1f1f1'];
const { auctionService, redisCommand, scheduler } = makeScheduler({
dueReply: matchIds,
});
redisCommand.expirePrepare
.mockRejectedValueOnce(new Error('temporary redis error'))
.mockResolvedValueOnce({
auctionStateTransitionId: 'expire-2',
bidRoundExpiryDecision: 'passed',
currentServerTimestampMS: 1000,
ok: true,
revision: 3,
});
await expect(scheduler.processDueBidRoundDeadlines(10)).resolves.toEqual({
completed: 1,
prepared: 1,
skipped: 1,
});
expect(redisCommand.expirePrepare).toHaveBeenCalledTimes(2);
expect(auctionService.completePreparedExpiry).toHaveBeenCalledTimes(1);
});
});