t/db_dependent/Koha/Biblio.t

   1 #!/usr/bin/perl
   2
   3 # This file is part of Koha.
   4 #
   5 # Koha is free software; you can redistribute it and/or modify it
   6 # under the terms of the GNU General Public License as published by
   7 # the Free Software Foundation; either version 3 of the License, or
   8 # (at your option) any later version.
   9 #
  10 # Koha is distributed in the hope that it will be useful, but
  11 # WITHOUT ANY WARRANTY; without even the implied warranty of
  12 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  13 # GNU General Public License for more details.
  14 #
  15 # You should have received a copy of the GNU General Public License
  16 # along with Koha; if not, see <http://www.gnu.org/licenses>.
  17
  18 use Modern::Perl;
  19
  20 use Test::More tests => 24;
  21 use Test::Exception;
  22 use Test::Warn;
  23
  24 use C4::Biblio qw( AddBiblio ModBiblio ModBiblioMarc );
  25 use C4::Circulation qw( AddIssue AddReturn );
  26
  27 use Koha::Database;
  28 use Koha::Cache::Memory::Lite;
  29 use Koha::Caches;
  30 use Koha::Acquisition::Orders;
  31 use Koha::AuthorisedValueCategories;
  32 use Koha::AuthorisedValues;
  33 use Koha::MarcSubfieldStructures;
  34 use Koha::Exception;
  35
  36 use MARC::Field;
  37 use MARC::Record;
  38
  39 use t::lib::TestBuilder;
  40 use t::lib::Mocks;
  41 use Test::MockModule;
  42
  43 BEGIN {
  44     use_ok('Koha::Biblio');
  45     use_ok('Koha::Biblios');
  46 }
  47
  48 my $schema  = Koha::Database->new->schema;
  49 my $builder = t::lib::TestBuilder->new;
  50
  51 subtest 'metadata() tests' => sub {
  52
  53     plan tests => 4;
  54
  55     $schema->storage->txn_begin;
  56
  57     my $title = 'Oranges and Peaches';
  58
  59     my $record = MARC::Record->new();
  60     my $field = MARC::Field->new('245','','','a' => $title);
  61     $record->append_fields( $field );
  62     my ($biblionumber) = C4::Biblio::AddBiblio($record, '');
  63
  64     my $biblio = Koha::Biblios->find( $biblionumber );
  65     is( ref $biblio, 'Koha::Biblio', 'Found a Koha::Biblio object' );
  66
  67     my $metadata = $biblio->metadata;
  68     is( ref $metadata, 'Koha::Biblio::Metadata', 'Method metadata() returned a Koha::Biblio::Metadata object' );
  69
  70     my $record2 = $metadata->record;
  71     is( ref $record2, 'MARC::Record', 'Method record() returned a MARC::Record object' );
  72
  73     is( $record2->field('245')->subfield("a"), $title, 'Title in 245$a matches title from original record object' );
  74
  75     $schema->storage->txn_rollback;
  76 };
  77
  78 subtest 'hidden_in_opac() tests' => sub {
  79
  80     plan tests => 6;
  81
  82     $schema->storage->txn_begin;
  83
  84     my $biblio = $builder->build_sample_biblio();
  85     my $rules  = { withdrawn => [ 2 ] };
  86
  87     t::lib::Mocks::mock_preference( 'OpacHiddenItemsHidesRecord', 0 );
  88
  89     ok(
  90         !$biblio->hidden_in_opac({ rules => $rules }),
  91         'Biblio not hidden if there is no item attached (!OpacHiddenItemsHidesRecord)'
  92     );
  93
  94     t::lib::Mocks::mock_preference( 'OpacHiddenItemsHidesRecord', 1 );
  95
  96     ok(
  97         !$biblio->hidden_in_opac({ rules => $rules }),
  98         'Biblio not hidden if there is no item attached (OpacHiddenItemsHidesRecord)'
  99     );
 100
 101     my $item_1 = $builder->build_sample_item({ biblionumber => $biblio->biblionumber });
 102     my $item_2 = $builder->build_sample_item({ biblionumber => $biblio->biblionumber });
 103
 104     $item_1->withdrawn( 1 )->store->discard_changes;
 105     $item_2->withdrawn( 1 )->store->discard_changes;
 106
 107     ok( !$biblio->hidden_in_opac({ rules => $rules }), 'Biblio not hidden' );
 108
 109     $item_2->withdrawn( 2 )->store->discard_changes;
 110     $biblio->discard_changes; # refresh
 111
 112     ok( !$biblio->hidden_in_opac({ rules => $rules }), 'Biblio not hidden' );
 113
 114     $item_1->withdrawn( 2 )->store->discard_changes;
 115     $biblio->discard_changes; # refresh
 116
 117     ok( $biblio->hidden_in_opac({ rules => $rules }), 'Biblio hidden' );
 118
 119     t::lib::Mocks::mock_preference( 'OpacHiddenItemsHidesRecord', 0 );
 120     ok(
 121         !$biblio->hidden_in_opac( { rules => $rules } ),
 122         'Biblio hidden (!OpacHiddenItemsHidesRecord)'
 123     );
 124
 125
 126     $schema->storage->txn_rollback;
 127 };
 128
 129 subtest 'items() tests' => sub {
 130
 131     plan tests => 3;
 132
 133     $schema->storage->txn_begin;
 134
 135     my $biblio = $builder->build_sample_biblio();
 136
 137     is( $biblio->items->count, 0, 'No items, count is 0' );
 138
 139     my $item_1 = $builder->build_sample_item({ biblionumber => $biblio->biblionumber });
 140     my $item_2 = $builder->build_sample_item({ biblionumber => $biblio->biblionumber });
 141
 142     my $items = $biblio->items;
 143     is( ref($items), 'Koha::Items', 'Returns a Koha::Items resultset' );
 144     is( $items->count, 2, 'Two items in resultset' );
 145
 146     $schema->storage->txn_rollback;
 147
 148 };
 149
 150 subtest 'get_coins and get_openurl' => sub {
 151
 152     plan tests => 4;
 153
 154     $schema->storage->txn_begin;
 155
 156     my $builder = t::lib::TestBuilder->new;
 157     my $biblio = $builder->build_sample_biblio({
 158             title => 'Title 1',
 159             author => 'Author 1'
 160         });
 161     is(
 162         $biblio->get_coins,
 163         'ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Abook&amp;rft.genre=book&amp;rft.btitle=Title%201&amp;rft.au=Author%201',
 164         'GetCOinsBiblio returned right metadata'
 165     );
 166
 167     my $record = MARC::Record->new();
 168     $record->append_fields( MARC::Field->new('100','','','a' => 'Author 2'), MARC::Field->new('880','','','a' => 'Something') );
 169     my ( $biblionumber ) = C4::Biblio::AddBiblio($record, '');
 170     my $biblio_no_title = Koha::Biblios->find($biblionumber);
 171     is(
 172         $biblio_no_title->get_coins,
 173         'ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Abook&amp;rft.genre=book&amp;rft.au=Author%202',
 174         'GetCOinsBiblio returned right metadata if biblio does not have a title'
 175     );
 176
 177     t::lib::Mocks::mock_preference("OpenURLResolverURL", "https://koha.example.com/");
 178     is(
 179         $biblio->get_openurl,
 180         'https://koha.example.com/?ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Abook&amp;rft.genre=book&amp;rft.btitle=Title%201&amp;rft.au=Author%201',
 181         'Koha::Biblio->get_openurl returned right URL'
 182     );
 183
 184     t::lib::Mocks::mock_preference("OpenURLResolverURL", "https://koha.example.com/?client_id=ci1");
 185     is(
 186         $biblio->get_openurl,
 187         'https://koha.example.com/?client_id=ci1&amp;ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Abook&amp;rft.genre=book&amp;rft.btitle=Title%201&amp;rft.au=Author%201',
 188         'Koha::Biblio->get_openurl returned right URL'
 189     );
 190
 191     $schema->storage->txn_rollback;
 192 };
 193
 194 subtest 'is_serial() tests' => sub {
 195
 196     plan tests => 3;
 197
 198     $schema->storage->txn_begin;
 199
 200     my $biblio = $builder->build_sample_biblio();
 201
 202     $biblio->serial( 1 )->store->discard_changes;
 203     ok( $biblio->is_serial, 'Bibliographic record is serial' );
 204
 205     $biblio->serial( 0 )->store->discard_changes;
 206     ok( !$biblio->is_serial, 'Bibliographic record is not serial' );
 207
 208     my $record = $biblio->metadata->record;
 209     $record->leader('00142nas a22     7a 4500');
 210     ModBiblio($record, $biblio->biblionumber );
 211     $biblio = Koha::Biblios->find($biblio->biblionumber);
 212
 213     ok( $biblio->is_serial, 'Bibliographic record is serial' );
 214
 215     $schema->storage->txn_rollback;
 216 };
 217
 218 subtest 'pickup_locations() tests' => sub {
 219
 220     plan tests => 11;
 221
 222     $schema->storage->txn_begin;
 223
 224     Koha::CirculationRules->search->delete;
 225     Koha::CirculationRules->set_rules(
 226         {
 227             categorycode => undef,
 228             itemtype     => undef,
 229             branchcode   => undef,
 230             rules        => {
 231                 reservesallowed => 25,
 232             }
 233         }
 234     );
 235
 236     my $root1 = $builder->build_object( { class => 'Koha::Library::Groups', value => { ft_local_hold_group => 1 } } );
 237     my $root2 = $builder->build_object( { class => 'Koha::Library::Groups', value => { ft_local_hold_group => 1 } } );
 238     my $root3 = $builder->build_object( { class => 'Koha::Library::Groups', value => { ft_local_hold_group => 1 } } );
 239
 240     my $library1 = $builder->build_object( { class => 'Koha::Libraries', value => { pickup_location => 1, branchname => 'zzz' } } );
 241     my $library2 = $builder->build_object( { class => 'Koha::Libraries', value => { pickup_location => 1, branchname => 'AAA' } } );
 242     my $library3 = $builder->build_object( { class => 'Koha::Libraries', value => { pickup_location => 0, branchname => 'FFF' } } );
 243     my $library4 = $builder->build_object( { class => 'Koha::Libraries', value => { pickup_location => 1, branchname => 'CCC' } } );
 244     my $library5 = $builder->build_object( { class => 'Koha::Libraries', value => { pickup_location => 1, branchname => 'eee' } } );
 245     my $library6 = $builder->build_object( { class => 'Koha::Libraries', value => { pickup_location => 1, branchname => 'BBB' } } );
 246     my $library7 = $builder->build_object( { class => 'Koha::Libraries', value => { pickup_location => 1, branchname => 'DDD' } } );
 247     my $library8 = $builder->build_object( { class => 'Koha::Libraries', value => { pickup_location => 0, branchname => 'GGG' } } );
 248
 249     our @branchcodes = map { $_->branchcode } ($library1, $library2, $library3, $library4, $library5, $library6, $library7, $library8);
 250
 251     Koha::CirculationRules->set_rules(
 252         {
 253             branchcode => $library1->branchcode,
 254             itemtype   => undef,
 255             rules => {
 256                 holdallowed => 'from_home_library',
 257                 hold_fulfillment_policy => 'any',
 258                 returnbranch => 'any'
 259             }
 260         }
 261     );
 262
 263     Koha::CirculationRules->set_rules(
 264         {
 265             branchcode => $library2->branchcode,
 266             itemtype   => undef,
 267             rules => {
 268                 holdallowed => 'from_local_hold_group',
 269                 hold_fulfillment_policy => 'holdgroup',
 270                 returnbranch => 'any'
 271             }
 272         }
 273     );
 274
 275     Koha::CirculationRules->set_rules(
 276         {
 277             branchcode => $library3->branchcode,
 278             itemtype   => undef,
 279             rules => {
 280                 holdallowed => 'from_local_hold_group',
 281                 hold_fulfillment_policy => 'patrongroup',
 282                 returnbranch => 'any'
 283             }
 284         }
 285     );
 286
 287     Koha::CirculationRules->set_rules(
 288         {
 289             branchcode => $library4->branchcode,
 290             itemtype   => undef,
 291             rules => {
 292                 holdallowed => 'from_any_library',
 293                 hold_fulfillment_policy => 'holdingbranch',
 294                 returnbranch => 'any'
 295             }
 296         }
 297     );
 298
 299     Koha::CirculationRules->set_rules(
 300         {
 301             branchcode => $library5->branchcode,
 302             itemtype   => undef,
 303             rules => {
 304                 holdallowed => 'from_any_library',
 305                 hold_fulfillment_policy => 'homebranch',
 306                 returnbranch => 'any'
 307             }
 308         }
 309     );
 310
 311     Koha::CirculationRules->set_rules(
 312         {
 313             branchcode => $library6->branchcode,
 314             itemtype   => undef,
 315             rules => {
 316                 holdallowed => 'from_home_library',
 317                 hold_fulfillment_policy => 'holdgroup',
 318                 returnbranch => 'any'
 319             }
 320         }
 321     );
 322
 323     Koha::CirculationRules->set_rules(
 324         {
 325             branchcode => $library7->branchcode,
 326             itemtype   => undef,
 327             rules => {
 328                 holdallowed => 'from_local_hold_group',
 329                 hold_fulfillment_policy => 'holdingbranch',
 330                 returnbranch => 'any'
 331             }
 332         }
 333     );
 334
 335
 336     Koha::CirculationRules->set_rules(
 337         {
 338             branchcode => $library8->branchcode,
 339             itemtype   => undef,
 340             rules => {
 341                 holdallowed => 'from_any_library',
 342                 hold_fulfillment_policy => 'patrongroup',
 343                 returnbranch => 'any'
 344             }
 345         }
 346     );
 347
 348     my $group1_1 = $builder->build_object( { class => 'Koha::Library::Groups', value => { parent_id => $root1->id, branchcode => $library1->branchcode } } );
 349     my $group1_2 = $builder->build_object( { class => 'Koha::Library::Groups', value => { parent_id => $root1->id, branchcode => $library2->branchcode } } );
 350
 351     my $group2_3 = $builder->build_object( { class => 'Koha::Library::Groups', value => { parent_id => $root2->id, branchcode => $library3->branchcode } } );
 352     my $group2_4 = $builder->build_object( { class => 'Koha::Library::Groups', value => { parent_id => $root2->id, branchcode => $library4->branchcode } } );
 353
 354     my $group3_5 = $builder->build_object( { class => 'Koha::Library::Groups', value => { parent_id => $root3->id, branchcode => $library5->branchcode } } );
 355     my $group3_6 = $builder->build_object( { class => 'Koha::Library::Groups', value => { parent_id => $root3->id, branchcode => $library6->branchcode } } );
 356     my $group3_7 = $builder->build_object( { class => 'Koha::Library::Groups', value => { parent_id => $root3->id, branchcode => $library7->branchcode } } );
 357     my $group3_8 = $builder->build_object( { class => 'Koha::Library::Groups', value => { parent_id => $root3->id, branchcode => $library8->branchcode } } );
 358
 359     my $biblio1  = $builder->build_sample_biblio({ title => '1' });
 360     my $biblio2  = $builder->build_sample_biblio({ title => '2' });
 361
 362     throws_ok
 363       { $biblio1->pickup_locations }
 364       'Koha::Exceptions::MissingParameter',
 365       'Exception thrown on missing parameter';
 366
 367     is( $@->parameter, 'patron', 'Exception param correctly set' );
 368
 369     my $item1_1  = $builder->build_sample_item({
 370         biblionumber     => $biblio1->biblionumber,
 371         homebranch       => $library1->branchcode,
 372         holdingbranch    => $library2->branchcode,
 373     })->store;
 374
 375     my $item1_3  = $builder->build_sample_item({
 376         biblionumber     => $biblio1->biblionumber,
 377         homebranch       => $library3->branchcode,
 378         holdingbranch    => $library4->branchcode,
 379     })->store;
 380
 381     my $item1_7  = $builder->build_sample_item({
 382         biblionumber     => $biblio1->biblionumber,
 383         homebranch       => $library7->branchcode,
 384         holdingbranch    => $library4->branchcode,
 385     })->store;
 386
 387     my $item2_2  = $builder->build_sample_item({
 388         biblionumber     => $biblio2->biblionumber,
 389         homebranch       => $library2->branchcode,
 390         holdingbranch    => $library1->branchcode,
 391     })->store;
 392
 393     my $item2_4  = $builder->build_sample_item({
 394         biblionumber     => $biblio2->biblionumber,
 395         homebranch       => $library4->branchcode,
 396         holdingbranch    => $library3->branchcode,
 397     })->store;
 398
 399     my $item2_6  = $builder->build_sample_item({
 400         biblionumber     => $biblio2->biblionumber,
 401         homebranch       => $library6->branchcode,
 402         holdingbranch    => $library4->branchcode,
 403     })->store;
 404
 405     my $patron1 = $builder->build_object( { class => 'Koha::Patrons', value => { firstname=>'1', branchcode => $library1->branchcode } } );
 406     my $patron8 = $builder->build_object( { class => 'Koha::Patrons', value => { firstname=>'8', branchcode => $library8->branchcode } } );
 407
 408     my $results = {
 409         "ItemHomeLibrary-1-1" => 6,
 410         "ItemHomeLibrary-1-8" => 1,
 411         "ItemHomeLibrary-2-1" => 2,
 412         "ItemHomeLibrary-2-8" => 0,
 413         "PatronLibrary-1-1" => 6,
 414         "PatronLibrary-1-8" => 3,
 415         "PatronLibrary-2-1" => 0,
 416         "PatronLibrary-2-8" => 3,
 417     };
 418
 419     sub _doTest {
 420         my ( $cbranch, $biblio, $patron, $results ) = @_;
 421         t::lib::Mocks::mock_preference('ReservesControlBranch', $cbranch);
 422
 423         my @pl = map {
 424             my $pickup_location = $_;
 425             grep { $pickup_location->branchcode eq $_ } @branchcodes
 426         } $biblio->pickup_locations( { patron => $patron } )->as_list;
 427
 428         ok(
 429             scalar(@pl) == $results->{ $cbranch . '-'
 430                   . $biblio->title . '-'
 431                   . $patron->firstname },
 432             'ReservesControlBranch: '
 433               . $cbranch
 434               . ', biblio'
 435               . $biblio->title
 436               . ', patron'
 437               . $patron->firstname
 438               . ' should return '
 439               . $results->{ $cbranch . '-'
 440                   . $biblio->title . '-'
 441                   . $patron->firstname }
 442               . ' but returns '
 443               . scalar(@pl)
 444         );
 445     }
 446
 447     foreach my $cbranch ('ItemHomeLibrary','PatronLibrary') {
 448         my $cache = Koha::Cache::Memory::Lite->get_instance();
 449         $cache->flush(); # needed since we change ReservesControlBranch
 450         foreach my $biblio ($biblio1, $biblio2) {
 451             foreach my $patron ($patron1, $patron8) {
 452                 _doTest($cbranch, $biblio, $patron, $results);
 453             }
 454         }
 455     }
 456
 457     my @pl_names = map { $_->branchname } $biblio1->pickup_locations( { patron => $patron1 } )->as_list;
 458     my $pl_ori_str = join('|', @pl_names);
 459     my $pl_sorted_str = join('|', sort { lc($a) cmp lc($b) } @pl_names);
 460     ok(
 461         $pl_ori_str eq $pl_sorted_str,
 462         'Libraries must be sorted by name'
 463     );
 464     $schema->storage->txn_rollback;
 465 };
 466
 467 subtest 'to_api() tests' => sub {
 468
 469     $schema->storage->txn_begin;
 470
 471     my $biblio = $builder->build_sample_biblio();
 472     my $item = $builder->build_sample_item({ biblionumber => $biblio->biblionumber });
 473
 474     my $biblioitem_api = $biblio->biblioitem->to_api;
 475     my $biblio_api     = $biblio->to_api;
 476
 477     plan tests => (scalar keys %{ $biblioitem_api }) + 1;
 478
 479     foreach my $key ( keys %{ $biblioitem_api } ) {
 480         is( $biblio_api->{$key}, $biblioitem_api->{$key}, "$key is added to the biblio object" );
 481     }
 482
 483     $biblio_api = $biblio->to_api({ embed => { items => {} } });
 484     is_deeply( $biblio_api->{items}, [ $item->to_api ], 'Item correctly embedded' );
 485
 486     $schema->storage->txn_rollback;
 487 };
 488
 489 subtest 'suggestions() tests' => sub {
 490
 491     plan tests => 3;
 492
 493     $schema->storage->txn_begin;
 494
 495     my $biblio     = $builder->build_sample_biblio();
 496
 497     is( ref($biblio->suggestions), 'Koha::Suggestions', 'Return type is correct' );
 498
 499     is_deeply(
 500         $biblio->suggestions->unblessed,
 501         [],
 502         '->suggestions returns an empty Koha::Suggestions resultset'
 503     );
 504
 505     my $suggestion = $builder->build_object(
 506         {
 507             class => 'Koha::Suggestions',
 508             value => { biblionumber => $biblio->biblionumber }
 509         }
 510     );
 511
 512     my $suggestions = $biblio->suggestions->unblessed;
 513
 514     is_deeply(
 515         $biblio->suggestions->unblessed,
 516         [ $suggestion->unblessed ],
 517         '->suggestions returns the related Koha::Suggestion objects'
 518     );
 519
 520     $schema->storage->txn_rollback;
 521 };
 522
 523 subtest 'get_marc_components() tests' => sub {
 524
 525     plan tests => 5;
 526
 527     $schema->storage->txn_begin;
 528
 529     my ($host_bibnum) = C4::Biblio::AddBiblio(host_record(), '');
 530     my $host_biblio = Koha::Biblios->find($host_bibnum);
 531     t::lib::Mocks::mock_preference( 'SearchEngine', 'Zebra' );
 532     my $search_mod = Test::MockModule->new( 'Koha::SearchEngine::Zebra::Search' );
 533     $search_mod->mock( 'search_compat', \&search_component_record2 );
 534
 535     my $components = $host_biblio->get_marc_components;
 536     is( ref($components), 'ARRAY', 'Return type is correct' );
 537
 538     is_deeply(
 539         $components,
 540         [],
 541         '->get_marc_components returns an empty ARRAY'
 542     );
 543
 544     $search_mod->unmock( 'search_compat');
 545     $search_mod->mock( 'search_compat', \&search_component_record1 );
 546     my $component_record = component_record1()->as_xml();
 547
 548     is_deeply(
 549         $host_biblio->get_marc_components,
 550         [$component_record],
 551         '->get_marc_components returns the related component part record'
 552     );
 553     $search_mod->unmock( 'search_compat');
 554
 555     $search_mod->mock( 'search_compat',
 556         sub { Koha::Exception->throw("error searching analytics") }
 557     );
 558     warning_like { $components = $host_biblio->get_marc_components }
 559         qr{Warning from search_compat: .* 'error searching analytics'};
 560
 561     is_deeply(
 562         $host_biblio->object_messages,
 563         [
 564             {
 565                 type    => 'error',
 566                 message => 'component_search',
 567                 payload => "Exception 'Koha::Exception' thrown 'error searching analytics'\n"
 568             }
 569         ]
 570     );
 571     $search_mod->unmock( 'search_compat');
 572
 573     $schema->storage->txn_rollback;
 574 };
 575
 576 subtest 'get_components_query' => sub {
 577     plan tests => 12;
 578
 579     my $biblio = $builder->build_sample_biblio();
 580     my $biblionumber = $biblio->biblionumber;
 581     my $record = $biblio->metadata->record;
 582
 583     foreach my $engine ('Zebra','Elasticsearch'){
 584         t::lib::Mocks::mock_preference( 'SearchEngine', $engine );
 585
 586         t::lib::Mocks::mock_preference( 'UseControlNumber', '0' );
 587         t::lib::Mocks::mock_preference( 'ComponentSortField', 'author' );
 588         t::lib::Mocks::mock_preference( 'ComponentSortOrder', 'za' );
 589         my ( $comp_query, $comp_query_str, $comp_sort ) = $biblio->get_components_query;
 590         is($comp_query_str, 'Host-item:("Some boring read")', "$engine: UseControlNumber disabled");
 591         is($comp_sort, "author_za", "$engine: UseControlNumber disabled sort is correct");
 592
 593         t::lib::Mocks::mock_preference( 'UseControlNumber', '1' );
 594         t::lib::Mocks::mock_preference( 'ComponentSortOrder', 'az' );
 595         my $marc_001_field = MARC::Field->new('001', $biblionumber);
 596         $record->append_fields($marc_001_field);
 597         C4::Biblio::ModBiblio( $record, $biblio->biblionumber );
 598         $biblio = Koha::Biblios->find( $biblio->biblionumber);
 599
 600         ( $comp_query, $comp_query_str, $comp_sort ) = $biblio->get_components_query;
 601         is($comp_query_str, "(rcn:\"$biblionumber\" AND (bib-level:a OR bib-level:b))", "$engine: UseControlNumber enabled without MarcOrgCode");
 602         is($comp_sort, "author_az", "$engine: UseControlNumber enabled without MarcOrgCode sort is correct");
 603
 604         my $marc_003_field = MARC::Field->new('003', 'OSt');
 605         $record->append_fields($marc_003_field);
 606         C4::Biblio::ModBiblio( $record, $biblio->biblionumber );
 607         $biblio = Koha::Biblios->find( $biblio->biblionumber);
 608
 609         t::lib::Mocks::mock_preference( 'ComponentSortField', 'title' );
 610         t::lib::Mocks::mock_preference( 'ComponentSortOrder', 'asc' );
 611         ( $comp_query, $comp_query_str, $comp_sort ) = $biblio->get_components_query;
 612         is($comp_query_str, "(((rcn:\"$biblionumber\" AND cni:\"OSt\") OR rcn:\"OSt $biblionumber\") AND (bib-level:a OR bib-level:b))", "$engine: UseControlNumber enabled with MarcOrgCode");
 613         is($comp_sort, "title_asc", "$engine: UseControlNumber enabled with MarcOrgCode sort if correct");
 614         $record->delete_field($marc_003_field);
 615     }
 616 };
 617
 618 subtest 'orders() and active_orders() tests' => sub {
 619
 620     plan tests => 5;
 621
 622     $schema->storage->txn_begin;
 623
 624     my $biblio = $builder->build_sample_biblio();
 625
 626     my $orders        = $biblio->orders;
 627     my $active_orders = $biblio->active_orders;
 628
 629     is( ref($orders), 'Koha::Acquisition::Orders', 'Result type is correct' );
 630     is( $biblio->orders->count, $biblio->active_orders->count, '->orders->count returns the count for the resultset' );
 631
 632     # Add a couple orders
 633     foreach (1..2) {
 634         $builder->build_object(
 635             {
 636                 class => 'Koha::Acquisition::Orders',
 637                 value => {
 638                     biblionumber => $biblio->biblionumber,
 639                     datecancellationprinted => '2019-12-31'
 640                 }
 641             }
 642         );
 643     }
 644
 645     $builder->build_object(
 646         {
 647             class => 'Koha::Acquisition::Orders',
 648             value => {
 649                 biblionumber => $biblio->biblionumber,
 650                 datecancellationprinted => undef
 651             }
 652         }
 653     );
 654
 655     $orders = $biblio->orders;
 656     $active_orders = $biblio->active_orders;
 657
 658     is( ref($orders), 'Koha::Acquisition::Orders', 'Result type is correct' );
 659     is( ref($active_orders), 'Koha::Acquisition::Orders', 'Result type is correct' );
 660     is( $orders->count, $active_orders->count + 2, '->active_orders->count returns the rigt count' );
 661
 662     $schema->storage->txn_rollback;
 663 };
 664
 665 subtest 'tickets() tests' => sub {
 666
 667     plan tests => 4;
 668
 669     $schema->storage->txn_begin;
 670
 671     my $biblio = $builder->build_sample_biblio();
 672     my $tickets = $biblio->tickets;
 673     is( ref($tickets), 'Koha::Tickets', 'Koha::Biblio->tickets should return a Koha::Tickets object' );
 674     is( $tickets->count, 0, 'Koha::Biblio->tickets should return a count of 0 when there are no related tickets' );
 675
 676     # Add two tickets
 677     foreach (1..2) {
 678         $builder->build_object(
 679             {
 680                 class => 'Koha::Tickets',
 681                 value => { biblio_id => $biblio->biblionumber }
 682             }
 683         );
 684     }
 685
 686     $tickets = $biblio->tickets;
 687     is( ref($tickets), 'Koha::Tickets', 'Koha::Biblio->tickets should return a Koha::Tickets object' );
 688     is( $tickets->count, 2, 'Koha::Biblio->tickets should return the correct number of tickets' );
 689
 690     $schema->storage->txn_rollback;
 691 };
 692
 693 subtest 'subscriptions() tests' => sub {
 694
 695     plan tests => 4;
 696
 697     $schema->storage->txn_begin;
 698
 699     my $biblio = $builder->build_sample_biblio;
 700
 701     my $subscriptions = $biblio->subscriptions;
 702     is( ref($subscriptions), 'Koha::Subscriptions',
 703         'Koha::Biblio->subscriptions should return a Koha::Subscriptions object'
 704     );
 705     is( $subscriptions->count, 0, 'Koha::Biblio->subscriptions should return the correct number of subscriptions');
 706
 707     # Add two subscriptions
 708     foreach (1..2) {
 709         $builder->build_object(
 710             {
 711                 class => 'Koha::Subscriptions',
 712                 value => { biblionumber => $biblio->biblionumber }
 713             }
 714         );
 715     }
 716
 717     $subscriptions = $biblio->subscriptions;
 718     is( ref($subscriptions), 'Koha::Subscriptions',
 719         'Koha::Biblio->subscriptions should return a Koha::Subscriptions object'
 720     );
 721     is( $subscriptions->count, 2, 'Koha::Biblio->subscriptions should return the correct number of subscriptions');
 722
 723     $schema->storage->txn_rollback;
 724 };
 725
 726 subtest 'get_marc_notes() MARC21 tests' => sub {
 727     plan tests => 14;
 728
 729     $schema->storage->txn_begin;
 730
 731     t::lib::Mocks::mock_preference( 'NotesToHide', '520' );
 732
 733     my $av = $builder->build_object( { class => 'Koha::AuthorisedValues' } );
 734
 735     my $biblio = $builder->build_sample_biblio;
 736     my $record = $biblio->metadata->record;
 737     $record->append_fields(
 738         MARC::Field->new( '500', '', '', a => 'Note1' ),
 739         MARC::Field->new( '505', '', '', a => 'Note2', u => 'http://someserver.com' ),
 740         MARC::Field->new( '520', '', '', a => 'Note3 skipped' ),
 741         MARC::Field->new( '541', '0', '', a => 'Note4 skipped on opac' ),
 742         MARC::Field->new( '544', '', '', a => 'Note5' ),
 743         MARC::Field->new( '590', '', '', a => $av->authorised_value ),
 744         MARC::Field->new( '545', '', '', a => 'Invisible on OPAC' ),
 745     );
 746
 747     my $mss = Koha::MarcSubfieldStructures->find({tagfield => "590", tagsubfield => "a", frameworkcode => $biblio->frameworkcode });
 748     $mss->update({ authorised_value => $av->category });
 749
 750     $mss = Koha::MarcSubfieldStructures->find({tagfield => "545", tagsubfield => "a", frameworkcode => $biblio->frameworkcode });
 751     $mss->update({ hidden => 1 });
 752
 753     my $cache = Koha::Caches->get_instance;
 754     $cache->clear_from_cache("MarcStructure-0-");
 755     $cache->clear_from_cache("MarcStructure-1-");
 756     $cache->clear_from_cache("MarcSubfieldStructure-");
 757     $cache->clear_from_cache("MarcCodedFields-");
 758
 759     C4::Biblio::ModBiblio( $record, $biblio->biblionumber );
 760     $biblio = Koha::Biblios->find( $biblio->biblionumber);
 761
 762     my $notes = $biblio->get_marc_notes;
 763     is( $notes->[0]->{marcnote}, 'Note1', 'First note' );
 764     is( $notes->[1]->{marcnote}, 'Note2', 'Second note' );
 765     is( $notes->[2]->{marcnote}, 'http://someserver.com', 'URL separated' );
 766     is( $notes->[3]->{marcnote}, 'Note4 skipped on opac',"Note shows if not opac (Hidden by Indicator)" );
 767     is( $notes->[4]->{marcnote}, 'Note5', 'Fifth note' );
 768     is( $notes->[5]->{marcnote}, $av->lib, 'Authorised value is correctly parsed to show description rather than code' );
 769     is( $notes->[6]->{marcnote}, 'Invisible on OPAC', 'Note shows if not opac (Hidden by framework)' );
 770     is( @$notes, 7, 'No more notes' );
 771     $notes = $biblio->get_marc_notes({ opac => 1 });
 772     is( $notes->[0]->{marcnote}, 'Note1', 'First note' );
 773     is( $notes->[1]->{marcnote}, 'Note2', 'Second note' );
 774     is( $notes->[2]->{marcnote}, 'http://someserver.com', 'URL separated' );
 775     is( $notes->[3]->{marcnote}, 'Note5', 'Fifth note shows after fourth skipped' );
 776     is( $notes->[4]->{marcnote}, $av->lib_opac, 'Authorised value is correctly parsed for OPAC to show description rather than code' );
 777     is( @$notes, 5, 'No more notes' );
 778
 779     $cache->clear_from_cache("MarcStructure-0-");
 780     $cache->clear_from_cache("MarcStructure-1-");
 781     $cache->clear_from_cache("MarcSubfieldStructure-");
 782     $cache->clear_from_cache("MarcCodedFields-");
 783
 784     $schema->storage->txn_rollback;
 785 };
 786
 787 subtest 'get_marc_notes() UNIMARC tests' => sub {
 788     plan tests => 3;
 789
 790     $schema->storage->txn_begin;
 791
 792     t::lib::Mocks::mock_preference( 'NotesToHide', '310' );
 793     t::lib::Mocks::mock_preference( 'marcflavour', 'UNIMARC' );
 794
 795     my $biblio = $builder->build_sample_biblio;
 796     my $record = $biblio->metadata->record;
 797     $record->append_fields(
 798         MARC::Field->new( '300', '', '', a => 'Note1' ),
 799         MARC::Field->new( '300', '', '', a => 'Note2' ),
 800         MARC::Field->new( '310', '', '', a => 'Note3 skipped' ),
 801     );
 802     C4::Biblio::ModBiblio( $record, $biblio->biblionumber );
 803     $biblio = Koha::Biblios->find( $biblio->biblionumber);
 804     my $notes = $biblio->get_marc_notes({ marcflavour => 'UNIMARC' });
 805     is( $notes->[0]->{marcnote}, 'Note1', 'First note' );
 806     is( $notes->[1]->{marcnote}, 'Note2', 'Second note' );
 807     is( @$notes, 2, 'No more notes' );
 808
 809     t::lib::Mocks::mock_preference( 'marcflavour', 'MARC21' );
 810     $schema->storage->txn_rollback;
 811 };
 812
 813 subtest 'host_items() tests' => sub {
 814     plan tests => 7;
 815
 816     $schema->storage->txn_begin;
 817
 818     my $biblio = $builder->build_sample_biblio( { frameworkcode => '' } );
 819
 820     t::lib::Mocks::mock_preference( 'EasyAnalyticalRecords', 1 );
 821     my $host_items = $biblio->host_items;
 822     is( ref($host_items),   'Koha::Items' );
 823     is( $host_items->count, 0 );
 824
 825     my $item_1 =
 826       $builder->build_sample_item( { biblionumber => $biblio->biblionumber } );
 827     my $host_item_1 = $builder->build_sample_item;
 828     my $host_item_2 = $builder->build_sample_item;
 829
 830     my $record = $biblio->metadata->record;
 831     $record->append_fields(
 832         MARC::Field->new(
 833             '773', '', '',
 834             9 => $host_item_1->itemnumber,
 835             9 => $host_item_2->itemnumber
 836         ),
 837     );
 838     C4::Biblio::ModBiblio( $record, $biblio->biblionumber );
 839     $biblio = $biblio->get_from_storage;
 840     $host_items = $biblio->host_items;
 841     is( $host_items->count, 2 );
 842     is_deeply( [ $host_items->get_column('itemnumber') ],
 843         [ $host_item_1->itemnumber, $host_item_2->itemnumber ] );
 844
 845     t::lib::Mocks::mock_preference( 'EasyAnalyticalRecords', 0 );
 846     $host_items = $biblio->host_items;
 847     is( ref($host_items),   'Koha::Items' );
 848     is( $host_items->count, 0 );
 849
 850     subtest 'test host_items param in items()' => sub {
 851         plan tests => 4;
 852
 853         my $items = $biblio->items;
 854         is( $items->count, 1, "Without host_items param we only get the items on the biblio");
 855         $items = $biblio->items({ host_items => 1 });
 856         is( $items->count, 3, "With param host_items we get the biblio items plus analytics");
 857         is( ref($items), 'Koha::Items', "We correctly get an Items object");
 858         is_deeply( [ $items->get_column('itemnumber') ],
 859             [ $item_1->itemnumber, $host_item_1->itemnumber, $host_item_2->itemnumber ] );
 860     };
 861
 862     $schema->storage->txn_rollback;
 863 };
 864
 865 subtest 'article_requests() tests' => sub {
 866
 867     plan tests => 3;
 868
 869     $schema->storage->txn_begin;
 870
 871     my $item   = $builder->build_sample_item;
 872     my $biblio = $item->biblio;
 873
 874     my $article_requests = $biblio->article_requests;
 875     is( ref($article_requests), 'Koha::ArticleRequests',
 876         'In scalar context, type is correct' );
 877     is( $article_requests->count, 0, 'No article requests' );
 878
 879     foreach my $i ( 0 .. 3 ) {
 880
 881         my $patron = $builder->build_object( { class => 'Koha::Patrons' } );
 882
 883         Koha::ArticleRequest->new(
 884             {
 885                 borrowernumber => $patron->id,
 886                 biblionumber   => $biblio->id,
 887                 itemnumber     => $item->id,
 888                 title          => $biblio->title,
 889             }
 890         )->request;
 891     }
 892
 893     $article_requests = $biblio->article_requests;
 894     is( $article_requests->count, 4, '4 article requests' );
 895
 896     $schema->storage->txn_rollback;
 897 };
 898
 899 subtest 'current_checkouts() and old_checkouts() tests' => sub {
 900
 901     plan tests => 4;
 902
 903     $schema->storage->txn_begin;
 904
 905     my $library = $builder->build_object({ class => 'Koha::Libraries' });
 906
 907     my $patron_1 = $builder->build_object({ class => 'Koha::Patrons' })->unblessed;
 908     my $patron_2 = $builder->build_object({ class => 'Koha::Patrons' })->unblessed;
 909
 910     my $item_1 = $builder->build_sample_item;
 911     my $item_2 = $builder->build_sample_item({ biblionumber => $item_1->biblionumber });
 912
 913     t::lib::Mocks::mock_userenv({ branchcode => $library->id });
 914
 915     AddIssue( $patron_1, $item_1->barcode );
 916     AddIssue( $patron_1, $item_2->barcode );
 917
 918     AddReturn( $item_1->barcode );
 919     AddIssue( $patron_2, $item_1->barcode );
 920
 921     my $biblio = $item_1->biblio;
 922     my $current_checkouts = $biblio->current_checkouts;
 923     my $old_checkouts = $biblio->old_checkouts;
 924
 925     is( ref($current_checkouts), 'Koha::Checkouts', 'Type is correct' );
 926     is( ref($old_checkouts), 'Koha::Old::Checkouts', 'Type is correct' );
 927
 928     is( $current_checkouts->count, 2, 'Count is correct for current checkouts' );
 929     is( $old_checkouts->count, 1, 'Count is correct for old checkouts' );
 930
 931     $schema->storage->txn_rollback;
 932 };
 933
 934 subtest 'get_marc_contributors() tests' => sub {
 935
 936     plan tests => 2;
 937
 938     $schema->storage->txn_begin;
 939
 940     my $biblio = $builder->build_sample_biblio({ author => 'Main author' });
 941     my $record = $biblio->metadata->record;
 942
 943     # add author information
 944     my $field = MARC::Field->new('700','1','','a' => 'Jefferson, Thomas');
 945     $record->append_fields($field);
 946     $field = MARC::Field->new('701','1','','d' => 'Secondary author 2');
 947     $record->append_fields($field);
 948
 949     # get record
 950     C4::Biblio::ModBiblio( $record, $biblio->biblionumber );
 951     $biblio = Koha::Biblios->find( $biblio->biblionumber );
 952
 953     is( @{$biblio->get_marc_authors}, 3, 'get_marc_authors retrieves correct number of author subfields' );
 954     is( @{$biblio->get_marc_contributors}, 2, 'get_marc_contributors retrieves correct number of author subfields' );
 955     $schema->storage->txn_rollback;
 956 };
 957
 958 subtest 'Recalls tests' => sub {
 959
 960     plan tests => 13;
 961
 962     $schema->storage->txn_begin;
 963
 964     my $item1 = $builder->build_sample_item;
 965     my $biblio = $item1->biblio;
 966     my $branchcode = $item1->holdingbranch;
 967     my $patron1 = $builder->build_object({ class => 'Koha::Patrons', value => { branchcode => $branchcode } });
 968     my $patron2 = $builder->build_object({ class => 'Koha::Patrons', value => { branchcode => $branchcode } });
 969     my $patron3 = $builder->build_object({ class => 'Koha::Patrons', value => { branchcode => $branchcode } });
 970     my $item2 = $builder->build_object({ class => 'Koha::Items', value => { holdingbranch => $branchcode, homebranch => $branchcode, biblionumber => $biblio->biblionumber, itype => $item1->effective_itemtype } });
 971     t::lib::Mocks::mock_userenv({ patron => $patron1 });
 972
 973     my $recall1 = Koha::Recall->new(
 974         {   patron_id         => $patron1->borrowernumber,
 975             created_date      => \'NOW()',
 976             biblio_id         => $biblio->biblionumber,
 977             pickup_library_id => $branchcode,
 978             item_id           => $item1->itemnumber,
 979             expiration_date   => undef,
 980             item_level        => 1
 981         }
 982     )->store;
 983     my $recall2 = Koha::Recall->new(
 984         {   patron_id         => $patron2->borrowernumber,
 985             created_date      => \'NOW()',
 986             biblio_id         => $biblio->biblionumber,
 987             pickup_library_id => $branchcode,
 988             item_id           => undef,
 989             expiration_date   => undef,
 990             item_level        => 0
 991         }
 992     )->store;
 993     my $recall3 = Koha::Recall->new(
 994         {   patron_id         => $patron3->borrowernumber,
 995             created_date      => \'NOW()',
 996             biblio_id         => $biblio->biblionumber,
 997             pickup_library_id => $branchcode,
 998             item_id           => $item1->itemnumber,
 999             expiration_date   => undef,
1000             item_level        => 1
1001         }
1002     )->store;
1003
1004     my $recalls = $biblio->recalls;
1005     is( $recalls->count, 3, 'Correctly get number of recalls for biblio' );
1006
1007     $recall1->set_cancelled;
1008     $recall2->set_expired({ interface => 'COMMANDLINE' });
1009
1010     is( $recalls->count, 3, 'Correctly get number of recalls for biblio' );
1011     is( $recalls->filter_by_current->count, 1, 'Correctly get number of active recalls for biblio' );
1012
1013     t::lib::Mocks::mock_preference('UseRecalls', 0);
1014     is( $biblio->can_be_recalled({ patron => $patron1 }), 0, "Can't recall with UseRecalls disabled" );
1015
1016     t::lib::Mocks::mock_preference("UseRecalls", 1);
1017     $item1->update({ notforloan => 1 });
1018     is( $biblio->can_be_recalled({ patron => $patron1 }), 0, "Can't recall with no available items" );
1019
1020     $item1->update({ notforloan => 0 });
1021     Koha::CirculationRules->set_rules({
1022         branchcode => $branchcode,
1023         categorycode => $patron1->categorycode,
1024         itemtype => $item1->effective_itemtype,
1025         rules => {
1026             recalls_allowed => 0,
1027             recalls_per_record => 1,
1028             on_shelf_recalls => 'all',
1029         },
1030     });
1031     is( $biblio->can_be_recalled({ patron => $patron1 }), 0, "Can't recall if recalls_allowed = 0" );
1032
1033     Koha::CirculationRules->set_rules({
1034         branchcode => $branchcode,
1035         categorycode => $patron1->categorycode,
1036         itemtype => $item1->effective_itemtype,
1037         rules => {
1038             recalls_allowed => 1,
1039             recalls_per_record => 1,
1040             on_shelf_recalls => 'all',
1041         },
1042     });
1043     is( $biblio->can_be_recalled({ patron => $patron1 }), 0, "Can't recall if patron has more existing recall(s) than recalls_allowed" );
1044     is( $biblio->can_be_recalled({ patron => $patron1 }), 0, "Can't recall if patron has more existing recall(s) than recalls_per_record" );
1045
1046     $recall1->set_cancelled;
1047     C4::Circulation::AddIssue( $patron1->unblessed, $item2->barcode );
1048     is( $biblio->can_be_recalled({ patron => $patron1 }), 0, "Can't recall if patron has already checked out an item attached to this biblio" );
1049
1050     is( $biblio->can_be_recalled({ patron => $patron1 }), 0, "Can't recall if on_shelf_recalls = all and items are still available" );
1051
1052     Koha::CirculationRules->set_rules({
1053         branchcode => $branchcode,
1054         categorycode => $patron1->categorycode,
1055         itemtype => $item1->effective_itemtype,
1056         rules => {
1057             recalls_allowed => 1,
1058             recalls_per_record => 1,
1059             on_shelf_recalls => 'any',
1060         },
1061     });
1062     C4::Circulation::AddReturn( $item2->barcode, $branchcode );
1063     is( $biblio->can_be_recalled({ patron => $patron1 }), 0, "Can't recall if no items are checked out" );
1064
1065     $recall2->set_cancelled;
1066     C4::Circulation::AddIssue( $patron2->unblessed, $item2->barcode );
1067     C4::Circulation::AddIssue( $patron2->unblessed, $item1->barcode );
1068     is( $biblio->can_be_recalled({ patron => $patron1 }), 2, "Can recall two items" );
1069
1070     $item1->update({ withdrawn => 1 });
1071     is( $biblio->can_be_recalled({ patron => $patron1 }), 1, "Can recall one item" );
1072
1073     $schema->storage->txn_rollback;
1074 };
1075
1076 subtest 'ill_requests() tests' => sub {
1077
1078     plan tests => 3;
1079
1080     $schema->storage->txn_begin;
1081
1082     my $biblio = $builder->build_sample_biblio;
1083
1084     my $rs = $biblio->ill_requests;
1085     is( ref($rs), 'Koha::Illrequests' );
1086     is( $rs->count, 0, 'No linked requests' );
1087
1088     foreach ( 1..10 ) {
1089         $builder->build_object(
1090             {
1091                 class => 'Koha::Illrequests',
1092                 value => { biblio_id => $biblio->id }
1093             }
1094         );
1095     }
1096
1097     is( $biblio->ill_requests->count, 10, 'Linked requests are present' );
1098
1099     $schema->storage->txn_rollback;
1100 };
1101
1102 subtest 'item_groups() tests' => sub {
1103
1104     plan tests => 6;
1105
1106     $schema->storage->txn_begin;
1107
1108     my $biblio = $builder->build_sample_biblio();
1109
1110     my @item_groups = $biblio->item_groups->as_list;
1111     is( scalar(@item_groups), 0, 'Got zero item groups');
1112
1113     my $item_group_1 = Koha::Biblio::ItemGroup->new( { biblio_id => $biblio->id } )->store();
1114
1115     @item_groups = $biblio->item_groups->as_list;
1116     is( scalar(@item_groups), 1, 'Got one item group');
1117     is( $item_groups[0]->id, $item_group_1->id, 'Got correct item group');
1118
1119     my $item_group_2 = Koha::Biblio::ItemGroup->new( { biblio_id => $biblio->id } )->store();
1120
1121     @item_groups = $biblio->item_groups->as_list;
1122     is( scalar(@item_groups), 2, 'Got two item groups');
1123     is( $item_groups[0]->id, $item_group_1->id, 'Got correct item group 1');
1124     is( $item_groups[1]->id, $item_group_2->id, 'Got correct item group 2');
1125
1126     $schema->storage->txn_rollback;
1127 };
1128
1129 sub component_record1 {
1130     my $marc = MARC::Record->new;
1131     $marc->append_fields(
1132         MARC::Field->new( '001', '3456' ),
1133         MARC::Field->new( '245', '', '', a => 'Some title 1' ),
1134         MARC::Field->new( '773', '', '', w => '(FIRST)1234' ),
1135     );
1136     return $marc;
1137 }
1138 sub search_component_record1 {
1139     my @results = ( component_record1()->as_xml() );
1140     return ( undef, { biblioserver => { RECORDS => \@results, hits => 1 } }, 1 );
1141 }
1142
1143 sub search_component_record2 {
1144     my @results;
1145     return ( undef, { biblioserver => { RECORDS => \@results, hits => 0 } }, 0 );
1146 }
1147
1148 sub host_record {
1149     my $marc = MARC::Record->new;
1150     $marc->append_fields(
1151         MARC::Field->new( '001', '1234' ),
1152         MARC::Field->new( '003', 'FIRST' ),
1153         MARC::Field->new( '245', '', '', a => 'Some title' ),
1154     );
1155     return $marc;
1156 }