Skip to content

Make Codex and Claude Code subscriptions go further: a local model router that gives routine agent work to economical models and keeps your strongest model for the hard parts.

25.1 KB
Raw Blame
use super::*;
use crate::store::tests::support::*;
use hiroute_domain::{ContentMode, ObservationQueryPort};
fn due(store: &LocalObservationStore) {
    store.capacity.lock().next_due = Instant::now();
}
#[test]
fn default_twenty_gb_persists_positive_u64_and_explicit_disable() {
    let dir = tempfile::tempdir().unwrap();
    let store = open_store(dir.path());
    assert_eq!(
        store.capacity_status().unwrap().max_active_bytes,
        Some(20_000_000_000)
    );
    assert!(store.set_capacity_limit(Some(0)).is_err());
    assert_eq!(
        store
            .set_capacity_limit(Some(u64::MAX))
            .unwrap()
            .max_active_bytes,
        Some(u64::MAX)
    );
    drop(store);
    let store = open_store(dir.path());
    assert_eq!(
        store.capacity_status().unwrap().max_active_bytes,
        Some(u64::MAX)
    );
    store.set_capacity_limit(None).unwrap();
    drop(store);
    let store = open_store(dir.path());
    assert_eq!(store.capacity_status().unwrap().max_active_bytes, None);
    assert_eq!(store.capacity_status().unwrap().reason, "disabled");
    assert_eq!(
        store
            .connection
            .lock()
            .query_row(
                "SELECT value FROM observation_meta WHERE key='max_active_bytes'",
                [],
                |row| row.get::<_, String>(0)
            )
            .unwrap(),
        "null"
    );
}

#[test]
fn page_release_consumes_the_bounded_pragma_instead_of_only_its_first_row() {
    let directory = tempfile::tempdir().unwrap();
    let store = open_store(directory.path());
    let db = store.connection.lock();
    db.execute_batch("CREATE TABLE capacity_page_fixture(payload BLOB); WITH RECURSIVE n(x) AS(VALUES(1) UNION ALL SELECT x+1 FROM n WHERE x<512) INSERT INTO capacity_page_fixture SELECT zeroblob(4096) FROM n; DELETE FROM capacity_page_fixture;").unwrap();
    let free = || {
        db.query_row("PRAGMA freelist_count", [], |row| row.get::<_, u64>(0))
            .unwrap()
    };
    let before = free();
    assert!(before > 32);
    assert!(vacuum_pages(&db).unwrap());
    assert!(
        before - free() > 1,
        "execute_batch steps a row-producing pragma only once"
    );
}

#[test]
fn physical_release_yields_to_a_pinned_reader_then_truncates_after_it_finishes() {
    let directory = tempfile::tempdir().unwrap();
    let store = open_store(directory.path());
    let db = store.connection.lock();
    db.busy_timeout(Duration::ZERO).unwrap();
    db.execute_batch("PRAGMA wal_checkpoint(TRUNCATE)").unwrap();
    let reader = Connection::open(&store.activity_path).unwrap();
    reader.execute_batch("BEGIN").unwrap();
    reader
        .query_row("SELECT COUNT(*) FROM observation_meta", [], |row| {
            row.get::<_, i64>(0)
        })
        .unwrap();
    db.execute(
        "INSERT INTO observation_meta(key,value) VALUES('capacity-reader-fixture','1')",
        [],
    )
    .unwrap();
    let start = Instant::now();
    assert!(!checkpoint_pages(&db, start + BUDGET).unwrap());
    assert!(start.elapsed() < BUDGET);
    drop(reader);
    assert!(checkpoint_pages(&db, Instant::now() + BUDGET).unwrap());
    assert_eq!(
        fs::metadata(format!("{}-wal", store.activity_path.display()))
            .unwrap()
            .len(),
        0
    );
}

#[test]
fn large_wal_recovers_after_reader_release_without_reopening_or_over_retiring() {
    for already_checkpointed in [false, true] {
        let directory = tempfile::tempdir().unwrap();
        let store = open_store(directory.path());
        let fixture = Fixture::new("large-wal-retirement");
        let writer = writer(&store);
        let channel = fact_channel(&fixture, 512 * 1024);
        for event in request_facts(&fixture, "large-wal", finished("large-wal"), 100) {
            assert!(matches!(
                offer_fact(&writer, &channel, event),
                crate::WriterCycleOutcome::Ack(_)
            ));
        }
        install_content(&store, &fixture, b"eligible old detail", 200);
        store.set_capacity_limit(Some(1)).unwrap();
        store
            .connection
            .lock()
            .execute_batch("PRAGMA wal_checkpoint(TRUNCATE)")
            .unwrap();
        let reader = Connection::open(&store.activity_path).unwrap();
        reader.execute_batch("BEGIN").unwrap();
        reader
            .query_row("SELECT COUNT(*) FROM logical_requests", [], |r| {
                r.get::<_, u64>(0)
            })
            .unwrap();
        // A temporary old reader can let a single committed transaction grow
        // the WAL above the former 16 MiB admission guard. The unrelated table
        // remains allocated, so a lower threshold cannot be satisfied by it.
        store.connection.lock().execute_batch("CREATE TABLE capacity_wal_fixture(payload BLOB); INSERT INTO capacity_wal_fixture VALUES(zeroblob(20971520));").unwrap();
        let wal = format!("{}-wal", store.activity_path.display());
        assert!(fs::metadata(&wal).unwrap().len() > 16 * 1024 * 1024);
        due(&store);
        store.capacity_cycle(1000).unwrap();
        assert_eq!(
            store.capacity_status().unwrap().reason,
            "page_release_pending"
        );
        assert_eq!(
            store
                .connection
                .lock()
                .query_row("SELECT COUNT(*) FROM logical_requests", [], |r| r
                    .get::<_, u64>(0))
                .unwrap(),
            1,
            "reader-pinned space must not cause additional logical expiry"
        );
        drop(reader);
        if already_checkpointed {
            let (_, frames, backfilled): (i64, i64, i64) = store
                .connection
                .lock()
                .query_row("PRAGMA wal_checkpoint(PASSIVE)", [], |r| {
                    Ok((r.get(0)?, r.get(1)?, r.get(2)?))
                })
                .unwrap();
            assert_eq!(frames, backfilled);
            assert!(
                fs::metadata(&wal).unwrap().len() > 16 * 1024 * 1024,
                "checkpointed WAL allocation retains its physical high-water mark"
            );
        }
        for _ in 0..30 {
            due(&store);
            store.capacity_cycle(1000).unwrap();
        }
        let db = store.connection.lock();
        assert_eq!(
            db.query_row("SELECT COUNT(*) FROM logical_requests", [], |r| r
                .get::<_, u64>(0))
                .unwrap(),
            0,
            "a released reader must allow capacity progress without reopening"
        );
        assert_eq!(
            db.query_row(
                "SELECT COUNT(*) FROM observation_capacity_pending_v5",
                [],
                |r| r.get::<_, u64>(0)
            )
            .unwrap(),
            0
        );
        assert_eq!(
            db.query_row(
                "SELECT COUNT(*) FROM observation_capacity_blobs_v5",
                [],
                |r| r.get::<_, u64>(0)
            )
            .unwrap(),
            0
        );
        assert!(fs::metadata(&wal).unwrap().len() < 16 * 1024 * 1024);
    }
}

#[test]
fn a_nonpreemptible_overrun_extends_the_completion_based_cooldown() {
    let directory = tempfile::tempdir().unwrap();
    let store = open_store(directory.path());
    store.set_capacity_limit(Some(1)).unwrap();
    store.connection.lock().trace(Some(|sql| {
        if sql.starts_with("SELECT EXISTS(SELECT 1 FROM observation_capacity_pending_v5)") {
            // Model a slow SQLite/filesystem unit that progress callbacks
            // cannot preempt; the next pass must account for its full cost.
            std::thread::sleep(Duration::from_millis(250));
        }
    }));
    let start = Instant::now();
    store.capacity_cycle(1000).unwrap();
    store.connection.lock().trace(None);
    assert!(start.elapsed() >= Duration::from_millis(250));
    assert!(store.capacity.lock().next_due >= Instant::now() + Duration::from_secs(20));
    assert!(!store.capacity_cycle(2000).unwrap());
}

#[test]
fn turn_cleanup_progresses_with_unrelated_requests_and_surviving_session_turns() {
    use std::sync::{
        Arc,
        atomic::{AtomicU8, Ordering},
    };

    let directory = tempfile::tempdir().unwrap();
    let store = open_store(directory.path());
    let fixture = Fixture::new("turn-cleanup");
    let writer = writer(&store);
    let channel = fact_channel(&fixture, 512 * 1024);
    for event in request_facts(&fixture, "turn-cleanup", finished("turn-cleanup"), 100) {
        assert!(matches!(
            offer_fact(&writer, &channel, event),
            crate::WriterCycleOutcome::Ack(_)
        ));
    }
    let db = store.connection.lock();
    db.execute("WITH RECURSIVE n(x) AS(VALUES(1) UNION ALL SELECT x+1 FROM n WHERE x<50000) INSERT INTO logical_requests(workspace_id,request_id,session_id,turn_id,started_at_ms,finished_at_ms) SELECT ?1,'unrelated-request-'||x,'unrelated-session','unrelated-turn-'||x,200,300 FROM n", [fixture.workspace.as_str()]).unwrap();
    db.execute("WITH RECURSIVE n(x) AS(VALUES(1) UNION ALL SELECT x+1 FROM n WHERE x<500) INSERT INTO turns(workspace_id,turn_id,session_id,started_at_ms) SELECT ?1,'surviving-turn-'||x,?2,200 FROM n", params![fixture.workspace.as_str(),fixture.session.as_str()]).unwrap();
    db.execute("INSERT INTO logical_requests(workspace_id,request_id,session_id,turn_id,started_at_ms,finished_at_ms) SELECT workspace_id,'surviving-request-'||turn_id,session_id,turn_id,200,300 FROM turns WHERE workspace_id=?1 AND session_id=?2 AND turn_id!=?3", params![fixture.workspace.as_str(),fixture.session.as_str(),fixture.turn.as_str()]).unwrap();
    // Reopen an already-current store that predates the required lookup index.
    db.execute_batch("DROP INDEX IF EXISTS observation_capacity_turn_v5")
        .unwrap();
    drop(db);
    drop(writer);
    drop(store);
    let store = open_store(directory.path());
    let mut db = store.connection.lock();
    store
        .capacity_retire(
            &mut db,
            fixture.workspace.as_str(),
            fixture.session.as_str(),
            fixture.request.as_str(),
            1000,
        )
        .unwrap();
    let mut state = State::default();
    // Maintenance may yield between durable phases on a busy host. Preserve
    // both the production time budget and the per-slice scan regression guard.
    for _ in 0..10 {
        let deadline = Instant::now() + BUDGET;
        let interrupted = Arc::new(AtomicU8::new(0));
        let reason = Arc::clone(&interrupted);
        let mut instructions = 0;
        db.progress_handler(
            1000,
            Some(move || {
                instructions += 1000;
                let value = if instructions > 100_000 {
                    2
                } else if Instant::now() >= deadline {
                    1
                } else {
                    return false;
                };
                reason.store(value, Ordering::Relaxed);
                true
            }),
        );
        let result = store.capacity_cleanup(&mut db, &mut state, deadline);
        db.progress_handler(0, None::<fn() -> bool>);
        let reason = interrupted.load(Ordering::Relaxed);
        assert_ne!(reason, 2, "turn cleanup must not scan unrelated history");
        assert!(result.is_ok() || reason == 1, "{result:?}");
        if !db
            .query_row(
                "SELECT EXISTS(SELECT 1 FROM observation_capacity_pending_v5)",
                [],
                |row| row.get::<_, bool>(0),
            )
            .unwrap()
        {
            break;
        }
    }
    assert_eq!(
        db.query_row(
            "SELECT COUNT(*) FROM observation_capacity_pending_v5",
            [],
            |r| r.get::<_, u64>(0)
        )
        .unwrap(),
        0
    );
    assert_eq!(
        db.query_row(
            "SELECT COUNT(*) FROM turns WHERE workspace_id=?1 AND session_id=?2",
            params![fixture.workspace.as_str(), fixture.session.as_str()],
            |r| r.get::<_, u64>(0)
        )
        .unwrap(),
        500
    );
    assert_eq!(
        db.query_row("SELECT COUNT(*) FROM logical_requests", [], |r| r
            .get::<_, u64>(0))
            .unwrap(),
        50_500
    );
}

#[test]
fn request_chunk_cleanup_uses_request_membership_before_unrelated_workspace_history() {
    let directory = tempfile::tempdir().unwrap();
    let store = open_store(directory.path());
    let fixture = Fixture::new("bounded-chunk-selection");
    install_content(&store, &fixture, b"selected request body", 100);
    let mut db = store.connection.lock();
    // Match a large workspace while keeping the selected request tiny. Both
    // carriers have valid matching content membership, preceding it by ID.
    db.execute_batch("WITH RECURSIVE n(x) AS(VALUES(1) UNION ALL SELECT x+1 FROM n WHERE x<10000) INSERT INTO content_instances_v2 SELECT workspace_id,'aaa-unrelated-'||x,message_instance_id,'unrelated-request',direction,fork_id,part_ordinal,content_kind,canonical_media_type,content_blob_digest,expected_byte_count,has_content_ref,transport_frame_id,downstream_delivery,accumulated_byte_count,state,created_at_unix_nanos FROM content_instances_v2 CROSS JOIN n WHERE content_id LIKE 'content-%' LIMIT 10000;").unwrap();
    db.execute_batch("INSERT INTO content_chunks_v2 SELECT workspace_id,content_id,0,'not-a-selected-object',0,1,'unrelated-event' FROM content_instances_v2 WHERE request_id='unrelated-request';").unwrap();
    db.execute(
        "INSERT INTO observation_capacity_pending_v5(workspace,request,session) VALUES(?1,?2,?3)",
        params![
            fixture.workspace.as_str(),
            fixture.request.as_str(),
            fixture.session.as_str()
        ],
    )
    .unwrap();
    let mut steps = 0;
    db.progress_handler(
        100,
        Some(move || {
            steps += 100;
            steps > 20000
        }),
    );
    let mut state = State::default();
    let _ = store.capacity_cleanup(&mut db, &mut state, Instant::now() + Duration::from_secs(5));
    db.progress_handler(0, None::<fn() -> bool>);
    let step: Option<i64> = db
        .query_row(
            "SELECT step FROM observation_capacity_pending_v5",
            [],
            |r| r.get(0),
        )
        .optional()
        .unwrap();
    assert!(
        step.is_none_or(|step| step > 0),
        "a tiny request cannot exhaust its SQL budget scanning other requests' chunks"
    );
}

#[cfg(unix)]
#[test]
fn capacity_accounting_preserves_sqlite_writer_locks_against_other_processes() {
    const CHILD_DB: &str = "HIROUTE_CAPACITY_LOCK_CHILD_DB";
    if let Some(path) = std::env::var_os(CHILD_DB) {
        let db = Connection::open(path).unwrap();
        db.busy_timeout(Duration::ZERO).unwrap();
        assert!(
            db.execute_batch("BEGIN IMMEDIATE").is_err(),
            "accounting must not release another SQLite connection's writer lock"
        );
        return;
    }
    let directory = tempfile::tempdir().unwrap();
    let store = open_store(directory.path());
    let db = store.connection.lock();
    db.execute_batch("BEGIN IMMEDIATE").unwrap();
    assert!(db_bytes(&store).unwrap() > 0);
    let child = std::process::Command::new(std::env::current_exe().unwrap())
        .args(["--exact", "store::capacity::tests::capacity_accounting_preserves_sqlite_writer_locks_against_other_processes", "--nocapture"])
        .env(CHILD_DB, &store.activity_path)
        .status()
        .unwrap();
    assert!(
        child.success(),
        "a competing process acquired the active writer transaction after accounting"
    );
    db.execute_batch("ROLLBACK").unwrap();
}
#[test]
fn retires_completed_request_in_slices_preserves_active_shared_history_and_rollup() {
    let dir = tempfile::tempdir().unwrap();
    let store = open_store(dir.path());
    let a = Fixture::new("capacity-old");
    let mut b = Fixture::new("capacity-live");
    b.workspace = hiroute_domain::WorkspaceId::parse("other-workspace").unwrap();
    let writer = writer(&store);
    let channel = fact_channel(&a, 512 * 1024);
    for event in request_facts(&a, "attempt-capacity", finished("attempt-capacity"), 100) {
        assert!(matches!(
            offer_fact(&writer, &channel, event),
            crate::WriterCycleOutcome::Ack(_)
        ));
    }
    install_content(&store, &a, b"shared retained body", 200);
    install_content(&store, &b, b"shared retained body", 300);
    let retired_fact =
        crate::store::fact_log::load_request(&store.connection.lock(), &a.workspace, &a.request)
            .unwrap()
            .remove(0);
    // A large request must make committed progress across multiple bounded units.
    {
        let mut db = store.connection.lock();
        let tx = db.transaction().unwrap();
        for i in 0..2048 {
            // Rowid order deliberately differs from the request index order.
            tx.execute("INSERT INTO conversation_content_events_v2(stream_ref,sequence,event_id,workspace_id,request_id,direction,fork_id,phase,metadata_json,envelope_digest) SELECT stream_ref,?1,?2,workspace_id,request_id,direction,fork_id,phase,metadata_json,envelope_digest FROM conversation_content_events_v2 WHERE request_id=?3 LIMIT 1",params![12047-i,format!("bulk-{i}"),a.request.as_str()]).unwrap();
            tx.execute("INSERT INTO observation_feedback_v2(stream_ref,rejected_or_acked_sequence,event_id,envelope_digest,feedback_kind,feedback_json,created_at_unix_nanos) SELECT stream_ref,sequence,event_id,envelope_digest,'ack',(SELECT feedback_json FROM observation_feedback_v2 WHERE feedback_kind='ack' LIMIT 1),100 FROM conversation_content_events_v2 WHERE event_id=?1",[format!("bulk-{i}")]).unwrap();
        }
        tx.commit().unwrap();
    }
    store.set_capacity_limit(Some(1)).unwrap();
    for _ in 0..30 {
        due(&store);
        store.capacity_cycle(1000).unwrap();
    }
    let db = store.connection.lock();
    assert!(
        !db.query_row(
            "SELECT EXISTS(SELECT 1 FROM logical_requests WHERE request_id=?1)",
            [a.request.as_str()],
            |r| r.get::<_, bool>(0)
        )
        .unwrap()
    );
    assert!(
        db.query_row(
            "SELECT EXISTS(SELECT 1 FROM logical_requests WHERE request_id=?1)",
            [b.request.as_str()],
            |r| r.get::<_, bool>(0)
        )
        .unwrap()
    );
    assert_eq!(
        db.query_row(
            "SELECT COUNT(*) FROM conversation_content_events_v2 WHERE request_id=?1",
            [a.request.as_str()],
            |r| r.get::<_, i64>(0)
        )
        .unwrap(),
        0
    );
    assert_eq!(
        db.query_row(
            "SELECT COUNT(*) FROM observation_feedback_v2 WHERE event_id LIKE 'bulk-%'",
            [],
            |r| r.get::<_, u64>(0)
        )
        .unwrap(),
        0,
        "retiring a carrier must not strand its accepted feedback"
    );
    assert_eq!(
        db.query_row(
            "SELECT COUNT(*) FROM observation_analysis_dirty_v1 WHERE request_id=?1",
            [a.request.as_str()],
            |r| r.get::<_, i64>(0)
        )
        .unwrap(),
        0
    );
    assert_eq!(
        db.query_row(
            "SELECT COUNT(*) FROM observation_feedback_v2 WHERE event_id=?1",
            [retired_fact.event_id.as_str()],
            |r| r.get::<_, u64>(0)
        )
        .unwrap(),
        0
    );
    assert_eq!(
        db.query_row(
            "SELECT COUNT(*) FROM observation_events WHERE event_id=?1",
            [retired_fact.event_id.as_str()],
            |r| r.get::<_, u64>(0)
        )
        .unwrap(),
        1
    );
    let next: u64 = db
        .query_row(
            "SELECT MAX(highest_accounted_sequence)+1 FROM observation_checkpoints",
            [],
            |r| r.get(0),
        )
        .unwrap();
    drop(db);
    use crate::writer::{IngestOutcome, ObservationCommitPort};
    assert!(matches!(
        store.ingest_fact(&retired_fact, &[]).unwrap(),
        IngestOutcome::Nack(_)
    ));
    let mut reused_id = retired_fact;
    reused_id.sequence = next;
    reused_id.correlation.request_id =
        hiroute_domain::LogicalRequestId::parse("changed-request-cannot-reuse-retired-event")
            .unwrap();
    assert!(
        matches!(store.ingest_fact(&reused_id,&[]).unwrap(), IngestOutcome::Nack(nack) if matches!(nack.detail,hiroute_domain::ObservationNackDetailV1::ImmutableProjectionConflict { .. }))
    );
    let detail = store
        .get_session(&b.workspace, &b.session, ContentMode::Messages)
        .unwrap();
    assert_eq!(detail.summary.request_count, 1);
    let value = store
        .get_value(&a.workspace, &value_query("plan/codex-daily", "USD", None))
        .unwrap();
    assert_eq!(value.input_tokens, 100);
    assert_eq!(value.estimated_total_savings_micros, Some(900));
    assert!(
        store
            .blob_path(
                store
                    .authority
                    .content_blob_digest("text/plain", b"shared retained body")
                    .as_str()
            )
            .exists()
    );
}
#[test]
fn busy_writer_yields_and_schedules_from_completion() {
    let dir = tempfile::tempdir().unwrap();
    let store = open_store(dir.path());
    store.set_capacity_limit(Some(1)).unwrap();
    let lock = store.connection.lock();
    let start = Instant::now();
    store.capacity_cycle(1).unwrap();
    assert!(start.elapsed() < Duration::from_millis(20));
    drop(lock);
    let state = store.capacity.lock();
    assert!(state.next_due >= start + INTERVAL);
    assert_eq!(state.status.reason, "writer_busy");
    drop(state);
    assert!(!store.capacity_cycle(2).unwrap());
}

#[test]
fn disabling_after_committed_retirement_resumes_cleanup_after_restart_without_selecting_another_request()
 {
    let directory = tempfile::tempdir().unwrap();
    let store = open_store(directory.path());
    let a = Fixture::new("disable-retired");
    let b = Fixture::new("disable-survivor");
    let writer = writer(&store);
    for (fixture, at) in [(&a, 100), (&b, 200)] {
        let channel = fact_channel(fixture, 512 * 1024);
        let attempt = format!("attempt-{}", fixture.request);
        for event in request_facts(fixture, &attempt, finished(&attempt), at) {
            assert!(matches!(
                offer_fact(&writer, &channel, event),
                crate::WriterCycleOutcome::Ack(_)
            ));
        }
    }
    install_content(&store, &a, b"already committed retirement", 300);
    install_content(&store, &b, b"completed but policy disabled", 400);
    store.set_capacity_limit(Some(1)).unwrap();
    store
        .capacity_retire(
            &mut store.connection.lock(),
            a.workspace.as_str(),
            a.session.as_str(),
            a.request.as_str(),
            1000,
        )
        .unwrap();
    store.set_capacity_limit(None).unwrap();
    drop(writer);
    drop(store);
    let store = open_store(directory.path());
    assert_eq!(store.capacity_status().unwrap().max_active_bytes, None);
    assert_eq!(
        store
            .connection
            .lock()
            .query_row(
                "SELECT COUNT(*) FROM observation_capacity_pending_v5",
                [],
                |r| r.get::<_, u64>(0)
            )
            .unwrap(),
        1
    );
    for _ in 0..30 {
        due(&store);
        store.capacity_cycle(1000).unwrap();
    }
    let db = store.connection.lock();
    assert_eq!(
        db.query_row(
            "SELECT COUNT(*) FROM observation_capacity_pending_v5",
            [],
            |r| r.get::<_, u64>(0)
        )
        .unwrap(),
        0
    );
    assert_eq!(
        db.query_row(
            "SELECT COUNT(*) FROM content_instances_v2 WHERE request_id=?1",
            [a.request.as_str()],
            |r| r.get::<_, u64>(0)
        )
        .unwrap(),
        0
    );
    assert!(
        db.query_row(
            "SELECT EXISTS(SELECT 1 FROM logical_requests WHERE request_id=?1)",
            [b.request.as_str()],
            |r| r.get::<_, bool>(0)
        )
        .unwrap()
    );
    assert!(db.query_row("SELECT EXISTS(SELECT 1 FROM content_instances_v2 WHERE request_id=?1 AND state='complete')", [b.request.as_str()], |r| r.get::<_, bool>(0)).unwrap());
}
#[test]
fn exhausted_sql_budget_rolls_back_without_deleting_or_running_fast_follow_on_work() {
    let dir = tempfile::tempdir().unwrap();
    let store = open_store(dir.path());
    let mut db = store.connection.lock();
    db.progress_handler(1, Some(|| true));
    let result = store.capacity_retire(&mut db, "default", "missing", "missing", 0);
    assert!(result.is_err());
    db.progress_handler(0, None::<fn() -> bool>);
    assert_eq!(
        db.query_row(
            "SELECT COUNT(*) FROM observation_capacity_pending_v5",
            [],
            |r| r.get::<_, i64>(0)
        )
        .unwrap(),
        0
    );
}

#[test]
fn failed_policy_commit_keeps_the_previous_limit() {
    let dir = tempfile::tempdir().unwrap();
    let store = open_store(dir.path());
    store.set_capacity_limit(Some(20_000_000_000)).unwrap();
    store.connection.lock().execute_batch("CREATE TRIGGER reject_capacity BEFORE UPDATE ON observation_meta WHEN OLD.key='max_active_bytes' BEGIN SELECT RAISE(ABORT,'injected write failure'); END;").unwrap();
    assert!(store.set_capacity_limit(Some(1)).is_err());
    assert!(store.set_capacity_limit(None).is_err());
    assert_eq!(
        store.capacity_status().unwrap().max_active_bytes,
        Some(20_000_000_000)
    );
}