use super::config_fixtures::{actor_over, apply_config, declared_app, established};
use super::*;
fn reset_grid() -> (AppConfig, DeclaredApp, shep_core::overrides::AppOverrides) {
let mut stored = AppConfig::minimal("web", "./srv");
stored.max_restarts = 3;
stored.max_memory = Some(MemSize::from_bytes(2 << 30));
stored.env = BTreeMap::from([("DB".to_string(), "operator".to_string())]);
let mut template = AppConfig::minimal("web", "./srv");
template.max_restarts = 10;
template.env = BTreeMap::from([("DB".to_string(), "template".to_string())]);
let incoming = declared_app(template, &["name", "script", "max_restarts", "env"]);
let mut record = established(
&["name", "script", "max_restarts", "env"],
vec![
("max_restarts", serde_json::json!(3)),
("max_memory", serde_json::json!("2G")),
("env", serde_json::json!({ "DB": "operator" })),
],
);
record.declared_env = BTreeSet::from(["DB".to_string()]);
(stored, incoming, record)
}
fn merged_over_grid(reset: ResetDepth) -> AppConfig {
let (stored, incoming, record) = reset_grid();
merge_declared(&stored, &incoming, &record, reset)
.expect("the grid fixture travels through serde")
.0
}
fn record_over_grid(reset: ResetDepth) -> shep_core::overrides::AppOverrides {
let (stored, incoming, record) = reset_grid();
merge_declared(&stored, &incoming, &record, reset)
.expect("the grid fixture travels through serde")
.1
}
fn held_keys(record: &shep_core::overrides::AppOverrides) -> Vec<&String> {
let mut held: Vec<&String> = record.fields.keys().collect();
held.sort();
held
}
#[test]
fn file_puts_back_what_the_template_declares_and_leaves_the_rest() {
let merged = merged_over_grid(ResetDepth::File);
assert_eq!(merged.max_restarts, 10, "a declared key goes back");
assert_eq!(
merged.max_memory,
Some(MemSize::from_bytes(2 << 30)),
"a key the template never declares is not the template's to reset"
);
assert_eq!(
merged.env.get("DB").map(String::as_str),
Some("operator"),
"`file` keeps env"
);
}
#[test]
fn policy_puts_back_every_setting_declared_or_not_and_keeps_env() {
let merged = merged_over_grid(ResetDepth::Policy);
assert_eq!(merged.max_restarts, 10, "a declared key goes back");
assert_eq!(
merged.max_memory,
AppConfig::default().max_memory,
"`policy` resets a key the template is silent about, which for an \
undeclared key means the value a fresh start off that template gives it"
);
assert_eq!(
merged.env.get("DB").map(String::as_str),
Some("operator"),
"`policy` keeps env"
);
}
#[test]
fn env_resets_env_and_touches_no_setting_at_all() {
let merged = merged_over_grid(ResetDepth::Env);
assert_eq!(
merged.max_restarts, 3,
"a declared policy field is not `env`'s to reset"
);
assert_eq!(
merged.max_memory,
Some(MemSize::from_bytes(2 << 30)),
"and neither is one the template is silent on"
);
assert_eq!(
merged.env.get("DB").map(String::as_str),
Some("template"),
"`env` puts env back to the template"
);
}
#[test]
fn all_puts_back_every_setting_and_env_with_it() {
let merged = merged_over_grid(ResetDepth::All);
assert_eq!(merged.max_restarts, 10, "a declared key goes back");
assert_eq!(
merged.max_memory,
AppConfig::default().max_memory,
"`all` resets a key the template is silent about"
);
assert_eq!(
merged.env.get("DB").map(String::as_str),
Some("template"),
"`all` puts env back to the template"
);
}
#[test]
fn file_spends_only_the_override_it_put_back() {
let record = record_over_grid(ResetDepth::File);
let held = held_keys(&record);
assert_eq!(
held,
vec!["env", "max_memory"],
"`file` keeps the undeclared override and env, and spends the rest"
);
}
#[test]
fn policy_spends_every_setting_override_and_keeps_env() {
let record = record_over_grid(ResetDepth::Policy);
let held = held_keys(&record);
assert_eq!(
held,
vec!["env"],
"`policy` spends both setting overrides and keeps env"
);
}
#[test]
fn env_spends_only_the_env_override() {
let record = record_over_grid(ResetDepth::Env);
let held = held_keys(&record);
assert_eq!(
held,
vec!["max_memory", "max_restarts"],
"`env` spends env and keeps every setting override"
);
}
#[test]
fn all_spends_every_override() {
let record = record_over_grid(ResetDepth::All);
assert!(
record.fields.is_empty(),
"`all` holds nothing back: {:?}",
record.fields.keys().collect::<Vec<_>>()
);
}
#[tokio::test(start_paused = true)]
async fn an_env_reset_keeps_the_override_record() {
let dir = tempfile::tempdir().unwrap();
let (mut actor, _enforcer) = actor_over(
&dir,
&[app_with("web", |app| {
app.max_memory = Some(MemSize::from_bytes(2 << 30));
app.env = BTreeMap::from([("DB".to_string(), "operator".to_string())]);
})],
);
let mut record = established(
&["name", "script", "env"],
vec![
("max_memory", serde_json::json!("2G")),
("env", serde_json::json!({ "DB": "operator" })),
],
);
record.declared_env = BTreeSet::from(["DB".to_string()]);
shep_core::overrides::put(&actor.paths.overrides, "web", &record).unwrap();
let mut file = AppConfig::minimal("web", "./srv");
file.env = BTreeMap::from([("DB".to_string(), "template".to_string())]);
let file = declared_app(file, &["name", "script", "env"]);
let reply = apply_config(&mut actor, vec![file], ResetDepth::Env).await;
let written = shep_core::overrides::get(&actor.paths.overrides, "web")
.unwrap()
.unwrap_or_else(|| panic!("`env` keeps the record: {reply:?}"));
assert!(
written.fields.contains_key("max_memory"),
"the undeclared override must survive an env reset: {reply:?}"
);
assert_eq!(
actor.sheep[&0].entry.overridden,
vec!["max_memory".to_string()],
"and `shep flock`'s CFG column must still say so"
);
}
#[test]
fn an_env_reset_still_appends_a_key_nobody_established() {
let (stored, _, record) = reset_grid();
let mut template = AppConfig::minimal("web", "./srv");
template.max_restarts = 10;
template.min_uptime = UpDuration::from_millis(9000);
template.env = BTreeMap::from([("DB".to_string(), "template".to_string())]);
let incoming = declared_app(
template,
&["name", "script", "max_restarts", "min_uptime", "env"],
);
let (merged, _) = merge_declared(&stored, &incoming, &record, ResetDepth::Env)
.expect("the grid fixture travels through serde");
assert_eq!(
merged.min_uptime,
UpDuration::from_millis(9000),
"a declared key nobody established is appended under `env` too"
);
assert_eq!(
merged.max_restarts, 3,
"and an established one is still not overwritten"
);
}
#[tokio::test(start_paused = true)]
async fn an_env_reset_never_reshapes_a_flock() {
let dir = tempfile::tempdir().unwrap();
let (mut actor, _enforcer) = actor_over(&dir, &[app_with("web", |app| app.instances = 4)]);
let mut file = AppConfig::minimal("web", "./srv");
file.instances = 2;
let file = declared_app(file, &["name", "script", "instances"]);
let reply = apply_config(&mut actor, vec![file], ResetDepth::Env).await;
assert_eq!(
actor.ids_of_name("web").len(),
4,
"`env` scaled a flock: {reply:?}"
);
assert_eq!(
reply[0].refused.as_deref(),
Some(
"instances: this load never reshapes a flock; no mode scales without also \
putting back every setting the file declares, and `--reset=file` is the \
narrowest that does, taking the file's count of 2"
),
"an operator whose count did not move must be told why, and what the \
mode they are pointed at would cost them: {reply:?}"
);
}
#[tokio::test(start_paused = true)]
async fn a_file_reset_does_not_scale_an_app_the_template_says_nothing_about() {
let stocked = || app_with("web", |app| app.instances = 4);
let silent_dir = tempfile::tempdir().unwrap();
let (mut actor, _enforcer) = actor_over(&silent_dir, &[stocked()]);
let silent = declared_app(AppConfig::minimal("web", "./srv"), &["name", "script"]);
let reply = apply_config(&mut actor, vec![silent], ResetDepth::File).await;
assert_eq!(
actor.ids_of_name("web").len(),
4,
"`file` scaled against a file with no `instances` line: {reply:?}"
);
assert!(
!reply[0].applied.contains(&"instances".to_string()),
"{reply:?}"
);
let declaring_dir = tempfile::tempdir().unwrap();
let (mut actor, _enforcer) = actor_over(&declaring_dir, &[stocked()]);
let mut declaring = AppConfig::minimal("web", "./srv");
declaring.instances = 2;
let declaring = declared_app(declaring, &["name", "script", "instances"]);
let reply = apply_config(&mut actor, vec![declaring], ResetDepth::File).await;
assert_eq!(
actor.ids_of_name("web").len(),
2,
"`file` must apply a count the template does declare: {reply:?}"
);
assert!(
reply[0].applied.contains(&"instances".to_string()),
"{reply:?}"
);
}
#[tokio::test(start_paused = true)]
async fn a_settings_reset_does_not_establish_an_env_key_it_never_merged() {
let dir = tempfile::tempdir().unwrap();
let (mut actor, _enforcer) = actor_over(&dir, &[app_with("web", |_| {})]);
shep_core::overrides::put(
&actor.paths.overrides,
"web",
&established(&["name", "script"], Vec::new()),
)
.unwrap();
let file = || {
let mut file = AppConfig::minimal("web", "./srv");
file.env = BTreeMap::from([("NEW_KEY".to_string(), "1".to_string())]);
declared_app(file, &["name", "script", "env"])
};
let reset = apply_config(&mut actor, vec![file()], ResetDepth::Policy).await;
assert!(
actor.sheep[&0].entry.spec.config().env.is_empty(),
"a `--reset=policy` merges no env at all: {reset:?}"
);
assert!(
shep_core::overrides::get(&actor.paths.overrides, "web")
.unwrap()
.expect("the load records what it established")
.declared_env
.is_empty(),
"a key that never merged is not established"
);
let plain = apply_config(&mut actor, vec![file()], ResetDepth::None).await;
assert_eq!(
actor.sheep[&0]
.entry
.pending
.as_ref()
.expect("an env change parks for the next spawn")
.config()
.env
.get("NEW_KEY")
.map(String::as_str),
Some("1"),
"{plain:?}"
);
}