vc-runtime 0.1.0

Runtime backend for Visual Compiler
Documentation
//! Unit tests for configuration validation.

use crate::config::model::{
    AppConfig, BackendDefinition, BackendOptions, ComfyConfig, GlobalConfig,
    RuntimeOverrides, RuntimeProfile,
};
use crate::config::validation::{
    validate, ConfigError, SemanticError, BackendValidationError,
};
use std::collections::HashMap;
use std::path::PathBuf;
use url::Url;

// Helper untuk membuat Comfy backend dengan cepat
fn comfy_backend(enabled: bool, timeout: u64, poll_timeout: u64, poll_interval: u64, scheme: &str) -> BackendDefinition {
    BackendDefinition {
        enabled,
        options: BackendOptions::ComfyUi(ComfyConfig {
            base_url: Url::parse(&format!("{}://127.0.0.1:8188", scheme)).unwrap(),
            timeout_secs: timeout,
            poll_timeout_secs: poll_timeout,
            poll_interval_ms: poll_interval,
            workflow_template_path: PathBuf::from("workflow.json"),
        }),
    }
}

#[test]
fn valid_config_passes() {
    let mut backends = HashMap::new();
    backends.insert("comfy".to_owned(), comfy_backend(true, 30, 300, 500, "http"));

    let mut profiles = HashMap::new();
    profiles.insert(
        "local".to_owned(),
        RuntimeProfile {
            backend_name: "comfy".to_owned(),
            overrides: RuntimeOverrides::default(),
        },
    );

    let config = AppConfig {
        global: GlobalConfig::default(),
        profiles,
        backends,
    };

    assert!(validate(&config).is_ok());
}

#[test]
fn unknown_backend_fails() {
    let mut profiles = HashMap::new();
    profiles.insert(
        "local".to_owned(),
        RuntimeProfile {
            backend_name: "missing".to_owned(),
            overrides: RuntimeOverrides::default(),
        },
    );

    let config = AppConfig {
        global: GlobalConfig::default(),
        profiles,
        backends: HashMap::new(),
    };

    let err = validate(&config).unwrap_err();
    assert!(matches!(
        err,
        ConfigError::Semantic(SemanticError::UnknownBackend { .. })
    ));
    if let ConfigError::Semantic(SemanticError::UnknownBackend { profile, backend }) = err {
        assert_eq!(profile, "local");
        assert_eq!(backend, "missing");
    }
}

#[test]
fn disabled_backend_fails() {
    let mut backends = HashMap::new();
    backends.insert("comfy".to_owned(), comfy_backend(false, 30, 300, 500, "http"));

    let mut profiles = HashMap::new();
    profiles.insert(
        "local".to_owned(),
        RuntimeProfile {
            backend_name: "comfy".to_owned(),
            overrides: RuntimeOverrides::default(),
        },
    );

    let config = AppConfig {
        global: GlobalConfig::default(),
        profiles,
        backends,
    };

    let err = validate(&config).unwrap_err();
    assert!(matches!(
        err,
        ConfigError::Semantic(SemanticError::DisabledBackend { .. })
    ));
    if let ConfigError::Semantic(SemanticError::DisabledBackend { backend }) = err {
        assert_eq!(backend, "comfy");
    }
}

#[test]
fn zero_timeout_fails() {
    let mut backends = HashMap::new();
    backends.insert("comfy".to_owned(), comfy_backend(true, 0, 300, 500, "http"));

    let config = AppConfig {
        global: GlobalConfig::default(),
        profiles: HashMap::new(),
        backends,
    };

    let err = validate(&config).unwrap_err();
    assert!(matches!(
        err,
        ConfigError::Backend(BackendValidationError::ZeroTimeout { .. })
    ));
    if let ConfigError::Backend(BackendValidationError::ZeroTimeout { backend }) = err {
        assert_eq!(backend, "comfy");
    }
}

#[test]
fn zero_poll_timeout_fails() {
    let mut backends = HashMap::new();
    backends.insert("comfy".to_owned(), comfy_backend(true, 30, 0, 500, "http"));

    let config = AppConfig {
        global: GlobalConfig::default(),
        profiles: HashMap::new(),
        backends,
    };

    let err = validate(&config).unwrap_err();
    assert!(matches!(
        err,
        ConfigError::Backend(BackendValidationError::ZeroPollTimeout { .. })
    ));
    if let ConfigError::Backend(BackendValidationError::ZeroPollTimeout { backend }) = err {
        assert_eq!(backend, "comfy");
    }
}

#[test]
fn zero_poll_interval_fails() {
    let mut backends = HashMap::new();
    backends.insert("comfy".to_owned(), comfy_backend(true, 30, 300, 0, "http"));

    let config = AppConfig {
        global: GlobalConfig::default(),
        profiles: HashMap::new(),
        backends,
    };

    let err = validate(&config).unwrap_err();
    assert!(matches!(
        err,
        ConfigError::Backend(BackendValidationError::ZeroPollInterval { .. })
    ));
    if let ConfigError::Backend(BackendValidationError::ZeroPollInterval { backend }) = err {
        assert_eq!(backend, "comfy");
    }
}

#[test]
fn unsupported_url_scheme_fails() {
    let mut backends = HashMap::new();
    backends.insert("comfy".to_owned(), comfy_backend(true, 30, 300, 500, "ftp"));

    let config = AppConfig {
        global: GlobalConfig::default(),
        profiles: HashMap::new(),
        backends,
    };

    let err = validate(&config).unwrap_err();
    assert!(matches!(
        err,
        ConfigError::Backend(BackendValidationError::UnsupportedScheme { .. })
    ));
    if let ConfigError::Backend(BackendValidationError::UnsupportedScheme { backend, scheme }) = err {
        assert_eq!(backend, "comfy");
        assert_eq!(scheme, "ftp");
    }
}