HTTP::Request results from the CPAN

    no warnings 'redefine';

    *Catalyst::Test::local_request = sub {
        my ( $class, $request ) = @_;

        require HTTP::Request::AsCGI;
        my $cgi = HTTP::Request::AsCGI->new( $request, %ENV )->setup;

        $class->handle_request;

        return $cgi->restore->response;
    };

sub run_tests {

    # test nameless
    {
        my $request =
          HTTP::Request->new( GET => 'http://localhost:3000/nameless' );

        ok( my $response = request($request), 'Request' );
        ok( $response->is_success, 'Response Successful 2xx' );
        is( $response->code, 200, 'Response Code' );

    }

    # test named
    {
        my $request =
          HTTP::Request->new( GET => 'http://localhost:3000/named' );

        ok( my $response = request($request), 'Request' );
        ok( $response->is_success, 'Response Successful 2xx' );
        is( $response->code, 200, 'Response Code' );

    }

    # test nameless_result
    {
        my $request =
          HTTP::Request->new(
            GET => 'http://localhost:3000/nameless_result?foo=bar' );

        ok( my $response = request($request), 'Request' );
        ok( $response->is_success, 'Response Successful 2xx' );
        is( $response->code, 200, 'Response Code' );

    }

    # test nameless_noresult
    {
        my $request =
          HTTP::Request->new(
            GET => 'http://localhost:3000/nameless_noresult' );

        ok( my $response = request($request), 'Request' );
        ok( $response->is_success, 'Response Successful 2xx' );
        is( $response->code, 200, 'Response Code' );

    }

    # test nameless_res_nores
    {
        my $request =
          HTTP::Request->new(
            GET => 'http://localhost:3000/nameless_res_nores' );

        ok( my $response = request($request), 'Request' );
        ok( $response->is_success, 'Response Successful 2xx' );
        is( $response->code, 200, 'Response Code' );

view all matches for this distribution

Catalyst-Plugin-HashedCookies

5 results

            "Catalyst" : "0",
            "Catalyst::Controller" : "0",
            "Data::Dumper" : "0",
            "File::Spec::Functions" : "0",
            "HTTP::Headers::Util" : "0",
            "HTTP::Request::Common" : "0",
            "Scalar::Util" : "0",
            "Test::More" : "0"
         }
      }
   },

view all matches for this distribution

Catalyst-Plugin-I18N-PathPrefix

7 results

t/lib/TestUtils.pm view on Meta::CPAN

use strict;
use warnings;

use base qw/ Exporter /;

use HTTP::Request::Common;
use Catalyst::Test 'TestApp';
use Data::Dumper;

use Test::Most;
use Test::Deep;

view all matches for this distribution

Catalyst-Plugin-I18N-PathPrefixGeoIP

7 results

t/lib/TestUtils.pm view on Meta::CPAN

use strict;
use warnings;

use base qw/ Exporter /;

use HTTP::Request::Common;
use Catalyst::Test 'TestApp';
use Data::Dumper;

use Test::Most;
use Test::Deep;

view all matches for this distribution

Catalyst-Plugin-I18N-Request

1 match

    no warnings 'redefine';

    *Catalyst::Test::local_request = sub {
        my ( $class, $request ) = @_;

        require HTTP::Request::AsCGI;
        my $cgi = HTTP::Request::AsCGI->new( $request, %ENV )->setup;

        $class->handle_request;

        return $cgi->restore->response;
    };


    # test maketext
    {
        my $expected = 'search';
        my $request  =
          HTTP::Request->new( GET => 'http://localhost:3000/maketext/PATH_delocalize_recherche' );

        $request->header( 'Accept-Language' => 'fr' );

        ok( my $response = request($request), 'Request' );
        ok( $response->is_success, 'Response Successful 2xx' );


    # test delocalized parameter name
    {
        my $expected = 'search';
        my $request  =
          HTTP::Request->new( GET => 'http://localhost:3000/current_parameter_name?recherche=foo' );

        $request->header( 'Accept-Language' => 'fr' );

        ok( my $response = request($request), 'Request' );
        ok( $response->is_success, 'Response Successful 2xx' );


    # test delocalized path name
    {
        my $expected = 'current_request_path/search';
        my $request  =
          HTTP::Request->new( GET => 'http://localhost:3000/current_request_path/recherche' );

        $request->header( 'Accept-Language' => 'fr' );

        ok( my $response = request($request), 'Request' );
        ok( $response->is_success, 'Response Successful 2xx' );


    # test localized uri_for
    {
        my $expected = 'http://localhost:3000/recherche?recherche=search';
        my $request  =
          HTTP::Request->new( GET => 'http://localhost:3000/localized_uri_for/search/search' );

        $request->header( 'Accept-Language' => 'fr' );

        ok( my $response = request($request), 'Request' );
        ok( $response->is_success, 'Response Successful 2xx' );


    # test localized uri_with
    {
        my $expected = 'http://localhost:3000/localized_uri_with/recherche?recherche=search';
        my $request  =
          HTTP::Request->new( GET => 'http://localhost:3000/localized_uri_with/search' );

        $request->header( 'Accept-Language' => 'fr' );

        ok( my $response = request($request), 'Request' );
        ok( $response->is_success, 'Response Successful 2xx' );

view all matches for this distribution

Catalyst-Plugin-I18N

1 match

    no warnings 'redefine';

    *Catalyst::Test::local_request = sub {
        my ( $class, $request ) = @_;

        require HTTP::Request::AsCGI;
        my $cgi = HTTP::Request::AsCGI->new( $request, %ENV )->setup;

        $class->handle_request;

        return $cgi->restore->response;
    };


    # test Lexicon
    {
        my $expected = 'Bonjour';
        my $request  =
          HTTP::Request->new( GET => 'http://localhost:3000/maketext/Hello' );

        $request->header( 'Accept-Language' => 'fr' );

        ok( my $response = request($request), 'Request' );
        ok( $response->is_success, 'Response Successful 2xx' );


    # test .po
    {
        my $expected = 'Hallo';
        my $request  =
          HTTP::Request->new( GET => 'http://localhost:3000/maketext/Hello' );

        $request->header( 'Accept-Language' => 'de' );

        ok( my $response = request($request), 'Request' );
        ok( $response->is_success, 'Response Successful 2xx' );


    # test language()
    {
        my $expected = 'fr';
        my $request  =
          HTTP::Request->new( GET => 'http://localhost:3000/current_language' );

        $request->header( 'Accept-Language' => 'fr' );

        ok( my $response = request($request), 'Request' );
        ok( $response->is_success, 'Response Successful 2xx' );


    # test language()/language_tag()
    {
        my $expected = 'en_us';
        my $request  =
          HTTP::Request->new( GET => 'http://localhost:3000/current_language' );

        $request->header( 'Accept-Language' => 'en-us' );

        ok( my $response = request($request), 'Request' );
        ok( $response->is_success, 'Response Successful 2xx' );

        is( $response->content, $expected, 'Content OK' );
    }
    {
        my $expected = 'en-us';
        my $request  =
          HTTP::Request->new( GET => 'http://localhost:3000/current_language_tag' );

        $request->header( 'Accept-Language' => 'en-us' );

        ok( my $response = request($request), 'Request' );
        ok( $response->is_success, 'Response Successful 2xx' );


    # test fallback (i.e. fr-ca => fr)
    {
        my $expected = 'fr';
        my $request  =
          HTTP::Request->new( GET => 'http://localhost:3000/current_language' );

        $request->header( 'Accept-Language' => 'fr-ca' );

        ok( my $response = request($request), 'Request' );
        ok( $response->is_success, 'Response Successful 2xx' );


    # Test languages_list
    {
        my $expected = "de=German, en_us=US English, fr=French";
        my $request  =
          HTTP::Request->new( GET => 'http://localhost:3000/current_languages_list' );

        ok( my $response = request($request), 'Request' );
        ok( $response->is_success, 'Response Successful 2xx' );
        is( $response->code, 200, 'Response Code' );

       
    # test fallback to i_default
    {
        my $expected = 'Hello - default';
        my $request  =
          HTTP::Request->new( GET => 'http://localhost:3000/maketext/messages.hello' );

        $request->header( 'Accept-Language' => 'fr-ca' );

        ok( my $response = request($request), 'Request' );
        ok( $response->is_success, 'Response Successful 2xx' );


    # test AUTO in i_default
    {
        my $expected = 'no.key';
        my $request  =
          HTTP::Request->new( GET => 'http://localhost:3000/maketext/no.key' );

        $request->header( 'Accept-Language' => 'fr-ca' );

        ok( my $response = request($request), 'Request' );
        ok( $response->is_success, 'Response Successful 2xx' );

view all matches for this distribution

Catalyst-Plugin-InjectionHelpers

6 results

      "test" : {
         "requires" : {
            "Catalyst::Plugin::Session" : "0.40",
            "Catalyst::Plugin::Session::State::Cookie" : "0.17",
            "Catalyst::Test" : "0",
            "HTTP::Request::Common" : "0",
            "Scalar::Util" : "0",
            "Test::Most" : "0"
         }
      }
   },

view all matches for this distribution

Catalyst-Plugin-JSONRPC

1 match

t/01_server.t view on Meta::CPAN

    no warnings 'redefine';

    *Catalyst::Test::local_request = sub {
        my ( $class, $request ) = @_;

        require HTTP::Request::AsCGI;
        my $cgi = HTTP::Request::AsCGI->new( $request, %ENV )->setup;

        $class->handle_request;

        return $cgi->restore->response;
    };

t/01_server.t view on Meta::CPAN

sub run_tests {

    # test echo
    {
        my $content = JSON::objToJson({ method => 'echo', params => [ 'hello' ], id => 1 });
        my $request = HTTP::Request->new( POST => $entrypoint );
        $request->header( 'Content-Length' => length($content) );
        $request->header( 'Content-Type'   => 'text/javascript+json' );
        $request->content($content);

        ok( my $response = request($request), 'Request' );

t/01_server.t view on Meta::CPAN

    }

    # test add
    {
        my $content = JSON::objToJson({ method => 'add', params => [ 1, 2 ], id => 2 });
        my $request = HTTP::Request->new( POST => $entrypoint );
        $request->header( 'Content-Length' => length($content) );
        $request->header( 'Content-Type'   => 'text/xml' );
        $request->content($content);

        ok( my $response = request($request), 'Request' );

view all matches for this distribution

Catalyst-Plugin-Log-Message

1 match

t/inc/local_request.pl view on Meta::CPAN


    *Catalyst::Test::local_request = sub {
        my ( $class, $request ) = @_;
        use Data::Dumper;

        require HTTP::Request::AsCGI;
        require Catalyst::Utils;
        $request = ref($request) ? $request : Catalyst::Utils::request($request);
        my $cgi = HTTP::Request::AsCGI->new( $request, %ENV )->setup;

        $class->handle_request;

        return $cgi->restore->response;
    };

view all matches for this distribution

Catalyst-Plugin-MobileAgent

1 match

t/01-request.t view on Meta::CPAN


package main;

use Catalyst::Test 'TestApp';
use HTTP::Headers;
use HTTP::Request::Common;

my @Tests = (
    {
        class      => 'HTTP::MobileAgent::DoCoMo',
        user_agent => 'DoCoMo/2.0 N2001(c10;ser0123456789abcde;icc01234567890123456789)',

view all matches for this distribution

Catalyst-Plugin-OIDC

6 results

            "Catalyst::Test" : "0",
            "Catalyst::View::JSON" : "0",
            "Config::General" : "0",
            "File::Spec" : "0",
            "HTTP::Cookies" : "0",
            "HTTP::Request::Common" : "0",
            "IO::Handle" : "0",
            "IPC::Open3" : "0",
            "Mojolicious" : "8.24",
            "Test::MockModule" : "v0.177.0",
            "Test::More" : "0"

view all matches for this distribution

Catalyst-Plugin-OrderedParams

1 match

t/04params.t view on Meta::CPAN

use FindBin;
use lib "$FindBin::Bin/lib";

use Test::More tests => 7;
use Catalyst::Test 'TestApp';
use HTTP::Request::Common;
use Tie::Hash::Indexed;

my $creq;

my %params;

view all matches for this distribution

Catalyst-Plugin-PageCache

1 match

sub run_tests {
# cache a page localized for a language
    {
        my $expected = 'hello 1';
        my $request  =
            HTTP::Request->new( GET => 'http://localhost:3000/cache/count' );

        $request->header( 'Accept-Language' => 'en' );

        ok( my $response = request($request), 'Request' );
        ok( $response->is_success, 'Response Successful 2xx' );

    
# request the same page with same language
    {
        my $expected = 'hello 1';
        my $request  =
            HTTP::Request->new( GET => 'http://localhost:3000/cache/count' );

        $request->header( 'Accept-Language' => 'en' );

        ok( my $response = request($request), 'Request' );
        ok( $response->is_success, 'Response Successful 2xx' );


# request same page, different language.
    {
        my $expected = 'hola 2';
        my $request  =
            HTTP::Request->new( GET => 'http://localhost:3000/cache/count' );

        $request->header( 'Accept-Language' => 'es' );

        ok( my $response = request($request), 'Request' );
        ok( $response->is_success, 'Response Successful 2xx' );


# request the same page with same language different from first...
    {
        my $expected = 'hola 2';
        my $request  =
            HTTP::Request->new( GET => 'http://localhost:3000/cache/count' );

        $request->header( 'Accept-Language' => 'es' );

        ok( my $response = request($request), 'Request' );
        ok( $response->is_success, 'Response Successful 2xx' );

    }

# clearing the cached page should affect *both* languages
    {
        my $request = 
            HTTP::Request->new( GET => 'http://localhost:3000/cache/clear_cache' );
        ok( my $response = request($request), 'request ok' );
    }

# the previous request to clear_cache also incremented the counter so we skip that one.

# first ask for a fresh copy for 'en'
    {
        my $expected = 'hello 4';
        my $request  =
            HTTP::Request->new( GET => 'http://localhost:3000/cache/count' );

        $request->header( 'Accept-Language' => 'en' );

        ok( my $response = request($request), 'Request' );
        ok( $response->is_success, 'Response Successful 2xx' );


# next ask for a fresh copy for 'es'
    {
        my $expected = 'hola 5';
        my $request  =
            HTTP::Request->new( GET => 'http://localhost:3000/cache/count' );

        $request->header( 'Accept-Language' => 'es' );

        ok( my $response = request($request), 'Request' );
        ok( $response->is_success, 'Response Successful 2xx' );

view all matches for this distribution

Catalyst-Plugin-Params-Profile

1 match

t/inc/local_request.pl view on Meta::CPAN


    *Catalyst::Test::local_request = sub {
        my ( $class, $request ) = @_;
        use Data::Dumper;

        require HTTP::Request::AsCGI;
        require Catalyst::Utils;
        $request = ref($request) ? $request : Catalyst::Utils::request($request);
        my $cgi = HTTP::Request::AsCGI->new( $request, %ENV )->setup;

        $class->handle_request;

        return $cgi->restore->response;
    };

view all matches for this distribution

Catalyst-Plugin-Pluggable

1 match

    no warnings 'redefine';

    *Catalyst::Test::local_request = sub {
        my ( $class, $request ) = @_;

        require HTTP::Request::AsCGI;
        my $cgi = HTTP::Request::AsCGI->new( $request, %ENV )->setup;

        $class->handle_request;

        return $cgi->restore->response;
    };


    # test normal execution
    {
        my $expected = "A\nB\nC\n";
        my $request  =
          HTTP::Request->new( GET => 'http://localhost:3000/runtest' );

        ok( my $response = request($request), 'Request' );
        ok( $response->is_success, 'Response Successful 2xx' );
        is( $response->code, 200, 'Response Code' );


    # test normal execution w/ args
    {
        my $expected = "AX\nBX\nCX\n";
        my $request  =
          HTTP::Request->new( GET => 'http://localhost:3000/runtest_args' );

        ok( my $response = request($request), 'Request' );
        ok( $response->is_success, 'Response Successful 2xx' );
        is( $response->code, 200, 'Response Code' );


    # test reverse execution
    {
        my $expected = "C\nB\nA\n";
        my $request  =
          HTTP::Request->new( GET => 'http://localhost:3000/runtest_reverse' );

        ok( my $response = request($request), 'Request' );
        ok( $response->is_success, 'Response Successful 2xx' );
        is( $response->code, 200, 'Response Code' );

view all matches for this distribution

Catalyst-Plugin-PrometheusTiny

4 results

t/lib/TestApp/Helper.pm view on Meta::CPAN

use strict;

use Test::More;
use Test::Deep;

use HTTP::Request::Common;
use Plack::Test;
use TestApp;

sub get_metrics {
    my ( $test, $endpoint ) = @_;

view all matches for this distribution

Catalyst-Plugin-RedirectTo

3 results

---
abstract: 'Easily set a Catalyst redirect response to an action object or private path'
author:
  - 'John Napiorkowski <jjnapiork@cpan.org>'
build_requires:
  HTTP::Request::Common: '0'
  Test::Most: '0'
configure_requires:
  ExtUtils::MakeMaker: '0'
dynamic_config: 0
generated_by: 'Dist::Zilla version 6.025, CPAN::Meta::Converter version 2.150010'

view all matches for this distribution

Catalyst-Plugin-RequireSSL

3 results

  Catalyst::Test: 0
  Data::Dumper: 0
  ExtUtils::MakeMaker: 6.42
  File::Spec: 0
  FindBin: 0
  HTTP::Request::Common: 0
  Test::More: 0
configure_requires:
  ExtUtils::MakeMaker: 6.42
distribution_type: module
generated_by: 'Module::Install version 1.02'

view all matches for this distribution

Catalyst-Plugin-ResponseFrom

6 results

lib/Catalyst/Plugin/ResponseFrom.pm view on Meta::CPAN


use URI ();
use Moose::Role;
use HTTP::Message::PSGI ();
use MIME::Base64 ();
use HTTP::Request ();
use Scalar::Util ();

our $VERSION = '0.003';

requires 'psgi_app', 'res', 'detach';

lib/Catalyst/Plugin/ResponseFrom.pm view on Meta::CPAN

    $method = 'GET';
    @rest = ();
  }

  # if it's a reference, assume a request object
  return $method if(Scalar::Util::blessed $method and $method->isa('HTTP::Request'));
 
  if ($path =~ s/^(.*?)\@//) {
    my $basic = $1;
    unshift @rest, 'Authorization:', 'Basic '.MIME::Base64::encode($basic);
  }
 
  my $request = HTTP::Request->new($method => $path);
 
  my @params;
 
  while (my ($header, $value) = splice(@rest, 0, 2)) {
    unless ($header =~ s/:$//) {

lib/Catalyst/Plugin/ResponseFrom.pm view on Meta::CPAN


    package MyApp::Controller::Example;

    use Moose;
    use MooseX::MethodAttributes;
    use HTTP::Request::Common;

    extends 'Catalyst::Controller';

    sub as_http_request :Local {
      my ($self, $c) = @_;

lib/Catalyst/Plugin/ResponseFrom.pm view on Meta::CPAN


Accept three style of arguments:

=over4

=item  An L<HTTP::Request> object

Runs this against the application as if running from a client such as a browser

=item Parameters ($method, $path) 

A single domain specific language used to construct an L<HTTP::Request> object.

If the HTTP method is POST or PUT, then a series of pairs can be passed after
this to create a form style message body. If you need to test an upload, then
create an L<HTTP::Request> object by hand or use the C<POST> subroutine
provided by L<HTTP::Request::Common>.
 
If you prefix the URL with 'user:pass@' this will be converted into
an Authorization header for HTTP basic auth:
 
    my $res = $app->http_response_from(

view all matches for this distribution

Catalyst-Plugin-Server-JSONRPC

10 results

lib/JSON/RPC/Common/Marshal/Catalyst.pm view on Meta::CPAN

=head1 DESCRIPTION

This object provides marshalling routines to convert L<Catalyst::Request> 
to L<JSON::RPC::Common:Call> object.

Use  L<JSON::RPC::Common::Marshal::Catalyst> to work with L<HTTP::Request>

=head1 METHODS

=over 4

view all matches for this distribution

Catalyst-Plugin-Server

7 results

t/inc/local_request.pl view on Meta::CPAN


    *Catalyst::Test::local_request = sub {
        my ( $class, $request ) = @_;
        use Data::Dumper;

        require HTTP::Request::AsCGI;
        require Catalyst::Utils;
        $request = ref($request) ? $request : Catalyst::Utils::request($request);
        my $cgi = HTTP::Request::AsCGI->new( $request, %ENV )->setup;

        $class->handle_request;

        return $cgi->restore->response;
    };

view all matches for this distribution

Catalyst-Plugin-Session-Store-Cookie

1 match

t/basic.t view on Meta::CPAN

  MyApp->config('Plugin::Session' => {storage_secret_key => 'abc123'});
  MyApp->setup;
}


use HTTP::Request::Common;
use Test::WWW::Mechanize::Catalyst qw/MyApp/;
 
ok my $m = Test::WWW::Mechanize::Catalyst->new;

$m->get_ok( "http://localhost/root/create_session", "create session" );

view all matches for this distribution

Catalyst-Plugin-Session

2 results

t/lib/MiniUA.pm view on Meta::CPAN

package MiniUA;
use strict;
use warnings;
use Plack::Test ();
use HTTP::Cookies;
use HTTP::Request::Common;

sub new {
  my ($class, $app, $opts) = @_;
  my $psgi
    = ref $app eq 'CODE' ? $app

view all matches for this distribution

Catalyst-Plugin-SmartURI

4 results

            "Catalyst::Action::REST" : "0",
            "Catalyst::Controller" : "0",
            "Catalyst::Test" : "0",
            "File::Spec" : "0",
            "FindBin" : "0",
            "HTTP::Request" : "0",
            "IO::Handle" : "0",
            "IPC::Open3" : "0",
            "Test::More" : "0",
            "Test::Warnings" : "0",
            "Time::HiRes" : "0",

view all matches for this distribution

Catalyst-Plugin-SpecialAction-Trail

4 results

build_requires:
  Catalyst::Test: 0
  Data::Dumper: 0
  ExtUtils::MakeMaker: 6.42
  FindBin: 0
  HTTP::Request::Common: 5.824
  Path::Class: 0.16
  Test::Deep: 0.103
  Test::Differences: 0.4801
  Test::More: 0.92
  Test::Most: 0.21

view all matches for this distribution

Catalyst-Plugin-Static-File

7 results

            "Catalyst" : "5.90129",
            "Catalyst::Controller" : "0",
            "Catalyst::Test" : "0",
            "File::Spec" : "0",
            "FindBin" : "0",
            "HTTP::Request::Common" : "0",
            "HTTP::Status" : "0",
            "Module::Metadata" : "1.000015",
            "Moose" : "0",
            "Path::Tiny" : "0",
            "Plack::Builder" : "0",

view all matches for this distribution

Catalyst-Plugin-Static

1 match

t/02static.t view on Meta::CPAN

use Catalyst::Test 'TestApp';

use File::stat;
use File::Slurp;
use HTTP::Date;
use HTTP::Request::Common;

my $stat = stat($0);

{
    ok( my $response = request('/02static.t'),        'Request'                   );

view all matches for this distribution

Catalyst-Plugin-URI

3 results

abstract: 'Sugar and strong errors for $c->uri_for'
author:
  - 'John Napiorkowski <jjnapiork@cpan.org>'
build_requires:
  Catalyst: '5.90060'
  HTTP::Request::Common: '0'
  Test::Most: '0'
configure_requires:
  ExtUtils::MakeMaker: '0'
dynamic_config: 0
generated_by: 'Dist::Zilla version 6.025, CPAN::Meta::Converter version 2.150010'

view all matches for this distribution

Catalyst-Plugin-URLMap

4 results

  - 'John Napiorkowski <jjnapiork@cpan.org>'
build_requires:
  Catalyst: 5.90001
  Catalyst::Test: 0
  FindBin: 0
  HTTP::Request::Common: 0
  Moose: 0
  Plack::App::File: 0
  Plack::App::URLMap: 0
  Plack::Component: 0
  Plack::Util: 0

view all matches for this distribution

Catalyst-Plugin-UploadProgress

1 match