Test 1Test 2Test 3
Test-WWW-Mechanize-1.50/t/html/form.html 0000644 0001017 0000764 00000000470 13252250733 017163 0 ustar alester ispc
Test Page
Test Page
Test-WWW-Mechanize-1.50/t/put_ok.t 0000644 0001017 0000764 00000002027 13252250733 016054 0 ustar alester ispc #!perl -T
use strict;
use warnings;
use Test::More tests => 7;
use Test::Builder::Tester;
use Test::WWW::Mechanize ();
use lib 't';
use TestServer;
my $server = TestServer->new;
my $pid = $server->background;
my $server_root = $server->root;
my $mech = Test::WWW::Mechanize->new( autocheck => 0 );
isa_ok($mech,'Test::WWW::Mechanize');
my $text = 'This is what we are putting';
GOOD_PUT: {
my $scratch = "$server_root/scratch.html";
$mech->put_ok($scratch, {content => $text});
ok($mech->success, 'sanity check: we can load scratch.html');
test_out('ok 1 - Try to PUT scratch.html');
my $ok = $mech->put_ok($scratch, 'Try to PUT scratch.html');
test_test('PUTs existing URI and reports success');
is( ref($ok), '', 'put_ok() should only return a scalar' );
ok( $ok, 'And the result should be true' );
# default desc
test_out("ok 1 - PUT $scratch");
$mech->put_ok($scratch);
test_test('PUTs existing URI and reports success - default desc');
}
$server->stop;
done_testing();
Test-WWW-Mechanize-1.50/t/follow_link_ok.t 0000644 0001017 0000764 00000002112 13252250733 017556 0 ustar alester ispc #!perl -T
use strict;
use warnings;
use Test::More tests => 6;
use Test::Builder::Tester;
use URI::file ();
use Test::WWW::Mechanize ();
FOLLOW_GOOD_LINK: {
my $mech = Test::WWW::Mechanize->new( autocheck => 0 );
isa_ok( $mech,'Test::WWW::Mechanize' );
my $uri = URI::file->new_abs( 't/goodlinks.html' )->as_string;
$mech->get_ok( $uri );
test_out( 'ok 1 - Go after first link' );
$mech->follow_link_ok( {n=>1}, 'Go after first link' );
test_test( 'Handles good links' );
}
FOLLOW_BAD_LINK: {
my $mech = Test::WWW::Mechanize->new( autocheck => 0 );
isa_ok( $mech, 'Test::WWW::Mechanize' );
my $uri = URI::file->new_abs( 't/badlinks.html' );
my $path = $uri->file;
$path =~ s{\Qbadlinks.html}{bad1.html};
$mech->get_ok( $uri->as_string );
test_out('not ok 1 - Go after bad link');
test_fail(+3);
test_diag( 404 ); # XXX Who is printing this 404, and should it be?
test_diag( qq{File `$path' does not exist} );
$mech->follow_link_ok( {n=>2}, 'Go after bad link' );
test_test('Handles bad links');
}
done_testing();
Test-WWW-Mechanize-1.50/t/head_ok.t 0000644 0001017 0000764 00000002774 13252250733 016156 0 ustar alester ispc #!perl -T
use strict;
use warnings;
use Test::More tests => 10;
use Test::WWW::Mechanize;
use Test::Builder::Tester;
use URI::file;
my $mech = Test::WWW::Mechanize->new( autocheck => 0 );
isa_ok($mech,'Test::WWW::Mechanize');
GOOD_HEAD: { # Stop giggling, you!
my $goodlinks = URI::file->new_abs( 't/goodlinks.html' )->as_string;
$mech->head($goodlinks);
ok($mech->success, 'sanity check: we can load goodlinks.html');
test_out('ok 1 - Try to HEAD goodlinks.html');
my $ok = $mech->head_ok($goodlinks, 'Try to HEAD goodlinks.html');
test_test('HEAD existing URI and reports success');
is( ref($ok), '', 'head_ok() should only return a scalar' );
ok( $ok, 'And the result should be true' );
# default desc
test_out("ok 1 - HEAD $goodlinks");
$mech->head_ok($goodlinks);
test_test('HEAD existing URI and reports success - default desc');
}
BAD_HEAD: {
my $badurl = URI::file->new_abs('t/no-such-file');
my $abs_path = $badurl->file;
$mech->head( $badurl->as_string );
ok(!$mech->success, qq{sanity check: we can't load $badurl} );
test_out( 'not ok 1 - Try to HEAD bad URL' );
test_fail( +3 );
test_diag( '404' );
test_diag( qq{File `$abs_path' does not exist} );
my $ok = $mech->head_ok( $badurl->as_string, 'Try to HEAD bad URL' );
test_test( 'Fails to HEAD nonexistent URI and reports failure' );
is( ref($ok), '', 'head_ok() should only return a scalar' );
ok( !$ok, 'And the result should be false' );
}
done_testing();
Test-WWW-Mechanize-1.50/t/pod-coverage.t 0000644 0001017 0000764 00000000354 13252250733 017127 0 ustar alester ispc #!perl -T
use strict;
use warnings;
use Test::More;
if ( not eval 'use Test::Pod::Coverage 0.08;' ) {
plan skip_all => 'Test::Pod::Coverage 0.08 required for testing POD coverage' if $@;
}
all_pod_coverage_ok();
done_testing();
Test-WWW-Mechanize-1.50/t/title_is.t 0000644 0001017 0000764 00000001313 13252250733 016364 0 ustar alester ispc #!perl -T
use strict;
use warnings;
use Test::More tests => 4;
use Test::Builder::Tester;
use URI::file;
use Test::WWW::Mechanize ();
my $mech=Test::WWW::Mechanize->new( autocheck => 0 );
isa_ok($mech,'Test::WWW::Mechanize');
# Good links.
my $uri = URI::file->new_abs( 't/good.html' )->as_string;
$mech->get_ok( $uri );
test_out( 'ok 1 - Is this the test page?' );
test_out( 'ok 2 - Title is "Test Page"' );
$mech->title_is( 'Test Page', 'Is this the test page?' );
$mech->title_is( 'Test Page' );
test_test( 'Finds the title OK' );
test_out( 'ok 1 - Is this like the test page?' );
$mech->title_like( qr/[tf]est (p)age/i, 'Is this like the test page?' );
test_test( 'Finds the title OK' );
done_testing();
Test-WWW-Mechanize-1.50/t/html_lint_ok.t 0000644 0001017 0000764 00000002022 13265202416 017230 0 ustar alester ispc #!perl -T
use strict;
use warnings;
use Test::Builder::Tester;
use Test::More;
use Test::WWW::Mechanize;
use URI::file;
BEGIN {
# Load HTML::Lint here for the imports
my $module = 'HTML::Lint 2.20';
if ( not eval "use $module; 1;" ) {
plan skip_all => "$module is not installed, cannot test html_lint_ok" if $@;
}
plan tests => 3;
}
GOOD_GET: {
my $mech = Test::WWW::Mechanize->new;
isa_ok( $mech, 'Test::WWW::Mechanize' );
my $uri = URI::file->new_abs( 't/bad.html' )->as_string;
$mech->get_ok( $uri, 'Fetching the file from disk' );
test_out( "not ok 1 - checking HTML ($uri)" );
test_fail( +6 );
test_err( "# HTML::Lint errors for $uri" );
test_err( '# (7:9) Unknown attribute "hrex" for tag ' );
test_err( '# (8:33) with no opening ' );
test_err( '# (9:5) at (8:9) is never closed' );
test_err( '# 3 errors on the page' );
$mech->html_lint_ok( 'checking HTML' );
test_test( 'Proper html_lint_ok results' );
}
done_testing();
exit 0;
Test-WWW-Mechanize-1.50/t/goodlinks.html 0000644 0001017 0000764 00000000375 13252250733 017251 0 ustar alester ispc
Test Page
Test 1Test 2Test 3
Test-WWW-Mechanize-1.50/t/badlinks.html 0000644 0001017 0000764 00000000411 13252250733 017036 0 ustar alester ispc
Test Page
Test Page
goodTestTestTest
Test-WWW-Mechanize-1.50/t/html_tidy_ok.t 0000644 0001017 0000764 00000001761 13265202416 017244 0 ustar alester ispc #!perl -T
use strict;
use warnings;
use Test::Builder::Tester;
use Test::More;
use Test::WWW::Mechanize;
use URI::file;
BEGIN {
my $module = 'HTML::Tidy5 1.00';
if ( not eval "use $module; 1;" ) {
plan skip_all => "$module is not installed, cannot test html_tidy_ok" if $@;
}
plan tests => 3;
}
GOOD_GET: {
my $mech = Test::WWW::Mechanize->new;
isa_ok( $mech, 'Test::WWW::Mechanize' );
my $uri = URI::file->new_abs( 't/bad.html' )->as_string;
$mech->get_ok( $uri, 'Fetching the file from disk' );
test_out( "not ok 1 - checking HTML ($uri)" );
test_fail( +6 );
test_err( "# HTML::Tidy5 messages for $uri" );
test_err( '# (1:1) Warning: missing declaration' );
test_err( '# (8:33) Warning: discarding unexpected ' );
test_err( '# (8:9) Warning: missing ' );
test_err( '# 3 messages on the page' );
$mech->html_tidy_ok( 'checking HTML' );
test_test( 'Proper html_tidy_ok results' );
}
done_testing();
exit 0;
Test-WWW-Mechanize-1.50/t/link_content.t 0000644 0001017 0000764 00000004671 13252250733 017251 0 ustar alester ispc #!perl -T
use strict;
use warnings;
use Test::More tests => 11;
use Test::Builder::Tester;
use URI::file;
use Test::WWW::Mechanize;
my $mech=Test::WWW::Mechanize->new();
isa_ok($mech,'Test::WWW::Mechanize');
my $uri = URI::file->new_abs( 't/goodlinks.html' )->as_string;
$mech->get_ok( $uri );
my @urls = $mech->links();
is( scalar @urls, 3, 'Got links from the HTTP server');
# test regex
test_out('not ok 1 - link_content_like');
test_fail(+2);
test_diag(q{ "blah" doesn't look much like a regex to me.});
$mech->link_content_like(\@urls,'blah','Testing the regex');
test_test('Handles bad regexs');
# like
test_out('ok 1 - Checking all page links contain: Test');
$mech->link_content_like(\@urls,qr/Test/,'Checking all page links contain: Test');
test_test('Handles All page links contents successful');
# like - default desc
my $re_string = ($] < 5.014) ? '(?-xism:Test)' : '(?^:Test)';
test_out('ok 1 - ' . scalar(@urls) . qq{ links are like "$re_string"} );
$mech->link_content_like(\@urls,qr/Test/);
test_test('Handles All page links contents successful - default desc');
test_out('not ok 1 - Checking all page link content failures');
test_fail(+4);
test_diag('goodlinks.html');
test_diag('badlinks.html');
test_diag('goodlinks.html');
$mech->link_content_like(\@urls,qr/BadTest/,'Checking all page link content failures');
test_test('Handles link content not found');
# unlike
# test regex
test_out('not ok 1 - link_content_unlike');
test_fail(+2);
test_diag(q{ "blah" doesn't look much like a regex to me.});
$mech->link_content_unlike(\@urls,'blah','Testing the regex');
test_test('Handles bad regexs');
test_out('ok 1 - Checking all page links do not contain: BadTest');
$mech->link_content_unlike(\@urls,qr/BadTest/,'Checking all page links do not contain: BadTest');
test_test('Handles All page links unlike contents successful');
# unlike - default desc
$re_string = ($] < 5.014) ? '(?-xism:BadTest)' : '(?^:BadTest)';
test_out('ok 1 - ' . scalar(@urls) . qq{ links are not like "$re_string"});
$mech->link_content_unlike(\@urls,qr/BadTest/);
test_test('Handles All page links unlike contents successful - default desc');
test_out('not ok 1 - Checking all page link unlike content failures');
test_fail(+4);
test_diag('goodlinks.html');
test_diag('badlinks.html');
test_diag('goodlinks.html');
$mech->link_content_unlike(\@urls,qr/Test/,'Checking all page link unlike content failures');
test_test('Handles link unlike content found');
done_testing();
Test-WWW-Mechanize-1.50/t/get_ok.t 0000644 0001017 0000764 00000002631 13252250733 016024 0 ustar alester ispc #!perl -T
use strict;
use warnings;
use Test::More tests => 10;
use Test::Builder::Tester;
use URI::file ();
use Test::WWW::Mechanize ();
my $mech = Test::WWW::Mechanize->new( autocheck => 0 );
isa_ok($mech,'Test::WWW::Mechanize');
GOOD_GET: {
my $goodlinks = URI::file->new_abs( 't/goodlinks.html' )->as_string;
$mech->get_ok($goodlinks);
test_out('ok 1 - Try to get goodlinks.html');
my $ok = $mech->get_ok($goodlinks, 'Try to get goodlinks.html');
test_test('Gets existing URI and reports success');
is( ref($ok), '', 'get_ok() should only return a scalar' );
ok( $ok, 'And the result should be true' );
# default desc
test_out("ok 1 - GET $goodlinks");
$mech->get_ok($goodlinks);
test_test('Gets existing URI and reports success - default desc');
}
BAD_GET: {
my $badurl = URI::file->new_abs('t/no-such-file');
my $abs_path = $badurl->file;
$mech->get( $badurl->as_string );
ok(!$mech->success, qq{sanity check: we can't load $badurl});
test_out( 'not ok 1 - Try to get bad URL' );
test_fail( +3 );
test_diag( '404' );
test_diag( qq{File `$abs_path' does not exist} );
my $ok = $mech->get_ok( $badurl->as_string, 'Try to get bad URL' );
test_test( 'Fails to get nonexistent URI and reports failure' );
is( ref($ok), '', 'get_ok() should only return a scalar' );
ok( !$ok, 'And the result should be false' );
}
done_testing();
Test-WWW-Mechanize-1.50/t/content_lacks.t 0000644 0001017 0000764 00000002012 13252250733 017374 0 ustar alester ispc #!perl -T
use strict;
use warnings;
use Test::More tests => 5;
use Test::Builder::Tester;
use URI::file;
use Test::WWW::Mechanize ();
my $mech=Test::WWW::Mechanize->new();
isa_ok($mech,'Test::WWW::Mechanize');
my $uri = URI::file->new_abs( 't/goodlinks.html' )->as_string;
$mech->get_ok( $uri );
# test regex
test_out( 'ok 1 - Does it say Mungo eats cheese?' );
$mech->content_lacks( 'Mungo eats cheese', 'Does it say Mungo eats cheese?' );
test_test( 'Finds the lacks' );
# default desc
test_out( 'ok 1 - Content lacks "Mungo eats cheese"' );
$mech->content_lacks( 'Mungo eats cheese');
test_test( 'Finds the lacks - default desc' );
test_out( q{not ok 1 - Shouldn't say it's a test page} );
test_fail(+4);
test_diag(q( searched: "\x{0a} \x{0a} Test Page"...) );
test_diag(q( and found: "Test Page") );
test_diag(q( at position: 33 (line 3 column 16)) );
$mech->content_lacks( 'Test Page', q{Shouldn't say it's a test page} );
test_test( 'Handles not finding it' );
done_testing();
Test-WWW-Mechanize-1.50/t/good.html 0000644 0001017 0000764 00000000320 13256217142 016177 0 ustar alester ispc
Test Page
Test Page
goodTest
Test-WWW-Mechanize-1.50/t/fluffy.html 0000644 0001017 0000764 00000000517 13252250733 016551 0 ustar alester ispc
Test Page
This page has valid structure, but contains errors that HTML::Lint
categorizes as fluff.
goodTest
Test-WWW-Mechanize-1.50/t/lacks_uncapped_inputs-bad.html 0000644 0001017 0000764 00000001236 13252250733 022357 0 ustar alester ispc
Title
Test-WWW-Mechanize-1.50/t/page_links_content.t 0000644 0001017 0000764 00000004067 13252250733 020427 0 ustar alester ispc #!perl -T
use strict;
use warnings;
use Test::More tests => 9;
use Test::Builder::Tester;
use URI::file;
use Test::WWW::Mechanize ();
use lib 't';
my $mech = Test::WWW::Mechanize->new();
isa_ok( $mech,'Test::WWW::Mechanize' );
my $uri = URI::file->new_abs( 't/goodlinks.html' )->as_string;
$mech->get_ok( $uri );
# test regex
test_out('not ok 1 - page_links_content_like');
test_fail(+2);
test_diag(q{ "blah" doesn't look much like a regex to me.});
$mech->page_links_content_like('blah','Testing the regex');
test_test('Handles bad regexs');
# like
test_out('ok 1 - Checking all page links contain: Test');
$mech->page_links_content_like(qr/Test/,'Checking all page links contain: Test');
test_test('Handles All page links contents successful');
# like - default desc
my $re_string = ($] < 5.014) ? '(?-xism:Test)' : '(?^:Test)';
test_out(qq{ok 1 - All links are like "$re_string"});
$mech->page_links_content_like(qr/Test/);
test_test('Handles All page links contents successful');
test_out('not ok 1 - Checking all page link content failures');
test_fail(+4);
test_diag('goodlinks.html');
test_diag('badlinks.html');
test_diag('goodlinks.html');
$mech->page_links_content_like(qr/BadTest/,'Checking all page link content failures');
test_test('Handles link content not found');
# unlike
# test regex
test_out('not ok 1 - page_links_content_unlike');
test_fail(+2);
test_diag(q{ "blah" doesn't look much like a regex to me.});
$mech->page_links_content_unlike('blah','Testing the regex');
test_test('Handles bad regexs');
test_out('ok 1 - Checking all page links do not contain: BadTest');
$mech->page_links_content_unlike(qr/BadTest/,'Checking all page links do not contain: BadTest');
test_test('Handles All page links unlike contents successful');
test_out('not ok 1 - Checking all page link unlike content failures');
test_fail(+4);
test_diag('goodlinks.html');
test_diag('badlinks.html');
test_diag('goodlinks.html');
$mech->page_links_content_unlike(qr/Test/,'Checking all page link unlike content failures');
test_test('Handles link unlike content found');
done_testing();
Test-WWW-Mechanize-1.50/t/table.html 0000644 0001017 0000764 00000001316 13252250733 016343 0 ustar alester ispc
nested table for mech
Test 1Blah blahSecureMail your complaintsGet your distroTest 2Test 3
Test-WWW-Mechanize-1.50/t/00-load.t 0000644 0001017 0000764 00000001167 13265202416 015712 0 ustar alester ispc #!perl -T
use warnings;
use strict;
use Test::More tests => 1;
use LWP;
use WWW::Mechanize;
use Test::WWW::Mechanize;
pass( 'Modules loaded' );
diag( "Testing Test::WWW::Mechanize $Test::WWW::Mechanize::VERSION, with WWW::Mechanize $WWW::Mechanize::VERSION, LWP $LWP::VERSION, Test::More $Test::More::VERSION, Perl $], $^X" );
for my $module ( qw( HTML::Lint HTML::Tidy5 ) ) {
my $rc = eval "use $module; 1;";
if ( $rc ) {
no strict 'refs';
my $version = ${"${module}::VERSION"};
diag( "Found $module $version" );
}
else {
diag( "No $module found." );
}
}
done_testing();
Test-WWW-Mechanize-1.50/t/link_status.t 0000644 0001017 0000764 00000002760 13252250733 017117 0 ustar alester ispc #!perl -T
use strict;
use warnings;
use Test::More tests => 9;
use Test::Builder::Tester;
use URI::file;
use Test::WWW::Mechanize ();
my $mech = Test::WWW::Mechanize->new( autocheck => 0 );
isa_ok( $mech,'Test::WWW::Mechanize' );
my $uri = URI::file->new_abs( 't/goodlinks.html' )->as_string;
$mech->get_ok( $uri );
# Good links.
my $links=$mech->links();
test_out('ok 1 - Checking all links status are 200');
$mech->link_status_is($links,200,'Checking all links status are 200');
test_test('Handles All Links successful');
# Good links - Default desc
test_out('ok 1 - ' . scalar(@{$links}) . ' links have status 200');
$mech->link_status_is($links,200);
test_test('Handles All Links successful - default desc');
$mech->link_status_isnt($links,404,'Checking all links isnt');
# Bad links
$uri = URI::file->new_abs( 't/badlinks.html' )->as_string;
$mech->get_ok( $uri );
$links=$mech->links();
test_out('not ok 1 - Checking all links some bad');
test_fail(+2);
test_diag('goodlinks.html');
$mech->link_status_is($links,404,'Checking all links some bad');
test_test('Handles bad links');
test_out('not ok 1 - Checking specified link not found');
test_fail(+2);
test_diag('test2.html');
$mech->links_ok('test2.html','Checking specified link not found');
test_test('Handles link not found');
test_out('not ok 1 - Checking all links not 200');
test_fail(+2);
test_diag('goodlinks.html');
$mech->link_status_isnt($links,200,'Checking all links not 200');
test_test('Handles all links mismatch');
done_testing();
Test-WWW-Mechanize-1.50/t/stuff_inputs.t 0000644 0001017 0000764 00000011164 13252250733 017306 0 ustar alester ispc #!perl -T
use strict;
use warnings;
use Test::More tests => 43;
use URI::file;
use Test::WWW::Mechanize ();
MAIN: {
my $mech = Test::WWW::Mechanize->new();
my $uri = URI::file->new_abs( 't/stuff_inputs.html' )->as_string;
EMPTY_FIELDS: {
$mech->get_ok( $uri ) or die;
add_test_fields( $mech );
$mech->stuff_inputs();
field_checks(
$mech, {
text0 => '',
text1 => '@',
text10 => '@' x 10,
text70k => '@' x 70_000,
textunlimited => '@' x 66_000,
textarea => '@' x 66_000,
},
'filling empty fields'
);
}
MULTICHAR_FILL: {
$mech->get_ok( $uri ) or die;
add_test_fields( $mech );
$mech->stuff_inputs( { fill => '123' } );
field_checks(
$mech, {
text0 => '',
text1 => '1',
text10 => '1231231231',
text70k => ('123' x 23_333) . '1',
textunlimited => '123' x 22_000,
textarea => '123' x 22_000,
},
'multichar_fill'
);
}
OVERWRITE: {
$mech->get_ok( $uri ) or die;
add_test_fields( $mech );
$mech->stuff_inputs();
is( $mech->value('text10'), '@' x 10, 'overwriting fields: initial fill as expected' );
$mech->stuff_inputs( { fill => 'X' } );
field_checks(
$mech, {
text0 => '',
text1 => 'X',
text10 => 'X' x 10,
text70k => 'X' x 70_000,
textunlimited => 'X' x 66_000,
textarea => 'X' x 66_000,
},
'overwriting fields'
);
}
CUSTOM_FILL: {
$mech->get_ok( $uri ) or die;
add_test_fields( $mech );
$mech->stuff_inputs( {
fill => 'z',
specs => {
text10 => { fill=>'#' },
textarea => { fill=>'*' },
}
} );
field_checks(
$mech, {
text0 => '',
text1 => 'z',
text10 => '#' x 10,
text70k => 'z' x 70_000,
textunlimited => 'z' x 66_000,
textarea => '*' x 66_000,
},
'custom fill'
);
}
MAXLENGTH: {
$mech->get_ok( $uri ) or die;
add_test_fields( $mech );
$mech->stuff_inputs( {
specs => {
text10 => { maxlength=>7 },
textarea => { fill=>'*', maxlength=>9 },
}
}
);
field_checks(
$mech, {
text0 => '',
text1 => '@',
text10 => '@' x 7,
text70k => '@' x 70_000,
textunlimited => '@' x 66_000,
textarea => '*' x 9,
},
'maxlength'
);
}
IGNORE: {
$mech->get_ok( $uri ) or die;
add_test_fields( $mech );
$mech->stuff_inputs( { ignore => [ 'text10' ] } );
field_checks(
$mech, {
text0 => '',
text1 => '@',
text10 => undef,
text70k => '@' x 70_000,
textunlimited => '@' x 66_000,
textarea => '@' x 66_000,
},
'ignore'
);
}
}
done_testing();
sub add_test_fields {
my $mech = shift;
HTML::Form::Input->new( type=>'text', name=>'text0', maxlength=>0 )->add_to_form( $mech->current_form() );
HTML::Form::Input->new( type=>'text', name=>'text1', maxlength=>1 )->add_to_form( $mech->current_form() );
HTML::Form::Input->new( type=>'text', name=>'text10', maxlength=>10 )->add_to_form( $mech->current_form() );
HTML::Form::Input->new( type=>'text', name=>'text70k', maxlength=>70_000 )->add_to_form( $mech->current_form() );
HTML::Form::Input->new( type=>'text', name=>'textunlimited' )->add_to_form( $mech->current_form() );
HTML::Form::Input->new( type=>'textarea', name=>'textarea' )->add_to_form( $mech->current_form() );
return;
}
sub field_checks {
my $mech = shift;
my $expected = shift;
my $desc = shift;
foreach my $key ( qw( text0 text1 text10 text70k textunlimited textarea ) ) {
is( $mech->value($key), $expected->{$key}, "$desc: field $key" );
}
return;
}
Test-WWW-Mechanize-1.50/t/new.t 0000644 0001017 0000764 00000001516 13252250733 015346 0 ustar alester ispc #!perl -T
use warnings;
use strict;
use Test::More tests => 2;
use Test::WWW::Mechanize ();
subtest 'basic new' => sub {
my $mech = Test::WWW::Mechanize->new;
isa_ok( $mech, 'Test::WWW::Mechanize' );
};
# Stolen from WWW::Mechanize's t/new.t.
# If this works, then subclassing works OK.
subtest 'constructor parms' => sub {
my $alias = 'Windows IE 6';
my $mech = Test::WWW::Mechanize->new( agent => $alias );
isa_ok( $mech, 'Test::WWW::Mechanize' );
can_ok( $mech, 'request' );
is( $mech->agent, $alias, q{Aliases don't get translated in the constructor} );
$mech->agent_alias( $alias );
like( $mech->agent, qr/^Mozilla.+compatible.+Windows/, 'Alias sets the agent' );
$mech->agent( 'ratso/bongo v.43' );
is( $mech->agent, 'ratso/bongo v.43', 'Can still set the agent' );
};
done_testing();
Test-WWW-Mechanize-1.50/t/submit_form_ok.t 0000644 0001017 0000764 00000001010 13252250733 017561 0 ustar alester ispc #!perl -T
use strict;
use warnings;
use Test::More tests => 3;
use Test::Builder::Tester;
use Test::WWW::Mechanize ();
use lib 't';
use TestServer;
my $server = TestServer->new;
my $pid = $server->background;
my $server_root = $server->root;
SUBMIT_GOOD_FORM: {
my $mech = Test::WWW::Mechanize->new();
isa_ok( $mech,'Test::WWW::Mechanize' );
$mech->get_ok( "$server_root/form.html" );
$mech->submit_form_ok( {form_number =>1}, 'Submit First Form' );
}
$server->stop;
done_testing();
Test-WWW-Mechanize-1.50/t/head_ok-parms.t 0000644 0001017 0000764 00000002372 13252250733 017270 0 ustar alester ispc #!perl -T
use strict;
use warnings;
use Test::More tests => 15;
use Test::Builder::Tester;
use Test::WWW::Mechanize;
my $ua_args;
sub Test::WWW::Mechanize::success { return 1; }
sub Test::WWW::Mechanize::head {
my $self = shift;
my $url = shift;
die 'Odd number of args sent in' if @_ % 2 != 0;
$ua_args = {@_};
return 1;
}
my $mech = Test::WWW::Mechanize->new();
isa_ok( $mech, 'Test::WWW::Mechanize' );
my $url = 'dummy://url';
$mech->head_ok( $url );
ok( eq_hash( {}, $ua_args ), 'passing URL only' );
$mech->head_ok( $url, 'Description' );
ok( eq_hash( {}, $ua_args ), 'Passing description' );
$mech->head_ok( $url, undef, 'Description' );
ok( eq_hash( {}, $ua_args ), 'Passing undef for hash' );
my $wanted = { foo=>1, bar=>2, baz=>3 };
$mech->head_ok( $url, [ %{$wanted} ] );
ok( eq_hash( $wanted, $ua_args ), 'Passing anonymous list for hash' );
$mech->head_ok( $url, [ %{$wanted} ], 'Description' );
ok( eq_hash( $wanted, $ua_args ), 'Passing anonymous list for hash' );
$mech->head_ok( $url, { %{$wanted} } );
ok( eq_hash( $wanted, $ua_args ), 'Passing anonymous array for hash' );
$mech->head_ok( $url, { %{$wanted} }, 'Description' );
ok( eq_hash( $wanted, $ua_args ), 'Passing anonymous array for hash' );
done_testing ();
Test-WWW-Mechanize-1.50/t/has_tag.t 0000644 0001017 0000764 00000004602 13252250733 016162 0 ustar alester ispc #!perl -T
use strict;
use warnings;
use Test::More tests => 15;
use Test::Builder::Tester;
use URI::file;
use Test::WWW::Mechanize ();
my $mech = Test::WWW::Mechanize->new();
isa_ok($mech,'Test::WWW::Mechanize');
my $uri = URI::file->new_abs( 't/goodlinks.html' )->as_string;
$mech->get_ok( $uri );
test_out( 'ok 1 - looking for "Test" link' );
$mech->has_tag( h1 => 'Test Page', 'looking for "Test" link' );
test_test( 'Handles finding tag by content' );
# default desc
test_out( 'ok 1 - Page has h1 tag with "Test Page"' );
$mech->has_tag( h1 => 'Test Page' );
test_test( 'Handles finding tag by content - default desc' );
test_out( 'not ok 1 - looking for "Quiz" link' );
test_fail( +1 );
$mech->has_tag( h1 => 'Quiz', 'looking for "Quiz" link' );
test_test( 'Handles unfindable tag by content' );
test_out( 'ok 1 - Should have qr/Test 3/i link' );
$mech->has_tag_like( a => qr/Test 3/, 'Should have qr/Test 3/i link' );
test_test( 'Handles finding tag by content regexp' );
test_out( 'not ok 1 - Should be missing qr/goof/i link' );
test_fail( +1 );
$mech->has_tag_like( a => qr/goof/i, 'Should be missing qr/goof/i link' );
test_test( 'Handles unfindable tag by content regexp' );
## nested table tag
my $table_uri = URI::file->new_abs( 't/table.html' )->as_string;
$mech->get_ok( $table_uri );
test_out( 'ok 1 - Page has td tag with "Foobar"' );
$mech->has_tag('td' => 'Foobar' );
test_test( 'Handles finding text in table data tag' );
test_out( 'ok 1 - User company' );
$mech->has_tag('td', 'company', 'User company');
test_test( 'Handles finding text in nested table data tag' );
test_out( 'ok 1 - Page has td tag with "company,email,employee,website"' );
$mech->has_tag('td', 'company,email,employee,website');
test_test( 'Handles finding text in nested table data second tag' );
test_out( 'ok 1 - Page has th tag with "Groups"' );
$mech->has_tag('th', 'Groups');
test_test( 'Handles finding text in nested table header' );
test_out( 'ok 1 - Page has h3 tag with "Show all users and groups"' );
$mech->has_tag('h3', 'Show all users and groups');
test_test( 'Handles finding text in h3 in table' );
test_out( 'ok 1 - Page has p tag with "Its been said:"' );
$mech->has_tag('p', 'Its been said:');
test_test( 'Checks finding text in sub inline element in p' );
test_out( 'ok 1 - Page has p tag with "Hi"');
$mech->has_tag( 'p', 'Hi' );
test_test( "Finding text in sub inline element in p" );
done_testing();
Test-WWW-Mechanize-1.50/t/lacks_uncapped_inputs.t 0000644 0001017 0000764 00000002137 13252250733 021133 0 ustar alester ispc #!perl -T
use strict;
use warnings;
use Test::More tests => 5;
use Test::Builder::Tester;
use URI::file;
use Test::WWW::Mechanize ();
my $mech = Test::WWW::Mechanize->new();
isa_ok( $mech,'Test::WWW::Mechanize' );
GOOD: {
my $uri = URI::file->new_abs( 't/lacks_uncapped_inputs-good.html' )->as_string;
$mech->get_ok( $uri ) or die;
test_out( 'ok 1 - This should have no failures' );
$mech->lacks_uncapped_inputs( 'This should have no failures' );
test_test( 'Finds the lacks' );
}
BAD: {
my $uri = URI::file->new_abs( 't/lacks_uncapped_inputs-bad.html' )->as_string;
$mech->get_ok( $uri ) or die;
test_out( 'not ok 1 - This should have three errors found' );
test_fail( +6 );
test_diag( q{ got: 3} );
test_diag( q{ expected: 0} );
test_diag( q{foo has no maxlength attribute} );
test_diag( q{quux has an invalid maxlength attribute of "dogs"} );
test_diag( q{crunchy has an invalid maxlength attribute of "-1"} );
$mech->lacks_uncapped_inputs( 'This should have three errors found' );
test_test( 'Detect uncapped' );
}
done_testing();
Test-WWW-Mechanize-1.50/Mechanize.pm 0000644 0001017 0000764 00000144342 13265202416 016372 0 ustar alester ispc package Test::WWW::Mechanize;
use strict;
use warnings;
=head1 NAME
Test::WWW::Mechanize - Testing-specific WWW::Mechanize subclass
=head1 VERSION
Version 1.50
=cut
our $VERSION = '1.50';
=head1 SYNOPSIS
Test::WWW::Mechanize is a subclass of L that incorporates
features for web application testing. For example:
use Test::More tests => 5;
use Test::WWW::Mechanize;
my $mech = Test::WWW::Mechanize->new;
$mech->get_ok( $page );
$mech->base_is( 'http://petdance.com/', 'Proper ' );
$mech->title_is( 'Invoice Status', "Make sure we're on the invoice page" );
$mech->text_contains( 'Andy Lester', 'My name somewhere' );
$mech->content_like( qr/(cpan|perl)\.org/, 'Link to perl.org or CPAN' );
This is equivalent to:
use Test::More tests => 5;
use WWW::Mechanize;
my $mech = WWW::Mechanize->new;
$mech->get( $page );
ok( $mech->success );
is( $mech->base, 'http://petdance.com', 'Proper ' );
is( $mech->title, 'Invoice Status', "Make sure we're on the invoice page" );
ok( index( $mech->content( format => 'text' ), 'Andy Lester' ) >= 0, 'My name somewhere' );
like( $mech->content, qr/(cpan|perl)\.org/, 'Link to perl.org or CPAN' );
but has nicer diagnostics if they fail.
Default descriptions will be supplied for most methods if you omit them. e.g.
my $mech = Test::WWW::Mechanize->new;
$mech->get_ok( 'http://petdance.com/' );
$mech->base_is( 'http://petdance.com/' );
$mech->title_is( 'Invoice Status' );
$mech->content_contains( 'Andy Lester' );
$mech->content_like( qr/(cpan|perl)\.org/ );
results in
ok - Got 'http://petdance.com/' ok
ok - Base is 'http://petdance.com/'
ok - Title is 'Invoice Status'
ok - Text contains 'Andy Lester'
ok - Content is like '(?-xism:(cpan|perl)\.org)'
=cut
use HTML::TokeParser ();
use WWW::Mechanize ();
use Test::LongString;
use Test::Builder ();
use Carp ();
use Carp::Assert::More;
use parent 'WWW::Mechanize';
my $TB = Test::Builder->new();
=head1 CONSTRUCTOR
=head2 new( %args )
Behaves like, and calls, L's C method. Any parms
passed in get passed to WWW::Mechanize's constructor.
You can pass in C<< autolint => 1 >> to make Test::WWW::Mechanize
automatically run HTML::Lint after any of the following methods are
called. You can also pass in an HTML::Lint object like this:
my $lint = HTML::Lint->new( only_types => HTML::Lint::Error::STRUCTURE );
my $mech = Test::WWW::Mechanize->new( autolint => $lint );
The same is also possible with C<< autotidy => 1 >> to use HTML::Tidy5.
=over
=item * get_ok()
=item * post_ok()
=item * submit_form_ok()
=item * follow_link_ok()
=item * click_ok()
=back
This means you no longer have to do the following:
my $mech = Test::WWW::Mechanize->new();
$mech->get_ok( $url, 'Fetch the intro page' );
$mech->html_lint_ok( 'Intro page looks OK' );
and can simply do
my $mech = Test::WWW::Mechanize->new( autolint => 1 );
$mech->get_ok( $url, 'Fetch the intro page' );
The C<< $mech->get_ok() >> only counts as one test in the test count. Both the
main IO operation and the linting must pass for the entire test to pass.
You can control autolint and autotidy on the fly with the C
and C methods.
=cut
sub new {
my $class = shift;
my %args = (
agent => "Test-WWW-Mechanize/$VERSION",
@_
);
my $autolint = delete $args{autolint};
my $autotidy = delete $args{autotidy};
my $self = $class->SUPER::new( %args );
$self->autolint( $autolint );
$self->autotidy( $autotidy );
return $self;
}
=head1 METHODS: HTTP VERBS
=head2 $mech->get_ok($url, [ \%LWP_options ,] $desc)
A wrapper around WWW::Mechanize's get(), with similar options, except
the second argument needs to be a hash reference, not a hash. Like
well-behaved C<*_ok()> functions, it returns true if the test passed,
or false if not.
A default description of "GET $url" is used if none if provided.
=cut
sub get_ok {
my $self = shift;
my ($url,$desc,%opts) = $self->_unpack_args( 'GET', @_ );
$self->get( $url, %opts );
my $ok = $self->success;
$ok = $self->_post_load_validation( $ok, $desc );
return $ok;
}
sub _post_load_validation {
my $self = shift;
my $ok = shift;
my $desc = shift;
local $Test::Builder::Level = $Test::Builder::Level + 1;
if ( $ok ) {
my $emitted_ok = 0;
if ( $self->is_html ) {
if ( $self->autolint && $self->autotidy ) {
my $msg = 'autolint & autotidy';
$msg .= ": $desc" if defined $desc;
$TB->subtest(
$desc,
sub {
$self->_lint_content_ok();
$self->_tidy_content_ok();
}
);
++$emitted_ok;
}
else {
if ( $self->autolint ) {
$ok = $self->_lint_content_ok( $desc );
++$emitted_ok;
}
elsif ( $self->autotidy ) {
$ok = $self->_tidy_content_ok( $desc );
++$emitted_ok;
}
}
}
if ( !$emitted_ok ) {
$TB->ok( $ok, $desc );
}
}
else {
$TB->ok( $ok, $desc );
$TB->diag( $self->status );
$TB->diag( $self->response->message ) if $self->response;
}
return $ok;
}
=head2 $mech->head_ok($url, [ \%LWP_options ,] $desc)
A wrapper around WWW::Mechanize's head(), with similar options, except
the second argument needs to be a hash reference, not a hash. Like
well-behaved C<*_ok()> functions, it returns true if the test passed,
or false if not.
A default description of "HEAD $url" is used if none if provided.
=cut
sub head_ok {
my $self = shift;
my ($url,$desc,%opts) = $self->_unpack_args( 'HEAD', @_ );
$self->head( $url, %opts );
my $ok = $self->success;
$TB->ok( $ok, $desc );
if ( !$ok ) {
$TB->diag( $self->status );
$TB->diag( $self->response->message ) if $self->response;
}
return $ok;
}
=head2 $mech->post_ok( $url, [ \%LWP_options ,] $desc )
A wrapper around WWW::Mechanize's post(), with similar options, except
the second argument needs to be a hash reference, not a hash. Like
well-behaved C<*_ok()> functions, it returns true if the test passed,
or false if not.
B Due to compatibility reasons it is not possible to pass
additional LWP_options beyond form data via this method (such as
Content or Content-Type). It is recommend that you use WWW::Mechanize's
post() directly for instances where more granular control of the post
is needed.
A default description of "POST to $url" is used if none if provided.
=cut
sub post_ok {
my $self = shift;
my ($url,$desc,%opts) = $self->_unpack_args( 'POST', @_ );
$self->post( $url, \%opts );
my $ok = $self->success;
$ok = $self->_post_load_validation( $ok, $desc );
return $ok;
}
=head2 $mech->put_ok( $url, [ \%LWP_options ,] $desc )
A wrapper around WWW::Mechanize's put(), with similar options, except
the second argument needs to be a hash reference, not a hash. Like
well-behaved C<*_ok()> functions, it returns true if the test passed,
or false if not.
A default description of "PUT to $url" is used if none if provided.
=cut
sub put_ok {
my $self = shift;
my ($url,$desc,%opts) = $self->_unpack_args( 'PUT', @_ );
$opts{content} = '' if !exists $opts{content};
$self->put( $url, %opts );
my $ok = $self->success;
$TB->ok( $ok, $desc );
if ( !$ok ) {
$TB->diag( $self->status );
$TB->diag( $self->response->message ) if $self->response;
}
return $ok;
}
=head2 $mech->delete_ok( $url, [ \%LWP_options ,] $desc )
A wrapper around WWW::Mechanize's delete(), with similar options, except
the second argument needs to be a hash reference, not a hash. Like
well-behaved C<*_ok()> functions, it returns true if the test passed,
or false if not.
A default description of "DELETE to $url" is used if none if provided.
=cut
sub delete_ok {
my $self = shift;
my ($url,$desc,%opts) = $self->_unpack_args( 'DELETE', @_ );
if ($self->can('delete')) {
$self->delete( $url, %opts );
}
else {
# When version of LWP::UserAgent is older than 6.04.
$self->_delete( $url, %opts );
}
my $ok = $self->success;
$ok = $self->_post_load_validation( $ok, $desc );
return $ok;
}
sub _delete {
require URI;
require HTTP::Request::Common;
my $self = shift;
my $uri = shift;
$uri = $uri->url if ref($uri) eq 'WWW::Mechanize::Link';
$uri = $self->base
? URI->new_abs( $uri, $self->base )
: URI->new($uri);
my @parameters = ( $uri->as_string, @_ );
my @suff = $self->_process_colonic_headers( \@parameters, 1 );
return $self->request( HTTP::Request::Common::DELETE(@parameters), @suff );
}
=head2 $mech->submit_form_ok( \%parms [, $desc] )
Makes a C call and executes tests on the results.
The form must be found, and then submitted successfully. Otherwise,
this test fails.
I<%parms> is a hashref containing the parms to pass to C.
Note that the parms to C are a hash whereas the parms to
this function are a hashref. You have to call this function like:
$mech->submit_form_ok( {
form_number => 3,
fields => {
answer => 42
},
}, 'now we just need the question'
);
As with other test functions, C<$desc> is optional. If it is supplied
then it will display when running the test harness in verbose mode.
Returns true value if the specified link was found and followed
successfully. The L object returned by submit_form()
is not available.
=cut
sub submit_form_ok {
my $self = shift;
my $parms = shift || {};
my $desc = shift;
if ( ref $parms ne 'HASH' ) {
Carp::croak 'FATAL: parameters must be given as a hashref';
}
# return from submit_form() is an HTTP::Response or undef
my $response = $self->submit_form( %{$parms} );
my $ok = $response && $response->is_success;
$ok = $self->_post_load_validation( $ok, $desc );
return $ok;
}
=head2 $mech->follow_link_ok( \%parms [, $desc] )
Makes a C call and executes tests on the results.
The link must be found, and then followed successfully. Otherwise,
this test fails.
I<%parms> is a hashref containing the parms to pass to C.
Note that the parms to C are a hash whereas the parms to
this function are a hashref. You have to call this function like:
$mech->follow_link_ok( {n=>3}, 'looking for 3rd link' );
As with other test functions, C<$desc> is optional. If it is supplied
then it will display when running the test harness in verbose mode.
Returns a true value if the specified link was found and followed
successfully. The L object returned by follow_link()
is not available.
=cut
sub follow_link_ok {
my $self = shift;
my $parms = shift || {};
my $desc = shift;
if (!defined($desc)) {
my $parms_str = join(', ', map { join('=', $_, $parms->{$_}) } keys(%{$parms}));
$desc = qq{Followed link with "$parms_str"} if !defined($desc);
}
if ( ref $parms ne 'HASH' ) {
Carp::croak 'FATAL: parameters must be given as a hashref';
}
# return from follow_link() is an HTTP::Response or undef
my $response = $self->follow_link( %{$parms} );
my $ok = $response && $response->is_success;
$ok = $self->_post_load_validation( $ok, $desc );
return $ok;
}
=head2 $mech->click_ok( $button[, $desc] )
Clicks the button named by C<$button>. An optional C<$desc> can
be given for the test.
=cut
sub click_ok {
my $self = shift;
my $button = shift;
my $desc = shift;
my $response = $self->click( $button );
if ( !$response ) {
return $TB->ok( 0, $desc );
}
my $ok = $response->is_success;
$ok = $self->_post_load_validation( $ok, $desc );
return $ok;
}
sub _unpack_args {
my $self = shift;
my $method = shift;
my $url = shift;
my $desc;
my %opts;
if ( @_ ) {
my $flex = shift; # The flexible argument
if ( !defined( $flex ) ) {
$desc = shift;
}
elsif ( ref $flex eq 'HASH' ) {
%opts = %{$flex};
$desc = shift;
}
elsif ( ref $flex eq 'ARRAY' ) {
%opts = @{$flex};
$desc = shift;
}
else {
$desc = $flex;
}
} # parms left
if ( not defined $desc ) {
$url = $url->url if ref($url) eq 'WWW::Mechanize::Link';
$desc = "$method $url";
}
return ($url, $desc, %opts);
}
=head1 METHODS: HEADER CHECKING
=head2 $mech->header_exists_ok( $header [, $desc ] )
Assures that a given response header exists. The actual value of the
response header is not checked, only that the header exists.
=cut
sub header_exists_ok {
my $self = shift;
my $header = shift;
my $desc = shift || qq{Response has $header header};
return $TB->ok( defined($self->response->header($header)), $desc );
}
=head2 $mech->lacks_header_ok( $header [, $desc ] )
Assures that a given response header does NOT exist.
=cut
sub lacks_header_ok {
my $self = shift;
my $header = shift;
my $desc = shift || qq{Response lacks $header header};
return $TB->ok( !defined($self->response->header($header)), $desc );
}
=head2 $mech->header_is( $header, $value [, $desc ] )
Assures that a given response header exists and has the given value.
=cut
sub header_is {
my $self = shift;
my $header = shift;
my $value = shift;
my $desc = shift || qq{Response has $header header with value "$value"};
# Force scalar context.
my $actual_value = $self->response->header($header);
my $ok;
if ( defined( $actual_value ) ) {
$ok = $TB->is_eq( $actual_value, $value, $desc );
}
else {
$ok = $TB->ok( 0, $desc );
$TB->diag( "Header $header does not exist" );
}
return $ok;
}
=head2 $mech->header_like( $header, $value [, $desc ] )
Assures that a given response header exists and has the given value.
=cut
sub header_like {
my $self = shift;
my $header = shift;
my $regex = shift;
my $desc = shift || qq{Response has $header header that matches regex $regex};
# Force scalar context.
my $actual_value = $self->response->header($header);
return $TB->like( $self->response->header($header), $regex, $desc );
}
=head1 METHODS: CONTENT CHECKING
=head2 $mech->html_lint_ok( [$desc] )
Checks the validity of the HTML on the current page using the HTML::Lint
module. If the page is not HTML, then it fails. The URI is automatically
appended to the I<$desc>.
Note that HTML::Lint must be installed for this to work. Otherwise,
it will blow up.
=cut
sub html_lint_ok {
my $self = shift;
my $desc = shift;
my $uri = $self->uri;
$desc = $desc ? "$desc ($uri)" : $uri;
my $ok;
if ( $self->is_html ) {
$ok = $self->_lint_content_ok( $desc );
}
else {
$ok = $TB->ok( 0, $desc );
$TB->diag( q{This page doesn't appear to be HTML, or didn't get the proper text/html content type returned.} );
}
return $ok;
}
sub _lint_content_ok {
local $Test::Builder::Level = $Test::Builder::Level + 1;
my $self = shift;
my $desc = shift;
my $module = "HTML::Lint 2.20";
if ( not ( eval "use $module; 1;" ) ) {
die "Test::WWW::Mechanize can't do linting without $module: $@";
}
my $lint = $self->{autolint};
if ( ref $lint && $lint->isa('HTML::Lint') ) {
$lint->newfile;
$lint->clear_errors;
}
else {
$lint = HTML::Lint->new();
}
$lint->parse( $self->content );
$lint->eof();
my @errors = $lint->errors;
my $nerrors = @errors;
my $ok;
if ( $nerrors ) {
$ok = $TB->ok( 0, $desc );
$TB->diag( 'HTML::Lint errors for ' . $self->uri );
$TB->diag( $_->as_string ) for @errors;
my $s = $nerrors == 1 ? '' : 's';
$TB->diag( "$nerrors error$s on the page" );
}
else {
$ok = $TB->ok( 1, $desc );
}
return $ok;
}
=head2 $mech->html_tidy_ok( [$desc] )
Checks the validity of the HTML on the current page using the HTML::Tidy
module. If the page is not HTML, then it fails. The URI is automatically
appended to the I<$desc>.
Note that HTML::tidy must be installed for this to work. Otherwise,
it will blow up.
=cut
sub html_tidy_ok {
my $self = shift;
my $desc = shift;
my $uri = $self->uri;
$desc = $desc ? "$desc ($uri)" : $uri;
my $ok;
if ( $self->is_html ) {
$ok = $self->_tidy_content_ok( $desc );
}
else {
$ok = $TB->ok( 0, $desc );
$TB->diag( q{This page doesn't appear to be HTML, or didn't get the proper text/html content type returned.} );
}
return $ok;
}
sub _tidy_content_ok {
local $Test::Builder::Level = $Test::Builder::Level + 1;
my $self = shift;
my $desc = shift;
my $module = 'HTML::Tidy5 1.00';
if ( not ( eval "use $module; 1;" ) ) {
die "Test::WWW::Mechanize can't do tidying without $module: $@";
}
my $tidy = $self->{autotidy};
if ( ref $tidy && $tidy->isa('HTML::Tidy5') ) {
$tidy->clear_messages();
}
else {
$tidy = HTML::Tidy5->new();
}
$tidy->parse( '', $self->content );
my @messages = $tidy->messages;
my $nmessages = @messages;
my $ok;
if ( $nmessages ) {
$ok = $TB->ok( 0, $desc );
$TB->diag( 'HTML::Tidy5 messages for ' . $self->uri );
$TB->diag( $_->as_string ) for @messages;
my $s = $nmessages == 1 ? '' : 's';
$TB->diag( "$nmessages message$s on the page" );
}
else {
$ok = $TB->ok( 1, $desc );
}
return $ok;
}
=head2 $mech->title_is( $str [, $desc ] )
Tells if the title of the page is the given string.
$mech->title_is( 'Invoice Summary' );
=cut
sub title_is {
my $self = shift;
my $str = shift;
my $desc = shift;
$desc = qq{Title is "$str"} if !defined($desc);
local $Test::Builder::Level = $Test::Builder::Level + 1;
return is_string( $self->title, $str, $desc );
}
=head2 $mech->title_like( $regex [, $desc ] )
Tells if the title of the page matches the given regex.
$mech->title_like( qr/Invoices for (.+)/ );
=cut
sub title_like {
my $self = shift;
my $regex = shift;
my $desc = shift;
$desc = qq{Title is like "$regex"} if !defined($desc);
local $Test::Builder::Level = $Test::Builder::Level + 1;
return like_string( $self->title, $regex, $desc );
}
=head2 $mech->title_unlike( $regex [, $desc ] )
Tells if the title of the page matches the given regex.
$mech->title_unlike( qr/Invoices for (.+)/ );
=cut
sub title_unlike {
my $self = shift;
my $regex = shift;
my $desc = shift;
$desc = qq{Title is unlike "$regex"} if !defined($desc);
local $Test::Builder::Level = $Test::Builder::Level + 1;
return unlike_string( $self->title, $regex, $desc );
}
=head2 $mech->base_is( $str [, $desc ] )
Tells if the base of the page is the given string.
$mech->base_is( 'http://example.com/' );
=cut
sub base_is {
my $self = shift;
my $str = shift;
my $desc = shift;
$desc = qq{Base is "$str"} if !defined($desc);
local $Test::Builder::Level = $Test::Builder::Level + 1;
return is_string( $self->base, $str, $desc );
}
=head2 $mech->base_like( $regex [, $desc ] )
Tells if the base of the page matches the given regex.
$mech->base_like( qr{http://example.com/index.php?PHPSESSID=(.+)});
=cut
sub base_like {
my $self = shift;
my $regex = shift;
my $desc = shift;
$desc = qq{Base is like "$regex"} if !defined($desc);
local $Test::Builder::Level = $Test::Builder::Level + 1;
return like_string( $self->base, $regex, $desc );
}
=head2 $mech->base_unlike( $regex [, $desc ] )
Tells if the base of the page matches the given regex.
$mech->base_unlike( qr{http://example.com/index.php?PHPSESSID=(.+)});
=cut
sub base_unlike {
my $self = shift;
my $regex = shift;
my $desc = shift;
$desc = qq{Base is unlike "$regex"} if !defined($desc);
local $Test::Builder::Level = $Test::Builder::Level + 1;
return unlike_string( $self->base, $regex, $desc );
}
=head2 $mech->content_is( $str [, $desc ] )
Tells if the content of the page matches the given string
=cut
sub content_is {
my $self = shift;
my $str = shift;
my $desc = shift;
local $Test::Builder::Level = $Test::Builder::Level + 1;
$desc = qq{Content is "$str"} if !defined($desc);
return is_string( $self->content, $str, $desc );
}
=head2 $mech->content_contains( $str [, $desc ] )
Tells if the content of the page contains I<$str>.
=cut
sub content_contains {
my $self = shift;
my $str = shift;
my $desc = shift;
local $Test::Builder::Level = $Test::Builder::Level + 1;
if ( ref($str) ) {
return $TB->ok( 0, 'Test::WWW::Mechanize->content_contains called incorrectly. It requires a scalar, not a reference.' );
}
$desc = qq{Content contains "$str"} if !defined($desc);
return contains_string( $self->content, $str, $desc );
}
=head2 $mech->content_lacks( $str [, $desc ] )
Tells if the content of the page lacks I<$str>.
=cut
sub content_lacks {
my $self = shift;
my $str = shift;
my $desc = shift;
local $Test::Builder::Level = $Test::Builder::Level + 1;
if ( ref($str) ) {
return $TB->ok( 0, 'Test::WWW::Mechanize->content_lacks called incorrectly. It requires a scalar, not a reference.' );
}
$desc = qq{Content lacks "$str"} if !defined($desc);
return lacks_string( $self->content, $str, $desc );
}
=head2 $mech->content_like( $regex [, $desc ] )
Tells if the content of the page matches I<$regex>.
=cut
sub content_like {
my $self = shift;
my $regex = shift;
my $desc = shift;
$desc = qq{Content is like "$regex"} if !defined($desc);
local $Test::Builder::Level = $Test::Builder::Level + 1;
return like_string( $self->content, $regex, $desc );
}
=head2 $mech->content_unlike( $regex [, $desc ] )
Tells if the content of the page does NOT match I<$regex>.
=cut
sub content_unlike {
my $self = shift;
my $regex = shift;
my $desc = shift || qq{Content is unlike "$regex"};
local $Test::Builder::Level = $Test::Builder::Level + 1;
return unlike_string( $self->content, $regex, $desc );
}
=head2 $mech->text_contains( $str [, $desc ] )
Tells if the text form of the page's content contains I<$str>.
When your page contains HTML which is difficult, unimportant, or
unlikely to match over time as designers alter markup, use
C instead of L.
# Hi, User!
$mech->content_contains('Hi, User'); # Fails.
$mech->text_contains('Hi, User'); # Passes.
Text is determined by calling C<< $mech->text() >>.
See L.
=cut
sub text_contains {
my $self = shift;
my $str = shift;
my $desc = shift || qq{Text contains "$str"};
local $Test::Builder::Level = $Test::Builder::Level + 1;
if ( ref($str) ) {
return $TB->ok( 0, 'Test::WWW::Mechanize->text_contains called incorrectly. It requires a scalar, not a reference.' );
}
return contains_string( $self->text, $str, $desc );
}
=head2 $mech->text_lacks( $str [, $desc ] )
Tells if the text of the page lacks I<$str>.
=cut
sub text_lacks {
my $self = shift;
my $str = shift;
my $desc = shift;
local $Test::Builder::Level = $Test::Builder::Level + 1;
if ( ref($str) ) {
return $TB->ok( 0, 'Test::WWW::Mechanize->text_lacks called incorrectly. It requires a scalar, not a reference.' );
}
$desc = qq{Text lacks "$str"} if !defined($desc);
return lacks_string( $self->text, $str, $desc );
}
=head2 $mech->text_like( $regex [, $desc ] )
Tells if the text form of the page's content matches I<$regex>.
=cut
sub text_like {
my $self = shift;
my $regex = shift;
my $desc = shift || qq{Text is like "$regex"};
local $Test::Builder::Level = $Test::Builder::Level + 1;
return like_string( $self->text, $regex, $desc );
}
=head2 $mech->text_unlike( $regex [, $desc ] )
Tells if the text format of the page's content does NOT match I<$regex>.
=cut
sub text_unlike {
my $self = shift;
my $regex = shift;
my $desc = shift || qq{Text is unlike "$regex"};
local $Test::Builder::Level = $Test::Builder::Level + 1;
return unlike_string( $self->text, $regex, $desc );
}
=head2 $mech->has_tag( $tag, $text [, $desc ] )
Tells if the page has a C<$tag> tag with the given content in its text.
=cut
sub has_tag {
my $self = shift;
my $tag = shift;
my $text = shift;
my $desc = shift || qq{Page has $tag tag with "$text"};
my $found = $self->_tag_walk( $tag, sub { $text eq $_[0] } );
return $TB->ok( $found, $desc );
}
=head2 $mech->has_tag_like( $tag, $regex [, $desc ] )
Tells if the page has a C<$tag> tag with the given content in its text.
=cut
sub has_tag_like {
my $self = shift;
my $tag = shift;
my $regex = shift;
my $desc = shift;
$desc = qq{Page has $tag tag like "$regex"} if !defined($desc);
my $found = $self->_tag_walk( $tag, sub { $_[0] =~ $regex } );
return $TB->ok( $found, $desc );
}
sub _tag_walk {
my $self = shift;
my $tag = shift;
my $match = shift;
my $p = HTML::TokeParser->new( \($self->content) );
while ( my $token = $p->get_tag( $tag ) ) {
my $tagtext = $p->get_trimmed_text();
return 1 if $match->( $tagtext );
}
return;
}
=head2 $mech->page_links_ok( [ $desc ] )
Follow all links on the current page and test for HTTP status 200
$mech->page_links_ok('Check all links');
=cut
sub page_links_ok {
my $self = shift;
my $desc = shift;
$desc = 'All links ok' unless defined $desc;
my @links = $self->followable_links();
my @urls = _format_links(\@links);
my @failures = $self->_check_links_status( \@urls );
my $ok = (@failures==0);
$TB->ok( $ok, $desc );
$TB->diag( $_ ) for @failures;
return $ok;
}
=head2 $mech->page_links_content_like( $regex [, $desc ] )
Follow all links on the current page and test their contents for I<$regex>.
$mech->page_links_content_like( qr/foo/,
'Check all links contain "foo"' );
=cut
sub page_links_content_like {
my $self = shift;
my $regex = shift;
my $desc = shift;
$desc = qq{All links are like "$regex"} unless defined $desc;
my $usable_regex=$TB->maybe_regex( $regex );
if ( !defined( $usable_regex ) ) {
my $ok = $TB->ok( 0, 'page_links_content_like' );
$TB->diag(qq{ "$regex" doesn't look much like a regex to me.});
return $ok;
}
my @links = $self->followable_links();
my @urls = _format_links(\@links);
my @failures = $self->_check_links_content( \@urls, $regex );
my $ok = (@failures==0);
$TB->ok( $ok, $desc );
$TB->diag( $_ ) for @failures;
return $ok;
}
=head2 $mech->page_links_content_unlike( $regex [, $desc ] )
Follow all links on the current page and test their contents do not
contain the specified regex.
$mech->page_links_content_unlike(qr/Restricted/,
'Check all links do not contain Restricted');
=cut
sub page_links_content_unlike {
my $self = shift;
my $regex = shift;
my $desc = shift;
$desc = qq{All links are unlike "$regex"} unless defined($desc);
my $usable_regex=$TB->maybe_regex( $regex );
if ( !defined( $usable_regex ) ) {
my $ok = $TB->ok( 0, 'page_links_content_unlike' );
$TB->diag(qq{ "$regex" doesn't look much like a regex to me.});
return $ok;
}
my @links = $self->followable_links();
my @urls = _format_links(\@links);
my @failures = $self->_check_links_content( \@urls, $regex, 'unlike' );
my $ok = (@failures==0);
$TB->ok( $ok, $desc );
$TB->diag( $_ ) for @failures;
return $ok;
}
=head2 $mech->links_ok( $links [, $desc ] )
Follow specified links on the current page and test for HTTP status
200. The links may be specified as a reference to an array containing
L objects, an array of URLs, or a scalar URL
name.
my @links = $mech->find_all_links( url_regex => qr/cnn\.com$/ );
$mech->links_ok( \@links, 'Check all links for cnn.com' );
my @links = qw( index.html search.html about.html );
$mech->links_ok( \@links, 'Check main links' );
$mech->links_ok( 'index.html', 'Check link to index' );
=cut
sub links_ok {
my $self = shift;
my $links = shift;
my $desc = shift;
my @urls = _format_links( $links );
$desc = _default_links_desc(\@urls, 'are ok') unless defined $desc;
my @failures = $self->_check_links_status( \@urls );
my $ok = (@failures == 0);
$TB->ok( $ok, $desc );
$TB->diag( $_ ) for @failures;
return $ok;
}
=head2 $mech->link_status_is( $links, $status [, $desc ] )
Follow specified links on the current page and test for HTTP status
passed. The links may be specified as a reference to an array
containing L objects, an array of URLs, or a
scalar URL name.
my @links = $mech->followable_links();
$mech->link_status_is( \@links, 403,
'Check all links are restricted' );
=cut
sub link_status_is {
my $self = shift;
my $links = shift;
my $status = shift;
my $desc = shift;
my @urls = _format_links( $links );
$desc = _default_links_desc(\@urls, "have status $status") if !defined($desc);
my @failures = $self->_check_links_status( \@urls, $status );
my $ok = (@failures == 0);
$TB->ok( $ok, $desc );
$TB->diag( $_ ) for @failures;
return $ok;
}
=head2 $mech->link_status_isnt( $links, $status [, $desc ] )
Follow specified links on the current page and test for HTTP status
passed. The links may be specified as a reference to an array
containing L objects, an array of URLs, or a
scalar URL name.
my @links = $mech->followable_links();
$mech->link_status_isnt( \@links, 404,
'Check all links are not 404' );
=cut
sub link_status_isnt {
my $self = shift;
my $links = shift;
my $status = shift;
my $desc = shift;
my @urls = _format_links( $links );
$desc = _default_links_desc(\@urls, "do not have status $status") if !defined($desc);
my @failures = $self->_check_links_status( \@urls, $status, 'isnt' );
my $ok = (@failures == 0);
$TB->ok( $ok, $desc );
$TB->diag( $_ ) for @failures;
return $ok;
}
=head2 $mech->link_content_like( $links, $regex [, $desc ] )
Follow specified links on the current page and test the resulting
content of each against I<$regex>. The links may be specified as a
reference to an array containing L objects, an
array of URLs, or a scalar URL name.
my @links = $mech->followable_links();
$mech->link_content_like( \@links, qr/Restricted/,
'Check all links are restricted' );
=cut
sub link_content_like {
my $self = shift;
my $links = shift;
my $regex = shift;
my $desc = shift;
my $usable_regex=$TB->maybe_regex( $regex );
if ( !defined( $usable_regex ) ) {
my $ok = $TB->ok( 0, 'link_content_like' );
$TB->diag(qq{ "$regex" doesn't look much like a regex to me.});
return $ok;
}
my @urls = _format_links( $links );
$desc = _default_links_desc( \@urls, qq{are like "$regex"} ) if !defined($desc);
my @failures = $self->_check_links_content( \@urls, $regex );
my $ok = (@failures == 0);
$TB->ok( $ok, $desc );
$TB->diag( $_ ) for @failures;
return $ok;
}
=head2 $mech->link_content_unlike( $links, $regex [, $desc ] )
Follow specified links on the current page and test that the resulting
content of each does not match I<$regex>. The links may be specified as a
reference to an array containing L objects, an array
of URLs, or a scalar URL name.
my @links = $mech->followable_links();
$mech->link_content_unlike( \@links, qr/Restricted/,
'No restricted links' );
=cut
sub link_content_unlike {
my $self = shift;
my $links = shift;
my $regex = shift;
my $desc = shift;
my $usable_regex=$TB->maybe_regex( $regex );
if ( !defined( $usable_regex ) ) {
my $ok = $TB->ok( 0, 'link_content_unlike' );
$TB->diag(qq{ "$regex" doesn't look much like a regex to me.});
return $ok;
}
my @urls = _format_links( $links );
$desc = _default_links_desc( \@urls, qq{are not like "$regex"} ) if !defined($desc);
my @failures = $self->_check_links_content( \@urls, $regex, 'unlike' );
my $ok = (@failures == 0);
$TB->ok( $ok, $desc );
$TB->diag( $_ ) for @failures;
return $ok;
}
# Create a default description for the link_* methods, including the link count.
sub _default_links_desc {
my ($urls, $desc_suffix) = @_;
my $url_count = scalar(@{$urls});
return sprintf( '%d link%s %s', $url_count, $url_count == 1 ? '' : 's', $desc_suffix );
}
# This actually performs the status check of each URL.
sub _check_links_status {
my $self = shift;
my $urls = shift;
my $status = shift || 200;
my $test = shift || 'is';
# Create a clone of the $mech used during the test as to not disrupt
# the original.
my $mech = $self->clone();
my @failures;
for my $url ( @{$urls} ) {
if ( $mech->follow_link( url => $url ) ) {
if ( $test eq 'is' ) {
push( @failures, $url ) unless $mech->status() == $status;
}
else {
push( @failures, $url ) if $mech->status() == $status;
}
$mech->back();
}
else {
push( @failures, $url );
}
} # for
return @failures;
}
# This actually performs the content check of each URL.
sub _check_links_content {
my $self = shift;
my $urls = shift;
my $regex = shift || qr//;
my $test = shift || 'like';
# Create a clone of the $mech used during the test as to not disrupt
# the original.
my $mech = $self->clone();
my @failures;
for my $url ( @{$urls} ) {
if ( $mech->follow_link( url => $url ) ) {
my $content=$mech->content();
if ( $test eq 'like' ) {
push( @failures, $url ) unless $content =~ /$regex/;
}
else {
push( @failures, $url ) if $content =~ /$regex/;
}
$mech->back();
}
else {
push( @failures, $url );
}
} # for
return @failures;
}
# Create an array of urls to match for mech to follow.
sub _format_links {
my $links = shift;
my @urls;
if (ref($links) eq 'ARRAY') {
my $link = $links->[0];
if ( defined($link) ) {
if ( ref($link) eq 'WWW::Mechanize::Link' ) {
@urls = map { $_->url() } @{$links};
}
else {
@urls = @{$links};
}
}
}
else {
push(@urls,$links);
}
return @urls;
}
=head1 METHODS: SCRAPING
=head2 $mech->scrape_text_by_attr( $attr, $attr_value [, $html ] )
=head2 $mech->scrape_text_by_attr( $attr, $attr_regex [, $html ] )
Returns an array of strings, each string the text surrounded by an
element with attribute I<$attr> of value I<$value>. You can also pass in
a regular expression. If nothing is found the return is an empty list.
In scalar context the return is the first string found.
If passed, I<$html> is scraped instead of the current page's content.
=cut
sub scrape_text_by_attr {
my $self = shift;
my $attr = shift;
my $value = shift;
my $html = $self->_get_optional_html( @_ );
my @results;
if ( defined $html ) {
my $parser = HTML::TokeParser->new(\$html);
while ( my $token = $parser->get_tag() ) {
if ( ref $token->[1] eq 'HASH' ) {
if ( exists $token->[1]->{$attr} ) {
my $matched =
(ref $value eq 'Regexp')
? $token->[1]->{$attr} =~ $value
: $token->[1]->{$attr} eq $value;
if ( $matched ) {
my $tag = $token->[ 0 ];
push @results, $parser->get_trimmed_text( "/$tag" );
if ( !wantarray ) {
last;
}
}
}
}
}
}
return $results[0] if !wantarray;
return @results;
}
=head2 $mech->scrape_text_by_id( $id [, $html ] )
Finds all elements with the given ID attribute and pulls out the text that that element encloses.
In list context, returns a list of all strings found. In scalar context, returns the first one found.
If C<$html> is not provided then the current content is used.
=cut
sub scrape_text_by_id {
my $self = shift;
my $id = shift;
my $html = $self->_get_optional_html( @_ );
my @results;
if ( defined $html ) {
# If the ID doesn't appear anywhere in the text, then there's no point in parsing.
my $found = index( $html, $id );
if ( $found >= 0 ) {
my $parser = HTML::TokeParser->new( \$html );
while ( my $token = $parser->get_tag() ) {
if ( ref $token->[1] eq 'HASH' ) {
my $actual_id = $token->[1]->{id};
$actual_id = '' unless defined $actual_id;
if ( $actual_id eq $id ) {
my $tag = $token->[ 0 ];
push @results, $parser->get_trimmed_text( "/$tag" );
if ( !wantarray ) {
last;
}
}
}
}
}
}
return $results[0] if !wantarray;
return @results;
}
sub _get_optional_html {
my $self = shift;
my $html;
if ( @_ ) {
$html = shift;
assert_nonblank( $html, '$html passed in is a populated scalar' );
}
else {
if ( $self->is_html ) {
$html = $self->content();
}
}
return $html;
}
=head2 $mech->scraped_id_is( $id, $expected [, $msg] )
Scrapes the current page for given ID and tests that it matches the expected value.
=cut
sub scraped_id_is {
my $self = shift;
my $id = shift;
my $expected = shift;
my $msg = shift;
my $ok;
my $got = $self->scrape_text_by_id( $id );
if ( defined( $got ) ) {
$ok = $TB->is_eq( $got, $expected, $msg );
}
else {
$ok = $TB->ok( 0, $msg );
$TB->diag( qq{Can't find ID "$id" to compare to "$expected"} );
}
return $ok;
}
=head2 $mech->scraped_id_like( $id, $expected_regex [, $msg] )
Scrapes the current page for given id and tests that it matches the expected regex.
=cut
sub scraped_id_like {
my $self = shift;
my $id = shift;
my $expected = shift;
my $msg = shift;
my $ok;
my $got = $self->scrape_text_by_id( $id );
if ( defined($got) ) {
$ok = $TB->like( $got, $expected, $msg );
}
else {
$ok = $TB->ok( 0, $msg );
$TB->diag( qq{Can't find ID "$id" to match against $expected} );
}
return $ok;
}
=head1 METHODS: MISCELLANEOUS
=head2 $mech->autolint( [$status] )
Without an argument, this method returns a true or false value indicating
whether autolint is active.
When passed an argument, autolint is turned on or off depending on whether
the argument is true or false, and the previous autolint status is returned.
As with the autolint option of C<< new >>, C<< $status >> can be an
L<< HTML::Lint >> object.
If autolint is currently using an L<< HTML::Lint >> object you provided,
the return is that object, so you can change and exactly restore
autolint status:
my $old_status = $mech->autolint( 0 );
... operations that should not be linted ...
$mech->autolint( $old_status );
=cut
sub autolint {
my $self = shift;
my $ret = $self->{autolint};
if ( @_ ) {
$self->{autolint} = shift;
}
return $ret;
}
=head2 $mech->autotidy( [$status] )
Without an argument, this method returns a true or false value indicating
whether autotidy is active.
When passed an argument, autotidy is turned on or off depending on whether
the argument is true or false, and the previous autotidy status is returned.
As with the autotidy option of C<< new >>, C<< $status >> can be an
L<< HTML::Tidy5 >> object.
If autotidy is currently using an L<< HTML::Tidy5 >> object you provided,
the return is that object, so you can change and exactly restore
autotidy status:
my $old_status = $mech->autotidy( 0 );
... operations that should not be tidied ...
$mech->autotidy( $old_status );
=cut
sub autotidy {
my $self = shift;
my $ret = $self->{autotidy};
if ( @_ ) {
$self->{autotidy} = shift;
}
return $ret;
}
=head2 $mech->grep_inputs( \%properties )
grep_inputs() returns an array of all the input controls in the
current form whose properties match all of the regexes in $properties.
The controls returned are all descended from HTML::Form::Input.
If $properties is undef or empty then all inputs will be
returned.
If there is no current page, there is no form on the current
page, or there are no submit controls in the current form
then the return will be an empty array.
# get all text controls whose names begin with "customer"
my @customer_text_inputs =
$mech->grep_inputs( {
type => qr/^(text|textarea)$/,
name => qr/^customer/
}
);
=cut
sub grep_inputs {
my $self = shift;
my $properties = shift;
my @found;
my $form = $self->current_form();
if ( $form ) {
my @inputs = $form->inputs();
@found = _grep_hashes( \@inputs, $properties );
}
return @found;
}
=head2 $mech->grep_submits( \%properties )
grep_submits() does the same thing as grep_inputs() except that
it only returns controls that are submit controls, ignoring
other types of input controls like text and checkboxes.
=cut
sub grep_submits {
my $self = shift;
my $properties = shift || {};
$properties->{type} = qr/^(?:submit|image)$/; # submits only
my @found = $self->grep_inputs( $properties );
return @found;
}
# search an array of hashrefs, returning an array of the incoming
# hashrefs that match *all* the pattern in $patterns.
sub _grep_hashes {
my $hashes = shift;
my $patterns = shift || {};
my @found;
if ( ! %{$patterns} ) {
# nothing to match on, so return them all
@found = @{$hashes};
}
else {
foreach my $hash ( @{$hashes} ) {
# check every pattern for a match on the current hash
my $matches_everything = 1;
foreach my $pattern_key ( keys %{$patterns} ) {
$matches_everything = 0 unless exists $hash->{$pattern_key} && $hash->{$pattern_key} =~ $patterns->{$pattern_key};
last if !$matches_everything;
}
push @found, $hash if $matches_everything;
}
}
return @found;
}
=head2 $mech->stuff_inputs( [\%options] )
Finds all free-text input fields (text, textarea, and password) in the
current form and fills them to their maximum length in hopes of finding
application code that can't handle it. Fields with no maximum length
and all textarea fields are set to 66000 bytes, which will often be
enough to overflow the data's eventual receptacle.
There is no return value.
If there is no current form then nothing is done.
The hashref $options can contain the following keys:
=over
=item * ignore
hash value is arrayref of field names to not touch, e.g.:
$mech->stuff_inputs( {
ignore => [qw( specialfield1 specialfield2 )],
} );
=item * fill
hash value is default string to use when stuffing fields. Copies
of the string are repeated up to the max length of each field. E.g.:
$mech->stuff_inputs( {
fill => '@' # stuff all fields with something easy to recognize
} );
=item * specs
hash value is arrayref of hashrefs with which you can pass detailed
instructions about how to stuff a given field. E.g.:
$mech->stuff_inputs( {
specs=>{
# Some fields are datatype-constrained. It's most common to
# want the field stuffed with valid data.
widget_quantity => { fill=>'9' },
notes => { maxlength=>2000 },
}
} );
The specs allowed are I (use this fill for the field rather than
the default) and I (use this as the field's maxlength instead
of any maxlength specified in the HTML).
=back
=cut
sub stuff_inputs {
my $self = shift;
my $options = shift || {};
assert_isa( $options, 'HASH' );
assert_in( $_, ['ignore', 'fill', 'specs'] ) foreach ( keys %{$options} );
# set up the fill we'll use unless a field overrides it
my $default_fill = '@';
if ( exists $options->{fill} && defined $options->{fill} && length($options->{fill}) > 0 ) {
$default_fill = $options->{fill};
}
# fields in the form to not stuff
my $ignore = {};
if ( exists $options->{ignore} ) {
assert_isa( $options->{ignore}, 'ARRAY' );
$ignore = { map {($_, 1)} @{$options->{ignore}} };
}
my $specs = {};
if ( exists $options->{specs} ) {
assert_isa( $options->{specs}, 'HASH' );
$specs = $options->{specs};
foreach my $field_name ( keys %{$specs} ) {
assert_isa( $specs->{$field_name}, 'HASH' );
assert_in( $_, ['fill', 'maxlength'] ) foreach ( keys %{$specs->{$field_name}} );
}
}
my @inputs = $self->find_all_inputs( type_regex => qr/^(text|textarea|password)$/ );
foreach my $field ( @inputs ) {
next if $field->readonly();
next if $field->disabled(); # TODO: HTML::Form::TextInput allows setting disabled--allow it here?
my $name = $field->name();
# skip if it's one of the fields to ignore
next if exists $ignore->{ $name };
# fields with no maxlength will get this many characters
my $maxlength = 66000;
# maxlength from the HTML
if ( $field->type ne 'textarea' ) {
if ( exists $field->{maxlength} ) {
$maxlength = $field->{maxlength};
# TODO: what to do about maxlength==0 ? non-numeric? less than 0 ?
}
}
my $fill = $default_fill;
if ( exists $specs->{$name} ) {
# process the per-field info
if ( exists $specs->{$name}->{fill} && defined $specs->{$name}->{fill} && length($specs->{$name}->{fill}) > 0 ) {
$fill = $specs->{$name}->{fill};
}
# maxlength override from specs
if ( exists $specs->{$name}->{maxlength} && defined $specs->{$name}->{maxlength} ) {
$maxlength = $specs->{$name}->{maxlength};
# TODO: what to do about maxlength==0 ? non-numeric? less than 0?
}
}
# stuff it
if ( ($maxlength % length($fill)) == 0 ) {
# the simple case
$field->value( $fill x ($maxlength/length($fill)) );
}
else {
# can be improved later
$field->value( substr( $fill x int(($maxlength + length($fill) - 1)/length($fill)), 0, $maxlength ) );
}
} # for @inputs
return;
}
=head2 $mech->followable_links()
Returns a list of links that Mech can follow. This is only http and
https links.
=cut
sub followable_links {
my $self = shift;
return $self->find_all_links( url_abs_regex => qr{^(?:https?|file)://} );
}
=head2 $mech->lacks_uncapped_inputs( [$comment] )
Executes a test to make sure that the current form content has no
text input fields that lack the C attribute, and that each
C value is a positive integer. The test fails if the current
form has such a field, and succeeds otherwise.
Checks that all text input fields in the current form specify a maximum
input length. Fields for which the concept of input length is irrelevant,
and controls that HTML does not allow to be capped (e.g. textarea)
are ignored.
The inputs in the returned array are descended from HTML::Form::Input.
The return is true if the test succeeded, false otherwise.
=cut
sub lacks_uncapped_inputs {
my $self = shift;
my $comment = shift;
local $Test::Builder::Level = $Test::Builder::Level + 1;
my @uncapped;
my @inputs = $self->grep_inputs( { type => qr/^(?:text|password)$/ } );
foreach my $field ( @inputs ) {
next if $field->readonly();
next if $field->disabled();
if ( not defined($field->{maxlength}) ) {
push( @uncapped, $field->name . ' has no maxlength attribute' );
next;
}
my $val = $field->{maxlength};
if ( ($val !~ /^\s*\d+\s*$/) || ($val+0 <= 0) ) {
push( @uncapped, $field->name . qq{ has an invalid maxlength attribute of "$val"} );
}
}
my $ok = $TB->cmp_ok( scalar @uncapped, '==', 0, $comment );
$TB->diag( $_ ) for @uncapped;
return $ok;
}
=head1 TODO
Add HTML::Tidy capabilities.
Other ideas for features are at https://github.com/petdance/test-www-mechanize
=head1 AUTHOR
Andy Lester, C<< >>
=head1 BUGS
Please report any bugs or feature requests to
.
=head1 SUPPORT
You can find documentation for this module with the perldoc command.
perldoc Test::WWW::Mechanize
You can also look for information at:
=over 4
=item * Bug tracker
L
=item * AnnoCPAN: Annotated CPAN documentation
L
=item * CPAN Ratings
L
=item * Search CPAN
L
=back
=head1 ACKNOWLEDGEMENTS
Thanks to
Eric A. Zarko,
moznion,
Robert Stone,
tynovsky,
Jerry Gay,
Jonathan "Duke" Leto,
Philip G. Potter,
Niko Tyni,
Greg Sheard,
Michael Schwern,
Mark Blackman,
Mike O'Regan,
Shawn Sorichetti,
Chris Dolan,
Matt Trout,
MATSUNO Tokuhiro,
and Pete Krawczyk for patches.
=head1 COPYRIGHT & LICENSE
Copyright 2004-2018 Andy Lester.
This library is free software; you can redistribute it and/or modify it
under the terms of the Artistic License version 2.0.
=cut
1; # End of Test::WWW::Mechanize
Test-WWW-Mechanize-1.50/MANIFEST 0000644 0001017 0000764 00000001707 13265202533 015257 0 ustar alester ispc Changes
MANIFEST
Makefile.PL
Mechanize.pm
README.md
t/00-load.t
t/autolint.t
t/autotidy.t
t/bad.html
t/badlinks.html
t/click_ok.t
t/content_contains.t
t/content_lacks.t
t/delete_ok.t
t/fluffy.html
t/followable_links.t
t/follow_link_ok.t
t/get_ok-parms.t
t/get_ok.t
t/good.html
t/goodlinks.html
t/has_tag.t
t/head_ok-parms.t
t/head_ok.t
t/headers.t
t/html/form.html
t/html_lint_ok.t
t/html_tidy_ok.t
t/html/scratch.html
t/lacks_uncapped_inputs-bad.html
t/lacks_uncapped_inputs-good.html
t/lacks_uncapped_inputs.t
t/link_content.t
t/links_ok.t
t/link_status.t
t/manylinks.html
t/new.t
t/page_links_content.t
t/page_links_ok.t
t/pod-coverage.t
t/pod.t
t/put_ok.t
t/scrape_text_by_id.t
t/stuff_inputs.html
t/stuff_inputs.t
t/submit_form_ok.t
t/table.html
t/TestServer.pm
t/text_contains.t
t/title_is.t
META.yml Module YAML meta-data (added by MakeMaker)
META.json Module JSON meta-data (added by MakeMaker)
Test-WWW-Mechanize-1.50/Changes 0000644 0001017 0000764 00000030625 13265202416 015422 0 ustar alester ispc Revision history for Test-WWW-Mechanize
WWW::Mechanize and Test::WWW::Mechanize do not use rt.cpan.org for
bug tracking. They are now being tracked via GitHub at
https://github.com/petdance/test-www-mechanize/issues
1.50 Mon Apr 16 15:16:59 CDT 2018
------------------------------------
[FIXES]
Added html_tidy_ok() methods, analogous to html_lint_ok().
Remove unnecessary dependency on HTML::TreeBuilder. Thanks, Kent Fredric.
1.49_01 Mon Mar 26 10:58:51 CDT 2018
------------------------------------
[ENHANCEMENTS]
Adding autotidy functionality. autotidy lets you validate every page that
Mech gets using the HTML::Tidy5 module, just like the autolint feature
does with the HTML::Lint module. HTML::Tidy5 is a much more complete
HTML checking tool, and validates HTML5 which HTML::Lint does not. You
must have HTML::Tidy5 1.00 installed to use autotidy.
1.48 Thu Dec 29 22:45:29 CST 2016
------------------------------------
[FIXES]
The linting method html_lint_ok() was not calling the HTML::Lint API
correctly, so may have missed some HTML errors at the end of a page.
This also applies to get, post, etc if you have the autolint argument on.
1.46
------------------------------------
[ENHANCEMENTS]
Added header_exists_ok(), lacks_header(), header_is() and header_like()
methods. Thanks to Eric A. Zarko for the original patches.
The scraped_id_is() method used to assign a description for the test if
one was not passed. Now it does not.
scraped_id_is() now gives proper diagnostics if an ID is not found in
the HTML.
Added a delete_ok() method. Thanks, moznion.
content_contains() now fails if it's called with a regex. content_like()
now fails if it's not called with a regex.
[FIXES]
The test server run during the test suite allowed URLs outside of the
document tree, which could potentially be a security problem. This has
been fixed. Thanks, Tynovsky.
https://github.com/petdance/test-www-mechanize/issues/33
Fixed an overly-restrictive optimization in scrape_text_by_id(), plus
scraped_id_is() and scraped_id_like() which wrap it.
The method checks to make sure that it doesn't bother looking for an ID
on the page if the ID doesn't exist. It did this by looking for the text
id="foo"
where foo is the ID being searched for. However, that would mean that
tags like
would be seen as not existing. This has been fixed by making
scrape_text_by_id() search for the string "foo" anywhere on the page.
1.44 Sat Jun 30 20:32:04 CDT 2012
------------------------------------
There is no new functionality in this release.
[FIXES]
Fixed test failures on Win32. Thanks, Jerry Gay.
1.42 Thu May 31 11:35:26 CDT 2012
------------------------------------
If you want to use the autolint functionality, you'll have to have
HTML::Lint 2.20.
[FIXES]
Custom lint objects don't get reset before they get used, making
autolint with a custom lint object practically useless.
https://github.com/petdance/test-www-mechanize/issues/25
1.40 Fri Apr 13 15:14:39 CDT 2012
------------------------------------
[ENHANCEMENTS]
Added a $mech->autolint() method so you can turn autolinting on and off
in mid-program. Thanks, Mike O'Regan.
New functions $mech->scrape_text_by_id() and $mech->scrape_text_by_attr()
let you extract text from your pages. Convenience function
$mech->scraped_id_is() makes it easy to scrape and compare in one
function.
tag has no HEIGHT and WIDTH attributes' );
test_err( '# (10:9)