t/db_dependent/Acquisition.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 POSIX qw(strftime);
  21
  22 use Test::More tests => 92;
  23 use Koha::Database;
  24
  25 BEGIN {
  26     use_ok('C4::Acquisition');
  27     use_ok('C4::Bookseller');
  28     use_ok('C4::Biblio');
  29     use_ok('C4::Budgets');
  30     use_ok('C4::Bookseller');
  31     use_ok('Koha::Acquisition::Order');
  32     use_ok('Koha::Acquisition::Bookseller');
  33 }
  34
  35 # Sub used for testing C4::Acquisition subs returning order(s):
  36 #    GetOrdersByStatus, GetOrders, GetDeletedOrders, GetOrder etc.
  37 # (\@test_missing_fields,\@test_extra_fields,\@test_different_fields,$test_nbr_fields) =
  38 #  _check_fields_of_order ($exp_fields, $original_order_content, $order_to_check);
  39 # params :
  40 # $exp_fields             : arrayref whose elements are the keys we expect to find
  41 # $original_order_content : hashref whose 2 keys str and num contains hashrefs
  42 #                           containing content fields of the order created with Koha::Acquisition::Order
  43 # $order_to_check         : hashref whose keys/values are the content of an order
  44 #                           returned by the C4::Acquisition sub we are testing
  45 # returns :
  46 # \@test_missing_fields   : arrayref void if ok ; otherwise contains the list of
  47 #                           fields missing in $order_to_check
  48 # \@test_extra_fields     : arrayref void if ok ; otherwise contains the list of
  49 #                           fields unexpected in $order_to_check
  50 # \@test_different_fields : arrayref void if ok ; otherwise contains the list of
  51 #                           fields which value is not the same in between $order_to_check and
  52 # $test_nbr_fields        : contains the number of fields of $order_to_check
  53
  54 sub _check_fields_of_order {
  55     my ( $exp_fields, $original_order_content, $order_to_check ) = @_;
  56     my @test_missing_fields   = ();
  57     my @test_extra_fields     = ();
  58     my @test_different_fields = ();
  59     my $test_nbr_fields       = scalar( keys %$order_to_check );
  60     foreach my $field (@$exp_fields) {
  61         push @test_missing_fields, $field
  62           unless exists( $order_to_check->{$field} );
  63     }
  64     foreach my $field ( keys %$order_to_check ) {
  65         push @test_extra_fields, $field
  66           unless grep ( /^$field$/, @$exp_fields );
  67     }
  68     foreach my $field ( keys %{ $original_order_content->{str} } ) {
  69         push @test_different_fields, $field
  70           unless ( !exists $order_to_check->{$field} )
  71           or ( $original_order_content->{str}->{$field} eq
  72             $order_to_check->{$field} );
  73     }
  74     foreach my $field ( keys %{ $original_order_content->{num} } ) {
  75         push @test_different_fields, $field
  76           unless ( !exists $order_to_check->{$field} )
  77           or ( $original_order_content->{num}->{$field} ==
  78             $order_to_check->{$field} );
  79     }
  80     return (
  81         \@test_missing_fields,   \@test_extra_fields,
  82         \@test_different_fields, $test_nbr_fields
  83     );
  84 }
  85
  86 # Sub used for testing C4::Acquisition subs returning several orders
  87 # (\@test_missing_fields,\@test_extra_fields,\@test_different_fields,\@test_nbr_fields) =
  88 #   _check_fields_of_orders ($exp_fields, $original_orders_content, $orders_to_check)
  89 sub _check_fields_of_orders {
  90     my ( $exp_fields, $original_orders_content, $orders_to_check ) = @_;
  91     my @test_missing_fields   = ();
  92     my @test_extra_fields     = ();
  93     my @test_different_fields = ();
  94     my @test_nbr_fields       = ();
  95     foreach my $order_to_check (@$orders_to_check) {
  96         my $original_order_content =
  97           ( grep { $_->{str}->{ordernumber} eq $order_to_check->{ordernumber} }
  98               @$original_orders_content )[0];
  99         my (
 100             $t_missing_fields,   $t_extra_fields,
 101             $t_different_fields, $t_nbr_fields
 102           )
 103           = _check_fields_of_order( $exp_fields, $original_order_content,
 104             $order_to_check );
 105         push @test_missing_fields,   @$t_missing_fields;
 106         push @test_extra_fields,     @$t_extra_fields;
 107         push @test_different_fields, @$t_different_fields;
 108         push @test_nbr_fields,       $t_nbr_fields;
 109     }
 110     @test_missing_fields = keys %{ { map { $_ => 1 } @test_missing_fields } };
 111     @test_extra_fields   = keys %{ { map { $_ => 1 } @test_extra_fields } };
 112     @test_different_fields =
 113       keys %{ { map { $_ => 1 } @test_different_fields } };
 114     return (
 115         \@test_missing_fields,   \@test_extra_fields,
 116         \@test_different_fields, \@test_nbr_fields
 117     );
 118 }
 119
 120
 121 my $schema = Koha::Database->new()->schema();
 122 $schema->storage->txn_begin();
 123
 124 my $dbh = C4::Context->dbh;
 125 $dbh->{RaiseError} = 1;
 126
 127 # Creating some orders
 128 my $booksellerid = C4::Bookseller::AddBookseller(
 129     {
 130         name         => "my vendor",
 131         address1     => "bookseller's address",
 132         phone        => "0123456",
 133         active       => 1,
 134         deliverytime => 5,
 135     }
 136 );
 137
 138 my $booksellerinfo = Koha::Acquisition::Bookseller->fetch({ id => $booksellerid });
 139
 140 is( $booksellerinfo->{deliverytime},
 141     5, 'set deliverytime when creating vendor (Bug 10556)' );
 142
 143 my ( $basket, $basketno );
 144 ok(
 145     $basketno = NewBasket( $booksellerid, 1 ),
 146     "NewBasket(  $booksellerid , 1  ) returns $basketno"
 147 );
 148 ok( $basket = GetBasket($basketno), "GetBasket($basketno) returns $basket" );
 149
 150 my $bpid=AddBudgetPeriod({
 151         budget_period_startdate => '2008-01-01'
 152         , budget_period_enddate => '2008-12-31'
 153         , budget_period_active  => 1
 154         , budget_period_description    => "MAPERI"
 155 });
 156
 157 my $budgetid = C4::Budgets::AddBudget(
 158     {
 159         budget_code => "budget_code_test_getordersbybib",
 160         budget_name => "budget_name_test_getordersbybib",
 161         budget_period_id => $bpid,
 162     }
 163 );
 164 my $budget = C4::Budgets::GetBudget($budgetid);
 165
 166 my @ordernumbers;
 167 my ( $biblionumber1, $biblioitemnumber1 ) = AddBiblio( MARC::Record->new, '' );
 168 my ( $biblionumber2, $biblioitemnumber2 ) = AddBiblio( MARC::Record->new, '' );
 169 my ( $biblionumber3, $biblioitemnumber3 ) = AddBiblio( MARC::Record->new, '' );
 170 my ( $biblionumber4, $biblioitemnumber4 ) = AddBiblio( MARC::Record->new, '' );
 171
 172 # Prepare 5 orders, and make distinction beween fields to be tested with eq and with ==
 173 # Ex : a price of 50.1 will be stored internally as 5.100000
 174
 175 my @order_content = (
 176     {
 177         str => {
 178             basketno       => $basketno,
 179             biblionumber   => $biblionumber1,
 180             budget_id      => $budget->{budget_id},
 181             uncertainprice => 0,
 182             order_internalnote => "internal note",
 183             order_vendornote   => "vendor note",
 184             ordernumber => '',
 185         },
 186         num => {
 187             quantity  => 24,
 188             listprice => 50.121111,
 189             ecost     => 38.15,
 190             rrp       => 40.15,
 191             discount  => 5.1111,
 192             gstrate   => 0.0515
 193         }
 194     },
 195     {
 196         str => {
 197             basketno     => $basketno,
 198             biblionumber => $biblionumber2,
 199             budget_id    => $budget->{budget_id}
 200         },
 201         num => { quantity => 42 }
 202     },
 203     {
 204         str => {
 205             basketno       => $basketno,
 206             biblionumber   => $biblionumber2,
 207             budget_id      => $budget->{budget_id},
 208             uncertainprice => 0,
 209             order_internalnote => "internal note",
 210             order_vendornote   => "vendor note"
 211         },
 212         num => {
 213             quantity  => 4,
 214             ecost     => 42.1,
 215             rrp       => 42.1,
 216             listprice => 10.1,
 217             ecost     => 38.1,
 218             rrp       => 11.0,
 219             discount  => 5.1,
 220             gstrate   => 0.1
 221         }
 222     },
 223     {
 224         str => {
 225             basketno     => $basketno,
 226             biblionumber => $biblionumber3,
 227             budget_id    => $budget->{budget_id},
 228             order_internalnote => "internal note",
 229             order_vendornote   => "vendor note"
 230         },
 231         num => {
 232             quantity       => 4,
 233             ecost          => 40,
 234             rrp            => 42,
 235             listprice      => 10,
 236             ecost          => 38.15,
 237             rrp            => 11.00,
 238             discount       => 0,
 239             uncertainprice => 0,
 240             gstrate        => 0
 241         }
 242     },
 243     {
 244         str => {
 245             basketno     => $basketno,
 246             biblionumber => $biblionumber4,
 247             budget_id    => $budget->{budget_id},
 248             order_internalnote => "internal note",
 249             order_vendornote   => "vendor note"
 250         },
 251         num => {
 252             quantity       => 1,
 253             ecost          => 10,
 254             rrp            => 10,
 255             listprice      => 10,
 256             ecost          => 10,
 257             rrp            => 10,
 258             discount       => 0,
 259             uncertainprice => 0,
 260             gstrate        => 0
 261         }
 262     }
 263 );
 264
 265 # Create 4 orders in database
 266 for ( 0 .. 4 ) {
 267     my %ocontent;
 268     @ocontent{ keys %{ $order_content[$_]->{num} } } =
 269       values %{ $order_content[$_]->{num} };
 270     @ocontent{ keys %{ $order_content[$_]->{str} } } =
 271       values %{ $order_content[$_]->{str} };
 272     $ordernumbers[$_] = Koha::Acquisition::Order->new( \%ocontent )->insert->{ordernumber};
 273     $order_content[$_]->{str}->{ordernumber} = $ordernumbers[$_];
 274 }
 275
 276 # Test UT sub _check_fields_of_order
 277
 278 my (
 279     $test_missing_fields,   $test_extra_fields,
 280     $test_different_fields, $test_nbr_fields
 281   )
 282   = _check_fields_of_order(
 283     [qw /a b c d e/],
 284     { str => { a => "bla", b => "105" }, num => { c => 15.12 } },
 285     { a => "blabla", f => "f", b => "105", c => 15.1200, g => '' }
 286   );
 287 ok(
 288     (
 289               ( $test_nbr_fields == 5 )
 290           and ( join( " ", sort @$test_missing_fields ) eq 'd e' )
 291           and ( join( " ", sort @$test_extra_fields )   eq 'f g' )
 292           and ( join( " ", @$test_different_fields )    eq 'a' )
 293     ),
 294     "_check_fields_of_order can check an order (test 1)"
 295 );
 296 (
 297     $test_missing_fields,   $test_extra_fields,
 298     $test_different_fields, $test_nbr_fields
 299   )
 300   = _check_fields_of_order(
 301     [qw /a b c /],
 302     { str => { a => "bla", b => "105" }, num => { c => 15.00 } },
 303     { a => "bla", b => "105", c => 15 }
 304   );
 305 ok(
 306     (
 307               ( $test_nbr_fields == 3 )
 308           and ( scalar @$test_missing_fields == 0 )
 309           and ( scalar @$test_extra_fields == 0 )
 310           and ( scalar @$test_different_fields == 0 )
 311     ),
 312     "_check_fields_of_order can check an order (test 2)"
 313 );
 314 (
 315     $test_missing_fields,   $test_extra_fields,
 316     $test_different_fields, $test_nbr_fields
 317   )
 318   = _check_fields_of_order(
 319     [qw /a b c d e/],
 320     { str => { a => "bla", b => "105" }, num => { c => 15.12 } },
 321     { a => "blabla", b => "105", c => 15, d => "error" }
 322   );
 323 ok(
 324     (
 325               ( $test_nbr_fields == 4 )
 326           and ( join( " ", sort @$test_missing_fields ) eq 'e' )
 327           and ( scalar @$test_extra_fields == 0 )
 328           and ( join( " ", @$test_different_fields ) eq 'a c' )
 329     ),
 330     "_check_fields_of_order can check an order (test 3)"
 331 );
 332
 333 #
 334 # test GetOrder
 335 #
 336
 337 my @expectedfields = qw(
 338   order_internalnote
 339   order_vendornote
 340   ordernumber
 341   biblionumber
 342   entrydate
 343   quantity
 344   currency
 345   listprice
 346   datereceived
 347   invoiceid
 348   freight
 349   unitprice
 350   quantityreceived
 351   datecancellationprinted
 352   purchaseordernumber
 353   basketno
 354   timestamp
 355   rrp
 356   ecost
 357   unitpricesupplier
 358   unitpricelib
 359   gstrate
 360   discount
 361   budget_id
 362   budgetdate
 363   sort1
 364   sort2
 365   sort1_authcat
 366   sort2_authcat
 367   uncertainprice
 368   claims_count
 369   claimed_date
 370   subscriptionid
 371   parent_ordernumber
 372   orderstatus
 373   line_item_id
 374   suppliers_reference_number
 375   suppliers_reference_qualifier
 376   suppliers_report
 377   title
 378   author
 379   basketname
 380   branchcode
 381   publicationyear
 382   copyrightdate
 383   editionstatement
 384   isbn
 385   ean
 386   seriestitle
 387   publishercode
 388   publisher
 389   budget
 390   supplier
 391   supplierid
 392   estimateddeliverydate
 393   orderdate
 394   quantity_to_receive
 395   subtotal
 396   latesince
 397   cancellationreason
 398 );
 399 (
 400     $test_missing_fields,   $test_extra_fields,
 401     $test_different_fields, $test_nbr_fields
 402   )
 403   = _check_fields_of_order( \@expectedfields, $order_content[0],
 404     GetOrder( $ordernumbers[0] ) );
 405 is(
 406     $test_nbr_fields,
 407     scalar @expectedfields,
 408     "GetOrder gets an order with the right number of fields"
 409 );
 410 is( join( " ", @$test_missing_fields ),
 411     '', "GetOrder gets an order with no missing fields" );
 412 is( join( " ", @$test_extra_fields ),
 413     '', "GetOrder gets an order with no unexpected fields" );
 414 is( join( " ", @$test_different_fields ),
 415     '', "GetOrder gets an order with the right content in every fields" );
 416
 417 #
 418 # Test GetOrders
 419 #
 420
 421 my @base_expectedfields = qw(
 422   order_internalnote
 423   order_vendornote
 424   notes
 425   ordernumber
 426   ecost
 427   uncertainprice
 428   url
 429   isbn
 430   copyrightdate
 431   serial
 432   cn_suffix
 433   cn_item
 434   marcxml
 435   freight
 436   cn_class
 437   title
 438   pages
 439   budget_encumb
 440   budget_name
 441   number
 442   itemtype
 443   totalissues
 444   author
 445   budget_permission
 446   parent_ordernumber
 447   size
 448   claims_count
 449   currency
 450   seriestitle
 451   timestamp
 452   editionstatement
 453   budget_parent_id
 454   publishercode
 455   unitprice
 456   collectionvolume
 457   budget_amount
 458   budget_owner_id
 459   datecreated
 460   claimed_date
 461   subscriptionid
 462   editionresponsibility
 463   sort2
 464   volumedate
 465   budget_id
 466   illus
 467   ean
 468   biblioitemnumber
 469   datereceived
 470   orderstatus
 471   line_item_id
 472   suppliers_reference_number
 473   suppliers_reference_qualifier
 474   suppliers_report
 475   agerestriction
 476   budget_branchcode
 477   gstrate
 478   listprice
 479   budget_code
 480   budgetdate
 481   basketno
 482   discount
 483   abstract
 484   collectionissn
 485   publicationyear
 486   collectiontitle
 487   invoiceid
 488   place
 489   issn
 490   quantityreceived
 491   entrydate
 492   cn_source
 493   sort1_authcat
 494   budget_notes
 495   biblionumber
 496   unititle
 497   sort2_authcat
 498   budget_expend
 499   rrp
 500   cn_sort
 501   lccn
 502   sort1
 503   volume
 504   purchaseordernumber
 505   quantity
 506   budget_period_id
 507   frameworkcode
 508   volumedesc
 509   datecancellationprinted
 510   cancellationreason
 511 );
 512 @expectedfields =
 513   ( @base_expectedfields,
 514     ( 'transferred_from_timestamp', 'transferred_from' ) );
 515 is( GetOrders(), undef, "GetOrders with no params returns undef" );
 516 DelOrder( $order_content[3]->{str}->{biblionumber}, $ordernumbers[3] );
 517 my @get_orders = GetOrders($basketno);
 518 (
 519     $test_missing_fields,   $test_extra_fields,
 520     $test_different_fields, $test_nbr_fields
 521   )
 522   = _check_fields_of_orders( \@expectedfields, \@order_content, \@get_orders );
 523 is(
 524     $$test_nbr_fields[0],
 525     scalar @expectedfields,
 526     "GetOrders gets orders with the right number of fields"
 527 );
 528 is( join( " ", @$test_missing_fields ),
 529     '', "GetOrders gets orders with no missing fields" );
 530 is( join( " ", @$test_extra_fields ),
 531     '', "GetOrders gets orders with no unexpected fields" );
 532 is( join( " ", @$test_different_fields ),
 533     '', "GetOrders gets orders with the right content in every fields" );
 534 ok(
 535     (
 536         ( scalar @get_orders == 4 )
 537           and !grep ( $_->{ordernumber} eq $ordernumbers[3], @get_orders )
 538     ),
 539     "GetOrders only gets non-cancelled orders"
 540 );
 541
 542 #
 543 # Test GetOrders { cancelled => 1 }
 544 #
 545
 546 @expectedfields =
 547   ( @base_expectedfields, ( 'transferred_to_timestamp', 'transferred_to' ) );
 548 @get_orders = GetOrders($basketno, { cancelled => 1 });
 549 (
 550     $test_missing_fields,   $test_extra_fields,
 551     $test_different_fields, $test_nbr_fields
 552   )
 553   = _check_fields_of_orders( \@expectedfields, \@order_content, \@get_orders );
 554 is(
 555     $$test_nbr_fields[0],
 556     scalar @expectedfields,
 557     "GetOrders { cancelled => 1 } gets orders with the right number of fields"
 558 );
 559 is( join( " ", @$test_missing_fields ),
 560     '', "GetOrders { cancelled => 1 } gets orders with no missing fields" );
 561 is( join( " ", @$test_extra_fields ),
 562     '', "GetOrders { cancelled => 1 } gets orders with no unexpected fields" );
 563 is( join( " ", @$test_different_fields ),
 564     '',
 565     "GetOrders { cancelled => 1 } gets orders with the right content in every fields" );
 566 ok(
 567     (
 568         ( scalar @get_orders == 1 )
 569           and grep ( $_->{ordernumber} eq $ordernumbers[3], @get_orders )
 570     ),
 571     "GetOrders { cancelled => 1 } only gets cancelled orders"
 572 );
 573
 574 #
 575 # Test SearchOrders
 576 #
 577
 578 @expectedfields = qw (
 579   order_internalnote
 580   order_vendornote
 581   notes
 582   basketgroupid
 583   basketgroupname
 584   firstname
 585   biblioitemnumber
 586   ecost
 587   uncertainprice
 588   creationdate
 589   datereceived
 590   orderstatus
 591   line_item_id
 592   suppliers_reference_number
 593   suppliers_reference_qualifier
 594   suppliers_report
 595   isbn
 596   copyrightdate
 597   gstrate
 598   serial
 599   listprice
 600   budgetdate
 601   basketno
 602   discount
 603   surname
 604   freight
 605   abstract
 606   title
 607   closedate
 608   basketname
 609   invoiceid
 610   author
 611   parent_ordernumber
 612   claims_count
 613   entrydate
 614   currency
 615   quantityreceived
 616   seriestitle
 617   sort1_authcat
 618   timestamp
 619   biblionumber
 620   unititle
 621   sort2_authcat
 622   rrp
 623   unitprice
 624   sort1
 625   ordernumber
 626   datecreated
 627   purchaseordernumber
 628   quantity
 629   claimed_date
 630   subscriptionid
 631   frameworkcode
 632   sort2
 633   datecancellationprinted
 634   budget_id
 635   authorisedby
 636   booksellerid
 637   cancellationreason
 638 );
 639
 640 # note that authorisedby was added to the return of SearchOrder by the
 641 # patch for bug 11777
 642
 643 my $invoiceid = AddInvoice(
 644     invoicenumber => 'invoice',
 645     booksellerid  => $booksellerid,
 646     unknown       => "unknown"
 647 );
 648
 649 my ($datereceived, $new_ordernumber) = ModReceiveOrder(
 650     {
 651         biblionumber      => $biblionumber4,
 652         ordernumber       => $ordernumbers[4],
 653         quantityreceived  => 1,
 654         cost              => 10,
 655         ecost             => 10,
 656         invoiceid         => $invoiceid,
 657         rrp               => 10,
 658         budget_id          => $order_content[4]->{str}->{budget_id},
 659     }
 660 );
 661
 662 my $search_orders = SearchOrders({
 663     booksellerid => $booksellerid,
 664     basketno     => $basketno
 665 });
 666 isa_ok( $search_orders, 'ARRAY' );
 667 (
 668     $test_missing_fields,   $test_extra_fields,
 669     $test_different_fields, $test_nbr_fields
 670   )
 671   = _check_fields_of_orders( \@expectedfields, \@order_content,
 672     $search_orders );
 673 is(
 674     $$test_nbr_fields[0],
 675     scalar @expectedfields,
 676     "SearchOrders gets orders with the right number of fields"
 677 );
 678 is( join( " ", @$test_missing_fields ),
 679     '', "SearchOrders gets orders with no missing fields" );
 680 is( join( " ", @$test_extra_fields ),
 681     '', "SearchOrders gets orders with no unexpected fields" );
 682 is( join( " ", @$test_different_fields ),
 683     '', "SearchOrders gets orders with the right content in every fields" );
 684 ok(
 685     (
 686         ( scalar @$search_orders == 4 )
 687           and !grep ( $_->{ordernumber} eq $ordernumbers[3], @$search_orders )
 688     ),
 689     "SearchOrders only gets non-cancelled orders"
 690 );
 691
 692 $search_orders = SearchOrders({
 693     booksellerid => $booksellerid,
 694     basketno     => $basketno,
 695     pending      => 1
 696 });
 697 ok(
 698     (
 699         ( scalar @$search_orders == 3 ) and !grep ( (
 700                      ( $_->{ordernumber} eq $ordernumbers[3] )
 701                   or ( $_->{ordernumber} eq $ordernumbers[4] )
 702             ),
 703             @$search_orders )
 704     ),
 705     "SearchOrders with pending params gets only pending orders (bug 10723)"
 706 );
 707
 708 $search_orders = SearchOrders({
 709     booksellerid => $booksellerid,
 710     basketno     => $basketno,
 711     pending      => 1,
 712     ordered      => 1,
 713 });
 714 is( scalar (@$search_orders), 0, "SearchOrders with pending and ordered params gets only pending ordered orders (bug 11170)" );
 715
 716 $search_orders = SearchOrders({
 717     ordernumber => $ordernumbers[4]
 718 });
 719 is( scalar (@$search_orders), 1, "SearchOrders takes into account the ordernumber filter" );
 720
 721 $search_orders = SearchOrders({
 722     biblionumber => $biblionumber4
 723 });
 724 is( scalar (@$search_orders), 1, "SearchOrders takes into account the biblionumber filter" );
 725
 726 $search_orders = SearchOrders({
 727     biblionumber => $biblionumber4,
 728     pending      => 1
 729 });
 730 is( scalar (@$search_orders), 0, "SearchOrders takes into account the biblionumber and pending filters" );
 731
 732 #
 733 # Test GetBudgetByOrderNumber
 734 #
 735 ok( GetBudgetByOrderNumber( $ordernumbers[0] )->{'budget_id'} eq $budgetid,
 736     "GetBudgetByOrderNumber returns expected budget" );
 737
 738 #
 739 # Test GetLateOrders
 740 #
 741
 742 @expectedfields = qw (
 743   orderdate
 744   author
 745   budget
 746   supplierid
 747   claims_count
 748   supplier
 749   publisher
 750   ordernumber
 751   quantity
 752   basketno
 753   claimed_date
 754   branch
 755   estimateddeliverydate
 756   title
 757   publicationyear
 758   unitpricelib
 759   unitpricesupplier
 760   subtotal
 761   latesince
 762   basketname
 763   basketgroupid
 764   basketgroupname
 765 );
 766 my @lateorders = GetLateOrders(0);
 767 is( scalar grep ( $_->{basketno} eq $basketno, @lateorders ),
 768     0, "GetLateOrders does not get orders from opened baskets" );
 769 C4::Acquisition::CloseBasket($basketno);
 770 @lateorders = GetLateOrders(0);
 771 isnt( scalar grep ( $_->{basketno} eq $basketno, @lateorders ),
 772     0, "GetLateOrders gets orders from closed baskets" );
 773 ok( !grep ( $_->{ordernumber} eq $ordernumbers[3], @lateorders ),
 774     "GetLateOrders does not gets cancelled orders" );
 775 ok( !grep ( $_->{ordernumber} eq $ordernumbers[4], @lateorders ),
 776     "GetLateOrders does not gets reveived orders" );
 777 (
 778     $test_missing_fields,   $test_extra_fields,
 779     $test_different_fields, $test_nbr_fields
 780   )
 781   = _check_fields_of_orders( \@expectedfields, \@order_content, \@lateorders );
 782 is(
 783     $$test_nbr_fields[0],
 784     scalar @expectedfields,
 785     "GetLateOrders gets orders with the right number of fields"
 786 );
 787 is( join( " ", @$test_missing_fields ),
 788     '', "GetLateOrders gets orders with no missing fields" );
 789 is( join( " ", @$test_extra_fields ),
 790     '', "GetLateOrders gets orders with no unexpected fields" );
 791 is( join( " ", @$test_different_fields ),
 792     '', "GetLateOrders gets orders with the right content in every fields" );
 793
 794 $search_orders = SearchOrders({
 795     booksellerid => $booksellerid,
 796     basketno     => $basketno,
 797     pending      => 1,
 798     ordered      => 1,
 799 });
 800 is( scalar (@$search_orders), 3, "SearchOrders with pending and ordered params gets only pending ordered orders. After closing the basket, orders are marked as 'ordered' (bug 11170)" );
 801
 802 #
 803 # Test AddClaim
 804 #
 805
 806 my $order = $lateorders[0];
 807 AddClaim( $order->{ordernumber} );
 808 my $neworder = GetOrder( $order->{ordernumber} );
 809 is(
 810     $neworder->{claimed_date},
 811     strftime( "%Y-%m-%d", localtime(time) ),
 812     "AddClaim : Check claimed_date"
 813 );
 814
 815 ( $datereceived, $new_ordernumber ) = ModReceiveOrder(
 816     {
 817         biblionumber     => $biblionumber2,
 818         ordernumber      => $ordernumbers[1],
 819         quantityreceived => 2,
 820         cost             => 12,
 821         ecost            => 12,
 822         invoiceid        => $invoiceid,
 823         rrp              => 42,
 824         order_internalnote => "my notes",
 825         order_vendornote   => "my vendor notes",
 826     }
 827 );
 828 my $order2 = GetOrder( $ordernumbers[1] );
 829 is( $order2->{'quantityreceived'},
 830     0, 'Splitting up order did not receive any on original order' );
 831 is( $order2->{'quantity'}, 40, '40 items on original order' );
 832 is( $order2->{'budget_id'}, $budgetid,
 833     'Budget on original order is unchanged' );
 834 is( $order2->{order_internalnote}, "my notes",
 835     'ModReceiveOrder and GetOrder deal with internal notes' );
 836 is( $order2->{order_vendornote}, "my vendor notes",
 837     'ModReceiveOrder and GetOrder deal with vendor notes' );
 838
 839 $neworder = GetOrder($new_ordernumber);
 840 is( $neworder->{'quantity'}, 2, '2 items on new order' );
 841 is( $neworder->{'quantityreceived'},
 842     2, 'Splitting up order received items on new order' );
 843 is( $neworder->{'budget_id'}, $budgetid, 'Budget on new order is unchanged' );
 844
 845 is( $neworder->{ordernumber}, $new_ordernumber, 'Split: test ordernumber' );
 846 is( $neworder->{parent_ordernumber}, $ordernumbers[1], 'Split: test parent_ordernumber' );
 847
 848 my $orders = GetHistory( ordernumber => $ordernumbers[1] );
 849 is( scalar( @$orders ), 1, 'GetHistory with a given ordernumber returns 1 order' );
 850 $orders = GetHistory( ordernumber => $ordernumbers[1], search_children_too => 1 );
 851 is( scalar( @$orders ), 2, 'GetHistory with a given ordernumber and search_children_too set returns 2 orders' );
 852
 853 my $budgetid2 = C4::Budgets::AddBudget(
 854     {
 855         budget_code => "budget_code_test_modrecv",
 856         budget_name => "budget_name_test_modrecv",
 857     }
 858 );
 859
 860 ( $datereceived, $new_ordernumber ) = ModReceiveOrder(
 861     {
 862         biblionumber     => $biblionumber2,
 863         ordernumber      => $ordernumbers[2],
 864         quantityreceived => 2,
 865         cost             => 12,
 866         ecost            => 12,
 867         invoiceid        => $invoiceid,
 868         rrp              => 42,
 869         budget_id        => $budgetid2,
 870         order_internalnote => "my other notes",
 871     }
 872 );
 873
 874 my $order3 = GetOrder( $ordernumbers[2] );
 875 is( $order3->{'quantityreceived'},
 876     0, 'Splitting up order did not receive any on original order' );
 877 is( $order3->{'quantity'}, 2, '2 items on original order' );
 878 is( $order3->{'budget_id'}, $budgetid,
 879     'Budget on original order is unchanged' );
 880 is( $order3->{order_internalnote}, "my other notes",
 881     'ModReceiveOrder and GetOrder deal with notes' );
 882
 883 $neworder = GetOrder($new_ordernumber);
 884 is( $neworder->{'quantity'}, 2, '2 items on new order' );
 885 is( $neworder->{'quantityreceived'},
 886     2, 'Splitting up order received items on new order' );
 887 is( $neworder->{'budget_id'}, $budgetid2, 'Budget on new order is changed' );
 888
 889 ( $datereceived, $new_ordernumber ) = ModReceiveOrder(
 890     {
 891         biblionumber     => $biblionumber2,
 892         ordernumber      => $ordernumbers[2],
 893         quantityreceived => 2,
 894         cost             => 12,
 895         ecost            => 12,
 896         invoiceid        => $invoiceid,
 897         rrp              => 42,
 898         budget_id        => $budgetid2,
 899         order_internalnote => "my third notes",
 900     }
 901 );
 902
 903 $order3 = GetOrder( $ordernumbers[2] );
 904 is( $order3->{'quantityreceived'}, 2,          'Order not split up' );
 905 is( $order3->{'quantity'},         2,          '2 items on order' );
 906 is( $order3->{'budget_id'},        $budgetid2, 'Budget has changed' );
 907 is( $order3->{order_internalnote}, "my third notes", 'ModReceiveOrder and GetOrder deal with notes' );
 908
 909 my $nonexistent_order = GetOrder();
 910 is( $nonexistent_order, undef, 'GetOrder returns undef if no ordernumber is given' );
 911 $nonexistent_order = GetOrder( 424242424242 );
 912 is( $nonexistent_order, undef, 'GetOrder returns undef if a nonexistent ordernumber is given' );
 913
 914 # Tests for DelOrder
 915 my $order1 = GetOrder($ordernumbers[0]);
 916 my $error = DelOrder($order1->{biblionumber}, $order1->{ordernumber});
 917 ok((not defined $error), "DelOrder does not fail");
 918 $order1 = GetOrder($order1->{ordernumber});
 919 ok((defined $order1->{datecancellationprinted}), "order is cancelled");
 920 ok((not defined $order1->{cancellationreason}), "order has no cancellation reason");
 921 ok((defined GetBiblio($order1->{biblionumber})), "biblio still exists");
 922
 923 $order2 = GetOrder($ordernumbers[1]);
 924 $error = DelOrder($order2->{biblionumber}, $order2->{ordernumber}, 1);
 925 ok((not defined $error), "DelOrder does not fail");
 926 $order2 = GetOrder($order2->{ordernumber});
 927 ok((defined $order2->{datecancellationprinted}), "order is cancelled");
 928 ok((not defined $order2->{cancellationreason}), "order has no cancellation reason");
 929 ok((not defined GetBiblio($order2->{biblionumber})), "biblio does not exist anymore");
 930
 931 my $order4 = GetOrder($ordernumbers[3]);
 932 $error = DelOrder($order4->{biblionumber}, $order4->{ordernumber}, 1, "foobar");
 933 ok((not defined $error), "DelOrder does not fail");
 934 $order4 = GetOrder($order4->{ordernumber});
 935 ok((defined $order4->{datecancellationprinted}), "order is cancelled");
 936 ok(($order4->{cancellationreason} eq "foobar"), "order has cancellation reason \"foobar\"");
 937 ok((not defined GetBiblio($order4->{biblionumber})), "biblio does not exist anymore");
 938 # End of tests for DelOrder
 939
 940 subtest 'ModOrder' => sub {
 941     plan tests => 1;
 942     ModOrder( { ordernumber => $order1->{ordernumber}, unitprice => 42 } );
 943     my $order = GetOrder( $order1->{ordernumber} );
 944     is( int($order->{unitprice}), 42, 'ModOrder should work even if biblionumber if not passed');
 945 };
 946
 947 # Budget reports
 948 my $all_count = scalar GetBudgetsReport();
 949 ok($all_count >= 1, "GetBudgetReport OK");
 950
 951 my $active_count = scalar GetBudgetsReport(1);
 952 ok($active_count >= 1 , "GetBudgetsReport(1) OK");
 953
 954 is($all_count, scalar GetBudgetsReport(), "GetBudgetReport returns inactive budget period acquisitions.");
 955 ok($active_count >= scalar GetBudgetsReport(1), "GetBudgetReport doesn't return inactive budget period acquisitions.");
 956
 957 $schema->storage->txn_rollback();