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");
   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 => 20;
 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 => 'c',
 681                 to_field      => 650,
 682                 to_subfield   => 'c',
 683             }
 684         );
 685
 686         is_deeply(
 687             [
 688                 read_field(
 689                     { record => $record, field => '650' }
 690                 )
 691             ],
 692             [ 'Computer programming.', '462', 'Donald E. Knuth.' ],
 693             'Copy a subfield to an existent field but inexistent subfield'
 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   => '9',
 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 / subfield'
 715         );
 716     };
 717
 718     subtest 'copy field' => sub {
 719         plan tests => 14;
 720         my $record = new_record;
 721         $record->append_fields(
 722             MARC::Field->new(
 723                 952, ' ', ' ',
 724                 p => '3010023918',
 725                 y => 'CD',
 726             ),
 727         );
 728
 729         #- copy all fields
 730         copy_field(
 731             { record => $record, from_field => '952', to_field => '953' } );
 732         my @fields_952 = read_field( { record => $record, field => '952' } );
 733         is_deeply(
 734             [
 735                 read_field(
 736                     { record => $record, field => '952', field_numbers => [1] }
 737                 )
 738             ],
 739             [ '3010023917', 'BK', 'GEN', '2001-06-25' ],
 740             "copy all: original first field still exists"
 741         );
 742         is_deeply(
 743             [
 744                 read_field(
 745                     { record => $record, field => '952', field_numbers => [2] }
 746                 )
 747             ],
 748             [ '3010023918', 'CD' ],
 749             "copy all: original second field still exists"
 750         );
 751         is_deeply(
 752             [
 753                 read_field(
 754                     { record => $record, field => '953', field_numbers => [1] }
 755                 )
 756             ],
 757             [ '3010023917', 'BK', 'GEN', '2001-06-25' ],
 758             "copy all: first original fields has been copied"
 759         );
 760         is_deeply(
 761             [
 762                 read_field(
 763                     { record => $record, field => '953', field_numbers => [2] }
 764                 )
 765             ],
 766             [ '3010023918', 'CD' ],
 767             "copy all: second original fields has been copied"
 768         );
 769
 770         #- copy only the first field
 771         copy_field(
 772             {
 773                 record        => $record,
 774                 from_field    => '953',
 775                 to_field      => '954',
 776                 field_numbers => [1]
 777             }
 778         );
 779         is_deeply(
 780             [
 781                 read_field(
 782                     { record => $record, field => '953', field_numbers => [1] }
 783                 )
 784             ],
 785             [ '3010023917', 'BK', 'GEN', '2001-06-25' ],
 786             "copy first: first original fields has been copied"
 787         );
 788         is_deeply(
 789             [
 790                 read_field(
 791                     { record => $record, field => '953', field_numbers => [2] }
 792                 )
 793             ],
 794             [ '3010023918', 'CD' ],
 795             "copy first: second original fields has been copied"
 796         );
 797         is_deeply(
 798             [ read_field( { record => $record, field => '954' } ) ],
 799             [ '3010023917', 'BK', 'GEN', '2001-06-25' ],
 800             "copy first: only first, first 953 has been copied"
 801         );
 802
 803         $record = new_record;
 804         $record->append_fields(
 805             MARC::Field->new(
 806                 952, ' ', ' ',
 807                 p => '3010023918',
 808                 y => 'CD',
 809             ),
 810         );
 811
 812         #- copy all fields and modify values using a regex
 813         copy_field(
 814             {
 815                 record     => $record,
 816                 from_field => '952',
 817                 to_field   => '953',
 818                 regex      => { search => '30100', replace => '42424' }
 819             }
 820         );
 821         is_deeply(
 822             [
 823                 read_field(
 824                     { record => $record, field => '952', field_numbers => [1] }
 825                 )
 826             ],
 827             [ '3010023917', 'BK', 'GEN', '2001-06-25' ],
 828             "copy all with regex: original first field still exists"
 829         );
 830         is_deeply(
 831             [
 832                 read_field(
 833                     { record => $record, field => '952', field_numbers => [2] }
 834                 )
 835             ],
 836             [ '3010023918', 'CD' ],
 837             "copy all with regex: original second field still exists"
 838         );
 839         is_deeply(
 840             [
 841                 read_field(
 842                     { record => $record, field => '953', field_numbers => [1] }
 843                 )
 844             ],
 845             [ '4242423917', 'BK', 'GEN', '2001-06-25' ],
 846             "copy all with regex: first original fields has been copied"
 847         );
 848         is_deeply(
 849             [
 850                 read_field(
 851                     { record => $record, field => '953', field_numbers => [2] }
 852                 )
 853             ],
 854             [ '4242423918', 'CD' ],
 855             "copy all with regex: second original fields has been copied"
 856         );
 857         copy_field(
 858             {
 859                 record     => $record,
 860                 from_field => '111',
 861                 to_field   => '999',
 862             }
 863         );
 864         my @fields_9999 =
 865           read_field( { record => $record, field => '999', subfield => '9' } );
 866         is_deeply( \@fields_9999, [],
 867             'copy a nonexistent field does not create a new one' );
 868
 869         $record = new_record;
 870         copy_field(
 871             {
 872                 record        => $record,
 873                 from_field    => 245,
 874                 to_field      => 650,
 875             }
 876         );
 877
 878         is_deeply(
 879             [
 880                 read_field(
 881                     { record => $record, field => '650', field_numbers => [2] }
 882                 )
 883             ],
 884             [ 'The art of computer programming', 'Donald E. Knuth.' ],
 885             'Copy a field to existent fields should create a new field'
 886         );
 887         is_deeply(
 888             [
 889                 read_field(
 890                     { record => $record, field => '650', field_numbers => [1] }
 891                 )
 892             ],
 893             [ 'Computer programming.', '462' ],
 894             'Copy a field to existent fields should create a new field, the original one should not have been updated'
 895         );
 896     };
 897 };
 898
 899 # copy_and_replace_field - subfield
 900 subtest 'copy_and_replace_field' => sub {
 901     plan tests              => 2;
 902     subtest 'copy and replace subfield' => sub {
 903         plan tests => 19;
 904         my $record = new_record;
 905         $record->append_fields(
 906             MARC::Field->new(
 907                 650, ' ', '0',
 908                 a => 'Computer algorithms.',
 909                 9 => '463',
 910             )
 911         );
 912         copy_and_replace_field(
 913             {
 914                 record        => $record,
 915                 from_field    => '245',
 916                 from_subfield => 'a',
 917                 to_field      => '246',
 918                 to_subfield   => 'a'
 919             }
 920         );
 921         is_deeply(
 922             [
 923                 read_field(
 924                     { record => $record, field => '245', subfield => 'a' }
 925                 )
 926             ],
 927             ['The art of computer programming'],
 928             'Copy and replace should not have modify original subfield 245$a (same as copy)'
 929         );
 930         is_deeply(
 931             [
 932                 read_field(
 933                     { record => $record, field => '246', subfield => 'a' }
 934                 )
 935             ],
 936             ['The art of computer programming'],
 937             'Copy and replace should create a new 246$a (same as copy)'
 938         );
 939
 940         $record = new_record;
 941         $record->append_fields(
 942             MARC::Field->new(
 943                 650, ' ', '0',
 944                 a => 'Computer algorithms.',
 945                 9 => '463',
 946             )
 947         );
 948         copy_and_replace_field(
 949             {
 950                 record        => $record,
 951                 from_field    => '650',
 952                 from_subfield => 'a',
 953                 to_field      => '651',
 954                 to_subfield   => 'a'
 955             }
 956         );
 957         my @fields_651a =
 958           read_field( { record => $record, field => '651', subfield => 'a' } );
 959         is_deeply(
 960             \@fields_651a,
 961             [ 'Computer programming.', 'Computer algorithms.' ],
 962             'Copy and replace multivalued field (same as copy)'
 963         );
 964         delete_field( { record => $record, field => '651' } );
 965
 966         copy_and_replace_field(
 967             {
 968                 record        => $record,
 969                 from_field    => '650',
 970                 from_subfield => 'a',
 971                 to_field      => '651',
 972                 to_subfield   => 'a',
 973                 field_numbers => [1]
 974             }
 975         );
 976         is_deeply(
 977             [
 978                 read_field(
 979                     { record => $record, field => '651', subfield => 'a' }
 980                 )
 981             ],
 982             ['Computer programming.'],
 983             'Copy and replace first field 650$a should only copy the 1st (same as copy)'
 984         );
 985
 986         copy_and_replace_field(
 987             {
 988                 record        => $record,
 989                 from_field    => '650',
 990                 from_subfield => 'a',
 991                 to_field      => '651',
 992                 to_subfield   => 'a',
 993                 field_numbers => [2]
 994             }
 995         );
 996         is_deeply(
 997             [
 998                 read_field(
 999                     { record => $record, field => '651', subfield => 'a' }
1000                 )
1001             ],
1002             ['Computer algorithms.'],
1003             'Copy and replace second field 650$a should erase 651$a'
1004         );
1005         delete_field( { record => $record, field => '651' } );
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                 regex => { search => 'Computer', replace => 'The art of' }
1015             }
1016         );
1017         @fields_651a =
1018           read_field( { record => $record, field => '651', subfield => 'a' } );
1019         is_deeply(
1020             \@fields_651a,
1021             [ 'The art of programming.', 'The art of algorithms.' ],
1022             'Copy and replace field using regex (same as copy)'
1023         );
1024         delete_field( { record => $record, field => '651' } );
1025
1026         copy_and_replace_field(
1027             {
1028                 record        => $record,
1029                 from_field    => '650',
1030                 from_subfield => 'a',
1031                 to_field      => '651',
1032                 to_subfield   => 'a',
1033                 regex => { search => 'Computer', replace => 'The mistake of' }
1034             }
1035         );
1036         @fields_651a =
1037           read_field( { record => $record, field => '651', subfield => 'a' } );
1038         is_deeply(
1039             \@fields_651a,
1040             [ 'The mistake of programming.', 'The mistake of algorithms.' ],
1041             'Copy and replace fields using regex on existing fields (same as copy)'
1042         );
1043         delete_field( { record => $record, field => '651' } );
1044
1045         copy_and_replace_field(
1046             {
1047                 record        => $record,
1048                 from_field    => '650',
1049                 from_subfield => 'a',
1050                 to_field      => '651',
1051                 to_subfield   => 'a',
1052                 regex => { search => 'Computer', replace => 'The art of' }
1053             }
1054         );
1055         @fields_651a =
1056           read_field( { record => $record, field => '651', subfield => 'a' } );
1057         is_deeply(
1058             \@fields_651a,
1059             [ 'The art of programming.', 'The art of algorithms.', ],
1060             'Copy and replace all fields using regex (same as copy)'
1061         );
1062         delete_field( { record => $record, field => '651' } );
1063
1064         copy_and_replace_field(
1065             {
1066                 record        => $record,
1067                 from_field    => '650',
1068                 from_subfield => 'a',
1069                 to_field      => '651',
1070                 to_subfield   => 'a',
1071                 regex => { search => 'Computer', replace => 'The art of' },
1072                 field_numbers => [1]
1073             }
1074         );
1075         @fields_651a =
1076           read_field( { record => $record, field => '651', subfield => 'a' } );
1077         is_deeply(
1078             \@fields_651a,
1079             [ 'The art of programming.', ],
1080             'Copy and replace first field using regex (same as copy)'
1081         );
1082         delete_field( { record => $record, field => '651' } );
1083
1084         # Copy and replace with regex modifiers
1085         $record = new_record;
1086         $record->append_fields(
1087             MARC::Field->new(
1088                 650, ' ', '0',
1089                 a => 'Computer algorithms.',
1090                 9 => '463',
1091             )
1092         );
1093         copy_and_replace_field(
1094             {
1095                 record        => $record,
1096                 from_field    => '650',
1097                 from_subfield => 'a',
1098                 to_field      => '652',
1099                 to_subfield   => 'a',
1100                 regex         => { search => 'o', replace => 'foo' }
1101             }
1102         );
1103         my @fields_652a =
1104           read_field( { record => $record, field => '652', subfield => 'a' } );
1105         is_deeply(
1106             \@fields_652a,
1107             [ 'Cfoomputer programming.', 'Cfoomputer algorithms.' ],
1108             'Copy and replace field using regex (same as copy)'
1109         );
1110
1111         copy_and_replace_field(
1112             {
1113                 record        => $record,
1114                 from_field    => '650',
1115                 from_subfield => 'a',
1116                 to_field      => '653',
1117                 to_subfield   => 'a',
1118                 regex => { search => 'o', replace => 'foo', modifiers => 'g' }
1119             }
1120         );
1121         my @fields_653a =
1122           read_field( { record => $record, field => '653', subfield => 'a' } );
1123         is_deeply(
1124             \@fields_653a,
1125             [ 'Cfoomputer prfoogramming.', 'Cfoomputer algfoorithms.' ],
1126             'Copy and replace field using regex (same as copy)'
1127         );
1128
1129         copy_and_replace_field(
1130             {
1131                 record        => $record,
1132                 from_field    => '650',
1133                 from_subfield => 'a',
1134                 to_field      => '654',
1135                 to_subfield   => 'a',
1136                 regex => { search => 'O', replace => 'foo', modifiers => 'i' }
1137             }
1138         );
1139         my @fields_654a =
1140           read_field( { record => $record, field => '654', subfield => 'a' } );
1141         is_deeply(
1142             \@fields_654a,
1143             [ 'Cfoomputer programming.', 'Cfoomputer algorithms.' ],
1144             'Copy and replace field using regex (same as copy)'
1145         );
1146
1147         copy_and_replace_field(
1148             {
1149                 record        => $record,
1150                 from_field    => '650',
1151                 from_subfield => 'a',
1152                 to_field      => '655',
1153                 to_subfield   => 'a',
1154                 regex => { search => 'O', replace => 'foo', modifiers => 'gi' }
1155             }
1156         );
1157         my @fields_655a =
1158           read_field( { record => $record, field => '655', subfield => 'a' } );
1159         is_deeply(
1160             \@fields_655a,
1161             [ 'Cfoomputer prfoogramming.', 'Cfoomputer algfoorithms.' ],
1162             'Copy and replace field using regex (same as copy)'
1163         );
1164
1165         $record = new_record;
1166         $record->append_fields(
1167             MARC::Field->new(
1168                 952, ' ', ' ',
1169                 p => '3010023917',
1170                 y => 'BK',
1171             ),
1172         );
1173
1174         copy_and_replace_field(
1175             {
1176                 record        => $record,
1177                 from_field    => '952',
1178                 from_subfield => 'd',
1179                 to_field      => '952',
1180                 to_subfield   => 'd'
1181             }
1182         );
1183         my @fields_952d =
1184           read_field( { record => $record, field => '952', subfield => 'd' } );
1185         is_deeply(
1186             \@fields_952d,
1187             [ '2001-06-25', '2001-06-25' ],
1188             'copy and replace 952$d into others 952 field'
1189         );
1190
1191         copy_and_replace_field(
1192             {
1193                 record        => $record,
1194                 from_field    => '111',
1195                 from_subfield => '1',
1196                 to_field      => '999',
1197                 to_subfield   => '9'
1198             }
1199         );
1200         my @fields_9999 =
1201           read_field( { record => $record, field => '999', subfield => '9' } );
1202         is_deeply( \@fields_9999, [],
1203             'copy and replace a nonexistent subfield does not create a new one (same as copy)' );
1204
1205         $record = new_record;
1206         copy_and_replace_field(
1207             {
1208                 record        => $record,
1209                 from_field    => 245,
1210                 from_subfield => 'a',
1211                 to_field      => 245,
1212                 to_subfield   => 'a',
1213                 regex         => { search => '^', replace => 'BEGIN ' }
1214             }
1215         );
1216         # This is the same as update the subfield
1217         is_deeply(
1218             [
1219                 read_field(
1220                     { record => $record, field => '245', subfield => 'a' }
1221                 )
1222             ],
1223             ['BEGIN The art of computer programming'],
1224             'Copy and replace - Update a subfield: add a string at the beginning'
1225         );
1226
1227         $record = new_record;
1228         copy_and_replace_field(
1229             {
1230                 record        => $record,
1231                 from_field    => 245,
1232                 from_subfield => 'a',
1233                 to_field      => 245,
1234                 to_subfield   => 'a',
1235                 regex         => { search => '$', replace => ' END' }
1236             }
1237         );
1238         # This is the same as update the subfield
1239         is_deeply(
1240             [
1241                 read_field(
1242                     { record => $record, field => '245', subfield => 'a' }
1243                 )
1244             ],
1245             ['The art of computer programming END'],
1246             'Copy and replace - Update a subfield: add a string at the end'
1247         );
1248
1249         $record = new_record;
1250         copy_and_replace_field(
1251             {
1252                 record        => $record,
1253                 from_field    => 245,
1254                 from_subfield => 'c',
1255                 to_field      => 650,
1256                 to_subfield   => 'c',
1257             }
1258         );
1259
1260         is_deeply(
1261             [
1262                 read_field(
1263                     { record => $record, field => '650' }
1264                 )
1265             ],
1266             [ 'Computer programming.', '462', 'Donald E. Knuth.' ],
1267             'Copy and replace a subfield to an existent field but inexistent subfield (same as copy)'
1268         );
1269
1270         $record = new_record;
1271         copy_and_replace_field(
1272             {
1273                 record        => $record,
1274                 from_field    => 245,
1275                 from_subfield => 'c',
1276                 to_field      => 650,
1277                 to_subfield   => '9',
1278             }
1279         );
1280
1281         is_deeply(
1282             [
1283                 read_field(
1284                     { record => $record, field => '650' }
1285                 )
1286             ],
1287             [ 'Computer programming.', 'Donald E. Knuth.' ],
1288             'Copy and replace a subfield to an existent field / subfield, the origin subfield is replaced'
1289         );
1290     };
1291
1292     subtest 'copy and replace field' => sub {
1293         plan tests => 14;
1294         my $record = new_record;
1295         $record->append_fields(
1296             MARC::Field->new(
1297                 952, ' ', ' ',
1298                 p => '3010023918',
1299                 y => 'CD',
1300             ),
1301         );
1302
1303         #- copy all fields
1304         copy_and_replace_field(
1305             { record => $record, from_field => '952', to_field => '953' } );
1306         my @fields_952 = read_field( { record => $record, field => '952' } );
1307         is_deeply(
1308             [
1309                 read_field(
1310                     { record => $record, field => '952', field_numbers => [1] }
1311                 )
1312             ],
1313             [ '3010023917', 'BK', 'GEN', '2001-06-25' ],
1314             "copy all: original first field still exists (same as copy)"
1315         );
1316         is_deeply(
1317             [
1318                 read_field(
1319                     { record => $record, field => '952', field_numbers => [2] }
1320                 )
1321             ],
1322             [ '3010023918', 'CD' ],
1323             "copy all: original second field still exists (same as copy)"
1324         );
1325         is_deeply(
1326             [
1327                 read_field(
1328                     { record => $record, field => '953', field_numbers => [1] }
1329                 )
1330             ],
1331             [ '3010023917', 'BK', 'GEN', '2001-06-25' ],
1332             "copy all: first original fields has been copied (same as copy)"
1333         );
1334         is_deeply(
1335             [
1336                 read_field(
1337                     { record => $record, field => '953', field_numbers => [2] }
1338                 )
1339             ],
1340             [ '3010023918', 'CD' ],
1341             "copy all: second original fields has been copied (same as copy)"
1342         );
1343
1344         #- copy only the first field
1345         copy_and_replace_field(
1346             {
1347                 record        => $record,
1348                 from_field    => '953',
1349                 to_field      => '954',
1350                 field_numbers => [1]
1351             }
1352         );
1353         is_deeply(
1354             [
1355                 read_field(
1356                     { record => $record, field => '953', field_numbers => [1] }
1357                 )
1358             ],
1359             [ '3010023917', 'BK', 'GEN', '2001-06-25' ],
1360             "copy and replace first: first original fields has been copied (same as copy)"
1361         );
1362         is_deeply(
1363             [
1364                 read_field(
1365                     { record => $record, field => '953', field_numbers => [2] }
1366                 )
1367             ],
1368             [ '3010023918', 'CD' ],
1369             "copy and replace first: second original fields has been copied (same as copy)"
1370         );
1371         is_deeply(
1372             [ read_field( { record => $record, field => '954' } ) ],
1373             [ '3010023917', 'BK', 'GEN', '2001-06-25' ],
1374             "copy and replace first: only first, first 953 has been copied (same as copy)"
1375         );
1376
1377         $record = new_record;
1378         $record->append_fields(
1379             MARC::Field->new(
1380                 952, ' ', ' ',
1381                 p => '3010023918',
1382                 y => 'CD',
1383             ),
1384         );
1385
1386         #- copy and replace all fields and modify values using a regex
1387         copy_and_replace_field(
1388             {
1389                 record     => $record,
1390                 from_field => '952',
1391                 to_field   => '953',
1392                 regex      => { search => '30100', replace => '42424' }
1393             }
1394         );
1395         is_deeply(
1396             [
1397                 read_field(
1398                     { record => $record, field => '952', field_numbers => [1] }
1399                 )
1400             ],
1401             [ '3010023917', 'BK', 'GEN', '2001-06-25' ],
1402             "copy and replace all with regex: original first field still exists (same as copy)"
1403         );
1404         is_deeply(
1405             [
1406                 read_field(
1407                     { record => $record, field => '952', field_numbers => [2] }
1408                 )
1409             ],
1410             [ '3010023918', 'CD' ],
1411             "copy and replace all with regex: original second field still exists (same as copy)"
1412         );
1413         is_deeply(
1414             [
1415                 read_field(
1416                     { record => $record, field => '953', field_numbers => [1] }
1417                 )
1418             ],
1419             [ '4242423917', 'BK', 'GEN', '2001-06-25' ],
1420             "copy and replace all with regex: first original fields has been copied (same as copy)"
1421         );
1422         is_deeply(
1423             [
1424                 read_field(
1425                     { record => $record, field => '953', field_numbers => [2] }
1426                 )
1427             ],
1428             [ '4242423918', 'CD' ],
1429             "copy and replace all with regex: second original fields has been copied (same as copy)"
1430         );
1431         copy_and_replace_field(
1432             {
1433                 record     => $record,
1434                 from_field => '111',
1435                 to_field   => '999',
1436             }
1437         );
1438         my @fields_9999 =
1439           read_field( { record => $record, field => '999', subfield => '9' } );
1440         is_deeply( \@fields_9999, [],
1441             'copy and replace a nonexistent field does not create a new one (same as copy)' );
1442
1443         $record = new_record;
1444         copy_and_replace_field(
1445             {
1446                 record        => $record,
1447                 from_field    => 245,
1448                 to_field      => 650,
1449             }
1450         );
1451
1452         is_deeply(
1453             [
1454                 read_field(
1455                     { record => $record, field => '650', field_numbers => [1] }
1456                 )
1457             ],
1458             [ 'The art of computer programming', 'Donald E. Knuth.' ],
1459             'Copy and replace to an existent field should erase the original field'
1460         );
1461         is_deeply(
1462             [
1463                 read_field(
1464                     { record => $record, field => '650', field_numbers => [2] }
1465                 )
1466             ],
1467             [],
1468             'Copy and replace to an existent field should not create a new field'
1469         );
1470     };
1471 };
1472
1473 # move_field - subfields
1474 subtest 'move_field' => sub {
1475     plan tests              => 2;
1476     subtest 'move subfield' => sub {
1477         plan tests => 7;
1478         my $record = new_record;
1479         my ( @fields_952d, @fields_952c, @fields_954c, @fields_954p );
1480         $record->append_fields(
1481             MARC::Field->new(
1482                 952, ' ', ' ',
1483                 p => '3010023917',
1484                 y => 'BK',
1485             ),
1486         );
1487         move_field(
1488             {
1489                 record        => $record,
1490                 from_field    => '952',
1491                 from_subfield => 'c',
1492                 to_field      => '954',
1493                 to_subfield   => 'c'
1494             }
1495         );
1496         @fields_952c =
1497           read_field( { record => $record, field => '952', subfield => 'c' } );
1498         @fields_954c =
1499           read_field( { record => $record, field => '954', subfield => 'c' } );
1500         is_deeply( \@fields_952c, [],      'The 952$c has moved' );
1501         is_deeply( \@fields_954c, ['GEN'], 'Now 954$c exists' );
1502
1503         move_field(
1504             {
1505                 record        => $record,
1506                 from_field    => '952',
1507                 from_subfield => 'p',
1508                 to_field      => '954',
1509                 to_subfield   => 'p',
1510                 field_numbers => [1]
1511             }
1512         );    # Move the first field
1513         my @fields_952p =
1514           read_field( { record => $record, field => '952', subfield => 'p' } );
1515         @fields_954p =
1516           read_field( { record => $record, field => '954', subfield => 'p' } );
1517         is_deeply( \@fields_952p, ['3010023917'], 'One of 952$p has moved' );
1518         is_deeply( \@fields_954p, ['3010023917'], 'Now 954$p exists' );
1519
1520         $record = new_record;
1521         $record->append_fields(
1522             MARC::Field->new(
1523                 952, ' ', ' ',
1524                 p => '3010023917',
1525                 y => 'BK',
1526             ),
1527         );
1528
1529         move_field(
1530             {
1531                 record        => $record,
1532                 from_field    => '952',
1533                 from_subfield => 'p',
1534                 to_field      => '954',
1535                 to_subfield   => 'p'
1536             }
1537         );    # Move all field
1538         @fields_952p =
1539           read_field( { record => $record, field => '952', subfield => 'p' } );
1540         @fields_954p =
1541           read_field( { record => $record, field => '954', subfield => 'p' } );
1542         is_deeply( \@fields_952p, [], 'All 952$p have moved' );
1543         is_deeply(
1544             \@fields_954p,
1545             [ '3010023917', '3010023917' ],
1546             'Now 2 954$p exist'
1547         );
1548
1549         move_field(
1550             {
1551                 record        => $record,
1552                 from_field    => '111',
1553                 from_subfield => '1',
1554                 to_field      => '999',
1555                 to_subfield   => '9'
1556             }
1557         );
1558         my @fields_9999 =
1559           read_field( { record => $record, field => '999', subfield => '9' } );
1560         is_deeply( \@fields_9999, [],
1561             'move a nonexistent subfield does not create a new one' );
1562     };
1563
1564     subtest 'move field' => sub {
1565         plan tests => 9;
1566
1567         # move_field - fields
1568         my $record = new_record;
1569         $record->append_fields(
1570             MARC::Field->new(
1571                 952, ' ', ' ',
1572                 p => '3010023917',
1573                 y => 'BK',
1574             ),
1575         );
1576
1577         #- Move all fields
1578         move_field(
1579             { record => $record, from_field => '952', to_field => '953' } );
1580         is_deeply( [ read_field( { record => $record, field => '952' } ) ],
1581             [], "original fields don't exist" );
1582         is_deeply(
1583             [
1584                 read_field(
1585                     { record => $record, field => '953', field_numbers => [1] }
1586                 )
1587             ],
1588             [ '3010023917', 'BK', 'GEN', '2001-06-25' ],
1589             "first original fields has been copied"
1590         );
1591         is_deeply(
1592             [
1593                 read_field(
1594                     { record => $record, field => '953', field_numbers => [2] }
1595                 )
1596             ],
1597             [ '3010023917', 'BK' ],
1598             "second original fields has been copied"
1599         );
1600
1601         #- Move only the first field
1602         move_field(
1603             {
1604                 record        => $record,
1605                 from_field    => '953',
1606                 to_field      => '954',
1607                 field_numbers => [1]
1608             }
1609         );
1610         is_deeply(
1611             [ read_field( { record => $record, field => '953' } ) ],
1612             [ '3010023917', 'BK' ],
1613             "only first, the second 953 still exists"
1614         );
1615         is_deeply(
1616             [ read_field( { record => $record, field => '954' } ) ],
1617             [ '3010023917', 'BK', 'GEN', '2001-06-25' ],
1618             "only first, first 953 has been copied"
1619         );
1620
1621         $record = new_record;
1622         $record->append_fields(
1623             MARC::Field->new(
1624                 952, ' ', ' ',
1625                 p => '3010023917',
1626                 y => 'BK',
1627             ),
1628         );
1629
1630         #- Move all fields and modify values using a regex
1631         move_field(
1632             {
1633                 record     => $record,
1634                 from_field => '952',
1635                 to_field   => '953',
1636                 regex      => { search => 'BK', replace => 'DVD' }
1637             }
1638         );
1639         is_deeply( [ read_field( { record => $record, field => '952' } ) ],
1640             [], "use a regex, original fields don't exist" );
1641         is_deeply(
1642             [
1643                 read_field(
1644                     { record => $record, field => '953', field_numbers => [1] }
1645                 )
1646             ],
1647             [ '3010023917', 'DVD', 'GEN', '2001-06-25' ],
1648             "use a regex, first original fields has been copied"
1649         );
1650         is_deeply(
1651             [
1652                 read_field(
1653                     { record => $record, field => '953', field_numbers => [2] }
1654                 )
1655             ],
1656             [ '3010023917', 'DVD' ],
1657             "use a regex, second original fields has been copied"
1658         );
1659
1660         move_field(
1661             {
1662                 record     => $record,
1663                 from_field => '111',
1664                 to_field   => '999',
1665             }
1666         );
1667         my @fields_9999 =
1668           read_field( { record => $record, field => '999', subfield => '9' } );
1669         is_deeply( \@fields_9999, [],
1670             'move a nonexistent field does not create a new one' );
1671
1672     };
1673 };
1674
1675 # delete_field
1676 subtest 'delete_field' => sub {
1677     plan tests                => 2;
1678     subtest 'delete subfield' => sub {
1679         plan tests => 2;
1680         my $record = new_record;
1681         $record->append_fields(
1682             MARC::Field->new(
1683                 952, ' ', ' ',
1684                 p => '3010023917',
1685                 y => 'BK',
1686             ),
1687         );
1688
1689         delete_field(
1690             {
1691                 record        => $record,
1692                 field         => '952',
1693                 subfield      => 'p',
1694                 field_numbers => [1]
1695             }
1696         );
1697         my @fields_952p =
1698           read_field( { record => $record, field => '952', subfield => 'p' } );
1699         is_deeply( \@fields_952p, ['3010023917'], 'Delete first 952$p' );
1700
1701         $record = new_record;
1702         $record->append_fields(
1703             MARC::Field->new(
1704                 952, ' ', ' ',
1705                 p => '3010023917',
1706                 y => 'BK',
1707             ),
1708         );
1709         delete_field( { record => $record, field => '952', subfield => 'p' } );
1710         @fields_952p =
1711           read_field( { record => $record, field => '952', subfield => 'p' } );
1712         is_deeply( \@fields_952p, [], 'Delete all 952$p' );
1713     };
1714
1715     subtest 'delete field' => sub {
1716         plan tests => 2;
1717         my $record = new_record;
1718         delete_field( { record => $record, field => '952' } );
1719         my @fields_952 = read_field( { record => $record, field => '952' } );
1720         is_deeply( \@fields_952, [], 'Delete all 952, 1 deleted' );
1721
1722         $record = new_record;
1723         $record->append_fields(
1724             MARC::Field->new(
1725                 952, ' ', ' ',
1726                 p => '3010023917',
1727                 y => 'BK',
1728             ),
1729         );
1730         delete_field( { record => $record, field => '952' } );
1731         @fields_952 = read_field( { record => $record, field => '952' } );
1732         is_deeply( \@fields_952, [], 'Delete all 952, 2 deleted' );
1733     };
1734 };
1735
1736 subtest 'field_equals' => sub {
1737     plan tests => 2;
1738     my $record = new_record;
1739     subtest 'standard MARC fields' => sub {
1740         plan tests => 2;
1741         my $match = Koha::SimpleMARC::field_equals({
1742                 record => $record,
1743                 value => 'Donald',
1744                 field => '100',
1745                 subfield => 'a',
1746             });
1747         is_deeply( $match, [], '100$a not equal to "Donald"' );
1748
1749         $match = Koha::SimpleMARC::field_equals({
1750                 record => $record,
1751                 value => 'Donald',
1752                 field => '100',
1753                 subfield => 'a',
1754                 is_regex => 1,
1755             });
1756         is_deeply( $match, [1], 'first 100$a matches "Donald"');
1757     };
1758
1759     subtest 'control fields' => sub {
1760         plan tests => 2;
1761         my $match = Koha::SimpleMARC::field_equals({
1762                 record => $record,
1763                 value => 'eng',
1764                 field => '008',
1765                 subfield => '',
1766             });
1767         is_deeply( $match, [], '008 control field not equal to "eng"' );
1768
1769         $match = Koha::SimpleMARC::field_equals({
1770                 record => $record,
1771                 value => 'eng',
1772                 field => '008',
1773                 subfield => '',
1774                 is_regex => 1,
1775             });
1776         is_deeply( $match, [1], 'first 008 control field matches "eng"' );
1777     };
1778 };