nmr 0.1.3

NMR data tools for Rust
Documentation
use crate::processed::model::ProcessedDescriptor;
use crate::processed::model::ProcessedOrigin;
use crate::processing::contracts::error::ProcessingError;
use crate::processing::contracts::operation::ProcessingOperation;
use crate::processing::contracts::operation::ProcessingRequest;
use crate::processing::contracts::operation::ResolvedOperation;
use crate::processing::contracts::state::PlanState;
use crate::processing::contracts::state::StateError;
use crate::processing::contracts::state::transition;
use crate::processing::contracts::state::transition_auto_phase;

use super::super::replay_record;
use super::*;
use crate::processing::ProcessingOptions;

#[test]
fn unknown_component_baseline_and_projection_rules_are_rejected() {
    use crate::Complex64;
    use crate::acquisition::{
        LinearComponentTransform, PeriodicLaneModulation, ResolvedComponentTransform,
    };
    use crate::axis::{AxisCoordinates, AxisDomain, AxisRole, AxisUnit};
    use crate::processed::{ComponentBasis, ProcessedAxis};
    use crate::processing::{PolarityState, PositivePeaksV1, Projection};

    let axis = |role, domain, unit, basis| {
        ProcessedAxis::new(
            role,
            domain,
            Some(unit),
            3,
            AxisCoordinates::Uniform {
                start: 0.0,
                step: 1.0,
            },
            basis,
        )
        .unwrap()
    };
    let one = Complex64::new(1.0, 0.0);
    let zero = Complex64::new(0.0, 0.0);
    let transform = ResolvedComponentTransform::user_constructed(
        LinearComponentTransform::try_new(
            2,
            vec![one, zero, zero, one],
            PeriodicLaneModulation::identity(2).unwrap(),
        )
        .unwrap(),
    )
    .unwrap();
    let cases = [
        (
            ProcessedDescriptor::new(vec![
                axis(
                    AxisRole::IndirectAcquisition,
                    AxisDomain::Time,
                    AxisUnit::Second,
                    ComponentBasis::Encoded(transform),
                ),
                axis(
                    AxisRole::Signal,
                    AxisDomain::Frequency,
                    AxisUnit::Hertz,
                    ComponentBasis::Cartesian,
                ),
            ])
            .unwrap(),
            ProcessingOperation::ComponentTransform { axis: 0 },
            "unknown-component-transform",
            "linear-component-transform.v1",
        ),
        (
            ProcessedDescriptor::new(vec![axis(
                AxisRole::Signal,
                AxisDomain::Frequency,
                AxisUnit::Hertz,
                ComponentBasis::Scalar,
            )])
            .unwrap(),
            ProcessingOperation::BaselineCorrection {
                axis: 0,
                profile: PositivePeaksV1.into(),
            },
            "unknown-baseline",
            "asls.v1",
        ),
        (
            ProcessedDescriptor::new(vec![axis(
                AxisRole::Signal,
                AxisDomain::Frequency,
                AxisUnit::Hertz,
                ComponentBasis::Cartesian,
            )])
            .unwrap(),
            ProcessingOperation::Projection {
                projection: Projection::Magnitude,
                polarity: PolarityState::Ambiguous180,
            },
            "unknown-projection",
            "projection.v1",
        ),
    ];
    for (descriptor, request, unknown_version, current_version) in cases {
        let initial = PlanState::from_descriptor(&descriptor);
        let mut expected = initial.clone();
        let resolved = transition(&mut expected, &request)
            .map_err(ProcessingError::from)
            .unwrap();
        let mut record = ProcessingRecord::applied(
            request,
            resolved,
            descriptor,
            expected
                .descriptor()
                .map_err(ProcessingError::from)
                .unwrap(),
            vec![],
        );
        assert_eq!(record.algorithm_version(), Some(current_version));
        let mut replayed = initial.clone();
        assert!(replay_record(&mut replayed, &record).is_ok());
        assert_eq!(replayed, expected);

        let ProcessingRecord::Applied {
            algorithm_version, ..
        } = &mut record
        else {
            unreachable!()
        };
        *algorithm_version = unknown_version;
        let mut rejected = initial.clone();
        assert!(matches!(
            replay_record(&mut rejected, &record),
            Err(StateError::Mapping(
                "processing history input contract disagrees"
            ))
        ));
        assert_eq!(
            rejected, initial,
            "unknown rules must fail before mutating state"
        );
    }
}

#[test]
fn unguarded_automatic_phase_history_is_rejected_before_state_mutation() {
    use crate::axis::{AxisCoordinates, AxisDomain, AxisRole, AxisUnit};
    use crate::processed::{ComponentBasis, ProcessedAxis};
    use crate::processing::{NormalizedAcmeV1, PhaseCorrection, PhaseFailurePolicy, PolarityState};
    let descriptor = ProcessedDescriptor::new(vec![
        ProcessedAxis::new(
            AxisRole::Signal,
            AxisDomain::Frequency,
            Some(AxisUnit::Hertz),
            8,
            AxisCoordinates::Uniform {
                start: 0.0,
                step: 1.0,
            },
            ComponentBasis::Cartesian,
        )
        .unwrap(),
    ])
    .unwrap();
    let initial = PlanState::from_descriptor(&descriptor);
    let mut after = initial.clone();
    transition_auto_phase(&mut after, 0)
        .map_err(ProcessingError::from)
        .unwrap();
    let mut record = ProcessingRecord::applied(
        ProcessingRequest::AutoPhase {
            axis: 0,
            profile: NormalizedAcmeV1::new(),
            polarity: PolarityState::UserAssertedPositive,
            failure_policy: PhaseFailurePolicy::Fail,
        },
        ResolvedOperation::PhaseCorrection(PhaseCorrection::new(0.0, 0.0, 1.0).unwrap()),
        descriptor,
        after.descriptor().map_err(ProcessingError::from).unwrap(),
        vec![],
    );
    assert_eq!(
        record.algorithm_version(),
        Some("normalized-acme.lorentzian-guard.v1")
    );
    assert!(replay_record(&mut initial.clone(), &record).is_ok());
    let ProcessingRecord::Applied {
        algorithm_version, ..
    } = &mut record
    else {
        unreachable!()
    };
    *algorithm_version = "phase-correction.v1";
    let mut rejected = initial.clone();
    assert!(replay_record(&mut rejected, &record).is_err());
    assert_eq!(rejected, initial);
}

#[test]
fn unsupported_history_inputs_and_axis_slots_are_rejected_before_execution() {
    use crate::axis::{AxisCoordinates, AxisDomain, AxisRole};
    use crate::processed::{
        ComponentBasis, ProcessedAxis, ProcessedData, ProcessedDataset, ProcessedProvenance,
    };
    let descriptor = ProcessedDescriptor::new(vec![
        ProcessedAxis::new(
            AxisRole::Signal,
            AxisDomain::Unknown,
            None,
            1,
            AxisCoordinates::Unknown,
            ComponentBasis::Scalar,
        )
        .unwrap(),
    ])
    .unwrap();
    let dataset = ProcessedDataset::new(
        descriptor.clone(),
        ProcessedData::new(vec![1], vec![1], vec![1.0]).unwrap(),
        ProcessedProvenance::new(ProcessedOrigin::Unknown, vec![]).unwrap(),
    )
    .unwrap();
    let binding = HistoryInput::Processed {
        digests: dataset.canonical_digests(),
        sources: vec![],
        read_record: None,
    };
    let mut history = ProcessingHistory::new(descriptor, binding.clone(), vec![]);
    history.inputs.push(binding);
    let input = crate::Dataset::from_processed(dataset);
    assert_eq!(
        history
            .replay(&[&input, &input], ProcessingOptions::default())
            .unwrap_err()
            .into_root_cause(),
        ProcessingError::MissingCapability {
            capability: "single external replay input",
            axis: None
        }
    );
    history.inputs.pop();
    history.axis_lineage[0] =
        crate::provenance::InputAxisRef::new(crate::provenance::InputSlot::new(1), 0);
    assert_eq!(
        history
            .replay(&[&input], ProcessingOptions::default())
            .unwrap_err()
            .into_root_cause(),
        ProcessingError::Mapping("history input-axis references are invalid")
    );
}