591 lines
22 KiB
Rust
591 lines
22 KiB
Rust
mod dashboard_tests {
|
|
use super::*;
|
|
use http_body_util::BodyExt;
|
|
async fn fill(cache: &Arc<Cache>, scope: &str, host: &str, path: &str) -> Ticket {
|
|
let t = cache
|
|
.ticket_scoped(
|
|
7,
|
|
scope,
|
|
"http",
|
|
host,
|
|
"origin@127.0.0.1:8080",
|
|
path,
|
|
&HeaderMap::new(),
|
|
)
|
|
.unwrap();
|
|
let settings = Settings {
|
|
enabled: true,
|
|
..Settings::default()
|
|
};
|
|
let mut response = Response::new(Body::from("public representation"));
|
|
response.headers_mut().insert(
|
|
"cache-control",
|
|
HeaderValue::from_static("public, max-age=30"),
|
|
);
|
|
response
|
|
.headers_mut()
|
|
.insert("vary", HeaderValue::from_static("Accept-Language"));
|
|
let p = plan(
|
|
StatusCode::OK,
|
|
response.headers(),
|
|
&settings,
|
|
Duration::ZERO,
|
|
)
|
|
.unwrap();
|
|
cache
|
|
.wrap(response, t.clone(), p, &settings)
|
|
.into_body()
|
|
.collect()
|
|
.await
|
|
.unwrap();
|
|
t
|
|
}
|
|
#[tokio::test]
|
|
async fn dashboard_is_scoped_paginated_and_exposes_invalidation_identity_not_bodies() {
|
|
let cache = Cache::new(7);
|
|
let a = fill(&cache, "alpha", "a.example", "/data?private-query=secret").await;
|
|
fill(&cache, "beta", "b.example", "/other").await;
|
|
cache.record("alpha", "a.example", "MISS", "cache_miss");
|
|
assert!(cache.get(&a).is_some());
|
|
cache.record("alpha", "a.example", "HIT", "cache_hit");
|
|
cache.record("alpha", "a.example", "BYPASS", "request_cookie");
|
|
let d = cache.dashboard(Some("alpha"), 0, 50);
|
|
assert_eq!(d.matching_objects, 1);
|
|
assert_eq!(d.domains.len(), 1);
|
|
assert_eq!(d.domains[0].counters.hits, 1);
|
|
assert_eq!(d.domains[0].counters.stored, 1);
|
|
assert_eq!(d.domains[0].counters.saved_body_bytes, 21);
|
|
assert_eq!(d.objects[0].path, "/data");
|
|
assert_eq!(d.objects[0].target, "/data?private-query=secret");
|
|
assert_eq!(d.objects[0].cache_key.len(), 64);
|
|
assert_eq!(d.objects[0].hits, 1);
|
|
let encoded = serde_json::to_string(&d).unwrap();
|
|
assert!(encoded.contains("private-query=secret"));
|
|
assert!(!encoded.contains("public representation"));
|
|
assert_eq!(cache.dashboard(None, 1, 1).objects.len(), 1);
|
|
assert_eq!(cache.dashboard(None, 99, 999).limit, 200);
|
|
assert_eq!(cache.purge_scope("alpha"), 1);
|
|
assert_eq!(cache.dashboard(Some("beta"), 0, 50).matching_objects, 1);
|
|
assert_eq!(
|
|
cache.dashboard(Some("alpha"), 0, 50).domains[0]
|
|
.counters
|
|
.hits,
|
|
1
|
|
);
|
|
cache.purge(Some(8));
|
|
assert!(cache.dashboard(None, 0, 50).domains.is_empty());
|
|
}
|
|
#[tokio::test]
|
|
async fn dashboard_retains_expired_entries_for_client_max_stale() {
|
|
let cache = Cache::new(7);
|
|
let ticket = fill(&cache, "a", "a.example", "/").await;
|
|
{
|
|
let mut store = cache.store.lock().unwrap();
|
|
for entry in store.entries.values_mut() {
|
|
entry.received = Instant::now() - Duration::from_secs(2 * 60 * 60);
|
|
}
|
|
}
|
|
let dashboard = cache.dashboard(None, 0, 50);
|
|
assert_eq!(dashboard.matching_objects, 1);
|
|
assert_eq!(dashboard.objects[0].remaining_ttl_seconds, 0);
|
|
assert!(dashboard.objects[0].age_seconds >= 2 * 60 * 60);
|
|
assert_eq!(cache.view().entries, 1);
|
|
assert_eq!(cache.view().expired, 0);
|
|
assert!(
|
|
cache.get(&ticket).is_none(),
|
|
"inventory visibility cannot permit unconditional stale delivery"
|
|
);
|
|
let mut stale = ticket;
|
|
stale
|
|
.request_headers
|
|
.insert("cache-control", HeaderValue::from_static("max-stale"));
|
|
assert!(cache.get(&stale).unwrap().stale);
|
|
}
|
|
#[test]
|
|
fn bypass_reasons_are_fixed_and_private_inputs_are_not_echoed() {
|
|
let settings = Settings {
|
|
varnish_compatible: false,
|
|
..Settings::default()
|
|
};
|
|
let mut headers = HeaderMap::new();
|
|
headers.insert("cookie", HeaderValue::from_static("session=very-private"));
|
|
assert_eq!(
|
|
request_reason(&Method::GET, &headers, true, "/", false, &settings),
|
|
Some("request_cookie")
|
|
);
|
|
headers.remove("cookie");
|
|
headers.insert("cache-control", HeaderValue::from_static("no-cache"));
|
|
assert_eq!(
|
|
request_reason(&Method::GET, &headers, true, "/", false, &settings),
|
|
None
|
|
);
|
|
assert_eq!(
|
|
request_policy(&Method::GET, &headers, true, "/", false, &settings),
|
|
RequestPolicy::Revalidate("request_no_cache")
|
|
);
|
|
let diagnostics = Settings {
|
|
expose_status: true,
|
|
expose_cache_status: true,
|
|
..settings
|
|
};
|
|
diagnostics.annotate_reason_transformed(
|
|
&mut headers,
|
|
"BYPASS",
|
|
0,
|
|
0,
|
|
"request_cookie",
|
|
true,
|
|
);
|
|
assert_eq!(headers["x-cache-reason"], "request_cookie");
|
|
assert_eq!(
|
|
headers["cache-status"],
|
|
"RustProxy; fwd=bypass; detail=\"request_cookie\"; transformed"
|
|
);
|
|
}
|
|
#[test]
|
|
fn hit_only_cache_diagnostics_hides_miss_bypass_and_preserves_hits() {
|
|
let global = Settings {
|
|
expose_status: true,
|
|
expose_hits: true,
|
|
expose_cache_status: true,
|
|
expose_resident_age: true,
|
|
expose_only_hits: true,
|
|
..Settings::default()
|
|
};
|
|
let mut headers = HeaderMap::new();
|
|
headers.insert("x-cache", HeaderValue::from_static("untrusted-upstream"));
|
|
headers.insert("cache-status", HeaderValue::from_static("Origin; hit"));
|
|
global.annotate_reason_transformed(
|
|
&mut headers,
|
|
"MISS",
|
|
0,
|
|
0,
|
|
"response_headers_policy",
|
|
true,
|
|
);
|
|
assert_eq!(headers["x-cache"], "untrusted-upstream");
|
|
assert_eq!(headers["cache-status"], "Origin; hit");
|
|
assert!(!headers.contains_key("x-cache-hits"));
|
|
assert!(!headers.contains_key("x-cache-reason"));
|
|
assert_eq!(headers["via"], "RustProxy");
|
|
global.annotate_reason(&mut headers, "BYPASS", 0, 0, "request_cookie");
|
|
assert_eq!(headers.get_all("cache-status").iter().count(), 1);
|
|
global.annotate_reason(&mut headers, "HIT", 4, 60, "cache_hit");
|
|
global.annotate_resident_age(&mut headers, 10);
|
|
assert_eq!(headers["x-cache"], "HIT");
|
|
assert_eq!(headers["x-cache-hits"], "4");
|
|
let chain: Vec<_> = headers
|
|
.get_all("cache-status")
|
|
.iter()
|
|
.map(|value| value.to_str().unwrap())
|
|
.collect();
|
|
assert_eq!(
|
|
chain,
|
|
vec![
|
|
"Origin; hit",
|
|
"RustProxy; hit; ttl=60; detail=\"cache_hit\""
|
|
]
|
|
);
|
|
assert_eq!(headers["x-upstream-cache"], "untrusted-upstream");
|
|
assert_eq!(headers["x-cache-resident-age"], "10");
|
|
let mut override_on = Overrides {
|
|
expose_only_hits: Some(false),
|
|
..Default::default()
|
|
};
|
|
let normal = override_on.resolve(&global).unwrap();
|
|
assert!(!normal.expose_only_hits);
|
|
override_on.expose_only_hits = Some(true);
|
|
assert!(
|
|
override_on
|
|
.resolve(&Settings::default())
|
|
.unwrap()
|
|
.expose_only_hits
|
|
);
|
|
}
|
|
#[test]
|
|
fn via_header_is_configurable_and_preserves_upstream_chain() {
|
|
let settings = Settings::default();
|
|
let mut headers = HeaderMap::new();
|
|
headers.append("via", HeaderValue::from_static("1.1 upstream"));
|
|
settings.annotate(&mut headers, "HIT", 1, 20);
|
|
let values: Vec<_> = headers
|
|
.get_all("via")
|
|
.iter()
|
|
.map(|value| value.to_str().unwrap())
|
|
.collect();
|
|
assert_eq!(values, vec!["1.1 upstream", "RustProxy"]);
|
|
|
|
let disabled = Settings {
|
|
via_header: None,
|
|
..Settings::default()
|
|
};
|
|
let mut headers = HeaderMap::new();
|
|
disabled.annotate(&mut headers, "MISS", 0, 0);
|
|
assert!(!headers.contains_key("via"));
|
|
}
|
|
|
|
#[test]
|
|
fn disabled_cache_forwards_origin_diagnostics_unchanged() {
|
|
let settings = Settings {
|
|
enabled: false,
|
|
expose_status: true,
|
|
expose_hits: true,
|
|
expose_cache_status: true,
|
|
expose_resident_age: true,
|
|
..Settings::default()
|
|
};
|
|
let mut headers = HeaderMap::new();
|
|
headers.insert("x-cache", HeaderValue::from_static("origin"));
|
|
headers.insert("x-cache-hits", HeaderValue::from_static("99"));
|
|
headers.insert("x-cache-status", HeaderValue::from_static("origin"));
|
|
headers.insert("cache-status", HeaderValue::from_static("Origin; hit"));
|
|
headers.insert("x-cache-reason", HeaderValue::from_static("origin"));
|
|
headers.insert("x-cache-resident-age", HeaderValue::from_static("5"));
|
|
settings.annotate_reason(&mut headers, "BYPASS", 0, 0, "cache_disabled");
|
|
settings.annotate_resident_age(&mut headers, 9);
|
|
assert_eq!(headers["x-cache"], "origin");
|
|
assert_eq!(headers["x-cache-hits"], "99");
|
|
assert_eq!(headers["x-cache-status"], "origin");
|
|
assert_eq!(headers["cache-status"], "Origin; hit");
|
|
assert_eq!(headers["x-cache-reason"], "origin");
|
|
assert_eq!(headers["x-cache-resident-age"], "5");
|
|
assert!(!headers.contains_key("x-upstream-cache"));
|
|
assert!(!headers.contains_key("via"));
|
|
}
|
|
|
|
#[test]
|
|
fn chain_and_legacy_header_collisions_keep_origin_values() {
|
|
let settings = Settings {
|
|
expose_status: true,
|
|
expose_hits: true,
|
|
expose_cache_status: true,
|
|
expose_resident_age: true,
|
|
..Settings::default()
|
|
};
|
|
let mut headers = HeaderMap::new();
|
|
headers.append(
|
|
"cache-status",
|
|
HeaderValue::from_static("Inner; hit; ttl=100"),
|
|
);
|
|
headers.append("cache-status", HeaderValue::from_static("Shield; fwd=miss"));
|
|
for (name, value) in [
|
|
("x-cache", "BACKEND-MISS"),
|
|
("x-cache-hits", "21"),
|
|
("x-cache-reason", "origin_reason"),
|
|
("x-cache-resident-age", "17"),
|
|
("x-cache-status", "backend-status"),
|
|
] {
|
|
headers.insert(name, value.parse().unwrap());
|
|
}
|
|
settings.annotate_reason_transformed(&mut headers, "HIT", 3, 482, "cache_hit", true);
|
|
settings.annotate_resident_age(&mut headers, 9);
|
|
let cache_chain: Vec<_> = headers
|
|
.get_all("cache-status")
|
|
.iter()
|
|
.map(|value| value.to_str().unwrap())
|
|
.collect();
|
|
assert_eq!(
|
|
cache_chain,
|
|
vec![
|
|
"Inner; hit; ttl=100",
|
|
"Shield; fwd=miss",
|
|
"RustProxy; hit; ttl=482; detail=\"cache_hit\"; transformed",
|
|
]
|
|
);
|
|
assert_eq!(headers["x-cache"], "HIT");
|
|
assert_eq!(headers["x-upstream-cache"], "BACKEND-MISS");
|
|
assert_eq!(headers["x-cache-hits"], "3");
|
|
assert_eq!(headers["x-upstream-cache-hits"], "21");
|
|
assert_eq!(headers["x-cache-reason"], "cache_hit");
|
|
assert_eq!(headers["x-upstream-cache-reason"], "origin_reason");
|
|
assert_eq!(headers["x-cache-resident-age"], "9");
|
|
assert_eq!(headers["x-upstream-cache-resident-age"], "17");
|
|
assert_eq!(headers["x-cache-status"], "backend-status");
|
|
}
|
|
|
|
#[test]
|
|
fn diagnostic_options_do_not_hide_backend_cache_status() {
|
|
for (enabled, status, only_hits) in [
|
|
(true, false, false),
|
|
(true, true, true),
|
|
(false, true, false),
|
|
] {
|
|
let settings = Settings {
|
|
enabled,
|
|
expose_status: status,
|
|
expose_cache_status: status,
|
|
expose_only_hits: only_hits,
|
|
..Settings::default()
|
|
};
|
|
let mut headers = HeaderMap::new();
|
|
headers.insert("x-cache", HeaderValue::from_static("Backend; MISS"));
|
|
headers.insert("cache-status", HeaderValue::from_static("Origin; fwd=miss"));
|
|
settings.annotate_reason_transformed(&mut headers, "MISS", 0, 0, "cache_miss", true);
|
|
assert_eq!(headers["x-cache"], "Backend; MISS");
|
|
assert_eq!(headers["cache-status"], "Origin; fwd=miss");
|
|
assert_eq!(headers.get_all("cache-status").iter().count(), 1);
|
|
assert!(!headers.contains_key("x-upstream-cache"));
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn repeated_upstream_legacy_values_are_not_collapsed_or_discarded() {
|
|
let settings = Settings {
|
|
expose_status: true,
|
|
expose_cache_status: true,
|
|
..Settings::default()
|
|
};
|
|
let mut headers = HeaderMap::new();
|
|
headers.append("x-cache", HeaderValue::from_static("inner-HIT"));
|
|
headers.append("x-cache", HeaderValue::from_static("outer-MISS"));
|
|
headers.append("cache-status", HeaderValue::from_static("Inner; hit"));
|
|
headers.append("cache-status", HeaderValue::from_static("Outer; fwd=miss"));
|
|
settings.annotate_reason(&mut headers, "MISS", 0, 0, "cache_miss");
|
|
let upstream_values: Vec<_> = headers
|
|
.get_all("x-upstream-cache")
|
|
.iter()
|
|
.map(|value| value.to_str().unwrap())
|
|
.collect();
|
|
assert_eq!(upstream_values, vec!["inner-HIT", "outer-MISS"]);
|
|
assert_eq!(headers["x-cache"], "MISS");
|
|
let status_chain: Vec<_> = headers
|
|
.get_all("cache-status")
|
|
.iter()
|
|
.map(|value| value.to_str().unwrap())
|
|
.collect();
|
|
assert_eq!(
|
|
status_chain,
|
|
vec![
|
|
"Inner; hit",
|
|
"Outer; fwd=miss",
|
|
"RustProxy; fwd=miss; detail=\"cache_miss\"",
|
|
]
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn client_no_cache_miss_does_not_claim_a_fresh_candidate() {
|
|
let settings = Settings {
|
|
expose_cache_status: true,
|
|
..Settings::default()
|
|
};
|
|
let mut headers = HeaderMap::new();
|
|
settings.annotate_reason(&mut headers, "MISS", 0, 0, "request_no_cache");
|
|
assert_eq!(
|
|
headers["cache-status"],
|
|
"RustProxy; fwd=miss; detail=\"request_no_cache\"",
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn revalidated_304_is_forwarded_under_rfc_9211_even_if_legacy_x_cache_is_hit() {
|
|
let settings = Settings {
|
|
expose_status: true,
|
|
expose_cache_status: true,
|
|
..Settings::default()
|
|
};
|
|
let mut headers = HeaderMap::new();
|
|
headers.insert("cache-status", HeaderValue::from_static("Origin; hit"));
|
|
settings.annotate_reason_transformed(
|
|
&mut headers,
|
|
"HIT",
|
|
2,
|
|
50,
|
|
"cache_revalidated",
|
|
false,
|
|
);
|
|
assert_eq!(headers["x-cache"], "HIT");
|
|
let chain: Vec<_> = headers
|
|
.get_all("cache-status")
|
|
.iter()
|
|
.map(|v| v.to_str().unwrap())
|
|
.collect();
|
|
assert_eq!(
|
|
chain,
|
|
vec![
|
|
"Origin; hit",
|
|
"RustProxy; fwd=stale; fwd-status=304; detail=\"cache_revalidated\"",
|
|
]
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn rfc9211_method_bypass_and_stale_hit_do_not_misstate_freshness() {
|
|
assert_eq!(cache_status_ttl(1, 2), -1);
|
|
assert_eq!(cache_status_ttl(10, 10), 0);
|
|
assert_eq!(cache_status_ttl(600, 5), 595);
|
|
let settings = Settings {
|
|
expose_status: true,
|
|
expose_cache_status: true,
|
|
..Settings::default()
|
|
};
|
|
let mut headers = HeaderMap::new();
|
|
settings.annotate_reason(&mut headers, "BYPASS", 0, 0, "request_method");
|
|
assert_eq!(
|
|
headers["cache-status"],
|
|
"RustProxy; fwd=method; detail=\"request_method\"",
|
|
);
|
|
let mut headers = HeaderMap::new();
|
|
settings.annotate_reason_transformed_freshness(
|
|
&mut headers,
|
|
"HIT",
|
|
3,
|
|
-7,
|
|
"cache_max_stale",
|
|
false,
|
|
);
|
|
assert_eq!(
|
|
headers["cache-status"],
|
|
"RustProxy; hit; ttl=-7; detail=\"cache_max_stale\"",
|
|
);
|
|
let mut headers = HeaderMap::new();
|
|
settings.annotate_reason_transformed_freshness(
|
|
&mut headers,
|
|
"HIT",
|
|
3,
|
|
-5,
|
|
"cache_stale_while_revalidate",
|
|
false,
|
|
);
|
|
assert_eq!(
|
|
headers["cache-status"],
|
|
"RustProxy; hit; ttl=-5; detail=\"cache_stale_while_revalidate\"",
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn rfc9211_forwarded_stale_error_and_forced_validation_report_real_hops() {
|
|
let settings = Settings {
|
|
expose_status: true,
|
|
expose_cache_status: true,
|
|
..Settings::default()
|
|
};
|
|
let mut headers = HeaderMap::new();
|
|
headers.append("cache-status", HeaderValue::from_static("OriginCache; hit"));
|
|
settings.annotate_reason_transformed_forwarded(
|
|
&mut headers,
|
|
"HIT",
|
|
3,
|
|
0,
|
|
"cache_stale_if_error",
|
|
false,
|
|
"stale",
|
|
Some(StatusCode::SERVICE_UNAVAILABLE),
|
|
);
|
|
assert_eq!(headers["x-cache"], "HIT");
|
|
let values: Vec<_> = headers
|
|
.get_all("cache-status")
|
|
.iter()
|
|
.map(|value| value.to_str().unwrap())
|
|
.collect();
|
|
assert_eq!(
|
|
values,
|
|
vec![
|
|
"OriginCache; hit",
|
|
"RustProxy; fwd=stale; fwd-status=503; detail=\"cache_stale_if_error\"",
|
|
]
|
|
);
|
|
let mut headers = HeaderMap::new();
|
|
settings.annotate_reason_transformed_forwarded(
|
|
&mut headers,
|
|
"HIT",
|
|
2,
|
|
42,
|
|
"cache_revalidated",
|
|
false,
|
|
"request",
|
|
Some(StatusCode::NOT_MODIFIED),
|
|
);
|
|
assert_eq!(
|
|
headers["cache-status"],
|
|
"RustProxy; fwd=request; fwd-status=304; detail=\"cache_revalidated\"",
|
|
);
|
|
let mut headers = HeaderMap::new();
|
|
settings.annotate_reason_transformed_forwarded(
|
|
&mut headers,
|
|
"HIT",
|
|
2,
|
|
0,
|
|
"cache_stale_if_error",
|
|
false,
|
|
"stale",
|
|
None,
|
|
);
|
|
assert_eq!(
|
|
headers["cache-status"],
|
|
"RustProxy; fwd=stale; detail=\"cache_stale_if_error\"",
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn cache_domain_metrics_do_not_lock_hot_store_and_preserve_reasons() {
|
|
let cache = Cache::new(7);
|
|
let store = cache.store.lock().unwrap();
|
|
cache.record("alpha", "a.example", "BYPASS", "cache_disabled");
|
|
cache.record_reason("alpha", "a.example", "background_refresh_failure");
|
|
drop(store);
|
|
let workers = 8;
|
|
let each = 2000;
|
|
let mut tasks = Vec::new();
|
|
for _ in 0..workers {
|
|
let cache = Arc::clone(&cache);
|
|
tasks.push(std::thread::spawn(move || {
|
|
for _ in 0..each {
|
|
cache.record("alpha", "a.example", "BYPASS", "cache_disabled");
|
|
cache.record("alpha", "a.example", "HIT", "cache_hit");
|
|
}
|
|
}));
|
|
}
|
|
for task in tasks {
|
|
task.join().expect("domain counter worker");
|
|
}
|
|
let scoped = cache.dashboard(Some("alpha"), 0, 1);
|
|
assert_eq!(scoped.domains.len(), 1);
|
|
let counters = &scoped.domains[0].counters;
|
|
assert_eq!(counters.bypasses, 1 + workers * each);
|
|
assert_eq!(counters.hits, workers * each);
|
|
assert_eq!(counters.reasons["cache_disabled"], 1 + workers * each);
|
|
assert_eq!(counters.reasons["cache_hit"], workers * each);
|
|
assert_eq!(counters.reasons["background_refresh_failure"], 1);
|
|
assert_eq!(cache.purge_scope("alpha"), 0);
|
|
assert_eq!(
|
|
cache.dashboard(Some("alpha"), 0, 1).domains[0]
|
|
.counters
|
|
.hits,
|
|
workers * each
|
|
);
|
|
cache.purge(Some(8));
|
|
assert!(cache.dashboard(None, 0, 1).domains.is_empty());
|
|
cache.record("alpha", "a.example", "MISS", "cache_miss");
|
|
let after_reset = cache.dashboard(Some("alpha"), 0, 1);
|
|
assert_eq!(after_reset.domains[0].counters.misses, 1);
|
|
assert_eq!(after_reset.domains[0].counters.hits, 0);
|
|
assert_eq!(after_reset.statistics_revision, 8);
|
|
}
|
|
|
|
#[test]
|
|
fn first_hit_saved_bytes_registers_domain_even_without_prior_record() {
|
|
let cache = Cache::new(7);
|
|
cache
|
|
.domain_stats
|
|
.saved_body_hit("cold", "restored.example", 1040);
|
|
let result = cache.dashboard(Some("cold"), 0, 1);
|
|
assert_eq!(result.domains.len(), 1);
|
|
assert_eq!(result.domains[0].counters.saved_body_bytes, 1040);
|
|
}
|
|
|
|
#[test]
|
|
fn per_domain_counter_cardinality_is_bounded() {
|
|
let cache = Cache::new(7);
|
|
for i in 0..5000 {
|
|
cache.record(
|
|
"legacy",
|
|
&format!("{i}.example"),
|
|
"BYPASS",
|
|
"cache_disabled",
|
|
);
|
|
}
|
|
assert_eq!(cache.dashboard(None, 0, 1).domains.len(), 4096);
|
|
}
|
|
}
|