Files
persona-lenz/apps/api/src/modules/analysis/analysis-queue.service.spec.ts
T
2026-07-03 00:45:04 -07:00

281 lines
8.3 KiB
TypeScript

import type { AnalysisJob } from '../global/database/schemas';
import type { ConnectionService } from '../global/database/connection.service';
import type { UserAnalysisJobData } from './analysis.types';
import {
FEATURE_RECOMPUTE_JOB_NAME,
USER_ANALYSIS_JOB_NAME,
} from './analysis.constants';
import { AnalysisQueueService } from './analysis-queue.service';
function createJobData(
overrides: Partial<UserAnalysisJobData> = {},
): UserAnalysisJobData {
return {
gameName: 'Hide on bush',
tagLine: 'KR1',
platformRoute: 'kr',
regionalRoute: 'asia',
queueId: 420,
requestedMatchCount: 20,
...overrides,
};
}
function createFindOneChain(
result: Pick<AnalysisJob, 'jobId' | 'status'> | null,
) {
const exec = jest
.fn<Promise<Pick<AnalysisJob, 'jobId' | 'status'> | null>, []>()
.mockResolvedValue(result);
const lean = jest.fn(() => ({ exec }));
const sort = jest.fn(() => ({ lean }));
return {
chain: { sort },
exec,
lean,
sort,
};
}
describe('AnalysisQueueService', () => {
it('creates an analysis job document and enqueues a BullMQ job', async () => {
const add = jest.fn().mockResolvedValue({ id: 'job-from-bull' });
const findOneChain = createFindOneChain(null);
const create = jest.fn().mockResolvedValue({});
const updateOne = jest.fn(() => ({
exec: jest.fn().mockResolvedValue({}),
}));
const analysisJobModel = {
create,
findOne: jest.fn(() => findOneChain.chain),
updateOne,
};
const connectionService = {
getModel: jest.fn().mockResolvedValue(analysisJobModel),
} as unknown as ConnectionService;
const service = new AnalysisQueueService(
{ add } as never,
connectionService,
() => 'analysis-job-1',
);
const result = await service.enqueueUserAnalysis(createJobData());
expect(result).toEqual({ jobId: 'analysis-job-1', status: 'queued' });
expect(create).toHaveBeenCalledWith(
expect.objectContaining({
jobId: 'analysis-job-1',
jobType: USER_ANALYSIS_JOB_NAME,
gameName: 'Hide on bush',
tagLine: 'KR1',
status: 'queued',
}),
);
expect(add).toHaveBeenCalledWith(
USER_ANALYSIS_JOB_NAME,
createJobData(),
expect.objectContaining({
attempts: 2,
jobId: 'analysis-job-1',
}),
);
});
it('creates a feature recompute job document and enqueues a BullMQ job', async () => {
const add = jest.fn().mockResolvedValue({ id: 'job-from-bull' });
const create = jest.fn().mockResolvedValue({});
const updateOne = jest.fn(() => ({
exec: jest.fn().mockResolvedValue({}),
}));
const analysisJobModel = {
create,
updateOne,
};
const connectionService = {
getModel: jest.fn().mockResolvedValue(analysisJobModel),
} as unknown as ConnectionService;
const service = new AnalysisQueueService(
{ add } as never,
connectionService,
() => 'recompute-job-1',
);
const result = await service.enqueueFeatureRecompute({
platformRoute: 'kr',
queueId: 420,
batchSize: 25,
puuid: 'target-puuid',
});
expect(result).toEqual({ jobId: 'recompute-job-1', status: 'queued' });
expect(create).toHaveBeenCalledWith(
expect.objectContaining({
jobId: 'recompute-job-1',
jobType: FEATURE_RECOMPUTE_JOB_NAME,
platformRoute: 'kr',
queueId: 420,
requestedMatchCount: 0,
puuid: 'target-puuid',
status: 'queued',
}),
);
expect(add).toHaveBeenCalledWith(
FEATURE_RECOMPUTE_JOB_NAME,
{
platformRoute: 'kr',
queueId: 420,
batchSize: 25,
puuid: 'target-puuid',
},
expect.objectContaining({
attempts: 1,
jobId: 'recompute-job-1',
}),
);
});
it('returns an existing active job instead of enqueueing a duplicate', async () => {
const add = jest.fn();
const findOneChain = createFindOneChain({
jobId: 'existing-job',
status: 'processing',
});
const analysisJobModel = {
create: jest.fn(),
findOne: jest.fn(() => findOneChain.chain),
};
const connectionService = {
getModel: jest.fn().mockResolvedValue(analysisJobModel),
} as unknown as ConnectionService;
const service = new AnalysisQueueService(
{ add } as never,
connectionService,
() => 'new-job',
);
await expect(service.enqueueUserAnalysis(createJobData())).resolves.toEqual(
{
jobId: 'existing-job',
status: 'processing',
},
);
expect(add).not.toHaveBeenCalled();
expect(analysisJobModel.create).not.toHaveBeenCalled();
});
it('marks the pre-created job failed when BullMQ enqueue fails', async () => {
const add = jest.fn().mockRejectedValue(new Error('redis unavailable'));
const findOneChain = createFindOneChain(null);
const create = jest.fn().mockResolvedValue({});
const updateOne = jest.fn(() => ({
exec: jest.fn().mockResolvedValue({}),
}));
const analysisJobModel = {
create,
findOne: jest.fn(() => findOneChain.chain),
updateOne,
};
const connectionService = {
getModel: jest.fn().mockResolvedValue(analysisJobModel),
} as unknown as ConnectionService;
const service = new AnalysisQueueService(
{ add } as never,
connectionService,
() => 'analysis-job-1',
);
await expect(service.enqueueUserAnalysis(createJobData())).rejects.toThrow(
'redis unavailable',
);
expect(updateOne).toHaveBeenCalledWith(
{ jobId: 'analysis-job-1' },
{
$set: {
status: 'failed',
stage: 'enqueue',
error: 'Analysis could not be queued.',
},
},
);
});
it('marks a pre-created feature recompute job failed when BullMQ enqueue fails', async () => {
const add = jest.fn().mockRejectedValue(new Error('redis unavailable'));
const create = jest.fn().mockResolvedValue({});
const updateOne = jest.fn(() => ({
exec: jest.fn().mockResolvedValue({}),
}));
const analysisJobModel = {
create,
updateOne,
};
const connectionService = {
getModel: jest.fn().mockResolvedValue(analysisJobModel),
} as unknown as ConnectionService;
const service = new AnalysisQueueService(
{ add } as never,
connectionService,
() => 'recompute-job-1',
);
await expect(
service.enqueueFeatureRecompute({
platformRoute: 'kr',
queueId: 420,
batchSize: 25,
}),
).rejects.toThrow('redis unavailable');
expect(updateOne).toHaveBeenCalledWith(
{ jobId: 'recompute-job-1' },
{
$set: {
status: 'failed',
stage: 'enqueue',
error: 'Analysis could not be queued.',
},
},
);
});
it('serializes identical in-process requests before creating a duplicate job', async () => {
const add = jest.fn().mockResolvedValue({ id: 'analysis-job-1' });
let activeJob: Pick<AnalysisJob, 'jobId' | 'status'> | null = null;
const findOne = jest.fn(() => ({
sort: jest.fn(() => ({
lean: jest.fn(() => ({
exec: jest
.fn<Promise<Pick<AnalysisJob, 'jobId' | 'status'> | null>, []>()
.mockImplementation(() => Promise.resolve(activeJob)),
})),
})),
}));
const create = jest.fn().mockImplementation(() => {
activeJob = { jobId: 'analysis-job-1', status: 'queued' };
return Promise.resolve({});
});
const analysisJobModel = {
create,
findOne,
updateOne: jest.fn(),
};
const connectionService = {
getModel: jest.fn().mockResolvedValue(analysisJobModel),
} as unknown as ConnectionService;
const service = new AnalysisQueueService(
{ add } as never,
connectionService,
() => (create.mock.calls.length === 0 ? 'analysis-job-1' : 'unexpected'),
);
const [firstResult, secondResult] = await Promise.all([
service.enqueueUserAnalysis(createJobData()),
service.enqueueUserAnalysis(createJobData()),
]);
expect(firstResult).toEqual({ jobId: 'analysis-job-1', status: 'queued' });
expect(secondResult).toEqual({ jobId: 'analysis-job-1', status: 'queued' });
expect(create).toHaveBeenCalledTimes(1);
expect(add).toHaveBeenCalledTimes(1);
});
});