use std::collections::BTreeMap;
use std::path::Path;
use serde::{Deserialize, Serialize};
use crate::error::Error;
use crate::paths::AppPaths;
pub const DEFAULT_ORIGIN_BASE: &str = "https://huggingface.co/ggerganov/whisper.cpp/resolve/main";
pub const BEAM_RANGE: std::ops::RangeInclusive<i32> = 1..=16;
pub const VAD_RANGE: std::ops::RangeInclusive<f32> = 0.0..=1.0;
pub const CONCURRENCY_RANGE: std::ops::RangeInclusive<usize> = 1..=32;
pub fn range_message<T: std::fmt::Display>(
key: &str,
range: &std::ops::RangeInclusive<T>,
) -> String {
format!("{key} must be {}..={}", range.start(), range.end())
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct DownloadKnobs {
pub retries: u32,
pub max_elapsed_secs: u64,
pub timeout_secs: u64,
pub backoff_ms: u64,
pub proxy: String,
pub io_chunk: usize,
}
pub const WRITABLE_KEYS: &[&str] = &[
"model",
"language",
"device",
"timeout",
"timeout-grace",
"max-duration",
"beam",
"vad",
"concurrency",
"helper",
"helper-fallback",
"max-memory",
"locale",
"origin-base",
"download-retries",
"retry-max-elapsed",
"download-timeout",
"download-backoff-ms",
"http-proxy",
"hallucination-filter",
"hallucination-patterns",
"log-level",
"log-format",
"log-timestamps",
"vad-frame-ms",
"vad-rms-min",
"vad-rms-max",
"resample-taps",
"io-chunk-bytes",
"probe-poll-ms",
"helper-args",
"nvidia-smi-path",
"audio-extensions",
"video-extensions",
"content-keys",
];
pub const VAD_FRAME_MS_RANGE: std::ops::RangeInclusive<u32> = 10..=100;
pub const VAD_RMS_RANGE: std::ops::RangeInclusive<f32> = 0.0..=1.0;
pub const RESAMPLE_TAPS_RANGE: std::ops::RangeInclusive<usize> = 3..=511;
pub const IO_CHUNK_RANGE: std::ops::RangeInclusive<usize> = 4096..=16_777_216;
pub const PROBE_POLL_RANGE: std::ops::RangeInclusive<u64> = 1..=1000;
pub const BACKOFF_RANGE: std::ops::RangeInclusive<u64> = 0..=60_000;
pub const LOG_LEVELS: &[&str] = &["off", "error", "warn", "info", "debug", "trace"];
pub const LOG_FORMATS: &[&str] = &["text", "json"];
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct Store {
pub model: Option<String>,
pub language: Option<String>,
pub device: Option<u32>,
pub timeout: Option<u64>,
#[serde(rename = "timeout-grace")]
pub timeout_grace: Option<u64>,
#[serde(rename = "max-duration")]
pub max_duration: Option<f64>,
pub beam: Option<i32>,
pub vad: Option<f32>,
pub concurrency: Option<usize>,
pub helper: Option<String>,
#[serde(rename = "helper-fallback")]
pub helper_fallback: Option<bool>,
#[serde(rename = "max-memory")]
pub max_memory: Option<u64>,
pub locale: Option<String>,
#[serde(rename = "origin-base")]
pub origin_base: Option<String>,
#[serde(rename = "download-retries")]
pub download_retries: Option<u32>,
#[serde(rename = "retry-max-elapsed")]
pub retry_max_elapsed: Option<u64>,
#[serde(rename = "download-timeout")]
pub download_timeout: Option<u64>,
#[serde(rename = "download-backoff-ms")]
pub download_backoff_ms: Option<u64>,
#[serde(rename = "http-proxy")]
pub http_proxy: Option<String>,
#[serde(rename = "hallucination-filter")]
pub hallucination_filter: Option<bool>,
#[serde(rename = "hallucination-patterns")]
pub hallucination_patterns: Option<String>,
#[serde(rename = "log-level")]
pub log_level: Option<String>,
#[serde(rename = "log-format")]
pub log_format: Option<String>,
#[serde(rename = "log-timestamps")]
pub log_timestamps: Option<bool>,
#[serde(rename = "vad-frame-ms")]
pub vad_frame_ms: Option<u32>,
#[serde(rename = "vad-rms-min")]
pub vad_rms_min: Option<f32>,
#[serde(rename = "vad-rms-max")]
pub vad_rms_max: Option<f32>,
#[serde(rename = "resample-taps")]
pub resample_taps: Option<usize>,
#[serde(rename = "io-chunk-bytes")]
pub io_chunk_bytes: Option<usize>,
#[serde(rename = "probe-poll-ms")]
pub probe_poll_ms: Option<u64>,
#[serde(rename = "helper-args")]
pub helper_args: Option<Vec<String>>,
#[serde(rename = "nvidia-smi-path")]
pub nvidia_smi_path: Option<String>,
#[serde(rename = "audio-extensions")]
pub audio_extensions: Option<Vec<String>>,
#[serde(rename = "video-extensions")]
pub video_extensions: Option<Vec<String>>,
#[serde(rename = "content-keys")]
pub content_keys: Option<Vec<String>>,
}
impl Store {
pub fn seeds() -> Self {
Self {
model: Some("large-v3".into()),
language: Some("auto".into()),
device: Some(0),
timeout: Some(0),
timeout_grace: Some(5),
max_duration: Some(24.0 * 3600.0),
beam: Some(5),
vad: Some(0.0),
concurrency: Some(1),
helper: Some(String::new()),
helper_fallback: Some(true),
max_memory: Some(0),
locale: None,
origin_base: Some(DEFAULT_ORIGIN_BASE.into()),
download_retries: Some(2),
retry_max_elapsed: Some(120),
download_timeout: Some(600),
download_backoff_ms: Some(200),
http_proxy: Some(String::new()),
hallucination_filter: Some(true),
hallucination_patterns: Some(String::new()),
log_level: Some("warn".into()),
log_format: Some("text".into()),
log_timestamps: Some(false),
vad_frame_ms: Some(30),
vad_rms_min: Some(0.002),
vad_rms_max: Some(0.10),
resample_taps: Some(31),
io_chunk_bytes: Some(64 * 1024),
probe_poll_ms: Some(25),
helper_args: Some(Vec::new()),
nvidia_smi_path: Some(String::new()),
audio_extensions: Some(
crate::audio::AUDIO_EXT
.iter()
.map(|s| (*s).to_string())
.collect(),
),
video_extensions: Some(
crate::audio::VIDEO_EXT
.iter()
.map(|s| (*s).to_string())
.collect(),
),
content_keys: Some(
crate::surface::CONTENT_KEYS
.iter()
.map(|s| (*s).to_string())
.collect(),
),
}
}
pub fn load(path: &Path) -> Result<Self, Error> {
if !path.exists() {
return Ok(Self::default());
}
let raw = std::fs::read_to_string(path)
.map_err(|e| Error::Config(format!("cannot read {}: {e}", path.display())))?;
toml::from_str(&raw).map_err(|e| Error::Config(e.to_string()))
}
pub fn save(&self, path: &Path) -> Result<(), Error> {
let body = toml::to_string_pretty(self).map_err(|e| Error::Config(e.to_string()))?;
crate::paths::write_atomic(path, &body)
}
pub fn effective(&self) -> Self {
let mut out = Self::seeds();
merge_opt(&mut out.model, &self.model);
merge_opt(&mut out.language, &self.language);
merge_opt(&mut out.device, &self.device);
merge_opt(&mut out.timeout, &self.timeout);
merge_opt(&mut out.timeout_grace, &self.timeout_grace);
merge_opt(&mut out.max_duration, &self.max_duration);
merge_opt(&mut out.beam, &self.beam);
merge_opt(&mut out.vad, &self.vad);
merge_opt(&mut out.concurrency, &self.concurrency);
merge_opt(&mut out.helper, &self.helper);
merge_opt(&mut out.helper_fallback, &self.helper_fallback);
merge_opt(&mut out.max_memory, &self.max_memory);
merge_opt(&mut out.locale, &self.locale);
merge_opt(&mut out.origin_base, &self.origin_base);
merge_opt(&mut out.download_retries, &self.download_retries);
merge_opt(&mut out.retry_max_elapsed, &self.retry_max_elapsed);
merge_opt(&mut out.download_timeout, &self.download_timeout);
merge_opt(&mut out.download_backoff_ms, &self.download_backoff_ms);
merge_opt(&mut out.http_proxy, &self.http_proxy);
merge_opt(&mut out.hallucination_filter, &self.hallucination_filter);
merge_opt(
&mut out.hallucination_patterns,
&self.hallucination_patterns,
);
merge_opt(&mut out.log_level, &self.log_level);
merge_opt(&mut out.log_format, &self.log_format);
merge_opt(&mut out.log_timestamps, &self.log_timestamps);
merge_opt(&mut out.vad_frame_ms, &self.vad_frame_ms);
merge_opt(&mut out.vad_rms_min, &self.vad_rms_min);
merge_opt(&mut out.vad_rms_max, &self.vad_rms_max);
merge_opt(&mut out.resample_taps, &self.resample_taps);
merge_opt(&mut out.io_chunk_bytes, &self.io_chunk_bytes);
merge_opt(&mut out.probe_poll_ms, &self.probe_poll_ms);
merge_opt(&mut out.helper_args, &self.helper_args);
merge_opt(&mut out.nvidia_smi_path, &self.nvidia_smi_path);
merge_opt(&mut out.audio_extensions, &self.audio_extensions);
merge_opt(&mut out.video_extensions, &self.video_extensions);
merge_opt(&mut out.content_keys, &self.content_keys);
out
}
pub fn origin(&self) -> &str {
self.origin_base.as_deref().unwrap_or(DEFAULT_ORIGIN_BASE)
}
pub fn download_knobs(&self) -> DownloadKnobs {
let s = Self::seeds();
DownloadKnobs {
retries: self
.download_retries
.or(s.download_retries)
.unwrap_or_default(),
max_elapsed_secs: self
.retry_max_elapsed
.or(s.retry_max_elapsed)
.unwrap_or_default(),
timeout_secs: self
.download_timeout
.or(s.download_timeout)
.unwrap_or_default(),
backoff_ms: self
.download_backoff_ms
.or(s.download_backoff_ms)
.unwrap_or_default(),
proxy: self
.http_proxy
.clone()
.or(s.http_proxy.clone())
.unwrap_or_default(),
io_chunk: self
.io_chunk_bytes
.or(s.io_chunk_bytes)
.filter(|n| *n > 0)
.unwrap_or(64 * 1024),
}
}
pub fn get_key(&self, key: &str) -> Result<String, Error> {
let e = self.effective();
let s = Self::seeds();
let value = match key {
"model" => e.model.or(s.model).unwrap_or_default(),
"language" => e.language.or(s.language).unwrap_or_default(),
"device" => e.device.or(s.device).unwrap_or_default().to_string(),
"timeout" => e.timeout.or(s.timeout).unwrap_or_default().to_string(),
"timeout-grace" => e
.timeout_grace
.or(s.timeout_grace)
.unwrap_or_default()
.to_string(),
"max-duration" => e
.max_duration
.or(s.max_duration)
.unwrap_or_default()
.to_string(),
"beam" => e.beam.or(s.beam).unwrap_or_default().to_string(),
"vad" => e.vad.or(s.vad).unwrap_or_default().to_string(),
"concurrency" => e
.concurrency
.or(s.concurrency)
.unwrap_or_default()
.to_string(),
"helper" => e.helper.or(s.helper).unwrap_or_default(),
"helper-fallback" => e
.helper_fallback
.or(s.helper_fallback)
.unwrap_or_default()
.to_string(),
"max-memory" => e
.max_memory
.or(s.max_memory)
.unwrap_or_default()
.to_string(),
"locale" => e.locale.or(s.locale).unwrap_or_default(),
"origin-base" => e.origin_base.or(s.origin_base).unwrap_or_default(),
"download-retries" => e
.download_retries
.or(s.download_retries)
.unwrap_or_default()
.to_string(),
"retry-max-elapsed" => e
.retry_max_elapsed
.or(s.retry_max_elapsed)
.unwrap_or_default()
.to_string(),
"download-timeout" => e
.download_timeout
.or(s.download_timeout)
.unwrap_or_default()
.to_string(),
"download-backoff-ms" => e
.download_backoff_ms
.or(s.download_backoff_ms)
.unwrap_or_default()
.to_string(),
"http-proxy" => e.http_proxy.or(s.http_proxy).unwrap_or_default(),
"hallucination-filter" => e
.hallucination_filter
.or(s.hallucination_filter)
.unwrap_or_default()
.to_string(),
"hallucination-patterns" => e
.hallucination_patterns
.or(s.hallucination_patterns)
.unwrap_or_default(),
"log-level" => e.log_level.or(s.log_level).unwrap_or_default(),
"log-format" => e.log_format.or(s.log_format).unwrap_or_default(),
"log-timestamps" => e
.log_timestamps
.or(s.log_timestamps)
.unwrap_or_default()
.to_string(),
"vad-frame-ms" => e
.vad_frame_ms
.or(s.vad_frame_ms)
.unwrap_or_default()
.to_string(),
"vad-rms-min" => e
.vad_rms_min
.or(s.vad_rms_min)
.unwrap_or_default()
.to_string(),
"vad-rms-max" => e
.vad_rms_max
.or(s.vad_rms_max)
.unwrap_or_default()
.to_string(),
"resample-taps" => e
.resample_taps
.or(s.resample_taps)
.unwrap_or_default()
.to_string(),
"io-chunk-bytes" => e
.io_chunk_bytes
.or(s.io_chunk_bytes)
.unwrap_or_default()
.to_string(),
"probe-poll-ms" => e
.probe_poll_ms
.or(s.probe_poll_ms)
.unwrap_or_default()
.to_string(),
"helper-args" => e
.helper_args
.or(s.helper_args)
.unwrap_or_default()
.join(","),
"nvidia-smi-path" => e.nvidia_smi_path.or(s.nvidia_smi_path).unwrap_or_default(),
"audio-extensions" => e
.audio_extensions
.or(s.audio_extensions)
.unwrap_or_default()
.join(","),
"video-extensions" => e
.video_extensions
.or(s.video_extensions)
.unwrap_or_default()
.join(","),
"content-keys" => e
.content_keys
.or(s.content_keys)
.unwrap_or_default()
.join(","),
_ => return Err(Error::Config(format!("unknown key: {key}"))),
};
Ok(value)
}
pub fn set_key(&mut self, key: &str, value: &str) -> Result<(), Error> {
if !WRITABLE_KEYS.contains(&key) {
return Err(Error::Config(format!("unknown key: {key}")));
}
match key {
"model" => self.model = Some(value.to_string()),
"language" => self.language = Some(value.to_string()),
"device" => self.device = Some(parse_u32(value)?),
"timeout" => self.timeout = Some(parse_u64(value)?),
"timeout-grace" => self.timeout_grace = Some(parse_u64(value)?),
"max-duration" => self.max_duration = Some(parse_f64(value)?),
"beam" => {
let n = parse_i32(value)?;
if !(BEAM_RANGE).contains(&n) {
return Err(Error::Config(range_message("beam", &BEAM_RANGE)));
}
self.beam = Some(n);
}
"vad" => {
let n = parse_f32(value)?;
if !(VAD_RANGE).contains(&n) {
return Err(Error::Config(range_message("vad", &VAD_RANGE)));
}
self.vad = Some(n);
}
"concurrency" => {
let n = parse_usize(value)?;
if !(CONCURRENCY_RANGE).contains(&n) {
return Err(Error::Config(range_message(
"concurrency",
&CONCURRENCY_RANGE,
)));
}
self.concurrency = Some(n);
}
"helper" => self.helper = Some(value.to_string()),
"helper-fallback" => self.helper_fallback = Some(parse_bool(value)?),
"max-memory" => self.max_memory = Some(parse_u64(value)?),
"locale" => self.locale = Some(value.to_string()),
"origin-base" => {
if !value.starts_with("https://") {
return Err(Error::InsecureOrigin {
url: value.to_string(),
});
}
self.origin_base = Some(value.trim_end_matches('/').to_string());
}
"download-retries" => self.download_retries = Some(parse_u32(value)?),
"retry-max-elapsed" => self.retry_max_elapsed = Some(parse_u64(value)?),
"download-timeout" => self.download_timeout = Some(parse_u64(value)?),
"download-backoff-ms" => {
let n = parse_u64(value)?;
if !BACKOFF_RANGE.contains(&n) {
return Err(Error::Config(range_message(key, &BACKOFF_RANGE)));
}
self.download_backoff_ms = Some(n);
}
"http-proxy" => {
if !value.is_empty()
&& !(value.starts_with("http://") || value.starts_with("https://"))
{
return Err(Error::Config(format!(
"http-proxy must start with http:// or https://: {value}"
)));
}
self.http_proxy = Some(value.to_string());
}
"hallucination-filter" => self.hallucination_filter = Some(parse_bool(value)?),
"hallucination-patterns" => {
if !value.trim().is_empty() {
crate::audio::hallucination_regex_from(&[value.to_string()])?;
}
self.hallucination_patterns = Some(value.to_string());
}
"log-level" => {
if !LOG_LEVELS.contains(&value) {
return Err(Error::Config(format!(
"log-level must be one of {}",
LOG_LEVELS.join(", ")
)));
}
self.log_level = Some(value.to_string());
}
"log-format" => {
if !LOG_FORMATS.contains(&value) {
return Err(Error::Config(format!(
"log-format must be one of {}",
LOG_FORMATS.join(", ")
)));
}
self.log_format = Some(value.to_string());
}
"log-timestamps" => self.log_timestamps = Some(parse_bool(value)?),
"vad-frame-ms" => {
let n = parse_u32(value)?;
if !VAD_FRAME_MS_RANGE.contains(&n) {
return Err(Error::Config(range_message(key, &VAD_FRAME_MS_RANGE)));
}
self.vad_frame_ms = Some(n);
}
"vad-rms-min" => self.vad_rms_min = Some(parse_rms(key, value)?),
"vad-rms-max" => self.vad_rms_max = Some(parse_rms(key, value)?),
"resample-taps" => {
let n = parse_usize(value)?;
if !RESAMPLE_TAPS_RANGE.contains(&n) {
return Err(Error::Config(range_message(key, &RESAMPLE_TAPS_RANGE)));
}
if n % 2 == 0 {
return Err(Error::Config("resample-taps must be odd".into()));
}
self.resample_taps = Some(n);
}
"io-chunk-bytes" => {
let n = parse_usize(value)?;
if !IO_CHUNK_RANGE.contains(&n) {
return Err(Error::Config(range_message(key, &IO_CHUNK_RANGE)));
}
self.io_chunk_bytes = Some(n);
}
"probe-poll-ms" => {
let n = parse_u64(value)?;
if !PROBE_POLL_RANGE.contains(&n) {
return Err(Error::Config(range_message(key, &PROBE_POLL_RANGE)));
}
self.probe_poll_ms = Some(n);
}
"helper-args" => self.helper_args = Some(parse_list(value)),
"nvidia-smi-path" => self.nvidia_smi_path = Some(value.to_string()),
"audio-extensions" => self.audio_extensions = Some(parse_ext_list(key, value)?),
"video-extensions" => self.video_extensions = Some(parse_ext_list(key, value)?),
"content-keys" => self.content_keys = Some(parse_list(value)),
_ => return Err(Error::Config(format!("unknown key: {key}"))),
}
Ok(())
}
pub fn unset_key(&mut self, key: &str) -> Result<(), Error> {
if !WRITABLE_KEYS.contains(&key) {
return Err(Error::Config(format!("unknown key: {key}")));
}
match key {
"model" => self.model = None,
"language" => self.language = None,
"device" => self.device = None,
"timeout" => self.timeout = None,
"timeout-grace" => self.timeout_grace = None,
"max-duration" => self.max_duration = None,
"beam" => self.beam = None,
"vad" => self.vad = None,
"concurrency" => self.concurrency = None,
"helper" => self.helper = None,
"helper-fallback" => self.helper_fallback = None,
"max-memory" => self.max_memory = None,
"locale" => self.locale = None,
"origin-base" => self.origin_base = None,
"download-retries" => self.download_retries = None,
"retry-max-elapsed" => self.retry_max_elapsed = None,
"download-timeout" => self.download_timeout = None,
"download-backoff-ms" => self.download_backoff_ms = None,
"http-proxy" => self.http_proxy = None,
"hallucination-filter" => self.hallucination_filter = None,
"hallucination-patterns" => self.hallucination_patterns = None,
"log-level" => self.log_level = None,
"log-format" => self.log_format = None,
"log-timestamps" => self.log_timestamps = None,
"vad-frame-ms" => self.vad_frame_ms = None,
"vad-rms-min" => self.vad_rms_min = None,
"vad-rms-max" => self.vad_rms_max = None,
"resample-taps" => self.resample_taps = None,
"io-chunk-bytes" => self.io_chunk_bytes = None,
"probe-poll-ms" => self.probe_poll_ms = None,
"helper-args" => self.helper_args = None,
"nvidia-smi-path" => self.nvidia_smi_path = None,
"audio-extensions" => self.audio_extensions = None,
"video-extensions" => self.video_extensions = None,
"content-keys" => self.content_keys = None,
_ => return Err(Error::Config(format!("unknown key: {key}"))),
}
Ok(())
}
pub fn list_map(&self) -> BTreeMap<String, String> {
WRITABLE_KEYS
.iter()
.filter_map(|k| self.get_key(k).ok().map(|v| ((*k).to_string(), v)))
.collect()
}
}
fn merge_opt<T: Clone>(dst: &mut Option<T>, src: &Option<T>) {
if src.is_some() {
*dst = src.clone();
}
}
fn parse_list(v: &str) -> Vec<String> {
v.split(',')
.map(str::trim)
.filter(|s| !s.is_empty())
.map(str::to_string)
.collect()
}
fn parse_ext_list(key: &str, v: &str) -> Result<Vec<String>, Error> {
let out: Vec<String> = parse_list(v)
.into_iter()
.map(|s| s.trim_start_matches('.').to_ascii_lowercase())
.collect();
if out.is_empty() {
return Err(Error::Config(format!("{key} must list at least one item")));
}
Ok(out)
}
fn parse_rms(key: &str, v: &str) -> Result<f32, Error> {
let n: f32 = v
.parse()
.map_err(|_| Error::Config(format!("not a number: {v}")))?;
if !VAD_RMS_RANGE.contains(&n) {
return Err(Error::Config(range_message(key, &VAD_RMS_RANGE)));
}
Ok(n)
}
fn parse_u32(v: &str) -> Result<u32, Error> {
v.parse()
.map_err(|_| Error::Config(format!("not u32: {v}")))
}
fn parse_u64(v: &str) -> Result<u64, Error> {
v.parse()
.map_err(|_| Error::Config(format!("not u64: {v}")))
}
fn parse_i32(v: &str) -> Result<i32, Error> {
v.parse()
.map_err(|_| Error::Config(format!("not i32: {v}")))
}
fn parse_f32(v: &str) -> Result<f32, Error> {
v.parse()
.map_err(|_| Error::Config(format!("not f32: {v}")))
}
fn parse_f64(v: &str) -> Result<f64, Error> {
v.parse()
.map_err(|_| Error::Config(format!("not f64: {v}")))
}
fn parse_usize(v: &str) -> Result<usize, Error> {
v.parse()
.map_err(|_| Error::Config(format!("not usize: {v}")))
}
fn parse_bool(v: &str) -> Result<bool, Error> {
match v {
"true" | "1" | "yes" => Ok(true),
"false" | "0" | "no" => Ok(false),
_ => Err(Error::Config(format!("not bool: {v}"))),
}
}
pub fn load(paths: &AppPaths) -> Result<Store, Error> {
paths.ensure()?;
Store::load(&paths.config_file())
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn default_model_is_the_most_accurate_and_the_cut_is_widest() {
assert_eq!(Store::seeds().model.as_deref(), Some("large-v3"));
assert_eq!(Store::seeds().vad, Some(0.0));
assert!(
VAD_RANGE.contains(&Store::seeds().vad.expect("seeded vad")),
"the seeded sensitivity must be inside the accepted range"
);
}
#[test]
fn default_concurrency_is_one() {
assert_eq!(Store::seeds().concurrency, Some(1));
}
#[test]
fn origin_is_never_empty_and_matches_the_single_seed() {
assert_eq!(Store::default().effective().origin(), DEFAULT_ORIGIN_BASE);
assert!(DEFAULT_ORIGIN_BASE.starts_with("https://"));
}
#[test]
fn out_of_range_config_value_is_config_not_usage() {
let mut s = Store::default();
for (key, value) in [("beam", "99"), ("vad", "2"), ("concurrency", "0")] {
let err = s.set_key(key, value).expect_err(key);
assert_eq!(err.exit_code(), 78, "{key} must fail closed as config");
}
}
#[test]
fn unset_restores_the_seed() {
let mut s = Store::default();
s.set_key("beam", "3").expect("set");
assert_eq!(s.get_key("beam").expect("get"), "3");
s.unset_key("beam").expect("unset");
assert_eq!(s.get_key("beam").expect("get"), "5");
}
#[test]
fn unknown_key_fails() {
let mut s = Store::default();
assert!(s.set_key("nope", "x").is_err());
}
#[test]
fn every_writable_key_survives_effective() {
for key in WRITABLE_KEYS {
let mut s = Store::default();
let seeded = Store::seeds()
.get_key(key)
.unwrap_or_else(|e| panic!("{key} must be readable: {e}"));
let probe = distinct_value(key, &seeded);
s.set_key(key, &probe)
.unwrap_or_else(|e| panic!("{key} must accept {probe:?}: {e}"));
let got = s
.get_key(key)
.unwrap_or_else(|e| panic!("{key} must be readable: {e}"));
assert_ne!(
got, seeded,
"{key} did not survive effective(): the seed overwrote the stored value"
);
}
}
fn distinct_value(key: &str, seeded: &str) -> String {
match key {
"model" => "small".into(),
"language" => "pt".into(),
"locale" => "en".into(),
"helper" | "nvidia-smi-path" => "/usr/bin/true".into(),
"http-proxy" => "http://proxy.invalid:3128".into(),
"origin-base" => "https://mirror.invalid/models".into(),
"hallucination-patterns" => "meu ruido".into(),
"log-level" => "debug".into(),
"log-format" => "json".into(),
"helper-args" | "content-keys" => "alpha,beta".into(),
"audio-extensions" | "video-extensions" => "wav,mp3".into(),
"vad" | "vad-rms-min" | "vad-rms-max" => "0.25".into(),
"beam" => "7".into(),
"concurrency" => "3".into(),
"vad-frame-ms" => "40".into(),
"resample-taps" => "63".into(),
"io-chunk-bytes" => "8192".into(),
"probe-poll-ms" => "7".into(),
"helper-fallback" | "hallucination-filter" | "log-timestamps" => {
if seeded == "true" { "false" } else { "true" }.into()
}
_ => {
let n: u64 = seeded.parse().unwrap_or(0);
(n + 17).to_string()
}
}
}
#[test]
fn list_contains_required_keys() {
let keys = Store::seeds().list_map();
for required in WRITABLE_KEYS {
assert!(keys.contains_key(*required), "missing {required}");
}
assert_eq!(keys.len(), WRITABLE_KEYS.len());
}
}