use std::{collections::BTreeMap, fs, io, path::Path};
use serde::{Deserialize, Deserializer, Serialize, de};
use crate::{
Error, Result,
types::{JobClass, JobProfile},
};
#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
#[serde(default, deny_unknown_fields)]
pub struct Config {
pub daemon: DaemonConfig,
pub admission: AdmissionConfig,
pub benchmark: BenchmarkConfig,
pub leases: LeaseConfig,
pub retention: RetentionConfig,
pub hook: HookConfig,
pub classes: ClassProfiles,
pub presets: Presets,
pub classifier: ClassifierConfig,
pub linux: LinuxConfig,
}
impl Config {
pub fn from_toml(text: &str) -> Result<Self> {
let config: Self = toml::from_str(text)?;
config.validate()?;
Ok(config)
}
pub fn load(path: &Path) -> Result<Self> {
let loaded = match fs::read_to_string(path) {
Ok(text) => Self::from_toml(&text),
Err(error) if error.kind() == io::ErrorKind::NotFound => return Ok(Self::default()),
Err(error) => Err(error.into()),
};
loaded.map_err(|reason| Error::ConfigFile {
path: path.to_owned(),
reason: Box::new(reason),
})
}
pub fn validate(&self) -> Result<()> {
ensure(self.daemon.port != 0, "daemon.port must not be 0")?;
ensure(
(0.0..100.0).contains(&self.admission.headroom_pct),
"admission.headroom_pct must be at least 0 and below 100",
)?;
ensure(
is_pct(self.benchmark.quiet_cpu_pct),
"benchmark.quiet_cpu_pct must be 0 to 100",
)?;
ensure(
is_pct(self.benchmark.quiet_gpu_pct),
"benchmark.quiet_gpu_pct must be 0 to 100",
)?;
ensure(
self.benchmark.quiet_secs > 0,
"benchmark.quiet_secs must be positive",
)?;
ensure(
self.benchmark.max_quiet_wait_secs >= self.benchmark.quiet_secs,
"benchmark.max_quiet_wait_secs must be at least quiet_secs",
)?;
ensure(
self.leases.heartbeat_ttl_secs > 0,
"leases.heartbeat_ttl_secs must be positive",
)?;
let retention = &self.retention;
ensure(
retention.lease_days > 0,
"retention.lease_days must be positive",
)?;
ensure(
retention.history_days > 0,
"retention.history_days must be positive",
)?;
ensure(
retention.keep_runs_per_job > 0,
"retention.keep_runs_per_job must be positive",
)?;
ensure(
retention.max_job_runs >= retention.keep_runs_per_job,
"retention.max_job_runs must be at least keep_runs_per_job",
)?;
for class in JobClass::ALL {
if let Some(reason) = self.classes.get(class).invalid_reason() {
return Err(Error::Config(format!(
"classes.{}: {reason}",
class.as_str()
)));
}
}
for (name, sizing) in &self.presets.0 {
let well_formed = !name.is_empty()
&& name
.bytes()
.all(|byte| byte.is_ascii_lowercase() || byte.is_ascii_digit() || byte == b'_');
ensure(
well_formed,
format!("presets.{name}: names use only a-z, 0-9 and _"),
)?;
ensure(
JobClass::ALL.iter().all(|class| class.as_str() != name),
format!("presets.{name}: a class already has this name"),
)?;
if let Some(reason) = sizing.invalid_reason() {
return Err(Error::Config(format!("presets.{name}: {reason}")));
}
}
for (index, rule) in self.classifier.rules.iter().enumerate() {
let has_blank =
rule.program.trim().is_empty() || rule.args.iter().any(|arg| arg.trim().is_empty());
ensure(
!has_blank,
format!("classifier.rules[{index}] has a blank program or arg"),
)?;
}
let flags = &self.classifier.light_flags;
ensure(
flags.iter().all(|flag| !flag.trim().is_empty()),
"classifier.light_flags must not contain blank entries",
)?;
Ok(())
}
}
fn ensure(condition: bool, message: impl Into<String>) -> Result<()> {
if condition {
Ok(())
} else {
Err(Error::Config(message.into()))
}
}
fn is_pct(value: f32) -> bool {
(0.0..=100.0).contains(&value)
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(default, deny_unknown_fields)]
pub struct DaemonConfig {
pub port: u16,
}
impl Default for DaemonConfig {
fn default() -> Self {
Self { port: 47_823 }
}
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(default, deny_unknown_fields)]
pub struct AdmissionConfig {
pub headroom_pct: f32,
}
impl Default for AdmissionConfig {
fn default() -> Self {
Self { headroom_pct: 15.0 }
}
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(default, deny_unknown_fields)]
pub struct BenchmarkConfig {
pub quiet_cpu_pct: f32,
pub quiet_gpu_pct: f32,
pub quiet_secs: u64,
pub max_quiet_wait_secs: u64,
}
impl Default for BenchmarkConfig {
fn default() -> Self {
Self {
quiet_cpu_pct: 10.0,
quiet_gpu_pct: 10.0,
quiet_secs: 10,
max_quiet_wait_secs: 60,
}
}
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(default, deny_unknown_fields)]
pub struct LeaseConfig {
pub heartbeat_ttl_secs: u64,
pub idle_release_secs: u64,
}
impl Default for LeaseConfig {
fn default() -> Self {
Self {
heartbeat_ttl_secs: 60,
idle_release_secs: 180,
}
}
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(default, deny_unknown_fields)]
pub struct RetentionConfig {
pub lease_days: u64,
pub history_days: u64,
pub keep_runs_per_job: u64,
pub max_job_runs: u64,
}
impl Default for RetentionConfig {
fn default() -> Self {
Self {
lease_days: 30,
history_days: 90,
keep_runs_per_job: 20,
max_job_runs: 5_000,
}
}
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(default, deny_unknown_fields)]
pub struct HookConfig {
pub fail_open: bool,
}
impl Default for HookConfig {
fn default() -> Self {
Self { fail_open: true }
}
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(default, deny_unknown_fields)]
pub struct LinuxConfig {
pub scopes: bool,
pub enforce_cpu: bool,
pub enforce_memory: bool,
}
impl Default for LinuxConfig {
fn default() -> Self {
Self {
scopes: true,
enforce_cpu: false,
enforce_memory: false,
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Serialize)]
pub struct Sizing {
#[serde(flatten)]
pub profile: JobProfile,
#[serde(skip_serializing_if = "Option::is_none")]
pub min_cores: Option<f32>,
}
impl Sizing {
pub const fn of(profile: JobProfile) -> Self {
Self {
profile,
min_cores: None,
}
}
pub fn minimum(&self) -> f32 {
self.min_cores
.unwrap_or_else(|| self.profile.default_min_cores())
}
pub fn invalid_reason(&self) -> Option<&'static str> {
self.profile.invalid_reason().or_else(|| {
self.min_cores
.and_then(|min_cores| self.profile.min_cores_reason(min_cores))
})
}
}
#[derive(Debug, Clone, PartialEq, Serialize)]
pub struct ClassProfiles {
pub light: Sizing,
pub cpu_heavy: Sizing,
pub gpu_heavy: Sizing,
pub mixed: Sizing,
}
impl ClassProfiles {
pub fn get(&self, class: JobClass) -> &Sizing {
match class {
JobClass::Light => &self.light,
JobClass::CpuHeavy => &self.cpu_heavy,
JobClass::GpuHeavy => &self.gpu_heavy,
JobClass::Mixed => &self.mixed,
}
}
}
impl Default for ClassProfiles {
fn default() -> Self {
Self {
light: Sizing::of(JobProfile {
cores: 1.0,
ram_mb: 512,
gpu_pct: 0.0,
vram_mb: 0,
est_secs: 30,
}),
cpu_heavy: Sizing::of(JobProfile {
cores: 8.0,
ram_mb: 4096,
gpu_pct: 0.0,
vram_mb: 0,
est_secs: 300,
}),
gpu_heavy: Sizing::of(JobProfile {
cores: 2.0,
ram_mb: 4096,
gpu_pct: 80.0,
vram_mb: 4096,
est_secs: 600,
}),
mixed: Sizing::of(JobProfile {
cores: 6.0,
ram_mb: 8192,
gpu_pct: 50.0,
vram_mb: 2048,
est_secs: 600,
}),
}
}
}
impl<'de> Deserialize<'de> for ClassProfiles {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: Deserializer<'de>,
{
let overrides = ClassOverrides::deserialize(deserializer)?;
let defaults = Self::default();
Ok(Self {
light: overrides.light.apply(defaults.light),
cpu_heavy: overrides.cpu_heavy.apply(defaults.cpu_heavy),
gpu_heavy: overrides.gpu_heavy.apply(defaults.gpu_heavy),
mixed: overrides.mixed.apply(defaults.mixed),
})
}
}
#[derive(Default, Deserialize)]
#[serde(default, deny_unknown_fields)]
struct ClassOverrides {
light: ProfileOverride,
cpu_heavy: ProfileOverride,
gpu_heavy: ProfileOverride,
mixed: ProfileOverride,
}
#[derive(Default, Deserialize)]
#[serde(deny_unknown_fields)]
struct ProfileOverride {
cores: Option<f32>,
ram_mb: Option<u64>,
gpu_pct: Option<f32>,
vram_mb: Option<u64>,
est_secs: Option<u64>,
min_cores: Option<f32>,
}
impl ProfileOverride {
fn apply(self, base: Sizing) -> Sizing {
let profile = base.profile;
Sizing {
profile: JobProfile {
cores: self.cores.unwrap_or(profile.cores),
ram_mb: self.ram_mb.unwrap_or(profile.ram_mb),
gpu_pct: self.gpu_pct.unwrap_or(profile.gpu_pct),
vram_mb: self.vram_mb.unwrap_or(profile.vram_mb),
est_secs: self.est_secs.unwrap_or(profile.est_secs),
},
min_cores: self.min_cores.or(base.min_cores),
}
}
}
#[derive(Debug, Clone, PartialEq, Serialize)]
#[serde(transparent)]
pub struct Presets(pub BTreeMap<String, Sizing>);
const PRESET_EST_SECS: u64 = 300;
impl Presets {
pub fn get(&self, name: &str) -> Option<&Sizing> {
self.0.get(name)
}
pub fn names(&self) -> impl Iterator<Item = &str> {
self.0.keys().map(String::as_str)
}
}
impl Default for Presets {
fn default() -> Self {
let preset = |cores, ram_mb, gpu_pct, vram_mb, est_secs| {
Sizing::of(JobProfile {
cores,
ram_mb,
gpu_pct,
vram_mb,
est_secs,
})
};
Self(BTreeMap::from([
("cpu_small".to_owned(), preset(2.0, 1024, 0.0, 0, 60)),
("cpu_medium".to_owned(), preset(4.0, 2048, 0.0, 0, 180)),
("gpu_small".to_owned(), preset(1.0, 2048, 30.0, 2048, 300)),
("quick".to_owned(), preset(4.0, 2048, 0.0, 0, 10)),
("low_impact".to_owned(), preset(0.25, 256, 0.0, 0, 60)),
]))
}
}
impl<'de> Deserialize<'de> for Presets {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: Deserializer<'de>,
{
let overrides = BTreeMap::<String, ProfileOverride>::deserialize(deserializer)?;
let mut presets = Self::default();
for (name, value) in overrides {
let profile = match presets.0.get(&name) {
Some(&base) => value.apply(base),
None => {
let (Some(cores), Some(ram_mb)) = (value.cores, value.ram_mb) else {
return Err(de::Error::custom(format!(
"new preset `{name}` needs both cores and ram_mb"
)));
};
value.apply(Sizing::of(JobProfile {
cores,
ram_mb,
gpu_pct: 0.0,
vram_mb: 0,
est_secs: PRESET_EST_SECS,
}))
}
};
presets.0.insert(name, profile);
}
Ok(presets)
}
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(default, deny_unknown_fields)]
pub struct ClassifierConfig {
pub rules: Vec<HeavyRule>,
pub light_flags: Vec<String>,
}
impl Default for ClassifierConfig {
fn default() -> Self {
Self {
rules: vec![
HeavyRule::new(
"cargo",
&["build", "test", "run", "bench"],
JobClass::CpuHeavy,
),
HeavyRule::new("pnpm", &["build*", "test*"], JobClass::CpuHeavy),
HeavyRule::new("msbuild", &[], JobClass::CpuHeavy),
HeavyRule::new("cmake", &["--build"], JobClass::CpuHeavy),
HeavyRule::new("python*", &["train*.py"], JobClass::GpuHeavy),
HeavyRule::new("py", &["train*.py"], JobClass::GpuHeavy),
],
light_flags: ["--help", "-h", "--version", "-V", "/?"]
.map(String::from)
.to_vec(),
}
}
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct HeavyRule {
pub program: String,
#[serde(default)]
pub args: Vec<String>,
pub class: JobClass,
}
impl HeavyRule {
fn new(program: &str, args: &[&str], class: JobClass) -> Self {
Self {
program: program.into(),
args: args.iter().map(|&arg| arg.into()).collect(),
class,
}
}
}
#[cfg(test)]
mod tests {
use std::env;
use super::*;
use crate::mutate::mutations;
fn config_error(text: &str) -> String {
match Config::from_toml(text) {
Err(Error::Config(message)) => message,
other => panic!("expected Error::Config, got {other:?}"),
}
}
#[test]
fn test_config_empty_document_yields_defaults() {
assert_eq!(Config::from_toml("").unwrap(), Config::default());
}
#[test]
fn test_config_default_passes_validation() {
Config::default().validate().unwrap();
}
#[test]
fn test_config_default_toml_round_trip_preserves_every_value() {
let text = toml::to_string(&Config::default()).unwrap();
assert_eq!(Config::from_toml(&text).unwrap(), Config::default());
}
#[test]
fn test_config_presets_merge_over_defaults_and_add_new_ones() {
let config = Config::from_toml(
"[presets.cpu_small]\ncores = 3.0\n\n[presets.render_preview]\ncores = 2.0\n\
ram_mb = 3000\ngpu_pct = 40.0\n",
)
.unwrap();
let defaults = Presets::default();
let small = config.presets.get("cpu_small").unwrap();
assert_eq!(small.profile.cores, 3.0);
assert_eq!(
small.profile.est_secs,
defaults.get("cpu_small").unwrap().profile.est_secs
);
let preview = config.presets.get("render_preview").unwrap().profile;
assert_eq!((preview.gpu_pct, preview.vram_mb), (40.0, 0));
assert_eq!(preview.est_secs, PRESET_EST_SECS);
assert_eq!(config.presets.get("quick"), defaults.get("quick"));
}
#[test]
fn test_config_presets_reject_bad_names_and_incomplete_new_ones() {
assert!(config_error("[presets.cpu_heavy]\ncores = 1.0\nram_mb = 1\n").contains("class"));
assert!(config_error("[presets.Big]\ncores = 1.0\nram_mb = 1\n").contains("a-z"));
assert!(config_error("[presets.quick]\ngpu_pct = 140.0\n").contains("presets.quick"));
let incomplete = Config::from_toml("[presets.huge]\ncores = 12.0\n").unwrap_err();
assert!(incomplete.to_string().contains("ram_mb"), "{incomplete}");
}
#[test]
fn test_default_presets_are_quick_and_low_impact_where_named() {
let presets = Presets::default();
let profile = |name| presets.get(name).unwrap().profile;
assert!(profile("quick").is_quick());
assert!(profile("low_impact").is_low_impact());
assert!(!profile("cpu_small").is_quick());
assert!(!profile("cpu_small").is_low_impact());
}
#[test]
fn test_config_partial_table_merges_over_defaults() {
let config = Config::from_toml(
"[leases]\nheartbeat_ttl_secs = 90\n\n[classes.gpu_heavy]\nvram_mb = 8192\n",
)
.unwrap();
let defaults = Config::default();
assert_eq!(config.leases.heartbeat_ttl_secs, 90);
assert_eq!(
config.leases.idle_release_secs,
defaults.leases.idle_release_secs
);
assert_eq!(config.classes.gpu_heavy.profile.vram_mb, 8192);
assert_eq!(
config.classes.gpu_heavy.profile.cores,
defaults.classes.gpu_heavy.profile.cores
);
assert_eq!(config.classes.cpu_heavy, defaults.classes.cpu_heavy);
assert_eq!(config.daemon, defaults.daemon);
assert_eq!(config.classifier, defaults.classifier);
}
#[test]
fn test_config_default_minimums_are_half_with_at_least_one_core() {
let config = Config::default();
let class = |class| config.classes.get(class).minimum();
assert_eq!(class(JobClass::Light), 1.0);
assert_eq!(class(JobClass::CpuHeavy), 4.0);
assert_eq!(class(JobClass::GpuHeavy), 1.0);
assert_eq!(class(JobClass::Mixed), 3.0);
let preset = |name| config.presets.get(name).unwrap().minimum();
assert_eq!(preset("cpu_small"), 1.0);
assert_eq!(preset("cpu_medium"), 2.0);
assert_eq!(preset("gpu_small"), 1.0);
assert_eq!(preset("quick"), 2.0);
assert_eq!(preset("low_impact"), 0.25);
}
#[test]
fn test_config_min_cores_overrides_and_default_follows_changed_cores() {
let config = Config::from_toml(
"[classes.cpu_heavy]\nmin_cores = 6.0\n\n[classes.mixed]\ncores = 10.0\n\n\
[presets.quick]\nmin_cores = 1.5\n\n[presets.wide]\ncores = 12.0\nram_mb = 1024\n",
)
.unwrap();
assert_eq!(config.classes.cpu_heavy.minimum(), 6.0);
assert_eq!(config.classes.cpu_heavy.profile.cores, 8.0);
assert_eq!(config.classes.mixed.minimum(), 5.0);
assert_eq!(config.presets.get("quick").unwrap().minimum(), 1.5);
assert_eq!(config.presets.get("wide").unwrap().minimum(), 6.0);
}
#[test]
fn test_config_min_cores_out_of_range_names_the_table_and_key() {
for (table, keys) in [
("classes.cpu_heavy", "min_cores = 0.0"),
("classes.light", "min_cores = 1.5"),
("classes.mixed", "cores = 2.0\nmin_cores = 3.0"),
("presets.cpu_small", "min_cores = -1.0"),
("presets.cpu_small", "min_cores = nan"),
] {
let message = config_error(&format!("[{table}]\n{keys}\n"));
let named = message.contains(table) && message.contains("min_cores");
assert!(named, "{message}");
}
}
#[test]
fn test_config_min_cores_round_trips_and_stays_out_when_unset() {
let text = toml::to_string(&Config::default()).unwrap();
assert!(!text.contains("min_cores"), "{text}");
let config = Config::from_toml("[classes.gpu_heavy]\nmin_cores = 2.0\n").unwrap();
let text = toml::to_string(&config).unwrap();
assert_eq!(Config::from_toml(&text).unwrap(), config);
assert_eq!(config.classes.gpu_heavy.min_cores, Some(2.0));
}
#[test]
fn test_config_linux_table_defaults_to_scopes_without_caps_and_merges() {
let defaults = LinuxConfig::default();
assert!(defaults.scopes);
assert!(!defaults.enforce_cpu);
assert!(!defaults.enforce_memory);
let config = Config::from_toml("[linux]\nenforce_memory = true\n").unwrap();
assert_eq!(
config.linux,
LinuxConfig {
enforce_memory: true,
..defaults
}
);
let result = Config::from_toml("[linux]\nenforce_io = true\n");
assert!(matches!(result, Err(Error::ConfigParse(_))));
}
#[test]
fn test_config_integer_percentage_parses_as_float() {
let config = Config::from_toml("[admission]\nheadroom_pct = 20\n").unwrap();
assert_eq!(config.admission.headroom_pct, 20.0);
}
#[test]
fn test_config_user_rules_replace_default_rules() {
let config = Config::from_toml(
"[[classifier.rules]]\nprogram = \"python\"\nargs = [\"train.py\"]\nclass = \"gpu_heavy\"\n",
)
.unwrap();
assert_eq!(
config.classifier.rules,
vec![HeavyRule::new("python", &["train.py"], JobClass::GpuHeavy)]
);
}
#[test]
fn test_config_rule_without_args_matches_any_arguments() {
let config =
Config::from_toml("[[classifier.rules]]\nprogram = \"ninja\"\nclass = \"cpu_heavy\"\n")
.unwrap();
assert!(config.classifier.rules[0].args.is_empty());
}
#[test]
fn test_config_user_rules_keep_default_light_flags() {
let config =
Config::from_toml("[[classifier.rules]]\nprogram = \"ninja\"\nclass = \"cpu_heavy\"\n")
.unwrap();
let defaults = ClassifierConfig::default();
assert_eq!(config.classifier.light_flags, defaults.light_flags);
assert!(defaults.light_flags.contains(&"--help".to_owned()));
}
#[test]
fn test_config_blank_light_flag_is_rejected() {
let message = config_error("[classifier]\nlight_flags = [\"--help\", \"\"]\n");
assert!(message.contains("classifier.light_flags"));
}
#[test]
fn test_config_unknown_key_is_rejected() {
let result = Config::from_toml("[leases]\nheartbeat_tll_secs = 90\n");
assert!(matches!(result, Err(Error::ConfigParse(_))));
let result = Config::from_toml("[classes.mixed]\nvram = 1024\n");
assert!(matches!(result, Err(Error::ConfigParse(_))));
let result = Config::from_toml("[classes.huge]\ncores = 32\n");
assert!(matches!(result, Err(Error::ConfigParse(_))));
}
#[test]
fn test_config_wrong_type_is_rejected() {
let result = Config::from_toml("[daemon]\nport = \"eighty\"\n");
assert!(matches!(result, Err(Error::ConfigParse(_))));
}
#[test]
fn test_config_out_of_range_values_name_the_key() {
assert!(config_error("[daemon]\nport = 0\n").contains("daemon.port"));
assert!(config_error("[admission]\nheadroom_pct = 100\n").contains("headroom_pct"));
assert!(config_error("[benchmark]\nquiet_cpu_pct = 120\n").contains("quiet_cpu_pct"));
assert!(config_error("[benchmark]\nquiet_secs = 0\n").contains("quiet_secs"));
let short_wait = "[benchmark]\nquiet_secs = 30\nmax_quiet_wait_secs = 20\n";
assert!(config_error(short_wait).contains("max_quiet_wait_secs"));
assert!(config_error("[leases]\nheartbeat_ttl_secs = 0\n").contains("heartbeat_ttl"));
assert!(config_error("[classes.mixed]\ngpu_pct = 150\n").contains("classes.mixed"));
assert!(config_error("[retention]\nlease_days = 0\n").contains("retention.lease_days"));
assert!(config_error("[retention]\nhistory_days = 0\n").contains("history_days"));
assert!(config_error("[retention]\nkeep_runs_per_job = 0\n").contains("keep_runs"));
let small_cap = "[retention]\nkeep_runs_per_job = 50\nmax_job_runs = 10\n";
assert!(config_error(small_cap).contains("retention.max_job_runs"));
}
#[test]
fn test_config_load_invalid_file_names_the_file_and_the_key() {
let path =
env::temp_dir().join(format!("allot-shared-test-bad-{}.toml", std::process::id()));
fs::write(&path, "[leases]\nheartbeat_ttl_secs = 0\n").unwrap();
let loaded = Config::load(&path);
fs::remove_file(&path).unwrap();
let message = loaded.unwrap_err().to_string();
assert!(
message.starts_with(&path.display().to_string()),
"{message}"
);
assert!(message.contains("leases.heartbeat_ttl_secs"), "{message}");
}
#[test]
fn test_config_malformed_documents_fail_without_panicking() {
let text = toml::to_string(&Config::default()).unwrap();
for variant in mutations(&text, 0x5eed, 2_000) {
match Config::from_toml(&variant) {
Ok(config) => config.validate().unwrap(),
Err(error) => assert!(!error.to_string().is_empty()),
}
}
}
#[test]
fn test_config_wrongly_typed_value_names_its_key() {
let text = toml::to_string(&Config::default()).unwrap();
let mut checked = 0;
for (index, line) in text.lines().enumerate() {
let Some((key, _)) = line.split_once(" = ") else {
continue;
};
for wrong in ["\"text\"", "[1, 2]", "{ x = 1 }", "-1", "true", "1.5", "0"] {
let mut lines: Vec<&str> = text.lines().collect();
let replaced = format!("{key} = {wrong}");
lines[index] = &replaced;
if let Err(error) = Config::from_toml(&lines.join("\n")) {
let message = error.to_string();
assert!(message.contains(key.trim()), "{key} = {wrong}: {message}");
checked += 1;
}
}
}
assert!(checked > 50, "only {checked} rejections were checked");
}
#[test]
fn test_config_blank_rule_program_is_rejected() {
let message =
config_error("[[classifier.rules]]\nprogram = \" \"\nclass = \"cpu_heavy\"\n");
assert!(message.contains("classifier.rules[0]"));
}
#[test]
fn test_config_load_missing_file_yields_defaults() {
let path = env::temp_dir()
.join("allot-shared-test-missing")
.join("config.toml");
assert_eq!(Config::load(&path).unwrap(), Config::default());
}
#[test]
fn test_config_load_existing_file_parses_it() {
let path = env::temp_dir().join(format!("allot-shared-test-{}.toml", std::process::id()));
fs::write(&path, "[hook]\nfail_open = false\n").unwrap();
let loaded = Config::load(&path);
fs::remove_file(&path).unwrap();
assert!(!loaded.unwrap().hook.fail_open);
}
}