t/SimpleMARC.t

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