t/db_dependent/Holds.t

   1 #!/usr/bin/perl
   2
   3 use Modern::Perl;
   4
   5 use t::lib::Mocks;
   6 use t::lib::TestBuilder;
   7
   8 use C4::Context;
   9
  10 use Test::More tests => 65;
  11 use MARC::Record;
  12
  13 use C4::Biblio;
  14 use C4::Calendar;
  15 use C4::Items;
  16 use C4::Reserves;
  17
  18 use Koha::Biblios;
  19 use Koha::CirculationRules;
  20 use Koha::Database;
  21 use Koha::DateUtils qw( dt_from_string output_pref );
  22 use Koha::Holds;
  23 use Koha::Item::Transfer::Limits;
  24 use Koha::Items;
  25 use Koha::Libraries;
  26 use Koha::Library::Groups;
  27 use Koha::Patrons;
  28
  29 BEGIN {
  30     use FindBin;
  31     use lib $FindBin::Bin;
  32 }
  33
  34 my $schema  = Koha::Database->new->schema;
  35 $schema->storage->txn_begin;
  36
  37 my $builder = t::lib::TestBuilder->new();
  38 my $dbh     = C4::Context->dbh;
  39
  40 # Create two random branches
  41 my $branch_1 = $builder->build({ source => 'Branch' })->{ branchcode };
  42 my $branch_2 = $builder->build({ source => 'Branch' })->{ branchcode };
  43
  44 my $category = $builder->build({ source => 'Category' });
  45
  46 my $borrowers_count = 5;
  47
  48 $dbh->do('DELETE FROM itemtypes');
  49 $dbh->do('DELETE FROM reserves');
  50 $dbh->do('DELETE FROM circulation_rules');
  51 my $insert_sth = $dbh->prepare('INSERT INTO itemtypes (itemtype) VALUES (?)');
  52 $insert_sth->execute('CAN');
  53 $insert_sth->execute('CANNOT');
  54 $insert_sth->execute('DUMMY');
  55 $insert_sth->execute('ONLY1');
  56
  57 # Setup Test------------------------
  58 my $biblio = $builder->build_sample_biblio({ itemtype => 'DUMMY' });
  59
  60 # Create item instance for testing.
  61 my $itemnumber = $builder->build_sample_item({ library => $branch_1, biblionumber => $biblio->biblionumber })->itemnumber;
  62
  63 # Create some borrowers
  64 my @borrowernumbers;
  65 foreach (1..$borrowers_count) {
  66     my $borrowernumber = Koha::Patron->new({
  67         firstname =>  'my firstname',
  68         surname => 'my surname ' . $_,
  69         categorycode => $category->{categorycode},
  70         branchcode => $branch_1,
  71     })->store->borrowernumber;
  72     push @borrowernumbers, $borrowernumber;
  73 }
  74
  75 # Create five item level holds
  76 foreach my $borrowernumber ( @borrowernumbers ) {
  77     AddReserve(
  78         {
  79             branchcode     => $branch_1,
  80             borrowernumber => $borrowernumber,
  81             biblionumber   => $biblio->biblionumber,
  82             priority       => C4::Reserves::CalculatePriority( $biblio->biblionumber ),
  83             itemnumber     => $itemnumber,
  84         }
  85     );
  86 }
  87
  88 my $holds = $biblio->holds;
  89 is( $holds->count, $borrowers_count, 'Test GetReserves()' );
  90 is( $holds->next->priority, 1, "Reserve 1 has a priority of 1" );
  91 is( $holds->next->priority, 2, "Reserve 2 has a priority of 2" );
  92 is( $holds->next->priority, 3, "Reserve 3 has a priority of 3" );
  93 is( $holds->next->priority, 4, "Reserve 4 has a priority of 4" );
  94 is( $holds->next->priority, 5, "Reserve 5 has a priority of 5" );
  95
  96 my $item = Koha::Items->find( $itemnumber );
  97 $holds = $item->current_holds;
  98 my $first_hold = $holds->next;
  99 my $reservedate = $first_hold->reservedate;
 100 my $borrowernumber = $first_hold->borrowernumber;
 101 my $branch_1code = $first_hold->branchcode;
 102 my $reserve_id = $first_hold->reserve_id;
 103 is( $reservedate, output_pref({ dt => dt_from_string, dateformat => 'iso', dateonly => 1 }), "holds_placed_today should return a valid reserve date");
 104 is( $borrowernumber, $borrowernumbers[0], "holds_placed_today should return a valid borrowernumber");
 105 is( $branch_1code, $branch_1, "holds_placed_today should return a valid branchcode");
 106 ok($reserve_id, "Test holds_placed_today()");
 107
 108 my $hold = Koha::Holds->find( $reserve_id );
 109 ok( $hold, "Koha::Holds found the hold" );
 110 my $hold_biblio = $hold->biblio();
 111 ok( $hold_biblio, "Got biblio using biblio() method" );
 112 ok( $hold_biblio == $hold->biblio(), "biblio method returns stashed biblio" );
 113 my $hold_item = $hold->item();
 114 ok( $hold_item, "Got item using item() method" );
 115 ok( $hold_item == $hold->item(), "item method returns stashed item" );
 116 my $hold_branch = $hold->branch();
 117 ok( $hold_branch, "Got branch using branch() method" );
 118 ok( $hold_branch == $hold->branch(), "branch method returns stashed branch" );
 119 my $hold_found = $hold->found();
 120 $hold->set({ found => 'W'})->store();
 121 is( Koha::Holds->waiting()->count(), 1, "Koha::Holds->waiting returns waiting holds" );
 122 is( Koha::Holds->unfilled()->count(), 4, "Koha::Holds->unfilled returns unfilled holds" );
 123
 124 my $patron = Koha::Patrons->find( $borrowernumbers[0] );
 125 $holds = $patron->holds;
 126 is( $holds->next->borrowernumber, $borrowernumbers[0], "Test Koha::Patron->holds");
 127
 128
 129 $holds = $item->current_holds;
 130 $first_hold = $holds->next;
 131 $borrowernumber = $first_hold->borrowernumber;
 132 $branch_1code = $first_hold->branchcode;
 133 $reserve_id = $first_hold->reserve_id;
 134
 135 ModReserve({
 136     reserve_id    => $reserve_id,
 137     rank          => '4',
 138     branchcode    => $branch_1,
 139     itemnumber    => $itemnumber,
 140     suspend_until => output_pref( { dt => dt_from_string( "2013-01-01", "iso" ), dateonly => 1 } ),
 141 });
 142
 143 $hold = Koha::Holds->find( $reserve_id );
 144 ok( $hold->priority eq '4', "Test ModReserve, priority changed correctly" );
 145 ok( $hold->suspend, "Test ModReserve, suspend hold" );
 146 is( $hold->suspend_until, '2013-01-01 00:00:00', "Test ModReserve, suspend until date" );
 147
 148 ModReserve({ # call without reserve_id
 149     rank          => '3',
 150     biblionumber  => $biblio->biblionumber,
 151     itemnumber    => $itemnumber,
 152     borrowernumber => $borrowernumber,
 153 });
 154 $hold = Koha::Holds->find( $reserve_id );
 155 ok( $hold->priority eq '3', "Test ModReserve, priority changed correctly" );
 156
 157 ToggleSuspend( $reserve_id );
 158 $hold = Koha::Holds->find( $reserve_id );
 159 ok( ! $hold->suspend, "Test ToggleSuspend(), no date" );
 160
 161 ToggleSuspend( $reserve_id, '2012-01-01' );
 162 $hold = Koha::Holds->find( $reserve_id );
 163 is( $hold->suspend_until, '2012-01-01 00:00:00', "Test ToggleSuspend(), with date" );
 164
 165 AutoUnsuspendReserves();
 166 $hold = Koha::Holds->find( $reserve_id );
 167 ok( ! $hold->suspend, "Test AutoUnsuspendReserves()" );
 168
 169 SuspendAll(
 170     borrowernumber => $borrowernumber,
 171     biblionumber   => $biblio->biblionumber,
 172     suspend => 1,
 173     suspend_until => '2012-01-01',
 174 );
 175 $hold = Koha::Holds->find( $reserve_id );
 176 is( $hold->suspend, 1, "Test SuspendAll()" );
 177 is( $hold->suspend_until, '2012-01-01 00:00:00', "Test SuspendAll(), with date" );
 178
 179 SuspendAll(
 180     borrowernumber => $borrowernumber,
 181     biblionumber   => $biblio->biblionumber,
 182     suspend => 0,
 183 );
 184 $hold = Koha::Holds->find( $reserve_id );
 185 is( $hold->suspend, 0, "Test resuming with SuspendAll()" );
 186 is( $hold->suspend_until, undef, "Test resuming with SuspendAll(), should have no suspend until date" );
 187
 188 # Add a new hold for the borrower whose hold we canceled earlier, this time at the bib level
 189     AddReserve(
 190         {
 191             branchcode     => $branch_1,
 192             borrowernumber => $borrowernumbers[0],
 193             biblionumber   => $biblio->biblionumber,
 194         }
 195     );
 196
 197 $patron = Koha::Patrons->find( $borrowernumber );
 198 $holds = $patron->holds;
 199 my $reserveid = Koha::Holds->search({ biblionumber => $biblio->biblionumber, borrowernumber => $borrowernumbers[0] })->next->reserve_id;
 200 ModReserveMinusPriority( $itemnumber, $reserveid );
 201 $holds = $patron->holds;
 202 is( $holds->next->itemnumber, $itemnumber, "Test ModReserveMinusPriority()" );
 203
 204 $holds = $biblio->holds;
 205 $hold = $holds->next;
 206 AlterPriority( 'top', $hold->reserve_id, undef, 2, 1, 6 );
 207 $hold = Koha::Holds->find( $reserveid );
 208 is( $hold->priority, '1', "Test AlterPriority(), move to top" );
 209
 210 AlterPriority( 'down', $hold->reserve_id, undef, 2, 1, 6 );
 211 $hold = Koha::Holds->find( $reserveid );
 212 is( $hold->priority, '2', "Test AlterPriority(), move down" );
 213
 214 AlterPriority( 'up', $hold->reserve_id, 1, 3, 1, 6 );
 215 $hold = Koha::Holds->find( $reserveid );
 216 is( $hold->priority, '1', "Test AlterPriority(), move up" );
 217
 218 AlterPriority( 'bottom', $hold->reserve_id, undef, 2, 1, 6 );
 219 $hold = Koha::Holds->find( $reserveid );
 220 is( $hold->priority, '6', "Test AlterPriority(), move to bottom" );
 221
 222 # Regression test for bug 2394
 223 #
 224 # If IndependentBranches is ON and canreservefromotherbranches is OFF,
 225 # a patron is not permittedo to request an item whose homebranch (i.e.,
 226 # owner of the item) is different from the patron's own library.
 227 # However, if canreservefromotherbranches is turned ON, the patron can
 228 # create such hold requests.
 229 #
 230 # Note that canreservefromotherbranches has no effect if
 231 # IndependentBranches is OFF.
 232
 233 my $foreign_biblio = $builder->build_sample_biblio({ itemtype => 'DUMMY' });
 234 my $foreign_itemnumber = $builder->build_sample_item({ library => $branch_2, biblionumber => $foreign_biblio->biblionumber })->itemnumber;
 235 Koha::CirculationRules->set_rules(
 236     {
 237         categorycode => undef,
 238         branchcode   => undef,
 239         itemtype     => undef,
 240         rules        => {
 241             reservesallowed  => 25,
 242             holds_per_record => 99,
 243         }
 244     }
 245 );
 246 Koha::CirculationRules->set_rules(
 247     {
 248         categorycode => undef,
 249         branchcode   => undef,
 250         itemtype     => 'CANNOT',
 251         rules        => {
 252             reservesallowed  => 0,
 253             holds_per_record => 99,
 254         }
 255     }
 256 );
 257
 258 # make sure some basic sysprefs are set
 259 t::lib::Mocks::mock_preference('ReservesControlBranch', 'ItemHomeLibrary');
 260 t::lib::Mocks::mock_preference('item-level_itypes', 1);
 261
 262 # if IndependentBranches is OFF, a $branch_1 patron can reserve an $branch_2 item
 263 t::lib::Mocks::mock_preference('IndependentBranches', 0);
 264
 265 is(
 266     CanItemBeReserved($borrowernumbers[0], $foreign_itemnumber)->{status}, 'OK',
 267     '$branch_1 patron allowed to reserve $branch_2 item with IndependentBranches OFF (bug 2394)'
 268 );
 269
 270 # if IndependentBranches is OFF, a $branch_1 patron cannot reserve an $branch_2 item
 271 t::lib::Mocks::mock_preference('IndependentBranches', 1);
 272 t::lib::Mocks::mock_preference('canreservefromotherbranches', 0);
 273 ok(
 274     CanItemBeReserved($borrowernumbers[0], $foreign_itemnumber)->{status} eq 'cannotReserveFromOtherBranches',
 275     '$branch_1 patron NOT allowed to reserve $branch_2 item with IndependentBranches ON ... (bug 2394)'
 276 );
 277
 278 # ... unless canreservefromotherbranches is ON
 279 t::lib::Mocks::mock_preference('canreservefromotherbranches', 1);
 280 ok(
 281     CanItemBeReserved($borrowernumbers[0], $foreign_itemnumber)->{status} eq 'OK',
 282     '... unless canreservefromotherbranches is ON (bug 2394)'
 283 );
 284
 285 {
 286     # Regression test for bug 11336 # Test if ModReserve correctly recalculate the priorities
 287     $biblio = $builder->build_sample_biblio({ itemtype => 'DUMMY' });
 288     $itemnumber = $builder->build_sample_item({ library => $branch_1, biblionumber => $biblio->biblionumber })->itemnumber;
 289     my $reserveid1 = AddReserve(
 290         {
 291             branchcode     => $branch_1,
 292             borrowernumber => $borrowernumbers[0],
 293             biblionumber   => $biblio->biblionumber,
 294             priority       => 1
 295         }
 296     );
 297
 298     $itemnumber = $builder->build_sample_item({ library => $branch_1, biblionumber => $biblio->biblionumber })->itemnumber;
 299     my $reserveid2 = AddReserve(
 300         {
 301             branchcode     => $branch_1,
 302             borrowernumber => $borrowernumbers[1],
 303             biblionumber   => $biblio->biblionumber,
 304             priority       => 2
 305         }
 306     );
 307
 308     $itemnumber = $builder->build_sample_item({ library => $branch_1, biblionumber => $biblio->biblionumber })->itemnumber;
 309     my $reserveid3 = AddReserve(
 310         {
 311             branchcode     => $branch_1,
 312             borrowernumber => $borrowernumbers[2],
 313             biblionumber   => $biblio->biblionumber,
 314             priority       => 3
 315         }
 316     );
 317
 318     my $hhh = Koha::Holds->search({ biblionumber => $biblio->biblionumber });
 319     my $hold3 = Koha::Holds->find( $reserveid3 );
 320     is( $hold3->priority, 3, "The 3rd hold should have a priority set to 3" );
 321     ModReserve({ reserve_id => $reserveid1, rank => 'del' });
 322     ModReserve({ reserve_id => $reserveid2, rank => 'del' });
 323     is( $hold3->discard_changes->priority, 1, "After ModReserve, the 3rd reserve becomes the first on the waiting list" );
 324 }
 325
 326 Koha::Items->find($itemnumber)->damaged(1)->store; # FIXME The $itemnumber is a bit confusing here
 327 t::lib::Mocks::mock_preference( 'AllowHoldsOnDamagedItems', 1 );
 328 is( CanItemBeReserved( $borrowernumbers[0], $itemnumber)->{status}, 'OK', "Patron can reserve damaged item with AllowHoldsOnDamagedItems enabled" );
 329 ok( defined( ( CheckReserves($itemnumber) )[1] ), "Hold can be trapped for damaged item with AllowHoldsOnDamagedItems enabled" );
 330
 331 $hold = Koha::Hold->new(
 332     {
 333         borrowernumber => $borrowernumbers[0],
 334         itemnumber     => $itemnumber,
 335         biblionumber   => $biblio->biblionumber,
 336     }
 337 )->store();
 338 is( CanItemBeReserved( $borrowernumbers[0], $itemnumber )->{status},
 339     'itemAlreadyOnHold',
 340     "Patron cannot place a second item level hold for a given item" );
 341 $hold->delete();
 342
 343 t::lib::Mocks::mock_preference( 'AllowHoldsOnDamagedItems', 0 );
 344 ok( CanItemBeReserved( $borrowernumbers[0], $itemnumber)->{status} eq 'damaged', "Patron cannot reserve damaged item with AllowHoldsOnDamagedItems disabled" );
 345 ok( !defined( ( CheckReserves($itemnumber) )[1] ), "Hold cannot be trapped for damaged item with AllowHoldsOnDamagedItems disabled" );
 346
 347 # Items that are not for loan, but holdable should not be trapped until they are available for loan
 348 t::lib::Mocks::mock_preference( 'TrapHoldsOnOrder', 0 );
 349 Koha::Items->find($itemnumber)->damaged(0)->notforloan(-1)->store;
 350 Koha::Holds->search({ biblionumber => $biblio->id })->delete();
 351 is( CanItemBeReserved( $borrowernumbers[0], $itemnumber)->{status}, 'OK', "Patron can place hold on item that is not for loan but holdable ( notforloan < 0 )" );
 352 $hold = Koha::Hold->new(
 353     {
 354         borrowernumber => $borrowernumbers[0],
 355         itemnumber     => $itemnumber,
 356         biblionumber   => $biblio->biblionumber,
 357         found          => undef,
 358         priority       => 1,
 359         reservedate    => dt_from_string,
 360         branchcode     => $branch_1,
 361     }
 362 )->store();
 363 ok( !defined( ( CheckReserves($itemnumber) )[1] ), "Hold cannot be trapped for item that is not for loan but holdable ( notforloan < 0 )" );
 364 t::lib::Mocks::mock_preference( 'TrapHoldsOnOrder', 1 );
 365 ok( defined( ( CheckReserves($itemnumber) )[1] ), "Hold is trapped for item that is not for loan but holdable ( notforloan < 0 )" );
 366 t::lib::Mocks::mock_preference( 'SkipHoldTrapOnNotForLoanValue', '-1' );
 367 ok( !defined( ( CheckReserves($itemnumber) )[1] ), "Hold cannot be trapped for item with notforloan value matching SkipHoldTrapOnNotForLoanValue" );
 368 $hold->delete();
 369
 370 # Regression test for bug 9532
 371 $biblio = $builder->build_sample_biblio({ itemtype => 'CANNOT' });
 372 $item = $builder->build_sample_item({ library => $branch_1, itype => 'CANNOT', biblionumber => $biblio->biblionumber});
 373 AddReserve(
 374     {
 375         branchcode     => $branch_1,
 376         borrowernumber => $borrowernumbers[0],
 377         biblionumber   => $biblio->biblionumber,
 378         priority       => 1,
 379     }
 380 );
 381 is(
 382     CanItemBeReserved( $borrowernumbers[0], $item->itemnumber)->{status}, 'tooManyReserves',
 383     "cannot request item if policy that matches on item-level item type forbids it"
 384 );
 385
 386 $item->itype('CAN')->store;
 387 ok(
 388     CanItemBeReserved( $borrowernumbers[0], $item->itemnumber)->{status} eq 'OK',
 389     "can request item if policy that matches on item type allows it"
 390 );
 391
 392 t::lib::Mocks::mock_preference('item-level_itypes', 0);
 393 $item->itype(undef)->store;
 394 ok(
 395     CanItemBeReserved( $borrowernumbers[0], $item->itemnumber)->{status} eq 'tooManyReserves',
 396     "cannot request item if policy that matches on bib-level item type forbids it (bug 9532)"
 397 );
 398
 399
 400 # Test branch item rules
 401
 402 $dbh->do('DELETE FROM circulation_rules');
 403 Koha::CirculationRules->set_rules(
 404     {
 405         categorycode => undef,
 406         branchcode   => undef,
 407         itemtype     => undef,
 408         rules        => {
 409             reservesallowed  => 25,
 410             holds_per_record => 99,
 411         }
 412     }
 413 );
 414 Koha::CirculationRules->set_rules(
 415     {
 416         branchcode => $branch_1,
 417         itemtype   => 'CANNOT',
 418         rules => {
 419             holdallowed => 0,
 420             returnbranch => 'homebranch',
 421         }
 422     }
 423 );
 424 Koha::CirculationRules->set_rules(
 425     {
 426         branchcode => $branch_1,
 427         itemtype   => 'CAN',
 428         rules => {
 429             holdallowed => 1,
 430             returnbranch => 'homebranch',
 431         }
 432     }
 433 );
 434 $biblio = $builder->build_sample_biblio({ itemtype => 'CANNOT' });
 435 $itemnumber = $builder->build_sample_item({ library => $branch_1, itype => 'CANNOT', biblionumber => $biblio->biblionumber})->itemnumber;
 436 is(CanItemBeReserved($borrowernumbers[0], $itemnumber)->{status}, 'notReservable',
 437     "CanItemBeReserved should return 'notReservable'");
 438
 439 t::lib::Mocks::mock_preference( 'ReservesControlBranch', 'PatronLibrary' );
 440 $itemnumber = $builder->build_sample_item({ library => $branch_2, itype => 'CAN', biblionumber => $biblio->biblionumber})->itemnumber;
 441 is(CanItemBeReserved($borrowernumbers[0], $itemnumber)->{status},
 442     'cannotReserveFromOtherBranches',
 443     "CanItemBeReserved should use PatronLibrary rule when ReservesControlBranch set to 'PatronLibrary'");
 444 t::lib::Mocks::mock_preference( 'ReservesControlBranch', 'ItemHomeLibrary' );
 445 is(CanItemBeReserved($borrowernumbers[0], $itemnumber)->{status},
 446     'OK',
 447     "CanItemBeReserved should use item home library rule when ReservesControlBranch set to 'ItemsHomeLibrary'");
 448
 449 $itemnumber = $builder->build_sample_item({ library => $branch_1, itype => 'CAN', biblionumber => $biblio->biblionumber})->itemnumber;
 450 is(CanItemBeReserved($borrowernumbers[0], $itemnumber)->{status}, 'OK',
 451     "CanItemBeReserved should return 'OK'");
 452
 453 # Bug 12632
 454 t::lib::Mocks::mock_preference( 'item-level_itypes',     1 );
 455 t::lib::Mocks::mock_preference( 'ReservesControlBranch', 'PatronLibrary' );
 456
 457 $dbh->do('DELETE FROM reserves');
 458 $dbh->do('DELETE FROM issues');
 459 $dbh->do('DELETE FROM items');
 460 $dbh->do('DELETE FROM biblio');
 461
 462 $biblio = $builder->build_sample_biblio({ itemtype => 'ONLY1' });
 463 $itemnumber = $builder->build_sample_item({ library => $branch_1, biblionumber => $biblio->biblionumber})->itemnumber;
 464
 465 Koha::CirculationRules->set_rules(
 466     {
 467         categorycode => undef,
 468         branchcode   => undef,
 469         itemtype     => 'ONLY1',
 470         rules        => {
 471             reservesallowed  => 1,
 472             holds_per_record => 99,
 473         }
 474     }
 475 );
 476 is( CanItemBeReserved( $borrowernumbers[0], $itemnumber )->{status},
 477     'OK', 'Patron can reserve item with hold limit of 1, no holds placed' );
 478
 479 my $res_id = AddReserve(
 480     {
 481         branchcode     => $branch_1,
 482         borrowernumber => $borrowernumbers[0],
 483         biblionumber   => $biblio->biblionumber,
 484         priority       => 1,
 485     }
 486 );
 487
 488 is( CanItemBeReserved( $borrowernumbers[0], $itemnumber )->{status},
 489     'tooManyReserves', 'Patron cannot reserve item with hold limit of 1, 1 bib level hold placed' );
 490
 491     #results should be the same for both ReservesControlBranch settings
 492 t::lib::Mocks::mock_preference( 'ReservesControlBranch', 'ItemHomeLibrary' );
 493 is( CanItemBeReserved( $borrowernumbers[0], $itemnumber )->{status},
 494     'tooManyReserves', 'Patron cannot reserve item with hold limit of 1, 1 bib level hold placed' );
 495 #reset for further tests
 496 t::lib::Mocks::mock_preference( 'ReservesControlBranch', 'PatronLibrary' );
 497
 498 subtest 'Test max_holds per library/patron category' => sub {
 499     plan tests => 6;
 500
 501     $dbh->do('DELETE FROM reserves');
 502
 503     $biblio = $builder->build_sample_biblio;
 504     $itemnumber = $builder->build_sample_item({ library => $branch_1, biblionumber => $biblio->biblionumber})->itemnumber;
 505     Koha::CirculationRules->set_rules(
 506         {
 507             categorycode => undef,
 508             branchcode   => undef,
 509             itemtype     => $biblio->itemtype,
 510             rules        => {
 511                 reservesallowed  => 99,
 512                 holds_per_record => 99,
 513             }
 514         }
 515     );
 516
 517     for ( 1 .. 3 ) {
 518         AddReserve(
 519             {
 520                 branchcode     => $branch_1,
 521                 borrowernumber => $borrowernumbers[0],
 522                 biblionumber   => $biblio->biblionumber,
 523                 priority       => 1,
 524             }
 525         );
 526     }
 527
 528     my $count =
 529       Koha::Holds->search( { borrowernumber => $borrowernumbers[0] } )->count();
 530     is( $count, 3, 'Patron now has 3 holds' );
 531
 532     my $ret = CanItemBeReserved( $borrowernumbers[0], $itemnumber );
 533     is( $ret->{status}, 'OK', 'Patron can place hold with no borrower circ rules' );
 534
 535     my $rule_all = Koha::CirculationRules->set_rule(
 536         {
 537             categorycode => $category->{categorycode},
 538             branchcode   => undef,
 539             rule_name    => 'max_holds',
 540             rule_value   => 3,
 541         }
 542     );
 543
 544     my $rule_branch = Koha::CirculationRules->set_rule(
 545         {
 546             branchcode   => $branch_1,
 547             categorycode => $category->{categorycode},
 548             rule_name    => 'max_holds',
 549             rule_value   => 5,
 550         }
 551     );
 552
 553     $ret = CanItemBeReserved( $borrowernumbers[0], $itemnumber );
 554     is( $ret->{status}, 'OK', 'Patron can place hold with branch/category rule of 5, category rule of 3' );
 555
 556     $rule_branch->delete();
 557
 558     $ret = CanItemBeReserved( $borrowernumbers[0], $itemnumber );
 559     is( $ret->{status}, 'tooManyReserves', 'Patron cannot place hold with only a category rule of 3' );
 560
 561     $rule_all->delete();
 562     $rule_branch->rule_value(3);
 563     $rule_branch->store();
 564
 565     $ret = CanItemBeReserved( $borrowernumbers[0], $itemnumber );
 566     is( $ret->{status}, 'tooManyReserves', 'Patron cannot place hold with only a branch/category rule of 3' );
 567
 568     $rule_branch->rule_value(5);
 569     $rule_branch->update();
 570     $rule_branch->rule_value(5);
 571     $rule_branch->store();
 572
 573     $ret = CanItemBeReserved( $borrowernumbers[0], $itemnumber );
 574     is( $ret->{status}, 'OK', 'Patron can place hold with branch/category rule of 5, category rule of 5' );
 575 };
 576
 577 subtest 'Pickup location availability tests' => sub {
 578     plan tests => 4;
 579
 580     $biblio = $builder->build_sample_biblio({ itemtype => 'ONLY1' });
 581     $itemnumber = $builder->build_sample_item({ library => $branch_1, biblionumber => $biblio->biblionumber})->itemnumber;
 582     #Add a default rule to allow some holds
 583
 584     Koha::CirculationRules->set_rules(
 585         {
 586             branchcode   => undef,
 587             categorycode => undef,
 588             itemtype     => undef,
 589             rules        => {
 590                 reservesallowed  => 25,
 591                 holds_per_record => 99,
 592             }
 593         }
 594     );
 595     my $item = Koha::Items->find($itemnumber);
 596     my $branch_to = $builder->build({ source => 'Branch' })->{ branchcode };
 597     my $library = Koha::Libraries->find($branch_to);
 598     $library->pickup_location('1')->store;
 599     my $patron = $builder->build({ source => 'Borrower' })->{ borrowernumber };
 600
 601     t::lib::Mocks::mock_preference('UseBranchTransferLimits', 1);
 602     t::lib::Mocks::mock_preference('BranchTransferLimitsType', 'itemtype');
 603
 604     $library->pickup_location('1')->store;
 605     is(CanItemBeReserved($patron, $item->itemnumber, $branch_to)->{status},
 606        'OK', 'Library is a pickup location');
 607
 608     my $limit = Koha::Item::Transfer::Limit->new({
 609         fromBranch => $item->holdingbranch,
 610         toBranch => $branch_to,
 611         itemtype => $item->effective_itemtype,
 612     })->store;
 613     is(CanItemBeReserved($patron, $item->itemnumber, $branch_to)->{status},
 614        'cannotBeTransferred', 'Item cannot be transferred');
 615     $limit->delete;
 616
 617     $library->pickup_location('0')->store;
 618     is(CanItemBeReserved($patron, $item->itemnumber, $branch_to)->{status},
 619        'libraryNotPickupLocation', 'Library is not a pickup location');
 620     is(CanItemBeReserved($patron, $item->itemnumber, 'nonexistent')->{status},
 621        'libraryNotFound', 'Cannot set unknown library as pickup location');
 622 };
 623
 624 $schema->storage->txn_rollback;
 625
 626 subtest 'CanItemBeReserved / holds_per_day tests' => sub {
 627
 628     plan tests => 10;
 629
 630     $schema->storage->txn_begin;
 631
 632     Koha::Holds->search->delete;
 633     $dbh->do('DELETE FROM issues');
 634     Koha::Items->search->delete;
 635     Koha::Biblios->search->delete;
 636
 637     my $itemtype = $builder->build_object( { class => 'Koha::ItemTypes' } );
 638     my $library  = $builder->build_object( { class => 'Koha::Libraries' } );
 639     my $patron   = $builder->build_object( { class => 'Koha::Patrons' } );
 640
 641     # Create 3 biblios with items
 642     my $biblio_1 = $builder->build_sample_biblio({ itemtype => $itemtype->itemtype });
 643     my $itemnumber_1 = $builder->build_sample_item({ library => $library->branchcode, biblionumber => $biblio_1->biblionumber})->itemnumber;
 644     my $biblio_2 = $builder->build_sample_biblio({ itemtype => $itemtype->itemtype });
 645     my $itemnumber_2 = $builder->build_sample_item({ library => $library->branchcode, biblionumber => $biblio_2->biblionumber})->itemnumber;
 646     my $biblio_3 = $builder->build_sample_biblio({ itemtype => $itemtype->itemtype });
 647     my $itemnumber_3 = $builder->build_sample_item({ library => $library->branchcode, biblionumber => $biblio_3->biblionumber})->itemnumber;
 648
 649     Koha::CirculationRules->search->delete;
 650     Koha::CirculationRules->set_rules(
 651         {
 652             categorycode => '*',
 653             branchcode   => '*',
 654             itemtype     => $itemtype->itemtype,
 655             rules        => {
 656                 reservesallowed  => 1,
 657                 holds_per_record => 99,
 658                 holds_per_day    => 2
 659             }
 660         }
 661     );
 662
 663     is_deeply(
 664         CanItemBeReserved( $patron->borrowernumber, $itemnumber_1 ),
 665         { status => 'OK' },
 666         'Patron can reserve item with hold limit of 1, no holds placed'
 667     );
 668
 669     AddReserve(
 670         {
 671             branchcode     => $library->branchcode,
 672             borrowernumber => $patron->borrowernumber,
 673             biblionumber   => $biblio_1->biblionumber,
 674             priority       => 1,
 675         }
 676     );
 677
 678     is_deeply(
 679         CanItemBeReserved( $patron->borrowernumber, $itemnumber_1 ),
 680         { status => 'tooManyReserves', limit => 1 },
 681         'Patron cannot reserve item with hold limit of 1, 1 bib level hold placed'
 682     );
 683
 684     # Raise reservesallowed to avoid tooManyReserves from it
 685     Koha::CirculationRules->set_rule(
 686         {
 687
 688             categorycode => '*',
 689             branchcode   => '*',
 690             itemtype     => $itemtype->itemtype,
 691             rule_name  => 'reservesallowed',
 692             rule_value => 3,
 693         }
 694     );
 695
 696     is_deeply(
 697         CanItemBeReserved( $patron->borrowernumber, $itemnumber_2 ),
 698         { status => 'OK' },
 699         'Patron can reserve item with 2 reserves daily cap'
 700     );
 701
 702     # Add a second reserve
 703     my $res_id = AddReserve(
 704         {
 705             branchcode     => $library->branchcode,
 706             borrowernumber => $patron->borrowernumber,
 707             biblionumber   => $biblio_2->biblionumber,
 708             priority       => 1,
 709         }
 710     );
 711     is_deeply(
 712         CanItemBeReserved( $patron->borrowernumber, $itemnumber_2 ),
 713         { status => 'tooManyReservesToday', limit => 2 },
 714         'Patron cannot a third item with 2 reserves daily cap'
 715     );
 716
 717     # Update last hold so reservedate is in the past, so 2 holds, but different day
 718     $hold = Koha::Holds->find($res_id);
 719     my $yesterday = dt_from_string() - DateTime::Duration->new( days => 1 );
 720     $hold->reservedate($yesterday)->store;
 721
 722     is_deeply(
 723         CanItemBeReserved( $patron->borrowernumber, $itemnumber_2 ),
 724         { status => 'OK' },
 725         'Patron can reserve item with 2 bib level hold placed on different days, 2 reserves daily cap'
 726     );
 727
 728     # Set holds_per_day to 0
 729     Koha::CirculationRules->set_rule(
 730         {
 731
 732             categorycode => '*',
 733             branchcode   => '*',
 734             itemtype     => $itemtype->itemtype,
 735             rule_name  => 'holds_per_day',
 736             rule_value => 0,
 737         }
 738     );
 739
 740
 741     # Delete existing holds
 742     Koha::Holds->search->delete;
 743     is_deeply(
 744         CanItemBeReserved( $patron->borrowernumber, $itemnumber_2 ),
 745         { status => 'tooManyReservesToday', limit => 0 },
 746         'Patron cannot reserve if holds_per_day is 0 (i.e. 0 is 0)'
 747     );
 748
 749     Koha::CirculationRules->set_rule(
 750         {
 751
 752             categorycode => '*',
 753             branchcode   => '*',
 754             itemtype     => $itemtype->itemtype,
 755             rule_name  => 'holds_per_day',
 756             rule_value => undef,
 757         }
 758     );
 759
 760     Koha::Holds->search->delete;
 761     is_deeply(
 762         CanItemBeReserved( $patron->borrowernumber, $itemnumber_2 ),
 763         { status => 'OK' },
 764         'Patron can reserve if holds_per_day is undef (i.e. undef is unlimited daily cap)'
 765     );
 766     AddReserve(
 767         {
 768             branchcode     => $library->branchcode,
 769             borrowernumber => $patron->borrowernumber,
 770             biblionumber   => $biblio_1->biblionumber,
 771             priority       => 1,
 772         }
 773     );
 774     AddReserve(
 775         {
 776             branchcode     => $library->branchcode,
 777             borrowernumber => $patron->borrowernumber,
 778             biblionumber   => $biblio_2->biblionumber,
 779             priority       => 1,
 780         }
 781     );
 782
 783     is_deeply(
 784         CanItemBeReserved( $patron->borrowernumber, $itemnumber_3 ),
 785         { status => 'OK' },
 786         'Patron can reserve if holds_per_day is undef (i.e. undef is unlimited daily cap)'
 787     );
 788     AddReserve(
 789         {
 790             branchcode     => $library->branchcode,
 791             borrowernumber => $patron->borrowernumber,
 792             biblionumber   => $biblio_3->biblionumber,
 793             priority       => 1,
 794         }
 795     );
 796     is_deeply(
 797         CanItemBeReserved( $patron->borrowernumber, $itemnumber_3 ),
 798         { status => 'tooManyReserves', limit => 3 },
 799         'Unlimited daily holds, but reached reservesallowed'
 800     );
 801     #results should be the same for both ReservesControlBranch settings
 802     t::lib::Mocks::mock_preference('ReservesControlBranch', 'ItemHomeLibrary');
 803     is_deeply(
 804         CanItemBeReserved( $patron->borrowernumber, $itemnumber_3 ),
 805         { status => 'tooManyReserves', limit => 3 },
 806         'Unlimited daily holds, but reached reservesallowed'
 807     );
 808
 809     $schema->storage->txn_rollback;
 810 };
 811
 812 subtest 'CanItemBeReserved / branch_not_in_hold_group' => sub {
 813     plan tests => 9;
 814
 815     $schema->storage->txn_begin;
 816
 817     # Cleanup database
 818     Koha::Holds->search->delete;
 819     $dbh->do('DELETE FROM issues');
 820     Koha::CirculationRules->set_rule(
 821         {
 822             branchcode   => undef,
 823             categorycode => undef,
 824             itemtype     => undef,
 825             rule_name    => 'reservesallowed',
 826             rule_value   => 25,
 827         }
 828     );
 829
 830     Koha::Items->search->delete;
 831     Koha::Biblios->search->delete;
 832
 833     # Create item types
 834     my $itemtype1 = $builder->build_object( { class => 'Koha::ItemTypes' } );
 835     my $itemtype2 = $builder->build_object( { class => 'Koha::ItemTypes' } );
 836
 837     # Create libraries
 838     my $library1  = $builder->build_object( { class => 'Koha::Libraries' } );
 839     my $library2  = $builder->build_object( { class => 'Koha::Libraries' } );
 840     my $library3  = $builder->build_object( { class => 'Koha::Libraries' } );
 841
 842     # Create library groups hierarchy
 843     my $rootgroup  = $builder->build_object( { class => 'Koha::Library::Groups', value => {ft_local_hold_group => 1} } );
 844     my $group1  = $builder->build_object( { class => 'Koha::Library::Groups', value => {parent_id => $rootgroup->id, branchcode => $library1->branchcode}} );
 845     my $group2  = $builder->build_object( { class => 'Koha::Library::Groups', value => {parent_id => $rootgroup->id, branchcode => $library2->branchcode} } );
 846
 847     # Create 2 patrons
 848     my $patron1   = $builder->build_object( { class => 'Koha::Patrons', value => {branchcode => $library1->branchcode} } );
 849     my $patron3   = $builder->build_object( { class => 'Koha::Patrons', value => {branchcode => $library3->branchcode} } );
 850
 851     # Create 3 biblios with items
 852     my $biblio_1 = $builder->build_sample_biblio({ itemtype => $itemtype1->itemtype });
 853     my $item_1   = $builder->build_sample_item(
 854         {
 855             biblionumber => $biblio_1->biblionumber,
 856             library      => $library1->branchcode
 857         }
 858     );
 859     my $biblio_2 = $builder->build_sample_biblio({ itemtype => $itemtype2->itemtype });
 860     my $item_2   = $builder->build_sample_item(
 861         {
 862             biblionumber => $biblio_2->biblionumber,
 863             library      => $library2->branchcode
 864         }
 865     );
 866     my $itemnumber_2 = $item_2->itemnumber;
 867     my $biblio_3 = $builder->build_sample_biblio({ itemtype => $itemtype1->itemtype });
 868     my $item_3   = $builder->build_sample_item(
 869         {
 870             biblionumber => $biblio_3->biblionumber,
 871             library      => $library1->branchcode
 872         }
 873     );
 874
 875     # Test 1: Patron 3 can place hold
 876     is_deeply(
 877         CanItemBeReserved( $patron3->borrowernumber, $itemnumber_2 ),
 878         { status => 'OK' },
 879         'Patron can place hold if no circ_rules where defined'
 880     );
 881
 882     # Insert default circ rule of holds allowed only from local hold group for all libraries
 883     Koha::CirculationRules->set_rules(
 884         {
 885             branchcode => undef,
 886             itemtype   => undef,
 887             rules => {
 888                 holdallowed => 3,
 889                 hold_fulfillment_policy => 'any',
 890                 returnbranch => 'any'
 891             }
 892         }
 893     );
 894
 895     # Test 2: Patron 1 can place hold
 896     is_deeply(
 897         CanItemBeReserved( $patron1->borrowernumber, $itemnumber_2 ),
 898         { status => 'OK' },
 899         'Patron can place hold because patron\'s home library is part of hold group'
 900     );
 901
 902     # Test 3: Patron 3 cannot place hold
 903     is_deeply(
 904         CanItemBeReserved( $patron3->borrowernumber, $itemnumber_2 ),
 905         { status => 'branchNotInHoldGroup' },
 906         'Patron cannot place hold because patron\'s home library is not part of hold group'
 907     );
 908
 909     # Insert default circ rule to "any" for library 2
 910     Koha::CirculationRules->set_rules(
 911         {
 912             branchcode => $library2->branchcode,
 913             itemtype   => undef,
 914             rules => {
 915                 holdallowed => 2,
 916                 hold_fulfillment_policy => 'any',
 917                 returnbranch => 'any'
 918             }
 919         }
 920     );
 921
 922     # Test 4: Patron 3 can place hold
 923     is_deeply(
 924         CanItemBeReserved( $patron3->borrowernumber, $itemnumber_2 ),
 925         { status => 'OK' },
 926         'Patron can place hold if holdallowed is set to "any" for library 2'
 927     );
 928
 929     # Update default circ rule to "hold group" for library 2
 930     Koha::CirculationRules->set_rules(
 931         {
 932             branchcode => $library2->branchcode,
 933             itemtype   => undef,
 934             rules => {
 935                 holdallowed => 3,
 936                 hold_fulfillment_policy => 'any',
 937                 returnbranch => 'any'
 938             }
 939         }
 940     );
 941
 942     # Test 5: Patron 3 cannot place hold
 943     is_deeply(
 944         CanItemBeReserved( $patron3->borrowernumber, $itemnumber_2 ),
 945         { status => 'branchNotInHoldGroup' },
 946         'Patron cannot place hold if holdallowed is set to "hold group" for library 2'
 947     );
 948
 949     # Insert default item rule to "any" for itemtype 2
 950     Koha::CirculationRules->set_rules(
 951         {
 952             branchcode => $library2->branchcode,
 953             itemtype   => $itemtype2->itemtype,
 954             rules => {
 955                 holdallowed => 2,
 956                 hold_fulfillment_policy => 'any',
 957                 returnbranch => 'any'
 958             }
 959         }
 960     );
 961
 962     # Test 6: Patron 3 can place hold
 963     is_deeply(
 964         CanItemBeReserved( $patron3->borrowernumber, $itemnumber_2 ),
 965         { status => 'OK' },
 966         'Patron can place hold if holdallowed is set to "any" for itemtype 2'
 967     );
 968
 969     # Update default item rule to "hold group" for itemtype 2
 970     Koha::CirculationRules->set_rules(
 971         {
 972             branchcode => $library2->branchcode,
 973             itemtype   => $itemtype2->itemtype,
 974             rules => {
 975                 holdallowed => 3,
 976                 hold_fulfillment_policy => 'any',
 977                 returnbranch => 'any'
 978             }
 979         }
 980     );
 981
 982     # Test 7: Patron 3 cannot place hold
 983     is_deeply(
 984         CanItemBeReserved( $patron3->borrowernumber, $itemnumber_2 ),
 985         { status => 'branchNotInHoldGroup' },
 986         'Patron cannot place hold if holdallowed is set to "hold group" for itemtype 2'
 987     );
 988
 989     # Insert branch item rule to "any" for itemtype 2 and library 2
 990     Koha::CirculationRules->set_rules(
 991         {
 992             branchcode => $library2->branchcode,
 993             itemtype   => $itemtype2->itemtype,
 994             rules => {
 995                 holdallowed => 2,
 996                 hold_fulfillment_policy => 'any',
 997                 returnbranch => 'any'
 998             }
 999         }
1000     );
1001
1002     # Test 8: Patron 3 can place hold
1003     is_deeply(
1004         CanItemBeReserved( $patron3->borrowernumber, $itemnumber_2 ),
1005         { status => 'OK' },
1006         'Patron can place hold if holdallowed is set to "any" for itemtype 2 and library 2'
1007     );
1008
1009     # Update branch item rule to "hold group" for itemtype 2 and library 2
1010     Koha::CirculationRules->set_rules(
1011         {
1012             branchcode => $library2->branchcode,
1013             itemtype   => $itemtype2->itemtype,
1014             rules => {
1015                 holdallowed => 3,
1016                 hold_fulfillment_policy => 'any',
1017                 returnbranch => 'any'
1018             }
1019         }
1020     );
1021
1022     # Test 9: Patron 3 cannot place hold
1023     is_deeply(
1024         CanItemBeReserved( $patron3->borrowernumber, $itemnumber_2 ),
1025         { status => 'branchNotInHoldGroup' },
1026         'Patron cannot place hold if holdallowed is set to "hold group" for itemtype 2 and library 2'
1027     );
1028
1029     $schema->storage->txn_rollback;
1030
1031 };
1032
1033 subtest 'CanItemBeReserved / pickup_not_in_hold_group' => sub {
1034     plan tests => 9;
1035
1036     $schema->storage->txn_begin;
1037
1038     # Cleanup database
1039     Koha::Holds->search->delete;
1040     $dbh->do('DELETE FROM issues');
1041     Koha::CirculationRules->set_rule(
1042         {
1043             branchcode   => undef,
1044             categorycode => undef,
1045             itemtype     => undef,
1046             rule_name    => 'reservesallowed',
1047             rule_value   => 25,
1048         }
1049     );
1050
1051     Koha::Items->search->delete;
1052     Koha::Biblios->search->delete;
1053
1054     # Create item types
1055     my $itemtype1 = $builder->build_object( { class => 'Koha::ItemTypes' } );
1056     my $itemtype2 = $builder->build_object( { class => 'Koha::ItemTypes' } );
1057
1058     # Create libraries
1059     my $library1  = $builder->build_object( { class => 'Koha::Libraries', value => {pickup_location => 1} } );
1060     my $library2  = $builder->build_object( { class => 'Koha::Libraries', value => {pickup_location => 1} } );
1061     my $library3  = $builder->build_object( { class => 'Koha::Libraries', value => {pickup_location => 1} } );
1062
1063     # Create library groups hierarchy
1064     my $rootgroup  = $builder->build_object( { class => 'Koha::Library::Groups', value => {ft_local_hold_group => 1} } );
1065     my $group1  = $builder->build_object( { class => 'Koha::Library::Groups', value => {parent_id => $rootgroup->id, branchcode => $library1->branchcode}} );
1066     my $group2  = $builder->build_object( { class => 'Koha::Library::Groups', value => {parent_id => $rootgroup->id, branchcode => $library2->branchcode} } );
1067
1068     # Create 2 patrons
1069     my $patron1   = $builder->build_object( { class => 'Koha::Patrons', value => {branchcode => $library1->branchcode} } );
1070     my $patron3   = $builder->build_object( { class => 'Koha::Patrons', value => {branchcode => $library3->branchcode} } );
1071
1072     # Create 3 biblios with items
1073     my $biblio_1 = $builder->build_sample_biblio({ itemtype => $itemtype1->itemtype });
1074     my $item_1   = $builder->build_sample_item(
1075         {
1076             biblionumber => $biblio_1->biblionumber,
1077             library      => $library1->branchcode
1078         }
1079     );
1080     my $biblio_2 = $builder->build_sample_biblio({ itemtype => $itemtype2->itemtype });
1081     my $item_2   = $builder->build_sample_item(
1082         {
1083             biblionumber => $biblio_2->biblionumber,
1084             library      => $library2->branchcode
1085         }
1086     );
1087     my $itemnumber_2 = $item_2->itemnumber;
1088     my $biblio_3 = $builder->build_sample_biblio({ itemtype => $itemtype1->itemtype });
1089     my $item_3   = $builder->build_sample_item(
1090         {
1091             biblionumber => $biblio_3->biblionumber,
1092             library      => $library1->branchcode
1093         }
1094     );
1095
1096     # Test 1: Patron 3 can place hold
1097     is_deeply(
1098         CanItemBeReserved( $patron3->borrowernumber, $itemnumber_2, $library3->branchcode ),
1099         { status => 'OK' },
1100         'Patron can place hold if no circ_rules where defined'
1101     );
1102
1103     # Insert default circ rule of holds allowed only from local hold group for all libraries
1104     Koha::CirculationRules->set_rules(
1105         {
1106             branchcode => undef,
1107             itemtype   => undef,
1108             rules => {
1109                 holdallowed => 2,
1110                 hold_fulfillment_policy => 'holdgroup',
1111                 returnbranch => 'any'
1112             }
1113         }
1114     );
1115
1116     # Test 2: Patron 1 can place hold
1117     is_deeply(
1118         CanItemBeReserved( $patron3->borrowernumber, $itemnumber_2, $library1->branchcode ),
1119         { status => 'OK' },
1120         'Patron can place hold because pickup location is part of hold group'
1121     );
1122
1123     # Test 3: Patron 3 cannot place hold
1124     is_deeply(
1125         CanItemBeReserved( $patron3->borrowernumber, $itemnumber_2, $library3->branchcode ),
1126         { status => 'pickupNotInHoldGroup' },
1127         'Patron cannot place hold because pickup location is not part of hold group'
1128     );
1129
1130     # Insert default circ rule to "any" for library 2
1131     Koha::CirculationRules->set_rules(
1132         {
1133             branchcode => $library2->branchcode,
1134             itemtype   => undef,
1135             rules => {
1136                 holdallowed => 2,
1137                 hold_fulfillment_policy => 'any',
1138                 returnbranch => 'any'
1139             }
1140         }
1141     );
1142
1143     # Test 4: Patron 3 can place hold
1144     is_deeply(
1145         CanItemBeReserved( $patron3->borrowernumber, $itemnumber_2, $library3->branchcode ),
1146         { status => 'OK' },
1147         'Patron can place hold if default_branch_circ_rules is set to "any" for library 2'
1148     );
1149
1150     # Update default circ rule to "hold group" for library 2
1151     Koha::CirculationRules->set_rules(
1152         {
1153             branchcode => $library2->branchcode,
1154             itemtype   => undef,
1155             rules => {
1156                 holdallowed => 2,
1157                 hold_fulfillment_policy => 'holdgroup',
1158                 returnbranch => 'any'
1159             }
1160         }
1161     );
1162
1163     # Test 5: Patron 3 cannot place hold
1164     is_deeply(
1165         CanItemBeReserved( $patron3->borrowernumber, $itemnumber_2, $library3->branchcode ),
1166         { status => 'pickupNotInHoldGroup' },
1167         'Patron cannot place hold if hold_fulfillment_policy is set to "hold group" for library 2'
1168     );
1169
1170     # Insert default item rule to "any" for itemtype 2
1171     Koha::CirculationRules->set_rules(
1172         {
1173             branchcode => $library2->branchcode,
1174             itemtype   => $itemtype2->itemtype,
1175             rules => {
1176                 holdallowed => 2,
1177                 hold_fulfillment_policy => 'any',
1178                 returnbranch => 'any'
1179             }
1180         }
1181     );
1182
1183     # Test 6: Patron 3 can place hold
1184     is_deeply(
1185         CanItemBeReserved( $patron3->borrowernumber, $itemnumber_2, $library3->branchcode ),
1186         { status => 'OK' },
1187         'Patron can place hold if hold_fulfillment_policy is set to "any" for itemtype 2'
1188     );
1189
1190     # Update default item rule to "hold group" for itemtype 2
1191     Koha::CirculationRules->set_rules(
1192         {
1193             branchcode => $library2->branchcode,
1194             itemtype   => $itemtype2->itemtype,
1195             rules => {
1196                 holdallowed => 2,
1197                 hold_fulfillment_policy => 'holdgroup',
1198                 returnbranch => 'any'
1199             }
1200         }
1201     );
1202
1203     # Test 7: Patron 3 cannot place hold
1204     is_deeply(
1205         CanItemBeReserved( $patron3->borrowernumber, $itemnumber_2, $library3->branchcode ),
1206         { status => 'pickupNotInHoldGroup' },
1207         'Patron cannot place hold if hold_fulfillment_policy is set to "hold group" for itemtype 2'
1208     );
1209
1210     # Insert branch item rule to "any" for itemtype 2 and library 2
1211     Koha::CirculationRules->set_rules(
1212         {
1213             branchcode => $library2->branchcode,
1214             itemtype   => $itemtype2->itemtype,
1215             rules => {
1216                 holdallowed => 2,
1217                 hold_fulfillment_policy => 'any',
1218                 returnbranch => 'any'
1219             }
1220         }
1221     );
1222
1223     # Test 8: Patron 3 can place hold
1224     is_deeply(
1225         CanItemBeReserved( $patron3->borrowernumber, $itemnumber_2, $library3->branchcode ),
1226         { status => 'OK' },
1227         'Patron can place hold if hold_fulfillment_policy is set to "any" for itemtype 2 and library 2'
1228     );
1229
1230     # Update branch item rule to "hold group" for itemtype 2 and library 2
1231     Koha::CirculationRules->set_rules(
1232         {
1233             branchcode => $library2->branchcode,
1234             itemtype   => $itemtype2->itemtype,
1235             rules => {
1236                 holdallowed => 2,
1237                 hold_fulfillment_policy => 'holdgroup',
1238                 returnbranch => 'any'
1239             }
1240         }
1241     );
1242
1243     # Test 9: Patron 3 cannot place hold
1244     is_deeply(
1245         CanItemBeReserved( $patron3->borrowernumber, $itemnumber_2, $library3->branchcode ),
1246         { status => 'pickupNotInHoldGroup' },
1247         'Patron cannot place hold if hold_fulfillment_policy is set to "hold group" for itemtype 2 and library 2'
1248     );
1249
1250     $schema->storage->txn_rollback;
1251 };