File Coverage

lib/App/Duppy.pm

Criterion	Covered	Total	%
statement	33	90	36.6
branch	0	20	0.0
condition	0	3	0.0
subroutine	11	18	61.1
pod	0	3	0.0
total	44	134	32.8

package App::Duppy;

# ABSTRACT: a wrapper around casperjs to pass test configurations as json files
use strict;
use warnings;
use Moo;
use MooX::Options;
use IPC::Run qw/run new_chunker/;
use File::Which;
use IO::All;
use JSON;
use DDP;
use Carp;
use Try::Tiny;

option 'test' => (
    is       => 'rw',
    required => 1,
    format   => 's@',
    doc =>
      'Test option: one ore more json file(s) containing the casperjs tests to perform'
);

option 'casper_path' => (
    is        => 'rw',
    format    => 's',
    doc       => 'Path to casperjs, if not standard',
    predicate => 'has_casper_path',
);

has 'tests' => ( is => 'lazy', );

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

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

sub _build_tests {
    my $self = shift;
    my $ret  = {};
    foreach my $file ( @{ $self->test } ) {
        if ( io($file)->exists ) {
            my $content = io($file)->slurp;
            try {
                $ret->{$file} = decode_json($content);
            }
            catch {
                carp "'$file' is not valid: $_";
            };
        }
        else {
            carp "'$file' does not exist";
        }
    }
    return $ret;
}

sub run_casper {
    my $self = shift;
    my $full_path;
    $self->buffer_return('') if ($self->buffer_return);
    if ( $self->has_casper_path ) {
        if ( -f $self->casper_path and -x $self->casper_path ) {
            $full_path = $self->casper_path;
        }
        else {
            croak sprintf(
                q{'%s' is not an executable file},
                $self->casper_path
            );
        }
    }
    else {
        $full_path = which('casperjs');
    }
    $self->silent_run (shift @_);
    foreach my $test ( keys %{ $self->tests } ) {
        my $param_spec = $self->transform_arg_spec( $self->tests->{$test} );
        unshift @{ $param_spec->{cmd} }, $full_path;
        push @{ $param_spec->{cmd} }, "test", @{ $param_spec->{paths} };
        print "\n\n\n";
        print "="x10;
        print "> Running test from file $test... \n\n\n";
        run  $param_spec->{cmd}, '>', new_chunker("\n"),$self->lines_handler;
    }

    if ($self->silent_run) {
        return $self->buffer_return;
    }
    else {
        return;
    }
}

sub lines_handler {
    my ($self,$in_ref,$out_ref) = @_;
    return sub {
        my ($out) = @_;
        if ($out) {
            if ($self->silent_run) {
                $self->buffer_return($self->buffer_return.$out);
            }
            else {
                print $out;
            }
        }
    }
}

sub transform_arg_spec {
    my $self       = shift;
    my $ref_params = shift;
    my $ret        = {};
    my %params     = %{$ref_params};
    $ret->{paths} = delete $params{paths};
    while ( my ( $k, $v ) = each %params ) {
        if ( ref($v) eq 'ARRAY' ) {
            $v = join( ',', @{$v} );
        }
        else {
            $v = "true"  if ( $v eq '1' );
            $v = "false" if ( $v eq '0' );
        }
        push @{ $ret->{cmd} }, "--$k=$v";
    }
    return $ret;
}



1;

__END__