fix: close competition cutover integrity gaps

This commit is contained in:
dahyeon committed 2026-07-12 21:22:22 +00:00
1 parent 7ea2002975
commit 683d602d63
57 files changed
+4805 -1582

No files matched your search

@@ -106,6 +106,49 @@ describe('CompetitionCommandService', () => {
expect(harness.session.abortTransaction).not.toHaveBeenCalled();
});
it('replays a concurrently committed identical command after a duplicate-key race', async () => {
const harness = createHarness();
let committedReceipt: Record<string, unknown> | null = null;
harness.outboxModel.findOne.mockImplementation(() =>
queryResult(committedReceipt),
);
harness.factModel.insertMany.mockImplementationOnce(
async ([fact]: Array<Record<string, unknown>>) => {
committedReceipt = {
competitionId: COMPETITION_ID,
idempotencyKey: fact.idempotencyKey,
requestHash: fact.requestHash,
commandId: fact.commandId,
revision: fact.revision,
payload: {
projection: PROJECTION,
phase: PROJECTION.phase,
},
};
throw Object.assign(new Error('duplicate command fact'), {
code: 11_000,
});
},
);
const service = new CompetitionCommandService(
harness.connectionService as ConnectionService,
);
await expect(
service.acceptGame(acceptGameCommand()),
).resolves.toMatchObject({
revision: 8,
replayed: true,
});
expect(harness.connectionService.createSession).toHaveBeenCalledTimes(2);
expect(harness.factModel.insertMany).toHaveBeenCalledTimes(1);
expect(harness.competitionModel.findOneAndUpdate).not.toHaveBeenCalled();
expect(harness.outboxModel.insertMany).not.toHaveBeenCalled();
expect(harness.session.abortTransaction).toHaveBeenCalledTimes(1);
expect(harness.session.commitTransaction).toHaveBeenCalledTimes(1);
});
it('rejects the same Idempotency-Key when its payload hash differs', async () => {
const harness = createHarness();
harness.outboxModel.findOne.mockReturnValue(
@@ -382,6 +425,39 @@ describe('CompetitionCommandService', () => {
{ session: harness.session },
);
expect(harness.tournamentCodeModel.updateMany).toHaveBeenCalled();
expect(harness.matchModel.updateOne).toHaveBeenCalledWith(
{ _id: reversal.competition.matchId },
{
$pull: {
tournamentCodeIds: {
$in: [reversal.parentCodeId, reversal.childCodeId],
},
},
},
{ session: harness.session },
);
const [, codeReversalPipeline] = harness.tournamentCodeModel.updateMany.mock
.calls[0] as unknown as [
Record<string, unknown>,
Array<Record<string, any>>,
];
expect(codeReversalPipeline[0].$set).toMatchObject({
state: {
$cond: [{ $eq: ['$state', 'reserved'] }, 'released', 'voided'],
},
matchId: {
$cond: [{ $eq: ['$state', 'reserved'] }, '$$REMOVE', '$matchId'],
},
gameNumber: {
$cond: [{ $eq: ['$state', 'reserved'] }, '$$REMOVE', '$gameNumber'],
},
bracketMatchId: {
$cond: [{ $eq: ['$state', 'reserved'] }, '$$REMOVE', '$bracketMatchId'],
},
reservedAt: {
$cond: [{ $eq: ['$state', 'reserved'] }, '$$REMOVE', '$reservedAt'],
},
});
expect(harness.competitionModel.findOneAndUpdate).toHaveBeenCalledWith(
{ _id: COMPETITION_ID, revision: 7 },
expect.objectContaining({ $inc: { revision: 1 } }),
@@ -390,6 +466,50 @@ describe('CompetitionCommandService', () => {
expect(harness.outboxModel.insertMany).toHaveBeenCalledTimes(1);
expect(harness.session.commitTransaction).toHaveBeenCalledTimes(1);
});
it('retries a cascade reversal after a transient transaction conflict', async () => {
const reversal = reversalFixture();
const harness = createHarness({
competition: reversal.competition,
facts: reversal.facts,
assignments: reversal.assignments,
});
harness.factModel.insertMany
.mockRejectedValueOnce(
Object.assign(new Error('write conflict'), {
code: 112,
codeName: 'WriteConflict',
}),
)
.mockResolvedValueOnce([]);
const service = new CompetitionCommandService(
harness.connectionService as ConnectionService,
);
const preview = await service.previewSeriesReversal({
competitionId: COMPETITION_ID,
expectedRevision: 7,
seriesId: reversal.parentSeriesId,
mode: 'cascade',
});
await expect(
service.reverseSeries({
competitionId: COMPETITION_ID,
expectedRevision: 7,
idempotencyKey: 'admin:reverse:transient-retry',
actor: { type: 'user', userId: USER_ID },
seriesId: reversal.parentSeriesId,
mode: 'cascade',
reason: 'Wrong result ingestion',
impactHash: preview.impactHash,
}),
).resolves.toMatchObject({ revision: 8, replayed: false });
expect(harness.connectionService.createSession).toHaveBeenCalledTimes(2);
expect(harness.factModel.insertMany).toHaveBeenCalledTimes(2);
expect(harness.session.abortTransaction).toHaveBeenCalledTimes(1);
expect(harness.session.commitTransaction).toHaveBeenCalledTimes(1);
});
});
const COMPETITION_ID = new Types.ObjectId('64b000000000000000000001');
@@ -496,12 +616,18 @@ function createHarness(
updateOne: jest.fn().mockResolvedValue({ modifiedCount: 1 }),
updateMany: jest.fn().mockResolvedValue({ modifiedCount: 2 }),
};
const matchModel = {
updateOne: jest
.fn()
.mockResolvedValue({ matchedCount: 1, modifiedCount: 1 }),
};
const models: Record<string, unknown> = {
competition: competitionModel,
competitionFact: factModel,
competitionOutbox: outboxModel,
tournamentCodeAssignment: assignmentModel,
tournamentCode: tournamentCodeModel,
match: matchModel,
};
const connectionService = {
createSession: jest.fn().mockResolvedValue(session),
@@ -515,6 +641,7 @@ function createHarness(
outboxModel,
assignmentModel,
tournamentCodeModel,
matchModel,
connectionService,
};
}
@@ -612,6 +739,8 @@ function reversalFixture() {
childFactId,
parentGameSlotId,
childGameSlotId,
parentCodeId,
childCodeId,
competition: {
...competitionDocument(7),
seriesGraph: [