hl7v2 1.5.0

HL7 v2 message parser and processor for Rust
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115

use hl7v2::model::{Batch, FileBatch};
use hl7v2::{Atom, Comp, Delims, Field, Message, Rep, Segment};
use std::error::Error;
use std::fmt::Debug;

fn require_eq<T>(actual: T, expected: T, label: &str) -> Result<(), Box<dyn Error>>
where
    T: PartialEq + Debug,
{
    if actual == expected {
        Ok(())
    } else {
        Err(std::io::Error::other(format!("{label}: expected {expected:?}, got {actual:?}")).into())
    }
}

fn require_some<T>(value: Option<T>, label: &str) -> Result<T, Box<dyn Error>> {
    value.ok_or_else(|| std::io::Error::other(format!("missing {label}")).into())
}

#[test]
fn model_roundtrips_complex_message_through_public_facade() -> Result<(), Box<dyn Error>> {
    let message = Message {
        delims: Delims::default(),
        segments: vec![Segment {
            id: *b"PID",
            fields: vec![
                Field::from_text("1"),
                Field {
                    reps: vec![
                        Rep {
                            comps: vec![
                                Comp::from_text("123456"),
                                Comp::from_text(""),
                                Comp::from_text(""),
                                Comp::from_text("HOSP"),
                                Comp::from_text("MR"),
                            ],
                        },
                        Rep {
                            comps: vec![Comp::from_text("ALT999"), Comp::from_text("ALT")],
                        },
                    ],
                },
                Field {
                    reps: vec![Rep {
                        comps: vec![Comp {
                            subs: vec![Atom::text("Doe"), Atom::text("John")],
                        }],
                    }],
                },
            ],
        }],
        charsets: vec!["ASCII".to_string()],
    };

    let json = serde_json::to_string(&message)?;
    let decoded: Message = serde_json::from_str(&json)?;
    let pid = require_some(decoded.segments.first(), "PID segment")?;

    require_eq(pid.id, *b"PID", "segment id")?;
    require_eq(pid.fields.len(), 3, "field count")?;
    require_eq(decoded.charsets, vec!["ASCII".to_string()], "charsets")?;

    let repeating_identifier = require_some(pid.fields.get(1), "PID-2 repeating identifier")?;
    require_eq(
        repeating_identifier.reps.len(),
        2,
        "identifier repetition count",
    )?;

    Ok(())
}

#[test]
fn model_file_batch_preserves_nested_batch_counts() -> Result<(), Box<dyn Error>> {
    let mut file_batch = FileBatch::default();
    let mut first_batch = Batch::default();
    let mut second_batch = Batch::default();

    first_batch
        .messages
        .push(Message::with_segments(vec![Segment {
            id: *b"MSH",
            fields: vec![Field::from_text("^~\\&")],
        }]));
    second_batch
        .messages
        .push(Message::with_segments(vec![Segment {
            id: *b"MSH",
            fields: vec![Field::from_text("^~\\&")],
        }]));
    second_batch
        .messages
        .push(Message::with_segments(vec![Segment {
            id: *b"MSH",
            fields: vec![Field::from_text("^~\\&")],
        }]));

    file_batch.batches.push(first_batch);
    file_batch.batches.push(second_batch);

    require_eq(file_batch.batches.len(), 2, "batch count")?;
    require_eq(
        file_batch
            .batches
            .iter()
            .map(|batch| batch.messages.len())
            .sum::<usize>(),
        3,
        "nested message count",
    )?;

    Ok(())
}