edifact-mapper 0.14.0

use edifact_mapper::{DataDir, Mapper, MapperError};

/// The committed bundles under `dist/`.
///
/// This used to read `/tmp/edifact-bundles` and return early when it was not
/// there, which is every fresh checkout and every CI run — so the tests below
/// passed without asserting anything.
fn mapper() -> Mapper {
    let dist = std::path::Path::new(env!("CARGO_MANIFEST_DIR")).join("../../dist");
    assert!(
        dist.join("edifact-data-FV2504.bin").exists(),
        "no FV2504 bundle at {}: run `cargo run -p automapper-generator -- bundle-data`",
        dist.display()
    );
    Mapper::from_data_dir(DataDir::path(&dist).eager(&["FV2504"])).expect("load bundle")
}

#[test]
fn test_mapper_lists_variants() {
    let mapper = mapper();
    let variants = mapper.variants("FV2504").unwrap();
    assert!(
        variants.len() >= 16,
        "Expected 16+ variants, got {}",
        variants.len()
    );
    assert!(variants.contains(&"UTILMD_Strom".to_string()));
    assert!(variants.contains(&"MSCONS".to_string()));
    assert!(variants.contains(&"APERAK".to_string()));
    assert!(variants.contains(&"CONTRL".to_string()));
}

#[test]
fn test_mapper_engine_for_pid() {
    let mapper = mapper();
    let engine = mapper.engine("FV2504", "UTILMD_Strom", "55001").unwrap();
    assert!(
        engine.definitions().len() > 10,
        "PID 55001 should have many definitions"
    );
}

#[test]
fn test_mapper_conversion_service() {
    let mapper = mapper();
    let _service = mapper.conversion_service("FV2504", "UTILMD_Strom").unwrap();
}

#[test]
fn test_mapper_nonexistent_pid() {
    let mapper = mapper();
    match mapper.engine("FV2504", "UTILMD_Strom", "99999") {
        Err(MapperError::PidNotFound { .. }) => {}
        Err(e) => panic!("Expected PidNotFound, got: {e}"),
        Ok(_) => panic!("Expected error, got Ok"),
    }
}

#[test]
fn test_mapper_nonexistent_variant() {
    let mapper = mapper();
    match mapper.conversion_service("FV2504", "NONEXISTENT") {
        Err(MapperError::VariantNotFound { .. }) => {}
        Err(e) => panic!("Expected VariantNotFound, got: {e}"),
        Ok(_) => panic!("Expected error, got Ok"),
    }
}