use quote::format_ident;
use crate::{
model::{PollBody, PollCadence, PollEntry, PollMode, Polls, RecordModel, default_due_name},
tests::{emission, enum_named, model},
};
fn swept() -> RecordModel {
let mut model = model("Reaper", &["media_id"], "id");
model.polls = Some(Polls {
entries: vec![
entry(
"orphans",
PollCadence::Every(core::time::Duration::new(600, 0)),
),
entry(
"sweep_stale",
PollCadence::Calendar {
expression: "0 3 * * *".to_owned(),
zone: None,
},
),
entry(
"compact",
PollCadence::Calendar {
expression: "*/15 * * * *".to_owned(),
zone: Some("America/New_York".to_owned()),
},
),
],
});
model
}
fn entry(name: &str, cadence: PollCadence) -> PollEntry {
use heck::ToUpperCamelCase as _;
let variant = format_ident!("{}", name.to_upper_camel_case());
PollEntry {
name: format_ident!("{name}"),
variant,
cadence,
grants: None,
body: PollBody::Light,
mode: PollMode::AsyncInline,
concurrent: false,
}
}
fn tight(model: &RecordModel) -> String {
model.emit().to_string().replace(' ', "")
}
fn written(model: &RecordModel) -> String {
model.emit().to_string()
}
#[test]
fn the_vocabulary_is_one_variant_per_entry_in_order() {
let model = swept();
let file = emission(&model);
let due = enum_named(&file, &default_due_name(&model.record).to_string());
assert_eq!(
due
.variants
.iter()
.map(|variant| variant.ident.to_string())
.collect::<Vec<_>>(),
["Orphans", "SweepStale", "Compact"],
);
assert!(due.variants.iter().all(|variant| variant.fields.is_empty()));
}
#[test]
fn a_node_with_no_clock_emits_no_vocabulary() {
let model = model("Plain", &["media_id"], "id");
let file = emission(&model);
let due = default_due_name(&model.record).to_string();
assert!(
!file.items.iter().any(|item| matches!(
item,
syn::Item::Enum(item) if item.ident == due
)),
"`{due}` is not emitted for a node with no clock"
);
}
#[test]
fn one_clock_still_gets_a_vocabulary() {
let mut model = model("Compactor", &["media_id"], "id");
model.polls = Some(Polls {
entries: vec![entry(
"compact",
PollCadence::Every(core::time::Duration::new(3_600, 0)),
)],
});
let file = emission(&model);
let due = enum_named(&file, &default_due_name(&model.record).to_string());
assert_eq!(due.variants.len(), 1);
assert!(tight(&model).contains("constCOUNT:usize=1usize"));
}
#[test]
fn position_and_name_translate_both_ways() {
let emitted = tight(&swept());
assert!(emitted.contains("constCOUNT:usize=3usize"), "{emitted}");
for (index, variant) in ["Orphans", "SweepStale", "Compact"].iter().enumerate() {
assert!(
emitted.contains(&format!(
"{index}usize=>::core::option::Option::Some(Self::{variant})"
)),
"position {index} translates to `{variant}`: {emitted}"
);
}
assert!(
emitted.contains("_=>::core::option::Option::None"),
"{emitted}"
);
for (index, variant) in ["Orphans", "SweepStale", "Compact"].iter().enumerate() {
assert!(
emitted.contains(&format!("Self::{variant}=>{index}usize")),
"`{variant}` translates to position {index}: {emitted}"
);
}
}
#[test]
fn the_schedule_carries_every_cadence_in_order() {
let model = swept();
let emitted = tight(&model);
assert!(
emitted.contains("schedule.every(::core::time::Duration::new(600u64,0u32))"),
"{emitted}"
);
assert!(emitted.contains("schedule.cron("), "{emitted}");
assert!(emitted.contains("schedule.cron_in("), "{emitted}");
let written = written(&model);
let opened = written
.find("fn schedule")
.expect("the schedule door is emitted");
let body = &written[opened..];
let interval = body.find("600u64").expect("the interval entry");
let bare = body
.find(r#""0 3 * * *""#)
.expect("the calendar entry with no zone");
let zoned = body
.find(r#""*/15 * * * *""#)
.expect("the calendar entry with a zone");
assert!(
body.contains(r#""America/New_York""#),
"the zone rides its entry: {body}"
);
assert!(interval < bare && bare < zoned, "declaration order: {body}");
}
#[test]
fn the_schedule_door_is_fallible_even_with_no_calendar() {
let mut model = model("Compactor", &["media_id"], "id");
model.polls = Some(Polls {
entries: vec![entry(
"compact",
PollCadence::Every(core::time::Duration::new(3_600, 500)),
)],
});
let emitted = tight(&model);
assert!(
emitted.contains("fnschedule()->::core::result::Result<"),
"{emitted}"
);
assert!(
emitted.contains("every(::core::time::Duration::new(3600u64,500u32))"),
"{emitted}"
);
}