3 # Copyright 2019 Koha Development team
5 # This file is part of Koha
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.
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.
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>.
22 use Test::More tests => 23;
29 use Koha::Authority::Types;
32 use Koha::Patron::Category;
33 use Koha::Patron::Categories;
36 use Koha::DateUtils qw( dt_from_string );
38 use t::lib::TestBuilder;
43 my $schema = Koha::Database->new->schema;
44 $schema->storage->txn_begin;
45 my $builder = t::lib::TestBuilder->new;
47 is( ref(Koha::Authority::Types->find('')), 'Koha::Authority::Type', 'Koha::Objects->find should work if the primary key is an empty string' );
49 my @columns = Koha::Patrons->columns;
50 my $borrowernumber_exists = grep { /^borrowernumber$/ } @columns;
51 is( $borrowernumber_exists, 1, 'Koha::Objects->columns should return the table columns' );
53 subtest 'find' => sub {
55 my $patron = $builder->build({source => 'Borrower'});
56 my $patron_object = Koha::Patrons->find( $patron->{borrowernumber} );
57 is( $patron_object->borrowernumber, $patron->{borrowernumber}, '->find should return the correct object' );
59 my @patrons = Koha::Patrons->find( $patron->{borrowernumber} );
60 is(scalar @patrons, 1, '->find in list context returns a value');
61 is($patrons[0]->borrowernumber, $patron->{borrowernumber}, '->find in list context returns the same value as in scalar context');
64 foo => Koha::Patrons->find('foo'),
67 is ($patrons->{foo}, undef, '->find in list context returns undef when no record is found');
69 # Test sending undef to find; should not generate a warning
70 warning_is { $patron = Koha::Patrons->find( undef ); }
71 "", "Sending undef does not trigger a DBIx warning";
72 warning_is { $patron = Koha::Patrons->find( undef, undef ); }
73 "", "Sending two undefs does not trigger a DBIx warning too";
76 subtest 'update' => sub {
79 $builder->build( { source => 'City', value => { city_country => 'UK' } } );
80 $builder->build( { source => 'City', value => { city_country => 'UK' } } );
81 $builder->build( { source => 'City', value => { city_country => 'UK' } } );
82 $builder->build( { source => 'City', value => { city_country => 'France' } } );
83 $builder->build( { source => 'City', value => { city_country => 'France' } } );
84 $builder->build( { source => 'City', value => { city_country => 'Germany' } } );
85 Koha::Cities->search( { city_country => 'UK' } )->update( { city_country => 'EU' } );
86 is( Koha::Cities->search( { city_country => 'EU' } )->count, 3, 'Koha::Objects->update should have updated the 3 rows' );
87 is( Koha::Cities->search( { city_country => 'UK' } )->count, 0, 'Koha::Objects->update should have updated the 3 rows' );
90 subtest 'reset' => sub {
93 my $patrons = Koha::Patrons->search;
94 my $first_borrowernumber = $patrons->next->borrowernumber;
95 my $second_borrowernumber = $patrons->next->borrowernumber;
96 is( ref( $patrons->reset ), 'Koha::Patrons', 'Koha::Objects->reset should allow chaining' );
97 is( ref( $patrons->reset->next ), 'Koha::Patron', 'Koha::Objects->reset should allow chaining' );
98 is( $patrons->reset->next->borrowernumber, $first_borrowernumber, 'Koha::Objects->reset should work as expected');
101 subtest 'delete' => sub {
104 my $patron_1 = $builder->build({source => 'Borrower'});
105 my $patron_2 = $builder->build({source => 'Borrower'});
106 is( Koha::Patrons->search({ -or => { borrowernumber => [ $patron_1->{borrowernumber}, $patron_2->{borrowernumber}]}})->delete, 2, '');
107 is( Koha::Patrons->search({ -or => { borrowernumber => [ $patron_1->{borrowernumber}, $patron_2->{borrowernumber}]}})->count, 0, '');
110 subtest 'new' => sub {
112 my $a_cat_code = 'A_CAT_CODE';
113 my $patron_category = Koha::Patron::Category->new( { categorycode => $a_cat_code } )->store;
114 is( Koha::Patron::Categories->find($a_cat_code)->category_type, 'A', 'Koha::Object->new should set the default value' );
115 Koha::Patron::Categories->find($a_cat_code)->delete;
116 $patron_category = Koha::Patron::Category->new( { categorycode => $a_cat_code, category_type => undef } )->store;
117 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' );
118 Koha::Patron::Categories->find($a_cat_code)->delete;
121 subtest 'find' => sub {
124 # check find on a single PK
125 my $patron = $builder->build({ source => 'Borrower' });
126 is( Koha::Patrons->find($patron->{borrowernumber})->surname,
127 $patron->{surname}, "Checking an arbitrary patron column after find"
129 # check find with unique column
130 my $obj = Koha::Patrons->find($patron->{cardnumber}, { key => 'cardnumber' });
131 is( $obj->borrowernumber, $patron->{borrowernumber},
132 'Find with unique column and key specified' );
133 # check find with an additional where clause in the attrs hash
134 # we do not expect to find something now
135 is( Koha::Patrons->find(
136 $patron->{borrowernumber},
137 { where => { surname => { '!=', $patron->{surname} }}},
138 ), undef, 'Additional where clause in find call' );
140 is( Koha::Patrons->find(), undef, 'Find returns undef if no params passed' );
143 subtest 'search_related' => sub {
147 my $builder = t::lib::TestBuilder->new;
148 my $patron_1 = $builder->build( { source => 'Borrower' } );
149 my $patron_2 = $builder->build( { source => 'Borrower' } );
150 my $libraries = Koha::Patrons->search(
154 [ $patron_1->{borrowernumber}, $patron_2->{borrowernumber} ]
157 )->search_related('branchcode');
158 is( ref($libraries), 'Koha::Libraries',
159 'Koha::Objects->search_related should return an instanciated Koha::Objects-based object'
161 is( $libraries->count, 2,
162 'Koha::Objects->search_related should work as expected' );
164 [ $libraries->get_column('branchcode') ],
165 [ $patron_1->{branchcode}, $patron_2->{branchcode} ] ),
166 'Koha::Objects->search_related should work as expected'
170 subtest 'single' => sub {
172 my $builder = t::lib::TestBuilder->new;
173 my $patron_1 = $builder->build( { source => 'Borrower' } );
174 my $patron_2 = $builder->build( { source => 'Borrower' } );
175 my $patron = Koha::Patrons->search({}, { rows => 1 })->single;
176 is(ref($patron), 'Koha::Patron', 'Koha::Objects->single returns a single Koha::Patron object.');
177 warning_like { Koha::Patrons->search->single } qr/SQL that returns multiple rows/,
178 "Warning is presented if single is used for a result with multiple rows.";
181 subtest 'last' => sub {
183 my $builder = t::lib::TestBuilder->new;
184 my $patron_1 = $builder->build( { source => 'Borrower' } );
185 my $patron_2 = $builder->build( { source => 'Borrower' } );
186 my $last_patron = Koha::Patrons->search->last;
187 is( $last_patron->borrowernumber, $patron_2->{borrowernumber}, '->last should return the last inserted patron' );
188 $last_patron = Koha::Patrons->search({ borrowernumber => $patron_1->{borrowernumber} })->last;
189 is( $last_patron->borrowernumber, $patron_1->{borrowernumber}, '->last should work even if there is only 1 result' );
190 $last_patron = Koha::Patrons->search({ surname => 'should_not_exist' })->last;
191 is( $last_patron, undef, '->last should return undef if search does not return any results' );
194 subtest 'get_column' => sub {
196 my @cities = Koha::Cities->search->as_list;
197 my @city_names = map { $_->city_name } @cities;
198 is_deeply( [ Koha::Cities->search->get_column('city_name') ], \@city_names, 'Koha::Objects->get_column should be allowed' );
201 subtest 'Exceptions' => sub {
204 my $patron_borrowernumber = $builder->build({ source => 'Borrower' })->{ borrowernumber };
205 my $patron = Koha::Patrons->find( $patron_borrowernumber );
209 $patron->blah('blah');
211 ok( $_->isa('Koha::Exceptions::Object::MethodNotCoveredByTests'),
212 'Calling a non-covered method should raise a Koha::Exceptions::Object::MethodNotCoveredByTests exception' );
213 is( $_->message, 'The method Koha::Patron->blah is not covered by tests!', 'The message raised should contain the package and the method' );
217 $patron->set({ blah => 'blah' });
219 ok( $_->isa('Koha::Exceptions::Object::PropertyNotFound'),
220 'Setting a non-existent property should raise a Koha::Exceptions::Object::PropertyNotFound exception' );
225 Koha::Patrons->search->not_covered_yet;
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::Patrons->not_covered_yet is not covered by tests!', 'The message raised should contain the package and the method' );
233 Koha::Patrons->not_covered_yet;
235 ok( $_->isa('Koha::Exceptions::Object::MethodNotCoveredByTests'),
236 'Calling a non-covered method should raise a Koha::Exceptions::Object::MethodNotCoveredByTests exception' );
237 is( $_->message, 'The method Koha::Patrons->not_covered_yet is not covered by tests!', 'The message raised should contain the package and the method' );
241 $schema->storage->txn_rollback;
243 subtest '->is_paged and ->pager tests' => sub {
247 $schema->storage->txn_begin;
249 # Count existing patrons
250 my $nb_patrons = Koha::Patrons->search()->count;
251 # Create 10 more patrons
253 $builder->build_object({ class => 'Koha::Patrons' });
256 # Non-paginated search
257 my $patrons = Koha::Patrons->search();
258 is( $patrons->count, $nb_patrons + 10, 'Search returns all patrons' );
259 ok( !$patrons->is_paged, 'Search is not paged' );
262 $patrons = Koha::Patrons->search( undef, { 'page' => 1, 'rows' => 3 } );
263 is( $patrons->count, 3, 'Search returns only one page, 3 patrons' );
264 ok( $patrons->is_paged, 'Search is paged' );
265 my $pager = $patrons->pager;
266 is( ref($patrons->pager), 'DBIx::Class::ResultSet::Pager',
267 'Koha::Objects->pager returns a valid DBIx::Class object' );
269 $schema->storage->txn_rollback;
272 subtest "to_api() tests" => sub {
276 $schema->storage->txn_begin;
278 my $city_1 = $builder->build_object( { class => 'Koha::Cities' } );
279 my $city_2 = $builder->build_object( { class => 'Koha::Cities' } );
281 my $cities = Koha::Cities->search(
283 cityid => [ $city_1->cityid, $city_2->cityid ]
285 { -orderby => { -desc => 'cityid' } }
288 is( $cities->count, 2, 'Count is correct' );
289 my $cities_api = $cities->to_api;
290 is( ref( $cities_api ), 'ARRAY', 'to_api returns an array' );
291 is_deeply( $cities_api->[0], $city_1->to_api, 'to_api returns the individual objects with ->to_api' );
292 is_deeply( $cities_api->[1], $city_2->to_api, 'to_api returns the individual objects with ->to_api' );
294 my $biblio_1 = $builder->build_sample_biblio();
295 my $item_1 = $builder->build_sample_item({ biblionumber => $biblio_1->biblionumber });
296 my $hold_1 = $builder->build_object(
298 class => 'Koha::Holds',
299 value => { itemnumber => $item_1->itemnumber }
303 my $biblio_2 = $builder->build_sample_biblio();
304 my $item_2 = $builder->build_sample_item({ biblionumber => $biblio_2->biblionumber });
305 my $hold_2 = $builder->build_object(
307 class => 'Koha::Holds',
308 value => { itemnumber => $item_2->itemnumber }
312 my $embed = { 'items' => {} };
315 my @items = ( $item_1, $item_2 );
316 my @holds = ( $hold_1, $hold_2 );
318 my $biblios_api = Koha::Biblios->search(
320 biblionumber => [ $biblio_1->biblionumber, $biblio_2->biblionumber ]
322 )->to_api( { embed => $embed } );
324 foreach my $biblio_api ( @{ $biblios_api } ) {
325 ok(exists $biblio_api->{items}, 'Items where embedded in biblio results');
326 is($biblio_api->{items}->[0]->{item_id}, $items[$i]->itemnumber, 'Item matches');
327 ok(!exists $biblio_api->{items}->[0]->{holds}, 'No holds info should be embedded yet');
335 children => { 'holds' => {} }
341 $biblios_api = Koha::Biblios->search(
343 biblionumber => [ $biblio_1->biblionumber, $biblio_2->biblionumber ]
345 )->to_api( { embed => $embed } );
347 foreach my $biblio_api ( @{ $biblios_api } ) {
349 ok(exists $biblio_api->{items}, 'Items where embedded in biblio results');
350 is($biblio_api->{items}->[0]->{item_id}, $items[$i]->itemnumber, 'Item still matches');
351 ok(exists $biblio_api->{items}->[0]->{holds}, 'Holds info should be embedded');
352 is($biblio_api->{items}->[0]->{holds}->[0]->{hold_id}, $holds[$i]->reserve_id, 'Hold matches');
357 subtest 'unprivileged request tests' => sub {
359 my @all_attrs = Koha::Libraries->columns();
360 my $public_attrs = { map { $_ => 1 } @{ Koha::Library->public_read_list() } };
361 my $mapping = Koha::Library->to_api_mapping;
363 # Create sample libraries
364 my $library_1 = $builder->build_object({ class => 'Koha::Libraries' });
365 my $library_2 = $builder->build_object({ class => 'Koha::Libraries' });
366 my $libraries = Koha::Libraries->search(
370 $library_1->branchcode, $library_2->branchcode
376 plan tests => scalar @all_attrs * 2 * $libraries->count;
378 my $libraries_unprivileged_representation = $libraries->to_api({ public => 1 });
379 my $libraries_privileged_representation = $libraries->to_api();
381 for (my $i = 0; $i < $libraries->count; $i++) {
382 my $privileged_representation = $libraries_privileged_representation->[$i];
383 my $unprivileged_representation = $libraries_unprivileged_representation->[$i];
384 foreach my $attr (@all_attrs) {
385 my $mapped = exists $mapping->{$attr} ? $mapping->{$attr} : $attr;
386 if ( defined($mapped) ) {
388 exists $privileged_representation->{$mapped},
389 "Attribute '$attr' is present when privileged"
391 if ( exists $public_attrs->{$attr} ) {
393 exists $unprivileged_representation->{$mapped},
394 "Attribute '$attr' is present when public"
399 !exists $unprivileged_representation->{$mapped},
400 "Attribute '$attr' is not present when public"
406 !exists $privileged_representation->{$attr},
407 "Unmapped attribute '$attr' is not present when privileged"
410 !exists $unprivileged_representation->{$attr},
411 "Unmapped attribute '$attr' is not present when public"
419 $schema->storage->txn_rollback;
422 subtest "TO_JSON() tests" => sub {
426 $schema->storage->txn_begin;
428 my $city_1 = $builder->build_object( { class => 'Koha::Cities' } );
429 my $city_2 = $builder->build_object( { class => 'Koha::Cities' } );
431 my $cities = Koha::Cities->search(
433 cityid => [ $city_1->cityid, $city_2->cityid ]
435 { -orderby => { -desc => 'cityid' } }
438 is( $cities->count, 2, 'Count is correct' );
439 my $cities_json = $cities->TO_JSON;
440 is( ref($cities_json), 'ARRAY', 'to_api returns an array' );
441 is_deeply( $cities_json->[0], $city_1->TO_JSON, 'TO_JSON returns the individual objects with ->TO_JSON' );
442 is_deeply( $cities_json->[1], $city_2->TO_JSON,'TO_JSON returns the individual objects with ->TO_JSON' );
444 $schema->storage->txn_rollback;
447 # Koha::Object[s] must behave the same as DBIx::Class
448 subtest 'Return same values as DBIx::Class' => sub {
451 subtest 'Delete' => sub {
454 $schema->storage->txn_begin;
456 subtest 'Simple Koha::Objects - Koha::Cities' => sub {
459 subtest 'Koha::Object->delete' => sub {
463 my ( $r_us, $e_us, $r_them, $e_them );
465 # CASE 1 - Delete an existing object
466 my $c = Koha::City->new( { city_name => 'city4test' } )->store;
467 try { $r_us = $c->delete; } catch { $e_us = $_ };
468 $c = $schema->resultset('City')->new( { city_name => 'city4test_2' } )->update_or_insert;
469 try { $r_them = $c->delete; } catch { $e_them = $_ };
470 ok( ref($r_us) && ref($r_them),
471 'Successful delete should return the object ' );
472 ok( !defined $e_us && !defined $e_them,
473 'Successful delete should not raise an exception' );
474 is( ref($r_us), 'Koha::City', 'Successful delete should return our Koha::Obect based object' );
476 # CASE 2 - Delete an object that is not in storage
477 try { $r_us = $r_us->delete; } catch { $e_us = $_ };
478 try { $r_them = $r_them->delete; } catch { $e_them = $_ };
480 defined $e_us && defined $e_them,
481 'Delete an object that is not in storage should raise an exception'
483 is( ref($e_us), 'DBIx::Class::Exception' )
484 ; # FIXME This needs adjustement, we want to throw a Koha::Exception
488 subtest 'Koha::Objects->delete' => sub {
492 my ( $r_us, $e_us, $r_them, $e_them );
494 # CASE 1 - Delete existing objects
495 my $city_1 = $builder->build_object({ class => 'Koha::Cities' });
496 my $city_2 = $builder->build_object({ class => 'Koha::Cities' });
497 my $city_3 = $builder->build_object({ class => 'Koha::Cities' });
498 my $cities = Koha::Cities->search(
510 try { $r_us = $cities->delete; } catch { $e_us = $_ };
512 $city_1 = $builder->build_object({ class => 'Koha::Cities' });
513 $city_2 = $builder->build_object({ class => 'Koha::Cities' });
514 $city_3 = $builder->build_object({ class => 'Koha::Cities' });
515 $cities = $schema->resultset('City')->search(
527 try { $r_them = $cities->delete; } catch { $e_them = $_ };
529 ok( $r_us == 3 && $r_them == 3 );
530 ok (!defined($e_us) && !defined($e_them));
532 # CASE 2 - One of the object is not in storage
533 $city_1 = $builder->build_object({ class => 'Koha::Cities' });
534 $city_2 = $builder->build_object({ class => 'Koha::Cities' });
535 $city_3 = $builder->build_object({ class => 'Koha::Cities' });
536 $cities = Koha::Cities->search(
548 $city_2->delete; # We delete one of the object
549 try { $r_us = $cities->delete; } catch { $e_us = $_ };
551 $city_1 = $builder->build_object({ class => 'Koha::Cities' });
552 $city_2 = $builder->build_object({ class => 'Koha::Cities' });
553 $city_3 = $builder->build_object({ class => 'Koha::Cities' });
554 $cities = $schema->resultset('City')->search(
566 $city_2->delete; # We delete one of the object
567 try { $r_them = $cities->delete; } catch { $e_them = $_ };
569 ok( $r_us == 2 && $r_them == 2 );
570 ok (!defined($e_us) && !defined($e_them));
574 subtest 'Overwritten Koha::Objects->delete - Koha::Patrons' => sub {
578 subtest 'Koha::Object->delete' => sub {
582 my ( $r_us, $e_us, $r_them, $e_them );
584 # CASE 1 - Delete an existing patron
585 my $patron = $builder->build_object({ class => 'Koha::Patrons' });
586 my $patron_data = $patron->unblessed;
589 $patron = Koha::Patron->new( $patron_data )->store;
590 try {$r_us = $patron->delete;} catch { $e_us = $_ };
591 $patron = $schema->resultset('Borrower')->new( $patron_data )->update_or_insert;
592 try {$r_them = $patron->delete;} catch { $e_them = $_ };
593 ok( ref($r_us) && ref($r_them),
594 'Successful delete should return the patron object' );
595 ok( !defined $e_us && !defined $e_them,
596 'Successful delete should not raise an exception' );
597 is( ref($r_us), 'Koha::Patron',
598 'Successful delete should return our Koha::Obect based object' );
600 # CASE 2 - Delete a patron that is not in storage
601 try { $r_us = $r_us->delete; } catch { $e_us = $_ };
602 try { $r_them = $r_them->delete; } catch { $e_them = $_ };
604 defined $e_us && defined $e_them,
605 'Delete a patron that is not in storage should raise an exception'
607 is( ref($e_us), 'DBIx::Class::Exception' )
608 ; # FIXME This needs adjustement, we want to throw a Koha::Exception
610 # CASE 3 - Delete a patron that cannot be deleted (as a checkout)
611 $patron = Koha::Patron->new($patron_data)->store;
612 $builder->build_object(
614 class => 'Koha::Checkouts',
615 value => { borrowernumber => $patron->borrowernumber }
618 try { $r_us = $r_us->delete; } catch { $e_us = $_ };
619 $patron = $schema->resultset('Borrower')->find( $patron->borrowernumber );
620 try { $r_them = $r_them->delete; } catch { $e_them = $_ };
622 defined $e_us && defined $e_them,
623 'Delete a patron that cannot be deleted should raise an exception'
625 is( ref($e_us), 'DBIx::Class::Exception' )
626 ; # FIXME This needs adjustement, we want to throw a Koha::Exception
629 subtest 'Koha::Objects->delete' => sub {
633 my ( $r_us, $e_us, $r_them, $e_them );
635 # CASE 1 - Delete existing objects
636 my $patron_1 = $builder->build_object({ class => 'Koha::Patrons' });
637 my $patron_2 = $builder->build_object({ class => 'Koha::Patrons' });
638 my $patron_3 = $builder->build_object({ class => 'Koha::Patrons' });
639 my $patrons = Koha::Patrons->search(
643 $patron_1->borrowernumber,
644 $patron_2->borrowernumber,
645 $patron_3->borrowernumber
651 try { $r_us = $patrons->delete; } catch { $e_us = $_ };
653 $patron_1 = $builder->build_object({ class => 'Koha::Patrons' });
654 $patron_2 = $builder->build_object({ class => 'Koha::Patrons' });
655 $patron_3 = $builder->build_object({ class => 'Koha::Patrons' });
656 $patrons = $schema->resultset('Borrower')->search(
660 $patron_1->borrowernumber,
661 $patron_2->borrowernumber,
662 $patron_3->borrowernumber
668 try { $r_them = $patrons->delete; } catch { $e_them = $_ };
670 ok( $r_us == 3 && $r_them == 3, '->delete should return the number of deleted patrons' );
671 ok (!defined($e_us) && !defined($e_them), '->delete should not raise exception if everything went well');
673 # CASE 2 - One of the patrons is not in storage
674 undef $_ for $r_us, $e_us, $r_them, $e_them;
675 $patron_1 = $builder->build_object({ class => 'Koha::Patrons' });
676 $patron_2 = $builder->build_object({ class => 'Koha::Patrons' });
677 $patron_3 = $builder->build_object({ class => 'Koha::Patrons' });
678 $patrons = Koha::Patrons->search(
682 $patron_1->borrowernumber,
683 $patron_2->borrowernumber,
684 $patron_3->borrowernumber
690 $patron_2->delete; # We delete one of the patron
691 try { $r_us = $patrons->delete; } catch { $e_us = $_ };
693 $patron_1 = $builder->build_object({ class => 'Koha::Patrons' });
694 $patron_2 = $builder->build_object({ class => 'Koha::Patrons' });
695 $patron_3 = $builder->build_object({ class => 'Koha::Patrons' });
696 $patrons = $schema->resultset('Borrower')->search(
700 $patron_1->borrowernumber,
701 $patron_2->borrowernumber,
702 $patron_3->borrowernumber
708 $patron_2->delete; # We delete one of the patron
709 try { $r_them = $patrons->delete; } catch { $e_them = $_ };
711 ok( $r_us == 2 && $r_them == 2, 'Delete patrons with one that was not in storage should delete the patrons' );
712 ok (!defined($e_us) && !defined($e_them), 'no exception should be raised if at least one patron was not in storage');
714 # CASE 3 - Delete a set of patrons with one that that cannot be deleted (as a checkout)
715 undef $_ for $r_us, $e_us, $r_them, $e_them;
716 $patron_1 = $builder->build_object({ class => 'Koha::Patrons' });
717 $patron_2 = $builder->build_object({ class => 'Koha::Patrons' });
718 $patron_3 = $builder->build_object({ class => 'Koha::Patrons' });
719 $patrons = Koha::Patrons->search(
723 $patron_1->borrowernumber,
724 $patron_2->borrowernumber,
725 $patron_3->borrowernumber
731 # Adding a checkout to patron_2
732 $builder->build_object(
734 class => 'Koha::Checkouts',
735 value => { borrowernumber => $patron_2->borrowernumber }
739 try { $r_us = $patrons->delete; } catch { $e_us = $_ };
740 my $not_deleted_us = $patron_1->in_storage + $patron_2->in_storage + $patron_3->in_storage;
742 $patron_1 = $builder->build_object({ class => 'Koha::Patrons' });
743 $patron_2 = $builder->build_object({ class => 'Koha::Patrons' });
744 $patron_3 = $builder->build_object({ class => 'Koha::Patrons' });
745 $patrons = $schema->resultset('Borrower')->search(
749 $patron_1->borrowernumber,
750 $patron_2->borrowernumber,
751 $patron_3->borrowernumber
757 # Adding a checkout to patron_2
758 $builder->build_object(
760 class => 'Koha::Checkouts',
761 value => { borrowernumber => $patron_2->borrowernumber }
765 try { $r_them = $patrons->delete; } catch { $e_them = $_ };
767 my $not_deleted_them = $patron_1->in_storage + $patron_2->in_storage + $patron_3->in_storage;
769 defined $e_us && defined $e_them,
770 'Delete patrons with one that cannot be deleted should raise an exception'
772 is( ref($e_us), 'DBIx::Class::Exception' )
773 ; # FIXME This needs adjustement, we want to throw a Koha::Exception
775 ok($not_deleted_us == 3 && $not_deleted_them == 3, 'If one patron cannot be deleted, none should have been deleted');
779 $schema->storage->txn_rollback;
783 subtest 'Update (set/store)' => sub {
786 $schema->storage->txn_begin;
788 subtest 'Simple Koha::Objects - Koha::Cities' => sub {
791 subtest 'Koha::Object->update' => sub {
795 my ( $r_us, $e_us, $r_them, $e_them );
797 # CASE 1 - Update an existing object
798 my $c_us = Koha::City->new( { city_name => 'city4test' } )->store;
799 try { $r_us = $c_us->update({ city_country => 'country4test' }); } catch { $e_us = $_ };
800 my $c_them = $schema->resultset('City')->new( { city_name => 'city4test_2' } )->update_or_insert;
801 try { $r_them = $c_them->update({ city_country => 'country4test_2' }); } catch { $e_them = $_ };
802 ok( ref($r_us) && ref($r_them),
803 'Successful update should return the object ' );
804 ok( !defined $e_us && !defined $e_them,
805 'Successful update should not raise an exception' );
806 is( ref($r_us), 'Koha::City', 'Successful update should return our Koha::Obect based object' );
808 # CASE 2 - Update an object that is not in storage
811 try { $r_us = $c_us->update({ city_country => 'another_country' }); } catch { $e_us = $_ };
812 try { $r_them = $c_them->update({ city_country => 'another_country' }); } catch { $e_them = $_ };
814 defined $e_us && defined $e_them,
815 'Update an object that is not in storage should raise an exception'
817 is( ref($e_us), 'Koha::Exceptions::Object::NotInStorage' );
820 subtest 'Koha::Objects->update' => sub {
824 my ( $r_us, $e_us, $r_them, $e_them );
826 # CASE 1 - update existing objects
827 my $city_1 = $builder->build_object({ class => 'Koha::Cities' });
828 my $city_2 = $builder->build_object({ class => 'Koha::Cities' });
829 my $city_3 = $builder->build_object({ class => 'Koha::Cities' });
830 my $cities = Koha::Cities->search(
842 try { $r_us = $cities->update({ city_country => 'country4test' }); } catch { $e_us = $_ };
844 $city_1 = $builder->build_object({ class => 'Koha::Cities' });
845 $city_2 = $builder->build_object({ class => 'Koha::Cities' });
846 $city_3 = $builder->build_object({ class => 'Koha::Cities' });
847 $cities = $schema->resultset('City')->search(
859 try { $r_them = $cities->update({ city_country => 'country4test' }); } catch { $e_them = $_ };
861 ok( $r_us == 3 && $r_them == 3, '->update should return the number of updated cities' );
862 ok(!defined($e_us) && !defined($e_them));
864 # CASE 2 - One of the object is not in storage
865 $city_1 = $builder->build_object({ class => 'Koha::Cities' });
866 $city_2 = $builder->build_object({ class => 'Koha::Cities' });
867 $city_3 = $builder->build_object({ class => 'Koha::Cities' });
868 $cities = Koha::Cities->search(
880 $city_2->delete; # We delete one of the object
881 try { $r_us = $cities->update({ city_country => 'country4test' }); } catch { $e_us = $_ };
883 $city_1 = $builder->build_object({ class => 'Koha::Cities' });
884 $city_2 = $builder->build_object({ class => 'Koha::Cities' });
885 $city_3 = $builder->build_object({ class => 'Koha::Cities' });
886 $cities = $schema->resultset('City')->search(
898 $city_2->delete; # We delete one of the object
899 try { $r_them = $cities->update({ city_country => 'country4test' }); } catch { $e_them = $_ };
901 ok( $r_us == 2 && $r_them == 2, '->update should return the number of updated cities' );
902 ok(!defined($e_us) && !defined($e_them));
905 { Koha::Cities->update({ city_country => 'Castalia' }); }
906 'Koha::Exceptions::Object::NotInstantiated',
907 'Exception thrown if not instantiated class';
909 is( "$@", 'Tried to access the \'update\' method, but Koha::Cities is not instantiated', 'Exception stringified correctly' );
914 subtest 'Overwritten Koha::Objects->store|update - Koha::Patrons' => sub {
918 subtest 'Koha::Object->update' => sub {
922 my ( $r_us, $e_us, $r_them, $e_them );
924 # CASE 1 - Update an existing patron
925 my $patron_us = $builder->build_object({ class => 'Koha::Patrons' });
926 try {$r_us = $patron_us->update({city => 'a_city'});} catch { $e_us = $_ };
928 my $patron_data = $builder->build_object({ class => 'Koha::Patrons' })->delete->unblessed;
929 my $patron_them = $schema->resultset('Borrower')->new( $patron_data )->update_or_insert;
930 try {$r_them = $patron_them->update({city => 'a_city'});} catch { $e_them = $_ };
931 ok( ref($r_us) && ref($r_them),
932 'Successful update should return the patron object' );
933 ok( !defined $e_us && !defined $e_them,
934 'Successful update should not raise an exception' );
935 is( ref($r_us), 'Koha::Patron',
936 'Successful update should return our Koha::Obect based object' );
938 # CASE 2 - Update a patron that is not in storage
940 $patron_them->delete;
941 try { $r_us = $patron_us->update({ city => 'another_city' }); } catch { $e_us = $_ };
942 try { $r_them = $patron_them->update({ city => 'another_city' }); } catch { $e_them = $_ };
944 defined $e_us && defined $e_them,
945 'Update a patron that is not in storage should raise an exception'
947 is( ref($e_us), 'Koha::Exceptions::Object::NotInStorage' );
951 subtest 'Koha::Objects->Update ' => sub {
955 my ( $r_us, $e_us, $r_them, $e_them );
957 # CASE 1 - Update existing objects
958 my $patron_1 = $builder->build_object({ class => 'Koha::Patrons' });
959 my $patron_2 = $builder->build_object({ class => 'Koha::Patrons' });
960 my $patron_3 = $builder->build_object({ class => 'Koha::Patrons' });
961 my $patrons_us = Koha::Patrons->search(
965 $patron_1->borrowernumber,
966 $patron_2->borrowernumber,
967 $patron_3->borrowernumber
973 try { $r_us = $patrons_us->update({ city => 'a_city' }); } catch { $e_us = $_ };
975 $patron_1 = $builder->build_object({ class => 'Koha::Patrons' });
976 $patron_2 = $builder->build_object({ class => 'Koha::Patrons' });
977 $patron_3 = $builder->build_object({ class => 'Koha::Patrons' });
978 my $patrons_them = $schema->resultset('Borrower')->search(
982 $patron_1->borrowernumber,
983 $patron_2->borrowernumber,
984 $patron_3->borrowernumber
990 try { $r_them = $patrons_them->update({ city => 'a_city' }); } catch { $e_them = $_ };
992 ok( $r_us == 3 && $r_them == 3, '->update should return the number of update patrons' );
993 ok (!defined($e_us) && !defined($e_them), '->update should not raise exception if everything went well');
995 # CASE 2 - One of the patrons is not in storage
996 undef $_ for $r_us, $e_us, $r_them, $e_them;
997 $patron_1 = $builder->build_object({ class => 'Koha::Patrons' });
998 $patron_2 = $builder->build_object({ class => 'Koha::Patrons' });
999 $patron_3 = $builder->build_object({ class => 'Koha::Patrons' });
1000 $patrons_us = Koha::Patrons->search(
1004 $patron_1->borrowernumber,
1005 $patron_2->borrowernumber,
1006 $patron_3->borrowernumber
1012 $patron_2->delete; # We delete one of the patron
1013 try { $r_us = $patrons_us->update({ city => 'another_city' }); } catch { $e_us = $_ };
1015 $patron_1 = $builder->build_object({ class => 'Koha::Patrons' });
1016 $patron_2 = $builder->build_object({ class => 'Koha::Patrons' });
1017 $patron_3 = $builder->build_object({ class => 'Koha::Patrons' });
1018 $patrons_them = $schema->resultset('Borrower')->search(
1022 $patron_1->borrowernumber,
1023 $patron_2->borrowernumber,
1024 $patron_3->borrowernumber
1030 $patron_2->delete; # We delete one of the patron
1031 try { $r_them = $patrons_them->update({ city => 'another_city' }); } catch { $e_them = $_ };
1033 ok( $r_us == 2 && $r_them == 2, 'Update patrons with one that was not in storage should update the patrons' );
1034 ok (!defined($e_us) && !defined($e_them), 'no exception should be raised if at least one patron was not in storage');
1037 # Testing no_triggers
1038 t::lib::Mocks::mock_preference('uppercasesurnames', 1);
1039 $patrons_us = Koha::Patrons->search(
1043 $patron_1->borrowernumber,
1044 $patron_2->borrowernumber,
1045 $patron_3->borrowernumber
1050 $patrons_us->update({ surname => 'foo' }); # Koha::Patron->store is supposed to uppercase the surnames
1051 is( $patrons_us->search({ surname => 'FOO' })->count, 2, 'Koha::Patron->store is hit' );
1053 $patrons_us->update({ surname => 'foo' }, { no_triggers => 1 }); # The surnames won't be uppercase as we won't hit Koha::Patron->store
1054 is( $patrons_us->search({ surname => 'foo' })->count, 2, 'Koha::Patron->store is not hit');
1060 $schema->storage->txn_rollback;
1066 subtest "attributes_from_api() tests" => sub {
1070 $schema->storage->txn_begin;
1072 my $cities_rs = Koha::Cities->new;
1073 my $city = Koha::City->new;
1075 my $api_attributes = {
1081 $cities_rs->attributes_from_api($api_attributes),
1082 $city->attributes_from_api($api_attributes)
1085 $schema->storage->txn_rollback;
1089 subtest "filter_by_last_update" => sub {
1091 $schema->storage->txn_begin;
1093 my $now = dt_from_string->truncate( to => 'day' );
1094 my @borrowernumbers;
1095 # Building 6 patrons that have been created today, yesterday, ... 1 per day
1096 for my $i ( 0 .. 5 ) {
1097 push @borrowernumbers,
1098 $builder->build_object(
1100 class => 'Koha::Patrons',
1101 value => { updated_on => $now->clone->subtract( days => $i ) }
1106 my $patrons = Koha::Patrons->search(
1107 { borrowernumber => { -in => \@borrowernumbers } } );
1110 $patrons->filter_by_last_update( { timestamp_column_name => 'updated_on' } )
1115 $_->isa('Koha::Exceptions::MissingParameter'),
1116 'Should raise an exception if no parameter given'
1120 my $filtered_patrons = $patrons->filter_by_last_update(
1121 { timestamp_column_name => 'updated_on', days => 2 } );
1122 is( ref($filtered_patrons), 'Koha::Patrons', 'filter_by_last_update must return a Koha::Objects-based object' );
1124 my $count = $patrons->filter_by_last_update(
1125 { timestamp_column_name => 'updated_on', days => 2 } )->count;
1126 is( $count, 3, '3 patrons have been updated before the last 2 days (exclusive)' );
1128 $count = $patrons->filter_by_last_update(
1129 { timestamp_column_name => 'updated_on', days => 2, days_inclusive => 1 } )->count;
1130 is( $count, 4, '4 patrons have been updated before the last 2 days (inclusive)' );
1132 $count = $patrons->filter_by_last_update(
1133 { timestamp_column_name => 'updated_on', days => 1 } )->count;
1134 is( $count, 4, '4 patrons have been updated before yesterday (exclusive)' );
1136 $count = $patrons->filter_by_last_update(
1137 { timestamp_column_name => 'updated_on', days => 1, days_inclusive => 1 } )->count;
1138 is( $count, 5, '5 patrons have been updated before yesterday (inclusive)' );
1140 $count = $patrons->filter_by_last_update(
1141 { timestamp_column_name => 'updated_on', days => 0 } )->count;
1142 is( $count, 5, '5 patrons have been updated before today (exclusive)' );
1144 $count = $patrons->filter_by_last_update(
1145 { timestamp_column_name => 'updated_on', days => 0, days_inclusive => 1 } )->count;
1146 is( $count, 6, '6 patrons have been updated before today (inclusive)' );
1148 $count = $patrons->filter_by_last_update(
1149 { timestamp_column_name => 'updated_on', from => $now } )->count;
1150 is( $count, 1, '1 patron has been updated "from today" (inclusive)' );
1152 $count = $patrons->filter_by_last_update(
1153 { timestamp_column_name => 'updated_on', to => $now } )->count;
1154 is( $count, 6, '6 patrons have been updated "to today" (inclusive)' );
1156 $count = $patrons->filter_by_last_update(
1158 timestamp_column_name => 'updated_on',
1159 from => $now->clone->subtract( days => 4 ),
1160 to => $now->clone->subtract( days => 2 )
1163 is( $count, 3, '3 patrons have been updated between D-4 and D-2' );
1165 t::lib::Mocks::mock_preference( 'dateformat', 'metric' );
1167 $count = $patrons->filter_by_last_update(
1168 { timestamp_column_name => 'updated_on', from => '1970-12-31' } )
1174 'No exception raised, from and to parameters can take an iso formatted date'
1179 $count = $patrons->filter_by_last_update(
1180 { timestamp_column_name => 'updated_on', from => '31/12/1970' } )
1186 'No exception raised, from and to parameters can take an metric formatted date (depending on dateformat syspref)'
1191 $schema->storage->txn_rollback;
1194 subtest "from_api_mapping() tests" => sub {
1198 $schema->storage->txn_begin;
1200 my $cities_rs = Koha::Cities->new;
1201 my $city = Koha::City->new;
1204 $cities_rs->from_api_mapping,
1205 $city->from_api_mapping
1208 $schema->storage->txn_rollback;
1211 subtest 'prefetch_whitelist() tests' => sub {
1215 $schema->storage->txn_begin;
1217 my $biblios = Koha::Biblios->new;
1219 my $prefetch_whitelist = $biblios->prefetch_whitelist;
1222 exists $prefetch_whitelist->{orders},
1223 'Relationship matching method name is listed'
1226 $prefetch_whitelist->{orders},
1227 'Koha::Acquisition::Order',
1228 'Guessed the non-standard object class correctly'
1232 $prefetch_whitelist->{items},
1234 'Guessed the standard object class correctly'
1237 $schema->storage->txn_rollback;
1240 subtest 'empty() tests' => sub {
1244 $schema->storage->txn_begin;
1246 # Add a patron, we need at least 1
1247 my $patron = $builder->build_object({ class => 'Koha::Patrons' });
1248 ok( Koha::Patrons->count > 0, 'There is at least one Koha::Patron on the resultset' );
1250 my $empty = Koha::Patrons->new->empty;
1251 is( ref($empty), 'Koha::Patrons', '->empty returns a Koha::Patrons iterator' );
1252 is( $empty->count, 0, 'The empty resultset is, well, empty :-D' );
1254 my $new_rs = $empty->search({ borrowernumber => $patron->borrowernumber });
1256 is( $new_rs->count, 0, 'Further chaining an empty resultset, returns an empty resultset' );
1259 { Koha::Patrons->empty; }
1260 'Koha::Exceptions::Object::NotInstantiated',
1261 'Exception thrown if not instantiated class';
1263 is( "$@", 'Tried to access the \'empty\' method, but Koha::Patrons is not instantiated', 'Exception stringified correctly' );
1265 $schema->storage->txn_rollback;
1268 subtest 'delete() tests' => sub {
1272 $schema->storage->txn_begin;
1274 # Make sure no cities
1275 warnings_are { Koha::Cities->delete }[],
1276 "No warnings, no Koha::City->delete called as it doesn't exist";
1279 my $mocked_city = Test::MockModule->new('Koha::City');
1283 shift->_result->delete;
1284 warn "delete called!";
1289 $builder->build_object( { class => 'Koha::Cities' } );
1290 $builder->build_object( { class => 'Koha::Cities' } );
1292 my $cities = Koha::Cities->search;
1294 warnings_are { $cities->delete }
1295 [ "delete called!", "delete called!" ],
1296 "No warnings, no Koha::City->delete called as it doesn't exist";
1298 $schema->storage->txn_rollback;