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 => 14;
  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 => 20;
 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_illview
 778     $backend->set_series('illview', { stage => '', method => 'illview' });
 779     is_deeply($illrq->backend_illview({test => 1}), 0,
 780               "Backend illview optional method.");
 781
 782     # backend_update_status
 783     $backend->set_series('update_status', { stage => 'bar', method => 'update_status' });
 784     is_deeply($illrq->backend_update_status({test => 1}),
 785               {
 786                   stage => 'bar', method => 'update_status',
 787                   template => "/tmp/Mock/intra-includes/update_status.inc",
 788                   opac_template => "/tmp/Mock/opac-includes/update_status.inc",
 789               },
 790               "Backend update_status: arbitrary stage.");
 791
 792     # backend_confirm
 793     $backend->set_series('confirm', { stage => 'bar', method => 'confirm' });
 794     is_deeply($illrq->backend_confirm({test => 1}),
 795               {
 796                   stage => 'bar', method => 'confirm',
 797                   template => "/tmp/Mock/intra-includes/confirm.inc",
 798                   opac_template => "/tmp/Mock/opac-includes/confirm.inc",
 799               },
 800               "Backend confirm: arbitrary stage.");
 801
 802     # backend_get_update
 803     $backend->mock(
 804         'get_supplier_update',
 805         sub {
 806             my ( $self, $options ) = @_;
 807             return $options;
 808         }
 809     );
 810     $backend->mock('capabilities', sub { return sub { return 1; } });
 811     is_deeply($illrq->backend_get_update({}), 1,
 812               "Backend get_update method.");
 813
 814     $config->set_always('partner_code', "ILLTSTLIB");
 815     $backend->set_always('metadata', { Test => "Foobar" });
 816     my $illbrn = $builder->build({
 817         source => 'Branch',
 818         value => { branchemail => "", branchreplyto => "" }
 819     });
 820     my $partner1 = $builder->build({
 821         source => 'Borrower',
 822         value => { categorycode => "ILLTSTLIB" },
 823     });
 824     my $partner2 = $builder->build({
 825         source => 'Borrower',
 826         value => { categorycode => "ILLTSTLIB" },
 827     });
 828     my $gen_conf = $illrq->generic_confirm({
 829         current_branchcode => $illbrn->{branchcode}
 830     });
 831     isnt(index($gen_conf->{value}->{draft}->{body}, $backend->metadata->{Test}), -1,
 832          "Generic confirm: draft contains metadata."
 833     );
 834     is($gen_conf->{value}->{partners}->next->borrowernumber, $partner1->{borrowernumber},
 835        "Generic cofnirm: partner 1 is correct."
 836     );
 837     is($gen_conf->{value}->{partners}->next->borrowernumber, $partner2->{borrowernumber},
 838        "Generic confirm: partner 2 is correct."
 839     );
 840
 841     dies_ok { $illrq->generic_confirm({
 842         current_branchcode => $illbrn->{branchcode},
 843         stage => 'draft'
 844     }) }
 845         "Generic confirm: missing to dies OK.";
 846
 847     $schema->storage->txn_rollback;
 848 };
 849
 850
 851 subtest 'Helpers' => sub {
 852
 853     plan tests => 25;
 854
 855     $schema->storage->txn_begin;
 856
 857     # Build infrastructure
 858     my $backend = Test::MockObject->new;
 859     $backend->set_isa('Koha::Illbackends::Mock');
 860     $backend->set_always('name', 'Mock');
 861     $backend->mock(
 862         'metadata',
 863         sub {
 864             my ( $self, $rq ) = @_;
 865             return {
 866                 title => 'mytitle',
 867                 author => 'myauthor'
 868             }
 869         }
 870     );
 871
 872     my $config = Test::MockObject->new;
 873     $config->set_always('backend_dir', "/tmp");
 874
 875     my $patron = $builder->build({
 876         source => 'Borrower',
 877         value => { categorycode => "A" }
 878     });
 879     # Create a mocked branch with no email addressed defined
 880     my $illbrn = $builder->build({
 881         source => 'Branch',
 882         value => {
 883             branchcode => 'HDE',
 884             branchemail => "",
 885             branchillemail => "",
 886             branchreplyto => ""
 887         }
 888     });
 889     my $illrq = $builder->build({
 890         source => 'Illrequest',
 891         value => { branchcode => "HDE", borrowernumber => $patron->{borrowernumber} }
 892     });
 893     my $illrq_obj = Koha::Illrequests->find($illrq->{illrequest_id});
 894     $illrq_obj->_config($config);
 895     $illrq_obj->_backend($backend);
 896
 897     #attach_processors
 898     my $type = 'test_type_1';
 899     my $name = 'test_name_1';
 900     my $update = Test::MockObject->new;
 901     $update->set_isa('Koha::Illrequest::SupplierUpdate');
 902     $update->{source_type} = $type;
 903     $update->{source_name} = $name;
 904     $update->{processors} = [];
 905     $update->mock('attach_processor', sub {
 906         my ( $self, $to_attach ) = @_;
 907         push @{$self->{processors}}, $to_attach;
 908     });
 909     my $processor = Test::MockObject->new;
 910     $processor->{target_source_type} = $type;
 911     $processor->{target_source_name} = $name;
 912     $illrq_obj->init_processors();
 913     $illrq_obj->push_processor($processor);
 914     $illrq_obj->attach_processors($update);
 915     is_deeply(
 916         scalar @{$update->{processors}},
 917         1,
 918         'attaching processors as appropriate works'
 919     );
 920
 921     # getPrefix
 922     $config->set_series('getPrefixes',
 923                         { HDE => "TEST", TSL => "BAR", default => "DEFAULT" },
 924                         { A => "ATEST", C => "CBAR", default => "DEFAULT" });
 925     is($illrq_obj->getPrefix({ brw_cat => "UNKNOWN", branch => "HDE" }), "TEST",
 926        "getPrefix: branch");
 927     $config->set_series('getPrefixes',
 928                         { HDE => "TEST", TSL => "BAR", default => "DEFAULT" },
 929                         { A => "ATEST", C => "CBAR", default => "DEFAULT" });
 930     is($illrq_obj->getPrefix({ branch => "UNKNOWN" }), "",
 931        "getPrefix: default");
 932     $config->set_always('getPrefixes', {});
 933     is($illrq_obj->getPrefix({ branch => "UNKNOWN" }), "",
 934        "getPrefix: the empty prefix");
 935
 936     # id_prefix
 937     $config->set_series('getPrefixes',
 938                         { HDE => "TEST", TSL => "BAR", default => "DEFAULT" },
 939                         { AB => "ATEST", CD => "CBAR", default => "DEFAULT" });
 940     is($illrq_obj->id_prefix, "TEST-", "id_prefix: branch");
 941     $config->set_series('getPrefixes',
 942                         { HDET => "TEST", TSLT => "BAR", default => "DEFAULT" },
 943                         { AB => "ATEST", CD => "CBAR", default => "DEFAULT" });
 944     is($illrq_obj->id_prefix, "", "id_prefix: default");
 945
 946     # requires_moderation
 947     $illrq_obj->status('NEW')->store;
 948     is($illrq_obj->requires_moderation, undef, "requires_moderation: No.");
 949     $illrq_obj->status('CANCREQ')->store;
 950     is($illrq_obj->requires_moderation, 'CANCREQ', "requires_moderation: Yes.");
 951
 952     #send_patron_notice
 953     my $attr = Koha::MessageAttributes->find({ message_name => 'Ill_ready' });
 954     C4::Members::Messaging::SetMessagingPreference({
 955         borrowernumber => $patron->{borrowernumber},
 956         message_attribute_id => $attr->message_attribute_id,
 957         message_transport_types => ['email']
 958     });
 959     my $return_patron = $illrq_obj->send_patron_notice('ILL_PICKUP_READY');
 960     my $notice = $schema->resultset('MessageQueue')->search({
 961             letter_code => 'ILL_PICKUP_READY',
 962             message_transport_type => 'email',
 963             borrowernumber => $illrq_obj->borrowernumber
 964         })->next()->letter_code;
 965     is_deeply(
 966         $return_patron,
 967         { result => { success => ['email'], fail => [] } },
 968         "Correct return when notice created"
 969     );
 970     is($notice, 'ILL_PICKUP_READY' ,"Notice is correctly created");
 971
 972     # ill update notice, passes additional text parameter
 973     my $attr_update = Koha::MessageAttributes->find({ message_name => 'Ill_update' });
 974     C4::Members::Messaging::SetMessagingPreference({
 975         borrowernumber => $patron->{borrowernumber},
 976         message_attribute_id => $attr_update->message_attribute_id,
 977         message_transport_types => ['email']
 978     });
 979     my $return_patron_update = $illrq_obj->send_patron_notice('ILL_REQUEST_UPDATE', 'Some additional text');
 980     my $notice_update = $schema->resultset('MessageQueue')->search({
 981             letter_code => 'ILL_REQUEST_UPDATE',
 982             message_transport_type => 'email',
 983             borrowernumber => $illrq_obj->borrowernumber
 984         })->next()->letter_code;
 985     is_deeply(
 986         $return_patron_update,
 987         { result => { success => ['email'], fail => [] } },
 988         "Correct return when notice created"
 989     );
 990     is($notice_update, 'ILL_REQUEST_UPDATE' ,"Notice is correctly created");
 991
 992
 993     my $return_patron_fail = $illrq_obj->send_patron_notice();
 994     is_deeply(
 995         $return_patron_fail,
 996         { error => 'notice_no_type' },
 997         "Correct error when missing type"
 998     );
 999
1000     #send_staff_notice
1001     # Specify that no staff notices should be send
1002     t::lib::Mocks::mock_preference('ILLSendStaffNotices', '');
1003     my $return_staff_cancel_fail =
1004         $illrq_obj->send_staff_notice('ILL_REQUEST_CANCEL');
1005     is_deeply(
1006         $return_staff_cancel_fail,
1007         { error => 'notice_not_enabled' },
1008         "Does not send notices that are not enabled"
1009     );
1010     my $queue = $schema->resultset('MessageQueue')->search({
1011             letter_code => 'ILL_REQUEST_CANCEL'
1012         });
1013     is($queue->count, 0, "Notice is not queued");
1014
1015     # Specify that the cancel notice can be sent
1016     t::lib::Mocks::mock_preference('ILLSendStaffNotices', 'ILL_REQUEST_CANCEL');
1017     my $return_staff_cancel = $illrq_obj->send_staff_notice(
1018         'ILL_REQUEST_CANCEL'
1019     );
1020     is_deeply(
1021         $return_staff_cancel,
1022         { success => 'notice_queued' },
1023         "Correct return when staff notice created"
1024     );
1025     $queue = $schema->resultset('MessageQueue')->search({
1026             letter_code => 'ILL_REQUEST_CANCEL'
1027         });
1028     is($queue->count, 1, "Notice queued as expected");
1029
1030     my $return_staff_fail = $illrq_obj->send_staff_notice();
1031     is_deeply(
1032         $return_staff_fail,
1033         { error => 'notice_no_type' },
1034         "Correct error when missing type"
1035     );
1036     $queue = $schema->resultset('MessageQueue')->search({
1037             letter_code => 'ILL_REQUEST_CANCEL'
1038         });
1039     is($queue->count, 1, "Notice is not queued");
1040
1041     #get_notice
1042     my $not = $illrq_obj->get_notice({
1043         notice_code => 'ILL_REQUEST_CANCEL',
1044         transport   => 'email'
1045     });
1046
1047     # We test the properties of the hashref separately because the random
1048     # hash ordering of the metadata means we can't test the entire thing
1049     # with is_deeply
1050     ok(
1051         $not->{module} eq 'ill',
1052         'Correct module return from get_notice'
1053     );
1054     ok(
1055         $not->{name} eq 'ILL request cancelled',
1056         'Correct name return from get_notice'
1057     );
1058     ok(
1059         $not->{message_transport_type} eq 'email',
1060         'Correct message_transport_type return from get_notice'
1061     );
1062     ok(
1063         $not->{title} eq 'Interlibrary loan request cancelled',
1064         'Correct title return from get_notice'
1065     );
1066     $not->{content} =~ s/\s//g;
1067
1068     is(
1069         $not->{content},"Thepatronforinterlibraryloansrequest" . $illrq_obj->id . ",withthefollowingdetails,hasrequestedcancellationofthisILLrequest:-author:myauthor-title:mytitle",
1070         'Correct content returned from get_notice with metadata correctly ordered'
1071     );
1072
1073     $illrq_obj->append_to_note('Some text');
1074     like(
1075         $illrq_obj->notesstaff,
1076         qr/Some text$/,
1077         'appending to a note works'
1078     );
1079
1080     $schema->storage->txn_rollback;
1081 };
1082
1083
1084 subtest 'Censorship' => sub {
1085
1086     plan tests => 2;
1087
1088     $schema->storage->txn_begin;
1089
1090     # Build infrastructure
1091     my $backend = Test::MockObject->new;
1092     $backend->set_isa('Koha::Illbackends::Mock');
1093     $backend->set_always('name', 'Mock');
1094
1095     my $config = Test::MockObject->new;
1096     $config->set_always('backend_dir', "/tmp");
1097
1098     my $illrq = $builder->build({source => 'Illrequest'});
1099     my $illrq_obj = Koha::Illrequests->find($illrq->{illrequest_id});
1100     $illrq_obj->_config($config);
1101     $illrq_obj->_backend($backend);
1102
1103     $config->set_always('censorship', { censor_notes_staff => 1, censor_reply_date => 0 });
1104
1105     my $censor_out = $illrq_obj->_censor({ foo => 'bar', baz => 564 });
1106     is_deeply($censor_out, { foo => 'bar', baz => 564, display_reply_date => 1 },
1107               "_censor: not OPAC, reply_date = 1");
1108
1109     $censor_out = $illrq_obj->_censor({ foo => 'bar', baz => 564, opac => 1 });
1110     is_deeply($censor_out, {
1111         foo => 'bar', baz => 564, censor_notes_staff => 1,
1112         display_reply_date => 1, opac => 1
1113     }, "_censor: notes_staff = 0, reply_date = 0");
1114
1115     $schema->storage->txn_rollback;
1116 };
1117
1118 subtest 'Checking out' => sub {
1119
1120     plan tests => 17;
1121
1122     $schema->storage->txn_begin;
1123
1124     my $itemtype = $builder->build_object({
1125         class => 'Koha::ItemTypes',
1126         value => {
1127             notforloan => 1
1128         }
1129     });
1130     my $library = $builder->build_object({ class => 'Koha::Libraries' });
1131     my $biblio = $builder->build_sample_biblio();
1132     my $patron = $builder->build_object({
1133         class => 'Koha::Patrons',
1134         value => { category_type => 'x' }
1135     });
1136     my $request = $builder->build_object({
1137         class => 'Koha::Illrequests',
1138         value => {
1139             borrowernumber => $patron->borrowernumber,
1140             biblio_id      => $biblio->biblionumber
1141         }
1142     });
1143
1144     # First test that calling check_out without a stage param returns
1145     # what's required to build the form
1146     my $no_stage = $request->check_out();
1147     is($no_stage->{method}, 'check_out');
1148     is($no_stage->{stage}, 'form');
1149     isa_ok($no_stage->{value}, 'HASH');
1150     isa_ok($no_stage->{value}->{itemtypes}, 'Koha::ItemTypes');
1151     isa_ok($no_stage->{value}->{libraries}, 'Koha::Libraries');
1152     isa_ok($no_stage->{value}->{statistical}, 'Koha::Patrons');
1153     isa_ok($no_stage->{value}->{biblio}, 'Koha::Biblio');
1154
1155     # Now test that form validation works when we supply a 'form' stage
1156     #
1157     # No item_type
1158     my $form_stage_missing_params = $request->check_out({
1159         stage => 'form'
1160     });
1161     is_deeply($form_stage_missing_params->{value}->{errors}, {
1162         item_type => 1
1163     });
1164     # inhouse passed but not a valid patron
1165     my $form_stage_bad_patron = $request->check_out({
1166         stage     => 'form',
1167         item_type => $itemtype->itemtype,
1168         inhouse   => 'I_DONT_EXIST'
1169     });
1170     is_deeply($form_stage_bad_patron->{value}->{errors}, {
1171         inhouse => 1
1172     });
1173     # Too many items attached to biblio
1174     my $item1 = $builder->build_sample_item({ biblionumber => $biblio->biblionumber });
1175     my $item2 = $builder->build_sample_item({ biblionumber => $biblio->biblionumber });
1176     my $form_stage_two_items = $request->check_out({
1177         stage     => 'form',
1178         item_type => $itemtype->itemtype,
1179     });
1180     is_deeply($form_stage_two_items->{value}->{errors}, {
1181         itemcount => 1
1182     });
1183
1184     # Delete the items we created, so we can test that we can create one
1185     $item1->delete;
1186     $item2->delete;
1187
1188     # We need to mock the user environment for AddIssue
1189     t::lib::Mocks::mock_userenv({ branchcode => $library->branchcode });
1190     #
1191
1192     # First we pass bad parameters to the item creation to test we're
1193     # catching the failure of item creation
1194     my $form_stage_bad_branchcode;
1195     warning_like {
1196         $form_stage_bad_branchcode = $request->check_out({
1197             stage     => 'form',
1198             item_type => $itemtype->itemtype,
1199             branchcode => '---'
1200         });
1201     } qr/DBD::mysql::st execute failed: Cannot add or update a child row: a foreign key constraint fails/,
1202     "Item creation fails on bad parameters";
1203
1204     is_deeply($form_stage_bad_branchcode->{value}->{errors}, {
1205         item_creation => 1
1206     },"We get expected failure of item creation");
1207
1208     # Now create a proper item
1209     my $form_stage_good_branchcode = $request->check_out({
1210         stage      => 'form',
1211         item_type  => $itemtype->itemtype,
1212         branchcode => $library->branchcode
1213     });
1214     # By default, this item should not be loanable, so check that we're
1215     # informed of that fact
1216     is_deeply(
1217         $form_stage_good_branchcode->{value}->{check_out_errors},
1218         {
1219             error => {
1220                 NOT_FOR_LOAN => 1,
1221                 itemtype_notforloan => $itemtype->itemtype
1222             }
1223         },
1224         "We get expected error on notforloan of item"
1225     );
1226     # Delete the item that was created
1227     $biblio->items->delete;
1228     # Now create an itemtype that is loanable
1229     my $itemtype_loanable = $builder->build_object({
1230         class => 'Koha::ItemTypes',
1231         value => {
1232             notforloan => 0
1233         }
1234     });
1235     # We need to mock the user environment for AddIssue
1236     t::lib::Mocks::mock_userenv({ branchcode => $library->branchcode });
1237     my $form_stage_loanable = $request->check_out({
1238         stage      => 'form',
1239         item_type  => $itemtype_loanable->itemtype,
1240         branchcode => $library->branchcode
1241     });
1242     is($form_stage_loanable->{stage}, 'done_check_out');
1243     isa_ok($patron->checkouts, 'Koha::Checkouts');
1244     is($patron->checkouts->count, 1);
1245     is($request->status, 'CHK');
1246
1247     $schema->storage->txn_rollback;
1248 };
1249
1250 subtest 'Checking out with custom due date' => sub {
1251     plan tests => 1;
1252     $schema->storage->txn_begin;
1253
1254     my $library = $builder->build_object({ class => 'Koha::Libraries' });
1255     my $patron = $builder->build_object({
1256         class => 'Koha::Patrons',
1257         value => { category_type => 'x' }
1258     });
1259     my $biblio = $builder->build_sample_biblio();
1260     my $itemtype_loanable = $builder->build_object({
1261         class => 'Koha::ItemTypes',
1262         value => {
1263             notforloan => 0
1264         }
1265     });
1266     my $request = $builder->build_object({
1267         class => 'Koha::Illrequests',
1268         value => {
1269             borrowernumber => $patron->borrowernumber,
1270             biblio_id      => $biblio->biblionumber
1271         }
1272     });
1273
1274     t::lib::Mocks::mock_userenv({ branchcode => $library->branchcode });
1275     my $duedate = '2099-05-21 00:00:00';
1276     my $form_stage_loanable = $request->check_out({
1277         stage      => 'form',
1278         item_type  => $itemtype_loanable->itemtype,
1279         branchcode => $library->branchcode,
1280         duedate    => $duedate
1281     });
1282     is($patron->checkouts->next->date_due, $duedate, "Custom due date was used");
1283
1284     $schema->storage->txn_rollback;
1285 };
1286
1287 subtest 'Checking Limits' => sub {
1288
1289     plan tests => 30;
1290
1291     $schema->storage->txn_begin;
1292
1293     # Build infrastructure
1294     my $backend = Test::MockObject->new;
1295     $backend->set_isa('Koha::Illbackends::Mock');
1296     $backend->set_always('name', 'Mock');
1297
1298     my $config = Test::MockObject->new;
1299     $config->set_always('backend_dir', "/tmp");
1300
1301     my $illrq = $builder->build({source => 'Illrequest'});
1302     my $illrq_obj = Koha::Illrequests->find($illrq->{illrequest_id});
1303     $illrq_obj->_config($config);
1304     $illrq_obj->_backend($backend);
1305
1306     # getLimits
1307     $config->set_series('getLimitRules',
1308                         { CPL => { count => 1, method => 'test' } },
1309                         { default => { count => 0, method => 'active' } });
1310     is_deeply($illrq_obj->getLimits({ type => 'branch', value => "CPL" }),
1311               { count => 1, method => 'test' },
1312               "getLimits: by value.");
1313     is_deeply($illrq_obj->getLimits({ type => 'branch' }),
1314               { count => 0, method => 'active' },
1315               "getLimits: by default.");
1316     is_deeply($illrq_obj->getLimits({ type => 'branch', value => "CPL" }),
1317               { count => -1, method => 'active' },
1318               "getLimits: by hard-coded.");
1319
1320     #_limit_counter
1321     is($illrq_obj->_limit_counter('annual', { branchcode => $illrq_obj->branchcode }),
1322        1, "_limit_counter: Initial branch annual count.");
1323     is($illrq_obj->_limit_counter('active', { branchcode => $illrq_obj->branchcode }),
1324        1, "_limit_counter: Initial branch active count.");
1325     is($illrq_obj->_limit_counter('annual', { borrowernumber => $illrq_obj->borrowernumber }),
1326        1, "_limit_counter: Initial patron annual count.");
1327     is($illrq_obj->_limit_counter('active', { borrowernumber => $illrq_obj->borrowernumber }),
1328        1, "_limit_counter: Initial patron active count.");
1329     $builder->build({
1330         source => 'Illrequest',
1331         value => {
1332             branchcode => $illrq_obj->branchcode,
1333             borrowernumber => $illrq_obj->borrowernumber,
1334         }
1335     });
1336     is($illrq_obj->_limit_counter('annual', { branchcode => $illrq_obj->branchcode }),
1337        2, "_limit_counter: Add a qualifying request for branch annual count.");
1338     is($illrq_obj->_limit_counter('active', { branchcode => $illrq_obj->branchcode }),
1339        2, "_limit_counter: Add a qualifying request for branch active count.");
1340     is($illrq_obj->_limit_counter('annual', { borrowernumber => $illrq_obj->borrowernumber }),
1341        2, "_limit_counter: Add a qualifying request for patron annual count.");
1342     is($illrq_obj->_limit_counter('active', { borrowernumber => $illrq_obj->borrowernumber }),
1343        2, "_limit_counter: Add a qualifying request for patron active count.");
1344     $builder->build({
1345         source => 'Illrequest',
1346         value => {
1347             branchcode => $illrq_obj->branchcode,
1348             borrowernumber => $illrq_obj->borrowernumber,
1349             placed => "2005-05-31",
1350         }
1351     });
1352     is($illrq_obj->_limit_counter('annual', { branchcode => $illrq_obj->branchcode }),
1353        2, "_limit_counter: Add an out-of-date branch request.");
1354     is($illrq_obj->_limit_counter('active', { branchcode => $illrq_obj->branchcode }),
1355        3, "_limit_counter: Add a qualifying request for branch active count.");
1356     is($illrq_obj->_limit_counter('annual', { borrowernumber => $illrq_obj->borrowernumber }),
1357        2, "_limit_counter: Add an out-of-date patron request.");
1358     is($illrq_obj->_limit_counter('active', { borrowernumber => $illrq_obj->borrowernumber }),
1359        3, "_limit_counter: Add a qualifying request for patron active count.");
1360     $builder->build({
1361         source => 'Illrequest',
1362         value => {
1363             branchcode => $illrq_obj->branchcode,
1364             borrowernumber => $illrq_obj->borrowernumber,
1365             status => "COMP",
1366         }
1367     });
1368     is($illrq_obj->_limit_counter('annual', { branchcode => $illrq_obj->branchcode }),
1369        3, "_limit_counter: Add a qualifying request for branch annual count.");
1370     is($illrq_obj->_limit_counter('active', { branchcode => $illrq_obj->branchcode }),
1371        3, "_limit_counter: Add a completed request for branch active count.");
1372     is($illrq_obj->_limit_counter('annual', { borrowernumber => $illrq_obj->borrowernumber }),
1373        3, "_limit_counter: Add a qualifying request for patron annual count.");
1374     is($illrq_obj->_limit_counter('active', { borrowernumber => $illrq_obj->borrowernumber }),
1375        3, "_limit_counter: Add a completed request for patron active count.");
1376
1377     # check_limits:
1378
1379     # We've tested _limit_counter, so all we need to test here is whether the
1380     # current counts of 3 for each work as they should against different
1381     # configuration declarations.
1382
1383     # No limits
1384     $config->set_always('getLimitRules', undef);
1385     is($illrq_obj->check_limits({patron => $illrq_obj->patron,
1386                                  librarycode => $illrq_obj->branchcode}),
1387        1, "check_limits: no configuration => no limits.");
1388
1389     # Branch tests
1390     $config->set_always('getLimitRules',
1391                         { $illrq_obj->branchcode => { count => 1, method => 'active' } });
1392     is($illrq_obj->check_limits({patron => $illrq_obj->patron,
1393                                  librarycode => $illrq_obj->branchcode}),
1394        0, "check_limits: branch active limit exceeded.");
1395     $config->set_always('getLimitRules',
1396                         { $illrq_obj->branchcode => { count => 1, method => 'annual' } });
1397     is($illrq_obj->check_limits({patron => $illrq_obj->patron,
1398                                  librarycode => $illrq_obj->branchcode}),
1399        0, "check_limits: branch annual limit exceeded.");
1400     $config->set_always('getLimitRules',
1401                         { $illrq_obj->branchcode => { count => 4, method => 'active' } });
1402     is($illrq_obj->check_limits({patron => $illrq_obj->patron,
1403                                  librarycode => $illrq_obj->branchcode}),
1404        1, "check_limits: branch active limit OK.");
1405     $config->set_always('getLimitRules',
1406                         { $illrq_obj->branchcode => { count => 4, method => 'annual' } });
1407     is($illrq_obj->check_limits({patron => $illrq_obj->patron,
1408                                  librarycode => $illrq_obj->branchcode}),
1409        1, "check_limits: branch annual limit OK.");
1410
1411     # Patron tests
1412     $config->set_always('getLimitRules',
1413                         { $illrq_obj->patron->categorycode => { count => 1, method => 'active' } });
1414     is($illrq_obj->check_limits({patron => $illrq_obj->patron,
1415                                  librarycode => $illrq_obj->branchcode}),
1416        0, "check_limits: patron category active limit exceeded.");
1417     $config->set_always('getLimitRules',
1418                         { $illrq_obj->patron->categorycode => { count => 1, method => 'annual' } });
1419     is($illrq_obj->check_limits({patron => $illrq_obj->patron,
1420                                  librarycode => $illrq_obj->branchcode}),
1421        0, "check_limits: patron category annual limit exceeded.");
1422     $config->set_always('getLimitRules',
1423                         { $illrq_obj->patron->categorycode => { count => 4, method => 'active' } });
1424     is($illrq_obj->check_limits({patron => $illrq_obj->patron,
1425                                  librarycode => $illrq_obj->branchcode}),
1426        1, "check_limits: patron category active limit OK.");
1427     $config->set_always('getLimitRules',
1428                         { $illrq_obj->patron->categorycode => { count => 4, method => 'annual' } });
1429     is($illrq_obj->check_limits({patron => $illrq_obj->patron,
1430                                  librarycode => $illrq_obj->branchcode}),
1431        1, "check_limits: patron category annual limit OK.");
1432
1433     # One rule cancels the other
1434     $config->set_series('getLimitRules',
1435                         # Branch rules allow request
1436                         { $illrq_obj->branchcode => { count => 4, method => 'active' } },
1437                         # Patron rule forbids it
1438                         { $illrq_obj->patron->categorycode => { count => 1, method => 'annual' } });
1439     is($illrq_obj->check_limits({patron => $illrq_obj->patron,
1440                                  librarycode => $illrq_obj->branchcode}),
1441        0, "check_limits: patron category veto overrides branch OK.");
1442     $config->set_series('getLimitRules',
1443                         # Branch rules allow request
1444                         { $illrq_obj->branchcode => { count => 1, method => 'active' } },
1445                         # Patron rule forbids it
1446                         { $illrq_obj->patron->categorycode => { count => 4, method => 'annual' } });
1447     is($illrq_obj->check_limits({patron => $illrq_obj->patron,
1448                                  librarycode => $illrq_obj->branchcode}),
1449        0, "check_limits: branch veto overrides patron category OK.");
1450
1451     $schema->storage->txn_rollback;
1452 };
1453
1454 subtest 'Custom statuses' => sub {
1455
1456     plan tests => 3;
1457
1458     $schema->storage->txn_begin;
1459
1460     my $cat = Koha::AuthorisedValueCategories->search(
1461         {
1462             category_name => 'ILLSTATUS'
1463         }
1464     );
1465
1466     if ($cat->count == 0) {
1467         $cat  = $builder->build_object(
1468             {
1469                 class => 'Koha::AuthorisedValueCategory',
1470                 value => {
1471                     category_name => 'ILLSTATUS'
1472                 }
1473             }
1474         );
1475     };
1476
1477     my $av = $builder->build_object(
1478         {
1479             class => 'Koha::AuthorisedValues',
1480             value => {
1481                 category => 'ILLSTATUS'
1482             }
1483         }
1484     );
1485
1486     is($av->category, 'ILLSTATUS',
1487        "Successfully created authorised value for custom status");
1488
1489     my $ill_req = $builder->build_object(
1490         {
1491             class => 'Koha::Illrequests',
1492             value => {
1493                 status_alias => $av->authorised_value
1494             }
1495         }
1496     );
1497     isa_ok($ill_req->statusalias, 'Koha::AuthorisedValue',
1498            "statusalias correctly returning Koha::AuthorisedValue object");
1499
1500     $ill_req->status("COMP");
1501     is($ill_req->statusalias, undef,
1502         "Koha::Illrequest->status overloading resetting status_alias");
1503
1504     $schema->storage->txn_rollback;
1505 };
1506
1507 subtest 'Checking in hook' => sub {
1508
1509     plan tests => 2;
1510
1511     $schema->storage->txn_begin;
1512
1513     # Build infrastructure
1514     my $backend = Test::MockObject->new;
1515     $backend->set_isa('Koha::Illbackends::Mock');
1516     $backend->set_always('name', 'Mock');
1517
1518     my $config = Test::MockObject->new;
1519     $config->set_always('backend_dir', "/tmp");
1520
1521     my $item   = $builder->build_sample_item();
1522     my $patron = $builder->build_object({ class => 'Koha::Patrons' });
1523
1524     t::lib::Mocks::mock_userenv(
1525         {
1526             patron     => $patron,
1527             branchcode => $patron->branchcode
1528         }
1529     );
1530
1531     my $illrq = $builder->build_object(
1532         {
1533             class => 'Koha::Illrequests',
1534             value => {
1535                 biblio_id => $item->biblio->biblionumber,
1536                 status    => 'NEW'
1537             }
1538         }
1539     );
1540
1541     $illrq->_config($config);
1542     $illrq->_backend($backend);
1543
1544     t::lib::Mocks::mock_preference('CirculateILL', 1);
1545
1546     # Add an issue
1547     AddIssue( $patron->unblessed, $item->barcode );
1548     # Make the item withdrawn so checking-in is rejected
1549     t::lib::Mocks::mock_preference('BlockReturnOfWithdrawnItems', 1);
1550     $item->set({ withdrawn => 1 })->store;
1551     AddReturn( $item->barcode, $patron->branchcode );
1552     # refresh request
1553     $illrq->discard_changes;
1554     isnt( $illrq->status, 'RET' );
1555
1556     # allow the check-in
1557     $item->set({ withdrawn => 0 })->store;
1558     AddReturn( $item->barcode, $patron->branchcode );
1559     # refresh request
1560     $illrq->discard_changes;
1561     is( $illrq->status, 'RET' );
1562
1563     $schema->storage->txn_rollback;
1564 };