t/SimpleMARC.t

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