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