use std::collections::HashSet;
use reqwest::Method;
use serde::Deserialize;
use shardline_xet_adapter::{XET_PATH_ROUTE, XET_TREE_ROUTE};
use crate::{
auth::{RepositoryId, TokenService},
client::XetClient,
error::SdxError,
retry::{RetryContext, RetryMarkers, RetryPolicy, RetryScope},
session::DownloadSessionInner,
transfer::TransferClient,
};
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct PathEntry {
pub path: String,
pub file_id: String,
pub size: u64,
pub updated_at: u64,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct DirEntry {
pub path: String,
pub is_dir: bool,
pub file_id: Option<String>,
pub size: Option<u64>,
pub updated_at: Option<u64>,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct DirListing {
pub entries: Vec<DirEntry>,
pub next_cursor: Option<String>,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct RegisterResult {
pub entry: PathEntry,
pub created: bool,
}
const PATH_RESPONSE_LIMIT: usize = 8_450;
fn tree_page_response_limit(limit: Option<usize>) -> usize {
let entries = limit.unwrap_or(1000).min(10_000);
entries
.saturating_mul(PATH_RESPONSE_LIMIT)
.saturating_add(8_450)
}
#[derive(Debug, Deserialize)]
#[cfg_attr(test, derive(serde::Serialize))]
#[serde(rename_all = "camelCase")]
struct ResolveResponse {
path: String,
file_id: String,
size: u64,
updated_at: u64,
}
#[derive(Debug, Deserialize)]
#[cfg_attr(test, derive(serde::Serialize))]
#[serde(rename_all = "camelCase")]
struct ListEntry {
path: String,
is_dir: bool,
file_id: Option<String>,
size: Option<u64>,
updated_at: Option<u64>,
}
#[derive(Debug, Deserialize)]
#[cfg_attr(test, derive(serde::Serialize))]
#[serde(rename_all = "camelCase")]
struct ListResponse {
entries: Vec<ListEntry>,
next_cursor: Option<String>,
}
#[derive(Debug, Deserialize)]
#[cfg_attr(test, derive(serde::Serialize))]
#[serde(rename_all = "camelCase")]
struct RegisterResponse {
path: String,
file_id: String,
size: u64,
updated_at: u64,
created: bool,
}
#[derive(Debug, Deserialize)]
#[cfg_attr(test, derive(serde::Serialize))]
#[serde(rename_all = "camelCase")]
struct DeletePathResponse {
deleted: u64,
}
#[derive(Clone)]
pub(crate) struct MetadataClient {
pub(crate) transfer: TransferClient,
pub(crate) tokens: TokenService,
pub(crate) api_base: String,
pub(crate) repository: RepositoryId,
pub(crate) retry_policy: RetryPolicy,
}
impl MetadataClient {
pub(crate) fn from_download(inner: &DownloadSessionInner) -> Self {
Self {
transfer: inner.transfer.clone(),
tokens: inner.tokens.clone(),
api_base: inner.api_base.clone(),
repository: inner.repository.clone(),
retry_policy: inner.retry_policy.clone(),
}
}
pub(crate) fn from_upload(
transfer: &TransferClient,
tokens: &TokenService,
api_base: &str,
repository: &RepositoryId,
retry_policy: &RetryPolicy,
) -> Self {
Self {
transfer: transfer.clone(),
tokens: tokens.clone(),
api_base: api_base.to_owned(),
repository: repository.clone(),
retry_policy: retry_policy.clone(),
}
}
pub(crate) fn read_retry(&self) -> RetryContext {
RetryContext {
policy: self.retry_policy.clone(),
tokens: Some(self.tokens.clone()),
scope: RetryScope::Read,
markers: RetryMarkers {
retry_on_403: true,
..RetryMarkers::default()
},
}
}
pub(crate) fn write_retry(&self) -> RetryContext {
RetryContext {
policy: self.retry_policy.clone(),
tokens: Some(self.tokens.clone()),
scope: RetryScope::Write,
markers: RetryMarkers {
retry_on_403: true,
..RetryMarkers::default()
},
}
}
pub(crate) fn repo_route(&self, template: &str) -> String {
template
.replace(
"{provider}",
&encode_path_segment(&self.repository.provider),
)
.replace("{owner}", &encode_path_segment(&self.repository.owner))
.replace("{repo}", &encode_path_segment(&self.repository.repo))
.replace("{rev}", &encode_path_segment(&self.repository.revision))
}
pub(crate) fn repo_route_scope(&self, template: &str) -> String {
template
.replace(
"{provider}",
&encode_path_segment(&self.repository.provider),
)
.replace("{owner}", &encode_path_segment(&self.repository.owner))
.replace("{repo}", &encode_path_segment(&self.repository.repo))
}
pub(crate) async fn send_json<T: serde::de::DeserializeOwned + Send + 'static>(
&self,
retry: &RetryContext,
token: String,
method: Method,
url: String,
body: Option<serde_json::Value>,
response: (&'static str, usize),
) -> Result<T, SdxError> {
let transfer = self.transfer.clone();
let decoded = retry
.run(token, move |tok| {
let transfer = transfer.clone();
let url = url.clone();
let method = method.clone();
let body = body.clone();
async move {
transfer
.request_json::<T>(&method, &url, &tok, body.as_ref(), response.1)
.await
}
})
.await?;
decoded.map_err(|error| metadata_parse(response.0, &error))
}
async fn resolve_path(&self, path: &str) -> Result<PathEntry, SdxError> {
let retry = self.read_retry();
let token = self.tokens.read_token().await?;
let route = self.repo_route(XET_TREE_ROUTE);
let url = build_url(&self.api_base, &route, &[("path", path)]);
let response: ResolveResponse = self
.send_json(
&retry,
token.token,
Method::GET,
url,
None,
("resolve_path", PATH_RESPONSE_LIMIT),
)
.await?;
Ok(PathEntry {
path: response.path,
file_id: response.file_id,
size: response.size,
updated_at: response.updated_at,
})
}
async fn list_paged(
&self,
prefix: &str,
limit: Option<usize>,
cursor: Option<&str>,
) -> Result<DirListing, SdxError> {
let retry = self.read_retry();
let token = self.tokens.read_token().await?;
let route = self.repo_route(XET_TREE_ROUTE);
let mut query: Vec<(String, String)> = vec![("prefix".to_owned(), prefix.to_owned())];
if let Some(limit) = limit {
query.push(("limit".to_owned(), limit.to_string()));
}
if let Some(cursor) = cursor {
query.push(("cursor".to_owned(), cursor.to_owned()));
}
let url = build_url(&self.api_base, &route, &query);
let response: ListResponse = self
.send_json(
&retry,
token.token,
Method::GET,
url,
None,
("list_dir", tree_page_response_limit(limit)),
)
.await?;
Ok(DirListing {
entries: response
.entries
.into_iter()
.map(|entry| DirEntry {
path: entry.path,
is_dir: entry.is_dir,
file_id: entry.file_id,
size: entry.size,
updated_at: entry.updated_at,
})
.collect(),
next_cursor: response.next_cursor,
})
}
pub(crate) async fn register_path(
&self,
remote: &str,
file_id: &str,
) -> Result<RegisterResult, SdxError> {
validate_mutation_path(remote)?;
let retry = self.write_retry();
let token = self.tokens.write_token().await?;
let route = self.repo_route(XET_PATH_ROUTE);
let url = build_url(&self.api_base, &route, no_query());
let url = url.replace("{*path}", &encode_path_segments(remote));
let response: RegisterResponse = self
.send_json(
&retry,
token.token,
Method::PUT,
url,
Some(serde_json::json!({ "fileId": file_id })),
("register_path", PATH_RESPONSE_LIMIT),
)
.await?;
Ok(RegisterResult {
entry: PathEntry {
path: response.path,
file_id: response.file_id,
size: response.size,
updated_at: response.updated_at,
},
created: response.created,
})
}
async fn delete_path(&self, remote: &str, recursive: bool) -> Result<u64, SdxError> {
validate_mutation_path(remote)?;
let retry = self.write_retry();
let token = self.tokens.write_token().await?;
let route = self.repo_route(XET_PATH_ROUTE);
let mut url = build_url(&self.api_base, &route, no_query());
url = url.replace("{*path}", &encode_path_segments(remote));
if recursive {
url.push_str("?recursive=true");
}
let response: DeletePathResponse = self
.send_json(
&retry,
token.token,
Method::DELETE,
url,
None,
("delete_path", PATH_RESPONSE_LIMIT),
)
.await?;
Ok(response.deleted)
}
}
impl XetClient {
pub async fn resolve_path(&self, path: &str) -> Result<PathEntry, SdxError> {
MetadataClient::from_download(self.download_inner())
.resolve_path(path)
.await
}
pub async fn list_dir(&self, prefix: &str) -> Result<DirListing, SdxError> {
MetadataClient::from_download(self.download_inner())
.list_paged(prefix, None, None)
.await
}
pub async fn list_dir_paged(
&self,
prefix: &str,
cursor: Option<&str>,
) -> Result<DirListing, SdxError> {
MetadataClient::from_download(self.download_inner())
.list_paged(prefix, None, cursor)
.await
}
pub async fn list_dir_all(&self, prefix: &str) -> Result<Vec<DirEntry>, SdxError> {
let client = MetadataClient::from_download(self.download_inner());
let mut all = Vec::new();
let mut seen = HashSet::new();
let mut cursor: Option<String> = None;
let mut cursors = HashSet::new();
loop {
let page = client.list_paged(prefix, None, cursor.as_deref()).await?;
for entry in page.entries {
if seen.insert(entry.path.clone()) {
all.push(entry);
}
}
cursor = checked_next_cursor("list_dir_all", page.next_cursor, &mut cursors)?;
if cursor.is_none() {
break;
}
}
Ok(all)
}
pub async fn register_path(
&self,
remote: &str,
file_id: &str,
) -> Result<RegisterResult, SdxError> {
MetadataClient::from_download(self.download_inner())
.register_path(remote, file_id)
.await
}
pub async fn delete_path(&self, remote: &str, recursive: bool) -> Result<u64, SdxError> {
MetadataClient::from_download(self.download_inner())
.delete_path(remote, recursive)
.await
}
}
pub(crate) const fn no_query() -> &'static [(&'static str, &'static str)] {
&[]
}
pub(crate) fn build_url<K: AsRef<str>, V: AsRef<str>>(
api_base: &str,
route: &str,
query: &[(K, V)],
) -> String {
let mut url = format!("{}{}", api_base.trim_end_matches('/'), route);
if !query.is_empty() {
url.push('?');
for (index, (key, value)) in query.iter().enumerate() {
if index > 0 {
url.push('&');
}
url.push_str(key.as_ref());
url.push('=');
url.push_str(&encode_query(value.as_ref()));
}
}
url
}
pub(crate) fn encode_query(value: &str) -> String {
url::form_urlencoded::byte_serialize(value.as_bytes()).collect()
}
const PATH_SEGMENT_PCHAR: &percent_encoding::AsciiSet = &percent_encoding::NON_ALPHANUMERIC
.remove(b'-')
.remove(b'.')
.remove(b'_')
.remove(b'~')
.remove(b'!')
.remove(b'$')
.remove(b'&')
.remove(b'\'')
.remove(b'(')
.remove(b')')
.remove(b'*')
.remove(b'+')
.remove(b',')
.remove(b';')
.remove(b'=')
.remove(b':')
.remove(b'@');
pub(crate) fn encode_path_segment(segment: &str) -> String {
percent_encoding::utf8_percent_encode(segment, PATH_SEGMENT_PCHAR).to_string()
}
pub(crate) fn encode_path_segments(path: &str) -> String {
path.split('/')
.map(encode_path_segment)
.collect::<Vec<_>>()
.join("/")
}
fn validate_mutation_path(remote: &str) -> Result<(), SdxError> {
if remote
.split('/')
.any(|segment| matches!(segment, "." | ".."))
{
return Err(SdxError::Metadata(
"path mutation: dot segments are not allowed".to_owned(),
));
}
Ok(())
}
pub(crate) fn checked_next_cursor(
context: &str,
next: Option<String>,
seen: &mut HashSet<String>,
) -> Result<Option<String>, SdxError> {
if let Some(cursor) = &next
&& (cursor.is_empty() || !seen.insert(cursor.clone()))
{
return Err(SdxError::Metadata(format!(
"{context}: empty or repeated pagination cursor"
)));
}
Ok(next)
}
pub(crate) fn metadata_parse(context: &str, error: &impl std::fmt::Display) -> SdxError {
SdxError::Metadata(format!("{context}: {error}"))
}
#[cfg(test)]
mod tests {
#[test]
fn metadata_response_envelopes_cover_maximum_legal_paths_and_pages() {
let path = "\"".repeat(4096);
let entry = super::ListEntry {
path: path.clone(),
is_dir: false,
file_id: Some("a".repeat(64)),
size: Some(u64::MAX),
updated_at: Some(u64::MAX),
};
let resolve = super::ResolveResponse {
path: path.clone(),
file_id: "a".repeat(64),
size: u64::MAX,
updated_at: u64::MAX,
};
let register = super::RegisterResponse {
path: path.clone(),
file_id: "a".repeat(64),
size: u64::MAX,
updated_at: u64::MAX,
created: false,
};
assert!(serde_json::to_vec(&resolve).unwrap().len() <= super::PATH_RESPONSE_LIMIT);
assert!(serde_json::to_vec(®ister).unwrap().len() <= super::PATH_RESPONSE_LIMIT);
let delete = serde_json::json!({ "path": &path, "deleted": u64::MAX, "recursive": false });
assert!(serde_json::to_vec(&delete).unwrap().len() <= super::PATH_RESPONSE_LIMIT);
#[derive(serde::Serialize)]
#[serde(rename_all = "camelCase")]
struct Page<'wire> {
entries: Vec<&'wire super::ListEntry>,
next_cursor: Option<&'wire str>,
}
struct Count(usize);
impl std::io::Write for Count {
fn write(&mut self, bytes: &[u8]) -> std::io::Result<usize> {
self.0 = self
.0
.checked_add(bytes.len())
.ok_or_else(|| std::io::Error::other("byte counter overflow"))?;
Ok(bytes.len())
}
fn flush(&mut self) -> std::io::Result<()> {
Ok(())
}
}
for limit in [None, Some(1), Some(10_000)] {
let page = Page {
entries: vec![&entry; limit.unwrap_or(1000)],
next_cursor: Some(&path),
};
let mut count = Count(0);
serde_json::to_writer(&mut count, &page).unwrap();
assert!(count.0 <= super::tree_page_response_limit(limit));
}
}
use std::collections::HashSet;
use serde_json::json;
use wiremock::{
Mock, MockServer, ResponseTemplate,
matchers::{method, path, path_regex, query_param},
};
use super::{encode_path_segments, encode_query};
use crate::{Auth, RepositoryId, XetClientBuilder};
const READ_TOKEN: &str = "read-token";
const WRITE_TOKEN: &str = "write-token";
const BOOTSTRAP_KEY: &str = "bootstrap";
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_KEY.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;
}
async fn mock_write_token(server: &MockServer) {
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;
}
#[tokio::test]
async fn resolve_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/tree/main"))
.respond_with(ResponseTemplate::new(200).set_body_string("{invalid"))
.expect(1)
.mount(&server)
.await;
let error = build_client(&server)
.await
.resolve_path("file.txt")
.await
.unwrap_err();
assert!(
matches!(error, crate::SdxError::Metadata(message) if message.starts_with("resolve_path: "))
);
}
#[test]
fn encode_query_escapes_reserved_characters() {
assert_eq!(encode_query("data/model.pt"), "data%2Fmodel.pt");
assert_eq!(encode_query("a b.txt"), "a+b.txt");
assert_eq!(encode_query("plain"), "plain");
}
#[test]
fn encode_path_segments_preserves_separators() {
assert_eq!(encode_path_segments("data/model.pt"), "data/model.pt");
assert_eq!(encode_path_segments("a b/c.txt"), "a%20b/c.txt");
}
#[tokio::test]
async fn mutation_dot_segments_never_reach_another_remote_path() {
let server = MockServer::start().await;
mock_write_token(&server).await;
Mock::given(method("DELETE"))
.and(path_regex(r"/api/github/team/assets/path/main/.*"))
.respond_with(ResponseTemplate::new(200).set_body_json(json!({"deleted": 1})))
.mount(&server)
.await;
Mock::given(method("PUT"))
.and(path_regex(r"/api/github/team/assets/path/main/.*"))
.respond_with(ResponseTemplate::new(200).set_body_json(json!({
"path": "victim", "fileId": "0".repeat(64), "size": 0,
"updatedAt": 1, "created": false,
})))
.mount(&server)
.await;
let client = build_client(&server).await;
for remote in ["directory/../victim", "directory/./victim", ".", ".."] {
assert!(matches!(
client.delete_path(remote, false).await,
Err(crate::SdxError::Metadata(_))
));
assert!(matches!(
client.register_path(remote, &"0".repeat(64)).await,
Err(crate::SdxError::Metadata(_))
));
}
assert!(server.received_requests().await.unwrap().is_empty());
}
#[tokio::test]
async fn encoded_endpoint_identity_survives_builder_auth_and_metadata_routes() {
let server = MockServer::start().await;
let revision = "release candidate+/%#?版本";
let repository = RepositoryId {
provider: "github".to_owned(),
owner: "team".to_owned(),
repo: "assets".to_owned(),
revision: revision.to_owned(),
};
for endpoint in ["xet-read-token", "tree"] {
let expected_revision = revision.to_owned();
let response = if endpoint == "tree" {
json!({"entries": [], "nextCursor": null})
} else {
json!({"casUrl": server.uri(), "exp": 4_000_000_000u64, "accessToken": READ_TOKEN})
};
Mock::given(method("GET"))
.and(move |request: &wiremock::Request| {
request
.url
.path()
.strip_prefix(&format!("/api/github/team/assets/{endpoint}/"))
.is_some_and(|segment| {
!segment.contains('/')
&& percent_encoding::percent_decode_str(segment)
.decode_utf8()
.is_ok_and(|decoded| decoded == expected_revision)
})
})
.respond_with(ResponseTemplate::new(200).set_body_json(response))
.expect(1)
.mount(&server)
.await;
}
let auth = Auth::new(&server.uri(), repository)
.unwrap()
.with_api_key(BOOTSTRAP_KEY.to_owned());
let endpoint = crate::XetUrl::parse(&format!(
"xet://127.0.0.1:{}/github/team/assets/release%20candidate+%2F%25%23%3F%E7%89%88%E6%9C%AC",
server.address().port()
)).unwrap();
let client = XetClientBuilder::new()
.endpoint(endpoint.endpoint_url())
.auth(auth)
.build()
.unwrap();
assert!(client.list_dir_all("").await.unwrap().is_empty());
server.verify().await;
}
#[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/tree/main"))
.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!({
"entries": [], "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_dir_all(""))
.await
.expect("malformed pagination must terminate");
assert!(
matches!(result, Err(crate::SdxError::Metadata(_))),
"{result:?}"
);
server.verify().await;
}
}
#[test]
fn encode_path_segments_round_trips_spaces_plus_percent_unicode() {
let original = "a b.txt";
let encoded = encode_path_segments(original);
assert_eq!(encoded, "a%20b.txt");
assert_ne!(
encoded, "a+b.txt",
"space must not be encoded as '+' in a path segment"
);
assert_eq!(encode_path_segments("x+y.txt"), "x+y.txt");
assert_eq!(encode_path_segments("100%done.txt"), "100%25done.txt");
assert_eq!(encode_path_segments("café.txt"), "caf%C3%A9.txt");
let path = "dir with space/sub dir/100% caf\u{e9}+x.txt";
let encoded = encode_path_segments(path);
let round_tripped = encoded
.split('/')
.map(|segment| {
percent_encoding::percent_decode_str(segment)
.decode_utf8()
.expect("encoded segments must be valid UTF-8")
.into_owned()
})
.collect::<Vec<_>>()
.join("/");
assert_eq!(round_tripped, path);
}
#[tokio::test]
async fn list_dir_all_walks_pages_and_dedups() {
let server = MockServer::start().await;
mock_read_token(&server).await;
Mock::given(method("GET"))
.and(path("/api/github/team/assets/tree/main"))
.and(query_param("cursor", "z"))
.and(|request: &wiremock::Request| {
request
.headers
.get("accept")
.and_then(|value| value.to_str().ok())
.is_some_and(|value| {
value.starts_with(shardline_xet_adapter::XET_METADATA_ACCEPT)
})
})
.respond_with(ResponseTemplate::new(200).set_body_json(json!({
"entries": [
{"path": "b.txt", "isDir": false, "fileId": "b", "size": 1, "updatedAt": 1},
{"path": "dir/", "isDir": true, "fileId": null, "size": null, "updatedAt": null}
],
"nextCursor": null
})))
.mount(&server)
.await;
Mock::given(method("GET"))
.and(path("/api/github/team/assets/tree/main"))
.and(|request: &wiremock::Request| {
request
.headers
.get("accept")
.and_then(|value| value.to_str().ok())
.is_some_and(|value| {
value.starts_with(shardline_xet_adapter::XET_METADATA_ACCEPT)
})
})
.respond_with(ResponseTemplate::new(200).set_body_json(json!({
"entries": [
{"path": "a.txt", "isDir": false, "fileId": "a", "size": 1, "updatedAt": 1},
{"path": "dir/", "isDir": true, "fileId": null, "size": null, "updatedAt": null}
],
"nextCursor": "z"
})))
.mount(&server)
.await;
let client = build_client(&server).await;
let all = client.list_dir_all("").await.unwrap();
let paths: Vec<String> = all.iter().map(|entry| entry.path.clone()).collect();
let unique: HashSet<String> = paths.iter().cloned().collect();
assert_eq!(
paths.len(),
unique.len(),
"list_dir_all must deduplicate: {paths:?}"
);
assert!(all.iter().any(|entry| entry.path == "a.txt"));
assert!(all.iter().any(|entry| entry.path == "b.txt"));
assert!(all.iter().any(|entry| entry.path == "dir/" && entry.is_dir));
assert_eq!(all.len(), 3);
}
#[tokio::test]
async fn register_path_403_surfaces_forbidden() {
let server = MockServer::start().await;
mock_write_token(&server).await;
Mock::given(method("PUT"))
.and(path_regex(r"/api/github/team/assets/path/main/.*"))
.respond_with(
ResponseTemplate::new(403).set_body_json(json!({"error": "insufficient scope"})),
)
.mount(&server)
.await;
let client = build_client(&server).await;
let err = client
.register_path("a/b.txt", &"0".repeat(64))
.await
.unwrap_err();
assert!(matches!(
err,
crate::error::SdxError::Transfer(crate::error::TransferError::Forbidden(_))
));
}
#[tokio::test]
async fn resolve_path_404_surfaces_not_found() {
let server = MockServer::start().await;
mock_read_token(&server).await;
Mock::given(method("GET"))
.and(path("/api/github/team/assets/tree/main"))
.respond_with(ResponseTemplate::new(404).set_body_json(json!({"error": "not found"})))
.mount(&server)
.await;
let client = build_client(&server).await;
let err = client.resolve_path("missing.txt").await.unwrap_err();
assert!(matches!(
err,
crate::error::SdxError::Transfer(crate::error::TransferError::NotFound(_))
));
}
}