lenso-process-protocol 0.2.3

Strict shared protocol values and conformance helpers for Lenso Execution Adapters.
Documentation
use lenso_process_protocol::{
    EXECUTION_TARGET_CAPABILITY_PROFILE, ExecutionTargetCapability,
    ExecutionTargetCapabilityProfile,
};
use serde::Deserialize;
use serde_json::Value;

#[derive(Deserialize)]
struct Fixture {
    valid: Vec<ValidVector>,
    invalid: Vec<InvalidVector>,
}

#[derive(Deserialize)]
struct ValidVector {
    name: String,
    profile: Value,
    required: Vec<String>,
    missing: Vec<String>,
}

#[derive(Deserialize)]
struct InvalidVector {
    name: String,
    profile: Value,
    error: String,
}

#[test]
fn execution_target_capability_profiles_match_shared_conformance_vectors() {
    let fixture: Fixture = serde_json::from_str(include_str!(
        "../../../fixtures/execution-target-capability-profile/conformance.json"
    ))
    .expect("the shared execution target capability fixture should be valid JSON");

    for vector in fixture.valid {
        let profile: ExecutionTargetCapabilityProfile = serde_json::from_value(vector.profile)
            .unwrap_or_else(|error| panic!("{}: {error}", vector.name));
        profile
            .validate()
            .unwrap_or_else(|error| panic!("{}: {error}", vector.name));
        let required = vector.required.iter().map(String::as_str);
        assert_eq!(
            profile.missing_capabilities(required),
            vector.missing,
            "{}",
            vector.name
        );
    }

    for vector in fixture.invalid {
        let result = serde_json::from_value::<ExecutionTargetCapabilityProfile>(vector.profile)
            .map_err(|error| error.to_string())
            .and_then(|profile| {
                profile
                    .validate()
                    .map(|()| profile)
                    .map_err(|error| error.to_string())
            });
        let error = result.expect_err(&vector.name);
        assert!(error.contains(&vector.error), "{}: {error}", vector.name);
    }
}

#[test]
fn invalid_profiles_and_unknown_requirements_fail_closed() {
    let invalid = ExecutionTargetCapabilityProfile {
        profile: "lenso.execution-target-capability-profile@2".to_owned(),
        target_profile: "example.invalid@1".to_owned(),
        capabilities: vec![ExecutionTargetCapability::Request],
    };
    assert!(!invalid.supports(ExecutionTargetCapability::Request));
    assert!(!invalid.supports_named("future-capability"));
    assert_eq!(
        invalid.missing_capabilities(["request", "future-capability"]),
        ["request", "future-capability"]
    );

    let valid = ExecutionTargetCapabilityProfile {
        profile: EXECUTION_TARGET_CAPABILITY_PROFILE.to_owned(),
        target_profile: "example.request-only@1".to_owned(),
        capabilities: vec![ExecutionTargetCapability::Request],
    };
    assert!(valid.supports(ExecutionTargetCapability::Request));
    assert!(!valid.supports_named("stream"));
    assert!(!valid.supports_named("future-capability"));
}