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 => 24;
27 use Koha::Authority::Types;
30 use Koha::Patron::Category;
31 use Koha::Patron::Categories;
34 use Koha::DateUtils qw( dt_from_string );
36 use t::lib::TestBuilder;
41 my $schema = Koha::Database->new->schema;
42 $schema->storage->txn_begin;
43 my $builder = t::lib::TestBuilder->new;
45 is( ref(Koha::Authority::Types->find('')), 'Koha::Authority::Type', 'Koha::Objects->find should work if the primary key is an empty string' );
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' );
51 subtest 'find' => sub {
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' );
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');
62 foo => Koha::Patrons->find('foo'),
65 is ($patrons->{foo}, undef, '->find in list context returns undef when no record is found');
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";
74 subtest 'update' => sub {
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' );
88 subtest 'reset' => sub {
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');
99 subtest 'delete' => sub {
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, '');
108 subtest 'new' => sub {
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;
119 subtest 'find' => sub {
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"
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' );
138 is( Koha::Patrons->find(), undef, 'Find returns undef if no params passed' );
141 subtest 'search_related' => sub {
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(
150 [ $patron_1->{borrowernumber}, $patron_2->{borrowernumber} ]
153 )->search_related('branchcode');
154 is( ref($libraries), 'Koha::Libraries',
155 'Koha::Objects->search_related should return an instanciated Koha::Objects-based object'
157 is( $libraries->count, 2,
158 'Koha::Objects->search_related should work as expected' );
160 [ $libraries->get_column('branchcode') ],
161 [ $patron_1->{branchcode}, $patron_2->{branchcode} ] ),
162 'Koha::Objects->search_related should work as expected'
165 my @libraries = Koha::Patrons->search(
169 [ $patron_1->{borrowernumber}, $patron_2->{borrowernumber} ]
172 )->search_related('branchcode');
174 ref( $libraries[0] ), 'Koha::Library',
175 'Koha::Objects->search_related should return a list of Koha::Object-based objects'
177 is( scalar(@libraries), 2,
178 'Koha::Objects->search_related should work as expected' );
180 [ map { $_->branchcode } @libraries ],
181 [ $patron_1->{branchcode}, $patron_2->{branchcode} ] ),
182 'Koha::Objects->search_related should work as expected'
186 subtest 'single' => sub {
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.";
197 subtest 'last' => sub {
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' );
210 subtest 'get_column' => sub {
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' );
217 subtest 'Exceptions' => sub {
220 my $patron_borrowernumber = $builder->build({ source => 'Borrower' })->{ borrowernumber };
221 my $patron = Koha::Patrons->find( $patron_borrowernumber );
225 $patron->blah('blah');
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' );
233 $patron->set({ blah => 'blah' });
235 ok( $_->isa('Koha::Exceptions::Object::PropertyNotFound'),
236 'Setting a non-existent property should raise a Koha::Exceptions::Object::PropertyNotFound exception' );
241 Koha::Patrons->search->not_covered_yet;
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' );
249 Koha::Patrons->not_covered_yet;
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' );
257 $schema->storage->txn_rollback;
259 subtest '->is_paged and ->pager tests' => sub {
263 $schema->storage->txn_begin;
265 # Delete existing patrons
266 t::lib::Mocks::mock_preference('AnonymousPatron', '');
267 Koha::Checkouts->delete;
268 Koha::Patrons->delete;
271 $builder->build_object({ class => 'Koha::Patrons' });
274 # Non-paginated search
275 my $patrons = Koha::Patrons->search();
276 is( $patrons->count, 10, 'Search returns all patrons' );
277 ok( !$patrons->is_paged, 'Search is not paged' );
280 $patrons = Koha::Patrons->search( undef, { 'page' => 1, 'rows' => 3 } );
281 is( $patrons->count, 3, 'Search returns only one page, 3 patrons' );
282 ok( $patrons->is_paged, 'Search is paged' );
283 my $pager = $patrons->pager;
284 is( ref($patrons->pager), 'DBIx::Class::ResultSet::Pager',
285 'Koha::Objects->pager returns a valid DBIx::Class object' );
287 $schema->storage->txn_rollback;
290 subtest '->search() tests' => sub {
294 $schema->storage->txn_begin;
296 my $count = Koha::Patrons->search->count;
300 $builder->build_object({ class => 'Koha::Patrons' });
303 my $patrons = Koha::Patrons->search();
304 is( ref($patrons), 'Koha::Patrons', 'search in scalar context returns the Koha::Object-based type' );
305 my @patrons = Koha::Patrons->search();
306 is( scalar @patrons, $count + 10, 'search in list context returns a list of objects' );
309 is( ref($patrons[$i]), 'Koha::Patron', 'Objects in the list have the singular type' );
313 $schema->storage->txn_rollback;
316 subtest "to_api() tests" => sub {
320 $schema->storage->txn_begin;
322 my $city_1 = $builder->build_object( { class => 'Koha::Cities' } );
323 my $city_2 = $builder->build_object( { class => 'Koha::Cities' } );
325 my $cities = Koha::Cities->search(
327 cityid => [ $city_1->cityid, $city_2->cityid ]
329 { -orderby => { -desc => 'cityid' } }
332 is( $cities->count, 2, 'Count is correct' );
333 my $cities_api = $cities->to_api;
334 is( ref( $cities_api ), 'ARRAY', 'to_api returns an array' );
335 is_deeply( $cities_api->[0], $city_1->to_api, 'to_api returns the individual objects with ->to_api' );
336 is_deeply( $cities_api->[1], $city_2->to_api, 'to_api returns the individual objects with ->to_api' );
338 my $biblio_1 = $builder->build_sample_biblio();
339 my $item_1 = $builder->build_sample_item({ biblionumber => $biblio_1->biblionumber });
340 my $hold_1 = $builder->build_object(
342 class => 'Koha::Holds',
343 value => { itemnumber => $item_1->itemnumber }
347 my $biblio_2 = $builder->build_sample_biblio();
348 my $item_2 = $builder->build_sample_item({ biblionumber => $biblio_2->biblionumber });
349 my $hold_2 = $builder->build_object(
351 class => 'Koha::Holds',
352 value => { itemnumber => $item_2->itemnumber }
356 my $embed = { 'items' => {} };
359 my @items = ( $item_1, $item_2 );
360 my @holds = ( $hold_1, $hold_2 );
362 my $biblios_api = Koha::Biblios->search(
364 biblionumber => [ $biblio_1->biblionumber, $biblio_2->biblionumber ]
366 )->to_api( { embed => $embed } );
368 foreach my $biblio_api ( @{ $biblios_api } ) {
369 ok(exists $biblio_api->{items}, 'Items where embedded in biblio results');
370 is($biblio_api->{items}->[0]->{item_id}, $items[$i]->itemnumber, 'Item matches');
371 ok(!exists $biblio_api->{items}->[0]->{holds}, 'No holds info should be embedded yet');
379 children => { 'holds' => {} }
385 $biblios_api = Koha::Biblios->search(
387 biblionumber => [ $biblio_1->biblionumber, $biblio_2->biblionumber ]
389 )->to_api( { embed => $embed } );
391 foreach my $biblio_api ( @{ $biblios_api } ) {
393 ok(exists $biblio_api->{items}, 'Items where embedded in biblio results');
394 is($biblio_api->{items}->[0]->{item_id}, $items[$i]->itemnumber, 'Item still matches');
395 ok(exists $biblio_api->{items}->[0]->{holds}, 'Holds info should be embedded');
396 is($biblio_api->{items}->[0]->{holds}->[0]->{hold_id}, $holds[$i]->reserve_id, 'Hold matches');
401 $schema->storage->txn_rollback;
404 subtest "TO_JSON() tests" => sub {
408 $schema->storage->txn_begin;
410 my $city_1 = $builder->build_object( { class => 'Koha::Cities' } );
411 my $city_2 = $builder->build_object( { class => 'Koha::Cities' } );
413 my $cities = Koha::Cities->search(
415 cityid => [ $city_1->cityid, $city_2->cityid ]
417 { -orderby => { -desc => 'cityid' } }
420 is( $cities->count, 2, 'Count is correct' );
421 my $cities_json = $cities->TO_JSON;
422 is( ref($cities_json), 'ARRAY', 'to_api returns an array' );
423 is_deeply( $cities_json->[0], $city_1->TO_JSON, 'TO_JSON returns the individual objects with ->TO_JSON' );
424 is_deeply( $cities_json->[1], $city_2->TO_JSON,'TO_JSON returns the individual objects with ->TO_JSON' );
426 $schema->storage->txn_rollback;
429 # Koha::Object[s] must behave the same as DBIx::Class
430 subtest 'Return same values as DBIx::Class' => sub {
433 subtest 'Delete' => sub {
436 $schema->storage->txn_begin;
438 subtest 'Simple Koha::Objects - Koha::Cities' => sub {
441 subtest 'Koha::Object->delete' => sub {
445 my ( $r_us, $e_us, $r_them, $e_them );
447 # CASE 1 - Delete an existing object
448 my $c = Koha::City->new( { city_name => 'city4test' } )->store;
449 try { $r_us = $c->delete; } catch { $e_us = $_ };
450 $c = $schema->resultset('City')->new( { city_name => 'city4test_2' } )->update_or_insert;
451 try { $r_them = $c->delete; } catch { $e_them = $_ };
452 ok( ref($r_us) && ref($r_them),
453 'Successful delete should return the object ' );
454 ok( !defined $e_us && !defined $e_them,
455 'Successful delete should not raise an exception' );
456 is( ref($r_us), 'Koha::City', 'Successful delete should return our Koha::Obect based object' );
458 # CASE 2 - Delete an object that is not in storage
459 try { $r_us = $r_us->delete; } catch { $e_us = $_ };
460 try { $r_them = $r_them->delete; } catch { $e_them = $_ };
462 defined $e_us && defined $e_them,
463 'Delete an object that is not in storage should raise an exception'
465 is( ref($e_us), 'DBIx::Class::Exception' )
466 ; # FIXME This needs adjustement, we want to throw a Koha::Exception
470 subtest 'Koha::Objects->delete' => sub {
474 my ( $r_us, $e_us, $r_them, $e_them );
476 # CASE 1 - Delete existing objects
477 my $city_1 = $builder->build_object({ class => 'Koha::Cities' });
478 my $city_2 = $builder->build_object({ class => 'Koha::Cities' });
479 my $city_3 = $builder->build_object({ class => 'Koha::Cities' });
480 my $cities = Koha::Cities->search(
492 try { $r_us = $cities->delete; } catch { $e_us = $_ };
494 $city_1 = $builder->build_object({ class => 'Koha::Cities' });
495 $city_2 = $builder->build_object({ class => 'Koha::Cities' });
496 $city_3 = $builder->build_object({ class => 'Koha::Cities' });
497 $cities = $schema->resultset('City')->search(
509 try { $r_them = $cities->delete; } catch { $e_them = $_ };
511 ok( $r_us == 3 && $r_them == 3 );
512 ok (!defined($e_us) && !defined($e_them));
514 # CASE 2 - One of the object is not in storage
515 $city_1 = $builder->build_object({ class => 'Koha::Cities' });
516 $city_2 = $builder->build_object({ class => 'Koha::Cities' });
517 $city_3 = $builder->build_object({ class => 'Koha::Cities' });
518 $cities = Koha::Cities->search(
530 $city_2->delete; # We delete one of the object
531 try { $r_us = $cities->delete; } catch { $e_us = $_ };
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 = $schema->resultset('City')->search(
548 $city_2->delete; # We delete one of the object
549 try { $r_them = $cities->delete; } catch { $e_them = $_ };
551 ok( $r_us == 2 && $r_them == 2 );
552 ok (!defined($e_us) && !defined($e_them));
556 subtest 'Overwritten Koha::Objects->delete - Koha::Patrons' => sub {
560 subtest 'Koha::Object->delete' => sub {
564 my ( $r_us, $e_us, $r_them, $e_them );
566 # CASE 1 - Delete an existing patron
567 my $patron = $builder->build_object({ class => 'Koha::Patrons' });
568 my $patron_data = $patron->unblessed;
571 $patron = Koha::Patron->new( $patron_data )->store;
572 try {$r_us = $patron->delete;} catch { $e_us = $_ };
573 $patron = $schema->resultset('Borrower')->new( $patron_data )->update_or_insert;
574 try {$r_them = $patron->delete;} catch { $e_them = $_ };
575 ok( ref($r_us) && ref($r_them),
576 'Successful delete should return the patron object' );
577 ok( !defined $e_us && !defined $e_them,
578 'Successful delete should not raise an exception' );
579 is( ref($r_us), 'Koha::Patron',
580 'Successful delete should return our Koha::Obect based object' );
582 # CASE 2 - Delete a patron that is not in storage
583 try { $r_us = $r_us->delete; } catch { $e_us = $_ };
584 try { $r_them = $r_them->delete; } catch { $e_them = $_ };
586 defined $e_us && defined $e_them,
587 'Delete a patron that is not in storage should raise an exception'
589 is( ref($e_us), 'DBIx::Class::Exception' )
590 ; # FIXME This needs adjustement, we want to throw a Koha::Exception
592 # CASE 3 - Delete a patron that cannot be deleted (as a checkout)
593 $patron = Koha::Patron->new($patron_data)->store;
594 $builder->build_object(
596 class => 'Koha::Checkouts',
597 value => { borrowernumber => $patron->borrowernumber }
600 try { $r_us = $r_us->delete; } catch { $e_us = $_ };
601 $patron = $schema->resultset('Borrower')->find( $patron->borrowernumber );
602 try { $r_them = $r_them->delete; } catch { $e_them = $_ };
604 defined $e_us && defined $e_them,
605 'Delete a patron that cannot be deleted should raise an exception'
607 is( ref($e_us), 'DBIx::Class::Exception' )
608 ; # FIXME This needs adjustement, we want to throw a Koha::Exception
611 subtest 'Koha::Objects->delete' => sub {
615 my ( $r_us, $e_us, $r_them, $e_them );
617 # CASE 1 - Delete existing objects
618 my $patron_1 = $builder->build_object({ class => 'Koha::Patrons' });
619 my $patron_2 = $builder->build_object({ class => 'Koha::Patrons' });
620 my $patron_3 = $builder->build_object({ class => 'Koha::Patrons' });
621 my $patrons = Koha::Patrons->search(
625 $patron_1->borrowernumber,
626 $patron_2->borrowernumber,
627 $patron_3->borrowernumber
633 try { $r_us = $patrons->delete; } catch { $e_us = $_ };
635 $patron_1 = $builder->build_object({ class => 'Koha::Patrons' });
636 $patron_2 = $builder->build_object({ class => 'Koha::Patrons' });
637 $patron_3 = $builder->build_object({ class => 'Koha::Patrons' });
638 $patrons = $schema->resultset('Borrower')->search(
642 $patron_1->borrowernumber,
643 $patron_2->borrowernumber,
644 $patron_3->borrowernumber
650 try { $r_them = $patrons->delete; } catch { $e_them = $_ };
652 ok( $r_us == 3 && $r_them == 3, '->delete should return the number of deleted patrons' );
653 ok (!defined($e_us) && !defined($e_them), '->delete should not raise exception if everything went well');
655 # CASE 2 - One of the patrons is not in storage
656 undef $_ for $r_us, $e_us, $r_them, $e_them;
657 $patron_1 = $builder->build_object({ class => 'Koha::Patrons' });
658 $patron_2 = $builder->build_object({ class => 'Koha::Patrons' });
659 $patron_3 = $builder->build_object({ class => 'Koha::Patrons' });
660 $patrons = Koha::Patrons->search(
664 $patron_1->borrowernumber,
665 $patron_2->borrowernumber,
666 $patron_3->borrowernumber
672 $patron_2->delete; # We delete one of the patron
673 try { $r_us = $patrons->delete; } catch { $e_us = $_ };
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 = $schema->resultset('Borrower')->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_them = $patrons->delete; } catch { $e_them = $_ };
693 ok( $r_us == 2 && $r_them == 2, 'Delete patrons with one that was not in storage should delete the patrons' );
694 ok (!defined($e_us) && !defined($e_them), 'no exception should be raised if at least one patron was not in storage');
696 # CASE 3 - Delete a set of patrons with one that that cannot be deleted (as a checkout)
697 undef $_ for $r_us, $e_us, $r_them, $e_them;
698 $patron_1 = $builder->build_object({ class => 'Koha::Patrons' });
699 $patron_2 = $builder->build_object({ class => 'Koha::Patrons' });
700 $patron_3 = $builder->build_object({ class => 'Koha::Patrons' });
701 $patrons = Koha::Patrons->search(
705 $patron_1->borrowernumber,
706 $patron_2->borrowernumber,
707 $patron_3->borrowernumber
713 # Adding a checkout to patron_2
714 $builder->build_object(
716 class => 'Koha::Checkouts',
717 value => { borrowernumber => $patron_2->borrowernumber }
721 try { $r_us = $patrons->delete; } catch { $e_us = $_ };
722 my $not_deleted_us = $patron_1->in_storage + $patron_2->in_storage + $patron_3->in_storage;
724 $patron_1 = $builder->build_object({ class => 'Koha::Patrons' });
725 $patron_2 = $builder->build_object({ class => 'Koha::Patrons' });
726 $patron_3 = $builder->build_object({ class => 'Koha::Patrons' });
727 $patrons = $schema->resultset('Borrower')->search(
731 $patron_1->borrowernumber,
732 $patron_2->borrowernumber,
733 $patron_3->borrowernumber
739 # Adding a checkout to patron_2
740 $builder->build_object(
742 class => 'Koha::Checkouts',
743 value => { borrowernumber => $patron_2->borrowernumber }
747 try { $r_them = $patrons->delete; } catch { $e_them = $_ };
749 my $not_deleted_them = $patron_1->in_storage + $patron_2->in_storage + $patron_3->in_storage;
751 defined $e_us && defined $e_them,
752 'Delete patrons with one that cannot be deleted should raise an exception'
754 is( ref($e_us), 'DBIx::Class::Exception' )
755 ; # FIXME This needs adjustement, we want to throw a Koha::Exception
757 ok($not_deleted_us == 3 && $not_deleted_them == 3, 'If one patron cannot be deleted, none should have been deleted');
761 $schema->storage->txn_rollback;
765 subtest 'Update (set/store)' => sub {
768 $schema->storage->txn_begin;
770 subtest 'Simple Koha::Objects - Koha::Cities' => sub {
773 subtest 'Koha::Object->update' => sub {
777 my ( $r_us, $e_us, $r_them, $e_them );
779 # CASE 1 - Update an existing object
780 my $c_us = Koha::City->new( { city_name => 'city4test' } )->store;
781 try { $r_us = $c_us->update({ city_country => 'country4test' }); } catch { $e_us = $_ };
782 my $c_them = $schema->resultset('City')->new( { city_name => 'city4test_2' } )->update_or_insert;
783 try { $r_them = $c_them->update({ city_country => 'country4test_2' }); } catch { $e_them = $_ };
784 ok( ref($r_us) && ref($r_them),
785 'Successful update should return the object ' );
786 ok( !defined $e_us && !defined $e_them,
787 'Successful update should not raise an exception' );
788 is( ref($r_us), 'Koha::City', 'Successful update should return our Koha::Obect based object' );
790 # CASE 2 - Update an object that is not in storage
793 try { $r_us = $c_us->update({ city_country => 'another_country' }); } catch { $e_us = $_ };
794 try { $r_them = $c_them->update({ city_country => 'another_country' }); } catch { $e_them = $_ };
796 defined $e_us && defined $e_them,
797 'Update an object that is not in storage should raise an exception'
799 is( ref($e_us), 'Koha::Exceptions::Object::NotInStorage' );
802 subtest 'Koha::Objects->update' => sub {
806 my ( $r_us, $e_us, $r_them, $e_them );
808 # CASE 1 - update existing objects
809 my $city_1 = $builder->build_object({ class => 'Koha::Cities' });
810 my $city_2 = $builder->build_object({ class => 'Koha::Cities' });
811 my $city_3 = $builder->build_object({ class => 'Koha::Cities' });
812 my $cities = Koha::Cities->search(
824 try { $r_us = $cities->update({ city_country => 'country4test' }); } catch { $e_us = $_ };
826 $city_1 = $builder->build_object({ class => 'Koha::Cities' });
827 $city_2 = $builder->build_object({ class => 'Koha::Cities' });
828 $city_3 = $builder->build_object({ class => 'Koha::Cities' });
829 $cities = $schema->resultset('City')->search(
841 try { $r_them = $cities->update({ city_country => 'country4test' }); } catch { $e_them = $_ };
843 ok( $r_us == 3 && $r_them == 3, '->update should return the number of updated cities' );
844 ok(!defined($e_us) && !defined($e_them));
846 # CASE 2 - One of the object is not in storage
847 $city_1 = $builder->build_object({ class => 'Koha::Cities' });
848 $city_2 = $builder->build_object({ class => 'Koha::Cities' });
849 $city_3 = $builder->build_object({ class => 'Koha::Cities' });
850 $cities = Koha::Cities->search(
862 $city_2->delete; # We delete one of the object
863 try { $r_us = $cities->update({ city_country => 'country4test' }); } catch { $e_us = $_ };
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 = $schema->resultset('City')->search(
880 $city_2->delete; # We delete one of the object
881 try { $r_them = $cities->update({ city_country => 'country4test' }); } catch { $e_them = $_ };
883 ok( $r_us == 2 && $r_them == 2, '->update should return the number of updated cities' );
884 ok(!defined($e_us) && !defined($e_them));
887 { Koha::Cities->update({ city_country => 'Castalia' }); }
888 'Koha::Exceptions::Object::NotInstantiated',
889 'Exception thrown if not instantiated class';
891 is( "$@", 'Tried to access the \'update\' method, but Koha::Cities is not instantiated', 'Exception stringified correctly' );
896 subtest 'Overwritten Koha::Objects->store|update - Koha::Patrons' => sub {
900 subtest 'Koha::Object->update' => sub {
904 my ( $r_us, $e_us, $r_them, $e_them );
906 # CASE 1 - Update an existing patron
907 my $patron_us = $builder->build_object({ class => 'Koha::Patrons' });
908 try {$r_us = $patron_us->update({city => 'a_city'});} catch { $e_us = $_ };
910 my $patron_data = $builder->build_object({ class => 'Koha::Patrons' })->delete->unblessed;
911 my $patron_them = $schema->resultset('Borrower')->new( $patron_data )->update_or_insert;
912 try {$r_them = $patron_them->update({city => 'a_city'});} catch { $e_them = $_ };
913 ok( ref($r_us) && ref($r_them),
914 'Successful update should return the patron object' );
915 ok( !defined $e_us && !defined $e_them,
916 'Successful update should not raise an exception' );
917 is( ref($r_us), 'Koha::Patron',
918 'Successful update should return our Koha::Obect based object' );
920 # CASE 2 - Update a patron that is not in storage
922 $patron_them->delete;
923 try { $r_us = $patron_us->update({ city => 'another_city' }); } catch { $e_us = $_ };
924 try { $r_them = $patron_them->update({ city => 'another_city' }); } catch { $e_them = $_ };
926 defined $e_us && defined $e_them,
927 'Update a patron that is not in storage should raise an exception'
929 is( ref($e_us), 'Koha::Exceptions::Object::NotInStorage' );
933 subtest 'Koha::Objects->Update ' => sub {
937 my ( $r_us, $e_us, $r_them, $e_them );
939 # CASE 1 - Update existing objects
940 my $patron_1 = $builder->build_object({ class => 'Koha::Patrons' });
941 my $patron_2 = $builder->build_object({ class => 'Koha::Patrons' });
942 my $patron_3 = $builder->build_object({ class => 'Koha::Patrons' });
943 my $patrons_us = Koha::Patrons->search(
947 $patron_1->borrowernumber,
948 $patron_2->borrowernumber,
949 $patron_3->borrowernumber
955 try { $r_us = $patrons_us->update({ city => 'a_city' }); } catch { $e_us = $_ };
957 $patron_1 = $builder->build_object({ class => 'Koha::Patrons' });
958 $patron_2 = $builder->build_object({ class => 'Koha::Patrons' });
959 $patron_3 = $builder->build_object({ class => 'Koha::Patrons' });
960 my $patrons_them = $schema->resultset('Borrower')->search(
964 $patron_1->borrowernumber,
965 $patron_2->borrowernumber,
966 $patron_3->borrowernumber
972 try { $r_them = $patrons_them->update({ city => 'a_city' }); } catch { $e_them = $_ };
974 ok( $r_us == 3 && $r_them == 3, '->update should return the number of update patrons' );
975 ok (!defined($e_us) && !defined($e_them), '->update should not raise exception if everything went well');
977 # CASE 2 - One of the patrons is not in storage
978 undef $_ for $r_us, $e_us, $r_them, $e_them;
979 $patron_1 = $builder->build_object({ class => 'Koha::Patrons' });
980 $patron_2 = $builder->build_object({ class => 'Koha::Patrons' });
981 $patron_3 = $builder->build_object({ class => 'Koha::Patrons' });
982 $patrons_us = Koha::Patrons->search(
986 $patron_1->borrowernumber,
987 $patron_2->borrowernumber,
988 $patron_3->borrowernumber
994 $patron_2->delete; # We delete one of the patron
995 try { $r_us = $patrons_us->update({ city => 'another_city' }); } catch { $e_us = $_ };
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_them = $schema->resultset('Borrower')->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_them = $patrons_them->update({ city => 'another_city' }); } catch { $e_them = $_ };
1015 ok( $r_us == 2 && $r_them == 2, 'Update patrons with one that was not in storage should update the patrons' );
1016 ok (!defined($e_us) && !defined($e_them), 'no exception should be raised if at least one patron was not in storage');
1019 # Testing no_triggers
1020 t::lib::Mocks::mock_preference('uppercasesurnames', 1);
1021 $patrons_us = Koha::Patrons->search(
1025 $patron_1->borrowernumber,
1026 $patron_2->borrowernumber,
1027 $patron_3->borrowernumber
1032 $patrons_us->update({ surname => 'foo' }); # Koha::Patron->store is supposed to uppercase the surnames
1033 is( $patrons_us->search({ surname => 'FOO' })->count, 2, 'Koha::Patron->store is hit' );
1035 $patrons_us->update({ surname => 'foo' }, { no_triggers => 1 }); # The surnames won't be uppercase as we won't hit Koha::Patron->store
1036 is( $patrons_us->search({ surname => 'foo' })->count, 2, 'Koha::Patron->store is not hit');
1042 $schema->storage->txn_rollback;
1048 subtest "attributes_from_api() tests" => sub {
1052 $schema->storage->txn_begin;
1054 my $cities_rs = Koha::Cities->new;
1055 my $city = Koha::City->new;
1057 my $api_attributes = {
1063 $cities_rs->attributes_from_api($api_attributes),
1064 $city->attributes_from_api($api_attributes)
1067 $schema->storage->txn_rollback;
1071 subtest "filter_by_last_update" => sub {
1073 $schema->storage->txn_begin;
1075 my $now = dt_from_string->truncate( to => 'day' );
1076 my @borrowernumbers;
1077 # Building 6 patrons that have been created today, yesterday, ... 1 per day
1078 for my $i ( 0 .. 5 ) {
1079 push @borrowernumbers,
1080 $builder->build_object(
1082 class => 'Koha::Patrons',
1083 value => { updated_on => $now->clone->subtract( days => $i ) }
1088 my $patrons = Koha::Patrons->search(
1089 { borrowernumber => { -in => \@borrowernumbers } } );
1092 $patrons->filter_by_last_update( { timestamp_column_name => 'updated_on' } )
1097 $_->isa('Koha::Exceptions::MissingParameter'),
1098 'Should raise an exception if no parameter given'
1102 my $count = $patrons->filter_by_last_update(
1103 { timestamp_column_name => 'updated_on', days => 2 } )->count;
1104 is( $count, 3, '3 patrons have been updated before the last 2 days (exclusive)' );
1106 $count = $patrons->filter_by_last_update(
1107 { timestamp_column_name => 'updated_on', days => 1 } )->count;
1108 is( $count, 4, '4 patrons have been updated before yesterday (exclusive)' );
1110 $count = $patrons->filter_by_last_update(
1111 { timestamp_column_name => 'updated_on', days => 0 } )->count;
1112 is( $count, 5, '5 patrons have been updated before today (exclusive)' );
1114 $count = $patrons->filter_by_last_update(
1115 { timestamp_column_name => 'updated_on', from => $now } )->count;
1116 is( $count, 1, '1 patron has been updated "from today" (inclusive)' );
1118 $count = $patrons->filter_by_last_update(
1119 { timestamp_column_name => 'updated_on', to => $now } )->count;
1120 is( $count, 6, '6 patrons have been updated "to today" (inclusive)' );
1122 $count = $patrons->filter_by_last_update(
1124 timestamp_column_name => 'updated_on',
1125 from => $now->clone->subtract( days => 4 ),
1126 to => $now->clone->subtract( days => 2 )
1129 is( $count, 3, '3 patrons have been updated between D-4 and D-2' );
1131 t::lib::Mocks::mock_preference( 'dateformat', 'metric' );
1133 $count = $patrons->filter_by_last_update(
1134 { timestamp_column_name => 'updated_on', from => '1970-12-31' } )
1140 'No exception raised, from and to parameters can take an iso formatted date'
1145 $count = $patrons->filter_by_last_update(
1146 { timestamp_column_name => 'updated_on', from => '31/12/1970' } )
1152 'No exception raised, from and to parameters can take an metric formatted date (depending on dateformat syspref)'
1157 $schema->storage->txn_rollback;
1160 subtest "from_api_mapping() tests" => sub {
1164 $schema->storage->txn_begin;
1166 my $cities_rs = Koha::Cities->new;
1167 my $city = Koha::City->new;
1170 $cities_rs->from_api_mapping,
1171 $city->from_api_mapping
1174 $schema->storage->txn_rollback;
1177 subtest 'prefetch_whitelist() tests' => sub {
1181 $schema->storage->txn_begin;
1183 my $biblios = Koha::Biblios->new;
1185 my $prefetch_whitelist = $biblios->prefetch_whitelist;
1188 exists $prefetch_whitelist->{orders},
1189 'Relationship matching method name is listed'
1192 $prefetch_whitelist->{orders},
1193 'Koha::Acquisition::Order',
1194 'Guessed the non-standard object class correctly'
1198 $prefetch_whitelist->{items},
1200 'Guessed the standard object class correctly'
1203 $schema->storage->txn_rollback;
1206 subtest 'empty() tests' => sub {
1210 $schema->storage->txn_begin;
1212 # Add a patron, we need at least 1
1213 my $patron = $builder->build_object({ class => 'Koha::Patrons' });
1214 ok( Koha::Patrons->count > 0, 'There is at least one Koha::Patron on the resultset' );
1216 my $empty = Koha::Patrons->new->empty;
1217 is( ref($empty), 'Koha::Patrons', '->empty returns a Koha::Patrons iterator' );
1218 is( $empty->count, 0, 'The empty resultset is, well, empty :-D' );
1220 my $new_rs = $empty->search({ borrowernumber => $patron->borrowernumber });
1222 is( $new_rs->count, 0, 'Further chaining an empty resultset, returns an empty resultset' );
1225 { Koha::Patrons->empty; }
1226 'Koha::Exceptions::Object::NotInstantiated',
1227 'Exception thrown if not instantiated class';
1229 is( "$@", 'Tried to access the \'empty\' method, but Koha::Patrons is not instantiated', 'Exception stringified correctly' );
1231 $schema->storage->txn_rollback;
1234 subtest 'delete() tests' => sub {
1238 $schema->storage->txn_begin;
1240 # Make sure no cities
1241 warnings_are { Koha::Cities->delete }[],
1242 "No warnings, no Koha::City->delete called as it doesn't exist";
1245 my $mocked_city = Test::MockModule->new('Koha::City');
1249 shift->_result->delete;
1250 warn "delete called!";
1255 $builder->build_object( { class => 'Koha::Cities' } );
1256 $builder->build_object( { class => 'Koha::Cities' } );
1258 my $cities = Koha::Cities->search;
1260 warnings_are { $cities->delete }
1261 [ "delete called!", "delete called!" ],
1262 "No warnings, no Koha::City->delete called as it doesn't exist";
1264 $schema->storage->txn_rollback;