File Coverage

blib/lib/Test/MockCommand/Result.pm

Criterion	Covered	Total	%
statement	67	72	93.0
branch	25	32	78.1
condition	7	13	53.8
subroutine	14	15	93.3
pod	6	6	100.0
total	119	138	86.2

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

use Carp qw(croak);
use Symbol;

use Test::MockCommand::TiedFH;

# create some accessor subroutines on the fly
my @ACCESSORS = qw(command function arguments return_value cwd
		   input_data output_data exit_code all_results);
no strict 'refs';
for my $attrib (@ACCESSORS) {
    my $method = __PACKAGE__ . '::' . $attrib;
    next if *$method{CODE};
    *$method = sub {
	$_[0]->{$attrib} = $_[1] if @_ > 1;
	return $_[0]->{$attrib};
    };
}
use strict 'refs';

sub new {
    my $class = shift;
    croak "odd number of parameters" if @_ % 2;
    my %args = @_;
    my $self = {
        command   => $args{command},
	function  => $args{function},
        arguments => [ @{$args{arguments}} ] # copy rather than reference
    };

    # turn the first argument to open() to undef, always
    $self->{arguments}->[0] = undef if $self->{function} eq 'open';

    return bless $self, $class;
}

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

    # function and command have already been matched

    # check the arguments match exactly
    if (exists $args{arguments}) {
	return 0 if @{$args{arguments}} != @{$self->{arguments}};
	for (my $i = 0; $i < @{$args{arguments}}; $i++) {
	    next if not defined $args{arguments}->[$i] and
	            not defined $self->{arguments}->[$i];
	    return 0 if not defined $args{arguments}->[$i] or
	                 not defined $self->{arguments}->[$i];
	    return 0 if $args{arguments}->[$i] ne $self->{arguments}->[$i];
	}
    }

    # result matches. award more points if cwd matches too
    my $cwd = defined $args{cwd} ? $args{cwd} : Cwd::cwd();
    return $self->cwd() eq $cwd ? 2 : 1;
}

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

    # set the list of all results
    $self->all_results($args{all_results});

    # handle open() emulation
    if ($args{function} eq 'open' && $self->return_value()) {

	# make our own filehandle and tie it to ourselves
	my $fh = $self->create_tied_fh();

	# create the requested filehandle
	if (defined $args{arguments}->[0]) {
	    no strict 'refs';
	    # file handle is a bareword symbol reference
	    my $sym = Symbol::qualify($args{arguments}->[0], $args{caller}->[0]);
	    *$sym = $fh;
	}
	else {
	    $args{arguments}->[0] = $fh;
	}
    }

    # set the exit code
    $? = $self->exit_code();

    # return the result
    return $self->return_value();
}

sub create_tied_fh {
    my $self = shift;
    my $fh = gensym();
    tie *$fh, 'Test::MockCommand::TiedFH', 0, undef, $self;
    return $fh;
}

sub append_input_data {
    my $self = shift;
    $self->{input_data} ||= '';
    $self->{input_data} .= $_[0];
}

sub append_output_data {
    my $self = shift;
    $self->{output_data} ||= '';
    $self->{output_data} .= $_[0];
}

1;

__END__