use crate::{Error, Result};
pub const MIN_ENGINE_VERSION: &str = "v0.80.0";
pub const IDEMPOTENCY_MIN_ENGINE_VERSION: &str = "v0.107.0";
pub const DURABLE_SPAWN_MIN_ENGINE_VERSION: &str = "v0.85.0";
pub const BATCH_MIN_ENGINE_VERSION: &str = "v0.98.0";
pub(crate) const EVICTION_MIN_ENGINE_VERSION: &str = MIN_ENGINE_VERSION;
pub(crate) fn ensure_supported(reported: &str) -> Result<()> {
let found = parse(reported)?;
let minimum = parse(MIN_ENGINE_VERSION).expect("MIN_ENGINE_VERSION is valid");
if found < minimum {
return Err(Error::UnsupportedEngine {
found: reported.to_string(),
minimum: MIN_ENGINE_VERSION.to_string(),
});
}
Ok(())
}
pub(crate) fn ensure_feature(feature: &str, minimum: &str, reported: &str) -> Result<()> {
let found = parse(reported)?;
let wanted = parse(minimum).expect("a feature minimum is valid");
if found < wanted {
return Err(Error::UnsupportedFeature {
feature: feature.to_string(),
found: reported.to_string(),
minimum: minimum.to_string(),
});
}
Ok(())
}
fn parse(version: &str) -> Result<(u64, u64, u64)> {
let invalid = || Error::InvalidEngineVersion(version.to_string());
let core = version.strip_prefix('v').unwrap_or(version);
let core = core.split_once('-').map_or(core, |(core, _)| core);
let mut parts = core.split('.').map(|part| part.parse::<u64>().ok());
match (parts.next(), parts.next(), parts.next(), parts.next()) {
(Some(Some(major)), Some(Some(minor)), Some(Some(patch)), None) => {
Ok((major, minor, patch))
}
_ => Err(invalid()),
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn versions_at_or_above_the_minimum_are_accepted() {
for version in [
"v0.80.0",
"v0.80.1",
"v0.107.0",
"v1.0.0",
"0.80.0",
"v0.80.0-alpha.1",
] {
ensure_supported(version).unwrap_or_else(|e| panic!("{version}: {e}"));
}
}
#[test]
fn versions_below_the_minimum_are_rejected_with_both_versions_named() {
for version in ["v0.79.9", "v0.78.23", "v0.9.200"] {
let err = ensure_supported(version).unwrap_err();
assert!(
matches!(err, Error::UnsupportedEngine { .. }),
"{version}: {err:?}"
);
assert!(err.to_string().contains(version), "{err}");
assert!(err.to_string().contains("v0.80.0"), "{err}");
}
}
#[test]
fn unparseable_versions_are_errors() {
for version in ["", "latest", "v0.80", "v0.x.1", "v1.2.3.4", "v-1.0.0"] {
let err = ensure_supported(version).unwrap_err();
assert!(
matches!(err, Error::InvalidEngineVersion(_)),
"{version:?}: {err:?}"
);
}
}
#[test]
fn a_feature_gate_names_the_feature_the_engine_and_the_minimum() {
let err =
ensure_feature("idempotency", IDEMPOTENCY_MIN_ENGINE_VERSION, "v0.80.0").unwrap_err();
assert!(matches!(err, Error::UnsupportedFeature { .. }), "{err:?}");
let message = err.to_string();
assert!(message.contains("idempotency"), "{message}");
assert!(message.contains("v0.80.0"), "{message}");
assert!(
message.contains(IDEMPOTENCY_MIN_ENGINE_VERSION),
"{message}"
);
}
#[test]
fn a_new_enough_engine_passes_the_gate() {
ensure_feature("idempotency", IDEMPOTENCY_MIN_ENGINE_VERSION, "v0.107.0").unwrap();
}
#[test]
fn the_batch_gate_names_the_feature_and_both_versions() {
let err = ensure_feature("batch tasks", BATCH_MIN_ENGINE_VERSION, "v0.97.0").unwrap_err();
assert!(matches!(err, Error::UnsupportedFeature { .. }), "{err:?}");
let message = err.to_string();
assert!(message.contains("batch"), "{message}");
assert!(message.contains("v0.97.0"), "{message}");
assert!(message.contains(BATCH_MIN_ENGINE_VERSION), "{message}");
assert!(ensure_feature("batch tasks", BATCH_MIN_ENGINE_VERSION, "v0.88.1").is_err());
ensure_feature("batch tasks", BATCH_MIN_ENGINE_VERSION, "v0.98.0").unwrap();
ensure_feature("batch tasks", BATCH_MIN_ENGINE_VERSION, "v0.107.0").unwrap();
}
#[test]
fn an_unparseable_engine_version_is_its_own_error_at_the_gate_too() {
let err =
ensure_feature("idempotency", IDEMPOTENCY_MIN_ENGINE_VERSION, "latest").unwrap_err();
assert!(matches!(err, Error::InvalidEngineVersion(_)), "{err:?}");
}
}