use clap::Parser;
use config::{Config, File};
use serde::{Deserialize, Serialize};
use std::path::PathBuf;
#[derive(Debug, Deserialize, Serialize, Clone)]
pub struct AppConfig {
#[serde(default = "default_host")]
pub host: String,
pub port: u16,
pub workers: usize,
pub log_level: String,
pub config_dir: PathBuf,
#[serde(default)]
pub latency: LatencyConfig,
#[serde(default)]
pub chaos: ChaosConfig,
#[serde(default)]
pub endpoints: Vec<EndpointConfig>,
#[serde(skip)]
pub response_file: Option<PathBuf>,
#[serde(default)]
pub isolated: bool,
}
fn default_host() -> String {
"0.0.0.0".to_string()
}
#[derive(Debug, Deserialize, Serialize, Clone)]
pub struct LatencyConfig {
pub mode: String, pub base_ms: u64,
pub jitter_pct: f64,
}
impl Default for LatencyConfig {
fn default() -> Self {
Self {
mode: "benchmark".to_string(),
base_ms: 0,
jitter_pct: 0.0,
}
}
}
#[derive(Debug, Deserialize, Serialize, Clone)]
pub struct EndpointConfig {
pub path: String,
pub format: String, pub content_type: Option<String>,
}
#[derive(Parser, Debug)]
#[command(author, version, about, long_about = None)]
pub struct Cli {
#[arg(long)]
pub host: Option<String>,
#[arg(short, long)]
pub port: Option<u16>,
#[arg(short, long)]
pub workers: Option<usize>,
#[arg(long, default_value = "mock-server.toml")]
pub config: PathBuf,
#[arg(long)]
pub config_dir: Option<PathBuf>,
#[arg(long)]
pub latency: Option<u64>,
#[arg(long, value_parser = ["benchmark", "realistic", "debug"])]
pub mode: Option<String>,
#[arg(long)]
pub response_file: Option<PathBuf>,
#[arg(long, value_delimiter = ',')]
pub endpoints: Option<Vec<String>>,
#[arg(long)]
pub format: Option<String>,
#[arg(long)]
pub content_type: Option<String>,
#[arg(long)]
pub isolated: bool,
}
impl AppConfig {
pub fn load() -> Result<Self, config::ConfigError> {
let args = Cli::parse();
Self::build_config(args)
}
pub fn for_embedded(config_dir: &std::path::Path, isolated: bool) -> Result<Self, config::ConfigError> {
let args = Cli {
host: None,
port: None,
workers: None,
config: PathBuf::from("mock-server.toml"),
config_dir: Some(config_dir.to_path_buf()),
latency: None,
mode: None,
response_file: None,
endpoints: None,
format: None,
content_type: None,
isolated,
};
Self::build_config(args)
}
pub fn build_config(args: Cli) -> Result<Self, config::ConfigError> {
let mut settings = Config::builder()
.set_default("port", 8100_i64)?
.set_default("workers", num_cpus::get() as i64)?
.set_default("log_level", "error")?
.set_default("config_dir", "config")?;
if args.config.exists() {
settings = settings.add_source(File::from(args.config.clone()));
}
settings = settings.add_source(config::Environment::with_prefix("VIDAIMOCK"));
let mut config: AppConfig = settings.build()?.try_deserialize()?;
if let Some(host) = args.host {
config.host = host;
}
if let Some(port) = args.port {
config.port = port;
}
if let Some(workers) = args.workers {
config.workers = workers;
}
if let Some(latency) = args.latency {
config.latency.base_ms = latency;
}
if let Some(mode) = args.mode {
config.latency.mode = mode;
}
if let Some(dir) = args.config_dir {
config.config_dir = dir;
}
if args.isolated {
config.isolated = true;
}
config.response_file = args.response_file;
if let Some(cli_endpoints) = args.endpoints {
let default_format = args.format.unwrap_or_else(|| "openai".to_string());
let content_type = args.content_type.clone();
config.endpoints = cli_endpoints.into_iter().map(|s| {
if s.contains(':') {
let parts: Vec<&str> = s.splitn(2, ':').collect();
EndpointConfig {
path: parts[0].to_string(),
format: parts[1].to_string(),
content_type: content_type.clone(),
}
} else {
EndpointConfig {
path: s,
format: default_format.clone(),
content_type: content_type.clone(),
}
}
}).collect();
} else if let Some(format) = args.format {
if config.endpoints.is_empty() {
let path = match format.as_str() {
"anthropic" => "/v1/messages",
"gemini" => "/v1beta/models/gemini-pro:generateContent",
_ => "/v1/chat/completions",
};
config.endpoints.push(EndpointConfig { path: path.to_string(), format, content_type: args.content_type });
}
}
Ok(config)
}
}
#[derive(Debug, Deserialize, Serialize, Clone)]
pub struct ChaosConfig {
#[serde(default)]
pub enabled: bool,
#[serde(default)]
pub malformed_pct: f64,
#[serde(default)]
pub drop_pct: f64,
#[serde(default)]
pub trickle_ms: u64,
#[serde(default)]
pub disconnect_pct: f64,
}
impl Default for ChaosConfig {
fn default() -> Self {
Self {
enabled: false,
malformed_pct: 0.0,
drop_pct: 0.0,
trickle_ms: 0,
disconnect_pct: 0.0,
}
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_cli_port_override() {
let args = Cli::parse_from(&["mock-server", "--port", "9999"]);
let config = AppConfig::build_config(args).unwrap();
assert_eq!(config.port, 9999);
}
#[test]
fn test_cli_latency_mode_override() {
let args = Cli::parse_from(&["mock-server", "--mode", "realistic", "--latency", "100"]);
let config = AppConfig::build_config(args).unwrap();
assert_eq!(config.latency.mode, "realistic");
assert_eq!(config.latency.base_ms, 100);
}
#[test]
fn test_cli_endpoints_override() {
let args = Cli::parse_from(&["mock-server", "--endpoints", "/custom1,/custom2", "--format", "echo"]);
let config = AppConfig::build_config(args).unwrap();
assert_eq!(config.endpoints.len(), 2);
assert_eq!(config.endpoints[0].path, "/custom1");
assert_eq!(config.endpoints[0].format, "echo");
assert_eq!(config.endpoints[1].path, "/custom2");
assert_eq!(config.endpoints[1].format, "echo");
}
#[test]
fn test_cli_endpoints_with_formats() {
let args = Cli::parse_from(&["mock-server", "--endpoints", "/v1/chat:openai,/v1/test:echo"]);
let config = AppConfig::build_config(args).unwrap();
assert_eq!(config.endpoints.len(), 2);
assert_eq!(config.endpoints[0].path, "/v1/chat");
assert_eq!(config.endpoints[0].format, "openai");
assert_eq!(config.endpoints[1].path, "/v1/test");
assert_eq!(config.endpoints[1].format, "echo");
}
#[test]
fn test_isolated_defaults_to_false() {
let args = Cli::parse_from(&["mock-server"]);
let config = AppConfig::build_config(args).unwrap();
assert!(!config.isolated, "isolated must default to false");
}
#[test]
fn test_isolated_cli_flag_enables() {
let args = Cli::parse_from(&["mock-server", "--isolated"]);
let config = AppConfig::build_config(args).unwrap();
assert!(config.isolated, "--isolated must enable the flag");
}
}