t/db_dependent/Illrequests.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
  20 use File::Basename qw/basename/;
  21
  22 use C4::Circulation qw( AddIssue AddReturn );
  23
  24 use Koha::Database;
  25 use Koha::Illrequestattributes;
  26 use Koha::Illrequest::Config;
  27 use Koha::Biblios;
  28 use Koha::Patrons;
  29 use Koha::ItemTypes;
  30 use Koha::Items;
  31 use Koha::Libraries;
  32 use Koha::MessageAttributes;
  33 use Koha::Notice::Templates;
  34 use Koha::AuthorisedValueCategories;
  35 use Koha::AuthorisedValues;
  36 use t::lib::Mocks;
  37 use t::lib::TestBuilder;
  38 use Test::MockObject;
  39 use Test::MockModule;
  40 use Test::Exception;
  41 use Test::Deep qw/ cmp_deeply ignore /;
  42 use Test::Warn;
  43
  44 use Test::More tests => 13;
  45
  46 my $schema = Koha::Database->new->schema;
  47 my $builder = t::lib::TestBuilder->new;
  48 use_ok('Koha::Illrequest');
  49 use_ok('Koha::Illrequests');
  50
  51 subtest 'Basic object tests' => sub {
  52
  53     plan tests => 24;
  54
  55     $schema->storage->txn_begin;
  56
  57     Koha::Illrequests->search->delete;
  58     my $illrq = $builder->build({ source => 'Illrequest' });
  59     my $illrq_obj = Koha::Illrequests->find($illrq->{illrequest_id});
  60
  61     isa_ok($illrq_obj, 'Koha::Illrequest',
  62            "Correctly create and load an illrequest object.");
  63     isa_ok($illrq_obj->_config, 'Koha::Illrequest::Config',
  64            "Created a config object as part of Illrequest creation.");
  65
  66     is($illrq_obj->illrequest_id, $illrq->{illrequest_id},
  67        "Illrequest_id getter works.");
  68     is($illrq_obj->borrowernumber, $illrq->{borrowernumber},
  69        "Borrowernumber getter works.");
  70     is($illrq_obj->biblio_id, $illrq->{biblio_id},
  71        "Biblio_Id getter works.");
  72     is($illrq_obj->branchcode, $illrq->{branchcode},
  73        "Branchcode getter works.");
  74     is($illrq_obj->status, $illrq->{status},
  75        "Status getter works.");
  76     is($illrq_obj->placed, $illrq->{placed},
  77        "Placed getter works.");
  78     is($illrq_obj->replied, $illrq->{replied},
  79        "Replied getter works.");
  80     is($illrq_obj->updated, $illrq->{updated},
  81        "Updated getter works.");
  82     is($illrq_obj->completed, $illrq->{completed},
  83        "Completed getter works.");
  84     is($illrq_obj->medium, $illrq->{medium},
  85        "Medium getter works.");
  86     is($illrq_obj->accessurl, $illrq->{accessurl},
  87        "Accessurl getter works.");
  88     is($illrq_obj->cost, $illrq->{cost},
  89        "Cost getter works.");
  90     is($illrq_obj->price_paid, $illrq->{price_paid},
  91        "Price_paid getter works.");
  92     is($illrq_obj->notesopac, $illrq->{notesopac},
  93        "Notesopac getter works.");
  94     is($illrq_obj->notesstaff, $illrq->{notesstaff},
  95        "Notesstaff getter works.");
  96     is($illrq_obj->orderid, $illrq->{orderid},
  97        "Orderid getter works.");
  98     is($illrq_obj->backend, $illrq->{backend},
  99        "Backend getter works.");
 100
 101     is($illrq_obj->get_type, undef,
 102         'get_type() returns undef if no type is set');
 103     $builder->build({
 104         source => 'Illrequestattribute',
 105         value  => {
 106             illrequest_id => $illrq_obj->illrequest_id,
 107             type => 'type',
 108             value => 'book'
 109         }
 110     });
 111     is($illrq_obj->get_type, 'book',
 112         'get_type() returns correct type if set');
 113
 114     isnt($illrq_obj->status, 'COMP',
 115          "ILL is not currently marked complete.");
 116     $illrq_obj->mark_completed;
 117     is($illrq_obj->status, 'COMP',
 118        "ILL is now marked complete.");
 119
 120     $illrq_obj->delete;
 121
 122     is(Koha::Illrequests->search->count, 0,
 123        "No illrequest found after delete.");
 124
 125     $schema->storage->txn_rollback;
 126 };
 127
 128 subtest 'Working with related objects' => sub {
 129
 130     plan tests => 7;
 131
 132     $schema->storage->txn_begin;
 133
 134     Koha::Illrequests->search->delete;
 135
 136     my $patron = $builder->build({ source => 'Borrower' });
 137     my $illrq = $builder->build({
 138         source => 'Illrequest',
 139         value => { borrowernumber => $patron->{borrowernumber} }
 140     });
 141     my $illrq_obj = Koha::Illrequests->find($illrq->{illrequest_id});
 142
 143     isa_ok($illrq_obj->patron, 'Koha::Patron',
 144            "OK accessing related patron.");
 145
 146     $builder->build({
 147         source => 'Illrequestattribute',
 148         value  => { illrequest_id => $illrq_obj->illrequest_id, type => 'X' }
 149     });
 150     $builder->build({
 151         source => 'Illrequestattribute',
 152         value  => { illrequest_id => $illrq_obj->illrequest_id, type => 'Y' }
 153     });
 154     $builder->build({
 155         source => 'Illrequestattribute',
 156         value  => { illrequest_id => $illrq_obj->illrequest_id, type => 'Z' }
 157     });
 158
 159     is($illrq_obj->illrequestattributes->count, Koha::Illrequestattributes->search->count,
 160        "Fetching expected number of Illrequestattributes for our request.");
 161
 162     my $illrq1 = $builder->build({ source => 'Illrequest' });
 163     $builder->build({
 164         source => 'Illrequestattribute',
 165         value  => { illrequest_id => $illrq1->{illrequest_id}, type => 'X' }
 166     });
 167
 168     is($illrq_obj->illrequestattributes->count + 1, Koha::Illrequestattributes->search->count,
 169        "Fetching expected number of Illrequestattributes for our request.");
 170
 171     is($illrq_obj->biblio, undef, "->biblio returns undef if no biblio");
 172     my $biblio = $builder->build_object({ class => 'Koha::Biblios' });
 173     my $req_bib = $builder->build_object({
 174         class => 'Koha::Illrequests',
 175         value => {
 176             biblio_id      => $biblio->biblionumber
 177         }
 178     });
 179     isa_ok($req_bib->biblio, 'Koha::Biblio', "OK accessing related biblio");
 180
 181     $illrq_obj->delete;
 182     is(Koha::Illrequestattributes->search->count, 1,
 183        "Correct number of illrequestattributes after delete.");
 184
 185     isa_ok(Koha::Patrons->find($patron->{borrowernumber}), 'Koha::Patron',
 186            "Borrower was not deleted after illrq delete.");
 187
 188     $schema->storage->txn_rollback;
 189 };
 190
 191 subtest 'Status Graph tests' => sub {
 192
 193     plan tests => 6;
 194
 195     $schema->storage->txn_begin;
 196
 197     my $illrq = $builder->build({source => 'Illrequest'});
 198     my $illrq_obj = Koha::Illrequests->find($illrq->{illrequest_id});
 199
 200     # _core_status_graph tests: it's just a constant, so here we just make
 201     # sure it returns a hashref.
 202     is(ref $illrq_obj->_core_status_graph, "HASH",
 203        "_core_status_graph returns a hash.");
 204
 205     # _status_graph_union: let's try different merge operations.
 206     # Identity operation
 207     is_deeply(
 208         $illrq_obj->_status_graph_union($illrq_obj->_core_status_graph, {}),
 209         $illrq_obj->_core_status_graph,
 210         "core_status_graph + null = core_status_graph"
 211     );
 212
 213     # Simple addition
 214     is_deeply(
 215         $illrq_obj->_status_graph_union({}, $illrq_obj->_core_status_graph),
 216         $illrq_obj->_core_status_graph,
 217         "null + core_status_graph = core_status_graph"
 218     );
 219
 220     # Correct merge behaviour
 221     is_deeply(
 222         $illrq_obj->_status_graph_union({
 223             REQ => {
 224                 prev_actions   => [ ],
 225                 id             => 'REQ',
 226                 next_actions   => [ ],
 227             },
 228         }, {
 229             QER => {
 230                 prev_actions   => [ 'REQ' ],
 231                 id             => 'QER',
 232                 next_actions   => [ 'REQ' ],
 233             },
 234         }),
 235         {
 236             REQ => {
 237                 prev_actions   => [ 'QER' ],
 238                 id             => 'REQ',
 239                 next_actions   => [ 'QER' ],
 240             },
 241             QER => {
 242                 prev_actions   => [ 'REQ' ],
 243                 id             => 'QER',
 244                 next_actions   => [ 'REQ' ],
 245             },
 246         },
 247         "REQ atom + linking QER = cyclical status graph"
 248     );
 249
 250     # Create a new node, with no prev_actions and no next_actions. This should
 251     # protect us against regressions related to bug 22280.
 252     my $new_node = {
 253         TEST => {
 254             prev_actions   => [ ],
 255             id             => 'TEST',
 256             next_actions   => [ ],
 257         },
 258     };
 259     # Add the new node to the core_status_grpah
 260     my $new_graph = $illrq_obj->_status_graph_union( $new_node, $illrq_obj->_core_status_graph);
 261     # Compare the updated graph to the expected graph
 262     # The structure we compare against here is just a copy of the structure found
 263     # in Koha::Illrequest::_core_status_graph() + the new node we created above
 264     cmp_deeply( $new_graph,
 265         {
 266         TEST => {
 267             prev_actions   => [ ],
 268             id             => 'TEST',
 269             next_actions   => [ ],
 270         },
 271         NEW => {
 272             prev_actions => [ ],                           # Actions containing buttons
 273                                                            # leading to this status
 274             id             => 'NEW',                       # ID of this status
 275             name           => 'New request',               # UI name of this status
 276             ui_method_name => 'New request',               # UI name of method leading
 277                                                            # to this status
 278             method         => 'create',                    # method to this status
 279             next_actions   => [ 'REQ', 'GENREQ', 'KILL' ], # buttons to add to all
 280                                                            # requests with this status
 281             ui_method_icon => 'fa-plus',                   # UI Style class
 282         },
 283         REQ => {
 284             prev_actions   => [ 'NEW', 'REQREV', 'QUEUED', 'CANCREQ' ],
 285             id             => 'REQ',
 286             name           => 'Requested',
 287             ui_method_name => 'Confirm request',
 288             method         => 'confirm',
 289             next_actions   => [ 'REQREV', 'COMP', 'CHK' ],
 290             ui_method_icon => 'fa-check',
 291         },
 292         GENREQ => {
 293             prev_actions   => [ 'NEW', 'REQREV' ],
 294             id             => 'GENREQ',
 295             name           => 'Requested from partners',
 296             ui_method_name => 'Place request with partners',
 297             method         => 'generic_confirm',
 298             next_actions   => [ 'COMP', 'CHK' ],
 299             ui_method_icon => 'fa-send-o',
 300         },
 301         REQREV => {
 302             prev_actions   => [ 'REQ' ],
 303             id             => 'REQREV',
 304             name           => 'Request reverted',
 305             ui_method_name => 'Revert Request',
 306             method         => 'cancel',
 307             next_actions   => [ 'REQ', 'GENREQ', 'KILL' ],
 308             ui_method_icon => 'fa-times',
 309         },
 310         QUEUED => {
 311             prev_actions   => [ ],
 312             id             => 'QUEUED',
 313             name           => 'Queued request',
 314             ui_method_name => 0,
 315             method         => 0,
 316             next_actions   => [ 'REQ', 'KILL' ],
 317             ui_method_icon => 0,
 318         },
 319         CANCREQ => {
 320             prev_actions   => [ 'NEW' ],
 321             id             => 'CANCREQ',
 322             name           => 'Cancellation requested',
 323             ui_method_name => 0,
 324             method         => 0,
 325             next_actions   => [ 'KILL', 'REQ' ],
 326             ui_method_icon => 0,
 327         },
 328         COMP => {
 329             prev_actions   => [ 'REQ' ],
 330             id             => 'COMP',
 331             name           => 'Completed',
 332             ui_method_name => 'Mark completed',
 333             method         => 'mark_completed',
 334             next_actions   => [ 'CHK' ],
 335             ui_method_icon => 'fa-check',
 336         },
 337         KILL => {
 338             prev_actions   => [ 'QUEUED', 'REQREV', 'NEW', 'CANCREQ' ],
 339             id             => 'KILL',
 340             name           => 0,
 341             ui_method_name => 'Delete request',
 342             method         => 'delete',
 343             next_actions   => [ ],
 344             ui_method_icon => 'fa-trash',
 345         },
 346         CHK => {
 347             prev_actions   => [ 'REQ', 'GENREQ', 'COMP' ],
 348             id             => 'CHK',
 349             name           => 'Checked out',
 350             ui_method_name => 'Check out',
 351             needs_prefs    => [ 'CirculateILL' ],
 352             needs_perms    => [ 'user_circulate_circulate_remaining_permissions' ],
 353             needs_all      => ignore(),
 354             method         => 'check_out',
 355             next_actions   => [ ],
 356             ui_method_icon => 'fa-upload',
 357         },
 358         RET => {
 359             prev_actions   => [ 'CHK' ],
 360             id             => 'RET',
 361             name           => 'Returned to library',
 362             ui_method_name => 'Check in',
 363             method         => 'check_in',
 364             next_actions   => [ 'COMP' ],
 365             ui_method_icon => 'fa-download',
 366         }
 367     },
 368         "new node + core_status_graph = bigger status graph"
 369     ) || diag explain $new_graph;
 370
 371     # Create a duplicate node
 372     my $dupe_node = {
 373         REQ => {
 374             prev_actions   => [ 'NEW', 'REQREV', 'QUEUED', 'CANCREQ' ],
 375             id             => 'REQ',
 376             name           => 'Requested',
 377             ui_method_name => 'Confirm request dupe',
 378             method         => 'confirm',
 379             next_actions   => [ 'REQREV', 'COMP', 'CHK' ],
 380             ui_method_icon => 'fa-check',
 381         }
 382     };
 383     # Add the dupe node to the core_status_grpah
 384     my $dupe_graph = $illrq_obj->_status_graph_union( $illrq_obj->_core_status_graph, $dupe_node);
 385     # Compare the updated graph to the expected graph
 386     # The structure we compare against here is just a copy of the structure found
 387     # in Koha::Illrequest::_core_status_graph() + the new node we created above
 388     cmp_deeply( $dupe_graph,
 389         {
 390         NEW => {
 391             prev_actions => [ ],                           # Actions containing buttons
 392                                                            # leading to this status
 393             id             => 'NEW',                       # ID of this status
 394             name           => 'New request',               # UI name of this status
 395             ui_method_name => 'New request',               # UI name of method leading
 396                                                            # to this status
 397             method         => 'create',                    # method to this status
 398             next_actions   => [ 'REQ', 'GENREQ', 'KILL' ], # buttons to add to all
 399                                                            # requests with this status
 400             ui_method_icon => 'fa-plus',                   # UI Style class
 401         },
 402         REQ => {
 403             prev_actions   => [ 'NEW', 'REQREV', 'QUEUED', 'CANCREQ' ],
 404             id             => 'REQ',
 405             name           => 'Requested',
 406             ui_method_name => 'Confirm request dupe',
 407             method         => 'confirm',
 408             next_actions   => [ 'REQREV', 'COMP', 'CHK' ],
 409             ui_method_icon => 'fa-check',
 410         },
 411         GENREQ => {
 412             prev_actions   => [ 'NEW', 'REQREV' ],
 413             id             => 'GENREQ',
 414             name           => 'Requested from partners',
 415             ui_method_name => 'Place request with partners',
 416             method         => 'generic_confirm',
 417             next_actions   => [ 'COMP', 'CHK' ],
 418             ui_method_icon => 'fa-send-o',
 419         },
 420         REQREV => {
 421             prev_actions   => [ 'REQ' ],
 422             id             => 'REQREV',
 423             name           => 'Request reverted',
 424             ui_method_name => 'Revert Request',
 425             method         => 'cancel',
 426             next_actions   => [ 'REQ', 'GENREQ', 'KILL' ],
 427             ui_method_icon => 'fa-times',
 428         },
 429         QUEUED => {
 430             prev_actions   => [ ],
 431             id             => 'QUEUED',
 432             name           => 'Queued request',
 433             ui_method_name => 0,
 434             method         => 0,
 435             next_actions   => [ 'REQ', 'KILL' ],
 436             ui_method_icon => 0,
 437         },
 438         CANCREQ => {
 439             prev_actions   => [ 'NEW' ],
 440             id             => 'CANCREQ',
 441             name           => 'Cancellation requested',
 442             ui_method_name => 0,
 443             method         => 0,
 444             next_actions   => [ 'KILL', 'REQ' ],
 445             ui_method_icon => 0,
 446         },
 447         COMP => {
 448             prev_actions   => [ 'REQ' ],
 449             id             => 'COMP',
 450             name           => 'Completed',
 451             ui_method_name => 'Mark completed',
 452             method         => 'mark_completed',
 453             next_actions   => [ 'CHK' ],
 454             ui_method_icon => 'fa-check',
 455         },
 456         KILL => {
 457             prev_actions   => [ 'QUEUED', 'REQREV', 'NEW', 'CANCREQ' ],
 458             id             => 'KILL',
 459             name           => 0,
 460             ui_method_name => 'Delete request',
 461             method         => 'delete',
 462             next_actions   => [ ],
 463             ui_method_icon => 'fa-trash',
 464         },
 465         CHK => {
 466             prev_actions   => [ 'REQ', 'GENREQ', 'COMP' ],
 467             id             => 'CHK',
 468             name           => 'Checked out',
 469             ui_method_name => 'Check out',
 470             needs_prefs    => [ 'CirculateILL' ],
 471             needs_perms    => [ 'user_circulate_circulate_remaining_permissions' ],
 472             needs_all      => ignore(),
 473             method         => 'check_out',
 474             next_actions   => [ ],
 475             ui_method_icon => 'fa-upload',
 476         },
 477         RET => {
 478             prev_actions   => [ 'CHK' ],
 479             id             => 'RET',
 480             name           => 'Returned to library',
 481             ui_method_name => 'Check in',
 482             method         => 'check_in',
 483             next_actions   => [ 'COMP' ],
 484             ui_method_icon => 'fa-download',
 485         }
 486     },
 487         "new node + core_status_graph = bigger status graph"
 488     ) || diag explain $dupe_graph;
 489
 490     $schema->storage->txn_rollback;
 491 };
 492
 493 subtest 'Backend testing (mocks)' => sub {
 494
 495     plan tests => 13;
 496
 497     $schema->storage->txn_begin;
 498
 499     # testing load_backend & available_backends requires that we have at least
 500     # the Dummy plugin installed.  load_backend & available_backends don't
 501     # currently have tests as a result.
 502
 503     t::lib::Mocks->mock_config('interlibrary_loans', { backend_dir => 'a_dir' }  );
 504     my $backend = Test::MockObject->new;
 505     $backend->set_isa('Koha::Illbackends::Mock');
 506     $backend->set_always('name', 'Mock');
 507
 508     my $patron = $builder->build({ source => 'Borrower' });
 509     my $illrq = $builder->build_object({
 510         class => 'Koha::Illrequests',
 511     });
 512
 513     $illrq->_backend($backend);
 514
 515     isa_ok($illrq->_backend, 'Koha::Illbackends::Mock',
 516            "OK accessing mocked backend.");
 517
 518     # _backend_capability tests:
 519     # We need to test whether this optional feature of a mocked backend
 520     # behaves as expected.
 521     # 3 scenarios: feature not implemented, feature implemented, but requested
 522     # capability is not provided by backend, & feature is implemented &
 523     # capability exists.  This method can be used to implement custom backend
 524     # functionality, such as unmediated in the BLDSS backend (also see
 525     # bugzilla 18837).
 526     $backend->set_always('capabilities', undef);
 527     is($illrq->_backend_capability('Test'), 0,
 528        "0 returned on Mock not implementing capabilities.");
 529
 530     $backend->set_always('capabilities', 0);
 531     is($illrq->_backend_capability('Test'), 0,
 532        "0 returned on Mock not implementing Test capability.");
 533
 534     $backend->set_always('capabilities', sub { return 'bar'; } );
 535     is($illrq->_backend_capability('Test'), 'bar',
 536        "'bar' returned on Mock implementing Test capability.");
 537
 538     # metadata test: we need to be sure that we return the arbitrary values
 539     # from the backend.
 540     $backend->mock(
 541         'metadata',
 542         sub {
 543             my ( $self, $rq ) = @_;
 544             return {
 545                 ID => $rq->illrequest_id,
 546                 Title => $rq->patron->borrowernumber
 547             }
 548         }
 549     );
 550
 551     is_deeply(
 552         $illrq->metadata,
 553         {
 554             ID => $illrq->illrequest_id,
 555             Title => $illrq->patron->borrowernumber
 556         },
 557         "Test metadata."
 558     );
 559
 560     # capabilities:
 561
 562     # No backend graph extension
 563     $backend->set_always('status_graph', {});
 564     is_deeply($illrq->capabilities('COMP'),
 565               {
 566                   prev_actions   => [ 'REQ' ],
 567                   id             => 'COMP',
 568                   name           => 'Completed',
 569                   ui_method_name => 'Mark completed',
 570                   method         => 'mark_completed',
 571                   next_actions   => [ 'CHK' ],
 572                   ui_method_icon => 'fa-check',
 573               },
 574               "Dummy status graph for COMP.");
 575     is($illrq->capabilities('UNKNOWN'), undef,
 576        "Dummy status graph for UNKNOWN.");
 577     is_deeply($illrq->capabilities(),
 578               $illrq->_core_status_graph,
 579               "Dummy full status graph.");
 580     # Simple backend graph extension
 581     $backend->set_always('status_graph',
 582                          {
 583                              QER => {
 584                                  prev_actions   => [ 'REQ' ],
 585                                  id             => 'QER',
 586                                  next_actions   => [ 'REQ' ],
 587                              },
 588                          });
 589     is_deeply($illrq->capabilities('QER'),
 590               {
 591                   prev_actions   => [ 'REQ' ],
 592                   id             => 'QER',
 593                   next_actions   => [ 'REQ' ],
 594               },
 595               "Simple status graph for QER.");
 596     is($illrq->capabilities('UNKNOWN'), undef,
 597        "Simple status graph for UNKNOWN.");
 598     is_deeply($illrq->capabilities(),
 599               $illrq->_status_graph_union(
 600                   $illrq->_core_status_graph,
 601                   {
 602                       QER => {
 603                           prev_actions   => [ 'REQ' ],
 604                           id             => 'QER',
 605                           next_actions   => [ 'REQ' ],
 606                       },
 607                   }
 608               ),
 609               "Simple full status graph.");
 610
 611     # custom_capability:
 612
 613     # No backend graph extension
 614     $backend->set_always('status_graph', {});
 615     is($illrq->custom_capability('unknown', {}), 0,
 616        "Unknown candidate.");
 617
 618     # Simple backend graph extension
 619     $backend->set_always('status_graph',
 620                          {
 621                              ID => {
 622                                  prev_actions   => [ 'REQ' ],
 623                                  id             => 'ID',
 624                                  method         => 'identity',
 625                                  next_actions   => [ 'REQ' ],
 626                              },
 627                          });
 628     $backend->mock('identity',
 629                    sub { my ( $self, $params ) = @_; return $params->{other}; });
 630     is($illrq->custom_capability('identity', { test => 1, method => 'blah' })->{test}, 1,
 631        "Resolve identity custom_capability");
 632
 633     $schema->storage->txn_rollback;
 634 };
 635
 636
 637 subtest 'Backend core methods' => sub {
 638
 639     plan tests => 18;
 640
 641     $schema->storage->txn_begin;
 642
 643     # Build infrastructure
 644     my $backend = Test::MockObject->new;
 645     $backend->set_isa('Koha::Illbackends::Mock');
 646     $backend->set_always('name', 'Mock');
 647     $backend->mock('capabilities', sub { return 'Mock'; });
 648
 649     my $config = Test::MockObject->new;
 650     $config->set_always('backend_dir', "/tmp");
 651     $config->set_always('getLimitRules',
 652                         { default => { count => 0, method => 'active' } });
 653
 654     my $illrq = $builder->build_object({
 655         class => 'Koha::Illrequests',
 656         value => { backend => undef }
 657     });
 658     $illrq->_config($config);
 659
 660     # Test error conditions (no backend)
 661     throws_ok { $illrq->load_backend; }
 662         'Koha::Exceptions::Ill::InvalidBackendId',
 663         'Exception raised correctly';
 664
 665     throws_ok { $illrq->load_backend(''); }
 666         'Koha::Exceptions::Ill::InvalidBackendId',
 667         'Exception raised correctly';
 668
 669     # Now load the mocked backend
 670     $illrq->_backend($backend);
 671
 672     # expandTemplate:
 673     is_deeply($illrq->expandTemplate({ test => 1, method => "bar" }),
 674               {
 675                   test => 1,
 676                   method => "bar",
 677                   template => "/tmp/Mock/intra-includes/bar.inc",
 678                   opac_template => "/tmp/Mock/opac-includes/bar.inc",
 679               },
 680               "ExpandTemplate");
 681
 682     # backend_create
 683     # we are testing simple cases.
 684     $backend->set_series('create',
 685                          { stage => 'bar', method => 'create' },
 686                          { stage => 'commit', method => 'create' },
 687                          { stage => 'commit', method => 'create' },
 688                          { stage => 'commit', method => 'create' },
 689                          { stage => 'commit', method => 'create' });
 690     # Test non-commit
 691     is_deeply($illrq->backend_create({test => 1}),
 692               {
 693                   stage => 'bar', method => 'create',
 694                   template => "/tmp/Mock/intra-includes/create.inc",
 695                   opac_template => "/tmp/Mock/opac-includes/create.inc",
 696               },
 697               "Backend create: arbitrary stage.");
 698     # Test commit
 699     is_deeply($illrq->backend_create({test => 1}),
 700               {
 701                   stage => 'commit', method => 'create', permitted => 0,
 702                   template => "/tmp/Mock/intra-includes/create.inc",
 703                   opac_template => "/tmp/Mock/opac-includes/create.inc",
 704               },
 705               "Backend create: arbitrary stage, not permitted.");
 706     is($illrq->status, "QUEUED", "Backend create: queued if restricted.");
 707     $config->set_always('getLimitRules', {});
 708     $illrq->status('NEW');
 709     is_deeply($illrq->backend_create({test => 1}),
 710               {
 711                   stage => 'commit', method => 'create', permitted => 1,
 712                   template => "/tmp/Mock/intra-includes/create.inc",
 713                   opac_template => "/tmp/Mock/opac-includes/create.inc",
 714               },
 715               "Backend create: arbitrary stage, permitted.");
 716     is($illrq->status, "NEW", "Backend create: not-queued.");
 717
 718     # Test that enabling the unmediated workflow causes the backend's
 719     # 'unmediated_ill' method to be called
 720     t::lib::Mocks::mock_preference('ILLModuleUnmediated', '1');
 721     $backend->mock(
 722         'capabilities',
 723         sub {
 724             my ($self, $name) = @_;
 725             if ($name eq 'unmediated_ill') {
 726                 return sub {
 727                     return { unmediated_ill => 1 };
 728                 };
 729             }
 730         }
 731     );
 732     $illrq->status('NEW');
 733     is_deeply(
 734         $illrq->backend_create({test => 1}),
 735         {
 736             'opac_template' => '/tmp/Mock/opac-includes/.inc',
 737             'template' => '/tmp/Mock/intra-includes/.inc',
 738             'unmediated_ill' => 1
 739         },
 740         "Backend create: commit stage, permitted, ILLModuleUnmediated enabled."
 741     );
 742
 743     # Test that disabling the unmediated workflow causes the backend's
 744     # 'unmediated_ill' method to be NOT called
 745     t::lib::Mocks::mock_preference('ILLModuleUnmediated', '0');
 746     $illrq->status('NEW');
 747     is_deeply(
 748         $illrq->backend_create({test => 1}),
 749         {
 750             stage => 'commit', method => 'create', permitted => 1,
 751             template => "/tmp/Mock/intra-includes/create.inc",
 752             opac_template => "/tmp/Mock/opac-includes/create.inc",
 753         },
 754         "Backend create: commit stage, permitted, ILLModuleUnmediated disabled."
 755     );
 756
 757     # backend_renew
 758     $backend->set_series('renew', { stage => 'bar', method => 'renew' });
 759     is_deeply($illrq->backend_renew({test => 1}),
 760               {
 761                   stage => 'bar', method => 'renew',
 762                   template => "/tmp/Mock/intra-includes/renew.inc",
 763                   opac_template => "/tmp/Mock/opac-includes/renew.inc",
 764               },
 765               "Backend renew: arbitrary stage.");
 766
 767     # backend_cancel
 768     $backend->set_series('cancel', { stage => 'bar', method => 'cancel' });
 769     is_deeply($illrq->backend_cancel({test => 1}),
 770               {
 771                   stage => 'bar', method => 'cancel',
 772                   template => "/tmp/Mock/intra-includes/cancel.inc",
 773                   opac_template => "/tmp/Mock/opac-includes/cancel.inc",
 774               },
 775               "Backend cancel: arbitrary stage.");
 776
 777     # backend_update_status
 778     $backend->set_series('update_status', { stage => 'bar', method => 'update_status' });
 779     is_deeply($illrq->backend_update_status({test => 1}),
 780               {
 781                   stage => 'bar', method => 'update_status',
 782                   template => "/tmp/Mock/intra-includes/update_status.inc",
 783                   opac_template => "/tmp/Mock/opac-includes/update_status.inc",
 784               },
 785               "Backend update_status: arbitrary stage.");
 786
 787     # backend_confirm
 788     $backend->set_series('confirm', { stage => 'bar', method => 'confirm' });
 789     is_deeply($illrq->backend_confirm({test => 1}),
 790               {
 791                   stage => 'bar', method => 'confirm',
 792                   template => "/tmp/Mock/intra-includes/confirm.inc",
 793                   opac_template => "/tmp/Mock/opac-includes/confirm.inc",
 794               },
 795               "Backend confirm: arbitrary stage.");
 796
 797     $config->set_always('partner_code', "ILLTSTLIB");
 798     $backend->set_always('metadata', { Test => "Foobar" });
 799     my $illbrn = $builder->build({
 800         source => 'Branch',
 801         value => { branchemail => "", branchreplyto => "" }
 802     });
 803     my $partner1 = $builder->build({
 804         source => 'Borrower',
 805         value => { categorycode => "ILLTSTLIB" },
 806     });
 807     my $partner2 = $builder->build({
 808         source => 'Borrower',
 809         value => { categorycode => "ILLTSTLIB" },
 810     });
 811     my $gen_conf = $illrq->generic_confirm({
 812         current_branchcode => $illbrn->{branchcode}
 813     });
 814     isnt(index($gen_conf->{value}->{draft}->{body}, $backend->metadata->{Test}), -1,
 815          "Generic confirm: draft contains metadata."
 816     );
 817     is($gen_conf->{value}->{partners}->next->borrowernumber, $partner1->{borrowernumber},
 818        "Generic cofnirm: partner 1 is correct."
 819     );
 820     is($gen_conf->{value}->{partners}->next->borrowernumber, $partner2->{borrowernumber},
 821        "Generic confirm: partner 2 is correct."
 822     );
 823
 824     dies_ok { $illrq->generic_confirm({
 825         current_branchcode => $illbrn->{branchcode},
 826         stage => 'draft'
 827     }) }
 828         "Generic confirm: missing to dies OK.";
 829
 830     $schema->storage->txn_rollback;
 831 };
 832
 833
 834 subtest 'Helpers' => sub {
 835
 836     plan tests => 21;
 837
 838     $schema->storage->txn_begin;
 839
 840     # Build infrastructure
 841     my $backend = Test::MockObject->new;
 842     $backend->set_isa('Koha::Illbackends::Mock');
 843     $backend->set_always('name', 'Mock');
 844     $backend->mock(
 845         'metadata',
 846         sub {
 847             my ( $self, $rq ) = @_;
 848             return {
 849                 title => 'mytitle',
 850                 author => 'myauthor'
 851             }
 852         }
 853     );
 854
 855     my $config = Test::MockObject->new;
 856     $config->set_always('backend_dir', "/tmp");
 857
 858     my $patron = $builder->build({
 859         source => 'Borrower',
 860         value => { categorycode => "A" }
 861     });
 862     # Create a mocked branch with no email addressed defined
 863     my $illbrn = $builder->build({
 864         source => 'Branch',
 865         value => {
 866             branchcode => 'HDE',
 867             branchemail => "",
 868             branchillemail => "",
 869             branchreplyto => ""
 870         }
 871     });
 872     my $illrq = $builder->build({
 873         source => 'Illrequest',
 874         value => { branchcode => "HDE", borrowernumber => $patron->{borrowernumber} }
 875     });
 876     my $illrq_obj = Koha::Illrequests->find($illrq->{illrequest_id});
 877     $illrq_obj->_config($config);
 878     $illrq_obj->_backend($backend);
 879
 880     # getPrefix
 881     $config->set_series('getPrefixes',
 882                         { HDE => "TEST", TSL => "BAR", default => "DEFAULT" },
 883                         { A => "ATEST", C => "CBAR", default => "DEFAULT" });
 884     is($illrq_obj->getPrefix({ brw_cat => "UNKNOWN", branch => "HDE" }), "TEST",
 885        "getPrefix: branch");
 886     $config->set_series('getPrefixes',
 887                         { HDE => "TEST", TSL => "BAR", default => "DEFAULT" },
 888                         { A => "ATEST", C => "CBAR", default => "DEFAULT" });
 889     is($illrq_obj->getPrefix({ branch => "UNKNOWN" }), "",
 890        "getPrefix: default");
 891     $config->set_always('getPrefixes', {});
 892     is($illrq_obj->getPrefix({ branch => "UNKNOWN" }), "",
 893        "getPrefix: the empty prefix");
 894
 895     # id_prefix
 896     $config->set_series('getPrefixes',
 897                         { HDE => "TEST", TSL => "BAR", default => "DEFAULT" },
 898                         { AB => "ATEST", CD => "CBAR", default => "DEFAULT" });
 899     is($illrq_obj->id_prefix, "TEST-", "id_prefix: branch");
 900     $config->set_series('getPrefixes',
 901                         { HDET => "TEST", TSLT => "BAR", default => "DEFAULT" },
 902                         { AB => "ATEST", CD => "CBAR", default => "DEFAULT" });
 903     is($illrq_obj->id_prefix, "", "id_prefix: default");
 904
 905     # requires_moderation
 906     $illrq_obj->status('NEW')->store;
 907     is($illrq_obj->requires_moderation, undef, "requires_moderation: No.");
 908     $illrq_obj->status('CANCREQ')->store;
 909     is($illrq_obj->requires_moderation, 'CANCREQ', "requires_moderation: Yes.");
 910
 911     #send_patron_notice
 912     my $attr = Koha::MessageAttributes->find({ message_name => 'Ill_ready' });
 913     C4::Members::Messaging::SetMessagingPreference({
 914         borrowernumber => $patron->{borrowernumber},
 915         message_attribute_id => $attr->message_attribute_id,
 916         message_transport_types => ['email']
 917     });
 918     my $return_patron = $illrq_obj->send_patron_notice('ILL_PICKUP_READY');
 919     my $notice = $schema->resultset('MessageQueue')->search({
 920             letter_code => 'ILL_PICKUP_READY',
 921             message_transport_type => 'email',
 922             borrowernumber => $illrq_obj->borrowernumber
 923         })->next()->letter_code;
 924     is_deeply(
 925         $return_patron,
 926         { result => { success => ['email'], fail => [] } },
 927         "Correct return when notice created"
 928     );
 929     is($notice, 'ILL_PICKUP_READY' ,"Notice is correctly created");
 930
 931     my $return_patron_fail = $illrq_obj->send_patron_notice();
 932     is_deeply(
 933         $return_patron_fail,
 934         { error => 'notice_no_type' },
 935         "Correct error when missing type"
 936     );
 937
 938     #send_staff_notice
 939     # Specify that no staff notices should be send
 940     t::lib::Mocks::mock_preference('ILLSendStaffNotices', '');
 941     my $return_staff_cancel_fail =
 942         $illrq_obj->send_staff_notice('ILL_REQUEST_CANCEL');
 943     is_deeply(
 944         $return_staff_cancel_fail,
 945         { error => 'notice_not_enabled' },
 946         "Does not send notices that are not enabled"
 947     );
 948     my $queue = $schema->resultset('MessageQueue')->search({
 949             letter_code => 'ILL_REQUEST_CANCEL'
 950         });
 951     is($queue->count, 0, "Notice is not queued");
 952
 953     # Specify that the cancel notice can be sent
 954     t::lib::Mocks::mock_preference('ILLSendStaffNotices', 'ILL_REQUEST_CANCEL');
 955     my $return_staff_cancel = $illrq_obj->send_staff_notice(
 956         'ILL_REQUEST_CANCEL'
 957     );
 958     is_deeply(
 959         $return_staff_cancel,
 960         { success => 'notice_queued' },
 961         "Correct return when staff notice created"
 962     );
 963     $queue = $schema->resultset('MessageQueue')->search({
 964             letter_code => 'ILL_REQUEST_CANCEL'
 965         });
 966     is($queue->count, 1, "Notice queued as expected");
 967
 968     my $return_staff_fail = $illrq_obj->send_staff_notice();
 969     is_deeply(
 970         $return_staff_fail,
 971         { error => 'notice_no_type' },
 972         "Correct error when missing type"
 973     );
 974     $queue = $schema->resultset('MessageQueue')->search({
 975             letter_code => 'ILL_REQUEST_CANCEL'
 976         });
 977     is($queue->count, 1, "Notice is not queued");
 978
 979     #get_notice
 980     my $not = $illrq_obj->get_notice({
 981         notice_code => 'ILL_REQUEST_CANCEL',
 982         transport   => 'email'
 983     });
 984
 985     # We test the properties of the hashref separately because the random
 986     # hash ordering of the metadata means we can't test the entire thing
 987     # with is_deeply
 988     ok(
 989         $not->{module} eq 'ill',
 990         'Correct module return from get_notice'
 991     );
 992     ok(
 993         $not->{name} eq 'ILL request cancelled',
 994         'Correct name return from get_notice'
 995     );
 996     ok(
 997         $not->{message_transport_type} eq 'email',
 998         'Correct message_transport_type return from get_notice'
 999     );
1000     ok(
1001         $not->{title} eq 'Interlibrary loan request cancelled',
1002         'Correct title return from get_notice'
1003     );
1004     $not->{content} =~ s/\s//g;
1005
1006     is(
1007         $not->{content},"Thepatronforinterlibraryloansrequest" . $illrq_obj->id . ",withthefollowingdetails,hasrequestedcancellationofthisILLrequest:-author:myauthor-title:mytitle",
1008         'Correct content returned from get_notice with metadata correctly ordered'
1009     );
1010
1011     $schema->storage->txn_rollback;
1012 };
1013
1014
1015 subtest 'Censorship' => sub {
1016
1017     plan tests => 2;
1018
1019     $schema->storage->txn_begin;
1020
1021     # Build infrastructure
1022     my $backend = Test::MockObject->new;
1023     $backend->set_isa('Koha::Illbackends::Mock');
1024     $backend->set_always('name', 'Mock');
1025
1026     my $config = Test::MockObject->new;
1027     $config->set_always('backend_dir', "/tmp");
1028
1029     my $illrq = $builder->build({source => 'Illrequest'});
1030     my $illrq_obj = Koha::Illrequests->find($illrq->{illrequest_id});
1031     $illrq_obj->_config($config);
1032     $illrq_obj->_backend($backend);
1033
1034     $config->set_always('censorship', { censor_notes_staff => 1, censor_reply_date => 0 });
1035
1036     my $censor_out = $illrq_obj->_censor({ foo => 'bar', baz => 564 });
1037     is_deeply($censor_out, { foo => 'bar', baz => 564, display_reply_date => 1 },
1038               "_censor: not OPAC, reply_date = 1");
1039
1040     $censor_out = $illrq_obj->_censor({ foo => 'bar', baz => 564, opac => 1 });
1041     is_deeply($censor_out, {
1042         foo => 'bar', baz => 564, censor_notes_staff => 1,
1043         display_reply_date => 1, opac => 1
1044     }, "_censor: notes_staff = 0, reply_date = 0");
1045
1046     $schema->storage->txn_rollback;
1047 };
1048
1049 subtest 'Checking out' => sub {
1050
1051     plan tests => 17;
1052
1053     $schema->storage->txn_begin;
1054
1055     my $itemtype = $builder->build_object({
1056         class => 'Koha::ItemTypes',
1057         value => {
1058             notforloan => 1
1059         }
1060     });
1061     my $library = $builder->build_object({ class => 'Koha::Libraries' });
1062     my $biblio = $builder->build_sample_biblio();
1063     my $patron = $builder->build_object({
1064         class => 'Koha::Patrons',
1065         value => { category_type => 'x' }
1066     });
1067     my $request = $builder->build_object({
1068         class => 'Koha::Illrequests',
1069         value => {
1070             borrowernumber => $patron->borrowernumber,
1071             biblio_id      => $biblio->biblionumber
1072         }
1073     });
1074
1075     # First test that calling check_out without a stage param returns
1076     # what's required to build the form
1077     my $no_stage = $request->check_out();
1078     is($no_stage->{method}, 'check_out');
1079     is($no_stage->{stage}, 'form');
1080     isa_ok($no_stage->{value}, 'HASH');
1081     isa_ok($no_stage->{value}->{itemtypes}, 'Koha::ItemTypes');
1082     isa_ok($no_stage->{value}->{libraries}, 'Koha::Libraries');
1083     isa_ok($no_stage->{value}->{statistical}, 'Koha::Patrons');
1084     isa_ok($no_stage->{value}->{biblio}, 'Koha::Biblio');
1085
1086     # Now test that form validation works when we supply a 'form' stage
1087     #
1088     # No item_type
1089     my $form_stage_missing_params = $request->check_out({
1090         stage => 'form'
1091     });
1092     is_deeply($form_stage_missing_params->{value}->{errors}, {
1093         item_type => 1
1094     });
1095     # inhouse passed but not a valid patron
1096     my $form_stage_bad_patron = $request->check_out({
1097         stage     => 'form',
1098         item_type => $itemtype->itemtype,
1099         inhouse   => 'I_DONT_EXIST'
1100     });
1101     is_deeply($form_stage_bad_patron->{value}->{errors}, {
1102         inhouse => 1
1103     });
1104     # Too many items attached to biblio
1105     my $item1 = $builder->build_sample_item({ biblionumber => $biblio->biblionumber });
1106     my $item2 = $builder->build_sample_item({ biblionumber => $biblio->biblionumber });
1107     my $form_stage_two_items = $request->check_out({
1108         stage     => 'form',
1109         item_type => $itemtype->itemtype,
1110     });
1111     is_deeply($form_stage_two_items->{value}->{errors}, {
1112         itemcount => 1
1113     });
1114
1115     # Delete the items we created, so we can test that we can create one
1116     $item1->delete;
1117     $item2->delete;
1118
1119     # We need to mock the user environment for AddIssue
1120     t::lib::Mocks::mock_userenv({ branchcode => $library->branchcode });
1121     #
1122
1123     # First we pass bad parameters to the item creation to test we're
1124     # catching the failure of item creation
1125     my $form_stage_bad_branchcode;
1126     warning_like {
1127         $form_stage_bad_branchcode = $request->check_out({
1128             stage     => 'form',
1129             item_type => $itemtype->itemtype,
1130             branchcode => '---'
1131         });
1132     } qr/DBD::mysql::st execute failed: Cannot add or update a child row: a foreign key constraint fails/,
1133     "Item creation fails on bad parameters";
1134
1135     is_deeply($form_stage_bad_branchcode->{value}->{errors}, {
1136         item_creation => 1
1137     },"We get expected failure of item creation");
1138
1139     # Now create a proper item
1140     my $form_stage_good_branchcode = $request->check_out({
1141         stage      => 'form',
1142         item_type  => $itemtype->itemtype,
1143         branchcode => $library->branchcode
1144     });
1145     # By default, this item should not be loanable, so check that we're
1146     # informed of that fact
1147     is_deeply(
1148         $form_stage_good_branchcode->{value}->{check_out_errors},
1149         {
1150             error => {
1151                 NOT_FOR_LOAN => 1,
1152                 itemtype_notforloan => $itemtype->itemtype
1153             }
1154         },
1155         "We get expected error on notforloan of item"
1156     );
1157     # Delete the item that was created
1158     $biblio->items->delete;
1159     # Now create an itemtype that is loanable
1160     my $itemtype_loanable = $builder->build_object({
1161         class => 'Koha::ItemTypes',
1162         value => {
1163             notforloan => 0
1164         }
1165     });
1166     # We need to mock the user environment for AddIssue
1167     t::lib::Mocks::mock_userenv({ branchcode => $library->branchcode });
1168     my $form_stage_loanable = $request->check_out({
1169         stage      => 'form',
1170         item_type  => $itemtype_loanable->itemtype,
1171         branchcode => $library->branchcode
1172     });
1173     is($form_stage_loanable->{stage}, 'done_check_out');
1174     isa_ok($patron->checkouts, 'Koha::Checkouts');
1175     is($patron->checkouts->count, 1);
1176     is($request->status, 'CHK');
1177
1178     $schema->storage->txn_rollback;
1179 };
1180
1181 subtest 'Checking Limits' => sub {
1182
1183     plan tests => 30;
1184
1185     $schema->storage->txn_begin;
1186
1187     # Build infrastructure
1188     my $backend = Test::MockObject->new;
1189     $backend->set_isa('Koha::Illbackends::Mock');
1190     $backend->set_always('name', 'Mock');
1191
1192     my $config = Test::MockObject->new;
1193     $config->set_always('backend_dir', "/tmp");
1194
1195     my $illrq = $builder->build({source => 'Illrequest'});
1196     my $illrq_obj = Koha::Illrequests->find($illrq->{illrequest_id});
1197     $illrq_obj->_config($config);
1198     $illrq_obj->_backend($backend);
1199
1200     # getLimits
1201     $config->set_series('getLimitRules',
1202                         { CPL => { count => 1, method => 'test' } },
1203                         { default => { count => 0, method => 'active' } });
1204     is_deeply($illrq_obj->getLimits({ type => 'branch', value => "CPL" }),
1205               { count => 1, method => 'test' },
1206               "getLimits: by value.");
1207     is_deeply($illrq_obj->getLimits({ type => 'branch' }),
1208               { count => 0, method => 'active' },
1209               "getLimits: by default.");
1210     is_deeply($illrq_obj->getLimits({ type => 'branch', value => "CPL" }),
1211               { count => -1, method => 'active' },
1212               "getLimits: by hard-coded.");
1213
1214     #_limit_counter
1215     is($illrq_obj->_limit_counter('annual', { branchcode => $illrq_obj->branchcode }),
1216        1, "_limit_counter: Initial branch annual count.");
1217     is($illrq_obj->_limit_counter('active', { branchcode => $illrq_obj->branchcode }),
1218        1, "_limit_counter: Initial branch active count.");
1219     is($illrq_obj->_limit_counter('annual', { borrowernumber => $illrq_obj->borrowernumber }),
1220        1, "_limit_counter: Initial patron annual count.");
1221     is($illrq_obj->_limit_counter('active', { borrowernumber => $illrq_obj->borrowernumber }),
1222        1, "_limit_counter: Initial patron active count.");
1223     $builder->build({
1224         source => 'Illrequest',
1225         value => {
1226             branchcode => $illrq_obj->branchcode,
1227             borrowernumber => $illrq_obj->borrowernumber,
1228         }
1229     });
1230     is($illrq_obj->_limit_counter('annual', { branchcode => $illrq_obj->branchcode }),
1231        2, "_limit_counter: Add a qualifying request for branch annual count.");
1232     is($illrq_obj->_limit_counter('active', { branchcode => $illrq_obj->branchcode }),
1233        2, "_limit_counter: Add a qualifying request for branch active count.");
1234     is($illrq_obj->_limit_counter('annual', { borrowernumber => $illrq_obj->borrowernumber }),
1235        2, "_limit_counter: Add a qualifying request for patron annual count.");
1236     is($illrq_obj->_limit_counter('active', { borrowernumber => $illrq_obj->borrowernumber }),
1237        2, "_limit_counter: Add a qualifying request for patron active count.");
1238     $builder->build({
1239         source => 'Illrequest',
1240         value => {
1241             branchcode => $illrq_obj->branchcode,
1242             borrowernumber => $illrq_obj->borrowernumber,
1243             placed => "2005-05-31",
1244         }
1245     });
1246     is($illrq_obj->_limit_counter('annual', { branchcode => $illrq_obj->branchcode }),
1247        2, "_limit_counter: Add an out-of-date branch request.");
1248     is($illrq_obj->_limit_counter('active', { branchcode => $illrq_obj->branchcode }),
1249        3, "_limit_counter: Add a qualifying request for branch active count.");
1250     is($illrq_obj->_limit_counter('annual', { borrowernumber => $illrq_obj->borrowernumber }),
1251        2, "_limit_counter: Add an out-of-date patron request.");
1252     is($illrq_obj->_limit_counter('active', { borrowernumber => $illrq_obj->borrowernumber }),
1253        3, "_limit_counter: Add a qualifying request for patron active count.");
1254     $builder->build({
1255         source => 'Illrequest',
1256         value => {
1257             branchcode => $illrq_obj->branchcode,
1258             borrowernumber => $illrq_obj->borrowernumber,
1259             status => "COMP",
1260         }
1261     });
1262     is($illrq_obj->_limit_counter('annual', { branchcode => $illrq_obj->branchcode }),
1263        3, "_limit_counter: Add a qualifying request for branch annual count.");
1264     is($illrq_obj->_limit_counter('active', { branchcode => $illrq_obj->branchcode }),
1265        3, "_limit_counter: Add a completed request for branch active count.");
1266     is($illrq_obj->_limit_counter('annual', { borrowernumber => $illrq_obj->borrowernumber }),
1267        3, "_limit_counter: Add a qualifying request for patron annual count.");
1268     is($illrq_obj->_limit_counter('active', { borrowernumber => $illrq_obj->borrowernumber }),
1269        3, "_limit_counter: Add a completed request for patron active count.");
1270
1271     # check_limits:
1272
1273     # We've tested _limit_counter, so all we need to test here is whether the
1274     # current counts of 3 for each work as they should against different
1275     # configuration declarations.
1276
1277     # No limits
1278     $config->set_always('getLimitRules', undef);
1279     is($illrq_obj->check_limits({patron => $illrq_obj->patron,
1280                                  librarycode => $illrq_obj->branchcode}),
1281        1, "check_limits: no configuration => no limits.");
1282
1283     # Branch tests
1284     $config->set_always('getLimitRules',
1285                         { $illrq_obj->branchcode => { count => 1, method => 'active' } });
1286     is($illrq_obj->check_limits({patron => $illrq_obj->patron,
1287                                  librarycode => $illrq_obj->branchcode}),
1288        0, "check_limits: branch active limit exceeded.");
1289     $config->set_always('getLimitRules',
1290                         { $illrq_obj->branchcode => { count => 1, method => 'annual' } });
1291     is($illrq_obj->check_limits({patron => $illrq_obj->patron,
1292                                  librarycode => $illrq_obj->branchcode}),
1293        0, "check_limits: branch annual limit exceeded.");
1294     $config->set_always('getLimitRules',
1295                         { $illrq_obj->branchcode => { count => 4, method => 'active' } });
1296     is($illrq_obj->check_limits({patron => $illrq_obj->patron,
1297                                  librarycode => $illrq_obj->branchcode}),
1298        1, "check_limits: branch active limit OK.");
1299     $config->set_always('getLimitRules',
1300                         { $illrq_obj->branchcode => { count => 4, method => 'annual' } });
1301     is($illrq_obj->check_limits({patron => $illrq_obj->patron,
1302                                  librarycode => $illrq_obj->branchcode}),
1303        1, "check_limits: branch annual limit OK.");
1304
1305     # Patron tests
1306     $config->set_always('getLimitRules',
1307                         { $illrq_obj->patron->categorycode => { count => 1, method => 'active' } });
1308     is($illrq_obj->check_limits({patron => $illrq_obj->patron,
1309                                  librarycode => $illrq_obj->branchcode}),
1310        0, "check_limits: patron category active limit exceeded.");
1311     $config->set_always('getLimitRules',
1312                         { $illrq_obj->patron->categorycode => { count => 1, method => 'annual' } });
1313     is($illrq_obj->check_limits({patron => $illrq_obj->patron,
1314                                  librarycode => $illrq_obj->branchcode}),
1315        0, "check_limits: patron category annual limit exceeded.");
1316     $config->set_always('getLimitRules',
1317                         { $illrq_obj->patron->categorycode => { count => 4, method => 'active' } });
1318     is($illrq_obj->check_limits({patron => $illrq_obj->patron,
1319                                  librarycode => $illrq_obj->branchcode}),
1320        1, "check_limits: patron category active limit OK.");
1321     $config->set_always('getLimitRules',
1322                         { $illrq_obj->patron->categorycode => { count => 4, method => 'annual' } });
1323     is($illrq_obj->check_limits({patron => $illrq_obj->patron,
1324                                  librarycode => $illrq_obj->branchcode}),
1325        1, "check_limits: patron category annual limit OK.");
1326
1327     # One rule cancels the other
1328     $config->set_series('getLimitRules',
1329                         # Branch rules allow request
1330                         { $illrq_obj->branchcode => { count => 4, method => 'active' } },
1331                         # Patron rule forbids it
1332                         { $illrq_obj->patron->categorycode => { count => 1, method => 'annual' } });
1333     is($illrq_obj->check_limits({patron => $illrq_obj->patron,
1334                                  librarycode => $illrq_obj->branchcode}),
1335        0, "check_limits: patron category veto overrides branch OK.");
1336     $config->set_series('getLimitRules',
1337                         # Branch rules allow request
1338                         { $illrq_obj->branchcode => { count => 1, method => 'active' } },
1339                         # Patron rule forbids it
1340                         { $illrq_obj->patron->categorycode => { count => 4, method => 'annual' } });
1341     is($illrq_obj->check_limits({patron => $illrq_obj->patron,
1342                                  librarycode => $illrq_obj->branchcode}),
1343        0, "check_limits: branch veto overrides patron category OK.");
1344
1345     $schema->storage->txn_rollback;
1346 };
1347
1348 subtest 'Custom statuses' => sub {
1349
1350     plan tests => 3;
1351
1352     $schema->storage->txn_begin;
1353
1354     my $cat = Koha::AuthorisedValueCategories->search(
1355         {
1356             category_name => 'ILLSTATUS'
1357         }
1358     );
1359
1360     if ($cat->count == 0) {
1361         $cat  = $builder->build_object(
1362             {
1363                 class => 'Koha::AuthorisedValueCategory',
1364                 value => {
1365                     category_name => 'ILLSTATUS'
1366                 }
1367             }
1368         );
1369     };
1370
1371     my $av = $builder->build_object(
1372         {
1373             class => 'Koha::AuthorisedValues',
1374             value => {
1375                 category => 'ILLSTATUS'
1376             }
1377         }
1378     );
1379
1380     is($av->category, 'ILLSTATUS',
1381        "Successfully created authorised value for custom status");
1382
1383     my $ill_req = $builder->build_object(
1384         {
1385             class => 'Koha::Illrequests',
1386             value => {
1387                 status_alias => $av->authorised_value
1388             }
1389         }
1390     );
1391     isa_ok($ill_req->statusalias, 'Koha::AuthorisedValue',
1392            "statusalias correctly returning Koha::AuthorisedValue object");
1393
1394     $ill_req->status("COMP");
1395     is($ill_req->statusalias, undef,
1396         "Koha::Illrequest->status overloading resetting status_alias");
1397
1398     $schema->storage->txn_rollback;
1399 };
1400
1401 subtest 'Checking in hook' => sub {
1402
1403     plan tests => 2;
1404
1405     $schema->storage->txn_begin;
1406
1407     # Build infrastructure
1408     my $backend = Test::MockObject->new;
1409     $backend->set_isa('Koha::Illbackends::Mock');
1410     $backend->set_always('name', 'Mock');
1411
1412     my $config = Test::MockObject->new;
1413     $config->set_always('backend_dir', "/tmp");
1414
1415     my $item   = $builder->build_sample_item();
1416     my $patron = $builder->build_object({ class => 'Koha::Patrons' });
1417
1418     t::lib::Mocks::mock_userenv(
1419         {
1420             patron     => $patron,
1421             branchcode => $patron->branchcode
1422         }
1423     );
1424
1425     my $illrq = $builder->build_object(
1426         {
1427             class => 'Koha::Illrequests',
1428             value => {
1429                 biblio_id => $item->biblio->biblionumber,
1430                 status    => 'NEW'
1431             }
1432         }
1433     );
1434
1435     $illrq->_config($config);
1436     $illrq->_backend($backend);
1437
1438     t::lib::Mocks::mock_preference('CirculateILL', 1);
1439
1440     # Add an issue
1441     AddIssue( $patron->unblessed, $item->barcode );
1442     # Make the item withdrawn so checking-in is rejected
1443     t::lib::Mocks::mock_preference('BlockReturnOfWithdrawnItems', 1);
1444     $item->set({ withdrawn => 1 })->store;
1445     AddReturn( $item->barcode, $patron->branchcode );
1446     # refresh request
1447     $illrq->discard_changes;
1448     isnt( $illrq->status, 'RET' );
1449
1450     # allow the check-in
1451     $item->set({ withdrawn => 0 })->store;
1452     AddReturn( $item->barcode, $patron->branchcode );
1453     # refresh request
1454     $illrq->discard_changes;
1455     is( $illrq->status, 'RET' );
1456
1457     $schema->storage->txn_rollback;
1458 };