roomeq-model 0.5.5

RoomEQ configuration, pipeline, and DSP-chain contracts
Documentation
#![allow(clippy::field_reassign_with_default)]
use super::super::validate::validate_room_config;
use crate::config::{OptimizerConfig, RoomConfig, SpeakerConfig};
use crate::{MeasurementRef, MeasurementSingle, MeasurementSource};
use std::collections::HashMap;

use crate::config::*;
use std::path::PathBuf;

/// Helper to create a minimal valid RoomConfig with a given algorithm
fn config_with_algorithm(algo: &str) -> RoomConfig {
    let mut speakers = HashMap::new();
    speakers.insert(
        "left".to_string(),
        SpeakerConfig::Single(MeasurementSource::Single(MeasurementSingle {
            measurement: MeasurementRef::Path(PathBuf::from("test.csv")),
            speaker_name: None,
        })),
    );
    let mut optimizer = OptimizerConfig::default();
    optimizer.algorithm = algo.to_string();
    RoomConfig {
        version: default_config_version(),
        system: None,
        speakers,
        crossovers: None,
        target_curve: None,
        optimizer,
        provenance: Default::default(),
        recording_config: None,
        ctc: None,
        cea2034_cache: None,
    }
}

#[test]
fn test_all_algorithm_prefixes_accepted() {
    // Bug #7: mh:firefly was flagged as unknown. All prefixed algorithms
    // (mh:*, nlopt:*, autoeq:*) and bare names (cobyla, de) must be valid.
    let valid_algos = [
        "mh:firefly",
        "mh:pso",
        "nlopt:cobyla",
        "nlopt:isres",
        "autoeq:de",
        "cobyla",
        "de",
    ];
    for algo in &valid_algos {
        let config = config_with_algorithm(algo);
        let result = validate_room_config(&config);
        let has_algo_warning = result
            .warnings
            .iter()
            .any(|w| w.contains("Unknown algorithm"));
        assert!(
            !has_algo_warning,
            "Algorithm '{}' should be accepted without warning, but got: {:?}",
            algo, result.warnings
        );
    }
}

#[test]
fn test_unknown_algorithm_warns_not_errors() {
    // An unrecognized algorithm should produce a warning, not an error.
    // The config should still be valid (algo might be a plugin).
    let config = config_with_algorithm("bogus_algo");
    let result = validate_room_config(&config);
    assert!(
        result.is_valid,
        "Unknown algorithm should warn, not error. Errors: {:?}",
        result.errors
    );
    assert!(
        result
            .warnings
            .iter()
            .any(|w| w.contains("Unknown algorithm")),
        "Unknown algorithm should produce a warning, but warnings: {:?}",
        result.warnings
    );
}

#[test]
fn test_all_peq_models_accepted() {
    use crate::PeqModel;
    for model in PeqModel::all() {
        let mut config = config_with_algorithm("autoeq:de");
        config.optimizer.peq_model = model.to_string();
        let result = validate_room_config(&config);
        let has_peq_warning = result
            .warnings
            .iter()
            .any(|w| w.contains("Unknown peq_model"));
        assert!(
            !has_peq_warning,
            "PEQ model '{}' should be accepted without warning, but got: {:?}",
            model, result.warnings
        );
    }
}

#[test]
fn test_unknown_peq_model_warns_not_errors() {
    let mut config = config_with_algorithm("autoeq:de");
    config.optimizer.peq_model = "bogus_model".to_string();
    let result = validate_room_config(&config);
    assert!(
        result.is_valid,
        "Unknown peq_model should warn, not error. Errors: {:?}",
        result.errors
    );
    assert!(
        result
            .warnings
            .iter()
            .any(|w| w.contains("Unknown peq_model")),
        "Unknown peq_model should produce a warning, but warnings: {:?}",
        result.warnings
    );
}

#[test]
fn validate_auto_optimizer_rejects_invalid_filter_range() {
    let mut config = config_with_algorithm("autoeq:de");
    config.optimizer.auto_optimizer = Some(AutoOptimizerConfig {
        enabled: true,
        min_filters: 8,
        max_filters: 4,
        ..Default::default()
    });

    let result = validate_room_config(&config);

    assert!(!result.is_valid);
    assert!(
        result
            .errors
            .iter()
            .any(|e| e.contains("auto_optimizer.min_filters")),
        "expected auto optimizer range error, got {:?}",
        result.errors
    );
}

#[test]
fn validate_auto_optimizer_requires_two_filters_for_schroeder_split() {
    let mut config = config_with_algorithm("autoeq:de");
    config.optimizer.schroeder_split = Some(SchroederSplitConfig {
        enabled: true,
        ..Default::default()
    });
    config.optimizer.auto_optimizer = Some(AutoOptimizerConfig {
        enabled: true,
        max_filters: 1,
        ..Default::default()
    });

    let result = validate_room_config(&config);

    assert!(!result.is_valid);
    assert!(
        result
            .errors
            .iter()
            .any(|e| e.contains("at least 2 when schroeder_split is enabled")),
        "expected schroeder auto max_filters error, got {:?}",
        result.errors
    );
}

#[test]
fn validate_auto_optimizer_warns_when_no_selectors_enabled() {
    let mut config = config_with_algorithm("autoeq:de");
    config.optimizer.auto_optimizer = Some(AutoOptimizerConfig {
        enabled: true,
        filter_count: false,
        q_bounds: false,
        gain_bounds: false,
        ..Default::default()
    });

    let result = validate_room_config(&config);

    assert!(result.is_valid);
    assert!(
        result
            .warnings
            .iter()
            .any(|w| w.contains("all automatic selection flags are disabled")),
        "expected auto optimizer no-op warning, got {:?}",
        result.warnings
    );
}

#[test]
fn validate_multi_seat_rejects_invalid_weights() {
    let mut config = config_with_algorithm("autoeq:de");
    config.optimizer.multi_seat = Some(MultiSeatConfig {
        enabled: true,
        seat_weights: Some(vec![1.0, -0.5]),
        primary_seat_weight: 0.0,
        ..Default::default()
    });

    let result = validate_room_config(&config);

    assert!(!result.is_valid);
    assert!(
        result
            .errors
            .iter()
            .any(|e| e.contains("primary_seat_weight")),
        "expected primary weight error, got {:?}",
        result.errors
    );
    assert!(
        result.errors.iter().any(|e| e.contains("seat_weights[1]")),
        "expected seat weight error, got {:?}",
        result.errors
    );
}