API-Client
view release on metacpan or search on metacpan
details on enabling it in your environment.## Installing with the CPAN shellAlternatively,ifyour CPAN shell is set up, you should just be able todo:% cpan API::Client## Manual installationAs alastresort, you can manually install it. Download the tarball, untar it,install configure prerequisites (see below), then build it:% perl Makefile.PL% make && make testThen install it:% make installOn Windows platforms, you shoulduse`dmake` or `nmake`, instead of `make`.
If your perl issystem-managed, you can create alocal::lib in your homedirectory to install modules to. For details, see thelocal::lib documentation:The prerequisites of this distribution will also have to be installed manually. Theprerequisites are listed in one of the files: `MYMETA.yml` or `MYMETA.json` generatedby running the manual build process described above.## Configure PrerequisitesThis distribution requires other modules to be installedbeforethisdistribution's installer can be run. They can be found under the"configure_requires"key of META.yml or the"{prereqs}{configure}{requires}"key of META.json.## Other PrerequisitesMakefile.PL.Lookforprerequisites in the following phases:* to run make, PHASE = build* to run tests, PHASE = testThey can all be found in the"PHASE_requires"key of MYMETA.yml or the"{prereqs}{PHASE}{requires}"key of MYMETA.json.## DocumentationAPI-Client documentation is available as POD.You can run `perldoc` from a shell toreadthe documentation:% perldoc API::ClientFor more information on installing Perl modules via CPAN, please see:
software and to any other program whose authors commit to using it.When we speak of free software, we are referring to freedom, notprice. Specifically, the General Public License is designed to makesure that you have the freedom to give away or sell copies of freesoftware, that you receive source code or can get itifyou want it,programs; and that you know you candothese things.To protect your rights, we need to make restrictions that forbidanyone to deny you these rights or to ask you to surrender the rights.These restrictions translate to certain responsibilitiesforyouifyoudistribute copies of the software, orifyou modify it.For example,ifyou distribute copies of a such a program, whethergratis orfora fee, you must give the recipients all the rights thatyou have. You must make sure that they, too, receive or can get thesource code. And you musttellthem their rights.We protect your rightswithtwo steps: (1) copyright the software, and(2) offer you this license which gives you legal permission to copy,distribute and/or modify the software.
GNU GENERAL PUBLIC LICENSETERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION0. This License Agreement applies to any program or other work whichcontains a notice placed by the copyright holder saying it may bedistributed under the terms of this General Public License. The"Program", below, refers to any such program or work, and a "work basedon the Program" means either the Program or any work containing theProgram or a portion of it, either verbatim orwithmodifications. Eachlicensee is addressed as"you".1. You may copy and distribute verbatim copies of the Program's sourcecode as you receive it, in any medium, provided that you conspicuously andappropriately publish oneachcopy an appropriate copyright notice anddisclaimer of warranty; keep intact all the notices that refer to thisGeneral Public License and to the absence of any warranty; and give anyother recipients of the Program a copy of this General Public Licensealongwiththe Program. You may charge a feeforthe physical act oftransferring a copy.
exchangefora fee.Mere aggregation of another independent workwiththe Program (or itsderivative) on a volume of a storage or distribution medium does not bringthe other work under the scope of these terms.3. You may copy and distribute the Program (or a portion or derivative ofit, under Paragraph 2) in object code or executable form under the terms ofParagraphs 1 and 2 above provided that you alsodoone of the following:a) accompany itwiththe complete corresponding machine-readablesource code, which must be distributed under the terms ofParagraphs 1 and 2 above; or,b) accompany itwitha written offer, validforat least threeyears, to give any third party free (exceptfora nominal chargeforthe cost of distribution) a complete machine-readable copy of thecorresponding source code, to be distributed under the terms ofParagraphs 1 and 2 above; or,c) accompany itwiththe information you received as to where thecorresponding source code may be obtained. (This alternative isallowed onlyfornoncommercial distribution and onlyifyoureceived the program in object code or executable form alone.)Source codefora work means the preferred form of the workformakingmodifications to it. For an executable file, complete source code meansall the source codeforall modules it contains; but, as a specialexception, it need not include source codeformodules which are standardlibraries that accompany the operatingsystemon which the executablefile runs, orforstandard header files or definitions files thataccompany that operatingsystem.4. You may not copy, modify, sublicense, distribute or transfer theProgram except as expressly provided under this General Public License.Any attempt otherwise to copy, modify, sublicense, distribute or transferthe Program is void, and will automatically terminate your rights tousethe Program under this License. However, parties who have receivedLicense will not have their licenses terminated so long as such partiesremain in full compliance.5. By copying, distributing or modifying the Program (or any work basedon the Program) you indicate your acceptance of this license todoso,and all its terms and conditions.6. Eachtimeyou redistribute the Program (or any work based on theProgram), the recipient automatically receives a license from the originallicensor to copy, distribute or modify the Program subject to theseterms and conditions. You may not impose any further restrictions on therecipients' exercise of the rights granted herein.7. The Free Software Foundation may publish revised and/or new versionsof the General Public License fromtimetotime. Such new versions willbe similar in spirit to the present version, but may differ in detail toaddress new problems or concerns.Each version isgivena distinguishing version number. If the Programspecifies a version number of the license which applies to it and "anylater version", you have the option of following the terms and conditionseither of that version or of any later version published by the FreeSoftware Foundation. If the Program does not specify a version number ofthe license, you may choose any version ever published by the Free SoftwareFoundation.8. If you wish to incorporate parts of the Program into other freeprograms whose distribution conditions are different,writeto the authorto askforpermission. For software which is copyrighted by the FreeSoftware Foundation,writeto the Free Software Foundation; we sometimesmake exceptionsforthis. Our decision will be guided by the two goalsof preserving the free status of all derivatives ofourfree software andof promoting the sharing and reuse of software generally.NO WARRANTY9. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTYFOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHENOTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIESPROVIDE THE PROGRAM"AS IS"WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSEDOR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OFMERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS
The hypothetical commands `show w' and `show c'should show theappropriate parts of the General Public License. Of course, thec'; they could even be mouse-clicks or menu items--whatever suits yourprogram.You should also get your employer (ifyou work as a programmer) or yourschool,ifany, to sign a"copyright disclaimer"forthe program,ifnecessary. Here a sample; alter the names:Yoyodyne, Inc., hereby disclaims all copyright interest in theprogram `Gnomovision' (a program to direct compilers to make passesat assemblers) written by James Hacker.<signature of Ty Coon>, 1 April 1989Ty Coon, President of ViceThat's all there is to it!--- The Artistic License 1.0 ---This software is Copyright (c) 2019 by Al Newkirk.This is free software, licensed under:
-"Reasonable copying fee"is whatever you can justify on the basis of mediacost, duplication charges,timeof people involved, and so on. (You willnot be required to justify it to the Copyright Holder, but only to thecomputing community at large as a market that must bear the fee.)-"Freely Available"means thatnofee is chargedforthe item itself, thoughthere may be fees involved in handling the item. It also means thatrecipients of the item may redistribute it under the same conditions theyreceived it.1. You may make and give away verbatim copies of the source form of theStandard Version of this Package without restriction, provided that youduplicate all of the original copyright notices and associated disclaimers.2. You may apply bug fixes, portability fixes and other modifications derivedfrom the Public Domain or from the Copyright Holder. A Package modified in sucha way shall still be considered the Standard Version.3. You may otherwise modify your copy of this Package in any way, provided thatyou insert a prominent notice ineachchanged file stating how andwhenyouchanged that file, and provided that youdoat least ONE of the following:
4. You may distribute the programs of this Package in object code or executableform, provided that youdoat least ONE of the following:a) distribute a Standard Version of the executables and library files,togetherwithinstructions (in the manual page or equivalent) on where toget the Standard Version.b) accompany the distributionwiththe machine-readable source of the Packagewithyour modifications.c) accompany any non-standard executableswiththeir corresponding StandardVersion executables, giving the non-standard executables non-standardnames, and clearly documenting the differences in manual pages (orequivalent), togetherwithinstructions on where to get the StandardVersion.d) make other distribution arrangementswiththe Copyright Holder.5. You may charge a reasonable copying feeforany distribution of thisPackage. You may charge any fee you chooseforsupport of this Package. Youmay not charge a feeforthis Package itself. However, you may distribute this
"license": ["perl_5"],"meta-spec": {"version": 2},"name":"API-Client","prereqs": {"configure": {"requires": {"ExtUtils::MakeMaker":"0"}},"runtime": {"requires": {"Data::Object::Class":"2.02","Data::Object::ClassHas":"2.01","Data::Object::Role::Buildable":"0.03","Data::Object::Role::Stashable":"2.01","Data::Object::Role::Throwable":"2.01","FlightRecorder":"0.03","Mojolicious":"8.35","perl":"5.014","routines":"0","strict":"0","warnings":"0"}},"test": {"requires": {"Data::Object::Class":"2.02","Data::Object::ClassHas":"2.01","Data::Object::Role::Buildable":"0.03","Data::Object::Role::Stashable":"2.01","Data::Object::Role::Throwable":"2.01","FlightRecorder":"0.03","Mojolicious":"8.35","Test::Auto":"0.10","perl":"5.014","routines":"0","strict":"0","warnings":"0"}}},"release_status":"stable","resources": {"repository": {"type":"git",}},"version":"0.12","x_authority":"cpan:AWNCORP","x_contributors": ["Al Newkirk <anewkirk@ana.io>"],"x_generated_by_perl":"v5.26.1","x_serialization_backend":"Cpanel::JSON::XS version 4.19","x_spdx_expression":"Artistic-1.0-Perl OR GPL-1.0-or-later"}
---abstract:'HTTP API Thin-Client Abstraction'author:-'Al Newkirk <awncorp@cpan.org>'build_requires:Data::Object::Class:'2.02'Data::Object::ClassHas:'2.01'Data::Object::Role::Buildable:'0.03'Data::Object::Role::Stashable:'2.01'Data::Object::Role::Throwable:'2.01'FlightRecorder:'0.03'Mojolicious:'8.35'Test::Auto:'0.10'perl:'5.014'routines:'0'strict:'0'warnings:'0'configure_requires:ExtUtils::MakeMaker:'0'dynamic_config: 0generated_by:'Dist::Zilla version 6.014, CPAN::Meta::Converter version 2.150010'license: perlmeta-spec:version:'1.4'name: API-Clientrequires:Data::Object::Class:'2.02'Data::Object::ClassHas:'2.01'Data::Object::Role::Buildable:'0.03'Data::Object::Role::Stashable:'2.01'Data::Object::Role::Throwable:'2.01'FlightRecorder:'0.03'Mojolicious:'8.35'perl:'5.014'routines:'0'strict:'0'warnings:'0'resources:repository: git://github.com/iamalnewkirk/API-Client.gitversion:'0.12'x_authority: cpan:AWNCORPx_contributors:-'Al Newkirk <anewkirk@ana.io>'x_generated_by_perl: v5.26.1x_serialization_backend:'YAML::Tiny version 1.73'x_spdx_expression:'Artistic-1.0-Perl OR GPL-1.0-or-later'
HTTP API Thin-Client AbstractionSYNOPSIS# $client->resource('post');# $client->update(json => {...});DESCRIPTIONHTTP API clients. While this module can be used to interactwithAPIsdirectly, API::Client was designed to be consumed (subclassed) byhigher-level purpose-specific API clients.THIN CLIENTThe thin API client library is advantageous as ithascomplete APIcoverage and can easily adapt to changes in the APIwithminimaleffort. As a thin-client superclass, this module does notmapspecificHTTP requests to specific routines, nor does it provide parametervalidation, pagination, or other conventions found in typical APIclient implementations; Instead, it simply provides a simple andconsistent mechanismfordynamically generating HTTP requests.Additionally, this modulehassupportfordebugging and retrying APIcalls as well as throwing exceptionswhen4xx and 5xx server responsecodes are returned.INTEGRATESData::Object::Role::BuildableData::Object::Role::Stashable
Types::StandardSCENARIOSbuilding# given: synopsismy$resource=$client->resource('get');# GET /getmy$get=$client->resource('get')->dispatch;# HEAD /headmy$head=$client->resource('head')->dispatch(method=>'head');# PATCH /patchmy$patch=$client->resource('patch')->dispatch(method=>'patch');[$get,$head,$patch]Building up an HTTP request is extremely easy, simply call the"resource"to create a new object instance representing the APIendpoint you wish to issue a request against.chaining# given: synopsismy$users=$client->resource('users');my$user=$client->resource('users','c09e91a');my$new_user=$users->resource('c09e91a');[$users,$user,$new_user]Becauseeachcall to"resource"returns a new object instanceconfiguredwitha path (resource locator) based on the suppliedparameters, reuse and request isolation are made simple, i.e., you willonly need to configure the client once in your application.creating# given: synopsismy$tx1=$client->resource('post')->create(json=> {active=> 1});# is equivalent tomy$tx2=$client->resource('post')->dispatch(method=>'post',json=> {active=> 1});[$tx1,$tx2]This example illustrates how you might create a new API resource.deleting# given: synopsismy$tx1=$client->resource('delete')->delete(json=> {active=> 1});# is equivalent tomy$tx2=$client->resource('delete')->dispatch(method=>'delete',json=> {active=> 1});[$tx1,$tx2]This example illustrates how you mightdeletea new API resource.fetching# given: synopsismy$tx1=$client->resource('get')->fetch(query=> {active=> 1});# is equivalent tomy$tx2=$client->resource('get')->dispatch(method=>'get',query=> {active=> 1});[$tx1,$tx2]This example illustrates how you might fetch an API resource.subclassingsubauth {
subbase {}my$hookbin= Hookbin->new;client building and request dispatching processes. Specifically, thereare three useful hooks (i.e. methods, whichifpresent are used tobuild up the client object and requests), which are, the auth hook,which shouldreturna Tuple[Str, Str] which is used to configure thebasic auth header, the base hook which shouldreturna Tuple[Str] whichis used to configure the base URL, and the headers hook, which shouldreturna ArrayRef[Tuple[Str, Str]] which are used to configure the HTTPrequest headers.transacting# given: synopsismy$tx1=$client->resource('patch')->patch(json=> {active=> 1});# is equivalent tomy$tx2=$client->resource('patch')->dispatch(method=>'patch',json=> {active=> 1});[$tx1,$tx2]An HTTP request is only issuedwhenthe"dispatch"method is called,directly or indirectly. Those callsreturna Mojo::Transaction objectwhich provides access to the request and response objects.updating# given: synopsismy$tx1=$client->resource('put')->update(json=> {active=> 1});# is equivalent tomy$tx2=$client->resource('put')->dispatch(method=>'put',json=> {active=> 1});[$tx1,$tx2]This example illustrates how you might update a new API resource.ATTRIBUTESThispackagehasthe following attributes:debugdebug(Bool)This attribute isread-only, accepts (Bool)values, and is optional.
This attribute isread-only, accepts (Str)values, and is optional.METHODScreatecreate(Any%args) : InstanceOf["Mojo::Transaction"]The create method issues a POST request to the API resource representedby the object.create example#1# given: synopsis$client->resource('post')->create(json=> {active=> 1});deletedelete(Any%args) : InstanceOf["Mojo::Transaction"]Thedeletemethod issues a DELETE request to the API resourcerepresented by the object.deleteexample#1# given: synopsis$client->resource('delete')->delete;dispatchdispatch(Str :$method='get', Any%args) : InstanceOf["Mojo::Transaction"]The dispatch method issues a request to the API resource represented bythe object.dispatch example#1# given: synopsis$client->resource('get')->dispatch;dispatch example#2# given: synopsis$client->resource('post')->dispatch(method=>'post',body=>'active=1');dispatch example#3# given: synopsis$client->resource('get')->dispatch(method=>'get',query=> {active=> 1});dispatch example#4# given: synopsis$client->resource('post')->dispatch(method=>'post',json=> {active=> 1});dispatch example#5# given: synopsis$client->resource('post')->dispatch(method=>'post',form=> {active=> 1});dispatch example#6# given: synopsis$client->resource('put')->dispatch(method=>'put',json=> {active=> 1});dispatch example#7# given: synopsis$client->resource('patch')->dispatch(method=>'patch',json=> {active=> 1});dispatch example#8# given: synopsis$client->resource('delete')->dispatch(method=>'delete',json=> {active=> 1});fetchfetch(Any%args) : InstanceOf["Mojo::Transaction"]The fetch method issues a GET request to the API resource representedby the object.fetch example#1# given: synopsis$client->resource('get')->fetch;patchpatch(Any%args) : InstanceOf["Mojo::Transaction"]The patch method issues a PATCH request to the API resource representedby the object.patch example#1# given: synopsis$client->resource('patch')->patch(json=> {active=> 1});prepareprepare(Object$ua, Object$tx, Any%args) : ObjectThe prepare method acts as abeforehook triggeredbeforeeachrequestwhere you can modify the transactor objects.
$client->prepare(Mojo::UserAgent->new,Mojo::Transaction::HTTP->new);processprocess(Object$ua, Object$tx, Any%args) : ObjectThe process method acts as anafterhook triggeredaftereachresponsewhere you can modify the transactor objects.process example#1# given: synopsis$client->process(Mojo::UserAgent->new,Mojo::Transaction::HTTP->new);resourceresource(Str@segments) : ObjectThe resource method returns a new instance of the objectforthe APIresource endpoint specified.resource example#1# given: synopsis$client->resource('status', 200);serializeserialize() : HashRefThe serialize method serializes and returns the object as a hashref.serialize example#1# given: synopsis$client->serialize;updateupdate(Any%args) : InstanceOf["Mojo::Transaction"]The update method issues a PUT request to the API resource representedby the object.update example#1# given: synopsis$client->resource('put')->update(json=> {active=> 1});AUTHORAl Newkirk, awncorp@cpan.orgLICENSECopyright (C) 2011-2019, Al Newkirk, et al.
HTTP API Thin-Client Abstraction# SYNOPSIS# $client->resource('post');# $client->update(json => {...});# DESCRIPTIONclients. While this module can be used to interactwithAPIs directly,API::Client was designed to be consumed (subclassed) by higher-levelpurpose-specific API clients.# THIN CLIENTThe thin API client library is advantageous as ithascomplete API coverage andcan easily adapt to changes in the APIwithminimal effort. As a thin-clientsuperclass, this module does notmapspecific HTTP requests to specificroutines, nor does it provide parameter validation, pagination, or otherconventions found in typical API client implementations; Instead, it simplyprovides a simple and consistent mechanismfordynamically generating HTTPrequests. Additionally, this modulehassupportfordebugging and retrying APIcalls as well as throwing exceptionswhen4xx and 5xx server response codes arereturned.# INTEGRATES[Data::Object::Role::Buildable](https://metacpan.org/pod/Data::Object::Role::Buildable)[Data::Object::Role::Stashable](https://metacpan.org/pod/Data::Object::Role::Stashable)
[Types::Standard](https://metacpan.org/pod/Types::Standard)# SCENARIOS## building# given: synopsismy$resource=$client->resource('get');# GET /getmy$get=$client->resource('get')->dispatch;# HEAD /headmy$head=$client->resource('head')->dispatch(method=>'head');# PATCH /patchmy$patch=$client->resource('patch')->dispatch(method=>'patch');[$get,$head,$patch]Building up an HTTP request is extremely easy, simply call the ["resource"](#resource) tocreate a new object instance representing the API endpoint you wish to issue arequest against.## chaining# given: synopsismy$users=$client->resource('users');my$user=$client->resource('users','c09e91a');my$new_user=$users->resource('c09e91a');[$users,$user,$new_user]Becauseeachcall to ["resource"](#resource) returns a new object instance configured witha path (resource locator) based on the supplied parameters, reuse and requestisolation are made simple, i.e., you will only need to configure the clientonce in your application.## creating# given: synopsismy$tx1=$client->resource('post')->create(json=> {active=> 1});# is equivalent tomy$tx2=$client->resource('post')->dispatch(method=>'post',json=> {active=> 1});[$tx1,$tx2]This example illustrates how you might create a new API resource.## deleting# given: synopsismy$tx1=$client->resource('delete')->delete(json=> {active=> 1});# is equivalent tomy$tx2=$client->resource('delete')->dispatch(method=>'delete',json=> {active=> 1});[$tx1,$tx2]This example illustrates how you mightdeletea new API resource.## fetching# given: synopsismy$tx1=$client->resource('get')->fetch(query=> {active=> 1});# is equivalent tomy$tx2=$client->resource('get')->dispatch(method=>'get',query=> {active=> 1});[$tx1,$tx2]This example illustrates how you might fetch an API resource.## subclassingsubauth {
subbase {}my$hookbin= Hookbin->new;building and request dispatching processes. Specifically, there are threeuseful hooks (i.e. methods, whichifpresent are used to build up the clientobject and requests), which are, the `auth` hook, which shouldreturna`Tuple[Str, Str]` which is used to configure the basic auth header, the`base` hook which shouldreturna `Tuple[Str]` which is used to configure thebase URL, and the `headers` hook, which shouldreturna`ArrayRef[Tuple[Str, Str]]` which are used to configure the HTTP requestheaders.## transacting# given: synopsismy$tx1=$client->resource('patch')->patch(json=> {active=> 1});# is equivalent tomy$tx2=$client->resource('patch')->dispatch(method=>'patch',json=> {active=> 1});[$tx1,$tx2]An HTTP request is only issuedwhenthe ["dispatch"](#dispatch) method is called, directlyor indirectly. Those callsreturna [Mojo::Transaction](https://metacpan.org/pod/Mojo::Transaction) object which providesaccess to the `request` and `response` objects.## updating# given: synopsismy$tx1=$client->resource('put')->update(json=> {active=> 1});# is equivalent tomy$tx2=$client->resource('put')->dispatch(method=>'put',json=> {active=> 1});[$tx1,$tx2]This example illustrates how you might update a new API resource.# ATTRIBUTESThispackagehasthe following attributes:## debugdebug(Bool)This attribute isread-only, accepts `(Bool)`values, and is optional.
This attribute isread-only, accepts `(Str)`values, and is optional.# METHODS## createcreate(Any%args) : InstanceOf["Mojo::Transaction"]The create method issues a `POST` request to the API resource represented bythe object.- create example#1# given: synopsis$client->resource('post')->create(json=> {active=> 1});## deletedelete(Any%args) : InstanceOf["Mojo::Transaction"]Thedeletemethod issues a `DELETE` request to the API resource represented bythe object.-deleteexample#1# given: synopsis$client->resource('delete')->delete;## dispatchdispatch(Str :$method='get', Any%args) : InstanceOf["Mojo::Transaction"]The dispatch method issues a request to the API resource represented by theobject.- dispatch example#1# given: synopsis$client->resource('get')->dispatch;- dispatch example#2# given: synopsis$client->resource('post')->dispatch(method=>'post',body=>'active=1');- dispatch example#3# given: synopsis$client->resource('get')->dispatch(method=>'get',query=> {active=> 1});- dispatch example#4# given: synopsis$client->resource('post')->dispatch(method=>'post',json=> {active=> 1});- dispatch example#5# given: synopsis$client->resource('post')->dispatch(method=>'post',form=> {active=> 1});- dispatch example#6# given: synopsis$client->resource('put')->dispatch(method=>'put',json=> {active=> 1});- dispatch example#7# given: synopsis$client->resource('patch')->dispatch(method=>'patch',json=> {active=> 1});- dispatch example#8# given: synopsis$client->resource('delete')->dispatch(method=>'delete',json=> {active=> 1});## fetchfetch(Any%args) : InstanceOf["Mojo::Transaction"]The fetch method issues a `GET` request to the API resource represented by theobject.- fetch example#1# given: synopsis$client->resource('get')->fetch;## patchpatch(Any%args) : InstanceOf["Mojo::Transaction"]The patch method issues a `PATCH` request to the API resource represented bythe object.- patch example#1# given: synopsis$client->resource('patch')->patch(json=> {active=> 1});## prepareprepare(Object$ua, Object$tx, Any%args) : ObjectThe prepare method acts as a `before` hook triggeredbeforeeachrequest whereyou can modify the transactor objects.
$client->prepare(Mojo::UserAgent->new,Mojo::Transaction::HTTP->new);## processprocess(Object$ua, Object$tx, Any%args) : ObjectThe process method acts as an `after` hook triggeredaftereachresponse whereyou can modify the transactor objects.- process example#1# given: synopsis$client->process(Mojo::UserAgent->new,Mojo::Transaction::HTTP->new);## resourceresource(Str@segments) : ObjectThe resource method returns a new instance of the objectforthe API resourceendpoint specified.- resource example#1# given: synopsis$client->resource('status', 200);## serializeserialize() : HashRefThe serialize method serializes and returns the object as a `hashref`.- serialize example#1# given: synopsis$client->serialize;## updateupdate(Any%args) : InstanceOf["Mojo::Transaction"]The update method issues a `PUT` request to the API resource represented bythe object.- update example#1# given: synopsis$client->resource('put')->update(json=> {active=> 1});# AUTHORAl Newkirk, `awncorp@cpan.org`# LICENSECopyright (C) 2011-2019, Al Newkirk, et al.
# This file is generated by Dist::Zilla::Plugin::CPANFile v6.014# Do not edit this file directly. To change prereqs, edit the `dist.ini` file.requires"Data::Object::Class"=>"2.02";requires"Data::Object::ClassHas"=>"2.01";requires"Data::Object::Role::Buildable"=>"0.03";requires"Data::Object::Role::Stashable"=>"2.01";requires"Data::Object::Role::Throwable"=>"2.01";requires"FlightRecorder"=>"0.03";requires"Mojolicious"=>"8.35";requires"perl"=>"5.014";requires"routines"=>"0";requires"strict"=>"0";requires"warnings"=>"0";on'test'=>sub{requires"Data::Object::Class"=>"2.02";requires"Data::Object::ClassHas"=>"2.01";requires"Data::Object::Role::Buildable"=>"0.03";requires"Data::Object::Role::Stashable"=>"2.01";requires"Data::Object::Role::Throwable"=>"2.01";requires"FlightRecorder"=>"0.03";requires"Mojolicious"=>"8.35";requires"Test::Auto"=>"0.10";requires"perl"=>"5.014";requires"routines"=>"0";requires"strict"=>"0";requires"warnings"=>"0";};on'configure'=>sub{requires"ExtUtils::MakeMaker"=>"0";};
lib/API/Client.pm view on Meta::CPAN
}methoddelete(Any%args) {return$self->dispatch(%args,method=>'delete');}method dispatch(Str :$method='get', Any%args) {my$log=$self->logger->info("@{[uc($method)]} @{[$self->url->to_string]}");my$result=$self->execute(%args,method=>$method);$log->end;return$result;}method fetch(Any%args) {return$self->dispatch(%args,method=>'get');}method patch(Any%args) {return$self->dispatch(%args,method=>'patch');
lib/API/Client.pm view on Meta::CPAN
$self->set_identity($ua,$tx,%args);return$self;}method process(Object$ua, Object$tx, Any%args) {return$self;}method resource(Str@segments) {my$url;if(@segments) {$url=$self->url->clone;$url->path->merge(join'/','', @{$self->url->path->parts},@segments);}
lib/API/Client.pm view on Meta::CPAN
$ua->on(prepare=> fun ($ua,$tx) {$self->prepare($ua,$tx,%args);});# client timeouts$ua->max_redirects(0);$ua->connect_timeout($self->timeout);$ua->request_timeout($self->timeout);# transactionmy($ok,$tx,$req,$res);# times to retry failuresmy$retries=$self->retries;# transaction retry loopfor(my$i= 0;$i< ($retries|| 1);$i++) {# execute transaction$tx=$ua->start($ua->build_tx($method,$url,$headers,@args));$self->process($ua,$tx,%args);# transaction objects$req=$tx->req;$res=$tx->res;# determine success/failure$ok=$res->code ?$res->code !~ /(4|5)\d\d/ : 0;# log activityif($req&&$res) {my$log=$self->logger;my$msg=join" ","attempt", ("#".($i+1)),": $method",$url->to_string;$log->debug("req: $msg")->data({request=>$req->to_string =~ s/\s*$/\n\n\n/r});$log->debug("res: $msg")->data({response=>$res->to_string =~ s/\s*$/\n\n\n/r});# output to the console where applicable$log->info("res: $msg [@{[$res->code]}]");$log->outputif$self->debug;}# no retry necessarylastif$ok;}# throw exception if fatal is truthyif($req&&$res&&$self->fatal && !$ok) {my$code=$res->code;$self->stash(tx=>$tx);$self->throw([$code,uc"${code}_http_response"]);}# return transactionreturn$tx;}1;=encoding utf8
lib/API/Client.pm view on Meta::CPAN
=cut=head1 SYNOPSISpackage main;use API::Client;my $client = API::Client->new(url => 'https://httpbin.org');# $client->resource('post');# $client->update(json => {...});=cut=head1 DESCRIPTIONThis package provides an abstraction and method for rapidly developing HTTP APIclients. While this module can be used to interact with APIs directly,API::Client was designed to be consumed (subclassed) by higher-level
lib/API/Client.pm view on Meta::CPAN
=head1 THIN CLIENTThe thin API client library is advantageous as it has complete API coverage andcan easily adapt to changes in the API with minimal effort. As a thin-clientsuperclass, this module does not map specific HTTP requests to specificroutines, nor does it provide parameter validation, pagination, or otherconventions found in typical API client implementations; Instead, it simplyprovides a simple and consistent mechanism for dynamically generating HTTPrequests. Additionally, this module has support for debugging and retrying APIcalls as well as throwing exceptions when 4xx and 5xx server response codes arereturned.=cut=head1 INTEGRATESThis package integrates behaviors from:L<Data::Object::Role::Buildable>
lib/API/Client.pm view on Meta::CPAN
=head1 SCENARIOSThis package supports the following scenarios:=cut=head2 building# given: synopsismy $resource = $client->resource('get');# GET /getmy $get = $client->resource('get')->dispatch;# HEAD /headmy $head = $client->resource('head')->dispatch(method => 'head');# PATCH /patchmy $patch = $client->resource('patch')->dispatch(method => 'patch');[$get, $head, $patch]Building up an HTTP request is extremely easy, simply call the L</resource> tocreate a new object instance representing the API endpoint you wish to issue arequest against.=cut=head2 chaining# given: synopsismy $users = $client->resource('users');my $user = $client->resource('users', 'c09e91a');my $new_user = $users->resource('c09e91a');[$users, $user, $new_user]Because each call to L</resource> returns a new object instance configured witha path (resource locator) based on the supplied parameters, reuse and requestisolation are made simple, i.e., you will only need to configure the clientonce in your application.=cut=head2 creating# given: synopsismy $tx1 = $client->resource('post')->create(json => {active => 1});# is equivalent tomy $tx2 = $client->resource('post')->dispatch(method => 'post',json => {active => 1});[$tx1, $tx2]This example illustrates how you might create a new API resource.=cut=head2 deleting# given: synopsismy $tx1 = $client->resource('delete')->delete(json => {active => 1});# is equivalent tomy $tx2 = $client->resource('delete')->dispatch(method => 'delete',json => {active => 1});[$tx1, $tx2]This example illustrates how you might delete a new API resource.=cut=head2 fetching# given: synopsismy $tx1 = $client->resource('get')->fetch(query => {active => 1});# is equivalent tomy $tx2 = $client->resource('get')->dispatch(method => 'get',query => {active => 1});[$tx1, $tx2]This example illustrates how you might fetch an API resource.=cut=head2 subclassingpackage Hookbin;use Data::Object::Class;extends 'API::Client';
lib/API/Client.pm view on Meta::CPAN
subbase {}my$hookbin= Hookbin->new;building and request dispatching processes. Specifically, there are threeuseful hooks (i.e. methods, whichifpresent are used to build up the clientobject and requests), which are, the C<auth> hook, which shouldreturnaC<Tuple[Str, Str]> which is used to configure the basic auth header, theC<base> hook which shouldreturna C<Tuple[Str]> which is used to configure thebase URL, and the C<headers> hook, which shouldreturnaC<ArrayRef[Tuple[Str, Str]]> which are used to configure the HTTP requestheaders.=cut=head2 transacting# given: synopsismy $tx1 = $client->resource('patch')->patch(json => {active => 1});# is equivalent tomy $tx2 = $client->resource('patch')->dispatch(method => 'patch',json => {active => 1});[$tx1, $tx2]An HTTP request is only issued when the L</dispatch> method is called, directlyor indirectly. Those calls return a L<Mojo::Transaction> object which providesaccess to the C<request> and C<response> objects.=cut=head2 updating# given: synopsismy $tx1 = $client->resource('put')->update(json => {active => 1});# is equivalent tomy $tx2 = $client->resource('put')->dispatch(method => 'put',json => {active => 1});[$tx1, $tx2]This example illustrates how you might update a new API resource.=cut=head1 ATTRIBUTESThis package has the following attributes:=cut=head2 debug
lib/API/Client.pm view on Meta::CPAN
=head1 METHODSThis package implements the following methods:=cut=head2 createcreate(Any %args) : InstanceOf["Mojo::Transaction"]The create method issues a C<POST> request to the API resource represented bythe object.=over 4=item create example #1# given: synopsis$client->resource('post')->create(json => {active => 1});=back=cut=head2 deletedelete(Any %args) : InstanceOf["Mojo::Transaction"]The delete method issues a C<DELETE> request to the API resource represented bythe object.=over 4=item delete example #1# given: synopsis$client->resource('delete')->delete;=back=cut=head2 dispatchdispatch(Str :$method = 'get', Any %args) : InstanceOf["Mojo::Transaction"]The dispatch method issues a request to the API resource represented by theobject.=over 4=item dispatch example #1# given: synopsis$client->resource('get')->dispatch;=back=over 4=item dispatch example #2# given: synopsis$client->resource('post')->dispatch(method => 'post', body => 'active=1');=back=over 4=item dispatch example #3# given: synopsis$client->resource('get')->dispatch(method => 'get', query => {active => 1});=back=over 4=item dispatch example #4# given: synopsis$client->resource('post')->dispatch(method => 'post', json => {active => 1});=back=over 4=item dispatch example #5# given: synopsis$client->resource('post')->dispatch(method => 'post', form => {active => 1});=back=over 4=item dispatch example #6# given: synopsis$client->resource('put')->dispatch(method => 'put', json => {active => 1});=back=over 4=item dispatch example #7# given: synopsis$client->resource('patch')->dispatch(method => 'patch', json => {active => 1});=back=over 4=item dispatch example #8# given: synopsis$client->resource('delete')->dispatch(method => 'delete', json => {active => 1});=back=cut=head2 fetchfetch(Any %args) : InstanceOf["Mojo::Transaction"]The fetch method issues a C<GET> request to the API resource represented by theobject.=over 4=item fetch example #1# given: synopsis$client->resource('get')->fetch;=back=cut=head2 patchpatch(Any %args) : InstanceOf["Mojo::Transaction"]The patch method issues a C<PATCH> request to the API resource represented bythe object.=over 4=item patch example #1# given: synopsis$client->resource('patch')->patch(json => {active => 1});=back=cut=head2 prepareprepare(Object $ua, Object $tx, Any %args) : Object
lib/API/Client.pm view on Meta::CPAN
);=back=cut=head2 processprocess(Object $ua, Object $tx, Any %args) : ObjectThe process method acts as an C<after> hook triggered after each response whereyou can modify the transactor objects.=over 4=item process example #1# given: synopsisrequire Mojo::UserAgent;require Mojo::Transaction::HTTP;$client->process(Mojo::UserAgent->new,Mojo::Transaction::HTTP->new);=back=cut=head2 resourceresource(Str @segments) : ObjectThe resource method returns a new instance of the object for the API resourceendpoint specified.=over 4=item resource example #1# given: synopsis$client->resource('status', 200);=back=cut=head2 serializeserialize() : HashRefThe serialize method serializes and returns the object as a C<hashref>.
lib/API/Client.pm view on Meta::CPAN
$client->serialize;=back=cut=head2 updateupdate(Any %args) : InstanceOf["Mojo::Transaction"]The update method issues a C<PUT> request to the API resource represented bythe object.=over 4=item update example #1# given: synopsis$client->resource('put')->update(json => {active => 1});=back=cut=head1 AUTHORAl Newkirk, C<awncorp@cpan.org>
t/API_Client.t view on Meta::CPAN
=includesmethod: createmethod: deletemethod: dispatchmethod: fetchmethod: patchmethod: preparemethod: processmethod: resourcemethod: serializemethod: update=cut=synopsispackage main;use API::Client;my $client = API::Client->new(url => 'https://httpbin.org');# $client->resource('post');# $client->update(json => {...});=cut=librariesTypes::Standard=cut
t/API_Client.t view on Meta::CPAN
+=head1 THIN CLIENTThe thin API client library is advantageous as ithascomplete API coverage andcan easily adapt to changes in the APIwithminimal effort. As a thin-clientsuperclass, this module does notmapspecific HTTP requests to specificroutines, nor does it provide parameter validation, pagination, or otherconventions found in typical API client implementations; Instead, it simplyprovides a simple and consistent mechanismfordynamically generating HTTPrequests. Additionally, this modulehassupportfordebugging and retrying APIcalls as well as throwing exceptionswhen4xx and 5xx server response codes arereturned.=cut=scenario buildingBuilding up an HTTP request is extremely easy, simply call the L</resource> tocreate a new object instance representing the API endpoint you wish to issue arequest against.=example building# given: synopsismy $resource = $client->resource('get');# GET /getmy $get = $client->resource('get')->dispatch;# HEAD /headmy $head = $client->resource('head')->dispatch(method => 'head');# PATCH /patchmy $patch = $client->resource('patch')->dispatch(method => 'patch');[$get, $head, $patch]=cut=scenario chainingBecause each call to L</resource> returns a new object instance configured witha path (resource locator) based on the supplied parameters, reuse and requestisolation are made simple, i.e., you will only need to configure the clientonce in your application.=example chaining# given: synopsismy $users = $client->resource('users');my $user = $client->resource('users', 'c09e91a');my $new_user = $users->resource('c09e91a');[$users, $user, $new_user]=cut=scenario fetchingThis example illustrates how you might fetch an API resource.=example fetching# given: synopsismy $tx1 = $client->resource('get')->fetch(query => {active => 1});# is equivalent tomy $tx2 = $client->resource('get')->dispatch(method => 'get',query => {active => 1});[$tx1, $tx2]=cut=scenario creatingThis example illustrates how you might create a new API resource.=example creating# given: synopsismy $tx1 = $client->resource('post')->create(json => {active => 1});# is equivalent tomy $tx2 = $client->resource('post')->dispatch(method => 'post',json => {active => 1});[$tx1, $tx2]=cut=scenario updatingThis example illustrates how you might update a new API resource.=example updating# given: synopsismy $tx1 = $client->resource('put')->update(json => {active => 1});# is equivalent tomy $tx2 = $client->resource('put')->dispatch(method => 'put',json => {active => 1});[$tx1, $tx2]=cut=scenario deletingThis example illustrates how you might delete a new API resource.=example deleting# given: synopsismy $tx1 = $client->resource('delete')->delete(json => {active => 1});# is equivalent tomy $tx2 = $client->resource('delete')->dispatch(method => 'delete',json => {active => 1});[$tx1, $tx2]=cut=scenario transactingAn HTTP request is only issued when the L</dispatch> method is called, directlyor indirectly. Those calls return a L<Mojo::Transaction> object which providesaccess to the C<request> and C<response> objects.=example transacting# given: synopsismy $tx1 = $client->resource('patch')->patch(json => {active => 1});# is equivalent tomy $tx2 = $client->resource('patch')->dispatch(method => 'patch',json => {active => 1});[$tx1, $tx2]=cut=scenario subclassingThis package was designed to be subclassed and provides hooks into the clientbuilding and request dispatching processes. Specifically, there are threeuseful hooks (i.e. methods, which if present are used to build up the clientobject and requests), which are, the C<auth> hook, which should return aC<Tuple[Str, Str]> which is used to configure the basic auth header, theC<base> hook which should return a C<Tuple[Str]> which is used to configure thebase URL, and the C<headers> hook, which should return aC<ArrayRef[Tuple[Str, Str]]> which are used to configure the HTTP requestheaders.=example subclassingpackage Hookbin;
t/API_Client.t view on Meta::CPAN
}my$hookbin= Hookbin->new;=cut=method dispatchThe dispatch method issues a request to the API resource represented by theobject.=signature dispatchdispatch(Str :$method = 'get', Any %args) : InstanceOf["Mojo::Transaction"]=example-1 dispatch# given: synopsis$client->resource('get')->dispatch;=example-2 dispatch# given: synopsis$client->resource('post')->dispatch(method => 'post', body => 'active=1');=example-3 dispatch# given: synopsis$client->resource('get')->dispatch(method => 'get', query => {active => 1});=example-4 dispatch# given: synopsis$client->resource('post')->dispatch(method => 'post', json => {active => 1});=example-5 dispatch# given: synopsis$client->resource('post')->dispatch(method => 'post', form => {active => 1});=example-6 dispatch# given: synopsis$client->resource('put')->dispatch(method => 'put', json => {active => 1});=example-7 dispatch# given: synopsis$client->resource('patch')->dispatch(method => 'patch', json => {active => 1});=example-8 dispatch# given: synopsis$client->resource('delete')->dispatch(method => 'delete', json => {active => 1});=cut=method createThe create method issues a C<POST> request to the API resource represented bythe object.=signature createcreate(Any %args) : InstanceOf["Mojo::Transaction"]=example-1 create# given: synopsis$client->resource('post')->create(json => {active => 1});=cut=method deleteThe delete method issues a C<DELETE> request to the API resource represented bythe object.=signature deletedelete(Any %args) : InstanceOf["Mojo::Transaction"]=example-1 delete# given: synopsis$client->resource('delete')->delete;=cut=method fetchThe fetch method issues a C<GET> request to the API resource represented by theobject.=signature fetchfetch(Any %args) : InstanceOf["Mojo::Transaction"]=example-1 fetch# given: synopsis$client->resource('get')->fetch;=cut=method patchThe patch method issues a C<PATCH> request to the API resource represented bythe object.=signature patchpatch(Any %args) : InstanceOf["Mojo::Transaction"]=example-1 patch# given: synopsis$client->resource('patch')->patch(json => {active => 1});=cut=method prepareThe prepare method acts as a C<before> hook triggered before each request whereyou can modify the transactor objects.
t/API_Client.t view on Meta::CPAN
$client->prepare(Mojo::UserAgent->new,Mojo::Transaction::HTTP->new);=cut=method processThe process method acts as an C<after> hook triggered after each response whereyou can modify the transactor objects.=signature processprocess(Object $ua, Object $tx, Any %args) : Object=example-1 process# given: synopsisrequire Mojo::UserAgent;require Mojo::Transaction::HTTP;$client->process(Mojo::UserAgent->new,Mojo::Transaction::HTTP->new);=cut=method resourceThe resource method returns a new instance of the object for the API resourceendpoint specified.=signature resourceresource(Str @segments) : Object=example-1 resource# given: synopsis$client->resource('status', 200);=cut=method serializeThe serialize method serializes and returns the object as a C<hashref>.=signature serializeserialize() : HashRef
t/API_Client.t view on Meta::CPAN
=example-1 serialize# given: synopsis$client->serialize;=cut=method updateThe update method issues a C<PUT> request to the API resource represented bythe object.=signature updateupdate(Any %args) : InstanceOf["Mojo::Transaction"]=example-1 update# given: synopsis$client->resource('put')->update(json => {active => 1});=cutpackagemain;useMojo::UserAgent;SKIP: {my$skip_tests=do{!eval{$tx->result->is_success};};unless($skip_tests) {my$test= testauto(__FILE__);my$subs=$test->standard;$subs->synopsis(fun($tryable) {okmy$result=$tryable->result;$result});$subs->scenario('building', fun($tryable) {okmy$result=$tryable->result;my$get=$result->[0];my$head=$result->[1];my$patch=$result->[2];isnt Scalar::Util::refaddr($get), Scalar::Util::refaddr($head);isnt Scalar::Util::refaddr($get), Scalar::Util::refaddr($patch);isnt Scalar::Util::refaddr($head), Scalar::Util::refaddr($patch);is$get->req->method,'get';is$head->req->method,'head';is$patch->req->method,'patch';});$subs->scenario('chaining', fun($tryable) {okmy$result=$tryable->result;my$users=$result->[0];my$user=$result->[1];my$new_user=$result->[2];isnt Scalar::Util::refaddr($users), Scalar::Util::refaddr($user);isnt Scalar::Util::refaddr($users), Scalar::Util::refaddr($new_user);isnt Scalar::Util::refaddr($user), Scalar::Util::refaddr($new_user);});$subs->scenario('fetching', fun($tryable) {okmy$result=$tryable->result;;});$subs->scenario('creating', fun($tryable) {okmy$result=$tryable->result;;});$subs->scenario('updating', fun($tryable) {okmy$result=$tryable->result;;});$subs->scenario('deleting', fun($tryable) {okmy$result=$tryable->result;;});$subs->scenario('transacting', fun($tryable) {okmy$result=$tryable->result;;});$subs->scenario('subclassing', fun($tryable) {okmy$result=$tryable->result;ok$result->isa('Hookbin');ok$result->isa('API::Client');is_deeply$result->auth, ['admin','secret'];is_deeply$result->headers, [['Accept','*/*']];is$result->name,'Hookbin (0.01)';});$subs->example(-1,'create','method', fun($tryable) {okmy$result=$tryable->result;my$req=$result->req;islc($req->method),'post';my$res=$result->res;is$res->code, 200;my$json=$res->json;is$json->{headers}{'Host'},'httpbin.org';is$json->{headers}{'Content-Type'},'application/json';is_deeply$json->{json}, {active=> 1};$result});$subs->example(-1,'delete','method', fun($tryable) {okmy$result=$tryable->result;my$req=$result->req;islc($req->method),'delete';my$res=$result->res;is$res->code, 200;my$json=$res->json;is$json->{headers}{'Host'},'httpbin.org';is$json->{headers}{'Content-Type'},'application/json';is_deeply$json->{json},undef;is_deeply$json->{form}, {};is$json->{data},'';$result});$subs->example(-1,'dispatch','method', fun($tryable) {okmy$result=$tryable->result;my$req=$result->req;islc($req->method),'get';my$res=$result->res;is$res->code, 200;my$json=$res->json;is$json->{headers}{'Host'},'httpbin.org';is$json->{headers}{'Content-Type'},'application/json';is_deeply$json->{args}, {};$result});$subs->example(-2,'dispatch','method', fun($tryable) {okmy$result=$tryable->result;my$req=$result->req;islc($req->method),'post';my$res=$result->res;is$res->code, 200;my$json=$res->json;is$json->{headers}{'Host'},'httpbin.org';is$json->{headers}{'Content-Type'},'application/json';is$json->{data},"active=1";$result});$subs->example(-3,'dispatch','method', fun($tryable) {okmy$result=$tryable->result;my$req=$result->req;islc($req->method),'get';my$res=$result->res;is$res->code, 200;my$json=$res->json;is$json->{headers}{'Host'},'httpbin.org';is$json->{headers}{'Content-Type'},'application/json';is_deeply$json->{args}, {active=> 1};$result});$subs->example(-4,'dispatch','method', fun($tryable) {okmy$result=$tryable->result;my$req=$result->req;islc($req->method),'post';my$res=$result->res;is$res->code, 200;my$json=$res->json;is$json->{headers}{'Host'},'httpbin.org';is$json->{headers}{'Content-Type'},'application/json';is_deeply$json->{json}, {active=> 1};$result});$subs->example(-5,'dispatch','method', fun($tryable) {okmy$result=$tryable->result;my$req=$result->req;islc($req->method),'post';my$res=$result->res;is$res->code, 200;my$json=$res->json;is$json->{headers}{'Host'},'httpbin.org';is$json->{headers}{'Content-Type'},'application/json';is$json->{data},"active=1";$result});$subs->example(-6,'dispatch','method', fun($tryable) {okmy$result=$tryable->result;my$req=$result->req;islc($req->method),'put';my$res=$result->res;is$res->code, 200;my$json=$res->json;is$json->{headers}{'Host'},'httpbin.org';is$json->{headers}{'Content-Type'},'application/json';is_deeply$json->{json}, {active=> 1};$result});$subs->example(-7,'dispatch','method', fun($tryable) {okmy$result=$tryable->result;my$req=$result->req;islc($req->method),'patch';my$res=$result->res;is$res->code, 200;my$json=$res->json;is$json->{headers}{'Host'},'httpbin.org';is$json->{headers}{'Content-Type'},'application/json';is_deeply$json->{json}, {active=> 1};$result});$subs->example(-8,'dispatch','method', fun($tryable) {okmy$result=$tryable->result;my$req=$result->req;islc($req->method),'delete';my$res=$result->res;is$res->code, 200;my$json=$res->json;is$json->{headers}{'Host'},'httpbin.org';is$json->{headers}{'Content-Type'},'application/json';is_deeply$json->{json}, {active=> 1};$result});$subs->example(-1,'fetch','method', fun($tryable) {okmy$result=$tryable->result;my$req=$result->req;islc($req->method),'get';my$res=$result->res;is$res->code, 200;my$json=$res->json;is$json->{headers}{'Host'},'httpbin.org';is$json->{headers}{'Content-Type'},'application/json';is_deeply$json->{json},undef;is_deeply$json->{form},undef;is$json->{data},undef;$result});$subs->example(-1,'patch','method', fun($tryable) {okmy$result=$tryable->result;my$req=$result->req;islc($req->method),'patch';my$res=$result->res;is$res->code, 200;my$json=$res->json;is$json->{headers}{'Host'},'httpbin.org';is$json->{headers}{'Content-Type'},'application/json';is_deeply$json->{json}, {active=> 1};$result});$subs->example(-1,'prepare','method', fun($tryable) {okmy$result=$tryable->result;$result});$subs->example(-1,'process','method', fun($tryable) {okmy$result=$tryable->result;$result});$subs->example(-1,'resource','method', fun($tryable) {okmy$result=$tryable->result;is$result->debug, 0;is$result->fatal, 0;like$result->name,qr/API::Client \(\d.\d\d\)/;is$result->retries, 0;is$result->timeout, 10;$result});$subs->example(-1,'serialize','method', fun($tryable) {okmy$result=$tryable->result;is$result->{debug}, 0;is$result->{fatal}, 0;like$result->{name},qr/API::Client \(\d.\d\d\)/;is$result->{retries}, 0;is$result->{timeout}, 10;$result});$subs->example(-1,'update','method', fun($tryable) {okmy$result=$tryable->result;my$req=$result->req;islc($req->method),'put';my$res=$result->res;is$res->code, 200;my$json=$res->json;is$json->{headers}{'Host'},'httpbin.org';is$json->{headers}{'Content-Type'},'application/json';is_deeply$json->{json}, {active=> 1};$result});}skip'Unable to connect to HTTPBin'if$skip_tests;}ok 1 and done_testing;
( run in 0.643 second using v1.01-cache-2.11-cpan-87723dcf8b7 )