View | Details | Raw Unified | Return to bug 11319
Collapse All | Expand All

(-)a/t/SimpleMARC.t (-152 / +820 lines)
Lines 1-6 Link Here
1
use Modern::Perl;
1
use Modern::Perl;
2
2
3
use Test::More tests => 37;
3
use Test::More tests => 9;
4
4
5
use_ok("MARC::Field");
5
use_ok("MARC::Field");
6
use_ok("MARC::Record");
6
use_ok("MARC::Record");
Lines 37-197 sub new_record { Link Here
37
    return $record;
37
    return $record;
38
}
38
}
39
39
40
my $record = new_record;
41
42
# field_exists
40
# field_exists
43
is( field_exists({ record => $record, field => '650', subfield => 'a' }), 'Computer programming.', '650$a exists' );
41
subtest 'field_exists' => sub {
44
is( field_exists({ record => $record, field => '650', subfield => 'b' }), undef, '650$b does not exist' );
42
    plan tests => 3;
43
    my $record = new_record;
44
    is(
45
        field_exists( { record => $record, field => '650', subfield => 'a' } ),
46
        'Computer programming.',
47
        '650$a exists'
48
    );
49
    is(
50
        field_exists( { record => $record, field => '650', subfield => 'b' } ),
51
        undef,
52
        '650$b does not exist'
53
    );
45
54
46
$record->append_fields(
55
    $record->append_fields(
47
    MARC::Field->new(
56
        MARC::Field->new(
48
        650, ' ', '0',
57
            650, ' ', '0',
49
        a => 'Computer algorithms.',
58
            a => 'Computer algorithms.',
50
        9 => '463',
59
            9 => '463',
51
    )
60
        )
52
);
61
    );
53
62
54
is( field_exists({ record => $record, field => '650', subfield => 'a' }), 'Computer programming.', '650$a exists, field_exists returns the first one' );
63
    is(
64
        field_exists( { record => $record, field => '650', subfield => 'a' } ),
65
        'Computer programming.',
66
        '650$a exists, field_exists returns the first one'
67
    );
68
};
55
69
56
# read_field
70
# read_field
57
my @fields_650a = read_field({ record => $record, field => '650', subfield => 'a' });
71
subtest 'read_field' => sub {
58
is( $fields_650a[0], 'Computer programming.', 'first 650$a' );
72
    plan tests              => 2;
59
is( $fields_650a[1], 'Computer algorithms.', 'second 650$a' );
73
    subtest 'read subfield' => sub {
60
is( read_field({ record => $record, field => '650', subfield => 'a', n => 1 }), 'Computer programming.', 'first 650$a bis' );
74
        plan tests => 5;
61
is( read_field({ record => $record, field => '650', subfield => 'a', n => 2 }), 'Computer algorithms.', 'second 650$a bis' );
75
        my $record = new_record;
62
is( read_field({ record => $record, field => '650', subfield => 'a', n => 3 }), undef, 'There is no 3 650$a' );
76
        $record->append_fields(
63
77
            MARC::Field->new(
64
# copy_field
78
                650, ' ', '0',
65
copy_field({ record => $record, from_field => '245', from_subfield => 'a', to_field => '246', to_subfield => 'a' });
79
                a => 'Computer algorithms.',
66
is_deeply( read_field({ record => $record, field => '245', subfield => 'a' }), 'The art of computer programming', 'After copy 245$a still exists' );
80
                9 => '463',
67
is_deeply( read_field({ record => $record, field => '246', subfield => 'a' }), 'The art of computer programming', '246$a is a new field' );
81
            )
68
delete_field({ record => $record, field => '246' });
82
        );
69
is( field_exists({ record => $record, field => '246', subfield => 'a' }), undef, '246$a does not exist anymore' );
83
70
84
        my @fields_650a =
71
copy_field({ record => $record, from_field => '650', from_subfield => 'a', to_field => '651', to_subfield => 'a' });
85
          read_field( { record => $record, field => '650', subfield => 'a' } );
72
my @fields_651a = read_field({ record =>  $record, field => '651', subfield => 'a' });
86
        is( $fields_650a[0], 'Computer programming.', 'first 650$a' );
73
is_deeply( \@fields_651a, ['Computer programming.', 'Computer algorithms.'], 'Copy multivalued field' );
87
        is( $fields_650a[1], 'Computer algorithms.',  'second 650$a' );
74
delete_field({ record => $record, field => '651' });
88
        is(
75
89
            read_field(
76
copy_field({ record => $record, from_field => '650', from_subfield => 'a', to_field => '651', to_subfield => 'a', n => 1 });
90
                {
77
is_deeply( read_field({record => $record, field => '651', subfield => 'a' }), 'Computer programming.', 'Copy first field 650$a' );
91
                    record   => $record,
78
delete_field({ record => $record, field => '652' });
92
                    field    => '650',
79
93
                    subfield => 'a',
80
copy_field({ record => $record, from_field => '650', from_subfield => 'a', to_field => '651', to_subfield => 'a', n => 2 });
94
                    n        => 1
81
is_deeply( read_field({ record => $record, field => '651', subfield => 'a' }), 'Computer algorithms.', 'Copy second field 650$a' );
95
                }
82
delete_field({ record => $record, field => '651' });
96
            ),
83
97
            'Computer programming.',
84
copy_field({ record => $record, from_field => '650', from_subfield => 'a', to_field => '651', to_subfield => 'a', regex => { search => 'Computer', replace => 'The art of' } } );
98
            'first 650$a bis'
85
@fields_651a = read_field({ record =>  $record, field => '651', subfield => 'a' });
99
        );
86
is_deeply( \@fields_651a, ['The art of programming.', 'The art of algorithms.'], 'Copy field using regex' );
100
        is(
87
101
            read_field(
88
copy_field({ record => $record, from_field => '650', from_subfield => 'a', to_field => '651', to_subfield => 'a', regex => { search => 'Computer', replace => 'The mistake of' } } );
102
                {
89
@fields_651a = read_field({ record =>  $record, field => '651', subfield => 'a' });
103
                    record   => $record,
90
is_deeply( \@fields_651a, ['The mistake of programming.', 'The mistake of algorithms.'], 'Copy fields using regex on existing fields' );
104
                    field    => '650',
91
delete_field({ record => $record, field => '651' });
105
                    subfield => 'a',
92
106
                    n        => 2
93
copy_field({ record => $record, from_field => '650', from_subfield => 'a', to_field => '651', to_subfield => 'a', regex => { search => 'Computer', replace => 'The art of' } } );
107
                }
94
copy_field({ record => $record, from_field => '650', from_subfield => 'a', to_field => '651', to_subfield => 'a', regex => { search => 'Computer', replace => 'The mistake of' }, n => 1, dont_erase => 1 } );
108
            ),
95
@fields_651a = read_field({ record => $record, field => '651', subfield => 'a' });
109
            'Computer algorithms.',
96
is_deeply( \@fields_651a, [
110
            'second 650$a bis'
97
    'The art of programming.',
111
        );
98
    'The mistake of programming.',
112
        is(
99
    'The art of algorithms.',
113
            read_field(
100
    'The mistake of programming.'
114
                {
101
], 'Copy first field using regex on existing fields without erase existing values' );
115
                    record   => $record,
102
delete_field({ record => $record, field => '651' });
116
                    field    => '650',
103
117
                    subfield => 'a',
104
copy_field({ record => $record, from_field => '650', from_subfield => 'a', to_field => '651', to_subfield => 'a', regex => { search => 'Computer', replace => 'The art of' }  });
118
                    n        => 3
105
copy_field({ record => $record, from_field => '650', from_subfield => 'a', to_field => '651', to_subfield => 'a', regex => { search => 'Computer', replace => 'The mistake of' }, dont_erase => 1 });
119
                }
106
@fields_651a = read_field({ record =>  $record, field => '651', subfield => 'a' });
120
            ),
107
is_deeply( \@fields_651a, [
121
            undef,
108
    'The art of programming.',
122
            'There is no 3 650$a'
109
    'The mistake of programming.',
123
        );
110
    'The mistake of algorithms.',
124
    };
111
    'The art of algorithms.',
125
    subtest 'read field' => sub {
112
    'The mistake of programming.',
126
        plan tests => 4;
113
    'The mistake of algorithms.'
127
        my $record = new_record;
114
], 'Copy fields using regex on existing fields without erase existing values' );
128
        $record->append_fields(
115
delete_field({ record => $record, field => '651' });
129
            MARC::Field->new(
116
130
                650, ' ', '0',
117
# Copy with regex modifiers
131
                a => 'Computer algorithms.',
118
copy_field({ record => $record, from_field => '650', from_subfield => 'a', to_field => '652', to_subfield => 'a', regex => { search => 'o', replace => 'foo' } });
132
                9 => '463',
119
my @fields_652a = read_field({ record => $record, field => '652', subfield => 'a' });
133
            )
120
is_deeply( \@fields_652a, ['Cfoomputer programming.', 'Cfoomputer algorithms.'], 'Copy field using regex' );
134
        );
121
135
        is_deeply(
122
copy_field({ record => $record, from_field => '650', from_subfield => 'a', to_field => '653', to_subfield => 'a', regex => { search => 'o', replace => 'foo', modifiers => 'g' } });
136
            [
123
my @fields_653a = read_field({ record =>  $record, field => '653', subfield => 'a' });
137
                read_field(
124
is_deeply( \@fields_653a, ['Cfoomputer prfoogramming.', 'Cfoomputer algfoorithms.'], 'Copy field using regex' );
138
                    {
125
139
                        record => $record,
126
copy_field({ record => $record, from_field => '650', from_subfield => 'a', to_field => '654', to_subfield => 'a', regex => { search => 'O', replace => 'foo', modifiers => 'i' } });
140
                        field  => '650'
127
my @fields_654a = read_field({ record =>  $record, field => '654', subfield => 'a' });
141
                    }
128
is_deeply( \@fields_654a, ['Cfoomputer programming.', 'Cfoomputer algorithms.'], 'Copy field using regex' );
142
                )
129
143
            ],
130
copy_field({ record => $record, from_field => '650', from_subfield => 'a', to_field => '655', to_subfield => 'a', regex => { search => 'O', replace => 'foo', modifiers => 'gi' } });
144
            [ 'Computer programming.', '462', 'Computer algorithms.', '463' ],
131
my @fields_655a = read_field({ record =>  $record, field => '655', subfield => 'a' });
145
            'Get the all subfield values for field 650'
132
is_deeply( \@fields_655a, ['Cfoomputer prfoogramming.', 'Cfoomputer algfoorithms.'], 'Copy field using regex' );
146
        );
147
        is_deeply(
148
            [
149
                read_field(
150
                    {
151
                        record => $record,
152
                        field  => '650',
153
                        n      => 1
154
                    }
155
                )
156
            ],
157
            [ 'Computer programming.', '462' ],
158
            'Get the all subfield values for the first field 650'
159
        );
160
        is_deeply(
161
            [ read_field( { record => $record, field => '650', n => 2 } ) ],
162
            [ 'Computer algorithms.', '463' ],
163
            'Get the all subfield values for the second field 650'
164
        );
165
        is_deeply(
166
            [ read_field( { record => $record, field => '650', n => 3 } ) ],
167
            [],
168
'Get the all subfield values for the third field 650 which does not exist'
169
        );
170
    };
171
};
133
172
134
# update_field
173
# update_field
135
update_field({ record => $record, field => '952', subfield => 'p', values => ['3010023918'] });
174
subtest 'update_field' => sub {
136
is_deeply( read_field({ record => $record, field => '952', subfield => 'p' }), '3010023918', 'update existing subfield 952$p' );
175
    plan tests                => 1;
137
delete_field({ record => $record, field => '952' });
176
    subtest 'update subfield' => sub {
138
update_field({ record => $record, field => '952', subfield => 'p', values => ['3010023918'] });
177
        plan tests => 5;
139
update_field({ record => $record, field => '952', subfield => 'y', values => ['BK'] });
178
        my $record = new_record;
140
is_deeply( read_field({ record => $record, field => '952', subfield => 'p' }), '3010023918', 'create subfield 952$p' );
179
141
is_deeply( read_field({ record => $record, field => '952', subfield => 'y' }), 'BK', 'create subfield 952$k on existing 952 field' );
180
        update_field(
142
$record->append_fields(
181
            {
143
    MARC::Field->new(
182
                record   => $record,
144
        952, ' ', ' ',
183
                field    => '952',
145
        p => '3010023917',
184
                subfield => 'p',
146
        y => 'BK',
185
                values   => ['3010023918']
147
    ),
186
            }
148
);
187
        );
149
update_field({ record => $record, field => '952', subfield => 'p', values => ['3010023919'] });
188
        is_deeply(
150
my @fields_952p = read_field({ record =>  $record, field => '952', subfield => 'p' });
189
            read_field(
151
is_deeply( \@fields_952p, ['3010023919', '3010023919'], 'update all subfields 952$p with the same value' );
190
                { record => $record, field => '952', subfield => 'p' }
152
191
            ),
153
update_field({ record => $record, field => '952', subfield => 'p', values => ['3010023917', '3010023918'] });
192
            '3010023918',
154
@fields_952p = read_field({ record => $record, field => '952', subfield => 'p' });
193
            'update existing subfield 952$p'
155
is_deeply( \@fields_952p, ['3010023917', '3010023918'], 'update all subfields 952$p with the different values' );
194
        );
156
195
        delete_field( { record => $record, field => '952' } );
157
# move_field
196
        update_field(
158
$record = new_record;
197
            {
159
my ( @fields_952d, @fields_952c, @fields_954c, @fields_954p);
198
                record   => $record,
160
$record->append_fields(
199
                field    => '952',
161
    MARC::Field->new(
200
                subfield => 'p',
162
        952, ' ', ' ',
201
                values   => ['3010023918']
163
        p => '3010023917',
202
            }
164
        y => 'BK',
203
        );
165
    ),
204
        update_field(
166
);
205
            {
167
copy_field({ record => $record, from_field => '952', from_subfield => 'd', to_field => '952', to_subfield => 'd' });
206
                record   => $record,
168
@fields_952d = read_field({ record =>  $record, field => '952', subfield => 'd' });
207
                field    => '952',
169
is_deeply( \@fields_952d, ['2001-06-25', '2001-06-25'], 'copy 952$d into others 952 field' );
208
                subfield => 'y',
170
209
                values   => ['BK']
171
move_field({ record => $record, from_field => '952', from_subfield => 'c', to_field => '954', to_subfield => 'c' });
210
            }
172
@fields_952c = read_field({ record =>  $record, field => '952', subfield => 'c' });
211
        );
173
@fields_954c = read_field({ record =>  $record, field => '954', subfield => 'c' });
212
        is_deeply(
174
is_deeply( \@fields_952c, [], 'The 952$c has moved' );
213
            read_field(
175
is_deeply( \@fields_954c, ['GEN'], 'Now 954$c exists' );
214
                { record => $record, field => '952', subfield => 'p' }
176
215
            ),
177
move_field({ record => $record, from_field => '952', from_subfield => 'p', to_field => '954', to_subfield => 'p', n => 1 }); # Move the first field
216
            '3010023918',
178
@fields_952p = read_field({ record =>  $record, field => '952', subfield => 'p' });
217
            'create subfield 952$p'
179
@fields_954p = read_field({ record =>  $record, field => '954', subfield => 'p' });
218
        );
180
is_deeply( \@fields_952p, ['3010023917'], 'One of 952$p has moved' );
219
        is_deeply(
181
is_deeply( \@fields_954p, ['3010023917'], 'Now 954$p exists' );
220
            read_field(
182
221
                { record => $record, field => '952', subfield => 'y' }
183
$record = new_record;
222
            ),
184
$record->append_fields(
223
            'BK',
185
    MARC::Field->new(
224
            'create subfield 952$k on existing 952 field'
186
        952, ' ', ' ',
225
        );
187
        p => '3010023917',
226
188
        y => 'BK',
227
        $record->append_fields(
189
    ),
228
            MARC::Field->new(
190
);
229
                952, ' ', ' ',
191
230
                p => '3010023917',
192
move_field({ record => $record, from_field => '952', from_subfield => 'p', to_field => '954', to_subfield => 'p' }); # Move all field
231
                y => 'BK',
193
@fields_952p = read_field({ record =>  $record, field => '952', subfield => 'p' });
232
            ),
194
@fields_954p = read_field({ record =>  $record, field => '954', subfield => 'p' });
233
        );
195
is_deeply( \@fields_952p, [], 'All 952$p have moved' );
234
        update_field(
196
is_deeply( \@fields_954p, ['3010023917', '3010023917'], 'Now 2 954$p exist' );
235
            {
236
                record   => $record,
237
                field    => '952',
238
                subfield => 'p',
239
                values   => ['3010023919']
240
            }
241
        );
242
        my @fields_952p =
243
          read_field( { record => $record, field => '952', subfield => 'p' } );
244
        is_deeply(
245
            \@fields_952p,
246
            [ '3010023919', '3010023919' ],
247
            'update all subfields 952$p with the same value'
248
        );
249
250
        update_field(
251
            {
252
                record   => $record,
253
                field    => '952',
254
                subfield => 'p',
255
                values   => [ '3010023917', '3010023918' ]
256
            }
257
        );
258
        @fields_952p =
259
          read_field( { record => $record, field => '952', subfield => 'p' } );
260
        is_deeply(
261
            \@fields_952p,
262
            [ '3010023917', '3010023918' ],
263
            'update all subfields 952$p with the different values'
264
        );
265
    };
266
};
267
268
# copy_field - subfield
269
subtest 'copy_field' => sub {
270
    plan tests              => 2;
271
    subtest 'copy subfield' => sub {
272
        plan tests => 15;
273
        my $record = new_record;
274
        $record->append_fields(
275
            MARC::Field->new(
276
                650, ' ', '0',
277
                a => 'Computer algorithms.',
278
                9 => '463',
279
            )
280
        );
281
        copy_field(
282
            {
283
                record        => $record,
284
                from_field    => '245',
285
                from_subfield => 'a',
286
                to_field      => '246',
287
                to_subfield   => 'a'
288
            }
289
        );
290
        is_deeply(
291
            read_field(
292
                { record => $record, field => '245', subfield => 'a' }
293
            ),
294
            'The art of computer programming',
295
            'After copy 245$a still exists'
296
        );
297
        is_deeply(
298
            read_field(
299
                { record => $record, field => '246', subfield => 'a' }
300
            ),
301
            'The art of computer programming',
302
            '246$a is a new field'
303
        );
304
        delete_field( { record => $record, field => '246' } );
305
        is(
306
            field_exists(
307
                { record => $record, field => '246', subfield => 'a' }
308
            ),
309
            undef,
310
            '246$a does not exist anymore'
311
        );
312
313
        copy_field(
314
            {
315
                record        => $record,
316
                from_field    => '650',
317
                from_subfield => 'a',
318
                to_field      => '651',
319
                to_subfield   => 'a'
320
            }
321
        );
322
        my @fields_651a =
323
          read_field( { record => $record, field => '651', subfield => 'a' } );
324
        is_deeply(
325
            \@fields_651a,
326
            [ 'Computer programming.', 'Computer algorithms.' ],
327
            'Copy multivalued field'
328
        );
329
        delete_field( { record => $record, field => '651' } );
330
331
        copy_field(
332
            {
333
                record        => $record,
334
                from_field    => '650',
335
                from_subfield => 'a',
336
                to_field      => '651',
337
                to_subfield   => 'a',
338
                n             => 1
339
            }
340
        );
341
        is_deeply(
342
            read_field(
343
                { record => $record, field => '651', subfield => 'a' }
344
            ),
345
            'Computer programming.',
346
            'Copy first field 650$a'
347
        );
348
        delete_field( { record => $record, field => '652' } );
349
350
        copy_field(
351
            {
352
                record        => $record,
353
                from_field    => '650',
354
                from_subfield => 'a',
355
                to_field      => '651',
356
                to_subfield   => 'a',
357
                n             => 2
358
            }
359
        );
360
        is_deeply(
361
            read_field(
362
                { record => $record, field => '651', subfield => 'a' }
363
            ),
364
            'Computer algorithms.',
365
            'Copy second field 650$a'
366
        );
367
        delete_field( { record => $record, field => '651' } );
368
369
        copy_field(
370
            {
371
                record        => $record,
372
                from_field    => '650',
373
                from_subfield => 'a',
374
                to_field      => '651',
375
                to_subfield   => 'a',
376
                regex => { search => 'Computer', replace => 'The art of' }
377
            }
378
        );
379
        @fields_651a =
380
          read_field( { record => $record, field => '651', subfield => 'a' } );
381
        is_deeply(
382
            \@fields_651a,
383
            [ 'The art of programming.', 'The art of algorithms.' ],
384
            'Copy field using regex'
385
        );
386
387
        copy_field(
388
            {
389
                record        => $record,
390
                from_field    => '650',
391
                from_subfield => 'a',
392
                to_field      => '651',
393
                to_subfield   => 'a',
394
                regex => { search => 'Computer', replace => 'The mistake of' }
395
            }
396
        );
397
        @fields_651a =
398
          read_field( { record => $record, field => '651', subfield => 'a' } );
399
        is_deeply(
400
            \@fields_651a,
401
            [ 'The mistake of programming.', 'The mistake of algorithms.' ],
402
            'Copy fields using regex on existing fields'
403
        );
404
        delete_field( { record => $record, field => '651' } );
405
406
        copy_field(
407
            {
408
                record        => $record,
409
                from_field    => '650',
410
                from_subfield => 'a',
411
                to_field      => '651',
412
                to_subfield   => 'a',
413
                regex => { search => 'Computer', replace => 'The art of' }
414
            }
415
        );
416
        @fields_651a =
417
          read_field( { record => $record, field => '651', subfield => 'a' } );
418
        is_deeply(
419
            \@fields_651a,
420
            [ 'The art of programming.', 'The art of algorithms.', ],
421
            'Copy all fields using regex'
422
        );
423
        delete_field( { record => $record, field => '651' } );
424
425
        copy_field(
426
            {
427
                record        => $record,
428
                from_field    => '650',
429
                from_subfield => 'a',
430
                to_field      => '651',
431
                to_subfield   => 'a',
432
                regex => { search => 'Computer', replace => 'The art of' },
433
                n     => 1
434
            }
435
        );
436
        @fields_651a =
437
          read_field( { record => $record, field => '651', subfield => 'a' } );
438
        is_deeply(
439
            \@fields_651a,
440
            [ 'The art of programming.', ],
441
            'Copy first field using regex'
442
        );
443
        delete_field( { record => $record, field => '651' } );
444
445
        # Copy with regex modifiers
446
        $record = new_record;
447
        $record->append_fields(
448
            MARC::Field->new(
449
                650, ' ', '0',
450
                a => 'Computer algorithms.',
451
                9 => '463',
452
            )
453
        );
454
        copy_field(
455
            {
456
                record        => $record,
457
                from_field    => '650',
458
                from_subfield => 'a',
459
                to_field      => '652',
460
                to_subfield   => 'a',
461
                regex         => { search => 'o', replace => 'foo' }
462
            }
463
        );
464
        my @fields_652a =
465
          read_field( { record => $record, field => '652', subfield => 'a' } );
466
        is_deeply(
467
            \@fields_652a,
468
            [ 'Cfoomputer programming.', 'Cfoomputer algorithms.' ],
469
            'Copy field using regex'
470
        );
471
472
        copy_field(
473
            {
474
                record        => $record,
475
                from_field    => '650',
476
                from_subfield => 'a',
477
                to_field      => '653',
478
                to_subfield   => 'a',
479
                regex => { search => 'o', replace => 'foo', modifiers => 'g' }
480
            }
481
        );
482
        my @fields_653a =
483
          read_field( { record => $record, field => '653', subfield => 'a' } );
484
        is_deeply(
485
            \@fields_653a,
486
            [ 'Cfoomputer prfoogramming.', 'Cfoomputer algfoorithms.' ],
487
            'Copy field using regex'
488
        );
489
490
        copy_field(
491
            {
492
                record        => $record,
493
                from_field    => '650',
494
                from_subfield => 'a',
495
                to_field      => '654',
496
                to_subfield   => 'a',
497
                regex => { search => 'O', replace => 'foo', modifiers => 'i' }
498
            }
499
        );
500
        my @fields_654a =
501
          read_field( { record => $record, field => '654', subfield => 'a' } );
502
        is_deeply(
503
            \@fields_654a,
504
            [ 'Cfoomputer programming.', 'Cfoomputer algorithms.' ],
505
            'Copy field using regex'
506
        );
507
508
        copy_field(
509
            {
510
                record        => $record,
511
                from_field    => '650',
512
                from_subfield => 'a',
513
                to_field      => '655',
514
                to_subfield   => 'a',
515
                regex => { search => 'O', replace => 'foo', modifiers => 'gi' }
516
            }
517
        );
518
        my @fields_655a =
519
          read_field( { record => $record, field => '655', subfield => 'a' } );
520
        is_deeply(
521
            \@fields_655a,
522
            [ 'Cfoomputer prfoogramming.', 'Cfoomputer algfoorithms.' ],
523
            'Copy field using regex'
524
        );
525
526
        $record->append_fields(
527
            MARC::Field->new(
528
                952, ' ', ' ',
529
                p => '3010023917',
530
                y => 'BK',
531
            ),
532
        );
533
534
        copy_field(
535
            {
536
                record        => $record,
537
                from_field    => '952',
538
                from_subfield => 'd',
539
                to_field      => '952',
540
                to_subfield   => 'd'
541
            }
542
        );
543
        my @fields_952d =
544
          read_field( { record => $record, field => '952', subfield => 'd' } );
545
        is_deeply(
546
            \@fields_952d,
547
            [ '2001-06-25', '2001-06-25' ],
548
            'copy 952$d into others 952 field'
549
        );
550
    };
551
552
    subtest 'copy field' => sub {
553
        plan tests => 11;
554
        my $record = new_record;
555
        $record->append_fields(
556
            MARC::Field->new(
557
                952, ' ', ' ',
558
                p => '3010023918',
559
                y => 'CD',
560
            ),
561
        );
562
563
        #- copy all fields
564
        copy_field(
565
            { record => $record, from_field => '952', to_field => '953' } );
566
        my @fields_952 = read_field( { record => $record, field => '952' } );
567
        is_deeply(
568
            [ read_field( { record => $record, field => '952', n => 1 } ) ],
569
            [ '3010023917', 'BK', 'GEN', '2001-06-25' ],
570
            "copy all: original first field still exists"
571
        );
572
        is_deeply(
573
            [ read_field( { record => $record, field => '952', n => 2 } ) ],
574
            [ '3010023918', 'CD' ],
575
            "copy all: original second field still exists"
576
        );
577
        is_deeply(
578
            [ read_field( { record => $record, field => '953', n => 1 } ) ],
579
            [ '3010023917', 'BK', 'GEN', '2001-06-25' ],
580
            "copy all: first original fields has been copied"
581
        );
582
        is_deeply(
583
            [ read_field( { record => $record, field => '953', n => 2 } ) ],
584
            [ '3010023918', 'CD' ],
585
            "copy all: second original fields has been copied"
586
        );
587
588
        #- copy only the first field
589
        copy_field(
590
            {
591
                record     => $record,
592
                from_field => '953',
593
                to_field   => '954',
594
                n          => 1
595
            }
596
        );
597
        is_deeply(
598
            [ read_field( { record => $record, field => '953', n => 1 } ) ],
599
            [ '3010023917', 'BK', 'GEN', '2001-06-25' ],
600
            "copy first: first original fields has been copied"
601
        );
602
        is_deeply(
603
            [ read_field( { record => $record, field => '953', n => 2 } ) ],
604
            [ '3010023918', 'CD' ],
605
            "copy first: second original fields has been copied"
606
        );
607
        is_deeply(
608
            [ read_field( { record => $record, field => '954' } ) ],
609
            [ '3010023917', 'BK', 'GEN', '2001-06-25' ],
610
            "copy first: only first, first 953 has been copied"
611
        );
612
613
        $record = new_record;
614
        $record->append_fields(
615
            MARC::Field->new(
616
                952, ' ', ' ',
617
                p => '3010023918',
618
                y => 'CD',
619
            ),
620
        );
621
622
        #- copy all fields and modify values using a regex
623
        copy_field(
624
            {
625
                record     => $record,
626
                from_field => '952',
627
                to_field   => '953',
628
                regex      => { search => '30100', replace => '42424' }
629
            }
630
        );
631
        is_deeply(
632
            [ read_field( { record => $record, field => '952', n => 1 } ) ],
633
            [ '3010023917', 'BK', 'GEN', '2001-06-25' ],
634
            "copy all with regex: original first field still exists"
635
        );
636
        is_deeply(
637
            [ read_field( { record => $record, field => '952', n => 2 } ) ],
638
            [ '3010023918', 'CD' ],
639
            "copy all with regex: original second field still exists"
640
        );
641
        is_deeply(
642
            [ read_field( { record => $record, field => '953', n => 1 } ) ],
643
            [ '4242423917', 'BK', 'GEN', '2001-06-25' ],
644
            "copy all wirh regex: first original fields has been copied"
645
        );
646
        is_deeply(
647
            [ read_field( { record => $record, field => '953', n => 2 } ) ],
648
            [ '4242423918', 'CD' ],
649
            "copy all with regex: second original fields has been copied"
650
        );
651
    };
652
};
653
654
# move_field - subfields
655
subtest 'move_field' => sub {
656
    plan tests              => 2;
657
    subtest 'move subfield' => sub {
658
        plan tests => 6;
659
        my $record = new_record;
660
        my ( @fields_952d, @fields_952c, @fields_954c, @fields_954p );
661
        $record->append_fields(
662
            MARC::Field->new(
663
                952, ' ', ' ',
664
                p => '3010023917',
665
                y => 'BK',
666
            ),
667
        );
668
        move_field(
669
            {
670
                record        => $record,
671
                from_field    => '952',
672
                from_subfield => 'c',
673
                to_field      => '954',
674
                to_subfield   => 'c'
675
            }
676
        );
677
        @fields_952c =
678
          read_field( { record => $record, field => '952', subfield => 'c' } );
679
        @fields_954c =
680
          read_field( { record => $record, field => '954', subfield => 'c' } );
681
        is_deeply( \@fields_952c, [],      'The 952$c has moved' );
682
        is_deeply( \@fields_954c, ['GEN'], 'Now 954$c exists' );
683
684
        move_field(
685
            {
686
                record        => $record,
687
                from_field    => '952',
688
                from_subfield => 'p',
689
                to_field      => '954',
690
                to_subfield   => 'p',
691
                n             => 1
692
            }
693
        );    # Move the first field
694
        my @fields_952p =
695
          read_field( { record => $record, field => '952', subfield => 'p' } );
696
        @fields_954p =
697
          read_field( { record => $record, field => '954', subfield => 'p' } );
698
        is_deeply( \@fields_952p, ['3010023917'], 'One of 952$p has moved' );
699
        is_deeply( \@fields_954p, ['3010023917'], 'Now 954$p exists' );
700
701
        $record = new_record;
702
        $record->append_fields(
703
            MARC::Field->new(
704
                952, ' ', ' ',
705
                p => '3010023917',
706
                y => 'BK',
707
            ),
708
        );
709
710
        move_field(
711
            {
712
                record        => $record,
713
                from_field    => '952',
714
                from_subfield => 'p',
715
                to_field      => '954',
716
                to_subfield   => 'p'
717
            }
718
        );    # Move all field
719
        @fields_952p =
720
          read_field( { record => $record, field => '952', subfield => 'p' } );
721
        @fields_954p =
722
          read_field( { record => $record, field => '954', subfield => 'p' } );
723
        is_deeply( \@fields_952p, [], 'All 952$p have moved' );
724
        is_deeply(
725
            \@fields_954p,
726
            [ '3010023917', '3010023917' ],
727
            'Now 2 954$p exist'
728
        );
729
    };
730
731
    subtest 'move field' => sub {
732
        plan tests => 8;
733
734
        # move_field - fields
735
        my $record = new_record;
736
        $record->append_fields(
737
            MARC::Field->new(
738
                952, ' ', ' ',
739
                p => '3010023917',
740
                y => 'BK',
741
            ),
742
        );
743
744
        #- Move all fields
745
        move_field(
746
            { record => $record, from_field => '952', to_field => '953' } );
747
        is_deeply( [ read_field( { record => $record, field => '952' } ) ],
748
            [], "original fields don't exist" );
749
        is_deeply(
750
            [ read_field( { record => $record, field => '953', n => 1 } ) ],
751
            [ '3010023917', 'BK', 'GEN', '2001-06-25' ],
752
            "first original fields has been copied"
753
        );
754
        is_deeply(
755
            [ read_field( { record => $record, field => '953', n => 2 } ) ],
756
            [ '3010023917', 'BK' ],
757
            "second original fields has been copied"
758
        );
759
760
        #- Move only the first field
761
        move_field(
762
            {
763
                record     => $record,
764
                from_field => '953',
765
                to_field   => '954',
766
                n          => 1
767
            }
768
        );
769
        is_deeply(
770
            [ read_field( { record => $record, field => '953' } ) ],
771
            [ '3010023917', 'BK' ],
772
            "only first, the second 953 still exists"
773
        );
774
        is_deeply(
775
            [ read_field( { record => $record, field => '954' } ) ],
776
            [ '3010023917', 'BK', 'GEN', '2001-06-25' ],
777
            "only first, first 953 has been copied"
778
        );
779
780
        $record = new_record;
781
        $record->append_fields(
782
            MARC::Field->new(
783
                952, ' ', ' ',
784
                p => '3010023917',
785
                y => 'BK',
786
            ),
787
        );
788
789
        #- Move all fields and modify values using a regex
790
        move_field(
791
            {
792
                record     => $record,
793
                from_field => '952',
794
                to_field   => '953',
795
                regex      => { search => 'BK', replace => 'DVD' }
796
            }
797
        );
798
        is_deeply( [ read_field( { record => $record, field => '952' } ) ],
799
            [], "use a regex, original fields don't exist" );
800
        is_deeply(
801
            [ read_field( { record => $record, field => '953', n => 1 } ) ],
802
            [ '3010023917', 'DVD', 'GEN', '2001-06-25' ],
803
            "use a regex, first original fields has been copied"
804
        );
805
        is_deeply(
806
            [ read_field( { record => $record, field => '953', n => 2 } ) ],
807
            [ '3010023917', 'DVD' ],
808
            "use a regex, second original fields has been copied"
809
        );
810
    };
811
};
812
813
# delete_field
814
subtest 'delete_field' => sub {
815
    plan tests                => 2;
816
    subtest 'delete subfield' => sub {
817
        plan tests => 2;
818
        my $record = new_record;
819
        $record->append_fields(
820
            MARC::Field->new(
821
                952, ' ', ' ',
822
                p => '3010023917',
823
                y => 'BK',
824
            ),
825
        );
826
827
        delete_field(
828
            { record => $record, field => '952', subfield => 'p', n => 1 } );
829
        my @fields_952p =
830
          read_field( { record => $record, field => '952', subfield => 'p' } );
831
        is_deeply( \@fields_952p, ['3010023917'], 'Delete first 952$p' );
832
833
        $record = new_record;
834
        $record->append_fields(
835
            MARC::Field->new(
836
                952, ' ', ' ',
837
                p => '3010023917',
838
                y => 'BK',
839
            ),
840
        );
841
        delete_field( { record => $record, field => '952', subfield => 'p' } );
842
        @fields_952p =
843
          read_field( { record => $record, field => '952', subfield => 'p' } );
844
        is_deeply( \@fields_952p, [], 'Delete all 952$p' );
845
    };
846
847
    subtest 'delete field' => sub {
848
        plan tests => 2;
849
        my $record = new_record;
850
        delete_field( { record => $record, field => '952' } );
851
        my @fields_952 = read_field( { record => $record, field => '952' } );
852
        is_deeply( \@fields_952, [], 'Delete all 952, 1 deleted' );
197
853
198
- 
854
        $record = new_record;
855
        $record->append_fields(
856
            MARC::Field->new(
857
                952, ' ', ' ',
858
                p => '3010023917',
859
                y => 'BK',
860
            ),
861
        );
862
        delete_field( { record => $record, field => '952' } );
863
        @fields_952 = read_field( { record => $record, field => '952' } );
864
        is_deeply( \@fields_952, [], 'Delete all 952, 2 deleted' );
865
    };
866
};

Return to bug 11319