use std::collections::HashSet;
use reqwest::Method;
use serde::Deserialize;
use shardline_xet_adapter::{XET_REVISION_ROUTE, XET_REVISIONS_ROUTE};
use crate::{
client::XetClient,
error::{SdxError, TransferError},
tree::MetadataClient,
};
const REVISION_RESPONSE_LIMIT: usize = 1152;
const REVISION_PAGE_RESPONSE_LIMIT: usize = 1_153_152;
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Revision {
pub name: String,
pub created_at: u64,
pub updated_at: u64,
}
#[derive(Debug, Deserialize)]
#[cfg_attr(test, derive(serde::Serialize))]
#[serde(rename_all = "camelCase")]
struct RevisionJson {
name: String,
created_at: u64,
updated_at: u64,
}
#[derive(Debug, Deserialize)]
#[cfg_attr(test, derive(serde::Serialize))]
#[serde(rename_all = "camelCase")]
struct RevisionsResponse {
revisions: Vec<RevisionJson>,
#[serde(default)]
next_cursor: Option<String>,
}
#[derive(Debug, Deserialize)]
#[cfg_attr(test, derive(serde::Serialize))]
#[serde(rename_all = "camelCase")]
struct DeleteRevisionResponse {}
impl MetadataClient {
async fn list_revisions(&self) -> Result<Vec<Revision>, SdxError> {
let retry = self.read_retry();
let token = self.tokens.read_token().await?;
let route = self.repo_route(XET_REVISIONS_ROUTE);
let mut revisions = Vec::new();
let mut cursor: Option<String> = None;
let mut cursors = HashSet::new();
loop {
let query: Vec<(String, String)> = cursor
.as_deref()
.map(|c| vec![("cursor".to_owned(), c.to_owned())])
.unwrap_or_default();
let url = crate::tree::build_url(&self.api_base, &route, &query);
let response: RevisionsResponse = self
.send_json(
&retry,
token.token.clone(),
Method::GET,
url,
None,
("list_revisions", REVISION_PAGE_RESPONSE_LIMIT),
)
.await?;
revisions.extend(response.revisions.into_iter().map(|revision| Revision {
name: revision.name,
created_at: revision.created_at,
updated_at: revision.updated_at,
}));
cursor = crate::tree::checked_next_cursor(
"list_revisions",
response.next_cursor,
&mut cursors,
)?;
if cursor.is_none() {
break;
}
}
Ok(revisions)
}
async fn create_revision(&self, rev: &str) -> Result<Revision, SdxError> {
let retry = self.write_retry();
let token = self.tokens.write_token().await?;
let route = self
.repo_route_scope(XET_REVISION_ROUTE)
.replace("{rev}", &crate::tree::encode_path_segment(rev));
let url = crate::tree::build_url(&self.api_base, &route, crate::tree::no_query());
match self
.send_json::<RevisionJson>(
&retry,
token.token,
Method::POST,
url,
None,
("create_revision", REVISION_RESPONSE_LIMIT),
)
.await
{
Ok(revision) => Ok(Revision {
name: revision.name,
created_at: revision.created_at,
updated_at: revision.updated_at,
}),
Err(SdxError::Transfer(TransferError::HttpStatus { status: 409, .. })) => {
Err(SdxError::RevisionExists(rev.to_owned()))
}
Err(error) => Err(error),
}
}
async fn delete_revision(&self, rev: &str) -> Result<(), SdxError> {
let retry = self.write_retry();
let token = self.tokens.write_token().await?;
let route = self
.repo_route_scope(XET_REVISION_ROUTE)
.replace("{rev}", &crate::tree::encode_path_segment(rev));
let url = crate::tree::build_url(&self.api_base, &route, crate::tree::no_query());
let _: DeleteRevisionResponse = self
.send_json(
&retry,
token.token,
Method::DELETE,
url,
None,
("delete_revision", REVISION_RESPONSE_LIMIT),
)
.await?;
Ok(())
}
}
impl XetClient {
pub async fn list_revisions(&self) -> Result<Vec<Revision>, SdxError> {
MetadataClient::from_download(self.download_inner())
.list_revisions()
.await
}
pub async fn create_revision(&self, rev: &str) -> Result<Revision, SdxError> {
MetadataClient::from_download(self.download_inner())
.create_revision(rev)
.await
}
pub async fn delete_revision(&self, rev: &str) -> Result<(), SdxError> {
MetadataClient::from_download(self.download_inner())
.delete_revision(rev)
.await
}
}
#[cfg(test)]
mod tests {
#[test]
fn revision_response_envelopes_cover_maximum_names_and_default_page() {
let name = "\"\\".repeat(256);
let record = super::RevisionJson {
name: name.clone(),
created_at: u64::MAX,
updated_at: u64::MAX,
};
assert!(serde_json::to_vec(&record).unwrap().len() <= super::REVISION_RESPONSE_LIMIT);
let delete = serde_json::json!({ "name": &name, "deleted": false });
assert!(serde_json::to_vec(&delete).unwrap().len() <= super::REVISION_RESPONSE_LIMIT);
#[derive(serde::Serialize)]
#[serde(rename_all = "camelCase")]
struct Page<'wire> {
revisions: Vec<&'wire super::RevisionJson>,
next_cursor: Option<&'wire str>,
}
let page = Page {
revisions: vec![&record; 1000],
next_cursor: Some(&name),
};
assert!(serde_json::to_vec(&page).unwrap().len() <= super::REVISION_PAGE_RESPONSE_LIMIT);
}
use serde_json::json;
use wiremock::{
Mock, MockServer, ResponseTemplate,
matchers::{method, path, query_param},
};
use super::Revision;
use crate::{Auth, RepositoryId, XetClientBuilder};
const READ_TOKEN: &str = "read-token";
async fn build_client(server: &MockServer) -> crate::XetClient {
let auth = Auth::new(
&server.uri(),
RepositoryId {
provider: "github".to_owned(),
owner: "team".to_owned(),
repo: "assets".to_owned(),
revision: "main".to_owned(),
},
)
.unwrap()
.with_api_key("bootstrap".to_owned())
.with_subject("user".to_owned());
let port = server.uri().split(':').next_back().unwrap().to_owned();
XetClientBuilder::new()
.endpoint(format!("xet://127.0.0.1:{port}/github/team/assets/main"))
.auth(auth)
.build()
.unwrap()
}
async fn mock_read_token(server: &MockServer) {
Mock::given(method("GET"))
.and(path("/api/github/team/assets/xet-read-token/main"))
.respond_with(ResponseTemplate::new(200).set_body_json(json!({
"casUrl": server.uri(),
"exp": 4_000_000_000u64,
"accessToken": READ_TOKEN,
})))
.mount(server)
.await;
}
fn revision_json(name: &str) -> serde_json::Value {
json!({"name": name, "createdAt": 1, "updatedAt": 2})
}
#[tokio::test]
async fn pagination_rejects_empty_repeated_and_cyclic_cursors() {
for returned_cursors in [vec![""], vec!["a", "a"], vec!["a", "b", "a"]] {
let server = MockServer::start().await;
mock_read_token(&server).await;
for (index, next) in returned_cursors.iter().enumerate() {
let expected = index.checked_sub(1).map(|i| returned_cursors[i].to_owned());
Mock::given(method("GET"))
.and(path("/api/github/team/assets/revisions"))
.and(move |request: &wiremock::Request| {
request
.url
.query_pairs()
.find(|(key, _)| key == "cursor")
.map(|(_, value)| value.into_owned())
== expected
})
.respond_with(ResponseTemplate::new(200).set_body_json(json!({
"revisions": [], "nextCursor": next
})))
.expect(1)
.mount(&server)
.await;
}
let client = build_client(&server).await;
let result =
tokio::time::timeout(std::time::Duration::from_secs(2), client.list_revisions())
.await
.expect("malformed pagination must terminate");
assert!(
matches!(result, Err(crate::SdxError::Metadata(_))),
"{result:?}"
);
server.verify().await;
}
}
#[tokio::test]
async fn revisions_json_decode_preserves_context_without_retrying_parse_errors() {
let server = MockServer::start().await;
mock_read_token(&server).await;
Mock::given(method("GET"))
.and(path("/api/github/team/assets/revisions"))
.respond_with(ResponseTemplate::new(200).set_body_string("{invalid"))
.expect(1)
.mount(&server)
.await;
let error = build_client(&server)
.await
.list_revisions()
.await
.unwrap_err();
assert!(
matches!(error, crate::SdxError::Metadata(message) if message.starts_with("list_revisions: "))
);
}
#[tokio::test]
async fn revisions_wrong_type_diagnostic_is_bounded_with_context_and_no_retry() {
let server = MockServer::start().await;
mock_read_token(&server).await;
Mock::given(method("GET"))
.and(path("/api/github/team/assets/revisions"))
.respond_with(ResponseTemplate::new(200).set_body_json(json!({
"revisions": [{"name": "main", "createdAt": "x".repeat(100_000), "updatedAt": 1}],
})))
.expect(1)
.mount(&server)
.await;
let error = build_client(&server)
.await
.list_revisions()
.await
.unwrap_err();
assert!(matches!(error, crate::SdxError::Metadata(message)
if message.starts_with("list_revisions: ") && message.len() <= 8 * 1024 + "list_revisions: ".len()
&& message.contains("[truncated; at line 1 column ")));
}
#[tokio::test]
async fn revision_mutations_preserve_path_segment_identity() {
let server = MockServer::start().await;
Mock::given(method("GET"))
.and(path("/api/github/team/assets/xet-write-token/main"))
.respond_with(ResponseTemplate::new(200).set_body_json(json!({
"casUrl": server.uri(), "exp": 4_000_000_000u64,
"accessToken": "write-token",
})))
.mount(&server)
.await;
let client = build_client(&server).await;
for revision in [
"release candidate",
"release+candidate",
"release%candidate",
"็ๆฌ",
"release/candidate",
] {
for verb in ["POST", "DELETE"] {
let expected = revision.to_owned();
let response = if verb == "POST" {
revision_json(revision)
} else {
json!({"deleted": true})
};
Mock::given(method(verb))
.and(move |request: &wiremock::Request| {
request
.url
.path()
.strip_prefix("/api/github/team/assets/revisions/")
.is_some_and(|segment| {
!segment.contains('/')
&& percent_encoding::percent_decode_str(segment)
.decode_utf8()
.is_ok_and(|decoded| decoded == expected)
})
})
.respond_with(ResponseTemplate::new(200).set_body_json(response))
.expect(1)
.mount(&server)
.await;
}
assert_eq!(
client.create_revision(revision).await.unwrap().name,
revision
);
client.delete_revision(revision).await.unwrap();
}
server.verify().await;
}
#[test]
fn revision_is_comparable() {
let a = Revision {
name: "main".to_owned(),
created_at: 1,
updated_at: 2,
};
let b = a.clone();
assert_eq!(a, b);
assert_ne!(
a,
Revision {
name: "other".to_owned(),
..a
}
);
}
#[tokio::test]
async fn list_revisions_follows_next_cursor_until_exhausted() {
let server = MockServer::start().await;
mock_read_token(&server).await;
Mock::given(method("GET"))
.and(path("/api/github/team/assets/revisions"))
.and(query_param("cursor", "two"))
.respond_with(ResponseTemplate::new(200).set_body_json(json!({
"revisions": [revision_json("three"), revision_json("four")],
"nextCursor": null
})))
.mount(&server)
.await;
Mock::given(method("GET"))
.and(path("/api/github/team/assets/revisions"))
.respond_with(ResponseTemplate::new(200).set_body_json(json!({
"revisions": [revision_json("one"), revision_json("two")],
"nextCursor": "two"
})))
.mount(&server)
.await;
let client = build_client(&server).await;
let revisions = client.list_revisions().await.unwrap();
let names: Vec<&str> = revisions.iter().map(|r| r.name.as_str()).collect();
assert_eq!(names, vec!["one", "two", "three", "four"]);
}
#[tokio::test]
async fn list_revisions_single_page_without_cursor() {
let server = MockServer::start().await;
mock_read_token(&server).await;
Mock::given(method("GET"))
.and(path("/api/github/team/assets/revisions"))
.respond_with(ResponseTemplate::new(200).set_body_json(json!({
"revisions": [revision_json("main")],
"nextCursor": null
})))
.mount(&server)
.await;
let client = build_client(&server).await;
let revisions = client.list_revisions().await.unwrap();
let names: Vec<&str> = revisions.iter().map(|r| r.name.as_str()).collect();
assert_eq!(names, vec!["main"]);
}
}