use std::time::Duration;
pub const FETCH_TIMEOUT: Duration = Duration::from_secs(120);
pub const MAX_PACKAGE_BYTES: u64 = 512 * 1024 * 1024;
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum PackageError {
SourceUnavailable(String),
DigestMismatch(String),
TooLarge(String),
}
impl std::fmt::Display for PackageError {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match self {
PackageError::SourceUnavailable(detail)
| PackageError::DigestMismatch(detail)
| PackageError::TooLarge(detail) => f.write_str(detail),
}
}
}
impl std::error::Error for PackageError {}
pub fn sha256_hex_bytes(bytes: &[u8]) -> String {
hex_lower(ring::digest::digest(&ring::digest::SHA256, bytes).as_ref())
}
pub fn content_id(prefix: &str, sha256_hex: &str) -> String {
let digest_prefix: String = sha256_hex.chars().take(16).collect();
format!("{prefix}-{digest_prefix}")
}
pub fn package_id_for_sha256(sha256_hex: &str) -> String {
content_id("pkg", sha256_hex)
}
pub fn is_safe_path_segment(value: &str) -> bool {
!value.is_empty()
&& value != "."
&& value != ".."
&& !value.contains(['/', '\\'])
&& !value.chars().any(char::is_control)
}
fn sanitize_segment(value: &str) -> String {
let cleaned: String = value
.chars()
.map(|ch| {
if ch == '/' || ch == '\\' || ch.is_control() {
'-'
} else {
ch
}
})
.collect();
if cleaned.is_empty() || cleaned == "." || cleaned == ".." {
return "_".to_string();
}
cleaned
}
pub async fn read_source(source: &str) -> Result<Vec<u8>, PackageError> {
read_source_within(source, MAX_PACKAGE_BYTES, FETCH_TIMEOUT).await
}
pub async fn read_source_within(
source: &str,
max_bytes: u64,
timeout: Duration,
) -> Result<Vec<u8>, PackageError> {
let client = reqwest::Client::builder()
.timeout(timeout)
.build()
.map_err(|err| {
PackageError::SourceUnavailable(format!("failed to build http client: {err}"))
})?;
read_source_with_client(&client, source, max_bytes, timeout).await
}
pub async fn read_source_with_client(
client: &reqwest::Client,
source: &str,
max_bytes: u64,
timeout: Duration,
) -> Result<Vec<u8>, PackageError> {
if source.starts_with('/') {
return read_local_source(source, max_bytes);
}
let response = client
.get(source)
.timeout(timeout)
.send()
.await
.map_err(|err| {
PackageError::SourceUnavailable(format!("failed to fetch package from {source}: {err}"))
})?;
if !response.status().is_success() {
return Err(PackageError::SourceUnavailable(format!(
"package source {source} returned HTTP {}",
response.status()
)));
}
if let Some(len) = response.content_length()
&& len > max_bytes
{
return Err(over_limit(source, len, max_bytes));
}
let bytes = response.bytes().await.map_err(|err| {
PackageError::SourceUnavailable(format!("failed to read package body from {source}: {err}"))
})?;
if bytes.len() as u64 > max_bytes {
return Err(over_limit(source, bytes.len() as u64, max_bytes));
}
Ok(bytes.to_vec())
}
pub fn read_local_source(path: &str, max_bytes: u64) -> Result<Vec<u8>, PackageError> {
let metadata = std::fs::metadata(path).map_err(|err| {
PackageError::SourceUnavailable(format!("failed to read package from {path}: {err}"))
})?;
if metadata.len() > max_bytes {
return Err(over_limit(path, metadata.len(), max_bytes));
}
let bytes = std::fs::read(path).map_err(|err| {
PackageError::SourceUnavailable(format!("failed to read package from {path}: {err}"))
})?;
if bytes.len() as u64 > max_bytes {
return Err(over_limit(path, bytes.len() as u64, max_bytes));
}
Ok(bytes)
}
fn over_limit(source: &str, actual: u64, max_bytes: u64) -> PackageError {
PackageError::TooLarge(format!(
"package at {source} is {actual} bytes, over the {max_bytes} byte limit"
))
}
pub async fn read_verified_source(
source: &str,
expected_sha256: Option<&str>,
) -> Result<(Vec<u8>, String), PackageError> {
let bytes = read_source(source).await?;
let actual = sha256_hex_bytes(&bytes);
if let Some(expected) = expected_sha256 {
let expected_hex = parse_digest(expected).map_err(|detail| {
PackageError::DigestMismatch(format!("expected sha256 is malformed: {detail}"))
})?;
if actual != expected_hex {
return Err(PackageError::DigestMismatch(format!(
"package sha256 mismatch: expected {expected_hex} got {actual}"
)));
}
}
Ok((bytes, actual))
}
pub fn parse_digest(value: &str) -> Result<String, String> {
let stripped = strip_digest_prefix(value);
let looks_like_hex = stripped.len() == 64 && stripped.chars().all(|ch| ch.is_ascii_hexdigit());
if !looks_like_hex {
return Err(format!(
"digest must be 64 hex chars (an optional `sha256:` prefix is allowed), got {value:?}"
));
}
Ok(stripped.to_ascii_lowercase())
}
pub fn parse_version(value: &str) -> Option<Vec<u64>> {
let core = value.trim().split(['-', '+']).next()?;
if core.is_empty() {
return None;
}
core.split('.')
.map(|segment| segment.parse::<u64>().ok())
.collect()
}
pub fn version_is_newer(target: &str, current: &str) -> Option<bool> {
Some(parse_version(target)? > parse_version(current)?)
}
fn strip_digest_prefix(value: &str) -> &str {
let trimmed = value.trim();
match trimmed.split_once(':') {
Some((scheme, rest)) if scheme.trim().eq_ignore_ascii_case("sha256") => rest.trim(),
_ => trimmed,
}
}
pub fn normalize_version(value: &str) -> String {
let trimmed = value.trim();
trimmed
.strip_prefix(['v', 'V'])
.unwrap_or(trimmed)
.to_string()
}
pub fn artifact_filename(url: &str, component: &str, version: &str) -> String {
let leading = url.split(['?', '#']).next().unwrap_or(url);
let basename = leading.rsplit('/').next().unwrap_or("");
if is_safe_path_segment(basename) {
return basename.to_string();
}
format!(
"{}-{}.bin",
sanitize_segment(component),
sanitize_segment(version)
)
}
pub fn read_package_identity(source: &str, bytes: &[u8]) -> (String, String) {
if let Some(dir) = first_tar_entry_component(bytes) {
let identity = parse_package_name(&dir);
if !identity.0.is_empty() {
return identity;
}
}
parse_package_name(source_basename(source))
}
pub fn read_binary_package_identity(bytes: &[u8]) -> (String, String) {
let Some(dir) = first_tar_entry_component(bytes) else {
return (String::new(), String::new());
};
let (version, arch) = parse_package_name(&dir);
if version.is_empty() || arch.is_empty() {
return (String::new(), String::new());
}
(version, arch)
}
fn source_basename(source: &str) -> &str {
let without_query = source.split(['?', '#']).next().unwrap_or(source);
without_query.rsplit('/').next().unwrap_or(without_query)
}
fn first_tar_entry_component(bytes: &[u8]) -> Option<String> {
let decoder = flate2::read::GzDecoder::new(bytes);
let mut archive = tar::Archive::new(decoder);
let mut entries = archive.entries().ok()?;
let entry = entries.next()?.ok()?;
let path = entry.path().ok()?;
path.components().find_map(|component| match component {
std::path::Component::Normal(name) => name.to_str().map(str::to_string),
_ => None,
})
}
const KNOWN_TRIPLE_ARCHES: &[&str] = &[
"aarch64",
"x86_64",
"i686",
"i586",
"armv7",
"armv6",
"arm",
"riscv64",
"powerpc64",
"powerpc64le",
"s390x",
"x86_64h",
"loongarch64",
];
fn parse_package_name(name: &str) -> (String, String) {
let name = strip_archive_suffix(name);
let (version_part, arch) = match triple_start(name) {
Some(index) => (&name[..index], name[index + 1..].to_string()),
None => (name, String::new()),
};
match version_start(version_part) {
Some(index) => (version_part[index..].to_string(), arch),
None => (String::new(), String::new()),
}
}
fn triple_start(name: &str) -> Option<usize> {
for (index, _) in name.match_indices('-') {
let candidate = &name[index + 1..];
let arch_head = candidate.split('-').next().unwrap_or("");
if KNOWN_TRIPLE_ARCHES.contains(&arch_head) && version_start(&name[..index]).is_some() {
return Some(index);
}
}
None
}
fn version_start(name: &str) -> Option<usize> {
let mut offset = 0;
for segment in name.split('-') {
if looks_like_version(segment) {
return Some(offset);
}
offset += segment.len() + 1;
}
None
}
fn looks_like_version(segment: &str) -> bool {
let rest = segment.strip_prefix(['v', 'V']).unwrap_or(segment);
let mut parts = rest.split('.');
let (Some(head), Some(second)) = (parts.next(), parts.next()) else {
return false;
};
!head.is_empty()
&& head.chars().all(|ch| ch.is_ascii_digit())
&& second.chars().next().is_some_and(|ch| ch.is_ascii_digit())
}
fn strip_archive_suffix(name: &str) -> &str {
for suffix in [
".tar.gz", ".tar.bz2", ".tar.xz", ".tgz", ".tar", ".gz", ".zip", ".bin",
] {
if let Some(stripped) = name.strip_suffix(suffix) {
return stripped;
}
}
name
}
fn hex_lower(bytes: &[u8]) -> String {
let mut output = String::with_capacity(bytes.len() * 2);
for byte in bytes {
output.push_str(&format!("{byte:02x}"));
}
output
}
#[cfg(test)]
mod tests {
use super::*;
fn tar_gz_with_entry(entry: &str, payload: &[u8]) -> Vec<u8> {
let mut tar_bytes = Vec::new();
{
let mut builder = tar::Builder::new(&mut tar_bytes);
let mut header = tar::Header::new_gnu();
header.set_size(payload.len() as u64);
header.set_mode(0o644);
header.set_cksum();
builder
.append_data(&mut header, entry, payload)
.expect("append tar entry");
builder.finish().expect("finish tar");
}
let mut encoder = flate2::write::GzEncoder::new(Vec::new(), flate2::Compression::default());
std::io::Write::write_all(&mut encoder, &tar_bytes).expect("gzip write");
encoder.finish().expect("gzip finish")
}
#[test]
fn sha256_hex_bytes_matches_known_vector() {
assert_eq!(
sha256_hex_bytes(b"abc"),
"ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad"
);
}
#[test]
fn package_id_is_stable_prefixed_and_digest_sized() {
let id = package_id_for_sha256("0123456789abcdef0123");
assert_eq!(id, "pkg-0123456789abcdef");
assert_eq!(id, package_id_for_sha256("0123456789abcdef0123"));
}
#[test]
fn artifact_filename_uses_the_source_basename_and_guards_paths() {
assert_eq!(
artifact_filename(
"https://github.com/galaxio-labs/galaxy-flow/releases/download/v0.16.1-alpha/galaxy-flow-v0.16.1-alpha-x86_64-unknown-linux-musl.tar.gz",
"galaxy-flow",
"v0.16.1-alpha",
),
"galaxy-flow-v0.16.1-alpha-x86_64-unknown-linux-musl.tar.gz"
);
assert_eq!(
artifact_filename("https://x/pkg.tar.gz?sig=1#frag", "c", "1.0"),
"pkg.tar.gz"
);
assert_eq!(
artifact_filename("https://x/dir/", "galaxy-ops", "1.2.3"),
"galaxy-ops-1.2.3.bin"
);
assert_eq!(
artifact_filename("/opt/pkgs/..", "galaxy-ops", "1.2.3"),
"galaxy-ops-1.2.3.bin"
);
}
#[test]
fn read_package_identity_parses_binary_package_dir() {
let cases = [
(
"wist-agentd-0.1.32-aarch64-apple-darwin/wist-agentd",
("0.1.32", "aarch64-apple-darwin"),
),
(
"wist-agentd-v0.2.0-beta.1-x86_64-unknown-linux-gnu/wist-agentd",
("v0.2.0-beta.1", "x86_64-unknown-linux-gnu"),
),
(
"gops-v0.18.2-aarch64-apple-darwin/gops",
("v0.18.2", "aarch64-apple-darwin"),
),
(
"gx-v0.15.1-x86_64-unknown-linux-gnu/gx",
("v0.15.1", "x86_64-unknown-linux-gnu"),
),
];
for (entry, expected) in cases {
let bytes = tar_gz_with_entry(entry, b"bin");
assert_eq!(
read_package_identity(entry, &bytes),
(expected.0.to_string(), expected.1.to_string()),
"entry {entry}"
);
}
}
#[test]
fn read_package_identity_falls_back_to_the_source_name() {
let stack = tar_gz_with_entry("sys/sys_model.yml", b"model");
for source in [
"/opt/pkgs/wist-gateway-stack-v0.1.17.tar.gz",
"https://github.com/dayu-sec/wist/releases/download/v0.1.17/wist-gateway-stack-v0.1.17.tar.gz",
] {
assert_eq!(
read_package_identity(source, &stack),
("v0.1.17".to_string(), String::new()),
"source {source}"
);
}
assert_eq!(
read_package_identity(
"https://x/gops-v0.18.2-aarch64-apple-darwin.tar.gz?sig=1",
&stack
),
("v0.18.2".to_string(), "aarch64-apple-darwin".to_string())
);
}
#[test]
fn read_package_identity_returns_empty_for_unreadable_packages() {
let bytes = tar_gz_with_entry("sys/sys_model.yml", b"x");
for source in [
"/opt/pkgs/wist-gateway-stack-notes.tar.gz",
"/tmp/wic-rel-1728000000000000000.tar.gz",
"download-1234.bin",
] {
assert_eq!(
read_package_identity(source, &bytes),
(String::new(), String::new()),
"source {source}"
);
}
assert_eq!(
read_package_identity("/opt/pkgs/thing.tar.gz", b"not a gzip stream"),
(String::new(), String::new())
);
}
#[test]
fn binary_package_identity_requires_a_known_triple() {
assert_eq!(
read_binary_package_identity(&tar_gz_with_entry(
"wist-agentd-1.2.3-x86_64-unknown-linux-gnu/wist-agentd",
b"bin",
)),
("1.2.3".to_string(), "x86_64-unknown-linux-gnu".to_string())
);
assert_eq!(
read_binary_package_identity(&tar_gz_with_entry(
"wist-agentd-0.2.0-beta.1-aarch64-apple-darwin/wist-agentd",
b"bin",
)),
(
"0.2.0-beta.1".to_string(),
"aarch64-apple-darwin".to_string()
)
);
assert_eq!(
read_binary_package_identity(&tar_gz_with_entry(
"wist-agentd-1.2.3-some-unknown-triple/wist-agentd",
b"bin",
)),
(String::new(), String::new())
);
assert_eq!(
read_binary_package_identity(&tar_gz_with_entry(
"wist-agentd-1.2.3/wist-agentd",
b"bin"
)),
(String::new(), String::new())
);
assert_eq!(
read_binary_package_identity(&tar_gz_with_entry("sys/sys_model.yml", b"model")),
(String::new(), String::new())
);
assert_eq!(
read_binary_package_identity(b"not a gzip stream"),
(String::new(), String::new())
);
}
#[test]
fn sha256_hex_bytes_is_lowercase_hex_of_the_expected_length() {
let digest = sha256_hex_bytes(b"");
assert_eq!(
digest,
"e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"
);
assert_eq!(digest.len(), 64);
assert!(digest.chars().all(|ch| ch.is_ascii_hexdigit()));
}
#[test]
fn package_id_takes_sixteen_chars_and_does_not_normalize_case() {
assert_eq!(package_id_for_sha256("abc"), "pkg-abc");
assert_eq!(package_id_for_sha256(""), "pkg-");
assert_eq!(
package_id_for_sha256("AB0123456789ABCDEF99"),
"pkg-AB0123456789ABCD"
);
assert_ne!(
package_id_for_sha256("AB0123456789ABCDEF99"),
package_id_for_sha256("ab0123456789abcdef99")
);
}
#[test]
fn normalize_version_strips_one_v_or_capital_v_prefix() {
assert_eq!(normalize_version("v0.1.32"), "0.1.32");
assert_eq!(normalize_version(" V0.1.32 "), "0.1.32");
assert_eq!(normalize_version("0.1.32"), "0.1.32");
assert_eq!(normalize_version("vv1.2"), "v1.2");
assert_eq!(
normalize_version("v0.16.1-alpha"),
normalize_version("0.16.1-alpha")
);
assert_eq!(normalize_version("V0.16.1"), normalize_version("v0.16.1"));
}
#[test]
fn read_package_identity_prefers_the_package_dir_over_the_source_name() {
let bytes = tar_gz_with_entry(
"wist-agentd-1.2.3-x86_64-unknown-linux-gnu/wist-agentd",
b"bin",
);
assert_eq!(
read_package_identity(
"/opt/pkgs/wist-agentd-9.9.9-aarch64-apple-darwin.tar.gz",
&bytes
),
("1.2.3".to_string(), "x86_64-unknown-linux-gnu".to_string())
);
}
#[test]
fn read_package_identity_stops_at_a_partial_dir_identity() {
let bytes = tar_gz_with_entry("gops-v0.18.2/gops", b"bin");
assert_eq!(
read_package_identity("/opt/pkgs/gops-v0.18.2-aarch64-apple-darwin.tar.gz", &bytes),
("v0.18.2".to_string(), String::new())
);
}
#[test]
fn read_package_identity_keeps_the_version_when_an_arch_word_is_only_part_of_the_name() {
let bytes = tar_gz_with_entry("sys/sys_model.yml", b"x");
for source in [
"/opt/pkgs/wist-arm-stack-1.2.3.tar.gz",
"https://x/wist-arm-stack-1.2.3.tar.gz",
] {
assert_eq!(
read_package_identity(source, &bytes),
("1.2.3".to_string(), String::new()),
"source {source}"
);
}
let bytes = tar_gz_with_entry("wist-arm-tool-1.2.3-aarch64-unknown-linux-gnu/w", b"x");
assert_eq!(
read_package_identity("/opt/pkgs/x.tar.gz", &bytes),
("1.2.3".to_string(), "aarch64-unknown-linux-gnu".to_string())
);
}
#[test]
fn read_package_identity_does_not_mistake_a_bare_number_for_a_version() {
let bytes = tar_gz_with_entry("sys/sys_model.yml", b"x");
for source in [
"/opt/pkgs/wist-stack-2024-10.tar.gz",
"/tmp/wist-stack-build1234.tar.gz",
] {
assert_eq!(
read_package_identity(source, &bytes),
(String::new(), String::new()),
"source {source}"
);
}
}
#[test]
fn is_safe_path_segment_accepts_plain_names_and_rejects_escaping_ones() {
for safe in [
"pkg",
"wist-gateway-stack",
"0.1.0-rc.1",
".hidden",
"a b",
"….gz",
] {
assert!(is_safe_path_segment(safe), "{safe:?} 应算安全");
}
for unsafe_value in [
"",
".",
"..",
"a/b",
"a\\b",
"../x",
"./x",
"/etc/passwd",
"a\nb",
"a\0b",
"\u{7f}",
] {
assert!(
!is_safe_path_segment(unsafe_value),
"{unsafe_value:?} 应算不安全"
);
}
}
#[test]
fn content_id_is_the_prefix_plus_sixteen_hex_chars() {
let sha = "0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef";
assert_eq!(content_id("kbp", sha), "kbp-0123456789abcdef");
assert_eq!(content_id("pkg", sha), package_id_for_sha256(sha));
assert_eq!(content_id("X", sha), "X-0123456789abcdef");
assert_eq!(content_id("", sha), "-0123456789abcdef");
assert_eq!(content_id("kbp", "abc"), "kbp-abc");
}
#[test]
fn artifact_filename_never_returns_an_escaping_segment() {
assert_eq!(
artifact_filename("https://x/dir/", "../etc", "../passwd"),
"..-etc-..-passwd.bin"
);
assert_eq!(
artifact_filename("https://x/..\\evil", "galaxy-ops", "1.2.3"),
"galaxy-ops-1.2.3.bin"
);
assert_eq!(
artifact_filename("https://x/bad\nname", "galaxy-ops", "1.2.3"),
"galaxy-ops-1.2.3.bin"
);
assert_eq!(artifact_filename("https://x/dir/", "..", "."), "_-_.bin");
assert_eq!(
artifact_filename("https://x/dir/pkg.tar.gz", "c", "1.0"),
"pkg.tar.gz"
);
}
#[test]
fn parse_digest_normalizes_the_documented_forms_and_rejects_the_rest() {
let digest = "0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef";
let upper = digest.to_ascii_uppercase();
for value in [
digest.to_string(),
upper.clone(),
format!("sha256:{digest}"),
format!("SHA256:{upper}"),
format!(" sha256: {upper} "),
] {
assert_eq!(
parse_digest(&value).expect(&value),
digest,
"value {value:?}"
);
}
for value in [
"",
"sha256:",
"deadbeef",
&digest[..63],
"zzzz",
"sha512:abc",
] {
assert!(
parse_digest(value).is_err(),
"value {value:?} should be rejected"
);
}
}
#[test]
fn version_is_newer_follows_the_documented_rules() {
assert_eq!(version_is_newer("0.1.10", "0.1.9"), Some(true));
assert_eq!(version_is_newer("0.1.9", "0.1.10"), Some(false));
assert_eq!(version_is_newer("0.1.9", "0.1.9"), Some(false));
assert_eq!(version_is_newer("0.2.0-beta.1", "0.1.9"), Some(true));
assert_eq!(version_is_newer("0.1.4+meta", "0.1.3"), Some(true));
assert_eq!(version_is_newer("0.1.9.1", "0.1.9"), Some(true));
assert_eq!(version_is_newer("0.1.0", "0.1"), Some(true));
for (target, current) in [
("dev", "0.1.9"),
("0.1.9", "dev"),
("v0.1.9", "0.1.9"),
("abc", "0.1.9"),
("0.1.9", ""),
("", "0.1.9"),
("0.1.9", "0.1.x"),
] {
assert_eq!(
version_is_newer(target, current),
None,
"{target:?} vs {current:?}"
);
}
let target = normalize_version("v0.1.9");
let current = normalize_version("0.1.8");
assert_eq!(version_is_newer(&target, ¤t), Some(true));
}
#[test]
fn normalize_version_ignores_whitespace_and_leading_v() {
assert_eq!(normalize_version(" v0.1.32 "), normalize_version("0.1.32"));
assert_ne!(normalize_version("0.1.32"), normalize_version("0.1.33"));
}
#[tokio::test]
async fn read_verified_source_accepts_a_prefixed_digest_in_any_case() {
let path = std::env::temp_dir().join("wist-release-digest-prefix.bin");
std::fs::write(&path, b"payload").expect("write");
let source = path.to_string_lossy().to_string();
let digest = sha256_hex_bytes(b"payload");
let upper = digest.to_ascii_uppercase();
for expected in [
format!("sha256:{digest}"),
format!("SHA256:{digest}"),
format!(" sha256: {upper} "),
upper.clone(),
] {
read_verified_source(&source, Some(&expected))
.await
.unwrap_or_else(|err| panic!("expected {expected} to verify: {err}"));
}
for bad in ["", "sha256:", &digest[..8]] {
assert!(
matches!(
read_verified_source(&source, Some(bad)).await,
Err(PackageError::DigestMismatch(_))
),
"expected {bad:?} to be rejected"
);
}
let _ = std::fs::remove_file(path);
}
#[tokio::test]
async fn read_source_within_caps_local_files_before_reading_them() {
let path = std::env::temp_dir().join("wist-release-size-cap.bin");
std::fs::write(&path, b"0123456789").expect("write"); let source = path.to_string_lossy().to_string();
let err = read_source_within(&source, 8, FETCH_TIMEOUT)
.await
.expect_err("over limit");
assert!(matches!(err, PackageError::TooLarge(_)), "{err}");
assert!(err.to_string().contains("over the 8 byte limit"), "{err}");
assert_eq!(
read_source_within(&source, 10, FETCH_TIMEOUT)
.await
.expect("at limit"),
b"0123456789"
);
let err = read_source_within(
&std::env::temp_dir().to_string_lossy(),
1 << 40,
FETCH_TIMEOUT,
)
.await
.expect_err("directory");
assert!(matches!(err, PackageError::SourceUnavailable(_)));
let _ = std::fs::remove_file(path);
}
#[tokio::test]
async fn read_source_with_client_still_reads_local_paths() {
let path = std::env::temp_dir().join("wist-release-with-client.bin");
std::fs::write(&path, b"payload").expect("write");
let client = reqwest::Client::new();
assert_eq!(
read_source_with_client(&client, &path.to_string_lossy(), 1024, FETCH_TIMEOUT)
.await
.expect("read"),
b"payload"
);
assert!(matches!(
read_source_with_client(&client, "/definitely/not/here.bin", 1024, FETCH_TIMEOUT).await,
Err(PackageError::SourceUnavailable(_))
));
let _ = std::fs::remove_file(path);
}
#[tokio::test]
async fn reads_a_local_path_and_verifies_the_expected_digest() {
let path = std::env::temp_dir().join("wist-release-src.bin");
std::fs::write(&path, b"payload").expect("write");
let source = path.to_string_lossy().to_string();
let (bytes, sha) = read_verified_source(&source, None).await.expect("read");
assert_eq!(bytes, b"payload");
assert_eq!(sha.len(), 64);
read_verified_source(&source, Some(&sha))
.await
.expect("matching digest");
read_verified_source(&source, Some(&format!("sha256:{sha}")))
.await
.expect("prefixed digest");
let err = read_verified_source(&source, Some("deadbeef"))
.await
.expect_err("mismatch");
assert!(matches!(err, PackageError::DigestMismatch(_)), "{err}");
let err = read_source("/definitely/not/here.bin")
.await
.expect_err("missing");
assert!(matches!(err, PackageError::SourceUnavailable(_)), "{err}");
let _ = std::fs::remove_file(path);
}
}