vc-runtime 0.1.0

Runtime backend for Visual Compiler
Documentation
//! Application configuration domain model.
//!
//! This module defines the root configuration type that aggregates
//! global settings, profiles, and backend definitions.

use super::{BackendDefinition, GlobalConfig, RuntimeProfile};
use serde::{Deserialize, Serialize};
use std::collections::HashMap;

/// Complete application configuration.
///
/// Names are the keys in the HashMaps; there is no duplicate name field
/// inside the structs themselves.
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
pub struct AppConfig {
    pub global: GlobalConfig,
    pub profiles: HashMap<String, RuntimeProfile>,
    pub backends: HashMap<String, BackendDefinition>,
}

impl AppConfig {
    /// Retrieves a profile by name.
    ///
    /// This is a pure data lookup; no validation is performed.
    pub fn profile(&self, name: &str) -> Option<&RuntimeProfile> {
        self.profiles.get(name)
    }

    /// Retrieves a backend definition by name.
    ///
    /// This is a pure data lookup; no validation is performed.
    pub fn backend(&self, name: &str) -> Option<&BackendDefinition> {
        self.backends.get(name)
    }

    /// Resolves the backend selected by the specified profile.
    ///
    /// This is a pure data lookup.
    /// No validation is performed.
    pub fn resolve_backend(&self, profile_name: &str) -> Option<&BackendDefinition> {
        let profile = self.profile(profile_name)?;
        self.backend(&profile.backend_name)
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::config::model::{BackendDefinition, BackendOptions, DummyConfig, RuntimeOverrides};
    use std::collections::HashMap;

    #[test]
    fn resolve_backend_found() {
        let mut backends = HashMap::new();
        backends.insert(
            "test".to_owned(),
            BackendDefinition {
                enabled: true,
                options: BackendOptions::Dummy(DummyConfig::default()),
            },
        );
        let mut profiles = HashMap::new();
        profiles.insert(
            "local".to_owned(),
            RuntimeProfile {
                backend_name: "test".to_owned(),
                overrides: RuntimeOverrides::default(),
            },
        );
        let config = AppConfig { global: GlobalConfig::default(), profiles, backends };

        let backend = config.resolve_backend("local");
        assert!(backend.is_some());
        assert_eq!(backend.unwrap().options, BackendOptions::Dummy(DummyConfig::default()));
    }

    #[test]
    fn resolve_backend_profile_missing() {
        let config = AppConfig::default();
        assert!(config.resolve_backend("missing").is_none());
    }

    #[test]
    fn resolve_backend_backend_missing() {
        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() };
        assert!(config.resolve_backend("local").is_none());
    }
}