~ knotless Search/
↑↓ move↵ open⇧↵ all results

johnandersen777.bsky.social/vuln-notif

0
0
main
918 lines · 30.6 KB Raw History
//! PDS lane parity: transport seam, session manager, error classification,
//! retry loops and publisher outcomes.

mod common;

use std::collections::HashMap;
use std::sync::{Arc, Mutex};
use std::time::{Duration, SystemTime, UNIX_EPOCH};

use async_trait::async_trait;
use serde_json::{Value, json};
use tokio::sync::Barrier;
use wiremock::matchers::{method, path};
use wiremock::{Mock, MockServer, ResponseTemplate};

use common::*;
use vuln_notif::db::DbHandle;
use vuln_notif::pds::error::{
    classify_at, parse_retry_after, rate_limit_delay, rate_limit_delay_from_headers,
};
use vuln_notif::pds::{PdsApi, PdsError, PdsErrorKind, Publisher, PublisherConfig, XrpcResponse};

// ---------------------------------------------------------------------------
// Error classifier
// ---------------------------------------------------------------------------

#[test]
fn classifier_table() {
    let empty = HashMap::new();
    let kind = |status: u16, body: &str| classify_at(Some(status), &empty, body, None, 0.0).kind;

    assert_eq!(kind(401, "unauthorized"), PdsErrorKind::Unauthorized);
    assert_eq!(kind(403, "forbidden"), PdsErrorKind::Unauthorized);
    assert_eq!(kind(400, "ExpiredToken"), PdsErrorKind::Unauthorized);
    assert_eq!(
        kind(400, "InvalidToken: invalid token"),
        PdsErrorKind::Unauthorized
    );

    assert_eq!(
        kind(400, "Value too large (max 65536 bytes)"),
        PdsErrorKind::TooLarge
    );
    assert_eq!(kind(413, "blob too large"), PdsErrorKind::TooLarge);
    assert_eq!(kind(500, "Value too large"), PdsErrorKind::TooLarge);

    assert_eq!(
        kind(400, "RecordNotFound: Could not locate record"),
        PdsErrorKind::NotFound
    );
    assert_eq!(kind(404, "not found"), PdsErrorKind::NotFound);

    assert_eq!(
        kind(400, "RecordAlreadyExists: Record already exists"),
        PdsErrorKind::AlreadyExists
    );
    assert_eq!(kind(409, "InvalidSwap"), PdsErrorKind::AlreadyExists);
    assert_eq!(
        kind(400, "record key already exists"),
        PdsErrorKind::AlreadyExists
    );

    assert_eq!(kind(429, "slow down"), PdsErrorKind::RateLimited);
    assert_eq!(kind(500, "internal"), PdsErrorKind::Transient);
    assert_eq!(kind(400, "InvalidRequest"), PdsErrorKind::Other);
    assert_eq!(kind(200, ""), PdsErrorKind::Other);

    let transport = classify_at(None, &empty, "", Some("connection reset"), 0.0);
    assert_eq!(transport.kind, PdsErrorKind::Transient);
    assert_eq!(transport.status, None);
}

#[test]
fn retry_after_numeric_and_http_date() {
    let mut headers = HashMap::new();
    headers.insert("retry-after".to_owned(), "42".to_owned());
    let error = classify_at(Some(429), &headers, "", None, 1_700_000_000.0);
    assert_eq!(error.retry_after, Some(42.0));

    let date = SystemTime::now() + Duration::from_secs(120);
    let date_secs = date.duration_since(UNIX_EPOCH).unwrap().as_secs_f64();
    let mut headers = HashMap::new();
    headers.insert("retry-after".to_owned(), httpdate::fmt_http_date(date));
    let error = classify_at(Some(429), &headers, "", None, date_secs - 120.0);
    let parsed = error.retry_after.expect("http date retry-after");
    assert!((parsed - 120.0).abs() < 1.0, "parsed {parsed}");

    assert_eq!(parse_retry_after("past", 1.0), None);
    assert_eq!(
        parse_retry_after("Wed, 21 Oct 2015 07:28:00 GMT", 1_500_000_000.0),
        Some(0.0)
    );
}

#[test]
fn rate_limit_delay_uses_reset_then_backoff() {
    let time = FakeTime::new(1_000.0);
    let error = PdsError {
        kind: PdsErrorKind::RateLimited,
        status: Some(429),
        message: String::new(),
        retry_after: None,
    };
    let mut headers = HashMap::new();
    headers.insert("ratelimit-reset".to_owned(), "1500".to_owned());
    assert_eq!(
        rate_limit_delay_from_headers(&error, &headers, 1, &*time),
        500.0
    );
    assert_eq!(rate_limit_delay(&error, 1, &*time), 60.0);
    assert_eq!(rate_limit_delay(&error, 2, &*time), 120.0);
    assert_eq!(rate_limit_delay(&error, 10, &*time), 1800.0);

    let with_retry_after = PdsError {
        retry_after: Some(7.5),
        ..error
    };
    assert_eq!(
        rate_limit_delay_from_headers(&with_retry_after, &headers, 1, &*time),
        7.5
    );
}

// ---------------------------------------------------------------------------
// Session manager
// ---------------------------------------------------------------------------

#[tokio::test]
async fn login_429_waits_at_least_300_seconds() {
    let api = FakePds::new();
    api.push_create(response_with_headers(
        429,
        json!({"error": "RateLimitExceeded"}),
        &[("retry-after", "42")],
    ));
    api.push_create(ok_session("access-a", "refresh-a"));
    let time = FakeTime::new(0.0);
    let (publisher, governor, _db) =
        publisher_with(api.clone(), time.clone(), COLLECTION, logger().0).await;

    publisher.login().await.expect("login");

    assert_eq!(time.sleeps(), vec![300.0]);
    assert_eq!(publisher.login_calls(), 1);
    assert_eq!(publisher.repo(), "did:plc:test");
    assert_eq!(api.count("createSession"), 2);
    assert_eq!(governor.waits(), 1);
}

#[tokio::test]
async fn refresh_rotates_without_relogin() {
    let api = FakePds::new();
    api.push_create(ok_session("access-a", "refresh-a"));
    api.push_refresh(ok_session("access-b", "refresh-b"));
    api.push_get(response(401, json!({"error": "ExpiredToken"})));
    api.push_get(response(
        200,
        json!({"uri": "at://did:plc:test/com.nahdig.cve.nvdV2/CVE-1", "cid": "cid-1"}),
    ));
    let time = FakeTime::new(0.0);
    let (publisher, _governor, _db) =
        publisher_with(api.clone(), time.clone(), COLLECTION, logger().0).await;

    publisher.login().await.expect("login");
    let outcome = publisher
        .check_row(&vuln_notif::db::model::CveRow::new(
            "CVE-1",
            json!({"id": "CVE-1"}),
        ))
        .await
        .expect("check");

    assert!(outcome.found);
    assert_eq!(publisher.login_calls(), 1);
    assert_eq!(api.count("createSession"), 1);
    assert_eq!(api.count("refreshSession"), 1);
    let gets: Vec<_> = api
        .calls()
        .into_iter()
        .filter(|call| call.method == "getRecord")
        .collect();
    assert_eq!(gets.len(), 2);
    assert_eq!(gets[0].access, "access-a");
    assert_eq!(gets[1].access, "access-b");
    assert_eq!(outcome.calls, 2);
    assert_eq!(outcome.retries, 1);
}

#[tokio::test]
async fn refresh_failure_relogins() {
    let api = FakePds::new();
    api.push_create(ok_session("access-a", "refresh-a"));
    api.push_refresh(response(401, json!({"error": "ExpiredToken"})));
    api.push_create(ok_session("access-b", "refresh-b"));
    api.push_get(response(401, json!({"error": "ExpiredToken"})));
    api.push_get(response(200, json!({"uri": "at://x", "cid": "cid"})));
    let time = FakeTime::new(0.0);
    let (publisher, _governor, _db) =
        publisher_with(api.clone(), time.clone(), COLLECTION, logger().0).await;

    publisher.login().await.expect("login");
    let outcome = publisher
        .check_row(&vuln_notif::db::model::CveRow::new(
            "CVE-1",
            json!({"id": "CVE-1"}),
        ))
        .await
        .expect("check");

    assert!(outcome.found);
    assert_eq!(publisher.login_calls(), 2);
    assert_eq!(api.count("createSession"), 2);
    assert_eq!(api.count("refreshSession"), 1);
    let gets: Vec<_> = api
        .calls()
        .into_iter()
        .filter(|call| call.method == "getRecord")
        .collect();
    assert_eq!(gets[1].access, "access-b");
}

struct GatedApi {
    state: Mutex<GatedState>,
}

struct GatedState {
    barrier: Arc<Barrier>,
    refresh_calls: usize,
    get_calls: usize,
    calls: Vec<ApiCall>,
}

impl GatedApi {
    fn new(barrier: Arc<Barrier>) -> Arc<Self> {
        Arc::new(Self {
            state: Mutex::new(GatedState {
                barrier,
                refresh_calls: 0,
                get_calls: 0,
                calls: Vec::new(),
            }),
        })
    }
}

#[async_trait]
impl PdsApi for GatedApi {
    async fn create_session(&self, handle: &str, _password: &str) -> anyhow::Result<XrpcResponse> {
        self.state.lock().unwrap().calls.push(ApiCall {
            method: "createSession",
            access: handle.to_owned(),
            ..ApiCall::default()
        });
        Ok(XrpcResponse {
            status: 200,
            headers: HashMap::new(),
            body: session_body("access-a", "refresh-a"),
            bytes: Vec::new(),
        })
    }

    async fn refresh_session(&self, _refresh_jwt: &str) -> anyhow::Result<XrpcResponse> {
        let mut state = self.state.lock().unwrap();
        state.refresh_calls += 1;
        state.calls.push(ApiCall {
            method: "refreshSession",
            ..ApiCall::default()
        });
        Ok(XrpcResponse {
            status: 200,
            headers: HashMap::new(),
            body: session_body("access-b", "refresh-b"),
            bytes: Vec::new(),
        })
    }

    async fn get_record(
        &self,
        repo: &str,
        collection: &str,
        rkey: &str,
        access_jwt: &str,
    ) -> anyhow::Result<XrpcResponse> {
        let barrier = {
            let mut state = self.state.lock().unwrap();
            state.get_calls += 1;
            state.calls.push(ApiCall {
                method: "getRecord",
                repo: repo.to_owned(),
                collection: collection.to_owned(),
                rkey: rkey.to_owned(),
                access: access_jwt.to_owned(),
                ..ApiCall::default()
            });
            state.barrier.clone()
        };
        if access_jwt == "access-a" {
            // Both workers must reach their stale 401 before either can
            // refresh, so the single-flight path is actually exercised.
            barrier.wait().await;
            return Ok(XrpcResponse {
                status: 401,
                headers: HashMap::new(),
                body: json!({"error": "ExpiredToken"}),
                bytes: Vec::new(),
            });
        }
        Ok(XrpcResponse {
            status: 200,
            headers: HashMap::new(),
            body: json!({"uri": "at://did:plc:test/x/1", "cid": "cid"}),
            bytes: Vec::new(),
        })
    }

    async fn create_record(
        &self,
        _repo: &str,
        _collection: &str,
        _rkey: &str,
        _record: &Value,
        _access_jwt: &str,
    ) -> anyhow::Result<XrpcResponse> {
        Err(anyhow::anyhow!("unexpected createRecord"))
    }

    async fn put_record(
        &self,
        _repo: &str,
        _collection: &str,
        _rkey: &str,
        _record: &Value,
        _access_jwt: &str,
    ) -> anyhow::Result<XrpcResponse> {
        Err(anyhow::anyhow!("unexpected putRecord"))
    }

    async fn apply_writes(
        &self,
        _repo: &str,
        _writes: &[Value],
        _access_jwt: &str,
    ) -> anyhow::Result<XrpcResponse> {
        Err(anyhow::anyhow!("unexpected applyWrites"))
    }

    async fn upload_blob(
        &self,
        _bytes: &[u8],
        _mime_type: &str,
        _access_jwt: &str,
    ) -> anyhow::Result<XrpcResponse> {
        Err(anyhow::anyhow!("unexpected uploadBlob"))
    }
}

#[tokio::test(flavor = "multi_thread", worker_threads = 4)]
async fn concurrent_401_is_single_flight() {
    let barrier = Arc::new(Barrier::new(2));
    let api = GatedApi::new(barrier);
    let time = FakeTime::new(0.0);
    let (publisher, _governor, _db) =
        publisher_with(api.clone(), time, COLLECTION, logger().0).await;
    publisher.login().await.expect("login");
    let publisher = Arc::new(publisher);

    let row = vuln_notif::db::model::CveRow::new("CVE-1", json!({"id": "CVE-1"}));
    let (left, right) = tokio::join!(publisher.check_row(&row), publisher.check_row(&row));
    assert!(left.expect("left").found);
    assert!(right.expect("right").found);

    let state = api.state.lock().unwrap();
    assert_eq!(state.refresh_calls, 1, "one refresh for two 401s");
    assert_eq!(state.get_calls, 4, "two stale + two retried getRecord");
    assert_eq!(
        state
            .calls
            .iter()
            .filter(|call| call.method == "createSession")
            .count(),
        1
    );
}

// ---------------------------------------------------------------------------
// Publisher outcomes and retry loops
// ---------------------------------------------------------------------------

#[tokio::test]
async fn check_row_missing_and_found() {
    let api = FakePds::new();
    api.push_create(ok_session("access-a", "refresh-a"));
    api.push_get(response(404, json!({"error": "RecordNotFound"})));
    api.push_get(response(200, json!({"uri": "at://x", "cid": "c"})));
    let time = FakeTime::new(0.0);
    let (publisher, _governor, _db) =
        publisher_with(api.clone(), time, COLLECTION, logger().0).await;
    publisher.login().await.expect("login");

    let row = vuln_notif::db::model::CveRow::new("CVE-1", json!({"id": "CVE-1"}));
    let missing = publisher.check_row(&row).await.expect("missing");
    assert!(!missing.found);
    assert!(missing.error.is_none());
    assert_eq!(missing.get_ops, 1);
    assert_eq!(missing.calls, 1);

    let found = publisher.check_row(&row).await.expect("found");
    assert!(found.found);
    assert_eq!(found.uri.as_deref(), Some("at://x"));
    assert_eq!(found.cid.as_deref(), Some("c"));
    assert_eq!(found.calls, 1);
    assert_eq!(found.durations.len(), 1);
}

#[tokio::test]
async fn create_row_success_exists_and_too_large() {
    let api = FakePds::new();
    api.push_create(ok_session("access-a", "refresh-a"));
    api.push_create_record(response(200, json!({"uri": "at://u", "cid": "cid"})));
    api.push_create_record(response(
        409,
        json!({"error": "RecordAlreadyExists", "message": "Record already exists"}),
    ));
    api.push_create_record(response(
        413,
        json!({"error": "PayloadTooLarge", "message": "Value too large"}),
    ));
    let time = FakeTime::new(0.0);
    let (publisher, governor, _db) =
        publisher_with(api.clone(), time, COLLECTION, logger().0).await;
    publisher.login().await.expect("login");

    let row = prepared("CVE-1");
    let created = publisher.create_row(&row).await.expect("create");
    assert!(created.created);
    assert_eq!(created.uri.as_deref(), Some("at://u"));
    assert_eq!(created.cid.as_deref(), Some("cid"));
    assert_eq!(created.record_bytes, 123);
    assert_eq!(created.create_ops, 1);
    assert_eq!(created.calls, 1);

    let exists = publisher.create_row(&row).await.expect("exists");
    assert!(exists.found);
    assert!(!exists.created);
    assert!(exists.error.is_none());

    let too_large = publisher.create_row(&row).await.expect("too large");
    assert!(too_large.skipped);
    assert!(!too_large.created);
    assert!(
        too_large
            .error
            .as_deref()
            .unwrap_or("")
            .contains("too large")
    );

    // Three creates at 3 points each.
    assert_eq!(governor.used().await.0, 9.0);
    let create = api
        .calls()
        .into_iter()
        .find(|call| call.method == "createRecord")
        .expect("create record call");
    assert_eq!(create.repo, "did:plc:test");
    let record = create.record.expect("create record body");
    assert_eq!(record["id"], "CVE-1");
}

#[tokio::test]
async fn transient_transport_retries_then_succeeds() {
    let api = FakePds::new();
    api.push_create(ok_session("access-a", "refresh-a"));
    api.push_get(Reply::Transport("connection reset".to_owned()));
    api.push_get(response(200, json!({"uri": "at://x", "cid": "c"})));
    let time = FakeTime::new(0.0);
    let (publisher, _governor, _db) =
        publisher_with(api.clone(), time.clone(), COLLECTION, logger().0).await;
    publisher.login().await.expect("login");

    let outcome = publisher
        .check_row(&vuln_notif::db::model::CveRow::new(
            "CVE-1",
            json!({"id": "CVE-1"}),
        ))
        .await
        .expect("check");

    assert!(outcome.found);
    assert_eq!(outcome.calls, 2);
    assert_eq!(outcome.retries, 1);
    assert_eq!(time.sleeps(), vec![1.0]);
}

#[tokio::test]
async fn rate_limit_retry_after_logs_and_retries() {
    let api = FakePds::new();
    api.push_create(ok_session("access-a", "refresh-a"));
    api.push_get(response_with_headers(
        429,
        json!({"error": "RateLimitExceeded"}),
        &[
            ("retry-after", "42"),
            ("ratelimit-remaining", "7"),
            ("ratelimit-reset", "1700000000"),
            ("ratelimit-limit", "5000"),
        ],
    ));
    api.push_get(response(200, json!({"uri": "at://x", "cid": "c"})));
    let time = FakeTime::new(0.0);
    let (logger, sink) = logger();
    let (publisher, governor, _db) =
        publisher_with(api.clone(), time.clone(), COLLECTION, logger).await;
    publisher.login().await.expect("login");

    let outcome = publisher
        .check_row(&vuln_notif::db::model::CveRow::new(
            "CVE-1",
            json!({"id": "CVE-1"}),
        ))
        .await
        .expect("check");

    assert!(outcome.found);
    assert_eq!(outcome.calls, 2);
    assert_eq!(outcome.retries, 1);
    assert_eq!(time.sleeps(), vec![42.0]);
    assert_eq!(governor.waits(), 1);

    let lines = sink.lines();
    let event: Value = lines
        .iter()
        .filter_map(|line| serde_json::from_str::<Value>(line).ok())
        .find(|value| value["event"] == "pds_rate_limited")
        .expect("pds_rate_limited log");
    assert_eq!(event["op"], "getRecord");
    assert_eq!(event["cve"], "CVE-1");
    assert_eq!(event["status"], 429);
    assert_eq!(event["retry_after"], 42.0);
    assert_eq!(event["remaining"], 7);
    assert_eq!(event["reset"], 1_700_000_000i64);
    assert_eq!(event["limit"], 5_000);
    assert_eq!(event["sleep_seconds"], 42.0);
}

#[tokio::test]
async fn rate_limit_default_backoff_uses_jitter_zero() {
    let api = FakePds::new();
    api.push_create(ok_session("access-a", "refresh-a"));
    api.push_get(response(429, json!({"error": "RateLimitExceeded"})));
    api.push_get(response(200, json!({"uri": "at://x", "cid": "c"})));
    let time = FakeTime::new(0.0);
    let (publisher, _governor, _db) =
        publisher_with(api.clone(), time.clone(), COLLECTION, logger().0).await;
    publisher.login().await.expect("login");

    publisher
        .check_row(&vuln_notif::db::model::CveRow::new(
            "CVE-1",
            json!({"id": "CVE-1"}),
        ))
        .await
        .expect("check");
    assert_eq!(time.sleeps(), vec![60.0]);
}

#[tokio::test]
async fn batch_results_absent_present_and_misaligned() {
    let api = FakePds::new();
    api.push_create(ok_session("access-a", "refresh-a"));
    api.push_apply(response(200, json!({})));
    api.push_apply(response(
        200,
        json!({"results": [
            {"uri": "at://r/1", "cid": "c1"},
            {"uri": "at://r/2", "cid": "c2"}
        ]}),
    ));
    api.push_apply(response(
        200,
        json!({"results": [{"uri": "at://r/1", "cid": "c1"}]}),
    ));
    let time = FakeTime::new(0.0);
    let (publisher, governor, _db) =
        publisher_with(api.clone(), time, COLLECTION, logger().0).await;
    publisher.login().await.expect("login");

    let rows = vec![prepared("CVE-1"), prepared("CVE-2")];
    let (absent, refs) = publisher.create_batch(&rows).await.expect("absent");
    assert!(refs.is_none());
    assert!(absent.error.is_none());
    assert_eq!(absent.create_ops, 1);
    assert_eq!(absent.calls, 1);

    let (present, refs) = publisher.create_batch(&rows).await.expect("present");
    assert!(present.error.is_none());
    let refs = refs.expect("aligned results");
    assert_eq!(refs.len(), 2);
    assert_eq!(refs[0].uri, "at://r/1");
    assert_eq!(refs[0].cid, "c1");
    assert_eq!(refs[1].uri, "at://r/2");
    assert_eq!(refs[1].cid, "c2");

    let (_misaligned, refs) = publisher.create_batch(&rows).await.expect("misaligned");
    assert!(refs.is_none(), "short results must fall back");

    // 3 points per write, three batches of two writes.
    assert_eq!(governor.used().await.0, 18.0);
    let writes = api
        .calls()
        .into_iter()
        .find(|call| call.method == "applyWrites")
        .and_then(|call| call.writes)
        .expect("writes");
    assert_eq!(writes.len(), 2);
    assert_eq!(writes[0]["$type"], "com.atproto.repo.applyWrites#create");
    assert_eq!(writes[0]["collection"], COLLECTION);
    assert_eq!(writes[0]["rkey"], "CVE-1");
    assert_eq!(writes[0]["value"]["id"], "CVE-1");
    assert!(writes[0].get("validate").is_none());
}

#[tokio::test]
async fn blob_upload_normalizes_ref_and_put_costs_three() {
    let blob_cid = vuln_notif::records::cidv1_raw(&vuln_notif::records::sha256_hex(b"blob"));
    let api = FakePds::new();
    api.push_create(ok_session("access-a", "refresh-a"));
    api.push_upload(response(
        200,
        json!({"blob": {"ref": blob_cid.clone(), "mimeType": "application/gzip", "size": 3}}),
    ));
    api.push_create_record(response(200, json!({"uri": "at://blob", "cid": "cid"})));
    api.push_put(response(200, json!({"uri": "at://put", "cid": "cid2"})));
    let time = FakeTime::new(0.0);
    let (publisher, governor, _db) =
        publisher_with(api.clone(), time, COLLECTION, logger().0).await;
    publisher.login().await.expect("login");

    let mut row = prepared("CVE-1");
    row.blob = Some(vec![1, 2, 3]);
    row.record = json!({"$type": COLLECTION, "id": "CVE-1"});
    let outcome = publisher.create_large_row(&row).await.expect("large");
    assert!(outcome.created, "{:?}", outcome.error);
    assert!(outcome.oversized);
    assert_eq!(outcome.blob_ops, 1);
    assert_eq!(outcome.blob_bytes, 3);
    assert_eq!(outcome.blob_cid.as_deref(), Some(blob_cid.as_str()));
    assert!(outcome.record_bytes > 0);
    assert_eq!(outcome.create_ops, 1);

    let calls = api.calls();
    let upload = calls
        .iter()
        .find(|call| call.method == "uploadBlob")
        .unwrap();
    assert_eq!(upload.mime.as_deref(), Some("application/gzip"));
    assert_eq!(upload.bytes.as_deref(), Some(&[1u8, 2, 3][..]));
    let create = calls
        .iter()
        .find(|call| call.method == "createRecord")
        .unwrap();
    let blob = &create.record.as_ref().unwrap()["dataBlob"];
    assert_eq!(create.collection, COLLECTION);
    assert_eq!(create.rkey, "CVE-1");
    assert_eq!(blob["$type"], "blob");
    assert_eq!(blob["ref"]["$link"], blob_cid.as_str());
    assert_eq!(blob["mimeType"], "application/gzip");
    assert_eq!(blob["size"], 3);

    let put = publisher
        .put_record("com.nahdig.software", "slug", json!({"slug": "slug"}))
        .await
        .expect("put");
    assert!(put.created);
    assert_eq!(put.uri.as_deref(), Some("at://put"));
    assert!(put.record_bytes > 0);
    assert_eq!(put.create_ops, 1);

    // uploadBlob costs 0; one create (3) and one put (3).
    assert_eq!(governor.used().await.0, 6.0);
}

#[tokio::test]
async fn custom_nsid_bodies_omit_validate_over_real_transport() {
    let server = MockServer::start().await;
    Mock::given(method("POST"))
        .and(path("/xrpc/com.atproto.server.createSession"))
        .respond_with(
            ResponseTemplate::new(200).set_body_json(session_body("access-a", "refresh-a")),
        )
        .expect(1)
        .mount(&server)
        .await;
    Mock::given(method("POST"))
        .and(path("/xrpc/com.atproto.repo.createRecord"))
        .respond_with(
            ResponseTemplate::new(200).set_body_json(json!({"uri": "at://u", "cid": "c"})),
        )
        .expect(1)
        .mount(&server)
        .await;

    let time = FakeTime::new(0.0);
    let db = DbHandle::open_in_memory().await.expect("db");
    let governor = governor(&db, time.clone()).await;
    let publisher = Publisher::new(PublisherConfig {
        pds_url: server.uri(),
        handle: "alice.test".to_owned(),
        app_password: "app-pw".to_owned(),
        collection: "com.example.custom".to_owned(),
        timeout_secs: 5.0,
        governor,
    })
    .expect("publisher");
    publisher.login().await.expect("login");
    publisher
        .create_row(&prepared("CVE-9"))
        .await
        .expect("create");

    let requests = server.received_requests().await.expect("requests");
    let create = requests
        .iter()
        .find(|request| request.url.path() == "/xrpc/com.atproto.repo.createRecord")
        .expect("createRecord request");
    assert_eq!(
        create
            .headers
            .get("authorization")
            .unwrap()
            .to_str()
            .unwrap(),
        "Bearer access-a"
    );
    let body: Value = serde_json::from_slice(&create.body).expect("json body");
    assert_eq!(body["collection"], "com.example.custom");
    assert!(body.get("validate").is_none());
    assert_eq!(body["record"]["$type"], COLLECTION);

    let session_request = requests
        .iter()
        .find(|request| request.url.path() == "/xrpc/com.atproto.server.createSession")
        .expect("createSession request");
    let session_body: Value = serde_json::from_slice(&session_request.body).expect("json");
    assert_eq!(session_body["identifier"], "alice.test");
    assert_eq!(session_body["password"], "app-pw");
}

// ---------------------------------------------------------------------------
// listRecords / deleteRecord / applyWrites contracts
// ---------------------------------------------------------------------------

#[tokio::test]
async fn list_records_paginates_with_cursor_round_trip() {
    let api = FakePds::new();
    for id in ["CVE-1", "CVE-2", "CVE-3"] {
        api.seed_record(COLLECTION, id, json!({"id": id}));
    }
    let time = FakeTime::new(0.0);
    let (publisher, governor, _db) =
        publisher_with(api.clone(), time, COLLECTION, logger().0).await;
    publisher.login().await.expect("login");

    let first = publisher
        .list_records(COLLECTION, None, Some(2))
        .await
        .expect("first page");
    assert_eq!(first.records.len(), 2);
    assert_eq!(first.records[0].uri, record_uri(REPO, COLLECTION, "CVE-1"));
    assert_eq!(first.records[0].cid, PUT_CID);
    assert_eq!(first.records[0].value, json!({"id": "CVE-1"}));
    assert_eq!(first.records[1].uri, record_uri(REPO, COLLECTION, "CVE-2"));
    let cursor = first.cursor.expect("next cursor");
    assert_eq!(cursor, "CVE-2");

    let second = publisher
        .list_records(COLLECTION, Some(&cursor), Some(2))
        .await
        .expect("second page");
    assert_eq!(second.records.len(), 1);
    assert_eq!(second.records[0].uri, record_uri(REPO, COLLECTION, "CVE-3"));
    assert_eq!(second.cursor, None);
    assert_eq!(
        governor.used().await.0,
        0.0,
        "listRecords reserves no write points"
    );

    let lists: Vec<_> = api
        .calls()
        .into_iter()
        .filter(|call| call.method == "listRecords")
        .collect();
    assert_eq!(lists.len(), 2);
    assert_eq!(lists[0].collection, COLLECTION);
    assert_eq!(lists[0].cursor, None);
    assert_eq!(lists[0].limit, Some(2));
    assert_eq!(lists[0].access, "access");
    assert_eq!(lists[1].cursor.as_deref(), Some("CVE-2"));
}

#[tokio::test]
async fn delete_record_removes_and_returns_uri() {
    let api = FakePds::new();
    api.seed_record(COLLECTION, "CVE-1", json!({"id": "CVE-1"}));
    let time = FakeTime::new(0.0);
    let (publisher, governor, _db) =
        publisher_with(api.clone(), time, COLLECTION, logger().0).await;
    publisher.login().await.expect("login");

    let outcome = publisher
        .delete_record(COLLECTION, "CVE-1")
        .await
        .expect("delete");
    let uri = record_uri(REPO, COLLECTION, "CVE-1");
    assert!(outcome.found);
    assert!(!outcome.skipped);
    assert!(outcome.error.is_none());
    assert_eq!(outcome.uri.as_deref(), Some(uri.as_str()));
    assert_eq!(outcome.cid.as_deref(), Some(DELETE_CID));
    assert_eq!(outcome.calls, 1);
    assert!(api.record(COLLECTION, "CVE-1").is_none());
    assert_eq!(api.count("deleteRecord"), 1);
    assert_eq!(governor.used().await.0, 1.0);
}

#[tokio::test]
async fn delete_missing_record_is_a_typed_miss() {
    let api = FakePds::new();
    let time = FakeTime::new(0.0);
    let (publisher, _governor, _db) =
        publisher_with(api.clone(), time, COLLECTION, logger().0).await;
    publisher.login().await.expect("login");

    let outcome = publisher
        .delete_record(COLLECTION, "CVE-404")
        .await
        .expect("delete missing");
    assert!(!outcome.found);
    assert!(!outcome.skipped);
    assert!(outcome.error.is_none());
    assert!(outcome.uri.is_none());
    assert_eq!(outcome.calls, 1);
    assert_eq!(api.count("deleteRecord"), 1);
}

#[tokio::test]
async fn apply_writes_deletes_and_updates_records() {
    let api = FakePds::new();
    api.seed_record(COLLECTION, "keep", json!({"id": "keep"}));
    api.seed_record(COLLECTION, "drop", json!({"id": "drop"}));
    let time = FakeTime::new(0.0);
    let (publisher, governor, _db) =
        publisher_with(api.clone(), time, COLLECTION, logger().0).await;
    publisher.login().await.expect("login");

    let writes = vec![
        json!({
            "$type": "com.atproto.repo.applyWrites#delete",
            "collection": COLLECTION,
            "rkey": "drop",
        }),
        json!({
            "$type": "com.atproto.repo.applyWrites#update",
            "collection": COLLECTION,
            "rkey": "keep",
            "value": {"id": "keep", "updated": true},
        }),
    ];
    let outcome = publisher
        .apply_writes(writes.clone())
        .await
        .expect("applyWrites");
    assert!(outcome.error.is_none(), "{:?}", outcome.error);
    assert!(!outcome.skipped);
    assert!(api.record(COLLECTION, "drop").is_none());
    assert_eq!(api.record(COLLECTION, "keep").unwrap()["updated"], true);

    let call = api
        .calls()
        .into_iter()
        .find(|call| call.method == "applyWrites")
        .expect("applyWrites call");
    assert_eq!(call.writes.as_deref(), Some(writes.as_slice()));
    assert_eq!(
        governor.used().await.0,
        4.0,
        "one delete (1) + one update (3)"
    );
}

#[tokio::test]
async fn list_costs_no_write_points_delete_costs_one() {
    let api = FakePds::new();
    api.seed_record(COLLECTION, "CVE-1", json!({"id": "CVE-1"}));
    let time = FakeTime::new(0.0);
    let (publisher, governor, _db) =
        publisher_with(api.clone(), time, COLLECTION, logger().0).await;
    publisher.login().await.expect("login");

    let page = publisher
        .list_records(COLLECTION, None, Some(10))
        .await
        .expect("list");
    assert_eq!(page.records.len(), 1);
    assert_eq!(governor.used().await.0, 0.0, "listRecords is a read");

    let outcome = publisher
        .delete_record(COLLECTION, "CVE-1")
        .await
        .expect("delete");
    assert!(outcome.found);
    assert_eq!(
        governor.used().await.0,
        1.0,
        "deleteRecord costs PDS_WRITE_DELETE"
    );
}