use core::{num::NonZeroUsize, time::Duration};
use super::{
DEFAULT_BATCH_MAX_ITEMS, DEFAULT_BATCH_MAX_WAIT, DEFAULT_DEBOUNCE, DEFAULT_RETIRE_DRAIN,
DEFAULT_SETTLE, RegistryOptions, RegistryOverride,
};
#[test]
fn new_holds_the_shipped_defaults() {
let options = RegistryOptions::new();
assert_eq!(options.debounce(), DEFAULT_DEBOUNCE);
assert_eq!(options.batch_max_items(), DEFAULT_BATCH_MAX_ITEMS);
assert_eq!(options.batch_max_wait(), DEFAULT_BATCH_MAX_WAIT);
assert_eq!(options.retire_drain(), DEFAULT_RETIRE_DRAIN);
assert_eq!(options.settle(), DEFAULT_SETTLE);
assert_eq!(options.families().count(), 0);
}
#[test]
fn default_delegates_to_new() {
assert_eq!(RegistryOptions::default(), RegistryOptions::new());
}
#[test]
fn the_builders_round_trip() {
let five_seconds = Duration::from_secs(5);
let stated = RegistryOptions::new().with_debounce(five_seconds);
assert_eq!(stated.debounce(), five_seconds);
let mut mutated = RegistryOptions::new();
mutated.set_batch_max_items(NonZeroUsize::new(64).expect("64 is not zero"));
assert_eq!(
mutated.batch_max_items(),
NonZeroUsize::new(64).expect("64 is not zero")
);
}
#[test]
fn for_family_with_no_override_reads_the_defaults_whole() {
let options = RegistryOptions::new().with_debounce(Duration::from_secs(9));
let resolved = options.for_family("nobody-wrote-this-one");
assert_eq!(resolved, options.for_family("nobody-wrote-this-one"));
assert_eq!(resolved.debounce(), Duration::from_secs(9));
assert_eq!(resolved.batch_max_items(), DEFAULT_BATCH_MAX_ITEMS);
}
#[test]
fn for_family_folds_only_the_knobs_it_named_over_the_deployments_own_defaults() {
let options = RegistryOptions::new()
.with_batch_max_items(NonZeroUsize::new(20).expect("20 is not zero"))
.with_family(
"media",
RegistryOverride::new().with_debounce(Duration::from_secs(1)),
);
let media = options.for_family("media");
assert_eq!(media.debounce(), Duration::from_secs(1), "media's own word");
assert_eq!(
media.batch_max_items(),
NonZeroUsize::new(20).expect("20 is not zero"),
"media named nothing here, so the DEPLOYMENT's own default stands — not the shipped 10"
);
assert_eq!(media.batch_max_wait(), DEFAULT_BATCH_MAX_WAIT);
}
#[test]
fn a_resolved_value_carries_no_further_overrides() {
let options = RegistryOptions::new().with_family("media", RegistryOverride::new());
assert_eq!(options.for_family("media").families().count(), 0);
}
#[test]
fn with_family_replaces_rather_than_accumulates() {
let options = RegistryOptions::new()
.with_family(
"media",
RegistryOverride::new().with_debounce(Duration::from_secs(1)),
)
.with_family(
"media",
RegistryOverride::new().with_debounce(Duration::from_secs(2)),
);
assert_eq!(options.families().count(), 1);
assert_eq!(
options.for_family("media").debounce(),
Duration::from_secs(2)
);
}
#[test]
fn families_lists_every_override_written() {
let options = RegistryOptions::new()
.with_family("media", RegistryOverride::new())
.with_family("video", RegistryOverride::new());
let mut names: Vec<&str> = options.families().collect();
names.sort_unstable();
assert_eq!(names, ["media", "video"]);
}
#[test]
fn a_family_overrides_own_set_can_clear_back_to_none() {
let mut over = RegistryOverride::new().with_debounce(Duration::from_secs(1));
assert_eq!(over.debounce(), Some(Duration::from_secs(1)));
over.set_debounce(None);
assert_eq!(over.debounce(), None);
}
#[cfg(feature = "serde")]
mod document {
use core::time::Duration;
use super::{
DEFAULT_BATCH_MAX_ITEMS, DEFAULT_DEBOUNCE, DEFAULT_RETIRE_DRAIN, RegistryOptions,
RegistryOverride,
};
fn parse(document: &str) -> Result<RegistryOptions, serde_json::Error> {
serde_json::from_str(document)
}
#[test]
fn an_empty_document_is_the_shipped_defaults() {
assert_eq!(
parse("{}").expect("an empty document parses"),
RegistryOptions::new()
);
}
#[test]
fn the_rulings_worked_example_round_trips() {
let parsed = parse(
r#"{
"debounce": "300ms",
"batch_max_items": 10,
"batch_max_wait": "500ms",
"retire_drain": "30s",
"settle": "0ms",
"media": { "debounce": "1s" }
}"#,
)
.expect("the ruling's own document parses");
assert_eq!(
parsed,
RegistryOptions::new().with_family(
"media",
RegistryOverride::new().with_debounce(Duration::from_secs(1))
)
);
assert_eq!(
parsed.for_family("media").debounce(),
Duration::from_secs(1)
);
}
#[test]
fn a_partial_document_overrides_one_knob_of_one_family_only() {
let parsed = parse(r#"{ "media": { "debounce": "1s" } }"#).expect("a partial document parses");
assert_eq!(
parsed,
RegistryOptions::new().with_family(
"media",
RegistryOverride::new().with_debounce(Duration::from_secs(1)),
)
);
assert_eq!(
parsed.for_family("media").debounce(),
Duration::from_secs(1)
);
assert_eq!(
parsed.for_family("media").batch_max_items(),
DEFAULT_BATCH_MAX_ITEMS
);
assert_eq!(
parsed.for_family("video").debounce(),
DEFAULT_DEBOUNCE,
"a family this document never named reads the defaults whole"
);
}
#[test]
fn humantime_parses_the_familiar_spellings() {
let parsed = parse(
r#"{ "debounce": "1s", "batch_max_wait": "2m", "retire_drain": "30s", "settle": "0ms" }"#,
)
.expect("humantime's own spellings parse");
assert_eq!(parsed.debounce(), Duration::from_secs(1));
assert_eq!(parsed.batch_max_wait(), Duration::from_secs(120));
assert_eq!(parsed.retire_drain(), DEFAULT_RETIRE_DRAIN);
assert_eq!(parsed.settle(), Duration::ZERO);
}
#[test]
fn a_bare_number_is_refused_rather_than_guessed() {
let refusal = parse(r#"{ "debounce": 300 }"#).expect_err("a bare number is not humantime");
let sentence = refusal.to_string();
assert!(sentence.contains("duration"), "{sentence}");
}
#[test]
fn a_zero_batch_ceiling_is_refused() {
let refusal = parse(r#"{ "batch_max_items": 0 }"#).expect_err("zero is not a nonzero usize");
let sentence = refusal.to_string();
assert!(
sentence.contains("nonzero") || sentence.contains("0"),
"{sentence}"
);
}
#[test]
fn a_family_override_naming_an_unknown_knob_is_refused() {
let refusal = parse(r#"{ "media": { "totally_unknown_knob": 5 } }"#)
.expect_err("`totally_unknown_knob` is not one of the five");
let sentence = refusal.to_string();
assert!(sentence.contains("totally_unknown_knob"), "{sentence}");
assert!(sentence.contains("unknown field"), "{sentence}");
}
#[test]
fn a_family_named_after_a_reserved_knob_is_refused() {
parse(r#"{ "debounce": { "batch_max_items": 1 } }"#)
.expect_err("`debounce` is a reserved knob word, not an open family name");
}
#[test]
fn a_family_with_an_empty_table_overrides_nothing() {
let parsed = parse(r#"{ "media": {} }"#).expect("an empty family table parses");
assert_eq!(parsed.families().collect::<Vec<_>>(), ["media"]);
assert_eq!(
parsed.for_family("media"),
RegistryOptions::new().for_family("anything-else")
);
}
}