File Coverage

blib/lib/Test/JsonAPI/Autodoc.pm

Criterion	Covered	Total	%
statement	75	76	98.6
branch	12	14	85.7
condition	5	6	83.3
subroutine	19	19	100.0
pod	5	5	100.0
total	116	120	96.6

package Test::JsonAPI::Autodoc;
use 5.008005;
use strict;
use warnings;
use parent qw/Exporter/;
use Carp;
use Test::More ();
use Scope::Guard;
use LWP::UserAgent;
use Test::JsonAPI::Autodoc::Markdown;
use Test::JsonAPI::Autodoc::Request;
use Test::JsonAPI::Autodoc::Response;

our @EXPORT = qw/
    describe
    http_ok
    plack_ok
    set_documents_path
    set_template
/;

our $VERSION = "0.20";

my $in_describe;
my $results;
my $first_time;

my $output_path;
my $template;

BEGIN {
    $first_time = 1;
}

sub set_documents_path {
    $output_path = shift;
}

sub set_template {
    $template = shift;
}

sub describe {
    if ($in_describe) {
        croak '`describe` must not call as nesting';
    }

    my $guard = sub {
        return Scope::Guard->new(sub {
            undef $in_describe;
            undef $results;
            undef $first_time;
        });
    }->();

    $in_describe = 1;

    my ($description, $coderef) = @_;

    # change location of test failure to be included Test::More's output
    # to be more helpful to user.
    local $Test::Builder::Level = $Test::Builder::Level + 1;

    my $result = Test::More::subtest($description => $coderef);

    if ($result && $results && $ENV{TEST_JSONAPI_AUTODOC}) {
        my $markdown = Test::JsonAPI::Autodoc::Markdown->new($output_path, $template);
        $markdown->generate($description, $results, $first_time);
    }
}

sub http_ok {
    my ($req, $expected_code, $note) = @_;
    return _api_ok($req, $expected_code, $note);
}

sub plack_ok {
    my ($plack_app, $req, $expected_code, $note) = @_;
    return _api_ok($req, $expected_code, $note, $plack_app);
}

sub _api_ok {
    my ($req, $expected_code, $note, $plack_app) = @_;

    my $description       = $note;
    my $param_description = {};
    if (ref $note eq 'HASH') {
        $description       = $note->{description};
        $param_description = $note->{param_description};
    }

    my $res;
    my $is_plack_app = 0;
    if ($plack_app) { # for Plack::Test
        $res = ref $plack_app eq 'CODE' ? $plack_app->($req)         # use `test_psgi`
                                        : $plack_app->request($req); # not use `test_psgi`
        $is_plack_app = 1;
    }
    else {
        $res = LWP::UserAgent->new->request($req);
    }

    # change location of test failure to be included Test::More's output
    # to be more helpful to user.
    local $Test::Builder::Level = $Test::Builder::Level + 2;

    my $result = Test::More::is $res->code, $expected_code;
    return unless $result;
    return unless $in_describe;

    my $parsed_request  = Test::JsonAPI::Autodoc::Request->new->parse($req, $param_description);
    my $parsed_response = Test::JsonAPI::Autodoc::Response->new->parse($res);

    my $response_body         = $parsed_response->{body};
    my $response_content_type = $parsed_response->{content_type};

    push @$results, {
        note                  => $description,

        path                  => $parsed_request->{path},
        server                => $parsed_request->{server},
        method                => $parsed_request->{method},
        query                 => $parsed_request->{query},
        request_content_type  => $parsed_request->{content_type},
        request_parameters    => $parsed_request->{parameters},
        is_plack_app          => $is_plack_app,

        status                => $expected_code,
        response_body         => $response_body,
        response_content_type => $response_content_type,
    };

    return +{
        status       => $expected_code,
        body         => $response_body,
        content_type => $response_content_type,
    };
}
1;
__END__