tangled-api 0.1.0

Lexicon-generated XRPC client for Tangled and AT Protocol APIs
Documentation
//! Tests for the generated lexicon types and the xrpc transport helpers.

use tangled_api::lexicon::com::atproto::repo as atproto_repo;
use tangled_api::lexicon::sh::tangled::repo as tangled_repo;
use tangled_api::xrpc;

/// Unknown fields must survive a deserialize→serialize round-trip so
/// getRecord→putRecord flows never drop data the lexicon doesn't know about.
#[test]
fn record_round_trip_preserves_unknown_fields() {
    let live = serde_json::json!({
        "$type": "sh.tangled.repo",
        "knot": "knot1.tangled.sh",
        "createdAt": "2026-01-01T00:00:00Z",
        "labels": ["at://did:plc:x/sh.tangled.label.definition/abc"],
        "someFutureField": {"nested": true},
    });
    let mut record: tangled_repo::Record =
        serde_json::from_value(live.clone()).unwrap();
    assert_eq!(record.knot, "knot1.tangled.sh");
    assert_eq!(record.r#type.as_deref(), Some(tangled_repo::NSID));

    record.spindle = Some("spindle.example.com".to_string());
    let out = serde_json::to_value(&record).unwrap();
    assert_eq!(out["someFutureField"], live["someFutureField"]);
    assert_eq!(out["labels"], live["labels"]);
    assert_eq!(out["spindle"], "spindle.example.com");
}

#[tokio::test]
async fn send_surfaces_xrpc_error_shape() {
    let mut server = mockito::Server::new_async().await;
    let _m = server
        .mock("GET", mockito::Matcher::Any)
        .with_status(400)
        .with_body(r#"{"error":"RepoNotFound","message":"no such repo"}"#)
        .create_async()
        .await;

    let http = reqwest::Client::new();
    let params = tangled_repo::describe_repo::Params {
        repo_did: "did:web:example.com".to_string(),
    };
    let rb = tangled_repo::describe_repo(&http, &server.url(), &params);
    let err = xrpc::send::<tangled_repo::describe_repo::Output>(rb)
        .await
        .unwrap_err();
    match err {
        xrpc::XrpcError::Status {
            status,
            error,
            message,
            ..
        } => {
            assert_eq!(status.as_u16(), 400);
            assert_eq!(error.as_deref(), Some("RepoNotFound"));
            assert_eq!(message.as_deref(), Some("no such repo"));
        }
        other => panic!("expected Status error, got {other:?}"),
    }
}

#[tokio::test]
async fn query_builder_serializes_params_and_repeats_arrays() {
    let mut server = mockito::Server::new_async().await;
    let m = server
        .mock("GET", "/xrpc/com.atproto.repo.listRecords")
        .match_query(mockito::Matcher::AllOf(vec![
            mockito::Matcher::UrlEncoded("repo".into(), "did:plc:abc".into()),
            mockito::Matcher::UrlEncoded(
                "collection".into(),
                "sh.tangled.repo".into(),
            ),
            mockito::Matcher::UrlEncoded("limit".into(), "100".into()),
        ]))
        .with_body(r#"{"records":[]}"#)
        .create_async()
        .await;

    let http = reqwest::Client::new();
    let params = atproto_repo::list_records::Params {
        repo: "did:plc:abc".to_string(),
        collection: "sh.tangled.repo".to_string(),
        limit: Some(100),
        cursor: None,
        reverse: None,
    };
    let rb = atproto_repo::list_records(&http, &server.url(), &params);
    let out: atproto_repo::list_records::Output = xrpc::send(rb).await.unwrap();
    assert!(out.records.is_empty());
    m.assert_async().await;
}