Test::WWW::Mechanize - Testing-specific WWW::Mechanize subclass

Version 1.32

Test::WWW::Mechanize is a subclass of WWW::Mechanize 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 <BASE HREF>' );
    $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 <BASE HREF>' );
    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)'

Behaves like, and calls, WWW::Mechanize's new method. Any parms passed in get passed to WWW::Mechanize's constructor.

You can pass in autolint => 1 to make Test::WWW::Mechanize automatically run HTML::Lint after any of the following methods are called.

* get_ok()

* post_ok()

* submit_form_ok()

* follow_link_ok()

* click_ok()

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 $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.

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 *_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.

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 *_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.

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 *_ok() functions, it returns true if the test passed, or false if not.

A default description of "POST to $url" is used if none if provided.

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 *_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.

Makes a submit_form() call and executes tests on the results. The form must be found, and then submitted successfully. Otherwise, this test fails.

%parms is a hashref containing the parms to pass to submit_form(). Note that the parms to submit_form() 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, $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 HTTP::Response object returned by submit_form() is not available.

Makes a follow_link() call and executes tests on the results. The link must be found, and then followed successfully. Otherwise, this test fails.

%parms is a hashref containing the parms to pass to follow_link(). Note that the parms to follow_link() 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, $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 HTTP::Response object returned by follow_link() is not available.

Clicks the button named by $button. An optional $desc can be given for the test.

Checks the validity of the HTML on the current page. If the page is not HTML, then it fails. The URI is automatically appended to the $desc.

Note that HTML::Lint must be installed for this to work. Otherwise, it will blow up.

Tells if the title of the page is the given string.

    $mech->title_is( 'Invoice Summary' );

Tells if the title of the page matches the given regex.

    $mech->title_like( qr/Invoices for (.+)/

Tells if the title of the page matches the given regex.

    $mech->title_unlike( qr/Invoices for (.+)/

Tells if the base of the page is the given string.

    $mech->base_is( 'http://example.com/' );

Tells if the base of the page matches the given regex.

    $mech->base_like( qr{http://example.com/index.php?PHPSESSID=(.+)});

Tells if the base of the page matches the given regex.

    $mech->base_unlike( qr{http://example.com/index.php?PHPSESSID=(.+)});

Tells if the content of the page matches the given string

Tells if the content of the page contains $str.

Tells if the content of the page lacks $str.

Tells if the content of the page matches $regex.

Tells if the content of the page does NOT match $regex.

Tells if the text form of the page's content contains $str.

When your page contains HTML which is difficult, unimportant, or unlikely to match over time as designers alter markup, use text_contains instead of content_contains.

 # <b>Hi, <i><a href="some/path">User</a></i>!</b>
 $mech->content_contains('Hi, User'); # Fails.
 $mech->text_contains('Hi, User'); # Passes.

Text is determined by calling $mech->content(format => 'text'). See content in WWW::Mechanize.

Tells if the text form of the page's content matches $regex.

Tells if the text format of the page's content does NOT match $regex.

Tells if the page has a $tag tag with the given content in its text.

Tells if the page has a $tag tag with the given content in its text.

Returns a list of links that Mech can follow. This is only http and https links.

Follow all links on the current page and test for HTTP status 200

    $mech->page_links_ok('Check all links');

Follow all links on the current page and test their contents for $regex.

    $mech->page_links_content_like( qr/foo/,
      'Check all links contain "foo"' );

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');

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 WWW::Mechanize::Link 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' );

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 WWW::Mechanize::Link 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' );

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 WWW::Mechanize::Link 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' );

Follow specified links on the current page and test the resulting content of each against $regex. The links may be specified as a reference to an array containing WWW::Mechanize::Link 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' );

Follow specified links on the current page and test that the resulting content of each does not match $regex. The links may be specified as a reference to an array containing WWW::Mechanize::Link 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' );

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 recepticle.

There is no return value.

If there is no current form then nothing is done.

The hashref $options can contain the following keys:

* ignore

hash value is arrayref of field names to not touch, e.g.:

    $mech->stuff_inputs( {
        ignore => [qw( specialfield1 specialfield2 )],
    } );

* 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
    } );

* 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 fill (use this fill for the field rather than the default) and maxlength (use this as the field's maxlength instead of any maxlength specified in the HTML).

Add HTML::Tidy capabilities.

Add a broken image check.

Andy Lester, <andy at petdance.com>

Please report any bugs or feature requests to <http://code.google.com/p/www-mechanize/issues/list>. I will be notified, and then you'll automatically be notified of progress on your bug as I make changes.

You can find documentation for this module with the perldoc command.

    perldoc Test::WWW::Mechanize

You can also look for information at:

* Google Code bug tracker

http://code.google.com/p/www-mechanize/issues/list

Please do not use the old queues for WWW::Mechanize and Test::WWW::Mechanize at http://rt.cpan.org/NoAuth/Bugs.html?Dist=Test-WWW-Mechanize

* AnnoCPAN: Annotated CPAN documentation

http://annocpan.org/dist/Test-WWW-Mechanize

* CPAN Ratings

http://cpanratings.perl.org/d/Test-WWW-Mechanize

* Search CPAN

http://search.cpan.org/dist/Test-WWW-Mechanize

Thanks to 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.

Copyright 2004-2011 Andy Lester.

This program is free software; you can redistribute it and/or modify it under the terms of either:

* the GNU General Public License as published by the Free Software Foundation; either version 1, or (at your option) any later version, or

* the Artistic License version 2.0.