t/db_dependent/Koha/Account/Lines.t

   1 #!/usr/bin/perl
   2
   3 # Copyright 2018 Koha Development team
   4 #
   5 # This file is part of Koha
   6 #
   7 # Koha is free software; you can redistribute it and/or modify it
   8 # under the terms of the GNU General Public License as published by
   9 # the Free Software Foundation; either version 3 of the License, or
  10 # (at your option) any later version.
  11 #
  12 # Koha is distributed in the hope that it will be useful, but
  13 # WITHOUT ANY WARRANTY; without even the implied warranty of
  14 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  15 # GNU General Public License for more details.
  16 #
  17 # You should have received a copy of the GNU General Public License
  18 # along with Koha; if not, see <http://www.gnu.org/licenses>
  19
  20 use Modern::Perl;
  21
  22 use Test::More tests => 15;
  23 use Test::Exception;
  24
  25 use C4::Circulation qw/AddIssue AddReturn/;
  26 use Koha::Account;
  27 use Koha::Account::Lines;
  28 use Koha::Account::Offsets;
  29 use Koha::Items;
  30
  31 use t::lib::Mocks;
  32 use t::lib::TestBuilder;
  33
  34 my $schema = Koha::Database->new->schema;
  35 my $builder = t::lib::TestBuilder->new;
  36
  37 subtest 'patron() tests' => sub {
  38
  39     plan tests => 3;
  40
  41     $schema->storage->txn_begin;
  42
  43     my $library = $builder->build( { source => 'Branch' } );
  44     my $patron = $builder->build( { source => 'Borrower' } );
  45
  46     my $line = Koha::Account::Line->new(
  47     {
  48         borrowernumber => $patron->{borrowernumber},
  49         debit_type_code    => "OVERDUE",
  50         status         => "RETURNED",
  51         amount         => 10,
  52         interface      => 'commandline',
  53     })->store;
  54
  55     my $account_line_patron = $line->patron;
  56     is( ref( $account_line_patron ), 'Koha::Patron', 'Koha::Account::Line->patron should return a Koha::Patron' );
  57     is( $line->borrowernumber, $account_line_patron->borrowernumber, 'Koha::Account::Line->patron should return the correct borrower' );
  58
  59     $line->borrowernumber(undef)->store;
  60     is( $line->patron, undef, 'Koha::Account::Line->patron should return undef if no patron linked' );
  61
  62     $schema->storage->txn_rollback;
  63 };
  64
  65
  66 subtest 'item() tests' => sub {
  67
  68     plan tests => 3;
  69
  70     $schema->storage->txn_begin;
  71
  72     my $library = $builder->build( { source => 'Branch' } );
  73     my $biblioitem = $builder->build( { source => 'Biblioitem' } );
  74     my $patron = $builder->build( { source => 'Borrower' } );
  75     my $item = Koha::Item->new(
  76     {
  77         biblionumber     => $biblioitem->{biblionumber},
  78         biblioitemnumber => $biblioitem->{biblioitemnumber},
  79         homebranch       => $library->{branchcode},
  80         holdingbranch    => $library->{branchcode},
  81         barcode          => 'some_barcode_12',
  82         itype            => 'BK',
  83     })->store;
  84
  85     my $line = Koha::Account::Line->new(
  86     {
  87         borrowernumber => $patron->{borrowernumber},
  88         itemnumber     => $item->itemnumber,
  89         debit_type_code    => "OVERDUE",
  90         status         => "RETURNED",
  91         amount         => 10,
  92         interface      => 'commandline',
  93     })->store;
  94
  95     my $account_line_item = $line->item;
  96     is( ref( $account_line_item ), 'Koha::Item', 'Koha::Account::Line->item should return a Koha::Item' );
  97     is( $line->itemnumber, $account_line_item->itemnumber, 'Koha::Account::Line->item should return the correct item' );
  98
  99     $line->itemnumber(undef)->store;
 100     is( $line->item, undef, 'Koha::Account::Line->item should return undef if no item linked' );
 101
 102     $schema->storage->txn_rollback;
 103 };
 104
 105 subtest 'total_outstanding() tests' => sub {
 106
 107     plan tests => 5;
 108
 109     $schema->storage->txn_begin;
 110
 111     my $patron  = $builder->build_object({ class => 'Koha::Patrons' });
 112
 113     my $lines = Koha::Account::Lines->search({ borrowernumber => $patron->id });
 114     is( $lines->total_outstanding, 0, 'total_outstanding returns 0 if no lines (undef case)' );
 115
 116     my $debit_1 = Koha::Account::Line->new(
 117         {   borrowernumber    => $patron->id,
 118             debit_type_code       => "OVERDUE",
 119             status            => "RETURNED",
 120             amount            => 10,
 121             amountoutstanding => 10,
 122             interface         => 'commandline',
 123         }
 124     )->store;
 125
 126     my $debit_2 = Koha::Account::Line->new(
 127         {   borrowernumber    => $patron->id,
 128             debit_type_code       => "OVERDUE",
 129             status            => "RETURNED",
 130             amount            => 10,
 131             amountoutstanding => 10,
 132             interface         => 'commandline',
 133         }
 134     )->store;
 135
 136     $lines = Koha::Account::Lines->search({ borrowernumber => $patron->id });
 137     is( $lines->total_outstanding, 20, 'total_outstanding sums correctly' );
 138
 139     my $credit_1 = Koha::Account::Line->new(
 140         {   borrowernumber    => $patron->id,
 141             debit_type_code       => "OVERDUE",
 142             status            => "RETURNED",
 143             amount            => -10,
 144             amountoutstanding => -10,
 145             interface         => 'commandline',
 146         }
 147     )->store;
 148
 149     $lines = Koha::Account::Lines->search({ borrowernumber => $patron->id });
 150     is( $lines->total_outstanding, 10, 'total_outstanding sums correctly' );
 151
 152     my $credit_2 = Koha::Account::Line->new(
 153         {   borrowernumber    => $patron->id,
 154             debit_type_code       => "OVERDUE",
 155             status            => "RETURNED",
 156             amount            => -10,
 157             amountoutstanding => -10,
 158             interface         => 'commandline',
 159         }
 160     )->store;
 161
 162     $lines = Koha::Account::Lines->search({ borrowernumber => $patron->id });
 163     is( $lines->total_outstanding, 0, 'total_outstanding sums correctly' );
 164
 165     my $credit_3 = Koha::Account::Line->new(
 166         {   borrowernumber    => $patron->id,
 167             debit_type_code       => "OVERDUE",
 168             status            => "RETURNED",
 169             amount            => -100,
 170             amountoutstanding => -100,
 171             interface         => 'commandline',
 172         }
 173     )->store;
 174
 175     $lines = Koha::Account::Lines->search({ borrowernumber => $patron->id });
 176     is( $lines->total_outstanding, -100, 'total_outstanding sums correctly' );
 177
 178     $schema->storage->txn_rollback;
 179 };
 180
 181 subtest 'total() tests' => sub {
 182
 183     plan tests => 5;
 184
 185     $schema->storage->txn_begin;
 186
 187     my $patron  = $builder->build_object({ class => 'Koha::Patrons' });
 188
 189     my $lines = Koha::Account::Lines->search({ borrowernumber => $patron->id });
 190     is( $lines->total, 0, 'total returns 0 if no lines (undef case)' );
 191
 192     my $debit_1 = Koha::Account::Line->new(
 193         {   borrowernumber    => $patron->id,
 194             debit_type_code   => "OVERDUE",
 195             status            => "RETURNED",
 196             amount            => 10,
 197             amountoutstanding => 10,
 198             interface         => 'commandline',
 199         }
 200     )->store;
 201
 202     my $debit_2 = Koha::Account::Line->new(
 203         {   borrowernumber    => $patron->id,
 204             debit_type_code       => "OVERDUE",
 205             status            => "RETURNED",
 206             amount            => 10,
 207             amountoutstanding => 10,
 208             interface         => 'commandline',
 209         }
 210     )->store;
 211
 212     $lines = Koha::Account::Lines->search({ borrowernumber => $patron->id });
 213     is( $lines->total, 20, 'total sums correctly' );
 214
 215     my $credit_1 = Koha::Account::Line->new(
 216         {   borrowernumber    => $patron->id,
 217             debit_type_code   => "OVERDUE",
 218             status            => "RETURNED",
 219             amount            => -10,
 220             amountoutstanding => -10,
 221             interface         => 'commandline',
 222         }
 223     )->store;
 224
 225     $lines = Koha::Account::Lines->search({ borrowernumber => $patron->id });
 226     is( $lines->total, 10, 'total sums correctly' );
 227
 228     my $credit_2 = Koha::Account::Line->new(
 229         {   borrowernumber    => $patron->id,
 230             debit_type_code   => "OVERDUE",
 231             status            => "RETURNED",
 232             amount            => -10,
 233             amountoutstanding => -10,
 234             interface         => 'commandline',
 235         }
 236     )->store;
 237
 238     $lines = Koha::Account::Lines->search({ borrowernumber => $patron->id });
 239     is( $lines->total, 0, 'total sums correctly' );
 240
 241     my $credit_3 = Koha::Account::Line->new(
 242         {   borrowernumber    => $patron->id,
 243             debit_type_code   => "OVERDUE",
 244             status            => "RETURNED",
 245             amount            => -100,
 246             amountoutstanding => -100,
 247             interface         => 'commandline',
 248         }
 249     )->store;
 250
 251     $lines = Koha::Account::Lines->search({ borrowernumber => $patron->id });
 252     is( $lines->total, -100, 'total sums correctly' );
 253
 254     $schema->storage->txn_rollback;
 255 };
 256
 257 subtest 'credits_total() tests' => sub {
 258
 259     plan tests => 5;
 260
 261     $schema->storage->txn_begin;
 262
 263     my $patron  = $builder->build_object({ class => 'Koha::Patrons' });
 264
 265     my $lines = Koha::Account::Lines->search({ borrowernumber => $patron->id });
 266     is( $lines->credits_total, 0, 'credits_total returns 0 if no lines (undef case)' );
 267
 268     my $debit_1 = Koha::Account::Line->new(
 269         {   borrowernumber    => $patron->id,
 270             debit_type_code   => "OVERDUE",
 271             status            => "RETURNED",
 272             amount            => 10,
 273             amountoutstanding => 10,
 274             interface         => 'commandline',
 275         }
 276     )->store;
 277
 278     my $debit_2 = Koha::Account::Line->new(
 279         {   borrowernumber    => $patron->id,
 280             debit_type_code   => "OVERDUE",
 281             status            => "RETURNED",
 282             amount            => 10,
 283             amountoutstanding => 10,
 284             interface         => 'commandline',
 285         }
 286     )->store;
 287
 288     $lines = Koha::Account::Lines->search({ borrowernumber => $patron->id });
 289     is( $lines->credits_total, 0, 'credits_total sums correctly' );
 290
 291     my $credit_1 = Koha::Account::Line->new(
 292         {   borrowernumber    => $patron->id,
 293             debit_type_code   => "OVERDUE",
 294             status            => "RETURNED",
 295             amount            => -10,
 296             amountoutstanding => -10,
 297             interface         => 'commandline',
 298         }
 299     )->store;
 300
 301     $lines = Koha::Account::Lines->search({ borrowernumber => $patron->id });
 302     is( $lines->credits_total, -10, 'credits_total sums correctly' );
 303
 304     my $credit_2 = Koha::Account::Line->new(
 305         {   borrowernumber    => $patron->id,
 306             debit_type_code   => "OVERDUE",
 307             status            => "RETURNED",
 308             amount            => -10,
 309             amountoutstanding => -10,
 310             interface         => 'commandline',
 311         }
 312     )->store;
 313
 314     $lines = Koha::Account::Lines->search({ borrowernumber => $patron->id });
 315     is( $lines->credits_total, -20, 'credits_total sums correctly' );
 316
 317     my $credit_3 = Koha::Account::Line->new(
 318         {   borrowernumber    => $patron->id,
 319             debit_type_code   => "OVERDUE",
 320             status            => "RETURNED",
 321             amount            => -100,
 322             amountoutstanding => -100,
 323             interface         => 'commandline',
 324         }
 325     )->store;
 326
 327     $lines = Koha::Account::Lines->search({ borrowernumber => $patron->id });
 328     is( $lines->credits_total, -120, 'credits_total sums correctly' );
 329
 330     $schema->storage->txn_rollback;
 331 };
 332
 333 subtest 'debits_total() tests' => sub {
 334
 335     plan tests => 5;
 336
 337     $schema->storage->txn_begin;
 338
 339     my $patron  = $builder->build_object({ class => 'Koha::Patrons' });
 340
 341     my $lines = Koha::Account::Lines->search({ borrowernumber => $patron->id });
 342     is( $lines->debits_total, 0, 'debits_total returns 0 if no lines (undef case)' );
 343
 344     my $debit_1 = Koha::Account::Line->new(
 345         {   borrowernumber    => $patron->id,
 346             debit_type_code   => "OVERDUE",
 347             status            => "RETURNED",
 348             amount            => 10,
 349             amountoutstanding => 0,
 350             interface         => 'commandline',
 351         }
 352     )->store;
 353
 354     my $debit_2 = Koha::Account::Line->new(
 355         {   borrowernumber    => $patron->id,
 356             debit_type_code   => "OVERDUE",
 357             status            => "RETURNED",
 358             amount            => 10,
 359             amountoutstanding => 0,
 360             interface         => 'commandline',
 361         }
 362     )->store;
 363
 364     $lines = Koha::Account::Lines->search({ borrowernumber => $patron->id });
 365     is( $lines->debits_total, 20, 'debits_total sums correctly' );
 366
 367     my $credit_1 = Koha::Account::Line->new(
 368         {   borrowernumber    => $patron->id,
 369             debit_type_code   => "OVERDUE",
 370             status            => "RETURNED",
 371             amount            => -10,
 372             amountoutstanding => 0,
 373             interface         => 'commandline',
 374         }
 375     )->store;
 376
 377     $lines = Koha::Account::Lines->search({ borrowernumber => $patron->id });
 378     is( $lines->debits_total, 20, 'debits_total sums correctly' );
 379
 380     my $credit_2 = Koha::Account::Line->new(
 381         {   borrowernumber    => $patron->id,
 382             debit_type_code   => "OVERDUE",
 383             status            => "RETURNED",
 384             amount            => -10,
 385             amountoutstanding => 0,
 386             interface         => 'commandline',
 387         }
 388     )->store;
 389
 390     $lines = Koha::Account::Lines->search({ borrowernumber => $patron->id });
 391     is( $lines->debits_total, 20, 'debits_total sums correctly' );
 392
 393     my $credit_3 = Koha::Account::Line->new(
 394         {   borrowernumber    => $patron->id,
 395             debit_type_code   => "OVERDUE",
 396             status            => "RETURNED",
 397             amount            => -100,
 398             amountoutstanding => 0,
 399             interface         => 'commandline',
 400         }
 401     )->store;
 402
 403     $lines = Koha::Account::Lines->search({ borrowernumber => $patron->id });
 404     is( $lines->debits_total, 20, 'debits_total sums correctly' );
 405
 406     $schema->storage->txn_rollback;
 407 };
 408
 409 subtest 'is_credit() and is_debit() tests' => sub {
 410
 411     plan tests => 4;
 412
 413     $schema->storage->txn_begin;
 414
 415     my $patron  = $builder->build_object({ class => 'Koha::Patrons' });
 416     my $account = $patron->account;
 417
 418     my $credit = $account->add_credit({ amount => 100, user_id => $patron->id, interface => 'commandline' });
 419
 420     ok( $credit->is_credit, 'is_credit detects credits' );
 421     ok( !$credit->is_debit, 'is_debit detects credits' );
 422
 423     my $debit = Koha::Account::Line->new(
 424     {
 425         borrowernumber => $patron->id,
 426         debit_type_code    => "OVERDUE",
 427         status         => "RETURNED",
 428         amount         => 10,
 429         interface      => 'commandline',
 430     })->store;
 431
 432     ok( !$debit->is_credit, 'is_credit detects debits' );
 433     ok( $debit->is_debit, 'is_debit detects debits');
 434
 435     $schema->storage->txn_rollback;
 436 };
 437
 438 subtest 'apply() tests' => sub {
 439
 440     plan tests => 24;
 441
 442     $schema->storage->txn_begin;
 443
 444     my $patron  = $builder->build_object( { class => 'Koha::Patrons' } );
 445     my $account = $patron->account;
 446
 447     my $credit = $account->add_credit( { amount => 100, user_id => $patron->id, interface => 'commandline' } );
 448
 449     my $debit_1 = Koha::Account::Line->new(
 450         {   borrowernumber    => $patron->id,
 451             debit_type_code       => "OVERDUE",
 452             status            => "RETURNED",
 453             amount            => 10,
 454             amountoutstanding => 10,
 455             interface         => 'commandline',
 456         }
 457     )->store;
 458
 459     my $debit_2 = Koha::Account::Line->new(
 460         {   borrowernumber    => $patron->id,
 461             debit_type_code       => "OVERDUE",
 462             status            => "RETURNED",
 463             amount            => 100,
 464             amountoutstanding => 100,
 465             interface         => 'commandline',
 466         }
 467     )->store;
 468
 469     $credit->discard_changes;
 470     $debit_1->discard_changes;
 471
 472     my $debits = Koha::Account::Lines->search({ accountlines_id => $debit_1->id });
 473     my $remaining_credit = $credit->apply( { debits => [ $debits->as_list ], offset_type => 'Manual Credit' } );
 474     is( $remaining_credit * 1, 90, 'Remaining credit is correctly calculated' );
 475     $credit->discard_changes;
 476     is( $credit->amountoutstanding * -1, $remaining_credit, 'Remaining credit correctly stored' );
 477
 478     # re-read debit info
 479     $debit_1->discard_changes;
 480     is( $debit_1->amountoutstanding * 1, 0, 'Debit has been cancelled' );
 481
 482     my $offsets = Koha::Account::Offsets->search( { credit_id => $credit->id, debit_id => $debit_1->id } );
 483     is( $offsets->count, 1, 'Only one offset is generated' );
 484     my $THE_offset = $offsets->next;
 485     is( $THE_offset->amount * 1, -10, 'Amount was calculated correctly (less than the available credit)' );
 486     is( $THE_offset->type, 'Manual Credit', 'Passed type stored correctly' );
 487
 488     $debits = Koha::Account::Lines->search({ accountlines_id => $debit_2->id });
 489     $remaining_credit = $credit->apply( { debits => [ $debits->as_list ] } );
 490     is( $remaining_credit, 0, 'No remaining credit left' );
 491     $credit->discard_changes;
 492     is( $credit->amountoutstanding * 1, 0, 'No outstanding credit' );
 493     $debit_2->discard_changes;
 494     is( $debit_2->amountoutstanding * 1, 10, 'Outstanding amount decremented correctly' );
 495
 496     $offsets = Koha::Account::Offsets->search( { credit_id => $credit->id, debit_id => $debit_2->id } );
 497     is( $offsets->count, 1, 'Only one offset is generated' );
 498     $THE_offset = $offsets->next;
 499     is( $THE_offset->amount * 1, -90, 'Amount was calculated correctly (less than the available credit)' );
 500     is( $THE_offset->type, 'Credit Applied', 'Defaults to \'Credit Applied\' offset type' );
 501
 502     $debits = Koha::Account::Lines->search({ accountlines_id => $debit_1->id });
 503     throws_ok
 504         { $credit->apply({ debits => [ $debits->as_list ] }); }
 505         'Koha::Exceptions::Account::NoAvailableCredit',
 506         '->apply() can only be used with outstanding credits';
 507
 508     $debits = Koha::Account::Lines->search({ accountlines_id => $credit->id });
 509     throws_ok
 510         { $debit_1->apply({ debits => [ $debits->as_list ] }); }
 511         'Koha::Exceptions::Account::IsNotCredit',
 512         '->apply() can only be used with credits';
 513
 514     $debits = Koha::Account::Lines->search({ accountlines_id => $credit->id });
 515     my $credit_3 = $account->add_credit({ amount => 1, interface => 'commandline' });
 516     throws_ok
 517         { $credit_3->apply({ debits => [ $debits->as_list ] }); }
 518         'Koha::Exceptions::Account::IsNotDebit',
 519         '->apply() can only be applied to credits';
 520
 521     my $credit_2 = $account->add_credit({ amount => 20, interface => 'commandline' });
 522     my $debit_3  = Koha::Account::Line->new(
 523         {   borrowernumber    => $patron->id,
 524             debit_type_code       => "OVERDUE",
 525             status            => "RETURNED",
 526             amount            => 100,
 527             amountoutstanding => 100,
 528             interface         => 'commandline',
 529         }
 530     )->store;
 531
 532     $debits = Koha::Account::Lines->search({ accountlines_id => { -in => [ $debit_1->id, $debit_2->id, $debit_3->id, $credit->id ] } });
 533     throws_ok {
 534         $credit_2->apply( { debits => [ $debits->as_list ], offset_type => 'Manual Credit' } ); }
 535         'Koha::Exceptions::Account::IsNotDebit',
 536         '->apply() rolls back if any of the passed lines is not a debit';
 537
 538     is( $debit_1->discard_changes->amountoutstanding * 1,   0, 'No changes to already cancelled debit' );
 539     is( $debit_2->discard_changes->amountoutstanding * 1,  10, 'Debit cancelled' );
 540     is( $debit_3->discard_changes->amountoutstanding * 1, 100, 'Outstanding amount correctly calculated' );
 541     is( $credit_2->discard_changes->amountoutstanding * -1, 20, 'No changes made' );
 542
 543     $debits = Koha::Account::Lines->search({ accountlines_id => { -in => [ $debit_1->id, $debit_2->id, $debit_3->id ] } });
 544     $remaining_credit = $credit_2->apply( { debits => [ $debits->as_list ], offset_type => 'Manual Credit' } );
 545
 546     is( $debit_1->discard_changes->amountoutstanding * 1,  0, 'No changes to already cancelled debit' );
 547     is( $debit_2->discard_changes->amountoutstanding * 1,  0, 'Debit cancelled' );
 548     is( $debit_3->discard_changes->amountoutstanding * 1, 90, 'Outstanding amount correctly calculated' );
 549     is( $credit_2->discard_changes->amountoutstanding * 1, 0, 'No remaining credit' );
 550
 551     $schema->storage->txn_rollback;
 552 };
 553
 554 subtest 'Keep account info when related patron, staff, item or cash_register is deleted' => sub {
 555
 556     plan tests => 4;
 557
 558     $schema->storage->txn_begin;
 559
 560     my $patron = $builder->build_object( { class => 'Koha::Patrons' } );
 561     my $staff = $builder->build_object( { class => 'Koha::Patrons' } );
 562     my $item = $builder->build_object({ class => 'Koha::Items' });
 563     my $issue = $builder->build_object(
 564         {
 565             class => 'Koha::Checkouts',
 566             value => { itemnumber => $item->itemnumber }
 567         }
 568     );
 569     my $register = $builder->build_object({ class => 'Koha::Cash::Registers' });
 570
 571     my $line = Koha::Account::Line->new(
 572     {
 573         borrowernumber => $patron->borrowernumber,
 574         manager_id     => $staff->borrowernumber,
 575         itemnumber     => $item->itemnumber,
 576         debit_type_code    => "OVERDUE",
 577         status         => "RETURNED",
 578         amount         => 10,
 579         interface      => 'commandline',
 580         register_id    => $register->id
 581     })->store;
 582
 583     $issue->delete;
 584     $item->delete;
 585     $line = $line->get_from_storage;
 586     is( $line->itemnumber, undef, "The account line should not be deleted when the related item is delete");
 587
 588     $staff->delete;
 589     $line = $line->get_from_storage;
 590     is( $line->manager_id, undef, "The account line should not be deleted when the related staff is delete");
 591
 592     $patron->delete;
 593     $line = $line->get_from_storage;
 594     is( $line->borrowernumber, undef, "The account line should not be deleted when the related patron is delete");
 595
 596     $register->delete;
 597     $line = $line->get_from_storage;
 598     is( $line->register_id, undef, "The account line should not be deleted when the related cash register is delete");
 599
 600     $schema->storage->txn_rollback;
 601 };
 602
 603 subtest 'adjust() tests' => sub {
 604
 605     plan tests => 29;
 606
 607     $schema->storage->txn_begin;
 608
 609     # count logs before any actions
 610     my $action_logs = $schema->resultset('ActionLog')->search()->count;
 611
 612     # Disable logs
 613     t::lib::Mocks::mock_preference( 'FinesLog', 0 );
 614
 615     my $patron  = $builder->build_object( { class => 'Koha::Patrons' } );
 616     my $account = $patron->account;
 617
 618     my $debit_1 = Koha::Account::Line->new(
 619         {   borrowernumber    => $patron->id,
 620             debit_type_code       => "OVERDUE",
 621             status            => "RETURNED",
 622             amount            => 10,
 623             amountoutstanding => 10,
 624             interface         => 'commandline',
 625         }
 626     )->store;
 627
 628     my $debit_2 = Koha::Account::Line->new(
 629         {   borrowernumber    => $patron->id,
 630             debit_type_code       => "OVERDUE",
 631             status            => "UNRETURNED",
 632             amount            => 100,
 633             amountoutstanding => 100,
 634             interface         => 'commandline'
 635         }
 636     )->store;
 637
 638     my $credit = $account->add_credit( { amount => 40, user_id => $patron->id, interface => 'commandline' } );
 639
 640     throws_ok { $debit_1->adjust( { amount => 50, type => 'bad', interface => 'commandline' } ) }
 641     qr/Update type not recognised/, 'Exception thrown for unrecognised type';
 642
 643     throws_ok { $debit_1->adjust( { amount => 50, type => 'overdue_update', interface => 'commandline' } ) }
 644     qr/Update type not allowed on this debit_type/,
 645       'Exception thrown for type conflict';
 646
 647     # Increment an unpaid fine
 648     $debit_2->adjust( { amount => 150, type => 'overdue_update', interface => 'commandline' } )->discard_changes;
 649
 650     is( $debit_2->amount * 1, 150, 'Fine amount was updated in full' );
 651     is( $debit_2->amountoutstanding * 1, 150, 'Fine amountoutstanding was update in full' );
 652     isnt( $debit_2->date, undef, 'Date has been set' );
 653
 654     my $offsets = Koha::Account::Offsets->search( { debit_id => $debit_2->id } );
 655     is( $offsets->count, 1, 'An offset is generated for the increment' );
 656     my $THIS_offset = $offsets->next;
 657     is( $THIS_offset->amount * 1, 50, 'Amount was calculated correctly (increment by 50)' );
 658     is( $THIS_offset->type, 'OVERDUE_INCREASE', 'Adjust type stored correctly' );
 659
 660     is( $schema->resultset('ActionLog')->count(), $action_logs + 0, 'No log was added' );
 661
 662     # Update fine to partially paid
 663     my $debits = Koha::Account::Lines->search({ accountlines_id => $debit_2->id });
 664     $credit->apply( { debits => [ $debits->as_list ], offset_type => 'Manual Credit' } );
 665
 666     $debit_2->discard_changes;
 667     is( $debit_2->amount * 1, 150, 'Fine amount unaffected by partial payment' );
 668     is( $debit_2->amountoutstanding * 1, 110, 'Fine amountoutstanding updated by partial payment' );
 669
 670     # Enable logs
 671     t::lib::Mocks::mock_preference( 'FinesLog', 1 );
 672
 673     # Increment the partially paid fine
 674     $debit_2->adjust( { amount => 160, type => 'overdue_update', interface => 'commandline' } )->discard_changes;
 675
 676     is( $debit_2->amount * 1, 160, 'Fine amount was updated in full' );
 677     is( $debit_2->amountoutstanding * 1, 120, 'Fine amountoutstanding was updated by difference' );
 678
 679     $offsets = Koha::Account::Offsets->search( { debit_id => $debit_2->id } );
 680     is( $offsets->count, 3, 'An offset is generated for the increment' );
 681     $THIS_offset = $offsets->last;
 682     is( $THIS_offset->amount * 1, 10, 'Amount was calculated correctly (increment by 10)' );
 683     is( $THIS_offset->type, 'OVERDUE_INCREASE', 'Adjust type stored correctly' );
 684
 685     is( $schema->resultset('ActionLog')->count(), $action_logs + 1, 'Log was added' );
 686
 687     # Decrement the partially paid fine, less than what was paid
 688     $debit_2->adjust( { amount => 50, type => 'overdue_update', interface => 'commandline' } )->discard_changes;
 689
 690     is( $debit_2->amount * 1, 50, 'Fine amount was updated in full' );
 691     is( $debit_2->amountoutstanding * 1, 10, 'Fine amountoutstanding was updated by difference' );
 692
 693     $offsets = Koha::Account::Offsets->search( { debit_id => $debit_2->id } );
 694     is( $offsets->count, 4, 'An offset is generated for the decrement' );
 695     $THIS_offset = $offsets->last;
 696     is( $THIS_offset->amount * 1, -110, 'Amount was calculated correctly (decrement by 110)' );
 697     is( $THIS_offset->type, 'OVERDUE_DECREASE', 'Adjust type stored correctly' );
 698
 699     # Decrement the partially paid fine, more than what was paid
 700     $debit_2->adjust( { amount => 30, type => 'overdue_update', interface => 'commandline' } )->discard_changes;
 701     is( $debit_2->amount * 1, 30, 'Fine amount was updated in full' );
 702     is( $debit_2->amountoutstanding * 1, 0, 'Fine amountoutstanding was zeroed (payment was 40)' );
 703
 704     $offsets = Koha::Account::Offsets->search( { debit_id => $debit_2->id } );
 705     is( $offsets->count, 5, 'An offset is generated for the decrement' );
 706     $THIS_offset = $offsets->last;
 707     is( $THIS_offset->amount * 1, -20, 'Amount was calculated correctly (decrement by 20)' );
 708     is( $THIS_offset->type, 'OVERDUE_DECREASE', 'Adjust type stored correctly' );
 709
 710     my $overpayment_refund = $account->lines->last;
 711     is( $overpayment_refund->amount * 1, -10, 'A new credit has been added' );
 712     is( $overpayment_refund->description, 'Overpayment refund', 'Credit generated with the expected description' );
 713
 714     $schema->storage->txn_rollback;
 715 };
 716
 717 subtest 'checkout() tests' => sub {
 718     plan tests => 6;
 719
 720     $schema->storage->txn_begin;
 721
 722     my $library = $builder->build_object( { class => 'Koha::Libraries' } );
 723     my $patron = $builder->build_object( { class => 'Koha::Patrons' } );
 724     my $item = $builder->build_sample_item;
 725     my $account = $patron->account;
 726
 727     t::lib::Mocks::mock_userenv({ branchcode => $library->branchcode });
 728     my $checkout = AddIssue( $patron->unblessed, $item->barcode );
 729
 730     my $line = $account->add_debit({
 731         amount    => 10,
 732         interface => 'commandline',
 733         item_id   => $item->itemnumber,
 734         issue_id  => $checkout->issue_id,
 735         type      => 'OVERDUE',
 736     });
 737
 738     my $line_checkout = $line->checkout;
 739     is( ref($line_checkout), 'Koha::Checkout', 'Result type is correct' );
 740     is( $line_checkout->issue_id, $checkout->issue_id, 'Koha::Account::Line->checkout should return the correct checkout');
 741
 742     my ( $returned, undef, $old_checkout) = C4::Circulation::AddReturn( $item->barcode, $library->branchcode );
 743     is( $returned, 1, 'The item should have been returned' );
 744
 745     $line = $line->get_from_storage;
 746     my $old_line_checkout = $line->checkout;
 747     is( ref($old_line_checkout), 'Koha::Old::Checkout', 'Result type is correct' );
 748     is( $old_line_checkout->issue_id, $old_checkout->issue_id, 'Koha::Account::Line->checkout should return the correct old_checkout' );
 749
 750     $line->issue_id(undef)->store;
 751     is( $line->checkout, undef, 'Koha::Account::Line->checkout should return undef if no checkout linked' );
 752
 753     $schema->storage->txn_rollback;
 754 };
 755
 756 subtest 'credits() and debits() tests' => sub {
 757     plan tests => 10;
 758
 759     $schema->storage->txn_begin;
 760
 761     my $patron = $builder->build_object( { class => 'Koha::Patrons' } );
 762     my $account = $patron->account;
 763
 764     my $debit1 = $account->add_debit({
 765         amount    => 8,
 766         interface => 'commandline',
 767         type      => 'ACCOUNT',
 768     });
 769     my $debit2 = $account->add_debit({
 770         amount    => 12,
 771         interface => 'commandline',
 772         type      => 'ACCOUNT',
 773     });
 774     my $credit1 = $account->add_credit({
 775         amount    => 5,
 776         interface => 'commandline',
 777         type      => 'CREDIT',
 778     });
 779     my $credit2 = $account->add_credit({
 780         amount    => 10,
 781         interface => 'commandline',
 782         type      => 'CREDIT',
 783     });
 784
 785     $credit1->apply({ debits => [ $debit1 ] });
 786     $credit2->apply({ debits => [ $debit1, $debit2 ] });
 787
 788     my $credits = $debit1->credits;
 789     is($credits->count, 2, '2 Credits applied to debit 1');
 790     my $credit = $credits->next;
 791     is($credit->amount + 0, -5, 'Correct first credit');
 792     $credit = $credits->next;
 793     is($credit->amount + 0, -10, 'Correct second credit');
 794
 795     $credits = $debit2->credits;
 796     is($credits->count, 1, '1 Credits applied to debit 2');
 797     $credit = $credits->next;
 798     is($credit->amount + 0, -10, 'Correct first credit');
 799
 800     my $debits = $credit1->debits;
 801     is($debits->count, 1, 'Credit 1 applied to 1 debit');
 802     my $debit = $debits->next;
 803     is($debit->amount + 0, 8, 'Correct first debit');
 804
 805     $debits = $credit2->debits;
 806     is($debits->count, 2, 'Credit 2 applied to 2 debits');
 807     $debit = $debits->next;
 808     is($debit->amount + 0, 8, 'Correct first debit');
 809     $debit = $debits->next;
 810     is($debit->amount + 0, 12, 'Correct second debit');
 811
 812     $schema->storage->txn_rollback;
 813 };
 814
 815 subtest "void() tests" => sub {
 816
 817     plan tests => 16;
 818
 819     $schema->storage->txn_begin;
 820
 821     # Create a borrower
 822     my $categorycode = $builder->build({ source => 'Category' })->{ categorycode };
 823     my $branchcode   = $builder->build({ source => 'Branch' })->{ branchcode };
 824
 825     my $borrower = Koha::Patron->new( {
 826         cardnumber => 'dariahall',
 827         surname => 'Hall',
 828         firstname => 'Daria',
 829     } );
 830     $borrower->categorycode( $categorycode );
 831     $borrower->branchcode( $branchcode );
 832     $borrower->store;
 833
 834     my $account = Koha::Account->new({ patron_id => $borrower->id });
 835
 836     my $line1 = Koha::Account::Line->new(
 837         {
 838             borrowernumber    => $borrower->borrowernumber,
 839             amount            => 10,
 840             amountoutstanding => 10,
 841             interface         => 'commandline',
 842             debit_type_code   => 'OVERDUE'
 843         }
 844     )->store();
 845     my $line2 = Koha::Account::Line->new(
 846         {
 847             borrowernumber    => $borrower->borrowernumber,
 848             amount            => 20,
 849             amountoutstanding => 20,
 850             interface         => 'commandline',
 851             debit_type_code   => 'OVERDUE'
 852         }
 853     )->store();
 854
 855     is( $account->balance(), 30, "Account balance is 30" );
 856     is( $line1->amountoutstanding, 10, 'First fee has amount outstanding of 10' );
 857     is( $line2->amountoutstanding, 20, 'Second fee has amount outstanding of 20' );
 858
 859     my $id = $account->pay(
 860         {
 861             lines  => [$line1, $line2],
 862             amount => 30,
 863         }
 864     );
 865
 866     my $account_payment = Koha::Account::Lines->find( $id );
 867
 868     is( $account->balance(), 0, "Account balance is 0" );
 869
 870     $line1->_result->discard_changes();
 871     $line2->_result->discard_changes();
 872     is( $line1->amountoutstanding+0, 0, 'First fee has amount outstanding of 0' );
 873     is( $line2->amountoutstanding+0, 0, 'Second fee has amount outstanding of 0' );
 874
 875     my $ret = $account_payment->void();
 876
 877     is( ref($ret), 'Koha::Account::Line', 'Void returns the account line' );
 878     is( $account->balance(), 30, "Account balance is again 30" );
 879
 880     $account_payment->_result->discard_changes();
 881     $line1->_result->discard_changes();
 882     $line2->_result->discard_changes();
 883
 884     is( $account_payment->credit_type_code, 'PAYMENT', 'Voided payment credit_type_code is still PAYMENT' );
 885     is( $account_payment->status, 'VOID', 'Voided payment status is VOID' );
 886     is( $account_payment->amount+0, 0, 'Voided payment amount is 0' );
 887     is( $account_payment->amountoutstanding+0, 0, 'Voided payment amount outstanding is 0' );
 888
 889     is( $line1->amountoutstanding+0, 10, 'First fee again has amount outstanding of 10' );
 890     is( $line2->amountoutstanding+0, 20, 'Second fee again has amount outstanding of 20' );
 891
 892     # Accountlines that are not credits should be un-voidable
 893     my $line1_pre = $line1->unblessed();
 894     $ret = $line1->void();
 895     $line1->_result->discard_changes();
 896     my $line1_post = $line1->unblessed();
 897     is( $ret, undef, 'Attempted void on non-credit returns undef' );
 898     is_deeply( $line1_pre, $line1_post, 'Non-credit account line cannot be voided' );
 899
 900     $schema->storage->txn_rollback;
 901 };
 902
 903 subtest "payout() tests" => sub {
 904
 905     plan tests => 18;
 906
 907     $schema->storage->txn_begin;
 908
 909     # Create a borrower
 910     my $categorycode =
 911       $builder->build( { source => 'Category' } )->{categorycode};
 912     my $branchcode = $builder->build( { source => 'Branch' } )->{branchcode};
 913
 914     my $borrower = Koha::Patron->new(
 915         {
 916             cardnumber => 'dariahall',
 917             surname    => 'Hall',
 918             firstname  => 'Daria',
 919         }
 920     );
 921     $borrower->categorycode($categorycode);
 922     $borrower->branchcode($branchcode);
 923     $borrower->store;
 924
 925     my $staff = Koha::Patron->new(
 926         {
 927             cardnumber => 'bobby',
 928             surname    => 'Bloggs',
 929             firstname  => 'Bobby',
 930         }
 931     );
 932     $staff->categorycode($categorycode);
 933     $staff->branchcode($branchcode);
 934     $staff->store;
 935
 936     my $account = Koha::Account->new( { patron_id => $borrower->id } );
 937
 938     my $debit1 = Koha::Account::Line->new(
 939         {
 940             borrowernumber    => $borrower->borrowernumber,
 941             amount            => 10,
 942             amountoutstanding => 10,
 943             interface         => 'commandline',
 944             debit_type_code   => 'OVERDUE'
 945         }
 946     )->store();
 947     my $credit1 = Koha::Account::Line->new(
 948         {
 949             borrowernumber    => $borrower->borrowernumber,
 950             amount            => -20,
 951             amountoutstanding => -20,
 952             interface         => 'commandline',
 953             credit_type_code  => 'CREDIT'
 954         }
 955     )->store();
 956
 957     is( $account->balance(), -10, "Account balance is -10" );
 958     is( $debit1->amountoutstanding + 0,
 959         10, 'Overdue fee has an amount outstanding of 10' );
 960     is( $credit1->amountoutstanding + 0,
 961         -20, 'Credit has an amount outstanding of -20' );
 962
 963     my $pay_params = {
 964         interface   => 'intranet',
 965         staff_id    => $staff->borrowernumber,
 966         branch      => $branchcode,
 967         payout_type => 'CASH',
 968         amount      => 20
 969     };
 970
 971     throws_ok { $debit1->payout($pay_params); }
 972     'Koha::Exceptions::Account::IsNotCredit',
 973       '->payout() can only be used with credits';
 974
 975     my @required =
 976       ( 'interface', 'staff_id', 'branch', 'payout_type', 'amount' );
 977     for my $required (@required) {
 978         my $params = {%$pay_params};
 979         delete( $params->{$required} );
 980         throws_ok {
 981             $credit1->payout($params);
 982         }
 983         'Koha::Exceptions::MissingParameter',
 984           "->payout() requires the `$required` parameter is passed";
 985     }
 986
 987     throws_ok {
 988         $credit1->payout(
 989             {
 990                 interface   => 'intranet',
 991                 staff_id    => $staff->borrowernumber,
 992                 branch      => $branchcode,
 993                 payout_type => 'CASH',
 994                 amount      => 25
 995             }
 996         );
 997     }
 998     'Koha::Exceptions::ParameterTooHigh',
 999       '->payout() cannot pay out more than the amountoutstanding';
1000
1001     t::lib::Mocks::mock_preference( 'UseCashRegisters', 1 );
1002     throws_ok {
1003         $credit1->payout(
1004             {
1005                 interface   => 'intranet',
1006                 staff_id    => $staff->borrowernumber,
1007                 branch      => $branchcode,
1008                 payout_type => 'CASH',
1009                 amount      => 10
1010             }
1011         );
1012     }
1013     'Koha::Exceptions::Account::RegisterRequired',
1014       '->payout() requires a cash_register if payout_type is `CASH`';
1015
1016     t::lib::Mocks::mock_preference( 'UseCashRegisters', 0 );
1017     my $payout = $credit1->payout(
1018         {
1019             interface   => 'intranet',
1020             staff_id    => $staff->borrowernumber,
1021             branch      => $branchcode,
1022             payout_type => 'CASH',
1023             amount      => 10
1024         }
1025     );
1026
1027     is( ref($payout), 'Koha::Account::Line',
1028         '->payout() returns a Koha::Account::Line' );
1029     is( $payout->amount() + 0,            10, "Payout amount is 10" );
1030     is( $payout->amountoutstanding() + 0, 0,  "Payout amountoutstanding is 0" );
1031     is( $account->balance() + 0,          0,  "Account balance is 0" );
1032     is( $debit1->amountoutstanding + 0,
1033         10, 'Overdue fee still has an amount outstanding of 10' );
1034     is( $credit1->amountoutstanding + 0,
1035         -10, 'Credit has an new amount outstanding of -10' );
1036     is( $credit1->status(), 'PAID', "Credit has a new status of PAID" );
1037
1038     $schema->storage->txn_rollback;
1039 };
1040
1041 subtest "reduce() tests" => sub {
1042
1043     plan tests => 27;
1044
1045     $schema->storage->txn_begin;
1046
1047     # Create a borrower
1048     my $categorycode =
1049       $builder->build( { source => 'Category' } )->{categorycode};
1050     my $branchcode = $builder->build( { source => 'Branch' } )->{branchcode};
1051
1052     my $borrower = Koha::Patron->new(
1053         {
1054             cardnumber => 'dariahall',
1055             surname    => 'Hall',
1056             firstname  => 'Daria',
1057         }
1058     );
1059     $borrower->categorycode($categorycode);
1060     $borrower->branchcode($branchcode);
1061     $borrower->store;
1062
1063     my $staff = Koha::Patron->new(
1064         {
1065             cardnumber => 'bobby',
1066             surname    => 'Bloggs',
1067             firstname  => 'Bobby',
1068         }
1069     );
1070     $staff->categorycode($categorycode);
1071     $staff->branchcode($branchcode);
1072     $staff->store;
1073
1074     my $account = Koha::Account->new( { patron_id => $borrower->id } );
1075
1076     my $debit1 = Koha::Account::Line->new(
1077         {
1078             borrowernumber    => $borrower->borrowernumber,
1079             amount            => 20,
1080             amountoutstanding => 20,
1081             interface         => 'commandline',
1082             debit_type_code   => 'LOST'
1083         }
1084     )->store();
1085     my $credit1 = Koha::Account::Line->new(
1086         {
1087             borrowernumber    => $borrower->borrowernumber,
1088             amount            => -20,
1089             amountoutstanding => -20,
1090             interface         => 'commandline',
1091             credit_type_code  => 'CREDIT'
1092         }
1093     )->store();
1094
1095     is( $account->balance(), 0, "Account balance is 0" );
1096     is( $debit1->amountoutstanding,
1097         20, 'Overdue fee has an amount outstanding of 20' );
1098     is( $credit1->amountoutstanding,
1099         -20, 'Credit has an amount outstanding of -20' );
1100
1101     my $reduce_params = {
1102         interface      => 'commandline',
1103         reduction_type => 'REFUND',
1104         amount         => 5,
1105         staff_id       => $staff->borrowernumber,
1106         branch         => $branchcode
1107     };
1108
1109     throws_ok { $credit1->reduce($reduce_params); }
1110     'Koha::Exceptions::Account::IsNotDebit',
1111       '->reduce() can only be used with debits';
1112
1113     my @required = ( 'interface', 'reduction_type', 'amount' );
1114     for my $required (@required) {
1115         my $params = {%$reduce_params};
1116         delete( $params->{$required} );
1117         throws_ok {
1118             $debit1->reduce($params);
1119         }
1120         'Koha::Exceptions::MissingParameter',
1121           "->reduce() requires the `$required` parameter is passed";
1122     }
1123
1124     $reduce_params->{interface} = 'intranet';
1125     my @dependant_required = ( 'staff_id', 'branch' );
1126     for my $d (@dependant_required) {
1127         my $params = {%$reduce_params};
1128         delete( $params->{$d} );
1129         throws_ok {
1130             $debit1->reduce($params);
1131         }
1132         'Koha::Exceptions::MissingParameter',
1133 "->reduce() requires the `$d` parameter is passed when interface is intranet";
1134     }
1135
1136     throws_ok {
1137         $debit1->reduce(
1138             {
1139                 interface      => 'intranet',
1140                 staff_id       => $staff->borrowernumber,
1141                 branch         => $branchcode,
1142                 reduction_type => 'REFUND',
1143                 amount         => 25
1144             }
1145         );
1146     }
1147     'Koha::Exceptions::ParameterTooHigh',
1148       '->reduce() cannot reduce more than original amount';
1149
1150     # Partial Reduction
1151     # (Refund 5 on debt of 20)
1152     my $reduction = $debit1->reduce($reduce_params);
1153
1154     is( ref($reduction), 'Koha::Account::Line',
1155         '->reduce() returns a Koha::Account::Line' );
1156     is( $reduction->amount() * 1, -5, "Reduce amount is -5" );
1157     is( $reduction->amountoutstanding() * 1,
1158         0, "Reduce amountoutstanding is 0" );
1159     is( $debit1->amountoutstanding() * 1,
1160         15, "Debit amountoutstanding reduced by 5 to 15" );
1161     is( $account->balance() * 1, -5,        "Account balance is -5" );
1162     is( $reduction->status(),    'APPLIED', "Reduction status is 'APPLIED'" );
1163
1164     my $offsets = Koha::Account::Offsets->search(
1165         { credit_id => $reduction->id, debit_id => $debit1->id } );
1166     is( $offsets->count, 1, 'Only one offset is generated' );
1167     my $THE_offset = $offsets->next;
1168     is( $THE_offset->amount * 1,
1169         -5, 'Correct amount was applied against debit' );
1170     is( $THE_offset->type, 'REFUND', "Offset type set to 'REFUND'" );
1171
1172     # Zero offset created when zero outstanding
1173     # (Refund another 5 on paid debt of 20)
1174     $credit1->apply( { debits => [$debit1] } );
1175     is( $debit1->amountoutstanding + 0,
1176         0, 'Debit1 amountoutstanding reduced to 0' );
1177     $reduction = $debit1->reduce($reduce_params);
1178     is( $reduction->amount() * 1, -5, "Reduce amount is -5" );
1179     is( $reduction->amountoutstanding() * 1,
1180         -5, "Reduce amountoutstanding is -5" );
1181
1182     $offsets = Koha::Account::Offsets->search(
1183         { credit_id => $reduction->id, debit_id => $debit1->id } );
1184     is( $offsets->count, 1, 'Only one new offset is generated' );
1185     $THE_offset = $offsets->next;
1186     is( $THE_offset->amount * 1,
1187         0, 'Zero offset created for already paid off debit' );
1188     is( $THE_offset->type, 'REFUND', "Offset type set to 'REFUND'" );
1189
1190     # Compound reduction should not allow more than original amount
1191     # (Reduction of 5 + 5 + 20 > 20)
1192     $reduce_params->{amount} = 20;
1193     throws_ok {
1194         $debit1->reduce($reduce_params);
1195     }
1196     'Koha::Exceptions::ParameterTooHigh',
1197 '->reduce cannot reduce more than the original amount (combined reductions test)';
1198
1199     # Throw exception if attempting to reduce a payout
1200     my $payout = $reduction->payout(
1201         {
1202             interface   => 'intranet',
1203             staff_id    => $staff->borrowernumber,
1204             branch      => $branchcode,
1205             payout_type => 'CASH',
1206             amount      => 5
1207         }
1208     );
1209     throws_ok {
1210         $payout->reduce($reduce_params);
1211     }
1212     'Koha::Exceptions::Account::IsNotDebit',
1213       '->reduce() cannot be used on a payout debit';
1214
1215     $schema->storage->txn_rollback;
1216 };
1217
1218 1;