Test Human Review Gates for Rejection, Delay, and Changed Inputs
Prepared with AI assistance by Alactic Editorial. Examples identified as hypothetical are illustrative, not customer results.
A workflow can pass its approval test and still act after a rejection, treat silence as consent, or execute against a record the reviewer never saw. To test a human review gate properly, vary both the reviewer’s response and the underlying inputs, then inspect whether any consequential action occurred.
The essential automation approval workflow test cases are approval, rejection, no response, repeated approval, and input changes after review. Each needs an explicit permitted outcome, a prohibited outcome, and evidence from the action boundary—not just a reassuring status label.
This guide uses a fictional record-update workflow to build that test set. It verifies configured review behavior; it does not determine who should hold organisational authority or what tools an AI assistant may use.
1. Define exactly what the reviewer approves
“Approve this record” is too vague to test. A useful approval scope identifies the target record, the proposed changes, and the revision presented for review. Otherwise, an approval can accidentally become permission for whatever the record contains later.
Write a gate contract before running tests. It should answer:
- Target: Which record or set of records can this decision affect?
- Action: What specific update or external action is being reviewed?
- Snapshot: Which values and revision did the reviewer inspect?
- Decision lifetime: When does the request stop accepting a decision?
- Invalidation: Which changes require a new review?
- Completion: What evidence establishes that the action happened once?
Not every field needs to invalidate approval. A change to an internal display preference might be irrelevant; a change to the proposed recipient, amount, destination, or update payload usually changes what the reviewer is being asked to accept. Explicitly classify those dependencies rather than relying on a general “record changed” flag.
These are recommended test-design choices, not claims that a particular product implements revision binding or approval expiry. Confirm the available approval controls, evidence, and execution behavior in your workspace and current plan before adopting the tests.
2. Use a safe, concrete worked example
Fictional worked example: A workflow proposes changing a CRM opportunity’s stage from “Qualification” to “Proposal” and assigning its owner to Maya. A human must review the proposed update before it is applied. No customer message is sent, and no other record may be changed.
All identifiers, values, timing, and outcomes below are hypothetical test fixtures—not customer results.
- Target: Test opportunity
OPP-TEST-042. - Starting state: Stage “Qualification”; owner “Leo”; revision
r17. - Proposed action: Set stage to “Proposal” and owner to “Maya”.
- Review request:
GATE-301, displaying the starting state and proposed values. - Hypothetical response deadline: Thirty minutes after the request is created.
- Invalidating inputs: Target identity, starting stage, starting owner, proposed stage, or proposed owner.
- Non-invalidating input: An internal test note that neither changes nor informs the proposed update.
- Intended completion: One successful application of the reviewed update, with a linked execution record.
Use an isolated test record and a controlled execution destination. Reset the fixture between cases, including pending requests and queued work. Otherwise, a delayed worker from the previous case can look like a failure in the next one.
Keep the same gate contract across the suite. If the intended rule changes halfway through testing, revise the expected outcomes before interpreting the results.
3. Run this filled review-gate decision table
The following decision table is formatted as individual rows so each case can be copied into a test tracker. Every row includes a permitted outcome and an outcome that must fail the test.
Case A — Approval of unchanged inputs
Setup and stimulus: Open GATE-301 for revision r17. Approve before the hypothetical deadline without changing any relevant input.
Permitted: The workflow applies the reviewed stage and owner update once. The execution evidence links the target, review request, and reviewed revision.
Prohibited: Updating another record, applying different values, or applying the update more than once.
Case B — Explicit rejection
Setup and stimulus: Reset the fixture. Reject the active request with the reason “Owner needs correction”.
Permitted: The request becomes rejected and the record remains at its starting values. A corrected proposal may create a separate review request.
Prohibited: Applying either proposed field change, retrying the rejected update as though approval had occurred, or silently reopening the rejected request.
Case C — No response before the deadline
Setup and stimulus: Reset the fixture. Leave the request unanswered. Observe it before and after the hypothetical thirty-minute deadline, then exercise any scheduled retry path.
Permitted: It waits before the deadline, then expires or moves to a non-executing escalation state according to the configured contract. The record remains unchanged.
Prohibited: Treating silence, a reminder, or a retry as approval.
Case D — Repeated approval
Setup and stimulus: Reset the fixture. Approve the unchanged request, then submit the same decision again, including while the first execution is still pending.
Permitted: One logical execution proceeds. Later submissions return an already-decided or already-completed result, or are otherwise harmless.
Prohibited: Creating a second consequential execution or a second approval-backed job for the same action.
Case E — Relevant input changes after approval
Setup and stimulus: Reset the fixture. Approve r17, pause before the update is applied, and change the starting owner from “Leo” to “Nora”, producing r18.
Permitted: The old approval no longer permits execution. The workflow blocks the update and requests review of the refreshed proposal.
Prohibited: Applying the old proposal to the changed record or attaching the old approval to the new revision without review.
Case F — Proposal changes after approval
Setup and stimulus: Reset the fixture. Approve the proposed owner “Maya”, then change the proposed owner to “Nora” before execution.
Permitted: The changed proposal requires a fresh review.
Prohibited: Using approval of “Maya” to justify assigning “Nora”, even if the target record itself is unchanged.
Case G — Irrelevant input changes after approval
Setup and stimulus: Reset the fixture. Approve the request, then alter only the internal test note explicitly excluded from the approval dependencies.
Permitted: The reviewed update executes once if the implementation can reliably distinguish this change from relevant changes.
Prohibited: Expanding the action’s scope or ignoring another relevant change because a note also changed. If dependency-level checks are unavailable, revise the contract to require review after every revision change and test that conservative rule instead.
Case H — Late approval of an expired request
Setup and stimulus: Reset the fixture. Allow the request to expire, then attempt approval through an old notification or open review screen.
Permitted: The stale decision is refused without execution. A new request can be created using current inputs.
Prohibited: Reviving the expired approval path or allowing a stale screen to bypass the deadline.
4. Check effects, not just approval labels
A “rejected” label does not prove that a queued action stopped. Equally, unchanged field values do not prove that a repeated approval was harmless: setting the same values twice can leave the record looking correct while triggering downstream work twice.
For every case, collect three kinds of evidence:
- Decision evidence: Request identifier, reviewed inputs, decision, and decision time.
- Execution evidence: Whether work was queued, started, blocked, completed, or failed, linked to the same request.
- Effect evidence: Record history and any downstream consequence associated with the attempted action.
For negative cases, inspect both the immediate result and the later retry path. Observe through the configured execution and retry lifecycle rather than choosing an arbitrary short wait and declaring success.
If you cannot inspect execution attempts or downstream effects, record the result as inconclusive. A test that lacks visibility should not be promoted to a passing test merely because nothing changed on screen.
5. Test the gap between review and execution
The most revealing changed-input test places the edit after approval but before the consequential action. An interface may correctly show the reviewed values while an execution worker later reads different live values.
Use a controlled pause, test queue, or equivalent supported test mechanism to create that gap. If the workspace cannot expose such a point, ask the implementation owner how the review-to-action interval can be tested safely. Do not infer protection from a successful edit-before-approval test.
There is another interval to consider: inputs might change after an execution check but before the write completes. The implementation needs a way to prevent a conflicting write from slipping through that gap. The test should verify the observable result, not assume a particular database or locking feature exists.
Also separate approval validity from execution eligibility. A valid human decision is not a reason to skip other configured checks at execution time. This suite verifies that the review gate holds; it does not establish the authority model or replace other controls.
6. Decide how strict invalidation should be
Invalidating every approval whenever any record field changes is easier to reason about, but can cause unnecessary re-review. Invalidating only selected dependencies reduces interruptions, but requires a complete understanding of what informs the action.
Start conservatively when that understanding is incomplete. Expand the non-invalidating list only when a test demonstrates that the excluded field cannot alter the target, payload, or interpretation of the decision.
Rejection and timeout should also remain distinct. Rejection records an explicit decision; timeout records the absence of one. Both may prevent execution, but they call for different recovery: revise a rejected proposal, or route an unanswered request to the configured human escalation path.
A reminder is not a decision. An escalation is not permission to execute. If a workflow deliberately supports a different timeout rule, document and test that rule explicitly rather than letting a retry mechanism define it accidentally.
7. Recover failures without reusing stale approval
When a prohibited action occurs, first contain the affected test path: stop pending work where supported, identify the resulting changes, and prevent a retry from repeating the effect. Preserve the request and execution evidence before resetting the fixture.
Then classify the failure. Did execution ignore a rejection? Did a repeated event create duplicate work? Did the action read an unreviewed proposal? Did the input check occur too early? These are different defects, even if each appears as “approval workflow failed”.
Do not repair the test by editing the old approval to match what eventually happened. Create a new request for corrected inputs. If an action partly completed, establish the actual state before retrying; a retry that blindly repeats every step may introduce another consequence.
After the correction, rerun the failing case and its neighbouring cases. A change that blocks stale approvals can also accidentally block valid unchanged approvals, so negative-path repairs need a positive-path regression check.
8. Set a measurable release check
Use the eight rows above as an initial acceptance set. Mark each pass, fail, or inconclusive, and attach the request identifier, reviewed revision, final state, execution evidence, and observed effect.
For this hypothetical contract, acceptance requires every row to pass: unchanged approval produces one intended execution; rejection, silence, expiry, and relevant changes produce none; repeated approval produces no duplicate consequence. An inconclusive row remains an evidence gap, not a pass.
Your next action is concrete: choose one low-risk gated workflow, write its approval scope, and run the rejection and changed-input cases before expanding the suite. Those two tests quickly reveal whether the gate controls the actual action or merely records a decision beside it.
Put the next conversation to work.
Explore Alactic Communications for WhatsApp conversations, campaigns and AI-assisted workflows. Choose the product and plan that fit your team.
Explore Communications