CPAN-Testers-API
view release on metacpan or search on metacpan
bin/cpantesters-legacy-metabase view on Meta::CPAN
#pod
#pod =route /beta/register
#pod
#pod Register a new Metabase user. This does not appear to be used by any
#pod CPAN Testers reporter client, but if it is, we can add the user to the
#pod C<metabase_user> table (the
#pod L<CPAN::Testers::Schema::Result::MetabaseUser> result class).
#pod
#pod =cut
sub handle_register( $c ) {
#$c->app->log->debug( $c->req->body );
my @things = ref $c->req->json eq 'ARRAY' ? $c->req->json->@* : ( $c->req->json );
for my $body ( @things ) {
my $fact = Metabase::Fact->class_from_type( $body->{metadata}{core}{type} )
->from_struct( $body );
$c->app->log->debug( sprintf 'Got %s object during registration', ref $fact );
if ( ref $fact->content ne 'ARRAY' ) {
$c->app->log->warn( 'Registration fact object content is not an array. Skipping!' );
$c->app->log->debug( sprintf 'Fact object content %s', Dumper $fact->content );
bin/cpantesters-legacy-metabase view on Meta::CPAN
#pod =route /api/v1/guid/:guid
#pod
#pod =route /beta/guid/:guid
#pod
#pod This is necessary during the registration as a pre-flight check before
#pod submitting the user registration, for some reason...
#pod
#pod =cut
sub handle_guid( $c ) {
my $guid = $c->stash( 'guid' );
my $user = $c->schema->resultset( 'MetabaseUser' )->search( { resource => 'metabase:user:' . $guid } )->single;
if ( !$user ) {
$c->app->log->info( 'Unregistered user ' . $guid );
return $c->render(
status => 404,
json => {
error => $guid . ' not found',
},
);
lib/CPAN/Testers/API.pm view on Meta::CPAN
#pod "errors": [
#pod {
#pod "path": "/since",
#pod "message": "Invalid date/time"
#pod }
#pod ]
#pod }
#pod
#pod =cut
sub render_error( $c, $status, @errors ) {
return $c->render(
status => $status,
openapi => {
errors => [
map { !ref $_ ? { message => $_, path => '/' } : $_ } @errors,
],
},
);
}
lib/CPAN/Testers/API/Controller/Release.pm view on Meta::CPAN
#pod limit (limits the total number of results sent with the C<limit> query parameter)
#pod
#pod =back
#pod
#pod Release data contains a summary of the pass, fail, na, and unknown test
#pod results created by stable Perls. Development Perls (odd-numbered 5.XX
#pod releases) are not included.
#pod
#pod =cut
sub release( $c ) {
$c->openapi->valid_input or return;
my $rs = $c->schema->resultset( 'Release' );
$rs = $rs->search(
{
perlmat => 1, # only stable perls
patched => 1, # not patched perls
},
{
columns => [qw( dist version pass fail na unknown )],
lib/CPAN/Testers/API/Controller/Report.pm view on Meta::CPAN
#pod
#pod ### Response:
#pod 201 Created
#pod { "id": "..." }
#pod
#pod Submit a new CPAN Testers report. This is used by testers when they're
#pod finished running a test.
#pod
#pod =cut
sub report_post( $c ) {
$c->app->log->debug( 'Submitting Report: ' . $c->req->body );
$c->openapi->valid_input or return;
my $report = $c->validation->param( 'report' );
my $row = $c->schema->resultset( 'TestReport' )->create( {
report => $report,
} );
return $c->render(
status => 201,
openapi => {
id => $row->id,
lib/CPAN/Testers/API/Controller/Report.pm view on Meta::CPAN
#pod GET /v3/report/:guid
#pod
#pod ### Response
#pod 200 OK
#pod { "id": "...", ... }
#pod
#pod Get a single CPAN Testers report from the database.
#pod
#pod =cut
sub report_get( $c ) {
$c->openapi->valid_input or return;
my $id = $c->validation->param( 'id' );
my $row = $c->schema->resultset( 'TestReport' )->find( $id );
if ( !$row ) {
return $c->render(
status => 404,
openapi => {
errors => [
{
message => 'Report ID not found',
lib/CPAN/Testers/API/Controller/Summary.pm view on Meta::CPAN
#pod ]
#pod
#pod Get test report summary data for the given distribution and version.
#pod
#pod Report summary data contains a select set of fields from the full test
#pod report. These fields are the most useful ones for building aggregate
#pod reporting and graphs for dashboards.
#pod
#pod =cut
sub summary( $c ) {
$c->openapi->valid_input or return;
my $dist = $c->validation->param( 'dist' );
my $version = $c->validation->param( 'version' );
my $grade = $c->validation->param( 'grade' );
my $perl = $c->validation->every_param( 'perl' );
my $osname = $c->validation->every_param( 'osname' );
if ( !$dist && !$version && ( !$perl || !@$perl ) && ( !$osname || !@$osname ) ) {
return $c->render_error( 400, "You must provide one of 'perl' or 'osname'" );
lib/CPAN/Testers/API/Controller/Summary.pm view on Meta::CPAN
$c->stream_rs( $rs, sub {
my $result = shift;
$result->{grade} = delete $result->{state};
$result->{date} = _format_date( delete $result->{fulldate} );
$result->{reporter} = delete $result->{tester};
return $result;
} );
}
sub _format_date( $fulldate ) {
my ( $y, $m, $d, $h, $n ) = $fulldate =~ /(\d{4})(\d{2})(\d{2})(\d{2})(\d{2})/;
return "$y-$m-${d}T$h:$n:00Z";
}
1;
__END__
=pod
lib/CPAN/Testers/API/Controller/Upload.pm view on Meta::CPAN
#pod "released": "2016-08-12T04:02:34Z",
#pod }
#pod ]
#pod
#pod Get CPAN upload data. Results can be limited by distribution (with the
#pod C<dist> key in the stash), by author (with the C<author> key in the
#pod stash), and by date (with the C<since> query parameter).
#pod
#pod =cut
sub get( $c ) {
$c->openapi->valid_input or return;
my $rs = $c->schema->resultset( 'Upload' );
$rs = $rs->search(
{ },
{
order_by => 'released',
columns => [qw( dist version author filename released )],
}
);
lib/CPAN/Testers/API/Controller/Upload.pm view on Meta::CPAN
);
}
#pod =method feed
#pod
#pod Get a feed for uploads to CPAN. This feed returns the same information as
#pod the regular API, but as they come in.
#pod
#pod =cut
sub feed( $c ) {
$c->inactivity_timeout( 60000 );
my $path = $c->stash( 'dist' ) ? '/upload/dist/' . $c->stash( 'dist' )
: $c->stash( 'author' ) ? '/upload/author/' . $c->stash( 'author' )
: '/upload/dist' # Default to all dists
;
my $ua = Mojo::UserAgent->new( inactivity_timeout => 6000 );
$ua->websocket(
$c->app->config->{broker} . '/sub' . $path,
sub( $ua, $tx ) {
t/controller/release.t view on Meta::CPAN
$t->get_ok( '/v3/release/dist/My-Dist/1.001' )
->status_is( 200 )
->json_is( { $data{Release}[0]->%{ @API_FIELDS } } );
$t->get_ok( '/v3/release/dist/My-Dist/0.001' )
->status_is( 404 )
->json_has( '/errors' )
;
};
};
sub _test_api( $base ) {
subtest 'all releases' => sub {
$t->get_ok( $base . '/release' )
->status_is( 200 )
->json_is( [ map { +{ $_->%{ @API_FIELDS } } } $data{Release}->@[0..8] ] );
subtest 'since (disabled until optimized)' => sub {
$t->get_ok( $base . '/release?since=2016-08-20T00:00:00' )
->status_is( 400 )
->json_has( '/errors' )
->or( sub { diag explain shift->tx->res->json } );
t/controller/report.t view on Meta::CPAN
use FindBin ();
use Mojo::File qw( path );
use Mojo::JSON qw( decode_json );
my $SHARE_DIR = path( $FindBin::Bin, '..', 'share' );
my $HEX = qr{[A-Fa-f0-9]};
my $t = prepare_test_app();
subtest '/v3/report' => \&_test_api, '/v3';
sub _test_api( $base ) {
subtest 'post valid report' => sub {
my $report = decode_json( $SHARE_DIR->child( qw( report perl5 valid.v3.json ) )->slurp );
$t->post_ok( $base . '/report', json => $report )
->status_is( 201 )
->or( sub { diag shift->tx->res->body } )
->json_like( '/id' => qr{${HEX}{8}-${HEX}{4}-${HEX}{4}-${HEX}{4}-${HEX}{12}} )
;
};
subtest 'invalid report: version number starts with v' => sub {
t/controller/summary.t view on Meta::CPAN
my $schema = $t->app->schema;
$schema->populate( $_, $data{ $_ } ) for keys %data;
my $rs = $schema->resultset( 'Stats' );
$rs->result_class( 'DBIx::Class::ResultClass::HashRefInflator' );
is_deeply [ $rs->all ], $data{Stats}, 'sanity check that items were inserted'
or diag explain [ $rs->all ];
};
subtest '/v3/summary/{dist}/{version}' => \&_test_api, '/v3';
sub _test_api( $base ) {
subtest 'by dist' => sub {
$t->get_ok( $base . '/summary/My-Dist' )
->status_is( 200 )
->json_is( '/0/guid' => $data{Stats}[0]{guid} )
->json_is( '/1/guid' => $data{Stats}[1]{guid} )
->json_is( '/2/guid' => $data{Stats}[2]{guid} )
->json_is( '/0/date' => '2016-08-12T04:01:00Z' )
->json_is( '/1/date' => '2016-08-12T00:00:00Z' )
->json_is( '/2/date' => '2016-08-20T00:00:00Z' )
t/controller/upload.t view on Meta::CPAN
};
for \my %upload ( $data{ Upload }->@* ) {
my $dt = DateTime->from_epoch( epoch => $upload{ released } );
$upload{ released } = $dt->datetime . 'Z';
}
subtest '/v1/upload' => \&_test_api, '/v1';
subtest '/v3/upload' => \&_test_api, '/v3';
sub _test_api( $base ) {
subtest 'all uploads' => sub {
$t->get_ok( $base . '/upload' )
->status_is( 200 )
->json_is( [ map { +{ $_->%{ @API_FIELDS } } } $data{Upload}->@[0..2] ] )
->or( sub { diag explain $_[0]->tx->res->json } );
subtest 'since' => sub {
$t->get_ok( $base . '/upload?since=2016-11-19T03:05:00Z' )
->status_is( 200 )
->json_is( [ map { +{ $_->%{ @API_FIELDS } } } $data{Upload}->@[1..2] ] )
t/legacy/metabase.t view on Meta::CPAN
# from => 'doug@example.com (PREACTION)',
# );
#
# Create a new report to submit. Returns a data structure suitable to be
# encoded into JSON and submitted.
#
# This code is stolen from:
# * Test::Reporter::Transport::Metabase sub send
# * Metabase::Client::Simple sub submit_fact
sub create_report( %args ) {
my $creator = delete $args{creator};
my $textreport = delete $args{textreport};
my $report = Test::Reporter->new( transport => 'Null', %args );
# Build CPAN::Testers::Report with its various component facts.
my $metabase_report = CPAN::Testers::Report->open(
resource => 'cpan:///distfile/' . $report->distfile,
creator => $creator,
);
t/lib/Local/App.pm view on Meta::CPAN
=sub prepare_test_app
my $t = prepare_test_app();
Prepare a L<Test::Mojo> object with a L<CPAN::Testers::API> application
hooked up to a local, temporary L<CPAN::Testers::Schema> schema.
=cut
sub prepare_test_app() {
my $schema = prepare_temp_schema();
my $app = CPAN::Testers::API->new(
schema => $schema,
);
return Test::Mojo->new( $app );
}
1;
( run in 0.367 second using v1.01-cache-2.11-cpan-65fba6d93b7 )