File Coverage

blib/lib/Test/Double/Mock/Expectation.pm

Criterion	Covered	Total	%
statement	85	85	100.0
branch	29	30	96.6
condition			n/a
subroutine	28	28	100.0
pod	7	9	77.7
total	149	152	98.0

package Test::Double::Mock::Expectation;

use strict;
use warnings;
use List::MoreUtils qw(each_array);
use Test::Deep qw(cmp_details);
use Test::More;

sub new {
    my ($class, %args) = @_;
    bless {
        behavior   => sub {},
        %args,
        called     => 0,
    }, $class;
}

sub with {
    my ($self, @args) = @_;
    $self->{with_args} = \@args;
    $self;
}

sub at_least {
    my ($self, $at_least) = @_;
    $self->{at_least} = $at_least;
    return $self;
}

sub at_most {
    my ($self, $at_most) = @_;
    $self->{at_most} = $at_most;
    return $self;
}

sub times {
    my ($self, $times) = @_;
    $self->{times} = $times;
    return $self;
}

sub returns {
    my ($self, $behavior) = @_;
    if (defined $behavior) {
        $self->{behavior} = ref($behavior) eq 'CODE' ? $behavior : sub { $behavior };
    }
    $self;
}

sub behavior {
    my $self = shift;
    return sub {
        my ($instance, @args) = @_;
        $self->{called}++;
        if ($self->{with_args}) {
            $self->_check_with($self->{called}, @args)
        }
        return $self->{behavior}->();
    };
}

sub _check_with {
    my ($self, $counter, @args) = @_;
    if (scalar @args != scalar @{$self->{with_args}}) {
        $self->{with}->{$counter} = 0;
        return;
    }
    my $ea = each_array(@{$self->{with_args}}, @args);
    while (my ($with_arg, $arg) = $ea->())  {
        my ($ok, $stack) = cmp_details($arg, $with_arg);
        if ($ok) {
            $self->{with}->{$counter} = 1;
        } else {
            $self->{with}->{$counter} = 0;
            return;
        }
    }
}

sub _check_at_least {
    my $self = shift;
    return $self->{called} < $self->{at_least} ? 0 : 1;
}

sub _check_at_most {
    my $self = shift;
    return $self->{called} > $self->{at_most} ? 0 : 1;
}

sub _check_at_times {
    my $self = shift;
    return $self->{called} != $self->{times} ? 0 : 1;
}

sub verify_result {
    my $self = shift;

    if ($self->{at_least}) {
        $self->{result}->{at_least} = $self->_check_at_least;
    }
    if ($self->{at_most}) {
        $self->{result}->{at_most} = $self->_check_at_most;
    }
    if ($self->{times}) {
        $self->{result}->{times} = $self->_check_at_times;
    }
    for (keys %{$self->{with}}) {
        $self->{result}->{with}->{$_} = $self->{with}->{$_};
    }

    return $self->{result};

}

sub verify {
    my $self = shift;

    $self->verify_result;
    if ($self->{at_least}) {
        ok $self->{result}->{at_least},
          "Expected method must be called at least " . $self->{at_least};
    }
    if ($self->{at_most}) {
        ok $self->{result}->{at_most},
          "Expected method must be called at most " . $self->{at_most};
    }
    if ($self->{times}) {
        ok $self->{result}->{times},
          "Expected method must be called " . $self->{times} . " times";
    }
    for (keys %{$self->{with}}) {
        ok $self->{result}->{with}->{$_},
          "Expected method must be called with "
          . join " ", map { ref $_ ? ref $_ : $_ } @{$self->{with_args}};
    }
}

1;
__END__