File Coverage

blib/lib/Fennec.pm

Criterion	Covered	Total	%
statement	166	178	93.2
branch	37	52	71.1
condition	15	39	38.4
subroutine	32	33	96.9
pod	0	2	0.0
total	250	304	82.2

package Fennec;
use strict;
use warnings;

BEGIN { require Fennec::Runner }

use Fennec::Test;
use Fennec::Util qw/inject_sub require_module verbose_message/;
use Carp qw/croak carp/;
our $VERSION = '2.018';

sub defaults {
    (
        utils => [
            'Test::More',
            'Test::Warn',
            'Test::Exception',
            'Test::Workflow',
            'Mock::Quick',
            'Child',
        ],
        parallel     => defined $ENV{'FENNEC_PARALLEL'} ? $ENV{'FENNEC_PARALLEL'} : 3,
        runner_class => 'Fennec::Runner',
        with_tests   => [],
        Child        => ['child'],
        debug        => $ENV{'FENNEC_DEBUG'} || 0,
    );
}

sub _setup_class {
    my $class = shift;
    my ( $runner, $importer, $load ) = @_;
    return unless $load;

    require_module $load;

    no strict 'refs';
    *{"$importer\::CLASS"} = \$load;
    *{"$importer\::class"} = sub { $load };
}

sub import {
    my $class    = shift;
    my $importer = caller;

    my %defaults = $class->defaults;
    $defaults{runner_class} ||= 'Fennec::Runner';
    my %params = ( %defaults, @_ );

    $ENV{FENNEC_SEED}  ||= $params{seed}  if $params{seed};
    $ENV{FENNEC_DEBUG} ||= $params{debug} if $params{debug};

    my ( $runner, $runner_init ) = $class->_get_runner(
        $importer,
        $defaults{runner_class},
        $defaults{runner_params},
    );

    verbose_message("Entering build stage: $importer\n");

    push @{$runner->test_classes} => $importer;

    my $meta = $class->_init_meta( $importer, %params );

    $class->_setup_class( $runner, $importer, $params{class} );
    $class->_process_deps( $runner, $params{skip_without} );
    $class->_set_isa( $importer, 'Fennec::Test', $meta->base );
    $class->_load_utils( $importer, %params );

    # Intercept Mock::Quick mocks
    my $wfmeta = $importer->TEST_WORKFLOW;
    if ( $wfmeta && grep { $_ eq 'Mock::Quick' } @{$defaults{utils} || []}) {
        my $intercept = sub {
            my ($code) = @_;
            my @caller = caller;

            my $store = $wfmeta->control_store;
            return push @$store => $code->() if $store;

            my $layer = $wfmeta->peek_layer || $wfmeta->root_layer;
            $layer->add_control($code);
        };
        no strict 'refs';
        *{"$importer\::QINTERCEPT"} = sub{ $intercept };
    }

    $class->_with_tests( $importer, $params{with_tests} );
    $class->init( %params, importer => $importer, meta => $meta );

    if ($ENV{FENNEC_DEBUG} || $params{debug}) {
        require Time::HiRes;
        my $collector;
        my $debug = sub {
            my $msg = pop;

            my ($sec, $ms) = Time::HiRes::gettimeofday();
            my $line = sprintf(
                "FENNEC_DEBUG_CUSTOM:PID:%d\0SEC:%d\0MSEC:%d\0MESSAGE:%s\n",
                $$,
                $sec,
                $ms,
                $msg
            );
            $collector ||= Fennec::Runner->new->collector;
            $collector->diag($line);
        };
        no strict 'refs';
        *{"$importer\::fennec_debug"} = $debug;
    }

    $class->_export_done_testing(
        $importer,
        $runner,
        $runner_init,
    );

    $class->after_import({
        importer => $importer,
        runner   => $runner,
        meta     => $meta,
        wf_meta  => $wfmeta,
        layer    => $wfmeta->peek_layer || $wfmeta->root_layer,
    }) if $class->can('after_import');

    verbose_message("Entering primary stage: $importer\n");
}

sub init {
    my $class    = shift;
    my %params   = @_;
    my $importer = $params{importer};
    my $meta     = $params{meta};

    my $wfmeta = $importer->TEST_WORKFLOW;
    $wfmeta->test_sort( $meta->test_sort )
        if $meta->test_sort;

    no strict 'refs';
    my $stash = \%{"$importer\::"};
    delete $stash->{$_} for qw/run_tests done_testing/;
}

sub _get_runner {
    my $class = shift;
    my ( $importer, $runner_class, $runner_params ) = @_;

    require_module $runner_class;
    my $runner_init = $runner_class->is_initialized;

    croak "Fennec cannot be used in package 'main' when the test is used with Fennec::Finder"
        if $runner_init && $importer eq 'main';

    if ($runner_init) {
        my $runner = $runner_class->new;
        carp "Runner is already initialized, but it is not a $runner_class"
            unless $runner->isa($runner_class);

        carp "Runner is already initialized, ignoring 'runner_params'"
            if $runner_params;

        return ( $runner, $runner_init );
    }

    my $runner = $runner_class->new(
        parallel => 0,
        $runner_params ? (%$runner_params) : (),
    );

    require Fennec::EndRunner;
    Fennec::EndRunner->set_pid($$);
    Fennec::EndRunner->set_runner($runner);

    return ( $runner, $runner_init );
}

sub _process_deps {
    my $class = shift;
    my ( $runner, $deps ) = @_;

    return unless $deps && @$deps;

    for my $require (@$deps) {
        unless ( eval { require_module $require; 1 } ) {
            $runner->_skip_all(1);
            $runner->collector->skip("'$require' is not installed");
            $runner->collector->finish;
            exit 0;
        }
    }
}

sub _init_meta {
    my $class = shift;
    my ( $importer, %params ) = @_;

    require Fennec::Meta;

    my $meta = Fennec::Meta->new(
        %params,

        # Well, this is confusing.
        fennec => $class,
        class  => $importer,
    );

    inject_sub( $importer, 'FENNEC', sub { $meta } );

    return $meta;
}

sub _set_isa {
    my $class = shift;
    my ( $importer, @bases ) = @_;

    for my $base (@bases) {
        next unless $base;
        no strict 'refs';
        require_module $base;
        push @{"$importer\::ISA"} => $base
            unless grep { $_ eq $base } @{"$importer\::ISA"};
    }
}

sub _load_utils {
    my $class = shift;
    my ( $importer, %params ) = @_;

    my $utils = $params{utils};
    return unless $utils && @$utils;

    for my $util (@$utils) {
        require_module $util;
        my $args = $params{$util} || [];
        my $code = "package $importer; $util\->import(\@\$args); 1";
        eval $code || die $@;
    }
}

sub _with_tests {
    my $class = shift;
    my ( $importer, $classes ) = @_;

    return unless $classes && @$classes;

    $importer->TEST_WORKFLOW->root_layer->merge_in( undef, @$classes );
}

sub _export_done_testing {
    my $class = shift;
    my ( $importer, $runner, $runner_init ) = @_;

    if ($runner_init) {
        no strict 'refs';
        no warnings 'redefine';
        *{"$importer\::done_testing"} = sub {
            $importer->FENNEC->post(@_) if @_;
            return 1;
        };
    }
    else {
        no strict 'refs';
        no warnings 'redefine';
        my $has_run = 0;
        *{"$importer\::done_testing"} = sub {
            croak "done_testing() called more than once!"
                if $has_run++;

            Fennec::EndRunner->set_runner(undef);

            $importer->FENNEC->post(@_) if @_;
            $runner->run();

            1;
        };
    }
}

1;

__END__