Flaky SQLite test: caller_deadline_caps_open_startup_execution_and_async_execution sees Timeout instead of TimeBudgetExceeded

Open Beginner friendly
#2,743 0 comments 0 reactions 0 assignees View on GitHub

Maintainers usually reply within 1 day

Nobody has claimed this yet.

Assessment

Difficulty
2/5
Estimated time
1-3 hours
Newbie friendliness
70/100
Issue type
Bug
Clarity
Clearly specified
Activity status
Active
Tech stack
rust, sqlite
Domain
testing

Research direction

Start in crates/registry-platform-sqlite/src/statement.rs: read the failing assertion near line 1427 and then execute_until, especially the permit wait around line 393 and the tokio::time::timeout_at mapping to Timeout around line 418. Decide whether the async caller-deadline expiry should also report TimeBudgetExceeded or whether the test should accept either result, then run cargo test -p registry-platform-sqlite statement::tests::caller_deadline_caps_open_startup_execution_and_async_execution repeatedly, ideally under load. Done means the test no longer depends on which side wins the race and still proves the deadline interrupts running work.

Written by the indexing model from the issue text.

Description

What happened

The Rust tests (platform) job failed in the merge group for #2727 (run 44767589662, 20 Nov 2026). #2727 does not touch registry-platform-sqlite. The next merge-group run for the same PR passed, and #2727 merged.

test statement::tests::caller_deadline_caps_open_startup_execution_and_async_execution ... FAILED
panicked at crates/registry-platform-sqlite/src/statement.rs:1427:9:
assertion `left == right` failed
  left: Timeout
 right: TimeBudgetExceeded
test result: FAILED. 7 passed; 1 failed; 0 ignored

Likely cause

The failing assertion is the last one in the test. It calls execute_before with a caller deadline 1 ms away and expects TimeBudgetExceeded.

In execute_until, two observers watch the same deadline:

  • The blocking worker runs the statement, and SQLite's progress check stops it at the deadline. That returns TimeBudgetExceeded.
  • The async side waits for the worker with tokio::time::timeout_at(async_deadline, execution), and maps expiry to Timeout (line 418). The permit wait at line 393 does the same.

When the worker has not returned its result by the time the timer fires, the async side reports Timeout. With a 1 ms deadline this depends on how quickly the blocking thread starts and notices the deadline, so a loaded runner can lose the race. The synchronous startup case (line 1417) has no async timer and is not affected.

The known consumer maps both kinds to the same code: registry-adapter-engine reports Timeout and TimeBudgetExceeded as adapter.sqlite.statement-budget. So this looks like a test race rather than a defect that users would see.

Suggested fix

One of:

  • In the test, accept either Timeout or TimeBudgetExceeded for the 1 ms async case. Both show that the caller deadline stopped the work.
  • If one kind per cause is the intended contract, map expiry of the caller's deadline on the async side to TimeBudgetExceeded as well, and keep the strict assertion.

Do not lengthen the deadline to hide the race. The test is meant to prove the deadline interrupts running work.

Impact

Merge-queue entries that select the platform Rust tests can be dropped. Rerunning the entry has passed so far.

Dominant language
Rust
Stars
2
Forks
0
Avg merge
9h 48m
Merged PRs (30d)
151

Getting set up

First steps

  1. Read the whole issue, then the project's contributing guide.
  2. Comment on the issue to say you are picking it up — it saves two people doing the same work.
  3. Fork the repository and make your change on a branch.
  4. Open a pull request that references the issue number.

More from registrystack/registry-stack

All issues in registrystack/registry-stack

Similar issues

More Rust issues

Get new issues in your inbox

A short digest of beginner-friendly GitHub issues.