File Coverage

blib/lib/Test/MockCommand/Recorder.pm

Criterion	Covered	Total	%
statement	75	78	96.1
branch	14	22	63.6
condition			n/a
subroutine	18	18	100.0
pod	10	10	100.0
total	117	128	91.4

package Test::MockCommand::Recorder;
use strict;
use warnings;

use Cwd;
use Carp qw(croak);
use Symbol;

use Test::MockCommand::Result;
use Test::MockCommand::TiedFH;

sub new {
    my $class = shift;
    return bless {}, $class;
}

sub handle {
    my $self = shift;
        croak "odd number of parameters" if @_ % 2;
    my %args = @_;

    # check arguments
    for (qw(command function arguments caller)) {
	croak "no $_ parameter" unless exists $args{$_};
    }

    # check function is one we know
    croak "unknown function $args{function}"
      unless $args{function} =~ /^(open|readpipe|system|exec)$/;

    # do we want to handle recording this command?
    return undef unless $self->matches(%args);

    # capture data before running the command
    $args{result} = $self->pre_capture(%args);

    # emulate and record the appropriate function
    if ($args{function} eq 'open') {
	$args{return_value} = $self->record_open(%args);
    }
    elsif ($args{function} eq 'readpipe') {
	$args{return_value} = $self->record_readpipe(%args);
    }
    elsif ($args{function} eq 'system') {
	$args{return_value} = $self->record_system(%args);
    }
    elsif ($args{function} eq 'exec') {
	$args{return_value} = $self->record_exec(%args);
    }

    # capture data after running the command
    $self->post_capture(%args);

    # return the result object
    return $args{result};
}

sub matches {
    # always record commands
    return 1;
}

sub pre_capture {
    my $self = shift;

    # create result object
    my $result = Test::MockCommand::Result->new(@_);

    # set the current working directory
    $result->cwd(Cwd::cwd());

    # TODO: check command line to see if it's a shell invocation, and if so,
    # check if it uses an external source of input with the '<' operator

    return $result;
}

sub post_capture {
    my $self = shift;
    my %args = @_;

    $args{result}->return_value($args{return_value});

    $args{result}->exit_code($?);

    # TODO: check command line to see if it's a shell invocation, and if so,
    # check if it writes or appends to an external output file with the
    # '>', '>>', '2>', etc. operators
}

sub record_open {
    my $self = shift;
    my %all_args = @_;
    my $args = $all_args{arguments};

    # call the real open() using our own filehandle
    my $fh = undef;
    my $opened = (@{$args} < 3)
        ? CORE::open($fh, $args->[-1])
	: CORE::open($fh, $args->[1], $args->[2], splice(@{$args}, 3));
    return 0 unless $opened;

    # make our own filehandle and tie it to the open FH and result object
    my $our_fh = $self->create_tied_fh($fh, $all_args{result});

    # create the requested filehandle
    if (defined $args->[0]) {
	# file handle is a bareword symbol reference
	my $sym = Symbol::qualify($args->[0], $all_args{caller}->[0]);

	no strict 'refs';
	*$sym = $our_fh;
    }
    else {
	$args->[0] = $our_fh;
    }

    # return result of open
    return $opened;
}

sub create_tied_fh {
    my ($self, $real_open_fh, $result_object) = @_;
    my $fh = gensym();
    tie *$fh, 'Test::MockCommand::TiedFH', 1, $real_open_fh, $result_object;
    return $fh;
}

sub record_system {
    my $self = shift;
    my %args = @_;
    return CORE::system(@{$args{arguments}});
}

sub record_exec {
    my $self = shift;
    return $self->record_system(@_);
}

sub record_readpipe {
    my $self = shift;
    my %args = @_;

    # readpipe() in perl >= 5.27.7 breaks when passed a dereferenced array,
    # it essentially calls scalar() on its arguments. @{["command"]} becomes
    # "1" rather than "command". We have to pass a single scalar value.
    # https://rt.perl.org/Public/Bug/Display.html?id=132810
    # https://rt.perl.org/Public/Bug/Display.html?id=4574
    my @out = CORE::readpipe($args{arguments}->[0]);

    # handle() will automatically split this according to $/
    # if needed, but we always return it as a scalar
    return join '', @out;
}

1;

__END__