t/SimpleMARC.t

   1 use Modern::Perl;
   2
   3 use Test::More tests => 10;
   4
   5 use_ok("MARC::Field");
   6 use_ok("MARC::Record");
   7 use_ok("Koha::SimpleMARC");
   8
   9 sub new_record {
  10     my $record = MARC::Record->new;
  11     $record->leader('03174nam a2200445 a 4500');
  12     my @fields = (
  13         MARC::Field->new(
  14             100, '1', ' ',
  15             a => 'Knuth, Donald Ervin',
  16             d => '1938',
  17         ),
  18         MARC::Field->new(
  19             245, '1', '4',
  20             a => 'The art of computer programming',
  21             c => 'Donald E. Knuth.',
  22         ),
  23         MARC::Field->new(
  24             650, ' ', '0',
  25             a => 'Computer programming.',
  26             9 => '462',
  27         ),
  28         MARC::Field->new(
  29             952, ' ', ' ',
  30             p => '3010023917',
  31             y => 'BK',
  32             c => 'GEN',
  33             d => '2001-06-25',
  34         ),
  35     );
  36     $record->append_fields(@fields);
  37     return $record;
  38 }
  39
  40 # field_exists
  41 subtest 'field_exists' => sub {
  42     plan tests => 3;
  43     my $record = new_record;
  44     is_deeply(
  45         field_exists( { record => $record, field => '650', subfield => 'a' } ),
  46         [1],
  47         '650$a exists'
  48     );
  49     is_deeply(
  50         field_exists( { record => $record, field => '650', subfield => 'b' } ),
  51         [],
  52         '650$b does not exist'
  53     );
  54
  55     $record->append_fields(
  56         MARC::Field->new(
  57             650, ' ', '0',
  58             a => 'Computer algorithms.',
  59             9 => '463',
  60         )
  61     );
  62
  63     is_deeply(
  64         field_exists( { record => $record, field => '650', subfield => 'a' } ),
  65         [ 1, 2 ],
  66         '650$a exists, field_exists returns the 2 field numbers'
  67     );
  68 };
  69
  70 # read_field
  71 subtest 'read_field' => sub {
  72     plan tests              => 2;
  73     subtest 'read subfield' => sub {
  74         plan tests => 5;
  75         my $record = new_record;
  76         $record->append_fields(
  77             MARC::Field->new(
  78                 650, ' ', '0',
  79                 a => 'Computer algorithms.',
  80                 9 => '463',
  81             )
  82         );
  83
  84         my @fields_650a =
  85           read_field( { record => $record, field => '650', subfield => 'a' } );
  86         is_deeply( $fields_650a[0], 'Computer programming.', 'first 650$a' );
  87         is_deeply( $fields_650a[1], 'Computer algorithms.',  'second 650$a' );
  88         is_deeply(
  89             [
  90                 read_field(
  91                     {
  92                         record        => $record,
  93                         field         => '650',
  94                         subfield      => 'a',
  95                         field_numbers => [1]
  96                     }
  97                 )
  98             ],
  99             ['Computer programming.'],
 100             'first 650$a bis'
 101         );
 102         is_deeply(
 103             [
 104                 read_field(
 105                     {
 106                         record        => $record,
 107                         field         => '650',
 108                         subfield      => 'a',
 109                         field_numbers => [2]
 110                     }
 111                 )
 112             ],
 113             ['Computer algorithms.'],
 114             'second 650$a bis'
 115         );
 116         is_deeply(
 117             [
 118                 read_field(
 119                     {
 120                         record        => $record,
 121                         field         => '650',
 122                         subfield      => 'a',
 123                         field_numbers => [3]
 124                     }
 125                 )
 126             ],
 127             [],
 128             'There is no 3 650$a'
 129         );
 130     };
 131     subtest 'read field' => sub {
 132         plan tests => 4;
 133         my $record = new_record;
 134         $record->append_fields(
 135             MARC::Field->new(
 136                 650, ' ', '0',
 137                 a => 'Computer algorithms.',
 138                 9 => '463',
 139             )
 140         );
 141         is_deeply(
 142             [
 143                 read_field(
 144                     {
 145                         record => $record,
 146                         field  => '650'
 147                     }
 148                 )
 149             ],
 150             [ 'Computer programming.', '462', 'Computer algorithms.', '463' ],
 151             'Get the all subfield values for field 650'
 152         );
 153         is_deeply(
 154             [
 155                 read_field(
 156                     {
 157                         record        => $record,
 158                         field         => '650',
 159                         field_numbers => [1]
 160                     }
 161                 )
 162             ],
 163             [ 'Computer programming.', '462' ],
 164             'Get the all subfield values for the first field 650'
 165         );
 166         is_deeply(
 167             [
 168                 read_field(
 169                     { record => $record, field => '650', field_numbers => [2] }
 170                 )
 171             ],
 172             [ 'Computer algorithms.', '463' ],
 173             'Get the all subfield values for the second field 650'
 174         );
 175         is_deeply(
 176             [
 177                 read_field(
 178                     { record => $record, field => '650', field_numbers => [3] }
 179                 )
 180             ],
 181             [],
 182 'Get the all subfield values for the third field 650 which does not exist'
 183         );
 184     };
 185 };
 186
 187 # update_field
 188 subtest 'update_field' => sub {
 189     plan tests                => 1;
 190     subtest 'update subfield' => sub {
 191         plan tests => 5;
 192         my $record = new_record;
 193
 194         update_field(
 195             {
 196                 record   => $record,
 197                 field    => '952',
 198                 subfield => 'p',
 199                 values   => ['3010023918']
 200             }
 201         );
 202         is_deeply(
 203             [
 204                 read_field(
 205                     { record => $record, field => '952', subfield => 'p' }
 206                 )
 207             ],
 208             ['3010023918'],
 209             'update existing subfield 952$p'
 210         );
 211         delete_field( { record => $record, field => '952' } );
 212         update_field(
 213             {
 214                 record   => $record,
 215                 field    => '952',
 216                 subfield => 'p',
 217                 values   => ['3010023918']
 218             }
 219         );
 220         update_field(
 221             {
 222                 record   => $record,
 223                 field    => '952',
 224                 subfield => 'y',
 225                 values   => ['BK']
 226             }
 227         );
 228         is_deeply(
 229             [
 230                 read_field(
 231                     { record => $record, field => '952', subfield => 'p' }
 232                 )
 233             ],
 234             ['3010023918'],
 235             'create subfield 952$p'
 236         );
 237         is_deeply(
 238             read_field(
 239                 { record => $record, field => '952', subfield => 'y' }
 240             ),
 241             'BK',
 242             'create subfield 952$k on existing 952 field'
 243         );
 244
 245         $record->append_fields(
 246             MARC::Field->new(
 247                 952, ' ', ' ',
 248                 p => '3010023917',
 249                 y => 'BK',
 250             ),
 251         );
 252         update_field(
 253             {
 254                 record   => $record,
 255                 field    => '952',
 256                 subfield => 'p',
 257                 values   => ['3010023919']
 258             }
 259         );
 260         my @fields_952p =
 261           read_field( { record => $record, field => '952', subfield => 'p' } );
 262         is_deeply(
 263             \@fields_952p,
 264             [ '3010023919', '3010023919' ],
 265             'update all subfields 952$p with the same value'
 266         );
 267
 268         update_field(
 269             {
 270                 record   => $record,
 271                 field    => '952',
 272                 subfield => 'p',
 273                 values   => [ '3010023917', '3010023918' ]
 274             }
 275         );
 276         @fields_952p =
 277           read_field( { record => $record, field => '952', subfield => 'p' } );
 278         is_deeply(
 279             \@fields_952p,
 280             [ '3010023917', '3010023918' ],
 281             'update all subfields 952$p with the different values'
 282         );
 283     };
 284 };
 285
 286 # copy_field - subfield
 287 subtest 'copy_field' => sub {
 288     plan tests              => 2;
 289     subtest 'copy subfield' => sub {
 290         plan tests => 20;
 291         my $record = new_record;
 292         $record->append_fields(
 293             MARC::Field->new(
 294                 650, ' ', '0',
 295                 a => 'Computer algorithms.',
 296                 9 => '463',
 297             )
 298         );
 299         copy_field(
 300             {
 301                 record        => $record,
 302                 from_field    => '245',
 303                 from_subfield => 'a',
 304                 to_field      => '246',
 305                 to_subfield   => 'a'
 306             }
 307         );
 308         is_deeply(
 309             [
 310                 read_field(
 311                     { record => $record, field => '245', subfield => 'a' }
 312                 )
 313             ],
 314             ['The art of computer programming'],
 315             'After copy 245$a still exists'
 316         );
 317         is_deeply(
 318             [
 319                 read_field(
 320                     { record => $record, field => '246', subfield => 'a' }
 321                 )
 322             ],
 323             ['The art of computer programming'],
 324             '246$a is a new field'
 325         );
 326         delete_field( { record => $record, field => '246' } );
 327         is_deeply(
 328             field_exists(
 329                 { record => $record, field => '246', subfield => 'a' }
 330             ),
 331             [],
 332             '246$a does not exist anymore'
 333         );
 334
 335         copy_field(
 336             {
 337                 record        => $record,
 338                 from_field    => '650',
 339                 from_subfield => 'a',
 340                 to_field      => '651',
 341                 to_subfield   => 'a'
 342             }
 343         );
 344         my @fields_651a =
 345           read_field( { record => $record, field => '651', subfield => 'a' } );
 346         is_deeply(
 347             \@fields_651a,
 348             [ 'Computer programming.', 'Computer algorithms.' ],
 349             'Copy multivalued field'
 350         );
 351         delete_field( { record => $record, field => '651' } );
 352
 353         copy_field(
 354             {
 355                 record        => $record,
 356                 from_field    => '650',
 357                 from_subfield => 'a',
 358                 to_field      => '651',
 359                 to_subfield   => 'a',
 360                 field_numbers => [1]
 361             }
 362         );
 363         is_deeply(
 364             [
 365                 read_field(
 366                     { record => $record, field => '651', subfield => 'a' }
 367                 )
 368             ],
 369             ['Computer programming.'],
 370             'Copy first field 650$a'
 371         );
 372         delete_field( { record => $record, field => '652' } );
 373
 374         copy_field(
 375             {
 376                 record        => $record,
 377                 from_field    => '650',
 378                 from_subfield => 'a',
 379                 to_field      => '651',
 380                 to_subfield   => 'a',
 381                 field_numbers => [2]
 382             }
 383         );
 384         is_deeply(
 385             [
 386                 read_field(
 387                     { record => $record, field => '651', subfield => 'a' }
 388                 )
 389             ],
 390             ['Computer programming.', 'Computer algorithms.'],
 391             'Copy second field 650$a'
 392         );
 393         delete_field( { record => $record, field => '651' } );
 394
 395         copy_field(
 396             {
 397                 record        => $record,
 398                 from_field    => '650',
 399                 from_subfield => 'a',
 400                 to_field      => '651',
 401                 to_subfield   => 'a',
 402                 regex => { search => 'Computer', replace => 'The art of' }
 403             }
 404         );
 405         @fields_651a =
 406           read_field( { record => $record, field => '651', subfield => 'a' } );
 407         is_deeply(
 408             \@fields_651a,
 409             [ 'The art of programming.', 'The art of algorithms.' ],
 410             'Copy field using regex'
 411         );
 412         delete_field( { record => $record, field => '651' } );
 413
 414         copy_field(
 415             {
 416                 record        => $record,
 417                 from_field    => '650',
 418                 from_subfield => 'a',
 419                 to_field      => '651',
 420                 to_subfield   => 'a',
 421                 regex => { search => 'Computer', replace => 'The mistake of' }
 422             }
 423         );
 424         @fields_651a =
 425           read_field( { record => $record, field => '651', subfield => 'a' } );
 426         is_deeply(
 427             \@fields_651a,
 428             [ 'The mistake of programming.', 'The mistake of algorithms.' ],
 429             'Copy fields using regex on existing fields'
 430         );
 431         delete_field( { record => $record, field => '651' } );
 432
 433         copy_field(
 434             {
 435                 record        => $record,
 436                 from_field    => '650',
 437                 from_subfield => 'a',
 438                 to_field      => '651',
 439                 to_subfield   => 'a',
 440                 regex => { search => 'Computer', replace => 'The art of' }
 441             }
 442         );
 443         @fields_651a =
 444           read_field( { record => $record, field => '651', subfield => 'a' } );
 445         is_deeply(
 446             \@fields_651a,
 447             [ 'The art of programming.', 'The art of algorithms.', ],
 448             'Copy all fields using regex'
 449         );
 450         delete_field( { record => $record, field => '651' } );
 451
 452         copy_field(
 453             {
 454                 record        => $record,
 455                 from_field    => '650',
 456                 from_subfield => 'a',
 457                 to_field      => '651',
 458                 to_subfield   => 'a',
 459                 regex => { search => 'Computer', replace => 'The art of' },
 460                 field_numbers => [1]
 461             }
 462         );
 463         @fields_651a =
 464           read_field( { record => $record, field => '651', subfield => 'a' } );
 465         is_deeply(
 466             \@fields_651a,
 467             [ 'The art of programming.', ],
 468             'Copy first field using regex'
 469         );
 470         delete_field( { record => $record, field => '651' } );
 471
 472         # Copy with regex modifiers
 473         $record = new_record;
 474         $record->append_fields(
 475             MARC::Field->new(
 476                 650, ' ', '0',
 477                 a => 'Computer algorithms.',
 478                 9 => '463',
 479             )
 480         );
 481         copy_field(
 482             {
 483                 record        => $record,
 484                 from_field    => '650',
 485                 from_subfield => 'a',
 486                 to_field      => '652',
 487                 to_subfield   => 'a',
 488                 regex         => { search => 'o', replace => 'foo' }
 489             }
 490         );
 491         my @fields_652a =
 492           read_field( { record => $record, field => '652', subfield => 'a' } );
 493         is_deeply(
 494             \@fields_652a,
 495             [ 'Cfoomputer programming.', 'Cfoomputer algorithms.' ],
 496             'Copy field using regex'
 497         );
 498
 499         copy_field(
 500             {
 501                 record        => $record,
 502                 from_field    => '650',
 503                 from_subfield => 'a',
 504                 to_field      => '653',
 505                 to_subfield   => 'a',
 506                 regex => { search => 'o', replace => 'foo', modifiers => 'g' }
 507             }
 508         );
 509         my @fields_653a =
 510           read_field( { record => $record, field => '653', subfield => 'a' } );
 511         is_deeply(
 512             \@fields_653a,
 513             [ 'Cfoomputer prfoogramming.', 'Cfoomputer algfoorithms.' ],
 514             'Copy field using regex'
 515         );
 516
 517         copy_field(
 518             {
 519                 record        => $record,
 520                 from_field    => '650',
 521                 from_subfield => 'a',
 522                 to_field      => '654',
 523                 to_subfield   => 'a',
 524                 regex => { search => 'O', replace => 'foo', modifiers => 'i' }
 525             }
 526         );
 527         my @fields_654a =
 528           read_field( { record => $record, field => '654', subfield => 'a' } );
 529         is_deeply(
 530             \@fields_654a,
 531             [ 'Cfoomputer programming.', 'Cfoomputer algorithms.' ],
 532             'Copy field using regex'
 533         );
 534
 535         copy_field(
 536             {
 537                 record        => $record,
 538                 from_field    => '650',
 539                 from_subfield => 'a',
 540                 to_field      => '655',
 541                 to_subfield   => 'a',
 542                 regex => { search => 'O', replace => 'foo', modifiers => 'gi' }
 543             }
 544         );
 545         my @fields_655a =
 546           read_field( { record => $record, field => '655', subfield => 'a' } );
 547         is_deeply(
 548             \@fields_655a,
 549             [ 'Cfoomputer prfoogramming.', 'Cfoomputer algfoorithms.' ],
 550             'Copy field using regex'
 551         );
 552
 553         $record = new_record;
 554         $record->append_fields(
 555             MARC::Field->new(
 556                 952, ' ', ' ',
 557                 p => '3010023917',
 558                 y => 'BK',
 559             ),
 560         );
 561
 562         copy_field(
 563             {
 564                 record        => $record,
 565                 from_field    => '952',
 566                 from_subfield => 'd',
 567                 to_field      => '952',
 568                 to_subfield   => 'd'
 569             }
 570         );
 571         my @fields_952d =
 572           read_field( { record => $record, field => '952', subfield => 'd' } );
 573         # FIXME We need a new action "duplicate" if we don't want to modify the original field
 574         is_deeply(
 575             \@fields_952d,
 576             [ '2001-06-25', '2001-06-25', '2001-06-25' ],
 577             'copy 952$d into others 952 field'
 578         );
 579
 580         copy_field(
 581             {
 582                 record        => $record,
 583                 from_field    => '111',
 584                 from_subfield => '1',
 585                 to_field      => '999',
 586                 to_subfield   => '9'
 587             }
 588         );
 589         my @fields_9999 =
 590           read_field( { record => $record, field => '999', subfield => '9' } );
 591         is_deeply( \@fields_9999, [],
 592             'copy a nonexistent subfield does not create a new one' );
 593
 594         $record = new_record;
 595         copy_field(
 596             {
 597                 record        => $record,
 598                 from_field    => 245,
 599                 from_subfield => 'a',
 600                 to_field      => 245,
 601                 to_subfield   => 'a',
 602                 regex         => { search => '^', replace => 'BEGIN ' }
 603             }
 604         );
 605         is_deeply(
 606             [
 607                 read_field(
 608                     { record => $record, field => '245', subfield => 'a' }
 609                 )
 610             ],
 611             ['The art of computer programming', 'BEGIN The art of computer programming'],
 612             'Update a subfield: add a string at the beginning'
 613         );
 614
 615         $record = new_record;
 616         copy_field(
 617             {
 618                 record        => $record,
 619                 from_field    => 245,
 620                 from_subfield => 'a',
 621                 to_field      => 245,
 622                 to_subfield   => 'a',
 623                 regex         => { search => '$', replace => ' END' }
 624             }
 625         );
 626         is_deeply(
 627             [
 628                 read_field(
 629                     { record => $record, field => '245', subfield => 'a' }
 630                 )
 631             ],
 632             ['The art of computer programming', 'The art of computer programming END'],
 633             'Update a subfield: add a string at the end'
 634         );
 635
 636         $record = new_record;
 637         copy_field(
 638             {
 639                 record        => $record,
 640                 from_field    => 245,
 641                 from_subfield => 'c',
 642                 to_field      => 650,
 643                 to_subfield   => 'c',
 644             }
 645         );
 646
 647         is_deeply(
 648             [
 649                 read_field(
 650                     { record => $record, field => '650' }
 651                 )
 652             ],
 653             [ 'Computer programming.', '462', 'Donald E. Knuth.' ],
 654             'Copy a subfield to an existent field but inexistent subfield'
 655         );
 656
 657         $record = new_record;
 658         copy_field(
 659             {
 660                 record        => $record,
 661                 from_field    => 245,
 662                 from_subfield => 'c',
 663                 to_field      => 650,
 664                 to_subfield   => '9',
 665             }
 666         );
 667
 668         is_deeply(
 669             [
 670                 read_field(
 671                     { record => $record, field => '650' }
 672                 )
 673             ],
 674             [ 'Computer programming.', '462', 'Donald E. Knuth.' ],
 675             'Copy a subfield to an existent field / subfield'
 676         );
 677     };
 678
 679     subtest 'copy field' => sub {
 680         plan tests => 14;
 681         my $record = new_record;
 682         $record->append_fields(
 683             MARC::Field->new(
 684                 952, ' ', ' ',
 685                 p => '3010023918',
 686                 y => 'CD',
 687             ),
 688         );
 689
 690         #- copy all fields
 691         copy_field(
 692             { record => $record, from_field => '952', to_field => '953' } );
 693         my @fields_952 = read_field( { record => $record, field => '952' } );
 694         is_deeply(
 695             [
 696                 read_field(
 697                     { record => $record, field => '952', field_numbers => [1] }
 698                 )
 699             ],
 700             [ '3010023917', 'BK', 'GEN', '2001-06-25' ],
 701             "copy all: original first field still exists"
 702         );
 703         is_deeply(
 704             [
 705                 read_field(
 706                     { record => $record, field => '952', field_numbers => [2] }
 707                 )
 708             ],
 709             [ '3010023918', 'CD' ],
 710             "copy all: original second field still exists"
 711         );
 712         is_deeply(
 713             [
 714                 read_field(
 715                     { record => $record, field => '953', field_numbers => [1] }
 716                 )
 717             ],
 718             [ '3010023917', 'BK', 'GEN', '2001-06-25' ],
 719             "copy all: first original fields has been copied"
 720         );
 721         is_deeply(
 722             [
 723                 read_field(
 724                     { record => $record, field => '953', field_numbers => [2] }
 725                 )
 726             ],
 727             [ '3010023918', 'CD' ],
 728             "copy all: second original fields has been copied"
 729         );
 730
 731         #- copy only the first field
 732         copy_field(
 733             {
 734                 record        => $record,
 735                 from_field    => '953',
 736                 to_field      => '954',
 737                 field_numbers => [1]
 738             }
 739         );
 740         is_deeply(
 741             [
 742                 read_field(
 743                     { record => $record, field => '953', field_numbers => [1] }
 744                 )
 745             ],
 746             [ '3010023917', 'BK', 'GEN', '2001-06-25' ],
 747             "copy first: first original fields has been copied"
 748         );
 749         is_deeply(
 750             [
 751                 read_field(
 752                     { record => $record, field => '953', field_numbers => [2] }
 753                 )
 754             ],
 755             [ '3010023918', 'CD' ],
 756             "copy first: second original fields has been copied"
 757         );
 758         is_deeply(
 759             [ read_field( { record => $record, field => '954' } ) ],
 760             [ '3010023917', 'BK', 'GEN', '2001-06-25' ],
 761             "copy first: only first, first 953 has been copied"
 762         );
 763
 764         $record = new_record;
 765         $record->append_fields(
 766             MARC::Field->new(
 767                 952, ' ', ' ',
 768                 p => '3010023918',
 769                 y => 'CD',
 770             ),
 771         );
 772
 773         #- copy all fields and modify values using a regex
 774         copy_field(
 775             {
 776                 record     => $record,
 777                 from_field => '952',
 778                 to_field   => '953',
 779                 regex      => { search => '30100', replace => '42424' }
 780             }
 781         );
 782         is_deeply(
 783             [
 784                 read_field(
 785                     { record => $record, field => '952', field_numbers => [1] }
 786                 )
 787             ],
 788             [ '3010023917', 'BK', 'GEN', '2001-06-25' ],
 789             "copy all with regex: original first field still exists"
 790         );
 791         is_deeply(
 792             [
 793                 read_field(
 794                     { record => $record, field => '952', field_numbers => [2] }
 795                 )
 796             ],
 797             [ '3010023918', 'CD' ],
 798             "copy all with regex: original second field still exists"
 799         );
 800         is_deeply(
 801             [
 802                 read_field(
 803                     { record => $record, field => '953', field_numbers => [1] }
 804                 )
 805             ],
 806             [ '4242423917', 'BK', 'GEN', '2001-06-25' ],
 807             "copy all with regex: first original fields has been copied"
 808         );
 809         is_deeply(
 810             [
 811                 read_field(
 812                     { record => $record, field => '953', field_numbers => [2] }
 813                 )
 814             ],
 815             [ '4242423918', 'CD' ],
 816             "copy all with regex: second original fields has been copied"
 817         );
 818         copy_field(
 819             {
 820                 record     => $record,
 821                 from_field => '111',
 822                 to_field   => '999',
 823             }
 824         );
 825         my @fields_9999 =
 826           read_field( { record => $record, field => '999', subfield => '9' } );
 827         is_deeply( \@fields_9999, [],
 828             'copy a nonexistent field does not create a new one' );
 829
 830         $record = new_record;
 831         copy_field(
 832             {
 833                 record        => $record,
 834                 from_field    => 245,
 835                 to_field      => 650,
 836             }
 837         );
 838
 839         is_deeply(
 840             [
 841                 read_field(
 842                     { record => $record, field => '650', field_numbers => [2] }
 843                 )
 844             ],
 845             [ 'The art of computer programming', 'Donald E. Knuth.' ],
 846             'Copy a field to existent fields should create a new field'
 847         );
 848         is_deeply(
 849             [
 850                 read_field(
 851                     { record => $record, field => '650', field_numbers => [1] }
 852                 )
 853             ],
 854             [ 'Computer programming.', '462' ],
 855             'Copy a field to existent fields should create a new field, the original one should not have been updated'
 856         );
 857     };
 858 };
 859
 860 # copy_and_replace_field - subfield
 861 subtest 'copy_and_replace_field' => sub {
 862     plan tests              => 2;
 863     subtest 'copy and replace subfield' => sub {
 864         plan tests => 19;
 865         my $record = new_record;
 866         $record->append_fields(
 867             MARC::Field->new(
 868                 650, ' ', '0',
 869                 a => 'Computer algorithms.',
 870                 9 => '463',
 871             )
 872         );
 873         copy_and_replace_field(
 874             {
 875                 record        => $record,
 876                 from_field    => '245',
 877                 from_subfield => 'a',
 878                 to_field      => '246',
 879                 to_subfield   => 'a'
 880             }
 881         );
 882         is_deeply(
 883             [
 884                 read_field(
 885                     { record => $record, field => '245', subfield => 'a' }
 886                 )
 887             ],
 888             ['The art of computer programming'],
 889             'Copy and replace should not have modify original subfield 245$a (same as copy)'
 890         );
 891         is_deeply(
 892             [
 893                 read_field(
 894                     { record => $record, field => '246', subfield => 'a' }
 895                 )
 896             ],
 897             ['The art of computer programming'],
 898             'Copy and replace should create a new 246$a (same as copy)'
 899         );
 900
 901         $record = new_record;
 902         $record->append_fields(
 903             MARC::Field->new(
 904                 650, ' ', '0',
 905                 a => 'Computer algorithms.',
 906                 9 => '463',
 907             )
 908         );
 909         copy_and_replace_field(
 910             {
 911                 record        => $record,
 912                 from_field    => '650',
 913                 from_subfield => 'a',
 914                 to_field      => '651',
 915                 to_subfield   => 'a'
 916             }
 917         );
 918         my @fields_651a =
 919           read_field( { record => $record, field => '651', subfield => 'a' } );
 920         is_deeply(
 921             \@fields_651a,
 922             [ 'Computer programming.', 'Computer algorithms.' ],
 923             'Copy and replace multivalued field (same as copy)'
 924         );
 925         delete_field( { record => $record, field => '651' } );
 926
 927         copy_and_replace_field(
 928             {
 929                 record        => $record,
 930                 from_field    => '650',
 931                 from_subfield => 'a',
 932                 to_field      => '651',
 933                 to_subfield   => 'a',
 934                 field_numbers => [1]
 935             }
 936         );
 937         is_deeply(
 938             [
 939                 read_field(
 940                     { record => $record, field => '651', subfield => 'a' }
 941                 )
 942             ],
 943             ['Computer programming.'],
 944             'Copy and replace first field 650$a should only copy the 1st (same as copy)'
 945         );
 946
 947         copy_and_replace_field(
 948             {
 949                 record        => $record,
 950                 from_field    => '650',
 951                 from_subfield => 'a',
 952                 to_field      => '651',
 953                 to_subfield   => 'a',
 954                 field_numbers => [2]
 955             }
 956         );
 957         is_deeply(
 958             [
 959                 read_field(
 960                     { record => $record, field => '651', subfield => 'a' }
 961                 )
 962             ],
 963             ['Computer algorithms.'],
 964             'Copy and replace second field 650$a should erase 651$a'
 965         );
 966         delete_field( { record => $record, field => '651' } );
 967
 968         copy_and_replace_field(
 969             {
 970                 record        => $record,
 971                 from_field    => '650',
 972                 from_subfield => 'a',
 973                 to_field      => '651',
 974                 to_subfield   => 'a',
 975                 regex => { search => 'Computer', replace => 'The art of' }
 976             }
 977         );
 978         @fields_651a =
 979           read_field( { record => $record, field => '651', subfield => 'a' } );
 980         is_deeply(
 981             \@fields_651a,
 982             [ 'The art of programming.', 'The art of algorithms.' ],
 983             'Copy and replace field using regex (same as copy)'
 984         );
 985         delete_field( { record => $record, field => '651' } );
 986
 987         copy_and_replace_field(
 988             {
 989                 record        => $record,
 990                 from_field    => '650',
 991                 from_subfield => 'a',
 992                 to_field      => '651',
 993                 to_subfield   => 'a',
 994                 regex => { search => 'Computer', replace => 'The mistake of' }
 995             }
 996         );
 997         @fields_651a =
 998           read_field( { record => $record, field => '651', subfield => 'a' } );
 999         is_deeply(
1000             \@fields_651a,
1001             [ 'The mistake of programming.', 'The mistake of algorithms.' ],
1002             'Copy and replace fields using regex on existing fields (same as copy)'
1003         );
1004         delete_field( { record => $record, field => '651' } );
1005
1006         copy_and_replace_field(
1007             {
1008                 record        => $record,
1009                 from_field    => '650',
1010                 from_subfield => 'a',
1011                 to_field      => '651',
1012                 to_subfield   => 'a',
1013                 regex => { search => 'Computer', replace => 'The art of' }
1014             }
1015         );
1016         @fields_651a =
1017           read_field( { record => $record, field => '651', subfield => 'a' } );
1018         is_deeply(
1019             \@fields_651a,
1020             [ 'The art of programming.', 'The art of algorithms.', ],
1021             'Copy and replace all fields using regex (same as copy)'
1022         );
1023         delete_field( { record => $record, field => '651' } );
1024
1025         copy_and_replace_field(
1026             {
1027                 record        => $record,
1028                 from_field    => '650',
1029                 from_subfield => 'a',
1030                 to_field      => '651',
1031                 to_subfield   => 'a',
1032                 regex => { search => 'Computer', replace => 'The art of' },
1033                 field_numbers => [1]
1034             }
1035         );
1036         @fields_651a =
1037           read_field( { record => $record, field => '651', subfield => 'a' } );
1038         is_deeply(
1039             \@fields_651a,
1040             [ 'The art of programming.', ],
1041             'Copy and replace first field using regex (same as copy)'
1042         );
1043         delete_field( { record => $record, field => '651' } );
1044
1045         # Copy and replace with regex modifiers
1046         $record = new_record;
1047         $record->append_fields(
1048             MARC::Field->new(
1049                 650, ' ', '0',
1050                 a => 'Computer algorithms.',
1051                 9 => '463',
1052             )
1053         );
1054         copy_and_replace_field(
1055             {
1056                 record        => $record,
1057                 from_field    => '650',
1058                 from_subfield => 'a',
1059                 to_field      => '652',
1060                 to_subfield   => 'a',
1061                 regex         => { search => 'o', replace => 'foo' }
1062             }
1063         );
1064         my @fields_652a =
1065           read_field( { record => $record, field => '652', subfield => 'a' } );
1066         is_deeply(
1067             \@fields_652a,
1068             [ 'Cfoomputer programming.', 'Cfoomputer algorithms.' ],
1069             'Copy and replace field using regex (same as copy)'
1070         );
1071
1072         copy_and_replace_field(
1073             {
1074                 record        => $record,
1075                 from_field    => '650',
1076                 from_subfield => 'a',
1077                 to_field      => '653',
1078                 to_subfield   => 'a',
1079                 regex => { search => 'o', replace => 'foo', modifiers => 'g' }
1080             }
1081         );
1082         my @fields_653a =
1083           read_field( { record => $record, field => '653', subfield => 'a' } );
1084         is_deeply(
1085             \@fields_653a,
1086             [ 'Cfoomputer prfoogramming.', 'Cfoomputer algfoorithms.' ],
1087             'Copy and replace field using regex (same as copy)'
1088         );
1089
1090         copy_and_replace_field(
1091             {
1092                 record        => $record,
1093                 from_field    => '650',
1094                 from_subfield => 'a',
1095                 to_field      => '654',
1096                 to_subfield   => 'a',
1097                 regex => { search => 'O', replace => 'foo', modifiers => 'i' }
1098             }
1099         );
1100         my @fields_654a =
1101           read_field( { record => $record, field => '654', subfield => 'a' } );
1102         is_deeply(
1103             \@fields_654a,
1104             [ 'Cfoomputer programming.', 'Cfoomputer algorithms.' ],
1105             'Copy and replace field using regex (same as copy)'
1106         );
1107
1108         copy_and_replace_field(
1109             {
1110                 record        => $record,
1111                 from_field    => '650',
1112                 from_subfield => 'a',
1113                 to_field      => '655',
1114                 to_subfield   => 'a',
1115                 regex => { search => 'O', replace => 'foo', modifiers => 'gi' }
1116             }
1117         );
1118         my @fields_655a =
1119           read_field( { record => $record, field => '655', subfield => 'a' } );
1120         is_deeply(
1121             \@fields_655a,
1122             [ 'Cfoomputer prfoogramming.', 'Cfoomputer algfoorithms.' ],
1123             'Copy and replace field using regex (same as copy)'
1124         );
1125
1126         $record = new_record;
1127         $record->append_fields(
1128             MARC::Field->new(
1129                 952, ' ', ' ',
1130                 p => '3010023917',
1131                 y => 'BK',
1132             ),
1133         );
1134
1135         copy_and_replace_field(
1136             {
1137                 record        => $record,
1138                 from_field    => '952',
1139                 from_subfield => 'd',
1140                 to_field      => '952',
1141                 to_subfield   => 'd'
1142             }
1143         );
1144         my @fields_952d =
1145           read_field( { record => $record, field => '952', subfield => 'd' } );
1146         is_deeply(
1147             \@fields_952d,
1148             [ '2001-06-25', '2001-06-25' ],
1149             'copy and replace 952$d into others 952 field'
1150         );
1151
1152         copy_and_replace_field(
1153             {
1154                 record        => $record,
1155                 from_field    => '111',
1156                 from_subfield => '1',
1157                 to_field      => '999',
1158                 to_subfield   => '9'
1159             }
1160         );
1161         my @fields_9999 =
1162           read_field( { record => $record, field => '999', subfield => '9' } );
1163         is_deeply( \@fields_9999, [],
1164             'copy and replace a nonexistent subfield does not create a new one (same as copy)' );
1165
1166         $record = new_record;
1167         copy_and_replace_field(
1168             {
1169                 record        => $record,
1170                 from_field    => 245,
1171                 from_subfield => 'a',
1172                 to_field      => 245,
1173                 to_subfield   => 'a',
1174                 regex         => { search => '^', replace => 'BEGIN ' }
1175             }
1176         );
1177         # This is the same as update the subfield
1178         is_deeply(
1179             [
1180                 read_field(
1181                     { record => $record, field => '245', subfield => 'a' }
1182                 )
1183             ],
1184             ['BEGIN The art of computer programming'],
1185             'Copy and replace - Update a subfield: add a string at the beginning'
1186         );
1187
1188         $record = new_record;
1189         copy_and_replace_field(
1190             {
1191                 record        => $record,
1192                 from_field    => 245,
1193                 from_subfield => 'a',
1194                 to_field      => 245,
1195                 to_subfield   => 'a',
1196                 regex         => { search => '$', replace => ' END' }
1197             }
1198         );
1199         # This is the same as update the subfield
1200         is_deeply(
1201             [
1202                 read_field(
1203                     { record => $record, field => '245', subfield => 'a' }
1204                 )
1205             ],
1206             ['The art of computer programming END'],
1207             'Copy and replace - Update a subfield: add a string at the end'
1208         );
1209
1210         $record = new_record;
1211         copy_and_replace_field(
1212             {
1213                 record        => $record,
1214                 from_field    => 245,
1215                 from_subfield => 'c',
1216                 to_field      => 650,
1217                 to_subfield   => 'c',
1218             }
1219         );
1220
1221         is_deeply(
1222             [
1223                 read_field(
1224                     { record => $record, field => '650' }
1225                 )
1226             ],
1227             [ 'Computer programming.', '462', 'Donald E. Knuth.' ],
1228             'Copy and replace a subfield to an existent field but inexistent subfield (same as copy)'
1229         );
1230
1231         $record = new_record;
1232         copy_and_replace_field(
1233             {
1234                 record        => $record,
1235                 from_field    => 245,
1236                 from_subfield => 'c',
1237                 to_field      => 650,
1238                 to_subfield   => '9',
1239             }
1240         );
1241
1242         is_deeply(
1243             [
1244                 read_field(
1245                     { record => $record, field => '650' }
1246                 )
1247             ],
1248             [ 'Computer programming.', 'Donald E. Knuth.' ],
1249             'Copy and replace a subfield to an existent field / subfield, the origin subfield is replaced'
1250         );
1251     };
1252
1253     subtest 'copy and replace field' => sub {
1254         plan tests => 14;
1255         my $record = new_record;
1256         $record->append_fields(
1257             MARC::Field->new(
1258                 952, ' ', ' ',
1259                 p => '3010023918',
1260                 y => 'CD',
1261             ),
1262         );
1263
1264         #- copy all fields
1265         copy_and_replace_field(
1266             { record => $record, from_field => '952', to_field => '953' } );
1267         my @fields_952 = read_field( { record => $record, field => '952' } );
1268         is_deeply(
1269             [
1270                 read_field(
1271                     { record => $record, field => '952', field_numbers => [1] }
1272                 )
1273             ],
1274             [ '3010023917', 'BK', 'GEN', '2001-06-25' ],
1275             "copy all: original first field still exists (same as copy)"
1276         );
1277         is_deeply(
1278             [
1279                 read_field(
1280                     { record => $record, field => '952', field_numbers => [2] }
1281                 )
1282             ],
1283             [ '3010023918', 'CD' ],
1284             "copy all: original second field still exists (same as copy)"
1285         );
1286         is_deeply(
1287             [
1288                 read_field(
1289                     { record => $record, field => '953', field_numbers => [1] }
1290                 )
1291             ],
1292             [ '3010023917', 'BK', 'GEN', '2001-06-25' ],
1293             "copy all: first original fields has been copied (same as copy)"
1294         );
1295         is_deeply(
1296             [
1297                 read_field(
1298                     { record => $record, field => '953', field_numbers => [2] }
1299                 )
1300             ],
1301             [ '3010023918', 'CD' ],
1302             "copy all: second original fields has been copied (same as copy)"
1303         );
1304
1305         #- copy only the first field
1306         copy_and_replace_field(
1307             {
1308                 record        => $record,
1309                 from_field    => '953',
1310                 to_field      => '954',
1311                 field_numbers => [1]
1312             }
1313         );
1314         is_deeply(
1315             [
1316                 read_field(
1317                     { record => $record, field => '953', field_numbers => [1] }
1318                 )
1319             ],
1320             [ '3010023917', 'BK', 'GEN', '2001-06-25' ],
1321             "copy and replace first: first original fields has been copied (same as copy)"
1322         );
1323         is_deeply(
1324             [
1325                 read_field(
1326                     { record => $record, field => '953', field_numbers => [2] }
1327                 )
1328             ],
1329             [ '3010023918', 'CD' ],
1330             "copy and replace first: second original fields has been copied (same as copy)"
1331         );
1332         is_deeply(
1333             [ read_field( { record => $record, field => '954' } ) ],
1334             [ '3010023917', 'BK', 'GEN', '2001-06-25' ],
1335             "copy and replace first: only first, first 953 has been copied (same as copy)"
1336         );
1337
1338         $record = new_record;
1339         $record->append_fields(
1340             MARC::Field->new(
1341                 952, ' ', ' ',
1342                 p => '3010023918',
1343                 y => 'CD',
1344             ),
1345         );
1346
1347         #- copy and replace all fields and modify values using a regex
1348         copy_and_replace_field(
1349             {
1350                 record     => $record,
1351                 from_field => '952',
1352                 to_field   => '953',
1353                 regex      => { search => '30100', replace => '42424' }
1354             }
1355         );
1356         is_deeply(
1357             [
1358                 read_field(
1359                     { record => $record, field => '952', field_numbers => [1] }
1360                 )
1361             ],
1362             [ '3010023917', 'BK', 'GEN', '2001-06-25' ],
1363             "copy and replace all with regex: original first field still exists (same as copy)"
1364         );
1365         is_deeply(
1366             [
1367                 read_field(
1368                     { record => $record, field => '952', field_numbers => [2] }
1369                 )
1370             ],
1371             [ '3010023918', 'CD' ],
1372             "copy and replace all with regex: original second field still exists (same as copy)"
1373         );
1374         is_deeply(
1375             [
1376                 read_field(
1377                     { record => $record, field => '953', field_numbers => [1] }
1378                 )
1379             ],
1380             [ '4242423917', 'BK', 'GEN', '2001-06-25' ],
1381             "copy and replace all with regex: first original fields has been copied (same as copy)"
1382         );
1383         is_deeply(
1384             [
1385                 read_field(
1386                     { record => $record, field => '953', field_numbers => [2] }
1387                 )
1388             ],
1389             [ '4242423918', 'CD' ],
1390             "copy and replace all with regex: second original fields has been copied (same as copy)"
1391         );
1392         copy_and_replace_field(
1393             {
1394                 record     => $record,
1395                 from_field => '111',
1396                 to_field   => '999',
1397             }
1398         );
1399         my @fields_9999 =
1400           read_field( { record => $record, field => '999', subfield => '9' } );
1401         is_deeply( \@fields_9999, [],
1402             'copy and replace a nonexistent field does not create a new one (same as copy)' );
1403
1404         $record = new_record;
1405         copy_and_replace_field(
1406             {
1407                 record        => $record,
1408                 from_field    => 245,
1409                 to_field      => 650,
1410             }
1411         );
1412
1413         is_deeply(
1414             [
1415                 read_field(
1416                     { record => $record, field => '650', field_numbers => [1] }
1417                 )
1418             ],
1419             [ 'The art of computer programming', 'Donald E. Knuth.' ],
1420             'Copy and replace to an existent field should erase the original field'
1421         );
1422         is_deeply(
1423             [
1424                 read_field(
1425                     { record => $record, field => '650', field_numbers => [2] }
1426                 )
1427             ],
1428             [],
1429             'Copy and replace to an existent field should not create a new field'
1430         );
1431     };
1432 };
1433
1434 # move_field - subfields
1435 subtest 'move_field' => sub {
1436     plan tests              => 2;
1437     subtest 'move subfield' => sub {
1438         plan tests => 7;
1439         my $record = new_record;
1440         my ( @fields_952d, @fields_952c, @fields_954c, @fields_954p );
1441         $record->append_fields(
1442             MARC::Field->new(
1443                 952, ' ', ' ',
1444                 p => '3010023917',
1445                 y => 'BK',
1446             ),
1447         );
1448         move_field(
1449             {
1450                 record        => $record,
1451                 from_field    => '952',
1452                 from_subfield => 'c',
1453                 to_field      => '954',
1454                 to_subfield   => 'c'
1455             }
1456         );
1457         @fields_952c =
1458           read_field( { record => $record, field => '952', subfield => 'c' } );
1459         @fields_954c =
1460           read_field( { record => $record, field => '954', subfield => 'c' } );
1461         is_deeply( \@fields_952c, [],      'The 952$c has moved' );
1462         is_deeply( \@fields_954c, ['GEN'], 'Now 954$c exists' );
1463
1464         move_field(
1465             {
1466                 record        => $record,
1467                 from_field    => '952',
1468                 from_subfield => 'p',
1469                 to_field      => '954',
1470                 to_subfield   => 'p',
1471                 field_numbers => [1]
1472             }
1473         );    # Move the first field
1474         my @fields_952p =
1475           read_field( { record => $record, field => '952', subfield => 'p' } );
1476         @fields_954p =
1477           read_field( { record => $record, field => '954', subfield => 'p' } );
1478         is_deeply( \@fields_952p, ['3010023917'], 'One of 952$p has moved' );
1479         is_deeply( \@fields_954p, ['3010023917'], 'Now 954$p exists' );
1480
1481         $record = new_record;
1482         $record->append_fields(
1483             MARC::Field->new(
1484                 952, ' ', ' ',
1485                 p => '3010023917',
1486                 y => 'BK',
1487             ),
1488         );
1489
1490         move_field(
1491             {
1492                 record        => $record,
1493                 from_field    => '952',
1494                 from_subfield => 'p',
1495                 to_field      => '954',
1496                 to_subfield   => 'p'
1497             }
1498         );    # Move all field
1499         @fields_952p =
1500           read_field( { record => $record, field => '952', subfield => 'p' } );
1501         @fields_954p =
1502           read_field( { record => $record, field => '954', subfield => 'p' } );
1503         is_deeply( \@fields_952p, [], 'All 952$p have moved' );
1504         is_deeply(
1505             \@fields_954p,
1506             [ '3010023917', '3010023917' ],
1507             'Now 2 954$p exist'
1508         );
1509
1510         move_field(
1511             {
1512                 record        => $record,
1513                 from_field    => '111',
1514                 from_subfield => '1',
1515                 to_field      => '999',
1516                 to_subfield   => '9'
1517             }
1518         );
1519         my @fields_9999 =
1520           read_field( { record => $record, field => '999', subfield => '9' } );
1521         is_deeply( \@fields_9999, [],
1522             'move a nonexistent subfield does not create a new one' );
1523     };
1524
1525     subtest 'move field' => sub {
1526         plan tests => 9;
1527
1528         # move_field - fields
1529         my $record = new_record;
1530         $record->append_fields(
1531             MARC::Field->new(
1532                 952, ' ', ' ',
1533                 p => '3010023917',
1534                 y => 'BK',
1535             ),
1536         );
1537
1538         #- Move all fields
1539         move_field(
1540             { record => $record, from_field => '952', to_field => '953' } );
1541         is_deeply( [ read_field( { record => $record, field => '952' } ) ],
1542             [], "original fields don't exist" );
1543         is_deeply(
1544             [
1545                 read_field(
1546                     { record => $record, field => '953', field_numbers => [1] }
1547                 )
1548             ],
1549             [ '3010023917', 'BK', 'GEN', '2001-06-25' ],
1550             "first original fields has been copied"
1551         );
1552         is_deeply(
1553             [
1554                 read_field(
1555                     { record => $record, field => '953', field_numbers => [2] }
1556                 )
1557             ],
1558             [ '3010023917', 'BK' ],
1559             "second original fields has been copied"
1560         );
1561
1562         #- Move only the first field
1563         move_field(
1564             {
1565                 record        => $record,
1566                 from_field    => '953',
1567                 to_field      => '954',
1568                 field_numbers => [1]
1569             }
1570         );
1571         is_deeply(
1572             [ read_field( { record => $record, field => '953' } ) ],
1573             [ '3010023917', 'BK' ],
1574             "only first, the second 953 still exists"
1575         );
1576         is_deeply(
1577             [ read_field( { record => $record, field => '954' } ) ],
1578             [ '3010023917', 'BK', 'GEN', '2001-06-25' ],
1579             "only first, first 953 has been copied"
1580         );
1581
1582         $record = new_record;
1583         $record->append_fields(
1584             MARC::Field->new(
1585                 952, ' ', ' ',
1586                 p => '3010023917',
1587                 y => 'BK',
1588             ),
1589         );
1590
1591         #- Move all fields and modify values using a regex
1592         move_field(
1593             {
1594                 record     => $record,
1595                 from_field => '952',
1596                 to_field   => '953',
1597                 regex      => { search => 'BK', replace => 'DVD' }
1598             }
1599         );
1600         is_deeply( [ read_field( { record => $record, field => '952' } ) ],
1601             [], "use a regex, original fields don't exist" );
1602         is_deeply(
1603             [
1604                 read_field(
1605                     { record => $record, field => '953', field_numbers => [1] }
1606                 )
1607             ],
1608             [ '3010023917', 'DVD', 'GEN', '2001-06-25' ],
1609             "use a regex, first original fields has been copied"
1610         );
1611         is_deeply(
1612             [
1613                 read_field(
1614                     { record => $record, field => '953', field_numbers => [2] }
1615                 )
1616             ],
1617             [ '3010023917', 'DVD' ],
1618             "use a regex, second original fields has been copied"
1619         );
1620
1621         move_field(
1622             {
1623                 record     => $record,
1624                 from_field => '111',
1625                 to_field   => '999',
1626             }
1627         );
1628         my @fields_9999 =
1629           read_field( { record => $record, field => '999', subfield => '9' } );
1630         is_deeply( \@fields_9999, [],
1631             'move a nonexistent field does not create a new one' );
1632
1633     };
1634 };
1635
1636 # delete_field
1637 subtest 'delete_field' => sub {
1638     plan tests                => 2;
1639     subtest 'delete subfield' => sub {
1640         plan tests => 2;
1641         my $record = new_record;
1642         $record->append_fields(
1643             MARC::Field->new(
1644                 952, ' ', ' ',
1645                 p => '3010023917',
1646                 y => 'BK',
1647             ),
1648         );
1649
1650         delete_field(
1651             {
1652                 record        => $record,
1653                 field         => '952',
1654                 subfield      => 'p',
1655                 field_numbers => [1]
1656             }
1657         );
1658         my @fields_952p =
1659           read_field( { record => $record, field => '952', subfield => 'p' } );
1660         is_deeply( \@fields_952p, ['3010023917'], 'Delete first 952$p' );
1661
1662         $record = new_record;
1663         $record->append_fields(
1664             MARC::Field->new(
1665                 952, ' ', ' ',
1666                 p => '3010023917',
1667                 y => 'BK',
1668             ),
1669         );
1670         delete_field( { record => $record, field => '952', subfield => 'p' } );
1671         @fields_952p =
1672           read_field( { record => $record, field => '952', subfield => 'p' } );
1673         is_deeply( \@fields_952p, [], 'Delete all 952$p' );
1674     };
1675
1676     subtest 'delete field' => sub {
1677         plan tests => 2;
1678         my $record = new_record;
1679         delete_field( { record => $record, field => '952' } );
1680         my @fields_952 = read_field( { record => $record, field => '952' } );
1681         is_deeply( \@fields_952, [], 'Delete all 952, 1 deleted' );
1682
1683         $record = new_record;
1684         $record->append_fields(
1685             MARC::Field->new(
1686                 952, ' ', ' ',
1687                 p => '3010023917',
1688                 y => 'BK',
1689             ),
1690         );
1691         delete_field( { record => $record, field => '952' } );
1692         @fields_952 = read_field( { record => $record, field => '952' } );
1693         is_deeply( \@fields_952, [], 'Delete all 952, 2 deleted' );
1694     };
1695 };