File Coverage

blib/lib/Test2/Tools/HTTP/UA/Mojo.pm

Criterion	Covered	Total	%
statement	63	64	98.4
branch	10	14	71.4
condition	3	3	100.0
subroutine	9	10	90.0
pod	1	3	33.3
total	86	94	91.4

package Test2::Tools::HTTP::UA::Mojo;

use strict;
use warnings;
use 5.01001;
use parent 'Test2::Tools::HTTP::UA';

# ABSTRACT: Mojo user agent wrapper for Test2::Tools::HTTP
our $VERSION = '0.04'; # VERSION


sub new
{
  my $class = shift;

  # we want to require tese on demand here when the wrapper gets
  # created rather than use them up at the top, because this .pm
  # gets used every time Test2::Tool::HTTP::UA gets used, even
  # if we aren't using Mojolicious in the .t file.
  require Mojolicious;
  require Mojo::URL;
  require IO::Socket::INET;
  require HTTP::Request;
  require HTTP::Response;
  require HTTP::Message::PSGI;
  require Test2::Tools::HTTP::UA::Mojo::Proxy;

  $class->SUPER::new(@_);
}

sub instrument
{
  my($self) = @_;

  if($self->ua->server->app)
  {
    $self->apps->base_url($self->ua->server->url->to_string);
  }

  my $proxy_psgi_app = sub {
    my $env = shift;

    my $app = $self->apps->uri_to_app($env->{REQUEST_URI});
    $app
      ? $app->($env)
      : [ 404, [ 'Content-Type' => 'text/plain' ], [ '404 Not Found' ] ];
  };

  my $proxy_mojo_app = Mojolicious->new;
  $proxy_mojo_app->plugin('Mojolicious::Plugin::MountPSGI' => { '/' => $proxy_psgi_app });

  my $proxy_url = Mojo::URL->new("http://127.0.0.1");
  $proxy_url->port(do {
    IO::Socket::INET->new(
      Listen    => 5,
      LocalAddr => '127.0.0.1',
    )->sockport;
  });

  my $proxy_mojo_server = $self->{proxy_mojo_server} = Mojo::Server::Daemon->new(
    ioloop => $self->ua->ioloop,
    silent => 1,
    app    => $proxy_mojo_app,
    listen => ["$proxy_url"],
  );
  $proxy_mojo_server->start;

  my $old_proxy = $self->ua->proxy;
  my $new_proxy = Test2::Tools::HTTP::UA::Mojo::Proxy->new(
    apps           => $self->apps,
    http           => $old_proxy->http,
    https          => $old_proxy->https,
    not            => $old_proxy->not,
    apps_proxy_url => $proxy_url,
  );

  $self->ua->proxy($new_proxy);
}

sub request
{
  my($self, $req, %options) = @_;

  require Mojo::Transaction::HTTP;
  require Mojo::Message::Request;

  # Add the User-Agent header to the HTTP::Request
  # so that T2::T::HTTP can see it in diagnostics
  $req->header('User-Agent' => $self->ua->transactor->name)
    unless $req->header('User-Agent');

  my $mojo_req = Mojo::Message::Request->new;
  $mojo_req->parse($req->to_psgi);
  $mojo_req->url(Mojo::URL->new($req->uri.''))
    if $req->uri !~ /^\//;

  my $tx = Mojo::Transaction::HTTP->new(req => $mojo_req);

  my $res;

  if($options{follow_redirects})
  {
    my $error;
    $self->ua->start_p($tx)->then(sub {
      my $tx = shift;
      $res = HTTP::Response->parse($tx->res->to_string);
      $res->request(HTTP::Request->parse($tx->req->to_string));
    })->catch(sub {
      $error = shift;
    })->wait;
    $self->error("connection error: $error") if $error;
  }
  else
  {
    $self->ua->start($tx);
    my $err = $tx->error;
    if($err && !$err->{code})
    {
      $self->error("connection error: " . $err->{message});
    }
    $res = HTTP::Response->parse($tx->res->to_string);
    $res->request($req);
  }

  # trim weird trailing stuff
  my $message = $res->message;
  $message =~ s/\s*$//;
  $res->message($message);

  $res;
}

__PACKAGE__->register('Mojo::UserAgent', 'instance');

1;

__END__