3 # This file is part of Koha.
5 # Koha is free software; you can redistribute it and/or modify it
6 # under the terms of the GNU General Public License as published by
7 # the Free Software Foundation; either version 3 of the License, or
8 # (at your option) any later version.
10 # Koha is distributed in the hope that it will be useful, but
11 # WITHOUT ANY WARRANTY; without even the implied warranty of
12 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 # GNU General Public License for more details.
15 # You should have received a copy of the GNU General Public License
16 # along with Koha; if not, see <http://www.gnu.org/licenses>.
20 use Test
::More tests
=> 20;
26 use C4
::Circulation
; # AddIssue
27 use C4
::Biblio
; # AddBiblio
31 use Koha
::Acquisition
::Orders
;
32 use Koha
::DateUtils
qw( dt_from_string );
38 use Scalar
::Util
qw( isvstring );
41 use t
::lib
::TestBuilder
;
45 use_ok
('Koha::Object');
46 use_ok
('Koha::Patron');
49 my $schema = Koha
::Database
->new->schema;
50 my $builder = t
::lib
::TestBuilder
->new();
52 subtest
'is_changed / make_column_dirty' => sub {
55 $schema->storage->txn_begin;
57 my $categorycode = $builder->build({ source
=> 'Category' })->{categorycode
};
58 my $branchcode = $builder->build({ source
=> 'Branch' })->{branchcode
};
60 my $object = Koha
::Patron
->new();
61 $object->categorycode( $categorycode );
62 $object->branchcode( $branchcode );
63 $object->surname("Test Surname");
64 $object->store->discard_changes;
65 is
( $object->is_changed(), 0, "Object is unchanged" );
66 $object->surname("Test Surname");
67 is
( $object->is_changed(), 0, "Object is still unchanged" );
68 $object->surname("Test Surname 2");
69 is
( $object->is_changed(), 1, "Object is changed" );
72 is
( $object->is_changed(), 0, "Object no longer marked as changed after being stored" );
74 $object->set({ firstname
=> 'Test Firstname' });
75 is
( $object->is_changed(), 1, "Object is changed after Set" );
77 is
( $object->is_changed(), 0, "Object no longer marked as changed after being stored" );
79 # Test make_column_dirty
80 is
( $object->make_column_dirty('firstname'), '', 'make_column_dirty returns empty string on success' );
81 is
( $object->make_column_dirty('firstname'), 1, 'make_column_dirty returns 1 if already dirty' );
82 is
( $object->is_changed, 1, "Object is changed after make dirty" );
84 is
( $object->is_changed, 0, "Store clears dirty mark" );
85 $object->make_column_dirty('firstname');
86 $object->discard_changes;
87 is
( $object->is_changed, 0, "Discard clears dirty mark too" );
89 $schema->storage->txn_rollback;
92 subtest
'in_storage' => sub {
95 $schema->storage->txn_begin;
97 my $categorycode = $builder->build({ source
=> 'Category' })->{categorycode
};
98 my $branchcode = $builder->build({ source
=> 'Branch' })->{branchcode
};
100 my $object = Koha
::Patron
->new();
101 is
( $object->in_storage, 0, "Object is not in storage" );
102 $object->categorycode( $categorycode );
103 $object->branchcode( $branchcode );
104 $object->surname("Test Surname");
106 is
( $object->in_storage, 1, "Object is now stored" );
107 $object->surname("another surname");
108 is
( $object->in_storage, 1 );
110 my $borrowernumber = $object->borrowernumber;
111 my $patron = $schema->resultset('Borrower')->find( $borrowernumber );
112 is
( $patron->surname(), "Test Surname", "Object found in database" );
115 $patron = $schema->resultset('Borrower')->find( $borrowernumber );
116 ok
( ! $patron, "Object no longer found in database" );
117 is
( $object->in_storage, 0, "Object is not in storage" );
119 $schema->storage->txn_rollback;
122 subtest
'id' => sub {
125 $schema->storage->txn_begin;
127 my $categorycode = $builder->build({ source
=> 'Category' })->{categorycode
};
128 my $branchcode = $builder->build({ source
=> 'Branch' })->{branchcode
};
130 my $patron = Koha
::Patron
->new({categorycode
=> $categorycode, branchcode
=> $branchcode })->store;
131 is
( $patron->id, $patron->borrowernumber );
133 $schema->storage->txn_rollback;
136 subtest
'get_column' => sub {
139 $schema->storage->txn_begin;
141 my $categorycode = $builder->build({ source
=> 'Category' })->{categorycode
};
142 my $branchcode = $builder->build({ source
=> 'Branch' })->{branchcode
};
144 my $patron = Koha
::Patron
->new({categorycode
=> $categorycode, branchcode
=> $branchcode })->store;
145 is
( $patron->get_column('borrowernumber'), $patron->borrowernumber, 'get_column should retrieve the correct value' );
147 $schema->storage->txn_rollback;
150 subtest
'discard_changes' => sub {
153 $schema->storage->txn_begin;
155 my $patron = $builder->build( { source
=> 'Borrower' } );
156 $patron = Koha
::Patrons
->find( $patron->{borrowernumber
} );
157 $patron->dateexpiry(dt_from_string
);
158 $patron->discard_changes;
160 dt_from_string
( $patron->dateexpiry ),
161 dt_from_string
->truncate( to
=> 'day' ),
162 'discard_changes should refresh the object'
165 $schema->storage->txn_rollback;
168 subtest
'TO_JSON tests' => sub {
172 $schema->storage->txn_begin;
174 my $dt = dt_from_string
();
175 my $borrowernumber = $builder->build(
176 { source
=> 'Borrower',
177 value
=> { lost
=> 1,
178 sms_provider_id
=> undef,
181 lastseen
=> $dt, } })->{borrowernumber
};
183 my $patron = Koha
::Patrons
->find($borrowernumber);
184 my $lost = $patron->TO_JSON()->{lost
};
185 my $gonenoaddress = $patron->TO_JSON->{gonenoaddress
};
186 my $updated_on = $patron->TO_JSON->{updated_on
};
187 my $lastseen = $patron->TO_JSON->{lastseen
};
189 ok
( $lost->isa('JSON::PP::Boolean'), 'Boolean attribute type is correct' );
190 is
( $lost, 1, 'Boolean attribute value is correct (true)' );
192 ok
( $gonenoaddress->isa('JSON::PP::Boolean'), 'Boolean attribute type is correct' );
193 is
( $gonenoaddress, 0, 'Boolean attribute value is correct (false)' );
195 is
( $patron->TO_JSON->{sms_provider_id
}, undef, 'Undef values should not be casted to 0' );
197 ok
( !isvstring
($patron->borrowernumber), 'Integer values are not coded as strings' );
199 my $rfc3999_regex = qr
/
211 (([Zz
])|([\
+|\
-]([01][0-9]|2[0-3]):[0-5][0-9]))
213 like
( $updated_on, $rfc3999_regex, "Date-time $updated_on formatted correctly");
214 like
( $lastseen, $rfc3999_regex, "Date-time $updated_on formatted correctly");
216 # Test JSON doesn't receive strings
217 my $order = $builder->build_object({ class => 'Koha::Acquisition::Orders' });
218 $order = Koha
::Acquisition
::Orders
->find( $order->ordernumber );
219 is_deeply
( $order->TO_JSON, decode_json
( encode_json
( $order->TO_JSON ) ), 'Orders are similar' );
221 $schema->storage->txn_rollback;
224 subtest
"to_api() tests" => sub {
228 $schema->storage->txn_begin;
230 my $city = $builder->build_object({ class => 'Koha::Cities' });
233 # cityid => 'city_id',
234 # city_country => 'country',
235 # city_name => 'name',
236 # city_state => 'state',
237 # city_zipcode => 'postal_code'
239 my $api_city = $city->to_api;
241 is
( $api_city->{city_id
}, $city->cityid, 'Attribute translated correctly' );
242 is
( $api_city->{country
}, $city->city_country, 'Attribute translated correctly' );
243 is
( $api_city->{name
}, $city->city_name, 'Attribute translated correctly' );
244 is
( $api_city->{state}, $city->city_state, 'Attribute translated correctly' );
245 is
( $api_city->{postal_code
}, $city->city_zipcode, 'Attribute translated correctly' );
247 # Lets emulate an undef
248 my $city_class = Test
::MockModule
->new('Koha::City');
249 $city_class->mock( 'to_api_mapping',
253 city_country
=> 'country',
255 city_state
=> 'state',
256 city_zipcode
=> undef
261 $api_city = $city->to_api;
263 is
( $api_city->{city_id
}, $city->cityid, 'Attribute translated correctly' );
264 is
( $api_city->{country
}, $city->city_country, 'Attribute translated correctly' );
265 is
( $api_city->{name
}, $city->city_name, 'Attribute translated correctly' );
266 is
( $api_city->{state}, $city->city_state, 'Attribute translated correctly' );
267 ok
( !exists $api_city->{postal_code
}, 'Attribute removed' );
269 # Pick a class that won't have a mapping for the API
270 my $illrequest = $builder->build_object({ class => 'Koha::Illrequests' });
271 is_deeply
( $illrequest->to_api, $illrequest->TO_JSON, 'If no overloaded to_api_mapping method, return TO_JSON' );
273 my $biblio = $builder->build_sample_biblio();
274 my $item = $builder->build_sample_item({ biblionumber
=> $biblio->biblionumber });
275 my $hold = $builder->build_object({ class => 'Koha::Holds', value
=> { itemnumber
=> $item->itemnumber } });
277 my $embeds = { 'items' => {} };
279 my $biblio_api = $biblio->to_api({ embed
=> $embeds });
281 ok
(exists $biblio_api->{items
}, 'Items where embedded in biblio results');
282 is
($biblio_api->{items
}->[0]->{item_id
}, $item->itemnumber, 'Item matches');
283 ok
(!exists $biblio_api->{items
}->[0]->{holds
}, 'No holds info should be embedded yet');
295 $biblio_api = $biblio->to_api({ embed
=> $embeds });
297 ok
(exists $biblio_api->{items
}, 'Items where embedded in biblio results');
298 is
($biblio_api->{items
}->[0]->{item_id
}, $item->itemnumber, 'Item still matches');
299 ok
(exists $biblio_api->{items
}->[0]->{holds
}, 'Holds info should be embedded');
300 is
($biblio_api->{items
}->[0]->{holds
}->[0]->{hold_id
}, $hold->reserve_id, 'Hold matches');
301 is_deeply
($biblio_api->{biblioitem
}, $biblio->biblioitem->to_api, 'More than one root');
303 my $hold_api = $hold->to_api(
305 embed
=> { 'item' => {} }
309 is
( ref($hold_api->{item
}), 'HASH', 'Single nested object works correctly' );
310 is
( $hold_api->{item
}->{item_id
}, $item->itemnumber, 'Object embedded correctly' );
312 # biblio with no items
313 my $new_biblio = $builder->build_sample_biblio;
314 my $new_biblio_api = $new_biblio->to_api({ embed
=> $embeds });
316 is_deeply
( $new_biblio_api->{items
}, [], 'Empty list if no items' );
318 my $biblio_class = Test
::MockModule
->new('Koha::Biblio');
319 $biblio_class->mock( 'undef_result', sub { return; } );
321 $new_biblio_api = $new_biblio->to_api({ embed
=> ( { 'undef_result' => {} } ) });
322 ok
( exists $new_biblio_api->{undef_result
}, 'If a method returns undef, then the attribute is defined' );
323 is
( $new_biblio_api->{undef_result
}, undef, 'If a method returns undef, then the attribute is undef' );
325 $biblio_class->mock( 'items',
326 sub { return [ bless { itemnumber
=> 1 }, 'Somethings' ]; } );
329 $new_biblio_api = $new_biblio->to_api(
330 { embed
=> { 'items' => { children
=> { asd
=> {} } } } } );
332 'Koha::Exceptions::Exception',
333 "An exception is thrown if a blessed object to embed doesn't implement to_api";
337 "Asked to embed items but its return value doesn't implement to_api",
338 "Exception message correct"
342 my $patron = $builder->build_object( { class => 'Koha::Patrons' } );
343 $builder->build_object(
345 class => 'Koha::Holds',
347 biblionumber
=> $biblio->biblionumber,
348 borrowernumber
=> $patron->borrowernumber
352 $builder->build_object(
354 class => 'Koha::Holds',
356 biblionumber
=> $biblio->biblionumber,
357 borrowernumber
=> $patron->borrowernumber
362 my $patron_api = $patron->to_api(
364 embed
=> { holds_count
=> { is_count
=> 1 } }
367 is
( $patron_api->{holds_count
}, $patron->holds->count, 'Count embeds are supported and work as expected' );
371 $patron->to_api({ embed
=> { holds_count
=> {} } });
373 'Koha::Exceptions::Object::MethodNotCoveredByTests',
374 'Unknown method exception thrown if is_count not specified';
376 $schema->storage->txn_rollback;
379 subtest
"to_api_mapping() tests" => sub {
383 $schema->storage->txn_begin;
385 my $illrequest = $builder->build_object({ class => 'Koha::Illrequests' });
386 is_deeply
( $illrequest->to_api_mapping, {}, 'If no to_api_mapping present, return empty hashref' );
388 $schema->storage->txn_rollback;
391 subtest
"from_api_mapping() tests" => sub {
395 $schema->storage->txn_begin;
397 my $city = $builder->build_object({ class => 'Koha::Cities' });
399 # Lets emulate an undef
400 my $city_class = Test
::MockModule
->new('Koha::City');
401 $city_class->mock( 'to_api_mapping',
405 city_country
=> 'country',
406 city_zipcode
=> undef
412 $city->from_api_mapping,
415 country
=> 'city_country'
417 'Mapping returns correctly, undef ommited'
420 $city_class->unmock( 'to_api_mapping');
421 $city_class->mock( 'to_api_mapping',
425 city_country
=> 'country',
426 city_zipcode
=> 'postal_code'
432 $city->from_api_mapping,
435 country
=> 'city_country'
437 'Reverse mapping is cached'
441 $city = $builder->build_object({ class => 'Koha::Cities' });
443 $city->from_api_mapping,
446 country
=> 'city_country',
447 postal_code
=> 'city_zipcode'
449 'Fresh mapping loaded'
452 $schema->storage->txn_rollback;
455 subtest
'set_from_api() tests' => sub {
459 $schema->storage->txn_begin;
461 my $city = $builder->build_object({ class => 'Koha::Cities' });
462 my $city_unblessed = $city->unblessed;
465 country
=> 'Argentina',
466 postal_code
=> '5000'
468 $city->set_from_api($attrs);
470 is
( $city->city_state, $city_unblessed->{city_state
}, 'Untouched attributes are preserved' );
471 is
( $city->city_name, $attrs->{name
}, 'city_name updated correctly' );
472 is
( $city->city_country, $attrs->{country
}, 'city_country updated correctly' );
473 is
( $city->city_zipcode, $attrs->{postal_code
}, 'city_zipcode updated correctly' );
475 $schema->storage->txn_rollback;
478 subtest
'new_from_api() tests' => sub {
482 $schema->storage->txn_begin;
486 country
=> 'Argentina',
487 postal_code
=> '5000'
489 my $city = Koha
::City
->new_from_api($attrs);
491 is
( ref($city), 'Koha::City', 'Object type is correct' );
492 is
( $city->city_name, $attrs->{name
}, 'city_name updated correctly' );
493 is
( $city->city_country, $attrs->{country
}, 'city_country updated correctly' );
494 is
( $city->city_zipcode, $attrs->{postal_code
}, 'city_zipcode updated correctly' );
496 $schema->storage->txn_rollback;
499 subtest
'attributes_from_api() tests' => sub {
503 my $patron = Koha
::Patron
->new();
505 my $attrs = $patron->attributes_from_api(
507 updated_on
=> '2019-12-27T14:53:00',
511 ok
( exists $attrs->{updated_on
},
512 'No translation takes place if no mapping' );
514 ref( $attrs->{updated_on
} ),
516 'Given a string, a timestamp field is converted into a DateTime object'
519 $attrs = $patron->attributes_from_api(
521 last_seen
=> '2019-12-27T14:53:00'
525 ok
( exists $attrs->{lastseen
},
526 'Translation takes place because of the defined mapping' );
528 ref( $attrs->{lastseen
} ),
530 'Given a string, a datetime field is converted into a DateTime object'
533 $attrs = $patron->attributes_from_api(
535 date_of_birth
=> '2019-12-27'
539 ok
( exists $attrs->{dateofbirth
},
540 'Translation takes place because of the defined mapping' );
542 ref( $attrs->{dateofbirth
} ),
544 'Given a string, a date field is converted into a DateTime object'
549 $attrs = $patron->attributes_from_api(
551 date_of_birth
=> '20141205',
555 'Koha::Exceptions::BadParameter',
556 'Bad date throws an exception';
561 'Exception parameter is the API field name, not the DB one'
565 $attrs = $patron->attributes_from_api(
567 incorrect_address
=> Mojo
::JSON
->true,
568 patron_card_lost
=> Mojo
::JSON
->false,
572 ok
( exists $attrs->{gonenoaddress
}, 'Attribute gets translated' );
573 is
( $attrs->{gonenoaddress
}, 1, 'Boolean correctly translated to integer (true => 1)' );
574 ok
( exists $attrs->{lost
}, 'Attribute gets translated' );
575 is
( $attrs->{lost
}, 0, 'Boolean correctly translated to integer (false => 0)' );
578 subtest
"Test update method" => sub {
581 $schema->storage->txn_begin;
583 my $branchcode = $builder->build({ source
=> 'Branch' })->{branchcode
};
584 my $library = Koha
::Libraries
->find( $branchcode );
585 $library->update({ branchname
=> 'New_Name', branchcity
=> 'AMS' });
586 is
( $library->branchname, 'New_Name', 'Changed name with update' );
587 is
( $library->branchcity, 'AMS', 'Changed city too' );
588 is
( $library->is_changed, 0, 'Change should be stored already' );
591 branchcity
=> 'NYC', not_a_column
=> 53, branchname
=> 'Name3',
593 fail
( 'It should not be possible to update an unexisting column without an error from Koha::Object/DBIx' );
595 ok
( $_->isa('Koha::Exceptions::Object'), 'Caught error when updating wrong column' );
596 $library->discard_changes; #requery after failing update
598 # Check if the columns are not updated
599 is
( $library->branchcity, 'AMS', 'First column not updated' );
600 is
( $library->branchname, 'New_Name', 'Third column not updated' );
602 $schema->storage->txn_rollback;
605 subtest
'store() tests' => sub {
609 # Using Koha::ApiKey to test Koha::Object>-store
610 # Simple object with foreign keys and unique key
612 $schema->storage->txn_begin;
614 # Create a patron to make sure its ID doesn't exist on the DB
615 my $patron = $builder->build_object({ class => 'Koha::Patrons' });
616 my $patron_id = $patron->id;
619 my $api_key = Koha
::ApiKey
->new({ patron_id
=> $patron_id, secret
=> 'a secret', description
=> 'a description' });
621 my $dbh = $schema->storage->dbh;
624 open STDERR
, '>', '/dev/null';
627 'Koha::Exceptions::Object::FKConstraint',
628 'Exception is thrown correctly';
631 "Broken FK constraint",
632 'Exception message is correct'
637 'Exception field is correct'
640 $patron = $builder->build_object({ class => 'Koha::Patrons' });
641 $api_key = $builder->build_object({ class => 'Koha::ApiKeys' });
643 my $new_api_key = Koha
::ApiKey
->new({
644 patron_id
=> $patron_id,
645 secret
=> $api_key->secret,
646 description
=> 'a description',
650 { $new_api_key->store }
651 'Koha::Exceptions::Object::DuplicateID',
652 'Exception is thrown correctly';
657 'Exception message is correct'
662 qr/(api_keys\.)?secret/,
663 'Exception field is correct (note that MySQL 8 is displaying the tablename)'
669 $api_key->set({ secret
=> 'Manuel' });
670 my $ret = $api_key->store;
671 is
( ref($ret), 'Koha::ApiKey', 'store() returns the object on success' );
673 my $library = $builder->build_object( { class => 'Koha::Libraries' } );
674 my $patron_category = $builder->build_object(
676 class => 'Koha::Patron::Categories',
677 value
=> { category_type
=> 'P', enrolmentfee
=> 0 }
684 categorycode
=> $patron_category->categorycode,
685 branchcode
=> $library->branchcode,
686 dateofbirth
=> "", # date will be set to NULL
687 sms_provider_id
=> "", # Integer will be set to NULL
688 privacy
=> "", # privacy cannot be NULL but has a default value
692 is
( $@
, '', 'No error should be raised by ->store if empty strings are passed' );
693 is
( $patron->privacy, 1, 'Default value for privacy should be set to 1' );
694 is
( $patron->dateofbirth, undef, 'dateofbirth must have been set to undef');
695 is
( $patron->sms_provider_id, undef, 'sms_provider_id must have been set to undef');
697 my $itemtype = eval {
700 itemtype
=> 'IT4test',
707 is
( $@
, '', 'No error should be raised by ->store if empty strings are passed' );
708 is
( $itemtype->rentalcharge, undef, 'decimal DEFAULT NULL should default to null');
709 is
( $itemtype->notforloan, undef, 'int DEFAULT NULL should default to null');
710 is
( $itemtype->hideinopac, 0, 'int NOT NULL DEFAULT 0 should default to 0');
712 subtest
'Bad value tests' => sub {
716 my $patron = $builder->build_object({ class => 'Koha::Patrons' });
721 open STDERR
, '>', '/dev/null';
722 $patron->lastseen('wrong_value')->store;
725 ok
( $_->isa('Koha::Exceptions::Object::BadValue'), 'Exception thrown correctly' );
726 like
( $_->property, qr/(borrowers\.)?lastseen/, 'Column should be the expected one' ); # The table name is not always displayed, it depends on the DBMS version
727 is
( $_->value, 'wrong_value', 'Value should be the expected one' );
731 $schema->storage->txn_rollback;
734 subtest
'unblessed_all_relateds' => sub {
737 $schema->storage->txn_begin;
739 # FIXME It's very painful to create an issue in tests!
740 my $library = $builder->build_object( { class => 'Koha::Libraries' } );
741 t
::lib
::Mocks
::mock_userenv
({ branchcode
=> $library->branchcode });
743 my $patron_category = $builder->build(
745 source
=> 'Category',
747 category_type
=> 'P',
749 BlockExpiredPatronOpacActions
=> -1, # Pick the pref value
754 firstname
=> 'firstname',
755 surname
=> 'surname',
756 categorycode
=> $patron_category->{categorycode
},
757 branchcode
=> $library->branchcode,
759 my $patron = Koha
::Patron
->new($patron_data)->store;
760 my ($biblionumber) = AddBiblio
( MARC
::Record
->new, '' );
761 my $biblio = Koha
::Biblios
->find( $biblionumber );
762 my $item = $builder->build_object(
764 class => 'Koha::Items',
766 homebranch
=> $library->branchcode,
767 holdingbranch
=> $library->branchcode,
768 biblionumber
=> $biblio->biblionumber,
775 my $issue = AddIssue
( $patron->unblessed, $item->barcode, DateTime
->now->subtract( days
=> 1 ) );
776 my $overdues = Koha
::Patrons
->find( $patron->id )->get_overdues; # Koha::Patron->get_overdue prefetches
777 my $overdue = $overdues->next->unblessed_all_relateds;
778 is
( $overdue->{issue_id
}, $issue->issue_id, 'unblessed_all_relateds has field from the original table (issues)' );
779 is
( $overdue->{title
}, $biblio->title, 'unblessed_all_relateds has field from other tables (biblio)' );
780 is
( $overdue->{homebranch
}, $item->homebranch, 'unblessed_all_relateds has field from other tables (items)' );
782 $schema->storage->txn_rollback;
785 subtest
'get_from_storage' => sub {
788 $schema->storage->txn_begin;
790 my $biblio = $builder->build_sample_biblio;
792 my $old_title = $biblio->title;
793 my $new_title = 'new_title';
794 Koha
::Biblios
->find( $biblio->biblionumber )->title($new_title)->store;
796 is
( $biblio->title, $old_title, 'current $biblio should not be modified' );
797 is
( $biblio->get_from_storage->title,
798 $new_title, 'get_from_storage should return an updated object' );
800 Koha
::Biblios
->find( $biblio->biblionumber )->delete;
801 is
( ref($biblio), 'Koha::Biblio', 'current $biblio should not be deleted' );
802 is
( $biblio->get_from_storage, undef,
803 'get_from_storage should return undef if the object has been deleted' );
805 $schema->storage->txn_rollback;
808 subtest
'prefetch_whitelist() tests' => sub {
812 $schema->storage->txn_begin;
814 my $biblio = Koha
::Biblio
->new;
816 my $prefetch_whitelist = $biblio->prefetch_whitelist;
819 exists $prefetch_whitelist->{orders
},
820 'Relationship matching method name is listed'
823 $prefetch_whitelist->{orders
},
824 'Koha::Acquisition::Order',
825 'Guessed the non-standard object class correctly'
829 $prefetch_whitelist->{items
},
831 'Guessed the standard object class correctly'
834 $schema->storage->txn_rollback;
837 subtest
'set_or_blank' => sub {
841 $schema->storage->txn_begin;
843 my $item = $builder->build_sample_item;
844 my $item_info = $item->unblessed;
845 $item = $item->set_or_blank($item_info);
846 is_deeply
($item->unblessed, $item_info, 'set_or_blank assign the correct value if unchanged');
849 delete $item_info->{itemlost
};
850 $item = $item->set_or_blank($item_info);
851 is
($item->itemlost, 0, 'set_or_blank should have set itemlost to 0, default value defined in DB');
854 delete $item_info->{restricted
};
855 $item = $item->set_or_blank($item_info);
856 is
($item->restricted, undef, 'set_or_blank should have set restristed to null' );
859 delete $item_info->{dateaccessioned
};
860 $item = $item->set_or_blank($item_info);
861 is
($item->dateaccessioned, undef, 'set_or_blank should have set dateaccessioned to null');
864 delete $item_info->{timestamp
};
865 $item = $item->set_or_blank($item_info);
866 isnt
($item->timestamp, undef, 'set_or_blank should have set timestamp to a correct value');
868 $schema->storage->txn_rollback;