From 2c28abefad7071821d6592125a6dc3fdf414ad54 Mon Sep 17 00:00:00 2001 From: Alex Sassmannshausen Date: Mon, 16 Oct 2017 10:47:14 +0200 Subject: [PATCH] Bug 7317: Add unit tests & fix, add comments to Illrequest.pm. * Koha/Illrequest.pm: Add code commentary. (_backend_capability): We need to invoke our code ref. * t/db_dependent/Illrequest/Config.t: Improve tests. * t/db_dependent/Illrequestattributes.t: Improve tests. * t/db_dependent/Illrequests.t: Improve tests. --- Koha/Illrequest.pm | 69 +++- t/db_dependent/Illrequest/Config.t | 10 +- t/db_dependent/Illrequestattributes.t | 63 ++++ t/db_dependent/Illrequests.t | 642 ++++++++++++++++++++++++++++++++++ 4 files changed, 771 insertions(+), 13 deletions(-) create mode 100644 t/db_dependent/Illrequestattributes.t create mode 100644 t/db_dependent/Illrequests.t diff --git a/Koha/Illrequest.pm b/Koha/Illrequest.pm index d91be8e5b1..2ac4a6e474 100644 --- a/Koha/Illrequest.pm +++ b/Koha/Illrequest.pm @@ -166,6 +166,17 @@ This is a helper method to invoke optional capabilities in the backend. If the capability named by $name is not supported, return 0, else invoke it, passing $args along with the invocation, and return its return value. +NOTE: this module suffers from a confusion in termninology: + +in _backend_capability, the notion of capability refers to an optional feature +that is implemented in core, but might not be supported by a given backend. + +in capabilities & custom_capability, capability refers to entries in the +status_graph (after union between backend and core). + +The easiest way to fix this would be to fix the terminology in +capabilities & custom_capability and their callers. + =cut sub _backend_capability { @@ -177,7 +188,7 @@ sub _backend_capability { return 0; }; if ( $capability ) { - return $capability($args); + return &{$capability}($args); } else { return 0; } @@ -213,6 +224,13 @@ sub metadata { =head3 _core_status_graph + my $core_status_graph = $illrequest->_core_status_graph; + +Returns ILL module's default status graph. A status graph defines the list of +available actions at any stage in the ILL workflow. This is for instance used +by the perl script & template to generate the correct buttons to display to +the end user at any given point. + =cut sub _core_status_graph { @@ -296,6 +314,27 @@ sub _core_status_graph { }; } +=head3 _core_status_graph + + my $status_graph = $illrequest->_core_status_graph($origin, $new_graph); + +Return a new status_graph, the result of merging $origin & new_graph. This is +operation is a union over the sets defied by the two graphs. + +Each entry in $new_graph is added to $origin. We do not provide a syntax for +'subtraction' of entries from $origin. + +Whilst it is not intended that this works, you can override entries in $origin +with entries with the same key in $new_graph. This can lead to problematic +behaviour when $new_graph adds an entry, which modifies a dependent entry in +$origin, only for the entry in $origin to be replaced later with a new entry +from $new_graph. + +NOTE: this procedure does not "re-link" entries in $origin or $new_graph, +i.e. each of the graphs need to be correct at the outset of the operation. + +=cut + sub _status_graph_union { my ( $self, $core_status_graph, $backend_status_graph ) = @_; # Create new status graph with: @@ -354,6 +393,17 @@ Example return value: { create => "Create Request", confirm => "Progress Request" } +NOTE: this module suffers from a confusion in termninology: + +in _backend_capability, the notion of capability refers to an optional feature +that is implemented in core, but might not be supported by a given backend. + +in capabilities & custom_capability, capability refers to entries in the +status_graph (after union between backend and core). + +The easiest way to fix this would be to fix the terminology in +capabilities & custom_capability and their callers. + =cut sub capabilities { @@ -377,6 +427,17 @@ sub capabilities { Return the result of invoking $CANDIDATE on this request's backend with $PARAMS, or 0 if $CANDIDATE is an unknown method on backend. +NOTE: this module suffers from a confusion in termninology: + +in _backend_capability, the notion of capability refers to an optional feature +that is implemented in core, but might not be supported by a given backend. + +in capabilities & custom_capability, capability refers to entries in the +status_graph (after union between backend and core). + +The easiest way to fix this would be to fix the terminology in +capabilities & custom_capability and their callers. + =cut sub custom_capability { @@ -413,7 +474,7 @@ sub available_actions { sub mark_completed { my ( $self ) = @_; - $self->status('COMP')->store unless ( $permitted ); + $self->status('COMP')->store; return { error => 0, status => '', @@ -629,7 +690,6 @@ or for the default, we must define fall-back values here. =cut -# FIXME: Needs unit tests! sub getLimits { my ( $self, $params ) = @_; my $limits = $self->_config->getLimitRules($params->{type}); @@ -683,7 +743,6 @@ LimitRules are derived from koha-conf.xml: =cut -# FIXME: Needs unit tests! sub check_limits { my ( $self, $params ) = @_; my $patron = $params->{patron}; @@ -723,7 +782,6 @@ sub check_limits { } } -# FIXME: Needs unit tests! sub _limit_counter { my ( $self, $method, $target ) = @_; @@ -888,7 +946,6 @@ file. sub id_prefix { my ( $self ) = @_; - # FIXME: can we automatically use borrowernumber as borrower? my $brw = $self->patron; my $brw_cat = "dummy"; $brw_cat = $brw->categorycode diff --git a/t/db_dependent/Illrequest/Config.t b/t/db_dependent/Illrequest/Config.t index df2bcac7aa..bb7603920c 100644 --- a/t/db_dependent/Illrequest/Config.t +++ b/t/db_dependent/Illrequest/Config.t @@ -17,9 +17,9 @@ use Modern::Perl; -use Test::Exception; -use Test::More; -use Test::Warn; +use Test::More tests => 1; + +use_ok('Koha::Illrequest::Config'); # Some data structures that will be repeatedly referenced my $defaults = { @@ -48,10 +48,6 @@ my $second_branch = { request_limit => { count => "5" }, }; -BEGIN { - use_ok('Koha::Illrequest::Config'); -} - my $config = Koha::Illrequest::Config->new(1); # with test_mode enabled. isa_ok($config, 'Koha::Illrequest::Config'); diff --git a/t/db_dependent/Illrequestattributes.t b/t/db_dependent/Illrequestattributes.t new file mode 100644 index 0000000000..ceb0474264 --- /dev/null +++ b/t/db_dependent/Illrequestattributes.t @@ -0,0 +1,63 @@ +#!/usr/bin/perl +# +# This file is part of Koha. +# +# Koha is free software; you can redistribute it and/or modify it under the +# terms of the GNU General Public License as published by the Free Software +# Foundation; either version 2 of the License, or (at your option) any later +# version. +# +# Koha is distributed in the hope that it will be useful, but WITHOUT ANY +# WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR +# A PARTICULAR PURPOSE. See the GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License along +# with Koha; if not, write to the Free Software Foundation, Inc., +# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA +# + +use Modern::Perl; + +use File::Basename qw/basename/; +use Koha::Database; +use Koha::Patrons; +use t::lib::TestBuilder; + +use Test::More tests => 3; + +my $schema = Koha::Database->new->schema; +use_ok('Koha::Illrequestattribute'); +use_ok('Koha::Illrequestattributes'); + +subtest 'Basic object tests' => sub { + + plan tests => 5; + + $schema->storage->txn_begin; + + my $builder = t::lib::TestBuilder->new; + + my $illrqattr = $builder->build({ source => 'Illrequestattribute' }); + + my $illrqattr_obj = Koha::Illrequestattributes->find( + $illrqattr->{illrequest_id}, + $illrqattr->{type} + ); + isa_ok($illrqattr_obj, 'Koha::Illrequestattribute', + "Correctly create and load an illrequestattribute object."); + is($illrqattr_obj->illrequest_id, $illrqattr->{illrequest_id}, + "Illrequest_id getter works."); + is($illrqattr_obj->type, $illrqattr->{type}, + "Type getter works."); + is($illrqattr_obj->value, $illrqattr->{value}, + "Value getter works."); + + $illrqattr_obj->delete; + + is(Koha::Illrequestattributes->search->count, 0, + "No attributes found after delete."); + + $schema->storage->txn_rollback; +}; + +1; diff --git a/t/db_dependent/Illrequests.t b/t/db_dependent/Illrequests.t new file mode 100644 index 0000000000..1a126b9463 --- /dev/null +++ b/t/db_dependent/Illrequests.t @@ -0,0 +1,642 @@ +#!/usr/bin/perl +# +# This file is part of Koha. +# +# Koha is free software; you can redistribute it and/or modify it under the +# terms of the GNU General Public License as published by the Free Software +# Foundation; either version 2 of the License, or (at your option) any later +# version. +# +# Koha is distributed in the hope that it will be useful, but WITHOUT ANY +# WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR +# A PARTICULAR PURPOSE. See the GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License along +# with Koha; if not, write to the Free Software Foundation, Inc., +# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA +# + +use Modern::Perl; + +use File::Basename qw/basename/; +use Koha::Database; +use Koha::Illrequestattributes; +use Koha::Illrequest::Config; +use Koha::Patrons; +use t::lib::Mocks; +use t::lib::TestBuilder; +use Test::MockObject; + +use Test::More tests => 10; + +# We want to test the Koha IllRequest object. At its core it's a simple +# Koha::Object, mapping to the ill_request table. +# +# This object will supersede the Status object in ILLModule. +# +# We must ensure perfect backward compatibility between the current model and +# the Status less model. + +my $schema = Koha::Database->new->schema; +my $builder = t::lib::TestBuilder->new; +use_ok('Koha::Illrequest'); +use_ok('Koha::Illrequests'); + +subtest 'Basic object tests' => sub { + + plan tests => 21; + + $schema->storage->txn_begin; + + my $illrq = $builder->build({ source => 'Illrequest' }); + my $illrq_obj = Koha::Illrequests->find($illrq->{illrequest_id}); + + isa_ok($illrq_obj, 'Koha::Illrequest', + "Correctly create and load an illrequest object."); + isa_ok($illrq_obj->_config, 'Koha::Illrequest::Config', + "Created a config object as part of Illrequest creation."); + + is($illrq_obj->illrequest_id, $illrq->{illrequest_id}, + "Illrequest_id getter works."); + is($illrq_obj->borrowernumber, $illrq->{borrowernumber}, + "Borrowernumber getter works."); + is($illrq_obj->biblio_id, $illrq->{biblio_id}, + "Biblio_Id getter works."); + is($illrq_obj->branchcode, $illrq->{branchcode}, + "Branchcode getter works."); + is($illrq_obj->status, $illrq->{status}, + "Status getter works."); + is($illrq_obj->placed, $illrq->{placed}, + "Placed getter works."); + is($illrq_obj->replied, $illrq->{replied}, + "Replied getter works."); + is($illrq_obj->updated, $illrq->{updated}, + "Updated getter works."); + is($illrq_obj->completed, $illrq->{completed}, + "Completed getter works."); + is($illrq_obj->medium, $illrq->{medium}, + "Medium getter works."); + is($illrq_obj->accessurl, $illrq->{accessurl}, + "Accessurl getter works."); + is($illrq_obj->cost, $illrq->{cost}, + "Cost getter works."); + is($illrq_obj->notesopac, $illrq->{notesopac}, + "Notesopac getter works."); + is($illrq_obj->notesstaff, $illrq->{notesstaff}, + "Notesstaff getter works."); + is($illrq_obj->orderid, $illrq->{orderid}, + "Orderid getter works."); + is($illrq_obj->backend, $illrq->{backend}, + "Backend getter works."); + + isnt($illrq_obj->status, 'COMP', + "ILL is not currently marked complete."); + $illrq_obj->mark_completed; + is($illrq_obj->status, 'COMP', + "ILL is now marked complete."); + + $illrq_obj->delete; + + is(Koha::Illrequests->search->count, 0, + "No illrequest found after delete."); + + $schema->storage->txn_rollback; +}; + +subtest 'Working with related objects' => sub { + + plan tests => 5; + + $schema->storage->txn_begin; + + my $patron = $builder->build({ source => 'Borrower' }); + my $illrq = $builder->build({ + source => 'Illrequest', + value => { borrowernumber => $patron->{borrowernumber} } + }); + my $illrq_obj = Koha::Illrequests->find($illrq->{illrequest_id}); + + isa_ok($illrq_obj->patron, 'Koha::Patron', + "OK accessing related patron."); + + $builder->build({ + source => 'Illrequestattribute', + value => { illrequest_id => $illrq_obj->illrequest_id, type => 'X' } + }); + $builder->build({ + source => 'Illrequestattribute', + value => { illrequest_id => $illrq_obj->illrequest_id, type => 'Y' } + }); + $builder->build({ + source => 'Illrequestattribute', + value => { illrequest_id => $illrq_obj->illrequest_id, type => 'Z' } + }); + + is($illrq_obj->illrequestattributes->count, Koha::Illrequestattributes->search->count, + "Fetching expected number of Illrequestattributes for our request."); + + my $illrq1 = $builder->build({ source => 'Illrequest' }); + $builder->build({ + source => 'Illrequestattribute', + value => { illrequest_id => $illrq1->{illrequest_id}, type => 'X' } + }); + + is($illrq_obj->illrequestattributes->count + 1, Koha::Illrequestattributes->search->count, + "Fetching expected number of Illrequestattributes for our request."); + + $illrq_obj->delete; + is(Koha::Illrequestattributes->search->count, 1, + "Correct number of illrequestattributes after delete."); + + isa_ok(Koha::Patrons->find($patron->{borrowernumber}), 'Koha::Patron', + "Borrower was not deleted after illrq delete."); + + $schema->storage->txn_rollback; +}; + +subtest 'Status Graph tests' => sub { + + plan tests => 4; + + $schema->storage->txn_begin; + + my $illrq = $builder->build({source => 'Illrequest'}); + my $illrq_obj = Koha::Illrequests->find($illrq->{illrequest_id}); + + # _core_status_graph tests: it's just a constant, so here we just make + # sure it returns a hashref. + is(ref $illrq_obj->_core_status_graph, "HASH", + "_core_status_graph returns a hash."); + + # _status_graph_union: let's try different merge operations. + # Identity operation + is_deeply( + $illrq_obj->_status_graph_union($illrq_obj->_core_status_graph, {}), + $illrq_obj->_core_status_graph, + "core_status_graph + null = core_status_graph" + ); + + # Simple addition + is_deeply( + $illrq_obj->_status_graph_union({}, $illrq_obj->_core_status_graph), + $illrq_obj->_core_status_graph, + "null + core_status_graph = core_status_graph" + ); + + # Correct merge behaviour + is_deeply( + $illrq_obj->_status_graph_union({ + REQ => { + prev_actions => [ ], + id => 'REQ', + next_actions => [ ], + }, + }, { + QER => { + prev_actions => [ 'REQ' ], + id => 'QER', + next_actions => [ 'REQ' ], + }, + }), + { + REQ => { + prev_actions => [ 'QER' ], + id => 'REQ', + next_actions => [ 'QER' ], + }, + QER => { + prev_actions => [ 'REQ' ], + id => 'QER', + next_actions => [ 'REQ' ], + }, + }, + "REQ atom + linking QER = cyclical status graph" + ); + + $schema->storage->txn_rollback; +}; + +subtest 'Backend testing (mocks)' => sub { + + plan tests => 13; + + $schema->storage->txn_begin; + + # testing load_backend & available_backends requires that we have at least + # the Dummy plugin installed. load_backend & available_backends don't + # currently have tests as a result. + + my $backend = Test::MockObject->new; + $backend->set_isa('Koha::Illbackends::Mock'); + $backend->set_always('name', 'Mock'); + + my $patron = $builder->build({ source => 'Borrower' }); + my $illrq = $builder->build({ + source => 'Illrequest', + value => { borrowernumber => $patron->{borrowernumber} } + }); + my $illrq_obj = Koha::Illrequests->find($illrq->{illrequest_id}); + + $illrq_obj->_backend($backend); + + isa_ok($illrq_obj->_backend, 'Koha::Illbackends::Mock', + "OK accessing mocked backend."); + + # _backend_capability tests: + # We need to test whether this optional feature of a mocked backend + # behaves as expected. + # 3 scenarios: feature not implemented, feature implemented, but requested + # capability is not provided by backend, & feature is implemented & + # capability exists. This method can be used to implement custom backend + # functionality, such as unmediated in the BLDSS backend (also see + # bugzilla 18837). + $backend->set_always('capabilities', undef); + is($illrq_obj->_backend_capability('Test'), 0, + "0 returned on Mock not implementing capabilities."); + + $backend->set_always('capabilities', 0); + is($illrq_obj->_backend_capability('Test'), 0, + "0 returned on Mock not implementing Test capability."); + + $backend->set_always('capabilities', sub { return 'bar'; } ); + is($illrq_obj->_backend_capability('Test'), 'bar', + "'bar' returned on Mock implementing Test capability."); + + # metadata test: we need to be sure that we return the arbitrary values + # from the backend. + $backend->mock( + 'metadata', + sub { + my ( $self, $rq ) = @_; + return { + ID => $rq->illrequest_id, + Title => $rq->patron->borrowernumber + } + } + ); + + is_deeply( + $illrq_obj->metadata, + { + ID => $illrq_obj->illrequest_id, + Title => $illrq_obj->patron->borrowernumber + }, + "Test metadata." + ); + + # capabilities: + + # No backend graph extension + $backend->set_always('status_graph', {}); + is_deeply($illrq_obj->capabilities('COMP'), + { + prev_actions => [ 'REQ' ], + id => 'COMP', + name => 'Completed', + ui_method_name => 'Mark completed', + method => 'mark_completed', + next_actions => [ ], + ui_method_icon => 'fa-check', + }, + "Dummy status graph for COMP."); + is($illrq_obj->capabilities('UNKNOWN'), undef, + "Dummy status graph for UNKNOWN."); + is_deeply($illrq_obj->capabilities(), + $illrq_obj->_core_status_graph, + "Dummy full status graph."); + # Simple backend graph extension + $backend->set_always('status_graph', + { + QER => { + prev_actions => [ 'REQ' ], + id => 'QER', + next_actions => [ 'REQ' ], + }, + }); + is_deeply($illrq_obj->capabilities('QER'), + { + prev_actions => [ 'REQ' ], + id => 'QER', + next_actions => [ 'REQ' ], + }, + "Simple status graph for QER."); + is($illrq_obj->capabilities('UNKNOWN'), undef, + "Simple status graph for UNKNOWN."); + is_deeply($illrq_obj->capabilities(), + $illrq_obj->_status_graph_union( + $illrq_obj->_core_status_graph, + { + QER => { + prev_actions => [ 'REQ' ], + id => 'QER', + next_actions => [ 'REQ' ], + }, + } + ), + "Simple full status graph."); + + # custom_capability: + + # No backend graph extension + $backend->set_always('status_graph', {}); + is($illrq_obj->custom_capability('unknown', {}), 0, + "Unknown candidate."); + + # Simple backend graph extension + $backend->set_always('status_graph', + { + ID => { + prev_actions => [ 'REQ' ], + id => 'ID', + method => 'identity', + next_actions => [ 'REQ' ], + }, + }); + $backend->mock('identity', + sub { my ( $self, $params ) = @_; return $params->{other}; }); + is($illrq_obj->custom_capability('identity', { test => 1 })->{test}, 1, + "Resolve identity custom_capability"); + + $schema->storage->txn_rollback; +}; + + +subtest 'Backend core methods' => sub { + + plan tests => 11; + + $schema->storage->txn_begin; + + # Build infrastructure + my $backend = Test::MockObject->new; + $backend->set_isa('Koha::Illbackends::Mock'); + $backend->set_always('name', 'Mock'); + + my $config = Test::MockObject->new; + $config->set_always('backend_dir', "/tmp"); + $config->set_always('getLimitRules', + { default => { count => 0, method => 'active' } }); + + my $illrq = $builder->build({source => 'Illrequest'}); + my $illrq_obj = Koha::Illrequests->find($illrq->{illrequest_id}); + $illrq_obj->_config($config); + $illrq_obj->_backend($backend); + + # expandTemplate: + is_deeply($illrq_obj->expandTemplate({ test => 1, method => "bar" }), + { + test => 1, + method => "bar", + template => "/tmp/Mock/intra-includes/bar.inc", + opac_template => "/tmp/Mock/opac-includes/bar.inc", + }, + "ExpandTemplate"); + + # backend_create + # we are testing simple cases. + $backend->set_series('create', + { stage => 'bar', method => 'create' }, + { stage => 'commit', method => 'create' }, + { stage => 'commit', method => 'create' }); + # Test Copyright Clearance + t::lib::Mocks::mock_preference("ILLModuleCopyrightClearance", "Test Copyright Clearance."); + is_deeply($illrq_obj->backend_create({test => 1}), + { + error => 0, + status => '', + message => '', + method => 'create', + stage => 'copyrightclearance', + value => { + backend => "Mock" + } + }, + "Backend create: copyright clearance."); + t::lib::Mocks::mock_preference("ILLModuleCopyrightClearance", ""); + # Test non-commit + is_deeply($illrq_obj->backend_create({test => 1}), + { + stage => 'bar', method => 'create', + template => "/tmp/Mock/intra-includes/create.inc", + opac_template => "/tmp/Mock/opac-includes/create.inc", + }, + "Backend create: arbitrary stage."); + # Test commit + is_deeply($illrq_obj->backend_create({test => 1}), + { + stage => 'commit', method => 'create', permitted => 0, + template => "/tmp/Mock/intra-includes/create.inc", + opac_template => "/tmp/Mock/opac-includes/create.inc", + }, + "Backend create: arbitrary stage, not permitted."); + is($illrq_obj->status, "QUEUED", "Backend create: queued if restricted."); + $config->set_always('getLimitRules', {}); + $illrq_obj->status('NEW'); + is_deeply($illrq_obj->backend_create({test => 1}), + { + stage => 'commit', method => 'create', permitted => 1, + template => "/tmp/Mock/intra-includes/create.inc", + opac_template => "/tmp/Mock/opac-includes/create.inc", + }, + "Backend create: arbitrary stage, permitted."); + is($illrq_obj->status, "NEW", "Backend create: not-queued."); + + # backend_renew + $backend->set_series('renew', { stage => 'bar', method => 'renew' }); + is_deeply($illrq_obj->backend_renew({test => 1}), + { + stage => 'bar', method => 'renew', + template => "/tmp/Mock/intra-includes/renew.inc", + opac_template => "/tmp/Mock/opac-includes/renew.inc", + }, + "Backend renew: arbitrary stage."); + + # backend_cancel + $backend->set_series('cancel', { stage => 'bar', method => 'cancel' }); + is_deeply($illrq_obj->backend_cancel({test => 1}), + { + stage => 'bar', method => 'cancel', + template => "/tmp/Mock/intra-includes/cancel.inc", + opac_template => "/tmp/Mock/opac-includes/cancel.inc", + }, + "Backend cancel: arbitrary stage."); + + # backend_update_status + $backend->set_series('update_status', { stage => 'bar', method => 'update_status' }); + is_deeply($illrq_obj->backend_update_status({test => 1}), + { + stage => 'bar', method => 'update_status', + template => "/tmp/Mock/intra-includes/update_status.inc", + opac_template => "/tmp/Mock/opac-includes/update_status.inc", + }, + "Backend update_status: arbitrary stage."); + + # backend_confirm + $backend->set_series('confirm', { stage => 'bar', method => 'confirm' }); + is_deeply($illrq_obj->backend_confirm({test => 1}), + { + stage => 'bar', method => 'confirm', + template => "/tmp/Mock/intra-includes/confirm.inc", + opac_template => "/tmp/Mock/opac-includes/confirm.inc", + }, + "Backend confirm: arbitrary stage."); + + # FIXME have to test generic_confirm. + + $schema->storage->txn_rollback; +}; + + +subtest 'Helpers' => sub { + + plan tests => 9; + + $schema->storage->txn_begin; + + # Build infrastructure + my $backend = Test::MockObject->new; + $backend->set_isa('Koha::Illbackends::Mock'); + $backend->set_always('name', 'Mock'); + + my $config = Test::MockObject->new; + $config->set_always('backend_dir', "/tmp"); + + my $patron = $builder->build({ + source => 'Borrower', + value => { categorycode => "A" } + }); + my $illrq = $builder->build({ + source => 'Illrequest', + value => { branchcode => "CPL", borrowernumber => $patron->{borrowernumber} } + }); + my $illrq_obj = Koha::Illrequests->find($illrq->{illrequest_id}); + $illrq_obj->_config($config); + $illrq_obj->_backend($backend); + + # getPrefix + $config->set_series('getPrefixes', + { CPL => "TEST", TSL => "BAR", default => "DEFAULT" }, + { A => "ATEST", C => "CBAR", default => "DEFAULT" }); + is($illrq_obj->getPrefix({ brw_cat => "C", branch => "CPL" }), "CBAR", + "getPrefix: brw_cat"); + $config->set_series('getPrefixes', + { CPL => "TEST", TSL => "BAR", default => "DEFAULT" }, + { A => "ATEST", C => "CBAR", default => "DEFAULT" }); + is($illrq_obj->getPrefix({ brw_cat => "UNKNOWN", branch => "CPL" }), "TEST", + "getPrefix: branch"); + $config->set_series('getPrefixes', + { CPL => "TEST", TSL => "BAR", default => "DEFAULT" }, + { A => "ATEST", C => "CBAR", default => "DEFAULT" }); + is($illrq_obj->getPrefix({ brw_cat => "UNKNOWN", branch => "UNKNOWN" }), "DEFAULT", + "getPrefix: default"); + $config->set_always('getPrefixes', {}); + is($illrq_obj->getPrefix({ brw_cat => "UNKNOWN", branch => "UNKNOWN" }), "", + "getPrefix: the empty prefix"); + + # id_prefix + $config->set_series('getPrefixes', + { CPL => "TEST", TSL => "BAR", default => "DEFAULT" }, + { A => "ATEST", C => "CBAR", default => "DEFAULT" }); + is($illrq_obj->id_prefix, "ATEST-", "id_prefix: brw_cat"); + $config->set_series('getPrefixes', + { CPL => "TEST", TSL => "BAR", default => "DEFAULT" }, + { AB => "ATEST", CD => "CBAR", default => "DEFAULT" }); + is($illrq_obj->id_prefix, "TEST-", "id_prefix: branch"); + $config->set_series('getPrefixes', + { CPLT => "TEST", TSLT => "BAR", default => "DEFAULT" }, + { AB => "ATEST", CD => "CBAR", default => "DEFAULT" }); + is($illrq_obj->id_prefix, "DEFAULT-", "id_prefix: default"); + + # requires_moderation + $illrq_obj->status('NEW')->store; + is($illrq_obj->requires_moderation, undef, "requires_moderation: No."); + $illrq_obj->status('CANCREQ')->store; + is($illrq_obj->requires_moderation, 'CANCREQ', "requires_moderation: Yes."); + + $schema->storage->txn_rollback; +}; + + +subtest 'Censorship' => sub { + + plan tests => 4; + + $schema->storage->txn_begin; + + # Build infrastructure + my $backend = Test::MockObject->new; + $backend->set_isa('Koha::Illbackends::Mock'); + $backend->set_always('name', 'Mock'); + + my $config = Test::MockObject->new; + $config->set_always('backend_dir', "/tmp"); + + my $illrq = $builder->build({source => 'Illrequest'}); + my $illrq_obj = Koha::Illrequests->find($illrq->{illrequest_id}); + $illrq_obj->_config($config); + $illrq_obj->_backend($backend); + + # getCensorNotesStaff + $config->set_series('censorship', + { censor_notes_staff => 1 }, + { censor_notes_staff => 0 }); + is($illrq_obj->getCensorNotesStaff, 1, + "getCensorNotesStaff: on."); + is($illrq_obj->getCensorNotesStaff, 0, + "getCensorNotesStaff: off."); + + # getDisplayReplyDate + $config->set_series('censorship', + { censor_reply_date => 1 }, + { censor_reply_date => 0 }); + is($illrq_obj->getDisplayReplyDate, 0, + "getDisplayReplyDate: off."); + is($illrq_obj->getDisplayReplyDate, 1, + "getDisplayReplyDate: on."); + + # FIXME need to test _censor + + $schema->storage->txn_rollback; +}; + +subtest 'Checking Limits' => sub { + + plan tests => 3; + + $schema->storage->txn_begin; + + # Build infrastructure + my $backend = Test::MockObject->new; + $backend->set_isa('Koha::Illbackends::Mock'); + $backend->set_always('name', 'Mock'); + + my $config = Test::MockObject->new; + $config->set_always('backend_dir', "/tmp"); + + my $illrq = $builder->build({source => 'Illrequest'}); + my $illrq_obj = Koha::Illrequests->find($illrq->{illrequest_id}); + $illrq_obj->_config($config); + $illrq_obj->_backend($backend); + + # getLimits + $config->set_series('getLimitRules', + { CPL => { count => 1, method => 'test' } }, + { default => { count => 0, method => 'active' } }); + is_deeply($illrq_obj->getLimits({ type => 'branch', value => "CPL" }), + { count => 1, method => 'test' }, + "getLimits: by value."); + is_deeply($illrq_obj->getLimits({ type => 'branch' }), + { count => 0, method => 'active' }, + "getLimits: by default."); + is_deeply($illrq_obj->getLimits({ type => 'branch', value => "CPL" }), + { count => -1, method => 'active' }, + "getLimits: by hard-coded."); + + # FIXME need to test _limit_counter & check_limits + + $schema->storage->txn_rollback; +}; + + + +1; -- 2.14.2