t/db_dependent/Koha/Acquisition/Order.t

   1 #!/usr/bin/perl
   2
   3 # Copyright 2017 Koha Development team
   4 #
   5 # This file is part of Koha
   6 #
   7 # Koha is free software; you can redistribute it and/or modify it
   8 # under the terms of the GNU General Public License as published by
   9 # the Free Software Foundation; either version 3 of the License, or
  10 # (at your option) any later version.
  11 #
  12 # Koha is distributed in the hope that it will be useful, but
  13 # WITHOUT ANY WARRANTY; without even the implied warranty of
  14 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  15 # GNU General Public License for more details.
  16 #
  17 # You should have received a copy of the GNU General Public License
  18 # along with Koha; if not, see <http://www.gnu.org/licenses>.
  19
  20 use Modern::Perl;
  21
  22 use Test::More tests => 12;
  23 use Test::Exception;
  24
  25 use t::lib::TestBuilder;
  26 use t::lib::Mocks;
  27
  28 use C4::Circulation;
  29
  30 use Koha::Biblios;
  31 use Koha::Database;
  32 use Koha::DateUtils qw(dt_from_string);
  33 use Koha::Items;
  34
  35 my $schema  = Koha::Database->schema;
  36 my $builder = t::lib::TestBuilder->new;
  37
  38 subtest 'basket() tests' => sub {
  39
  40     plan tests => 2;
  41
  42     $schema->storage->txn_begin;
  43
  44     my $basket = $builder->build_object(
  45         {
  46             class => 'Koha::Acquisition::Baskets'
  47         }
  48     );
  49     my $order = $builder->build_object(
  50         {
  51             class => 'Koha::Acquisition::Orders',
  52             value => { basketno => $basket->basketno }
  53         }
  54     );
  55
  56     my $retrieved_basket = $order->basket;
  57     is( ref($retrieved_basket), 'Koha::Acquisition::Basket',
  58         'Type is correct for ->basket' );
  59     is_deeply( $retrieved_basket->unblessed,
  60         $basket->unblessed, "Correct basket found and updated" );
  61
  62     $schema->storage->txn_rollback;
  63 };
  64
  65 subtest 'biblio() tests' => sub {
  66
  67     plan tests => 5;
  68
  69     $schema->storage->txn_begin;
  70
  71     my $order = $builder->build_object(
  72         {
  73             class => 'Koha::Acquisition::Orders',
  74             value => { biblionumber => undef }
  75         }
  76     );
  77
  78     is( $order->biblio, undef, 'If no linked biblio, undef is returned' );
  79
  80     # Add and link a biblio to the order
  81     my $biblio = $builder->build_sample_biblio();
  82     $order->set({ biblionumber => $biblio->biblionumber })->store->discard_changes;
  83
  84     my $THE_biblio = $order->biblio;
  85     is( ref($THE_biblio), 'Koha::Biblio', 'Returns a Koha::Biblio object' );
  86     is( $THE_biblio->biblionumber, $biblio->biblionumber, 'It is not cheating about the object' );
  87
  88     $order->biblio->delete;
  89     $order = Koha::Acquisition::Orders->find($order->ordernumber);
  90     ok( $order, 'The order is not deleted if the biblio is deleted' );
  91     is( $order->biblio, undef, 'order.biblio is correctly set to NULL when the biblio is deleted' );
  92
  93     $schema->storage->txn_rollback;
  94 };
  95
  96 subtest 'store' => sub {
  97     plan tests => 1;
  98
  99     $schema->storage->txn_begin;
 100     my $o = $builder->build_object(
 101         {
 102             class => 'Koha::Acquisition::Orders'
 103         }
 104     );
 105
 106     subtest 'entrydate' => sub {
 107         plan tests => 2;
 108
 109         my $order;
 110
 111         t::lib::Mocks::mock_preference( 'TimeFormat', '12hr' );
 112         $order = Koha::Acquisition::Order->new(
 113             {
 114                 basketno     => $o->basketno,
 115                 biblionumber => $o->biblionumber,
 116                 budget_id    => $o->budget_id,
 117                 quantity     => 1,
 118             }
 119         )->store;
 120         $order->discard_changes;
 121         like( $order->entrydate, qr|^\d{4}-\d{2}-\d{2}$| );
 122
 123         t::lib::Mocks::mock_preference( 'TimeFormat', '24hr' );
 124         $order = Koha::Acquisition::Order->new(
 125             {
 126                 basketno     => $o->basketno,
 127                 biblionumber => $o->biblionumber,
 128                 budget_id    => $o->budget_id,
 129                 quantity     => 1,
 130             }
 131         )->store;
 132         $order->discard_changes;
 133         like( $order->entrydate, qr|^\d{4}-\d{2}-\d{2}$| );
 134     };
 135     $schema->storage->txn_rollback;
 136 };
 137
 138 subtest 'fund' => sub {
 139     plan tests => 1;
 140
 141     $schema->storage->txn_begin;
 142     my $o = $builder->build_object(
 143         {
 144             class => 'Koha::Acquisition::Orders',
 145         }
 146     );
 147
 148     my $order = Koha::Acquisition::Orders->find( $o->ordernumber );
 149     is( ref( $order->fund ),
 150         'Koha::Acquisition::Fund',
 151         '->fund should return a Koha::Acquisition::Fund object' );
 152     $schema->storage->txn_rollback;
 153 };
 154
 155 subtest 'invoice' => sub {
 156     plan tests => 2;
 157
 158     $schema->storage->txn_begin;
 159     my $o = $builder->build_object(
 160         {
 161             class => 'Koha::Acquisition::Orders',
 162             value => { cancellationreason => 'XXXXXXXX', invoiceid => undef }, # not received yet
 163         }
 164     );
 165
 166     my $order = Koha::Acquisition::Orders->find( $o->ordernumber );
 167     is( $order->invoice, undef,
 168         '->invoice should return undef if no invoice defined yet');
 169
 170     my $invoice = $builder->build_object(
 171         {
 172             class => 'Koha::Acquisition::Invoices',
 173         },
 174     );
 175
 176     $o->invoiceid( $invoice->invoiceid )->store;
 177     $order = Koha::Acquisition::Orders->find( $o->ordernumber );
 178     is( ref( $order->invoice ), 'Koha::Acquisition::Invoice',
 179         '->invoice should return a Koha::Acquisition::Invoice object if an invoice is defined');
 180
 181     $schema->storage->txn_rollback;
 182 };
 183
 184 subtest 'subscription' => sub {
 185     plan tests => 2;
 186
 187     $schema->storage->txn_begin;
 188     my $o = $builder->build_object(
 189         {
 190             class => 'Koha::Acquisition::Orders',
 191             value => { subscriptionid => undef }, # not linked to a subscription
 192         }
 193     );
 194
 195     my $order = Koha::Acquisition::Orders->find( $o->ordernumber );
 196     is( $order->subscription, undef,
 197         '->subscription should return undef if not created from a subscription');
 198
 199     $o = $builder->build_object(
 200         {
 201             class => 'Koha::Acquisition::Orders',
 202             # Will be linked to a subscription by TestBuilder
 203         }
 204     );
 205
 206     $order = Koha::Acquisition::Orders->find( $o->ordernumber );
 207     is( ref( $order->subscription ), 'Koha::Subscription',
 208         '->subscription should return a Koha::Subscription object if created from a subscription');
 209
 210     $schema->storage->txn_rollback;
 211 };
 212
 213 subtest 'duplicate_to | add_item' => sub {
 214     plan tests => 3;
 215
 216     $schema->storage->txn_begin;
 217
 218     my $item = $builder->build_sample_item;
 219     my $order_no_sub = $builder->build_object(
 220         {
 221             class => 'Koha::Acquisition::Orders',
 222             value =>
 223               {
 224                   biblionumber => $item->biblionumber,
 225                   subscriptionid => undef, # not linked to a subscription
 226               }
 227         }
 228     );
 229     $order_no_sub->basket->create_items(undef)->store; # use syspref
 230     $order_no_sub->add_item( $item->itemnumber );
 231
 232     $item = $builder->build_sample_item;
 233     my $order_from_sub = $builder->build_object(
 234         {
 235             class => 'Koha::Acquisition::Orders',
 236             value =>
 237               {
 238                   biblionumber => $item->biblionumber,
 239                   # Will be linked to a subscription by TestBuilder
 240               }
 241         }
 242     );
 243     $order_from_sub->basket->create_items(undef)->store; # use syspref
 244     $order_from_sub->add_item( $item->itemnumber );
 245
 246     my $basket_to = $builder->build_object(
 247          { class => 'Koha::Acquisition::Baskets' });
 248
 249     subtest 'Create item on receiving' => sub {
 250         plan tests => 2;
 251
 252         t::lib::Mocks::mock_preference('AcqCreateItem', 'receiving');
 253
 254         my $duplicated_order = $order_no_sub->duplicate_to($basket_to);
 255         is( $duplicated_order->items->count, 0,
 256             'Items should not be copied if the original order did not create items on ordering'
 257         );
 258
 259         $duplicated_order = $order_from_sub->duplicate_to($basket_to);
 260         is( $duplicated_order->items->count, 0,
 261             'Items should not be copied if the original order is created from a subscription'
 262         );
 263     };
 264
 265     subtest 'Create item on ordering' => sub {
 266         plan tests => 2;
 267
 268         t::lib::Mocks::mock_preference('AcqCreateItem', 'ordering');
 269
 270         my $duplicated_order = $order_no_sub->duplicate_to($basket_to);
 271         is( $duplicated_order->items->count, 1,
 272             'Items should be copied if items are created on ordering'
 273         );
 274
 275         $duplicated_order = $order_from_sub->duplicate_to($basket_to);
 276         is( $duplicated_order->items->count, 0,
 277             'Items should never be copied if the original order is created from a subscription'
 278         );
 279     };
 280
 281     subtest 'Regression tests' => sub {
 282         plan tests => 1;
 283
 284         my $duplicated_order = $order_no_sub->duplicate_to($basket_to);
 285         is($duplicated_order->invoiceid, undef, "invoiceid should be set to null for a new duplicated order");
 286     };
 287
 288     $schema->storage->txn_rollback;
 289 };
 290
 291 subtest 'current_item_level_holds() tests' => sub {
 292
 293     plan tests => 5;
 294
 295     $schema->storage->txn_begin;
 296
 297     my $patron = $builder->build_object( { class => 'Koha::Patrons' } );
 298     my $biblio = $builder->build_sample_biblio();
 299     my $item_1 = $builder->build_sample_item( { biblionumber => $biblio->biblionumber } );
 300     my $item_2 = $builder->build_sample_item( { biblionumber => $biblio->biblionumber } );
 301     my $item_3 = $builder->build_sample_item( { biblionumber => $biblio->biblionumber } );
 302
 303     C4::Reserves::AddReserve(
 304         {
 305             branchcode       => $patron->branchcode,
 306             borrowernumber   => $patron->borrowernumber,
 307             biblionumber     => $biblio->biblionumber,
 308             reservation_date => dt_from_string->add( days => -2 ),
 309             itemnumber       => $item_1->itemnumber,
 310         }
 311     );
 312     C4::Reserves::AddReserve(
 313         {
 314             branchcode       => $patron->branchcode,
 315             borrowernumber   => $patron->borrowernumber,
 316             biblionumber     => $biblio->biblionumber,
 317             reservation_date => dt_from_string->add( days => -2 ),
 318             itemnumber       => $item_2->itemnumber,
 319         }
 320     );
 321     # Add a hold in the future
 322     C4::Reserves::AddReserve(
 323         {
 324             branchcode       => $patron->branchcode,
 325             borrowernumber   => $patron->borrowernumber,
 326             biblionumber     => $biblio->biblionumber,
 327             reservation_date => dt_from_string->add( days => 2 ),
 328             itemnumber       => $item_3->itemnumber,
 329         }
 330     );
 331
 332     # Add an order with no biblionumber
 333     my $order = $builder->build_object(
 334         {
 335             class => 'Koha::Acquisition::Orders',
 336             value => {
 337                 biblionumber => undef
 338             }
 339         }
 340     );
 341
 342     my $holds = $order->current_item_level_holds;
 343
 344     is( ref($holds), 'Koha::Holds', 'Koha::Holds iterator returned if no linked biblio' );
 345     is( $holds->count, 0, 'Count is 0 if no linked biblio' );
 346
 347     $order->set({ biblionumber => $biblio->biblionumber })->store->discard_changes;
 348
 349     $holds = $order->current_item_level_holds;
 350
 351     is( ref($holds), 'Koha::Holds', 'Koha::Holds iterator returned if no linked items' );
 352     is( $holds->count, 0, 'Count is 0 if no linked items' );
 353
 354     $order->add_item( $item_2->itemnumber );
 355     $order->add_item( $item_3->itemnumber );
 356
 357     $holds = $order->current_item_level_holds;
 358     is( $holds->count, 1, 'Only current (not future) holds are returned');
 359
 360     $schema->storage->txn_rollback;
 361 };
 362
 363 subtest 'claim*' => sub {
 364     plan tests => 6;
 365
 366     $schema->storage->txn_begin;
 367     my $order = $builder->build_object(
 368         {
 369             class => 'Koha::Acquisition::Orders',
 370         }
 371     );
 372
 373     my $now = dt_from_string;
 374     is( $order->claims->count, 0, 'No claim yet, ->claims should return an empty set');
 375     is( $order->claims_count, 0, 'No claim yet, ->claims_count should return 0');
 376     is( $order->claimed_date, undef, 'No claim yet, ->claimed_date should return undef');
 377
 378     my $claim_1 = $order->claim;
 379     my $claim_2 = $order->claim;
 380
 381     $claim_1->claimed_on($now->clone->subtract(days => 1))->store;
 382     $claim_2->claimed_on($now)->store;
 383
 384     is( $order->claims->count, 2, '->claims should return the correct number of claims');
 385     is( $order->claims_count, 2, '->claims_count should return the correct number of claims');
 386     is( dt_from_string($order->claimed_date), $now, '->claimed_date should return the date of the last claim');
 387
 388     $schema->storage->txn_rollback;
 389 };
 390
 391 subtest 'filter_by_late' => sub {
 392     plan tests => 16;
 393
 394     $schema->storage->txn_begin;
 395     my $now        = dt_from_string;
 396     my $bookseller = $builder->build_object(
 397         {
 398             class => 'Koha::Acquisition::Booksellers',
 399             value => { deliverytime => 2 }
 400         }
 401     );
 402     my $basket_1 = $builder->build_object(
 403         {
 404             class => 'Koha::Acquisition::Baskets',
 405             value => {
 406                 booksellerid => $bookseller->id,
 407                 closedate    => undef,
 408             }
 409         }
 410     );
 411     my $order_1 = $builder->build_object(
 412         {
 413             class => 'Koha::Acquisition::Orders',
 414             value => {
 415                 basketno                => $basket_1->basketno,
 416                 datereceived            => undef,
 417                 datecancellationprinted => undef,
 418             }
 419         }
 420     );
 421     my $basket_2 = $builder->build_object(    # expected tomorrow
 422         {
 423             class => 'Koha::Acquisition::Baskets',
 424             value => {
 425                 booksellerid => $bookseller->id,
 426                 closedate    => $now->clone->subtract( days => 1 ),
 427             }
 428         }
 429     );
 430     my $order_2 = $builder->build_object(
 431         {
 432             class => 'Koha::Acquisition::Orders',
 433             value => {
 434                 basketno                => $basket_2->basketno,
 435                 datereceived            => undef,
 436                 datecancellationprinted => undef,
 437             }
 438         }
 439     );
 440     my $basket_3 = $builder->build_object(    # expected yesterday (1 day)
 441         {
 442             class => 'Koha::Acquisition::Baskets',
 443             value => {
 444                 booksellerid => $bookseller->id,
 445                 closedate    => $now->clone->subtract( days => 3 ),
 446             }
 447         }
 448     );
 449     my $order_3 = $builder->build_object(
 450         {
 451             class => 'Koha::Acquisition::Orders',
 452             value => {
 453                 basketno                => $basket_3->basketno,
 454                 datereceived            => undef,
 455                 datecancellationprinted => undef,
 456             }
 457         }
 458     );
 459     my $basket_4 = $builder->build_object(    # expected 3 days ago
 460         {
 461             class => 'Koha::Acquisition::Baskets',
 462             value => {
 463                 booksellerid => $bookseller->id,
 464                 closedate    => $now->clone->subtract( days => 5 ),
 465             }
 466         }
 467     );
 468     my $order_4 = $builder->build_object(
 469         {
 470             class => 'Koha::Acquisition::Orders',
 471             value => {
 472                 basketno                => $basket_4->basketno,
 473                 datereceived            => undef,
 474                 datecancellationprinted => undef,
 475             }
 476         }
 477     );
 478
 479     my $orders = Koha::Acquisition::Orders->search(
 480         {
 481             ordernumber => {
 482                 -in => [
 483                     $order_1->ordernumber, $order_2->ordernumber,
 484                     $order_3->ordernumber, $order_4->ordernumber,
 485                 ]
 486             }
 487         }
 488     );
 489
 490     my $late_orders = $orders->filter_by_lates;
 491     is( $late_orders->count, 3 );
 492
 493     $late_orders = $orders->filter_by_lates( { delay => 0 } );
 494     is( $late_orders->count, 3 );
 495
 496     $late_orders = $orders->filter_by_lates( { delay => 1 } );
 497     is( $late_orders->count, 3 );
 498
 499     $late_orders = $orders->filter_by_lates( { delay => 3 } );
 500     is( $late_orders->count, 2 );
 501
 502     $late_orders = $orders->filter_by_lates( { delay => 4 } );
 503     is( $late_orders->count, 1 );
 504
 505     $late_orders = $orders->filter_by_lates( { delay => 5 } );
 506     is( $late_orders->count, 1 );
 507
 508     $late_orders = $orders->filter_by_lates( { delay => 6 } );
 509     is( $late_orders->count, 0 );
 510
 511     $late_orders = $orders->filter_by_lates(
 512         { estimated_from => $now->clone->subtract( days => 6 ) } );
 513     is( $late_orders->count,             2 );
 514     is( $late_orders->next->ordernumber, $order_3->ordernumber );
 515
 516     $late_orders = $orders->filter_by_lates(
 517         { estimated_from => $now->clone->subtract( days => 5 ) } );
 518     is( $late_orders->count,             2 );
 519     is( $late_orders->next->ordernumber, $order_3->ordernumber );
 520
 521     $late_orders = $orders->filter_by_lates(
 522         { estimated_from => $now->clone->subtract( days => 4 ) } );
 523     is( $late_orders->count,             2 );
 524     is( $late_orders->next->ordernumber, $order_3->ordernumber );
 525
 526     $late_orders = $orders->filter_by_lates(
 527         { estimated_from => $now->clone->subtract( days => 3 ) } );
 528     is( $late_orders->count, 2 );
 529
 530     $late_orders = $orders->filter_by_lates(
 531         { estimated_from => $now->clone->subtract( days => 1 ) } );
 532     is( $late_orders->count, 1 );
 533
 534     $late_orders = $orders->filter_by_lates(
 535         {
 536             estimated_from => $now->clone->subtract( days => 4 ),
 537             estimated_to   => $now->clone->subtract( days => 3 )
 538         }
 539     );
 540     is( $late_orders->count, 1 );
 541
 542     $schema->storage->txn_rollback;
 543 };
 544
 545 subtest 'filter_by_current & filter_by_cancelled' => sub {
 546     plan tests => 2;
 547
 548     $schema->storage->txn_begin;
 549     my $now        = dt_from_string;
 550     my $order_1 = $builder->build_object(
 551         {
 552             class => 'Koha::Acquisition::Orders',
 553             value => {
 554                 datecancellationprinted => undef,
 555             }
 556         }
 557     );
 558     my $order_2 = $builder->build_object(
 559         {
 560             class => 'Koha::Acquisition::Orders',
 561             value => {
 562                 datecancellationprinted => undef,
 563             }
 564         }
 565     );
 566     my $order_3 = $builder->build_object(
 567         {
 568             class => 'Koha::Acquisition::Orders',
 569             value => {
 570                 datecancellationprinted => dt_from_string,
 571             }
 572         }
 573     );
 574
 575     my $orders = Koha::Acquisition::Orders->search(
 576         {
 577             ordernumber => {
 578                 -in => [
 579                     $order_1->ordernumber, $order_2->ordernumber,
 580                     $order_3->ordernumber,
 581                 ]
 582             }
 583         }
 584     );
 585
 586     is( $orders->filter_by_current->count, 2);
 587     is( $orders->filter_by_cancelled->count, 1);
 588
 589
 590     $schema->storage->txn_rollback;
 591 };
 592
 593 subtest 'cancel() tests' => sub {
 594
 595     plan tests => 32;
 596
 597     $schema->storage->txn_begin;
 598
 599     # Scenario:
 600     # * order with one item attached
 601     # * the item is on loan
 602     # * delete_biblio is passed
 603     # => order is not cancelled
 604     # => item in order is not removed
 605     # => biblio in order is not removed
 606     # => message about not being able to delete
 607
 608     my $item      = $builder->build_sample_item;
 609     my $biblio_id = $item->biblio->id;
 610     my $order     = $builder->build_object(
 611         {
 612             class => 'Koha::Acquisition::Orders',
 613             value => {
 614                 orderstatus             => 'new',
 615                 biblionumber            => $item->biblio->id,
 616                 datecancellationprinted => undef,
 617                 cancellationreason      => undef,
 618             }
 619         }
 620     )->reset_messages; # reset them as TestBuilder doesn't call new
 621     $order->add_item( $item->id );
 622
 623     my $patron = $builder->build_object({ class => 'Koha::Patrons' });
 624     t::lib::Mocks::mock_userenv(
 625         { patron => $patron, branchcode => $patron->branchcode } );
 626
 627     # Add a checkout so cancelling fails because od 'book_on_loan'
 628     C4::Circulation::AddIssue( $patron->unblessed, $item->barcode );
 629
 630     my $result = $order->cancel({ reason => 'Some reason' });
 631     # refresh the order object
 632     $order->discard_changes;
 633
 634     is( $result, $order, 'self is returned' );
 635     is( $order->orderstatus, 'cancelled', 'Order is not marked as cancelled' );
 636     isnt( $order->datecancellationprinted, undef, 'datecancellationprinted is not undef' );
 637     is( $order->cancellationreason, 'Some reason', 'cancellationreason is set' );
 638     is( ref(Koha::Items->find($item->id)), 'Koha::Item', 'The item is present' );
 639     is( ref(Koha::Biblios->find($biblio_id)), 'Koha::Biblio', 'The biblio is present' );
 640     my @messages = @{ $order->messages };
 641     is( $messages[0]->message, 'error_delitem', 'An error message is attached to the order' );
 642
 643     # Scenario:
 644     # * order with one item attached
 645     # * the item is no longer on loan
 646     # * delete_biblio not passed
 647     # => order is cancelled
 648     # => item in order is removed
 649     # => biblio remains untouched
 650
 651     C4::Circulation::AddReturn( $item->barcode );
 652
 653     $order->reset_messages;
 654     $order->cancel({ reason => 'Some reason' })
 655           ->discard_changes;
 656
 657     is( $order->orderstatus, 'cancelled', 'Order is marked as cancelled' );
 658     isnt( $order->datecancellationprinted, undef, 'datecancellationprinted is set' );
 659     is( $order->cancellationreason, 'Some reason', 'cancellationreason is undef' );
 660     is( Koha::Items->find($item->id), undef, 'The item is no longer present' );
 661     is( ref(Koha::Biblios->find($biblio_id)), 'Koha::Biblio', 'The biblio is present' );
 662     @messages = @{ $order->messages };
 663     is( scalar @messages, 0, 'No messages' );
 664
 665     # Scenario:
 666     # * order with one item attached
 667     # * biblio has another item
 668     # => order is cancelled
 669     # => item in order is removed
 670     # => the extra item remains untouched
 671     # => biblio remains untouched
 672
 673     my $item_1 = $builder->build_sample_item;
 674     $biblio_id = $item_1->biblio->id;
 675     my $item_2 = $builder->build_sample_item({ biblionumber => $biblio_id });
 676     $order     = $builder->build_object(
 677         {
 678             class => 'Koha::Acquisition::Orders',
 679             value => {
 680                 orderstatus             => 'new',
 681                 biblionumber            => $biblio_id,
 682                 datecancellationprinted => undef,
 683                 cancellationreason      => undef,
 684             }
 685         }
 686     )->reset_messages;
 687     $order->add_item( $item_1->id );
 688
 689     $order->cancel({ reason => 'Some reason', delete_biblio => 1 })
 690           ->discard_changes;
 691
 692     is( $order->orderstatus, 'cancelled', 'Order is marked as cancelled' );
 693     isnt( $order->datecancellationprinted, undef, 'datecancellationprinted is set' );
 694     is( $order->cancellationreason, 'Some reason', 'cancellationreason is undef' );
 695     is( Koha::Items->find($item_1->id), undef, 'The item is no longer present' );
 696     is( ref(Koha::Items->find($item_2->id)), 'Koha::Item', 'The item is still present' );
 697     is( ref(Koha::Biblios->find($biblio_id)), 'Koha::Biblio', 'The biblio is still present' );
 698     @messages = @{ $order->messages };
 699     is( $messages[0]->message, 'error_delbiblio', 'Cannot delete biblio and it gets notified' );
 700
 701     # Scenario:
 702     # * order with one item attached
 703     # * there's another order pointing to the biblio
 704     # => order is cancelled
 705     # => item in order is removed
 706     # => biblio remains untouched
 707     # => biblio delete error notified
 708
 709     $item      = $builder->build_sample_item;
 710     $biblio_id = $item->biblio->id;
 711     $order     = $builder->build_object(
 712         {
 713             class => 'Koha::Acquisition::Orders',
 714             value => {
 715                 orderstatus             => 'new',
 716                 biblionumber            => $biblio_id,
 717                 datecancellationprinted => undef,
 718                 cancellationreason      => undef,
 719             }
 720         }
 721     )->reset_messages;
 722     $order->add_item( $item->id );
 723
 724     # Add another order
 725     $builder->build_object(
 726         {
 727             class => 'Koha::Acquisition::Orders',
 728             value => {
 729                 orderstatus             => 'new',
 730                 biblionumber            => $biblio_id,
 731                 datecancellationprinted => undef,
 732                 cancellationreason      => undef,
 733             }
 734         }
 735     );
 736
 737     $order->cancel({ reason => 'Some reason', delete_biblio => 1 })
 738           ->discard_changes;
 739
 740     is( $order->orderstatus, 'cancelled', 'Order is marked as cancelled' );
 741     isnt( $order->datecancellationprinted, undef, 'datecancellationprinted is set' );
 742     is( $order->cancellationreason, 'Some reason', 'cancellationreason is undef' );
 743     is( Koha::Items->find($item->id), undef, 'The item is no longer present' );
 744     is( ref(Koha::Biblios->find($biblio_id)), 'Koha::Biblio', 'The biblio is still present' );
 745     @messages = @{ $order->messages };
 746     is( $messages[0]->message, 'error_delbiblio', 'Cannot delete biblio and it gets notified' );
 747
 748     # Scenario:
 749     # * order with one item attached
 750     # * there's a subscription on the biblio
 751     # => order is cancelled
 752     # => item in order is removed
 753     # => biblio remains untouched
 754     # => biblio delete error notified
 755
 756     $item      = $builder->build_sample_item;
 757     $biblio_id = $item->biblio->id;
 758     $order     = $builder->build_object(
 759         {
 760             class => 'Koha::Acquisition::Orders',
 761             value => {
 762                 orderstatus             => 'new',
 763                 biblionumber            => $biblio_id,
 764                 datecancellationprinted => undef,
 765                 cancellationreason      => undef,
 766             }
 767         }
 768     )->reset_messages;
 769     $order->add_item( $item->id );
 770
 771     # Add a subscription
 772     $builder->build_object(
 773         {
 774             class => 'Koha::Subscriptions',
 775             value => {
 776                 biblionumber => $biblio_id,
 777             }
 778         }
 779     );
 780
 781     $order->cancel({ reason => 'Some reason', delete_biblio => 1 })
 782           ->discard_changes;
 783
 784     is( $order->orderstatus, 'cancelled', 'Order is marked as cancelled' );
 785     isnt( $order->datecancellationprinted, undef, 'datecancellationprinted is set' );
 786     is( $order->cancellationreason, 'Some reason', 'cancellationreason is undef' );
 787     is( Koha::Items->find($item->id), undef, 'The item is no longer present' );
 788     is( ref(Koha::Biblios->find($biblio_id)), 'Koha::Biblio', 'The biblio is still present' );
 789     @messages = @{ $order->messages };
 790     is( $messages[0]->message, 'error_delbiblio', 'Cannot delete biblio and it gets notified' );
 791
 792     $schema->storage->txn_rollback;
 793 };