view release on metacpan or  search on metacpan

t/01_unit.t  view on Meta::CPAN

#!/usr/local/bin/perl

use strict;
use warnings;
use Test::More;
use Data::Dumper;
use FindBin qw($Bin);
use lib "$Bin/../lib", "$Bin/../local/lib/perl5";
use JSON::MaybeXS;
use WWW::Mechanize;
use URI::http;
use HTTP::Request;
use Artifactory::Client;
use Path::Tiny;

# it became silly to do this in every subtest
no strict 'refs';
no warnings 'redefine';

my $artifactory = 'http://example.com';
my $port        = 7777;
my $repository  = 'repository';

my %mock_responses = (
    http_404 => bless( { '_rc' => 404, '_headers' => bless( {}, 'HTTP::Headers' ) }, 'HTTP::Response' ),
    http_200 => bless( { '_rc' => 200,   '_content' => '{ "foo" : "bar" }' }, 'HTTP::Response' ),
    http_201 => bless( { '_rc' => 201 }, 'HTTP::Response' ),
    http_202 => bless( { '_rc' => 202 }, 'HTTP::Response' ),
    http_204 => bless( { '_rc' => 204 }, 'HTTP::Response' ),
);

subtest 'check if ua is LWP::UserAgent', sub {
    my $client = setup();
    isa_ok( $client->ua, 'LWP::UserAgent' );

    my $ua = WWW::Mechanize->new();
    $client->ua($ua);
    isa_ok( $client->ua, 'WWW::Mechanize' );
};

subtest 'deploy_artifact with properties and content', sub {
    my $client     = setup();
    my $properties = {
        one => ['two'],
        baz => [ 'three', 'four' ],
    };
    my $path    = '/unique_path';
    my $content = "content of artifact";

    local *{'LWP::UserAgent::request'} = sub {
        return $mock_responses{http_201};
    };

    my $resp = $client->deploy_artifact( path => $path, properties => $properties, file => "$Bin/data/test.json" );
    is( $resp->is_success, 1, 'request came back successfully' );

    local *{'LWP::UserAgent::get'} = sub {
        my ( $self, $url ) = @_;

        if ( $url eq "$artifactory:$port/artifactory/api/storage/$repository/unique_path?properties" ) {
            return bless(
                {
                    '_content' => '{
                    "properties" : {
                        "baz" : [ "three", "four" ],
                        "one" : [ "two" ]
                    }
                }',
                    '_rc'      => 200,
                    '_headers' => bless( {}, 'HTTP::Headers' ),
                },
                'HTTP::Response'
            );
        }
        else {
            return bless(
                {
                    '_content' => 'content of artifact',
                    '_rc'      => 200,
                    '_headers' => bless( {}, 'HTTP::Headers' ),
                },
                'HTTP::Response'
            );
        }
    };

    my $resp2 = $client->item_properties( path => $path );
    my $scalar = decode_json( $resp2->decoded_content );
    is_deeply( $scalar->{properties}, $properties, 'properties are correct' );
    my $artifact_url = "$artifactory:$port/$repository$path";
    my $resp3        = $client->get($artifact_url);
    is( $resp3->decoded_content, $content, 'content matches' );
};

subtest 'set_item_properties on non-existing artifact', sub {
    my $client     = setup();
    my $properties = {
        one => [1],
        two => [2],
    };

    local *{'LWP::UserAgent::put'} = sub {
        return $mock_responses{http_404};
    };
    my $resp = $client->set_item_properties( path => '/unique_path', properties => $properties );
    is( $resp->code, 404, 'got 404 for attempting to set props on non-existent artifact' );
};

subtest 'deploy artifact by checksum', sub {
    my $client = setup();
    my $path   = '/unique_path';
    my $sha1   = 'da39a3ee5e6b4b0d3255bfef95601890afd80709';    # sha-1 of 0 byte file

    local *{'LWP::UserAgent::request'} = sub {
        return bless(
            {
                '_request' => bless(
                    {
                        '_headers' => bless(
                            {
                                'x-checksum-sha1'   => $sha1,
                                'x-checksum-deploy' => 'true',
                            },
                            'HTTP::Headers'
                        ),
                    },
                    'HTTP::Request'
                )
            },
            'HTTP::Response'
        );
    };

    my $resp = $client->deploy_artifact_by_checksum( path => $path, sha1 => $sha1 );
    is( $resp->request()->header('x-checksum-deploy'), 'true', 'x-checksum-deploy set' );
    is( $resp->request()->header('x-checksum-sha1'),   $sha1,  'x-checksum-sha1 set' );

    local *{'LWP::UserAgent::request'} = sub {
        return $mock_responses{http_404};
    };

    my $resp2 = $client->deploy_artifact_by_checksum( path => $path );    # no sha-1 on purpose
    is( $resp2->code, 404, 'got 404 since no sha1 was supplied' );
};

subtest 'item properties', sub {
    my $client     = setup();
    my $properties = {
        this => [ 'here', 'there' ],
        that => ['one'],
    };

    local *{'LWP::UserAgent::get'} = sub {
        return bless(
            {
                '_content' => '{
                "properties" : {
                    "that" : [ "one" ]
                }
            }',
                '_headers' => bless( {}, 'HTTP::Headers' ),
            },
            'HTTP::Response'
        );
    };

    my $resp = $client->item_properties( path => '/unique_path', properties => ['that'] );
    my $scalar = decode_json( $resp->decoded_content );
    is_deeply( $scalar->{properties}, { that => ['one'] }, 'property content is correct' );
};

subtest 'retrieve artifact', sub {
    my $client  = setup();
    my $content = "content of artifact";

    local *{'LWP::UserAgent::get'} = sub {
        return bless(
            {
                '_content' => 'content of artifact',
                '_headers' => bless( {}, 'HTTP::Headers' ),
            },
            'HTTP::Response'
        );
    };

    my $resp = $client->retrieve_artifact('/unique_path');
    is( $resp->decoded_content, $content, 'artifact retrieved successfully' );
};

subtest 'all_builds', sub {
    my $client = setup();

    local *{'LWP::UserAgent::get'} = sub {
        return $mock_responses{http_200};
    };
    my $resp = $client->all_builds();
    is( $resp->is_success, 1, 'fetched all builds' );
};

subtest 'delete_item', sub {
    my $client = setup();

    local *{'LWP::UserAgent::delete'} = sub {