use shep_core::protocol::{EnvCopyChange, EnvCopyKind};
use super::*;
async fn start_pair(h: &Harness) {
shep_core::secrets::set(
&h.ctx.paths.secrets,
"PADDOCK_KEY",
"production",
"paddock-value",
)
.unwrap();
let mut web = AppConfig::minimal("web", "./srv");
for (key, value) in [
("PADDOCK_KEY", "{{secret:PADDOCK_KEY}}"),
("B", "web-literal"),
("C", "same"),
] {
web.env.insert(key.to_string(), value.to_string());
}
let mut api = AppConfig::minimal("api", "./srv");
for (key, value) in [("B", "api-literal"), ("C", "same"), ("D", "only-api")] {
api.env.insert(key.to_string(), value.to_string());
}
let started = reply_of(
dispatch(
envelope(
1,
Request::Start {
apps: vec![web, api],
},
),
&h.ctx,
)
.await,
);
assert!(started.result.is_ok(), "{:?}", started.result);
}
async fn copy(
h: &Harness,
id: u64,
replace: bool,
except: &[&str],
dry_run: bool,
) -> Result<Response, RpcError> {
copy_expecting(h, id, replace, except, dry_run, None).await
}
async fn copy_expecting(
h: &Harness,
id: u64,
replace: bool,
except: &[&str],
dry_run: bool,
expect: Option<Vec<EnvCopyChange>>,
) -> Result<Response, RpcError> {
reply_of(
dispatch(
envelope(
id,
Request::CopySheepEnv {
from: "web".to_string(),
to: "api".to_string(),
replace,
except: except.iter().map(|key| (*key).to_string()).collect(),
dry_run,
expect,
},
),
&h.ctx,
)
.await,
)
.result
}
fn changes_of(reply: Result<Response, RpcError>) -> Vec<EnvCopyChange> {
match reply {
Ok(Response::SheepEnvCopied { changes, .. }) => changes,
other => panic!("expected SheepEnvCopied, got {other:?}"),
}
}
fn unsealed(changes: Vec<EnvCopyChange>) -> Vec<EnvCopyChange> {
changes.into_iter().map(|change| change.sealed(0)).collect()
}
fn stored_env(h: &Harness, name: &str) -> serde_json::Value {
shep_core::overrides::get(&h.ctx.paths.overrides, name)
.unwrap()
.map_or(serde_json::Value::Null, |record| {
record
.fields
.get("env")
.cloned()
.unwrap_or(serde_json::Value::Null)
})
}
#[tokio::test(start_paused = true)]
async fn a_merge_copies_every_key_and_shows_only_references() {
let h = harness(vec![ProcScript::never_exits(), ProcScript::never_exits()]);
start_pair(&h).await;
let reply = copy(&h, 2, false, &[], false).await;
let wire = format!("{reply:?}");
for literal in ["web-literal", "api-literal", "only-api"] {
assert!(!wire.contains(literal), "{literal} leaked: {wire}");
}
assert_eq!(
unsealed(changes_of(reply)),
vec![
EnvCopyChange::new(
"B",
EnvCopyKind::Changed,
Some("<redacted>".into()),
Some("<redacted>".into())
),
EnvCopyChange::new(
"PADDOCK_KEY",
EnvCopyKind::Added,
None,
Some("{{secret:PADDOCK_KEY}}".into())
),
]
);
let stored = stored_env(&h, "api");
assert_eq!(stored["PADDOCK_KEY"], "{{secret:PADDOCK_KEY}}");
assert_eq!(stored["B"], "web-literal");
assert!(
stored.get("D").is_none(),
"a merge leaves D alone: {stored}"
);
let api = describe(&h.ctx, 3, SelectorSpec::Name("api".to_string())).await;
assert_eq!(
api[0].pending.as_deref(),
Some(["env".to_string()].as_slice()),
"env parks for the next spawn"
);
}
#[tokio::test(start_paused = true)]
async fn replace_removes_the_keys_only_the_target_had() {
let h = harness(vec![ProcScript::never_exits(), ProcScript::never_exits()]);
start_pair(&h).await;
let changes = changes_of(copy(&h, 2, true, &[], false).await);
let kinds: Vec<(&str, EnvCopyKind)> = changes
.iter()
.map(|change| (change.key.as_str(), change.kind))
.collect();
assert_eq!(
kinds,
[
("B", EnvCopyKind::Changed),
("D", EnvCopyKind::Removed),
("PADDOCK_KEY", EnvCopyKind::Added),
]
);
assert_eq!(stored_env(&h, "api")["D"], serde_json::Value::Null);
}
#[tokio::test(start_paused = true)]
async fn an_excepted_key_is_left_as_the_target_had_it() {
let h = harness(vec![ProcScript::never_exits(), ProcScript::never_exits()]);
start_pair(&h).await;
let changes = changes_of(copy(&h, 2, true, &["B", "D", "PADDOCK_KEY"], false).await);
assert!(changes.is_empty(), "{changes:?}");
assert_eq!(stored_env(&h, "api"), serde_json::Value::Null);
}
#[tokio::test(start_paused = true)]
async fn a_dry_run_writes_nothing() {
let h = harness(vec![ProcScript::never_exits(), ProcScript::never_exits()]);
start_pair(&h).await;
let dry = changes_of(copy(&h, 2, false, &[], true).await);
assert_eq!(dry.len(), 2);
assert_eq!(stored_env(&h, "api"), serde_json::Value::Null);
let api = describe(&h.ctx, 3, SelectorSpec::Name("api".to_string())).await;
assert_eq!(api[0].pending, None);
let real = changes_of(copy(&h, 4, false, &[], false).await);
assert_eq!(real, dry);
}
#[tokio::test(start_paused = true)]
async fn a_second_copy_changes_nothing() {
let h = harness(vec![ProcScript::never_exits(), ProcScript::never_exits()]);
start_pair(&h).await;
changes_of(copy(&h, 2, false, &[], false).await);
assert!(changes_of(copy(&h, 3, false, &[], false).await).is_empty());
}
#[tokio::test(start_paused = true)]
async fn a_missing_sheep_on_either_side_is_not_found() {
let h = harness(vec![ProcScript::never_exits(), ProcScript::never_exits()]);
start_pair(&h).await;
for (id, from, to) in [(2, "ghost", "api"), (3, "web", "ghost")] {
let reply = reply_of(
dispatch(
envelope(
id,
Request::CopySheepEnv {
from: from.to_string(),
to: to.to_string(),
replace: false,
except: Vec::new(),
dry_run: false,
expect: None,
},
),
&h.ctx,
)
.await,
);
let Err(err) = reply.result else {
panic!("{from} to {to} must be refused");
};
assert_eq!(err.code, RpcErrorCode::NotFound, "{err:?}");
assert!(err.message.contains("ghost"), "{err:?}");
}
}
#[tokio::test(start_paused = true)]
async fn a_dog_on_either_side_is_refused() {
let h = harness(vec![
ProcScript::never_exits(),
ProcScript::never_exits(),
ProcScript::never_exits(),
]);
start_pair(&h).await;
enable_dog(&h.ctx, 2, "bark").await;
for (id, from, to) in [(3, "web", "bark"), (4, "bark", "web")] {
let reply = reply_of(
dispatch(
envelope(
id,
Request::CopySheepEnv {
from: from.to_string(),
to: to.to_string(),
replace: false,
except: Vec::new(),
dry_run: false,
expect: None,
},
),
&h.ctx,
)
.await,
);
let Err(err) = reply.result else {
panic!("{from} to {to} must be refused");
};
assert_eq!(err.code, RpcErrorCode::InvalidConfig, "{err:?}");
}
}
#[tokio::test(start_paused = true)]
async fn a_write_whose_reviewed_changes_no_longer_hold_is_refused() {
let h = harness(vec![ProcScript::never_exits(), ProcScript::never_exits()]);
start_pair(&h).await;
let reviewed = changes_of(copy(&h, 2, true, &[], true).await);
let edited = reply_of(
dispatch(
envelope(
3,
Request::SetSheepEnv {
name: "api".to_string(),
key: "ADDED_SINCE".to_string(),
value: Some("late".to_string().into()),
},
),
&h.ctx,
)
.await,
);
assert!(edited.result.is_ok(), "{:?}", edited.result);
let before = stored_env(&h, "api");
let err = copy_expecting(&h, 4, true, &[], false, Some(reviewed))
.await
.unwrap_err();
assert_eq!(err.code, RpcErrorCode::InvalidConfig, "{err:?}");
assert!(err.message.contains("changed"), "{err:?}");
assert_eq!(stored_env(&h, "api"), before, "nothing was written");
}
#[tokio::test(start_paused = true)]
async fn a_write_whose_reviewed_changes_still_hold_is_applied() {
let h = harness(vec![ProcScript::never_exits(), ProcScript::never_exits()]);
start_pair(&h).await;
let reviewed = changes_of(copy(&h, 2, false, &[], true).await);
let applied =
changes_of(copy_expecting(&h, 3, false, &[], false, Some(reviewed.clone())).await);
assert_eq!(applied, reviewed);
assert_eq!(stored_env(&h, "api")["B"], "web-literal");
}
#[tokio::test(start_paused = true)]
async fn a_literal_swapped_since_the_review_is_refused() {
for (id, edited) in [(3, "api"), (5, "web")] {
let h = harness(vec![ProcScript::never_exits(), ProcScript::never_exits()]);
start_pair(&h).await;
let reviewed = changes_of(copy(&h, 2, false, &[], true).await);
let swapped = reply_of(
dispatch(
envelope(
id,
Request::SetSheepEnv {
name: edited.to_string(),
key: "B".to_string(),
value: Some("swapped".to_string().into()),
},
),
&h.ctx,
)
.await,
);
assert!(swapped.result.is_ok(), "{:?}", swapped.result);
let before = stored_env(&h, "api");
let err = copy_expecting(&h, id + 1, false, &[], false, Some(reviewed))
.await
.unwrap_err();
assert_eq!(err.code, RpcErrorCode::InvalidConfig, "{edited}: {err:?}");
assert!(err.message.contains('B'), "{edited}: {err:?}");
assert_eq!(stored_env(&h, "api"), before, "nothing was written");
}
}