package SImpls::Accountlines;

# Copyright Vaara-kirjastot 2015

#

# 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, write to the Free Software Foundation, Inc.,

# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.

use Modern::Perl;

use Carp;

use Test::More;

use Koha::Database;

sub deleteAllFines {

    my $schema = Koha::Database->new()->schema();

    $schema->resultset('Accountline')->search({})->delete_all();

}

sub checkAccountlines {

    my $C = shift;

    my $S = $C->{stash}->{scenario};

    my $F = $C->{stash}->{feature};

    my $checks = $C->data(); #Get the checks, which might not have manifested itselves to the message_queue_items

    ok(($checks && scalar(@$checks) > 0), "You must give checks as the data");

    #See which checks are supposed to be in the accountlines-table, and which are just to clarify intent.

    my @checksToDo;

    foreach my $check (@$checks) {

        my $status = $check->{fine};

        push @checksToDo, $check if ($status ne 'none');

    }

    ##Make sure that there are no trailing Accountlines.

    my $schema = Koha::Database->new()->schema();

    my $allFinesCount = $schema->resultset('Accountline')->search({})->count();

    is($allFinesCount, scalar(@checksToDo), "We should have ".scalar(@checksToDo)." checks for $allFinesCount fines, with no trailing fines.");

    my $dbh = C4::Context->dbh();

    my $check_statement = $dbh->prepare(

        "SELECT 1 FROM accountlines a ".

        "LEFT JOIN borrowers b ON a.borrowernumber = b.borrowernumber ".

        "WHERE b.cardnumber = ? AND a.amountoutstanding = ? ".

    "");

    ##Check that there is a matching Accountline for each given test.

    foreach my $check (@checksToDo) {

        my @params;

        push @params, $check->{cardnumber};

        push @params, $check->{fine};

        $check_statement->execute( @params );

        my $ok = $check_statement->fetchrow();

        last unless ok(($ok && $ok == 1), "Check: For params @params");

    }

}

1;

package SImpls::Biblios;

# Copyright Vaara-kirjastot 2015

#

# 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, write to the Free Software Foundation, Inc.,

# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.

use Modern::Perl;

use Carp;

use Test::More;

use t::db_dependent::TestObjects::Biblios::BiblioFactory;

sub addBiblios {

    my $C = shift;

    my $S = $C->{stash}->{scenario};

    my $F = $C->{stash}->{feature};

    $S->{biblios} = {} unless $S->{biblios};

    $F->{biblios} = {} unless $F->{biblios};

    my $records = t::db_dependent::TestObjects::Biblios::BiblioFactory::createTestGroup($C->data(),'biblioitems.isbn');

    while( my ($key, $record) = each %$records) {

        $S->{biblios}->{ $key } = $record;

        $F->{biblios}->{ $key } = $record;

    }

}

sub deleteBiblios {

    my $C = shift;

    my $F = $C->{stash}->{feature};

    t::db_dependent::TestObjects::Biblios::BiblioFactory::deleteTestGroup( $F->{biblios} );

}

1;

package SImpls::Borrowers;

# Copyright Vaara-kirjastot 2015

#

# 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, write to the Free Software Foundation, Inc.,

# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.

use Modern::Perl;

use Carp;

use Test::More;

use Koha::Borrowers;

use Koha::Borrower::Debarments;

use t::db_dependent::TestObjects::Borrowers::BorrowerFactory;

sub addBorrowers {

    my $C = shift;

    my $S = $C->{stash}->{scenario};

    my $F = $C->{stash}->{feature};

    $S->{borrowers} = {} unless $S->{borrowers};

    $F->{borrowers} = {} unless $F->{borrowers};

    my $borrowers = t::db_dependent::TestObjects::Borrowers::BorrowerFactory::createTestGroup($C->data(),'cardnumber');

    while( my ($key, $borrower) = each %$borrowers) {

        $S->{borrowers}->{ $key } = $borrower;

        $F->{borrowers}->{ $key } = $borrower;

    }

}

sub deleteBorrowers {

    my $C = shift;

    my $F = $C->{stash}->{feature};

    t::db_dependent::TestObjects::Borrowers::BorrowerFactory::deleteTestGroup( $F->{borrowers} );

}

sub checkDebarments {

    my $C = shift;

    my $S = $C->{stash}->{scenario};

    my $F = $C->{stash}->{feature};

    my $checks = $C->data(); #Get the checks we need to do.

    ok(($checks && scalar(@$checks) > 0), "You must give checks as the data");

    ##Make sure that there are no trailing Debarments.

    my $schema = Koha::Database->new()->schema();

    my $allDebarmentsCount = $schema->resultset('BorrowerDebarment')->search({})->count();

    is($allDebarmentsCount, scalar(@$checks), "We should have ".scalar(@$checks)." checks for $allDebarmentsCount fines, with no trailing fines.");

    #We need to collect all checks for each borrower, because a single borrower can have multiple checks

    my %checksByBorrower;

    foreach my $check (@$checks) {

        unless ($checksByBorrower{$check->{cardnumber}}) {

            $checksByBorrower{$check->{cardnumber}} = [];

        }

        push( @{$checksByBorrower{$check->{cardnumber}}}, $check );

        #Remove keys not needed in the comparison ahead. Leaving keys not found in the debarment-object will ruin the check.

        delete $check->{cardnumber};

    }

    ##Check that there is a matching Debarment for each given check.

    while( my ($cardnumber, $checks) =  each %checksByBorrower ) {

        my $borrower = Koha::Borrowers->find({cardnumber => $cardnumber});

        die "checkDebarments():> No borrower for cardnumber '$cardnumber'" unless ($cardnumber);

        my $debarments = Koha::Borrower::Debarments::GetDebarments({borrowernumber => $borrower->id()});

        #Check every check against every debarment, if all checks are satisifed from the found debarments, all is fine!

        foreach my $check (@$checks) {

            my $checkOk = 0;

            for (my $i=0 ; $i<@$debarments ; $i++) {

                my $debarment = $debarments->[$i];

                #Iterate all the keys in check, and see if they match the debarment

                my $keysNeedingSuccessfulMatch = scalar(keys(%$check));

                while( my ($key, $value) = each %$check ) {

                    if ($debarment->{$key} eq $check->{$key}) {

                        $keysNeedingSuccessfulMatch--;

                    }

                }

                #This debarment matches this check

                if ($keysNeedingSuccessfulMatch == 0) {

                    splice @$debarments, $i, 1;

                    $i--;

                    $checkOk = 1;

                    last();

                }

            }

            return unless ok($checkOk, "Debarment '".join(', ',join(' => ',each(%$check)))."' found.");

        }

    }

}

1;

package SImpls::BranchTransfers;

# Copyright Vaara-kirjastot 2015

#

# 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, write to the Free Software Foundation, Inc.,

# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.

use Modern::Perl;

use Carp;

use Test::More;

use C4::Context;

use C4::Items;

use C4::Circulation;

sub verifyItemsInTransit {

    my $C = shift;

    my $S = $C->{stash}->{scenario};

    my $F = $C->{stash}->{feature};

    my $checks = $C->data(); #Get the checks, which might not have manifested itselves to the branchtransfers

    ok(($checks && scalar(@$checks) > 0), "You must give checks as the data");

    #See which checks are supposed to be in the branchtransfers-table, and which are just to clarify intent.

    my @checksInTable;

    foreach my $check (@$checks) {

        my $status = $check->{status};

        push @checksInTable, $check if (not($status) || ($status ne 'no_trfr'));

    }

    ##Check that there is a matching branchtransfer-row for each given test.

    my %testedBranchtransfers; #Collect the branchtransfers here so we can see that we won't accidentally test the same transfer twice,

                               # and can tell which branchtransfers are left untested and shouldn't exist according to the test plan.

    foreach my $check (@checksInTable) {

        my @params; #DEL THIS

        my $itemnumber = C4::Items::GetItemnumberFromBarcode( $check->{barcode} );

        my @transfer = C4::Circulation::GetTransfers($itemnumber);

        ##See if the branchtransfer_id is already tested and fail the test, or add the branchtransfer to the tested group.

         #    Throw an failed test only if the test should fail, don't clutter with meaningless tests.

        ok((0), "Not testing fromBranch '".$check->{fromBranch}."', toBranch '".$check->{toBranch}."' twice. Awsum!")

                if(defined($testedBranchtransfers{$transfer[3]}));

        $testedBranchtransfers{$transfer[3]} = \@transfer; #Store the branchtransfer by id

        last unless ok(($transfer[1] eq $check->{fromBranch} && $transfer[2] eq $check->{toBranch}), "Check: fromBranch '".$check->{fromBranch}."', toBranch '".$check->{toBranch}."'");

    }

    ##!# Check for leaking branchtransfers, eg. unintended side-effects.  #!##

    #Remove all tested branchtransfers from all the transfers in DB, and see if we have some more in the DB. This means that our tests leak branchtransfers we didn't intend to have!

    my $allBranchtransfers = C4::Circulation::GetAllTransfers();

    while (my ($branchtransfer_id, $branchtransferArr) = each(%testedBranchtransfers)) {

        for (my $i=0 ; $i<scalar(@$allBranchtransfers) ; $i++) {

            my $branchTransfer = $allBranchtransfers->[$i];

            if ($branchTransfer->{branchtransfer_id} == $branchtransferArr->[3]) { #If id's match, this branchtransfer is tested.

                splice(@$allBranchtransfers, $i, 1); #Remove array element at position $i

                last;

            }

        }

    }

    #Throw a failed tests for each excess branchtransfer encountered. We never get into this loop if tests work ok.

    foreach my $branchTransfer (@$allBranchtransfers) {

        my $item = C4::Items::GetItem(  $branchTransfer->{itemnumber}  );

        ok((not($branchTransfer)), "Trailing branchtransfer for barcode '".$item->{barcode}."' fromBranch '".$branchTransfer->{frombranch}."' toBranch '".$branchTransfer->{tobranch}."'");

    }

}

##We cannot use the Koha internal API, because then these would be preserved as arrived transfers

#Sometimes the test feature can fail and leave straggler Transfers, which prevent proper clean up. So it is better to just

#remove all Transfers. These tests should be transitive anyway.

sub deleteAllTransfers {

    my $C = shift;

    my $F = $C->{stash}->{feature};

    my $schema = Koha::Database->new()->schema();

    $schema->resultset('Branchtransfer')->search({})->delete_all();

}

1;

package SImpls::Context;

# Copyright Vaara-kirjastot 2015

#

# 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, write to the Free Software Foundation, Inc.,

# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.

use Modern::Perl;

use Carp;

use C4::Context;

sub setKohaContext {

    my $C = shift;

    my $contextHash = $C->{_data}->[0];

    C4::Context->_new_userenv($contextHash->{userenvName} || 'DUMMY SESSION');

    C4::Context->set_userenv(

            0,

            0,

            0,

            $contextHash->{firstName}      || 'firstname',

            $contextHash->{surname}        || 'surname',

            $contextHash->{branchCode}     || 'CPL',

            $contextHash->{branchName}     || 'Centerville Public Library',

            $contextHash->{userFlags}      || 0,

            $contextHash->{userEmail}      || 'noemail@example.com',

            $contextHash->{branchPrinter}  || 'branchPrinter?',

    );

}

1;

package SImpls::FileUtils;

# Copyright Vaara-kirjastot 2015

#

# 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, write to the Free Software Foundation, Inc.,

# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.

use Modern::Perl;

use Carp;

use Test::More;

sub checkRegexpInsideFiles {

    my $C = shift;

    my $data = $C->data;

    ##First cache files to avoid unnecessary file loading

    my %files;

    foreach my $d (@$data) {

        unless ( $files{ $d->{fileName} } ) {

            my $directory = $d->{directory};

            $directory =~ s/\$KOHA_PATH/$ENV{KOHA_PATH}/gsm;

            my $fileContent = File::Slurp::read_file( $directory.$d->{fileName}, {binmode => ':utf8'} )

                                or die "common_stepImpl::checkRegexpInsideFiles():> $!";

            $files{ $d->{fileName} } = $fileContent;

        }

    }

    foreach my $d (@$data) {

        my $fileContent = $files{ $d->{fileName} };

        my $regexp = $d->{recordFindingRegexp};

        last unless ok(($fileContent =~ m/$regexp/u), "File ".$d->{fileName}." matches $regexp");

    }

}

sub findFile {

    my $C = shift;

    my $file = $1;

    $file =~ s/\$KOHA_PATH/$ENV{KOHA_PATH}/gsm;

    ok((-f $file && -r $file), "$file exists and is readable");

    $C->{stash}->{scenario}->{file} = $file;

}

1;

package SImpls::Issues;

# Copyright Vaara-kirjastot 2015

#

# 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, write to the Free Software Foundation, Inc.,

# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.

use Modern::Perl;

use Carp;

use Test::More;

use C4::Circulation;

use t::db_dependent::TestObjects::Issues::IssueFactory;

sub addIssues {

    my $C = shift;

    my $homeOrHoldingbranch = shift;

    die "addIssues():> \$homeOrHoldingbranch must be 'homebranch' or 'holdingbranch'" unless ($homeOrHoldingbranch eq 'homebranch' || $homeOrHoldingbranch eq 'holdingbranch');

    my $S = $C->{stash}->{scenario};

    my $F = $C->{stash}->{feature};

    $S->{issues} = {} unless $S->{issues};

    $F->{issues} = {} unless $F->{issues};

    my $issues = t::db_dependent::TestObjects::Issues::IssueFactory::createTestGroup( $C->data(), undef, $homeOrHoldingbranch );

    while( my ($key, $issue) = each %$issues) {

        $S->{issues}->{ $key } = $issue;

        $F->{issues}->{ $key } = $issue;

    }

}

##We cannot use the Koha internal API, because then these would be put to the deleteditems, deletedbiblio, old_issues, ... -tables

#Sometimes the test feature can fail and leave straggler Issues, which prevent proper clean up. So it is better to just

#remove all Issues. These tests should be transitive anyway.

sub deleteAllIssues {

    my $C = shift;

    my $F = $C->{stash}->{feature};

    my $schema = Koha::Database->new()->schema();

    $schema->resultset('Issue')->search({})->delete_all();

    $schema->resultset('OldIssue')->search({})->delete_all();

}

sub checkInIssues {

    my $C = shift;

    my $S = $C->{stash}->{scenario};

    my $F = $C->{stash}->{feature};

    my $homeOrHoldingbranch = shift;

    die "checkInAllIssues():> \$homeOrHoldingbranch must be 'homebranch' or 'holdingbranch'" unless ($homeOrHoldingbranch eq 'homebranch' || $homeOrHoldingbranch eq 'holdingbranch');

    if (ref $S->{issues} eq 'HASH') {

        while( my ($key, $issue) = each %{$S->{issues}}) {

            my $is = $S->{issues}->{ $key };

            my ($doreturn, $messages, $iteminformation, $borrower) = C4::Circulation::AddReturn( $is->{barcode}, $is->{branchcode} );

            my $debug; #Just here so I can inspect the AddReturn return values with the DBGP-protocol.

        }

    }

    else {

        die "checkInIssues():> No Scenario HASH for Issues!";

    }

}

1;

package SImpls::Items;

# Copyright Vaara-kirjastot 2015

#

# 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, write to the Free Software Foundation, Inc.,

# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.

use Modern::Perl;

use Carp;

use Test::More;

use t::db_dependent::TestObjects::Items::ItemFactory;

sub addItems {

    my $C = shift;

    my $S = $C->{stash}->{scenario};

    my $F = $C->{stash}->{feature};

    $S->{items} = {} unless $S->{items};

    $F->{items} = {} unless $F->{items};

    #Find the biblionumber of the parent Biblios

    my $data = $C->data();

    foreach my $itemHash (@$data) {

        my $biblionumber = $S->{biblios}->{  $itemHash->{biblioisbn}  }->{biblionumber};

        $itemHash->{biblionumber} = $biblionumber;

    }

    my $items = t::db_dependent::TestObjects::Items::ItemFactory::createTestGroup($data, undef);

    while( my ($key, $item) = each %$items) {

        $S->{items}->{ $key } = $item;

        $F->{items}->{ $key } = $item;

    }

}

sub deleteItems {

    my $C = shift;

    my $F = $C->{stash}->{feature};

    t::db_dependent::TestObjects::Items::ItemFactory::deleteTestGroup( $F->{items} );

}

1;

package SImpls::LetterTemplates;

# Copyright Vaara-kirjastot 2015

#

# 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, write to the Free Software Foundation, Inc.,

# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.

use Modern::Perl;

use Carp;

use Test::More;

use t::db_dependent::TestObjects::LetterTemplates::LetterTemplateFactory;

sub addLetterTemplates {

    my $C = shift;

    my $S = $C->{stash}->{scenario};

    my $F = $C->{stash}->{feature};

    $S->{letterTemplates} = {} unless $S->{letterTemplates};

    $F->{letterTemplates} = {} unless $F->{letterTemplates};

    #Split the given message_transport_types-column to separate mtts

    #and create separate letterTemplates for each mtt.

    my $data = $C->data();

    my @letterTemplatesSeparatedMTTs;

    foreach my $lt (@$data) {

        my @mtts = map {my $a = $_; $a =~ s/\s+//gsm; $a;} split(',', $lt->{message_transport_types});

        delete $lt->{message_transport_types};

        foreach my $mtt (@mtts) {

            my %newLt = %$lt; #Clone the messageQueue.

            $newLt{message_transport_type} = $mtt;

            $newLt{content} =~ s/\\n/\n/gsm;

            push @letterTemplatesSeparatedMTTs, \%newLt;

        }

    }

    my $letterTemplates = t::db_dependent::TestObjects::LetterTemplates::LetterTemplateFactory::createTestGroup(\@letterTemplatesSeparatedMTTs, undef);

    while( my ($key, $letterTemplate) = each %$letterTemplates) {

        $S->{letterTemplates}->{ $key } = $letterTemplate;

        $F->{letterTemplates}->{ $key } = $letterTemplate;

    }

}

sub deleteLetterTemplates {

    my $C = shift;

    my $F = $C->{stash}->{feature};

    t::db_dependent::TestObjects::LetterTemplates::LetterTemplateFactory::deleteTestGroup( $F->{letterTemplates} );

}

sub deleteAllLetterTemplates {

    my $schema = Koha::Database->new()->schema();

    $schema->resultset('Letter')->search({})->delete_all();

}

1;

package SImpls::MessageQueues;

# Copyright 2015 Vaara-kirjastot

#

# 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 Carp;

use Test::More;

use Koha::Database;

use C4::Context;

sub addMessageQueues {

    my $C = shift;

    my $letterCode = shift;

    my $messageTransportType = shift;

    my $S = $C->{stash}->{scenario};

    my $F = $C->{stash}->{feature};

    $S->{message_queues} = {} unless $S->{message_queues};

    $F->{message_queues} = {} unless $F->{message_queues};

    foreach my $cardumber (sort keys %{$S->{borrowers}}) {

        my $borrower = $S->{borrowers}->{$cardumber};

        my @repeat;

        foreach my $i ( sort keys %{$S->{issues}} ) {

            my $issue = $S->{issues}->{$i};

            if ( $issue->{borrowernumber} eq $borrower->{borrowernumber} ) {

                my $itemForCurrentBorrower = $S->{items}->{  $issue->{itemnumber}  };

                push @repeat, {items => $itemForCurrentBorrower};

            }

        }

        my $letter = C4::Letters::GetPreparedLetter (

                        module => 'circulation',

                        letter_code => $letterCode,

                        branchcode => $borrower->{branchcode},

                        tables => {borrowers => $borrower},

                        #substitute => $substitute,

                        repeat => { item => \@repeat },

                        message_transport_type => $messageTransportType,

        );

        my $mqHash = {

                        letter                 => $letter,

                        borrowernumber         => $borrower->{borrowernumber},

                        message_transport_type => $messageTransportType,

                        from_address           => C4::Context->preference('KohaAdminEmailAddress'),

                        to_address             => 'dontsend@example.com',

        };

        my $message_queue_id = C4::Letters::EnqueueLetter( $mqHash );

        like($message_queue_id, qr/^\d+$/, "Message enqueued.");

        $S->{message_queues}->{$message_queue_id} = $mqHash;

        $F->{message_queues}->{$message_queue_id} = $mqHash;

    }

}

sub deleteAllMessageQueues {

    my $C = shift;

    my $F = $C->{stash}->{feature};

    my $schema = Koha::Database->new()->schema();

    $schema->resultset('MessageQueue')->search({})->delete_all();

}

sub verifyMessageQueueItems {

    my $C = shift;

    my $S = $C->{stash}->{scenario};

    my $F = $C->{stash}->{feature};

    my $checks = $C->data(); #Get the checks, which might not have manifested itselves to the message_queue_items

    ok(($checks && scalar(@$checks) > 0), "You must give checks as the data");

    #See which checks are supposed to be in the message_queue_item-table, and which are just to clarify intent.

    my @checksInTable;

    foreach my $check (@$checks) {

        my $status = $check->{status};

        push @checksInTable, $check if ($status ne 'not_odue' && $status ne 'no_rule');

    }

    ##Make sure that there are no trailing MessageQueueItems.

    my $schema = Koha::Database->new()->schema();

    my $allMessageQueueItemsCount = $schema->resultset('MessageQueueItem')->search({})->count();

    is($allMessageQueueItemsCount, scalar(@checksInTable), "We should have ".scalar(@checksInTable)." checks for $allMessageQueueItemsCount message_queue_items, with no trailing items.");

    #Expressing the following cannot be comfortably done with DBIx

    #especially since message_queue_items-table should not have foreign key linkings to items and issues-tables.

    my $dbh = C4::Context->dbh();

    my $check_statement = $dbh->prepare(

        "SELECT 1 FROM message_queue_items mi ".

        "LEFT JOIN message_queue mq ON mi.message_id = mq.message_id ".

        "LEFT JOIN borrowers b ON mq.borrowernumber = b.borrowernumber ".

        "LEFT JOIN items i ON mi.itemnumber = i.itemnumber ".

        "LEFT JOIN issues iss ON iss.issue_id = mi.issue_id ".

        "WHERE b.cardnumber = ? AND i.barcode = ? AND mi.branch = ? AND mq.letter_code = ? ".

        "AND mi.letternumber = ? AND mq.status = ?  AND mq.message_transport_type = ? ".

    "");

    ##Check that there is a matching MessageQueueItem for each given test.

    foreach my $check (@checksInTable) {

        my @params;

        push @params, $check->{cardnumber};

        push @params, $check->{barcode};

        push @params, $check->{branch};

        push @params, $check->{lettercode};

        push @params, $check->{letternumber};

        push @params, $check->{status};

        push @params, $check->{transport_type};

        $check_statement->execute( @params );

        my $ok = $check_statement->fetchrow();

        last unless ok(($ok && $ok == 1), "Check: For params @params");

    }

}

sub verifyMessageQueues {

    my $C = shift;

    my $S = $C->{stash}->{scenario};

    my $F = $C->{stash}->{feature};

    my $checks = $C->data(); #Get the checks, which might not have manifested itselves to the message_queues

    ok(($checks && scalar(@$checks) > 0), "You must give checks as the data");

    ##Make sure that there are no trailing MessageQueueItems.

    my $schema = Koha::Database->new()->schema();

    my $allMessageQueuesCount = $schema->resultset('MessageQueue')->search({})->count();

    is($allMessageQueuesCount, scalar(@$checks), "We should have ".scalar(@$checks)." checks for $allMessageQueuesCount message_queue_items, with no trailing items.");

    my @all = $schema->resultset('MessageQueue')->search({});

    foreach my $a ( @all ) {

        print $a->content()."\n";

    }

    if ($checks->[0]->{contentRegexp}) {

        verifyMessageQueuesFromContentRegexp($checks);

    }

    elsif ($checks->[0]->{containedBarcodes}) {

        verifyMessageQueuesFromBarcodes($checks);

    }

    else {

        die "\nverifyMessageQueues():> The MessageQueues-data table must contain column 'barcodes', or 'contentRegexp'.\n".

            "'barcodes' contains comma separated list of barcodes that must be found inside the message_queue.content.\n".

            "'contentRegexp' is a regexp that must match with the message_queue.content.\n";

    }

}

sub verifyMessageQueuesFromBarcodes {

    my ($checks) = @_;

    my $dbh = C4::Context->dbh();

    my $check_statement = $dbh->prepare(

        "SELECT 1 FROM message_queue mq ".

        "LEFT JOIN message_queue_items mqi ON mqi.message_id = mq.message_id ".

        "LEFT JOIN borrowers b ON mq.borrowernumber = b.borrowernumber ".

        "LEFT JOIN items i ON mqi.itemnumber = i.itemnumber ".

        "WHERE b.cardnumber = ? ".

        "AND i.barcode = ? ".

        "AND mq.letter_code = ? ".

        "AND mq.status = ? ".

        "AND mq.message_transport_type = ? ".

    "");

    ##Check that there is a matching MessageQueue for each given test.

    foreach my $check (@$checks) {

        my @barcodes = map {my $a = $_; $a =~ s/\s+//gsm; $a;} split(',',$check->{containedBarcodes});

        foreach my $bc (@barcodes) {

            my @params;

            push @params, $check->{cardnumber};

            push @params, $bc;

            push @params, $check->{lettercode};

            push @params, $check->{status};

            push @params, $check->{transport_type};

            $check_statement->execute( @params );

            my $ok = $check_statement->fetchrow();

            last unless ok(($ok && $ok == 1), "Check: For params @params");

        }

    }

}

sub verifyMessageQueuesFromContentRegexp {

    my ($checks) = @_;

    my $dbh = C4::Context->dbh();

    my $check_statement = $dbh->prepare(

        "SELECT 1 FROM message_queue mq ".

        "LEFT JOIN borrowers b ON mq.borrowernumber = b.borrowernumber ".

        "WHERE b.cardnumber = ? ".

        "AND mq.letter_code = ? ".

        "AND mq.status = ? ".

        "AND mq.message_transport_type = ? ".

        "AND mq.content REGEXP ? ".

    "");

    ##Check that there is a matching MessageQueue for each given test.

    foreach my $check (@$checks) {

        my @params;

        push @params, $check->{cardnumber};

        push @params, $check->{lettercode};

        push @params, $check->{status};

        push @params, $check->{transport_type};

        push @params, $check->{contentRegexp};

        $check_statement->execute( @params );

        my $ok = $check_statement->fetchrow();

        last unless ok(($ok && $ok == 1), "Check: For params @params");

    }

}

1;

package SImpls::ScriptRunning;

# Copyright Vaara-kirjastot 2015

#

# 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, write to the Free Software Foundation, Inc.,

# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.

use Modern::Perl;

use Carp;

use Test::More;

sub runScript {

    my $C = shift;

    my $scriptPath = $C->matches()->[0];

    $scriptPath =~ s/\$KOHA_PATH/$ENV{KOHA_PATH}/gsm;

    my $params = $C->data();

    my @args = ($scriptPath);

    while (my ($param, $value) = each(%{$params->[0]})) {

        push @args, "$param $value";

    }

    my $retval = system("@args");

    ok(($retval == 0), "System call\n@args\nsucceeded");

}

1;

package SImpls::SystemPreferences;

# Copyright Vaara-kirjastot 2015

#

# 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, write to the Free Software Foundation, Inc.,

# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.

use Modern::Perl;

use Carp;

use Test::More;

use C4::Context;

sub setSystemPreferences {

    my $C = shift;

    my $data = $C->data();

    foreach my $syspref (@$data) {

        setSystemPreference($C, $syspref->{systemPreference}, $syspref->{value});

    }

}

sub setSystemPreference {

    my ($C, $key, $value) = @_;

    my $S = $C->{stash}->{scenario};

    my $F = $C->{stash}->{feature};

    $S->{originalSystempreferences} = {} unless $S->{originalSystempreferences};

    $F->{originalSystempreferences} = {} unless $F->{originalSystempreferences};

    if ($S->{originalSystempreferences}->{$key} && $F->{originalSystempreferences}->{$key}) {

        #This syspref has been set from somewhere already, so let's not remove the stored original value.

    }

    else {

        my $oldSysprefValue = C4::Context->preference($key);

        $S->{originalSystempreferences}->{$key} = $oldSysprefValue;

        $F->{originalSystempreferences}->{$key} = $oldSysprefValue;

    }

    C4::Context->set_preference($key, $value);

}

sub rollbackSystemPreferences {

    my $C = shift;

    my $F = $C->{stash}->{feature};

    if (ref $F->{originalSystempreferences} eq 'HASH') {

        while (my ($syspref, $value) = each(%{$F->{originalSystempreferences}})) {

            C4::Context->set_preference($syspref, $value);

        }

    }

}

1;

#!/usr/bin/perl

# Copyright Vaara-kirjastot 2015

#

# 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, write to the Free Software Foundation, Inc.,

# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.

use Modern::Perl;

use Test::More;

use Test::BDD::Cucumber::StepFile;

use Test::BDD::Cucumber::Loader;

use Test::BDD::Cucumber::Harness::TestBuilder;

use Test::BDD::Cucumber::Model::TagSpec;

use Getopt::Long qw(:config no_ignore_case);

my $help;

my $featureRegexp;

my $verbose;

my @tags;

GetOptions(

    'h|help'                      => \$help,

    'f|featureRegexp:s'           => \$featureRegexp,

    'v|verbose:i'                 => \$verbose,

    't|tags:s'                    => \@tags,

);

my $usage = <<USAGE;

perl runCucumberTests.t --verbose 2 --featureRegexp "overdues" --tags \@overdues

Executes all Cucumber tests. You can narrow down the tests to run using --tags

and --featureRegexp, and make various testing configurations with them.

  --tags                See https://github.com/cucumber/cucumber/wiki/Tags

                        ~\@tag is not supported, only \@tag.

                        Only runs the scenarios/features these tags are given to.

                        This is quite useful when developing, because you can

                        easily narrow down which scenarios to execute amidst

                        features containing lots of expensive tests.

  --featureRegexp       Will run only features whose feature description's first

                        line matches the given escaped regexp.

                        Prefer using tags if possible, since that is the Cucumber-way.

USAGE

if ($help) {

    print $usage;

    exit 0;

}

if ($verbose) {

    $ENV{CUCUMBER_VERBOSE} = $verbose;

}

#Set the default Koha context

use C4::Context;

C4::Context->_new_userenv('DUMMY SESSION');

C4::Context->set_userenv(0,0,0,'firstname','surname', 'CPL', 'Library 1', 0, '', '');

######  #  #  #  #  #  #  #  ######

###   Run the Cucumber tests.   ###

######  #  #  #  #  #  #  #  ######

my ( $executor, @features ) = Test::BDD::Cucumber::Loader->load( '.' );

if ($featureRegexp) {

    #Pick only the needed feature

    my @filteredFeatures;

    for (my $i=0 ; $i<@features ; $i++) {

        my $feature = $features[$i];

        push @filteredFeatures, ($features[$i]) if $feature->name() =~ m/$featureRegexp/i;

    }

    @features = @filteredFeatures;

}

my $tagSet;

if (scalar(@tags)) {

    #Load given tags.

    for (my $i=0 ; $i<@tags ; $i++) {

        $tags[$i] =~ s/[@]//;

    }

    $tagSet = Test::BDD::Cucumber::Model::TagSpec->new({

       tags => [ and => @tags ],

    });

}

my $harness = Test::BDD::Cucumber::Harness::TestBuilder->new({});

$executor->execute( $_, $harness, $tagSet ) for @features;

done_testing;

#!/usr/bin/perl

# Copyright Vaara-kirjastot 2015

#

# 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, write to the Free Software Foundation, Inc.,

# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.

use Modern::Perl;

use Test::More;

use Test::BDD::Cucumber::StepFile;

use SImpls::Accountlines;

Given qr/there are no previous fines/, sub {

    SImpls::Accountlines::deleteAllFines(@_);

};

Then qr/the following fines are encumbered on naughty borrowers/, sub {

    SImpls::Accountlines::checkAccountlines( @_ );

};

#!/usr/bin/perl

# Copyright Vaara-kirjastot 2015

#

# 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, write to the Free Software Foundation, Inc.,

# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.

use Modern::Perl;

use Test::More;

use Test::BDD::Cucumber::StepFile;

use SImpls::Biblios;

Given qr/a set of Biblios/, sub {

    SImpls::Biblios::addBiblios(@_);

};

#!/usr/bin/perl

# Copyright Vaara-kirjastot 2015

#

# 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, write to the Free Software Foundation, Inc.,

# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.

use Modern::Perl;

use Test::More;

use Test::BDD::Cucumber::StepFile;

use SImpls::Borrowers;

Given qr/a set of Borrowers/, sub {

    SImpls::Borrowers::addBorrowers(@_);

};

Then qr/the following borrowers are debarred/, sub {

    SImpls::Borrowers::checkDebarments( @_ );

};

#!/usr/bin/perl

# Copyright Vaara-kirjastot 2015

#

# 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, write to the Free Software Foundation, Inc.,

# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.

use Modern::Perl;

use Test::More;

use Test::BDD::Cucumber::StepFile;

use SImpls::BranchTransfers;

Then qr/the following Items are in-transit/, sub {

    SImpls::BranchTransfers::verifyItemsInTransit(@_);

};

#!/usr/bin/perl

# Copyright Vaara-kirjastot 2015

#

# 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, write to the Free Software Foundation, Inc.,

# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.

use Modern::Perl;

use Test::More;

use Test::BDD::Cucumber::StepFile;

When qr/all scenarios are executed, tear down database changes./, sub {

    my $C = shift;

    #Forcibly make a new schema, because the existing schema might get timeout and cause this tear down step to fail.

    #Koha::Database->new_schema() just wraps around the C4::Context->dbh() which has already died :(

    #So we must get the new schema forcibly.

    my $schema = Koha::Schema->connect( sub { C4::Context->_new_dbh() }, { unsafe => 1 } );

    my $db = Koha::Database->new();

    $db->set_schema($schema);

    SImpls::BranchTransfers::deleteAllTransfers($C);

    SImpls::Issues::deleteAllIssues($C);

    SImpls::Borrowers::deleteBorrowers($C);

    SImpls::Items::deleteItems($C);

    SImpls::Accountlines::deleteAllFines($C);

    SImpls::Biblios::deleteBiblios($C);

    SImpls::MessageQueues::deleteAllMessageQueues($C);

    SImpls::LetterTemplates::deleteLetterTemplates($C);

    SImpls::SystemPreferences::rollbackSystemPreferences($C);

};

#!/usr/bin/perl

# Copyright Vaara-kirjastot 2015

#

# 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, write to the Free Software Foundation, Inc.,

# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.

use Modern::Perl;

use Test::More;

use Test::BDD::Cucumber::StepFile;

use SImpls::Context;

Given qr/the Koha-context, we can proceed with other scenarios./, sub {

    my $C = shift;

    SImpls::Context::setKohaContext($C);

};

#!/usr/bin/perl

# Copyright Vaara-kirjastot 2015

#

# 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, write to the Free Software Foundation, Inc.,

# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.

use Modern::Perl;

use Test::More;

use Test::BDD::Cucumber::StepFile;

use SImpls::FileUtils;

Given qr/a file at '(.*?)'/, sub {

    SImpls::FileUtils::findFile( @_ );

};

Then qr/I have the following text inside these files/, sub {

    SImpls::FileUtils::checkRegexpInsideFiles( @_ );

};

#!/usr/bin/perl

# Copyright Vaara-kirjastot 2015

#

# 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, write to the Free Software Foundation, Inc.,

# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.

use Modern::Perl;

use Test::More;

use Test::BDD::Cucumber::StepFile;

use SImpls::Issues;

Given qr/there are no previous issues/, sub {

    SImpls::Issues::deleteAllIssues(@_);

};

Given qr/a set of overdue Issues, checked out from the Items' current holdingbranch/, sub {

    my $C = shift;

    SImpls::Issues::addIssues($C, 'holdingbranch');

};

Given qr/a set of Issues, checked out from the Items' current '(\w+)'/, sub {

    my $C = shift;

    SImpls::Issues::addIssues($C, $C->matches()->[0]);

};

When qr/checked-out Items are checked-in to their '(\w+)'/, sub {

    my $C = shift;

    SImpls::Issues::checkInIssues($C, $C->matches()->[0]);

};

#!/usr/bin/perl

# Copyright Vaara-kirjastot 2015

#

# 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, write to the Free Software Foundation, Inc.,

# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.

use Modern::Perl;

use Test::More;

use Test::BDD::Cucumber::StepFile;

use SImpls::Items;

Given qr/a set of Items/, sub {

    SImpls::Items::addItems(@_);

};

#!/usr/bin/perl

# Copyright Vaara-kirjastot 2015

#

# 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, write to the Free Software Foundation, Inc.,

# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.

use Modern::Perl;

use Test::More;

use Test::BDD::Cucumber::StepFile;

use SImpls::LetterTemplates;

Given qr/a set of letter templates/, sub {

    SImpls::LetterTemplates::addLetterTemplates(@_);

};

#!/usr/bin/perl

# Copyright Vaara-kirjastot 2015

#

# 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, write to the Free Software Foundation, Inc.,

# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.

use Modern::Perl;

use Test::More;

use Test::BDD::Cucumber::StepFile;

use SImpls::MessageQueues;

Given qr/a bunch of message_queue-rows using letter code '(.*?)' and message_transport_type '(.*?)' based on the given Borrowers, Biblios, Items and Issues/, sub {

    my $C = shift;

    my $letterCode = $1;

    my $messageTransportType = $2;

    SImpls::MessageQueues::addMessageQueues($C, $letterCode, $messageTransportType);

};

Then qr/I have the following enqueued message queue items/, sub {

    SImpls::MessageQueues::verifyMessageQueueItems( @_ );

};

Then qr/I have the following message queue notices/, sub {

    SImpls::MessageQueues::verifyMessageQueues( @_ );

};

#!/usr/bin/perl

# Copyright Vaara-kirjastot 2015

#

# 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, write to the Free Software Foundation, Inc.,

# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.

use Modern::Perl;

use Test::More;

use Test::BDD::Cucumber::StepFile;

use SImpls::ScriptRunning;

When qr/I run '(.*?)'-script with the following parameters/, sub {

    SImpls::ScriptRunning::runScript( @_ );

};

#!/usr/bin/perl

# Copyright Vaara-kirjastot 2015

#

# 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, write to the Free Software Foundation, Inc.,

# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.

use Modern::Perl;

use Test::More;

use Test::BDD::Cucumber::StepFile;

use SImpls::SystemPreferences;

Given qr/the following system preferences/, sub {

    SImpls::SystemPreferences::setSystemPreferences( @_ );

};