t/db_dependent/Koha/Objects.t

   1 #!/usr/bin/perl
   2
   3 # Copyright 2019 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 => 24;
  23 use Test::Exception;
  24 use Test::MockModule;
  25 use Test::Warn;
  26
  27 use Koha::Authority::Types;
  28 use Koha::Cities;
  29 use Koha::Biblios;
  30 use Koha::Patron::Category;
  31 use Koha::Patron::Categories;
  32 use Koha::Patrons;
  33 use Koha::Database;
  34 use Koha::DateUtils qw( dt_from_string );
  35
  36 use t::lib::TestBuilder;
  37 use t::lib::Mocks;
  38
  39 use Try::Tiny;
  40
  41 my $schema = Koha::Database->new->schema;
  42 $schema->storage->txn_begin;
  43 my $builder = t::lib::TestBuilder->new;
  44
  45 is( ref(Koha::Authority::Types->find('')), 'Koha::Authority::Type', 'Koha::Objects->find should work if the primary key is an empty string' );
  46
  47 my @columns = Koha::Patrons->columns;
  48 my $borrowernumber_exists = grep { /^borrowernumber$/ } @columns;
  49 is( $borrowernumber_exists, 1, 'Koha::Objects->columns should return the table columns' );
  50
  51 subtest 'find' => sub {
  52     plan tests => 6;
  53     my $patron = $builder->build({source => 'Borrower'});
  54     my $patron_object = Koha::Patrons->find( $patron->{borrowernumber} );
  55     is( $patron_object->borrowernumber, $patron->{borrowernumber}, '->find should return the correct object' );
  56
  57     my @patrons = Koha::Patrons->find( $patron->{borrowernumber} );
  58     is(scalar @patrons, 1, '->find in list context returns a value');
  59     is($patrons[0]->borrowernumber, $patron->{borrowernumber}, '->find in list context returns the same value as in scalar context');
  60
  61     my $patrons = {
  62         foo => Koha::Patrons->find('foo'),
  63         bar => 'baz',
  64     };
  65     is ($patrons->{foo}, undef, '->find in list context returns undef when no record is found');
  66
  67     # Test sending undef to find; should not generate a warning
  68     warning_is { $patron = Koha::Patrons->find( undef ); }
  69         "", "Sending undef does not trigger a DBIx warning";
  70     warning_is { $patron = Koha::Patrons->find( undef, undef ); }
  71         "", "Sending two undefs does not trigger a DBIx warning too";
  72 };
  73
  74 subtest 'update' => sub {
  75     plan tests => 2;
  76
  77     $builder->build( { source => 'City', value => { city_country => 'UK' } } );
  78     $builder->build( { source => 'City', value => { city_country => 'UK' } } );
  79     $builder->build( { source => 'City', value => { city_country => 'UK' } } );
  80     $builder->build( { source => 'City', value => { city_country => 'France' } } );
  81     $builder->build( { source => 'City', value => { city_country => 'France' } } );
  82     $builder->build( { source => 'City', value => { city_country => 'Germany' } } );
  83     Koha::Cities->search( { city_country => 'UK' } )->update( { city_country => 'EU' } );
  84     is( Koha::Cities->search( { city_country => 'EU' } )->count, 3, 'Koha::Objects->update should have updated the 3 rows' );
  85     is( Koha::Cities->search( { city_country => 'UK' } )->count, 0, 'Koha::Objects->update should have updated the 3 rows' );
  86 };
  87
  88 subtest 'reset' => sub {
  89     plan tests => 3;
  90
  91     my $patrons = Koha::Patrons->search;
  92     my $first_borrowernumber = $patrons->next->borrowernumber;
  93     my $second_borrowernumber = $patrons->next->borrowernumber;
  94     is( ref( $patrons->reset ), 'Koha::Patrons', 'Koha::Objects->reset should allow chaining' );
  95     is( ref( $patrons->reset->next ), 'Koha::Patron', 'Koha::Objects->reset should allow chaining' );
  96     is( $patrons->reset->next->borrowernumber, $first_borrowernumber, 'Koha::Objects->reset should work as expected');
  97 };
  98
  99 subtest 'delete' => sub {
 100     plan tests => 2;
 101
 102     my $patron_1 = $builder->build({source => 'Borrower'});
 103     my $patron_2 = $builder->build({source => 'Borrower'});
 104     is( Koha::Patrons->search({ -or => { borrowernumber => [ $patron_1->{borrowernumber}, $patron_2->{borrowernumber}]}})->delete, 2, '');
 105     is( Koha::Patrons->search({ -or => { borrowernumber => [ $patron_1->{borrowernumber}, $patron_2->{borrowernumber}]}})->count, 0, '');
 106 };
 107
 108 subtest 'new' => sub {
 109     plan tests => 2;
 110     my $a_cat_code = 'A_CAT_CODE';
 111     my $patron_category = Koha::Patron::Category->new( { categorycode => $a_cat_code } )->store;
 112     is( Koha::Patron::Categories->find($a_cat_code)->category_type, 'A', 'Koha::Object->new should set the default value' );
 113     Koha::Patron::Categories->find($a_cat_code)->delete;
 114     $patron_category = Koha::Patron::Category->new( { categorycode => $a_cat_code, category_type => undef } )->store;
 115     is( Koha::Patron::Categories->find($a_cat_code)->category_type, 'A', 'Koha::Object->new should set the default value even if the argument exists but is not defined' );
 116     Koha::Patron::Categories->find($a_cat_code)->delete;
 117 };
 118
 119 subtest 'find' => sub {
 120     plan tests => 4;
 121
 122     # check find on a single PK
 123     my $patron = $builder->build({ source => 'Borrower' });
 124     is( Koha::Patrons->find($patron->{borrowernumber})->surname,
 125         $patron->{surname}, "Checking an arbitrary patron column after find"
 126     );
 127     # check find with unique column
 128     my $obj = Koha::Patrons->find($patron->{cardnumber}, { key => 'cardnumber' });
 129     is( $obj->borrowernumber, $patron->{borrowernumber},
 130         'Find with unique column and key specified' );
 131     # check find with an additional where clause in the attrs hash
 132     # we do not expect to find something now
 133     is( Koha::Patrons->find(
 134         $patron->{borrowernumber},
 135         { where => { surname => { '!=', $patron->{surname} }}},
 136     ), undef, 'Additional where clause in find call' );
 137
 138     is( Koha::Patrons->find(), undef, 'Find returns undef if no params passed' );
 139 };
 140
 141 subtest 'search_related' => sub {
 142     plan tests => 6;
 143     my $builder   = t::lib::TestBuilder->new;
 144     my $patron_1  = $builder->build( { source => 'Borrower' } );
 145     my $patron_2  = $builder->build( { source => 'Borrower' } );
 146     my $libraries = Koha::Patrons->search(
 147         {
 148             -or => {
 149                 borrowernumber =>
 150                   [ $patron_1->{borrowernumber}, $patron_2->{borrowernumber} ]
 151             }
 152         }
 153     )->search_related('branchcode');
 154     is( ref($libraries), 'Koha::Libraries',
 155         'Koha::Objects->search_related should return an instanciated Koha::Objects-based object'
 156     );
 157     is( $libraries->count, 2,
 158         'Koha::Objects->search_related should work as expected' );
 159     ok( eq_array(
 160         [ $libraries->get_column('branchcode') ],
 161         [ $patron_1->{branchcode}, $patron_2->{branchcode} ] ),
 162         'Koha::Objects->search_related should work as expected'
 163     );
 164
 165     my @libraries = Koha::Patrons->search(
 166         {
 167             -or => {
 168                 borrowernumber =>
 169                   [ $patron_1->{borrowernumber}, $patron_2->{borrowernumber} ]
 170             }
 171         }
 172     )->search_related('branchcode');
 173     is(
 174         ref( $libraries[0] ), 'Koha::Library',
 175         'Koha::Objects->search_related should return a list of Koha::Object-based objects'
 176     );
 177     is( scalar(@libraries), 2,
 178         'Koha::Objects->search_related should work as expected' );
 179     ok( eq_array(
 180         [ map { $_->branchcode } @libraries ],
 181         [ $patron_1->{branchcode}, $patron_2->{branchcode} ] ),
 182         'Koha::Objects->search_related should work as expected'
 183     );
 184 };
 185
 186 subtest 'single' => sub {
 187     plan tests => 2;
 188     my $builder   = t::lib::TestBuilder->new;
 189     my $patron_1  = $builder->build( { source => 'Borrower' } );
 190     my $patron_2  = $builder->build( { source => 'Borrower' } );
 191     my $patron = Koha::Patrons->search({}, { rows => 1 })->single;
 192     is(ref($patron), 'Koha::Patron', 'Koha::Objects->single returns a single Koha::Patron object.');
 193     warning_like { Koha::Patrons->search->single } qr/SQL that returns multiple rows/,
 194     "Warning is presented if single is used for a result with multiple rows.";
 195 };
 196
 197 subtest 'last' => sub {
 198     plan tests => 3;
 199     my $builder = t::lib::TestBuilder->new;
 200     my $patron_1  = $builder->build( { source => 'Borrower' } );
 201     my $patron_2  = $builder->build( { source => 'Borrower' } );
 202     my $last_patron = Koha::Patrons->search->last;
 203     is( $last_patron->borrowernumber, $patron_2->{borrowernumber}, '->last should return the last inserted patron' );
 204     $last_patron = Koha::Patrons->search({ borrowernumber => $patron_1->{borrowernumber} })->last;
 205     is( $last_patron->borrowernumber, $patron_1->{borrowernumber}, '->last should work even if there is only 1 result' );
 206     $last_patron = Koha::Patrons->search({ surname => 'should_not_exist' })->last;
 207     is( $last_patron, undef, '->last should return undef if search does not return any results' );
 208 };
 209
 210 subtest 'get_column' => sub {
 211     plan tests => 1;
 212     my @cities = Koha::Cities->search;
 213     my @city_names = map { $_->city_name } @cities;
 214     is_deeply( [ Koha::Cities->search->get_column('city_name') ], \@city_names, 'Koha::Objects->get_column should be allowed' );
 215 };
 216
 217 subtest 'Exceptions' => sub {
 218     plan tests => 7;
 219
 220     my $patron_borrowernumber = $builder->build({ source => 'Borrower' })->{ borrowernumber };
 221     my $patron = Koha::Patrons->find( $patron_borrowernumber );
 222
 223     # Koha::Object
 224     try {
 225         $patron->blah('blah');
 226     } catch {
 227         ok( $_->isa('Koha::Exceptions::Object::MethodNotCoveredByTests'),
 228             'Calling a non-covered method should raise a Koha::Exceptions::Object::MethodNotCoveredByTests exception' );
 229         is( $_->message, 'The method Koha::Patron->blah is not covered by tests!', 'The message raised should contain the package and the method' );
 230     };
 231
 232     try {
 233         $patron->set({ blah => 'blah' });
 234     } catch {
 235         ok( $_->isa('Koha::Exceptions::Object::PropertyNotFound'),
 236             'Setting a non-existent property should raise a Koha::Exceptions::Object::PropertyNotFound exception' );
 237     };
 238
 239     # Koha::Objects
 240     try {
 241         Koha::Patrons->search->not_covered_yet;
 242     } catch {
 243         ok( $_->isa('Koha::Exceptions::Object::MethodNotCoveredByTests'),
 244             'Calling a non-covered method should raise a Koha::Exceptions::Object::MethodNotCoveredByTests exception' );
 245         is( $_->message, 'The method Koha::Patrons->not_covered_yet is not covered by tests!', 'The message raised should contain the package and the method' );
 246     };
 247
 248     try {
 249         Koha::Patrons->not_covered_yet;
 250     } catch {
 251         ok( $_->isa('Koha::Exceptions::Object::MethodNotCoveredByTests'),
 252             'Calling a non-covered method should raise a Koha::Exceptions::Object::MethodNotCoveredByTests exception' );
 253         is( $_->message, 'The method Koha::Patrons->not_covered_yet is not covered by tests!', 'The message raised should contain the package and the method' );
 254     };
 255 };
 256
 257 $schema->storage->txn_rollback;
 258
 259 subtest '->is_paged and ->pager tests' => sub {
 260
 261     plan tests => 5;
 262
 263     $schema->storage->txn_begin;
 264
 265     # Count existing patrons
 266     my $nb_patrons = Koha::Patrons->search()->count;
 267     # Create 10 more patrons
 268     foreach (1..10) {
 269         $builder->build_object({ class => 'Koha::Patrons' });
 270     }
 271
 272     # Non-paginated search
 273     my $patrons = Koha::Patrons->search();
 274     is( $patrons->count, $nb_patrons + 10, 'Search returns all patrons' );
 275     ok( !$patrons->is_paged, 'Search is not paged' );
 276
 277     # Paginated search
 278     $patrons = Koha::Patrons->search( undef, { 'page' => 1, 'rows' => 3 } );
 279     is( $patrons->count, 3, 'Search returns only one page, 3 patrons' );
 280     ok( $patrons->is_paged, 'Search is paged' );
 281     my $pager = $patrons->pager;
 282     is( ref($patrons->pager), 'DBIx::Class::ResultSet::Pager',
 283        'Koha::Objects->pager returns a valid DBIx::Class object' );
 284
 285     $schema->storage->txn_rollback;
 286 };
 287
 288 subtest '->search() tests' => sub {
 289
 290     plan tests => 12;
 291
 292     $schema->storage->txn_begin;
 293
 294     my $count = Koha::Patrons->search->count;
 295
 296     # Create 10 patrons
 297     foreach (1..10) {
 298         $builder->build_object({ class => 'Koha::Patrons' });
 299     }
 300
 301     my $patrons = Koha::Patrons->search();
 302     is( ref($patrons), 'Koha::Patrons', 'search in scalar context returns the Koha::Object-based type' );
 303     my @patrons = Koha::Patrons->search();
 304     is( scalar @patrons, $count + 10, 'search in list context returns a list of objects' );
 305     my $i = 0;
 306     foreach (1..10) {
 307         is( ref($patrons[$i]), 'Koha::Patron', 'Objects in the list have the singular type' );
 308         $i++;
 309     }
 310
 311     $schema->storage->txn_rollback;
 312 };
 313
 314 subtest "to_api() tests" => sub {
 315
 316     plan tests => 18;
 317
 318     $schema->storage->txn_begin;
 319
 320     my $city_1 = $builder->build_object( { class => 'Koha::Cities' } );
 321     my $city_2 = $builder->build_object( { class => 'Koha::Cities' } );
 322
 323     my $cities = Koha::Cities->search(
 324         {
 325             cityid => [ $city_1->cityid, $city_2->cityid ]
 326         },
 327         { -orderby => { -desc => 'cityid' } }
 328     );
 329
 330     is( $cities->count, 2, 'Count is correct' );
 331     my $cities_api = $cities->to_api;
 332     is( ref( $cities_api ), 'ARRAY', 'to_api returns an array' );
 333     is_deeply( $cities_api->[0], $city_1->to_api, 'to_api returns the individual objects with ->to_api' );
 334     is_deeply( $cities_api->[1], $city_2->to_api, 'to_api returns the individual objects with ->to_api' );
 335
 336     my $biblio_1 = $builder->build_sample_biblio();
 337     my $item_1   = $builder->build_sample_item({ biblionumber => $biblio_1->biblionumber });
 338     my $hold_1   = $builder->build_object(
 339         {
 340             class => 'Koha::Holds',
 341             value => { itemnumber => $item_1->itemnumber }
 342         }
 343     );
 344
 345     my $biblio_2 = $builder->build_sample_biblio();
 346     my $item_2   = $builder->build_sample_item({ biblionumber => $biblio_2->biblionumber });
 347     my $hold_2   = $builder->build_object(
 348         {
 349             class => 'Koha::Holds',
 350             value => { itemnumber => $item_2->itemnumber }
 351         }
 352     );
 353
 354     my $embed = { 'items' => {} };
 355
 356     my $i = 0;
 357     my @items = ( $item_1, $item_2 );
 358     my @holds = ( $hold_1, $hold_2 );
 359
 360     my $biblios_api = Koha::Biblios->search(
 361         {
 362             biblionumber => [ $biblio_1->biblionumber, $biblio_2->biblionumber ]
 363         }
 364     )->to_api( { embed => $embed } );
 365
 366     foreach my $biblio_api ( @{ $biblios_api } ) {
 367         ok(exists $biblio_api->{items}, 'Items where embedded in biblio results');
 368         is($biblio_api->{items}->[0]->{item_id}, $items[$i]->itemnumber, 'Item matches');
 369         ok(!exists $biblio_api->{items}->[0]->{holds}, 'No holds info should be embedded yet');
 370
 371         $i++;
 372     }
 373
 374     # One more level
 375     $embed = {
 376         'items' => {
 377             children => { 'holds' => {} }
 378         }
 379     };
 380
 381     $i = 0;
 382
 383     $biblios_api = Koha::Biblios->search(
 384         {
 385             biblionumber => [ $biblio_1->biblionumber, $biblio_2->biblionumber ]
 386         }
 387     )->to_api( { embed => $embed } );
 388
 389     foreach my $biblio_api ( @{ $biblios_api } ) {
 390
 391         ok(exists $biblio_api->{items}, 'Items where embedded in biblio results');
 392         is($biblio_api->{items}->[0]->{item_id}, $items[$i]->itemnumber, 'Item still matches');
 393         ok(exists $biblio_api->{items}->[0]->{holds}, 'Holds info should be embedded');
 394         is($biblio_api->{items}->[0]->{holds}->[0]->{hold_id}, $holds[$i]->reserve_id, 'Hold matches');
 395
 396         $i++;
 397     }
 398
 399     $schema->storage->txn_rollback;
 400 };
 401
 402 subtest "TO_JSON() tests" => sub {
 403
 404     plan tests => 4;
 405
 406     $schema->storage->txn_begin;
 407
 408     my $city_1 = $builder->build_object( { class => 'Koha::Cities' } );
 409     my $city_2 = $builder->build_object( { class => 'Koha::Cities' } );
 410
 411     my $cities = Koha::Cities->search(
 412         {
 413             cityid => [ $city_1->cityid, $city_2->cityid ]
 414         },
 415         { -orderby => { -desc => 'cityid' } }
 416     );
 417
 418     is( $cities->count, 2, 'Count is correct' );
 419     my $cities_json = $cities->TO_JSON;
 420     is( ref($cities_json), 'ARRAY', 'to_api returns an array' );
 421     is_deeply( $cities_json->[0], $city_1->TO_JSON, 'TO_JSON returns the individual objects with ->TO_JSON' );
 422     is_deeply( $cities_json->[1], $city_2->TO_JSON,'TO_JSON returns the individual objects with ->TO_JSON' );
 423
 424     $schema->storage->txn_rollback;
 425 };
 426
 427 # Koha::Object[s] must behave the same as DBIx::Class
 428 subtest 'Return same values as DBIx::Class' => sub {
 429     plan tests => 2;
 430
 431     subtest 'Delete' => sub {
 432         plan tests => 2;
 433
 434         $schema->storage->txn_begin;
 435
 436         subtest 'Simple Koha::Objects - Koha::Cities' => sub {
 437             plan tests => 2;
 438
 439             subtest 'Koha::Object->delete' => sub {
 440
 441                 plan tests => 5;
 442
 443                 my ( $r_us, $e_us, $r_them, $e_them );
 444
 445                 # CASE 1 - Delete an existing object
 446                 my $c = Koha::City->new( { city_name => 'city4test' } )->store;
 447                 try { $r_us = $c->delete; } catch { $e_us = $_ };
 448                 $c = $schema->resultset('City')->new( { city_name => 'city4test_2' } )->update_or_insert;
 449                 try { $r_them = $c->delete; } catch { $e_them = $_ };
 450                 ok( ref($r_us) && ref($r_them),
 451                     'Successful delete should return the object ' );
 452                 ok( !defined $e_us && !defined $e_them,
 453                     'Successful delete should not raise an exception' );
 454                 is( ref($r_us), 'Koha::City', 'Successful delete should return our Koha::Obect based object' );
 455
 456                 # CASE 2 - Delete an object that is not in storage
 457                 try { $r_us   = $r_us->delete;   } catch { $e_us   = $_ };
 458                 try { $r_them = $r_them->delete; } catch { $e_them = $_ };
 459                 ok(
 460                     defined $e_us && defined $e_them,
 461                     'Delete an object that is not in storage should raise an exception'
 462                 );
 463                 is( ref($e_us), 'DBIx::Class::Exception' )
 464                   ; # FIXME This needs adjustement, we want to throw a Koha::Exception
 465
 466             };
 467
 468             subtest 'Koha::Objects->delete' => sub {
 469
 470                 plan tests => 4;
 471
 472                 my ( $r_us, $e_us, $r_them, $e_them );
 473
 474                 # CASE 1 - Delete existing objects
 475                 my $city_1 = $builder->build_object({ class => 'Koha::Cities' });
 476                 my $city_2 = $builder->build_object({ class => 'Koha::Cities' });
 477                 my $city_3 = $builder->build_object({ class => 'Koha::Cities' });
 478                 my $cities = Koha::Cities->search(
 479                     {
 480                         cityid => {
 481                             -in => [
 482                                 $city_1->cityid,
 483                                 $city_2->cityid,
 484                                 $city_3->cityid,
 485                             ]
 486                         }
 487                     }
 488                 );
 489
 490                 try { $r_us = $cities->delete; } catch { $e_us = $_ };
 491
 492                 $city_1 = $builder->build_object({ class => 'Koha::Cities' });
 493                 $city_2 = $builder->build_object({ class => 'Koha::Cities' });
 494                 $city_3 = $builder->build_object({ class => 'Koha::Cities' });
 495                 $cities = $schema->resultset('City')->search(
 496                     {
 497                         cityid => {
 498                             -in => [
 499                                 $city_1->cityid,
 500                                 $city_2->cityid,
 501                                 $city_3->cityid,
 502                             ]
 503                         }
 504                     }
 505                 );
 506
 507                 try { $r_them = $cities->delete; } catch { $e_them = $_ };
 508
 509                 ok( $r_us == 3 && $r_them == 3 );
 510                 ok (!defined($e_us) && !defined($e_them));
 511
 512                 # CASE 2 - One of the object is not in storage
 513                 $city_1 = $builder->build_object({ class => 'Koha::Cities' });
 514                 $city_2 = $builder->build_object({ class => 'Koha::Cities' });
 515                 $city_3 = $builder->build_object({ class => 'Koha::Cities' });
 516                 $cities = Koha::Cities->search(
 517                     {
 518                         cityid => {
 519                             -in => [
 520                                 $city_1->cityid,
 521                                 $city_2->cityid,
 522                                 $city_3->cityid,
 523                             ]
 524                         }
 525                     }
 526                 );
 527
 528                 $city_2->delete; # We delete one of the object
 529                 try { $r_us = $cities->delete; } catch { $e_us = $_ };
 530
 531                 $city_1 = $builder->build_object({ class => 'Koha::Cities' });
 532                 $city_2 = $builder->build_object({ class => 'Koha::Cities' });
 533                 $city_3 = $builder->build_object({ class => 'Koha::Cities' });
 534                 $cities = $schema->resultset('City')->search(
 535                     {
 536                         cityid => {
 537                             -in => [
 538                                 $city_1->cityid,
 539                                 $city_2->cityid,
 540                                 $city_3->cityid,
 541                             ]
 542                         }
 543                     }
 544                 );
 545
 546                 $city_2->delete; # We delete one of the object
 547                 try { $r_them = $cities->delete; } catch { $e_them = $_ };
 548
 549                 ok( $r_us == 2 && $r_them == 2 );
 550                 ok (!defined($e_us) && !defined($e_them));
 551             };
 552         };
 553
 554         subtest 'Overwritten Koha::Objects->delete - Koha::Patrons' => sub {
 555
 556             plan tests => 2;
 557
 558             subtest 'Koha::Object->delete' => sub {
 559
 560                 plan tests => 7;
 561
 562                 my ( $r_us, $e_us, $r_them, $e_them );
 563
 564                 # CASE 1 - Delete an existing patron
 565                 my $patron = $builder->build_object({ class => 'Koha::Patrons' });
 566                 my $patron_data = $patron->unblessed;
 567                 $patron->delete;
 568
 569                 $patron = Koha::Patron->new( $patron_data )->store;
 570                 try {$r_us = $patron->delete;} catch { $e_us = $_ };
 571                 $patron = $schema->resultset('Borrower')->new( $patron_data )->update_or_insert;
 572                 try {$r_them = $patron->delete;} catch { $e_them = $_ };
 573                 ok( ref($r_us) && ref($r_them),
 574                     'Successful delete should return the patron object' );
 575                 ok( !defined $e_us && !defined $e_them,
 576                     'Successful delete should not raise an exception' );
 577                 is( ref($r_us), 'Koha::Patron',
 578                     'Successful delete should return our Koha::Obect based object' );
 579
 580                 # CASE 2 - Delete a patron that is not in storage
 581                 try { $r_us   = $r_us->delete;   } catch { $e_us   = $_ };
 582                 try { $r_them = $r_them->delete; } catch { $e_them = $_ };
 583                 ok(
 584                     defined $e_us && defined $e_them,
 585                     'Delete a patron that is not in storage should raise an exception'
 586                 );
 587                 is( ref($e_us), 'DBIx::Class::Exception' )
 588                   ; # FIXME This needs adjustement, we want to throw a Koha::Exception
 589
 590                 # CASE 3 - Delete a patron that cannot be deleted (as a checkout)
 591                 $patron = Koha::Patron->new($patron_data)->store;
 592                 $builder->build_object(
 593                     {
 594                         class => 'Koha::Checkouts',
 595                         value => { borrowernumber => $patron->borrowernumber }
 596                     }
 597                 );
 598                 try { $r_us = $r_us->delete; } catch { $e_us = $_ };
 599                 $patron = $schema->resultset('Borrower')->find( $patron->borrowernumber );
 600                 try { $r_them = $r_them->delete; } catch { $e_them = $_ };
 601                 ok(
 602                     defined $e_us && defined $e_them,
 603                     'Delete a patron that cannot be deleted should raise an exception'
 604                 );
 605                 is( ref($e_us), 'DBIx::Class::Exception' )
 606                   ; # FIXME This needs adjustement, we want to throw a Koha::Exception
 607             };
 608
 609             subtest 'Koha::Objects->delete' => sub {
 610
 611                 plan tests => 7;
 612
 613                 my ( $r_us, $e_us, $r_them, $e_them );
 614
 615                 # CASE 1 - Delete existing objects
 616                 my $patron_1 = $builder->build_object({ class => 'Koha::Patrons' });
 617                 my $patron_2 = $builder->build_object({ class => 'Koha::Patrons' });
 618                 my $patron_3 = $builder->build_object({ class => 'Koha::Patrons' });
 619                 my $patrons = Koha::Patrons->search(
 620                     {
 621                         borrowernumber => {
 622                             -in => [
 623                                 $patron_1->borrowernumber,
 624                                 $patron_2->borrowernumber,
 625                                 $patron_3->borrowernumber
 626                             ]
 627                         }
 628                     }
 629                 );
 630
 631                 try { $r_us = $patrons->delete; } catch { $e_us = $_ };
 632
 633                 $patron_1 = $builder->build_object({ class => 'Koha::Patrons' });
 634                 $patron_2 = $builder->build_object({ class => 'Koha::Patrons' });
 635                 $patron_3 = $builder->build_object({ class => 'Koha::Patrons' });
 636                 $patrons = $schema->resultset('Borrower')->search(
 637                     {
 638                         borrowernumber => {
 639                             -in => [
 640                                 $patron_1->borrowernumber,
 641                                 $patron_2->borrowernumber,
 642                                 $patron_3->borrowernumber
 643                             ]
 644                         }
 645                     }
 646                 );
 647
 648                 try { $r_them = $patrons->delete; } catch { $e_them = $_ };
 649
 650                 ok( $r_us == 3 && $r_them == 3, '->delete should return the number of deleted patrons' );
 651                 ok (!defined($e_us) && !defined($e_them), '->delete should not raise exception if everything went well');
 652
 653                 # CASE 2 - One of the patrons is not in storage
 654                 undef $_ for $r_us, $e_us, $r_them, $e_them;
 655                 $patron_1 = $builder->build_object({ class => 'Koha::Patrons' });
 656                 $patron_2 = $builder->build_object({ class => 'Koha::Patrons' });
 657                 $patron_3 = $builder->build_object({ class => 'Koha::Patrons' });
 658                 $patrons = Koha::Patrons->search(
 659                     {
 660                         borrowernumber => {
 661                             -in => [
 662                                 $patron_1->borrowernumber,
 663                                 $patron_2->borrowernumber,
 664                                 $patron_3->borrowernumber
 665                             ]
 666                         }
 667                     }
 668                 );
 669
 670                 $patron_2->delete; # We delete one of the patron
 671                 try { $r_us = $patrons->delete; } catch { $e_us = $_ };
 672
 673                 $patron_1 = $builder->build_object({ class => 'Koha::Patrons' });
 674                 $patron_2 = $builder->build_object({ class => 'Koha::Patrons' });
 675                 $patron_3 = $builder->build_object({ class => 'Koha::Patrons' });
 676                 $patrons = $schema->resultset('Borrower')->search(
 677                     {
 678                         borrowernumber => {
 679                             -in => [
 680                                 $patron_1->borrowernumber,
 681                                 $patron_2->borrowernumber,
 682                                 $patron_3->borrowernumber
 683                             ]
 684                         }
 685                     }
 686                 );
 687
 688                 $patron_2->delete; # We delete one of the patron
 689                 try { $r_them = $patrons->delete; } catch { $e_them = $_ };
 690
 691                 ok( $r_us == 2 && $r_them == 2, 'Delete patrons with one that was not in storage should delete the patrons' );
 692                 ok (!defined($e_us) && !defined($e_them), 'no exception should be raised if at least one patron was not in storage');
 693
 694                 # CASE 3 - Delete a set of patrons with one that that cannot be deleted (as a checkout)
 695                 undef $_ for $r_us, $e_us, $r_them, $e_them;
 696                 $patron_1 = $builder->build_object({ class => 'Koha::Patrons' });
 697                 $patron_2 = $builder->build_object({ class => 'Koha::Patrons' });
 698                 $patron_3 = $builder->build_object({ class => 'Koha::Patrons' });
 699                 $patrons = Koha::Patrons->search(
 700                     {
 701                         borrowernumber => {
 702                             -in => [
 703                                 $patron_1->borrowernumber,
 704                                 $patron_2->borrowernumber,
 705                                 $patron_3->borrowernumber
 706                             ]
 707                         }
 708                     }
 709                 );
 710
 711                 # Adding a checkout to patron_2
 712                 $builder->build_object(
 713                     {
 714                         class => 'Koha::Checkouts',
 715                         value => { borrowernumber => $patron_2->borrowernumber }
 716                     }
 717                 );
 718
 719                 try { $r_us = $patrons->delete; } catch { $e_us = $_ };
 720                 my $not_deleted_us = $patron_1->in_storage + $patron_2->in_storage + $patron_3->in_storage;
 721
 722                 $patron_1 = $builder->build_object({ class => 'Koha::Patrons' });
 723                 $patron_2 = $builder->build_object({ class => 'Koha::Patrons' });
 724                 $patron_3 = $builder->build_object({ class => 'Koha::Patrons' });
 725                 $patrons = $schema->resultset('Borrower')->search(
 726                     {
 727                         borrowernumber => {
 728                             -in => [
 729                                 $patron_1->borrowernumber,
 730                                 $patron_2->borrowernumber,
 731                                 $patron_3->borrowernumber
 732                             ]
 733                         }
 734                     }
 735                 );
 736
 737                 # Adding a checkout to patron_2
 738                 $builder->build_object(
 739                     {
 740                         class => 'Koha::Checkouts',
 741                         value => { borrowernumber => $patron_2->borrowernumber }
 742                     }
 743                 );
 744
 745                 try { $r_them = $patrons->delete; } catch { $e_them = $_ };
 746
 747                 my $not_deleted_them = $patron_1->in_storage + $patron_2->in_storage + $patron_3->in_storage;
 748                 ok(
 749                     defined $e_us && defined $e_them,
 750                     'Delete patrons with one that cannot be deleted should raise an exception'
 751                 );
 752                 is( ref($e_us), 'DBIx::Class::Exception' )
 753                   ; # FIXME This needs adjustement, we want to throw a Koha::Exception
 754
 755                 ok($not_deleted_us == 3 && $not_deleted_them == 3, 'If one patron cannot be deleted, none should have been deleted');
 756             };
 757         };
 758
 759         $schema->storage->txn_rollback;
 760
 761     };
 762
 763     subtest 'Update (set/store)' => sub {
 764         plan tests => 2;
 765
 766         $schema->storage->txn_begin;
 767
 768         subtest 'Simple Koha::Objects - Koha::Cities' => sub {
 769             plan tests => 2;
 770
 771             subtest 'Koha::Object->update' => sub {
 772
 773                 plan tests => 5;
 774
 775                 my ( $r_us, $e_us, $r_them, $e_them );
 776
 777                 # CASE 1 - Update an existing object
 778                 my $c_us = Koha::City->new( { city_name => 'city4test' } )->store;
 779                 try { $r_us = $c_us->update({ city_country => 'country4test' }); } catch { $e_us = $_ };
 780                 my $c_them = $schema->resultset('City')->new( { city_name => 'city4test_2' } )->update_or_insert;
 781                 try { $r_them = $c_them->update({ city_country => 'country4test_2' }); } catch { $e_them = $_ };
 782                 ok( ref($r_us) && ref($r_them),
 783                     'Successful update should return the object ' );
 784                 ok( !defined $e_us && !defined $e_them,
 785                     'Successful update should not raise an exception' );
 786                 is( ref($r_us), 'Koha::City', 'Successful update should return our Koha::Obect based object' );
 787
 788                 # CASE 2 - Update an object that is not in storage
 789                 $c_us->delete;
 790                 $c_them->delete;
 791                 try { $r_us   = $c_us->update({ city_country => 'another_country' });   } catch { $e_us   = $_ };
 792                 try { $r_them = $c_them->update({ city_country => 'another_country' }); } catch { $e_them = $_ };
 793                 ok(
 794                     defined $e_us && defined $e_them,
 795                     'Update an object that is not in storage should raise an exception'
 796                 );
 797                 is( ref($e_us), 'Koha::Exceptions::Object::NotInStorage' );
 798             };
 799
 800             subtest 'Koha::Objects->update' => sub {
 801
 802                 plan tests => 6;
 803
 804                 my ( $r_us, $e_us, $r_them, $e_them );
 805
 806                 # CASE 1 - update existing objects
 807                 my $city_1 = $builder->build_object({ class => 'Koha::Cities' });
 808                 my $city_2 = $builder->build_object({ class => 'Koha::Cities' });
 809                 my $city_3 = $builder->build_object({ class => 'Koha::Cities' });
 810                 my $cities = Koha::Cities->search(
 811                     {
 812                         cityid => {
 813                             -in => [
 814                                 $city_1->cityid,
 815                                 $city_2->cityid,
 816                                 $city_3->cityid,
 817                             ]
 818                         }
 819                     }
 820                 );
 821
 822                 try { $r_us = $cities->update({ city_country => 'country4test' }); } catch { $e_us = $_ };
 823
 824                 $city_1 = $builder->build_object({ class => 'Koha::Cities' });
 825                 $city_2 = $builder->build_object({ class => 'Koha::Cities' });
 826                 $city_3 = $builder->build_object({ class => 'Koha::Cities' });
 827                 $cities = $schema->resultset('City')->search(
 828                     {
 829                         cityid => {
 830                             -in => [
 831                                 $city_1->cityid,
 832                                 $city_2->cityid,
 833                                 $city_3->cityid,
 834                             ]
 835                         }
 836                     }
 837                 );
 838
 839                 try { $r_them = $cities->update({ city_country => 'country4test' }); } catch { $e_them = $_ };
 840
 841                 ok( $r_us == 3 && $r_them == 3, '->update should return the number of updated cities' );
 842                 ok(!defined($e_us) && !defined($e_them));
 843
 844                 # CASE 2 - One of the object is not in storage
 845                 $city_1 = $builder->build_object({ class => 'Koha::Cities' });
 846                 $city_2 = $builder->build_object({ class => 'Koha::Cities' });
 847                 $city_3 = $builder->build_object({ class => 'Koha::Cities' });
 848                 $cities = Koha::Cities->search(
 849                     {
 850                         cityid => {
 851                             -in => [
 852                                 $city_1->cityid,
 853                                 $city_2->cityid,
 854                                 $city_3->cityid,
 855                             ]
 856                         }
 857                     }
 858                 );
 859
 860                 $city_2->delete; # We delete one of the object
 861                 try { $r_us = $cities->update({ city_country => 'country4test' }); } catch { $e_us = $_ };
 862
 863                 $city_1 = $builder->build_object({ class => 'Koha::Cities' });
 864                 $city_2 = $builder->build_object({ class => 'Koha::Cities' });
 865                 $city_3 = $builder->build_object({ class => 'Koha::Cities' });
 866                 $cities = $schema->resultset('City')->search(
 867                     {
 868                         cityid => {
 869                             -in => [
 870                                 $city_1->cityid,
 871                                 $city_2->cityid,
 872                                 $city_3->cityid,
 873                             ]
 874                         }
 875                     }
 876                 );
 877
 878                 $city_2->delete; # We delete one of the object
 879                 try { $r_them = $cities->update({ city_country => 'country4test' }); } catch { $e_them = $_ };
 880
 881                 ok( $r_us == 2 && $r_them == 2, '->update should return the number of updated cities' );
 882                 ok(!defined($e_us) && !defined($e_them));
 883
 884                 throws_ok
 885                     { Koha::Cities->update({ city_country => 'Castalia' }); }
 886                     'Koha::Exceptions::Object::NotInstantiated',
 887                     'Exception thrown if not instantiated class';
 888
 889                 is( "$@", 'Tried to access the \'update\' method, but Koha::Cities is not instantiated', 'Exception stringified correctly' );
 890
 891             };
 892         };
 893
 894         subtest 'Overwritten Koha::Objects->store|update - Koha::Patrons' => sub {
 895
 896             plan tests => 2;
 897
 898             subtest 'Koha::Object->update' => sub {
 899
 900                 plan tests => 5;
 901
 902                 my ( $r_us, $e_us, $r_them, $e_them );
 903
 904                 # CASE 1 - Update an existing patron
 905                 my $patron_us = $builder->build_object({ class => 'Koha::Patrons' });
 906                 try {$r_us = $patron_us->update({city => 'a_city'});} catch { $e_us = $_ };
 907
 908                 my $patron_data = $builder->build_object({ class => 'Koha::Patrons' })->delete->unblessed;
 909                 my $patron_them = $schema->resultset('Borrower')->new( $patron_data )->update_or_insert;
 910                 try {$r_them = $patron_them->update({city => 'a_city'});} catch { $e_them = $_ };
 911                 ok( ref($r_us) && ref($r_them),
 912                     'Successful update should return the patron object' );
 913                 ok( !defined $e_us && !defined $e_them,
 914                     'Successful update should not raise an exception' );
 915                 is( ref($r_us), 'Koha::Patron',
 916                     'Successful update should return our Koha::Obect based object' );
 917
 918                 # CASE 2 - Update a patron that is not in storage
 919                 $patron_us->delete;
 920                 $patron_them->delete;
 921                 try { $r_us   = $patron_us->update({ city => 'another_city' });   } catch { $e_us   = $_ };
 922                 try { $r_them = $patron_them->update({ city => 'another_city' }); } catch { $e_them = $_ };
 923                 ok(
 924                     defined $e_us && defined $e_them,
 925                     'Update a patron that is not in storage should raise an exception'
 926                 );
 927                 is( ref($e_us), 'Koha::Exceptions::Object::NotInStorage' );
 928
 929             };
 930
 931             subtest 'Koha::Objects->Update ' => sub {
 932
 933                 plan tests => 6;
 934
 935                 my ( $r_us, $e_us, $r_them, $e_them );
 936
 937                 # CASE 1 - Update existing objects
 938                 my $patron_1 = $builder->build_object({ class => 'Koha::Patrons' });
 939                 my $patron_2 = $builder->build_object({ class => 'Koha::Patrons' });
 940                 my $patron_3 = $builder->build_object({ class => 'Koha::Patrons' });
 941                 my $patrons_us = Koha::Patrons->search(
 942                     {
 943                         borrowernumber => {
 944                             -in => [
 945                                 $patron_1->borrowernumber,
 946                                 $patron_2->borrowernumber,
 947                                 $patron_3->borrowernumber
 948                             ]
 949                         }
 950                     }
 951                 );
 952
 953                 try { $r_us = $patrons_us->update({ city => 'a_city' }); } catch { $e_us = $_ };
 954
 955                 $patron_1 = $builder->build_object({ class => 'Koha::Patrons' });
 956                 $patron_2 = $builder->build_object({ class => 'Koha::Patrons' });
 957                 $patron_3 = $builder->build_object({ class => 'Koha::Patrons' });
 958                 my $patrons_them = $schema->resultset('Borrower')->search(
 959                     {
 960                         borrowernumber => {
 961                             -in => [
 962                                 $patron_1->borrowernumber,
 963                                 $patron_2->borrowernumber,
 964                                 $patron_3->borrowernumber
 965                             ]
 966                         }
 967                     }
 968                 );
 969
 970                 try { $r_them = $patrons_them->update({ city => 'a_city' }); } catch { $e_them = $_ };
 971
 972                 ok( $r_us == 3 && $r_them == 3, '->update should return the number of update patrons' );
 973                 ok (!defined($e_us) && !defined($e_them), '->update should not raise exception if everything went well');
 974
 975                 # CASE 2 - One of the patrons is not in storage
 976                 undef $_ for $r_us, $e_us, $r_them, $e_them;
 977                 $patron_1 = $builder->build_object({ class => 'Koha::Patrons' });
 978                 $patron_2 = $builder->build_object({ class => 'Koha::Patrons' });
 979                 $patron_3 = $builder->build_object({ class => 'Koha::Patrons' });
 980                 $patrons_us = Koha::Patrons->search(
 981                     {
 982                         borrowernumber => {
 983                             -in => [
 984                                 $patron_1->borrowernumber,
 985                                 $patron_2->borrowernumber,
 986                                 $patron_3->borrowernumber
 987                             ]
 988                         }
 989                     }
 990                 );
 991
 992                 $patron_2->delete; # We delete one of the patron
 993                 try { $r_us = $patrons_us->update({ city => 'another_city' }); } catch { $e_us = $_ };
 994
 995                 $patron_1 = $builder->build_object({ class => 'Koha::Patrons' });
 996                 $patron_2 = $builder->build_object({ class => 'Koha::Patrons' });
 997                 $patron_3 = $builder->build_object({ class => 'Koha::Patrons' });
 998                 $patrons_them = $schema->resultset('Borrower')->search(
 999                     {
1000                         borrowernumber => {
1001                             -in => [
1002                                 $patron_1->borrowernumber,
1003                                 $patron_2->borrowernumber,
1004                                 $patron_3->borrowernumber
1005                             ]
1006                         }
1007                     }
1008                 );
1009
1010                 $patron_2->delete; # We delete one of the patron
1011                 try { $r_them = $patrons_them->update({ city => 'another_city' }); } catch { $e_them = $_ };
1012
1013                 ok( $r_us == 2 && $r_them == 2, 'Update patrons with one that was not in storage should update the patrons' );
1014                 ok (!defined($e_us) && !defined($e_them), 'no exception should be raised if at least one patron was not in storage');
1015
1016
1017                 # Testing no_triggers
1018                 t::lib::Mocks::mock_preference('uppercasesurnames', 1);
1019                 $patrons_us = Koha::Patrons->search(
1020                     {
1021                         borrowernumber => {
1022                             -in => [
1023                                 $patron_1->borrowernumber,
1024                                 $patron_2->borrowernumber,
1025                                 $patron_3->borrowernumber
1026                             ]
1027                         }
1028                     }
1029                 );
1030                 $patrons_us->update({ surname => 'foo' }); # Koha::Patron->store is supposed to uppercase the surnames
1031                 is( $patrons_us->search({ surname => 'FOO' })->count, 2, 'Koha::Patron->store is hit' );
1032
1033                 $patrons_us->update({ surname => 'foo' }, { no_triggers => 1 }); # The surnames won't be uppercase as we won't hit Koha::Patron->store
1034                 is( $patrons_us->search({ surname => 'foo' })->count, 2, 'Koha::Patron->store is not hit');
1035
1036             };
1037
1038         };
1039
1040         $schema->storage->txn_rollback;
1041
1042     };
1043
1044 };
1045
1046 subtest "attributes_from_api() tests" => sub {
1047
1048     plan tests => 1;
1049
1050     $schema->storage->txn_begin;
1051
1052     my $cities_rs = Koha::Cities->new;
1053     my $city      = Koha::City->new;
1054
1055     my $api_attributes = {
1056         name        => 'Cordoba',
1057         postal_code => 5000
1058     };
1059
1060     is_deeply(
1061         $cities_rs->attributes_from_api($api_attributes),
1062         $city->attributes_from_api($api_attributes)
1063     );
1064
1065     $schema->storage->txn_rollback;
1066
1067 };
1068
1069 subtest "filter_by_last_update" => sub {
1070
1071     $schema->storage->txn_begin;
1072
1073     my $now = dt_from_string->truncate( to => 'day' );
1074     my @borrowernumbers;
1075     # Building 6 patrons that have been created today, yesterday, ... 1 per day
1076     for my $i ( 0 .. 5 ) {
1077         push @borrowernumbers,
1078           $builder->build_object(
1079             {
1080                 class => 'Koha::Patrons',
1081                 value => { updated_on => $now->clone->subtract( days => $i ) }
1082             }
1083           )->borrowernumber;
1084     }
1085
1086     my $patrons = Koha::Patrons->search(
1087         { borrowernumber => { -in => \@borrowernumbers } } );
1088
1089     try {
1090         $patrons->filter_by_last_update( { timestamp_column_name => 'updated_on' } )
1091           ->count;
1092     }
1093     catch {
1094         ok(
1095             $_->isa('Koha::Exceptions::MissingParameter'),
1096             'Should raise an exception if no parameter given'
1097         );
1098     };
1099
1100     my $count = $patrons->filter_by_last_update(
1101         { timestamp_column_name => 'updated_on', days => 2 } )->count;
1102     is( $count, 3, '3 patrons have been updated before the last 2 days (exclusive)' );
1103
1104     $count = $patrons->filter_by_last_update(
1105         { timestamp_column_name => 'updated_on', days => 1 } )->count;
1106     is( $count, 4, '4 patrons have been updated before yesterday (exclusive)' );
1107
1108     $count = $patrons->filter_by_last_update(
1109         { timestamp_column_name => 'updated_on', days => 0 } )->count;
1110     is( $count, 5, '5 patrons have been updated before today (exclusive)' );
1111
1112     $count = $patrons->filter_by_last_update(
1113         { timestamp_column_name => 'updated_on', from => $now } )->count;
1114     is( $count, 1, '1 patron has been updated "from today" (inclusive)' );
1115
1116     $count = $patrons->filter_by_last_update(
1117         { timestamp_column_name => 'updated_on', to => $now } )->count;
1118     is( $count, 6, '6 patrons have been updated "to today" (inclusive)' );
1119
1120     $count = $patrons->filter_by_last_update(
1121         {
1122             timestamp_column_name => 'updated_on',
1123             from                  => $now->clone->subtract( days => 4 ),
1124             to                    => $now->clone->subtract( days => 2 )
1125         }
1126     )->count;
1127     is( $count, 3, '3 patrons have been updated between D-4 and D-2' );
1128
1129     t::lib::Mocks::mock_preference( 'dateformat', 'metric' );
1130     try {
1131         $count = $patrons->filter_by_last_update(
1132             { timestamp_column_name => 'updated_on', from => '1970-12-31' } )
1133           ->count;
1134     }
1135     catch {
1136         ok(
1137             $_->isa(
1138                 'No exception raised, from and to parameters can take an iso formatted date'
1139             )
1140         );
1141     };
1142     try {
1143         $count = $patrons->filter_by_last_update(
1144             { timestamp_column_name => 'updated_on', from => '31/12/1970' } )
1145           ->count;
1146     }
1147     catch {
1148         ok(
1149             $_->isa(
1150                 'No exception raised, from and to parameters can take an metric formatted date (depending on dateformat syspref)'
1151             )
1152         );
1153     };
1154
1155     $schema->storage->txn_rollback;
1156 };
1157
1158 subtest "from_api_mapping() tests" => sub {
1159
1160     plan tests => 1;
1161
1162     $schema->storage->txn_begin;
1163
1164     my $cities_rs = Koha::Cities->new;
1165     my $city      = Koha::City->new;
1166
1167     is_deeply(
1168         $cities_rs->from_api_mapping,
1169         $city->from_api_mapping
1170     );
1171
1172     $schema->storage->txn_rollback;
1173 };
1174
1175 subtest 'prefetch_whitelist() tests' => sub {
1176
1177     plan tests => 3;
1178
1179     $schema->storage->txn_begin;
1180
1181     my $biblios = Koha::Biblios->new;
1182
1183     my $prefetch_whitelist = $biblios->prefetch_whitelist;
1184
1185     ok(
1186         exists $prefetch_whitelist->{orders},
1187         'Relationship matching method name is listed'
1188     );
1189     is(
1190         $prefetch_whitelist->{orders},
1191         'Koha::Acquisition::Order',
1192         'Guessed the non-standard object class correctly'
1193     );
1194
1195     is(
1196         $prefetch_whitelist->{items},
1197         'Koha::Item',
1198         'Guessed the standard object class correctly'
1199     );
1200
1201     $schema->storage->txn_rollback;
1202 };
1203
1204 subtest 'empty() tests' => sub {
1205
1206     plan tests => 6;
1207
1208     $schema->storage->txn_begin;
1209
1210     # Add a patron, we need at least 1
1211     my $patron = $builder->build_object({ class => 'Koha::Patrons' });
1212     ok( Koha::Patrons->count > 0, 'There is at least one Koha::Patron on the resultset' );
1213
1214     my $empty = Koha::Patrons->new->empty;
1215     is( ref($empty), 'Koha::Patrons', '->empty returns a Koha::Patrons iterator' );
1216     is( $empty->count, 0, 'The empty resultset is, well, empty :-D' );
1217
1218     my $new_rs = $empty->search({ borrowernumber => $patron->borrowernumber });
1219
1220     is( $new_rs->count, 0, 'Further chaining an empty resultset, returns an empty resultset' );
1221
1222     throws_ok
1223         { Koha::Patrons->empty; }
1224         'Koha::Exceptions::Object::NotInstantiated',
1225         'Exception thrown if not instantiated class';
1226
1227     is( "$@", 'Tried to access the \'empty\' method, but Koha::Patrons is not instantiated', 'Exception stringified correctly' );
1228
1229     $schema->storage->txn_rollback;
1230 };
1231
1232 subtest 'delete() tests' => sub {
1233
1234     plan tests => 2;
1235
1236     $schema->storage->txn_begin;
1237
1238     # Make sure no cities
1239     warnings_are { Koha::Cities->delete }[],
1240       "No warnings, no Koha::City->delete called as it doesn't exist";
1241
1242     # Mock Koha::City
1243     my $mocked_city = Test::MockModule->new('Koha::City');
1244     $mocked_city->mock(
1245         'delete',
1246         sub {
1247             shift->_result->delete;
1248             warn "delete called!";
1249         }
1250     );
1251
1252     # Add two cities
1253     $builder->build_object( { class => 'Koha::Cities' } );
1254     $builder->build_object( { class => 'Koha::Cities' } );
1255
1256     my $cities = Koha::Cities->search;
1257     $cities->next;
1258     warnings_are { $cities->delete }
1259         [ "delete called!", "delete called!" ],
1260         "No warnings, no Koha::City->delete called as it doesn't exist";
1261
1262     $schema->storage->txn_rollback;
1263 };