#![forbid(unsafe_code)]
#![deny(missing_docs)]
#![doc = "Transport-neutral acquisition seam and deterministic fixture transport."]
#![doc = ""]
#![doc = "An adapter receives an exact caller-selected URL, enforces caller-provided"]
#![doc = "byte/time bounds, writes artifacts to a transaction-owned destination, and"]
#![doc = "returns typed `Success | NotFound | Failure` without release or fallback"]
#![doc = "policy. Downloaded bytes are data and are never executed."]
use std::collections::HashMap;
use std::fmt;
use std::fs;
use std::path::Path;
use std::sync::atomic::{AtomicBool, AtomicU64, Ordering};
use std::sync::{Arc, Mutex};
use std::time::{Duration, Instant};
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct AcquisitionRequest {
url: String,
}
impl AcquisitionRequest {
pub fn new(url: impl Into<String>) -> Result<Self, AcquisitionError> {
let url = url.into();
if url.is_empty() || url.chars().any(char::is_control) {
return Err(AcquisitionError::invalid(
"URL is empty or has control characters",
));
}
if !(url.starts_with("http://") || url.starts_with("https://")) {
return Err(AcquisitionError::invalid(
"URL must use http:// or https://",
));
}
if url.len() > 8192 {
return Err(AcquisitionError::invalid("URL exceeds bound"));
}
Ok(Self { url })
}
pub fn url(&self) -> &str {
&self.url
}
pub fn redacted(&self) -> String {
redact_url(&self.url)
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct FetchLimits {
pub max_metadata_bytes: usize,
pub max_artifact_bytes: u64,
pub connect_timeout: Duration,
pub total_timeout: Duration,
}
impl Default for FetchLimits {
fn default() -> Self {
Self {
max_metadata_bytes: 256 * 1024,
max_artifact_bytes: 128 * 1024 * 1024,
connect_timeout: Duration::from_secs(10),
total_timeout: Duration::from_secs(120),
}
}
}
impl FetchLimits {
pub fn validate(&self) -> Result<(), AcquisitionError> {
if self.max_metadata_bytes == 0 || self.max_metadata_bytes > 16 * 1024 * 1024 {
return Err(AcquisitionError::invalid("metadata bound out of range"));
}
if self.max_artifact_bytes == 0 {
return Err(AcquisitionError::invalid("artifact bound must be positive"));
}
if self.total_timeout.is_zero() || self.connect_timeout.is_zero() {
return Err(AcquisitionError::invalid("timeouts must be positive"));
}
if self.connect_timeout > self.total_timeout {
return Err(AcquisitionError::invalid(
"connect timeout must not exceed total timeout",
));
}
Ok(())
}
pub fn new(
max_metadata_bytes: usize,
max_artifact_bytes: u64,
connect_timeout: Duration,
total_timeout: Duration,
) -> Result<Self, AcquisitionError> {
let limits = Self {
max_metadata_bytes,
max_artifact_bytes,
connect_timeout,
total_timeout,
};
limits.validate()?;
Ok(limits)
}
pub fn effective(
&self,
adapter_connect_ceiling: Duration,
adapter_total_ceiling: Duration,
) -> (Duration, Duration) {
let connect = std::cmp::min(self.connect_timeout, adapter_connect_ceiling);
let total = std::cmp::min(self.total_timeout, adapter_total_ceiling);
(connect, total)
}
}
#[derive(Debug, Default)]
pub struct CancelFlag {
cancelled: AtomicBool,
}
impl CancelFlag {
pub fn new() -> Self {
Self::default()
}
pub fn cancel(&self) {
self.cancelled.store(true, Ordering::SeqCst);
}
pub fn is_cancelled(&self) -> bool {
self.cancelled.load(Ordering::SeqCst)
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum FetchOutcome<T> {
Success(T),
NotFound,
}
impl<T> FetchOutcome<T> {
pub fn success(self) -> Option<T> {
match self {
Self::Success(v) => Some(v),
Self::NotFound => None,
}
}
pub fn is_success(&self) -> bool {
matches!(self, Self::Success(_))
}
pub fn is_not_found(&self) -> bool {
matches!(self, Self::NotFound)
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct MetadataBytes {
bytes: Vec<u8>,
}
impl MetadataBytes {
pub fn bytes(&self) -> &[u8] {
&self.bytes
}
pub fn len(&self) -> usize {
self.bytes.len()
}
pub fn is_empty(&self) -> bool {
self.bytes.is_empty()
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct ArtifactEvidence {
pub bytes_written: u64,
}
impl ArtifactEvidence {
pub fn bytes_written(&self) -> u64 {
self.bytes_written
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
#[non_exhaustive]
pub enum AcquisitionError {
InvalidInput(String),
Transport(String),
TooLarge {
limit: u64,
},
Timeout {
phase: &'static str,
},
Cancelled,
Io(String),
Unavailable(String),
}
impl AcquisitionError {
pub(crate) fn invalid(detail: impl Into<String>) -> Self {
Self::InvalidInput(bound_detail(detail.into()))
}
pub(crate) fn transport_redacted(detail: impl Into<String>) -> Self {
Self::Transport(bound_detail(detail.into()))
}
#[doc(hidden)]
pub fn __adapter_unavailable(detail: impl Into<String>) -> Self {
Self::Unavailable(bound_detail(detail.into()))
}
pub(crate) fn io(operation: &'static str, source: std::io::Error) -> Self {
Self::Io(bound_detail(format!("{operation}: {source}")))
}
pub fn is_unavailable(&self) -> bool {
matches!(self, Self::Unavailable(_))
}
}
impl fmt::Display for AcquisitionError {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
Self::InvalidInput(d) => write!(f, "invalid acquisition input: {d}"),
Self::Transport(d) => write!(f, "acquisition transport failed: {d}"),
Self::TooLarge { limit } => write!(f, "response exceeded bound ({limit} bytes)"),
Self::Timeout { phase } => write!(f, "acquisition timed out ({phase})"),
Self::Cancelled => write!(f, "acquisition cancelled"),
Self::Io(d) => write!(f, "acquisition I/O failed: {d}"),
Self::Unavailable(d) => write!(f, "acquisition transport unavailable: {d}"),
}
}
}
impl std::error::Error for AcquisitionError {}
fn bound_detail(s: String) -> String {
truncate_utf8_bytes(s, 512)
}
fn truncate_utf8_bytes(mut s: String, max: usize) -> String {
if s.len() > max {
let mut end = max;
while !s.is_char_boundary(end) {
end -= 1;
}
s.truncate(end);
}
s
}
pub fn redact_url(url: &str) -> String {
let mut out = url.to_string();
if let Some(scheme_end) = out.find("://") {
let after = scheme_end + 3;
if let Some(at) = out[after..].find('@') {
let at_abs = after + at;
out = format!("{}://<redacted>@{}", &url[..scheme_end], &url[at_abs + 1..]);
}
}
if let Some(h) = out.find('#') {
out.truncate(h);
out.push_str("#<redacted>");
}
if let Some(q) = out.find('?') {
out.truncate(q);
out.push_str("?<redacted>");
}
if out.len() > 256 {
let mut end = 256;
while !out.is_char_boundary(end) {
end -= 1;
}
out.truncate(end);
out.push('…');
}
out
}
#[doc(hidden)]
pub fn __scrub_upstream_text(text: &str) -> String {
let mut out = text.to_string();
let mut search_from: usize = 0;
while search_from < out.len() {
let Some(rel_scheme) = out[search_from..].find("://") else {
break;
};
let scheme = search_from + rel_scheme;
let after = scheme + 3;
let Some(rel_at) = out[after..].find('@') else {
break;
};
let at_abs = after + rel_at;
if out[after..at_abs].contains("://") {
search_from = after;
continue;
}
if at_abs - after > 512 {
break;
}
out.replace_range(after..at_abs, "<redacted>");
search_from = after + "<redacted>".len() + 1;
}
if let Some(q) = out.find('?') {
let suffix = &out[q..];
if suffix.contains('=') || suffix.contains('&') {
out.truncate(q);
out.push_str("?<redacted>");
}
}
if out.len() > 512 {
let mut end = 512;
while !out.is_char_boundary(end) {
end -= 1;
}
out.truncate(end);
}
out
}
#[doc(hidden)]
pub const __TEMP_COLLISION_BOUND: u32 = 32;
#[doc(hidden)]
pub fn __acquire_exclusive_temp(
parent: &Path,
prefix: &str,
) -> Result<(std::fs::File, std::path::PathBuf), AcquisitionError> {
use std::fs::OpenOptions;
for _ in 0..__TEMP_COLLISION_BOUND {
let nonce = NEXT_TEMP_NONCE.fetch_add(1, Ordering::Relaxed);
let nanos = std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.map(|d| d.as_nanos())
.unwrap_or(0);
let candidate = parent.join(format!(
".{prefix}-{}-{nanos}-{nonce}.part",
std::process::id()
));
let mut opts = OpenOptions::new();
opts.write(true).create_new(true);
#[cfg(unix)]
{
use std::os::unix::fs::OpenOptionsExt;
opts.mode(0o600);
}
match opts.open(&candidate) {
Ok(file) => {
#[cfg(unix)]
{
use std::os::unix::fs::PermissionsExt;
let mut perms = file
.metadata()
.map_err(|e| AcquisitionError::io("reading part permissions", e))?
.permissions();
if perms.mode() & 0o777 != 0o600 {
perms.set_mode(0o600);
std::fs::set_permissions(&candidate, perms)
.map_err(|e| AcquisitionError::io("securing part file", e))?;
}
}
return Ok((file, candidate));
}
Err(e) if e.kind() == std::io::ErrorKind::AlreadyExists => continue,
Err(e) => return Err(AcquisitionError::io("creating part file", e)),
}
}
Err(AcquisitionError::io(
"creating part file",
std::io::Error::new(
std::io::ErrorKind::AlreadyExists,
"too many temporary name collisions",
),
))
}
#[doc(hidden)]
pub fn __promote_no_clobber(tmp: &Path, dest: &Path) -> Result<(), AcquisitionError> {
__promote_no_clobber_with(tmp, dest, |path| fs::remove_file(path))
}
fn __promote_no_clobber_with(
tmp: &Path,
dest: &Path,
remove_temp: impl FnOnce(&Path) -> std::io::Result<()>,
) -> Result<(), AcquisitionError> {
match std::fs::hard_link(tmp, dest) {
Ok(()) => {
let _ = remove_temp(tmp);
Ok(())
}
Err(e) if e.kind() == std::io::ErrorKind::AlreadyExists => Err(AcquisitionError::invalid(
"artifact destination already exists; refusing to overwrite",
)),
Err(e) => Err(AcquisitionError::io("promoting artifact", e)),
}
}
#[doc(hidden)]
pub fn __remove_owned_temp(path: &Path) {
let _ = std::fs::remove_file(path);
}
pub trait AcquisitionTransport {
fn fetch_metadata(
&self,
request: &AcquisitionRequest,
limits: FetchLimits,
cancel: &CancelFlag,
) -> Result<FetchOutcome<MetadataBytes>, AcquisitionError>;
fn fetch_artifact(
&self,
request: &AcquisitionRequest,
dest: &Path,
limits: FetchLimits,
cancel: &CancelFlag,
) -> Result<FetchOutcome<ArtifactEvidence>, AcquisitionError>;
}
static NEXT_TEMP_NONCE: AtomicU64 = AtomicU64::new(0);
#[derive(Debug, Clone)]
pub struct FixtureResponse {
kind: FixtureKind,
}
#[derive(Debug, Clone)]
enum FixtureKind {
Body(Vec<u8>),
NotFound,
Failure,
Unavailable,
Truncated { prefix_len: usize },
Slow { body: Vec<u8>, delay: Duration },
}
impl FixtureResponse {
pub fn body(bytes: impl Into<Vec<u8>>) -> Self {
Self {
kind: FixtureKind::Body(bytes.into()),
}
}
pub fn not_found() -> Self {
Self {
kind: FixtureKind::NotFound,
}
}
pub fn failure(_detail: impl Into<String>) -> Self {
Self {
kind: FixtureKind::Failure,
}
}
pub fn truncated(prefix_len: usize) -> Self {
Self {
kind: FixtureKind::Truncated { prefix_len },
}
}
pub fn slow(body: Vec<u8>, delay: Duration) -> Self {
Self {
kind: FixtureKind::Slow { body, delay },
}
}
pub fn unavailable() -> Self {
Self {
kind: FixtureKind::Unavailable,
}
}
}
#[derive(Debug, Default)]
pub struct FixtureTransport {
routes: Mutex<HashMap<String, FixtureResponse>>,
}
impl FixtureTransport {
pub fn new() -> Self {
Self::default()
}
pub fn route(&self, url: &str, response: FixtureResponse) {
self.routes
.lock()
.expect("fixture lock")
.insert(url.to_string(), response);
}
fn lookup(&self, url: &str) -> Result<FixtureResponse, AcquisitionError> {
self.routes
.lock()
.expect("fixture lock")
.get(url)
.cloned()
.ok_or_else(|| {
AcquisitionError::transport_redacted(format!(
"no fixture route for {}",
redact_url(url)
))
})
}
}
impl AcquisitionTransport for FixtureTransport {
fn fetch_metadata(
&self,
request: &AcquisitionRequest,
limits: FetchLimits,
cancel: &CancelFlag,
) -> Result<FetchOutcome<MetadataBytes>, AcquisitionError> {
limits.validate()?;
let start = Instant::now();
if cancel.is_cancelled() {
return Err(AcquisitionError::Cancelled);
}
let fixture = self.lookup(request.url())?;
match fixture.kind {
FixtureKind::NotFound => Ok(FetchOutcome::NotFound),
FixtureKind::Failure => Err(AcquisitionError::transport_redacted(
"fixture transport failure",
)),
FixtureKind::Unavailable => Err(AcquisitionError::__adapter_unavailable(
"fixture transport unavailable",
)),
FixtureKind::Body(bytes) => {
if start.elapsed() > limits.total_timeout {
return Err(AcquisitionError::Timeout { phase: "total" });
}
if cancel.is_cancelled() {
return Err(AcquisitionError::Cancelled);
}
if bytes.len() > limits.max_metadata_bytes {
return Err(AcquisitionError::TooLarge {
limit: limits.max_metadata_bytes as u64,
});
}
Ok(FetchOutcome::Success(MetadataBytes { bytes }))
}
FixtureKind::Truncated { .. } => Err(AcquisitionError::transport_redacted(
"truncated fixture body",
)),
FixtureKind::Slow { body, delay } => {
if delay > limits.total_timeout {
return Err(AcquisitionError::Timeout { phase: "total" });
}
if cancel.is_cancelled() {
return Err(AcquisitionError::Cancelled);
}
if body.len() > limits.max_metadata_bytes {
return Err(AcquisitionError::TooLarge {
limit: limits.max_metadata_bytes as u64,
});
}
Ok(FetchOutcome::Success(MetadataBytes { bytes: body }))
}
}
}
fn fetch_artifact(
&self,
request: &AcquisitionRequest,
dest: &Path,
limits: FetchLimits,
cancel: &CancelFlag,
) -> Result<FetchOutcome<ArtifactEvidence>, AcquisitionError> {
limits.validate()?;
let start = Instant::now();
if cancel.is_cancelled() {
return Err(AcquisitionError::Cancelled);
}
let parent = dest
.parent()
.ok_or_else(|| AcquisitionError::invalid("artifact destination has no parent"))?;
let parent_meta = fs::symlink_metadata(parent)
.map_err(|e| AcquisitionError::io("reading artifact parent", e))?;
if !parent_meta.is_dir() || parent_meta.file_type().is_symlink() {
return Err(AcquisitionError::invalid(
"artifact parent must be an existing real directory",
));
}
if fs::symlink_metadata(dest).is_ok() {
return Err(AcquisitionError::invalid(
"artifact destination already exists; refusing to overwrite",
));
}
let fixture = self.lookup(request.url())?;
let body = match fixture.kind {
FixtureKind::NotFound => return Ok(FetchOutcome::NotFound),
FixtureKind::Failure => {
return Err(AcquisitionError::transport_redacted(
"fixture transport failure",
));
}
FixtureKind::Unavailable => {
return Err(AcquisitionError::__adapter_unavailable(
"fixture transport unavailable",
));
}
FixtureKind::Body(b) => b,
FixtureKind::Truncated { prefix_len } => {
if let Ok((mut f, tmp)) = __acquire_exclusive_temp(parent, "eggup-acquire") {
use std::io::Write;
let prefix = vec![0u8; prefix_len.min(1024)];
let _ = f.write_all(&prefix);
drop(f);
__remove_owned_temp(&tmp);
}
return Err(AcquisitionError::transport_redacted(
"early disconnect during artifact body",
));
}
FixtureKind::Slow { body, delay } => {
if delay > limits.total_timeout || start.elapsed() + delay > limits.total_timeout {
return Err(AcquisitionError::Timeout { phase: "total" });
}
body
}
};
if body.len() as u64 > limits.max_artifact_bytes {
return Err(AcquisitionError::TooLarge {
limit: limits.max_artifact_bytes,
});
}
if start.elapsed() > limits.total_timeout {
return Err(AcquisitionError::Timeout { phase: "total" });
}
if cancel.is_cancelled() {
return Err(AcquisitionError::Cancelled);
}
let (mut file, tmp) = __acquire_exclusive_temp(parent, "eggup-acquire")?;
struct Guard {
path: std::path::PathBuf,
disarm: bool,
}
impl Drop for Guard {
fn drop(&mut self) {
if !self.disarm {
__remove_owned_temp(&self.path);
}
}
}
let mut guard = Guard {
path: tmp.clone(),
disarm: false,
};
let mut written: u64 = 0;
{
use std::io::Write;
for chunk in body.chunks(8192) {
if cancel.is_cancelled() {
return Err(AcquisitionError::Cancelled);
}
file.write_all(chunk)
.map_err(|e| AcquisitionError::io("writing part file", e))?;
written += chunk.len() as u64;
}
file.flush()
.map_err(|e| AcquisitionError::io("flushing part file", e))?;
drop(file);
}
if cancel.is_cancelled() {
return Err(AcquisitionError::Cancelled);
}
match __promote_no_clobber(&tmp, dest) {
Ok(()) => {
guard.disarm = true;
Ok(FetchOutcome::Success(ArtifactEvidence {
bytes_written: written,
}))
}
Err(e) => {
__remove_owned_temp(&tmp);
guard.disarm = true;
Err(e)
}
}
}
}
pub type SharedTransport = Arc<FixtureTransport>;
#[doc(hidden)]
pub fn __adapter_metadata(bytes: Vec<u8>) -> MetadataBytes {
MetadataBytes { bytes }
}
#[doc(hidden)]
pub fn __adapter_artifact(bytes_written: u64) -> ArtifactEvidence {
ArtifactEvidence { bytes_written }
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
pub enum CompositionPolicy {
#[default]
UnavailableOnly,
UnavailableOrTransport,
}
pub struct ComposedTransport<'a> {
primary: &'a dyn AcquisitionTransport,
secondary: &'a dyn AcquisitionTransport,
policy: CompositionPolicy,
}
impl std::fmt::Debug for ComposedTransport<'_> {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("ComposedTransport")
.field("policy", &self.policy)
.finish_non_exhaustive()
}
}
impl<'a> ComposedTransport<'a> {
pub fn new(
primary: &'a dyn AcquisitionTransport,
secondary: &'a dyn AcquisitionTransport,
policy: CompositionPolicy,
) -> Self {
Self {
primary,
secondary,
policy,
}
}
pub fn policy(&self) -> CompositionPolicy {
self.policy
}
fn should_fallback(&self, err: &AcquisitionError) -> bool {
match err {
AcquisitionError::Unavailable(_) => true,
AcquisitionError::Transport(_) | AcquisitionError::Timeout { .. } => {
self.policy == CompositionPolicy::UnavailableOrTransport
}
_ => false,
}
}
}
impl AcquisitionTransport for ComposedTransport<'_> {
fn fetch_metadata(
&self,
request: &AcquisitionRequest,
limits: FetchLimits,
cancel: &CancelFlag,
) -> Result<FetchOutcome<MetadataBytes>, AcquisitionError> {
limits.validate()?;
if cancel.is_cancelled() {
return Err(AcquisitionError::Cancelled);
}
match self.primary.fetch_metadata(request, limits, cancel) {
Ok(outcome) => Ok(outcome),
Err(err) => {
if self.should_fallback(&err) {
self.secondary.fetch_metadata(request, limits, cancel)
} else {
Err(err)
}
}
}
}
fn fetch_artifact(
&self,
request: &AcquisitionRequest,
dest: &Path,
limits: FetchLimits,
cancel: &CancelFlag,
) -> Result<FetchOutcome<ArtifactEvidence>, AcquisitionError> {
limits.validate()?;
if cancel.is_cancelled() {
return Err(AcquisitionError::Cancelled);
}
match self.primary.fetch_artifact(request, dest, limits, cancel) {
Ok(outcome) => Ok(outcome),
Err(err) => {
if self.should_fallback(&err) {
self.secondary.fetch_artifact(request, dest, limits, cancel)
} else {
Err(err)
}
}
}
}
}
#[cfg(test)]
mod tests {
use super::*;
use std::path::PathBuf;
use std::time::Duration;
fn req(url: &str) -> AcquisitionRequest {
AcquisitionRequest::new(url).unwrap()
}
fn limits() -> FetchLimits {
FetchLimits {
max_metadata_bytes: 1024,
max_artifact_bytes: 4096,
connect_timeout: Duration::from_secs(1),
total_timeout: Duration::from_secs(5),
}
}
fn temp_dir(prefix: &str) -> PathBuf {
let nanos = std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.map(|d| d.as_nanos())
.unwrap_or(0);
let p = std::env::temp_dir().join(format!("{prefix}-{}-{nanos}", std::process::id()));
let _ = fs::create_dir_all(&p);
p
}
#[test]
fn exact_body_success() {
let t = FixtureTransport::new();
t.route(
"https://example.com/meta",
FixtureResponse::body(b"hello".to_vec()),
);
let out = t
.fetch_metadata(
&req("https://example.com/meta"),
limits(),
&CancelFlag::new(),
)
.unwrap();
assert_eq!(out.success().unwrap().bytes(), b"hello");
}
#[test]
fn streamed_artifact_success() {
let t = FixtureTransport::new();
t.route(
"https://example.com/app",
FixtureResponse::body(vec![7u8; 2048]),
);
let dir = temp_dir("acq-stream");
let dest = dir.join("app");
let out = t
.fetch_artifact(
&req("https://example.com/app"),
&dest,
limits(),
&CancelFlag::new(),
)
.unwrap();
let ev = out.success().unwrap();
assert_eq!(ev.bytes_written, 2048);
assert_eq!(fs::read(&dest).unwrap().len(), 2048);
assert!(!dir.join(".eggup-acquire-0.part").exists());
let _ = fs::remove_dir_all(&dir);
}
#[test]
fn metadata_limit_is_enforced() {
let t = FixtureTransport::new();
t.route(
"https://example.com/big",
FixtureResponse::body(vec![0u8; 2048]),
);
let err = t
.fetch_metadata(
&req("https://example.com/big"),
limits(),
&CancelFlag::new(),
)
.unwrap_err();
assert!(matches!(err, AcquisitionError::TooLarge { .. }));
}
#[test]
fn artifact_limit_is_enforced_without_promotion() {
let t = FixtureTransport::new();
t.route(
"https://example.com/big",
FixtureResponse::body(vec![0u8; 8192]),
);
let dir = temp_dir("acq-limit");
let dest = dir.join("app");
let err = t
.fetch_artifact(
&req("https://example.com/big"),
&dest,
limits(),
&CancelFlag::new(),
)
.unwrap_err();
assert!(matches!(err, AcquisitionError::TooLarge { .. }));
assert!(!dest.exists());
let _ = fs::remove_dir_all(&dir);
}
#[test]
fn not_found_is_data_not_failure() {
let t = FixtureTransport::new();
t.route("https://example.com/missing", FixtureResponse::not_found());
let out = t
.fetch_metadata(
&req("https://example.com/missing"),
limits(),
&CancelFlag::new(),
)
.unwrap();
assert!(out.is_not_found());
let dir = temp_dir("acq-404");
let dest = dir.join("app");
let out = t
.fetch_artifact(
&req("https://example.com/missing"),
&dest,
limits(),
&CancelFlag::new(),
)
.unwrap();
assert!(out.is_not_found());
assert!(!dest.exists());
let _ = fs::remove_dir_all(&dir);
}
#[test]
fn hard_failures_never_become_not_found() {
let t = FixtureTransport::new();
t.route(
"https://example.com/boom",
FixtureResponse::failure("500 internal error"),
);
let err = t
.fetch_metadata(
&req("https://example.com/boom"),
limits(),
&CancelFlag::new(),
)
.unwrap_err();
assert!(matches!(err, AcquisitionError::Transport(_)));
}
#[test]
fn timeout_is_a_hard_failure() {
let t = FixtureTransport::new();
t.route(
"https://example.com/slow",
FixtureResponse::slow(b"late".to_vec(), Duration::from_secs(30)),
);
let err = t
.fetch_metadata(
&req("https://example.com/slow"),
limits(),
&CancelFlag::new(),
)
.unwrap_err();
assert!(matches!(err, AcquisitionError::Timeout { .. }));
}
#[test]
fn cancellation_cleans_partial_output() {
let t = FixtureTransport::new();
t.route(
"https://example.com/app",
FixtureResponse::body(vec![1u8; 1024]),
);
let dir = temp_dir("acq-cancel");
let dest = dir.join("app");
let cancel = CancelFlag::new();
cancel.cancel();
let err = t
.fetch_artifact(&req("https://example.com/app"), &dest, limits(), &cancel)
.unwrap_err();
assert!(matches!(err, AcquisitionError::Cancelled));
assert!(!dest.exists());
let leftovers: Vec<_> = fs::read_dir(&dir)
.unwrap()
.filter_map(|e| e.ok())
.filter(|e| {
e.file_name()
.to_string_lossy()
.starts_with(".eggup-acquire-")
})
.collect();
assert!(leftovers.is_empty());
let _ = fs::remove_dir_all(&dir);
}
#[test]
fn partial_write_failure_promotes_nothing() {
let t = FixtureTransport::new();
t.route("https://example.com/cut", FixtureResponse::truncated(512));
let dir = temp_dir("acq-partial");
let dest = dir.join("app");
let err = t
.fetch_artifact(
&req("https://example.com/cut"),
&dest,
limits(),
&CancelFlag::new(),
)
.unwrap_err();
assert!(matches!(err, AcquisitionError::Transport(_)));
assert!(!dest.exists());
let _ = fs::remove_dir_all(&dir);
}
#[test]
fn diagnostics_are_redacted() {
let redacted = redact_url("https://user:s3cret@example.com/app?token=abc");
assert!(!redacted.contains("s3cret"));
assert!(!redacted.contains("token=abc"));
assert!(redacted.contains("example.com"));
let err = AcquisitionRequest::new("https://user:pw@example.com/x?k=v").unwrap();
assert!(!err.redacted().contains("pw"));
}
#[test]
fn bounded_diagnostics_preserve_utf8_at_256_and_512_byte_edges() {
for limit in [256, 512] {
for (width, ch) in [(2, "é"), (3, "€"), (4, "🦀")] {
let prefix = "a".repeat(limit - 1);
let bounded = truncate_utf8_bytes(format!("{prefix}{ch}tail"), limit);
assert!(bounded.len() <= limit);
assert!(std::str::from_utf8(bounded.as_bytes()).is_ok());
assert!(bounded.ends_with(&prefix));
assert!(width > 1);
}
}
}
#[test]
fn zero_artifact_limit_is_rejected() {
let invalid = FetchLimits {
max_artifact_bytes: 0,
..FetchLimits::default()
};
assert!(matches!(
invalid.validate(),
Err(AcquisitionError::InvalidInput(_))
));
}
#[test]
fn no_fallback_on_unregistered_url() {
let t = FixtureTransport::new();
let err = t
.fetch_metadata(
&req("https://example.com/unknown"),
limits(),
&CancelFlag::new(),
)
.unwrap_err();
assert!(matches!(err, AcquisitionError::Transport(_)));
}
#[test]
fn invalid_public_limits_are_rejected_before_fixture_io() {
let transport = FixtureTransport::new();
let request = req("https://example.com/no-route");
let invalid = [
FetchLimits {
max_metadata_bytes: 0,
..limits()
},
FetchLimits {
max_metadata_bytes: 16 * 1024 * 1024 + 1,
..limits()
},
FetchLimits {
connect_timeout: Duration::ZERO,
..limits()
},
FetchLimits {
total_timeout: Duration::ZERO,
..limits()
},
FetchLimits {
connect_timeout: Duration::from_secs(6),
total_timeout: Duration::from_secs(5),
..limits()
},
];
let dir = temp_dir("acq-invalid-limits");
let dest = dir.join("app");
for limits in invalid {
assert!(matches!(
limits.validate(),
Err(AcquisitionError::InvalidInput(_))
));
assert!(matches!(
transport.fetch_metadata(&request, limits, &CancelFlag::new()),
Err(AcquisitionError::InvalidInput(_))
));
assert!(matches!(
transport.fetch_artifact(&request, &dest, limits, &CancelFlag::new()),
Err(AcquisitionError::InvalidInput(_))
));
assert!(!dest.exists());
assert_eq!(fs::read_dir(&dir).unwrap().count(), 0);
}
assert!(limits().validate().is_ok());
assert!(
FetchLimits::new(1024, 4096, Duration::from_secs(1), Duration::from_secs(5)).is_ok()
);
let _ = fs::remove_dir_all(&dir);
}
#[test]
fn missing_artifact_parent_fails_without_creation() {
let t = FixtureTransport::new();
t.route(
"https://example.com/app",
FixtureResponse::body(b"x".to_vec()),
);
let dir = temp_dir("acq-noparent");
let dest = dir.join("no-such-dir/app");
let err = t
.fetch_artifact(
&req("https://example.com/app"),
&dest,
limits(),
&CancelFlag::new(),
)
.unwrap_err();
assert!(matches!(
err,
AcquisitionError::InvalidInput(_) | AcquisitionError::Io(_)
));
assert!(!dir.join("no-such-dir").exists());
let _ = fs::remove_dir_all(&dir);
}
#[test]
fn connect_exceeding_total_is_rejected() {
let err = FetchLimits::new(1024, 4096, Duration::from_secs(5), Duration::from_secs(1))
.unwrap_err();
assert!(matches!(err, AcquisitionError::InvalidInput(_)));
}
#[test]
fn zero_timeouts_are_rejected() {
assert!(FetchLimits::new(1024, 1, Duration::ZERO, Duration::from_secs(1)).is_err());
assert!(FetchLimits::new(1024, 1, Duration::from_secs(1), Duration::ZERO).is_err());
}
#[test]
fn effective_timeouts_take_minimums() {
let request = FetchLimits {
max_metadata_bytes: 1024,
max_artifact_bytes: 4096,
connect_timeout: Duration::from_millis(50),
total_timeout: Duration::from_millis(50),
};
let (c, t) = request.effective(Duration::from_secs(5), Duration::from_secs(5));
assert_eq!(c, Duration::from_millis(50));
assert_eq!(t, Duration::from_millis(50));
let request2 = FetchLimits {
max_metadata_bytes: 1024,
max_artifact_bytes: 4096,
connect_timeout: Duration::from_secs(5),
total_timeout: Duration::from_secs(5),
};
let (c2, t2) = request2.effective(Duration::from_millis(50), Duration::from_millis(50));
assert_eq!(c2, Duration::from_millis(50));
assert_eq!(t2, Duration::from_millis(50));
let (c3, t3) = request2.effective(Duration::from_secs(1), Duration::from_secs(10));
assert_eq!(c3, Duration::from_secs(1));
assert_eq!(t3, Duration::from_secs(5));
}
#[test]
fn timeout_never_maps_to_not_found() {
let t = FixtureTransport::new();
t.route(
"https://example.com/slow-art",
FixtureResponse::slow(vec![1u8; 16], Duration::from_secs(30)),
);
let dir = temp_dir("acq-timeout-nf");
let dest = dir.join("app");
let tiny = FetchLimits {
max_metadata_bytes: 1024,
max_artifact_bytes: 4096,
connect_timeout: Duration::from_millis(10),
total_timeout: Duration::from_millis(10),
};
let err = t
.fetch_artifact(
&req("https://example.com/slow-art"),
&dest,
tiny,
&CancelFlag::new(),
)
.unwrap_err();
assert!(matches!(err, AcquisitionError::Timeout { .. }));
assert!(!matches!(err, AcquisitionError::InvalidInput(_)));
assert!(!dest.exists());
let _ = fs::remove_dir_all(&dir);
}
#[test]
fn existing_destination_is_a_hard_no_clobber_failure() {
let t = FixtureTransport::new();
t.route(
"https://example.com/app",
FixtureResponse::body(vec![9u8; 64]),
);
let dir = temp_dir("acq-noclobber");
let dest = dir.join("app");
fs::write(&dest, b"FOREIGN-BYTES").unwrap();
let err = t
.fetch_artifact(
&req("https://example.com/app"),
&dest,
limits(),
&CancelFlag::new(),
)
.unwrap_err();
assert!(matches!(
err,
AcquisitionError::InvalidInput(_) | AcquisitionError::Io(_)
));
assert_eq!(fs::read(&dest).unwrap(), b"FOREIGN-BYTES");
let leftovers: Vec<_> = fs::read_dir(&dir)
.unwrap()
.filter_map(|e| e.ok())
.filter(|e| {
let n = e.file_name().to_string_lossy().into_owned();
n.ends_with(".part") && n.starts_with(".eggup-acquire-")
})
.collect();
assert!(leftovers.is_empty());
let _ = fs::remove_dir_all(&dir);
}
#[test]
fn post_link_cleanup_failure_keeps_committed_destination_successful() {
let dir = temp_dir("acq-promote-cleanup");
let tmp = dir.join("owned.part");
let dest = dir.join("app");
fs::write(&tmp, b"complete artifact").unwrap();
let result = __promote_no_clobber_with(&tmp, &dest, |_| {
Err(std::io::Error::new(
std::io::ErrorKind::PermissionDenied,
"injected",
))
});
assert!(result.is_ok());
assert_eq!(fs::read(&dest).unwrap(), b"complete artifact");
assert_eq!(fs::read(&tmp).unwrap(), b"complete artifact");
let _ = fs::remove_dir_all(&dir);
}
#[test]
fn promote_no_clobber_preserves_raced_destination() {
let dir = temp_dir("acq-race");
let (mut f, tmp) = __acquire_exclusive_temp(&dir, "eggup-acquire").unwrap();
use std::io::Write;
f.write_all(b"race-payload").unwrap();
let dest = dir.join("app");
fs::write(&dest, b"RACED-FOREIGN").unwrap();
let err = __promote_no_clobber(&tmp, &dest).unwrap_err();
assert!(matches!(
err,
AcquisitionError::InvalidInput(_) | AcquisitionError::Io(_)
));
assert_eq!(fs::read(&dest).unwrap(), b"RACED-FOREIGN");
assert!(tmp.exists());
__remove_owned_temp(&tmp);
assert!(!tmp.exists());
let _ = fs::remove_dir_all(&dir);
}
#[test]
fn promote_succeeds_when_destination_absent() {
let dir = temp_dir("acq-promote-ok");
let (mut f, tmp) = __acquire_exclusive_temp(&dir, "eggup-acquire").unwrap();
use std::io::Write;
f.write_all(b"payload").unwrap();
drop(f);
let dest = dir.join("app");
__promote_no_clobber(&tmp, &dest).unwrap();
assert_eq!(fs::read(&dest).unwrap(), b"payload");
assert!(!tmp.exists());
let _ = fs::remove_dir_all(&dir);
}
#[cfg(unix)]
#[test]
fn exclusive_temp_is_owner_private() {
use std::os::unix::fs::PermissionsExt;
let dir = temp_dir("acq-mode");
let (f, tmp) = __acquire_exclusive_temp(&dir, "eggup-acquire").unwrap();
let mode = f.metadata().unwrap().permissions().mode() & 0o777;
assert_eq!(mode, 0o600, "temp must be owner-private 0600");
drop(f);
__remove_owned_temp(&tmp);
let _ = fs::remove_dir_all(&dir);
}
#[test]
fn exclusive_temp_never_truncates_existing_file() {
use std::fs::OpenOptions;
let dir = temp_dir("acq-notrunc");
let victim = dir.join("victim");
fs::write(&victim, b"SENTINEL").unwrap();
let err = OpenOptions::new()
.write(true)
.create_new(true)
.open(&victim)
.unwrap_err();
assert_eq!(err.kind(), std::io::ErrorKind::AlreadyExists);
assert_eq!(fs::read(&victim).unwrap(), b"SENTINEL");
let (f, tmp) = __acquire_exclusive_temp(&dir, "eggup-acquire").unwrap();
assert_ne!(tmp, victim);
assert_eq!(fs::read(&victim).unwrap(), b"SENTINEL");
drop(f);
__remove_owned_temp(&tmp);
let _ = fs::remove_dir_all(&dir);
}
#[cfg(unix)]
#[test]
fn exclusive_temp_does_not_follow_symlink() {
use std::fs::OpenOptions;
use std::os::unix::fs::symlink;
let dir = temp_dir("acq-symlink");
let target = dir.join("target");
fs::write(&target, b"TARGET-SENTINEL").unwrap();
let link = dir.join("link");
symlink(&target, &link).unwrap();
let err = OpenOptions::new()
.write(true)
.create_new(true)
.open(&link)
.unwrap_err();
assert_eq!(err.kind(), std::io::ErrorKind::AlreadyExists);
assert_eq!(fs::read(&target).unwrap(), b"TARGET-SENTINEL");
let t = FixtureTransport::new();
t.route(
"https://example.com/app",
FixtureResponse::body(vec![1u8; 32]),
);
let dest = dir.join("app");
t.fetch_artifact(
&req("https://example.com/app"),
&dest,
limits(),
&CancelFlag::new(),
)
.unwrap();
assert_eq!(fs::read(&target).unwrap(), b"TARGET-SENTINEL");
let _ = fs::remove_dir_all(&dir);
}
#[test]
fn cancellation_preserves_foreign_sibling_and_removes_only_owned() {
let t = FixtureTransport::new();
t.route(
"https://example.com/app",
FixtureResponse::body(vec![2u8; 128]),
);
let dir = temp_dir("acq-cancel-own");
let foreign = dir.join("foreign-keep");
fs::write(&foreign, b"KEEP").unwrap();
let dest = dir.join("app");
let cancel = CancelFlag::new();
cancel.cancel();
let err = t
.fetch_artifact(&req("https://example.com/app"), &dest, limits(), &cancel)
.unwrap_err();
assert!(matches!(err, AcquisitionError::Cancelled));
assert!(!dest.exists());
assert_eq!(fs::read(&foreign).unwrap(), b"KEEP");
let leftovers: Vec<_> = fs::read_dir(&dir)
.unwrap()
.filter_map(|e| e.ok())
.filter(|e| {
let n = e.file_name().to_string_lossy().into_owned();
n.ends_with(".part")
})
.collect();
assert!(leftovers.is_empty());
let _ = fs::remove_dir_all(&dir);
}
#[test]
fn early_disconnect_removes_only_owned_temp() {
let t = FixtureTransport::new();
t.route("https://example.com/cut", FixtureResponse::truncated(256));
let dir = temp_dir("acq-disconnect-own");
let foreign = dir.join("keep");
fs::write(&foreign, b"KEEP").unwrap();
let dest = dir.join("app");
let err = t
.fetch_artifact(
&req("https://example.com/cut"),
&dest,
limits(),
&CancelFlag::new(),
)
.unwrap_err();
assert!(matches!(err, AcquisitionError::Transport(_)));
assert!(!dest.exists());
assert_eq!(fs::read(&foreign).unwrap(), b"KEEP");
let leftovers: Vec<_> = fs::read_dir(&dir)
.unwrap()
.filter_map(|e| e.ok())
.filter(|e| {
let n = e.file_name().to_string_lossy().into_owned();
n.ends_with(".part")
})
.collect();
assert!(leftovers.is_empty());
let _ = fs::remove_dir_all(&dir);
}
#[test]
fn redaction_sentinels_are_absent_from_diagnostics() {
let userinfo_sentinel = "S3CR3T-USERINFO-9917";
let query_sentinel = "TOKEN-QUERY-5523";
let url =
format!("https://user:{userinfo_sentinel}@example.com/app?token={query_sentinel}");
let t = FixtureTransport::new();
let err = t
.fetch_metadata(&req(&url), limits(), &CancelFlag::new())
.unwrap_err();
let msg = format!("{err}");
assert!(!msg.contains(userinfo_sentinel));
assert!(!msg.contains(query_sentinel));
assert!(!msg.contains("token="));
let t2 = FixtureTransport::new();
t2.route(
"https://example.com/secret",
FixtureResponse::failure(format!(
"upstream says {userinfo_sentinel} {query_sentinel}"
)),
);
let err2 = t2
.fetch_metadata(
&req("https://example.com/secret"),
limits(),
&CancelFlag::new(),
)
.unwrap_err();
let msg2 = format!("{err2}");
assert!(!msg2.contains(userinfo_sentinel));
assert!(!msg2.contains(query_sentinel));
let red = redact_url("https://example.com/app#FRAG-SENTINEL-7788");
assert!(!red.contains("FRAG-SENTINEL-7788"));
}
#[test]
fn upstream_scrub_removes_credential_patterns() {
let scrubbed = __scrub_upstream_text(
"fetch failed for https://alice:HUNTER2-PROXY-3311@example.com/x?token=abc&v=1",
);
assert!(!scrubbed.contains("HUNTER2-PROXY-3311"));
assert!(!scrubbed.contains("alice"));
let t = FixtureTransport::new();
t.route(
"https://example.com/p",
FixtureResponse::failure("proxy password HUNTER2-PROXY-3311 in detail"),
);
let err = t
.fetch_metadata(&req("https://example.com/p"), limits(), &CancelFlag::new())
.unwrap_err();
assert!(!format!("{err}").contains("HUNTER2-PROXY-3311"));
}
struct CountingTransport {
inner: FixtureTransport,
metadata_calls: std::sync::atomic::AtomicUsize,
artifact_calls: std::sync::atomic::AtomicUsize,
}
impl CountingTransport {
fn new() -> Self {
Self {
inner: FixtureTransport::new(),
metadata_calls: std::sync::atomic::AtomicUsize::new(0),
artifact_calls: std::sync::atomic::AtomicUsize::new(0),
}
}
fn route(&self, url: &str, response: FixtureResponse) {
self.inner.route(url, response);
}
fn metadata_calls(&self) -> usize {
self.metadata_calls
.load(std::sync::atomic::Ordering::SeqCst)
}
fn artifact_calls(&self) -> usize {
self.artifact_calls
.load(std::sync::atomic::Ordering::SeqCst)
}
}
impl AcquisitionTransport for CountingTransport {
fn fetch_metadata(
&self,
request: &AcquisitionRequest,
limits: FetchLimits,
cancel: &CancelFlag,
) -> Result<FetchOutcome<MetadataBytes>, AcquisitionError> {
self.metadata_calls
.fetch_add(1, std::sync::atomic::Ordering::SeqCst);
self.inner.fetch_metadata(request, limits, cancel)
}
fn fetch_artifact(
&self,
request: &AcquisitionRequest,
dest: &Path,
limits: FetchLimits,
cancel: &CancelFlag,
) -> Result<FetchOutcome<ArtifactEvidence>, AcquisitionError> {
self.artifact_calls
.fetch_add(1, std::sync::atomic::Ordering::SeqCst);
self.inner.fetch_artifact(request, dest, limits, cancel)
}
}
#[test]
fn composition_prefers_primary_without_fallback_call() {
let primary = CountingTransport::new();
let secondary = CountingTransport::new();
primary.route(
"https://example.com/meta",
FixtureResponse::body(b"primary".to_vec()),
);
secondary.route(
"https://example.com/meta",
FixtureResponse::body(b"secondary".to_vec()),
);
let composed =
ComposedTransport::new(&primary, &secondary, CompositionPolicy::UnavailableOnly);
let out = composed
.fetch_metadata(
&req("https://example.com/meta"),
limits(),
&CancelFlag::new(),
)
.unwrap();
assert_eq!(out.success().unwrap().bytes(), b"primary");
assert_eq!(primary.metadata_calls(), 1);
assert_eq!(secondary.metadata_calls(), 0);
}
#[test]
fn composition_falls_back_on_unavailable_by_default() {
let primary = CountingTransport::new();
let secondary = CountingTransport::new();
primary.route("https://example.com/meta", FixtureResponse::unavailable());
secondary.route(
"https://example.com/meta",
FixtureResponse::body(b"fallback".to_vec()),
);
let composed =
ComposedTransport::new(&primary, &secondary, CompositionPolicy::UnavailableOnly);
let out = composed
.fetch_metadata(
&req("https://example.com/meta"),
limits(),
&CancelFlag::new(),
)
.unwrap();
assert_eq!(out.success().unwrap().bytes(), b"fallback");
assert_eq!(primary.metadata_calls(), 1);
assert_eq!(secondary.metadata_calls(), 1);
}
#[test]
fn composition_default_does_not_retry_transport_failures() {
let primary = CountingTransport::new();
let secondary = CountingTransport::new();
primary.route("https://example.com/meta", FixtureResponse::failure("boom"));
secondary.route(
"https://example.com/meta",
FixtureResponse::body(b"secondary".to_vec()),
);
let composed =
ComposedTransport::new(&primary, &secondary, CompositionPolicy::UnavailableOnly);
let err = composed
.fetch_metadata(
&req("https://example.com/meta"),
limits(),
&CancelFlag::new(),
)
.unwrap_err();
assert!(matches!(err, AcquisitionError::Transport(_)));
assert_eq!(primary.metadata_calls(), 1);
assert_eq!(secondary.metadata_calls(), 0);
}
#[test]
fn composition_broad_policy_retries_transport_and_timeout() {
let primary = CountingTransport::new();
let secondary = CountingTransport::new();
primary.route("https://example.com/meta", FixtureResponse::failure("boom"));
secondary.route(
"https://example.com/meta",
FixtureResponse::body(b"recovered".to_vec()),
);
let composed = ComposedTransport::new(
&primary,
&secondary,
CompositionPolicy::UnavailableOrTransport,
);
let out = composed
.fetch_metadata(
&req("https://example.com/meta"),
limits(),
&CancelFlag::new(),
)
.unwrap();
assert_eq!(out.success().unwrap().bytes(), b"recovered");
assert_eq!(secondary.metadata_calls(), 1);
let p2 = CountingTransport::new();
let s2 = CountingTransport::new();
p2.route(
"https://example.com/slow",
FixtureResponse::slow(b"x".to_vec(), Duration::from_secs(30)),
);
s2.route(
"https://example.com/slow",
FixtureResponse::body(b"fast".to_vec()),
);
let composed2 = ComposedTransport::new(&p2, &s2, CompositionPolicy::UnavailableOrTransport);
let out2 = composed2
.fetch_metadata(
&req("https://example.com/slow"),
limits(),
&CancelFlag::new(),
)
.unwrap();
assert_eq!(out2.success().unwrap().bytes(), b"fast");
}
#[test]
fn composition_never_retries_terminal_conditions() {
let primary = CountingTransport::new();
let secondary = CountingTransport::new();
primary.route("https://example.com/missing", FixtureResponse::not_found());
secondary.route(
"https://example.com/missing",
FixtureResponse::body(b"other".to_vec()),
);
let composed = ComposedTransport::new(
&primary,
&secondary,
CompositionPolicy::UnavailableOrTransport,
);
let out = composed
.fetch_metadata(
&req("https://example.com/missing"),
limits(),
&CancelFlag::new(),
)
.unwrap();
assert!(out.is_not_found());
assert_eq!(secondary.metadata_calls(), 0);
let cancel = CancelFlag::new();
cancel.cancel();
let out = composed.fetch_metadata(&req("https://example.com/missing"), limits(), &cancel);
assert!(matches!(out, Err(AcquisitionError::Cancelled)));
assert_eq!(secondary.metadata_calls(), 0);
let p3 = CountingTransport::new();
let s3 = CountingTransport::new();
p3.route(
"https://example.com/big",
FixtureResponse::body(vec![0u8; 2048]),
);
s3.route(
"https://example.com/big",
FixtureResponse::body(b"small".to_vec()),
);
let c3 = ComposedTransport::new(&p3, &s3, CompositionPolicy::UnavailableOrTransport);
let err = c3
.fetch_metadata(
&req("https://example.com/big"),
limits(),
&CancelFlag::new(),
)
.unwrap_err();
assert!(matches!(err, AcquisitionError::TooLarge { .. }));
assert_eq!(s3.metadata_calls(), 0);
let err = c3
.fetch_metadata(
&req("https://example.com/big"),
FetchLimits {
max_metadata_bytes: 0,
..limits()
},
&CancelFlag::new(),
)
.unwrap_err();
assert!(matches!(err, AcquisitionError::InvalidInput(_)));
assert_eq!(p3.metadata_calls(), 1);
assert_eq!(s3.metadata_calls(), 0);
}
#[test]
fn composition_artifact_fallback_preserves_no_clobber() {
let primary = CountingTransport::new();
let secondary = CountingTransport::new();
primary.route("https://example.com/app", FixtureResponse::unavailable());
secondary.route(
"https://example.com/app",
FixtureResponse::body(vec![9u8; 128]),
);
let composed =
ComposedTransport::new(&primary, &secondary, CompositionPolicy::UnavailableOnly);
let dir = temp_dir("acq-composed-artifact");
let dest = dir.join("app");
let out = composed
.fetch_artifact(
&req("https://example.com/app"),
&dest,
limits(),
&CancelFlag::new(),
)
.unwrap();
assert_eq!(out.success().unwrap().bytes_written, 128);
assert_eq!(primary.artifact_calls(), 1);
assert_eq!(secondary.artifact_calls(), 1);
assert_eq!(fs::read(&dest).unwrap().len(), 128);
let _ = fs::remove_dir_all(&dir);
}
}