File Coverage

blib/lib/Test/Mojo/Role/OpenAPI/Modern.pm

Criterion	Covered	Total	%
statement	120	136	88.2
branch	17	26	65.3
condition	15	29	51.7
subroutine	26	30	86.6
pod	11	11	100.0
total	189	232	81.4

use strict;
use warnings;
package Test::Mojo::Role::OpenAPI::Modern; # git description: v0.010-3-ge7925fd
# vim: set ts=8 sts=2 sw=2 tw=100 et :
# ABSTRACT: Test::Mojo role providing access to an OpenAPI document and parser
# KEYWORDS: validation evaluation JSON Schema OpenAPI Swagger HTTP request response

our $VERSION = '0.011';

use 5.020;  # for fc, unicode_strings features
use strictures 2;
use utf8;
use if "$]" >= 5.022, experimental => 're_strict';
no if "$]" >= 5.031009, feature => 'indirect';
no if "$]" >= 5.033001, feature => 'multidimensional';
no if "$]" >= 5.033006, feature => 'bareword_filehandles';
no if "$]" >= 5.041009, feature => 'smartmatch';
no feature 'switch';
use JSON::Schema::Modern 0.577;
use OpenAPI::Modern 0.054;
use List::Util 'any';
use namespace::clean;

use Mojo::Base -role, -signatures;

has openapi => sub ($self) {
  # use the plugin's object, if the plugin is being used
  # FIXME: we should be calling $self->app->$_call_if_can, but can() isn't behaving
  my $openapi = eval { $self->app->openapi };
  return $openapi if $openapi;

  # otherwise try to construct our own using provided configs
  if (my $config = $self->app->config->{openapi}) {
    return $config->{openapi_obj} if $config->{openapi_obj};

    if (my $args = eval {
        +require Mojolicious::Plugin::OpenAPI::Modern;
        Mojolicious::Plugin::OpenAPI::Modern->VERSION('0.007');
        Mojolicious::Plugin::OpenAPI::Modern::_process_configs($config);
      }) {
      return OpenAPI::Modern->new($args);
    }
  }

  die 'openapi object or configs required';
};

has test_openapi_verbose => 0;

# keys being tracked here:
# - request_result
# - response_result
# - validation_options
sub _openapi_stash ($self, @data) { Mojo::Util::_stash(_openapi_stash => $self, @data) }

after _request_ok => sub ($self, @args) {
  $self->{_openapi_stash} = {};
};

sub request_valid ($self, $desc = 'request is valid') {
  $self->test('ok', $self->request_validation_result->valid, $desc);
  $self->dump_request_validation_result if not $self->success and $self->test_openapi_verbose;
  return $self;
}

sub response_valid ($self, $desc = 'response is valid') {
  $self->test('ok', $self->response_validation_result->valid, $desc);
  $self->dump_response_validation_result if not $self->success and $self->test_openapi_verbose;
  return $self;
}

# expected_error can either be the 'recommended_response' or any error string in the result.
sub request_not_valid ($self, $expected_error = undef, $desc = undef) {
  my $result = $self->request_validation_result;
  if ($expected_error and not $result->valid) {
    $desc //= 'request validation error matches';
    if ($expected_error eq $result->recommended_response->[1]) {
      $self->test('pass', $desc);
    }
    else {
      $self->test('ok', (any { $expected_error eq $_ } $result->errors), $desc);
    }
  }
  else {
    $self->test('ok', !$self->request_validation_result->valid, $desc // 'request is not valid');
  }

  $self->dump_request_validation_result if not $self->success and $self->test_openapi_verbose;
  return $self;
}

# expected_error must match an error string in the result.
sub response_not_valid ($self, $expected_error = undef, $desc = undef) {
  my $result = $self->response_validation_result;
  if ($expected_error and not $result->valid) {
    $self->test('ok', (any { $expected_error eq $_ } $result->errors),
      $desc // 'response validation error matches');
  }
  else {
    $self->test('ok', !$self->response_validation_result->valid, $desc // 'response is not valid');
  }

  $self->dump_response_validation_result if not $self->success and $self->test_openapi_verbose;
  return $self;
}

# I'm not sure yet which names are best, why not go for both?
sub request_invalid { goto \&request_not_valid }
sub response_invalid { goto \&response_not_valid }

sub request_validation_result ($self) {
  my $result = $self->_openapi_stash('request_result');
  return $result if defined $result;

  $result = $self->openapi->validate_request($self->tx->req, my $options = {});
  $self->_openapi_stash(request_result => $result, validation_options => $options);
  return $result;
}

sub response_validation_result ($self) {
  my $result = $self->_openapi_stash('response_result');
  return $result if defined $result;

  my $options = $self->_openapi_stash('validation_options');
  $self->_openapi_stash(validation_options => $options = {}) if not $options;
  $options->{request} = $self->tx->req;

  $result = $self->openapi->validate_response($self->tx->res, $options);
  $self->_openapi_stash(response_result => $result);
  return $result;
}

sub operation_id_is ($self, $operation_id, $desc = undef) {
  my $validation_options = $self->_openapi_stash('validation_options');
  return $self->test('fail', 'operation_id was captured during the last validation')
    if not $validation_options->{operation_id};

  $self->test('is', $validation_options->{operation_id}, $operation_id, $desc // 'operation_id is '.$operation_id);
}

my $encoder = JSON::Schema::Modern::_JSON_BACKEND()->new
  ->allow_nonref(1)
  ->utf8(0)
  ->canonical(1)
  ->pretty(1)
  ->indent_length(2);

sub dump_request_validation_result ($self, $style = 'data_only') {
  my $result = $self->request_validation_result;
  my $method = $ENV{AUTOMATED_TESTING} ? 'diag' : 'note';
  $self->handler->($method, "got request validation result:\n".$encoder->encode($result->format($style)));
}

sub dump_response_validation_result ($self, $style = 'data_only') {
  my $result = $self->response_validation_result;
  my $method = $ENV{AUTOMATED_TESTING} ? 'diag' : 'note';
  $self->handler->($method, "got response validation result:\n".$encoder->encode($result->format($style)));
}

1;

__END__