Koha-community/Koha
13
7
Fork 0
Code Issues Releases Wiki Activity
Koha/t/db_dependent/StockRotationItems.t
Martin Renvoize 320f82857c Bug 22569: Add Unit Tests 
Test plan:
1/ Run the updated unit tests

Signed-off-by: Kathleen Milne <kathleen.milne@cne-siar.gov.uk>

Signed-off-by: Katrin Fischer <katrin.fischer.83@web.de>

Signed-off-by: Jonathan Druart <jonathan.druart@bugs.koha-community.org>
2021-03-11 11:51:40 +01:00

711 lines
27 KiB
Perl
Executable file
Raw Blame History

#!/usr/bin/perl
# Copyright PTFS Europe 2016
#
# 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 3 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, see <http://www.gnu.org/licenses>.
use Modern::Perl;
use DateTime;
use DateTime::Duration;
use Koha::Database;
use Koha::DateUtils;
use Koha::Item::Transfer;
use Test::Warn;
use t::lib::TestBuilder;
use t::lib::Mocks;
use Test::More tests => 9;
my $schema = Koha::Database->new->schema;
use_ok('Koha::StockRotationItems');
use_ok('Koha::StockRotationItem');
my $builder = t::lib::TestBuilder->new;
subtest 'Basic object tests' => sub {
plan tests => 5;
$schema->storage->txn_begin;
my $itm = $builder->build_sample_item;
my $stage = $builder->build({ source => 'Stockrotationstage' });
my $item = $builder->build({
source => 'Stockrotationitem',
value => {
itemnumber_id => $itm->itemnumber,
stage_id => $stage->{stage_id},
},
});
my $sritem = Koha::StockRotationItems->find($item->{itemnumber_id});
isa_ok(
$sritem,
'Koha::StockRotationItem',
"Correctly create and load a stock rotation item."
);
# Relationship to rota
isa_ok( $sritem->itemnumber, 'Koha::Item', "Fetched related item." );
is( $sritem->itemnumber->itemnumber, $itm->itemnumber, "Related rota OK." );
# Relationship to stage
isa_ok( $sritem->stage, 'Koha::StockRotationStage', "Fetched related stage." );
is( $sritem->stage->stage_id, $stage->{stage_id}, "Related stage OK." );
$schema->storage->txn_rollback;
};
subtest 'Tests for needs_repatriating' => sub {
plan tests => 4;
$schema->storage->txn_begin;
# Setup a pristine stockrotation context.
my $sritem = $builder->build(
{
source => 'Stockrotationitem',
value =>
{ itemnumber_id => $builder->build_sample_item->itemnumber }
}
);
my $dbitem = Koha::StockRotationItems->find($sritem->{itemnumber_id});
$dbitem->itemnumber->homebranch($dbitem->stage->branchcode_id);
$dbitem->itemnumber->holdingbranch($dbitem->stage->branchcode_id);
$dbitem->stage->position(1);
my $dbrota = $dbitem->stage->rota;
my $newstage = $builder->build({
source => 'Stockrotationstage',
value => {
rota_id => $dbrota->rota_id,
position => 2,
}
});
# - homebranch == holdingbranch [0]
is(
$dbitem->needs_repatriating, 0,
"Homebranch == Holdingbranch."
);
my $branch = $builder->build({ source => 'Branch' });
$dbitem->itemnumber->holdingbranch($branch->{branchcode});
# - homebranch != holdingbranch [1]
is(
$dbitem->needs_repatriating, 1,
"Homebranch != holdingbranch."
);
# Set to incorrect homebranch.
$dbitem->itemnumber->holdingbranch($dbitem->stage->branchcode_id);
$dbitem->itemnumber->homebranch($branch->{branchcode});
# - homebranch != stockrotationstage.branch & not in transit [1]
is(
$dbitem->needs_repatriating, 1,
"Homebranch != StockRotationStage.Branchcode_id & not in transit."
);
# Set to in transit (by implication).
$dbitem->stage($newstage->{stage_id});
# - homebranch != stockrotaitonstage.branch & in transit [0]
is(
$dbitem->needs_repatriating, 1,
"homebranch != stockrotaitonstage.branch & in transit."
);
$schema->storage->txn_rollback;
};
subtest "Tests for repatriate." => sub {
plan tests => 9;
$schema->storage->txn_begin;
my $sritem_1 = $builder->build_object(
{
class => 'Koha::StockRotationItems',
value => {
itemnumber_id => $builder->build_sample_item->itemnumber
}
}
);
my $item_id = $sritem_1->itemnumber->itemnumber;
my $srstage_1 = $sritem_1->stage;
$sritem_1->discard_changes;
$sritem_1->stage->position(1);
$sritem_1->stage->duration(50);
my $branch = $builder->build({ source => 'Branch' });
$sritem_1->itemnumber->holdingbranch($branch->{branchcode});
# Test a straight up repatriate
ok($sritem_1->repatriate, "Repatriation done.");
my $intransfer = $sritem_1->itemnumber->get_transfer;
is($intransfer->frombranch, $branch->{branchcode}, "Origin correct.");
is($intransfer->tobranch, $sritem_1->stage->branchcode_id, "Target Correct.");
# Reset
$intransfer->datearrived(dt_from_string())->store;
$sritem_1->itemnumber->holdingbranch($branch->{branchcode});
# Setup a conflicting manual transfer
my $item = Koha::Items->find($item_id);
$item->request_transfer({ to => $srstage_1->branchcode, reason => "Manual" });
$intransfer = $item->get_transfer;
is (ref($intransfer), 'Koha::Item::Transfer', "Conflicting transfer added");
is ($intransfer->reason, 'Manual', "Conflicting transfer reason is 'Manual'");
# Stockrotation should handle transfer clashes
is($sritem_1->repatriate, 0, "Repatriation skipped if transfer in progress.");
# Reset
$intransfer->datearrived(dt_from_string())->store;
$sritem_1->itemnumber->holdingbranch($branch->{branchcode});
# Confirm that stockrotation ignores transfer limits
t::lib::Mocks::mock_preference('UseBranchTransferLimits', 1);
t::lib::Mocks::mock_preference('BranchTransferLimitsType', 'itemtype');
my $limit = Koha::Item::Transfer::Limit->new(
{
fromBranch => $branch->{branchcode},
toBranch => $srstage_1->branchcode_id,
itemtype => $sritem_1->itemnumber->effective_itemtype,
}
)->store;
# Stockrotation should overrule transfer limits
ok($sritem_1->repatriate, "Repatriation done regardless of transfer limits.");
$intransfer = $sritem_1->itemnumber->get_transfer;
is($intransfer->frombranch, $branch->{branchcode}, "Origin correct.");
is($intransfer->tobranch, $sritem_1->stage->branchcode_id, "Target Correct.");
$schema->storage->txn_rollback;
};
subtest "Tests for needs_advancing." => sub {
plan tests => 7;
$schema->storage->txn_begin;
# Test behaviour of item freshly added to rota.
my $sritem = $builder->build(
{
source => 'Stockrotationitem',
value => {
'fresh' => 1,
itemnumber_id => $builder->build_sample_item->itemnumber
},
}
);
my $dbitem = Koha::StockRotationItems->find($sritem->{itemnumber_id});
is($dbitem->needs_advancing, 1, "An item that is fresh will always need advancing.");
# Setup a pristine stockrotation context.
$sritem = $builder->build(
{
source => 'Stockrotationitem',
value => {
'fresh' => 0,
itemnumber_id => $builder->build_sample_item->itemnumber
}
}
);
$dbitem = Koha::StockRotationItems->find($sritem->{itemnumber_id});
$dbitem->itemnumber->homebranch($dbitem->stage->branchcode_id);
$dbitem->itemnumber->holdingbranch($dbitem->stage->branchcode_id);
$dbitem->stage->position(1);
$dbitem->stage->duration(50);
my $dbtransfer = Koha::Item::Transfer->new({
'itemnumber' => $dbitem->itemnumber_id,
'frombranch' => $dbitem->stage->branchcode_id,
'tobranch' => $dbitem->stage->branchcode_id,
'datesent' => dt_from_string(),
'datearrived' => undef,
'reason' => "StockrotationAdvance",
})->store;
# Test item will not be advanced if in transit.
is($dbitem->needs_advancing, 0, "Not ready to advance: in transfer.");
# Test item will not be advanced if in transit even if fresh.
$dbitem->fresh(1)->store;
is($dbitem->needs_advancing, 0, "Not ready to advance: in transfer (fresh).");
$dbitem->fresh(0)->store;
# Test item will not be advanced if it has not spent enough time.
$dbtransfer->datearrived(dt_from_string())->store;
is($dbitem->needs_advancing, 0, "Not ready to advance: Not spent enough time.");
# Test item will be advanced if it has not spent enough time, but is fresh.
$dbitem->fresh(1)->store;
is($dbitem->needs_advancing, 1, "Advance: Not spent enough time, but fresh.");
$dbitem->fresh(0)->store;
# Test item will be advanced if it has spent enough time.
$dbtransfer->datesent( # Item was sent 100 days ago...
dt_from_string() - DateTime::Duration->new( days => 100 )
)->store;
$dbtransfer->datearrived( # And arrived 75 days ago.
dt_from_string() - DateTime::Duration->new( days => 75 )
)->store;
is($dbitem->needs_advancing, 1, "Ready to be advanced.");
$dbtransfer->delete;
warning_is {$dbitem->needs_advancing} "We have no historical branch transfer for itemnumber " . $dbitem->itemnumber->itemnumber . "; This should not have happened!", "Missing transfer is warned.";
$schema->storage->txn_rollback;
};
subtest "Tests for advance." => sub {
plan tests => 44;
$schema->storage->txn_begin;
my $sritem_1 = $builder->build_object(
{
class => 'Koha::StockRotationItems',
value => {
'fresh' => 1,
itemnumber_id => $builder->build_sample_item->itemnumber
}
}
);
$sritem_1->discard_changes;
$sritem_1->itemnumber->holdingbranch($sritem_1->stage->branchcode_id);
my $item_id = $sritem_1->itemnumber->itemnumber;
my $srstage_1 = $sritem_1->stage;
$srstage_1->position(1)->duration(50)->store; # Configure stage.
# Configure item
$sritem_1->itemnumber->holdingbranch($srstage_1->branchcode_id)->store;
$sritem_1->itemnumber->homebranch($srstage_1->branchcode_id)->store;
# Sanity check
is($sritem_1->stage->stage_id, $srstage_1->stage_id, "Stage sanity check.");
# Test if an item is fresh, always move to first stage.
is($sritem_1->fresh, 1, "Fresh is correct.");
$sritem_1->advance;
is($sritem_1->stage->stage_id, $srstage_1->stage_id, "Stage is first stage after fresh advance.");
is($sritem_1->fresh, 0, "Fresh reset after advance.");
# Test cases of single stage
$srstage_1->rota->cyclical(1)->store; # Set Rota to cyclical.
ok($sritem_1->advance, "Single stage cyclical advance done.");
## Refetch sritem_1
$sritem_1->discard_changes;
is($sritem_1->stage->stage_id, $srstage_1->stage_id, "Single stage cyclical stage OK.");
# Test with indemand advance
$sritem_1->indemand(1)->store;
ok($sritem_1->advance, "Indemand item advance done.");
## Refetch sritem_1
$sritem_1->discard_changes;
is($sritem_1->indemand, 0, "Indemand OK.");
is($sritem_1->stage->stage_id, $srstage_1->stage_id, "Indemand item advance stage OK.");
# Multi stages
my $srstage_2 = $builder->build_object({
class => 'Koha::StockRotationStages',
value => { duration => 50 }
});
$srstage_2->discard_changes;
$srstage_2->move_to_group($sritem_1->stage->rota_id);
$srstage_2->move_last;
# Test a straight up advance
ok($sritem_1->advance, "Advancement done.");
## Refetch sritem_1
$sritem_1->discard_changes;
## Test results
is($sritem_1->stage->stage_id, $srstage_2->stage_id, "Stage updated.");
is(
$sritem_1->itemnumber->homebranch,
$srstage_2->branchcode_id,
"Item homebranch updated"
);
my $transfer_request = $sritem_1->itemnumber->get_transfer;
is($transfer_request->frombranch, $srstage_1->branchcode_id, "Origin correct.");
is($transfer_request->tobranch, $srstage_2->branchcode_id, "Target Correct.");
is($transfer_request->datesent, undef, "Transfer requested, but not sent.");
# Arrive at new branch
$transfer_request->datearrived(dt_from_string())->store;
$sritem_1->itemnumber->holdingbranch($srstage_2->branchcode_id)->store;
# Test a cyclical advance
ok($sritem_1->advance, "Cyclical advancement done.");
## Refetch sritem_1
$sritem_1->discard_changes;
## Test results
is($sritem_1->stage->stage_id, $srstage_1->stage_id, "Stage updated.");
is(
$sritem_1->itemnumber->homebranch,
$srstage_1->branchcode_id,
"Item homebranch updated"
);
$transfer_request = $sritem_1->itemnumber->get_transfer;
is($transfer_request->frombranch, $srstage_2->branchcode_id, "Origin correct.");
is($transfer_request->tobranch, $srstage_1->branchcode_id, "Target correct.");
# Arrive at new branch
$transfer_request->datearrived(dt_from_string())->store;
$sritem_1->itemnumber->holdingbranch($srstage_1->branchcode_id)->store;
# Confirm that stockrotation ignores transfer limits
t::lib::Mocks::mock_preference('UseBranchTransferLimits', 1);
t::lib::Mocks::mock_preference('BranchTransferLimitsType', 'itemtype');
my $limit = Koha::Item::Transfer::Limit->new(
{
fromBranch => $srstage_1->branchcode_id,
toBranch => $srstage_2->branchcode_id,
itemtype => $sritem_1->itemnumber->effective_itemtype,
}
)->store;
ok($sritem_1->advance, "Advancement overrules transfer limits.");
## Refetch sritem_1
$sritem_1->discard_changes;
## Test results
is($sritem_1->stage->stage_id, $srstage_2->stage_id, "Stage updated ignoring transfer limits.");
is(
$sritem_1->itemnumber->homebranch,
$srstage_2->branchcode_id,
"Item homebranch updated ignoring transfer limits"
);
$transfer_request = $sritem_1->itemnumber->get_transfer;
is($transfer_request->frombranch, $srstage_1->branchcode_id, "Origin correct ignoring transfer limits.");
is($transfer_request->tobranch, $srstage_2->branchcode_id, "Target correct ignoring transfer limits.");
# Arrive at new branch
$transfer_request->datearrived(dt_from_string())->store;
$sritem_1->itemnumber->holdingbranch($srstage_2->branchcode_id)->store;
# Setup a conflicting manual transfer
my $item = Koha::Items->find($item_id);
$item->request_transfer({ to => $srstage_1->branchcode, reason => "Manual" });
$transfer_request = $item->get_transfer;
is (ref($transfer_request), 'Koha::Item::Transfer', "Conflicting transfer added");
is ($transfer_request->reason, 'Manual', "Conflicting transfer reason is 'Manual'");
# Advance item whilst conflicting manual transfer exists
ok($sritem_1->advance, "Advancement done.");
## Refetch sritem_1
$sritem_1->discard_changes;
## Refetch conflicted transfer
$transfer_request->discard_changes;
# Conflicted transfer should have been cancelled
isnt($transfer_request->datecancelled, undef, "Conflicting manual transfer was cancelled");
# StockRotationAdvance transfer added
$transfer_request = $sritem_1->itemnumber->get_transfer;
is($transfer_request->reason, 'StockrotationAdvance', "StockrotationAdvance transfer added");
is($transfer_request->frombranch, $srstage_2->branchcode_id, "Origin correct.");
is($transfer_request->tobranch, $srstage_1->branchcode_id, "Target correct.");
# Arrive at new branch
$transfer_request->datearrived(dt_from_string())->store;
$sritem_1->itemnumber->holdingbranch($srstage_1->branchcode_id)->store;
# Setup a conflicting reserve transfer
$item->request_transfer({ to => $srstage_2->branchcode, reason => "Reserve" });
$transfer_request = $item->get_transfer;
is (ref($transfer_request), 'Koha::Item::Transfer', "Conflicting transfer added");
is ($transfer_request->reason, 'Reserve', "Conflicting transfer reason is 'Reserve'");
# Advance item whilst conflicting reserve transfer exists
ok($sritem_1->advance, "Advancement done.");
## Refetch sritem_1
$sritem_1->discard_changes;
## Refetch conflicted transfer
$transfer_request->discard_changes;
# Conflicted transfer should not been cancelled
is($transfer_request->datecancelled, undef, "Conflicting reserve transfer was not cancelled");
# StockRotationAdvance transfer added
my $transfer_requests = Koha::Item::Transfers->search(
{
itemnumber => $sritem_1->itemnumber->itemnumber,
datearrived => undef,
datecancelled => undef
}
);
is($transfer_requests->count, '2', "StockrotationAdvance transfer queued");
# Arrive at new branch
$transfer_request->datearrived(dt_from_string())->store;
$sritem_1->itemnumber->holdingbranch($srstage_2->branchcode_id)->store;
# StockRotationAdvance transfer added
$transfer_request = $sritem_1->itemnumber->get_transfer;
is($transfer_request->reason, 'StockrotationAdvance', "StockrotationAdvance transfer remains after reserve is met");
is($transfer_request->frombranch, $srstage_1->branchcode_id, "Origin correct.");
is($transfer_request->tobranch, $srstage_2->branchcode_id, "Target correct.");
# Arrive at new branch
$transfer_request->datearrived(dt_from_string())->store;
$sritem_1->itemnumber->holdingbranch($srstage_2->branchcode_id)->store;
$srstage_1->rota->cyclical(0)->store; # Set Rota to non-cyclical.
my $srstage_3 = $builder->build_object({
class => 'Koha::StockRotationStages',
value => { duration => 50 }
});
$srstage_3->discard_changes;
$srstage_3->move_to_group($sritem_1->stage->rota_id);
$srstage_3->move_last;
# Advance again, to end of rota.
ok($sritem_1->advance, "Non-cyclical advance to last stage.");
# Arrive at new branch
$transfer_request->datearrived(dt_from_string())->store;
$sritem_1->itemnumber->holdingbranch($srstage_3->branchcode_id)->store;
# Advance again, Remove from rota.
ok($sritem_1->advance, "Non-cyclical advance.");
## Refetch sritem_1
$sritem_1 = Koha::StockRotationItems->find({ itemnumber_id => $item_id });
is($sritem_1, undef, "StockRotationItem has been removed.");
$item = Koha::Items->find($item_id);
is($item->homebranch, $srstage_3->branchcode_id, "Item homebranch remains");
$schema->storage->txn_rollback;
};
subtest "Tests for investigate (singular)." => sub {
plan tests => 7;
$schema->storage->txn_begin;
# Test brand new item's investigation ['initiation']
my $sritem = $builder->build(
{
source => 'Stockrotationitem',
value => {
fresh => 1,
itemnumber_id => $builder->build_sample_item->itemnumber
}
}
);
my $dbitem = Koha::StockRotationItems->find($sritem->{itemnumber_id});
is($dbitem->investigate->{reason}, 'initiation', "fresh item initiates.");
# Test brand new item at stagebranch ['initiation']
$sritem = $builder->build(
{
source => 'Stockrotationitem',
value => {
fresh => 1,
itemnumber_id => $builder->build_sample_item->itemnumber
}
}
);
$dbitem = Koha::StockRotationItems->find($sritem->{itemnumber_id});
$dbitem->itemnumber->homebranch($dbitem->stage->branchcode_id)->store;
$dbitem->itemnumber->holdingbranch($dbitem->stage->branchcode_id)->store;
is($dbitem->investigate->{reason}, 'initiation', "fresh item at stagebranch initiates.");
# Test item not at stagebranch with branchtransfer history ['repatriation']
$sritem = $builder->build(
{
source => 'Stockrotationitem',
value => {
'fresh' => 0,
itemnumber_id => $builder->build_sample_item->itemnumber
}
}
);
$dbitem = Koha::StockRotationItems->find($sritem->{itemnumber_id});
my $dbtransfer = Koha::Item::Transfer->new({
'itemnumber' => $dbitem->itemnumber_id,
'frombranch' => $dbitem->itemnumber->homebranch,
'tobranch' => $dbitem->itemnumber->homebranch,
'datesent' => dt_from_string(),
'datearrived' => dt_from_string(),
'reason' => "StockrotationAdvance",
})->store;
is($dbitem->investigate->{reason}, 'repatriation', "older item repatriates.");
# Test item at stagebranch with branchtransfer history ['not-ready']
$sritem = $builder->build(
{
source => 'Stockrotationitem',
value => {
'fresh' => 0,
itemnumber_id => $builder->build_sample_item->itemnumber
}
}
);
$dbitem = Koha::StockRotationItems->find($sritem->{itemnumber_id});
$dbtransfer = Koha::Item::Transfer->new({
'itemnumber' => $dbitem->itemnumber_id,
'frombranch' => $dbitem->itemnumber->homebranch,
'tobranch' => $dbitem->stage->branchcode_id,
'datesent' => dt_from_string(),
'datearrived' => dt_from_string(),
'reason' => "StockrotationAdvance",
})->store;
$dbitem->itemnumber->homebranch($dbitem->stage->branchcode_id)->store;
$dbitem->itemnumber->holdingbranch($dbitem->stage->branchcode_id)->store;
is($dbitem->investigate->{reason}, 'not-ready', "older item at stagebranch not-ready.");
# Test item due for advancement ['advancement']
$sritem = $builder->build(
{
source => 'Stockrotationitem',
value => {
fresh => 0,
itemnumber_id => $builder->build_sample_item->itemnumber
}
}
);
$dbitem = Koha::StockRotationItems->find($sritem->{itemnumber_id});
$dbitem->indemand(0)->store;
$dbitem->stage->duration(50)->store;
my $sent_duration = DateTime::Duration->new( days => 55);
my $arrived_duration = DateTime::Duration->new( days => 52);
$dbtransfer = Koha::Item::Transfer->new({
'itemnumber' => $dbitem->itemnumber_id,
'frombranch' => $dbitem->itemnumber->homebranch,
'tobranch' => $dbitem->stage->branchcode_id,
'datesent' => dt_from_string() - $sent_duration,
'datearrived' => dt_from_string() - $arrived_duration,
'reason' => "StockrotationAdvance",
})->store;
$dbitem->itemnumber->homebranch($dbitem->stage->branchcode_id)->store;
$dbitem->itemnumber->holdingbranch($dbitem->stage->branchcode_id)->store;
is($dbitem->investigate->{reason}, 'advancement',
"Item ready for advancement.");
# Test item due for advancement but in-demand ['in-demand']
$sritem = $builder->build(
{
source => 'Stockrotationitem',
value => {
fresh => 0,
itemnumber_id => $builder->build_sample_item->itemnumber
}
}
);
$dbitem = Koha::StockRotationItems->find($sritem->{itemnumber_id});
$dbitem->indemand(1)->store;
$dbitem->stage->duration(50)->store;
$sent_duration = DateTime::Duration->new( days => 55);
$arrived_duration = DateTime::Duration->new( days => 52);
$dbtransfer = Koha::Item::Transfer->new({
'itemnumber' => $dbitem->itemnumber_id,
'frombranch' => $dbitem->itemnumber->homebranch,
'tobranch' => $dbitem->stage->branchcode_id,
'datesent' => dt_from_string() - $sent_duration,
'datearrived' => dt_from_string() - $arrived_duration,
'reason' => "StockrotationAdvance",
})->store;
$dbitem->itemnumber->homebranch($dbitem->stage->branchcode_id)->store;
$dbitem->itemnumber->holdingbranch($dbitem->stage->branchcode_id)->store;
is($dbitem->investigate->{reason}, 'in-demand',
"Item advances, but in-demand.");
# Test item ready for advancement, but at wrong library ['repatriation']
$sritem = $builder->build(
{
source => 'Stockrotationitem',
value => {
fresh => 0,
itemnumber_id => $builder->build_sample_item->itemnumber
}
}
);
$dbitem = Koha::StockRotationItems->find($sritem->{itemnumber_id});
$dbitem->indemand(0)->store;
$dbitem->stage->duration(50)->store;
$sent_duration = DateTime::Duration->new( days => 55);
$arrived_duration = DateTime::Duration->new( days => 52);
$dbtransfer = Koha::Item::Transfer->new({
'itemnumber' => $dbitem->itemnumber_id,
'frombranch' => $dbitem->itemnumber->homebranch,
'tobranch' => $dbitem->stage->branchcode_id,
'datesent' => dt_from_string() - $sent_duration,
'datearrived' => dt_from_string() - $arrived_duration,
'reason' => "StockrotationAdvance",
})->store;
is($dbitem->investigate->{reason}, 'repatriation',
"Item advances, but not at stage branch.");
$schema->storage->txn_rollback;
};
subtest "Tests for toggle_indemand" => sub {
plan tests => 15;
$schema->storage->txn_begin;
my $sritem = $builder->build({
source => 'Stockrotationitem',
value => { 'fresh' => 0, 'indemand' => 0 }
});
my $dbitem = Koha::StockRotationItems->find($sritem->{itemnumber_id});
my $firstbranch = $dbitem->stage->branchcode_id;
$dbitem->itemnumber->holdingbranch($firstbranch)->store;
my $dbstage = $dbitem->stage;
$dbstage->position(1)->duration(50)->store; # Configure stage.
# Configure item
$dbitem->itemnumber->holdingbranch($firstbranch)->store;
$dbitem->itemnumber->homebranch($firstbranch)->store;
# Sanity check
is($dbitem->stage->stage_id, $dbstage->stage_id, "Stage sanity check.");
# Test if an item is not in transfer, toggle always acts.
is($dbitem->indemand, 0, "Item not in transfer starts with indemand disabled.");
$dbitem->toggle_indemand;
is($dbitem->indemand, 1, "Item not in transfer toggled correctly first time.");
$dbitem->toggle_indemand;
is($dbitem->indemand, 0, "Item not in transfer toggled correctly second time.");
# Add stages
my $srstage = $builder->build({
source => 'Stockrotationstage',
value => { duration => 50 }
});
my $dbstage2 = Koha::StockRotationStages->find($srstage->{stage_id});
$dbstage2->move_to_group($dbitem->stage->rota_id);
$dbstage2->position(2)->store;
my $secondbranch = $dbstage2->branchcode_id;
# Test an item in transfer, toggle cancels transfer and resets indemand.
ok($dbitem->advance, "Advancement done.");
$dbitem->get_from_storage;
my $transfer = $dbitem->itemnumber->get_transfer;
is(ref($transfer), 'Koha::Item::Transfer', 'Item set to in transfer as expected');
is($transfer->frombranch, $firstbranch, 'Transfer from set correctly');
is($transfer->tobranch, $secondbranch, 'Transfer to set correctly');
is($transfer->datearrived, undef, 'Transfer datearrived not set');
$dbitem->toggle_indemand;
my $updated_transfer = $transfer->get_from_storage;
is($updated_transfer->frombranch, $firstbranch, 'Transfer from retained correctly');
is($updated_transfer->tobranch, $firstbranch, 'Transfer to updated correctly');
isnt($updated_transfer->datearrived, undef, 'Transfer datearrived set as expected');
is($dbitem->indemand, 0, "Item retains indemand as expected.");
is($dbitem->stage_id, $dbstage->id, 'Item stage reset as expected.');
is($dbitem->itemnumber->homebranch, $firstbranch, 'Item homebranch reset as expected.');
$schema->storage->txn_rollback;
};
1;
View git blame Copy permalink