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