t/SimpleMARC.t

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