Files
lolympus-tournament-support/apps/web/test/auction-action-retry.test.ts
T

200 lines
5.1 KiB
TypeScript

import assert from "node:assert/strict";
import test from "node:test";
import {
resolveAuctionActionRejection,
shouldRetryAuctionAction,
} from "../src/api/auction-action-retry.ts";
const request = {
clientObservedAuctionLifecycleId: "auction-1",
clientObservedCurrentAuctionPlayerOrderIndex: 11,
clientObservedCurrentBidRoundPlayerUserId: "player-11",
clientObservedPhase: "sold",
clientObservedRevision: 130,
};
const state = {
auctionLifecycleId: "auction-1",
currentAuctionPlayerOrderIndex: 11,
currentBidRoundPlayerUserId: "player-11",
phase: "sold" as const,
revision: 131,
};
const input = {
action: "next",
request,
serverState: state,
currentState: state,
resyncRecommended: true,
retryAttempt: 0,
};
test("a delayed old-lifecycle rejection cannot roll back the screen and retry", () => {
const currentState = {
...state,
auctionLifecycleId: "auction-2",
revision: 1,
};
const decision = resolveAuctionActionRejection({ ...input, currentState });
assert.deepEqual(decision, { applyServerState: false, retry: false });
});
test("an older forced-resync rejection cannot roll back an already advanced player", () => {
const serverState = { ...state, shouldForceAuctionStateResync: true };
const currentState = {
...state,
revision: 132,
currentAuctionPlayerOrderIndex: 12,
};
assert.deepEqual(
resolveAuctionActionRejection({ ...input, serverState, currentState }),
{
applyServerState: false,
retry: false,
},
);
});
test("a fresh rejection updates the screen to the new player without retrying", () => {
const serverState = {
...state,
currentAuctionPlayerOrderIndex: 12,
phase: "presenting" as const,
};
assert.deepEqual(
resolveAuctionActionRejection({
...input,
serverState,
currentState: { ...state, revision: 130 },
}),
{ applyServerState: true, retry: false },
);
});
test("a same-target revision update is applied and permits one retry", () => {
assert.deepEqual(
resolveAuctionActionRejection({
...input,
currentState: { ...state, revision: 130 },
}),
{ applyServerState: true, retry: true },
);
});
test("retries a revision conflict only while the original action target is unchanged", () => {
assert.equal(shouldRetryAuctionAction(input), true);
});
test("does not retry next for the following player after a conflict", () => {
const nextPlayer = {
...state,
currentAuctionPlayerOrderIndex: 12,
currentBidRoundPlayerUserId: "player-12",
phase: "presenting" as const,
};
assert.equal(
shouldRetryAuctionAction({
...input,
serverState: nextPlayer,
currentState: nextPlayer,
}),
false,
);
});
for (const patch of [
{ auctionLifecycleId: "auction-2" },
{ currentAuctionPlayerOrderIndex: 12 },
{ currentBidRoundPlayerUserId: "player-12" },
{ phase: "passed" as const },
]) {
test(`does not retarget a retry when ${Object.keys(patch)[0]} changes`, () => {
assert.equal(
shouldRetryAuctionAction({
...input,
serverState: { ...state, ...patch },
}),
false,
);
});
}
test("does not retry from an older acknowledgement after the live screen has advanced", () => {
assert.equal(
shouldRetryAuctionAction({
...input,
currentState: { ...state, currentAuctionPlayerOrderIndex: 12 },
}),
false,
);
});
test("does not retry with missing original target identity", () => {
for (const field of Object.keys(request)) {
assert.equal(
shouldRetryAuctionAction({
...input,
request: { ...request, [field]: undefined },
}),
false,
);
}
});
test("does not retry without a current state, a server state, or a retry recommendation", () => {
assert.equal(
shouldRetryAuctionAction({ ...input, currentState: null }),
false,
);
assert.equal(
shouldRetryAuctionAction({ ...input, serverState: undefined }),
false,
);
assert.equal(
shouldRetryAuctionAction({ ...input, resyncRecommended: false }),
false,
);
assert.equal(shouldRetryAuctionAction({ ...input, retryAttempt: 1 }), false);
});
test("does not retry next in presenting even if the target is unchanged", () => {
assert.equal(
shouldRetryAuctionAction({
...input,
request: { ...request, clientObservedPhase: "presenting" },
serverState: { ...state, phase: "presenting" },
currentState: { ...state, phase: "presenting" },
}),
false,
);
});
test("does not retry using a revision older than the original request", () => {
assert.equal(
shouldRetryAuctionAction({
...input,
serverState: { ...state, revision: 129 },
}),
false,
);
});
for (const [action, phase] of [
["open-bidding", "presenting"],
["sold", "bidding"],
["passed", "bidding"],
["next", "passed"],
] as const) {
test(`allows a same-target ${action} retry in ${phase}`, () => {
assert.equal(
shouldRetryAuctionAction({
...input,
action,
request: { ...request, clientObservedPhase: phase },
serverState: { ...state, phase },
currentState: { ...state, phase },
}),
true,
);
});
}