t/db_dependent/Reserves.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 => 62;
  21 use Test::MockModule;
  22 use Test::Warn;
  23
  24 use t::lib::Mocks;
  25 use t::lib::TestBuilder;
  26
  27 use MARC::Record;
  28 use DateTime::Duration;
  29
  30 use C4::Circulation;
  31 use C4::Items;
  32 use C4::Biblio;
  33 use C4::Members;
  34 use C4::Reserves;
  35 use Koha::Caches;
  36 use Koha::DateUtils;
  37 use Koha::Holds;
  38 use Koha::Items;
  39 use Koha::Libraries;
  40 use Koha::Notice::Templates;
  41 use Koha::Patrons;
  42 use Koha::Patron::Categories;
  43 use Koha::CirculationRules;
  44
  45 BEGIN {
  46     require_ok('C4::Reserves');
  47 }
  48
  49 # Start transaction
  50 my $database = Koha::Database->new();
  51 my $schema = $database->schema();
  52 $schema->storage->txn_begin();
  53 my $dbh = C4::Context->dbh;
  54 $dbh->do('DELETE FROM circulation_rules');
  55
  56 my $builder = t::lib::TestBuilder->new;
  57
  58 my $frameworkcode = q//;
  59
  60
  61 t::lib::Mocks::mock_preference('ReservesNeedReturns', 1);
  62
  63 # Somewhat arbitrary field chosen for age restriction unit tests. Must be added to db before the framework is cached
  64 $dbh->do("update marc_subfield_structure set kohafield='biblioitems.agerestriction' where tagfield='521' and tagsubfield='a' and frameworkcode=?", undef, $frameworkcode);
  65 my $cache = Koha::Caches->get_instance;
  66 $cache->clear_from_cache("MarcStructure-0-$frameworkcode");
  67 $cache->clear_from_cache("MarcStructure-1-$frameworkcode");
  68 $cache->clear_from_cache("default_value_for_mod_marc-");
  69 $cache->clear_from_cache("MarcSubfieldStructure-$frameworkcode");
  70
  71 ## Setup Test
  72 # Add branches
  73 my $branch_1 = $builder->build({ source => 'Branch' })->{ branchcode };
  74 my $branch_2 = $builder->build({ source => 'Branch' })->{ branchcode };
  75 my $branch_3 = $builder->build({ source => 'Branch' })->{ branchcode };
  76 # Add categories
  77 my $category_1 = $builder->build({ source => 'Category' })->{ categorycode };
  78 my $category_2 = $builder->build({ source => 'Category' })->{ categorycode };
  79 # Add an item type
  80 my $itemtype = $builder->build(
  81     { source => 'Itemtype', value => { notforloan => undef } } )->{itemtype};
  82
  83 t::lib::Mocks::mock_userenv({ branchcode => $branch_1 });
  84
  85 my $bibnum = $builder->build_sample_biblio({frameworkcode => $frameworkcode})->biblionumber;
  86
  87 # Create a helper item instance for testing
  88 my $item = $builder->build_sample_item({ biblionumber => $bibnum, library => $branch_1, itype => $itemtype });
  89
  90 my $biblio_with_no_item = $builder->build({
  91     source => 'Biblio'
  92 });
  93
  94
  95 # Modify item; setting barcode.
  96 my $testbarcode = '97531';
  97 $item->barcode($testbarcode)->store; # FIXME We should not hardcode a barcode! Also, what's the purpose of this?
  98
  99 # Create a borrower
 100 my %data = (
 101     firstname =>  'my firstname',
 102     surname => 'my surname',
 103     categorycode => $category_1,
 104     branchcode => $branch_1,
 105 );
 106 Koha::Patron::Categories->find($category_1)->set({ enrolmentfee => 0})->store;
 107 my $borrowernumber = Koha::Patron->new(\%data)->store->borrowernumber;
 108 my $patron = Koha::Patrons->find( $borrowernumber );
 109 my $borrower = $patron->unblessed;
 110 my $biblionumber   = $bibnum;
 111 my $barcode        = $testbarcode;
 112
 113 my $branchcode = Koha::Libraries->search->next->branchcode;
 114
 115 AddReserve(
 116     {
 117         branchcode     => $branchcode,
 118         borrowernumber => $borrowernumber,
 119         biblionumber   => $biblionumber,
 120         priority       => 1,
 121     }
 122 );
 123
 124 my ($status, $reserve, $all_reserves) = CheckReserves($item->itemnumber, $barcode);
 125
 126 is($status, "Reserved", "CheckReserves Test 1");
 127
 128 ok(exists($reserve->{reserve_id}), 'CheckReserves() include reserve_id in its response');
 129
 130 ($status, $reserve, $all_reserves) = CheckReserves($item->itemnumber);
 131 is($status, "Reserved", "CheckReserves Test 2");
 132
 133 ($status, $reserve, $all_reserves) = CheckReserves(undef, $barcode);
 134 is($status, "Reserved", "CheckReserves Test 3");
 135
 136 my $ReservesControlBranch = C4::Context->preference('ReservesControlBranch');
 137 t::lib::Mocks::mock_preference( 'ReservesControlBranch', 'ItemHomeLibrary' );
 138 ok(
 139     'ItemHomeLib' eq GetReservesControlBranch(
 140         { homebranch => 'ItemHomeLib' },
 141         { branchcode => 'PatronHomeLib' }
 142     ), "GetReservesControlBranch returns item home branch when set to ItemHomeLibrary"
 143 );
 144 t::lib::Mocks::mock_preference( 'ReservesControlBranch', 'PatronLibrary' );
 145 ok(
 146     'PatronHomeLib' eq GetReservesControlBranch(
 147         { homebranch => 'ItemHomeLib' },
 148         { branchcode => 'PatronHomeLib' }
 149     ), "GetReservesControlBranch returns patron home branch when set to PatronLibrary"
 150 );
 151 t::lib::Mocks::mock_preference( 'ReservesControlBranch', $ReservesControlBranch );
 152
 153 ###
 154 ### Regression test for bug 10272
 155 ###
 156 my %requesters = ();
 157 $requesters{$branch_1} = Koha::Patron->new({
 158     branchcode   => $branch_1,
 159     categorycode => $category_2,
 160     surname      => "borrower from $branch_1",
 161 })->store->borrowernumber;
 162 for my $i ( 2 .. 5 ) {
 163     $requesters{"CPL$i"} = Koha::Patron->new({
 164         branchcode   => $branch_1,
 165         categorycode => $category_2,
 166         surname      => "borrower $i from $branch_1",
 167     })->store->borrowernumber;
 168 }
 169 $requesters{$branch_2} = Koha::Patron->new({
 170     branchcode   => $branch_2,
 171     categorycode => $category_2,
 172     surname      => "borrower from $branch_2",
 173 })->store->borrowernumber;
 174 $requesters{$branch_3} = Koha::Patron->new({
 175     branchcode   => $branch_3,
 176     categorycode => $category_2,
 177     surname      => "borrower from $branch_3",
 178 })->store->borrowernumber;
 179
 180 # Configure rules so that $branch_1 allows only $branch_1 patrons
 181 # to request its items, while $branch_2 will allow its items
 182 # to fill holds from anywhere.
 183
 184 $dbh->do('DELETE FROM circulation_rules');
 185 Koha::CirculationRules->set_rules(
 186     {
 187         branchcode   => undef,
 188         categorycode => undef,
 189         itemtype     => undef,
 190         rules        => {
 191             reservesallowed => 25,
 192             holds_per_record => 1,
 193         }
 194     }
 195 );
 196
 197 # CPL allows only its own patrons to request its items
 198 Koha::CirculationRules->set_rules(
 199     {
 200         branchcode   => $branch_1,
 201         itemtype     => undef,
 202         rules        => {
 203             holdallowed  => 1,
 204             returnbranch => 'homebranch',
 205         }
 206     }
 207 );
 208
 209 # ... while FPL allows anybody to request its items
 210 Koha::CirculationRules->set_rules(
 211     {
 212         branchcode   => $branch_2,
 213         itemtype     => undef,
 214         rules        => {
 215             holdallowed  => 2,
 216             returnbranch => 'homebranch',
 217         }
 218     }
 219 );
 220
 221 my $bibnum2 = $builder->build_sample_biblio({frameworkcode => $frameworkcode})->biblionumber;
 222
 223 my ($itemnum_cpl, $itemnum_fpl);
 224 $itemnum_cpl = $builder->build_sample_item(
 225     {
 226         biblionumber => $bibnum2,
 227         library      => $branch_1,
 228         barcode      => 'bug10272_CPL',
 229         itype        => $itemtype
 230     }
 231 )->itemnumber;
 232 $itemnum_fpl = $builder->build_sample_item(
 233     {
 234         biblionumber => $bibnum2,
 235         library      => $branch_2,
 236         barcode      => 'bug10272_FPL',
 237         itype        => $itemtype
 238     }
 239 )->itemnumber;
 240
 241 # Ensure that priorities are numbered correcly when a hold is moved to waiting
 242 # (bug 11947)
 243 $dbh->do("DELETE FROM reserves WHERE biblionumber=?",undef,($bibnum2));
 244 AddReserve(
 245     {
 246         branchcode     => $branch_3,
 247         borrowernumber => $requesters{$branch_3},
 248         biblionumber   => $bibnum2,
 249         priority       => 1,
 250     }
 251 );
 252 AddReserve(
 253     {
 254         branchcode     => $branch_2,
 255         borrowernumber => $requesters{$branch_2},
 256         biblionumber   => $bibnum2,
 257         priority       => 2,
 258     }
 259 );
 260 AddReserve(
 261     {
 262         branchcode     => $branch_1,
 263         borrowernumber => $requesters{$branch_1},
 264         biblionumber   => $bibnum2,
 265         priority       => 3,
 266     }
 267 );
 268 ModReserveAffect($itemnum_cpl, $requesters{$branch_3}, 0);
 269
 270 # Now it should have different priorities.
 271 my $biblio = Koha::Biblios->find( $bibnum2 );
 272 my $holds = $biblio->holds({}, { order_by => 'reserve_id' });;
 273 is($holds->next->priority, 0, 'Item is correctly waiting');
 274 is($holds->next->priority, 1, 'Item is correctly priority 1');
 275 is($holds->next->priority, 2, 'Item is correctly priority 2');
 276
 277 my @reserves = Koha::Holds->search({ borrowernumber => $requesters{$branch_3} })->waiting();
 278 is( @reserves, 1, 'GetWaiting got only the waiting reserve' );
 279 is( $reserves[0]->borrowernumber(), $requesters{$branch_3}, 'GetWaiting got the reserve for the correct borrower' );
 280
 281
 282 $dbh->do("DELETE FROM reserves WHERE biblionumber=?",undef,($bibnum2));
 283 AddReserve(
 284     {
 285         branchcode     => $branch_3,
 286         borrowernumber => $requesters{$branch_3},
 287         biblionumber   => $bibnum2,
 288         priority       => 1,
 289     }
 290 );
 291 AddReserve(
 292     {
 293         branchcode     => $branch_2,
 294         borrowernumber => $requesters{$branch_2},
 295         biblionumber   => $bibnum2,
 296         priority       => 2,
 297     }
 298 );
 299
 300 AddReserve(
 301     {
 302         branchcode     => $branch_1,
 303         borrowernumber => $requesters{$branch_1},
 304         biblionumber   => $bibnum2,
 305         priority       => 3,
 306     }
 307 );
 308
 309 # Ensure that the item's home library controls hold policy lookup
 310 t::lib::Mocks::mock_preference( 'ReservesControlBranch', 'ItemHomeLibrary' );
 311
 312 my $messages;
 313 # Return the CPL item at FPL.  The hold that should be triggered is
 314 # the one placed by the CPL patron, as the other two patron's hold
 315 # requests cannot be filled by that item per policy.
 316 (undef, $messages, undef, undef) = AddReturn('bug10272_CPL', $branch_2);
 317 is( $messages->{ResFound}->{borrowernumber},
 318     $requesters{$branch_1},
 319     'restrictive library\'s items only fill requests by own patrons (bug 10272)');
 320
 321 # Return the FPL item at FPL.  The hold that should be triggered is
 322 # the one placed by the RPL patron, as that patron is first in line
 323 # and RPL imposes no restrictions on whose holds its items can fill.
 324
 325 # Ensure that the preference 'LocalHoldsPriority' is not set (Bug 15244):
 326 t::lib::Mocks::mock_preference( 'LocalHoldsPriority', '' );
 327
 328 (undef, $messages, undef, undef) = AddReturn('bug10272_FPL', $branch_2);
 329 is( $messages->{ResFound}->{borrowernumber},
 330     $requesters{$branch_3},
 331     'for generous library, its items fill first hold request in line (bug 10272)');
 332
 333 $biblio = Koha::Biblios->find( $biblionumber );
 334 $holds = $biblio->holds;
 335 is($holds->count, 1, "Only one reserves for this biblio");
 336 $holds->next->reserve_id;
 337
 338 # Tests for bug 9761 (ConfirmFutureHolds): new CheckReserves lookahead parameter, and corresponding change in AddReturn
 339 # Note that CheckReserve uses its lookahead parameter and does not check ConfirmFutureHolds pref (it should be passed if needed like AddReturn does)
 340 # Test 9761a: Add a reserve without date, CheckReserve should return it
 341 $dbh->do("DELETE FROM reserves WHERE biblionumber=?",undef,($bibnum));
 342 AddReserve(
 343     {
 344         branchcode     => $branch_1,
 345         borrowernumber => $requesters{$branch_1},
 346         biblionumber   => $bibnum,
 347         priority       => 1,
 348     }
 349 );
 350 ($status)=CheckReserves($item->itemnumber,undef,undef);
 351 is( $status, 'Reserved', 'CheckReserves returns reserve without lookahead');
 352 ($status)=CheckReserves($item->itemnumber,undef,7);
 353 is( $status, 'Reserved', 'CheckReserves also returns reserve with lookahead');
 354
 355 # Test 9761b: Add a reserve with future date, CheckReserve should not return it
 356 $dbh->do("DELETE FROM reserves WHERE biblionumber=?",undef,($bibnum));
 357 t::lib::Mocks::mock_preference('AllowHoldDateInFuture', 1);
 358 my $resdate= dt_from_string();
 359 $resdate->add_duration(DateTime::Duration->new(days => 4));
 360 $resdate=output_pref($resdate);
 361 my $reserve_id = AddReserve(
 362     {
 363         branchcode       => $branch_1,
 364         borrowernumber   => $requesters{$branch_1},
 365         biblionumber     => $bibnum,
 366         priority         => 1,
 367         reservation_date => $resdate,
 368     }
 369 );
 370 ($status)=CheckReserves($item->itemnumber,undef,undef);
 371 is( $status, '', 'CheckReserves returns no future reserve without lookahead');
 372
 373 # Test 9761c: Add a reserve with future date, CheckReserve should return it if lookahead is high enough
 374 ($status)=CheckReserves($item->itemnumber,undef,3);
 375 is( $status, '', 'CheckReserves returns no future reserve with insufficient lookahead');
 376 ($status)=CheckReserves($item->itemnumber,undef,4);
 377 is( $status, 'Reserved', 'CheckReserves returns future reserve with sufficient lookahead');
 378
 379 # Test 9761d: Check ResFound message of AddReturn for future hold
 380 # Note that AddReturn is in Circulation.pm, but this test really pertains to reserves; AddReturn uses the ConfirmFutureHolds pref when calling CheckReserves
 381 # In this test we do not need an issued item; it is just a 'checkin'
 382 t::lib::Mocks::mock_preference('ConfirmFutureHolds', 0);
 383 (my $doreturn, $messages)= AddReturn('97531',$branch_1);
 384 is($messages->{ResFound}//'', '', 'AddReturn does not care about future reserve when ConfirmFutureHolds is off');
 385 t::lib::Mocks::mock_preference('ConfirmFutureHolds', 3);
 386 ($doreturn, $messages)= AddReturn('97531',$branch_1);
 387 is(exists $messages->{ResFound}?1:0, 0, 'AddReturn ignores future reserve beyond ConfirmFutureHolds days');
 388 t::lib::Mocks::mock_preference('ConfirmFutureHolds', 7);
 389 ($doreturn, $messages)= AddReturn('97531',$branch_1);
 390 is(exists $messages->{ResFound}?1:0, 1, 'AddReturn considers future reserve within ConfirmFutureHolds days');
 391
 392 # End of tests for bug 9761 (ConfirmFutureHolds)
 393
 394 # test marking a hold as captured
 395 my $hold_notice_count = count_hold_print_messages();
 396 ModReserveAffect($item->itemnumber, $requesters{$branch_1}, 0);
 397 my $new_count = count_hold_print_messages();
 398 is($new_count, $hold_notice_count + 1, 'patron notified when item set to waiting');
 399
 400 # test that duplicate notices aren't generated
 401 ModReserveAffect($item->itemnumber, $requesters{$branch_1}, 0);
 402 $new_count = count_hold_print_messages();
 403 is($new_count, $hold_notice_count + 1, 'patron not notified a second time (bug 11445)');
 404
 405 # avoiding the not_same_branch error
 406 t::lib::Mocks::mock_preference('IndependentBranches', 0);
 407 $item = Koha::Items->find($item->itemnumber);
 408 is(
 409     $item->safe_delete,
 410     'book_reserved',
 411     'item that is captured to fill a hold cannot be deleted',
 412 );
 413
 414 my $letter = ReserveSlip( { branchcode => $branch_1, reserve_id => $reserve_id } );
 415 ok(defined($letter), 'can successfully generate hold slip (bug 10949)');
 416
 417 # Tests for bug 9788: Does Koha::Item->current_holds return a future wait?
 418 # 9788a: current_holds does not return future next available hold
 419 $dbh->do("DELETE FROM reserves WHERE biblionumber=?",undef,($bibnum));
 420 t::lib::Mocks::mock_preference('ConfirmFutureHolds', 2);
 421 t::lib::Mocks::mock_preference('AllowHoldDateInFuture', 1);
 422 $resdate= dt_from_string();
 423 $resdate->add_duration(DateTime::Duration->new(days => 2));
 424 $resdate=output_pref($resdate);
 425 AddReserve(
 426     {
 427         branchcode       => $branch_1,
 428         borrowernumber   => $requesters{$branch_1},
 429         biblionumber     => $bibnum,
 430         priority         => 1,
 431         reservation_date => $resdate,
 432     }
 433 );
 434
 435 $holds = $item->current_holds;
 436 my $dtf = Koha::Database->new->schema->storage->datetime_parser;
 437 my $future_holds = $holds->search({ reservedate => { '>' => $dtf->format_date( dt_from_string ) } } );
 438 is( $future_holds->count, 0, 'current_holds does not return a future next available hold');
 439 # 9788b: current_holds does not return future item level hold
 440 $dbh->do("DELETE FROM reserves WHERE biblionumber=?",undef,($bibnum));
 441 AddReserve(
 442     {
 443         branchcode       => $branch_1,
 444         borrowernumber   => $requesters{$branch_1},
 445         biblionumber     => $bibnum,
 446         priority         => 1,
 447         reservation_date => $resdate,
 448         itemnumber       => $item->itemnumber,
 449     }
 450 ); #item level hold
 451 $future_holds = $holds->search({ reservedate => { '>' => $dtf->format_date( dt_from_string ) } } );
 452 is( $future_holds->count, 0, 'current_holds does not return a future item level hold' );
 453 # 9788c: current_holds returns future wait (confirmed future hold)
 454 ModReserveAffect( $item->itemnumber,  $requesters{$branch_1} , 0); #confirm hold
 455 $future_holds = $holds->search({ reservedate => { '>' => $dtf->format_date( dt_from_string ) } } );
 456 is( $future_holds->count, 1, 'current_holds returns a future wait (confirmed future hold)' );
 457 # End of tests for bug 9788
 458
 459 $dbh->do("DELETE FROM reserves WHERE biblionumber=?",undef,($bibnum));
 460 # Tests for CalculatePriority (bug 8918)
 461 my $p = C4::Reserves::CalculatePriority($bibnum2);
 462 is($p, 4, 'CalculatePriority should now return priority 4');
 463 AddReserve(
 464     {
 465         branchcode     => $branch_1,
 466         borrowernumber => $requesters{'CPL2'},
 467         biblionumber   => $bibnum2,
 468         priority       => $p,
 469     }
 470 );
 471 $p = C4::Reserves::CalculatePriority($bibnum2);
 472 is($p, 5, 'CalculatePriority should now return priority 5');
 473 #some tests on bibnum
 474 $dbh->do("DELETE FROM reserves WHERE biblionumber=?",undef,($bibnum));
 475 $p = C4::Reserves::CalculatePriority($bibnum);
 476 is($p, 1, 'CalculatePriority should now return priority 1');
 477 #add a new reserve and confirm it to waiting
 478 AddReserve(
 479     {
 480         branchcode     => $branch_1,
 481         borrowernumber => $requesters{$branch_1},
 482         biblionumber   => $bibnum,
 483         priority       => $p,
 484         itemnumber     => $item->itemnumber,
 485     }
 486 );
 487 $p = C4::Reserves::CalculatePriority($bibnum);
 488 is($p, 2, 'CalculatePriority should now return priority 2');
 489 ModReserveAffect( $item->itemnumber,  $requesters{$branch_1} , 0);
 490 $p = C4::Reserves::CalculatePriority($bibnum);
 491 is($p, 1, 'CalculatePriority should now return priority 1');
 492 #add another biblio hold, no resdate
 493 AddReserve(
 494     {
 495         branchcode     => $branch_1,
 496         borrowernumber => $requesters{'CPL2'},
 497         biblionumber   => $bibnum,
 498         priority       => $p,
 499     }
 500 );
 501 $p = C4::Reserves::CalculatePriority($bibnum);
 502 is($p, 2, 'CalculatePriority should now return priority 2');
 503 #add another future hold
 504 t::lib::Mocks::mock_preference('AllowHoldDateInFuture', 1);
 505 $resdate= dt_from_string();
 506 $resdate->add_duration(DateTime::Duration->new(days => 1));
 507 AddReserve(
 508     {
 509         branchcode     => $branch_1,
 510         borrowernumber => $requesters{'CPL2'},
 511         biblionumber   => $bibnum,
 512         priority       => $p,
 513         reservation_date => output_pref($resdate),
 514     }
 515 );
 516 $p = C4::Reserves::CalculatePriority($bibnum);
 517 is($p, 2, 'CalculatePriority should now still return priority 2');
 518 #calc priority with future resdate
 519 $p = C4::Reserves::CalculatePriority($bibnum, $resdate);
 520 is($p, 3, 'CalculatePriority should now return priority 3');
 521 # End of tests for bug 8918
 522
 523 # Tests for cancel reserves by users from OPAC.
 524 $dbh->do('DELETE FROM reserves', undef, ($bibnum));
 525 AddReserve(
 526     {
 527         branchcode     => $branch_1,
 528         borrowernumber => $requesters{$branch_1},
 529         biblionumber   => $bibnum,
 530         priority       => 1,
 531     }
 532 );
 533 my (undef, $canres, undef) = CheckReserves($item->itemnumber);
 534
 535 is( CanReserveBeCanceledFromOpac(), undef,
 536     'CanReserveBeCanceledFromOpac should return undef if called without any parameter'
 537 );
 538 is(
 539     CanReserveBeCanceledFromOpac( $canres->{resserve_id} ),
 540     undef,
 541     'CanReserveBeCanceledFromOpac should return undef if called without the reserve_id'
 542 );
 543 is(
 544     CanReserveBeCanceledFromOpac( undef, $requesters{CPL} ),
 545     undef,
 546     'CanReserveBeCanceledFromOpac should return undef if called without borrowernumber'
 547 );
 548
 549 my $cancancel = CanReserveBeCanceledFromOpac($canres->{reserve_id}, $requesters{$branch_1});
 550 is($cancancel, 1, 'Can user cancel its own reserve');
 551
 552 $cancancel = CanReserveBeCanceledFromOpac($canres->{reserve_id}, $requesters{$branch_2});
 553 is($cancancel, 0, 'Other user cant cancel reserve');
 554
 555 ModReserveAffect($item->itemnumber, $requesters{$branch_1}, 1);
 556 $cancancel = CanReserveBeCanceledFromOpac($canres->{reserve_id}, $requesters{$branch_1});
 557 is($cancancel, 0, 'Reserve in transfer status cant be canceled');
 558
 559 $dbh->do('DELETE FROM reserves', undef, ($bibnum));
 560 AddReserve(
 561     {
 562         branchcode     => $branch_1,
 563         borrowernumber => $requesters{$branch_1},
 564         biblionumber   => $bibnum,
 565         priority       => 1,
 566     }
 567 );
 568 (undef, $canres, undef) = CheckReserves($item->itemnumber);
 569
 570 ModReserveAffect($item->itemnumber, $requesters{$branch_1}, 0);
 571 $cancancel = CanReserveBeCanceledFromOpac($canres->{reserve_id}, $requesters{$branch_1});
 572 is($cancancel, 0, 'Reserve in waiting status cant be canceled');
 573
 574 # End of tests for bug 12876
 575
 576        ####
 577 ####### Testing Bug 13113 - Prevent juvenile/children from reserving ageRestricted material >>>
 578        ####
 579
 580 t::lib::Mocks::mock_preference( 'AgeRestrictionMarker', 'FSK|PEGI|Age|K' );
 581
 582 #Reserving an not-agerestricted Biblio by a Borrower with no dateofbirth is tested previously.
 583
 584 #Set the ageRestriction for the Biblio
 585 my $record = GetMarcBiblio({ biblionumber =>  $bibnum });
 586 my ( $ageres_tagid, $ageres_subfieldid ) = GetMarcFromKohaField( "biblioitems.agerestriction" );
 587 $record->append_fields(  MARC::Field->new($ageres_tagid, '', '', $ageres_subfieldid => 'PEGI 16')  );
 588 C4::Biblio::ModBiblio( $record, $bibnum, $frameworkcode );
 589
 590 is( C4::Reserves::CanBookBeReserved($borrowernumber, $biblionumber)->{status} , 'OK', "Reserving an ageRestricted Biblio without a borrower dateofbirth succeeds" );
 591
 592 #Set the dateofbirth for the Borrower making them "too young".
 593 $borrower->{dateofbirth} = DateTime->now->add( years => -15 );
 594 Koha::Patrons->find( $borrowernumber )->set({ dateofbirth => $borrower->{dateofbirth} })->store;
 595
 596 is( C4::Reserves::CanBookBeReserved($borrowernumber, $biblionumber)->{status} , 'ageRestricted', "Reserving a 'PEGI 16' Biblio by a 15 year old borrower fails");
 597
 598 #Set the dateofbirth for the Borrower making them "too old".
 599 $borrower->{dateofbirth} = DateTime->now->add( years => -30 );
 600 Koha::Patrons->find( $borrowernumber )->set({ dateofbirth => $borrower->{dateofbirth} })->store;
 601
 602 is( C4::Reserves::CanBookBeReserved($borrowernumber, $biblionumber)->{status} , 'OK', "Reserving a 'PEGI 16' Biblio by a 30 year old borrower succeeds");
 603
 604 is( C4::Reserves::CanBookBeReserved($borrowernumber, $biblio_with_no_item->{biblionumber})->{status} , '', "Biblio with no item. Status is empty");
 605        ####
 606 ####### EO Bug 13113 <<<
 607        ####
 608
 609 ok( C4::Reserves::IsAvailableForItemLevelRequest($item, $patron), "Reserving a book on item level" );
 610
 611 my $pickup_branch = $builder->build({ source => 'Branch' })->{ branchcode };
 612 t::lib::Mocks::mock_preference( 'UseBranchTransferLimits',  '1' );
 613 t::lib::Mocks::mock_preference( 'BranchTransferLimitsType', 'itemtype' );
 614 my $limit = Koha::Item::Transfer::Limit->new(
 615     {
 616         toBranch   => $pickup_branch,
 617         fromBranch => $item->holdingbranch,
 618         itemtype   => $item->effective_itemtype,
 619     }
 620 )->store();
 621 is( C4::Reserves::IsAvailableForItemLevelRequest($item, $patron, $pickup_branch), 0, "Item level request not available due to transfer limit" );
 622 t::lib::Mocks::mock_preference( 'UseBranchTransferLimits',  '0' );
 623
 624 my $categorycode = $borrower->{categorycode};
 625 my $holdingbranch = $item->{holdingbranch};
 626 Koha::CirculationRules->set_rules(
 627     {
 628         categorycode => $categorycode,
 629         itemtype     => $item->effective_itemtype,
 630         branchcode   => $holdingbranch,
 631         rules => {
 632             onshelfholds => 1,
 633         }
 634     }
 635 );
 636
 637 # tests for MoveReserve in relation to ConfirmFutureHolds (BZ 14526)
 638 #   hold from A pos 1, today, no fut holds: MoveReserve should fill it
 639 $dbh->do('DELETE FROM reserves', undef, ($bibnum));
 640 t::lib::Mocks::mock_preference('ConfirmFutureHolds', 0);
 641 t::lib::Mocks::mock_preference('AllowHoldDateInFuture', 1);
 642 AddReserve(
 643     {
 644         branchcode     => $branch_1,
 645         borrowernumber => $borrowernumber,
 646         biblionumber   => $bibnum,
 647         priority       => 1,
 648     }
 649 );
 650 MoveReserve( $item->itemnumber, $borrowernumber );
 651 ($status)=CheckReserves( $item->itemnumber );
 652 is( $status, '', 'MoveReserve filled hold');
 653 #   hold from A waiting, today, no fut holds: MoveReserve should fill it
 654 AddReserve(
 655     {
 656         branchcode     => $branch_1,
 657         borrowernumber => $borrowernumber,
 658         biblionumber   => $bibnum,
 659         priority       => 1,
 660         found          => 'W',
 661     }
 662 );
 663 MoveReserve( $item->itemnumber, $borrowernumber );
 664 ($status)=CheckReserves( $item->itemnumber );
 665 is( $status, '', 'MoveReserve filled waiting hold');
 666 #   hold from A pos 1, tomorrow, no fut holds: not filled
 667 $resdate= dt_from_string();
 668 $resdate->add_duration(DateTime::Duration->new(days => 1));
 669 $resdate=output_pref($resdate);
 670 AddReserve(
 671     {
 672         branchcode     => $branch_1,
 673         borrowernumber => $borrowernumber,
 674         biblionumber   => $bibnum,
 675         priority       => 1,
 676         reservation_date => $resdate,
 677     }
 678 );
 679 MoveReserve( $item->itemnumber, $borrowernumber );
 680 ($status)=CheckReserves( $item->itemnumber, undef, 1 );
 681 is( $status, 'Reserved', 'MoveReserve did not fill future hold');
 682 $dbh->do('DELETE FROM reserves', undef, ($bibnum));
 683 #   hold from A pos 1, tomorrow, fut holds=2: MoveReserve should fill it
 684 t::lib::Mocks::mock_preference('ConfirmFutureHolds', 2);
 685 AddReserve(
 686     {
 687         branchcode     => $branch_1,
 688         borrowernumber => $borrowernumber,
 689         biblionumber   => $bibnum,
 690         priority       => 1,
 691         reservation_date => $resdate,
 692     }
 693 );
 694 MoveReserve( $item->itemnumber, $borrowernumber );
 695 ($status)=CheckReserves( $item->itemnumber, undef, 2 );
 696 is( $status, '', 'MoveReserve filled future hold now');
 697 #   hold from A waiting, tomorrow, fut holds=2: MoveReserve should fill it
 698 AddReserve(
 699     {
 700         branchcode     => $branch_1,
 701         borrowernumber => $borrowernumber,
 702         biblionumber   => $bibnum,
 703         priority       => 1,
 704         reservation_date => $resdate,
 705     }
 706 );
 707 MoveReserve( $item->itemnumber, $borrowernumber );
 708 ($status)=CheckReserves( $item->itemnumber, undef, 2 );
 709 is( $status, '', 'MoveReserve filled future waiting hold now');
 710 #   hold from A pos 1, today+3, fut holds=2: MoveReserve should not fill it
 711 $resdate= dt_from_string();
 712 $resdate->add_duration(DateTime::Duration->new(days => 3));
 713 $resdate=output_pref($resdate);
 714 AddReserve(
 715     {
 716         branchcode     => $branch_1,
 717         borrowernumber => $borrowernumber,
 718         biblionumber   => $bibnum,
 719         priority       => 1,
 720         reservation_date => $resdate,
 721     }
 722 );
 723 MoveReserve( $item->itemnumber, $borrowernumber );
 724 ($status)=CheckReserves( $item->itemnumber, undef, 3 );
 725 is( $status, 'Reserved', 'MoveReserve did not fill future hold of 3 days');
 726 $dbh->do('DELETE FROM reserves', undef, ($bibnum));
 727
 728 $cache->clear_from_cache("MarcStructure-0-$frameworkcode");
 729 $cache->clear_from_cache("MarcStructure-1-$frameworkcode");
 730 $cache->clear_from_cache("default_value_for_mod_marc-");
 731 $cache->clear_from_cache("MarcSubfieldStructure-$frameworkcode");
 732
 733 subtest '_koha_notify_reserve() tests' => sub {
 734
 735     plan tests => 2;
 736
 737     my $wants_hold_and_email = {
 738         wants_digest => '0',
 739         transports => {
 740             sms => 'HOLD',
 741             email => 'HOLD',
 742             },
 743         letter_code => 'HOLD'
 744     };
 745
 746     my $mp = Test::MockModule->new( 'C4::Members::Messaging' );
 747
 748     $mp->mock("GetMessagingPreferences",$wants_hold_and_email);
 749
 750     $dbh->do('DELETE FROM letter');
 751
 752     my $email_hold_notice = $builder->build({
 753             source => 'Letter',
 754             value => {
 755                 message_transport_type => 'email',
 756                 branchcode => '',
 757                 code => 'HOLD',
 758                 module => 'reserves',
 759                 lang => 'default',
 760             }
 761         });
 762
 763     my $sms_hold_notice = $builder->build({
 764             source => 'Letter',
 765             value => {
 766                 message_transport_type => 'sms',
 767                 branchcode => '',
 768                 code => 'HOLD',
 769                 module => 'reserves',
 770                 lang=>'default',
 771             }
 772         });
 773
 774     my $hold_borrower = $builder->build({
 775             source => 'Borrower',
 776             value => {
 777                 smsalertnumber=>'5555555555',
 778                 email=>'a@b.com',
 779             }
 780         })->{borrowernumber};
 781
 782     C4::Reserves::AddReserve(
 783         {
 784             branchcode     => $item->homebranch,
 785             borrowernumber => $hold_borrower,
 786             biblionumber   => $item->biblionumber,
 787         }
 788     );
 789
 790     ModReserveAffect($item->itemnumber, $hold_borrower, 0);
 791     my $sms_message_address = $schema->resultset('MessageQueue')->search({
 792             letter_code     => 'HOLD',
 793             message_transport_type => 'sms',
 794             borrowernumber => $hold_borrower,
 795         })->next()->to_address();
 796     is($sms_message_address, undef ,"We should not populate the sms message with the sms number, sending will do so");
 797
 798     my $email_message_address = $schema->resultset('MessageQueue')->search({
 799             letter_code     => 'HOLD',
 800             message_transport_type => 'email',
 801             borrowernumber => $hold_borrower,
 802         })->next()->to_address();
 803     is($email_message_address, undef ,"We should not populate the hold message with the email address, sending will do so");
 804
 805 };
 806
 807 subtest 'ReservesNeedReturns' => sub {
 808     plan tests => 18;
 809
 810     my $library    = $builder->build_object( { class => 'Koha::Libraries' } );
 811     my $item_info  = {
 812         homebranch       => $library->branchcode,
 813         holdingbranch    => $library->branchcode,
 814     };
 815     my $item = $builder->build_sample_item($item_info);
 816     my $patron   = $builder->build_object(
 817         {
 818             class => 'Koha::Patrons',
 819             value => { branchcode => $library->branchcode, }
 820         }
 821     );
 822     my $patron_2   = $builder->build_object(
 823         {
 824             class => 'Koha::Patrons',
 825             value => { branchcode => $library->branchcode, }
 826         }
 827     );
 828
 829     my $priority = 1;
 830
 831     t::lib::Mocks::mock_preference('ReservesNeedReturns', 1); # Test with feature disabled
 832     my $hold = place_item_hold( $patron, $item, $library, $priority );
 833     is( $hold->priority, $priority, 'If ReservesNeedReturns is 1, priority must not have been set to changed' );
 834     is( $hold->found, undef, 'If ReservesNeedReturns is 1, found must not have been set waiting' );
 835     $hold->delete;
 836
 837     t::lib::Mocks::mock_preference('ReservesNeedReturns', 0); # '0' means 'Automatically mark a hold as found and waiting'
 838     $hold = place_item_hold( $patron, $item, $library, $priority );
 839     is( $hold->priority, 0, 'If ReservesNeedReturns is 0 and no other status, priority must have been set to 0' );
 840     is( $hold->found, 'W', 'If ReservesNeedReturns is 0 and no other status, found must have been set waiting' );
 841     $hold->delete;
 842
 843     $item->onloan('2010-01-01')->store;
 844     $hold = place_item_hold( $patron, $item, $library, $priority );
 845     is( $hold->priority, 1, 'If ReservesNeedReturns is 0 but item onloan priority must be set to 1' );
 846     $hold->delete;
 847
 848     t::lib::Mocks::mock_preference('AllowHoldsOnDamagedItems', 0); # '0' means damaged holds not allowed
 849     $item->onloan(undef)->damaged(1)->store;
 850     $hold = place_item_hold( $patron, $item, $library, $priority );
 851     is( $hold->priority, 1, 'If ReservesNeedReturns is 0 but item damaged and not allowed holds on damaged items priority must be set to 1' );
 852     $hold->delete;
 853     t::lib::Mocks::mock_preference('AllowHoldsOnDamagedItems', 1); # '0' means damaged holds not allowed
 854     $hold = place_item_hold( $patron, $item, $library, $priority );
 855     is( $hold->priority, 0, 'If ReservesNeedReturns is 0 and damaged holds allowed, priority must have been set to 0' );
 856     is( $hold->found,  'W', 'If ReservesNeedReturns is 0 and damaged holds allowed, found must have been set waiting' );
 857     $hold->delete;
 858
 859     my $hold_1 = place_item_hold( $patron, $item, $library, $priority );
 860     is( $hold_1->found,  'W', 'First hold on item is set to waiting with ReservesNeedReturns set to 0' );
 861     is( $hold_1->priority, 0, 'First hold on item is set to waiting with ReservesNeedReturns set to 0' );
 862     $hold = place_item_hold( $patron_2, $item, $library, $priority );
 863     is( $hold->priority, 1, 'If ReservesNeedReturns is 0 but item already on hold priority must be set to 1' );
 864     $hold->delete;
 865     $hold_1->delete;
 866
 867     my $transfer = $builder->build_object({
 868         class => "Koha::Item::Transfers",
 869         value => {
 870           itemnumber  => $item->itemnumber,
 871           datearrived => undef,
 872         }
 873     });
 874     $item->damaged(0)->store;
 875     $hold = place_item_hold( $patron, $item, $library, $priority );
 876     is( $hold->found, undef, 'If ReservesNeedReturns is 0 but item in transit the hold must not be set to waiting' );
 877     is( $hold->priority, 1,  'If ReservesNeedReturns is 0 but item in transit the hold must not be set to waiting' );
 878     $hold->delete;
 879     $transfer->delete;
 880
 881     $hold = place_item_hold( $patron, $item, $library, $priority );
 882     is( $hold->priority, 0, 'If ReservesNeedReturns is 0 and no other status, priority must have been set to 0' );
 883     is( $hold->found, 'W', 'If ReservesNeedReturns is 0 and no other status, found must have been set waiting' );
 884     $hold_1 = place_item_hold( $patron, $item, $library, $priority );
 885     is( $hold_1->priority, 1, 'If ReservesNeedReturns is 0 but item has a hold priority is 1' );
 886     $hold_1->suspend(1)->store; # We suspend the hold
 887     $hold->delete; # Delete the waiting hold
 888     $hold = place_item_hold( $patron, $item, $library, $priority );
 889     is( $hold->priority, 0, 'If ReservesNeedReturns is 0 and other hold(s) suspended, priority must have been set to 0' );
 890     is( $hold->found, 'W', 'If ReservesNeedReturns is 0 and other  hold(s) suspended, found must have been set waiting' );
 891
 892
 893
 894
 895     t::lib::Mocks::mock_preference('ReservesNeedReturns', 1); # Don't affect other tests
 896 };
 897
 898 subtest 'ChargeReserveFee tests' => sub {
 899
 900     plan tests => 8;
 901
 902     my $library = $builder->build_object({ class => 'Koha::Libraries' });
 903     my $patron  = $builder->build_object({ class => 'Koha::Patrons' });
 904
 905     my $fee   = 20;
 906     my $title = 'A title';
 907
 908     my $context = Test::MockModule->new('C4::Context');
 909     $context->mock( userenv => { branch => $library->id } );
 910
 911     my $line = C4::Reserves::ChargeReserveFee( $patron->id, $fee, $title );
 912
 913     is( ref($line), 'Koha::Account::Line' , 'Returns a Koha::Account::Line object');
 914     ok( $line->is_debit, 'Generates a debit line' );
 915     is( $line->debit_type_code, 'RESERVE' , 'generates RESERVE debit_type');
 916     is( $line->borrowernumber, $patron->id , 'generated line belongs to the passed patron');
 917     is( $line->amount, $fee , 'amount set correctly');
 918     is( $line->amountoutstanding, $fee , 'amountoutstanding set correctly');
 919     is( $line->description, "$title" , 'description is title of reserved item');
 920     is( $line->branchcode, $library->id , "Library id is picked from userenv and stored correctly" );
 921 };
 922
 923 subtest 'reserves.item_level_hold' => sub {
 924     plan tests => 2;
 925
 926     my $item   = $builder->build_sample_item;
 927     my $patron = $builder->build_object(
 928         {
 929             class => 'Koha::Patrons',
 930             value => { branchcode => $item->homebranch }
 931         }
 932     );
 933
 934     subtest 'item level hold' => sub {
 935         plan tests => 2;
 936         my $reserve_id = AddReserve(
 937             {
 938                 branchcode     => $item->homebranch,
 939                 borrowernumber => $patron->borrowernumber,
 940                 biblionumber   => $item->biblionumber,
 941                 priority       => 1,
 942                 itemnumber     => $item->itemnumber,
 943             }
 944         );
 945
 946         my $hold = Koha::Holds->find($reserve_id);
 947         is( $hold->item_level_hold, 1, 'item_level_hold should be set when AddReserve is called with a specific item' );
 948
 949         # Mark it waiting
 950         ModReserveAffect( $item->itemnumber, $patron->borrowernumber, 1 );
 951
 952         # Revert the waiting status
 953         C4::Reserves::RevertWaitingStatus(
 954             { itemnumber => $item->itemnumber } );
 955
 956         $hold = Koha::Holds->find($reserve_id);
 957
 958         is( $hold->itemnumber, $item->itemnumber, 'Itemnumber should not be removed when the waiting status is revert' );
 959
 960         $hold->delete;    # cleanup
 961     };
 962
 963     subtest 'biblio level hold' => sub {
 964         plan tests => 3;
 965         my $reserve_id = AddReserve(
 966             {
 967                 branchcode     => $item->homebranch,
 968                 borrowernumber => $patron->borrowernumber,
 969                 biblionumber   => $item->biblionumber,
 970                 priority       => 1,
 971             }
 972         );
 973
 974         my $hold = Koha::Holds->find($reserve_id);
 975         is( $hold->item_level_hold, 0, 'item_level_hold should not be set when AddReserve is called without a specific item' );
 976
 977         # Mark it waiting
 978         ModReserveAffect( $item->itemnumber, $patron->borrowernumber, 1 );
 979
 980         $hold = Koha::Holds->find($reserve_id);
 981         is( $hold->itemnumber, $item->itemnumber, 'Itemnumber should be set on hold confirmation' );
 982
 983         # Revert the waiting status
 984         C4::Reserves::RevertWaitingStatus( { itemnumber => $item->itemnumber } );
 985
 986         $hold = Koha::Holds->find($reserve_id);
 987         is( $hold->itemnumber, undef, 'Itemnumber should be removed when the waiting status is revert' );
 988
 989         $hold->delete;
 990     };
 991
 992 };
 993
 994 subtest 'MoveReserve additional test' => sub {
 995
 996     plan tests => 4;
 997
 998     # Create the items and patrons we need
 999     my $biblio = $builder->build_sample_biblio();
1000     my $itype = $builder->build_object({ class => "Koha::ItemTypes", value => { notforloan => 0 } });
1001     my $item_1 = $builder->build_sample_item({ biblionumber => $biblio->biblionumber,notforloan => 0, itype => $itype->itemtype });
1002     my $item_2 = $builder->build_sample_item({ biblionumber => $biblio->biblionumber, notforloan => 0, itype => $itype->itemtype });
1003     my $patron_1 = $builder->build_object({ class => "Koha::Patrons" });
1004     my $patron_2 = $builder->build_object({ class => "Koha::Patrons" });
1005
1006     # Place a hold on the title for both patrons
1007     my $reserve_1 = AddReserve(
1008         {
1009             branchcode     => $item_1->homebranch,
1010             borrowernumber => $patron_1->borrowernumber,
1011             biblionumber   => $biblio->biblionumber,
1012             priority       => 1,
1013             itemnumber     => $item_1->itemnumber,
1014         }
1015     );
1016     my $reserve_2 = AddReserve(
1017         {
1018             branchcode     => $item_2->homebranch,
1019             borrowernumber => $patron_2->borrowernumber,
1020             biblionumber   => $biblio->biblionumber,
1021             priority       => 1,
1022             itemnumber     => $item_1->itemnumber,
1023         }
1024     );
1025     is($patron_1->holds->next()->reserve_id, $reserve_1, "The 1st patron has a hold");
1026     is($patron_2->holds->next()->reserve_id, $reserve_2, "The 2nd patron has a hold");
1027
1028     # Fake the holds queue
1029     $dbh->do(q{INSERT INTO hold_fill_targets VALUES (?, ?, ?, ?, ?)},undef,($patron_1->borrowernumber,$biblio->biblionumber,$item_1->itemnumber,$item_1->homebranch,0));
1030
1031     # The 2nd hold should be filed even if the item is preselected for the first hold
1032     MoveReserve($item_1->itemnumber,$patron_2->borrowernumber);
1033     is($patron_2->holds->count, 0, "The 2nd patrons no longer has a hold");
1034     is($patron_2->old_holds->next()->reserve_id, $reserve_2, "The 2nd patrons hold was filled and moved to old holds");
1035
1036 };
1037
1038 sub count_hold_print_messages {
1039     my $message_count = $dbh->selectall_arrayref(q{
1040         SELECT COUNT(*)
1041         FROM message_queue
1042         WHERE letter_code = 'HOLD'
1043         AND   message_transport_type = 'print'
1044     });
1045     return $message_count->[0]->[0];
1046 }
1047
1048 sub place_item_hold {
1049     my ($patron,$item,$library,$priority) = @_;
1050
1051     my $hold_id = C4::Reserves::AddReserve(
1052         {
1053             branchcode     => $library->branchcode,
1054             borrowernumber => $patron->borrowernumber,
1055             biblionumber   => $item->biblionumber,
1056             priority       => $priority,
1057             title          => "title for fee",
1058             itemnumber     => $item->itemnumber,
1059         }
1060     );
1061
1062     my $hold = Koha::Holds->find($hold_id);
1063     return $hold;
1064 }
1065
1066 # we reached the finish
1067 $schema->storage->txn_rollback();