t/db_dependent/Circulation.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 use utf8;
  20
  21 use Test::More tests => 65;
  22 use Test::Exception;
  23 use Test::MockModule;
  24 use Test::Deep qw( cmp_deeply );
  25 use Test::Warn;
  26
  27 use Data::Dumper;
  28 use DateTime;
  29 use Time::Fake;
  30 use POSIX qw( floor );
  31 use t::lib::Mocks;
  32 use t::lib::TestBuilder;
  33
  34 use C4::Accounts;
  35 use C4::Calendar qw( new insert_single_holiday insert_week_day_holiday delete_holiday );
  36 use C4::Circulation qw( AddIssue AddReturn CanBookBeRenewed GetIssuingCharges AddRenewal GetSoonestRenewDate GetLatestAutoRenewDate LostItem GetUpcomingDueIssues CanBookBeIssued AddIssuingCharge MarkIssueReturned ProcessOfflinePayment transferbook updateWrongTransfer );
  37 use C4::Biblio;
  38 use C4::Items qw( ModItemTransfer );
  39 use C4::Log;
  40 use C4::Reserves qw( AddReserve ModReserve ModReserveCancelAll ModReserveAffect CheckReserves GetOtherReserves );
  41 use C4::Overdues qw( CalcFine UpdateFine get_chargeable_units );
  42 use C4::Members::Messaging qw( SetMessagingPreference );
  43 use Koha::DateUtils qw( dt_from_string output_pref );
  44 use Koha::Database;
  45 use Koha::Items;
  46 use Koha::Item::Transfers;
  47 use Koha::Checkouts;
  48 use Koha::Patrons;
  49 use Koha::Patron::Debarments qw( AddDebarment DelUniqueDebarment );
  50 use Koha::Holds;
  51 use Koha::CirculationRules;
  52 use Koha::Subscriptions;
  53 use Koha::Account::Lines;
  54 use Koha::Account::Offsets;
  55 use Koha::ActionLogs;
  56 use Koha::Notice::Messages;
  57 use Koha::Cache::Memory::Lite;
  58
  59 my $builder = t::lib::TestBuilder->new;
  60 sub set_userenv {
  61     my ( $library ) = @_;
  62     my $staff = $builder->build_object({ class => "Koha::Patrons" });
  63     t::lib::Mocks::mock_userenv({ patron => $staff, branchcode => $library->{branchcode} });
  64 }
  65
  66 sub str {
  67     my ( $error, $question, $alert ) = @_;
  68     my $s;
  69     $s  = %$error    ? ' (error: '    . join( ' ', keys %$error    ) . ')' : '';
  70     $s .= %$question ? ' (question: ' . join( ' ', keys %$question ) . ')' : '';
  71     $s .= %$alert    ? ' (alert: '    . join( ' ', keys %$alert    ) . ')' : '';
  72     return $s;
  73 }
  74
  75 sub test_debarment_on_checkout {
  76     my ($params) = @_;
  77     my $item     = $params->{item};
  78     my $library  = $params->{library};
  79     my $patron   = $params->{patron};
  80     my $due_date = $params->{due_date} || dt_from_string;
  81     my $return_date = $params->{return_date} || dt_from_string;
  82     my $expected_expiration_date = $params->{expiration_date};
  83
  84     $expected_expiration_date = output_pref(
  85         {
  86             dt         => $expected_expiration_date,
  87             dateformat => 'sql',
  88             dateonly   => 1,
  89         }
  90     );
  91     my @caller      = caller;
  92     my $line_number = $caller[2];
  93     AddIssue( $patron->unblessed, $item->barcode, $due_date );
  94
  95     my ( undef, $message ) = AddReturn( $item->barcode, $library->{branchcode}, undef, $return_date );
  96     is( $message->{WasReturned} && exists $message->{Debarred}, 1, 'AddReturn must have debarred the patron' )
  97         or diag('AddReturn returned message ' . Dumper $message );
  98     my $suspensions = $patron->restrictions->search({ type => 'SUSPENSION' } );
  99     is( $suspensions->count, 1, 'Test at line ' . $line_number );
 100
 101     my $THE_suspension = $suspensions->next;
 102     is( $THE_suspension->expiration,
 103         $expected_expiration_date, 'Test at line ' . $line_number );
 104     Koha::Patron::Debarments::DelUniqueDebarment(
 105         { borrowernumber => $patron->borrowernumber, type => 'SUSPENSION' } );
 106 };
 107
 108 my $schema = Koha::Database->schema;
 109 $schema->storage->txn_begin;
 110 my $dbh = C4::Context->dbh;
 111
 112 # Prevent random failures by mocking ->now
 113 my $now_value       = dt_from_string;
 114 my $mocked_datetime = Test::MockModule->new('DateTime');
 115 $mocked_datetime->mock( 'now', sub { return $now_value->clone; } );
 116
 117 my $cache = Koha::Caches->get_instance();
 118 $dbh->do(q|DELETE FROM special_holidays|);
 119 $dbh->do(q|DELETE FROM repeatable_holidays|);
 120 my $branches = Koha::Libraries->search();
 121 for my $branch ( $branches->next ) {
 122     my $key = $branch->branchcode . "_holidays";
 123     $cache->clear_from_cache($key);
 124 }
 125
 126 # Start with a clean slate
 127 $dbh->do('DELETE FROM issues');
 128 $dbh->do('DELETE FROM borrowers');
 129
 130 # Disable recording of the staff who checked out an item until we're ready for it
 131 t::lib::Mocks::mock_preference('RecordStaffUserOnCheckout', 0);
 132
 133 my $module = Test::MockModule->new('C4::Context');
 134
 135 my $library = $builder->build({
 136     source => 'Branch',
 137 });
 138 my $library2 = $builder->build({
 139     source => 'Branch',
 140 });
 141 my $itemtype = $builder->build(
 142     {
 143         source => 'Itemtype',
 144         value  => {
 145             notforloan          => undef,
 146             rentalcharge        => 0,
 147             rentalcharge_daily => 0,
 148             defaultreplacecost  => undef,
 149             processfee          => undef
 150         }
 151     }
 152 )->{itemtype};
 153 my $patron_category = $builder->build(
 154     {
 155         source => 'Category',
 156         value  => {
 157             category_type                 => 'P',
 158             enrolmentfee                  => 0,
 159             BlockExpiredPatronOpacActions => -1, # Pick the pref value
 160         }
 161     }
 162 );
 163
 164 my $CircControl = C4::Context->preference('CircControl');
 165 my $HomeOrHoldingBranch = C4::Context->preference('HomeOrHoldingBranch');
 166
 167 my $item = {
 168     homebranch => $library2->{branchcode},
 169     holdingbranch => $library2->{branchcode}
 170 };
 171
 172 my $borrower = {
 173     branchcode => $library2->{branchcode}
 174 };
 175
 176 t::lib::Mocks::mock_preference('AutoReturnCheckedOutItems', 0);
 177
 178 # No userenv, PickupLibrary
 179 t::lib::Mocks::mock_preference('IndependentBranches', '0');
 180 t::lib::Mocks::mock_preference('CircControl', 'PickupLibrary');
 181 is(
 182     C4::Context->preference('CircControl'),
 183     'PickupLibrary',
 184     'CircControl changed to PickupLibrary'
 185 );
 186 is(
 187     C4::Circulation::_GetCircControlBranch($item, $borrower),
 188     $item->{$HomeOrHoldingBranch},
 189     '_GetCircControlBranch returned item branch (no userenv defined)'
 190 );
 191
 192 # No userenv, PatronLibrary
 193 t::lib::Mocks::mock_preference('CircControl', 'PatronLibrary');
 194 is(
 195     C4::Context->preference('CircControl'),
 196     'PatronLibrary',
 197     'CircControl changed to PatronLibrary'
 198 );
 199 is(
 200     C4::Circulation::_GetCircControlBranch($item, $borrower),
 201     $borrower->{branchcode},
 202     '_GetCircControlBranch returned borrower branch'
 203 );
 204
 205 # No userenv, ItemHomeLibrary
 206 t::lib::Mocks::mock_preference('CircControl', 'ItemHomeLibrary');
 207 is(
 208     C4::Context->preference('CircControl'),
 209     'ItemHomeLibrary',
 210     'CircControl changed to ItemHomeLibrary'
 211 );
 212 is(
 213     $item->{$HomeOrHoldingBranch},
 214     C4::Circulation::_GetCircControlBranch($item, $borrower),
 215     '_GetCircControlBranch returned item branch'
 216 );
 217
 218 # Now, set a userenv
 219 t::lib::Mocks::mock_userenv({ branchcode => $library2->{branchcode} });
 220 is(C4::Context->userenv->{branch}, $library2->{branchcode}, 'userenv set');
 221
 222 # Userenv set, PickupLibrary
 223 t::lib::Mocks::mock_preference('CircControl', 'PickupLibrary');
 224 is(
 225     C4::Context->preference('CircControl'),
 226     'PickupLibrary',
 227     'CircControl changed to PickupLibrary'
 228 );
 229 is(
 230     C4::Circulation::_GetCircControlBranch($item, $borrower),
 231     $library2->{branchcode},
 232     '_GetCircControlBranch returned current branch'
 233 );
 234
 235 # Userenv set, PatronLibrary
 236 t::lib::Mocks::mock_preference('CircControl', 'PatronLibrary');
 237 is(
 238     C4::Context->preference('CircControl'),
 239     'PatronLibrary',
 240     'CircControl changed to PatronLibrary'
 241 );
 242 is(
 243     C4::Circulation::_GetCircControlBranch($item, $borrower),
 244     $borrower->{branchcode},
 245     '_GetCircControlBranch returned borrower branch'
 246 );
 247
 248 # Userenv set, ItemHomeLibrary
 249 t::lib::Mocks::mock_preference('CircControl', 'ItemHomeLibrary');
 250 is(
 251     C4::Context->preference('CircControl'),
 252     'ItemHomeLibrary',
 253     'CircControl changed to ItemHomeLibrary'
 254 );
 255 is(
 256     C4::Circulation::_GetCircControlBranch($item, $borrower),
 257     $item->{$HomeOrHoldingBranch},
 258     '_GetCircControlBranch returned item branch'
 259 );
 260
 261 # Reset initial configuration
 262 t::lib::Mocks::mock_preference('CircControl', $CircControl);
 263 is(
 264     C4::Context->preference('CircControl'),
 265     $CircControl,
 266     'CircControl reset to its initial value'
 267 );
 268
 269 # Set a simple circ policy
 270 $dbh->do('DELETE FROM circulation_rules');
 271 Koha::CirculationRules->set_rules(
 272     {
 273         categorycode => undef,
 274         branchcode   => undef,
 275         itemtype     => undef,
 276         rules        => {
 277             reservesallowed => 25,
 278             issuelength     => 14,
 279             lengthunit      => 'days',
 280             renewalsallowed => 1,
 281             renewalperiod   => 7,
 282             norenewalbefore => undef,
 283             auto_renew      => 0,
 284             fine            => .10,
 285             chargeperiod    => 1,
 286         }
 287     }
 288 );
 289
 290 subtest "CanBookBeRenewed AllowRenewalIfOtherItemsAvailable multiple borrowers and items tests" => sub {
 291     plan tests => 5;
 292
 293     #Can only reserve from home branch
 294     Koha::CirculationRules->set_rule(
 295         {
 296             branchcode   => undef,
 297             itemtype     => undef,
 298             rule_name    => 'holdallowed',
 299             rule_value   => 1
 300         }
 301     );
 302     Koha::CirculationRules->set_rule(
 303         {
 304             branchcode   => undef,
 305             categorycode   => undef,
 306             itemtype     => undef,
 307             rule_name    => 'onshelfholds',
 308             rule_value   => 1
 309         }
 310     );
 311
 312     # Patrons from three different branches
 313     my $patron_borrower = $builder->build_object({ class => 'Koha::Patrons' });
 314     my $patron_hold_1   = $builder->build_object({ class => 'Koha::Patrons' });
 315     my $patron_hold_2   = $builder->build_object({ class => 'Koha::Patrons' });
 316     my $biblio = $builder->build_sample_biblio();
 317
 318     # Item at each patron branch
 319     my $item_1 = $builder->build_sample_item({
 320         biblionumber => $biblio->biblionumber,
 321         homebranch   => $patron_borrower->branchcode
 322     });
 323     my $item_2 = $builder->build_sample_item({
 324         biblionumber => $biblio->biblionumber,
 325         homebranch   => $patron_hold_2->branchcode
 326     });
 327     my $item_3 = $builder->build_sample_item({
 328         biblionumber => $biblio->biblionumber,
 329         homebranch   => $patron_hold_1->branchcode
 330     });
 331
 332     my $issue = AddIssue( $patron_borrower->unblessed, $item_1->barcode);
 333     my $datedue = dt_from_string( $issue->date_due() );
 334     is (defined $issue->date_due(), 1, "Item 1 checked out, due date: " . $issue->date_due() );
 335
 336     # Biblio-level holds
 337     AddReserve(
 338         {
 339             branchcode       => $patron_hold_1->branchcode,
 340             borrowernumber   => $patron_hold_1->borrowernumber,
 341             biblionumber     => $biblio->biblionumber,
 342             priority         => 1,
 343             reservation_date => dt_from_string(),
 344             expiration_date  => undef,
 345             itemnumber       => undef,
 346             found            => undef,
 347         }
 348     );
 349     AddReserve(
 350         {
 351             branchcode       => $patron_hold_2->branchcode,
 352             borrowernumber   => $patron_hold_2->borrowernumber,
 353             biblionumber     => $biblio->biblionumber,
 354             priority         => 2,
 355             reservation_date => dt_from_string(),
 356             expiration_date  => undef,
 357             itemnumber       => undef,
 358             found            => undef,
 359         }
 360     );
 361     t::lib::Mocks::mock_preference('AllowRenewalIfOtherItemsAvailable', 0 );
 362
 363     my ( $renewokay, $error ) = CanBookBeRenewed($patron_borrower->borrowernumber, $item_1->itemnumber);
 364     is( $renewokay, 0, 'Cannot renew, reserved');
 365     is( $error, 'on_reserve', 'Cannot renew, reserved (returned error is on_reserve)');
 366
 367     t::lib::Mocks::mock_preference('AllowRenewalIfOtherItemsAvailable', 1 );
 368
 369     ( $renewokay, $error ) = CanBookBeRenewed($patron_borrower->borrowernumber, $item_1->itemnumber);
 370     is( $renewokay, 1, 'Can renew, two items available for two holds');
 371     is( $error, undef, 'Can renew, each reserve has an item');
 372
 373
 374 };
 375
 376 subtest "GetIssuingCharges tests" => sub {
 377     plan tests => 4;
 378     my $branch_discount = $builder->build_object({ class => 'Koha::Libraries' });
 379     my $branch_no_discount = $builder->build_object({ class => 'Koha::Libraries' });
 380     Koha::CirculationRules->set_rule(
 381         {
 382             categorycode => undef,
 383             branchcode   => $branch_discount->branchcode,
 384             itemtype     => undef,
 385             rule_name    => 'rentaldiscount',
 386             rule_value   => 15
 387         }
 388     );
 389     my $itype_charge = $builder->build_object({
 390         class => 'Koha::ItemTypes',
 391         value => {
 392             rentalcharge => 10
 393         }
 394     });
 395     my $itype_no_charge = $builder->build_object({
 396         class => 'Koha::ItemTypes',
 397         value => {
 398             rentalcharge => 0
 399         }
 400     });
 401     my $patron = $builder->build_object({ class => 'Koha::Patrons' });
 402     my $item_1 = $builder->build_sample_item({ itype => $itype_charge->itemtype });
 403     my $item_2 = $builder->build_sample_item({ itype => $itype_no_charge->itemtype });
 404
 405     t::lib::Mocks::mock_userenv({ branchcode => $branch_no_discount->branchcode });
 406     # For now the sub always uses the env branch, this should follow CircControl instead
 407     my ($charge, $itemtype) = GetIssuingCharges( $item_1->itemnumber, $patron->borrowernumber);
 408     is( $charge + 0, 10.00, "Charge fetched correctly when no discount exists");
 409     ($charge, $itemtype) = GetIssuingCharges( $item_2->itemnumber, $patron->borrowernumber);
 410     is( $charge + 0, 0.00, "Charge fetched correctly when no discount exists and no charge");
 411
 412     t::lib::Mocks::mock_userenv({ branchcode => $branch_discount->branchcode });
 413     # For now the sub always uses the env branch, this should follow CircControl instead
 414     ($charge, $itemtype) = GetIssuingCharges( $item_1->itemnumber, $patron->borrowernumber);
 415     is( $charge + 0, 8.50, "Charge fetched correctly when discount exists");
 416     ($charge, $itemtype) = GetIssuingCharges( $item_2->itemnumber, $patron->borrowernumber);
 417     is( $charge + 0, 0.00, "Charge fetched correctly when discount exists and no charge");
 418
 419 };
 420
 421 my ( $reused_itemnumber_1, $reused_itemnumber_2 );
 422 subtest "CanBookBeRenewed tests" => sub {
 423     plan tests => 104;
 424
 425     C4::Context->set_preference('ItemsDeniedRenewal','');
 426     # Generate test biblio
 427     my $biblio = $builder->build_sample_biblio();
 428
 429     my $branch = $library2->{branchcode};
 430
 431     my $item_1 = $builder->build_sample_item(
 432         {
 433             biblionumber     => $biblio->biblionumber,
 434             library          => $branch,
 435             replacementprice => 12.00,
 436             itype            => $itemtype
 437         }
 438     );
 439     $reused_itemnumber_1 = $item_1->itemnumber;
 440
 441     my $item_2 = $builder->build_sample_item(
 442         {
 443             biblionumber     => $biblio->biblionumber,
 444             library          => $branch,
 445             replacementprice => 23.00,
 446             itype            => $itemtype
 447         }
 448     );
 449     $reused_itemnumber_2 = $item_2->itemnumber;
 450
 451     my $item_3 = $builder->build_sample_item(
 452         {
 453             biblionumber     => $biblio->biblionumber,
 454             library          => $branch,
 455             replacementprice => 23.00,
 456             itype            => $itemtype
 457         }
 458     );
 459
 460     # Create borrowers
 461     my %renewing_borrower_data = (
 462         firstname =>  'John',
 463         surname => 'Renewal',
 464         categorycode => $patron_category->{categorycode},
 465         branchcode => $branch,
 466     );
 467
 468     my %reserving_borrower_data = (
 469         firstname =>  'Katrin',
 470         surname => 'Reservation',
 471         categorycode => $patron_category->{categorycode},
 472         branchcode => $branch,
 473     );
 474
 475     my %hold_waiting_borrower_data = (
 476         firstname =>  'Kyle',
 477         surname => 'Reservation',
 478         categorycode => $patron_category->{categorycode},
 479         branchcode => $branch,
 480     );
 481
 482     my %restricted_borrower_data = (
 483         firstname =>  'Alice',
 484         surname => 'Reservation',
 485         categorycode => $patron_category->{categorycode},
 486         debarred => '3228-01-01',
 487         branchcode => $branch,
 488     );
 489
 490     my %expired_borrower_data = (
 491         firstname =>  'Ça',
 492         surname => 'Glisse',
 493         categorycode => $patron_category->{categorycode},
 494         branchcode => $branch,
 495         dateexpiry => dt_from_string->subtract( months => 1 ),
 496     );
 497
 498     my $renewing_borrowernumber = Koha::Patron->new(\%renewing_borrower_data)->store->borrowernumber;
 499     my $reserving_borrowernumber = Koha::Patron->new(\%reserving_borrower_data)->store->borrowernumber;
 500     my $hold_waiting_borrowernumber = Koha::Patron->new(\%hold_waiting_borrower_data)->store->borrowernumber;
 501     my $restricted_borrowernumber = Koha::Patron->new(\%restricted_borrower_data)->store->borrowernumber;
 502     my $expired_borrowernumber = Koha::Patron->new(\%expired_borrower_data)->store->borrowernumber;
 503
 504     my $renewing_borrower_obj = Koha::Patrons->find( $renewing_borrowernumber );
 505     my $renewing_borrower = $renewing_borrower_obj->unblessed;
 506     my $restricted_borrower = Koha::Patrons->find( $restricted_borrowernumber )->unblessed;
 507     my $expired_borrower = Koha::Patrons->find( $expired_borrowernumber )->unblessed;
 508
 509     my $bibitems       = '';
 510     my $priority       = '1';
 511     my $resdate        = undef;
 512     my $expdate        = undef;
 513     my $notes          = '';
 514     my $checkitem      = undef;
 515     my $found          = undef;
 516
 517     my $issue = AddIssue( $renewing_borrower, $item_1->barcode);
 518     my $datedue = dt_from_string( $issue->date_due() );
 519     is (defined $issue->date_due(), 1, "Item 1 checked out, due date: " . $issue->date_due() );
 520
 521     my $issue2 = AddIssue( $renewing_borrower, $item_2->barcode);
 522     $datedue = dt_from_string( $issue->date_due() );
 523     is (defined $issue2, 1, "Item 2 checked out, due date: " . $issue2->date_due());
 524
 525
 526     my $borrowing_borrowernumber = Koha::Checkouts->find( { itemnumber => $item_1->itemnumber } )->borrowernumber;
 527     is ($borrowing_borrowernumber, $renewing_borrowernumber, "Item checked out to $renewing_borrower->{firstname} $renewing_borrower->{surname}");
 528
 529     my ( $renewokay, $error ) = CanBookBeRenewed($renewing_borrowernumber, $item_1->itemnumber, 1);
 530     is( $renewokay, 1, 'Can renew, no holds for this title or item');
 531
 532
 533     # Biblio-level hold, renewal test
 534     AddReserve(
 535         {
 536             branchcode       => $branch,
 537             borrowernumber   => $reserving_borrowernumber,
 538             biblionumber     => $biblio->biblionumber,
 539             priority         => $priority,
 540             reservation_date => $resdate,
 541             expiration_date  => $expdate,
 542             notes            => $notes,
 543             itemnumber       => $checkitem,
 544             found            => $found,
 545         }
 546     );
 547
 548     # Testing of feature to allow the renewal of reserved items if other items on the record can fill all needed holds
 549     Koha::CirculationRules->set_rule(
 550         {
 551             categorycode => undef,
 552             branchcode   => undef,
 553             itemtype     => undef,
 554             rule_name    => 'onshelfholds',
 555             rule_value   => '1',
 556         }
 557     );
 558     Koha::CirculationRules->set_rule(
 559         {
 560             categorycode => undef,
 561             branchcode   => undef,
 562             itemtype     => undef,
 563             rule_name    => 'renewalsallowed',
 564             rule_value   => '5',
 565         }
 566     );
 567     t::lib::Mocks::mock_preference('AllowRenewalIfOtherItemsAvailable', 1 );
 568     ( $renewokay, $error ) = CanBookBeRenewed($renewing_borrowernumber, $item_1->itemnumber);
 569     is( $renewokay, 1, 'Bug 11634 - Allow renewal of item with unfilled holds if other available items can fill those holds');
 570     ( $renewokay, $error ) = CanBookBeRenewed($renewing_borrowernumber, $item_2->itemnumber);
 571     is( $renewokay, 1, 'Bug 11634 - Allow renewal of item with unfilled holds if other available items can fill those holds');
 572
 573
 574     # Second biblio-level hold
 575     my $reserve_id = AddReserve(
 576         {
 577             branchcode       => $branch,
 578             borrowernumber   => $reserving_borrowernumber,
 579             biblionumber     => $biblio->biblionumber,
 580             priority         => $priority,
 581             reservation_date => $resdate,
 582             expiration_date  => $expdate,
 583             notes            => $notes,
 584             itemnumber       => $checkitem,
 585             found            => $found,
 586         }
 587     );
 588     ( $renewokay, $error ) = CanBookBeRenewed($renewing_borrowernumber, $item_1->itemnumber);
 589     is( $renewokay, 0, 'Renewal not possible when single patron\'s holds exceed the number of available items');
 590     Koha::Holds->find($reserve_id)->delete;
 591
 592     # Now let's add an item level hold, we should no longer be able to renew the item
 593     my $hold = Koha::Database->new()->schema()->resultset('Reserve')->create(
 594         {
 595             borrowernumber => $hold_waiting_borrowernumber,
 596             biblionumber   => $biblio->biblionumber,
 597             itemnumber     => $item_1->itemnumber,
 598             branchcode     => $branch,
 599             priority       => 3,
 600             reservedate    => '1999-01-01',
 601         }
 602     );
 603     ( $renewokay, $error ) = CanBookBeRenewed($renewing_borrowernumber, $item_1->itemnumber);
 604     is( $renewokay, 0, 'Bug 13919 - Renewal possible with item level hold on item');
 605     $hold->delete();
 606
 607     # Now let's add a waiting hold on the 3rd item, it's no longer available tp check out by just anyone, so we should no longer
 608     # be able to renew these items
 609     $hold = Koha::Database->new()->schema()->resultset('Reserve')->create(
 610         {
 611             borrowernumber => $hold_waiting_borrowernumber,
 612             biblionumber   => $biblio->biblionumber,
 613             itemnumber     => $item_3->itemnumber,
 614             branchcode     => $branch,
 615             priority       => 0,
 616             found          => 'W'
 617         }
 618     );
 619     ( $renewokay, $error ) = CanBookBeRenewed($renewing_borrowernumber, $item_1->itemnumber);
 620     is( $renewokay, 0, 'Bug 11634 - Allow renewal of item with unfilled holds if other available items can fill those holds');
 621     ( $renewokay, $error ) = CanBookBeRenewed($renewing_borrowernumber, $item_2->itemnumber);
 622     is( $renewokay, 0, 'Bug 11634 - Allow renewal of item with unfilled holds if other available items can fill those holds');
 623     t::lib::Mocks::mock_preference('AllowRenewalIfOtherItemsAvailable', 0 );
 624
 625     ( $renewokay, $error ) = CanBookBeRenewed($renewing_borrowernumber, $item_1->itemnumber);
 626     is( $renewokay, 0, '(Bug 10663) Cannot renew, reserved');
 627     is( $error, 'on_reserve', '(Bug 10663) Cannot renew, reserved (returned error is on_reserve)');
 628
 629     ( $renewokay, $error ) = CanBookBeRenewed($renewing_borrowernumber, $item_2->itemnumber);
 630     is( $renewokay, 0, '(Bug 10663) Cannot renew, reserved');
 631     is( $error, 'on_reserve', '(Bug 10663) Cannot renew, reserved (returned error is on_reserve)');
 632
 633     my $reserveid = Koha::Holds->search({ biblionumber => $biblio->biblionumber, borrowernumber => $reserving_borrowernumber })->next->reserve_id;
 634     my $reserving_borrower = Koha::Patrons->find( $reserving_borrowernumber )->unblessed;
 635     AddIssue($reserving_borrower, $item_3->barcode);
 636     my $reserve = $dbh->selectrow_hashref(
 637         'SELECT * FROM old_reserves WHERE reserve_id = ?',
 638         { Slice => {} },
 639         $reserveid
 640     );
 641     is($reserve->{found}, 'F', 'hold marked completed when checking out item that fills it');
 642
 643     # Item-level hold, renewal test
 644     AddReserve(
 645         {
 646             branchcode       => $branch,
 647             borrowernumber   => $reserving_borrowernumber,
 648             biblionumber     => $biblio->biblionumber,
 649             priority         => $priority,
 650             reservation_date => $resdate,
 651             expiration_date  => $expdate,
 652             notes            => $notes,
 653             itemnumber       => $item_1->itemnumber,
 654             found            => $found,
 655         }
 656     );
 657
 658     ( $renewokay, $error ) = CanBookBeRenewed($renewing_borrowernumber, $item_1->itemnumber, 1);
 659     is( $renewokay, 0, '(Bug 10663) Cannot renew, item reserved');
 660     is( $error, 'on_reserve', '(Bug 10663) Cannot renew, item reserved (returned error is on_reserve)');
 661
 662     ( $renewokay, $error ) = CanBookBeRenewed($renewing_borrowernumber, $item_2->itemnumber, 1);
 663     is( $renewokay, 1, 'Can renew item 2, item-level hold is on item 1');
 664
 665     # Items can't fill hold for reasons
 666     $item_1->notforloan(1)->store;
 667     ( $renewokay, $error ) = CanBookBeRenewed($renewing_borrowernumber, $item_1->itemnumber, 1);
 668     is( $renewokay, 1, 'Can renew, item is marked not for loan, hold does not block');
 669     $item_1->set({notforloan => 0, itype => $itemtype })->store;
 670
 671     # FIXME: Add more for itemtype not for loan etc.
 672
 673     # Restricted users cannot renew when RestrictionBlockRenewing is enabled
 674     my $item_5 = $builder->build_sample_item(
 675         {
 676             biblionumber     => $biblio->biblionumber,
 677             library          => $branch,
 678             replacementprice => 23.00,
 679             itype            => $itemtype,
 680         }
 681     );
 682     my $datedue5 = AddIssue($restricted_borrower, $item_5->barcode);
 683     is (defined $datedue5, 1, "Item with date due checked out, due date: $datedue5");
 684
 685     t::lib::Mocks::mock_preference('RestrictionBlockRenewing','1');
 686     ( $renewokay, $error ) = CanBookBeRenewed($renewing_borrowernumber, $item_2->itemnumber);
 687     is( $renewokay, 1, '(Bug 8236), Can renew, user is not restricted');
 688     ( $renewokay, $error ) = CanBookBeRenewed($restricted_borrowernumber, $item_5->itemnumber);
 689     is( $renewokay, 0, '(Bug 8236), Cannot renew, user is restricted');
 690     is( $error, 'restriction', "Correct error returned");
 691
 692     # Users cannot renew an overdue item
 693     my $item_6 = $builder->build_sample_item(
 694         {
 695             biblionumber     => $biblio->biblionumber,
 696             library          => $branch,
 697             replacementprice => 23.00,
 698             itype            => $itemtype,
 699         }
 700     );
 701
 702     my $item_7 = $builder->build_sample_item(
 703         {
 704             biblionumber     => $biblio->biblionumber,
 705             library          => $branch,
 706             replacementprice => 23.00,
 707             itype            => $itemtype,
 708         }
 709     );
 710
 711     my $datedue6 = AddIssue( $renewing_borrower, $item_6->barcode);
 712     is (defined $datedue6, 1, "Item 2 checked out, due date: ".$datedue6->date_due);
 713
 714     my $now = dt_from_string();
 715     my $five_weeks = DateTime::Duration->new(weeks => 5);
 716     my $five_weeks_ago = $now - $five_weeks;
 717     t::lib::Mocks::mock_preference('finesMode', 'production');
 718
 719     my $passeddatedue1 = AddIssue($renewing_borrower, $item_7->barcode, $five_weeks_ago);
 720     is (defined $passeddatedue1, 1, "Item with passed date due checked out, due date: " . $passeddatedue1->date_due);
 721
 722     t::lib::Mocks::mock_preference('OverduesBlockRenewing','allow');
 723     ( $renewokay, $error ) = CanBookBeRenewed($renewing_borrowernumber, $item_6->itemnumber);
 724     is( $renewokay, 1, '(Bug 8236), Can renew, this item is not overdue');
 725     ( $renewokay, $error ) = CanBookBeRenewed($renewing_borrowernumber, $item_7->itemnumber);
 726     is( $renewokay, 1, '(Bug 8236), Can renew, this item is overdue but not pref does not block');
 727
 728     t::lib::Mocks::mock_preference('OverduesBlockRenewing','block');
 729     ( $renewokay, $error ) = CanBookBeRenewed($renewing_borrowernumber, $item_6->itemnumber);
 730     is( $renewokay, 0, '(Bug 8236), Cannot renew, this item is not overdue but patron has overdues');
 731     is( $error, 'overdue', "Correct error returned");
 732     ( $renewokay, $error ) = CanBookBeRenewed($renewing_borrowernumber, $item_7->itemnumber);
 733     is( $renewokay, 0, '(Bug 8236), Cannot renew, this item is overdue so patron has overdues');
 734     is( $error, 'overdue', "Correct error returned");
 735
 736     t::lib::Mocks::mock_preference('OverduesBlockRenewing','blockitem');
 737     ( $renewokay, $error ) = CanBookBeRenewed($renewing_borrowernumber, $item_6->itemnumber);
 738     is( $renewokay, 1, '(Bug 8236), Can renew, this item is not overdue');
 739     ( $renewokay, $error ) = CanBookBeRenewed($renewing_borrowernumber, $item_7->itemnumber);
 740     is( $renewokay, 0, '(Bug 8236), Cannot renew, this item is overdue');
 741     is( $error, 'overdue', "Correct error returned");
 742
 743     my ( $fine ) = CalcFine( $item_7->unblessed, $renewing_borrower->{categorycode}, $branch, $five_weeks_ago, $now );
 744     C4::Overdues::UpdateFine(
 745         {
 746             issue_id       => $passeddatedue1->id(),
 747             itemnumber     => $item_7->itemnumber,
 748             borrowernumber => $renewing_borrower->{borrowernumber},
 749             amount         => $fine,
 750             due            => Koha::DateUtils::output_pref($five_weeks_ago)
 751         }
 752     );
 753
 754     # Make sure fine calculation isn't skipped when adding renewal
 755     t::lib::Mocks::mock_preference('CalculateFinesOnReturn', 1);
 756
 757     # Calculate new due-date based on the present date not to incur
 758     # multiple fees
 759     t::lib::Mocks::mock_preference('RenewalPeriodBase', 'now');
 760
 761     my $staff = $builder->build_object({ class => "Koha::Patrons" });
 762     t::lib::Mocks::mock_userenv({ patron => $staff });
 763
 764     t::lib::Mocks::mock_preference('RenewalLog', 0);
 765     my $date = output_pref( { dt => dt_from_string(), dateonly => 1, dateformat => 'iso' } );
 766     my %params_renewal = (
 767         timestamp => { -like => $date . "%" },
 768         module => "CIRCULATION",
 769         action => "RENEWAL",
 770     );
 771     my %params_issue = (
 772         timestamp => { -like => $date . "%" },
 773         module => "CIRCULATION",
 774         action => "ISSUE"
 775     );
 776     my $old_log_size = Koha::ActionLogs->count( \%params_renewal );
 777     my $dt = dt_from_string();
 778     Time::Fake->offset( $dt->epoch );
 779     my $datedue1 = AddRenewal( $renewing_borrower->{borrowernumber}, $item_7->itemnumber, $branch );
 780     my $new_log_size = Koha::ActionLogs->count( \%params_renewal );
 781     is ($new_log_size, $old_log_size, 'renew log not added because of the syspref RenewalLog');
 782     isnt (DateTime->compare($datedue1, $dt), 0, "AddRenewal returned a good duedate");
 783     Time::Fake->reset;
 784
 785     t::lib::Mocks::mock_preference('RenewalLog', 1);
 786     $date = output_pref( { dt => dt_from_string(), dateonly => 1, dateformat => 'iso' } );
 787     $old_log_size = Koha::ActionLogs->count( \%params_renewal );
 788     AddRenewal( $renewing_borrower->{borrowernumber}, $item_7->itemnumber, $branch );
 789     $new_log_size = Koha::ActionLogs->count( \%params_renewal );
 790     is ($new_log_size, $old_log_size + 1, 'renew log successfully added');
 791
 792     my $fines = Koha::Account::Lines->search( { borrowernumber => $renewing_borrower->{borrowernumber}, itemnumber => $item_7->itemnumber } );
 793     is( $fines->count, 1, 'AddRenewal left fine' );
 794     is( $fines->next->status, 'RENEWED', 'Fine on renewed item is closed out properly' );
 795     $fines->delete();
 796
 797     my $old_issue_log_size = Koha::ActionLogs->count( \%params_issue );
 798     my $old_renew_log_size = Koha::ActionLogs->count( \%params_renewal );
 799     AddIssue( $renewing_borrower,$item_7->barcode,Koha::DateUtils::output_pref({str=>$datedue6->date_due, dateformat =>'iso'}),0,$date, 0, undef );
 800     $new_log_size = Koha::ActionLogs->count( \%params_renewal );
 801     is ($new_log_size, $old_renew_log_size + 1, 'renew log successfully added when renewed via issuing');
 802     $new_log_size = Koha::ActionLogs->count( \%params_issue );
 803     is ($new_log_size, $old_issue_log_size, 'renew not logged as issue when renewed via issuing');
 804
 805     $hold = Koha::Holds->search({ biblionumber => $biblio->biblionumber, borrowernumber => $reserving_borrowernumber })->next;
 806     $hold->cancel;
 807
 808     # Bug 14101
 809     # Test automatic renewal before value for "norenewalbefore" in policy is set
 810     # In this case automatic renewal is not permitted prior to due date
 811     my $item_4 = $builder->build_sample_item(
 812         {
 813             biblionumber     => $biblio->biblionumber,
 814             library          => $branch,
 815             replacementprice => 16.00,
 816             itype            => $itemtype,
 817         }
 818     );
 819
 820     $issue = AddIssue( $renewing_borrower, $item_4->barcode, undef, undef, undef, undef, { auto_renew => 1 } );
 821     my $info;
 822     ( $renewokay, $error, $info ) =
 823       CanBookBeRenewed( $renewing_borrowernumber, $item_4->itemnumber );
 824     is( $renewokay, 0, 'Bug 14101: Cannot renew, renewal is automatic and premature' );
 825     is( $error, 'auto_too_soon',
 826         'Bug 14101: Cannot renew, renewal is automatic and premature, "No renewal before" = undef (returned code is auto_too_soon)' );
 827     is( $info->{soonest_renew_date} , dt_from_string($issue->date_due), "Due date is returned as earliest renewal date when error is 'auto_too_soon'" );
 828     AddReserve(
 829         {
 830             branchcode       => $branch,
 831             borrowernumber   => $reserving_borrowernumber,
 832             biblionumber     => $biblio->biblionumber,
 833             itemnumber       => $bibitems,
 834             priority         => $priority,
 835             reservation_date => $resdate,
 836             expiration_date  => $expdate,
 837             notes            => $notes,
 838             title            => 'a title',
 839             itemnumber       => $item_4->itemnumber,
 840             found            => $found
 841         }
 842     );
 843     ( $renewokay, $error ) = CanBookBeRenewed( $renewing_borrowernumber, $item_4->itemnumber );
 844     is( $renewokay, 0, 'Still should not be able to renew' );
 845     is( $error, 'on_reserve', 'returned code is on_reserve, reserve checked when not checking for cron' );
 846     ( $renewokay, $error, $info ) = CanBookBeRenewed( $renewing_borrowernumber, $item_4->itemnumber, undef, 1 );
 847     is( $renewokay, 0, 'Still should not be able to renew' );
 848     is( $error, 'auto_too_soon', 'returned code is auto_too_soon, reserve not checked when checking for cron' );
 849     is( $info->{soonest_renew_date}, dt_from_string($issue->date_due), "Due date is returned as earliest renewal date when error is 'auto_too_soon'" );
 850     ( $renewokay, $error ) = CanBookBeRenewed( $renewing_borrowernumber, $item_4->itemnumber, 1 );
 851     is( $renewokay, 0, 'Still should not be able to renew' );
 852     is( $error, 'on_reserve', 'returned code is on_reserve, auto_too_soon limit is overridden' );
 853     ( $renewokay, $error ) = CanBookBeRenewed( $renewing_borrowernumber, $item_4->itemnumber, 1, 1 );
 854     is( $renewokay, 0, 'Still should not be able to renew' );
 855     is( $error, 'on_reserve', 'returned code is on_reserve, auto_too_soon limit is overridden' );
 856     $dbh->do('UPDATE circulation_rules SET rule_value = 0 where rule_name = "norenewalbefore"');
 857     Koha::Cache::Memory::Lite->flush();
 858     ( $renewokay, $error ) = CanBookBeRenewed( $renewing_borrowernumber, $item_4->itemnumber, 1 );
 859     is( $renewokay, 0, 'Still should not be able to renew' );
 860     is( $error, 'on_reserve', 'returned code is on_reserve, auto_renew only happens if not on reserve' );
 861     ModReserveCancelAll($item_4->itemnumber, $reserving_borrowernumber);
 862
 863
 864
 865     $renewing_borrower_obj->autorenew_checkouts(0)->store;
 866     ( $renewokay, $error ) = CanBookBeRenewed( $renewing_borrowernumber, $item_4->itemnumber );
 867     is( $renewokay, 1, 'No renewal before is undef, but patron opted out of auto_renewal' );
 868     $renewing_borrower_obj->autorenew_checkouts(1)->store;
 869
 870
 871     # Bug 7413
 872     # Test premature manual renewal
 873     Koha::CirculationRules->set_rule(
 874         {
 875             categorycode => undef,
 876             branchcode   => undef,
 877             itemtype     => undef,
 878             rule_name    => 'norenewalbefore',
 879             rule_value   => '7',
 880         }
 881     );
 882
 883     ( $renewokay, $error, $info ) = CanBookBeRenewed($renewing_borrowernumber, $item_1->itemnumber);
 884     is( $renewokay, 0, 'Bug 7413: Cannot renew, renewal is premature');
 885     is( $error, 'too_soon', 'Bug 7413: Cannot renew, renewal is premature (returned code is too_soon)');
 886     is( $info->{soonest_renew_date}, dt_from_string($issue->date_due)->subtract( days => 7 ), "Soonest renew date returned when error is 'too_soon'");
 887
 888     # Bug 14101
 889     # Test premature automatic renewal
 890     ( $renewokay, $error, $info ) =
 891       CanBookBeRenewed( $renewing_borrowernumber, $item_4->itemnumber );
 892     is( $renewokay, 0, 'Bug 14101: Cannot renew, renewal is automatic and premature' );
 893     is( $error, 'auto_too_soon',
 894         'Bug 14101: Cannot renew, renewal is automatic and premature (returned code is auto_too_soon)'
 895     );
 896     is( $info->{soonest_renew_date}, dt_from_string($issue->date_due)->subtract( days => 7 ), "Soonest renew date returned when error is 'auto_too_soon'");
 897
 898     $renewing_borrower_obj->autorenew_checkouts(0)->store;
 899     ( $renewokay, $error, $info ) = CanBookBeRenewed( $renewing_borrowernumber, $item_4->itemnumber );
 900     is( $renewokay, 0, 'No renewal before is 7, patron opted out of auto_renewal still cannot renew early' );
 901     is( $error, 'too_soon', 'Error is too_soon, no auto' );
 902     is( $info->{soonest_renew_date}, dt_from_string($issue->date_due)->subtract( days => 7 ), "Soonest renew date returned when error is 'too_soon'");
 903     $renewing_borrower_obj->autorenew_checkouts(1)->store;
 904
 905     # Change policy so that loans can only be renewed exactly on due date (0 days prior to due date)
 906     # and test automatic renewal again
 907     $dbh->do(q{UPDATE circulation_rules SET rule_value = '0' WHERE rule_name = 'norenewalbefore'});
 908     Koha::Cache::Memory::Lite->flush();
 909     ( $renewokay, $error, $info ) =
 910       CanBookBeRenewed( $renewing_borrowernumber, $item_4->itemnumber );
 911     is( $renewokay, 0, 'Bug 14101: Cannot renew, renewal is automatic and premature' );
 912     is( $error, 'auto_too_soon',
 913         'Bug 14101: Cannot renew, renewal is automatic and premature, "No renewal before" = 0 (returned code is auto_too_soon)'
 914     );
 915     is( $info->{soonest_renew_date}, dt_from_string($issue->date_due), "Soonest renew date returned when error is 'auto_too_soon'");
 916
 917     $renewing_borrower_obj->autorenew_checkouts(0)->store;
 918     ( $renewokay, $error, $info ) = CanBookBeRenewed( $renewing_borrowernumber, $item_4->itemnumber );
 919     is( $renewokay, 0, 'No renewal before is 0, patron opted out of auto_renewal still cannot renew early' );
 920     is( $error, 'too_soon', 'Error is too_soon, no auto' );
 921     is( $info->{soonest_renew_date}, dt_from_string($issue->date_due), "Soonest renew date returned when error is 'auto_too_soon'");
 922     $renewing_borrower_obj->autorenew_checkouts(1)->store;
 923
 924     # Change policy so that loans can be renewed 99 days prior to the due date
 925     # and test automatic renewal again
 926     $dbh->do(q{UPDATE circulation_rules SET rule_value = '99' WHERE rule_name = 'norenewalbefore'});
 927     Koha::Cache::Memory::Lite->flush();
 928     ( $renewokay, $error ) =
 929       CanBookBeRenewed( $renewing_borrowernumber, $item_4->itemnumber );
 930     is( $renewokay, 0, 'Bug 14101: Cannot renew, renewal is automatic' );
 931     is( $error, 'auto_renew',
 932         'Bug 14101: Cannot renew, renewal is automatic (returned code is auto_renew)'
 933     );
 934
 935     $renewing_borrower_obj->autorenew_checkouts(0)->store;
 936     ( $renewokay, $error ) = CanBookBeRenewed( $renewing_borrowernumber, $item_4->itemnumber );
 937     is( $renewokay, 1, 'No renewal before is 99, patron opted out of auto_renewal so can renew' );
 938     $renewing_borrower_obj->autorenew_checkouts(1)->store;
 939
 940     subtest "too_late_renewal / no_auto_renewal_after" => sub {
 941         plan tests => 14;
 942         my $item_to_auto_renew = $builder->build_sample_item(
 943             {
 944                 biblionumber => $biblio->biblionumber,
 945                 library      => $branch,
 946             }
 947         );
 948
 949         my $ten_days_before = dt_from_string->add( days => -10 );
 950         my $ten_days_ahead  = dt_from_string->add( days => 10 );
 951         AddIssue( $renewing_borrower, $item_to_auto_renew->barcode, $ten_days_ahead, undef, $ten_days_before, undef, { auto_renew => 1 } );
 952
 953         Koha::CirculationRules->set_rules(
 954             {
 955                 categorycode => undef,
 956                 branchcode   => undef,
 957                 itemtype     => undef,
 958                 rules        => {
 959                     norenewalbefore       => '7',
 960                     no_auto_renewal_after => '9',
 961                 }
 962             }
 963         );
 964         ( $renewokay, $error ) =
 965           CanBookBeRenewed( $renewing_borrowernumber, $item_to_auto_renew->itemnumber );
 966         is( $renewokay, 0, 'Do not renew, renewal is automatic' );
 967         is( $error, 'auto_too_late', 'Cannot renew, too late(returned code is auto_too_late)' );
 968
 969         Koha::CirculationRules->set_rules(
 970             {
 971                 categorycode => undef,
 972                 branchcode   => undef,
 973                 itemtype     => undef,
 974                 rules        => {
 975                     norenewalbefore       => '7',
 976                     no_auto_renewal_after => '10',
 977                 }
 978             }
 979         );
 980         ( $renewokay, $error ) =
 981           CanBookBeRenewed( $renewing_borrowernumber, $item_to_auto_renew->itemnumber );
 982         is( $renewokay, 0, 'Do not renew, renewal is automatic' );
 983         is( $error, 'auto_too_late', 'Cannot auto renew, too late - no_auto_renewal_after is inclusive(returned code is auto_too_late)' );
 984
 985         Koha::CirculationRules->set_rules(
 986             {
 987                 categorycode => undef,
 988                 branchcode   => undef,
 989                 itemtype     => undef,
 990                 rules        => {
 991                     norenewalbefore       => '7',
 992                     no_auto_renewal_after => '11',
 993                 }
 994             }
 995         );
 996         ( $renewokay, $error ) =
 997           CanBookBeRenewed( $renewing_borrowernumber, $item_to_auto_renew->itemnumber );
 998         is( $renewokay, 0, 'Do not renew, renewal is automatic' );
 999         is( $error, 'auto_too_soon', 'Cannot auto renew, too soon - no_auto_renewal_after is defined(returned code is auto_too_soon)' );
1000
1001         Koha::CirculationRules->set_rules(
1002             {
1003                 categorycode => undef,
1004                 branchcode   => undef,
1005                 itemtype     => undef,
1006                 rules        => {
1007                     norenewalbefore       => '10',
1008                     no_auto_renewal_after => '11',
1009                 }
1010             }
1011         );
1012         ( $renewokay, $error ) =
1013           CanBookBeRenewed( $renewing_borrowernumber, $item_to_auto_renew->itemnumber );
1014         is( $renewokay, 0,            'Do not renew, renewal is automatic' );
1015         is( $error,     'auto_renew', 'Cannot renew, renew is automatic' );
1016
1017         Koha::CirculationRules->set_rules(
1018             {
1019                 categorycode => undef,
1020                 branchcode   => undef,
1021                 itemtype     => undef,
1022                 rules        => {
1023                     norenewalbefore       => '10',
1024                     no_auto_renewal_after => undef,
1025                     no_auto_renewal_after_hard_limit => dt_from_string->add( days => -1 ),
1026                 }
1027             }
1028         );
1029         ( $renewokay, $error ) =
1030           CanBookBeRenewed( $renewing_borrowernumber, $item_to_auto_renew->itemnumber );
1031         is( $renewokay, 0, 'Do not renew, renewal is automatic' );
1032         is( $error, 'auto_too_late', 'Cannot renew, too late(returned code is auto_too_late)' );
1033
1034         Koha::CirculationRules->set_rules(
1035             {
1036                 categorycode => undef,
1037                 branchcode   => undef,
1038                 itemtype     => undef,
1039                 rules        => {
1040                     norenewalbefore       => '7',
1041                     no_auto_renewal_after => '15',
1042                     no_auto_renewal_after_hard_limit => dt_from_string->add( days => -1 ),
1043                 }
1044             }
1045         );
1046         ( $renewokay, $error ) =
1047           CanBookBeRenewed( $renewing_borrowernumber, $item_to_auto_renew->itemnumber );
1048         is( $renewokay, 0, 'Do not renew, renewal is automatic' );
1049         is( $error, 'auto_too_late', 'Cannot renew, too late(returned code is auto_too_late)' );
1050
1051         Koha::CirculationRules->set_rules(
1052             {
1053                 categorycode => undef,
1054                 branchcode   => undef,
1055                 itemtype     => undef,
1056                 rules        => {
1057                     norenewalbefore       => '10',
1058                     no_auto_renewal_after => undef,
1059                     no_auto_renewal_after_hard_limit => dt_from_string->add( days => 1 ),
1060                 }
1061             }
1062         );
1063         ( $renewokay, $error ) =
1064           CanBookBeRenewed( $renewing_borrowernumber, $item_to_auto_renew->itemnumber );
1065         is( $renewokay, 0, 'Do not renew, renewal is automatic' );
1066         is( $error, 'auto_renew', 'Cannot renew, renew is automatic' );
1067     };
1068
1069     subtest "auto_too_much_oweing | OPACFineNoRenewalsBlockAutoRenew & OPACFineNoRenewalsIncludeCredit" => sub {
1070         plan tests => 10;
1071         my $item_to_auto_renew = $builder->build_sample_item(
1072             {
1073                 biblionumber => $biblio->biblionumber,
1074                 library      => $branch,
1075             }
1076         );
1077
1078         my $ten_days_before = dt_from_string->add( days => -10 );
1079         my $ten_days_ahead = dt_from_string->add( days => 10 );
1080         AddIssue( $renewing_borrower, $item_to_auto_renew->barcode, $ten_days_ahead, undef, $ten_days_before, undef, { auto_renew => 1 } );
1081
1082         Koha::CirculationRules->set_rules(
1083             {
1084                 categorycode => undef,
1085                 branchcode   => undef,
1086                 itemtype     => undef,
1087                 rules        => {
1088                     norenewalbefore       => '10',
1089                     no_auto_renewal_after => '11',
1090                 }
1091             }
1092         );
1093         C4::Context->set_preference('OPACFineNoRenewalsBlockAutoRenew','1');
1094         C4::Context->set_preference('OPACFineNoRenewals','10');
1095         C4::Context->set_preference('OPACFineNoRenewalsIncludeCredit','1');
1096         my $fines_amount = 5;
1097         my $account = Koha::Account->new({patron_id => $renewing_borrowernumber});
1098         $account->add_debit(
1099             {
1100                 amount      => $fines_amount,
1101                 interface   => 'test',
1102                 type        => 'OVERDUE',
1103                 item_id     => $item_to_auto_renew->itemnumber,
1104                 description => "Some fines"
1105             }
1106         )->status('RETURNED')->store;
1107         ( $renewokay, $error ) =
1108           CanBookBeRenewed( $renewing_borrowernumber, $item_to_auto_renew->itemnumber );
1109         is( $renewokay, 0, 'Do not renew, renewal is automatic' );
1110         is( $error, 'auto_renew', 'Can auto renew, OPACFineNoRenewals=10, patron has 5' );
1111
1112         $account->add_debit(
1113             {
1114                 amount      => $fines_amount,
1115                 interface   => 'test',
1116                 type        => 'OVERDUE',
1117                 item_id     => $item_to_auto_renew->itemnumber,
1118                 description => "Some fines"
1119             }
1120         )->status('RETURNED')->store;
1121         ( $renewokay, $error ) =
1122           CanBookBeRenewed( $renewing_borrowernumber, $item_to_auto_renew->itemnumber );
1123         is( $renewokay, 0, 'Do not renew, renewal is automatic' );
1124         is( $error, 'auto_renew', 'Can auto renew, OPACFineNoRenewals=10, patron has 10' );
1125
1126         $account->add_debit(
1127             {
1128                 amount      => $fines_amount,
1129                 interface   => 'test',
1130                 type        => 'OVERDUE',
1131                 item_id     => $item_to_auto_renew->itemnumber,
1132                 description => "Some fines"
1133             }
1134         )->status('RETURNED')->store;
1135         ( $renewokay, $error ) =
1136           CanBookBeRenewed( $renewing_borrowernumber, $item_to_auto_renew->itemnumber );
1137         is( $renewokay, 0, 'Do not renew, renewal is automatic' );
1138         is( $error, 'auto_too_much_oweing', 'Cannot auto renew, OPACFineNoRenewals=10, patron has 15' );
1139
1140         $account->add_credit(
1141             {
1142                 amount      => $fines_amount,
1143                 interface   => 'test',
1144                 type        => 'PAYMENT',
1145                 description => "Some payment"
1146             }
1147         )->store;
1148         ( $renewokay, $error ) =
1149           CanBookBeRenewed( $renewing_borrowernumber, $item_to_auto_renew->itemnumber );
1150         is( $renewokay, 0, 'Do not renew, renewal is automatic' );
1151         is( $error, 'auto_renew', 'Can auto renew, OPACFineNoRenewals=10, OPACFineNoRenewalsIncludeCredit=1, patron has 15 debt, 5 credit'  );
1152
1153         C4::Context->set_preference('OPACFineNoRenewalsIncludeCredit','0');
1154         ( $renewokay, $error ) =
1155           CanBookBeRenewed( $renewing_borrowernumber, $item_to_auto_renew->itemnumber );
1156         is( $renewokay, 0, 'Do not renew, renewal is automatic' );
1157         is( $error, 'auto_too_much_oweing', 'Cannot auto renew, OPACFineNoRenewals=10, OPACFineNoRenewalsIncludeCredit=1, patron has 15 debt, 5 credit'  );
1158
1159         $dbh->do('DELETE FROM accountlines WHERE borrowernumber=?', undef, $renewing_borrowernumber);
1160         C4::Context->set_preference('OPACFineNoRenewalsIncludeCredit','1');
1161     };
1162
1163     subtest "auto_account_expired | BlockExpiredPatronOpacActions" => sub {
1164         plan tests => 6;
1165         my $item_to_auto_renew = $builder->build_sample_item(
1166             {
1167                 biblionumber => $biblio->biblionumber,
1168                 library      => $branch,
1169             }
1170         );
1171
1172         Koha::CirculationRules->set_rules(
1173             {
1174                 categorycode => undef,
1175                 branchcode   => undef,
1176                 itemtype     => undef,
1177                 rules        => {
1178                     norenewalbefore       => 10,
1179                     no_auto_renewal_after => 11,
1180                 }
1181             }
1182         );
1183
1184         my $ten_days_before = dt_from_string->add( days => -10 );
1185         my $ten_days_ahead = dt_from_string->add( days => 10 );
1186
1187         # Patron is expired and BlockExpiredPatronOpacActions=0
1188         # => auto renew is allowed
1189         t::lib::Mocks::mock_preference('BlockExpiredPatronOpacActions', 0);
1190         my $patron = $expired_borrower;
1191         my $checkout = AddIssue( $patron, $item_to_auto_renew->barcode, $ten_days_ahead, undef, $ten_days_before, undef, { auto_renew => 1 } );
1192         ( $renewokay, $error ) =
1193           CanBookBeRenewed( $patron->{borrowernumber}, $item_to_auto_renew->itemnumber );
1194         is( $renewokay, 0, 'Do not renew, renewal is automatic' );
1195         is( $error, 'auto_renew', 'Can auto renew, patron is expired but BlockExpiredPatronOpacActions=0' );
1196         Koha::Checkouts->find( $checkout->issue_id )->delete;
1197
1198
1199         # Patron is expired and BlockExpiredPatronOpacActions=1
1200         # => auto renew is not allowed
1201         t::lib::Mocks::mock_preference('BlockExpiredPatronOpacActions', 1);
1202         $patron = $expired_borrower;
1203         $checkout = AddIssue( $patron, $item_to_auto_renew->barcode, $ten_days_ahead, undef, $ten_days_before, undef, { auto_renew => 1 } );
1204         ( $renewokay, $error ) =
1205           CanBookBeRenewed( $patron->{borrowernumber}, $item_to_auto_renew->itemnumber );
1206         is( $renewokay, 0, 'Do not renew, renewal is automatic' );
1207         is( $error, 'auto_account_expired', 'Can not auto renew, lockExpiredPatronOpacActions=1 and patron is expired' );
1208         Koha::Checkouts->find( $checkout->issue_id )->delete;
1209
1210
1211         # Patron is not expired and BlockExpiredPatronOpacActions=1
1212         # => auto renew is allowed
1213         t::lib::Mocks::mock_preference('BlockExpiredPatronOpacActions', 1);
1214         $patron = $renewing_borrower;
1215         $checkout = AddIssue( $patron, $item_to_auto_renew->barcode, $ten_days_ahead, undef, $ten_days_before, undef, { auto_renew => 1 } );
1216         ( $renewokay, $error ) =
1217           CanBookBeRenewed( $patron->{borrowernumber}, $item_to_auto_renew->itemnumber );
1218         is( $renewokay, 0, 'Do not renew, renewal is automatic' );
1219         is( $error, 'auto_renew', 'Can auto renew, BlockExpiredPatronOpacActions=1 but patron is not expired' );
1220         Koha::Checkouts->find( $checkout->issue_id )->delete;
1221     };
1222
1223     subtest "GetLatestAutoRenewDate" => sub {
1224         plan tests => 5;
1225         my $item_to_auto_renew = $builder->build_sample_item(
1226             {
1227                 biblionumber => $biblio->biblionumber,
1228                 library      => $branch,
1229             }
1230         );
1231
1232         my $ten_days_before = dt_from_string->add( days => -10 );
1233         my $ten_days_ahead  = dt_from_string->add( days => 10 );
1234         AddIssue( $renewing_borrower, $item_to_auto_renew->barcode, $ten_days_ahead, undef, $ten_days_before, undef, { auto_renew => 1 } );
1235         Koha::CirculationRules->set_rules(
1236             {
1237                 categorycode => undef,
1238                 branchcode   => undef,
1239                 itemtype     => undef,
1240                 rules        => {
1241                     norenewalbefore       => '7',
1242                     no_auto_renewal_after => '',
1243                     no_auto_renewal_after_hard_limit => undef,
1244                 }
1245             }
1246         );
1247         my $latest_auto_renew_date = GetLatestAutoRenewDate( $renewing_borrowernumber, $item_to_auto_renew->itemnumber );
1248         is( $latest_auto_renew_date, undef, 'GetLatestAutoRenewDate should return undef if no_auto_renewal_after or no_auto_renewal_after_hard_limit are not defined' );
1249         my $five_days_before = dt_from_string->add( days => -5 );
1250         Koha::CirculationRules->set_rules(
1251             {
1252                 categorycode => undef,
1253                 branchcode   => undef,
1254                 itemtype     => undef,
1255                 rules        => {
1256                     norenewalbefore       => '10',
1257                     no_auto_renewal_after => '5',
1258                     no_auto_renewal_after_hard_limit => undef,
1259                 }
1260             }
1261         );
1262         $latest_auto_renew_date = GetLatestAutoRenewDate( $renewing_borrowernumber, $item_to_auto_renew->itemnumber );
1263         is( $latest_auto_renew_date->truncate( to => 'minute' ),
1264             $five_days_before->truncate( to => 'minute' ),
1265             'GetLatestAutoRenewDate should return -5 days if no_auto_renewal_after = 5 and date_due is 10 days before'
1266         );
1267         my $five_days_ahead = dt_from_string->add( days => 5 );
1268         $dbh->do(q{UPDATE circulation_rules SET rule_value = '10' WHERE rule_name = 'norenewalbefore'});
1269         $dbh->do(q{UPDATE circulation_rules SET rule_value = '15' WHERE rule_name = 'no_auto_renewal_after'});
1270         $dbh->do(q{UPDATE circulation_rules SET rule_value = NULL WHERE rule_name = 'no_auto_renewal_after_hard_limit'});
1271         Koha::Cache::Memory::Lite->flush();
1272         Koha::CirculationRules->set_rules(
1273             {
1274                 categorycode => undef,
1275                 branchcode   => undef,
1276                 itemtype     => undef,
1277                 rules        => {
1278                     norenewalbefore       => '10',
1279                     no_auto_renewal_after => '15',
1280                     no_auto_renewal_after_hard_limit => undef,
1281                 }
1282             }
1283         );
1284         $latest_auto_renew_date = GetLatestAutoRenewDate( $renewing_borrowernumber, $item_to_auto_renew->itemnumber );
1285         is( $latest_auto_renew_date->truncate( to => 'minute' ),
1286             $five_days_ahead->truncate( to => 'minute' ),
1287             'GetLatestAutoRenewDate should return +5 days if no_auto_renewal_after = 15 and date_due is 10 days before'
1288         );
1289         my $two_days_ahead = dt_from_string->add( days => 2 );
1290         Koha::CirculationRules->set_rules(
1291             {
1292                 categorycode => undef,
1293                 branchcode   => undef,
1294                 itemtype     => undef,
1295                 rules        => {
1296                     norenewalbefore       => '10',
1297                     no_auto_renewal_after => '',
1298                     no_auto_renewal_after_hard_limit => dt_from_string->add( days => 2 ),
1299                 }
1300             }
1301         );
1302         $latest_auto_renew_date = GetLatestAutoRenewDate( $renewing_borrowernumber, $item_to_auto_renew->itemnumber );
1303         is( $latest_auto_renew_date->truncate( to => 'day' ),
1304             $two_days_ahead->truncate( to => 'day' ),
1305             'GetLatestAutoRenewDate should return +2 days if no_auto_renewal_after_hard_limit is defined and not no_auto_renewal_after'
1306         );
1307         Koha::CirculationRules->set_rules(
1308             {
1309                 categorycode => undef,
1310                 branchcode   => undef,
1311                 itemtype     => undef,
1312                 rules        => {
1313                     norenewalbefore       => '10',
1314                     no_auto_renewal_after => '15',
1315                     no_auto_renewal_after_hard_limit => dt_from_string->add( days => 2 ),
1316                 }
1317             }
1318         );
1319         $latest_auto_renew_date = GetLatestAutoRenewDate( $renewing_borrowernumber, $item_to_auto_renew->itemnumber );
1320         is( $latest_auto_renew_date->truncate( to => 'day' ),
1321             $two_days_ahead->truncate( to => 'day' ),
1322             'GetLatestAutoRenewDate should return +2 days if no_auto_renewal_after_hard_limit is < no_auto_renewal_after'
1323         );
1324
1325     };
1326     # Too many renewals
1327
1328     # set policy to forbid renewals
1329     Koha::CirculationRules->set_rules(
1330         {
1331             categorycode => undef,
1332             branchcode   => undef,
1333             itemtype     => undef,
1334             rules        => {
1335                 norenewalbefore => undef,
1336                 renewalsallowed => 0,
1337             }
1338         }
1339     );
1340
1341     ( $renewokay, $error ) = CanBookBeRenewed($renewing_borrowernumber, $item_1->itemnumber);
1342     is( $renewokay, 0, 'Cannot renew, 0 renewals allowed');
1343     is( $error, 'too_many', 'Cannot renew, 0 renewals allowed (returned code is too_many)');
1344
1345     # Too many unseen renewals
1346     Koha::CirculationRules->set_rules(
1347         {
1348             categorycode => undef,
1349             branchcode   => undef,
1350             itemtype     => undef,
1351             rules        => {
1352                 unseen_renewals_allowed => 2,
1353                 renewalsallowed => 10,
1354             }
1355         }
1356     );
1357     t::lib::Mocks::mock_preference('UnseenRenewals', 1);
1358     $dbh->do('UPDATE issues SET unseen_renewals = 2 where borrowernumber = ? AND itemnumber = ?', undef, ($renewing_borrowernumber, $item_1->itemnumber));
1359     ( $renewokay, $error ) = CanBookBeRenewed($renewing_borrowernumber, $item_1->itemnumber);
1360     is( $renewokay, 0, 'Cannot renew, 0 unseen renewals allowed');
1361     is( $error, 'too_unseen', 'Cannot renew, returned code is too_unseen');
1362     Koha::CirculationRules->set_rules(
1363         {
1364             categorycode => undef,
1365             branchcode   => undef,
1366             itemtype     => undef,
1367             rules        => {
1368                 norenewalbefore => undef,
1369                 renewalsallowed => 0,
1370             }
1371         }
1372     );
1373     t::lib::Mocks::mock_preference('UnseenRenewals', 0);
1374
1375     # Test WhenLostForgiveFine and WhenLostChargeReplacementFee
1376     t::lib::Mocks::mock_preference('WhenLostForgiveFine','1');
1377     t::lib::Mocks::mock_preference('WhenLostChargeReplacementFee','1');
1378
1379     C4::Overdues::UpdateFine(
1380         {
1381             issue_id       => $issue->id(),
1382             itemnumber     => $item_1->itemnumber,
1383             borrowernumber => $renewing_borrower->{borrowernumber},
1384             amount         => 15.00,
1385             type           => q{},
1386             due            => Koha::DateUtils::output_pref($datedue)
1387         }
1388     );
1389
1390     my $line = Koha::Account::Lines->search({ borrowernumber => $renewing_borrower->{borrowernumber} })->next();
1391     is( $line->debit_type_code, 'OVERDUE', 'Account line type is OVERDUE' );
1392     is( $line->status, 'UNRETURNED', 'Account line status is UNRETURNED' );
1393     is( $line->amountoutstanding+0, 15, 'Account line amount outstanding is 15.00' );
1394     is( $line->amount+0, 15, 'Account line amount is 15.00' );
1395     is( $line->issue_id, $issue->id, 'Account line issue id matches' );
1396
1397     my $offset = Koha::Account::Offsets->search({ debit_id => $line->id })->next();
1398     is( $offset->type, 'CREATE', 'Account offset type is CREATE' );
1399     is( $offset->amount+0, 15, 'Account offset amount is 15.00' );
1400
1401     t::lib::Mocks::mock_preference('WhenLostForgiveFine','0');
1402     t::lib::Mocks::mock_preference('WhenLostChargeReplacementFee','0');
1403
1404     LostItem( $item_1->itemnumber, 'test', 1 );
1405
1406     $line = Koha::Account::Lines->find($line->id);
1407     is( $line->debit_type_code, 'OVERDUE', 'Account type remains as OVERDUE' );
1408     isnt( $line->status, 'UNRETURNED', 'Account status correctly changed from UNRETURNED to RETURNED' );
1409
1410     my $item = Koha::Items->find($item_1->itemnumber);
1411     ok( !$item->onloan(), "Lost item marked as returned has false onloan value" );
1412     my $checkout = Koha::Checkouts->find({ itemnumber => $item_1->itemnumber });
1413     is( $checkout, undef, 'LostItem called with forced return has checked in the item' );
1414
1415     my $total_due = $dbh->selectrow_array(
1416         'SELECT SUM( amountoutstanding ) FROM accountlines WHERE borrowernumber = ?',
1417         undef, $renewing_borrower->{borrowernumber}
1418     );
1419
1420     is( $total_due+0, 15, 'Borrower only charged replacement fee with both WhenLostForgiveFine and WhenLostChargeReplacementFee enabled' );
1421
1422     C4::Context->dbh->do("DELETE FROM accountlines");
1423
1424     C4::Overdues::UpdateFine(
1425         {
1426             issue_id       => $issue2->id(),
1427             itemnumber     => $item_2->itemnumber,
1428             borrowernumber => $renewing_borrower->{borrowernumber},
1429             amount         => 15.00,
1430             type           => q{},
1431             due            => Koha::DateUtils::output_pref($datedue)
1432         }
1433     );
1434
1435     LostItem( $item_2->itemnumber, 'test', 0 );
1436
1437     my $item2 = Koha::Items->find($item_2->itemnumber);
1438     ok( $item2->onloan(), "Lost item *not* marked as returned has true onloan value" );
1439     ok( Koha::Checkouts->find({ itemnumber => $item_2->itemnumber }), 'LostItem called without forced return has checked in the item' );
1440
1441     $total_due = $dbh->selectrow_array(
1442         'SELECT SUM( amountoutstanding ) FROM accountlines WHERE borrowernumber = ?',
1443         undef, $renewing_borrower->{borrowernumber}
1444     );
1445
1446     ok( $total_due == 15, 'Borrower only charged fine with both WhenLostForgiveFine and WhenLostChargeReplacementFee disabled' );
1447
1448     my $future = dt_from_string();
1449     $future->add( days => 7 );
1450     my $units = C4::Overdues::get_chargeable_units('days', $future, $now, $library2->{branchcode});
1451     ok( $units == 0, '_get_chargeable_units returns 0 for items not past due date (Bug 12596)' );
1452
1453     my $manager = $builder->build_object({ class => "Koha::Patrons" });
1454     t::lib::Mocks::mock_userenv({ patron => $manager,branchcode => $manager->branchcode });
1455     t::lib::Mocks::mock_preference('WhenLostChargeReplacementFee','1');
1456     $checkout = Koha::Checkouts->find( { itemnumber => $item_3->itemnumber } );
1457     LostItem( $item_3->itemnumber, 'test', 0 );
1458     my $accountline = Koha::Account::Lines->find( { itemnumber => $item_3->itemnumber } );
1459     is( $accountline->issue_id, $checkout->id, "Issue id added for lost replacement fee charge" );
1460     is(
1461         $accountline->description,
1462         sprintf( "%s %s %s",
1463             $item_3->biblio->title  || '',
1464             $item_3->barcode        || '',
1465             $item_3->itemcallnumber || '' ),
1466         "Account line description must not contain 'Lost Items ', but be title, barcode, itemcallnumber"
1467     );
1468
1469     # Recalls
1470     t::lib::Mocks::mock_preference('UseRecalls', 1);
1471     Koha::CirculationRules->set_rules({
1472         categorycode => undef,
1473         branchcode => undef,
1474         itemtype => undef,
1475         rules => {
1476             recalls_allowed => 10,
1477             renewalsallowed => 5,
1478         },
1479     });
1480     my $recall_borrower = $builder->build_object({ class => 'Koha::Patrons' });
1481     my $recall_biblio = $builder->build_object({ class => 'Koha::Biblios' });
1482     my $recall_item1 = $builder->build_object({ class => 'Koha::Items' }, { value => { biblionumber => $recall_biblio->biblionumber } });
1483     my $recall_item2 = $builder->build_object({ class => 'Koha::Items' }, { value => { biblionumber => $recall_biblio->biblionumber } });
1484
1485     AddIssue( $renewing_borrower, $recall_item1->barcode );
1486
1487     # item-level and this item: renewal not allowed
1488     my $recall = Koha::Recall->new({
1489         biblio_id => $recall_item1->biblionumber,
1490         item_id => $recall_item1->itemnumber,
1491         patron_id => $recall_borrower->borrowernumber,
1492         pickup_library_id => $recall_borrower->branchcode,
1493         item_level => 1,
1494     })->store;
1495     ( $renewokay, $error ) = CanBookBeRenewed( $renewing_borrowernumber, $recall_item1->itemnumber );
1496     is( $error, 'recalled', 'Cannot renew item that has been recalled' );
1497     $recall->set_cancelled;
1498
1499     # biblio-level requested recall: renewal not allowed
1500     $recall = Koha::Recall->new({
1501         biblio_id => $recall_item1->biblionumber,
1502         item_id => undef,
1503         patron_id => $recall_borrower->borrowernumber,
1504         pickup_library_id => $recall_borrower->branchcode,
1505         item_level => 0,
1506     })->store;
1507     ( $renewokay, $error ) = CanBookBeRenewed( $renewing_borrowernumber, $recall_item1->itemnumber );
1508     is( $error, 'recalled', 'Cannot renew item if biblio is recalled and has no item allocated' );
1509     $recall->set_cancelled;
1510
1511     # item-level and not this item: renewal allowed
1512     $recall = Koha::Recall->new({
1513         biblio_id => $recall_item2->biblionumber,
1514         item_id => $recall_item2->itemnumber,
1515         patron_id => $recall_borrower->borrowernumber,
1516         pickup_library_id => $recall_borrower->branchcode,
1517         item_level => 1,
1518     })->store;
1519     ( $renewokay, $error ) = CanBookBeRenewed( $renewing_borrowernumber, $recall_item1->itemnumber );
1520     is( $renewokay, 1, 'Can renew item if item-level recall on biblio is not on this item' );
1521     $recall->set_cancelled;
1522
1523     # biblio-level waiting recall: renewal allowed
1524     $recall = Koha::Recall->new({
1525         biblio_id => $recall_item1->biblionumber,
1526         item_id => undef,
1527         patron_id => $recall_borrower->borrowernumber,
1528         pickup_library_id => $recall_borrower->branchcode,
1529         item_level => 0,
1530     })->store;
1531     $recall->set_waiting({ item => $recall_item1 });
1532     ( $renewokay, $error ) = CanBookBeRenewed( $renewing_borrowernumber, $recall_item1->itemnumber );
1533     is( $renewokay, 1, 'Can renew item if biblio-level recall has already been allocated an item' );
1534     $recall->set_cancelled;
1535 };
1536
1537 subtest "GetUpcomingDueIssues" => sub {
1538     plan tests => 12;
1539
1540     my $branch   = $library2->{branchcode};
1541
1542     #Create another record
1543     my $biblio2 = $builder->build_sample_biblio();
1544
1545     #Create third item
1546     my $item_1 = Koha::Items->find($reused_itemnumber_1);
1547     my $item_2 = Koha::Items->find($reused_itemnumber_2);
1548     my $item_3 = $builder->build_sample_item(
1549         {
1550             biblionumber     => $biblio2->biblionumber,
1551             library          => $branch,
1552             itype            => $itemtype,
1553         }
1554     );
1555
1556
1557     # Create a borrower
1558     my %a_borrower_data = (
1559         firstname =>  'Fridolyn',
1560         surname => 'SOMERS',
1561         categorycode => $patron_category->{categorycode},
1562         branchcode => $branch,
1563     );
1564
1565     my $a_borrower_borrowernumber = Koha::Patron->new(\%a_borrower_data)->store->borrowernumber;
1566     my $a_borrower = Koha::Patrons->find( $a_borrower_borrowernumber )->unblessed;
1567
1568     my $yesterday = DateTime->today(time_zone => C4::Context->tz())->add( days => -1 );
1569     my $two_days_ahead = DateTime->today(time_zone => C4::Context->tz())->add( days => 2 );
1570     my $today = DateTime->today(time_zone => C4::Context->tz());
1571
1572     my $issue = AddIssue( $a_borrower, $item_1->barcode, $yesterday );
1573     my $datedue = dt_from_string( $issue->date_due() );
1574     my $issue2 = AddIssue( $a_borrower, $item_2->barcode, $two_days_ahead );
1575     my $datedue2 = dt_from_string( $issue->date_due() );
1576
1577     my $upcoming_dues;
1578
1579     # GetUpcomingDueIssues tests
1580     for my $i(0..1) {
1581         $upcoming_dues = C4::Circulation::GetUpcomingDueIssues( { days_in_advance => $i } );
1582         is ( scalar( @$upcoming_dues ), 0, "No items due in less than one day ($i days in advance)" );
1583     }
1584
1585     #days_in_advance needs to be inclusive, so 1 matches items due tomorrow, 0 items due today etc.
1586     $upcoming_dues = C4::Circulation::GetUpcomingDueIssues( { days_in_advance => 2 } );
1587     is ( scalar ( @$upcoming_dues), 1, "Only one item due in 2 days or less" );
1588
1589     for my $i(3..5) {
1590         $upcoming_dues = C4::Circulation::GetUpcomingDueIssues( { days_in_advance => $i } );
1591         is ( scalar( @$upcoming_dues ), 1,
1592             "Bug 9362: Only one item due in more than 2 days ($i days in advance)" );
1593     }
1594
1595     # Bug 11218 - Due notices not generated - GetUpcomingDueIssues needs to select due today items as well
1596
1597     my $issue3 = AddIssue( $a_borrower, $item_3->barcode, $today );
1598
1599     $upcoming_dues = C4::Circulation::GetUpcomingDueIssues( { days_in_advance => -1 } );
1600     is ( scalar ( @$upcoming_dues), 0, "Overdues can not be selected" );
1601
1602     $upcoming_dues = C4::Circulation::GetUpcomingDueIssues( { days_in_advance => 0 } );
1603     is ( scalar ( @$upcoming_dues), 1, "1 item is due today" );
1604
1605     $upcoming_dues = C4::Circulation::GetUpcomingDueIssues( { days_in_advance => 1 } );
1606     is ( scalar ( @$upcoming_dues), 1, "1 item is due today, none tomorrow" );
1607
1608     $upcoming_dues = C4::Circulation::GetUpcomingDueIssues( { days_in_advance => 2 }  );
1609     is ( scalar ( @$upcoming_dues), 2, "2 items are due withing 2 days" );
1610
1611     $upcoming_dues = C4::Circulation::GetUpcomingDueIssues( { days_in_advance => 3 } );
1612     is ( scalar ( @$upcoming_dues), 2, "2 items are due withing 2 days" );
1613
1614     $upcoming_dues = C4::Circulation::GetUpcomingDueIssues();
1615     is ( scalar ( @$upcoming_dues), 2, "days_in_advance is 7 in GetUpcomingDueIssues if not provided" );
1616
1617 };
1618
1619 subtest "Bug 13841 - Do not create new 0 amount fines" => sub {
1620     my $branch   = $library2->{branchcode};
1621
1622     my $biblio = $builder->build_sample_biblio();
1623
1624     #Create third item
1625     my $item = $builder->build_sample_item(
1626         {
1627             biblionumber     => $biblio->biblionumber,
1628             library          => $branch,
1629             itype            => $itemtype,
1630         }
1631     );
1632
1633     # Create a borrower
1634     my %a_borrower_data = (
1635         firstname =>  'Kyle',
1636         surname => 'Hall',
1637         categorycode => $patron_category->{categorycode},
1638         branchcode => $branch,
1639     );
1640
1641     my $borrowernumber = Koha::Patron->new(\%a_borrower_data)->store->borrowernumber;
1642
1643     my $borrower = Koha::Patrons->find( $borrowernumber )->unblessed;
1644     my $issue = AddIssue( $borrower, $item->barcode );
1645     UpdateFine(
1646         {
1647             issue_id       => $issue->id(),
1648             itemnumber     => $item->itemnumber,
1649             borrowernumber => $borrowernumber,
1650             amount         => 0,
1651             type           => q{}
1652         }
1653     );
1654
1655     my $hr = $dbh->selectrow_hashref(q{SELECT COUNT(*) AS count FROM accountlines WHERE borrowernumber = ? AND itemnumber = ?}, undef, $borrowernumber, $item->itemnumber );
1656     my $count = $hr->{count};
1657
1658     is ( $count, 0, "Calling UpdateFine on non-existant fine with an amount of 0 does not result in an empty fine" );
1659 };
1660
1661 subtest "AllowRenewalIfOtherItemsAvailable tests" => sub {
1662     plan tests => 13;
1663     my $biblio = $builder->build_sample_biblio();
1664     my $item_1 = $builder->build_sample_item(
1665         {
1666             biblionumber     => $biblio->biblionumber,
1667             library          => $library2->{branchcode},
1668         }
1669     );
1670     my $item_2= $builder->build_sample_item(
1671         {
1672             biblionumber     => $biblio->biblionumber,
1673             library          => $library2->{branchcode},
1674             itype            => $item_1->effective_itemtype,
1675         }
1676     );
1677
1678     Koha::CirculationRules->set_rules(
1679         {
1680             categorycode => undef,
1681             itemtype     => $item_1->effective_itemtype,
1682             branchcode   => undef,
1683             rules        => {
1684                 reservesallowed => 25,
1685                 holds_per_record => 25,
1686                 issuelength     => 14,
1687                 lengthunit      => 'days',
1688                 renewalsallowed => 1,
1689                 renewalperiod   => 7,
1690                 norenewalbefore => undef,
1691                 auto_renew      => 0,
1692                 fine            => .10,
1693                 chargeperiod    => 1,
1694                 maxissueqty     => 20
1695             }
1696         }
1697     );
1698
1699
1700     my $borrowernumber1 = Koha::Patron->new({
1701         firstname    => 'Kyle',
1702         surname      => 'Hall',
1703         categorycode => $patron_category->{categorycode},
1704         branchcode   => $library2->{branchcode},
1705     })->store->borrowernumber;
1706     my $borrowernumber2 = Koha::Patron->new({
1707         firstname    => 'Chelsea',
1708         surname      => 'Hall',
1709         categorycode => $patron_category->{categorycode},
1710         branchcode   => $library2->{branchcode},
1711     })->store->borrowernumber;
1712     my $patron_category_2 = $builder->build(
1713         {
1714             source => 'Category',
1715             value  => {
1716                 category_type                 => 'P',
1717                 enrolmentfee                  => 0,
1718                 BlockExpiredPatronOpacActions => -1, # Pick the pref value
1719             }
1720         }
1721     );
1722     my $borrowernumber3 = Koha::Patron->new({
1723         firstname    => 'Carnegie',
1724         surname      => 'Hall',
1725         categorycode => $patron_category_2->{categorycode},
1726         branchcode   => $library2->{branchcode},
1727     })->store->borrowernumber;
1728
1729     my $borrower1 = Koha::Patrons->find( $borrowernumber1 )->unblessed;
1730     my $borrower2 = Koha::Patrons->find( $borrowernumber2 )->unblessed;
1731
1732     my $issue = AddIssue( $borrower1, $item_1->barcode );
1733
1734     my ( $renewokay, $error ) = CanBookBeRenewed( $borrowernumber1, $item_1->itemnumber );
1735     is( $renewokay, 1, 'Bug 14337 - Verify the borrower can renew with no hold on the record' );
1736
1737     AddReserve(
1738         {
1739             branchcode     => $library2->{branchcode},
1740             borrowernumber => $borrowernumber2,
1741             biblionumber   => $biblio->biblionumber,
1742             priority       => 1,
1743         }
1744     );
1745
1746     Koha::CirculationRules->set_rules(
1747         {
1748             categorycode => undef,
1749             itemtype     => $item_1->effective_itemtype,
1750             branchcode   => undef,
1751             rules        => {
1752                 onshelfholds => 0,
1753             }
1754         }
1755     );
1756     t::lib::Mocks::mock_preference( 'AllowRenewalIfOtherItemsAvailable', 0 );
1757     ( $renewokay, $error ) = CanBookBeRenewed( $borrowernumber1, $item_1->itemnumber );
1758     is( $renewokay, 0, 'Bug 14337 - Verify the borrower cannot renew with a hold on the record if AllowRenewalIfOtherItemsAvailable and onshelfholds are disabled' );
1759
1760     t::lib::Mocks::mock_preference( 'AllowRenewalIfOtherItemsAvailable', 1 );
1761     ( $renewokay, $error ) = CanBookBeRenewed( $borrowernumber1, $item_1->itemnumber );
1762     is( $renewokay, 0, 'Bug 14337 - Verify the borrower cannot renew with a hold on the record if AllowRenewalIfOtherItemsAvailable is enabled and onshelfholds is disabled' );
1763
1764     Koha::CirculationRules->set_rules(
1765         {
1766             categorycode => undef,
1767             itemtype     => $item_1->effective_itemtype,
1768             branchcode   => undef,
1769             rules        => {
1770                 onshelfholds => 1,
1771             }
1772         }
1773     );
1774     t::lib::Mocks::mock_preference( 'AllowRenewalIfOtherItemsAvailable', 0 );
1775     ( $renewokay, $error ) = CanBookBeRenewed( $borrowernumber1, $item_1->itemnumber );
1776     is( $renewokay, 0, 'Bug 14337 - Verify the borrower cannot renew with a hold on the record if AllowRenewalIfOtherItemsAvailable is disabled and onshelfhold is enabled' );
1777
1778     t::lib::Mocks::mock_preference( 'AllowRenewalIfOtherItemsAvailable', 1 );
1779     ( $renewokay, $error ) = CanBookBeRenewed( $borrowernumber1, $item_1->itemnumber );
1780     is( $renewokay, 1, 'Bug 14337 - Verify the borrower can renew with a hold on the record if AllowRenewalIfOtherItemsAvailable and onshelfhold are enabled' );
1781
1782     AddReserve(
1783         {
1784             branchcode     => $library2->{branchcode},
1785             borrowernumber => $borrowernumber3,
1786             biblionumber   => $biblio->biblionumber,
1787             priority       => 1,
1788         }
1789     );
1790
1791     ( $renewokay, $error ) = CanBookBeRenewed( $borrowernumber1, $item_1->itemnumber );
1792     is( $renewokay, 0, 'Verify the borrower cannot renew with 2 holds on the record if AllowRenewalIfOtherItemsAvailable and onshelfhold are enabled and one other item on record' );
1793
1794     my $item_3= $builder->build_sample_item(
1795         {
1796             biblionumber     => $biblio->biblionumber,
1797             library          => $library2->{branchcode},
1798             itype            => $item_1->effective_itemtype,
1799         }
1800     );
1801
1802     ( $renewokay, $error ) = CanBookBeRenewed( $borrowernumber1, $item_1->itemnumber );
1803     is( $renewokay, 1, 'Verify the borrower cannot renew with 2 holds on the record if AllowRenewalIfOtherItemsAvailable and onshelfhold are enabled and two other items on record' );
1804
1805     Koha::CirculationRules->set_rules(
1806         {
1807             categorycode => $patron_category_2->{categorycode},
1808             itemtype     => $item_1->effective_itemtype,
1809             branchcode   => undef,
1810             rules        => {
1811                 reservesallowed => 0,
1812             }
1813         }
1814     );
1815
1816     ( $renewokay, $error ) = CanBookBeRenewed( $borrowernumber1, $item_1->itemnumber );
1817     is( $renewokay, 0, 'Verify the borrower cannot renew with 2 holds on the record, but only one of those holds can be filled when AllowRenewalIfOtherItemsAvailable and onshelfhold are enabled and two other items on record' );
1818
1819     Koha::CirculationRules->set_rules(
1820         {
1821             categorycode => $patron_category_2->{categorycode},
1822             itemtype     => $item_1->effective_itemtype,
1823             branchcode   => undef,
1824             rules        => {
1825                 reservesallowed => 25,
1826             }
1827         }
1828     );
1829
1830     # Setting item not checked out to be not for loan but holdable
1831     $item_2->notforloan(-1)->store;
1832
1833     ( $renewokay, $error ) = CanBookBeRenewed( $borrowernumber1, $item_1->itemnumber );
1834     is( $renewokay, 0, 'Bug 14337 - Verify the borrower can not renew with a hold on the record if AllowRenewalIfOtherItemsAvailable is enabled but the only available item is notforloan' );
1835
1836     my $mock_circ = Test::MockModule->new("C4::Circulation");
1837     $mock_circ->mock( CanItemBeReserved => sub {
1838         warn "Checked";
1839         return { status => 'no' }
1840     } );
1841
1842     $item_2->notforloan(0)->store;
1843     $item_3->delete();
1844     # Two items total, one item available, one issued, two holds on record
1845
1846     warnings_are{
1847        ( $renewokay, $error ) = CanBookBeRenewed( $borrowernumber1, $item_1->itemnumber );
1848     } [], "CanItemBeReserved not called when there are more possible holds than available items";
1849     is( $renewokay, 0, 'Borrower cannot renew when there are more holds than available items' );
1850
1851     $item_3 = $builder->build_sample_item(
1852         {
1853             biblionumber     => $biblio->biblionumber,
1854             library          => $library2->{branchcode},
1855             itype            => $item_1->effective_itemtype,
1856         }
1857     );
1858
1859     Koha::CirculationRules->set_rules(
1860         {
1861             categorycode => undef,
1862             itemtype     => $item_1->effective_itemtype,
1863             branchcode   => undef,
1864             rules        => {
1865                 reservesallowed => 0,
1866             }
1867         }
1868     );
1869
1870     warnings_are{
1871        ( $renewokay, $error ) = CanBookBeRenewed( $borrowernumber1, $item_1->itemnumber );
1872     } ["Checked","Checked"], "CanItemBeReserved only called once per available item if it returns a negative result for all items for a borrower";
1873     is( $renewokay, 0, 'Borrower cannot renew when there are more holds than available items' );
1874
1875 };
1876
1877 {
1878     # Don't allow renewing onsite checkout
1879     my $branch   = $library->{branchcode};
1880
1881     #Create another record
1882     my $biblio = $builder->build_sample_biblio();
1883
1884     my $item = $builder->build_sample_item(
1885         {
1886             biblionumber     => $biblio->biblionumber,
1887             library          => $branch,
1888             itype            => $itemtype,
1889         }
1890     );
1891
1892     my $borrowernumber = Koha::Patron->new({
1893         firstname =>  'fn',
1894         surname => 'dn',
1895         categorycode => $patron_category->{categorycode},
1896         branchcode => $branch,
1897     })->store->borrowernumber;
1898
1899     my $borrower = Koha::Patrons->find( $borrowernumber )->unblessed;
1900
1901     my $issue = AddIssue( $borrower, $item->barcode, undef, undef, undef, undef, { onsite_checkout => 1 } );
1902     my ( $renewed, $error ) = CanBookBeRenewed( $borrowernumber, $item->itemnumber );
1903     is( $renewed, 0, 'CanBookBeRenewed should not allow to renew on-site checkout' );
1904     is( $error, 'onsite_checkout', 'A correct error code should be returned by CanBookBeRenewed for on-site checkout' );
1905 }
1906
1907 {
1908     my $library = $builder->build({ source => 'Branch' });
1909
1910     my $biblio = $builder->build_sample_biblio();
1911
1912     my $item = $builder->build_sample_item(
1913         {
1914             biblionumber     => $biblio->biblionumber,
1915             library          => $library->{branchcode},
1916             itype            => $itemtype,
1917         }
1918     );
1919
1920     my $patron = $builder->build({ source => 'Borrower', value => { branchcode => $library->{branchcode}, categorycode => $patron_category->{categorycode} } } );
1921
1922     my $issue = AddIssue( $patron, $item->barcode );
1923     UpdateFine(
1924         {
1925             issue_id       => $issue->id(),
1926             itemnumber     => $item->itemnumber,
1927             borrowernumber => $patron->{borrowernumber},
1928             amount         => 1,
1929             type           => q{}
1930         }
1931     );
1932     UpdateFine(
1933         {
1934             issue_id       => $issue->id(),
1935             itemnumber     => $item->itemnumber,
1936             borrowernumber => $patron->{borrowernumber},
1937             amount         => 2,
1938             type           => q{}
1939         }
1940     );
1941     is( Koha::Account::Lines->search({ issue_id => $issue->id })->count, 1, 'UpdateFine should not create a new accountline when updating an existing fine');
1942 }
1943
1944 subtest 'CanBookBeIssued & AllowReturnToBranch' => sub {
1945     plan tests => 24;
1946
1947     my $homebranch    = $builder->build( { source => 'Branch' } );
1948     my $holdingbranch = $builder->build( { source => 'Branch' } );
1949     my $otherbranch   = $builder->build( { source => 'Branch' } );
1950     my $patron_1      = $builder->build_object( { class => 'Koha::Patrons', value => { categorycode => $patron_category->{categorycode} } } );
1951     my $patron_2      = $builder->build_object( { class => 'Koha::Patrons', value => { categorycode => $patron_category->{categorycode} } } );
1952
1953     my $item = $builder->build_sample_item(
1954         {
1955             homebranch    => $homebranch->{branchcode},
1956             holdingbranch => $holdingbranch->{branchcode},
1957         }
1958     );
1959     Koha::CirculationRules->set_rules(
1960         {
1961             categorycode => undef,
1962             itemtype     => $item->effective_itemtype,
1963             branchcode   => undef,
1964             rules        => {
1965                 reservesallowed => 25,
1966                 issuelength     => 14,
1967                 lengthunit      => 'days',
1968                 renewalsallowed => 1,
1969                 renewalperiod   => 7,
1970                 norenewalbefore => undef,
1971                 auto_renew      => 0,
1972                 fine            => .10,
1973                 chargeperiod    => 1,
1974                 maxissueqty     => 20
1975             }
1976         }
1977     );
1978
1979     set_userenv($holdingbranch);
1980
1981     my $issue = AddIssue( $patron_1->unblessed, $item->barcode );
1982     is( ref($issue), 'Koha::Checkout', 'AddIssue should return a Koha::Checkout object' );
1983
1984     my ( $error, $question, $alerts );
1985
1986     # AllowReturnToBranch == anywhere
1987     t::lib::Mocks::mock_preference( 'AllowReturnToBranch', 'anywhere' );
1988     ## Test that unknown barcodes don't generate internal server errors
1989     set_userenv($homebranch);
1990     ( $error, $question, $alerts ) = CanBookBeIssued( $patron_2, 'KohaIsAwesome' );
1991     ok( $error->{UNKNOWN_BARCODE}, '"KohaIsAwesome" is not a valid barcode as expected.' );
1992     ## Can be issued from homebranch
1993     set_userenv($homebranch);
1994     ( $error, $question, $alerts ) = CanBookBeIssued( $patron_2, $item->barcode );
1995     is( keys(%$error) + keys(%$alerts), 0, 'There should not be any errors or alerts (impossible)' . str($error, $question, $alerts) );
1996     is( exists $question->{ISSUED_TO_ANOTHER}, 1, 'ISSUED_TO_ANOTHER must be set' );
1997     ## Can be issued from holdingbranch
1998     set_userenv($holdingbranch);
1999     ( $error, $question, $alerts ) = CanBookBeIssued( $patron_2, $item->barcode );
2000     is( keys(%$error) + keys(%$alerts), 0, 'There should not be any errors or alerts (impossible)' . str($error, $question, $alerts) );
2001     is( exists $question->{ISSUED_TO_ANOTHER}, 1, 'ISSUED_TO_ANOTHER must be set' );
2002     ## Can be issued from another branch
2003     ( $error, $question, $alerts ) = CanBookBeIssued( $patron_2, $item->barcode );
2004     is( keys(%$error) + keys(%$alerts), 0, 'There should not be any errors or alerts (impossible)' . str($error, $question, $alerts) );
2005     is( exists $question->{ISSUED_TO_ANOTHER}, 1, 'ISSUED_TO_ANOTHER must be set' );
2006
2007     # AllowReturnToBranch == holdingbranch
2008     t::lib::Mocks::mock_preference( 'AllowReturnToBranch', 'holdingbranch' );
2009     ## Cannot be issued from homebranch
2010     set_userenv($homebranch);
2011     ( $error, $question, $alerts ) = CanBookBeIssued( $patron_2, $item->barcode );
2012     is( keys(%$question) + keys(%$alerts), 0, 'There should not be any errors or alerts (impossible)' . str($error, $question, $alerts) );
2013     is( exists $error->{RETURN_IMPOSSIBLE}, 1, 'RETURN_IMPOSSIBLE must be set' );
2014     is( $error->{branch_to_return},         $holdingbranch->{branchcode}, 'branch_to_return matched holdingbranch' );
2015     ## Can be issued from holdinbranch
2016     set_userenv($holdingbranch);
2017     ( $error, $question, $alerts ) = CanBookBeIssued( $patron_2, $item->barcode );
2018     is( keys(%$error) + keys(%$alerts), 0, 'There should not be any errors or alerts (impossible)' . str($error, $question, $alerts) );
2019     is( exists $question->{ISSUED_TO_ANOTHER}, 1, 'ISSUED_TO_ANOTHER must be set' );
2020     ## Cannot be issued from another branch
2021     set_userenv($otherbranch);
2022     ( $error, $question, $alerts ) = CanBookBeIssued( $patron_2, $item->barcode );
2023     is( keys(%$question) + keys(%$alerts), 0, 'There should not be any errors or alerts (impossible)' . str($error, $question, $alerts) );
2024     is( exists $error->{RETURN_IMPOSSIBLE}, 1, 'RETURN_IMPOSSIBLE must be set' );
2025     is( $error->{branch_to_return},         $holdingbranch->{branchcode}, 'branch_to_return matches holdingbranch' );
2026
2027     # AllowReturnToBranch == homebranch
2028     t::lib::Mocks::mock_preference( 'AllowReturnToBranch', 'homebranch' );
2029     ## Can be issued from holdinbranch
2030     set_userenv($homebranch);
2031     ( $error, $question, $alerts ) = CanBookBeIssued( $patron_2, $item->barcode );
2032     is( keys(%$error) + keys(%$alerts), 0, 'There should not be any errors or alerts (impossible)' . str($error, $question, $alerts) );
2033     is( exists $question->{ISSUED_TO_ANOTHER}, 1, 'ISSUED_TO_ANOTHER must be set' );
2034     ## Cannot be issued from holdinbranch
2035     set_userenv($holdingbranch);
2036     ( $error, $question, $alerts ) = CanBookBeIssued( $patron_2, $item->barcode );
2037     is( keys(%$question) + keys(%$alerts), 0, 'There should not be any errors or alerts (impossible)' . str($error, $question, $alerts) );
2038     is( exists $error->{RETURN_IMPOSSIBLE}, 1, 'RETURN_IMPOSSIBLE must be set' );
2039     is( $error->{branch_to_return},         $homebranch->{branchcode}, 'branch_to_return matches homebranch' );
2040     ## Cannot be issued from holdinbranch
2041     set_userenv($otherbranch);
2042     ( $error, $question, $alerts ) = CanBookBeIssued( $patron_2, $item->barcode );
2043     is( keys(%$question) + keys(%$alerts), 0, 'There should not be any errors or alerts (impossible)' . str($error, $question, $alerts) );
2044     is( exists $error->{RETURN_IMPOSSIBLE}, 1, 'RETURN_IMPOSSIBLE must be set' );
2045     is( $error->{branch_to_return},         $homebranch->{branchcode}, 'branch_to_return matches homebranch' );
2046
2047     # TODO t::lib::Mocks::mock_preference('AllowReturnToBranch', 'homeorholdingbranch');
2048 };
2049
2050 subtest 'AddIssue & AllowReturnToBranch' => sub {
2051     plan tests => 9;
2052
2053     my $homebranch    = $builder->build( { source => 'Branch' } );
2054     my $holdingbranch = $builder->build( { source => 'Branch' } );
2055     my $otherbranch   = $builder->build( { source => 'Branch' } );
2056     my $patron_1      = $builder->build( { source => 'Borrower', value => { categorycode => $patron_category->{categorycode} } } );
2057     my $patron_2      = $builder->build( { source => 'Borrower', value => { categorycode => $patron_category->{categorycode} } } );
2058
2059     my $item = $builder->build_sample_item(
2060         {
2061             homebranch    => $homebranch->{branchcode},
2062             holdingbranch => $holdingbranch->{branchcode},
2063         }
2064     );
2065
2066     set_userenv($holdingbranch);
2067
2068     my $ref_issue = 'Koha::Checkout';
2069     my $issue = AddIssue( $patron_1, $item->barcode );
2070
2071     my ( $error, $question, $alerts );
2072
2073     # AllowReturnToBranch == homebranch
2074     t::lib::Mocks::mock_preference( 'AllowReturnToBranch', 'anywhere' );
2075     ## Can be issued from homebranch
2076     set_userenv($homebranch);
2077     is ( ref( AddIssue( $patron_2, $item->barcode ) ), $ref_issue, 'AllowReturnToBranch - anywhere | Can be issued from homebranch');
2078     set_userenv($holdingbranch); AddIssue( $patron_1, $item->barcode ); # Reinsert the original issue
2079     ## Can be issued from holdinbranch
2080     set_userenv($holdingbranch);
2081     is ( ref( AddIssue( $patron_2, $item->barcode ) ), $ref_issue, 'AllowReturnToBranch - anywhere | Can be issued from holdingbranch');
2082     set_userenv($holdingbranch); AddIssue( $patron_1, $item->barcode ); # Reinsert the original issue
2083     ## Can be issued from another branch
2084     set_userenv($otherbranch);
2085     is ( ref( AddIssue( $patron_2, $item->barcode ) ), $ref_issue, 'AllowReturnToBranch - anywhere | Can be issued from otherbranch');
2086     set_userenv($holdingbranch); AddIssue( $patron_1, $item->barcode ); # Reinsert the original issue
2087
2088     # AllowReturnToBranch == holdinbranch
2089     t::lib::Mocks::mock_preference( 'AllowReturnToBranch', 'holdingbranch' );
2090     ## Cannot be issued from homebranch
2091     set_userenv($homebranch);
2092     is ( ref( AddIssue( $patron_2, $item->barcode ) ), '', 'AllowReturnToBranch - holdingbranch | Cannot be issued from homebranch');
2093     ## Can be issued from holdingbranch
2094     set_userenv($holdingbranch);
2095     is ( ref( AddIssue( $patron_2, $item->barcode ) ), $ref_issue, 'AllowReturnToBranch - holdingbranch | Can be issued from holdingbranch');
2096     set_userenv($holdingbranch); AddIssue( $patron_1, $item->barcode ); # Reinsert the original issue
2097     ## Cannot be issued from another branch
2098     set_userenv($otherbranch);
2099     is ( ref( AddIssue( $patron_2, $item->barcode ) ), '', 'AllowReturnToBranch - holdingbranch | Cannot be issued from otherbranch');
2100
2101     # AllowReturnToBranch == homebranch
2102     t::lib::Mocks::mock_preference( 'AllowReturnToBranch', 'homebranch' );
2103     ## Can be issued from homebranch
2104     set_userenv($homebranch);
2105     is ( ref( AddIssue( $patron_2, $item->barcode ) ), $ref_issue, 'AllowReturnToBranch - homebranch | Can be issued from homebranch' );
2106     set_userenv($holdingbranch); AddIssue( $patron_1, $item->barcode ); # Reinsert the original issue
2107     ## Cannot be issued from holdinbranch
2108     set_userenv($holdingbranch);
2109     is ( ref( AddIssue( $patron_2, $item->barcode ) ), '', 'AllowReturnToBranch - homebranch | Cannot be issued from holdingbranch' );
2110     ## Cannot be issued from another branch
2111     set_userenv($otherbranch);
2112     is ( ref( AddIssue( $patron_2, $item->barcode ) ), '', 'AllowReturnToBranch - homebranch | Cannot be issued from otherbranch' );
2113     # TODO t::lib::Mocks::mock_preference('AllowReturnToBranch', 'homeorholdingbranch');
2114 };
2115
2116 subtest 'AddIssue | recalls' => sub {
2117     plan tests => 3;
2118
2119     t::lib::Mocks::mock_preference("UseRecalls", 1);
2120     t::lib::Mocks::mock_preference("item-level_itypes", 1);
2121     my $patron1 = $builder->build_object({ class => 'Koha::Patrons' });
2122     my $patron2 = $builder->build_object({ class => 'Koha::Patrons' });
2123     my $item = $builder->build_sample_item;
2124     Koha::CirculationRules->set_rules({
2125         branchcode => undef,
2126         itemtype => undef,
2127         categorycode => undef,
2128         rules => {
2129             recalls_allowed => 10,
2130         },
2131     });
2132
2133     # checking out item that they have recalled
2134     my $recall1 = Koha::Recall->new(
2135         {   patron_id         => $patron1->borrowernumber,
2136             biblio_id         => $item->biblionumber,
2137             item_id           => $item->itemnumber,
2138             item_level        => 1,
2139             pickup_library_id => $patron1->branchcode,
2140         }
2141     )->store;
2142     AddIssue( $patron1->unblessed, $item->barcode, undef, undef, undef, undef, { recall_id => $recall1->id } );
2143     $recall1 = Koha::Recalls->find( $recall1->id );
2144     is( $recall1->fulfilled, 1, 'Recall was fulfilled when patron checked out item' );
2145     AddReturn( $item->barcode, $item->homebranch );
2146
2147     # this item is has a recall request. cancel recall
2148     my $recall2 = Koha::Recall->new(
2149         {   patron_id         => $patron2->borrowernumber,
2150             biblio_id         => $item->biblionumber,
2151             item_id           => $item->itemnumber,
2152             item_level        => 1,
2153             pickup_library_id => $patron2->branchcode,
2154         }
2155     )->store;
2156     AddIssue( $patron1->unblessed, $item->barcode, undef, undef, undef, undef, { recall_id => $recall2->id, cancel_recall => 'cancel' } );
2157     $recall2 = Koha::Recalls->find( $recall2->id );
2158     is( $recall2->cancelled, 1, 'Recall was cancelled when patron checked out item' );
2159     AddReturn( $item->barcode, $item->homebranch );
2160
2161     # this item is waiting to fulfill a recall. revert recall
2162     my $recall3 = Koha::Recall->new(
2163         {   patron_id         => $patron2->borrowernumber,
2164             biblio_id         => $item->biblionumber,
2165             item_id           => $item->itemnumber,
2166             item_level        => 1,
2167             pickup_library_id => $patron2->branchcode,
2168         }
2169     )->store;
2170     $recall3->set_waiting;
2171     AddIssue( $patron1->unblessed, $item->barcode, undef, undef, undef, undef, { recall_id => $recall3->id, cancel_recall => 'revert' } );
2172     $recall3 = Koha::Recalls->find( $recall3->id );
2173     is( $recall3->requested, 1, 'Recall was reverted from waiting when patron checked out item' );
2174     AddReturn( $item->barcode, $item->homebranch );
2175 };
2176
2177 subtest 'AddIssue & illrequests.due_date' => sub {
2178     plan tests => 2;
2179
2180     t::lib::Mocks::mock_preference( 'ILLModule', 1 );
2181     my $library = $builder->build( { source => 'Branch' } );
2182     my $patron = $builder->build_object( { class => 'Koha::Patrons' } );
2183     my $item = $builder->build_sample_item();
2184
2185     set_userenv($library);
2186
2187     my $custom_date_due = '9999-12-18 12:34:56';
2188     my $expected_date_due = '9999-12-18 23:59:00';
2189     my $illrequest = Koha::Illrequest->new({
2190         borrowernumber => $patron->borrowernumber,
2191         biblio_id => $item->biblionumber,
2192         branchcode => $library->{'branchcode'},
2193         due_date => $custom_date_due,
2194     })->store;
2195
2196     my $issue = AddIssue( $patron->unblessed, $item->barcode );
2197     is( $issue->date_due, $expected_date_due, 'Custom illrequest date due has been set for this issue');
2198
2199     $patron = $builder->build_object( { class => 'Koha::Patrons' } );
2200     $item = $builder->build_sample_item();
2201     $custom_date_due = '9999-12-19';
2202     $expected_date_due = '9999-12-19 23:59:00';
2203     $illrequest = Koha::Illrequest->new({
2204         borrowernumber => $patron->borrowernumber,
2205         biblio_id => $item->biblionumber,
2206         branchcode => $library->{'branchcode'},
2207         due_date => $custom_date_due,
2208     })->store;
2209
2210     $issue = AddIssue( $patron->unblessed, $item->barcode );
2211     is( $issue->date_due, $expected_date_due, 'Custom illrequest date due has been set for this issue');
2212 };
2213
2214 subtest 'CanBookBeIssued + Koha::Patron->is_debarred|has_overdues' => sub {
2215     plan tests => 8;
2216
2217     my $library = $builder->build( { source => 'Branch' } );
2218     my $patron  = $builder->build_object( { class => 'Koha::Patrons', value => { categorycode => $patron_category->{categorycode} } } );
2219     my $item_1 = $builder->build_sample_item(
2220         {
2221             library => $library->{branchcode},
2222         }
2223     );
2224     my $item_2 = $builder->build_sample_item(
2225         {
2226             library => $library->{branchcode},
2227         }
2228     );
2229     Koha::CirculationRules->set_rules(
2230         {
2231             categorycode => undef,
2232             itemtype     => undef,
2233             branchcode   => $library->{branchcode},
2234             rules        => {
2235                 reservesallowed => 25,
2236                 issuelength     => 14,
2237                 lengthunit      => 'days',
2238                 renewalsallowed => 1,
2239                 renewalperiod   => 7,
2240                 norenewalbefore => undef,
2241                 auto_renew      => 0,
2242                 fine            => .10,
2243                 chargeperiod    => 1,
2244                 maxissueqty     => 20
2245             }
2246         }
2247     );
2248
2249
2250     my ( $error, $question, $alerts );
2251
2252     # Patron cannot issue item_1, they have overdues
2253     my $yesterday = DateTime->today( time_zone => C4::Context->tz() )->add( days => -1 );
2254     my $issue = AddIssue( $patron->unblessed, $item_1->barcode, $yesterday );    # Add an overdue
2255
2256     t::lib::Mocks::mock_preference( 'OverduesBlockCirc', 'confirmation' );
2257     ( $error, $question, $alerts ) = CanBookBeIssued( $patron, $item_2->barcode );
2258     is( keys(%$error) + keys(%$alerts),  0, 'No key for error and alert' . str($error, $question, $alerts) );
2259     is( $question->{USERBLOCKEDOVERDUE}, 1, 'OverduesBlockCirc=confirmation, USERBLOCKEDOVERDUE should be set for question' );
2260
2261     t::lib::Mocks::mock_preference( 'OverduesBlockCirc', 'block' );
2262     ( $error, $question, $alerts ) = CanBookBeIssued( $patron, $item_2->barcode );
2263     is( keys(%$question) + keys(%$alerts),  0, 'No key for question and alert ' . str($error, $question, $alerts) );
2264     is( $error->{USERBLOCKEDOVERDUE},      1, 'OverduesBlockCirc=block, USERBLOCKEDOVERDUE should be set for error' );
2265
2266     # Patron cannot issue item_1, they are debarred
2267     my $tomorrow = DateTime->today( time_zone => C4::Context->tz() )->add( days => 1 );
2268     Koha::Patron::Debarments::AddDebarment( { borrowernumber => $patron->borrowernumber, expiration => $tomorrow } );
2269     ( $error, $question, $alerts ) = CanBookBeIssued( $patron, $item_2->barcode );
2270     is( keys(%$question) + keys(%$alerts),  0, 'No key for question and alert ' . str($error, $question, $alerts) );
2271     is( $error->{USERBLOCKEDWITHENDDATE}, output_pref( { dt => $tomorrow, dateformat => 'sql', dateonly => 1 } ), 'USERBLOCKEDWITHENDDATE should be tomorrow' );
2272
2273     Koha::Patron::Debarments::AddDebarment( { borrowernumber => $patron->borrowernumber } );
2274     ( $error, $question, $alerts ) = CanBookBeIssued( $patron, $item_2->barcode );
2275     is( keys(%$question) + keys(%$alerts),  0, 'No key for question and alert ' . str($error, $question, $alerts) );
2276     is( $error->{USERBLOCKEDNOENDDATE},    '9999-12-31', 'USERBLOCKEDNOENDDATE should be 9999-12-31 for unlimited debarments' );
2277 };
2278
2279 subtest 'CanBookBeIssued + Statistic patrons "X"' => sub {
2280     plan tests => 1;
2281
2282     my $library = $builder->build_object( { class => 'Koha::Libraries' } );
2283     my $patron_category_x = $builder->build_object(
2284         {
2285             class => 'Koha::Patron::Categories',
2286             value => { category_type => 'X' }
2287         }
2288     );
2289     my $patron = $builder->build_object(
2290         {
2291             class => 'Koha::Patrons',
2292             value => {
2293                 categorycode  => $patron_category_x->categorycode,
2294                 gonenoaddress => undef,
2295                 lost          => undef,
2296                 debarred      => undef,
2297                 borrowernotes => ""
2298             }
2299         }
2300     );
2301     my $item_1 = $builder->build_sample_item(
2302         {
2303             library => $library->{branchcode},
2304         }
2305     );
2306
2307     my ( $error, $question, $alerts ) = CanBookBeIssued( $patron, $item_1->barcode );
2308     is( $error->{STATS}, 1, '"Error" flag "STATS" must be set if CanBookBeIssued is called with a statistic patron (category_type=X)' );
2309
2310     # TODO There are other tests to provide here
2311 };
2312
2313 subtest 'MultipleReserves' => sub {
2314     plan tests => 3;
2315
2316     my $biblio = $builder->build_sample_biblio();
2317
2318     my $branch = $library2->{branchcode};
2319
2320     my $item_1 = $builder->build_sample_item(
2321         {
2322             biblionumber     => $biblio->biblionumber,
2323             library          => $branch,
2324             replacementprice => 12.00,
2325             itype            => $itemtype,
2326         }
2327     );
2328
2329     my $item_2 = $builder->build_sample_item(
2330         {
2331             biblionumber     => $biblio->biblionumber,
2332             library          => $branch,
2333             replacementprice => 12.00,
2334             itype            => $itemtype,
2335         }
2336     );
2337
2338     my $bibitems       = '';
2339     my $priority       = '1';
2340     my $resdate        = undef;
2341     my $expdate        = undef;
2342     my $notes          = '';
2343     my $checkitem      = undef;
2344     my $found          = undef;
2345
2346     my %renewing_borrower_data = (
2347         firstname =>  'John',
2348         surname => 'Renewal',
2349         categorycode => $patron_category->{categorycode},
2350         branchcode => $branch,
2351     );
2352     my $renewing_borrowernumber = Koha::Patron->new(\%renewing_borrower_data)->store->borrowernumber;
2353     my $renewing_borrower = Koha::Patrons->find( $renewing_borrowernumber )->unblessed;
2354     my $issue = AddIssue( $renewing_borrower, $item_1->barcode);
2355     my $datedue = dt_from_string( $issue->date_due() );
2356     is (defined $issue->date_due(), 1, "item 1 checked out");
2357     my $borrowing_borrowernumber = Koha::Checkouts->find({ itemnumber => $item_1->itemnumber })->borrowernumber;
2358
2359     my %reserving_borrower_data1 = (
2360         firstname =>  'Katrin',
2361         surname => 'Reservation',
2362         categorycode => $patron_category->{categorycode},
2363         branchcode => $branch,
2364     );
2365     my $reserving_borrowernumber1 = Koha::Patron->new(\%reserving_borrower_data1)->store->borrowernumber;
2366     AddReserve(
2367         {
2368             branchcode       => $branch,
2369             borrowernumber   => $reserving_borrowernumber1,
2370             biblionumber     => $biblio->biblionumber,
2371             priority         => $priority,
2372             reservation_date => $resdate,
2373             expiration_date  => $expdate,
2374             notes            => $notes,
2375             itemnumber       => $checkitem,
2376             found            => $found,
2377         }
2378     );
2379
2380     my %reserving_borrower_data2 = (
2381         firstname =>  'Kirk',
2382         surname => 'Reservation',
2383         categorycode => $patron_category->{categorycode},
2384         branchcode => $branch,
2385     );
2386     my $reserving_borrowernumber2 = Koha::Patron->new(\%reserving_borrower_data2)->store->borrowernumber;
2387     AddReserve(
2388         {
2389             branchcode       => $branch,
2390             borrowernumber   => $reserving_borrowernumber2,
2391             biblionumber     => $biblio->biblionumber,
2392             priority         => $priority,
2393             reservation_date => $resdate,
2394             expiration_date  => $expdate,
2395             notes            => $notes,
2396             itemnumber       => $checkitem,
2397             found            => $found,
2398         }
2399     );
2400
2401     {
2402         my ( $renewokay, $error ) = CanBookBeRenewed($renewing_borrowernumber, $item_1->itemnumber, 1);
2403         is($renewokay, 0, 'Bug 17941 - should cover the case where 2 books are both reserved, so failing');
2404     }
2405
2406     my $item_3 = $builder->build_sample_item(
2407         {
2408             biblionumber     => $biblio->biblionumber,
2409             library          => $branch,
2410             replacementprice => 12.00,
2411             itype            => $itemtype,
2412         }
2413     );
2414
2415     {
2416         my ( $renewokay, $error ) = CanBookBeRenewed($renewing_borrowernumber, $item_1->itemnumber, 1);
2417         is($renewokay, 1, 'Bug 17941 - should cover the case where 2 books are reserved, but a third one is available');
2418     }
2419 };
2420
2421 subtest 'CanBookBeIssued + AllowMultipleIssuesOnABiblio' => sub {
2422     plan tests => 5;
2423
2424     my $library = $builder->build( { source => 'Branch' } );
2425     my $patron  = $builder->build_object( { class => 'Koha::Patrons', value => { categorycode => $patron_category->{categorycode} } } );
2426
2427     my $biblionumber = $builder->build_sample_biblio(
2428         {
2429             branchcode => $library->{branchcode},
2430         }
2431     )->biblionumber;
2432     my $item_1 = $builder->build_sample_item(
2433         {
2434             biblionumber => $biblionumber,
2435             library      => $library->{branchcode},
2436         }
2437     );
2438
2439     my $item_2 = $builder->build_sample_item(
2440         {
2441             biblionumber => $biblionumber,
2442             library      => $library->{branchcode},
2443         }
2444     );
2445
2446     Koha::CirculationRules->set_rules(
2447         {
2448             categorycode => undef,
2449             itemtype     => undef,
2450             branchcode   => $library->{branchcode},
2451             rules        => {
2452                 reservesallowed => 25,
2453                 issuelength     => 14,
2454                 lengthunit      => 'days',
2455                 renewalsallowed => 1,
2456                 renewalperiod   => 7,
2457                 norenewalbefore => undef,
2458                 auto_renew      => 0,
2459                 fine            => .10,
2460                 chargeperiod    => 1,
2461                 maxissueqty     => 20
2462             }
2463         }
2464     );
2465
2466     my ( $error, $question, $alerts );
2467     my $issue = AddIssue( $patron->unblessed, $item_1->barcode, dt_from_string->add( days => 1 ) );
2468
2469     t::lib::Mocks::mock_preference('AllowMultipleIssuesOnABiblio', 0);
2470     ( $error, $question, $alerts ) = CanBookBeIssued( $patron, $item_2->barcode );
2471     cmp_deeply(
2472         { error => $error, alerts => $alerts },
2473         { error => {}, alerts => {} },
2474         'No error or alert should be raised'
2475     );
2476     is( $question->{BIBLIO_ALREADY_ISSUED}, 1, 'BIBLIO_ALREADY_ISSUED question flag should be set if AllowMultipleIssuesOnABiblio=0 and issue already exists' );
2477
2478     t::lib::Mocks::mock_preference('AllowMultipleIssuesOnABiblio', 1);
2479     ( $error, $question, $alerts ) = CanBookBeIssued( $patron, $item_2->barcode );
2480     cmp_deeply(
2481         { error => $error, question => $question, alerts => $alerts },
2482         { error => {}, question => {}, alerts => {} },
2483         'No BIBLIO_ALREADY_ISSUED flag should be set if AllowMultipleIssuesOnABiblio=1'
2484     );
2485
2486     # Add a subscription
2487     Koha::Subscription->new({ biblionumber => $biblionumber })->store;
2488
2489     t::lib::Mocks::mock_preference('AllowMultipleIssuesOnABiblio', 0);
2490     ( $error, $question, $alerts ) = CanBookBeIssued( $patron, $item_2->barcode );
2491     cmp_deeply(
2492         { error => $error, question => $question, alerts => $alerts },
2493         { error => {}, question => {}, alerts => {} },
2494         'No BIBLIO_ALREADY_ISSUED flag should be set if it is a subscription'
2495     );
2496
2497     t::lib::Mocks::mock_preference('AllowMultipleIssuesOnABiblio', 1);
2498     ( $error, $question, $alerts ) = CanBookBeIssued( $patron, $item_2->barcode );
2499     cmp_deeply(
2500         { error => $error, question => $question, alerts => $alerts },
2501         { error => {}, question => {}, alerts => {} },
2502         'No BIBLIO_ALREADY_ISSUED flag should be set if it is a subscription'
2503     );
2504 };
2505
2506 subtest 'AddReturn + CumulativeRestrictionPeriods' => sub {
2507     plan tests => 8;
2508
2509     my $library = $builder->build( { source => 'Branch' } );
2510     my $patron  = $builder->build_object( { class => 'Koha::Patrons', value => { categorycode => $patron_category->{categorycode} } } );
2511
2512     # Add 2 items
2513     my $biblionumber = $builder->build_sample_biblio(
2514         {
2515             branchcode => $library->{branchcode},
2516         }
2517     )->biblionumber;
2518     my $item_1 = $builder->build_sample_item(
2519         {
2520             biblionumber => $biblionumber,
2521             library      => $library->{branchcode},
2522         }
2523     );
2524     my $item_2 = $builder->build_sample_item(
2525         {
2526             biblionumber => $biblionumber,
2527             library      => $library->{branchcode},
2528         }
2529     );
2530
2531     # And the circulation rule
2532     Koha::CirculationRules->search->delete;
2533     Koha::CirculationRules->set_rules(
2534         {
2535             categorycode => undef,
2536             itemtype     => undef,
2537             branchcode   => undef,
2538             rules        => {
2539                 issuelength => 1,
2540                 firstremind => 1,        # 1 day of grace
2541                 finedays    => 2,        # 2 days of fine per day of overdue
2542                 lengthunit  => 'days',
2543             }
2544         }
2545     );
2546
2547     # Patron cannot issue item_1, they have overdues
2548     my $now = dt_from_string;
2549     my $five_days_ago = $now->clone->subtract( days => 5 );
2550     my $ten_days_ago  = $now->clone->subtract( days => 10 );
2551     AddIssue( $patron->unblessed, $item_1->barcode, $five_days_ago );    # Add an overdue
2552     AddIssue( $patron->unblessed, $item_2->barcode, $ten_days_ago )
2553       ;    # Add another overdue
2554
2555     t::lib::Mocks::mock_preference( 'CumulativeRestrictionPeriods', '0' );
2556     AddReturn( $item_1->barcode, $library->{branchcode}, undef, $now );
2557     my $suspensions = $patron->restrictions->search( { type => 'SUSPENSION' } );
2558     is( $suspensions->count, 1, "Suspension added" );
2559     my $THE_suspension = $suspensions->next;
2560
2561     # FIXME Is it right? I'd have expected 5 * 2 - 1 instead
2562     # Same for the others
2563     my $expected_expiration = output_pref(
2564         {
2565             dt         => $now->clone->add( days => ( 5 - 1 ) * 2 ),
2566             dateformat => 'sql',
2567             dateonly   => 1
2568         }
2569     );
2570     is( $THE_suspension->expiration, $expected_expiration, "Suspesion expiration set" );
2571
2572     AddReturn( $item_2->barcode, $library->{branchcode}, undef, $now );
2573     $suspensions = $patron->restrictions->search( { type => 'SUSPENSION' } );
2574     is( $suspensions->count, 1, "Only one suspension" );
2575     $THE_suspension = $suspensions->next;
2576
2577     $expected_expiration = output_pref(
2578         {
2579             dt         => $now->clone->add( days => ( 10 - 1 ) * 2 ),
2580             dateformat => 'sql',
2581             dateonly   => 1
2582         }
2583     );
2584     is( $THE_suspension->expiration, $expected_expiration, "Suspension expiration date updated" );
2585
2586     Koha::Patron::Debarments::DelUniqueDebarment(
2587         { borrowernumber => $patron->borrowernumber, type => 'SUSPENSION' } );
2588
2589     t::lib::Mocks::mock_preference( 'CumulativeRestrictionPeriods', '1' );
2590     AddIssue( $patron->unblessed, $item_1->barcode, $five_days_ago );    # Add an overdue
2591     AddIssue( $patron->unblessed, $item_2->barcode, $ten_days_ago )
2592       ;    # Add another overdue
2593     AddReturn( $item_1->barcode, $library->{branchcode}, undef, $now );
2594     $suspensions = $patron->restrictions->search( { type => 'SUSPENSION' } );
2595     is( $suspensions->count, 1, "Only one suspension" );
2596     $THE_suspension = $suspensions->next;
2597
2598     $expected_expiration = output_pref(
2599         {
2600             dt         => $now->clone->add( days => ( 5 - 1 ) * 2 ),
2601             dateformat => 'sql',
2602             dateonly   => 1
2603         }
2604     );
2605     is( $THE_suspension->expiration, $expected_expiration, "Suspension expiration date updated" );
2606
2607     AddReturn( $item_2->barcode, $library->{branchcode}, undef, $now );
2608     $suspensions = $patron->restrictions->search( { type => 'SUSPENSION' } );
2609     is( $suspensions->count, 1, "Only one suspension" );
2610     $THE_suspension = $suspensions->next;
2611
2612     $expected_expiration = output_pref(
2613         {
2614             dt => $now->clone->add( days => ( 5 - 1 ) * 2 + ( 10 - 1 ) * 2 ),
2615             dateformat => 'sql',
2616             dateonly   => 1
2617         }
2618     );
2619     is( $THE_suspension->expiration, $expected_expiration, "Suspension expiration date updated" );
2620 };
2621
2622 subtest 'AddReturn + suspension_chargeperiod' => sub {
2623     plan tests => 29;
2624
2625     my $library = $builder->build( { source => 'Branch' } );
2626     my $patron  = $builder->build_object( { class => 'Koha::Patrons', value => { categorycode => $patron_category->{categorycode} } } );
2627
2628     my $biblionumber = $builder->build_sample_biblio(
2629         {
2630             branchcode => $library->{branchcode},
2631         }
2632     )->biblionumber;
2633     my $item_1 = $builder->build_sample_item(
2634         {
2635             biblionumber => $biblionumber,
2636             library      => $library->{branchcode},
2637         }
2638     );
2639
2640     # And the issuing rule
2641     Koha::CirculationRules->search->delete;
2642     Koha::CirculationRules->set_rules(
2643         {
2644             categorycode => '*',
2645             itemtype     => '*',
2646             branchcode   => '*',
2647             rules        => {
2648                 issuelength => 1,
2649                 firstremind => 0,    # 0 day of grace
2650                 finedays    => 2,    # 2 days of fine per day of overdue
2651                 suspension_chargeperiod => 1,
2652                 lengthunit              => 'days',
2653             }
2654         }
2655     );
2656
2657     my $now = dt_from_string;
2658     my $five_days_ago = $now->clone->subtract( days => 5 );
2659     # We want to charge 2 days every day, without grace
2660     # With 5 days of overdue: 5 * Z
2661     my $expected_expiration = $now->clone->add( days => ( 5 * 2 ) / 1 );
2662     test_debarment_on_checkout(
2663         {
2664             item            => $item_1,
2665             library         => $library,
2666             patron          => $patron,
2667             due_date        => $five_days_ago,
2668             expiration_date => $expected_expiration,
2669         }
2670     );
2671
2672     # Same with undef firstremind
2673     Koha::CirculationRules->search->delete;
2674     Koha::CirculationRules->set_rules(
2675         {
2676             categorycode => '*',
2677             itemtype     => '*',
2678             branchcode   => '*',
2679             rules        => {
2680                 issuelength => 1,
2681                 firstremind => undef,    # 0 day of grace
2682                 finedays    => 2,    # 2 days of fine per day of overdue
2683                 suspension_chargeperiod => 1,
2684                 lengthunit              => 'days',
2685             }
2686         }
2687     );
2688     {
2689     my $now = dt_from_string;
2690     my $five_days_ago = $now->clone->subtract( days => 5 );
2691     # We want to charge 2 days every day, without grace
2692     # With 5 days of overdue: 5 * Z
2693     my $expected_expiration = $now->clone->add( days => ( 5 * 2 ) / 1 );
2694     test_debarment_on_checkout(
2695         {
2696             item            => $item_1,
2697             library         => $library,
2698             patron          => $patron,
2699             due_date        => $five_days_ago,
2700             expiration_date => $expected_expiration,
2701         }
2702     );
2703     }
2704     # We want to charge 2 days every 2 days, without grace
2705     # With 5 days of overdue: (5 * 2) / 2
2706     Koha::CirculationRules->set_rule(
2707         {
2708             categorycode => undef,
2709             branchcode   => undef,
2710             itemtype     => undef,
2711             rule_name    => 'suspension_chargeperiod',
2712             rule_value   => '2',
2713         }
2714     );
2715
2716     $expected_expiration = $now->clone->add( days => floor( 5 * 2 ) / 2 );
2717     test_debarment_on_checkout(
2718         {
2719             item            => $item_1,
2720             library         => $library,
2721             patron          => $patron,
2722             due_date        => $five_days_ago,
2723             expiration_date => $expected_expiration,
2724         }
2725     );
2726
2727     # We want to charge 2 days every 3 days, with 1 day of grace
2728     # With 5 days of overdue: ((5-1) / 3 ) * 2
2729     Koha::CirculationRules->set_rules(
2730         {
2731             categorycode => undef,
2732             branchcode   => undef,
2733             itemtype     => undef,
2734             rules        => {
2735                 suspension_chargeperiod => 3,
2736                 firstremind             => 1,
2737             }
2738         }
2739     );
2740     $expected_expiration = $now->clone->add( days => floor( ( ( 5 - 1 ) / 3 ) * 2 ) );
2741     test_debarment_on_checkout(
2742         {
2743             item            => $item_1,
2744             library         => $library,
2745             patron          => $patron,
2746             due_date        => $five_days_ago,
2747             expiration_date => $expected_expiration,
2748         }
2749     );
2750
2751     # Use finesCalendar to know if holiday must be skipped to calculate the due date
2752     # We want to charge 2 days every days, with 0 day of grace (to not burn brains)
2753     Koha::CirculationRules->set_rules(
2754         {
2755             categorycode => undef,
2756             branchcode   => undef,
2757             itemtype     => undef,
2758             rules        => {
2759                 finedays                => 2,
2760                 suspension_chargeperiod => 1,
2761                 firstremind             => 0,
2762             }
2763         }
2764     );
2765     t::lib::Mocks::mock_preference('finesCalendar', 'noFinesWhenClosed');
2766     t::lib::Mocks::mock_preference('SuspensionsCalendar', 'noSuspensionsWhenClosed');
2767
2768     # Adding a holiday 2 days ago
2769     my $calendar = C4::Calendar->new(branchcode => $library->{branchcode});
2770     my $two_days_ago = $now->clone->subtract( days => 2 );
2771     $calendar->insert_single_holiday(
2772         day             => $two_days_ago->day,
2773         month           => $two_days_ago->month,
2774         year            => $two_days_ago->year,
2775         title           => 'holidayTest-2d',
2776         description     => 'holidayDesc 2 days ago'
2777     );
2778     # With 5 days of overdue, only 4 (x finedays=2) days must charged (one was an holiday)
2779     $expected_expiration = $now->clone->add( days => floor( ( ( 5 - 0 - 1 ) / 1 ) * 2 ) );
2780     test_debarment_on_checkout(
2781         {
2782             item            => $item_1,
2783             library         => $library,
2784             patron          => $patron,
2785             due_date        => $five_days_ago,
2786             expiration_date => $expected_expiration,
2787         }
2788     );
2789
2790     # Adding a holiday 2 days ahead, with finesCalendar=noFinesWhenClosed it should be skipped
2791     my $two_days_ahead = $now->clone->add( days => 2 );
2792     $calendar->insert_single_holiday(
2793         day             => $two_days_ahead->day,
2794         month           => $two_days_ahead->month,
2795         year            => $two_days_ahead->year,
2796         title           => 'holidayTest+2d',
2797         description     => 'holidayDesc 2 days ahead'
2798     );
2799
2800     # Same as above, but we should skip D+2
2801     $expected_expiration = $now->clone->add( days => floor( ( ( 5 - 0 - 1 ) / 1 ) * 2 ) + 1 );
2802     test_debarment_on_checkout(
2803         {
2804             item            => $item_1,
2805             library         => $library,
2806             patron          => $patron,
2807             due_date        => $five_days_ago,
2808             expiration_date => $expected_expiration,
2809         }
2810     );
2811
2812     # Adding another holiday, day of expiration date
2813     my $expected_expiration_dt = dt_from_string($expected_expiration);
2814     $calendar->insert_single_holiday(
2815         day             => $expected_expiration_dt->day,
2816         month           => $expected_expiration_dt->month,
2817         year            => $expected_expiration_dt->year,
2818         title           => 'holidayTest_exp',
2819         description     => 'holidayDesc on expiration date'
2820     );
2821     # Expiration date will be the day after
2822     test_debarment_on_checkout(
2823         {
2824             item            => $item_1,
2825             library         => $library,
2826             patron          => $patron,
2827             due_date        => $five_days_ago,
2828             expiration_date => $expected_expiration_dt->clone->add( days => 1 ),
2829         }
2830     );
2831
2832     test_debarment_on_checkout(
2833         {
2834             item            => $item_1,
2835             library         => $library,
2836             patron          => $patron,
2837             return_date     => $now->clone->add(days => 5),
2838             expiration_date => $now->clone->add(days => 5 + (5 * 2 - 1) ),
2839         }
2840     );
2841
2842     test_debarment_on_checkout(
2843         {
2844             item            => $item_1,
2845             library         => $library,
2846             patron          => $patron,
2847             due_date        => $now->clone->add(days => 1),
2848             return_date     => $now->clone->add(days => 5),
2849             expiration_date => $now->clone->add(days => 5 + (4 * 2 - 1) ),
2850         }
2851     );
2852
2853     Koha::CirculationRules->search->delete;
2854     Koha::CirculationRules->set_rules(
2855         {
2856             categorycode => undef,
2857             itemtype     => undef,
2858             branchcode   => undef,
2859             rules => {
2860                 finedays   => 0,
2861                 lengthunit => 'days',
2862               }
2863         }
2864     );
2865
2866     Koha::Patron::Debarments::AddDebarment(
2867         {
2868             borrowernumber => $patron->borrowernumber,
2869             expiration     => '9999-12-31',
2870             type           => 'MANUAL',
2871         }
2872     );
2873
2874     AddIssue( $patron->unblessed, $item_1->barcode, $now->clone->subtract( days => 1 ) );
2875     my ( undef, $message ) = AddReturn( $item_1->barcode, $library->{branchcode}, undef, $now );
2876     is( $message->{WasReturned} && exists $message->{ForeverDebarred}, 1, 'Forever debarred message for Addreturn when overdue');
2877
2878     Koha::Patron::Debarments::DelUniqueDebarment(
2879         {
2880             borrowernumber => $patron->borrowernumber,
2881             type           => 'MANUAL',
2882         }
2883     );
2884     Koha::Patron::Debarments::AddDebarment(
2885         {
2886             borrowernumber => $patron->borrowernumber,
2887             expiration     => $now->clone->add( days => 10 ),
2888             type           => 'MANUAL',
2889         }
2890     );
2891
2892     AddIssue( $patron->unblessed, $item_1->barcode, $now->clone->subtract( days => 1 ) );
2893     (undef, $message) = AddReturn( $item_1->barcode, $library->{branchcode}, undef, $now );
2894     is( $message->{WasReturned} && exists $message->{PrevDebarred}, 1, 'Previously debarred message for Addreturn when overdue');
2895 };
2896
2897 subtest 'CanBookBeIssued + AutoReturnCheckedOutItems' => sub {
2898     plan tests => 2;
2899
2900     my $library = $builder->build_object( { class => 'Koha::Libraries' } );
2901     my $patron1 = $builder->build_object(
2902         {
2903             class => 'Koha::Patrons',
2904             value => {
2905                 branchcode   => $library->branchcode,
2906                 categorycode => $patron_category->{categorycode}
2907             }
2908         }
2909     );
2910     my $patron2 = $builder->build_object(
2911         {
2912             class => 'Koha::Patrons',
2913             value => {
2914                 branchcode   => $library->branchcode,
2915                 categorycode => $patron_category->{categorycode}
2916             }
2917         }
2918     );
2919
2920     t::lib::Mocks::mock_userenv({ branchcode => $library->branchcode });
2921
2922     my $item = $builder->build_sample_item(
2923         {
2924             library      => $library->branchcode,
2925         }
2926     );
2927
2928     my ( $error, $question, $alerts );
2929     my $issue = AddIssue( $patron1->unblessed, $item->barcode );
2930
2931     t::lib::Mocks::mock_preference('AutoReturnCheckedOutItems', 0);
2932     ( $error, $question, $alerts ) = CanBookBeIssued( $patron2, $item->barcode );
2933     is( $question->{ISSUED_TO_ANOTHER}, 1, 'ISSUED_TO_ANOTHER question flag should be set if AutoReturnCheckedOutItems is disabled and item is checked out to another' );
2934
2935     t::lib::Mocks::mock_preference('AutoReturnCheckedOutItems', 1);
2936     ( $error, $question, $alerts ) = CanBookBeIssued( $patron2, $item->barcode );
2937     is( $alerts->{RETURNED_FROM_ANOTHER}->{patron}->borrowernumber, $patron1->borrowernumber, 'RETURNED_FROM_ANOTHER alert flag should be set if AutoReturnCheckedOutItems is enabled and item is checked out to another' );
2938
2939     t::lib::Mocks::mock_preference('AutoReturnCheckedOutItems', 0);
2940 };
2941
2942
2943 subtest 'AddReturn | is_overdue' => sub {
2944     plan tests => 9;
2945
2946     t::lib::Mocks::mock_preference('MarkLostItemsAsReturned', 'batchmod|moredetail|cronjob|additem|pendingreserves|onpayment');
2947     t::lib::Mocks::mock_preference('CalculateFinesOnReturn', 1);
2948     t::lib::Mocks::mock_preference('finesMode', 'production');
2949     t::lib::Mocks::mock_preference('MaxFine', '100');
2950
2951     my $library = $builder->build( { source => 'Branch' } );
2952     my $patron  = $builder->build_object(
2953         {
2954             class => 'Koha::Patrons',
2955             value => { categorycode => $patron_category->{categorycode} }
2956         }
2957     );
2958     my $manager = $builder->build_object( { class => "Koha::Patrons" } );
2959     t::lib::Mocks::mock_userenv({ patron => $manager, branchcode => $manager->branchcode });
2960
2961     my $item = $builder->build_sample_item(
2962         {
2963             library      => $library->{branchcode},
2964             replacementprice => 7
2965         }
2966     );
2967
2968     Koha::CirculationRules->search->delete;
2969     Koha::CirculationRules->set_rules(
2970         {
2971             categorycode => undef,
2972             itemtype     => undef,
2973             branchcode   => undef,
2974             rules        => {
2975                 issuelength  => 6,
2976                 lengthunit   => 'days',
2977                 fine         => 1,        # Charge 1 every day of overdue
2978                 chargeperiod => 1,
2979             }
2980         }
2981     );
2982
2983     my $now   = dt_from_string;
2984     my $one_day_ago   = $now->clone->subtract( days => 1 );
2985     my $two_days_ago  = $now->clone->subtract( days => 2 );
2986     my $five_days_ago = $now->clone->subtract( days => 5 );
2987     my $ten_days_ago  = $now->clone->subtract( days => 10 );
2988
2989     # No return date specified, today will be used => 10 days overdue charged
2990     AddIssue( $patron->unblessed, $item->barcode, $ten_days_ago ); # date due was 10d ago
2991     AddReturn( $item->barcode, $library->{branchcode} );
2992     is( int($patron->account->balance()), 10, 'Patron should have a charge of 10 (10 days x 1)' );
2993     Koha::Account::Lines->search({ borrowernumber => $patron->borrowernumber })->delete;
2994
2995     # specify return date 5 days before => no overdue charged
2996     AddIssue( $patron->unblessed, $item->barcode, $five_days_ago ); # date due was 5d ago
2997     AddReturn( $item->barcode, $library->{branchcode}, undef, $ten_days_ago );
2998     is( int($patron->account->balance()), 0, 'AddReturn: pass return_date => no overdue' );
2999     Koha::Account::Lines->search({ borrowernumber => $patron->borrowernumber })->delete;
3000
3001     # specify return date 5 days later => 5 days overdue charged
3002     AddIssue( $patron->unblessed, $item->barcode, $ten_days_ago ); # date due was 10d ago
3003     AddReturn( $item->barcode, $library->{branchcode}, undef, $five_days_ago );
3004     is( int($patron->account->balance()), 5, 'AddReturn: pass return_date => overdue' );
3005     Koha::Account::Lines->search({ borrowernumber => $patron->borrowernumber })->delete;
3006
3007     # specify return date 5 days later, specify exemptfine => no overdue charge
3008     AddIssue( $patron->unblessed, $item->barcode, $ten_days_ago ); # date due was 10d ago
3009     AddReturn( $item->barcode, $library->{branchcode}, 1, $five_days_ago );
3010     is( int($patron->account->balance()), 0, 'AddReturn: pass return_date => no overdue' );
3011     Koha::Account::Lines->search({ borrowernumber => $patron->borrowernumber })->delete;
3012
3013     subtest 'bug 22877 | Lost item return' => sub {
3014
3015         plan tests => 3;
3016
3017         my $issue = AddIssue( $patron->unblessed, $item->barcode, $ten_days_ago );    # date due was 10d ago
3018
3019         # Fake fines cronjob on this checkout
3020         my ($fine) =
3021           CalcFine( $item, $patron->categorycode, $library->{branchcode},
3022             $ten_days_ago, $now );
3023         UpdateFine(
3024             {
3025                 issue_id       => $issue->issue_id,
3026                 itemnumber     => $item->itemnumber,
3027                 borrowernumber => $patron->borrowernumber,
3028                 amount         => $fine,
3029                 due            => output_pref($ten_days_ago)
3030             }
3031         );
3032         is( int( $patron->account->balance() ),
3033             10, "Overdue fine of 10 days overdue" );
3034
3035         # Fake longoverdue with charge and not marking returned
3036         LostItem( $item->itemnumber, 'cronjob', 0 );
3037         is( int( $patron->account->balance() ),
3038             17, "Lost fine of 7 plus 10 days overdue" );
3039
3040         # Now we return it today
3041         AddReturn( $item->barcode, $library->{branchcode} );
3042         is( int( $patron->account->balance() ),
3043             17, "Should have a single 10 days overdue fine and lost charge" );
3044
3045         # Cleanup
3046         Koha::Account::Lines->search({ borrowernumber => $patron->borrowernumber })->delete;
3047     };
3048
3049     subtest 'bug 8338 | backdated return resulting in zero amount fine' => sub {
3050
3051         plan tests => 17;
3052
3053         t::lib::Mocks::mock_preference('CalculateFinesOnBackdate', 1);
3054
3055         my $issue = AddIssue( $patron->unblessed, $item->barcode, $one_day_ago );    # date due was 1d ago
3056
3057         # Fake fines cronjob on this checkout
3058         my ($fine) =
3059           CalcFine( $item, $patron->categorycode, $library->{branchcode},
3060             $one_day_ago, $now );
3061         UpdateFine(
3062             {
3063                 issue_id       => $issue->issue_id,
3064                 itemnumber     => $item->itemnumber,
3065                 borrowernumber => $patron->borrowernumber,
3066                 amount         => $fine,
3067                 due            => output_pref($one_day_ago)
3068             }
3069         );
3070         is( int( $patron->account->balance() ),
3071             1, "Overdue fine of 1 day overdue" );
3072
3073         # Backdated return (dropbox mode example - charge should be removed)
3074         AddReturn( $item->barcode, $library->{branchcode}, 1, $one_day_ago );
3075         is( int( $patron->account->balance() ),
3076             0, "Overdue fine should be annulled" );
3077         my $lines = Koha::Account::Lines->search({ borrowernumber => $patron->borrowernumber });
3078         is( $lines->count, 0, "Overdue fine accountline has been removed");
3079
3080         $issue = AddIssue( $patron->unblessed, $item->barcode, $two_days_ago );    # date due was 2d ago
3081
3082         # Fake fines cronjob on this checkout
3083         ($fine) =
3084           CalcFine( $item, $patron->categorycode, $library->{branchcode},
3085             $two_days_ago, $now );
3086         UpdateFine(
3087             {
3088                 issue_id       => $issue->issue_id,
3089                 itemnumber     => $item->itemnumber,
3090                 borrowernumber => $patron->borrowernumber,
3091                 amount         => $fine,
3092                 due            => output_pref($one_day_ago)
3093             }
3094         );
3095         is( int( $patron->account->balance() ),
3096             2, "Overdue fine of 2 days overdue" );
3097
3098         # Payment made against fine
3099         $lines = Koha::Account::Lines->search({ borrowernumber => $patron->borrowernumber });
3100         my $debit = $lines->next;
3101         my $credit = $patron->account->add_credit(
3102             {
3103                 amount    => 2,
3104                 type      => 'PAYMENT',
3105                 interface => 'test',
3106             }
3107         );
3108         $credit->apply( { debits => [$debit] } );
3109
3110         is( int( $patron->account->balance() ),
3111             0, "Overdue fine should be paid off" );
3112         $lines = Koha::Account::Lines->search({ borrowernumber => $patron->borrowernumber });
3113         is ( $lines->count, 2, "Overdue (debit) and Payment (credit) present");
3114         my $line = $lines->next;
3115         is( $line->amount+0, 2, "Overdue fine amount remains as 2 days");
3116         is( $line->amountoutstanding+0, 0, "Overdue fine amountoutstanding reduced to 0");
3117
3118         # Backdated return (dropbox mode example - charge should be removed)
3119         AddReturn( $item->barcode, $library->{branchcode}, undef, $one_day_ago );
3120         is( int( $patron->account->balance() ),
3121             -1, "Refund credit has been applied" );
3122         $lines = Koha::Account::Lines->search({ borrowernumber => $patron->borrowernumber }, { order_by => { '-asc' => 'accountlines_id' }});
3123         is( $lines->count, 3, "Overdue (debit), Payment (credit) and Refund (credit) are all present");
3124
3125         $line = $lines->next;
3126         is($line->amount+0,1, "Overdue fine amount has been reduced to 1");
3127         is($line->amountoutstanding+0,0, "Overdue fine amount outstanding remains at 0");
3128         is($line->status,'RETURNED', "Overdue fine is fixed");
3129         $line = $lines->next;
3130         is($line->amount+0,-2, "Original payment amount remains as 2");
3131         is($line->amountoutstanding+0,0, "Original payment remains applied");
3132         $line = $lines->next;
3133         is($line->amount+0,-1, "Refund amount correctly set to 1");
3134         is($line->amountoutstanding+0,-1, "Refund amount outstanding unspent");
3135
3136         # Cleanup
3137         Koha::Account::Lines->search({ borrowernumber => $patron->borrowernumber })->delete;
3138     };
3139
3140     subtest 'bug 25417 | backdated return + exemptfine' => sub {
3141
3142         plan tests => 2;
3143
3144         t::lib::Mocks::mock_preference('CalculateFinesOnBackdate', 1);
3145
3146         my $issue = AddIssue( $patron->unblessed, $item->barcode, $one_day_ago );    # date due was 1d ago
3147
3148         # Fake fines cronjob on this checkout
3149         my ($fine) =
3150           CalcFine( $item, $patron->categorycode, $library->{branchcode},
3151             $one_day_ago, $now );
3152         UpdateFine(
3153             {
3154                 issue_id       => $issue->issue_id,
3155                 itemnumber     => $item->itemnumber,
3156                 borrowernumber => $patron->borrowernumber,
3157                 amount         => $fine,
3158                 due            => output_pref($one_day_ago)
3159             }
3160         );
3161         is( int( $patron->account->balance() ),
3162             1, "Overdue fine of 1 day overdue" );
3163
3164         # Backdated return (dropbox mode example - charge should no longer exist)
3165         AddReturn( $item->barcode, $library->{branchcode}, 1, $one_day_ago );
3166         is( int( $patron->account->balance() ),
3167             0, "Overdue fine should be annulled" );
3168
3169         # Cleanup
3170         Koha::Account::Lines->search({ borrowernumber => $patron->borrowernumber })->delete;
3171     };
3172
3173     subtest 'bug 24075 | backdated return with return datetime matching due datetime' => sub {
3174         plan tests => 7;
3175
3176         t::lib::Mocks::mock_preference( 'CalculateFinesOnBackdate', 1 );
3177
3178         my $due_date = dt_from_string;
3179         my $issue = AddIssue( $patron->unblessed, $item->barcode, $due_date );
3180
3181         # Add fine
3182         UpdateFine(
3183             {
3184                 issue_id       => $issue->issue_id,
3185                 itemnumber     => $item->itemnumber,
3186                 borrowernumber => $patron->borrowernumber,
3187                 amount         => 0.25,
3188                 due            => output_pref($due_date)
3189             }
3190         );
3191         is( $patron->account->balance(),
3192             0.25, 'Overdue fine of $0.25 recorded' );
3193
3194         # Backdate return to exact due date and time
3195         my ( undef, $message ) =
3196           AddReturn( $item->barcode, $library->{branchcode},
3197             undef, $due_date );
3198
3199         my $accountline =
3200           Koha::Account::Lines->find( { issue_id => $issue->id } );
3201         ok( !$accountline, 'accountline removed as expected' );
3202
3203         # Re-issue
3204         $issue = AddIssue( $patron->unblessed, $item->barcode, $due_date );
3205
3206         # Add fine
3207         UpdateFine(
3208             {
3209                 issue_id       => $issue->issue_id,
3210                 itemnumber     => $item->itemnumber,
3211                 borrowernumber => $patron->borrowernumber,
3212                 amount         => .25,
3213                 due            => output_pref($due_date)
3214             }
3215         );
3216         is( $patron->account->balance(),
3217             0.25, 'Overdue fine of $0.25 recorded' );
3218
3219         # Partial pay accruing fine
3220         my $lines = Koha::Account::Lines->search(
3221             {
3222                 borrowernumber => $patron->borrowernumber,
3223                 issue_id       => $issue->id
3224             }
3225         );
3226         my $debit  = $lines->next;
3227         my $credit = $patron->account->add_credit(
3228             {
3229                 amount    => .20,
3230                 type      => 'PAYMENT',
3231                 interface => 'test',
3232             }
3233         );
3234         $credit->apply( { debits => [$debit] } );
3235
3236         is( $patron->account->balance(), .05, 'Overdue fine reduced to $0.05' );
3237
3238         # Backdate return to exact due date and time
3239         ( undef, $message ) =
3240           AddReturn( $item->barcode, $library->{branchcode},
3241             undef, $due_date );
3242
3243         $lines = Koha::Account::Lines->search(
3244             {
3245                 borrowernumber => $patron->borrowernumber,
3246                 issue_id       => $issue->id
3247             }
3248         );
3249         $accountline = $lines->next;
3250         is( $accountline->amountoutstanding + 0,
3251             0, 'Partially paid fee amount outstanding was reduced to 0' );
3252         is( $accountline->amount + 0,
3253             0, 'Partially paid fee amount was reduced to 0' );
3254         is( $patron->account->balance(), -0.20, 'Patron refund recorded' );
3255
3256         # Cleanup
3257         Koha::Account::Lines->search(
3258             { borrowernumber => $patron->borrowernumber } )->delete;
3259     };
3260
3261     subtest 'enh 23091 | Lost item return policies' => sub {
3262         plan tests => 5;
3263
3264         my $manager = $builder->build_object({ class => "Koha::Patrons" });
3265
3266         my $branchcode_false =
3267           $builder->build( { source => 'Branch' } )->{branchcode};
3268         my $specific_rule_false = $builder->build(
3269             {
3270                 source => 'CirculationRule',
3271                 value  => {
3272                     branchcode   => $branchcode_false,
3273                     categorycode => undef,
3274                     itemtype     => undef,
3275                     rule_name    => 'lostreturn',
3276                     rule_value   => 0
3277                 }
3278             }
3279         );
3280         my $branchcode_refund =
3281           $builder->build( { source => 'Branch' } )->{branchcode};
3282         my $specific_rule_refund = $builder->build(
3283             {
3284                 source => 'CirculationRule',
3285                 value  => {
3286                     branchcode   => $branchcode_refund,
3287                     categorycode => undef,
3288                     itemtype     => undef,
3289                     rule_name    => 'lostreturn',
3290                     rule_value   => 'refund'
3291                 }
3292             }
3293         );
3294         my $branchcode_restore =
3295           $builder->build( { source => 'Branch' } )->{branchcode};
3296         my $specific_rule_restore = $builder->build(
3297             {
3298                 source => 'CirculationRule',
3299                 value  => {
3300                     branchcode   => $branchcode_restore,
3301                     categorycode => undef,
3302                     itemtype     => undef,
3303                     rule_name    => 'lostreturn',
3304                     rule_value   => 'restore'
3305                 }
3306             }
3307         );
3308         my $branchcode_charge =
3309           $builder->build( { source => 'Branch' } )->{branchcode};
3310         my $specific_rule_charge = $builder->build(
3311             {
3312                 source => 'CirculationRule',
3313                 value  => {
3314                     branchcode   => $branchcode_charge,
3315                     categorycode => undef,
3316                     itemtype     => undef,
3317                     rule_name    => 'lostreturn',
3318                     rule_value   => 'charge'
3319                 }
3320             }
3321         );
3322
3323         my $branchcode_refund_unpaid =
3324         $builder->build( { source => 'Branch' } )->{branchcode};
3325         my $specific_rule_refund_unpaid = $builder->build(
3326             {
3327                 source => 'CirculationRule',
3328                 value  => {
3329                     branchcode   => $branchcode_refund_unpaid,
3330                     categorycode => undef,
3331                     itemtype     => undef,
3332                     rule_name    => 'lostreturn',
3333                     rule_value   => 'refund_unpaid'
3334                 }
3335             }
3336         );
3337
3338         my $replacement_amount = 99.00;
3339         t::lib::Mocks::mock_preference( 'AllowReturnToBranch', 'anywhere' );
3340         t::lib::Mocks::mock_preference( 'WhenLostChargeReplacementFee', 1 );
3341         t::lib::Mocks::mock_preference( 'WhenLostForgiveFine',          0 );
3342         t::lib::Mocks::mock_preference( 'BlockReturnOfLostItems',       0 );
3343         t::lib::Mocks::mock_preference( 'RefundLostOnReturnControl',
3344             'CheckinLibrary' );
3345         t::lib::Mocks::mock_preference( 'NoRefundOnLostReturnedItemsAge',
3346             undef );
3347
3348         subtest 'lostreturn | refund_unpaid' => sub {
3349             plan tests => 21;
3350
3351             t::lib::Mocks::mock_userenv({ patron => $manager, branchcode => $branchcode_refund_unpaid });
3352
3353             my $item = $builder->build_sample_item(
3354                 {
3355                     replacementprice => $replacement_amount
3356                 }
3357             );
3358
3359             # Issue the item
3360             my $issue = C4::Circulation::AddIssue( $patron->unblessed, $item->barcode );
3361
3362             # Mark item as lost
3363             $item->itemlost(3)->store;
3364             C4::Circulation::LostItem( $item->itemnumber, 1 );
3365
3366             my $lost_fee_lines = Koha::Account::Lines->search(
3367                 {
3368                     borrowernumber  => $patron->id,
3369                     itemnumber      => $item->itemnumber,
3370                     debit_type_code => 'LOST'
3371                 }
3372             );
3373             is( $lost_fee_lines->count, 1, 'Lost item fee produced' );
3374             my $lost_fee_line = $lost_fee_lines->next;
3375             is( int($lost_fee_line->amount),
3376                 $replacement_amount, 'The right LOST amount is generated' );
3377             is( int($lost_fee_line->amountoutstanding),
3378                 $replacement_amount,
3379                 'The right LOST amountoutstanding is generated' );
3380             is( $lost_fee_line->status, undef, 'The LOST status was not set' );
3381
3382             is(
3383                 int($patron->account->balance),
3384                 $replacement_amount ,
3385                 "Account balance equals the replacement amount after being charged lost fee when no payments has been made"
3386             );
3387
3388             # Return lost item without any payments having been made
3389             my ( $returned, $message ) = AddReturn( $item->barcode, $branchcode_refund_unpaid );
3390
3391             $lost_fee_line->discard_changes;
3392
3393             is( int($lost_fee_line->amount), $replacement_amount, 'The LOST amount is left intact' );
3394             is( int($lost_fee_line->amountoutstanding) , 0, 'The LOST amountoutstanding is zero' );
3395             is( $lost_fee_line->status, 'FOUND', 'The FOUND status was set' );
3396             is(
3397                 int($patron->account->balance),
3398                 0,
3399                 'Account balance should be zero after returning item with lost fee when no payments has been made'
3400             );
3401
3402             # Create a second item
3403             $item = $builder->build_sample_item(
3404                 {
3405                     replacementprice => $replacement_amount
3406                 }
3407             );
3408
3409             # Issue the item
3410             $issue = C4::Circulation::AddIssue( $patron->unblessed, $item->barcode );
3411
3412             # Mark item as lost
3413             $item->itemlost(3)->store;
3414             C4::Circulation::LostItem( $item->itemnumber, 1 );
3415
3416             $lost_fee_lines = Koha::Account::Lines->search(
3417                 {
3418                     borrowernumber  => $patron->id,
3419                     itemnumber      => $item->itemnumber,
3420                     debit_type_code => 'LOST'
3421                 }
3422             );
3423             is( $lost_fee_lines->count, 1, 'Lost item fee produced' );
3424             $lost_fee_line = $lost_fee_lines->next;
3425
3426             # Make partial payment
3427             $patron->account->payin_amount({
3428                 type => 'PAYMENT',
3429                 interface => 'intranet',
3430                 payment_type => 'CASH',
3431                 user_id => $patron->borrowernumber,
3432                 amount => 39.00,
3433                 debits => [$lost_fee_line]
3434             });
3435
3436             $lost_fee_line->discard_changes;
3437
3438             is( int($lost_fee_line->amountoutstanding),
3439                 60,
3440                 'The LOST amountoutstanding is the expected amount after partial payment of lost fee'
3441             );
3442
3443             is(
3444                 int($patron->account->balance),
3445                 60,
3446                 'Account balance is the expected amount after partial payment of lost fee'
3447             );
3448
3449              # Return lost item with partial payment having been made
3450             ( $returned, $message ) = AddReturn( $item->barcode, $branchcode_refund_unpaid );
3451
3452             $lost_fee_line->discard_changes;
3453
3454             is( int($lost_fee_line->amountoutstanding) , 0, 'The LOST amountoutstanding is zero after returning lost item with partial payment' );
3455             is( $lost_fee_line->status, 'FOUND', 'The FOUND status was set for lost item with partial payment' );
3456             is(
3457                 int($patron->account->balance),
3458                 0,
3459                 'Account balance should be zero after returning item with lost fee when partial payment has been made'
3460             );
3461
3462             # Create a third item
3463             $item = $builder->build_sample_item(
3464                 {
3465                     replacementprice => $replacement_amount
3466                 }
3467             );
3468
3469             # Issue the item
3470             $issue = C4::Circulation::AddIssue( $patron->unblessed, $item->barcode );
3471
3472             # Mark item as lost
3473             $item->itemlost(3)->store;
3474             C4::Circulation::LostItem( $item->itemnumber, 1 );
3475
3476             $lost_fee_lines = Koha::Account::Lines->search(
3477                 {
3478                     borrowernumber  => $patron->id,
3479                     itemnumber      => $item->itemnumber,
3480                     debit_type_code => 'LOST'
3481                 }
3482             );
3483             is( $lost_fee_lines->count, 1, 'Lost item fee produced' );
3484             $lost_fee_line = $lost_fee_lines->next;
3485
3486             # Make full payment
3487             $patron->account->payin_amount({
3488                 type => 'PAYMENT',
3489                 interface => 'intranet',
3490                 payment_type => 'CASH',
3491                 user_id => $patron->borrowernumber,
3492                 amount => $replacement_amount,
3493                 debits => [$lost_fee_line]
3494             });
3495
3496             $lost_fee_line->discard_changes;
3497
3498             is( int($lost_fee_line->amountoutstanding),
3499                 0,
3500                 'The LOST amountoutstanding is the expected amount after partial payment of lost fee'
3501             );
3502
3503             is(
3504                 int($patron->account->balance),
3505                 0,
3506                 'Account balance is the expected amount after partial payment of lost fee'
3507             );
3508
3509              # Return lost item with partial payment having been made
3510             ( $returned, $message ) = AddReturn( $item->barcode, $branchcode_refund_unpaid );
3511
3512             $lost_fee_line->discard_changes;
3513
3514             is( int($lost_fee_line->amountoutstanding) , 0, 'The LOST amountoutstanding is zero after returning lost item with full payment' );
3515             is( $lost_fee_line->status, 'FOUND', 'The FOUND status was set for lost item with partial payment' );
3516             is(
3517                 int($patron->account->balance),
3518                 0,
3519                 'Account balance should be zero after returning item with lost fee when full payment has been made'
3520             );
3521         };
3522
3523         subtest 'lostreturn | false' => sub {
3524             plan tests => 12;
3525
3526             t::lib::Mocks::mock_userenv({ patron => $manager, branchcode => $branchcode_false });
3527
3528             my $item = $builder->build_sample_item(
3529                 {
3530                     replacementprice => $replacement_amount
3531                 }
3532             );
3533
3534             # Issue the item
3535             my $issue = C4::Circulation::AddIssue( $patron->unblessed, $item->barcode, $ten_days_ago );
3536
3537             # Fake fines cronjob on this checkout
3538             my ($fine) =
3539               CalcFine( $item, $patron->categorycode, $library->{branchcode},
3540                 $ten_days_ago, $now );
3541             UpdateFine(
3542                 {
3543                     issue_id       => $issue->issue_id,
3544                     itemnumber     => $item->itemnumber,
3545                     borrowernumber => $patron->borrowernumber,
3546                     amount         => $fine,
3547                     due            => output_pref($ten_days_ago)
3548                 }
3549             );
3550             my $overdue_fees = Koha::Account::Lines->search(
3551                 {
3552                     borrowernumber  => $patron->id,
3553                     itemnumber      => $item->itemnumber,
3554                     debit_type_code => 'OVERDUE'
3555                 }
3556             );
3557             is( $overdue_fees->count, 1, 'Overdue item fee produced' );
3558             my $overdue_fee = $overdue_fees->next;
3559             is( $overdue_fee->amount + 0,
3560                 10, 'The right OVERDUE amount is generated' );
3561             is( $overdue_fee->amountoutstanding + 0,
3562                 10,
3563                 'The right OVERDUE amountoutstanding is generated' );
3564
3565             # Simulate item marked as lost
3566             $item->itemlost(3)->store;
3567             C4::Circulation::LostItem( $item->itemnumber, 1 );
3568
3569             my $lost_fee_lines = Koha::Account::Lines->search(
3570                 {
3571                     borrowernumber  => $patron->id,
3572                     itemnumber      => $item->itemnumber,
3573                     debit_type_code => 'LOST'
3574                 }
3575             );
3576             is( $lost_fee_lines->count, 1, 'Lost item fee produced' );
3577             my $lost_fee_line = $lost_fee_lines->next;
3578             is( $lost_fee_line->amount + 0,
3579                 $replacement_amount, 'The right LOST amount is generated' );
3580             is( $lost_fee_line->amountoutstanding + 0,
3581                 $replacement_amount,
3582                 'The right LOST amountoutstanding is generated' );
3583             is( $lost_fee_line->status, undef, 'The LOST status was not set' );
3584
3585             # Return lost item
3586             my ( $returned, $message ) =
3587               AddReturn( $item->barcode, $branchcode_false, undef, $five_days_ago );
3588
3589             $overdue_fee->discard_changes;
3590             is( $overdue_fee->amount + 0,
3591                 10, 'The OVERDUE amount is left intact' );
3592             is( $overdue_fee->amountoutstanding + 0,
3593                 10,
3594                 'The OVERDUE amountoutstanding is left intact' );
3595
3596             $lost_fee_line->discard_changes;
3597             is( $lost_fee_line->amount + 0,
3598                 $replacement_amount, 'The LOST amount is left intact' );
3599             is( $lost_fee_line->amountoutstanding + 0,
3600                 $replacement_amount,
3601                 'The LOST amountoutstanding is left intact' );
3602             # FIXME: Should we set the LOST fee status to 'FOUND' regardless of whether we're refunding or not?
3603             is( $lost_fee_line->status, undef, 'The LOST status was not set' );
3604         };
3605
3606         subtest 'lostreturn | refund' => sub {
3607             plan tests => 12;
3608
3609             t::lib::Mocks::mock_userenv({ patron => $manager, branchcode => $branchcode_refund });
3610
3611             my $item = $builder->build_sample_item(
3612                 {
3613                     replacementprice => $replacement_amount
3614                 }
3615             );
3616
3617             # Issue the item
3618             my $issue = C4::Circulation::AddIssue( $patron->unblessed, $item->barcode, $ten_days_ago );
3619
3620             # Fake fines cronjob on this checkout
3621             my ($fine) =
3622               CalcFine( $item, $patron->categorycode, $library->{branchcode},
3623                 $ten_days_ago, $now );
3624             UpdateFine(
3625                 {
3626                     issue_id       => $issue->issue_id,
3627                     itemnumber     => $item->itemnumber,
3628                     borrowernumber => $patron->borrowernumber,
3629                     amount         => $fine,
3630                     due            => output_pref($ten_days_ago)
3631                 }
3632             );
3633             my $overdue_fees = Koha::Account::Lines->search(
3634                 {
3635                     borrowernumber  => $patron->id,
3636                     itemnumber      => $item->itemnumber,
3637                     debit_type_code => 'OVERDUE'
3638                 }
3639             );
3640             is( $overdue_fees->count, 1, 'Overdue item fee produced' );
3641             my $overdue_fee = $overdue_fees->next;
3642             is( $overdue_fee->amount + 0,
3643                 10, 'The right OVERDUE amount is generated' );
3644             is( $overdue_fee->amountoutstanding + 0,
3645                 10,
3646                 'The right OVERDUE amountoutstanding is generated' );
3647
3648             # Simulate item marked as lost
3649             $item->itemlost(3)->store;
3650             C4::Circulation::LostItem( $item->itemnumber, 1 );
3651
3652             my $lost_fee_lines = Koha::Account::Lines->search(
3653                 {
3654                     borrowernumber  => $patron->id,
3655                     itemnumber      => $item->itemnumber,
3656                     debit_type_code => 'LOST'
3657                 }
3658             );
3659             is( $lost_fee_lines->count, 1, 'Lost item fee produced' );
3660             my $lost_fee_line = $lost_fee_lines->next;
3661             is( $lost_fee_line->amount + 0,
3662                 $replacement_amount, 'The right LOST amount is generated' );
3663             is( $lost_fee_line->amountoutstanding + 0,
3664                 $replacement_amount,
3665                 'The right LOST amountoutstanding is generated' );
3666             is( $lost_fee_line->status, undef, 'The LOST status was not set' );
3667
3668             # Return the lost item
3669             my ( undef, $message ) =
3670               AddReturn( $item->barcode, $branchcode_refund, undef, $five_days_ago );
3671
3672             $overdue_fee->discard_changes;
3673             is( $overdue_fee->amount + 0,
3674                 10, 'The OVERDUE amount is left intact' );
3675             is( $overdue_fee->amountoutstanding + 0,
3676                 10,
3677                 'The OVERDUE amountoutstanding is left intact' );
3678
3679             $lost_fee_line->discard_changes;
3680             is( $lost_fee_line->amount + 0,
3681                 $replacement_amount, 'The LOST amount is left intact' );
3682             is( $lost_fee_line->amountoutstanding + 0,
3683                 0,
3684                 'The LOST amountoutstanding is refunded' );
3685             is( $lost_fee_line->status, 'FOUND', 'The LOST status was set to FOUND' );
3686         };
3687
3688         subtest 'lostreturn | restore' => sub {
3689             plan tests => 13;
3690
3691             t::lib::Mocks::mock_userenv({ patron => $manager, branchcode => $branchcode_restore });
3692
3693             my $item = $builder->build_sample_item(
3694                 {
3695                     replacementprice => $replacement_amount
3696                 }
3697             );
3698
3699             # Issue the item
3700             my $issue = C4::Circulation::AddIssue( $patron->unblessed, $item->barcode , $ten_days_ago);
3701
3702             # Fake fines cronjob on this checkout
3703             my ($fine) =
3704               CalcFine( $item, $patron->categorycode, $library->{branchcode},
3705                 $ten_days_ago, $now );
3706             UpdateFine(
3707                 {
3708                     issue_id       => $issue->issue_id,
3709                     itemnumber     => $item->itemnumber,
3710                     borrowernumber => $patron->borrowernumber,
3711                     amount         => $fine,
3712                     due            => output_pref($ten_days_ago)
3713                 }
3714             );
3715             my $overdue_fees = Koha::Account::Lines->search(
3716                 {
3717                     borrowernumber  => $patron->id,
3718                     itemnumber      => $item->itemnumber,
3719                     debit_type_code => 'OVERDUE'
3720                 }
3721             );
3722             is( $overdue_fees->count, 1, 'Overdue item fee produced' );
3723             my $overdue_fee = $overdue_fees->next;
3724             is( $overdue_fee->amount + 0,
3725                 10, 'The right OVERDUE amount is generated' );
3726             is( $overdue_fee->amountoutstanding + 0,
3727                 10,
3728                 'The right OVERDUE amountoutstanding is generated' );
3729
3730             # Simulate item marked as lost
3731             $item->itemlost(3)->store;
3732             C4::Circulation::LostItem( $item->itemnumber, 1 );
3733
3734             my $lost_fee_lines = Koha::Account::Lines->search(
3735                 {
3736                     borrowernumber  => $patron->id,
3737                     itemnumber      => $item->itemnumber,
3738                     debit_type_code => 'LOST'
3739                 }
3740             );
3741             is( $lost_fee_lines->count, 1, 'Lost item fee produced' );
3742             my $lost_fee_line = $lost_fee_lines->next;
3743             is( $lost_fee_line->amount + 0,
3744                 $replacement_amount, 'The right LOST amount is generated' );
3745             is( $lost_fee_line->amountoutstanding + 0,
3746                 $replacement_amount,
3747                 'The right LOST amountoutstanding is generated' );
3748             is( $lost_fee_line->status, undef, 'The LOST status was not set' );
3749
3750             # Simulate refunding overdue fees upon marking item as lost
3751             my $overdue_forgive = $patron->account->add_credit(
3752                 {
3753                     amount     => 10.00,
3754                     user_id    => $manager->borrowernumber,
3755                     library_id => $branchcode_restore,
3756                     interface  => 'test',
3757                     type       => 'FORGIVEN',
3758                     item_id    => $item->itemnumber
3759                 }
3760             );
3761             $overdue_forgive->apply( { debits => [$overdue_fee] } );
3762             $overdue_fee->discard_changes;
3763             is($overdue_fee->amountoutstanding + 0, 0, 'Overdue fee forgiven');
3764
3765             # Do nothing
3766             my ( undef, $message ) =
3767               AddReturn( $item->barcode, $branchcode_restore, undef, $five_days_ago );
3768
3769             $overdue_fee->discard_changes;
3770             is( $overdue_fee->amount + 0,
3771                 10, 'The OVERDUE amount is left intact' );
3772             is( $overdue_fee->amountoutstanding + 0,
3773                 10,
3774                 'The OVERDUE amountoutstanding is restored' );
3775
3776             $lost_fee_line->discard_changes;
3777             is( $lost_fee_line->amount + 0,
3778                 $replacement_amount, 'The LOST amount is left intact' );
3779             is( $lost_fee_line->amountoutstanding + 0,
3780                 0,
3781                 'The LOST amountoutstanding is refunded' );
3782             is( $lost_fee_line->status, 'FOUND', 'The LOST status was set to FOUND' );
3783         };
3784
3785         subtest 'lostreturn | charge' => sub {
3786             plan tests => 16;
3787
3788             t::lib::Mocks::mock_userenv({ patron => $manager, branchcode => $branchcode_charge });
3789
3790             my $item = $builder->build_sample_item(
3791                 {
3792                     replacementprice => $replacement_amount
3793                 }
3794             );
3795
3796             # Issue the item
3797             my $issue = C4::Circulation::AddIssue( $patron->unblessed, $item->barcode, $ten_days_ago );
3798
3799             # Fake fines cronjob on this checkout
3800             my ($fine) =
3801               CalcFine( $item, $patron->categorycode, $library->{branchcode},
3802                 $ten_days_ago, $now );
3803             UpdateFine(
3804                 {
3805                     issue_id       => $issue->issue_id,
3806                     itemnumber     => $item->itemnumber,
3807                     borrowernumber => $patron->borrowernumber,
3808                     amount         => $fine,
3809                     due            => output_pref($ten_days_ago)
3810                 }
3811             );
3812             my $overdue_fees = Koha::Account::Lines->search(
3813                 {
3814                     borrowernumber  => $patron->id,
3815                     itemnumber      => $item->itemnumber,
3816                     debit_type_code => 'OVERDUE'
3817                 }
3818             );
3819             is( $overdue_fees->count, 1, 'Overdue item fee produced' );
3820             my $overdue_fee = $overdue_fees->next;
3821             is( $overdue_fee->amount + 0,
3822                 10, 'The right OVERDUE amount is generated' );
3823             is( $overdue_fee->amountoutstanding + 0,
3824                 10,
3825                 'The right OVERDUE amountoutstanding is generated' );
3826
3827             # Simulate item marked as lost
3828             $item->itemlost(3)->store;
3829             C4::Circulation::LostItem( $item->itemnumber, 1 );
3830
3831             my $lost_fee_lines = Koha::Account::Lines->search(
3832                 {
3833                     borrowernumber  => $patron->id,
3834                     itemnumber      => $item->itemnumber,
3835                     debit_type_code => 'LOST'
3836                 }
3837             );
3838             is( $lost_fee_lines->count, 1, 'Lost item fee produced' );
3839             my $lost_fee_line = $lost_fee_lines->next;
3840             is( $lost_fee_line->amount + 0,
3841                 $replacement_amount, 'The right LOST amount is generated' );
3842             is( $lost_fee_line->amountoutstanding + 0,
3843                 $replacement_amount,
3844                 'The right LOST amountoutstanding is generated' );
3845             is( $lost_fee_line->status, undef, 'The LOST status was not set' );
3846
3847             # Simulate refunding overdue fees upon marking item as lost
3848             my $overdue_forgive = $patron->account->add_credit(
3849                 {
3850                     amount     => 10.00,
3851                     user_id    => $manager->borrowernumber,
3852                     library_id => $branchcode_charge,
3853                     interface  => 'test',
3854                     type       => 'FORGIVEN',
3855                     item_id    => $item->itemnumber
3856                 }
3857             );
3858             $overdue_forgive->apply( { debits => [$overdue_fee] } );
3859             $overdue_fee->discard_changes;
3860             is($overdue_fee->amountoutstanding + 0, 0, 'Overdue fee forgiven');
3861
3862             # Do nothing
3863             my ( undef, $message ) =
3864               AddReturn( $item->barcode, $branchcode_charge, undef, $five_days_ago );
3865
3866             $lost_fee_line->discard_changes;
3867             is( $lost_fee_line->amount + 0,
3868                 $replacement_amount, 'The LOST amount is left intact' );
3869             is( $lost_fee_line->amountoutstanding + 0,
3870                 0,
3871                 'The LOST amountoutstanding is refunded' );
3872             is( $lost_fee_line->status, 'FOUND', 'The LOST status was set to FOUND' );
3873
3874             $overdue_fees = Koha::Account::Lines->search(
3875                 {
3876                     borrowernumber  => $patron->id,
3877                     itemnumber      => $item->itemnumber,
3878                     debit_type_code => 'OVERDUE'
3879                 },
3880                 {
3881                     order_by => { '-asc' => 'accountlines_id'}
3882                 }
3883             );
3884             is( $overdue_fees->count, 2, 'A second OVERDUE fee has been added' );
3885             $overdue_fee = $overdue_fees->next;
3886             is( $overdue_fee->amount + 0,
3887                 10, 'The original OVERDUE amount is left intact' );
3888             is( $overdue_fee->amountoutstanding + 0,
3889                 0,
3890                 'The original OVERDUE amountoutstanding is left as forgiven' );
3891             $overdue_fee = $overdue_fees->next;
3892             is( $overdue_fee->amount + 0,
3893                 5, 'The new OVERDUE amount is correct for the backdated return' );
3894             is( $overdue_fee->amountoutstanding + 0,
3895                 5,
3896                 'The new OVERDUE amountoutstanding is correct for the backdated return' );
3897         };
3898     };
3899 };
3900
3901 subtest '_FixOverduesOnReturn' => sub {
3902     plan tests => 14;
3903
3904     my $manager = $builder->build_object({ class => "Koha::Patrons" });
3905     t::lib::Mocks::mock_userenv({ patron => $manager, branchcode => $manager->branchcode });
3906
3907     my $biblio = $builder->build_sample_biblio({ author => 'Hall, Kylie' });
3908
3909     my $branchcode  = $library2->{branchcode};
3910
3911     my $item = $builder->build_sample_item(
3912         {
3913             biblionumber     => $biblio->biblionumber,
3914             library          => $branchcode,
3915             replacementprice => 99.00,
3916             itype            => $itemtype,
3917         }
3918     );
3919
3920     my $patron = $builder->build( { source => 'Borrower' } );
3921
3922     ## Start with basic call, should just close out the open fine
3923     my $accountline = Koha::Account::Line->new(
3924         {
3925             borrowernumber => $patron->{borrowernumber},
3926             debit_type_code    => 'OVERDUE',
3927             status         => 'UNRETURNED',
3928             itemnumber     => $item->itemnumber,
3929             amount => 99.00,
3930             amountoutstanding => 99.00,
3931             interface => 'test',
3932         }
3933     )->store();
3934
3935     C4::Circulation::_FixOverduesOnReturn( $patron->{borrowernumber}, $item->itemnumber, undef, 'RETURNED' );
3936
3937     $accountline->_result()->discard_changes();
3938
3939     is( $accountline->amountoutstanding+0, 99, 'Fine has the same amount outstanding as previously' );
3940     isnt( $accountline->status, 'UNRETURNED', 'Open fine ( account type OVERDUE ) has been closed out ( status not UNRETURNED )');
3941     is( $accountline->status, 'RETURNED', 'Passed status has been used to set as RETURNED )');
3942
3943     ## Run again, with exemptfine enabled
3944     $accountline->set(
3945         {
3946             debit_type_code    => 'OVERDUE',
3947             status         => 'UNRETURNED',
3948             amountoutstanding => 99.00,
3949         }
3950     )->store();
3951
3952     C4::Circulation::_FixOverduesOnReturn( $patron->{borrowernumber}, $item->itemnumber, 1, 'RETURNED' );
3953
3954     $accountline->_result()->discard_changes();
3955     my $offset = Koha::Account::Offsets->search({ debit_id => $accountline->id, type => 'APPLY' })->next();
3956
3957     is( $accountline->amountoutstanding + 0, 0, 'Fine amountoutstanding has been reduced to 0' );
3958     isnt( $accountline->status, 'UNRETURNED', 'Open fine ( account type OVERDUE ) has been closed out ( status not UNRETURNED )');
3959     is( $accountline->status, 'RETURNED', 'Open fine ( account type OVERDUE ) has been set to returned ( status RETURNED )');
3960     is( ref $offset, "Koha::Account::Offset", "Found matching offset for fine reduction via forgiveness" );
3961     is( $offset->amount + 0, -99, "Amount of offset is correct" );
3962     my $credit = $offset->credit;
3963     is( ref $credit, "Koha::Account::Line", "Found matching credit for fine forgiveness" );
3964     is( $credit->amount + 0, -99, "Credit amount is set correctly" );
3965     is( $credit->amountoutstanding + 0, 0, "Credit amountoutstanding is correctly set to 0" );
3966
3967     # Bug 25417 - Only forgive fines where there is an amount outstanding to forgive
3968     $accountline->set(
3969         {
3970             debit_type_code    => 'OVERDUE',
3971             status         => 'UNRETURNED',
3972             amountoutstanding => 0.00,
3973         }
3974     )->store();
3975     $offset->delete;
3976
3977     C4::Circulation::_FixOverduesOnReturn( $patron->{borrowernumber}, $item->itemnumber, 1, 'RETURNED' );
3978
3979     $accountline->_result()->discard_changes();
3980     $offset = Koha::Account::Offsets->search({ debit_id => $accountline->id, type => 'CREATE' })->next();
3981     is( $offset, undef, "No offset created when trying to forgive fine with no outstanding balance" );
3982     isnt( $accountline->status, 'UNRETURNED', 'Open fine ( account type OVERDUE ) has been closed out ( status not UNRETURNED )');
3983     is( $accountline->status, 'RETURNED', 'Passed status has been used to set as RETURNED )');
3984 };
3985
3986 subtest 'Set waiting flag' => sub {
3987     plan tests => 11;
3988
3989     my $library_1 = $builder->build( { source => 'Branch' } );
3990     my $patron_1  = $builder->build( { source => 'Borrower', value => { branchcode => $library_1->{branchcode}, categorycode => $patron_category->{categorycode} } } );
3991     my $library_2 = $builder->build( { source => 'Branch' } );
3992     my $patron_2  = $builder->build( { source => 'Borrower', value => { branchcode => $library_2->{branchcode}, categorycode => $patron_category->{categorycode} } } );
3993
3994     my $item = $builder->build_sample_item(
3995         {
3996             library      => $library_1->{branchcode},
3997         }
3998     );
3999
4000     set_userenv( $library_2 );
4001     my $reserve_id = AddReserve(
4002         {
4003             branchcode     => $library_2->{branchcode},
4004             borrowernumber => $patron_2->{borrowernumber},
4005             biblionumber   => $item->biblionumber,
4006             priority       => 1,
4007             itemnumber     => $item->itemnumber,
4008         }
4009     );
4010
4011     set_userenv( $library_1 );
4012     my $do_transfer = 1;
4013     my ( $res, $rr ) = AddReturn( $item->barcode, $library_1->{branchcode} );
4014     ModReserveAffect( $item->itemnumber, undef, $do_transfer, $reserve_id );
4015     my $hold = Koha::Holds->find( $reserve_id );
4016     is( $hold->found, 'T', 'Hold is in transit' );
4017
4018     my ( $status ) = CheckReserves($item->itemnumber);
4019     is( $status, 'Transferred', 'Hold is not waiting yet');
4020
4021     set_userenv( $library_2 );
4022     $do_transfer = 0;
4023     AddReturn( $item->barcode, $library_2->{branchcode} );
4024     ModReserveAffect( $item->itemnumber, undef, $do_transfer, $reserve_id );
4025     $hold = Koha::Holds->find( $reserve_id );
4026     is( $hold->found, 'W', 'Hold is waiting' );
4027     ( $status ) = CheckReserves($item->itemnumber);
4028     is( $status, 'Waiting', 'Now the hold is waiting');
4029
4030     #Bug 21944 - Waiting transfer checked in at branch other than pickup location
4031     set_userenv( $library_1 );
4032     (undef, my $messages, undef, undef ) = AddReturn ( $item->barcode, $library_1->{branchcode} );
4033     $hold = Koha::Holds->find( $reserve_id );
4034     is( $hold->found, undef, 'Hold is no longer marked waiting' );
4035     is( $hold->priority, 1,  "Hold is now priority one again");
4036     is( $hold->waitingdate, undef, "Hold no longer has a waiting date");
4037     is( $hold->itemnumber, $item->itemnumber, "Hold has retained its' itemnumber");
4038     is( $messages->{ResFound}->{ResFound}, "Reserved", "Hold is still returned");
4039     is( $messages->{ResFound}->{found}, undef, "Hold is no longer marked found in return message");
4040     is( $messages->{ResFound}->{priority}, 1, "Hold is priority 1 in return message");
4041 };
4042
4043 subtest 'Cancel transfers on lost items' => sub {
4044     plan tests => 6;
4045
4046     my $library_to = $builder->build_object( { class => 'Koha::Libraries' } );
4047     my $item   = $builder->build_sample_item();
4048     my $holdingbranch = $item->holdingbranch;
4049     # Historic transfer (datearrived is defined)
4050     my $old_transfer = $builder->build_object(
4051         {
4052             class => 'Koha::Item::Transfers',
4053             value => {
4054                 itemnumber    => $item->itemnumber,
4055                 frombranch    => $holdingbranch,
4056                 tobranch      => $library_to->branchcode,
4057                 reason        => 'Manual',
4058                 datesent      => \'NOW()',
4059                 datearrived   => \'NOW()',
4060                 datecancelled => undef,
4061                 daterequested => \'NOW()'
4062             }
4063         }
4064     );
4065     # Queued transfer (datesent is undefined)
4066     my $transfer_1 = $builder->build_object(
4067         {
4068             class => 'Koha::Item::Transfers',
4069             value => {
4070                 itemnumber    => $item->itemnumber,
4071                 frombranch    => $holdingbranch,
4072                 tobranch      => $library_to->branchcode,
4073                 reason        => 'Manual',
4074                 datesent      => undef,
4075                 datearrived   => undef,
4076                 datecancelled => undef,
4077                 daterequested => \'NOW()'
4078             }
4079         }
4080     );
4081     # In transit transfer (datesent is defined, datearrived and datecancelled are both undefined)
4082     my $transfer_2 = $builder->build_object(
4083         {
4084             class => 'Koha::Item::Transfers',
4085             value => {
4086                 itemnumber    => $item->itemnumber,
4087                 frombranch    => $holdingbranch,
4088                 tobranch      => $library_to->branchcode,
4089                 reason        => 'Manual',
4090                 datesent      => \'NOW()',
4091                 datearrived   => undef,
4092                 datecancelled => undef,
4093                 daterequested => \'NOW()'
4094             }
4095         }
4096     );
4097
4098     # Simulate item being marked as lost
4099     $item->itemlost(1)->store;
4100     LostItem( $item->itemnumber, 'test', 1 );
4101
4102     $transfer_1->discard_changes;
4103     isnt($transfer_1->datecancelled, undef, "Queud transfer was cancelled upon item lost");
4104     is($transfer_1->cancellation_reason, 'ItemLost', "Cancellation reason was set to 'ItemLost'");
4105     $transfer_2->discard_changes;
4106     isnt($transfer_2->datecancelled, undef, "Active transfer was cancelled upon item lost");
4107     is($transfer_2->cancellation_reason, 'ItemLost', "Cancellation reason was set to 'ItemLost'");
4108     $old_transfer->discard_changes;
4109     is($old_transfer->datecancelled, undef, "Old transfers are unaffected");
4110     $item->discard_changes;
4111     is($item->holdingbranch, $holdingbranch, "Items holding branch remains unchanged");
4112 };
4113
4114 subtest 'CanBookBeIssued | is_overdue' => sub {
4115     plan tests => 3;
4116
4117     # Set a simple circ policy
4118     Koha::CirculationRules->set_rules(
4119         {
4120             categorycode => undef,
4121             branchcode   => undef,
4122             itemtype     => undef,
4123             rules        => {
4124                 maxissueqty     => 1,
4125                 reservesallowed => 25,
4126                 issuelength     => 14,
4127                 lengthunit      => 'days',
4128                 renewalsallowed => 1,
4129                 renewalperiod   => 7,
4130                 norenewalbefore => undef,
4131                 auto_renew      => 0,
4132                 fine            => .10,
4133                 chargeperiod    => 1,
4134             }
4135         }
4136     );
4137
4138     my $now   = dt_from_string()->truncate( to => 'day' );
4139     my $five_days_go = $now->clone->add( days => 5 );
4140     my $ten_days_go  = $now->clone->add( days => 10);
4141     my $library = $builder->build( { source => 'Branch' } );
4142     my $patron  = $builder->build_object( { class => 'Koha::Patrons', value => { categorycode => $patron_category->{categorycode} } } );
4143
4144     my $item = $builder->build_sample_item(
4145         {
4146             library      => $library->{branchcode},
4147         }
4148     );
4149
4150     my $issue = AddIssue( $patron->unblessed, $item->barcode, $five_days_go ); # date due was 10d ago
4151     my $actualissue = Koha::Checkouts->find( { itemnumber => $item->itemnumber } );
4152     is( output_pref({ str => $actualissue->date_due, dateonly => 1}), output_pref({ str => $five_days_go, dateonly => 1}), "First issue works");
4153     my ($issuingimpossible, $needsconfirmation) = CanBookBeIssued($patron, $item->barcode, $ten_days_go, undef, undef, undef);
4154     is( $needsconfirmation->{RENEW_ISSUE}, 1, "This is a renewal");
4155     is( $needsconfirmation->{TOO_MANY}, undef, "Not too many, is a renewal");
4156 };
4157
4158 subtest 'ItemsDeniedRenewal rules are checked' => sub {
4159     plan tests => 4;
4160
4161     my $idr_lib = $builder->build_object({ class => 'Koha::Libraries'});
4162     Koha::CirculationRules->set_rules(
4163         {
4164             categorycode => '*',
4165             itemtype     => '*',
4166             branchcode   => $idr_lib->branchcode,
4167             rules        => {
4168                 reservesallowed => 25,
4169                 issuelength     => 14,
4170                 lengthunit      => 'days',
4171                 renewalsallowed => 10,
4172                 renewalperiod   => 7,
4173                 norenewalbefore => undef,
4174                 auto_renew      => 0,
4175                 fine            => .10,
4176                 chargeperiod    => 1,
4177             }
4178         }
4179     );
4180
4181     my $allow_book = $builder->build_object({ class => 'Koha::Items', value => {
4182         homebranch => $idr_lib->branchcode,
4183         withdrawn => 0,
4184         itype => 'NOHIDE',
4185         location => 'NOPROC'
4186         }
4187     });
4188
4189     my $idr_borrower = $builder->build_object({ class => 'Koha::Patrons', value=> {
4190         branchcode => $idr_lib->branchcode,
4191         }
4192     });
4193     my $future = dt_from_string->add( days => 1 );
4194     my $issue = $builder->build_object(
4195         {
4196             class => 'Koha::Checkouts',
4197             value => {
4198                 returndate      => undef,
4199                 renewals_count  => 0,
4200                 auto_renew      => 0,
4201                 borrowernumber  => $idr_borrower->borrowernumber,
4202                 itemnumber      => $allow_book->itemnumber,
4203                 onsite_checkout => 0,
4204                 date_due        => $future,
4205             }
4206         }
4207     );
4208
4209     my $mock_item_class = Test::MockModule->new("Koha::Item");
4210     $mock_item_class->mock( 'is_denied_renewal', sub { return 1; } );
4211
4212     my ( $mayrenew, $error ) = CanBookBeRenewed( $idr_borrower->borrowernumber, $issue->itemnumber );
4213     is( $mayrenew, 0, 'Renewal blocked when $item->is_denied_renewal returns true' );
4214     is( $error, 'item_denied_renewal', 'Renewal blocked when $item->is_denied_renewal returns true' );
4215
4216     $mock_item_class->unmock( 'is_denied_renewal' );
4217     $mock_item_class->mock( 'is_denied_renewal', sub { return 0; } );
4218
4219     ( $mayrenew, $error ) = CanBookBeRenewed( $idr_borrower->borrowernumber, $issue->itemnumber );
4220     is( $mayrenew, 1, 'Renewal allowed when $item->is_denied_renewal returns false' );
4221     is( $error, undef, 'Renewal allowed when $item->is_denied_renewal returns false' );
4222
4223     $mock_item_class->unmock( 'is_denied_renewal' );
4224 };
4225
4226 subtest 'CanBookBeIssued | item-level_itypes=biblio' => sub {
4227     plan tests => 2;
4228
4229     t::lib::Mocks::mock_preference('item-level_itypes', 0); # biblio
4230     my $library = $builder->build( { source => 'Branch' } );
4231     my $patron  = $builder->build_object( { class => 'Koha::Patrons', value => { categorycode => $patron_category->{categorycode} } } )->store;
4232
4233     my $item = $builder->build_sample_item(
4234         {
4235             library      => $library->{branchcode},
4236         }
4237     );
4238
4239     my ( $issuingimpossible, $needsconfirmation ) = CanBookBeIssued( $patron, $item->barcode, undef, undef, undef, undef );
4240     is_deeply( $needsconfirmation, {}, 'Item can be issued to this patron' );
4241     is_deeply( $issuingimpossible, {}, 'Item can be issued to this patron' );
4242 };
4243
4244 subtest 'CanBookBeIssued | notforloan' => sub {
4245     plan tests => 2;
4246
4247     t::lib::Mocks::mock_preference('AllowNotForLoanOverride', 0);
4248
4249     my $library = $builder->build( { source => 'Branch' } );
4250     my $patron  = $builder->build_object( { class => 'Koha::Patrons', value => { categorycode => $patron_category->{categorycode} } } )->store;
4251
4252     my $itemtype = $builder->build(
4253         {
4254             source => 'Itemtype',
4255             value  => { notforloan => undef, }
4256         }
4257     );
4258     my $item = $builder->build_sample_item(
4259         {
4260             library  => $library->{branchcode},
4261             itype    => $itemtype->{itemtype},
4262         }
4263     );
4264     $item->biblioitem->itemtype($itemtype->{itemtype})->store;
4265
4266     my ( $issuingimpossible, $needsconfirmation );
4267
4268
4269     subtest 'item-level_itypes = 1' => sub {
4270         plan tests => 6;
4271
4272         t::lib::Mocks::mock_preference('item-level_itypes', 1); # item
4273         # Is for loan at item type and item level
4274         ( $issuingimpossible, $needsconfirmation ) = CanBookBeIssued( $patron, $item->barcode, undef, undef, undef, undef );
4275         is_deeply( $needsconfirmation, {}, 'Item can be issued to this patron' );
4276         is_deeply( $issuingimpossible, {}, 'Item can be issued to this patron' );
4277
4278         # not for loan at item type level
4279         Koha::ItemTypes->find( $itemtype->{itemtype} )->notforloan(1)->store;
4280         ( $issuingimpossible, $needsconfirmation ) = CanBookBeIssued( $patron, $item->barcode, undef, undef, undef, undef );
4281         is_deeply( $needsconfirmation, {}, 'No confirmation needed, AllowNotForLoanOverride=0' );
4282         is_deeply(
4283             $issuingimpossible,
4284             { NOT_FOR_LOAN => 1, itemtype_notforloan => $itemtype->{itemtype} },
4285             'Item can not be issued, not for loan at item type level'
4286         );
4287
4288         # not for loan at item level
4289         Koha::ItemTypes->find( $itemtype->{itemtype} )->notforloan(undef)->store;
4290         $item->notforloan( 1 )->store;
4291         ( $issuingimpossible, $needsconfirmation ) = CanBookBeIssued( $patron, $item->barcode, undef, undef, undef, undef );
4292         is_deeply( $needsconfirmation, {}, 'No confirmation needed, AllowNotForLoanOverride=0' );
4293         is_deeply(
4294             $issuingimpossible,
4295             { NOT_FOR_LOAN => 1, item_notforloan => 1 },
4296             'Item can not be issued, not for loan at item type level'
4297         );
4298     };
4299
4300     subtest 'item-level_itypes = 0' => sub {
4301         plan tests => 6;
4302
4303         t::lib::Mocks::mock_preference('item-level_itypes', 0); # biblio
4304
4305         # We set another itemtype for biblioitem
4306         my $itemtype = $builder->build(
4307             {
4308                 source => 'Itemtype',
4309                 value  => { notforloan => undef, }
4310             }
4311         );
4312
4313         # for loan at item type and item level
4314         $item->notforloan(0)->store;
4315         $item->biblioitem->itemtype($itemtype->{itemtype})->store;
4316         ( $issuingimpossible, $needsconfirmation ) = CanBookBeIssued( $patron, $item->barcode, undef, undef, undef, undef );
4317         is_deeply( $needsconfirmation, {}, 'Item can be issued to this patron' );
4318         is_deeply( $issuingimpossible, {}, 'Item can be issued to this patron' );
4319
4320         # not for loan at item type level
4321         Koha::ItemTypes->find( $itemtype->{itemtype} )->notforloan(1)->store;
4322         ( $issuingimpossible, $needsconfirmation ) = CanBookBeIssued( $patron, $item->barcode, undef, undef, undef, undef );
4323         is_deeply( $needsconfirmation, {}, 'No confirmation needed, AllowNotForLoanOverride=0' );
4324         is_deeply(
4325             $issuingimpossible,
4326             { NOT_FOR_LOAN => 1, itemtype_notforloan => $itemtype->{itemtype} },
4327             'Item can not be issued, not for loan at item type level'
4328         );
4329
4330         # not for loan at item level
4331         Koha::ItemTypes->find( $itemtype->{itemtype} )->notforloan(undef)->store;
4332         $item->notforloan( 1 )->store;
4333         ( $issuingimpossible, $needsconfirmation ) = CanBookBeIssued( $patron, $item->barcode, undef, undef, undef, undef );
4334         is_deeply( $needsconfirmation, {}, 'No confirmation needed, AllowNotForLoanOverride=0' );
4335         is_deeply(
4336             $issuingimpossible,
4337             { NOT_FOR_LOAN => 1, item_notforloan => 1 },
4338             'Item can not be issued, not for loan at item type level'
4339         );
4340     };
4341
4342     # TODO test with AllowNotForLoanOverride = 1
4343 };
4344
4345 subtest 'CanBookBeIssued | recalls' => sub {
4346     plan tests => 3;
4347
4348     t::lib::Mocks::mock_preference("UseRecalls", 1);
4349     t::lib::Mocks::mock_preference("item-level_itypes", 1);
4350     my $patron1 = $builder->build_object({ class => 'Koha::Patrons' });
4351     my $patron2 = $builder->build_object({ class => 'Koha::Patrons' });
4352     my $item = $builder->build_sample_item;
4353     Koha::CirculationRules->set_rules({
4354         branchcode => undef,
4355         itemtype => undef,
4356         categorycode => undef,
4357         rules => {
4358             recalls_allowed => 10,
4359         },
4360     });
4361
4362     # item-level recall
4363     my $recall = Koha::Recall->new(
4364         {   patron_id         => $patron1->borrowernumber,
4365             biblio_id         => $item->biblionumber,
4366             item_id           => $item->itemnumber,
4367             item_level        => 1,
4368             pickup_library_id => $patron1->branchcode,
4369         }
4370     )->store;
4371
4372     my ( $issuingimpossible, $needsconfirmation ) = CanBookBeIssued( $patron2, $item->barcode, undef, undef, undef, undef );
4373     is( $needsconfirmation->{RECALLED}->id, $recall->id, "Another patron has placed an item-level recall on this item" );
4374
4375     $recall->set_cancelled;
4376
4377     # biblio-level recall
4378     $recall = Koha::Recall->new(
4379         {   patron_id         => $patron1->borrowernumber,
4380             biblio_id         => $item->biblionumber,
4381             item_id           => undef,
4382             item_level        => 0,
4383             pickup_library_id => $patron1->branchcode,
4384         }
4385     )->store;
4386
4387     ( $issuingimpossible, $needsconfirmation ) = CanBookBeIssued( $patron2, $item->barcode, undef, undef, undef, undef );
4388     is( $needsconfirmation->{RECALLED}->id, $recall->id, "Another patron has placed a biblio-level recall and this item is eligible to fill it" );
4389
4390     $recall->set_cancelled;
4391
4392     # biblio-level recall
4393     $recall = Koha::Recall->new(
4394         {   patron_id         => $patron1->borrowernumber,
4395             biblio_id         => $item->biblionumber,
4396             item_id           => undef,
4397             item_level        => 0,
4398             pickup_library_id => $patron1->branchcode,
4399         }
4400     )->store;
4401     $recall->set_waiting( { item => $item, expirationdate => dt_from_string() } );
4402
4403     my ( undef, undef, undef, $messages ) = CanBookBeIssued( $patron1, $item->barcode, undef, undef, undef, undef );
4404     is( $messages->{RECALLED}, $recall->id, "This book can be issued by this patron and they have placed a recall" );
4405
4406     $recall->set_cancelled;
4407 };
4408
4409 subtest 'AddReturn should clear items.onloan for unissued items' => sub {
4410     plan tests => 1;
4411
4412     t::lib::Mocks::mock_preference( "AllowReturnToBranch", 'anywhere' );
4413     my $item = $builder->build_sample_item(
4414         {
4415             onloan => '2018-01-01',
4416         }
4417     );
4418
4419     AddReturn( $item->barcode, $item->homebranch );
4420     $item->discard_changes; # refresh
4421     is( $item->onloan, undef, 'AddReturn did clear items.onloan' );
4422 };
4423
4424 subtest 'AddReturn | recalls' => sub {
4425     plan tests => 3;
4426
4427     t::lib::Mocks::mock_preference("UseRecalls", 1);
4428     t::lib::Mocks::mock_preference("item-level_itypes", 1);
4429     my $patron1 = $builder->build_object({ class => 'Koha::Patrons' });
4430     my $patron2 = $builder->build_object({ class => 'Koha::Patrons' });
4431     my $item1 = $builder->build_sample_item;
4432     Koha::CirculationRules->set_rules({
4433         branchcode => undef,
4434         itemtype => undef,
4435         categorycode => undef,
4436         rules => {
4437             recalls_allowed => 10,
4438         },
4439     });
4440
4441     # this item can fill a recall with pickup at this branch
4442     AddIssue( $patron1->unblessed, $item1->barcode );
4443     my $recall1 = Koha::Recall->new(
4444         {   patron_id         => $patron2->borrowernumber,
4445             biblio_id         => $item1->biblionumber,
4446             item_id           => $item1->itemnumber,
4447             item_level        => 1,
4448             pickup_library_id => $item1->homebranch,
4449         }
4450     )->store;
4451     my ( $doreturn, $messages, $iteminfo, $borrowerinfo ) = AddReturn( $item1->barcode, $item1->homebranch );
4452     is( $messages->{RecallFound}->id, $recall1->id, "Recall found" );
4453     $recall1->set_cancelled;
4454
4455     # this item can fill a recall but needs transfer
4456     AddIssue( $patron1->unblessed, $item1->barcode );
4457     $recall1 = Koha::Recall->new(
4458         {   patron_id         => $patron2->borrowernumber,
4459             biblio_id         => $item1->biblionumber,
4460             item_id           => $item1->itemnumber,
4461             item_level        => 1,
4462             pickup_library_id => $patron2->branchcode,
4463         }
4464     )->store;
4465     ( $doreturn, $messages, $iteminfo, $borrowerinfo ) = AddReturn( $item1->barcode, $item1->homebranch );
4466     is( $messages->{RecallNeedsTransfer}, $item1->homebranch, "Recall requiring transfer found" );
4467     $recall1->set_cancelled;
4468
4469     # this item is already in transit, do not ask to transfer
4470     AddIssue( $patron1->unblessed, $item1->barcode );
4471     $recall1 = Koha::Recall->new(
4472         {   patron_id         => $patron2->borrowernumber,
4473             biblio_id         => $item1->biblionumber,
4474             item_id           => $item1->itemnumber,
4475             item_level        => 1,
4476             pickup_library_id => $patron2->branchcode,
4477         }
4478     )->store;
4479     $recall1->start_transfer;
4480     ( $doreturn, $messages, $iteminfo, $borrowerinfo ) = AddReturn( $item1->barcode, $patron2->branchcode );
4481     is( $messages->{TransferredRecall}->id, $recall1->id, "In transit recall found" );
4482     $recall1->set_cancelled;
4483 };
4484
4485 subtest 'AddReturn | bundles' => sub {
4486     plan tests => 1;
4487
4488     my $schema = Koha::Database->schema;
4489     $schema->storage->txn_begin;
4490
4491     my $patron1 = $builder->build_object({ class => 'Koha::Patrons' });
4492     my $host_item1 = $builder->build_sample_item;
4493     my $bundle_item1 = $builder->build_sample_item;
4494     $schema->resultset('ItemBundle')
4495       ->create(
4496         { host => $host_item1->itemnumber, item => $bundle_item1->itemnumber } );
4497
4498     my ( $doreturn, $messages, $iteminfo, $borrowerinfo ) = AddReturn( $bundle_item1->barcode, $bundle_item1->homebranch );
4499     is($messages->{InBundle}->id, $host_item1->id, 'AddReturn returns InBundle host item when item is part of a bundle');
4500
4501     $schema->storage->txn_rollback;
4502 };
4503
4504 subtest 'AddRenewal and AddIssuingCharge tests' => sub {
4505
4506     plan tests => 13;
4507
4508
4509     t::lib::Mocks::mock_preference('item-level_itypes', 1);
4510
4511     my $issuing_charges = 15;
4512     my $title   = 'A title';
4513     my $author  = 'Author, An';
4514     my $barcode = 'WHATARETHEODDS';
4515
4516     my $circ = Test::MockModule->new('C4::Circulation');
4517     $circ->mock(
4518         'GetIssuingCharges',
4519         sub {
4520             return $issuing_charges;
4521         }
4522     );
4523
4524     my $library  = $builder->build_object({ class => 'Koha::Libraries' });
4525     my $itemtype = $builder->build_object({ class => 'Koha::ItemTypes', value => { rentalcharge_daily => 0.00 }});
4526     my $patron   = $builder->build_object({
4527         class => 'Koha::Patrons',
4528         value => { branchcode => $library->id }
4529     });
4530
4531     my $biblio = $builder->build_sample_biblio({ title=> $title, author => $author });
4532     my $item_id = Koha::Item->new(
4533         {
4534             biblionumber     => $biblio->biblionumber,
4535             homebranch       => $library->id,
4536             holdingbranch    => $library->id,
4537             barcode          => $barcode,
4538             replacementprice => 23.00,
4539             itype            => $itemtype->id
4540         },
4541     )->store->itemnumber;
4542     my $item = Koha::Items->find( $item_id );
4543
4544     my $context = Test::MockModule->new('C4::Context');
4545     $context->mock( userenv => { branch => $library->id } );
4546
4547     # Check the item out
4548     AddIssue( $patron->unblessed, $item->barcode );
4549
4550     throws_ok {
4551         AddRenewal( $patron->borrowernumber, $item->itemnumber, $library->id, undef, {break=>"the_renewal"} );
4552     } 'Koha::Exceptions::Checkout::FailedRenewal', 'Exception is thrown when renewal update to issues fails';
4553
4554     t::lib::Mocks::mock_preference( 'RenewalLog', 0 );
4555     my $date = output_pref( { dt => dt_from_string(), dateonly => 1, dateformat => 'iso' } );
4556     my %params_renewal = (
4557         timestamp => { -like => $date . "%" },
4558         module => "CIRCULATION",
4559         action => "RENEWAL",
4560     );
4561     my $old_log_size = Koha::ActionLogs->count( \%params_renewal );;
4562     AddRenewal( $patron->id, $item->id, $library->id );
4563     my $new_log_size = Koha::ActionLogs->count( \%params_renewal );
4564     is( $new_log_size, $old_log_size, 'renew log not added because of the syspref RenewalLog' );
4565
4566     my $checkouts = $patron->checkouts;
4567     # The following will fail if run on 00:00:00
4568     unlike ( $checkouts->next->lastreneweddate, qr/00:00:00/, 'AddRenewal should set the renewal date with the time part');
4569
4570     my $lines = Koha::Account::Lines->search({
4571         borrowernumber => $patron->id,
4572         itemnumber     => $item->id
4573     });
4574
4575     is( $lines->count, 2 );
4576
4577     my $line = $lines->next;
4578     is( $line->debit_type_code, 'RENT',       'The issue of item with issuing charge generates an accountline of the correct type' );
4579     is( $line->branchcode,  $library->id, 'AddIssuingCharge correctly sets branchcode' );
4580     is( $line->description, '',     'AddIssue does not set a hardcoded description for the accountline' );
4581
4582     $line = $lines->next;
4583     is( $line->debit_type_code, 'RENT_RENEW', 'The renewal of item with issuing charge generates an accountline of the correct type' );
4584     is( $line->branchcode,  $library->id, 'AddRenewal correctly sets branchcode' );
4585     is( $line->description, '', 'AddRenewal does not set a hardcoded description for the accountline' );
4586
4587     t::lib::Mocks::mock_preference( 'RenewalLog', 1 );
4588
4589     $context = Test::MockModule->new('C4::Context');
4590     $context->mock( userenv => { branch => undef, interface => 'CRON'} ); #Test statistical logging of renewal via cron (atuo_renew)
4591
4592     my $now = dt_from_string;
4593     $date = output_pref( { dt => $now, dateonly => 1, dateformat => 'iso' } );
4594     $old_log_size = Koha::ActionLogs->count( \%params_renewal );
4595     my $sth = $dbh->prepare("SELECT COUNT(*) FROM statistics WHERE itemnumber = ? AND branch = ?");
4596     $sth->execute($item->id, $library->id);
4597     my ($old_stats_size) = $sth->fetchrow_array;
4598     AddRenewal( $patron->id, $item->id, $library->id );
4599     $new_log_size = Koha::ActionLogs->count( \%params_renewal );
4600     $sth->execute($item->id, $library->id);
4601     my ($new_stats_size) = $sth->fetchrow_array;
4602     is( $new_log_size, $old_log_size + 1, 'renew log successfully added' );
4603     is( $new_stats_size, $old_stats_size + 1, 'renew statistic successfully added with passed branch' );
4604
4605     AddReturn( $item->id, $library->id, undef, $date );
4606     AddIssue( $patron->unblessed, $item->barcode, $now );
4607     AddRenewal( $patron->id, $item->id, $library->id, undef, undef, 1 );
4608     my $lines_skipped = Koha::Account::Lines->search({
4609         borrowernumber => $patron->id,
4610         itemnumber     => $item->id
4611     });
4612     is( $lines_skipped->count, 5, 'Passing skipfinecalc causes fine calculation on renewal to be skipped' );
4613
4614 };
4615
4616 subtest 'AddRenewal() adds to renewals' => sub {
4617     plan tests => 5;
4618
4619     my $library  = $builder->build_object({ class => 'Koha::Libraries' });
4620     my $patron   = $builder->build_object({
4621         class => 'Koha::Patrons',
4622         value => { branchcode => $library->id }
4623     });
4624
4625     my $item = $builder->build_sample_item();
4626
4627     set_userenv( $library->unblessed );
4628
4629     # Check the item out
4630     my $issue = AddIssue( $patron->unblessed, $item->barcode );
4631     is(ref($issue), 'Koha::Checkout', 'Issue added');
4632
4633     # Renew item
4634     my $duedate = AddRenewal( $patron->id, $item->id, $library->id, undef, undef, undef, undef, 1 );
4635
4636     ok( $duedate, "Renewal added" );
4637
4638     my $renewals = Koha::Checkouts::Renewals->search({ checkout_id => $issue->issue_id });
4639     is($renewals->count, 1, 'One renewal added');
4640     my $THE_renewal = $renewals->next;
4641     is( $THE_renewal->renewer_id, C4::Context->userenv->{'number'}, 'Renewer recorded from context' );
4642     is( $THE_renewal->renewal_type, 'Automatic', 'AddRenewal "automatic" parameter sets renewal type to "Automatic"');
4643 };
4644
4645 subtest 'ProcessOfflinePayment() tests' => sub {
4646
4647     plan tests => 4;
4648
4649
4650     my $amount = 123;
4651
4652     my $patron  = $builder->build_object({ class => 'Koha::Patrons' });
4653     my $library = $builder->build_object({ class => 'Koha::Libraries' });
4654     my $result  = C4::Circulation::ProcessOfflinePayment({ cardnumber => $patron->cardnumber, amount => $amount, branchcode => $library->id });
4655
4656     is( $result, 'Success.', 'The right string is returned' );
4657
4658     my $lines = $patron->account->lines;
4659     is( $lines->count, 1, 'line created correctly');
4660
4661     my $line = $lines->next;
4662     is( $line->amount+0, $amount * -1, 'amount picked from params' );
4663     is( $line->branchcode, $library->id, 'branchcode set correctly' );
4664
4665 };
4666
4667 subtest 'Incremented fee tests' => sub {
4668     plan tests => 19;
4669
4670     my $dt = dt_from_string();
4671     Time::Fake->offset( $dt->epoch );
4672
4673     t::lib::Mocks::mock_preference( 'item-level_itypes', 1 );
4674
4675     my $library = $builder->build_object( { class => 'Koha::Libraries' } )->store;
4676
4677     $module->mock( 'userenv', sub { { branch => $library->id } } );
4678
4679     my $patron = $builder->build_object(
4680         {
4681             class => 'Koha::Patrons',
4682             value => { categorycode => $patron_category->{categorycode} }
4683         }
4684     )->store;
4685
4686     my $itemtype = $builder->build_object(
4687         {
4688             class => 'Koha::ItemTypes',
4689             value => {
4690                 notforloan                   => undef,
4691                 rentalcharge                 => 0,
4692                 rentalcharge_daily           => 1,
4693                 rentalcharge_daily_calendar  => 0
4694             }
4695         }
4696     )->store;
4697
4698     my $item = $builder->build_sample_item(
4699         {
4700             library  => $library->id,
4701             itype    => $itemtype->id,
4702         }
4703     );
4704
4705     is( $itemtype->rentalcharge_daily + 0,1, 'Daily rental charge stored and retreived correctly' );
4706     is( $item->effective_itemtype, $itemtype->id, "Itemtype set correctly for item" );
4707
4708     my $now         = dt_from_string;
4709     my $dt_from     = $now->clone;
4710     my $dt_to       = $now->clone->add( days => 7 );
4711     my $dt_to_renew = $now->clone->add( days => 13 );
4712
4713     # Daily Tests
4714     my $issue =
4715       AddIssue( $patron->unblessed, $item->barcode, $dt_to, undef, $dt_from );
4716     my $accountline = Koha::Account::Lines->find( { itemnumber => $item->id } );
4717     is(
4718         $accountline->amount + 0,
4719         7,
4720         "Daily rental charge calculated correctly with rentalcharge_daily_calendar = 0"
4721     );
4722     $accountline->delete();
4723     AddRenewal( $patron->id, $item->id, $library->id, $dt_to_renew, $dt_to );
4724     $accountline = Koha::Account::Lines->find( { itemnumber => $item->id } );
4725     is(
4726         $accountline->amount + 0,
4727         6,
4728         "Daily rental charge calculated correctly with rentalcharge_daily_calendar = 0, for renewal"
4729     );
4730     $accountline->delete();
4731     $issue->delete();
4732
4733     t::lib::Mocks::mock_preference( 'finesCalendar', 'noFinesWhenClosed' );
4734     $itemtype->rentalcharge_daily_calendar(1)->store();
4735     $issue =
4736       AddIssue( $patron->unblessed, $item->barcode, $dt_to, undef, $dt_from );
4737     $accountline = Koha::Account::Lines->find( { itemnumber => $item->id } );
4738     is(
4739         $accountline->amount + 0,
4740         7,
4741         "Daily rental charge calculated correctly with rentalcharge_daily_calendar = 1"
4742     );
4743     $accountline->delete();
4744     AddRenewal( $patron->id, $item->id, $library->id, $dt_to_renew, $dt_to );
4745     $accountline = Koha::Account::Lines->find( { itemnumber => $item->id } );
4746     is(
4747         $accountline->amount + 0,
4748         6,
4749         "Daily rental charge calculated correctly with rentalcharge_daily_calendar = 1, for renewal"
4750     );
4751     $accountline->delete();
4752     $issue->delete();
4753
4754     my $calendar = C4::Calendar->new( branchcode => $library->id );
4755     # DateTime 1..7 (Mon..Sun), C4::Calender 0..6 (Sun..Sat)
4756     my $closed_day =
4757         ( $dt_from->day_of_week == 6 ) ? 0
4758       : ( $dt_from->day_of_week == 7 ) ? 1
4759       :                                  $dt_from->day_of_week + 1;
4760     my $closed_day_name = $dt_from->clone->add(days => 1)->day_name;
4761     $calendar->insert_week_day_holiday(
4762         weekday     => $closed_day,
4763         title       => 'Test holiday',
4764         description => 'Test holiday'
4765     );
4766     $issue =
4767       AddIssue( $patron->unblessed, $item->barcode, $dt_to, undef, $dt_from );
4768     $accountline = Koha::Account::Lines->find( { itemnumber => $item->id } );
4769     is(
4770         $accountline->amount + 0,
4771         6,
4772         "Daily rental charge calculated correctly with rentalcharge_daily_calendar = 1 and closed $closed_day_name"
4773     );
4774     $accountline->delete();
4775     AddRenewal( $patron->id, $item->id, $library->id, $dt_to_renew, $dt_to );
4776     $accountline = Koha::Account::Lines->find( { itemnumber => $item->id } );
4777     is(
4778         $accountline->amount + 0,
4779         5,
4780         "Daily rental charge calculated correctly with rentalcharge_daily_calendar = 1 and closed $closed_day_name, for renewal"
4781     );
4782     $accountline->delete();
4783     $issue->delete();
4784
4785     $itemtype->rentalcharge(2)->store;
4786     is( $itemtype->rentalcharge + 0, 2, 'Rental charge updated and retreived correctly' );
4787     $issue =
4788       AddIssue( $patron->unblessed, $item->barcode, $dt_to, undef, $dt_from );
4789     my $accountlines =
4790       Koha::Account::Lines->search( { itemnumber => $item->id } );
4791     is( $accountlines->count, '2', "Fixed charge and accrued charge recorded distinctly" );
4792     $accountlines->delete();
4793     AddRenewal( $patron->id, $item->id, $library->id, $dt_to_renew, $dt_to );
4794     $accountlines = Koha::Account::Lines->search( { itemnumber => $item->id } );
4795     is( $accountlines->count, '2', "Fixed charge and accrued charge recorded distinctly, for renewal" );
4796     $accountlines->delete();
4797     $issue->delete();
4798     $itemtype->rentalcharge(0)->store;
4799     is( $itemtype->rentalcharge + 0, 0, 'Rental charge reset and retreived correctly' );
4800
4801     # Hourly
4802     Koha::CirculationRules->set_rule(
4803         {
4804             categorycode => $patron->categorycode,
4805             itemtype     => $itemtype->id,
4806             branchcode   => $library->id,
4807             rule_name    => 'lengthunit',
4808             rule_value   => 'hours',
4809         }
4810     );
4811
4812     $itemtype->rentalcharge_hourly('0.25')->store();
4813     is( $itemtype->rentalcharge_hourly, '0.25', 'Hourly rental charge stored and retreived correctly' );
4814
4815     $dt_to       = $now->clone->add( hours => 168 );
4816     $dt_to_renew = $now->clone->add( hours => 312 );
4817
4818     $itemtype->rentalcharge_hourly_calendar(0)->store();
4819     $issue =
4820       AddIssue( $patron->unblessed, $item->barcode, $dt_to, undef, $dt_from );
4821     $accountline = Koha::Account::Lines->find( { itemnumber => $item->id } );
4822     is(
4823         $accountline->amount + 0,
4824         42,
4825         "Hourly rental charge calculated correctly with rentalcharge_hourly_calendar = 0 (168h * 0.25u)"
4826     );
4827     $accountline->delete();
4828     AddRenewal( $patron->id, $item->id, $library->id, $dt_to_renew, $dt_to );
4829     $accountline = Koha::Account::Lines->find( { itemnumber => $item->id } );
4830     is(
4831         $accountline->amount + 0,
4832         36,
4833         "Hourly rental charge calculated correctly with rentalcharge_hourly_calendar = 0, for renewal (312h - 168h * 0.25u)"
4834     );
4835     $accountline->delete();
4836     $issue->delete();
4837
4838     $itemtype->rentalcharge_hourly_calendar(1)->store();
4839     $issue =
4840       AddIssue( $patron->unblessed, $item->barcode, $dt_to, undef, $dt_from );
4841     $accountline = Koha::Account::Lines->find( { itemnumber => $item->id } );
4842     is(
4843         $accountline->amount + 0,
4844         36,
4845         "Hourly rental charge calculated correctly with rentalcharge_hourly_calendar = 1 and closed $closed_day_name (168h - 24h * 0.25u)"
4846     );
4847     $accountline->delete();
4848     AddRenewal( $patron->id, $item->id, $library->id, $dt_to_renew, $dt_to );
4849     $accountline = Koha::Account::Lines->find( { itemnumber => $item->id } );
4850     is(
4851         $accountline->amount + 0,
4852         30,
4853         "Hourly rental charge calculated correctly with rentalcharge_hourly_calendar = 1 and closed $closed_day_name, for renewal (312h - 168h - 24h * 0.25u"
4854     );
4855     $accountline->delete();
4856     $issue->delete();
4857
4858     $calendar->delete_holiday( weekday => $closed_day );
4859     $issue =
4860       AddIssue( $patron->unblessed, $item->barcode, $dt_to, undef, $dt_from );
4861     $accountline = Koha::Account::Lines->find( { itemnumber => $item->id } );
4862     is(
4863         $accountline->amount + 0,
4864         42,
4865         "Hourly rental charge calculated correctly with rentalcharge_hourly_calendar = 1 (168h - 0h * 0.25u"
4866     );
4867     $accountline->delete();
4868     AddRenewal( $patron->id, $item->id, $library->id, $dt_to_renew, $dt_to );
4869     $accountline = Koha::Account::Lines->find( { itemnumber => $item->id } );
4870     is(
4871         $accountline->amount + 0,
4872         36,
4873         "Hourly rental charge calculated correctly with rentalcharge_hourly_calendar = 1, for renewal (312h - 168h - 0h * 0.25u)"
4874     );
4875     $accountline->delete();
4876     $issue->delete();
4877     Time::Fake->reset;
4878 };
4879
4880 subtest 'CanBookBeIssued & RentalFeesCheckoutConfirmation' => sub {
4881     plan tests => 2;
4882
4883     t::lib::Mocks::mock_preference('RentalFeesCheckoutConfirmation', 1);
4884     t::lib::Mocks::mock_preference('item-level_itypes', 1);
4885
4886     my $library =
4887       $builder->build_object( { class => 'Koha::Libraries' } )->store;
4888     my $patron = $builder->build_object(
4889         {
4890             class => 'Koha::Patrons',
4891             value => { categorycode => $patron_category->{categorycode} }
4892         }
4893     )->store;
4894
4895     my $itemtype = $builder->build_object(
4896         {
4897             class => 'Koha::ItemTypes',
4898             value => {
4899                 notforloan             => 0,
4900                 rentalcharge           => 0,
4901                 rentalcharge_daily => 0
4902             }
4903         }
4904     );
4905
4906     my $item = $builder->build_sample_item(
4907         {
4908             library    => $library->id,
4909             notforloan => 0,
4910             itemlost   => 0,
4911             withdrawn  => 0,
4912             itype      => $itemtype->id,
4913         }
4914     )->store;
4915
4916     my ( $issuingimpossible, $needsconfirmation );
4917     my $dt_from = dt_from_string();
4918     my $dt_due = $dt_from->clone->add( days => 3 );
4919
4920     $itemtype->rentalcharge(1)->store;
4921     ( $issuingimpossible, $needsconfirmation ) = CanBookBeIssued( $patron, $item->barcode, $dt_due, undef, undef, undef );
4922     is_deeply( $needsconfirmation, { RENTALCHARGE => '1.00' }, 'Item needs rentalcharge confirmation to be issued' );
4923     $itemtype->rentalcharge('0')->store;
4924     $itemtype->rentalcharge_daily(1)->store;
4925     ( $issuingimpossible, $needsconfirmation ) = CanBookBeIssued( $patron, $item->barcode, $dt_due, undef, undef, undef );
4926     is_deeply( $needsconfirmation, { RENTALCHARGE => '3' }, 'Item needs rentalcharge confirmation to be issued, increment' );
4927     $itemtype->rentalcharge_daily('0')->store;
4928 };
4929
4930 subtest 'CanBookBeIssued & CircConfirmItemParts' => sub {
4931     plan tests => 1;
4932
4933     t::lib::Mocks::mock_preference('CircConfirmItemParts', 1);
4934
4935     my $patron = $builder->build_object(
4936         {
4937             class => 'Koha::Patrons',
4938             value => { categorycode => $patron_category->{categorycode} }
4939         }
4940     )->store;
4941
4942     my $item = $builder->build_sample_item(
4943         {
4944             materials => 'includes DVD',
4945         }
4946     )->store;
4947
4948     my $dt_due = dt_from_string->add( days => 3 );
4949
4950     my ( $issuingimpossible, $needsconfirmation ) = CanBookBeIssued( $patron, $item->barcode, $dt_due, undef, undef, undef );
4951     is_deeply( $needsconfirmation, { ADDITIONAL_MATERIALS => 'includes DVD' }, 'Item needs confirmation of additional parts' );
4952 };
4953
4954 subtest 'Do not return on renewal (LOST charge)' => sub {
4955     plan tests => 1;
4956
4957     t::lib::Mocks::mock_preference('MarkLostItemsAsReturned', 'onpayment');
4958     my $library = $builder->build_object( { class => "Koha::Libraries" } );
4959     my $manager = $builder->build_object( { class => "Koha::Patrons" } );
4960     t::lib::Mocks::mock_userenv({ patron => $manager,branchcode => $manager->branchcode });
4961
4962     my $biblio = $builder->build_sample_biblio;
4963
4964     my $item = $builder->build_sample_item(
4965         {
4966             biblionumber     => $biblio->biblionumber,
4967             library          => $library->branchcode,
4968             replacementprice => 99.00,
4969             itype            => $itemtype,
4970         }
4971     );
4972
4973     my $patron = $builder->build_object( { class => 'Koha::Patrons' } );
4974     AddIssue( $patron->unblessed, $item->barcode );
4975
4976     my $accountline = Koha::Account::Line->new(
4977         {
4978             borrowernumber    => $patron->borrowernumber,
4979             debit_type_code   => 'LOST',
4980             status            => undef,
4981             itemnumber        => $item->itemnumber,
4982             amount            => 12,
4983             amountoutstanding => 12,
4984             interface         => 'something',
4985         }
4986     )->store();
4987
4988     # AddRenewal doesn't call _FixAccountForLostAndFound
4989     AddIssue( $patron->unblessed, $item->barcode );
4990
4991     is( $patron->checkouts->count, 1,
4992         'Renewal should not return the item even if a LOST payment has been made earlier'
4993     );
4994 };
4995
4996 subtest 'Filling a hold should cancel existing transfer' => sub {
4997     plan tests => 4;
4998
4999     t::lib::Mocks::mock_preference('AutomaticItemReturn', 1);
5000
5001     my $libraryA = $builder->build_object( { class => 'Koha::Libraries' } );
5002     my $libraryB = $builder->build_object( { class => 'Koha::Libraries' } );
5003     my $patron = $builder->build_object(
5004         {
5005             class => 'Koha::Patrons',
5006             value => {
5007                 categorycode => $patron_category->{categorycode},
5008                 branchcode => $libraryA->branchcode,
5009             }
5010         }
5011     )->store;
5012
5013     my $item = $builder->build_sample_item({
5014         homebranch => $libraryB->branchcode,
5015     });
5016
5017     my ( undef, $message ) = AddReturn( $item->barcode, $libraryA->branchcode, undef, undef );
5018     is( Koha::Item::Transfers->search({ itemnumber => $item->itemnumber, datearrived => undef })->count, 1, "We generate a transfer on checkin");
5019     AddReserve({
5020         branchcode     => $libraryA->branchcode,
5021         borrowernumber => $patron->borrowernumber,
5022         biblionumber   => $item->biblionumber,
5023         itemnumber     => $item->itemnumber
5024     });
5025     my $reserves = Koha::Holds->search({ itemnumber => $item->itemnumber });
5026     is( $reserves->count, 1, "Reserve is placed");
5027     ( undef, $message ) = AddReturn( $item->barcode, $libraryA->branchcode, undef, undef );
5028     my $reserve = $reserves->next;
5029     ModReserveAffect( $item->itemnumber, $patron->borrowernumber, 0, $reserve->reserve_id );
5030     $reserve->discard_changes;
5031     ok( $reserve->found eq 'W', "Reserve is marked waiting" );
5032     is( Koha::Item::Transfers->search({ itemnumber => $item->itemnumber, datearrived => undef })->count, 0, "No outstanding transfers when hold is waiting");
5033 };
5034
5035 subtest 'Tests for NoRefundOnLostReturnedItemsAge with AddReturn' => sub {
5036
5037     plan tests => 4;
5038
5039     t::lib::Mocks::mock_preference('BlockReturnOfLostItems', 0);
5040     my $library = $builder->build_object( { class => 'Koha::Libraries' } );
5041     my $patron  = $builder->build_object(
5042         {
5043             class => 'Koha::Patrons',
5044             value => { categorycode => $patron_category->{categorycode} }
5045         }
5046     );
5047
5048     my $biblionumber = $builder->build_sample_biblio(
5049         {
5050             branchcode => $library->branchcode,
5051         }
5052     )->biblionumber;
5053
5054     # And the circulation rule
5055     Koha::CirculationRules->search->delete;
5056     Koha::CirculationRules->set_rules(
5057         {
5058             categorycode => undef,
5059             itemtype     => undef,
5060             branchcode   => undef,
5061             rules        => {
5062                 issuelength => 14,
5063                 lengthunit  => 'days',
5064             }
5065         }
5066     );
5067     $builder->build(
5068         {
5069             source => 'CirculationRule',
5070             value  => {
5071                 branchcode   => undef,
5072                 categorycode => undef,
5073                 itemtype     => undef,
5074                 rule_name    => 'lostreturn',
5075                 rule_value   => 'refund'
5076             }
5077         }
5078     );
5079
5080     subtest 'NoRefundOnLostReturnedItemsAge = undef' => sub {
5081         plan tests => 3;
5082
5083         t::lib::Mocks::mock_preference( 'WhenLostChargeReplacementFee',   1 );
5084         t::lib::Mocks::mock_preference( 'NoRefundOnLostReturnedItemsAge', undef );
5085
5086         my $lost_on = dt_from_string->subtract( days => 7 )->date;
5087
5088         my $item = $builder->build_sample_item(
5089             {
5090                 biblionumber     => $biblionumber,
5091                 library          => $library->branchcode,
5092                 replacementprice => '42',
5093             }
5094         );
5095         my $issue = AddIssue( $patron->unblessed, $item->barcode );
5096         LostItem( $item->itemnumber, 'cli', 0 );
5097         $item->_result->itemlost(1);
5098         $item->_result->itemlost_on( $lost_on );
5099         $item->_result->update();
5100
5101         my $a = Koha::Account::Lines->search(
5102             {
5103                 itemnumber     => $item->id,
5104                 borrowernumber => $patron->borrowernumber
5105             }
5106         )->next;
5107         ok( $a, "Found accountline for lost fee" );
5108         is( $a->amountoutstanding + 0, 42, "Lost fee charged correctly" );
5109         my ( $doreturn, $messages ) = AddReturn( $item->barcode, $library->branchcode, undef, dt_from_string );
5110         $a = $a->get_from_storage;
5111         is( $a->amountoutstanding + 0, 0, "Lost fee was refunded" );
5112         $a->delete;
5113     };
5114
5115     subtest 'NoRefundOnLostReturnedItemsAge > length of days item has been lost' => sub {
5116         plan tests => 3;
5117
5118         t::lib::Mocks::mock_preference( 'WhenLostChargeReplacementFee',   1 );
5119         t::lib::Mocks::mock_preference( 'NoRefundOnLostReturnedItemsAge', 7 );
5120
5121         my $lost_on = dt_from_string->subtract( days => 6 )->date;
5122
5123         my $item = $builder->build_sample_item(
5124             {
5125                 biblionumber     => $biblionumber,
5126                 library          => $library->branchcode,
5127                 replacementprice => '42',
5128             }
5129         );
5130         my $issue = AddIssue( $patron->unblessed, $item->barcode );
5131         LostItem( $item->itemnumber, 'cli', 0 );
5132         $item->_result->itemlost(1);
5133         $item->_result->itemlost_on( $lost_on );
5134         $item->_result->update();
5135
5136         my $a = Koha::Account::Lines->search(
5137             {
5138                 itemnumber     => $item->id,
5139                 borrowernumber => $patron->borrowernumber
5140             }
5141         )->next;
5142         ok( $a, "Found accountline for lost fee" );
5143         is( $a->amountoutstanding + 0, 42, "Lost fee charged correctly" );
5144         my ( $doreturn, $messages ) = AddReturn( $item->barcode, $library->branchcode, undef, dt_from_string );
5145         $a = $a->get_from_storage;
5146         is( $a->amountoutstanding + 0, 0, "Lost fee was refunded" );
5147         $a->delete;
5148     };
5149
5150     subtest 'NoRefundOnLostReturnedItemsAge = length of days item has been lost' => sub {
5151         plan tests => 3;
5152
5153         t::lib::Mocks::mock_preference( 'WhenLostChargeReplacementFee',   1 );
5154         t::lib::Mocks::mock_preference( 'NoRefundOnLostReturnedItemsAge', 7 );
5155
5156         my $lost_on = dt_from_string->subtract( days => 7 )->date;
5157
5158         my $item = $builder->build_sample_item(
5159             {
5160                 biblionumber     => $biblionumber,
5161                 library          => $library->branchcode,
5162                 replacementprice => '42',
5163             }
5164         );
5165         my $issue = AddIssue( $patron->unblessed, $item->barcode );
5166         LostItem( $item->itemnumber, 'cli', 0 );
5167         $item->_result->itemlost(1);
5168         $item->_result->itemlost_on( $lost_on );
5169         $item->_result->update();
5170
5171         my $a = Koha::Account::Lines->search(
5172             {
5173                 itemnumber     => $item->id,
5174                 borrowernumber => $patron->borrowernumber
5175             }
5176         )->next;
5177         ok( $a, "Found accountline for lost fee" );
5178         is( $a->amountoutstanding + 0, 42, "Lost fee charged correctly" );
5179         my ( $doreturn, $messages ) = AddReturn( $item->barcode, $library->branchcode, undef, dt_from_string );
5180         $a = $a->get_from_storage;
5181         is( $a->amountoutstanding + 0, 42, "Lost fee was not refunded" );
5182         $a->delete;
5183     };
5184
5185     subtest 'NoRefundOnLostReturnedItemsAge < length of days item has been lost' => sub {
5186         plan tests => 3;
5187
5188         t::lib::Mocks::mock_preference( 'WhenLostChargeReplacementFee',   1 );
5189         t::lib::Mocks::mock_preference( 'NoRefundOnLostReturnedItemsAge', 7 );
5190
5191         my $lost_on = dt_from_string->subtract( days => 8 )->date;
5192
5193         my $item = $builder->build_sample_item(
5194             {
5195                 biblionumber     => $biblionumber,
5196                 library          => $library->branchcode,
5197                 replacementprice => '42',
5198             }
5199         );
5200         my $issue = AddIssue( $patron->unblessed, $item->barcode );
5201         LostItem( $item->itemnumber, 'cli', 0 );
5202         $item->_result->itemlost(1);
5203         $item->_result->itemlost_on( $lost_on );
5204         $item->_result->update();
5205
5206         my $a = Koha::Account::Lines->search(
5207             {
5208                 itemnumber     => $item->id,
5209                 borrowernumber => $patron->borrowernumber
5210             }
5211         );
5212         $a = $a->next;
5213         ok( $a, "Found accountline for lost fee" );
5214         is( $a->amountoutstanding + 0, 42, "Lost fee charged correctly" );
5215         my ( $doreturn, $messages ) = AddReturn( $item->barcode, $library->branchcode, undef, dt_from_string );
5216         $a = $a->get_from_storage;
5217         is( $a->amountoutstanding + 0, 42, "Lost fee was not refunded" );
5218         $a->delete;
5219     };
5220 };
5221
5222 subtest 'Tests for NoRefundOnLostReturnedItemsAge with AddIssue' => sub {
5223
5224     plan tests => 4;
5225
5226     t::lib::Mocks::mock_preference('BlockReturnOfLostItems', 0);
5227     my $library = $builder->build_object( { class => 'Koha::Libraries' } );
5228     my $patron  = $builder->build_object(
5229         {
5230             class => 'Koha::Patrons',
5231             value => { categorycode => $patron_category->{categorycode} }
5232         }
5233     );
5234     my $patron2  = $builder->build_object(
5235         {
5236             class => 'Koha::Patrons',
5237             value => { categorycode => $patron_category->{categorycode} }
5238         }
5239     );
5240
5241     my $biblionumber = $builder->build_sample_biblio(
5242         {
5243             branchcode => $library->branchcode,
5244         }
5245     )->biblionumber;
5246
5247     # And the circulation rule
5248     Koha::CirculationRules->search->delete;
5249     Koha::CirculationRules->set_rules(
5250         {
5251             categorycode => undef,
5252             itemtype     => undef,
5253             branchcode   => undef,
5254             rules        => {
5255                 issuelength => 14,
5256                 lengthunit  => 'days',
5257             }
5258         }
5259     );
5260     $builder->build(
5261         {
5262             source => 'CirculationRule',
5263             value  => {
5264                 branchcode   => undef,
5265                 categorycode => undef,
5266                 itemtype     => undef,
5267                 rule_name    => 'lostreturn',
5268                 rule_value   => 'refund'
5269             }
5270         }
5271     );
5272
5273     subtest 'NoRefundOnLostReturnedItemsAge = undef' => sub {
5274         plan tests => 3;
5275
5276         t::lib::Mocks::mock_preference( 'WhenLostChargeReplacementFee',   1 );
5277         t::lib::Mocks::mock_preference( 'NoRefundOnLostReturnedItemsAge', undef );
5278
5279         my $lost_on = dt_from_string->subtract( days => 7 )->date;
5280
5281         my $item = $builder->build_sample_item(
5282             {
5283                 biblionumber     => $biblionumber,
5284                 library          => $library->branchcode,
5285                 replacementprice => '42',
5286             }
5287         );
5288         my $issue = AddIssue( $patron->unblessed, $item->barcode );
5289         LostItem( $item->itemnumber, 'cli', 0 );
5290         $item->_result->itemlost(1);
5291         $item->_result->itemlost_on( $lost_on );
5292         $item->_result->update();
5293
5294         my $a = Koha::Account::Lines->search(
5295             {
5296                 itemnumber     => $item->id,
5297                 borrowernumber => $patron->borrowernumber
5298             }
5299         )->next;
5300         ok( $a, "Found accountline for lost fee" );
5301         is( $a->amountoutstanding + 0, 42, "Lost fee charged correctly" );
5302         $issue = AddIssue( $patron2->unblessed, $item->barcode );
5303         $a = $a->get_from_storage;
5304         is( $a->amountoutstanding + 0, 0, "Lost fee was refunded" );
5305         $a->delete;
5306         $issue->delete;
5307     };
5308
5309     subtest 'NoRefundOnLostReturnedItemsAge > length of days item has been lost' => sub {
5310         plan tests => 3;
5311
5312         t::lib::Mocks::mock_preference( 'WhenLostChargeReplacementFee',   1 );
5313         t::lib::Mocks::mock_preference( 'NoRefundOnLostReturnedItemsAge', 7 );
5314
5315         my $lost_on = dt_from_string->subtract( days => 6 )->date;
5316
5317         my $item = $builder->build_sample_item(
5318             {
5319                 biblionumber     => $biblionumber,
5320                 library          => $library->branchcode,
5321                 replacementprice => '42',
5322             }
5323         );
5324         my $issue = AddIssue( $patron->unblessed, $item->barcode );
5325         LostItem( $item->itemnumber, 'cli', 0 );
5326         $item->_result->itemlost(1);
5327         $item->_result->itemlost_on( $lost_on );
5328         $item->_result->update();
5329
5330         my $a = Koha::Account::Lines->search(
5331             {
5332                 itemnumber     => $item->id,
5333                 borrowernumber => $patron->borrowernumber
5334             }
5335         )->next;
5336         ok( $a, "Found accountline for lost fee" );
5337         is( $a->amountoutstanding + 0, 42, "Lost fee charged correctly" );
5338         $issue = AddIssue( $patron2->unblessed, $item->barcode );
5339         $a = $a->get_from_storage;
5340         is( $a->amountoutstanding + 0, 0, "Lost fee was refunded" );
5341         $a->delete;
5342     };
5343
5344     subtest 'NoRefundOnLostReturnedItemsAge = length of days item has been lost' => sub {
5345         plan tests => 3;
5346
5347         t::lib::Mocks::mock_preference( 'WhenLostChargeReplacementFee',   1 );
5348         t::lib::Mocks::mock_preference( 'NoRefundOnLostReturnedItemsAge', 7 );
5349
5350         my $lost_on = dt_from_string->subtract( days => 7 )->date;
5351
5352         my $item = $builder->build_sample_item(
5353             {
5354                 biblionumber     => $biblionumber,
5355                 library          => $library->branchcode,
5356                 replacementprice => '42',
5357             }
5358         );
5359         my $issue = AddIssue( $patron->unblessed, $item->barcode );
5360         LostItem( $item->itemnumber, 'cli', 0 );
5361         $item->_result->itemlost(1);
5362         $item->_result->itemlost_on( $lost_on );
5363         $item->_result->update();
5364
5365         my $a = Koha::Account::Lines->search(
5366             {
5367                 itemnumber     => $item->id,
5368                 borrowernumber => $patron->borrowernumber
5369             }
5370         )->next;
5371         ok( $a, "Found accountline for lost fee" );
5372         is( $a->amountoutstanding + 0, 42, "Lost fee charged correctly" );
5373         $issue = AddIssue( $patron2->unblessed, $item->barcode );
5374         $a = $a->get_from_storage;
5375         is( $a->amountoutstanding + 0, 42, "Lost fee was not refunded" );
5376         $a->delete;
5377     };
5378
5379     subtest 'NoRefundOnLostReturnedItemsAge < length of days item has been lost' => sub {
5380         plan tests => 3;
5381
5382         t::lib::Mocks::mock_preference( 'WhenLostChargeReplacementFee',   1 );
5383         t::lib::Mocks::mock_preference( 'NoRefundOnLostReturnedItemsAge', 7 );
5384
5385         my $lost_on = dt_from_string->subtract( days => 8 )->date;
5386
5387         my $item = $builder->build_sample_item(
5388             {
5389                 biblionumber     => $biblionumber,
5390                 library          => $library->branchcode,
5391                 replacementprice => '42',
5392             }
5393         );
5394         my $issue = AddIssue( $patron->unblessed, $item->barcode );
5395         LostItem( $item->itemnumber, 'cli', 0 );
5396         $item->_result->itemlost(1);
5397         $item->_result->itemlost_on( $lost_on );
5398         $item->_result->update();
5399
5400         my $a = Koha::Account::Lines->search(
5401             {
5402                 itemnumber     => $item->id,
5403                 borrowernumber => $patron->borrowernumber
5404             }
5405         );
5406         $a = $a->next;
5407         ok( $a, "Found accountline for lost fee" );
5408         is( $a->amountoutstanding + 0, 42, "Lost fee charged correctly" );
5409         $issue = AddIssue( $patron2->unblessed, $item->barcode );
5410         $a = $a->get_from_storage;
5411         is( $a->amountoutstanding + 0, 42, "Lost fee was not refunded" );
5412         $a->delete;
5413     };
5414 };
5415
5416 subtest 'transferbook tests' => sub {
5417     plan tests => 9;
5418
5419     throws_ok
5420     { C4::Circulation::transferbook({}); }
5421     'Koha::Exceptions::MissingParameter',
5422     'Koha::Patron->store raises an exception on missing params';
5423
5424     throws_ok
5425     { C4::Circulation::transferbook({to_branch=>'anything'}); }
5426     'Koha::Exceptions::MissingParameter',
5427     'Koha::Patron->store raises an exception on missing params';
5428
5429     throws_ok
5430     { C4::Circulation::transferbook({from_branch=>'anything'}); }
5431     'Koha::Exceptions::MissingParameter',
5432     'Koha::Patron->store raises an exception on missing params';
5433
5434     my ($doreturn,$messages) = C4::Circulation::transferbook({to_branch=>'there',from_branch=>'here'});
5435     is( $doreturn, 0, "No return without barcode");
5436     ok( exists $messages->{BadBarcode}, "We get a BadBarcode message if no barcode passed");
5437     is( $messages->{BadBarcode}, undef, "No barcode passed means undef BadBarcode" );
5438
5439     ($doreturn,$messages) = C4::Circulation::transferbook({to_branch=>'there',from_branch=>'here',barcode=>'BadBarcode'});
5440     is( $doreturn, 0, "No return without barcode");
5441     ok( exists $messages->{BadBarcode}, "We get a BadBarcode message if no barcode passed");
5442     is( $messages->{BadBarcode}, 'BadBarcode', "No barcode passed means undef BadBarcode" );
5443
5444 };
5445
5446 subtest 'Checkout should correctly terminate a transfer' => sub {
5447     plan tests => 7;
5448
5449     my $library_1 = $builder->build_object( { class => 'Koha::Libraries' } );
5450     my $patron_1 = $builder->build_object(
5451         {
5452             class => 'Koha::Patrons',
5453             value => { branchcode => $library_1->branchcode }
5454         }
5455     );
5456     my $library_2 = $builder->build_object( { class => 'Koha::Libraries' } );
5457     my $patron_2 = $builder->build_object(
5458         {
5459             class => 'Koha::Patrons',
5460             value => { branchcode => $library_2->branchcode }
5461         }
5462     );
5463
5464     my $item = $builder->build_sample_item(
5465         {
5466             library => $library_1->branchcode,
5467         }
5468     );
5469
5470     t::lib::Mocks::mock_userenv( { branchcode => $library_1->branchcode } );
5471     my $reserve_id = AddReserve(
5472         {
5473             branchcode     => $library_2->branchcode,
5474             borrowernumber => $patron_2->borrowernumber,
5475             biblionumber   => $item->biblionumber,
5476             itemnumber     => $item->itemnumber,
5477             priority       => 1,
5478         }
5479     );
5480
5481     my $do_transfer = 1;
5482     ModItemTransfer( $item->itemnumber, $library_1->branchcode,
5483         $library_2->branchcode, 'Manual' );
5484     ModReserveAffect( $item->itemnumber, undef, $do_transfer, $reserve_id );
5485     GetOtherReserves( $item->itemnumber )
5486       ;    # To put the Reason, it's what does returns.pl...
5487     my $hold = Koha::Holds->find($reserve_id);
5488     is( $hold->found, 'T', 'Hold is in transit' );
5489     my $transfer = $item->get_transfer;
5490     is( $transfer->frombranch, $library_1->branchcode );
5491     is( $transfer->tobranch,   $library_2->branchcode );
5492     is( $transfer->reason,     'Reserve' );
5493
5494     t::lib::Mocks::mock_userenv( { branchcode => $library_2->branchcode } );
5495     AddIssue( $patron_1->unblessed, $item->barcode );
5496     $transfer = $transfer->get_from_storage;
5497     isnt( $transfer->datearrived, undef );
5498     $hold = $hold->get_from_storage;
5499     is( $hold->found, undef, 'Hold is waiting' );
5500     is( $hold->priority, 1, );
5501 };
5502
5503 subtest 'AddIssue records staff who checked out item if appropriate' => sub  {
5504     plan tests => 2;
5505
5506     $module->mock( 'userenv', sub { { branch => $library->{id} } } );
5507
5508     my $library = $builder->build_object( { class => 'Koha::Libraries' } );
5509     my $patron = $builder->build_object(
5510         {
5511             class => 'Koha::Patrons',
5512             value => { categorycode => $patron_category->{categorycode} }
5513         }
5514     );
5515     my $issuer = $builder->build_object(
5516         {
5517             class => 'Koha::Patrons',
5518             value => { categorycode => $patron_category->{categorycode} }
5519         }
5520     );
5521     my $item_1 = $builder->build_sample_item(
5522         {
5523             library  => $library->{branchcode}
5524         }
5525     );
5526
5527     my $item_2 = $builder->build_sample_item(
5528         {
5529             library  => $library->branchcode
5530         }
5531     );
5532
5533     $module->mock( 'userenv', sub { { branch => $library->id, number => $issuer->borrowernumber } } );
5534
5535     my $dt_from = dt_from_string();
5536     my $dt_to   = dt_from_string()->add( days => 7 );
5537
5538     my $issue_1 = AddIssue( $patron->unblessed, $item_1->barcode, $dt_to, undef, $dt_from );
5539
5540     is( $issue_1->issuer, undef, "Staff who checked out the item not recorded when RecordStaffUserOnCheckout turned off" );
5541
5542     t::lib::Mocks::mock_preference('RecordStaffUserOnCheckout', 1);
5543
5544     my $issue_2 =
5545       AddIssue( $patron->unblessed, $item_2->barcode, $dt_to, undef, $dt_from );
5546
5547     is( $issue_2->issuer->borrowernumber, $issuer->borrowernumber, "Staff who checked out the item recorded when RecordStaffUserOnCheckout turned on" );
5548 };
5549
5550 subtest "Item's onloan value should be set if checked out item is checked out to a different patron" => sub {
5551     plan tests => 2;
5552
5553     my $library_1 = $builder->build_object( { class => 'Koha::Libraries' } );
5554     my $patron_1 = $builder->build_object(
5555         {
5556             class => 'Koha::Patrons',
5557             value => { branchcode => $library_1->branchcode }
5558         }
5559     );
5560     my $patron_2 = $builder->build_object(
5561         {
5562             class => 'Koha::Patrons',
5563             value => { branchcode => $library_1->branchcode }
5564         }
5565     );
5566
5567     my $item = $builder->build_sample_item(
5568         {
5569             library => $library_1->branchcode,
5570         }
5571     );
5572
5573     AddIssue( $patron_1->unblessed, $item->barcode );
5574     ok( $item->get_from_storage->onloan, "Item's onloan column is set after initial checkout" );
5575     AddIssue( $patron_2->unblessed, $item->barcode );
5576     ok( $item->get_from_storage->onloan, "Item's onloan column is set after second checkout" );
5577 };
5578
5579 subtest "updateWrongTransfer tests" => sub {
5580     plan tests => 5;
5581
5582     my $library1 = $builder->build_object( { class => 'Koha::Libraries' } );
5583     my $library2 = $builder->build_object( { class => 'Koha::Libraries' } );
5584     my $library3 = $builder->build_object( { class => 'Koha::Libraries' } );
5585     my $item     = $builder->build_sample_item(
5586         {
5587             homebranch    => $library1->branchcode,
5588             holdingbranch => $library2->branchcode,
5589             datelastseen  => undef
5590         }
5591     );
5592
5593     my $transfer = $builder->build_object(
5594         {
5595             class => 'Koha::Item::Transfers',
5596             value => {
5597                 itemnumber    => $item->itemnumber,
5598                 frombranch    => $library2->branchcode,
5599                 tobranch      => $library1->branchcode,
5600                 daterequested => dt_from_string,
5601                 datesent      => dt_from_string,
5602                 datecancelled => undef,
5603                 datearrived   => undef,
5604                 reason        => 'Manual'
5605             }
5606         }
5607     );
5608     is( ref($transfer), 'Koha::Item::Transfer', 'Mock transfer added' );
5609
5610     my $new_transfer = C4::Circulation::updateWrongTransfer($item->itemnumber, $library1->branchcode);
5611     is(ref($new_transfer), 'Koha::Item::Transfer', "updateWrongTransfer returns a 'Koha::Item::Transfer' object");
5612     ok( !$new_transfer->in_transit, "New transfer is NOT created as in transit (or cancelled)");
5613
5614     my $original_transfer = $transfer->get_from_storage;
5615     ok( defined($original_transfer->datecancelled), "Original transfer was cancelled");
5616     is( $original_transfer->cancellation_reason, 'WrongTransfer', "Original transfer cancellation reason is 'WrongTransfer'");
5617 };
5618
5619 subtest "SendCirculationAlert" => sub {
5620     plan tests => 3;
5621
5622     # When you would unsuspectingly call this unit test (with perl, not prove), you will be bitten by LOCK.
5623     # LOCK will commit changes and ruin your data
5624     # In order to prevent that, we will add KOHA_TESTING to $ENV; see further Circulation.pm
5625     $ENV{KOHA_TESTING} = 1;
5626
5627     # Setup branch, borrowr, and notice
5628     my $library = $builder->build_object({ class => 'Koha::Libraries' });
5629     set_userenv( $library->unblessed);
5630     my $patron = $builder->build_object({ class => 'Koha::Patrons' });
5631     C4::Members::Messaging::SetMessagingPreference({
5632         borrowernumber => $patron->id,
5633         message_transport_types => ['sms'],
5634         message_attribute_id => 5
5635     });
5636     my $item = $builder->build_sample_item();
5637     my $checkin_notice = $builder->build_object({
5638         class => 'Koha::Notice::Templates',
5639         value =>{
5640             module => 'circulation',
5641             code => 'CHECKIN',
5642             branchcode => $library->branchcode,
5643             name => 'Test Checkin',
5644             is_html => 0,
5645             content => "Checkins:\n----\n[% biblio.title %]-[% old_checkout.issue_id %]\n----Thank you.",
5646             message_transport_type => 'sms',
5647             lang => 'default'
5648         }
5649     })->store;
5650
5651     # Checkout an item, mark it returned, generate a notice
5652     my $issue_1 = AddIssue( $patron->unblessed, $item->barcode);
5653     MarkIssueReturned( $patron->borrowernumber, $item->itemnumber, undef, 0, { skip_record_index => 1} );
5654     C4::Circulation::SendCirculationAlert({
5655         type => 'CHECKIN',
5656         item => $item->unblessed,
5657         borrower => $patron->unblessed,
5658         branch => $library->branchcode,
5659         issue => $issue_1
5660     });
5661     my $notice = Koha::Notice::Messages->find({ borrowernumber => $patron->id, letter_code => 'CHECKIN' });
5662     is($notice->content,"Checkins:\n".$item->biblio->title."-".$issue_1->id."\nThank you.", 'Letter generated with expected output on first checkin' );
5663     is($notice->to_address, $patron->smsalertnumber, "Letter has the correct to_address set to smsalertnumber for SMS type notices");
5664
5665     # Checkout an item, mark it returned, generate a notice
5666     my $issue_2 = AddIssue( $patron->unblessed, $item->barcode);
5667     MarkIssueReturned( $patron->borrowernumber, $item->itemnumber, undef, 0, { skip_record_index => 1} );
5668     C4::Circulation::SendCirculationAlert({
5669         type => 'CHECKIN',
5670         item => $item->unblessed,
5671         borrower => $patron->unblessed,
5672         branch => $library->branchcode,
5673         issue => $issue_2
5674     });
5675     $notice->discard_changes();
5676     is($notice->content,"Checkins:\n".$item->biblio->title."-".$issue_1->id."\n".$item->biblio->title."-".$issue_2->id."\nThank you.", 'Letter appended with expected output on second checkin' );
5677
5678 };
5679
5680 subtest "GetSoonestRenewDate tests" => sub {
5681     plan tests => 5;
5682     Koha::CirculationRules->set_rule(
5683         {
5684             categorycode => undef,
5685             branchcode   => undef,
5686             itemtype     => undef,
5687             rule_name    => 'norenewalbefore',
5688             rule_value   => '7',
5689         }
5690     );
5691     my $patron = $builder->build_object(
5692         {
5693             class => 'Koha::Patrons',
5694             value => {
5695                 autorenew_checkouts => 1,
5696             }
5697         }
5698     );
5699     my $item = $builder->build_sample_item();
5700     my $issue = AddIssue( $patron->unblessed, $item->barcode);
5701     my $datedue = dt_from_string( $issue->date_due() );
5702
5703     # Bug 14395
5704     # Test 'exact time' setting for syspref NoRenewalBeforePrecision
5705     t::lib::Mocks::mock_preference( 'NoRenewalBeforePrecision', 'exact_time' );
5706     is(
5707         GetSoonestRenewDate( $issue ),
5708         $datedue->clone->add( days => -7 ),
5709         'Bug 14395: Renewals permitted 7 days before due date, as expected'
5710     );
5711
5712     # Bug 14395
5713     # Test 'date' setting for syspref NoRenewalBeforePrecision
5714     t::lib::Mocks::mock_preference( 'NoRenewalBeforePrecision', 'date' );
5715     is(
5716         GetSoonestRenewDate( $issue ),
5717         $datedue->clone->add( days => -7 )->truncate( to => 'day' ),
5718         'Bug 14395: Renewals permitted 7 days before due date, as expected'
5719     );
5720
5721
5722     Koha::CirculationRules->set_rule(
5723         {
5724             categorycode => undef,
5725             branchcode   => undef,
5726             itemtype     => undef,
5727             rule_name    => 'norenewalbefore',
5728             rule_value   => undef,
5729         }
5730     );
5731
5732     is(
5733         GetSoonestRenewDate( $issue ),
5734         dt_from_string,
5735         'Checkouts without auto-renewal can be renewed immediately if no norenewalbefore'
5736     );
5737
5738     t::lib::Mocks::mock_preference( 'NoRenewalBeforePrecision', 'date' );
5739     $issue->auto_renew(1)->store;
5740     is(
5741         GetSoonestRenewDate( $issue ),
5742         $datedue->clone->truncate( to => 'day' ),
5743         'Checkouts with auto-renewal can be renewed earliest on due date if no renewalbefore'
5744     );
5745     t::lib::Mocks::mock_preference( 'NoRenewalBeforePrecision', 'exact' );
5746     is(
5747         GetSoonestRenewDate( $issue ),
5748         $datedue,
5749         'Checkouts with auto-renewal can be renewed earliest on due date if no renewalbefore'
5750     );
5751 };
5752
5753 subtest "CanBookBeIssued + needsconfirmation message" => sub {
5754     plan tests => 4;
5755
5756     my $patron = $builder->build_object( { class => 'Koha::Patrons' } );
5757     my $library = $builder->build_object( { class => 'Koha::Libraries' } );
5758     my $biblio = $builder->build_object({ class => 'Koha::Biblios' });
5759     my $biblioitem = $builder->build_object({ class => 'Koha::Biblioitems', value => { biblionumber => $biblio->biblionumber }});
5760     my $item = $builder->build_object({ class => 'Koha::Items' , value => { biblionumber => $biblio->biblionumber }});
5761
5762     my $hold = $builder->build_object({ class => 'Koha::Holds', value => {
5763         biblionumber => $item->biblionumber,
5764         branchcode => $library->branchcode,
5765         itemnumber => undef,
5766         itemtype => undef,
5767         priority => 1,
5768         found => undef,
5769         suspend => 0,
5770     }});
5771
5772     my ( $error, $needsconfirmation, $alerts, $messages );
5773
5774     ( $error, $needsconfirmation, $alerts, $messages ) = CanBookBeIssued( $patron, $item->barcode );
5775     is($needsconfirmation->{resbranchcode}, $hold->branchcode, "Branchcodes match when hold exists.");
5776
5777     $hold->priority(0)->store();
5778
5779     $hold->found("W")->store();
5780     ( $error, $needsconfirmation, $alerts, $messages ) = CanBookBeIssued( $patron, $item->barcode );
5781     is($needsconfirmation->{resbranchcode}, $hold->branchcode, "Branchcodes match when hold is waiting.");
5782
5783     $hold->found("T")->store();
5784     ( $error, $needsconfirmation, $alerts, $messages ) = CanBookBeIssued( $patron, $item->barcode );
5785     is($needsconfirmation->{resbranchcode}, $hold->branchcode, "Branchcodes match when hold is being transferred.");
5786
5787     $hold->found("P")->store();
5788     ( $error, $needsconfirmation, $alerts, $messages ) = CanBookBeIssued( $patron, $item->barcode );
5789     is($needsconfirmation->{resbranchcode}, $hold->branchcode, "Branchcodes match when hold is being processed.");
5790 };
5791
5792 subtest 'Tests for BlockReturnOfWithdrawnItems' => sub {
5793
5794     plan tests => 1;
5795
5796     t::lib::Mocks::mock_preference('BlockReturnOfWithdrawnItems', 1);
5797     my $item = $builder->build_sample_item();
5798     $item->withdrawn(1)->itemlost(1)->store;
5799     my @return = AddReturn( $item->barcode, $item->homebranch, 0, undef );
5800     is_deeply(
5801         \@return,
5802         [ 0, { NotIssued => $item->barcode, withdrawn => 1 }, undef, {} ], "Item returned as withdrawn, no other messages");
5803 };
5804
5805 $schema->storage->txn_rollback;
5806 C4::Context->clear_syspref_cache();
5807 $branches = Koha::Libraries->search();
5808 for my $branch ( $branches->next ) {
5809     my $key = $branch->branchcode . "_holidays";
5810     $cache->clear_from_cache($key);
5811 }