1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
|
BEGIN { chdir 't' if -d 't' };
use strict;
use lib '../lib';
use Test::More 'no_plan';
use Cwd qw[cwd];
use File::Basename qw[basename];
use Data::Dumper;
use_ok('File::Fetch');
### optionally set debugging ###
$File::Fetch::DEBUG = $File::Fetch::DEBUG = 1 if $ARGV[0];
$IPC::Cmd::DEBUG = $IPC::Cmd::DEBUG = 1 if $ARGV[0];
unless( $ENV{PERL_CORE} ) {
warn qq[
####################### NOTE ##############################
Some of these tests assume you are connected to the
internet. If you are not, or if certain protocols or hosts
are blocked and/or firewalled, these tests could fail due
to no fault of the module itself.
###########################################################
];
sleep 3 unless $File::Fetch::DEBUG;
}
### show us the tools IPC::Cmd will use to run binary programs
if( $File::Fetch::DEBUG ) {
### stupid 'used only once' warnings ;(
diag( "IPC::Run enabled: " .
$IPC::Cmd::USE_IPC_RUN || $IPC::Cmd::USE_IPC_RUN );
diag( "IPC::Run available: " . IPC::Cmd->can_use_ipc_run );
diag( "IPC::Run vesion: $IPC::Run::VERSION" );
diag( "IPC::Open3 enabled: " .
$IPC::Cmd::USE_IPC_OPEN3 || $IPC::Cmd::USE_IPC_OPEN3 );
diag( "IPC::Open3 available: " . IPC::Cmd->can_use_ipc_open3 );
diag( "IPC::Open3 vesion: $IPC::Open3::VERSION" );
}
### _parse_uri tests
### these go on all platforms
my @map = (
{ uri => 'ftp://cpan.org/pub/mirror/index.txt',
scheme => 'ftp',
host => 'cpan.org',
path => '/pub/mirror/',
file => 'index.txt'
},
{ uri => 'rsync://cpan.pair.com/CPAN/MIRRORING.FROM',
scheme => 'rsync',
host => 'cpan.pair.com',
path => '/CPAN/',
file => 'MIRRORING.FROM',
},
{ uri => 'http://localhost/tmp/index.txt',
scheme => 'http',
host => 'localhost', # host is empty only on 'file://'
path => '/tmp/',
file => 'index.txt',
},
### only test host part, the rest is OS dependant
{ uri => 'file://localhost/tmp/index.txt',
host => '', # host should be empty on 'file://'
},
);
### these only if we're not on win32/vms
push @map, (
{ uri => 'file:///usr/local/tmp/foo.txt',
scheme => 'file',
host => '',
path => '/usr/local/tmp/',
file => 'foo.txt',
},
{ uri => 'file://hostname/tmp/foo.txt',
scheme => 'file',
host => 'hostname',
path => '/tmp/',
file => 'foo.txt',
},
) if not &File::Fetch::ON_WIN and not &File::Fetch::ON_VMS;
### these only on win32
push @map, (
{ uri => 'file:////hostname/share/tmp/foo.txt',
scheme => 'file',
host => 'hostname',
share => 'share',
path => '/tmp/',
file => 'foo.txt',
},
{ uri => 'file:///D:/tmp/foo.txt',
scheme => 'file',
host => '',
vol => 'D:',
path => '/tmp/',
file => 'foo.txt',
},
{ uri => 'file:///D|/tmp/foo.txt',
scheme => 'file',
host => '',
vol => 'D:',
path => '/tmp/',
file => 'foo.txt',
},
) if &File::Fetch::ON_WIN;
### sanity tests
{
no warnings;
like( $File::Fetch::USER_AGENT, qr/$File::Fetch::VERSION/,
"User agent contains version" );
like( $File::Fetch::FROM_EMAIL, qr/@/,
q[Email contains '@'] );
}
### parse uri tests ###
for my $entry (@map ) {
my $uri = $entry->{'uri'};
my $href = File::Fetch->_parse_uri( $uri );
ok( $href, "Able to parse uri '$uri'" );
for my $key ( sort keys %$entry ) {
is( $href->{$key}, $entry->{$key},
" '$key' ok ($entry->{$key}) for $uri");
}
}
### File::Fetch->new tests ###
for my $entry (@map) {
my $ff = File::Fetch->new( uri => $entry->{uri} );
ok( $ff, "Object for uri '$entry->{uri}'" );
isa_ok( $ff, "File::Fetch", " Object" );
for my $acc ( keys %$entry ) {
is( $ff->$acc(), $entry->{$acc},
" Accessor '$acc' ok ($entry->{$acc})" );
}
}
### fetch() tests ###
### file:// tests ###
{
my $prefix = &File::Fetch::ON_UNIX ? 'file://' : 'file:///';
my $uri = $prefix . cwd() .'/'. basename($0);
for (qw[lwp lftp file]) {
_fetch_uri( file => $uri, $_ );
}
}
### ftp:// tests ###
{ my $uri = 'ftp://ftp.funet.fi/pub/CPAN/index.html';
for (qw[lwp netftp wget curl lftp fetch ncftp]) {
### STUPID STUPID warnings ###
next if $_ eq 'ncftp' and $File::Fetch::FTP_PASSIVE
and $File::Fetch::FTP_PASSIVE;
_fetch_uri( ftp => $uri, $_ );
}
}
### http:// tests ###
{ for my $uri ( 'http://www.cpan.org/index.html',
'http://www.cpan.org/index.html?q=1',
'http://www.cpan.org/index.html?q=1&y=2',
) {
for (qw[lwp httplite wget curl lftp fetch lynx iosock]) {
_fetch_uri( http => $uri, $_ );
}
}
}
### rsync:// tests ###
{ my $uri = 'rsync://cpan.pair.com/CPAN/MIRRORING.FROM';
for (qw[rsync]) {
_fetch_uri( rsync => $uri, $_ );
}
}
sub _fetch_uri {
my $type = shift;
my $uri = shift;
my $method = shift or return;
SKIP: {
skip "'$method' fetching tests disabled under perl core", 4
if $ENV{PERL_CORE};
### stupid warnings ###
$File::Fetch::METHODS =
$File::Fetch::METHODS = { $type => [$method] };
### fetch regularly
my $ff = File::Fetch->new( uri => $uri );
ok( $ff, "FF object for $uri (fetch with $method)" );
for my $to ( 'tmp', do { \my $o } ) { SKIP: {
my $how = ref $to ? 'slurp' : 'file';
my $skip = ref $to ? 4 : 3;
ok( 1, " Fetching '$uri' in $how mode" );
my $file = $ff->fetch( to => $to );
skip "You do not have '$method' installed/available", $skip
if $File::Fetch::METHOD_FAIL->{$method} &&
$File::Fetch::METHOD_FAIL->{$method};
### if the file wasn't fetched, it may be a network/firewall issue
skip "Fetch failed; no network connectivity for '$type'?", $skip
unless $file;
ok( $file, " File ($file) fetched with $method ($uri)" );
### check we got some contents if we were meant to slurp
if( ref $to ) {
ok( $$to, " Contents slurped" );
}
ok( $file && -s $file,
" File has size" );
is( $file && basename($file), $ff->output_file,
" File has expected name" );
unlink $file;
}}
}
}
|
