422 lines
15 KiB
Rust
422 lines
15 KiB
Rust
use super::*;
|
|
use http_body_util::BodyExt;
|
|
|
|
fn active_settings() -> Settings {
|
|
Settings {
|
|
enabled: true,
|
|
..Settings::default()
|
|
}
|
|
}
|
|
|
|
async fn store(
|
|
cache: &Arc<Cache>,
|
|
scope: &str,
|
|
host: &str,
|
|
target: &str,
|
|
request_headers: HeaderMap,
|
|
extra_response_headers: &[(&str, &str)],
|
|
body: &'static str,
|
|
) -> Ticket {
|
|
let ticket = cache
|
|
.ticket_scoped(
|
|
22,
|
|
scope,
|
|
"http",
|
|
host,
|
|
"origin@127.0.0.1:8080",
|
|
target,
|
|
&request_headers,
|
|
)
|
|
.unwrap();
|
|
let settings = active_settings();
|
|
let mut response = Response::new(Body::from(body));
|
|
response.headers_mut().insert(
|
|
"cache-control",
|
|
HeaderValue::from_static("public, max-age=120, stale-if-error=60"),
|
|
);
|
|
for (name, value) in extra_response_headers {
|
|
response.headers_mut().insert(
|
|
http::HeaderName::from_bytes(name.as_bytes()).unwrap(),
|
|
HeaderValue::from_str(value).unwrap(),
|
|
);
|
|
}
|
|
let plan = plan(
|
|
StatusCode::OK,
|
|
response.headers(),
|
|
&settings,
|
|
Duration::ZERO,
|
|
)
|
|
.unwrap();
|
|
cache
|
|
.wrap(response, ticket.clone(), plan, &settings)
|
|
.into_body()
|
|
.collect()
|
|
.await
|
|
.unwrap();
|
|
ticket
|
|
}
|
|
|
|
fn invalidation(
|
|
operation: InvalidationOperation,
|
|
selector: InvalidationSelector,
|
|
value: &str,
|
|
host: Option<&str>,
|
|
vhost: Option<&str>,
|
|
) -> InvalidationRequest {
|
|
InvalidationRequest {
|
|
operation,
|
|
selector,
|
|
value: value.to_owned(),
|
|
host: host.map(str::to_owned),
|
|
vhost: vhost.map(str::to_owned),
|
|
ttl_seconds: None,
|
|
confirm_wide: false,
|
|
}
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn cached_single_range_returns_206_and_preserves_validators() {
|
|
let cache = Cache::new(22);
|
|
let ticket = store(
|
|
&cache,
|
|
"range",
|
|
"range.example",
|
|
"/asset.bin",
|
|
HeaderMap::new(),
|
|
&[
|
|
("etag", "\"asset-v1\""),
|
|
("last-modified", "Mon, 26 Jan 2026 23:11:40 GMT"),
|
|
],
|
|
"abcdefghij",
|
|
)
|
|
.await;
|
|
let mut request_headers = HeaderMap::new();
|
|
request_headers.insert("range", HeaderValue::from_static("bytes=2-5"));
|
|
let range = match request_range(&Method::GET, &request_headers) {
|
|
RangeSelection::Single(range) => range,
|
|
other => panic!("unexpected range selection: {other:?}"),
|
|
};
|
|
let hit = cache.get(&ticket).unwrap().apply_range(range, None);
|
|
assert_eq!(hit.response.status(), StatusCode::PARTIAL_CONTENT);
|
|
assert_eq!(hit.response.headers()["content-range"], "bytes 2-5/10");
|
|
assert_eq!(hit.response.headers()["content-length"], "4");
|
|
assert_eq!(hit.response.headers()["accept-ranges"], "bytes");
|
|
assert_eq!(hit.response.headers()["etag"], "\"asset-v1\"");
|
|
assert!(hit.response.headers().contains_key("age"));
|
|
let body = hit.response.into_body().collect().await.unwrap().to_bytes();
|
|
assert_eq!(body, Bytes::from_static(b"cdef"));
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn cached_range_supports_suffix_open_unsatisfied_and_if_range() {
|
|
let cache = Cache::new(22);
|
|
let ticket = store(
|
|
&cache,
|
|
"range",
|
|
"range.example",
|
|
"/asset.bin",
|
|
HeaderMap::new(),
|
|
&[
|
|
("etag", "\"asset-v1\""),
|
|
("last-modified", "Mon, 26 Jan 2026 23:11:40 GMT"),
|
|
],
|
|
"abcdefghij",
|
|
)
|
|
.await;
|
|
let cases = [
|
|
(ByteRange { start: None, end: Some(3) }, "hij", "bytes 7-9/10"),
|
|
(ByteRange { start: Some(7), end: None }, "hij", "bytes 7-9/10"),
|
|
];
|
|
for (range, expected, content_range) in cases {
|
|
let hit = cache.get(&ticket).unwrap().apply_range(range, None);
|
|
assert_eq!(hit.response.status(), StatusCode::PARTIAL_CONTENT);
|
|
assert_eq!(hit.response.headers()["content-range"], content_range);
|
|
let body = hit.response.into_body().collect().await.unwrap().to_bytes();
|
|
assert_eq!(body, Bytes::copy_from_slice(expected.as_bytes()));
|
|
}
|
|
|
|
let unsatisfied = cache.get(&ticket).unwrap().apply_range(
|
|
ByteRange { start: Some(50), end: None },
|
|
None,
|
|
);
|
|
assert_eq!(unsatisfied.response.status(), StatusCode::RANGE_NOT_SATISFIABLE);
|
|
assert_eq!(unsatisfied.response.headers()["content-range"], "bytes */10");
|
|
assert_eq!(
|
|
unsatisfied.response.into_body().collect().await.unwrap().to_bytes().len(),
|
|
0
|
|
);
|
|
|
|
let mismatch = HeaderValue::from_static("\"asset-v2\"");
|
|
let full = cache.get(&ticket).unwrap().apply_range(
|
|
ByteRange { start: Some(0), end: Some(2) },
|
|
Some(&mismatch),
|
|
);
|
|
assert_eq!(full.response.status(), StatusCode::OK);
|
|
assert!(!full.response.headers().contains_key("content-range"));
|
|
assert_eq!(
|
|
full.response.into_body().collect().await.unwrap().to_bytes(),
|
|
Bytes::from_static(b"abcdefghij")
|
|
);
|
|
|
|
let matched = HeaderValue::from_static("\"asset-v1\"");
|
|
let partial = cache.get(&ticket).unwrap().apply_range(
|
|
ByteRange { start: Some(0), end: Some(2) },
|
|
Some(&matched),
|
|
);
|
|
assert_eq!(partial.response.status(), StatusCode::PARTIAL_CONTENT);
|
|
}
|
|
|
|
#[test]
|
|
fn range_parser_rejects_multipart_and_duplicate_fields_and_if_range_date_allows_older_representation() {
|
|
let mut multipart = HeaderMap::new();
|
|
multipart.insert("range", HeaderValue::from_static("bytes=0-1,4-5"));
|
|
assert_eq!(
|
|
request_range(&Method::GET, &multipart),
|
|
RangeSelection::Unsupported
|
|
);
|
|
|
|
let mut duplicate = HeaderMap::new();
|
|
duplicate.append("range", HeaderValue::from_static("bytes=0-1"));
|
|
duplicate.append("range", HeaderValue::from_static("bytes=4-5"));
|
|
assert_eq!(
|
|
request_range(&Method::GET, &duplicate),
|
|
RangeSelection::Unsupported
|
|
);
|
|
|
|
let mut response_headers = HeaderMap::new();
|
|
response_headers.insert(
|
|
"last-modified",
|
|
HeaderValue::from_static("Mon, 26 Jan 2026 23:11:40 GMT"),
|
|
);
|
|
let newer_if_range = HeaderValue::from_static("Tue, 27 Jan 2026 23:11:40 GMT");
|
|
assert!(if_range_matches(&response_headers, Some(&newer_if_range)));
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn concurrent_miss_single_flight_waits_until_fill_is_published() {
|
|
let cache = Cache::new(22);
|
|
let mut settings = active_settings();
|
|
settings.collapse_wait_timeout_ms = 500;
|
|
let ticket = cache
|
|
.ticket_scoped(
|
|
22,
|
|
"collapse",
|
|
"http",
|
|
"collapse.example",
|
|
"origin@127.0.0.1:8080",
|
|
"/same",
|
|
&HeaderMap::new(),
|
|
)
|
|
.unwrap();
|
|
let leader = match cache.claim_fill(&ticket, &settings).await {
|
|
FillClaim::Leader(guard) => guard,
|
|
_ => panic!("first request must become fill leader"),
|
|
};
|
|
let follower_cache = cache.clone();
|
|
let follower_ticket = ticket.clone();
|
|
let follower_settings = settings.clone();
|
|
let follower = tokio::spawn(async move {
|
|
match follower_cache
|
|
.claim_fill(&follower_ticket, &follower_settings)
|
|
.await
|
|
{
|
|
FillClaim::Waited => follower_cache.get(&follower_ticket).is_some(),
|
|
_ => false,
|
|
}
|
|
});
|
|
for _ in 0..50 {
|
|
if cache.view().collapse_waiters == 1 {
|
|
break;
|
|
}
|
|
tokio::time::sleep(Duration::from_millis(2)).await;
|
|
}
|
|
assert_eq!(cache.view().collapse_waiters, 1);
|
|
assert!(!follower.is_finished());
|
|
|
|
let mut response = Response::new(Body::from("collapsed-payload"));
|
|
response.headers_mut().insert(
|
|
"cache-control",
|
|
HeaderValue::from_static("public, max-age=60"),
|
|
);
|
|
let plan = plan(
|
|
StatusCode::OK,
|
|
response.headers(),
|
|
&settings,
|
|
Duration::ZERO,
|
|
)
|
|
.unwrap();
|
|
cache
|
|
.wrap_with_fill(response, ticket.clone(), plan, &settings, Some(leader))
|
|
.into_body()
|
|
.collect()
|
|
.await
|
|
.unwrap();
|
|
assert!(follower.await.unwrap());
|
|
assert_eq!(cache.view().collapsed_fills, 1);
|
|
assert_eq!(cache.view().collapse_waiters, 0);
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn single_flight_timeout_and_leader_drop_release_the_key() {
|
|
let cache = Cache::new(22);
|
|
let mut settings = active_settings();
|
|
settings.collapse_wait_timeout_ms = 10;
|
|
let ticket = cache
|
|
.ticket(22, "http", "collapse.example", "origin", "/timeout", &HeaderMap::new())
|
|
.unwrap();
|
|
let leader = match cache.claim_fill(&ticket, &settings).await {
|
|
FillClaim::Leader(guard) => guard,
|
|
_ => panic!("missing leader"),
|
|
};
|
|
assert!(matches!(cache.claim_fill(&ticket, &settings).await, FillClaim::Timeout));
|
|
assert_eq!(cache.view().collapse_timeouts, 1);
|
|
drop(leader);
|
|
assert!(matches!(
|
|
cache.claim_fill(&ticket, &settings).await,
|
|
FillClaim::Leader(_)
|
|
));
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn cancelled_single_flight_waiter_releases_waiter_metric() {
|
|
let cache = Cache::new(22);
|
|
let mut settings = active_settings();
|
|
settings.collapse_wait_timeout_ms = 5_000;
|
|
let ticket = cache
|
|
.ticket(22, "http", "collapse.example", "origin", "/cancel", &HeaderMap::new())
|
|
.unwrap();
|
|
let leader = match cache.claim_fill(&ticket, &settings).await {
|
|
FillClaim::Leader(guard) => guard,
|
|
_ => panic!("missing leader"),
|
|
};
|
|
let follower_cache = cache.clone();
|
|
let follower_ticket = ticket.clone();
|
|
let follower_settings = settings.clone();
|
|
let follower = tokio::spawn(async move {
|
|
follower_cache
|
|
.claim_fill(&follower_ticket, &follower_settings)
|
|
.await
|
|
});
|
|
for _ in 0..50 {
|
|
if cache.view().collapse_waiters == 1 {
|
|
break;
|
|
}
|
|
tokio::time::sleep(Duration::from_millis(2)).await;
|
|
}
|
|
assert_eq!(cache.view().collapse_waiters, 1);
|
|
follower.abort();
|
|
let _ = follower.await;
|
|
tokio::task::yield_now().await;
|
|
assert_eq!(cache.view().collapse_waiters, 0);
|
|
drop(leader);
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn single_flight_retries_after_another_vary_representation_is_published() {
|
|
let cache = Cache::new(22);
|
|
let mut settings = active_settings();
|
|
settings.collapse_wait_timeout_ms = 500;
|
|
let mut en_headers = HeaderMap::new();
|
|
en_headers.insert("accept-language", HeaderValue::from_static("en"));
|
|
let mut pl_headers = HeaderMap::new();
|
|
pl_headers.insert("accept-language", HeaderValue::from_static("pl"));
|
|
let en = cache
|
|
.ticket(22, "http", "vary-collapse.example", "origin", "/page", &en_headers)
|
|
.unwrap();
|
|
let pl = cache
|
|
.ticket(22, "http", "vary-collapse.example", "origin", "/page", &pl_headers)
|
|
.unwrap();
|
|
assert_eq!(en.key, pl.key, "Vary is learned from the response");
|
|
let leader = match cache.claim_fill(&en, &settings).await {
|
|
FillClaim::Leader(guard) => guard,
|
|
_ => panic!("first representation must become leader"),
|
|
};
|
|
let follower_cache = cache.clone();
|
|
let follower_ticket = pl.clone();
|
|
let follower_settings = settings.clone();
|
|
let follower = tokio::spawn(async move {
|
|
assert!(matches!(
|
|
follower_cache
|
|
.claim_fill(&follower_ticket, &follower_settings)
|
|
.await,
|
|
FillClaim::Waited
|
|
));
|
|
assert!(follower_cache.get(&follower_ticket).is_none());
|
|
matches!(
|
|
follower_cache
|
|
.claim_fill(&follower_ticket, &follower_settings)
|
|
.await,
|
|
FillClaim::Leader(_)
|
|
)
|
|
});
|
|
for _ in 0..50 {
|
|
if cache.view().collapse_waiters == 1 {
|
|
break;
|
|
}
|
|
tokio::time::sleep(Duration::from_millis(2)).await;
|
|
}
|
|
|
|
let mut response = Response::new(Body::from("hello"));
|
|
response.headers_mut().insert(
|
|
"cache-control",
|
|
HeaderValue::from_static("public, max-age=60"),
|
|
);
|
|
response
|
|
.headers_mut()
|
|
.insert("vary", HeaderValue::from_static("Accept-Language"));
|
|
let plan = plan(
|
|
StatusCode::OK,
|
|
response.headers(),
|
|
&settings,
|
|
Duration::ZERO,
|
|
)
|
|
.unwrap();
|
|
cache
|
|
.wrap_with_fill(response, en, plan, &settings, Some(leader))
|
|
.into_body()
|
|
.collect()
|
|
.await
|
|
.unwrap();
|
|
assert!(follower.await.unwrap());
|
|
}
|
|
|
|
#[test]
|
|
fn stale_if_error_policy_is_configurable_by_error_class_and_status() {
|
|
let mut settings = Settings::default();
|
|
settings.stale_if_error_timeout = false;
|
|
settings.stale_if_error_dns = false;
|
|
settings.stale_if_error_statuses = vec![500, 503];
|
|
assert!(!settings.allows_stale_error_class(StaleErrorClass::Timeout));
|
|
assert!(!settings.allows_stale_error_class(StaleErrorClass::Dns));
|
|
assert!(settings.allows_stale_error_class(StaleErrorClass::Connection));
|
|
assert!(settings.allows_stale_error_class(StaleErrorClass::Tls));
|
|
assert!(settings.allows_stale_error_status(StatusCode::INTERNAL_SERVER_ERROR));
|
|
assert!(settings.allows_stale_error_status(StatusCode::SERVICE_UNAVAILABLE));
|
|
assert!(!settings.allows_stale_error_status(StatusCode::BAD_GATEWAY));
|
|
}
|
|
|
|
#[test]
|
|
fn proactive_refresh_guards_deduplicate_and_bound_parallel_work() {
|
|
let cache = Cache::new(22);
|
|
let ticket = cache
|
|
.ticket(22, "http", "refresh.example", "origin", "/asset", &HeaderMap::new())
|
|
.unwrap();
|
|
let mut settings = active_settings();
|
|
settings.proactive_refresh_enabled = true;
|
|
settings.proactive_refresh_percent = 100;
|
|
settings.proactive_refresh_max_inflight = 1;
|
|
let scheduled = cache
|
|
.begin_proactive_schedule(&ticket, &settings)
|
|
.expect("first schedule");
|
|
assert!(cache.begin_proactive_schedule(&ticket, &settings).is_none());
|
|
let running = cache
|
|
.try_begin_proactive_refresh(&settings)
|
|
.expect("first inflight refresh");
|
|
assert!(cache.try_begin_proactive_refresh(&settings).is_none());
|
|
assert_eq!(cache.view().proactive_inflight, 1);
|
|
drop(running);
|
|
drop(scheduled);
|
|
assert!(cache.begin_proactive_schedule(&ticket, &settings).is_some());
|
|
assert_eq!(cache.view().proactive_inflight, 0);
|
|
}
|