App-Prove-Plugin-Elasticsearch

 view release on metacpan or  search on metacpan

lib/App/Prove/Elasticsearch/Harness.pm  view on Meta::CPAN

use strict;
use warnings;

use parent qw/TAP::Harness/;

# inject parser_class as Test::Rail::Parser.
sub new {
    my $class   = shift;
    my $arg_for = shift;
    $arg_for->{parser_class} = 'App::Prove::Elasticsearch::Parser';
    my $self = $class->SUPER::new($arg_for);
    return $self;
}

sub make_parser {
    my ($self, $job) = @_;

    my $args = $self->SUPER::_get_parser_args($job);

    my @relevant_keys =
      qw{SERVER_HOST SERVER_PORT CLIENT_INDEXER CLIENT_BLAMER CLIENT_VERSIONER CLIENT_PLATFORMER CLIENT_AUTODISCOVER};
    my @keys_filtered = grep {
        my $subj = $_;
        grep { $_ eq $subj } @relevant_keys
    } keys(%ENV);
    foreach my $key (@keys_filtered) {
        my $km = lc($key);
        $km =~ s/_/./g;
        $args->{$km} = $ENV{$key};
        $self->{$km} = $ENV{$key};
    }

    $self->SUPER::_make_callback('parser_args', $args, $job->as_array_ref);
    my $parser = $self->SUPER::_construct($self->SUPER::parser_class, $args);

    $self->SUPER::_make_callback('made_parser', $parser, $job->as_array_ref);
    my $session =
      $self->SUPER::formatter->open_test($job->description, $parser);

    return ($parser, $session);
}

sub runtests {
    my ($self, @tests) = @_;

    if ($ENV{CLIENT_AUTODISCOVER}) {
        my $searcher = $self->_require_deps();
        @tests = $self->_filter_tests_with_results($searcher, @tests);
    }

    return $self->SUPER::runtests(@tests);
}

sub _filter_tests_with_results {
    my ($self, $searcher, @tests) = @_;
    my $indexer = $ENV{CLIENT_INDEXER};
    my $conf    = {
        'server.host'       => $ENV{SERVER_HOST},
        'server.port'       => $ENV{SERVER_PORT},
        'client.versioner'  => $ENV{CLIENT_VERSIONER},
        'client.platformer' => $ENV{CLIENT_PLATFORMER},

lib/App/Prove/Elasticsearch/Indexer/DzilDist.pm  view on Meta::CPAN

package App::Prove::Elasticsearch::Indexer::DzilDist;
$App::Prove::Elasticsearch::Indexer::DzilDist::VERSION = '0.001';
use strict;
use warnings;

use parent qw{App::Prove::Elasticsearch::Indexer};

#Basically, do this:
#our $index = `awk '/^name/ {print \$NF}' dist.ini`;

our $index = __CLASS__->SUPER::index;
our $dfile //= 'dist.ini';

if (open(my $dh, '<', $dfile)) {
    while (<$dh>) {
        ($index) = $_ =~ /^name\s*?=\s*?(.*)/;
        if ($index) {
            $index =~ s/^\s+//;
            last;
        }
    }

lib/App/Prove/Elasticsearch/Indexer/MMDist.pm  view on Meta::CPAN

# ABSTRACT: Names your elasticsearch index after your distribution as defined in Makefile.PL
# PODNAME: App::Prove::Elasticsearch::Indexer::MMDist

package App::Prove::Elasticsearch::Indexer::MMDist;
$App::Prove::Elasticsearch::Indexer::MMDist::VERSION = '0.001';
use strict;
use warnings;

use parent qw{App::Prove::Elasticsearch::Indexer};

our $index = __CLASS__->SUPER::index;
our $dfile //= 'Makefile.PL';

if (open(my $dh, '<', $dfile)) {
    ;
    while (<$dh>) {
        ($index) = $_ =~ /DISTNAME.*\s*?=>\s*?["|'](.*)["|'],?/;
        if ($index) {
            $index =~ s/^\s+//;
            last;
        }

lib/App/Prove/Elasticsearch/Parser.pm  view on Meta::CPAN

    my $esopts = {
        'server.host'       => delete $opts->{'server.host'},
        'server.port'       => delete $opts->{'server.port'},
        'client.indexer'    => delete $opts->{'client.indexer'},
        'client.versioner'  => delete $opts->{'client.versioner'} // 'Default',
        'client.blamer'     => delete $opts->{'client.blamer'} // 'Default',
        'client.platformer' => delete $opts->{'client.platformer'} // 'Default',
        'client.autodiscover' => delete $opts->{'client.autodiscover'},
    };

    my $self = $class->SUPER::new($opts);
    if (ref($self->{'_iterator'}->{'command'}) eq 'ARRAY') {
        $self->{'file'} = $self->{'_iterator'}->{'command'}->[-1];
        print "# PROCESSING RESULTS FROM TEST FILE: $self->{'file'}\n";
    }

    my $indexer = $esopts->{'client.indexer'};
    _require_indexer($indexer);
    my $versioner =
      App::Prove::Elasticsearch::Utils::require_versioner($esopts);
    my $platformer =

lib/App/Prove/Elasticsearch/Parser.pm  view on Meta::CPAN

}

sub planCallback {
    my ($plan) = @_;
    my $self = $plan->{'parser'};
    $self->{raw_output} .= $plan->as_string . "\n";
}

sub make_result {
    my ($self, @args) = @_;
    my $res = $self->SUPER::make_result(@args);
    $res->{'parser'} = $self;
    return $res;
}

1;

__END__

=pod

lib/App/Prove/Elasticsearch/Queue/Rabbit.pm  view on Meta::CPAN

use strict;
use warnings;

use parent qw{App::Prove::Elasticsearch::Queue::Default};

use Net::RabbitMQ;
use JSON::MaybeXS;

sub new {
    my ($class, $input) = @_;
    my $self = $class->SUPER::new($input);

    #Connect to rabbit
    $self->{mq} = Net::RabbitMQ->new();
    $self->{config}->{'queue.exchange'} ||= 'testsuite';

    #Allow callers to overwrite this to prevent double-usage of channels
    $self->{write_channel} = 1;
    $self->{read_channel}  = 2;

    my $port =