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

(-)a/Koha/SFTP/Server.pm (-446 lines)
Lines 1-446 Link Here
1
package Koha::SFTP::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::Encryption;
23
use Koha::Logger;
24
use Koha::SFTP::Servers;
25
26
use Try::Tiny qw( catch try );
27
use Mojo::JSON;
28
use Net::SFTP::Foreign;
29
use Net::FTP;
30
use File::Spec;
31
use IO::File;
32
33
use base qw(Koha::Object);
34
35
=head1 NAME
36
37
Koha::SFTP::Server - Koha SFTP Server Object class
38
39
=head1 API
40
41
=head2 Class methods
42
43
=head3 store
44
45
    $server->store;
46
47
Overloaded store method that ensures directory paths end with a forward slash.
48
49
=cut
50
51
sub store {
52
    my ($self) = @_;
53
54
    for my $dir_field (qw( download_directory upload_directory )) {
55
        my $dir = $self->$dir_field;
56
        next unless $dir && $dir ne '';
57
58
        $self->$dir_field( $dir . '/' ) unless substr( $dir, -1 ) eq '/';
59
    }
60
61
    return $self->SUPER::store;
62
}
63
64
=head3 to_api
65
66
    my $json = $sftp_server->to_api;
67
68
Returns a JSON representation of the object suitable for API output,
69
excluding sensitive data.
70
71
=cut
72
73
sub to_api {
74
    my ( $self, $params ) = @_;
75
76
    my $json_sftp = $self->SUPER::to_api($params) or return;
77
    delete $json_sftp->{password};
78
    delete $json_sftp->{key_file};
79
80
    return $json_sftp;
81
}
82
83
=head3 to_api_mapping
84
85
This method returns the mapping for representing a Koha::SFTP::Server object
86
on the API.
87
88
=cut
89
90
sub to_api_mapping {
91
    return { id => 'sftp_server_id' };
92
}
93
94
=head3 plain_text_password
95
96
    my $password = $server->plain_text_password;
97
98
Returns the decrypted plaintext password.
99
100
=cut
101
102
sub plain_text_password {
103
    my ($self) = @_;
104
    return unless $self->password;
105
    return Koha::Encryption->new->decrypt_hex( $self->password );
106
}
107
108
=head3 plain_text_key
109
110
    my $key = $server->plain_text_key;
111
112
Returns the decrypted plaintext key file.
113
114
=cut
115
116
sub plain_text_key {
117
    my ($self) = @_;
118
    return unless $self->key_file;
119
    return Koha::Encryption->new->decrypt_hex( $self->key_file ) . "\n";
120
}
121
122
=head3 write_key_file
123
124
    my $success = $server->write_key_file;
125
126
Writes the keyfile from the db into a file.
127
128
Returns 1 on success, undef on failure.
129
130
=cut
131
132
sub write_key_file {
133
    my ($self) = @_;
134
135
    my $upload_path = C4::Context->config('upload_path') or return;
136
    my $logger      = Koha::Logger->get;
137
    my $key_path    = File::Spec->catdir( $upload_path, 'ssh_keys' );
138
    my $key_file    = File::Spec->catfile( $key_path, 'id_ssh_' . $self->id );
139
140
    mkdir $key_path unless -d $key_path;
141
    unlink $key_file if -f $key_file;
142
143
    my $fh = IO::File->new( $key_file, 'w' ) or return;
144
145
    try {
146
        chmod 0600, $key_file if -f $key_file;
147
        print $fh $self->plain_text_key;
148
        close $fh or $logger->warn("Failed to close key file: $!");
149
        return 1;
150
    } catch {
151
        $logger->warn("Error writing key file: $_");
152
        close $fh;
153
        return;
154
    };
155
}
156
157
=head3 locate_key_file
158
159
    my $path = $server->locate_key_file;
160
161
Returns the keyfile's path if it exists, undef otherwise.
162
163
=cut
164
165
sub locate_key_file {
166
    my ($self) = @_;
167
168
    my $upload_path = C4::Context->config('upload_path') or return;
169
    my $key_file    = File::Spec->catfile(
170
        $upload_path,
171
        'ssh_keys',
172
        'id_ssh_' . $self->id
173
    );
174
175
    return ( -f $key_file ) ? $key_file : undef;
176
}
177
178
=head3 update_password
179
180
    my $success = $server->update_password;
181
182
Update the server's encrypted password.
183
184
=cut
185
186
sub update_password {
187
    my ( $self, $value ) = @_;
188
    return unless defined $value;
189
190
    $self->password( Koha::Encryption->new->encrypt_hex($value) );
191
    return $self->SUPER::store;
192
}
193
194
=head3 update_key_file
195
196
    my $success = $server->update_key_file($new_key_file);
197
198
Update the server's encrypted key file.
199
200
=cut
201
202
sub update_key_file {
203
    my ( $self, $value ) = @_;
204
    return unless defined $value;
205
206
    $self->key_file( Koha::Encryption->new->encrypt_hex( _dos2unix($value) ) );
207
    return $self->SUPER::store;
208
}
209
210
=head3 update_status
211
212
    my $success = $server->update_status($new_status);
213
214
Update the server's status
215
216
=cut
217
218
sub update_status {
219
    my ( $self, $value ) = @_;
220
    return unless defined $value;
221
222
    return $self->set( { status => $value } )->store;
223
}
224
225
=head3 test_conn
226
227
    my ($success, $results) = $server->test_conn;
228
229
Tests connection to the server. Returns success flag and detailed test results.
230
231
=cut
232
233
sub test_conn {
234
    my ($self) = @_;
235
    my $default_result = {
236
        passed => Mojo::JSON->false,
237
        err    => undef,
238
        msg    => undef,
239
    };
240
    my $sftp_test_results;
241
242
    if ( $self->transport eq 'sftp' ) {
243
        $sftp_test_results->{'1_sftp_conn'} = {%$default_result};
244
        my $sftp = Net::SFTP::Foreign->new(
245
            host     => $self->host,
246
            user     => $self->user_name,
247
            password => $self->plain_text_password,
248
            key_path => $self->locate_key_file,
249
            port     => $self->port,
250
            timeout  => 10,
251
            more     => [
252
                qw(-vv),
253
                qw(-o StrictHostKeyChecking=no),
254
            ],
255
        );
256
        unless ( $sftp->error ) {
257
            $sftp_test_results->{'1_sftp_conn'}->{'passed'} = Mojo::JSON->true;
258
            $sftp_test_results->{'1_sftp_conn'}->{'msg'}    = $sftp->status;
259
        } else {
260
            $sftp_test_results->{'1_sftp_conn'}->{'err'} = $sftp->error;
261
        }
262
263
        unless ( $sftp->error ) {
264
            unless ( $self->download_directory eq '' ) {
265
                $sftp_test_results->{'2a_sftp_cwd_dl'} = {%$default_result};
266
                $sftp->setcwd( $self->download_directory );
267
                unless ( $sftp->error ) {
268
                    $sftp_test_results->{'2a_sftp_cwd_dl'}->{'passed'} = Mojo::JSON->true;
269
                    $sftp_test_results->{'2a_sftp_cwd_dl'}->{'msg'}    = $sftp->status;
270
                } else {
271
                    $sftp_test_results->{'2a_sftp_cwd_dl'}->{'err'} = $sftp->error;
272
                }
273
            }
274
275
            $sftp_test_results->{'2b_sftp_ls_dl'} = {%$default_result};
276
            $sftp->ls();
277
            unless ( $sftp->error ) {
278
                $sftp_test_results->{'2b_sftp_ls_dl'}->{'passed'} = Mojo::JSON->true;
279
                $sftp_test_results->{'2b_sftp_ls_dl'}->{'msg'}    = $sftp->status;
280
            } else {
281
                $sftp_test_results->{'2b_sftp_ls_dl'}->{'err'} = $sftp->error;
282
            }
283
284
            unless ( $self->upload_directory eq '' ) {
285
                $sftp_test_results->{'2c_sftp_cwd_ul'} = {%$default_result};
286
                $sftp->setcwd( $self->upload_directory );
287
                unless ( $sftp->error ) {
288
                    $sftp_test_results->{'2c_sftp_cwd_ul'}->{'passed'} = Mojo::JSON->true;
289
                    $sftp_test_results->{'2c_sftp_cwd_ul'}->{'msg'}    = $sftp->status;
290
                } else {
291
                    $sftp_test_results->{'2c_sftp_cwd_ul'}->{'err'} = $sftp->error;
292
                }
293
            }
294
295
            $sftp_test_results->{'2d_sftp_ls_ul'} = {%$default_result};
296
            $sftp->ls( $self->upload_directory );
297
            unless ( $sftp->error ) {
298
                $sftp_test_results->{'2d_sftp_ls_ul'}->{'passed'} = Mojo::JSON->true;
299
                $sftp_test_results->{'2d_sftp_ls_ul'}->{'msg'}    = $sftp->status;
300
            } else {
301
                $sftp_test_results->{'2d_sftp_ls_ul'}->{'err'} = $sftp->error;
302
            }
303
304
            $sftp_test_results->{'3_sftp_write'} = {%$default_result};
305
            open my $fh, '<', \"Hello, world!\n";
306
            close $fh if ( $sftp->put( $fh, $self->upload_directory . '.koha_test_file' ) );
307
            unless ( $sftp->error ) {
308
                $sftp_test_results->{'3_sftp_write'}->{'passed'} = Mojo::JSON->true;
309
                $sftp_test_results->{'3_sftp_write'}->{'msg'}    = $sftp->status;
310
            } else {
311
                $sftp_test_results->{'3_sftp_write'}->{'err'} = $sftp->error;
312
            }
313
314
            $sftp_test_results->{'4_sftp_del'} = {%$default_result};
315
            $sftp->remove( $self->upload_directory . '.koha_test_file' );
316
            unless ( $sftp->error ) {
317
                $sftp_test_results->{'4_sftp_del'}->{'passed'} = Mojo::JSON->true;
318
                $sftp_test_results->{'4_sftp_del'}->{'msg'}    = $sftp->status;
319
            } else {
320
                $sftp_test_results->{'4_sftp_del'}->{'err'} = $sftp->error;
321
            }
322
        }
323
    } elsif ( $self->transport eq 'ftp' ) {
324
        $sftp_test_results->{'1_ftp_conn'} = {%$default_result};
325
        my $ftp = Net::FTP->new(
326
            $self->host,
327
            Port    => $self->port,
328
            Timeout => 10,
329
            Passive => ( scalar $self->passive ) ? 1 : 0,
330
        );
331
        if ($ftp) {
332
            $sftp_test_results->{'1_ftp_conn'}->{'passed'} = Mojo::JSON->true;
333
            $sftp_test_results->{'1_ftp_conn'}->{'msg'}    = $ftp->message;
334
        } else {
335
            $sftp_test_results->{'1_ftp_conn'}->{'err'} = 'cannot connect to ' . $self->host . ': ' . $@;
336
        }
337
338
        if ($ftp) {
339
            $sftp_test_results->{'2_ftp_login'} = {%$default_result};
340
            my $login = $ftp->login(
341
                $self->user_name,
342
                $self->plain_text_password,
343
            );
344
            if ($login) {
345
                $sftp_test_results->{'2_ftp_login'}->{'passed'} = Mojo::JSON->true;
346
                $sftp_test_results->{'2_ftp_login'}->{'msg'}    = $ftp->message;
347
            } else {
348
                $sftp_test_results->{'2_ftp_login'}->{'err'} = $ftp->message;
349
            }
350
351
            unless ( $self->download_directory eq '' ) {
352
                $sftp_test_results->{'3a_ftp_cwd_dl'} = {%$default_result};
353
                my $cwd_dl = $ftp->cwd( $self->download_directory );
354
                if ($cwd_dl) {
355
                    $sftp_test_results->{'3a_ftp_cwd_dl'}->{'passed'} = Mojo::JSON->true;
356
                    $sftp_test_results->{'3a_ftp_cwd_dl'}->{'msg'}    = $ftp->message;
357
                } else {
358
                    $sftp_test_results->{'3a_ftp_cwd_dl'}->{'err'} = $ftp->message;
359
                }
360
            }
361
362
            $sftp_test_results->{'3b_ftp_ls_dl'} = {%$default_result};
363
            my $ls_dl = $ftp->ls();
364
            if ($ls_dl) {
365
                $sftp_test_results->{'3b_ftp_ls_dl'}->{'passed'} = Mojo::JSON->true;
366
                $sftp_test_results->{'3b_ftp_ls_dl'}->{'msg'}    = $ftp->message;
367
            } else {
368
                $sftp_test_results->{'3b_ftp_ls_dl'}->{'err'} = $ftp->message;
369
            }
370
371
            unless ( $self->upload_directory eq '' ) {
372
                $sftp_test_results->{'3c_ftp_cwd_ul'} = {%$default_result};
373
                my $cwd_ul = $ftp->cwd( $self->upload_directory );
374
                if ($cwd_ul) {
375
                    $sftp_test_results->{'3c_ftp_cwd_ul'}->{'passed'} = Mojo::JSON->true;
376
                    $sftp_test_results->{'3c_ftp_cwd_ul'}->{'msg'}    = $ftp->message;
377
                } else {
378
                    $sftp_test_results->{'3c_ftp_cwd_ul'}->{'err'} = $ftp->message;
379
                }
380
            }
381
382
            $sftp_test_results->{'3d_ftp_ls_ul'} = {%$default_result};
383
            my $ls_ul = $ftp->ls();
384
            if ($ls_ul) {
385
                $sftp_test_results->{'3d_ftp_ls_ul'}->{'passed'} = Mojo::JSON->true;
386
                $sftp_test_results->{'3d_ftp_ls_ul'}->{'msg'}    = $ftp->message;
387
            } else {
388
                $sftp_test_results->{'3d_ftp_ls_ul'}->{'err'} = $ftp->message;
389
            }
390
391
            $sftp_test_results->{'4_ftp_write'} = {%$default_result};
392
            open my $fh, '<', \"Hello, world!\n";
393
            close $fh if ( my $put = $ftp->put( $fh, $self->upload_directory . '.koha_test_file' ) );
394
            if ($put) {
395
                $sftp_test_results->{'4_ftp_write'}->{'passed'} = Mojo::JSON->true;
396
                $sftp_test_results->{'4_ftp_write'}->{'msg'}    = $ftp->message;
397
            } else {
398
                $sftp_test_results->{'4_ftp_write'}->{'err'} = $ftp->message;
399
            }
400
401
            $sftp_test_results->{'5_ftp_del'} = {%$default_result};
402
            my $delete = $ftp->delete( $self->upload_directory . '.koha_test_file' );
403
            if ($delete) {
404
                $sftp_test_results->{'5_ftp_del'}->{'passed'} = Mojo::JSON->true;
405
                $sftp_test_results->{'5_ftp_del'}->{'msg'}    = $ftp->message;
406
            } else {
407
                $sftp_test_results->{'5_ftp_del'}->{'err'} = $ftp->message;
408
            }
409
        }
410
    }
411
412
    #    $self->update_status('tests_ok');
413
    #    foreach my $val ( values %$sftp_test_results ) {
414
    #        if ( defined $val->{'err'} ) {
415
    #            $self->update_status('tests_failed');
416
    #        }
417
    #    }
418
419
    return ( 1, $sftp_test_results );
420
}
421
422
=head2 Internal methods
423
424
=head3 _dos2unix
425
426
Return a CR-free string from an input
427
428
=cut
429
430
sub _dos2unix {
431
    my $dosStr = shift;
432
433
    return $dosStr =~ s/\015\012/\012/gr;
434
}
435
436
=head3 _type
437
438
Return type of Object relating to Schema ResultSet
439
440
=cut
441
442
sub _type {
443
    return 'SftpServer';
444
}
445
446
1;
(-)a/Koha/SFTP/Servers.pm (-55 lines)
Lines 1-55 Link Here
1
package Koha::SFTP::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::SFTP::Server;
24
25
use base qw(Koha::Objects);
26
27
=head1 NAME
28
29
Koha::SFTP::Servers - Koha SFTP Server Object set class
30
31
=head1 API
32
33
=head2 Internal methods
34
35
=head3 _type
36
37
Return type of object, relating to Schema ResultSet
38
39
=cut
40
41
sub _type {
42
    return 'SftpServer';
43
}
44
45
=head3 object_class
46
47
Return object class
48
49
=cut
50
51
sub object_class {
52
    return 'Koha::SFTP::Server';
53
}
54
55
1;
(-)a/admin/sftp_servers.pl (-1 lines)
Lines 26-32 use Try::Tiny qw( catch try ); Link Here
26
use C4::Auth   qw( get_template_and_user );
26
use C4::Auth   qw( get_template_and_user );
27
use C4::Output qw( output_html_with_http_headers );
27
use C4::Output qw( output_html_with_http_headers );
28
28
29
use Koha::SFTP::Servers;
30
use Koha::File::Transports;
29
use Koha::File::Transports;
31
30
32
my $input = CGI->new;
31
my $input = CGI->new;
(-)a/t/db_dependent/Koha/SFTP/Server.t (-167 lines)
Lines 1-167 Link Here
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 => 7;
21
use Test::Exception;
22
use Test::Warn;
23
24
use Koha::SFTP::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 'to_api() tests' => sub {
33
34
    plan tests => 2;
35
36
    $schema->storage->txn_begin;
37
38
    my $sftp_server = $builder->build_object( { class => 'Koha::SFTP::Servers' } );
39
40
    ok( !exists $sftp_server->to_api->{password}, 'Password is not part of the API representation' );
41
    ok( !exists $sftp_server->to_api->{key_file}, 'Key file is not part of the API representation' );
42
43
    $schema->storage->txn_rollback;
44
};
45
46
subtest 'update_password() tests' => sub {
47
48
    plan tests => 2;
49
50
    $schema->storage->txn_begin;
51
52
    my $sftp_server = $builder->build_object( { class => 'Koha::SFTP::Servers' } );
53
    $sftp_server->update_password('test123');
54
55
    ok( $sftp_server->password ne 'test123', 'Password should not be in plain text' );
56
    is( length( $sftp_server->password ), 64, 'Password has should be 64 characters long' );
57
58
    $schema->storage->txn_rollback;
59
};
60
61
subtest 'update_key_file() tests' => sub {
62
63
    plan tests => 2;
64
65
    $schema->storage->txn_begin;
66
67
    my $sftp_server = $builder->build_object( { class => 'Koha::SFTP::Servers' } );
68
    $sftp_server->update_key_file('321tset');
69
70
    ok( $sftp_server->key_file ne 'test123', 'Password should not be in plain text' );
71
    is( length( $sftp_server->key_file ), 64, 'Password has should be 64 characters long' );
72
73
    $schema->storage->txn_rollback;
74
};
75
76
subtest 'update_status() tests' => sub {
77
78
    plan tests => 2;
79
80
    $schema->storage->txn_begin;
81
82
    my $sftp_server        = $builder->build_object( { class => 'Koha::SFTP::Servers' } );
83
    my $sftp_server_status = 'tests_ok';
84
85
    $sftp_server->set(
86
        {
87
            password => 'somepass',
88
            key_file => 'somekey',
89
        }
90
    )->store;
91
92
    isnt( $sftp_server_status, $sftp_server->status, 'Status should not by tests_ok' );
93
94
    $sftp_server->update_status($sftp_server_status);
95
96
    is( $sftp_server_status, $sftp_server->status, 'Status should be tests_ok' );
97
98
    $schema->storage->txn_rollback;
99
100
};
101
102
subtest 'plain_text_password() tests' => sub {
103
104
    plan tests => 2;
105
106
    $schema->storage->txn_begin;
107
108
    my $sftp_server = $builder->build_object( { class => 'Koha::SFTP::Servers' } );
109
110
    $sftp_server->update_password('test123');
111
112
    my $sftp_server_plain_text_password = $sftp_server->plain_text_password;
113
114
    isnt( $sftp_server_plain_text_password, $sftp_server->password, 'Password and password hash shouldn\'t match' );
115
    is( $sftp_server_plain_text_password, 'test123', 'Password should be in plain text' );
116
117
    $schema->storage->txn_rollback;
118
};
119
120
subtest 'plain_text_key() tests' => sub {
121
122
    plan tests => 2;
123
124
    $schema->storage->txn_begin;
125
126
    my $sftp_server = $builder->build_object( { class => 'Koha::SFTP::Servers' } );
127
128
    $sftp_server->update_key_file('321tset');
129
130
    my $sftp_server_plain_text_key = $sftp_server->plain_text_key;
131
132
    isnt( $sftp_server_plain_text_key, $sftp_server->key_file, 'Key file and key file hash shouldn\'t match' );
133
    is( $sftp_server_plain_text_key, "321tset\n", 'Key file should be in plain text' );
134
135
    $schema->storage->txn_rollback;
136
};
137
138
subtest 'write_key_file() tests' => sub {
139
140
    plan tests => 3;
141
142
    $schema->storage->txn_begin;
143
144
    my $sftp_server = $builder->build_object( { class => 'Koha::SFTP::Servers' } );
145
146
    $sftp_server->update_key_file('321tset');
147
148
    my $path = '/tmp/kohadev_test';
149
    t::lib::Mocks::mock_config( 'upload_path', $path );
150
    mkdir $path if !-d $path;
151
152
    my $first_test = $sftp_server->write_key_file;
153
154
    my $file        = $sftp_server->locate_key_file;
155
    my $second_test = ( -f $file );
156
157
    open( my $fh, '<', $sftp_server->locate_key_file );
158
    my $third_test = <$fh>;
159
160
    is( $first_test,  1,           'Writing key file should return 1' );
161
    is( $second_test, 1,           'Written key file should exist' );
162
    is( $third_test,  "321tset\n", 'The contents of the key file should be 321tset\n' );
163
164
    unlink $file;
165
166
    $schema->storage->txn_rollback;
167
};
(-)a/t/db_dependent/api/v1/sftp_servers.t (-13 / +11 lines)
Lines 23-29 use Test::Mojo; Link Here
23
use t::lib::TestBuilder;
23
use t::lib::TestBuilder;
24
use t::lib::Mocks;
24
use t::lib::Mocks;
25
25
26
use Koha::SFTP::Servers;
27
use Koha::Database;
26
use Koha::Database;
28
27
29
my $schema  = Koha::Database->new->schema;
28
my $schema  = Koha::Database->new->schema;
Lines 38-44 subtest 'list() tests' => sub { Link Here
38
37
39
    $schema->storage->txn_begin;
38
    $schema->storage->txn_begin;
40
39
41
    Koha::SFTP::Servers->search->delete;
40
    Koha::File::Transports->search->delete;
42
41
43
    my $librarian = $builder->build_object(
42
    my $librarian = $builder->build_object(
44
        {
43
        {
Lines 66-72 subtest 'list() tests' => sub { Link Here
66
65
67
    my $sftp_server = $builder->build_object(
66
    my $sftp_server = $builder->build_object(
68
        {
67
        {
69
            class => 'Koha::SFTP::Servers',
68
            class => 'Koha::File::Transports',
70
            value => {
69
            value => {
71
                password => undef,
70
                password => undef,
72
                key_file => undef,
71
                key_file => undef,
Lines 80-86 subtest 'list() tests' => sub { Link Here
80
79
81
    my $another_sftp_server = $builder->build_object(
80
    my $another_sftp_server = $builder->build_object(
82
        {
81
        {
83
            class => 'Koha::SFTP::Servers',
82
            class => 'Koha::File::Transports',
84
            value => {
83
            value => {
85
                password => undef,
84
                password => undef,
86
                key_file => undef,
85
                key_file => undef,
Lines 107-113 subtest 'get() tests' => sub { Link Here
107
106
108
    my $sftp_server = $builder->build_object(
107
    my $sftp_server = $builder->build_object(
109
        {
108
        {
110
            class => 'Koha::SFTP::Servers',
109
            class => 'Koha::File::Transports',
111
            value => {
110
            value => {
112
                password => undef,
111
                password => undef,
113
                key_file => undef,
112
                key_file => undef,
Lines 142-148 subtest 'get() tests' => sub { Link Here
142
141
143
    my $sftp_server_to_delete = $builder->build_object(
142
    my $sftp_server_to_delete = $builder->build_object(
144
        {
143
        {
145
            class => 'Koha::SFTP::Servers',
144
            class => 'Koha::File::Transports',
146
            value => {
145
            value => {
147
                password => undef,
146
                password => undef,
148
                key_file => undef,
147
                key_file => undef,
Lines 165-171 subtest 'add() tests' => sub { Link Here
165
164
166
    $schema->storage->txn_begin;
165
    $schema->storage->txn_begin;
167
166
168
    Koha::SFTP::Servers->search->delete;
167
    Koha::File::Transports->search->delete;
169
168
170
    my $librarian = $builder->build_object(
169
    my $librarian = $builder->build_object(
171
        {
170
        {
Lines 189-195 subtest 'add() tests' => sub { Link Here
189
188
190
    my $sftp_server = $builder->build_object(
189
    my $sftp_server = $builder->build_object(
191
        {
190
        {
192
            class => 'Koha::SFTP::Servers',
191
            class => 'Koha::File::Transports',
193
            value => {
192
            value => {
194
                password => undef,
193
                password => undef,
195
                key_file => undef,
194
                key_file => undef,
Lines 276-282 subtest 'update() tests' => sub { Link Here
276
275
277
    my $sftp_server_id = $builder->build_object(
276
    my $sftp_server_id = $builder->build_object(
278
        {
277
        {
279
            class => 'Koha::SFTP::Servers',
278
            class => 'Koha::File::Transports',
280
            value => {
279
            value => {
281
                password => undef,
280
                password => undef,
282
                key_file => undef,
281
                key_file => undef,
Lines 328-334 subtest 'update() tests' => sub { Link Here
328
327
329
    my $sftp_server_to_delete = $builder->build_object(
328
    my $sftp_server_to_delete = $builder->build_object(
330
        {
329
        {
331
            class => 'Koha::SFTP::Servers',
330
            class => 'Koha::File::Transports',
332
            value => {
331
            value => {
333
                password => undef,
332
                password => undef,
334
                key_file => undef,
333
                key_file => undef,
Lines 381-387 subtest 'delete() tests' => sub { Link Here
381
380
382
    my $sftp_server_id = $builder->build_object(
381
    my $sftp_server_id = $builder->build_object(
383
        {
382
        {
384
            class => 'Koha::SFTP::Servers',
383
            class => 'Koha::File::Transports',
385
            value => {
384
            value => {
386
                password => undef,
385
                password => undef,
387
                key_file => undef,
386
                key_file => undef,
Lines 429-435 subtest 'test() tests' => sub { Link Here
429
428
430
    my $sftp_server = $builder->build_object(
429
    my $sftp_server = $builder->build_object(
431
        {
430
        {
432
            class => 'Koha::SFTP::Servers',
431
            class => 'Koha::File::Transports',
433
            value => {
432
            value => {
434
                password => undef,
433
                password => undef,
435
                key_file => undef,
434
                key_file => undef,
436
- 

Return to bug 39190