t/db_dependent/Koha/Hold.t

   1 #!/usr/bin/perl
   2
   3 # Copyright 2020 Koha Development team
   4 #
   5 # This file is part of Koha
   6 #
   7 # Koha is free software; you can redistribute it and/or modify it
   8 # under the terms of the GNU General Public License as published by
   9 # the Free Software Foundation; either version 3 of the License, or
  10 # (at your option) any later version.
  11 #
  12 # Koha is distributed in the hope that it will be useful, but
  13 # WITHOUT ANY WARRANTY; without even the implied warranty of
  14 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  15 # GNU General Public License for more details.
  16 #
  17 # You should have received a copy of the GNU General Public License
  18 # along with Koha; if not, see <http://www.gnu.org/licenses>.
  19
  20 use Modern::Perl;
  21
  22 use Test::More tests => 5;
  23
  24 use Test::Exception;
  25 use Test::MockModule;
  26
  27 use t::lib::Mocks;
  28 use t::lib::TestBuilder;
  29 use t::lib::Mocks;
  30
  31 use Koha::ActionLogs;
  32 use Koha::Holds;
  33 use Koha::Libraries;
  34 use Koha::Old::Holds;
  35
  36 my $schema  = Koha::Database->new->schema;
  37 my $builder = t::lib::TestBuilder->new;
  38
  39 subtest 'fill() tests' => sub {
  40
  41     plan tests => 12;
  42
  43     $schema->storage->txn_begin;
  44
  45     my $fee = 15;
  46
  47     my $category = $builder->build_object(
  48         {
  49             class => 'Koha::Patron::Categories',
  50             value => { reservefee => $fee }
  51         }
  52     );
  53     my $patron = $builder->build_object(
  54         {
  55             class => 'Koha::Patrons',
  56             value => { categorycode => $category->id }
  57         }
  58     );
  59     my $manager = $builder->build_object( { class => 'Koha::Patrons' } );
  60
  61     my $title  = 'Do what you want';
  62     my $biblio = $builder->build_sample_biblio( { title => $title } );
  63     my $item   = $builder->build_sample_item( { biblionumber => $biblio->id } );
  64     my $hold   = $builder->build_object(
  65         {
  66             class => 'Koha::Holds',
  67             value => {
  68                 biblionumber   => $biblio->id,
  69                 borrowernumber => $patron->id,
  70                 itemnumber     => $item->id,
  71                 priority       => 10,
  72             }
  73         }
  74     );
  75
  76     t::lib::Mocks::mock_preference( 'HoldFeeMode', 'any_time_is_collected' );
  77     t::lib::Mocks::mock_preference( 'HoldsLog',    1 );
  78     t::lib::Mocks::mock_userenv(
  79         { patron => $manager, branchcode => $manager->branchcode } );
  80
  81     my $interface = 'api';
  82     C4::Context->interface($interface);
  83
  84     my $ret = $hold->fill;
  85
  86     is( ref($ret), 'Koha::Hold', '->fill returns the object type' );
  87     is( $ret->id, $hold->id, '->fill returns the object' );
  88
  89     is( Koha::Holds->find($hold->id), undef, 'Hold no longer current' );
  90     my $old_hold = Koha::Old::Holds->find( $hold->id );
  91
  92     is( $old_hold->id, $hold->id, 'reserve_id retained' );
  93     is( $old_hold->priority, 0, 'priority set to 0' );
  94     is( $old_hold->found, 'F', 'found set to F' );
  95
  96     subtest 'fee applied tests' => sub {
  97
  98         plan tests => 9;
  99
 100         my $account = $patron->account;
 101         is( $account->balance, $fee, 'Charge applied correctly' );
 102
 103         my $debits = $account->outstanding_debits;
 104         is( $debits->count, 1, 'Only one fee charged' );
 105
 106         my $fee_debit = $debits->next;
 107         is( $fee_debit->amount * 1, $fee, 'Fee amount stored correctly' );
 108         is( $fee_debit->description, $title,
 109             'Fee description stored correctly' );
 110         is( $fee_debit->manager_id, $manager->id,
 111             'Fee manager_id stored correctly' );
 112         is( $fee_debit->branchcode, $manager->branchcode,
 113             'Fee branchcode stored correctly' );
 114         is( $fee_debit->interface, $interface,
 115             'Fee interface stored correctly' );
 116         is( $fee_debit->debit_type_code,
 117             'RESERVE', 'Fee debit_type_code stored correctly' );
 118         is( $fee_debit->itemnumber, $item->id,
 119             'Fee itemnumber stored correctly' );
 120     };
 121
 122     my $logs = Koha::ActionLogs->search(
 123         {
 124             action => 'FILL',
 125             module => 'HOLDS',
 126             object => $hold->id
 127         }
 128     );
 129
 130     is( $logs->count, 1, '1 log line added' );
 131
 132     # Set HoldFeeMode to something other than any_time_is_collected
 133     t::lib::Mocks::mock_preference( 'HoldFeeMode', 'not_always' );
 134     # Disable logging
 135     t::lib::Mocks::mock_preference( 'HoldsLog',    0 );
 136
 137     $hold = $builder->build_object(
 138         {
 139             class => 'Koha::Holds',
 140             value => {
 141                 biblionumber   => $biblio->id,
 142                 borrowernumber => $patron->id,
 143                 itemnumber     => $item->id,
 144                 priority       => 10,
 145             }
 146         }
 147     );
 148
 149     $hold->fill;
 150
 151     my $account = $patron->account;
 152     is( $account->balance, $fee, 'No new charge applied' );
 153
 154     my $debits = $account->outstanding_debits;
 155     is( $debits->count, 1, 'Only one fee charged, because of HoldFeeMode' );
 156
 157     $logs = Koha::ActionLogs->search(
 158         {
 159             action => 'FILL',
 160             module => 'HOLDS',
 161             object => $hold->id
 162         }
 163     );
 164
 165     is( $logs->count, 0, 'HoldsLog disabled, no logs added' );
 166
 167     subtest 'anonymization behavior tests' => sub {
 168
 169         plan tests => 4;
 170
 171         # reduce the tests noise
 172         t::lib::Mocks::mock_preference( 'HoldsLog',    0 );
 173         t::lib::Mocks::mock_preference( 'HoldFeeMode', 'not_always' );
 174
 175         # 0 == keep forever
 176         $patron->privacy(0)->store;
 177         my $hold = $builder->build_object(
 178             {
 179                 class => 'Koha::Holds',
 180                 value => { borrowernumber => $patron->id, status => undef }
 181             }
 182         );
 183         $hold->fill();
 184         is( Koha::Old::Holds->find( $hold->id )->borrowernumber,
 185             $patron->borrowernumber, 'Patron link is kept' );
 186
 187         # 1 == "default", meaning it is not protected from removal
 188         $patron->privacy(1)->store;
 189         $hold = $builder->build_object(
 190             {
 191                 class => 'Koha::Holds',
 192                 value => { borrowernumber => $patron->id, status => undef }
 193             }
 194         );
 195         $hold->fill();
 196         is( Koha::Old::Holds->find( $hold->id )->borrowernumber,
 197             $patron->borrowernumber, 'Patron link is kept' );
 198
 199         # 2 == delete immediately
 200         $patron->privacy(2)->store;
 201         $hold = $builder->build_object(
 202             {
 203                 class => 'Koha::Holds',
 204                 value => { borrowernumber => $patron->id, status => undef }
 205             }
 206         );
 207         $hold->fill();
 208         is( Koha::Old::Holds->find( $hold->id )->borrowernumber,
 209             undef, 'Patron link is deleted immediately' );
 210
 211         my $anonymous_patron = $builder->build_object({ class => 'Koha::Patrons' });
 212         t::lib::Mocks::mock_preference( 'AnonymousPatron', $anonymous_patron->id );
 213
 214         $hold = $builder->build_object(
 215             {
 216                 class => 'Koha::Holds',
 217                 value => { borrowernumber => $patron->id, status => undef }
 218             }
 219         );
 220         $hold->cancel();
 221         is(
 222             Koha::Old::Holds->find( $hold->id )->borrowernumber,
 223             $anonymous_patron->id,
 224             'Patron link is set to the configured anonymous patron immediately'
 225         );
 226     };
 227
 228     $schema->storage->txn_rollback;
 229 };
 230
 231 subtest 'patron() tests' => sub {
 232
 233     plan tests => 2;
 234
 235     $schema->storage->txn_begin;
 236
 237     my $patron = $builder->build_object({ class => 'Koha::Patrons' });
 238     my $hold   = $builder->build_object(
 239         {
 240             class => 'Koha::Holds',
 241             value => {
 242                 borrowernumber => $patron->borrowernumber
 243             }
 244         }
 245     );
 246
 247     my $hold_patron = $hold->patron;
 248     is( ref($hold_patron), 'Koha::Patron', 'Right type' );
 249     is( $hold_patron->id, $patron->id, 'Right object' );
 250
 251     $schema->storage->txn_rollback;
 252 };
 253
 254 subtest 'set_pickup_location() tests' => sub {
 255
 256     plan tests => 11;
 257
 258     $schema->storage->txn_begin;
 259
 260     my $mock_biblio = Test::MockModule->new('Koha::Biblio');
 261     my $mock_item   = Test::MockModule->new('Koha::Item');
 262
 263     my $library_1 = $builder->build_object({ class => 'Koha::Libraries' });
 264     my $library_2 = $builder->build_object({ class => 'Koha::Libraries' });
 265     my $library_3 = $builder->build_object({ class => 'Koha::Libraries' });
 266
 267     # let's control what Koha::Biblio->pickup_locations returns, for testing
 268     $mock_biblio->mock( 'pickup_locations', sub {
 269         return Koha::Libraries->search( { branchcode => [ $library_2->branchcode, $library_3->branchcode ] } );
 270     });
 271     # let's mock what Koha::Item->pickup_locations returns, for testing
 272     $mock_item->mock( 'pickup_locations', sub {
 273         return Koha::Libraries->search( { branchcode => [ $library_2->branchcode, $library_3->branchcode ] } );
 274     });
 275
 276     my $biblio = $builder->build_sample_biblio;
 277     my $item   = $builder->build_sample_item({ biblionumber => $biblio->biblionumber });
 278
 279     # Test biblio-level holds
 280     my $biblio_hold = $builder->build_object(
 281         {
 282             class => "Koha::Holds",
 283             value => {
 284                 biblionumber => $biblio->biblionumber,
 285                 branchcode   => $library_3->branchcode,
 286                 itemnumber   => undef,
 287             }
 288         }
 289     );
 290
 291     throws_ok
 292         { $biblio_hold->set_pickup_location({ library_id => $library_1->branchcode }); }
 293         'Koha::Exceptions::Hold::InvalidPickupLocation',
 294         'Exception thrown on invalid pickup location';
 295
 296     $biblio_hold->discard_changes;
 297     is( $biblio_hold->branchcode, $library_3->branchcode, 'branchcode remains untouched' );
 298
 299     my $ret = $biblio_hold->set_pickup_location({ library_id => $library_2->id });
 300     is( ref($ret), 'Koha::Hold', 'self is returned' );
 301
 302     $biblio_hold->discard_changes;
 303     is( $biblio_hold->branchcode, $library_2->id, 'Pickup location changed correctly' );
 304
 305     # Test item-level holds
 306     my $item_hold = $builder->build_object(
 307         {
 308             class => "Koha::Holds",
 309             value => {
 310                 biblionumber => $biblio->biblionumber,
 311                 branchcode   => $library_3->branchcode,
 312                 itemnumber   => $item->itemnumber,
 313             }
 314         }
 315     );
 316
 317     throws_ok
 318         { $item_hold->set_pickup_location({ library_id => $library_1->branchcode }); }
 319         'Koha::Exceptions::Hold::InvalidPickupLocation',
 320         'Exception thrown on invalid pickup location';
 321
 322     $item_hold->discard_changes;
 323     is( $item_hold->branchcode, $library_3->branchcode, 'branchcode remains untouched' );
 324
 325     $item_hold->set_pickup_location({ library_id => $library_1->branchcode, force => 1 });
 326     $item_hold->discard_changes;
 327     is( $item_hold->branchcode, $library_1->branchcode, 'branchcode changed because of \'force\'' );
 328
 329     $ret = $item_hold->set_pickup_location({ library_id => $library_2->id });
 330     is( ref($ret), 'Koha::Hold', 'self is returned' );
 331
 332     $item_hold->discard_changes;
 333     is( $item_hold->branchcode, $library_2->id, 'Pickup location changed correctly' );
 334
 335     throws_ok
 336         { $item_hold->set_pickup_location({ library_id => undef }); }
 337         'Koha::Exceptions::MissingParameter',
 338         'Exception thrown if missing parameter';
 339
 340     is( "$@", 'The library_id parameter is mandatory', 'Exception message is clear' );
 341
 342     $schema->storage->txn_rollback;
 343 };
 344
 345 subtest 'is_pickup_location_valid() tests' => sub {
 346
 347     plan tests => 5;
 348
 349     $schema->storage->txn_begin;
 350
 351     my $mock_biblio = Test::MockModule->new('Koha::Biblio');
 352     my $mock_item   = Test::MockModule->new('Koha::Item');
 353
 354     my $library_1 = $builder->build_object({ class => 'Koha::Libraries' });
 355     my $library_2 = $builder->build_object({ class => 'Koha::Libraries' });
 356     my $library_3 = $builder->build_object({ class => 'Koha::Libraries' });
 357
 358     # let's control what Koha::Biblio->pickup_locations returns, for testing
 359     $mock_biblio->mock( 'pickup_locations', sub {
 360         return Koha::Libraries->search( { branchcode => [ $library_2->branchcode, $library_3->branchcode ] } );
 361     });
 362     # let's mock what Koha::Item->pickup_locations returns, for testing
 363     $mock_item->mock( 'pickup_locations', sub {
 364         return Koha::Libraries->search( { branchcode => [ $library_2->branchcode, $library_3->branchcode ] } );
 365     });
 366
 367     my $biblio = $builder->build_sample_biblio;
 368     my $item   = $builder->build_sample_item({ biblionumber => $biblio->biblionumber });
 369
 370     # Test biblio-level holds
 371     my $biblio_hold = $builder->build_object(
 372         {
 373             class => "Koha::Holds",
 374             value => {
 375                 biblionumber => $biblio->biblionumber,
 376                 branchcode   => $library_3->branchcode,
 377                 itemnumber   => undef,
 378             }
 379         }
 380     );
 381
 382     ok( !$biblio_hold->is_pickup_location_valid({ library_id => $library_1->branchcode }), 'Pickup location invalid');
 383     ok( $biblio_hold->is_pickup_location_valid({ library_id => $library_2->id }), 'Pickup location valid');
 384
 385     # Test item-level holds
 386     my $item_hold = $builder->build_object(
 387         {
 388             class => "Koha::Holds",
 389             value => {
 390                 biblionumber => $biblio->biblionumber,
 391                 branchcode   => $library_3->branchcode,
 392                 itemnumber   => $item->itemnumber,
 393             }
 394         }
 395     );
 396
 397     ok( !$item_hold->is_pickup_location_valid({ library_id => $library_1->branchcode }), 'Pickup location invalid');
 398     ok( $item_hold->is_pickup_location_valid({ library_id => $library_2->id }), 'Pickup location valid' );
 399
 400     subtest 'pickup_locations() returning ->empty' => sub {
 401
 402         plan tests => 2;
 403
 404         $schema->storage->txn_begin;
 405
 406         my $library = $builder->build_object({ class => 'Koha::Libraries' });
 407
 408         my $mock_item = Test::MockModule->new('Koha::Item');
 409         $mock_item->mock( 'pickup_locations', sub { return Koha::Libraries->new->empty; } );
 410
 411         my $mock_biblio = Test::MockModule->new('Koha::Biblio');
 412         $mock_biblio->mock( 'pickup_locations', sub { return Koha::Libraries->new->empty; } );
 413
 414         my $item   = $builder->build_sample_item();
 415         my $biblio = $item->biblio;
 416
 417         # Test biblio-level holds
 418         my $biblio_hold = $builder->build_object(
 419             {
 420                 class => "Koha::Holds",
 421                 value => {
 422                     biblionumber => $biblio->biblionumber,
 423                     itemnumber   => undef,
 424                 }
 425             }
 426         );
 427
 428         ok( !$biblio_hold->is_pickup_location_valid({ library_id => $library->branchcode }), 'Pickup location invalid');
 429
 430         # Test item-level holds
 431         my $item_hold = $builder->build_object(
 432             {
 433                 class => "Koha::Holds",
 434                 value => {
 435                     biblionumber => $biblio->biblionumber,
 436                     itemnumber   => $item->itemnumber,
 437                 }
 438             }
 439         );
 440
 441         ok( !$item_hold->is_pickup_location_valid({ library_id => $library->branchcode }), 'Pickup location invalid');
 442
 443         $schema->storage->txn_rollback;
 444     };
 445
 446     $schema->storage->txn_rollback;
 447 };
 448
 449 subtest 'cancel() tests' => sub {
 450
 451     plan tests => 4;
 452
 453     $schema->storage->txn_begin;
 454
 455     my $patron = $builder->build_object( { class => 'Koha::Patrons' } );
 456
 457     # reduce the tests noise
 458     t::lib::Mocks::mock_preference( 'HoldsLog', 0 );
 459     t::lib::Mocks::mock_preference( 'ExpireReservesMaxPickUpDelayCharge',
 460         undef );
 461
 462     t::lib::Mocks::mock_preference( 'AnonymousPatron', undef );
 463
 464     # 0 == keep forever
 465     $patron->privacy(0)->store;
 466     my $hold = $builder->build_object(
 467         {
 468             class => 'Koha::Holds',
 469             value => { borrowernumber => $patron->id, status => undef }
 470         }
 471     );
 472     $hold->cancel();
 473     is( Koha::Old::Holds->find( $hold->id )->borrowernumber,
 474         $patron->borrowernumber, 'Patron link is kept' );
 475
 476     # 1 == "default", meaning it is not protected from removal
 477     $patron->privacy(1)->store;
 478     $hold = $builder->build_object(
 479         {
 480             class => 'Koha::Holds',
 481             value => { borrowernumber => $patron->id, status => undef }
 482         }
 483     );
 484     $hold->cancel();
 485     is( Koha::Old::Holds->find( $hold->id )->borrowernumber,
 486         $patron->borrowernumber, 'Patron link is kept' );
 487
 488     # 2 == delete immediately
 489     $patron->privacy(2)->store;
 490     $hold = $builder->build_object(
 491         {
 492             class => 'Koha::Holds',
 493             value => { borrowernumber => $patron->id, status => undef }
 494         }
 495     );
 496     $hold->cancel();
 497     is( Koha::Old::Holds->find( $hold->id )->borrowernumber,
 498         undef, 'Patron link is deleted immediately' );
 499
 500     my $anonymous_patron = $builder->build_object({ class => 'Koha::Patrons' });
 501     t::lib::Mocks::mock_preference( 'AnonymousPatron', $anonymous_patron->id );
 502
 503     $hold = $builder->build_object(
 504         {
 505             class => 'Koha::Holds',
 506             value => { borrowernumber => $patron->id, status => undef }
 507         }
 508     );
 509     $hold->cancel();
 510     is(
 511         Koha::Old::Holds->find( $hold->id )->borrowernumber,
 512         $anonymous_patron->id,
 513         'Patron link is set to the configured anonymous patron immediately'
 514     );
 515
 516     $schema->storage->txn_rollback;
 517 };