Attachment #107601 for bug #22343

View | Details | Raw Unified | Return to bug 22343
Collapse All | Expand All




package Koha::SMTP::Server;

# 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 Koha::Database;
use Koha::Exceptions::Object;
use Koha::SMTP::Servers;

use base qw(Koha::Object);

=head1 NAME

Koha::SMTP::Server - Koha SMTP Server Object class

=head1 API

=head2 Class methods

=head3 store

    my $server = Koha::SMTP::Server->new({...})->store;
    $server->set({...})->store;

Overloaded I<store> method that takes care of checking unicity of the
default server (i.e. when library_id IS NULL).

FIXME: Replace with a CHECK constraint when the feature is available.

=cut

sub store {
    my ( $self, $params ) = @_;

    if ( $self->in_storage ) {

        # update
        if ( !defined $self->library_id ) {

            # trying to set a default, check manually
            # until the DB can handle it
            Koha::Exceptions::Object::DuplicateID->throw( duplicate_id => 'library_id' )
              if Koha::SMTP::Servers->search(
                { library_id => undef, id => { '!=' => $self->id } } )->count > 0;
        }
    }
    else {
        # new
        if ( !defined $self->library_id ) {

            # trying to set a default, check manually
            # until the DB can handle it
            Koha::Exceptions::Object::DuplicateID->throw( duplicate_id => 'library_id' )
              if Koha::SMTP::Servers->search( { library_id => undef } )->count > 0;
        }
    }

    return $self->SUPER::store;
}

=head3 is_default

    my $is_default = $server->is_default

Helper method to determine if the server is the default one

=cut

sub is_default {
    my ($self) = @_;

    return (defined $self->library_id) ? 0 : 1;
}

=head3 library

Returns the Koha::Library object linked to the SMTP server.

=cut

sub library {
    my ( $self ) = @_;

    my $library_rs = $self->_result->library;
    return unless $library_rs;
    return Koha::Library->_new_from_dbic($self->_result->library);
}

=head3 to_api_mapping

This method returns the mapping for representing a Koha::SMTP::Server object
on the API.

=cut

sub to_api_mapping {
    return {
        id => 'smtp_server_id'
    };
}

=head2 Internal methods

=head3 _type

Return type of Object relating to Schema ResultSet

=cut

sub _type {
    return 'SmtpServer';
}

1;




package Koha::SMTP::Servers;

# 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 Koha::Database;
use Koha::Exceptions;

use Koha::SMTP::Server;

use base qw(Koha::Objects);

=head1 NAME

Koha::SMTP::Servers - Koha SMTP Server Object set class

=head1 API

=head2 Class methods

=head3 get_effective_server

    my $server = Koha::SMTP::Servers->get_effective_server({ library => $library });

Returns a I<Koha::SMTP::Server> representing the effective configured SMTP for the library.

=cut

sub get_effective_server {
    my ($self, $args) = @_;

    my $library = $args->{library};

    Koha::Exceptions::MissingParameter->throw('Mandatory parameter missing: library')
        unless $library;

    my $servers_rs = Koha::SMTP::Servers->search({ library_id => $library->branchcode });
    if ( $servers_rs->count > 0 ) {
        return $servers_rs->next;
    }

    return $self->get_default;
}

=head3 get_default

    my $server = Koha::SMTP::Servers->new->get_default;

Returns the default I<Koha::SMTP::Server> object.

=cut

sub get_default {
    my ($self) = @_;

    my $servers_rs = $self->search({ library_id => undef });

    my $server;
    if ($servers_rs->count > 0) {
        $server = $servers_rs->next;
    }
    else {
        $server = Koha::SMTP::Server->new( $self->default_setting );
    }

    return $server;
}

=head3 set_default

    my $server = Koha::SMTP::Servers->new->set_default;

Set the default I<Koha::SMTP::Server> server, and returns it.

=cut

sub set_default {
    my ($self, $params) = @_;

    Koha::Exceptions::BadParameter->throw( 'library_id must be undef when setting the default SMTP server' )
        if defined $params->{library_id};

    my $smtp_server;
    $self->_resultset()->result_source->schema->txn_do( sub {

        # Delete existing default
        $self->search({ library_id => undef })->delete;

       $smtp_server = Koha::SMTP::Server->new($params)->store;
    });

    return $smtp_server;
}

=head3 set_library_server

    my $server = Koha::SMTP::Servers->new->set_library_server(
        {
            name       => $name,
            library_id => $library->id,
            host       => $smtp_host,
            port       => $smtp_port,
            timeout    => $smtp_timeout,
            ssl        => 1,
            user_name  => $user_name,
            password   => $password
        }
    );

Set the I<Koha::SMTP::Server> server for a library, and return it.

=cut

sub set_library_server {
    my ( $self, $params ) = @_;

    Koha::Exceptions::MissingParameter->throw(
        'Mandatory parameter missing: library_id')
      unless $params->{library_id};

    my $smtp_server;
    $self->_resultset()->result_source->schema->txn_do( sub {
        # Delete existing default
        $self->search({ library_id => $params->{library_id} })->delete;

        $smtp_server = Koha::SMTP::Server->new($params)->store;
    });

    return $smtp_server;
}

=head2 Internal methods

=head3 _type

Return type of object, relating to Schema ResultSet

=cut

sub _type {
    return 'SmtpServer';
}

=head3 default_setting

    my $hash = Koha::SMTP::Servers::default_setting;

Returns the default setting that is to be used when no user-defined default
SMTP server is provided

=cut

sub default_setting {
    return {
        name       => 'localhost',
        library_id => undef,
        host       => 'localhost',
        port       => 25,
        timeout    => 120,
        ssl        => 0,
        user_name  => undef,
        password   => undef
    };
}

=head3 object_class

Return object class

=cut

sub object_class {
    return 'Koha::SMTP::Server';
}

1;




#!/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 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 Test::More tests => 2;
use Test::Exception;
use Test::Warn;

use Koha::SMTP::Servers;

use t::lib::TestBuilder;
use t::lib::Mocks;

my $schema  = Koha::Database->new->schema;
my $builder = t::lib::TestBuilder->new;

subtest 'is_default() tests' => sub {

    plan tests => 2;

    $schema->storage->txn_begin;

    Koha::SMTP::Servers->search->delete;

    my $default_server = $builder->build_object(
        {
            class => 'Koha::SMTP::Servers',
            value => {
                library_id => undef
            }
        }
    );

    my $library = $builder->build_object( { class => 'Koha::Libraries' } );
    my $library_specific_server = $builder->build_object(
        {
            class => 'Koha::SMTP::Servers',
            value => {
                library_id => $library->branchcode
            }
        }
    );

    ok( $default_server->is_default, 'Server is the default one' );
    ok( !$library_specific_server->is_default,
        'Server is not the default one' );

    $schema->storage->txn_rollback;
};

subtest 'store() tests' => sub {

    plan tests => 4;

    $schema->storage->txn_begin;

    Koha::SMTP::Servers->search->delete;

    my $default_server = Koha::SMTP::Server->new(
        {
            library_id => undef,
            name       => 'Default SMTP server'
        }
    )->store;

    my $library = $builder->build_object( { class => 'Koha::Libraries' } );
    my $library_specific_server = Koha::SMTP::Server->new(
        {
            library_id => $library->id,
            name       => 'Library-specific SMTP server'
        }
    )->store;

    warning_like
        {
            throws_ok
                { Koha::SMTP::Server->new(
                    {
                        library_id => $library->id,
                        name       => 'Some fake name'
                    }
                )->store; }
                'Koha::Exceptions::Object::DuplicateID',
                'Cannot define two servers for the same library';
        }
        qr/DBI Exception: DBD::mysql::st execute failed: Duplicate entry/,
        'Warning is printed';

    throws_ok
        { Koha::SMTP::Server->new(
            {
                library_id => undef,
                name       => 'Some fake name'
            }
        )->store; }
        'Koha::Exceptions::Object::DuplicateID',
        'Cannot define two default SMTP servers';

    $default_server->set({ name => 'New name' })->store;
    $default_server->discard_changes;

    is( $default_server->name, 'New name', 'Default server updated correctly' );

    $schema->storage->txn_rollback;
};




#!/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 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 Test::More tests => 4;
use Test::Exception;

use Koha::SMTP::Servers;

use t::lib::TestBuilder;
use t::lib::Mocks;

my $schema  = Koha::Database->new->schema;
my $builder = t::lib::TestBuilder->new;

subtest 'get_default() tests' => sub {

    plan tests => 3;

    $schema->storage->txn_begin;

    Koha::SMTP::Servers->search->delete;

    my $default_server = $builder->build_object(
        {
            class => 'Koha::SMTP::Servers',
            value => {
                library_id => undef
            }
        }
    );

    my $library = $builder->build_object( { class => 'Koha::Libraries' } );
    my $library_specific_server = $builder->build_object(
        {
            class => 'Koha::SMTP::Servers',
            value => {
                library_id => $library->branchcode
            }
        }
    );

    my $servers = Koha::SMTP::Servers->new;
    my $server  = $servers->get_default;
    is( $server->id, $default_server->id,
        'The default server is correctly retrieved' );

    # Delete the default server
    $server->delete;

    # Get the default
    $default_server = $servers->get_default;
    is( ref($default_server), 'Koha::SMTP::Server',
        'An object of the right type is returned' );

    my $unblessed_server = $default_server->unblessed;
    delete $unblessed_server->{id};
    is_deeply(
        $unblessed_server,
        Koha::SMTP::Servers::default_setting,
        'The default setting is returned if no user-defined default'
    );

    $schema->storage->txn_rollback;
};

subtest 'set_default() tests' => sub {

    plan tests => 4;

    $schema->storage->txn_begin;

    Koha::SMTP::Servers->search->delete;

    my $default_server = $builder->build_object(
        {
            class => 'Koha::SMTP::Servers',
            value => {
                library_id => undef
            }
        }
    );

    throws_ok {
        Koha::SMTP::Servers->new->set_default(
            {
                name       => 'A new default',
                library_id => 'Whatever',
            }
        );
    }
    'Koha::Exceptions::BadParameter',
'Exception thrown when trying to set default SMTP server with a library_id';

    is(
        "$@",
        'library_id must be undef when setting the default SMTP server',
        'Exception message is clear'
    );

    my $new_default = Koha::SMTP::Servers->new->set_default(
        {
            name       => 'A new default',
            library_id => undef,
        }
    );

    is( ref($new_default), 'Koha::SMTP::Server', 'Type is correct' );
    is(
        $new_default->id,
        Koha::SMTP::Servers->get_default->id,
        'Default SMTP server is correctly set'
    );

    $schema->storage->txn_rollback;
};

subtest 'get_effective_server() tests' => sub {

    plan tests => 4;

    $schema->storage->txn_begin;

    Koha::SMTP::Servers->search->delete;

    my $library = $builder->build_object( { class => 'Koha::Libraries' } );

    my $default_server = $builder->build_object(
        {
            class => 'Koha::SMTP::Servers',
            value => {
                library_id => undef
            }
        }
    );

    throws_ok { Koha::SMTP::Servers->new->get_effective_server() }
    'Koha::Exceptions::MissingParameter', 'Exception thrown';

    is( "$@", 'Mandatory parameter missing: library' );

    is(
        Koha::SMTP::Servers->new->get_effective_server(
            { library => $library }
        )->id,
        $default_server->id,
        'Fallback default server retrieved'
    );

    my $specific_server = $builder->build_object(
        {
            class => 'Koha::SMTP::Servers',
            value => {
                library_id => $library->branchcode
            }
        }
    );

    is(
        Koha::SMTP::Servers->new->get_effective_server(
            { library => $library }
        )->id,
        $specific_server->id,
        'Library specific server retrieved'
    );

    $schema->storage->txn_rollback;
};

subtest 'set_library_server() tests' => sub {

    plan tests => 6;

    $schema->storage->txn_begin;

    Koha::SMTP::Servers->search->delete;

    my $library = $builder->build_object( { class => 'Koha::Libraries' } );

    my $default_server = $builder->build_object(
        {
            class => 'Koha::SMTP::Servers',
            value => {
                library_id => undef
            }
        }
    );

    is(
        Koha::SMTP::Servers->new->get_effective_server(
            { library => $library }
        )->id,
        $default_server->id,
        'Fallback default server retrieved'
    );

    my $specific_server = Koha::SMTP::Servers->new->set_library_server(
        {
            name       => 'Specific server 1',
            library_id => $library->id
        }
    );

    is(
        Koha::SMTP::Servers->new->get_effective_server(
            { library => $library }
        )->id,
        $specific_server->id,
        'Library specific server retrieved'
    );

    throws_ok {
        Koha::SMTP::Servers->new->set_library_server(
            {
                name => 'Specific server 2'
            }
        );
    }
    'Koha::Exceptions::MissingParameter',
      'Exception thrown on missing parameter';

    is( "$@", 'Mandatory parameter missing: library_id' );

    $specific_server = Koha::SMTP::Servers->new->set_library_server(
        {
            name       => 'Specific server 2',
            library_id => $library->id
        }
    );

    is(
        Koha::SMTP::Servers->new->get_effective_server(
            { library => $library }
        )->id,
        $specific_server->id,
        'New library specific server retrieved'
    );

    is( Koha::SMTP::Servers->search( { library_id => $library->id } )->count,
        1, 'Only one SMTP server set' );

    $schema->storage->txn_rollback;
};

Return to bug 22343

Line 0 Link Here

(-)a/Koha/SMTP/Server.pm (+128 lines)
		1	package Koha::SMTP::Server;
		2
		3	# This file is part of Koha.
		4	#
		5	# Koha is free software; you can redistribute it and/or modify it
		6	# under the terms of the GNU General Public License as published by
		7	# the Free Software Foundation; either version 3 of the License, or
		8	# (at your option) any later version.
		9	#
		10	# Koha is distributed in the hope that it will be useful, but
		11	# WITHOUT ANY WARRANTY; without even the implied warranty of
		12	# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
		13	# GNU General Public License for more details.
		14	#
		15	# You should have received a copy of the GNU General Public License
		16	# along with Koha; if not, see <http://www.gnu.org/licenses>.
		17
		18	use Modern::Perl;
		19
		20	use Koha::Database;
		21	use Koha::Exceptions::Object;
		22	use Koha::SMTP::Servers;
		23
		24	use base qw(Koha::Object);
		25
		26	=head1 NAME
		27
		28	Koha::SMTP::Server - Koha SMTP Server Object class
		29
		30	=head1 API
		31
		32	=head2 Class methods
		33
		34	=head3 store
		35
		36	my $server = Koha::SMTP::Server->new({...})->store;
		37	$server->set({...})->store;
		38
		39	Overloaded I<store> method that takes care of checking unicity of the
		40	default server (i.e. when library_id IS NULL).
		41
		42	FIXME: Replace with a CHECK constraint when the feature is available.
		43
		44	=cut
		45
		46	sub store {
		47	my ( $self, $params ) = @_;
		48
		49	if ( $self->in_storage ) {
		50
		51	# update
		52	if ( !defined $self->library_id ) {
		53
		54	# trying to set a default, check manually
		55	# until the DB can handle it
		56	Koha::Exceptions::Object::DuplicateID->throw( duplicate_id => 'library_id' )
		57	if Koha::SMTP::Servers->search(
		58	{ library_id => undef, id => { '!=' => $self->id } } )->count > 0;
		59	}
		60	}
		61	else {
		62	# new
		63	if ( !defined $self->library_id ) {
		64
65	# trying to set a default, check manually
66	# until the DB can handle it
67	Koha::Exceptions::Object::DuplicateID->throw( duplicate_id => 'library_id' )
68	if Koha::SMTP::Servers->search( { library_id => undef } )->count > 0;
69	}
70	}
71
72	return $self->SUPER::store;
73	}
74
75	=head3 is_default
76
77	my $is_default = $server->is_default
78
79	Helper method to determine if the server is the default one
80
81	=cut
82
83	sub is_default {
84	my ($self) = @_;
85
86	return (defined $self->library_id) ? 0 : 1;
87	}
88
89	=head3 library
90
91	Returns the Koha::Library object linked to the SMTP server.
92
93	=cut
94
95	sub library {
96	my ( $self ) = @_;
97
98	my $library_rs = $self->_result->library;
99	return unless $library_rs;
100	return Koha::Library->_new_from_dbic($self->_result->library);
101	}
102
103	=head3 to_api_mapping
104
105	This method returns the mapping for representing a Koha::SMTP::Server object
106	on the API.
107
108	=cut
109
110	sub to_api_mapping {
111	return {
112	id => 'smtp_server_id'
113	};
114	}
115
116	=head2 Internal methods
117
118	=head3 _type
119
120	Return type of Object relating to Schema ResultSet
121
122	=cut
123
124	sub _type {
125	return 'SmtpServer';
126	}
127
128	1;

Line 0 Link Here

(-)a/Koha/SMTP/Servers.pm (+190 lines)
		1	package Koha::SMTP::Servers;
		2
		3	# This file is part of Koha.
		4	#
		5	# Koha is free software; you can redistribute it and/or modify it
		6	# under the terms of the GNU General Public License as published by
		7	# the Free Software Foundation; either version 3 of the License, or
		8	# (at your option) any later version.
		9	#
		10	# Koha is distributed in the hope that it will be useful, but
		11	# WITHOUT ANY WARRANTY; without even the implied warranty of
		12	# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
		13	# GNU General Public License for more details.
		14	#
		15	# You should have received a copy of the GNU General Public License
		16	# along with Koha; if not, see <http://www.gnu.org/licenses>.
		17
		18	use Modern::Perl;
		19
		20	use Koha::Database;
		21	use Koha::Exceptions;
		22
		23	use Koha::SMTP::Server;
		24
		25	use base qw(Koha::Objects);
		26
		27	=head1 NAME
		28
		29	Koha::SMTP::Servers - Koha SMTP Server Object set class
		30
		31	=head1 API
		32
		33	=head2 Class methods
		34
		35	=head3 get_effective_server
		36
		37	my $server = Koha::SMTP::Servers->get_effective_server({ library => $library });
		38
		39	Returns a I<Koha::SMTP::Server> representing the effective configured SMTP for the library.
		40
		41	=cut
		42
		43	sub get_effective_server {
		44	my ($self, $args) = @_;
		45
		46	my $library = $args->{library};
		47
		48	Koha::Exceptions::MissingParameter->throw('Mandatory parameter missing: library')
		49	unless $library;
		50
		51	my $servers_rs = Koha::SMTP::Servers->search({ library_id => $library->branchcode });
		52	if ( $servers_rs->count > 0 ) {
		53	return $servers_rs->next;
		54	}
		55
		56	return $self->get_default;
		57	}
		58
		59	=head3 get_default
		60
		61	my $server = Koha::SMTP::Servers->new->get_default;
		62
		63	Returns the default I<Koha::SMTP::Server> object.
		64
65	=cut
66
67	sub get_default {
68	my ($self) = @_;
69
70	my $servers_rs = $self->search({ library_id => undef });
71
72	my $server;
73	if ($servers_rs->count > 0) {
74	$server = $servers_rs->next;
75	}
76	else {
77	$server = Koha::SMTP::Server->new( $self->default_setting );
78	}
79
80	return $server;
81	}
82
83	=head3 set_default
84
85	my $server = Koha::SMTP::Servers->new->set_default;
86
87	Set the default I<Koha::SMTP::Server> server, and returns it.
88
89	=cut
90
91	sub set_default {
92	my ($self, $params) = @_;
93
94	Koha::Exceptions::BadParameter->throw( 'library_id must be undef when setting the default SMTP server' )
95	if defined $params->{library_id};
96
97	my $smtp_server;
98	$self->_resultset()->result_source->schema->txn_do( sub {
99
100	# Delete existing default
101	$self->search({ library_id => undef })->delete;
102
103	$smtp_server = Koha::SMTP::Server->new($params)->store;
104	});
105
106	return $smtp_server;
107	}
108
109	=head3 set_library_server
110
111	my $server = Koha::SMTP::Servers->new->set_library_server(
112	{
113	name => $name,
114	library_id => $library->id,
115	host => $smtp_host,
116	port => $smtp_port,
117	timeout => $smtp_timeout,
118	ssl => 1,
119	user_name => $user_name,
120	password => $password
121	}
122	);
123
124	Set the I<Koha::SMTP::Server> server for a library, and return it.
125
126	=cut
127
128	sub set_library_server {
129	my ( $self, $params ) = @_;
130
131	Koha::Exceptions::MissingParameter->throw(
132	'Mandatory parameter missing: library_id')
133	unless $params->{library_id};
134
135	my $smtp_server;
136	$self->_resultset()->result_source->schema->txn_do( sub {
137	# Delete existing default
138	$self->search({ library_id => $params->{library_id} })->delete;
139
140	$smtp_server = Koha::SMTP::Server->new($params)->store;
141	});
142
143	return $smtp_server;
144	}
145
146	=head2 Internal methods
147
148	=head3 _type
149
150	Return type of object, relating to Schema ResultSet
151
152	=cut
153
154	sub _type {
155	return 'SmtpServer';
156	}
157
158	=head3 default_setting
159
160	my $hash = Koha::SMTP::Servers::default_setting;
161
162	Returns the default setting that is to be used when no user-defined default
163	SMTP server is provided
164
165	=cut
166
167	sub default_setting {
168	return {
169	name => 'localhost',
170	library_id => undef,
171	host => 'localhost',
172	port => 25,
173	timeout => 120,
174	ssl => 0,
175	user_name => undef,
176	password => undef
177	};
178	}
179
180	=head3 object_class
181
182	Return object class
183
184	=cut
185
186	sub object_class {
187	return 'Koha::SMTP::Server';
188	}
189
190	1;

Line 0 Link Here

(-)a/t/db_dependent/Koha/SMTP/Server.t (+120 lines)
		1	#!/usr/bin/perl
		2
		3	# This file is part of Koha.
		4	#
		5	# Koha is free software; you can redistribute it and/or modify it
		6	# under the terms of the GNU General Public License as published by
		7	# the Free Software Foundation; either version 3 of the License, or
		8	# (at your option) any later version.
		9	#
		10	# Koha is distributed in the hope that it will be useful, but
		11	# WITHOUT ANY WARRANTY; without even the implied warranty of
		12	# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
		13	# GNU General Public License for more details.
		14	#
		15	# You should have received a copy of the GNU General Public License
		16	# along with Koha; if not, see <http://www.gnu.org/licenses>.
		17
		18	use Modern::Perl;
		19
		20	use Test::More tests => 2;
		21	use Test::Exception;
		22	use Test::Warn;
		23
		24	use Koha::SMTP::Servers;
		25
		26	use t::lib::TestBuilder;
		27	use t::lib::Mocks;
		28
		29	my $schema = Koha::Database->new->schema;
		30	my $builder = t::lib::TestBuilder->new;
		31
		32	subtest 'is_default() tests' => sub {
		33
		34	plan tests => 2;
		35
		36	$schema->storage->txn_begin;
		37
		38	Koha::SMTP::Servers->search->delete;
		39
		40	my $default_server = $builder->build_object(
		41	{
		42	class => 'Koha::SMTP::Servers',
		43	value => {
		44	library_id => undef
		45	}
		46	}
		47	);
		48
		49	my $library = $builder->build_object( { class => 'Koha::Libraries' } );
		50	my $library_specific_server = $builder->build_object(
		51	{
		52	class => 'Koha::SMTP::Servers',
		53	value => {
		54	library_id => $library->branchcode
		55	}
		56	}
		57	);
		58
		59	ok( $default_server->is_default, 'Server is the default one' );
		60	ok( !$library_specific_server->is_default,
		61	'Server is not the default one' );
		62
		63	$schema->storage->txn_rollback;
		64	};
65
66	subtest 'store() tests' => sub {
67
68	plan tests => 4;
69
70	$schema->storage->txn_begin;
71
72	Koha::SMTP::Servers->search->delete;
73
74	my $default_server = Koha::SMTP::Server->new(
75	{
76	library_id => undef,
77	name => 'Default SMTP server'
78	}
79	)->store;
80
81	my $library = $builder->build_object( { class => 'Koha::Libraries' } );
82	my $library_specific_server = Koha::SMTP::Server->new(
83	{
84	library_id => $library->id,
85	name => 'Library-specific SMTP server'
86	}
87	)->store;
88
89	warning_like
90	{
91	throws_ok
92	{ Koha::SMTP::Server->new(
93	{
94	library_id => $library->id,
95	name => 'Some fake name'
96	}
97	)->store; }
98	'Koha::Exceptions::Object::DuplicateID',
99	'Cannot define two servers for the same library';
100	}
101	qr/DBI Exception: DBD::mysql::st execute failed: Duplicate entry/,
102	'Warning is printed';
103
104	throws_ok
105	{ Koha::SMTP::Server->new(
106	{
107	library_id => undef,
108	name => 'Some fake name'
109	}
110	)->store; }
111	'Koha::Exceptions::Object::DuplicateID',
112	'Cannot define two default SMTP servers';
113
114	$default_server->set({ name => 'New name' })->store;
115	$default_server->discard_changes;
116
117	is( $default_server->name, 'New name', 'Default server updated correctly' );
118
119	$schema->storage->txn_rollback;
120	};

Line 0 Link Here

(-)a/t/db_dependent/Koha/SMTP/Servers.t (-1 / +258 lines)
0	-	1	#!/usr/bin/perl
		2
		3	# This file is part of Koha.
		4	#
		5	# Koha is free software; you can redistribute it and/or modify it
		6	# under the terms of the GNU General Public License as published by
		7	# the Free Software Foundation; either version 3 of the License, or
		8	# (at your option) any later version.
		9	#
		10	# Koha is distributed in the hope that it will be useful, but
		11	# WITHOUT ANY WARRANTY; without even the implied warranty of
		12	# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
		13	# GNU General Public License for more details.
		14	#
		15	# You should have received a copy of the GNU General Public License
		16	# along with Koha; if not, see <http://www.gnu.org/licenses>.
		17
		18	use Modern::Perl;
		19
		20	use Test::More tests => 4;
		21	use Test::Exception;
		22
		23	use Koha::SMTP::Servers;
		24
		25	use t::lib::TestBuilder;
		26	use t::lib::Mocks;
		27
		28	my $schema = Koha::Database->new->schema;
		29	my $builder = t::lib::TestBuilder->new;
		30
		31	subtest 'get_default() tests' => sub {
		32
		33	plan tests => 3;
		34
		35	$schema->storage->txn_begin;
		36
		37	Koha::SMTP::Servers->search->delete;
		38
		39	my $default_server = $builder->build_object(
		40	{
		41	class => 'Koha::SMTP::Servers',
		42	value => {
		43	library_id => undef
		44	}
		45	}
		46	);
		47
		48	my $library = $builder->build_object( { class => 'Koha::Libraries' } );
		49	my $library_specific_server = $builder->build_object(
		50	{
		51	class => 'Koha::SMTP::Servers',
		52	value => {
		53	library_id => $library->branchcode
		54	}
		55	}
		56	);
		57
		58	my $servers = Koha::SMTP::Servers->new;
		59	my $server = $servers->get_default;
		60	is( $server->id, $default_server->id,
		61	'The default server is correctly retrieved' );
		62
		63	# Delete the default server
		64	$server->delete;
		65
66	# Get the default
67	$default_server = $servers->get_default;
68	is( ref($default_server), 'Koha::SMTP::Server',
69	'An object of the right type is returned' );
70
71	my $unblessed_server = $default_server->unblessed;
72	delete $unblessed_server->{id};
73	is_deeply(
74	$unblessed_server,
75	Koha::SMTP::Servers::default_setting,
76	'The default setting is returned if no user-defined default'
77	);
78
79	$schema->storage->txn_rollback;
80	};
81
82	subtest 'set_default() tests' => sub {
83
84	plan tests => 4;
85
86	$schema->storage->txn_begin;
87
88	Koha::SMTP::Servers->search->delete;
89
90	my $default_server = $builder->build_object(
91	{
92	class => 'Koha::SMTP::Servers',
93	value => {
94	library_id => undef
95	}
96	}
97	);
98
99	throws_ok {
100	Koha::SMTP::Servers->new->set_default(
101	{
102	name => 'A new default',
103	library_id => 'Whatever',
104	}
105	);
106	}
107	'Koha::Exceptions::BadParameter',
108	'Exception thrown when trying to set default SMTP server with a library_id';
109
110	is(
111	"$@",
112	'library_id must be undef when setting the default SMTP server',
113	'Exception message is clear'
114	);
115
116	my $new_default = Koha::SMTP::Servers->new->set_default(
117	{
118	name => 'A new default',
119	library_id => undef,
120	}
121	);
122
123	is( ref($new_default), 'Koha::SMTP::Server', 'Type is correct' );
124	is(
125	$new_default->id,
126	Koha::SMTP::Servers->get_default->id,
127	'Default SMTP server is correctly set'
128	);
129
130	$schema->storage->txn_rollback;
131	};
132
133	subtest 'get_effective_server() tests' => sub {
134
135	plan tests => 4;
136
137	$schema->storage->txn_begin;
138
139	Koha::SMTP::Servers->search->delete;
140
141	my $library = $builder->build_object( { class => 'Koha::Libraries' } );
142
143	my $default_server = $builder->build_object(
144	{
145	class => 'Koha::SMTP::Servers',
146	value => {
147	library_id => undef
148	}
149	}
150	);
151
152	throws_ok { Koha::SMTP::Servers->new->get_effective_server() }
153	'Koha::Exceptions::MissingParameter', 'Exception thrown';
154
155	is( "$@", 'Mandatory parameter missing: library' );
156
157	is(
158	Koha::SMTP::Servers->new->get_effective_server(
159	{ library => $library }
160	)->id,
161	$default_server->id,
162	'Fallback default server retrieved'
163	);
164
165	my $specific_server = $builder->build_object(
166	{
167	class => 'Koha::SMTP::Servers',
168	value => {
169	library_id => $library->branchcode
170	}
171	}
172	);
173
174	is(
175	Koha::SMTP::Servers->new->get_effective_server(
176	{ library => $library }
177	)->id,
178	$specific_server->id,
179	'Library specific server retrieved'
180	);
181
182	$schema->storage->txn_rollback;
183	};
184
185	subtest 'set_library_server() tests' => sub {
186
187	plan tests => 6;
188
189	$schema->storage->txn_begin;
190
191	Koha::SMTP::Servers->search->delete;
192
193	my $library = $builder->build_object( { class => 'Koha::Libraries' } );
194
195	my $default_server = $builder->build_object(
196	{
197	class => 'Koha::SMTP::Servers',
198	value => {
199	library_id => undef
200	}
201	}
202	);
203
204	is(
205	Koha::SMTP::Servers->new->get_effective_server(
206	{ library => $library }
207	)->id,
208	$default_server->id,
209	'Fallback default server retrieved'
210	);
211
212	my $specific_server = Koha::SMTP::Servers->new->set_library_server(
213	{
214	name => 'Specific server 1',
215	library_id => $library->id
216	}
217	);
218
219	is(
220	Koha::SMTP::Servers->new->get_effective_server(
221	{ library => $library }
222	)->id,
223	$specific_server->id,
224	'Library specific server retrieved'
225	);
226
227	throws_ok {
228	Koha::SMTP::Servers->new->set_library_server(
229	{
230	name => 'Specific server 2'
231	}
232	);
233	}
234	'Koha::Exceptions::MissingParameter',
235	'Exception thrown on missing parameter';
236
237	is( "$@", 'Mandatory parameter missing: library_id' );
238
239	$specific_server = Koha::SMTP::Servers->new->set_library_server(
240	{
241	name => 'Specific server 2',
242	library_id => $library->id
243	}
244	);
245
246	is(
247	Koha::SMTP::Servers->new->get_effective_server(
248	{ library => $library }
249	)->id,
250	$specific_server->id,
251	'New library specific server retrieved'
252	);
253
254	is( Koha::SMTP::Servers->search( { library_id => $library->id } )->count,
255	1, 'Only one SMTP server set' );
256
257	$schema->storage->txn_rollback;
258	};