use axum::{
Router,
body::{Body, to_bytes},
http::{Request, StatusCode, header},
};
use base64::{Engine, engine::general_purpose::STANDARD};
use clap::Parser;
use fluentci_cache::{Config, router};
use futures_util::stream;
use object_store::{ObjectStore, memory::InMemory};
use sha2::{Digest, Sha256};
use std::{
io,
sync::{
Arc,
atomic::{AtomicUsize, Ordering},
},
};
use tower::ServiceExt;
#[derive(Parser)]
struct Options {
#[command(flatten)]
config: Config,
}
fn config() -> Config {
Options::parse_from(["test", "--backend", "memory", "--token", "test-token"]).config
}
fn app() -> Router {
router(config(), Arc::new(InMemory::new())).unwrap()
}
fn request(method: &str, path: &str, body: impl Into
) -> Request {
Request::builder()
.method(method)
.uri(path)
.header(header::AUTHORIZATION, "Bearer test-token")
.body(body.into())
.unwrap()
}
async fn bytes(response: axum::response::Response) -> bytes::Bytes {
to_bytes(response.into_body(), 32 * 1024 * 1024)
.await
.unwrap()
}
#[tokio::test]
async fn all_protocols_round_trip_and_head() {
let app = app();
let digest = hex::encode(Sha256::digest(b"artifact"));
for path in [
format!("/cas/{digest}"),
format!("/ac/{digest}"),
format!("/bazel/cas/{digest}"),
"/gradle/task".into(),
"/sccache/a/b/key".into(),
"/maven/v1/org.example/module/hash/buildinfo.xml".into(),
"/generic/team/key".into(),
"/gocache/action".into(),
"/0123456789abcdfghijklmnpqrsvwxyz.narinfo".into(),
"/nar/object.nar.zst".into(),
"/nix/nar/object.nar.xz".into(),
] {
let response = app
.clone()
.oneshot(request("PUT", &path, "artifact"))
.await
.unwrap();
assert_eq!(response.status(), StatusCode::CREATED, "{path}");
let response = app
.clone()
.oneshot(request("GET", &path, Body::empty()))
.await
.unwrap();
assert_eq!(response.status(), StatusCode::OK, "{path}");
assert_eq!(bytes(response).await, "artifact");
let response = app
.clone()
.oneshot(request("HEAD", &path, Body::empty()))
.await
.unwrap();
assert_eq!(response.status(), StatusCode::OK);
assert_eq!(response.headers()[header::CONTENT_LENGTH], "8");
assert!(bytes(response).await.is_empty());
}
}
#[tokio::test]
async fn duplicate_nars_enforce_size_and_body_integrity() {
let mut config = config();
config.max_upload = 8;
let app = router(config, Arc::new(InMemory::new())).unwrap();
let path = format!("/nix/nar/{}.nar.zst", "a".repeat(52));
assert_eq!(
app.clone()
.oneshot(request("PUT", &path, "original"))
.await
.unwrap()
.status(),
StatusCode::CREATED
);
let oversized = stream::iter([
Ok::<_, io::Error>(bytes::Bytes::from_static(b"12345678")),
Ok(bytes::Bytes::from_static(b"9")),
]);
assert_eq!(
app.clone()
.oneshot(request("PUT", &path, Body::from_stream(oversized)))
.await
.unwrap()
.status(),
StatusCode::PAYLOAD_TOO_LARGE
);
let broken =
stream::once(async { Err::(io::Error::other("interrupted duplicate")) });
assert_eq!(
app.clone()
.oneshot(request("PUT", &path, Body::from_stream(broken)))
.await
.unwrap()
.status(),
StatusCode::BAD_REQUEST
);
assert_eq!(
bytes(
app.oneshot(request("GET", &path, Body::empty()))
.await
.unwrap()
)
.await,
"original"
);
}
#[tokio::test]
async fn duplicate_hash_addressed_nars_drain_body_without_rewriting_and_require_auth() {
let app = app();
for path in [
format!("/nix/nar/{}.nar.zst", "a".repeat(52)),
format!("/nar/{}.nar.xz", "b".repeat(52)),
format!(
"/accounts/{}/nix/nar/{}.nar.zst",
"did:plc:aaaaaaaaaaaaaaaaaaaaaaaa",
"c".repeat(52)
),
] {
assert_eq!(
app.clone()
.oneshot(request("PUT", &path, "original"))
.await
.unwrap()
.status(),
StatusCode::CREATED
);
let consumed = Arc::new(AtomicUsize::new(0));
let observed = consumed.clone();
let duplicate = stream::iter((0..16).map(move |_| {
observed.fetch_add(1, Ordering::Relaxed);
Ok::<_, io::Error>(bytes::Bytes::from_static(b"duplicate chunk"))
}));
assert_eq!(
app.clone()
.oneshot(request("PUT", &path, Body::from_stream(duplicate)))
.await
.unwrap()
.status(),
StatusCode::OK
);
assert_eq!(consumed.load(Ordering::Relaxed), 16);
assert_eq!(
bytes(
app.clone()
.oneshot(request("GET", &path, Body::empty()))
.await
.unwrap()
)
.await,
"original"
);
let unauthorized = Request::builder()
.method("PUT")
.uri(&path)
.body(Body::empty())
.unwrap();
assert_eq!(
app.clone().oneshot(unauthorized).await.unwrap().status(),
StatusCode::UNAUTHORIZED
);
}
for path in [
"/nix/package.narinfo",
"/gradle/task",
"/generic/key",
"/nix/nar/named-payload.nar.zst",
] {
for body in ["first", "updated"] {
assert_eq!(
app.clone()
.oneshot(request("PUT", path, body))
.await
.unwrap()
.status(),
StatusCode::CREATED
);
}
assert_eq!(
bytes(
app.clone()
.oneshot(request("GET", path, Body::empty()))
.await
.unwrap()
)
.await,
"updated"
);
}
}
#[tokio::test]
async fn public_reads_and_token_required_writes() {
let app = app();
for auth in [None, Some("Bearer wrong"), Some("Basic !!!")] {
let mut builder = Request::builder().method("PUT").uri("/generic/key");
if let Some(auth) = auth {
builder = builder.header(header::AUTHORIZATION, auth);
}
let response = app
.clone()
.oneshot(builder.body(Body::from("bad")).unwrap())
.await
.unwrap();
assert_eq!(response.status(), StatusCode::UNAUTHORIZED);
assert!(response.headers().contains_key(header::WWW_AUTHENTICATE));
}
let auth = format!("Basic {}", STANDARD.encode("ci:test-token"));
let response = app
.clone()
.oneshot(
Request::builder()
.method("PUT")
.uri("/generic/key")
.header(header::AUTHORIZATION, auth)
.body(Body::from("ok"))
.unwrap(),
)
.await
.unwrap();
assert_eq!(response.status(), StatusCode::CREATED);
let response = app
.oneshot(
Request::builder()
.uri("/generic/key")
.body(Body::empty())
.unwrap(),
)
.await
.unwrap();
assert_eq!(bytes(response).await, "ok");
}
#[tokio::test]
async fn private_reads_and_metrics_require_auth() {
let mut config = config();
config.public_read = false;
let app = router(config, Arc::new(InMemory::new())).unwrap();
for path in ["/generic/key", "/nix-cache-info", "/metrics", "/readyz"] {
assert_eq!(
app.clone()
.oneshot(Request::builder().uri(path).body(Body::empty()).unwrap())
.await
.unwrap()
.status(),
StatusCode::UNAUTHORIZED
);
}
assert_eq!(
app.clone()
.oneshot(
Request::builder()
.uri("/healthz")
.body(Body::empty())
.unwrap()
)
.await
.unwrap()
.status(),
StatusCode::OK
);
assert_eq!(
app.clone()
.oneshot(request("GET", "/readyz", Body::empty()))
.await
.unwrap()
.status(),
StatusCode::OK
);
}
#[tokio::test]
async fn read_only_and_missing_write_token() {
let mut config = config();
config.token = None;
assert!(router(config.clone(), Arc::new(InMemory::new())).is_err());
config.read_only = true;
let app = router(config, Arc::new(InMemory::new())).unwrap();
assert_eq!(
app.oneshot(request("PUT", "/generic/key", "value"))
.await
.unwrap()
.status(),
StatusCode::FORBIDDEN
);
}
#[tokio::test]
async fn misses_and_namespace_isolation() {
let app = app();
app.clone()
.oneshot(request("PUT", "/generic/key", "private namespace"))
.await
.unwrap();
for path in [
"/gradle/key",
"/sccache/key",
"/generic/absent",
"/unknown/key",
] {
let response = app
.clone()
.oneshot(request("GET", path, Body::empty()))
.await
.unwrap();
assert_eq!(response.status(), StatusCode::NOT_FOUND);
assert_eq!(response.headers()[header::CACHE_CONTROL], "no-store");
}
}
#[tokio::test]
async fn ranges_and_conditionals() {
let app = app();
app.clone()
.oneshot(request("PUT", "/generic/key", "0123456789"))
.await
.unwrap();
for (range, expected, content_range) in [
("bytes=2-5", "2345", "bytes 2-5/10"),
("bytes=7-", "789", "bytes 7-9/10"),
("bytes=-3", "789", "bytes 7-9/10"),
("bytes=8-99", "89", "bytes 8-9/10"),
] {
let mut req = request("GET", "/generic/key", Body::empty());
req.headers_mut()
.insert(header::RANGE, range.parse().unwrap());
let response = app.clone().oneshot(req).await.unwrap();
assert_eq!(response.status(), StatusCode::PARTIAL_CONTENT);
assert_eq!(response.headers()[header::CONTENT_RANGE], content_range);
assert_eq!(bytes(response).await, expected);
}
for range in [
"bytes=100-",
"bytes=3-1",
"bytes=-0",
"bytes=0-1,4-5",
"nonsense",
] {
let mut req = request("GET", "/generic/key", Body::empty());
req.headers_mut()
.insert(header::RANGE, range.parse().unwrap());
assert_eq!(
app.clone().oneshot(req).await.unwrap().status(),
StatusCode::RANGE_NOT_SATISFIABLE
);
}
let response = app
.clone()
.oneshot(request("GET", "/generic/key", Body::empty()))
.await
.unwrap();
let etag = response.headers()[header::ETAG].clone();
assert!(etag.to_str().unwrap().starts_with('"'));
drop(response);
for (name, value, expected) in [
(header::IF_NONE_MATCH, etag, StatusCode::NOT_MODIFIED),
(
header::IF_MATCH,
"\"wrong\"".parse().unwrap(),
StatusCode::PRECONDITION_FAILED,
),
] {
let mut req = request("GET", "/generic/key", Body::empty());
req.headers_mut().insert(name, value);
assert_eq!(app.clone().oneshot(req).await.unwrap().status(), expected);
}
}
#[tokio::test]
async fn nix_discovery_and_aliases() {
let app = app();
for path in ["/nix-cache-info", "/nix/nix-cache-info"] {
let response = app
.clone()
.oneshot(request("GET", path, Body::empty()))
.await
.unwrap();
assert_eq!(
response.headers()[header::CONTENT_TYPE],
"text/x-nix-cache-info"
);
assert_eq!(
bytes(response).await,
"StoreDir: /nix/store\nWantMassQuery: 0\nPriority: 40\n"
);
assert_eq!(
app.clone()
.oneshot(request("PUT", path, "bad"))
.await
.unwrap()
.status(),
StatusCode::FORBIDDEN
);
}
app.clone()
.oneshot(request("PUT", "/nix/hash.narinfo", "signed metadata"))
.await
.unwrap();
let response = app
.oneshot(request("GET", "/hash.narinfo", Body::empty()))
.await
.unwrap();
assert_eq!(
response.headers()[header::CONTENT_TYPE],
"text/x-nix-narinfo"
);
assert_eq!(bytes(response).await, "signed metadata");
}
#[tokio::test]
async fn invalid_keys_and_methods() {
let app = app();
for path in [
"/generic/../escape",
"/generic/%2e%2e/escape",
"/generic/a%2Fb/../c",
"/generic/a%5Cb",
"/generic/a//b",
"/generic/%00",
"/cas/short",
"/bazel/unknown/key",
"/generic",
] {
assert_eq!(
app.clone()
.oneshot(request("PUT", path, "bad"))
.await
.unwrap()
.status(),
StatusCode::BAD_REQUEST,
"{path}"
);
}
for method in ["DELETE", "POST", "PATCH", "PROPFIND", "MKCOL"] {
let response = app
.clone()
.oneshot(request(method, "/generic/key", Body::empty()))
.await
.unwrap();
assert_eq!(response.status(), StatusCode::METHOD_NOT_ALLOWED);
assert_eq!(response.headers()[header::ALLOW], "GET, HEAD, PUT");
}
}
#[tokio::test]
async fn upload_limits_apply_to_declared_and_streamed_bodies() {
let mut config = config();
config.max_upload = 4;
let app = router(config, Arc::new(InMemory::new())).unwrap();
let mut req = request("PUT", "/generic/declared", "small");
req.headers_mut()
.insert(header::CONTENT_LENGTH, "5".parse().unwrap());
assert_eq!(
app.clone().oneshot(req).await.unwrap().status(),
StatusCode::PAYLOAD_TOO_LARGE
);
let stream = stream::iter([
Ok::<_, io::Error>(bytes::Bytes::from_static(b"123")),
Ok(bytes::Bytes::from_static(b"45")),
]);
assert_eq!(
app.clone()
.oneshot(request(
"PUT",
"/generic/streamed",
Body::from_stream(stream)
))
.await
.unwrap()
.status(),
StatusCode::PAYLOAD_TOO_LARGE
);
assert_eq!(
app.oneshot(request("GET", "/generic/streamed", Body::empty()))
.await
.unwrap()
.status(),
StatusCode::NOT_FOUND
);
}
#[tokio::test]
async fn cas_rejects_poisoning_without_replacing_previous_content() {
let app = app();
let path = format!("/cas/{}", hex::encode(Sha256::digest(b"valid")));
assert_eq!(
app.clone()
.oneshot(request("PUT", &path, "valid"))
.await
.unwrap()
.status(),
StatusCode::CREATED
);
assert_eq!(
app.clone()
.oneshot(request("PUT", &path, "invalid"))
.await
.unwrap()
.status(),
StatusCode::BAD_REQUEST
);
assert_eq!(
bytes(
app.oneshot(request("GET", &path, Body::empty()))
.await
.unwrap()
)
.await,
"valid"
);
}
#[tokio::test]
async fn multipart_upload_and_interrupted_overwrite_are_atomic() {
let app = app();
let payload = bytes::Bytes::from(vec![42; 17 * 1024 * 1024 + 7]);
assert_eq!(
app.clone()
.oneshot(request("PUT", "/generic/large", payload.clone()))
.await
.unwrap()
.status(),
StatusCode::CREATED
);
let chunks = stream::iter([
Ok(bytes::Bytes::from(vec![9; 9 * 1024 * 1024])),
Err(io::Error::other("client disconnected")),
]);
assert_eq!(
app.clone()
.oneshot(request("PUT", "/generic/large", Body::from_stream(chunks)))
.await
.unwrap()
.status(),
StatusCode::BAD_REQUEST
);
assert_eq!(
bytes(
app.clone()
.oneshot(request("GET", "/generic/large", Body::empty()))
.await
.unwrap()
)
.await,
payload
);
}
#[tokio::test]
async fn download_holds_concurrency_permit_until_consumed_or_dropped() {
let mut config = config();
config.concurrency = 1;
let app = router(config, Arc::new(InMemory::new())).unwrap();
app.clone()
.oneshot(request("PUT", "/generic/key", "data"))
.await
.unwrap();
let download = app
.clone()
.oneshot(request("GET", "/generic/key", Body::empty()))
.await
.unwrap();
assert_eq!(
app.clone()
.oneshot(request("PUT", "/generic/other", "data"))
.await
.unwrap()
.status(),
StatusCode::SERVICE_UNAVAILABLE
);
drop(download);
assert_eq!(
app.oneshot(request("PUT", "/generic/other", "data"))
.await
.unwrap()
.status(),
StatusCode::CREATED
);
}
#[tokio::test]
async fn upload_deadline_does_not_publish_partial_objects() {
let mut config = config();
config.timeout = 1;
let app = router(config, Arc::new(InMemory::new())).unwrap();
let stalled = stream::once(async {
tokio::time::sleep(std::time::Duration::from_secs(60)).await;
Ok::<_, io::Error>(bytes::Bytes::from_static(b"late"))
});
assert_eq!(
app.clone()
.oneshot(request(
"PUT",
"/generic/stalled",
Body::from_stream(stalled)
))
.await
.unwrap()
.status(),
StatusCode::REQUEST_TIMEOUT
);
assert_eq!(
app.oneshot(request("GET", "/generic/stalled", Body::empty()))
.await
.unwrap()
.status(),
StatusCode::NOT_FOUND
);
}
#[tokio::test]
async fn filesystem_persists_across_router_restarts() {
let directory = tempfile::tempdir().unwrap();
let mut config = config();
config.backend = fluentci_cache::config::Backend::File;
config.directory = directory.path().to_owned();
let first = router(config.clone(), config.storage().unwrap()).unwrap();
first
.oneshot(request("PUT", "/generic/key", "persisted"))
.await
.unwrap();
let second = router(config.clone(), config.storage().unwrap()).unwrap();
assert_eq!(
bytes(
second
.oneshot(request("GET", "/generic/key", Body::empty()))
.await
.unwrap()
)
.await,
"persisted"
);
}
#[tokio::test]
async fn metrics_record_reads_writes_and_misses() {
let app = app();
app.clone()
.oneshot(request("PUT", "/generic/key", "abc"))
.await
.unwrap();
bytes(
app.clone()
.oneshot(request("GET", "/generic/key", Body::empty()))
.await
.unwrap(),
)
.await;
app.clone()
.oneshot(request("GET", "/generic/missing", Body::empty()))
.await
.unwrap();
let metrics = bytes(
app.oneshot(request("GET", "/metrics", Body::empty()))
.await
.unwrap(),
)
.await;
let metrics = String::from_utf8(metrics.to_vec()).unwrap();
for expected in [
"fluentci_cache_requests_total 3",
"fluentci_cache_hits_total 1",
"fluentci_cache_misses_total 1",
"fluentci_cache_writes_total 1",
"fluentci_cache_bytes_written_total 3",
] {
assert!(metrics.contains(expected), "{metrics}");
}
}
#[tokio::test]
async fn oversized_cas_mismatch_never_commits_multipart() {
let app = app();
let path = format!("/cas/{}", "0".repeat(64));
assert_eq!(
app.clone()
.oneshot(request("PUT", &path, vec![7; 9 * 1024 * 1024]))
.await
.unwrap()
.status(),
StatusCode::BAD_REQUEST
);
assert_eq!(
app.oneshot(request("GET", &path, Body::empty()))
.await
.unwrap()
.status(),
StatusCode::NOT_FOUND
);
}
#[tokio::test]
#[ignore = "requires an S3-compatible service; see README"]
async fn s3_backend_round_trip() {
let mut config = config();
config.backend = fluentci_cache::config::Backend::S3;
config.bucket = Some(std::env::var("FLUENTCI_CACHE_TEST_BUCKET").expect("set test bucket"));
config.endpoint = std::env::var("FLUENTCI_CACHE_TEST_ENDPOINT").ok();
config.cdn_url = Some(
std::env::var("FLUENTCI_CACHE_TEST_CDN_URL").expect("set public CDN URL at bucket root"),
);
config.allow_http = config
.endpoint
.as_ref()
.is_some_and(|v| v.starts_with("http://"));
config.prefix = format!(
"fluentci-cache-tests/{}",
std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.unwrap()
.as_nanos()
);
let store = config.storage().unwrap();
let app = router(config, store.clone()).unwrap();
let payload = bytes::Bytes::from(vec![3; 17 * 1024 * 1024]);
assert_eq!(
app.clone()
.oneshot(request("PUT", "/generic/large", payload.clone()))
.await
.unwrap()
.status(),
StatusCode::CREATED
);
assert_eq!(
bytes(
app.clone()
.oneshot(request("GET", "/generic/large", Body::empty()))
.await
.unwrap()
)
.await,
payload
);
let mut ranged = request("GET", "/generic/large", Body::empty());
ranged
.headers_mut()
.insert(header::RANGE, "bytes=3-7".parse().unwrap());
let ranged = app.clone().oneshot(ranged).await.unwrap();
assert_eq!(ranged.status(), StatusCode::PARTIAL_CONTENT);
assert_eq!(bytes(ranged).await, vec![3; 5]);
assert_eq!(
app.clone()
.oneshot(request("HEAD", "/generic/large", Body::empty()))
.await
.unwrap()
.headers()[header::CONTENT_LENGTH],
(17 * 1024 * 1024).to_string()
);
assert_eq!(
app.clone()
.oneshot(request("PUT", "/generic/small", "small"))
.await
.unwrap()
.status(),
StatusCode::CREATED
);
assert_eq!(
bytes(
app.oneshot(request("GET", "/generic/small", Body::empty()))
.await
.unwrap()
)
.await,
"small"
);
store
.delete(&object_store::path::Path::from("generic/small"))
.await
.unwrap();
store
.delete(&object_store::path::Path::from("generic/large"))
.await
.unwrap();
}