mrrc 0.7.6

A Rust library for reading, writing, and manipulating MARC bibliographic records in ISO 2709 binary format
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
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268

//! Integration tests for the mrrc library

use mrrc::{AuthorityMarcReader, AuthorityMarcWriter, MarcReader, MarcWriter};
use std::fs::File;
use std::io::Cursor;

#[test]
fn test_read_simple_book_record() {
    let file = File::open("tests/data/simple_book.mrc").expect("Could not open test file");
    let mut reader = MarcReader::new(file);

    let record = reader.read_record().expect("Failed to read record");
    let record = record.expect("No record found");

    // Verify record structure
    assert_eq!(record.leader.record_type, 'a'); // Book
    assert_eq!(record.leader.bibliographic_level, 'm'); // Monograph

    // Check title field
    let title_fields = record.get_fields("245").expect("No title field");
    assert!(!title_fields.is_empty());
    assert_eq!(title_fields[0].get_subfield('a'), Some("The Great Gatsby"));
    assert_eq!(
        title_fields[0].get_subfield('c'),
        Some("F. Scott Fitzgerald")
    );

    // Check author field
    let author_fields = record.get_fields("100").expect("No author field");
    assert!(!author_fields.is_empty());
    assert_eq!(
        author_fields[0].get_subfield('a'),
        Some("Fitzgerald, F. Scott")
    );
}

#[test]
fn test_read_music_record() {
    let file = File::open("tests/data/music_score.mrc").expect("Could not open test file");
    let mut reader = MarcReader::new(file);

    let record = reader.read_record().expect("Failed to read record");
    let record = record.expect("No record found");

    // Verify it's a music record
    assert_eq!(record.leader.record_type, 'c'); // Musical notation

    // Check title
    let title_fields = record.get_fields("245").expect("No title field");
    assert_eq!(
        title_fields[0].get_subfield('a'),
        Some("Beethovens Ninth Symphony")
    );
}

#[test]
fn test_read_record_with_control_fields() {
    let file = File::open("tests/data/with_control_fields.mrc").expect("Could not open test file");
    let mut reader = MarcReader::new(file);

    let record = reader.read_record().expect("Failed to read record");
    let record = record.expect("No record found");

    // Check control field
    let field_008 = record.get_control_field("008");
    assert!(field_008.is_some());
    assert!(field_008.unwrap().starts_with("200101"));
}

#[test]
fn test_read_multiple_records() {
    let file = File::open("tests/data/multi_records.mrc").expect("Could not open test file");
    let mut reader = MarcReader::new(file);

    // Read first record
    let record1 = reader.read_record().expect("Failed to read first record");
    assert!(record1.is_some());

    // Read second record
    let record2 = reader.read_record().expect("Failed to read second record");
    assert!(record2.is_some());

    // Read third record
    let record3 = reader.read_record().expect("Failed to read third record");
    assert!(record3.is_some());

    // No more records
    let record4 = reader
        .read_record()
        .expect("Failed to check for fourth record");
    assert!(record4.is_none());
}

#[test]
fn test_roundtrip_book_record() {
    // Read the original file
    let file = File::open("tests/data/simple_book.mrc").expect("Could not open test file");
    let mut reader = MarcReader::new(file);
    let original = reader.read_record().expect("Failed to read record");
    let original = original.expect("No record found");

    // Write to buffer
    let mut buffer = Vec::new();
    {
        let mut writer = MarcWriter::new(&mut buffer);
        writer
            .write_record(&original)
            .expect("Failed to write record");
    }

    // Read back from buffer
    let cursor = Cursor::new(buffer);
    let mut reader = MarcReader::new(cursor);
    let restored = reader
        .read_record()
        .expect("Failed to read restored record");
    let restored = restored.expect("No restored record");

    // Verify the roundtrip preserved data
    assert_eq!(original.leader.record_type, restored.leader.record_type);
    assert_eq!(
        original.leader.bibliographic_level,
        restored.leader.bibliographic_level
    );

    let orig_title = original.get_fields("245").unwrap()[0].get_subfield('a');
    let restored_title = restored.get_fields("245").unwrap()[0].get_subfield('a');
    assert_eq!(orig_title, restored_title);

    let orig_author = original.get_fields("100").unwrap()[0].get_subfield('a');
    let restored_author = restored.get_fields("100").unwrap()[0].get_subfield('a');
    assert_eq!(orig_author, restored_author);
}

#[test]
fn test_json_serialization_with_file_data() {
    use mrrc::json;

    let file = File::open("tests/data/simple_book.mrc").expect("Could not open test file");
    let mut reader = MarcReader::new(file);
    let record = reader.read_record().expect("Failed to read record");
    let record = record.expect("No record found");

    // Convert to JSON
    let json = json::record_to_json(&record).expect("Failed to convert to JSON");

    // Verify JSON structure
    assert!(json.is_array());
    let array = json.as_array().unwrap();
    assert!(!array.is_empty());

    // Convert back from JSON
    let restored = json::json_to_record(&json).expect("Failed to restore from JSON");

    // Verify data
    assert_eq!(record.leader.record_type, restored.leader.record_type);
}

#[test]
fn test_marcxml_serialization_with_file_data() {
    use mrrc::marcxml;

    let file = File::open("tests/data/simple_book.mrc").expect("Could not open test file");
    let mut reader = MarcReader::new(file);
    let record = reader.read_record().expect("Failed to read record");
    let record = record.expect("No record found");

    // Convert to MARCXML
    let xml_str = marcxml::record_to_marcxml(&record).expect("Failed to convert to MARCXML");

    // Verify MARCXML has expected elements with attributes
    assert!(xml_str.contains("<leader>"));
    assert!(xml_str.contains("<datafield tag=\"245\""));
    assert!(xml_str.contains("The Great Gatsby"));
    assert!(xml_str.contains("xmlns=\"http://www.loc.gov/MARC21/slim\""));

    // Convert back from MARCXML
    let restored = marcxml::marcxml_to_record(&xml_str).expect("Failed to restore from MARCXML");

    // Verify data
    assert_eq!(record.leader.record_type, restored.leader.record_type);
}

#[test]
fn test_marcjson_serialization_with_file_data() {
    use mrrc::marcjson;

    let file = File::open("tests/data/simple_book.mrc").expect("Could not open test file");
    let mut reader = MarcReader::new(file);
    let record = reader.read_record().expect("Failed to read record");
    let record = record.expect("No record found");

    // Convert to MARCJSON
    let json = marcjson::record_to_marcjson(&record).expect("Failed to convert to MARCJSON");

    // Convert back from MARCJSON
    let restored = marcjson::marcjson_to_record(&json).expect("Failed to restore from MARCJSON");

    // Verify data
    assert_eq!(record.leader.record_type, restored.leader.record_type);

    let orig_title = record.get_fields("245").unwrap()[0].get_subfield('a');
    let restored_title = restored.get_fields("245").unwrap()[0].get_subfield('a');
    assert_eq!(orig_title, restored_title);
}

#[test]
fn test_read_simple_authority_record() {
    let file = File::open("tests/data/simple_authority.mrc").expect("Could not open test file");
    let mut reader = AuthorityMarcReader::new(file);

    let record = reader.read_record().expect("Failed to read record");
    let record = record.expect("No record found");

    // Verify record structure
    assert_eq!(record.leader.record_type, 'z'); // Authority record

    // Check control field 001 (control number)
    assert_eq!(record.get_control_field("001"), Some("n79021800"));

    // Check heading field
    assert!(record.heading().is_some());
    let heading = record.heading().unwrap();
    assert_eq!(heading.tag, "100");
    assert_eq!(heading.get_subfield('a'), Some("Smith, John"));
}

#[test]
fn test_authority_record_roundtrip() {
    // Read the original file
    let file = File::open("tests/data/simple_authority.mrc").expect("Could not open test file");
    let mut reader = AuthorityMarcReader::new(file);
    let original = reader.read_record().expect("Failed to read record");
    let original = original.expect("No record found");

    // Write to buffer
    let mut buffer = Vec::new();
    {
        let mut writer = AuthorityMarcWriter::new(&mut buffer);
        writer
            .write_record(&original)
            .expect("Failed to write record");
    }

    // Read back from buffer
    let cursor = Cursor::new(buffer);
    let mut reader = AuthorityMarcReader::new(cursor);
    let restored = reader
        .read_record()
        .expect("Failed to read restored record");
    let restored = restored.expect("No restored record");

    // Verify the roundtrip preserved data
    assert_eq!(original.leader.record_type, restored.leader.record_type);
    assert_eq!(
        original.get_control_field("001"),
        restored.get_control_field("001")
    );

    if let Some(orig_heading) = original.heading() {
        let restored_heading = restored.heading().expect("Restored heading missing");
        assert_eq!(orig_heading.tag, restored_heading.tag);
        assert_eq!(
            orig_heading.get_subfield('a'),
            restored_heading.get_subfield('a')
        );
    }
}