t/db_dependent/ILSDI_Services.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 CGI qw ( -utf8 );
  21
  22 use Test::More tests => 9;
  23 use Test::MockModule;
  24 use t::lib::Mocks;
  25 use t::lib::TestBuilder;
  26
  27 use C4::Items qw( ModItemTransfer );
  28 use C4::Circulation;
  29
  30 use Koha::AuthUtils;
  31
  32 BEGIN {
  33     use_ok('C4::ILSDI::Services');
  34 }
  35
  36 my $schema  = Koha::Database->schema;
  37 my $dbh     = C4::Context->dbh;
  38 my $builder = t::lib::TestBuilder->new;
  39
  40 subtest 'AuthenticatePatron test' => sub {
  41
  42     plan tests => 14;
  43
  44     $schema->storage->txn_begin;
  45
  46     my $plain_password = 'tomasito';
  47
  48     $builder->build({
  49         source => 'Borrower',
  50         value => {
  51             cardnumber => undef,
  52         }
  53     });
  54
  55     my $borrower = $builder->build({
  56         source => 'Borrower',
  57         value  => {
  58             cardnumber => undef,
  59             password => Koha::AuthUtils::hash_password( $plain_password )
  60         }
  61     });
  62
  63     my $query = new CGI;
  64     $query->param( 'username', $borrower->{userid});
  65     $query->param( 'password', $plain_password);
  66
  67     my $reply = C4::ILSDI::Services::AuthenticatePatron( $query );
  68     is( $reply->{id}, $borrower->{borrowernumber}, "userid and password - Patron authenticated" );
  69     is( $reply->{code}, undef, "Error code undef");
  70
  71     $query->param('password','ilsdi-passworD');
  72     $reply = C4::ILSDI::Services::AuthenticatePatron( $query );
  73     is( $reply->{code}, 'PatronNotFound', "userid and wrong password - PatronNotFound" );
  74     is( $reply->{id}, undef, "id undef");
  75
  76     $query->param( 'password', $plain_password );
  77     $query->param( 'username', 'wrong-ilsdi-useriD' );
  78     $reply = C4::ILSDI::Services::AuthenticatePatron( $query );
  79     is( $reply->{code}, 'PatronNotFound', "non-existing userid - PatronNotFound" );
  80     is( $reply->{id}, undef, "id undef");
  81
  82     $query->param( 'username', uc( $borrower->{userid} ));
  83     $reply = C4::ILSDI::Services::AuthenticatePatron( $query );
  84     is( $reply->{id}, $borrower->{borrowernumber}, "userid is not case sensitive - Patron authenticated" );
  85     is( $reply->{code}, undef, "Error code undef");
  86
  87     $query->param( 'username', $borrower->{cardnumber} );
  88     $reply = C4::ILSDI::Services::AuthenticatePatron( $query );
  89     is( $reply->{id}, $borrower->{borrowernumber}, "cardnumber and password - Patron authenticated" );
  90     is( $reply->{code}, undef, "Error code undef" );
  91
  92     $query->param( 'password', 'ilsdi-passworD' );
  93     $reply = C4::ILSDI::Services::AuthenticatePatron( $query );
  94     is( $reply->{code}, 'PatronNotFound', "cardnumber and wrong password - PatronNotFount" );
  95     is( $reply->{id}, undef, "id undef" );
  96
  97     $query->param( 'username', 'randomcardnumber1234' );
  98     $query->param( 'password', $plain_password );
  99     $reply = C4::ILSDI::Services::AuthenticatePatron($query);
 100     is( $reply->{code}, 'PatronNotFound', "non-existing cardnumer/userid - PatronNotFound" );
 101     is( $reply->{id}, undef, "id undef");
 102
 103     $schema->storage->txn_rollback;
 104 };
 105
 106
 107 subtest 'GetPatronInfo/GetBorrowerAttributes test for extended patron attributes' => sub {
 108
 109     plan tests => 5;
 110
 111     $schema->storage->txn_begin;
 112
 113     $schema->resultset( 'Issue' )->delete_all;
 114     $schema->resultset( 'Borrower' )->delete_all;
 115     $schema->resultset( 'BorrowerAttribute' )->delete_all;
 116     $schema->resultset( 'BorrowerAttributeType' )->delete_all;
 117     $schema->resultset( 'Category' )->delete_all;
 118     $schema->resultset( 'Item' )->delete_all; # 'Branch' deps. on this
 119     $schema->resultset( 'Club' )->delete_all;
 120     $schema->resultset( 'Branch' )->delete_all;
 121
 122     # Configure Koha to enable ILS-DI server and extended attributes:
 123     t::lib::Mocks::mock_preference( 'ILS-DI', 1 );
 124     t::lib::Mocks::mock_preference( 'ExtendedPatronAttributes', 1 );
 125
 126     # Set up a library/branch for our user to belong to:
 127     my $lib = $builder->build( {
 128         source => 'Branch',
 129         value => {
 130             branchcode => 'T_ILSDI',
 131         }
 132     } );
 133
 134     # Create a new category for user to belong to:
 135     my $cat = $builder->build( {
 136         source => 'Category',
 137         value  => {
 138             category_type                 => 'A',
 139             BlockExpiredPatronOpacActions => -1,
 140         }
 141     } );
 142
 143     # Create a new attribute type:
 144     my $attr_type = $builder->build( {
 145         source => 'BorrowerAttributeType',
 146         value  => {
 147             code                      => 'HIDEME',
 148             opac_display              => 0,
 149             authorised_value_category => '',
 150             class                     => '',
 151         }
 152     } );
 153     my $attr_type_visible = $builder->build( {
 154         source => 'BorrowerAttributeType',
 155         value  => {
 156             code                      => 'SHOWME',
 157             opac_display              => 1,
 158             authorised_value_category => '',
 159             class                     => '',
 160         }
 161     } );
 162
 163     # Create a new user:
 164     my $brwr = $builder->build( {
 165         source => 'Borrower',
 166         value  => {
 167             categorycode => $cat->{'categorycode'},
 168             branchcode   => $lib->{'branchcode'},
 169         }
 170     } );
 171
 172     # Authorised value:
 173     my $auth = $builder->build( {
 174         source => 'AuthorisedValue',
 175         value  => {
 176             category => $cat->{'categorycode'}
 177         }
 178     } );
 179
 180     # Set the new attribute for our user:
 181     my $attr_hidden = $builder->build( {
 182         source => 'BorrowerAttribute',
 183         value  => {
 184             borrowernumber => $brwr->{'borrowernumber'},
 185             code           => $attr_type->{'code'},
 186             attribute      => '1337 hidden',
 187         }
 188     } );
 189     my $attr_shown = $builder->build( {
 190         source => 'BorrowerAttribute',
 191         value  => {
 192             borrowernumber => $brwr->{'borrowernumber'},
 193             code           => $attr_type_visible->{'code'},
 194             attribute      => '1337 shown',
 195         }
 196     } );
 197
 198     my $fine = $builder->build(
 199         {
 200             source => 'Accountline',
 201             value  => {
 202                 borrowernumber    => $brwr->{borrowernumber},
 203                 accounttype       => 'xxx',
 204                 debit_type_code   => undef,
 205                 amountoutstanding => 10
 206             }
 207         }
 208     );
 209
 210     # Prepare and send web request for IL-SDI server:
 211     my $query = new CGI;
 212     $query->param( 'service', 'GetPatronInfo' );
 213     $query->param( 'patron_id', $brwr->{'borrowernumber'} );
 214     $query->param( 'show_attributes', '1' );
 215     $query->param( 'show_fines', '1' );
 216
 217     my $reply = C4::ILSDI::Services::GetPatronInfo( $query );
 218
 219     # Build a structure for comparison:
 220     my $cmp = {
 221         category_code     => $attr_type_visible->{'category_code'},
 222         class             => $attr_type_visible->{'class'},
 223         code              => $attr_shown->{'code'},
 224         description       => $attr_type_visible->{'description'},
 225         display_checkout  => $attr_type_visible->{'display_checkout'},
 226         value             => $attr_shown->{'attribute'},
 227         value_description => undef,
 228     };
 229
 230     is( $reply->{'charges'}, '10.00',
 231         'The \'charges\' attribute should be correctly filled (bug 17836)' );
 232
 233     is( scalar( @{$reply->{fines}->{fine}}), 1, 'There should be only 1 account line');
 234     is(
 235         $reply->{fines}->{fine}->[0]->{accountlines_id},
 236         $fine->{accountlines_id},
 237         "The accountline should be the correct one"
 238     );
 239
 240     # Check results:
 241     is_deeply( $reply->{'attributes'}, [ $cmp ], 'Test GetPatronInfo - show_attributes parameter' );
 242
 243     ok( exists $reply->{is_expired}, 'There should be the is_expired information');
 244
 245     # Cleanup
 246     $schema->storage->txn_rollback;
 247 };
 248
 249 subtest 'LookupPatron test' => sub {
 250
 251     plan tests => 9;
 252
 253     $schema->storage->txn_begin;
 254
 255     $schema->resultset( 'Issue' )->delete_all;
 256     $schema->resultset( 'Borrower' )->delete_all;
 257     $schema->resultset( 'BorrowerAttribute' )->delete_all;
 258     $schema->resultset( 'BorrowerAttributeType' )->delete_all;
 259     $schema->resultset( 'Category' )->delete_all;
 260     $schema->resultset( 'Item' )->delete_all; # 'Branch' deps. on this
 261     $schema->resultset( 'Branch' )->delete_all;
 262
 263     my $borrower = $builder->build({
 264         source => 'Borrower',
 265     });
 266
 267     my $query = CGI->new();
 268     my $bad_result = C4::ILSDI::Services::LookupPatron($query);
 269     is( $bad_result->{message}, 'PatronNotFound', 'No parameters' );
 270
 271     $query->delete_all();
 272     $query->param( 'id', $borrower->{firstname} );
 273     my $optional_result = C4::ILSDI::Services::LookupPatron($query);
 274     is(
 275         $optional_result->{id},
 276         $borrower->{borrowernumber},
 277         'Valid Firstname only'
 278     );
 279
 280     $query->delete_all();
 281     $query->param( 'id', 'ThereIsNoWayThatThisCouldPossiblyBeValid' );
 282     my $bad_optional_result = C4::ILSDI::Services::LookupPatron($query);
 283     is( $bad_optional_result->{message}, 'PatronNotFound', 'Invalid ID' );
 284
 285     foreach my $id_type (
 286         'cardnumber',
 287         'userid',
 288         'email',
 289         'borrowernumber',
 290         'surname',
 291         'firstname'
 292     ) {
 293         $query->delete_all();
 294         $query->param( 'id_type', $id_type );
 295         $query->param( 'id', $borrower->{$id_type} );
 296         my $result = C4::ILSDI::Services::LookupPatron($query);
 297         is( $result->{'id'}, $borrower->{borrowernumber}, "Checking $id_type" );
 298     }
 299
 300     # Cleanup
 301     $schema->storage->txn_rollback;
 302 };
 303
 304 subtest 'Holds test' => sub {
 305
 306     plan tests => 5;
 307
 308     $schema->storage->txn_begin;
 309
 310     t::lib::Mocks::mock_preference( 'AllowHoldsOnDamagedItems', 0 );
 311
 312     my $patron = $builder->build({
 313         source => 'Borrower',
 314     });
 315
 316     my $biblio = $builder->build({
 317         source => 'Biblio',
 318     });
 319
 320     my $biblioitems = $builder->build({
 321         source => 'Biblioitem',
 322         value => {
 323             biblionumber => $biblio->{biblionumber},
 324         }
 325     });
 326
 327     my $item = $builder->build({
 328         source => 'Item',
 329         value => {
 330             biblionumber => $biblio->{biblionumber},
 331             damaged => 1
 332         }
 333     });
 334
 335     my $query = new CGI;
 336     $query->param( 'patron_id', $patron->{borrowernumber});
 337     $query->param( 'bib_id', $biblio->{biblionumber});
 338
 339     my $reply = C4::ILSDI::Services::HoldTitle( $query );
 340     is( $reply->{code}, 'damaged', "Item damaged" );
 341
 342     my $item_o = Koha::Items->find($item->{itemnumber});
 343     $item_o->damaged(0)->store;
 344
 345     my $hold = $builder->build({
 346         source => 'Reserve',
 347         value => {
 348             borrowernumber => $patron->{borrowernumber},
 349             biblionumber => $biblio->{biblionumber},
 350             itemnumber => $item->{itemnumber}
 351         }
 352     });
 353
 354     $reply = C4::ILSDI::Services::HoldTitle( $query );
 355     is( $reply->{code}, 'itemAlreadyOnHold', "Item already on hold" );
 356
 357     my $biblio_with_no_item = $builder->build({
 358         source => 'Biblio',
 359     });
 360
 361     $query = new CGI;
 362     $query->param( 'patron_id', $patron->{borrowernumber});
 363     $query->param( 'bib_id', $biblio_with_no_item->{biblionumber});
 364
 365     $reply = C4::ILSDI::Services::HoldTitle( $query );
 366     is( $reply->{code}, 'NoItems', 'Biblio has no item' );
 367
 368     my $biblio2 = $builder->build({
 369         source => 'Biblio',
 370     });
 371
 372     my $biblioitems2 = $builder->build({
 373         source => 'Biblioitem',
 374         value => {
 375             biblionumber => $biblio2->{biblionumber},
 376         }
 377     });
 378
 379     my $item2 = $builder->build({
 380         source => 'Item',
 381         value => {
 382             biblionumber => $biblio2->{biblionumber},
 383             damaged => 0
 384         }
 385     });
 386
 387     t::lib::Mocks::mock_preference( 'ReservesControlBranch', 'PatronLibrary' );
 388     my $issuingrule = $builder->build({
 389         source => 'Issuingrule',
 390         value => {
 391             categorycode => $patron->{categorycode},
 392             itemtype => $item2->{itype},
 393             branchcode => $patron->{branchcode},
 394             reservesallowed => 0,
 395         }
 396     });
 397
 398     $query = new CGI;
 399     $query->param( 'patron_id', $patron->{borrowernumber});
 400     $query->param( 'bib_id', $biblio2->{biblionumber});
 401     $query->param( 'item_id', $item2->{itemnumber});
 402
 403     $reply = C4::ILSDI::Services::HoldItem( $query );
 404     is( $reply->{code}, 'tooManyReserves', "Too many reserves" );
 405
 406     my $biblio3 = $builder->build({
 407         source => 'Biblio',
 408     });
 409
 410     my $biblioitems3 = $builder->build({
 411         source => 'Biblioitem',
 412         value => {
 413             biblionumber => $biblio3->{biblionumber},
 414         }
 415     });
 416
 417     # Adding a holdable item to biblio 3.
 418     my $item3 = $builder->build({
 419         source => 'Item',
 420         value => {
 421             biblionumber => $biblio3->{biblionumber},
 422             damaged => 0,
 423         }
 424     });
 425
 426     my $item4 = $builder->build({
 427         source => 'Item',
 428         value => {
 429             biblionumber => $biblio3->{biblionumber},
 430             damaged => 1,
 431         }
 432     });
 433
 434     my $issuingrule2 = $builder->build({
 435         source => 'Issuingrule',
 436         value => {
 437             categorycode => $patron->{categorycode},
 438             itemtype => $item3->{itype},
 439             branchcode => $patron->{branchcode},
 440             reservesallowed => 10,
 441         }
 442     });
 443
 444     $query = new CGI;
 445     $query->param( 'patron_id', $patron->{borrowernumber});
 446     $query->param( 'bib_id', $biblio3->{biblionumber});
 447     $query->param( 'item_id', $item4->{itemnumber});
 448
 449     $reply = C4::ILSDI::Services::HoldItem( $query );
 450     is( $reply->{code}, 'damaged', "Item is damaged" );
 451
 452     $schema->storage->txn_rollback;
 453 };
 454
 455 subtest 'Holds test for branch transfer limits' => sub {
 456
 457     plan tests => 4;
 458
 459     $schema->storage->txn_begin;
 460
 461     # Test enforement of branch transfer limits
 462     t::lib::Mocks::mock_preference( 'UseBranchTransferLimits', '1' );
 463     t::lib::Mocks::mock_preference( 'BranchTransferLimitsType', 'itemtype' );
 464
 465     my $patron = $builder->build({
 466         source => 'Borrower',
 467     });
 468
 469     my $origin_branch = $builder->build(
 470         {
 471             source => 'Branch',
 472             value  => {
 473                 pickup_location => 1,
 474             }
 475         }
 476     );
 477     my $pickup_branch = $builder->build(
 478         {
 479             source => 'Branch',
 480             value  => {
 481                 pickup_location => 1,
 482             }
 483         }
 484     );
 485
 486     my $biblio = $builder->build({
 487         source => 'Biblio',
 488     });
 489     my $biblioitem = $builder->build({
 490         source => 'Biblioitem',
 491         value => {
 492             biblionumber => $biblio->{biblionumber},
 493         }
 494     });
 495     my $item = $builder->build({
 496         source => 'Item',
 497         value => {
 498             homebranch => $origin_branch->{branchcode},
 499             holdingbranch => $origin_branch->{branchcode},
 500             biblionumber => $biblio->{biblionumber},
 501             damaged => 0,
 502             itemlost => 0,
 503         }
 504     });
 505
 506     Koha::IssuingRules->search()->delete();
 507     my $issuingrule = $builder->build({
 508         source => 'Issuingrule',
 509         value => {
 510             categorycode => '*',
 511             itemtype => '*',
 512             branchcode => '*',
 513             reservesallowed => 99,
 514         }
 515     });
 516
 517     my $limit = Koha::Item::Transfer::Limit->new({
 518         toBranch => $pickup_branch->{branchcode},
 519         fromBranch => $item->{holdingbranch},
 520         itemtype => $item->{itype},
 521     })->store();
 522
 523     my $query = new CGI;
 524     $query->param( 'pickup_location', $pickup_branch->{branchcode} );
 525     $query->param( 'patron_id', $patron->{borrowernumber});
 526     $query->param( 'bib_id', $biblio->{biblionumber});
 527     $query->param( 'item_id', $item->{itemnumber});
 528
 529     my $reply = C4::ILSDI::Services::HoldItem( $query );
 530     is( $reply->{code}, 'cannotBeTransferred', "Item hold, Item cannot be transferred" );
 531
 532     $reply = C4::ILSDI::Services::HoldTitle( $query );
 533     is( $reply->{code}, 'cannotBeTransferred', "Record hold, Item cannot be transferred" );
 534
 535     t::lib::Mocks::mock_preference( 'UseBranchTransferLimits', '0' );
 536
 537     $reply = C4::ILSDI::Services::HoldItem( $query );
 538     is( $reply->{code}, undef, "Item hold, Item can be transferred" );
 539
 540     Koha::Holds->search()->delete();
 541
 542     $reply = C4::ILSDI::Services::HoldTitle( $query );
 543     is( $reply->{code}, undef, "Record hold, Item con be transferred" );
 544
 545     $schema->storage->txn_rollback;
 546 };
 547
 548 subtest 'GetRecords' => sub {
 549
 550     plan tests => 1;
 551
 552     $schema->storage->txn_begin;
 553
 554     t::lib::Mocks::mock_preference( 'ILS-DI', 1 );
 555
 556     my $branch1 = $builder->build({
 557         source => 'Branch',
 558     });
 559     my $branch2 = $builder->build({
 560         source => 'Branch',
 561     });
 562
 563     my $biblio = $builder->build({
 564         source => 'Biblio',
 565     });
 566     my $biblioitem = $builder->build({
 567         source => 'Biblioitem',
 568         value => {
 569             biblionumber => $biblio->{biblionumber},
 570         },
 571     });
 572     my $item = $builder->build_object({
 573         class => 'Koha::Items',
 574         value => {
 575             biblionumber => $biblio->{biblionumber},
 576             biblioitemnumber => $biblioitem->{biblioitemnumber},
 577             homebranch => $branch1->{branchcode},
 578             holdingbranch => $branch1->{branchcode},
 579         },
 580     });
 581
 582     ModItemTransfer($item->itemnumber, $branch1->{branchcode}, $branch2->{branchcode});
 583
 584     my $cgi = new CGI;
 585     $cgi->param(service => 'GetRecords');
 586     $cgi->param(id => $biblio->{biblionumber});
 587
 588     my $reply = C4::ILSDI::Services::GetRecords($cgi);
 589
 590     my $transfer = $item->get_transfer;
 591     my $expected = {
 592         datesent => $transfer->datesent,
 593         frombranch => $transfer->frombranch,
 594         tobranch => $transfer->tobranch,
 595     };
 596     is_deeply($reply->{record}->[0]->{items}->{item}->[0]->{transfer}, $expected,
 597         'GetRecords returns transfer informations');
 598
 599     $schema->storage->txn_rollback;
 600 };
 601
 602 subtest 'RenewHold' => sub {
 603     plan tests => 4;
 604
 605     $schema->storage->txn_begin;
 606
 607     my $cgi    = new CGI;
 608     my $patron = $builder->build_object( { class => 'Koha::Patrons' } );
 609     my $item   = $builder->build_object( { class => 'Koha::Items' } );
 610     $cgi->param( patron_id => $patron->borrowernumber );
 611     $cgi->param( item_id   => $item->itemnumber );
 612
 613     t::lib::Mocks::mock_userenv( { patron => $patron } );    # For AddIssue
 614     my $checkout = C4::Circulation::AddIssue( $patron->unblessed, $item->barcode );
 615
 616     # Everything is ok
 617     my $reply = C4::ILSDI::Services::RenewLoan($cgi);
 618     is( exists $reply->{date_due}, 1, 'If the item is checked out, the date_due key should exist' );
 619
 620     # The item is not checked out
 621     $checkout->delete;
 622     $reply = C4::ILSDI::Services::RenewLoan($cgi);
 623     is( $reply, undef, 'If the item is not checked out, we should not explode.');    # FIXME We should return an error code instead
 624
 625     # The item does not exist
 626     $item->delete;
 627     $reply = C4::ILSDI::Services::RenewLoan($cgi);
 628     is( $reply->{code}, 'RecordNotFound', 'If the item does not exist, RecordNotFound should be returned');
 629
 630     $patron->delete;
 631     $reply = C4::ILSDI::Services::RenewLoan($cgi);
 632     is( $reply->{code}, 'PatronNotFound', 'If the patron does not exist, PatronNotFound should be returned');
 633
 634     $schema->storage->txn_rollback;
 635 };
 636
 637 subtest 'GetPatronInfo paginated loans' => sub {
 638     plan tests => 7;
 639
 640     $schema->storage->txn_begin;
 641
 642     my $library = $builder->build_object({
 643         class => 'Koha::Libraries',
 644     });
 645
 646     my $item1 = $builder->build_sample_item({ library => $library->branchcode });
 647     my $item2 = $builder->build_sample_item({ library => $library->branchcode });
 648     my $item3 = $builder->build_sample_item({ library => $library->branchcode });
 649     my $patron = $builder->build_object({
 650         class => 'Koha::Patrons',
 651         value => {
 652             branchcode => $library->branchcode,
 653         },
 654     });
 655     my $module = new Test::MockModule('C4::Context');
 656     $module->mock('userenv', sub { { branch => $library->branchcode } });
 657     my $date_due = DateTime->now->add(weeks => 2);
 658     my $issue1 = C4::Circulation::AddIssue($patron->unblessed, $item1->barcode, $date_due);
 659     my $date_due1 = Koha::DateUtils::dt_from_string( $issue1->date_due );
 660     my $issue2 = C4::Circulation::AddIssue($patron->unblessed, $item2->barcode, $date_due);
 661     my $date_due2 = Koha::DateUtils::dt_from_string( $issue2->date_due );
 662     my $issue3 = C4::Circulation::AddIssue($patron->unblessed, $item3->barcode, $date_due);
 663     my $date_due3 = Koha::DateUtils::dt_from_string( $issue3->date_due );
 664
 665     my $cgi = new CGI;
 666
 667     $cgi->param( 'service', 'GetPatronInfo' );
 668     $cgi->param( 'patron_id', $patron->borrowernumber );
 669     $cgi->param( 'show_loans', '1' );
 670     $cgi->param( 'loans_per_page', '2' );
 671     $cgi->param( 'loans_page', '1' );
 672     my $reply = C4::ILSDI::Services::GetPatronInfo($cgi);
 673
 674     is($reply->{total_loans}, 3, 'total_loans == 3');
 675     is(scalar @{ $reply->{loans}->{loan} }, 2, 'GetPatronInfo returned only 2 loans');
 676     is($reply->{loans}->{loan}->[0]->{itemnumber}, $item3->itemnumber);
 677     is($reply->{loans}->{loan}->[1]->{itemnumber}, $item2->itemnumber);
 678
 679     $cgi->param( 'loans_page', '2' );
 680     $reply = C4::ILSDI::Services::GetPatronInfo($cgi);
 681
 682     is($reply->{total_loans}, 3, 'total_loans == 3');
 683     is(scalar @{ $reply->{loans}->{loan} }, 1, 'GetPatronInfo returned only 1 loan');
 684     is($reply->{loans}->{loan}->[0]->{itemnumber}, $item1->itemnumber);
 685
 686     $schema->storage->txn_rollback;
 687 };