Frey/Test/Runner.pm

package Frey::Test::Runner;
use Moose;

extends 'Frey';
with 'Frey::Web';
with 'Frey::Storage';

use TAP::Harness;
use TAP::Formatter::HTML;
use Data::Dump qw/dump/;

use Frey::SVK;
use Frey::PPI;

has tests => (
        is => 'rw',
        isa => 'ArrayRef[Str]',
        required => 1,
        lazy => 1, # FIXME ask users which tests to run
        default => sub {
#               [ glob('t/*.t') ] # all tests
                [ Frey::SVK->modified ]
        },
);

sub as_markup {
        my ($self) = @_;

        my $f = TAP::Formatter::HTML->new({
                silent => 1,

                inline_css => 1,
                inline_js => 1,
        });
        my $h = TAP::Harness->new({
                merge => 1,
                formatter => $f,
        });

        my @tests =
                grep { ! m{$0} } # FIXME privitive way to break recursion
                grep { m{\.t$} } # take just tests
                map {
                        if ( m{(.+)\.pm$} ) {
                                my $class = $1;
                                $class =~ s{^lib/}{};
                                $class =~ s{/}{::}g;
                                warn "extract $_ tests $class";
                                Frey::PPI->new( class => $class )->has_tests;
                        } else {
                                $_
                        }
                }
                @{ $self->tests };

        die "no tests for files ", dump( $self->tests ) unless @tests;

        warn "testing ",dump( @tests );
        $h->runtests( @tests );

        $self->store( 'var/test.yaml', $h );

        my $html = ${ $f->html };
#       warn $html;
        warn "got ",length($html), " bytes";
#       $html =~ s{^.*<body>}{}s;
#       $html =~ s{</body>.*$}{}s;
        return $self->editor_links( $html );
}

1;
1	dpavlin	484	package Frey::Test::Runner;
2			use Moose;
3
4			extends 'Frey';
5			with 'Frey::Web';
6	dpavlin	486	with 'Frey::Storage';
7	dpavlin	484
8			use TAP::Harness;
9			use TAP::Formatter::HTML;
10			use Data::Dump qw/dump/;
11
12	dpavlin	486	use Frey::SVK;
13	dpavlin	489	use Frey::PPI;
14	dpavlin	486
15	dpavlin	484	has tests => (
16			is => 'rw',
17			isa => 'ArrayRef[Str]',
18			required => 1,
19			lazy => 1, # FIXME ask users which tests to run
20	dpavlin	486	default => sub {
21			# [ glob('t/*.t') ] # all tests
22			[ Frey::SVK->modified ]
23			},
24	dpavlin	484	);
25
26			sub as_markup {
27			my ($self) = @_;
28
29			my $f = TAP::Formatter::HTML->new({
30			silent => 1,
31
32			inline_css => 1,
33			inline_js => 1,
34			});
35			my $h = TAP::Harness->new({
36			merge => 1,
37			formatter => $f,
38			});
39
40	dpavlin	486	my @tests =
41			grep { ! m{$0} } # FIXME privitive way to break recursion
42			grep { m{\.t$} } # take just tests
43	dpavlin	489	map {
44			if ( m{(.+)\.pm$} ) {
45			my $class = $1;
46			$class =~ s{^lib/}{};
47			$class =~ s{/}{::}g;
48			warn "extract $_ tests $class";
49			Frey::PPI->new( class => $class )->has_tests;
50			} else {
51			$_
52			}
53			}
54	dpavlin	486	@{ $self->tests };
55	dpavlin	489
56			die "no tests for files ", dump( $self->tests ) unless @tests;
57
58	dpavlin	484	warn "testing ",dump( @tests );
59			$h->runtests( @tests );
60
61	dpavlin	486	$self->store( 'var/test.yaml', $h );
62
63	dpavlin	484	my $html = ${ $f->html };
64			# warn $html;
65			warn "got ",length($html), " bytes";
66			# $html =~ s{^.*<body>}{}s;
67			# $html =~ s{</body>.*$}{}s;
68			return $self->editor_links( $html );
69			}
70
71			1;