Provided by: libtest-www-mechanize-mojo-perl_0.0.20-1_all bug

NAME

       Test::WWW::Mechanize::Mojo - Test::WWW::Mechanize for Mojo / Mojolicious

VERSION

       version 0.0.20

SYNOPSIS

         # We're in a t/*.t test script...
         use Test::WWW::Mechanize::Mojo;

         my $tester = Test::Mojo->new();

         # To test a Mojo application
         my $mech = Test::WWW::Mechanize::Mojo->new(tester => $tester);

         $mech->get_ok("/"); # no hostname needed
         is($mech->ct, "text/html");
         $mech->title_is("Root", "On the root page");
         $mech->content_contains("This is the root page", "Correct content");
         $mech->follow_link_ok({text => 'Hello'}, "Click on Hello");
         # ... and all other Test::WWW::Mechanize methods

         # White label site testing
         $mech->host("foo.com");
         $mech->get_ok("/");

DESCRIPTION

       Mojo is an MVC Web Application Framework.  Test::WWW::Mechanize is a subclass of
       WWW::Mechanize that incorporates features for web application testing. The
       Test::WWW::Mechanize::Mojo module meshes the two to allow easy testing of Mojo
       applications without needing to starting up a web server.

       Testing web applications has always been a bit tricky, normally requiring starting a web
       server for your application and making real HTTP requests to it. This module allows you to
       test Mojo web applications but does not require a server or issue HTTP requests. Instead,
       it passes the HTTP request object directly to Mojo. Thus you do not need to use a real
       hostname: "http://localhost/" will do. However, this is optional. The following two lines
       of code do exactly the same thing:

         $mech->get_ok('/action');
         $mech->get_ok('http://localhost/action');

       Links which do not begin with / or are not for localhost can be handled as normal Web
       requests - this is handy if you have an external single sign-on system. You must set
       allow_external to true for this:

         $mech->allow_external(1);

       You can also test a remote server by setting the environment variable MOJO_SERVER; for
       example:

         $ MOJO_SERVER=http://example.com/myapp prove -l t

       will run the same tests on the application running at http://example.com/myapp regardless
       of whether or not you specify http:://localhost for Test::WWW::Mechanize::Mojo.

       Furthermore, if you set MOJO_SERVER, the server will be regarded as a remote server even
       if your links point to localhost. Thus, you can use Test::WWW::Mechanize::Mojo to test
       your live webserver running on your local machine, if you need to test aspects of your
       deployment environment (for example, configuration options in an http.conf file) instead
       of just the Mojo request handling.

       This makes testing fast and easy. Test::WWW::Mechanize provides functions for common web
       testing scenarios. For example:

         $mech->get_ok( $page );
         $mech->title_is( "Invoice Status", "Make sure we're on the invoice page" );
         $mech->content_contains( "Andy Lester", "My name somewhere" );
         $mech->content_like( qr/(cpan|perl)\.org/, "Link to perl.org or CPAN" );

       This module supports cookies automatically.

       To use this module you must pass it the name of the application. See the SYNOPSIS above.

       Note that Mojo has a special developing feature: the debug screen. By default this module
       will treat responses which are the debug screen as failures. If you actually want to test
       debug screens, please use:

         $mmech->{catalyst_debug} = 1;

       An alternative to this module is Test::Mojo.

CONSTRUCTOR

   new
       Behaves like, and calls, WWW::Mechanize's "new" method.  Any params passed in get passed
       to WWW::Mechanize's constructor. Note that we need to pass the name of the Catalyst
       application to the "use":

         use Test::WWW::Mechanize::Catalyst;

         use Test::Mojo;

         my $tester = Test::Mojo->new();

         my $mech = Test::WWW::Mechanize::Catalyst->new(tester => $tester);

       In addition, one can specify a 'tester' argument as the Test::Mojo instance.

METHODS

   allow_external
       Links which do not begin with / or are not for localhost can be handled as normal Web
       requests - this is handy if you have an external single sign-on system. You must set
       allow_external to true for this:

         $m->allow_external(1);

   mojo_app
       The name of the Mojo app which we are testing against. Read-only.

   has_mojo_app
       For internal use.

   tester
       For internal use.

   host
       The host value to set the "Host:" HTTP header to, if none is present already in the
       request. If not set (default) then Catalyst::Test will set this to localhost:80

   clear_host
       Unset the host attribute.

   has_host
       Do we have a value set for the host attribute

   $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. Returns true or false.

   $mech->title_is( $str [, $desc ] )
       Tells if the title of the page is the given string.

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

   $mech->title_like( $regex [, $desc ] )
       Tells if the title of the page matches the given regex.

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

   $mech->title_unlike( $regex [, $desc ] )
       Tells if the title of the page does NOT match the given regex.

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

   $mech->content_is( $str [, $desc ] )
       Tells if the content of the page matches the given string

   $mech->content_contains( $str [, $desc ] )
       Tells if the content of the page contains $str.

   $mech->content_lacks( $str [, $desc ] )
       Tells if the content of the page lacks $str.

   $mech->content_like( $regex [, $desc ] )
       Tells if the content of the page matches $regex.

   $mech->content_unlike( $regex [, $desc ] )
       Tells if the content of the page does NOT match $regex.

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

   $mech->page_links_content_like( $regex,[ $desc ] )
       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"' );

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

   $mech->links_ok( $links [, $desc ] )
       Check the current page for specified links 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' );

   $mech->link_status_is( $links, $status [, $desc ] )
       Check the current page for specified links 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->links();
           $mech->link_status_is( \@links, 403,
             'Check all links are restricted' );

   $mech->link_status_isnt( $links, $status [, $desc ] )
       Check the current page for specified links 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->links();
           $mech->link_status_isnt( \@links, 404,
             'Check all links are not 404' );

   $mech->link_content_like( $links, $regex [, $desc ] )
       Check the current page for specified links and test the 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->links();
           $mech->link_content_like( \@links, qr/Restricted/,
               'Check all links are restricted' );

   $mech->link_content_unlike( $links, $regex [, $desc ] )
       Check the current page for specified links and test the 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->links();
           $mech->link_content_like( \@links, qr/Restricted/,
             'Check all links are restricted' );

   follow_link_ok( \%parms [, $comment] )
       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 params to pass to "follow_link()".  Note that the
       params to "follow_link()" are a hash whereas the parms to this function are a hashref.
       You have to call this function like:

           $agent->follow_like_ok( {n=>3}, "looking for 3rd link" );

       As with other test functions, $comment 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 follow_link() is not available.

CAVEATS

   External Redirects and allow_external
       If you use non-fully qualified urls in your test scripts (i.e. anything without a host,
       such as "->get_ok( "/foo")" ) and your app redirects to an external URL, expect to be
       bitten once you come back to your application's urls (it will try to request them on the
       remote server.) This is due to a limitation in WWW::Mechanize.

       One workaround for this is that if you are expecting to redirect to an external site,
       clone the TWMC obeject and use the cloned object for the external redirect.

SEE ALSO

       Related modules which may be of interest: Mojo, Test::WWW::Mechanize, WWW::Mechanize,
       Test::WWW::Mechanize::Catalyst.

AUTHOR

   Of Test::WWW::Mechanize::Catalyst
       Ash Berlin "<ash@cpan.org>"

       Original Author: Leon Brocard, "<acme@astray.com>"

   Of Test::WWW::Mechanize::Mojo
       Shlomi Fish, <http://www.shlomifish.org/> - while disclaiming all rights.

COPYRIGHT

       Copyright (C) 2005-8, Leon Brocard

LICENSE

       This module is free software; you can redistribute it or modify it under the same terms as
       Perl itself.

AUTHOR

       Shlomi Fish <shlomif@cpan.org>

COPYRIGHT AND LICENSE

       This software is copyright (c) 2005 by Leon Brocard.

       This is free software; you can redistribute it and/or modify it under the same terms as
       the Perl 5 programming language system itself.

BUGS

       Please report any bugs or feature requests on the bugtracker website
       <https://github.com/shlomif/perl-test-www-mechanize-mojo/issues>

       When submitting a bug or request, please include a test-file or a patch to an existing
       test-file that illustrates the bug or desired feature.

SUPPORT

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

         perldoc Test::WWW::Mechanize::Mojo

   Websites
       The following websites have more information about this module, and may be of help to you.
       As always, in addition to those websites please use your favorite search engine to
       discover more resources.

       ·   MetaCPAN

           A modern, open-source CPAN search engine, useful to view POD in HTML format.

           <https://metacpan.org/release/Test-WWW-Mechanize-Mojo>

       ·   Search CPAN

           The default CPAN search engine, useful to view POD in HTML format.

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

       ·   RT: CPAN's Bug Tracker

           The RT ( Request Tracker ) website is the default bug/issue tracking system for CPAN.

           <https://rt.cpan.org/Public/Dist/Display.html?Name=Test-WWW-Mechanize-Mojo>

       ·   AnnoCPAN

           The AnnoCPAN is a website that allows community annotations of Perl module
           documentation.

           <http://annocpan.org/dist/Test-WWW-Mechanize-Mojo>

       ·   CPAN Ratings

           The CPAN Ratings is a website that allows community ratings and reviews of Perl
           modules.

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

       ·   CPANTS

           The CPANTS is a website that analyzes the Kwalitee ( code metrics ) of a distribution.

           <http://cpants.cpanauthors.org/dist/Test-WWW-Mechanize-Mojo>

       ·   CPAN Testers

           The CPAN Testers is a network of smoke testers who run automated tests on uploaded
           CPAN distributions.

           <http://www.cpantesters.org/distro/T/Test-WWW-Mechanize-Mojo>

       ·   CPAN Testers Matrix

           The CPAN Testers Matrix is a website that provides a visual overview of the test
           results for a distribution on various Perls/platforms.

           <http://matrix.cpantesters.org/?dist=Test-WWW-Mechanize-Mojo>

       ·   CPAN Testers Dependencies

           The CPAN Testers Dependencies is a website that shows a chart of the test results of
           all dependencies for a distribution.

           <http://deps.cpantesters.org/?module=Test::WWW::Mechanize::Mojo>

   Bugs / Feature Requests
       Please report any bugs or feature requests by email to "bug-test-www-mechanize-mojo at
       rt.cpan.org", or through the web interface at
       <https://rt.cpan.org/Public/Bug/Report.html?Queue=Test-WWW-Mechanize-Mojo>. You will be
       automatically notified of any progress on the request by the system.

   Source Code
       The code is open to the world, and available for you to hack on. Please feel free to
       browse it and play with it, or whatever. If you want to contribute patches, please send me
       a diff or prod me to pull from your repository :)

       <https://github.com/shlomif/perl-test-www-mechanize-mojo>

         git clone git://github.com/shlomif/perl-test-www-mechanize-mojo.git