t/db_dependent/Circulation/CalcFine.t

   1 #!/usr/bin/perl
   2
   3 use Modern::Perl;
   4
   5 use Test::More tests => 3;
   6
   7 use C4::Context;
   8 use C4::Overdues;
   9
  10 use Koha::DateUtils qw( dt_from_string );
  11
  12 use t::lib::TestBuilder;
  13 use t::lib::Mocks;
  14
  15 my $schema = Koha::Database->schema;
  16 $schema->storage->txn_begin;
  17
  18 our $dbh = C4::Context->dbh;
  19 $dbh->do(q|DELETE FROM issues|);
  20
  21 t::lib::Mocks::mock_preference('item-level_itypes', '1');
  22
  23 my $builder = t::lib::TestBuilder->new();
  24
  25 my $branch = $builder->build(
  26     {
  27         source => 'Branch',
  28     }
  29 );
  30
  31 my $category = $builder->build(
  32     {
  33         source => 'Category',
  34     }
  35 );
  36
  37 my $patron = $builder->build(
  38     {
  39         source => 'Borrower',
  40         value  => {
  41             categorycode => $category->{categorycode},
  42             branchcode   => $branch->{branchcode},
  43         },
  44     }
  45 );
  46
  47 my $biblio = $builder->build(
  48     {
  49         source => 'Biblio',
  50         value  => {
  51             branchcode => $branch->{branchcode},
  52         },
  53     }
  54 );
  55
  56 my $itemtype = $builder->build(
  57     {
  58         source => 'Itemtype',
  59         value => {
  60             defaultreplacecost => 6,
  61         },
  62     }
  63 );
  64
  65 my $item = $builder->build(
  66     {
  67         source => 'Item',
  68         value  => {
  69             biblionumber     => $biblio->{biblionumber},
  70             homebranch       => $branch->{branchcode},
  71             holdingbranch    => $branch->{branchcode},
  72             replacementprice => '5.00',
  73             itype            => $itemtype->{itemtype},
  74         },
  75     }
  76 );
  77
  78 subtest 'Test basic functionality' => sub {
  79     plan tests => 1;
  80
  81     my $rule = $builder->schema->resultset('Issuingrule')->find({
  82         branchcode                    => '*',
  83         categorycode                  => '*',
  84         itemtype                      => '*',
  85     });
  86     $rule->delete if $rule;
  87     my $issuingrule = $builder->build(
  88         {
  89             source => 'Issuingrule',
  90             value  => {
  91                 branchcode                    => '*',
  92                 categorycode                  => '*',
  93                 itemtype                      => '*',
  94                 fine                          => '1.00',
  95                 lengthunit                    => 'days',
  96                 finedays                      => 0,
  97                 firstremind                   => 0,
  98                 chargeperiod                  => 1,
  99                 overduefinescap               => undef,
 100                 cap_fine_to_replacement_price => 0,
 101             },
 102         }
 103     );
 104
 105     my $start_dt = DateTime->new(
 106         year       => 2000,
 107         month      => 1,
 108         day        => 1,
 109     );
 110
 111     my $end_dt = DateTime->new(
 112         year       => 2000,
 113         month      => 1,
 114         day        => 30,
 115     );
 116
 117     my ($amount) = CalcFine( $item, $patron->{categorycode}, $branch->{branchcode}, $start_dt, $end_dt );
 118
 119     is( $amount, 29, 'Amount is calculated correctly' );
 120
 121     teardown();
 122 };
 123
 124 subtest 'Test cap_fine_to_replacement_price' => sub {
 125     plan tests => 2;
 126
 127     t::lib::Mocks::mock_preference('useDefaultReplacementCost', '1');
 128     my $issuingrule = $builder->build(
 129         {
 130             source => 'Issuingrule',
 131             value  => {
 132                 branchcode                    => '*',
 133                 categorycode                  => '*',
 134                 itemtype                      => '*',
 135                 fine                          => '1.00',
 136                 lengthunit                    => 'days',
 137                 finedays                      => 0,
 138                 firstremind                   => 0,
 139                 chargeperiod                  => 1,
 140                 overduefinescap               => undef,
 141                 cap_fine_to_replacement_price => 1,
 142             },
 143         }
 144     );
 145
 146     my $start_dt = DateTime->new(
 147         year       => 2000,
 148         month      => 1,
 149         day        => 1,
 150     );
 151
 152     my $end_dt = DateTime->new(
 153         year       => 2000,
 154         month      => 1,
 155         day        => 30,
 156     );
 157
 158     my ($amount) = CalcFine( $item, $patron->{categorycode}, $branch->{branchcode}, $start_dt, $end_dt );
 159
 160     is( int($amount), 5, 'Amount is calculated correctly' );
 161
 162
 163     # Use default replacement cost (useDefaultReplacementCost) is item's replacement price is 0
 164     my $item_obj = Koha::Items->find($item->{itemnumber});
 165     $item_obj->replacementprice(0)->store;
 166     ($amount) = CalcFine( $item_obj->unblessed, $patron->{categorycode}, $branch->{branchcode}, $start_dt, $end_dt );
 167     is( int($amount), 6, 'Amount is calculated correctly' );
 168
 169     teardown();
 170 };
 171
 172 subtest 'Test cap_fine_to_replacement_pricew with overduefinescap' => sub {
 173     plan tests => 2;
 174
 175     t::lib::Mocks::mock_preference('useDefaultReplacementCost', '1');
 176     my $issuingrule = $builder->build_object(
 177         {
 178             class => 'Koha::IssuingRules',
 179             value  => {
 180                 branchcode                    => '*',
 181                 categorycode                  => '*',
 182                 itemtype                      => '*',
 183                 fine                          => '1.00',
 184                 lengthunit                    => 'days',
 185                 finedays                      => 0,
 186                 firstremind                   => 0,
 187                 chargeperiod                  => 1,
 188                 overduefinescap               => 3,
 189                 cap_fine_to_replacement_price => 1,
 190             },
 191         }
 192     );
 193
 194     my $start_dt = DateTime->new(
 195         year       => 2000,
 196         month      => 1,
 197         day        => 1,
 198     );
 199
 200     my $end_dt = DateTime->new(
 201         year       => 2000,
 202         month      => 1,
 203         day        => 30,
 204     );
 205
 206     my ($amount) = CalcFine( $item, $patron->{categorycode}, $branch->{branchcode}, $start_dt, $end_dt );
 207     is( int($amount), 3, 'Got the lesser of overduefinescap and replacement price where overduefinescap < replacement price' );
 208
 209     $issuingrule->overduefinescap(6)->store();
 210     ($amount) = CalcFine( $item, $patron->{categorycode}, $branch->{branchcode}, $start_dt, $end_dt );
 211     is( int($amount), 5, 'Get the lesser of overduefinescap and replacement price where overduefinescap > replacement price' );
 212
 213     teardown();
 214 };
 215
 216 sub teardown {
 217     $dbh->do(q|DELETE FROM issuingrules|);
 218 }