File Coverage

blib/lib/Selenium/Remote/Mock/RemoteConnection.pm

Criterion	Covered	Total	%
statement	80	97	82.4
branch	21	30	70.0
condition	11	15	73.3
subroutine	13	14	92.8
pod	2	5	40.0
total	127	161	78.8

package Selenium::Remote::Mock::RemoteConnection;
$Selenium::Remote::Mock::RemoteConnection::VERSION = '1.48';
# ABSTRACT: utility class to mock the responses from Selenium server

use strict;
use warnings;

use Moo;
use JSON;
use Carp;
use Try::Tiny;
use HTTP::Response;
use Data::Dumper;

extends 'Selenium::Remote::RemoteConnection';

has 'spec' => (
    is      => 'ro',
    default => sub { {} },
);

has 'mock_cmds' => ( is => 'ro', );

has 'fake_session_id' => (
    is      => 'lazy',
    builder => sub {
        my $id = join '',
          map +( 0 .. 9, 'a' .. 'z', 'A' .. 'Z' )[ rand( 10 + 26 * 2 ) ],
          1 .. 50;
        return $id;
    },
);

has 'record' => (
    is      => 'ro',
    default => sub { 0 }
);

has 'replay' => ( is => 'ro', );

has 'replay_file' => ( is => 'ro', );

has 'session_store' => (
    is      => 'rw',
    default => sub { {} }
);

has 'session_id' => (
    is      => 'rw',
    default => sub { undef },
);

has 'remote_server_addr' => (
    is      => 'lazy',
    default => sub { 'localhost' }
);


sub BUILD {
    my $self = shift;
    croak 'Cannot define replay and record attributes at the same time'
      if ( ( $self->replay ) && ( $self->record ) );
    croak 'replay_file attribute needs to be defined'
      if ( ( $self->replay ) && !( $self->replay_file ) );
    croak 'replay attribute needs to be defined'
      if ( !( $self->replay ) && ( $self->replay_file ) );
    $self->port('4444');
    if ( $self->replay ) {
        $self->load_session_store( $self->replay_file );
    }
}

sub check_status {
    return;
}

sub load_session_store {
    my $self = shift;
    my $file = shift;
    croak "'$file' is not a valid file" unless ( -f $file );
    open( my $fh, '<', $file ) or croak "Opening '$file' failed";

    # here we use a fake session id since we have no way of figuring out
    # which session is good or not
    local $/ = undef;

    my $json = JSON->new;
    $json->allow_blessed;
    my $decoded_json = $json->allow_nonref(1)->utf8(1)->decode(<$fh>);
    close($fh);
    $self->session_store($decoded_json);
}

sub dump_session_store {
    my $self = shift;
    my ($file) = @_;
    open( my $fh, '>', $file ) or croak "Opening '$file' failed";
    my $session_store = $self->session_store;
    my $dump          = {};
    foreach my $path ( keys %{$session_store} ) {
        $dump->{$path} = $session_store->{$path};
    }
    my $json = JSON->new;
    $json->allow_blessed;
    my $json_session = $json->allow_nonref->utf8->pretty->encode($dump);
    print $fh $json_session;
    close($fh);
}

sub request {
    my $self = shift;
    my ( $resource, $params ) = @_;
    my $method             = $resource->{method};
    my $url                = $resource->{url};
    my $no_content_success = $resource->{no_content_success} // 0;
    my $content            = '';
    my $json               = JSON->new;
    $json->allow_blessed;

    if ($params) {
        $content = $json->allow_nonref->utf8->canonical(1)->encode($params);
    }
    my $url_params = $resource->{url_params};

    print "REQ: $method, $url, $content\n" if $self->debug;

    if ( $self->record ) {
        my $response = $self->SUPER::request( $resource, $params, 1 );
        push @{ $self->session_store->{"$method $url $content"} },
          $response->as_string;
        return $self->_process_response( $response, $no_content_success );
    }
    if ( $self->replay ) {
        my $resp;
        my $arr_of_resps = $self->session_store->{"$method $url $content"}
          // [];
        if ( scalar(@$arr_of_resps) ) {
            $resp = shift @$arr_of_resps;
            $resp = HTTP::Response->parse($resp);
        }
        else {
            $resp = HTTP::Response->new( '501', "Failed to find a response" );
        }
        return $self->_process_response( $resp, $no_content_success );
    }
    my $mock_cmds = $self->mock_cmds;
    my $spec      = $self->spec;
    my $cmd       = $mock_cmds->get_method_name_from_parameters(
        { method => $method, url => $url } );
    my $ret = { cmd_status => 'OK', cmd_return => 1 };
    if ( defined( $spec->{$cmd} ) ) {
        my $return_sub = $spec->{$cmd};
        my $mock_return = $return_sub->( $url_params, $params );
        if ( ref($mock_return) eq 'HASH' ) {
            $ret->{cmd_status} = $mock_return->{status};
            $ret->{cmd_return} = $mock_return->{return};
            $ret->{cmd_error}  = $mock_return->{error} // '';
        }
        else {
            $ret = $mock_return;
        }
        $ret->{session_id} = $self->fake_session_id if ( ref($ret) eq 'HASH' );
    }
    else {
        $ret->{sessionId} = $self->fake_session_id;
    }
    return $ret;
}

1;

__END__