t/db_dependent/Acquisition.t

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