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
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373

"""
Unit tests for Leader value lookup helpers and validation.

Tests MARC 21 spec-compliant leader position value mappings and descriptions.
Ensures API parity with pymarc while providing enhanced functionality.
"""

from mrrc import Leader


class TestLeaderValidValuesPosition5:
    """Test Leader valid values for position 5 (Record status)."""

    def test_get_valid_values_position_5(self):
        """Test retrieving valid values for record status position."""
        leader = Leader()
        values = leader.get_valid_values(5)

        assert isinstance(values, dict)
        assert len(values) > 0
        assert "a" in values
        assert "n" in values

    def test_record_status_values_mapped_correctly(self):
        """Test that record status values map to correct descriptions."""
        leader = Leader()
        values = leader.get_valid_values(5)

        assert values["a"] == "Increase in encoding level"
        assert values["c"] == "Corrected or revised"
        assert values["d"] == "Deleted"
        assert values["n"] == "New"
        assert values["p"] == "Increase in encoding level from prepublication"

    def test_describe_value_position_5(self):
        """Test describing a specific record status value."""
        desc = Leader.describe_value(5, "a")
        assert desc == "Increase in encoding level"

        desc = Leader.describe_value(5, "n")
        assert desc == "New"

    def test_describe_invalid_value_position_5(self):
        """Test that invalid values return None."""
        desc = Leader.describe_value(5, "x")
        assert desc is None


class TestLeaderValidValuesPosition6:
    """Test Leader valid values for position 6 (Type of record)."""

    def test_get_valid_values_position_6(self):
        """Test retrieving valid values for record type position."""
        leader = Leader()
        values = leader.get_valid_values(6)

        assert len(values) > 0
        assert "a" in values
        assert "m" in values

    def test_record_type_values_mapped_correctly(self):
        """Test that record type values map to correct descriptions."""
        leader = Leader()
        values = leader.get_valid_values(6)

        assert values["a"] == "Language material"
        assert values["c"] == "Notated music"
        assert values["m"] == "Computer file"
        assert values["t"] == "Manuscript language material"

    def test_describe_value_position_6(self):
        """Test describing record type values."""
        assert Leader.describe_value(6, "a") == "Language material"
        assert Leader.describe_value(6, "t") == "Manuscript language material"


class TestLeaderValidValuesPosition7:
    """Test Leader valid values for position 7 (Bibliographic level)."""

    def test_get_valid_values_position_7(self):
        """Test retrieving valid values for bibliographic level position."""
        leader = Leader()
        values = leader.get_valid_values(7)

        assert len(values) > 0
        assert "m" in values
        assert "s" in values

    def test_bibliographic_level_values_mapped_correctly(self):
        """Test that bibliographic level values map to correct descriptions."""
        values = Leader.get_valid_values(7)

        assert values["a"] == "Monographic component part"
        assert values["b"] == "Serial component part"
        assert values["m"] == "Monograph/Item"
        assert values["s"] == "Serial"
        assert values["i"] == "Integrating resource"

    def test_describe_value_position_7(self):
        """Test describing bibliographic level values."""
        assert Leader.describe_value(7, "m") == "Monograph/Item"
        assert Leader.describe_value(7, "s") == "Serial"


class TestLeaderValidValuesPosition8:
    """Test Leader valid values for position 8 (Type of control)."""

    def test_get_valid_values_position_8(self):
        """Test retrieving valid values for type of control position."""
        values = Leader.get_valid_values(8)

        assert "#" in values
        assert "a" in values

    def test_type_of_control_values_mapped_correctly(self):
        """Test that type of control values map to correct descriptions."""
        values = Leader.get_valid_values(8)

        assert values["#"] == "No specified type"
        assert values["a"] == "Archival"

    def test_describe_value_position_8(self):
        """Test describing type of control values."""
        assert Leader.describe_value(8, "#") == "No specified type"
        assert Leader.describe_value(8, "a") == "Archival"


class TestLeaderValidValuesPosition9:
    """Test Leader valid values for position 9 (Character coding scheme)."""

    def test_get_valid_values_position_9(self):
        """Test retrieving valid values for character coding position."""
        values = Leader.get_valid_values(9)

        assert " " in values
        assert "a" in values

    def test_character_coding_values_mapped_correctly(self):
        """Test that character coding values map to correct descriptions."""
        values = Leader.get_valid_values(9)

        assert values[" "] == "MARC-8"
        assert values["a"] == "UCS/Unicode"

    def test_describe_value_position_9(self):
        """Test describing character coding values."""
        assert Leader.describe_value(9, " ") == "MARC-8"
        assert Leader.describe_value(9, "a") == "UCS/Unicode"


class TestLeaderValidValuesPosition17:
    """Test Leader valid values for position 17 (Encoding level)."""

    def test_get_valid_values_position_17(self):
        """Test retrieving valid values for encoding level position."""
        values = Leader.get_valid_values(17)

        assert len(values) > 0
        assert " " in values
        assert "8" in values

    def test_encoding_level_values_mapped_correctly(self):
        """Test that encoding level values map to correct descriptions."""
        values = Leader.get_valid_values(17)

        assert values[" "] == "Full level"
        assert values["3"] == "Abbreviated level"
        assert values["8"] == "Prepublication level"

    def test_describe_value_position_17(self):
        """Test describing encoding level values."""
        assert Leader.describe_value(17, " ") == "Full level"
        assert Leader.describe_value(17, "8") == "Prepublication level"


class TestLeaderValidValuesPosition18:
    """Test Leader valid values for position 18 (Cataloging form)."""

    def test_get_valid_values_position_18(self):
        """Test retrieving valid values for cataloging form position."""
        values = Leader.get_valid_values(18)

        assert " " in values
        assert "a" in values

    def test_cataloging_form_values_mapped_correctly(self):
        """Test that cataloging form values map to correct descriptions."""
        values = Leader.get_valid_values(18)

        assert values[" "] == "Non-ISBD"
        assert values["a"] == "AACR 2"
        assert values["c"] == "ISBD punctuation omitted"
        assert values["i"] == "ISBD punctuation included"
        assert values["n"] == "Non-ISBD punctuation omitted"

    def test_describe_value_position_18(self):
        """Test describing cataloging form values."""
        assert Leader.describe_value(18, " ") == "Non-ISBD"
        assert Leader.describe_value(18, "a") == "AACR 2"
        assert Leader.describe_value(18, "i") == "ISBD punctuation included"


class TestLeaderValidValuesPosition19:
    """Test Leader valid values for position 19 (Multipart level)."""

    def test_get_valid_values_position_19(self):
        """Test retrieving valid values for multipart level position."""
        values = Leader.get_valid_values(19)

        assert " " in values
        assert "a" in values

    def test_multipart_level_values_mapped_correctly(self):
        """Test that multipart level values map to correct descriptions."""
        values = Leader.get_valid_values(19)

        assert values[" "] == "Not specified or not applicable"
        assert values["a"] == "Set"
        assert values["b"] == "Part with independent title"

    def test_describe_value_position_19(self):
        """Test describing multipart level values."""
        assert (
            Leader.describe_value(19, " ") == "Not specified or not applicable"
        )
        assert Leader.describe_value(19, "a") == "Set"


class TestLeaderValidValuesInvalidPosition:
    """Test Leader behavior with invalid positions."""

    def test_get_valid_values_invalid_position(self):
        """Test that invalid positions return None."""
        values = Leader.get_valid_values(0)
        assert values is None

        values = Leader.get_valid_values(99)
        assert values is None

    def test_describe_value_invalid_position(self):
        """Test that invalid positions return None."""
        desc = Leader.describe_value(0, "a")
        assert desc is None

        desc = Leader.describe_value(99, "x")
        assert desc is None


class TestLeaderValueValidationIntegration:
    """Integration tests for leader values with actual leader manipulation."""

    def test_set_and_describe_record_status(self):
        """Test setting record status and getting its description."""
        leader = Leader()
        leader.record_status = "a"

        # Get the actual value set
        assert leader.record_status == "a"

        # Get its description
        desc = Leader.describe_value(5, leader.record_status)
        assert desc == "Increase in encoding level"

    def test_set_and_describe_record_type(self):
        """Test setting record type and getting its description."""
        leader = Leader()
        leader.record_type = "t"

        assert leader.record_type == "t"

        desc = Leader.describe_value(6, leader.record_type)
        assert desc == "Manuscript language material"

    def test_set_and_describe_bibliographic_level(self):
        """Test setting bibliographic level and getting its description."""
        leader = Leader()
        leader.bibliographic_level = "s"

        assert leader.bibliographic_level == "s"

        desc = Leader.describe_value(7, leader.bibliographic_level)
        assert desc == "Serial"

    def test_describe_all_valid_values_position_5(self):
        """Test that all values in the valid_values dict are describable."""
        valid_values = Leader.get_valid_values(5)

        for value in valid_values.keys():
            desc = Leader.describe_value(5, value)
            assert desc is not None
            assert desc == valid_values[value]

    def test_describe_all_valid_values_position_6(self):
        """Test that all values in the valid_values dict are describable."""
        valid_values = Leader.get_valid_values(6)

        for value in valid_values.keys():
            desc = Leader.describe_value(6, value)
            assert desc is not None
            assert desc == valid_values[value]


class TestLeaderStaticMethods:
    """Test that helper methods are accessible as both static and instance methods."""

    def test_static_method_access(self):
        """Test accessing helpers via static method syntax."""
        values = Leader.get_valid_values(5)
        assert len(values) > 0

        desc = Leader.describe_value(5, "n")
        assert desc == "New"

    def test_instance_method_access(self):
        """Test accessing get_valid_values via instance method."""
        leader = Leader()
        values = leader.get_valid_values(5)
        assert len(values) > 0

    def test_describe_value_static_method(self):
        """Test describe_value as static method on instance."""
        leader = Leader()
        # Static methods should be callable on instances too
        desc = leader.describe_value(5, "n")
        assert desc == "New"


class TestLeaderAPICompatibility:
    """Test API compatibility with pymarc expectations."""

    def test_leader_values_not_regress_existing_api(self):
        """Test that new methods don't break existing leader API."""
        leader = Leader()

        # Existing API should still work
        leader.record_status = "a"
        assert leader.record_status == "a"

        leader.record_type = "t"
        assert leader.record_type == "t"

        leader.bibliographic_level = "m"
        assert leader.bibliographic_level == "m"

    def test_descriptor_returns_consistent_data(self):
        """Test that describe_value always returns consistent data."""
        desc1 = Leader.describe_value(5, "a")
        desc2 = Leader.describe_value(5, "a")
        assert desc1 == desc2

    def test_valid_values_dict_format(self):
        """Test that get_valid_values returns proper dictionary format."""
        values = Leader.get_valid_values(5)

        assert isinstance(values, dict)
        for key, val in values.items():
            assert isinstance(key, str)
            assert isinstance(val, str)


class TestLeaderDocumentation:
    """Test that helper methods have proper documentation."""

    def test_get_valid_values_docstring(self):
        """Test that get_valid_values has docstring."""
        leader = Leader()
        assert leader.get_valid_values.__doc__ is not None
        assert len(leader.get_valid_values.__doc__) > 0

    def test_describe_value_docstring(self):
        """Test that describe_value has docstring."""
        assert Leader.describe_value.__doc__ is not None
        assert len(Leader.describe_value.__doc__) > 0