BlackMATov/curly.hpp
1
0
Fork 0
mirror of https://github.com/BlackMATov/curly.hpp.git synced 2025-12-15 12:19:47 +07:00
Code Issues Packages Projects Releases Wiki Activity

rename methods to http_method, statuses to req_status

Browse Source
This commit is contained in:
Matvey Cherevko
2019-07-07 08:48:43 +07:00
parent 320c1c2d6e
commit 4b9dae2f38
4 changed files with 156 additions and 156 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
README.md
View File

@@ -67,7 +67,7 @@ net::perform();
```cpp ```cpp
// makes a GET request and async send it // makes a GET request and async send it
auto request = net::request_builder() auto request = net::request_builder()
.method(net::methods::get) .method(net::http_method::GET)
.url("http://www.httpbin.org/get") .url("http://www.httpbin.org/get")
.send(); .send();
@@ -97,7 +97,7 @@ std::cout << "Body content: " << response.content.as_string_view() << std::endl;
```cpp ```cpp
auto request = net::request_builder() auto request = net::request_builder()
.method(net::methods::post) .method(net::http_method::POST)
.url("http://www.httpbin.org/post") .url("http://www.httpbin.org/post")
.header("Content-Type", "application/json") .header("Content-Type", "application/json")
.content(R"({"hello" : "world"})") .content(R"({"hello" : "world"})")
@@ -217,7 +217,7 @@ private:
}; };
net::request_builder() net::request_builder()
.method(net::methods::post) .method(net::http_method::POST)
.url("https://httpbin.org/anything") .url("https://httpbin.org/anything")
.uploader<file_uploader>("image.jpeg") .uploader<file_uploader>("image.jpeg")
.send().wait(); .send().wait();

52
headers/curly.hpp/curly.hpp
View File

@@ -39,11 +39,11 @@ namespace curly_hpp
using time_ms_t = std::chrono::milliseconds; using time_ms_t = std::chrono::milliseconds;
using time_point_t = std::chrono::steady_clock::time_point; using time_point_t = std::chrono::steady_clock::time_point;
enum class methods { enum class http_method {
put, PUT,
get, GET,
head, HEAD,
post POST
}; };
class upload_handler { class upload_handler {
@@ -173,16 +173,16 @@ namespace curly_hpp
namespace curly_hpp namespace curly_hpp
{ {
enum class req_status {
done,
empty,
failed,
timeout,
pending,
canceled
};
class request final { class request final {
public:
enum class statuses {
done,
empty,
failed,
timeout,
pending,
canceled
};
public: public:
class internal_state; class internal_state;
using internal_state_ptr = std::shared_ptr<internal_state>; using internal_state_ptr = std::shared_ptr<internal_state>;
@@ -190,18 +190,18 @@ namespace curly_hpp
request(internal_state_ptr); request(internal_state_ptr);
bool cancel() noexcept; bool cancel() noexcept;
statuses status() const noexcept; req_status status() const noexcept;
bool is_done() const noexcept; bool is_done() const noexcept;
bool is_pending() const noexcept; bool is_pending() const noexcept;
statuses wait() const noexcept; req_status wait() const noexcept;
statuses wait_for(time_ms_t ms) const noexcept; req_status wait_for(time_ms_t ms) const noexcept;
statuses wait_until(time_point_t tp) const noexcept; req_status wait_until(time_point_t tp) const noexcept;
statuses wait_callback() const noexcept; req_status wait_callback() const noexcept;
statuses wait_callback_for(time_ms_t ms) const noexcept; req_status wait_callback_for(time_ms_t ms) const noexcept;
statuses wait_callback_until(time_point_t tp) const noexcept; req_status wait_callback_until(time_point_t tp) const noexcept;
response take(); response take();
const std::string& get_error() const noexcept; const std::string& get_error() const noexcept;
@@ -223,12 +223,12 @@ namespace curly_hpp
request_builder(const request_builder&) = delete; request_builder(const request_builder&) = delete;
request_builder& operator=(const request_builder&) = delete; request_builder& operator=(const request_builder&) = delete;
explicit request_builder(methods m) noexcept; explicit request_builder(http_method m) noexcept;
explicit request_builder(std::string u) noexcept; explicit request_builder(std::string u) noexcept;
explicit request_builder(methods m, std::string u) noexcept; explicit request_builder(http_method m, std::string u) noexcept;
request_builder& url(std::string u) noexcept; request_builder& url(std::string u) noexcept;
request_builder& method(methods m) noexcept; request_builder& method(http_method m) noexcept;
request_builder& header(std::string key, std::string value); request_builder& header(std::string key, std::string value);
request_builder& verbose(bool v) noexcept; request_builder& verbose(bool v) noexcept;
@@ -245,7 +245,7 @@ namespace curly_hpp
request_builder& downloader(downloader_uptr d) noexcept; request_builder& downloader(downloader_uptr d) noexcept;
const std::string& url() const noexcept; const std::string& url() const noexcept;
methods method() const noexcept; http_method method() const noexcept;
const headers_t& headers() const noexcept; const headers_t& headers() const noexcept;
bool verbose() const noexcept; bool verbose() const noexcept;
@@ -288,7 +288,7 @@ namespace curly_hpp
} }
private: private:
std::string url_; std::string url_;
methods method_{methods::get}; http_method method_{http_method::GET};
headers_t headers_; headers_t headers_;
bool verbose_{false}; bool verbose_{false};
bool verification_{false}; bool verification_{false};

80
sources/curly.hpp/curly.cpp
View File

@@ -295,18 +295,18 @@ namespace curly_hpp
curl_easy_setopt(curlh_.get(), CURLOPT_VERBOSE, breq_.verbose() ? 1l : 0l); curl_easy_setopt(curlh_.get(), CURLOPT_VERBOSE, breq_.verbose() ? 1l : 0l);
switch ( breq_.method() ) { switch ( breq_.method() ) {
case methods::put: case http_method::PUT:
curl_easy_setopt(curlh_.get(), CURLOPT_UPLOAD, 1l); curl_easy_setopt(curlh_.get(), CURLOPT_UPLOAD, 1l);
curl_easy_setopt(curlh_.get(), CURLOPT_INFILESIZE_LARGE, curl_easy_setopt(curlh_.get(), CURLOPT_INFILESIZE_LARGE,
static_cast<curl_off_t>(breq_.uploader()->size())); static_cast<curl_off_t>(breq_.uploader()->size()));
break; break;
case methods::get: case http_method::GET:
curl_easy_setopt(curlh_.get(), CURLOPT_HTTPGET, 1l); curl_easy_setopt(curlh_.get(), CURLOPT_HTTPGET, 1l);
break; break;
case methods::head: case http_method::HEAD:
curl_easy_setopt(curlh_.get(), CURLOPT_NOBODY, 1l); curl_easy_setopt(curlh_.get(), CURLOPT_NOBODY, 1l);
break; break;
case methods::post: case http_method::POST:
curl_easy_setopt(curlh_.get(), CURLOPT_POST, 1l); curl_easy_setopt(curlh_.get(), CURLOPT_POST, 1l);
curl_easy_setopt(curlh_.get(), CURLOPT_POSTFIELDSIZE_LARGE, curl_easy_setopt(curlh_.get(), CURLOPT_POSTFIELDSIZE_LARGE,
static_cast<curl_off_t>(breq_.uploader()->size())); static_cast<curl_off_t>(breq_.uploader()->size()));
@@ -355,7 +355,7 @@ namespace curly_hpp
bool done() noexcept { bool done() noexcept {
std::lock_guard<std::mutex> guard(mutex_); std::lock_guard<std::mutex> guard(mutex_);
if ( status_ != statuses::pending ) { if ( status_ != req_status::pending ) {
return false; return false;
} }
@@ -365,7 +365,7 @@ namespace curly_hpp
CURLINFO_RESPONSE_CODE, CURLINFO_RESPONSE_CODE,
&http_code) || !http_code ) &http_code) || !http_code )
{ {
status_ = statuses::failed; status_ = req_status::failed;
cvar_.notify_all(); cvar_.notify_all();
return false; return false;
} }
@@ -377,12 +377,12 @@ namespace curly_hpp
response_.uploader = std::move(breq_.uploader()); response_.uploader = std::move(breq_.uploader());
response_.downloader = std::move(breq_.downloader()); response_.downloader = std::move(breq_.downloader());
} catch (...) { } catch (...) {
status_ = statuses::failed; status_ = req_status::failed;
cvar_.notify_all(); cvar_.notify_all();
return false; return false;
} }
status_ = statuses::done; status_ = req_status::done;
error_.clear(); error_.clear();
cvar_.notify_all(); cvar_.notify_all();
@@ -391,21 +391,21 @@ namespace curly_hpp
bool fail(CURLcode err) noexcept { bool fail(CURLcode err) noexcept {
std::lock_guard<std::mutex> guard(mutex_); std::lock_guard<std::mutex> guard(mutex_);
if ( status_ != statuses::pending ) { if ( status_ != req_status::pending ) {
return false; return false;
} }
switch ( err ) { switch ( err ) {
case CURLE_OPERATION_TIMEDOUT: case CURLE_OPERATION_TIMEDOUT:
status_ = statuses::timeout; status_ = req_status::timeout;
break; break;
case CURLE_READ_ERROR: case CURLE_READ_ERROR:
case CURLE_WRITE_ERROR: case CURLE_WRITE_ERROR:
case CURLE_ABORTED_BY_CALLBACK: case CURLE_ABORTED_BY_CALLBACK:
status_ = statuses::canceled; status_ = req_status::canceled;
break; break;
default: default:
status_ = statuses::failed; status_ = req_status::failed;
break; break;
} }
@@ -421,54 +421,54 @@ namespace curly_hpp
bool cancel() noexcept { bool cancel() noexcept {
std::lock_guard<std::mutex> guard(mutex_); std::lock_guard<std::mutex> guard(mutex_);
if ( status_ != statuses::pending ) { if ( status_ != req_status::pending ) {
return false; return false;
} }
status_ = statuses::canceled; status_ = req_status::canceled;
error_.clear(); error_.clear();
cvar_.notify_all(); cvar_.notify_all();
return true; return true;
} }
statuses status() const noexcept { req_status status() const noexcept {
std::lock_guard<std::mutex> guard(mutex_); std::lock_guard<std::mutex> guard(mutex_);
return status_; return status_;
} }
bool is_done() const noexcept { bool is_done() const noexcept {
std::lock_guard<std::mutex> guard(mutex_); std::lock_guard<std::mutex> guard(mutex_);
return status_ == statuses::done; return status_ == req_status::done;
} }
bool is_pending() const noexcept { bool is_pending() const noexcept {
std::lock_guard<std::mutex> guard(mutex_); std::lock_guard<std::mutex> guard(mutex_);
return status_ == statuses::pending; return status_ == req_status::pending;
} }
statuses wait(bool wait_callback) const noexcept { req_status wait(bool wait_callback) const noexcept {
std::unique_lock<std::mutex> lock(mutex_); std::unique_lock<std::mutex> lock(mutex_);
cvar_.wait(lock, [this, wait_callback](){ cvar_.wait(lock, [this, wait_callback](){
return (status_ != statuses::pending) return (status_ != req_status::pending)
&& (!wait_callback || callbacked_); && (!wait_callback || callbacked_);
}); });
return status_; return status_;
} }
statuses wait_for(time_ms_t ms, bool wait_callback) const noexcept { req_status wait_for(time_ms_t ms, bool wait_callback) const noexcept {
std::unique_lock<std::mutex> lock(mutex_); std::unique_lock<std::mutex> lock(mutex_);
cvar_.wait_for(lock, ms, [this, wait_callback](){ cvar_.wait_for(lock, ms, [this, wait_callback](){
return (status_ != statuses::pending) return (status_ != req_status::pending)
&& (!wait_callback || callbacked_); && (!wait_callback || callbacked_);
}); });
return status_; return status_;
} }
statuses wait_until(time_point_t tp, bool wait_callback) const noexcept { req_status wait_until(time_point_t tp, bool wait_callback) const noexcept {
std::unique_lock<std::mutex> lock(mutex_); std::unique_lock<std::mutex> lock(mutex_);
cvar_.wait_until(lock, tp, [this, wait_callback](){ cvar_.wait_until(lock, tp, [this, wait_callback](){
return (status_ != statuses::pending) return (status_ != req_status::pending)
&& (!wait_callback || callbacked_); && (!wait_callback || callbacked_);
}); });
return status_; return status_;
@@ -477,19 +477,19 @@ namespace curly_hpp
response take() { response take() {
std::unique_lock<std::mutex> lock(mutex_); std::unique_lock<std::mutex> lock(mutex_);
cvar_.wait(lock, [this](){ cvar_.wait(lock, [this](){
return status_ != statuses::pending; return status_ != req_status::pending;
}); });
if ( status_ != statuses::done ) { if ( status_ != req_status::done ) {
throw exception("curly_hpp: response is unavailable"); throw exception("curly_hpp: response is unavailable");
} }
status_ = statuses::empty; status_ = req_status::empty;
return std::move(response_); return std::move(response_);
} }
const std::string& get_error() const noexcept { const std::string& get_error() const noexcept {
std::unique_lock<std::mutex> lock(mutex_); std::unique_lock<std::mutex> lock(mutex_);
cvar_.wait(lock, [this](){ cvar_.wait(lock, [this](){
return status_ != statuses::pending; return status_ != req_status::pending;
}); });
return error_; return error_;
} }
@@ -513,7 +513,7 @@ namespace curly_hpp
callback_exception_ = std::current_exception(); callback_exception_ = std::current_exception();
} }
std::lock_guard<std::mutex> guard(mutex_); std::lock_guard<std::mutex> guard(mutex_);
assert(!callbacked_ && status_ != statuses::pending); assert(!callbacked_ && status_ != req_status::pending);
callbacked_ = true; callbacked_ = true;
cvar_.notify_all(); cvar_.notify_all();
} }
@@ -615,7 +615,7 @@ namespace curly_hpp
bool callbacked_{false}; bool callbacked_{false};
std::exception_ptr callback_exception_{nullptr}; std::exception_ptr callback_exception_{nullptr};
private: private:
statuses status_{statuses::pending}; req_status status_{req_status::pending};
std::string error_{"Unknown error"}; std::string error_{"Unknown error"};
private: private:
mutable std::mutex mutex_; mutable std::mutex mutex_;
@@ -634,7 +634,7 @@ namespace curly_hpp
return state_->cancel(); return state_->cancel();
} }
request::statuses request::status() const noexcept { req_status request::status() const noexcept {
return state_->status(); return state_->status();
} }
@@ -646,27 +646,27 @@ namespace curly_hpp
return state_->is_pending(); return state_->is_pending();
} }
request::statuses request::wait() const noexcept { req_status request::wait() const noexcept {
return state_->wait(false); return state_->wait(false);
} }
request::statuses request::wait_for(time_ms_t ms) const noexcept { req_status request::wait_for(time_ms_t ms) const noexcept {
return state_->wait_for(ms, false); return state_->wait_for(ms, false);
} }
request::statuses request::wait_until(time_point_t tp) const noexcept { req_status request::wait_until(time_point_t tp) const noexcept {
return state_->wait_until(tp, false); return state_->wait_until(tp, false);
} }
request::statuses request::wait_callback() const noexcept { req_status request::wait_callback() const noexcept {
return state_->wait(true); return state_->wait(true);
} }
request::statuses request::wait_callback_for(time_ms_t ms) const noexcept { req_status request::wait_callback_for(time_ms_t ms) const noexcept {
return state_->wait_for(ms, true); return state_->wait_for(ms, true);
} }
request::statuses request::wait_callback_until(time_point_t tp) const noexcept { req_status request::wait_callback_until(time_point_t tp) const noexcept {
return state_->wait_until(tp, true); return state_->wait_until(tp, true);
} }
@@ -691,13 +691,13 @@ namespace curly_hpp
namespace curly_hpp namespace curly_hpp
{ {
request_builder::request_builder(methods m) noexcept request_builder::request_builder(http_method m) noexcept
: method_(m) {} : method_(m) {}
request_builder::request_builder(std::string u) noexcept request_builder::request_builder(std::string u) noexcept
: url_(std::move(u)) {} : url_(std::move(u)) {}
request_builder::request_builder(methods m, std::string u) noexcept request_builder::request_builder(http_method m, std::string u) noexcept
: url_(std::move(u)) : url_(std::move(u))
, method_(m) {} , method_(m) {}
@@ -706,7 +706,7 @@ namespace curly_hpp
return *this; return *this;
} }
request_builder& request_builder::method(methods m) noexcept { request_builder& request_builder::method(http_method m) noexcept {
method_ = m; method_ = m;
return *this; return *this;
} }
@@ -775,7 +775,7 @@ namespace curly_hpp
return url_; return url_;
} }
methods request_builder::method() const noexcept { http_method request_builder::method() const noexcept {
return method_; return method_;
} }

174
untests/curly_tests.cpp
View File

@@ -86,33 +86,33 @@ TEST_CASE("curly") {
SECTION("wait") { SECTION("wait") {
{ {
auto req = net::request_builder("https://httpbin.org/delay/1").send(); auto req = net::request_builder("https://httpbin.org/delay/1").send();
REQUIRE(req.status() == net::request::statuses::pending); REQUIRE(req.status() == net::req_status::pending);
REQUIRE(req.wait() == net::request::statuses::done); REQUIRE(req.wait() == net::req_status::done);
REQUIRE(req.status() == net::request::statuses::done); REQUIRE(req.status() == net::req_status::done);
auto resp = req.take(); auto resp = req.take();
REQUIRE(resp.http_code() == 200u); REQUIRE(resp.http_code() == 200u);
REQUIRE(req.status() == net::request::statuses::empty); REQUIRE(req.status() == net::req_status::empty);
} }
{ {
auto req = net::request_builder("https://httpbin.org/delay/2").send(); auto req = net::request_builder("https://httpbin.org/delay/2").send();
REQUIRE(req.wait_for(net::time_sec_t(1)) == net::request::statuses::pending); REQUIRE(req.wait_for(net::time_sec_t(1)) == net::req_status::pending);
REQUIRE(req.wait_for(net::time_sec_t(5)) == net::request::statuses::done); REQUIRE(req.wait_for(net::time_sec_t(5)) == net::req_status::done);
REQUIRE(req.take().http_code() == 200u); REQUIRE(req.take().http_code() == 200u);
} }
{ {
auto req = net::request_builder("https://httpbin.org/delay/2").send(); auto req = net::request_builder("https://httpbin.org/delay/2").send();
REQUIRE(req.wait_until(net::time_point_t::clock::now() + net::time_sec_t(1)) REQUIRE(req.wait_until(net::time_point_t::clock::now() + net::time_sec_t(1))
== net::request::statuses::pending); == net::req_status::pending);
REQUIRE(req.wait_until(net::time_point_t::clock::now() + net::time_sec_t(5)) REQUIRE(req.wait_until(net::time_point_t::clock::now() + net::time_sec_t(5))
== net::request::statuses::done); == net::req_status::done);
REQUIRE(req.take().http_code() == 200u); REQUIRE(req.take().http_code() == 200u);
} }
} }
SECTION("error") { SECTION("error") {
auto req = net::request_builder("|||").send(); auto req = net::request_builder("|||").send();
REQUIRE(req.wait() == net::request::statuses::failed); REQUIRE(req.wait() == net::req_status::failed);
REQUIRE(req.status() == net::request::statuses::failed); REQUIRE(req.status() == net::req_status::failed);
REQUIRE_FALSE(req.get_error().empty()); REQUIRE_FALSE(req.get_error().empty());
} }
@@ -120,21 +120,21 @@ TEST_CASE("curly") {
{ {
auto req = net::request_builder("https://httpbin.org/delay/1").send(); auto req = net::request_builder("https://httpbin.org/delay/1").send();
REQUIRE(req.cancel()); REQUIRE(req.cancel());
REQUIRE(req.status() == net::request::statuses::canceled); REQUIRE(req.status() == net::req_status::canceled);
REQUIRE(req.get_error().empty()); REQUIRE(req.get_error().empty());
} }
{ {
auto req = net::request_builder("https://httpbin.org/status/200").send(); auto req = net::request_builder("https://httpbin.org/status/200").send();
REQUIRE(req.wait() == net::request::statuses::done); REQUIRE(req.wait() == net::req_status::done);
REQUIRE_FALSE(req.cancel()); REQUIRE_FALSE(req.cancel());
REQUIRE(req.status() == net::request::statuses::done); REQUIRE(req.status() == net::req_status::done);
REQUIRE(req.get_error().empty()); REQUIRE(req.get_error().empty());
} }
} }
SECTION("is_done/is_pending") { SECTION("is_done/is_pending") {
{ {
auto req = net::request_builder(net::methods::get) auto req = net::request_builder(net::http_method::GET)
.url("https://httpbin.org/delay/1") .url("https://httpbin.org/delay/1")
.send(); .send();
REQUIRE_FALSE(req.is_done()); REQUIRE_FALSE(req.is_done());
@@ -144,7 +144,7 @@ TEST_CASE("curly") {
REQUIRE_FALSE(req.is_pending()); REQUIRE_FALSE(req.is_pending());
} }
{ {
auto req = net::request_builder(net::methods::post, "http://www.httpbin.org/post") auto req = net::request_builder(net::http_method::POST, "http://www.httpbin.org/post")
.url("https://httpbin.org/delay/2") .url("https://httpbin.org/delay/2")
.request_timeout(net::time_sec_t(1)) .request_timeout(net::time_sec_t(1))
.send(); .send();
@@ -161,22 +161,22 @@ TEST_CASE("curly") {
{ {
auto req = net::request_builder("https://httpbin.org/status/204").send(); auto req = net::request_builder("https://httpbin.org/status/204").send();
auto resp = req.take(); auto resp = req.take();
REQUIRE(req.status() == net::request::statuses::empty); REQUIRE(req.status() == net::req_status::empty);
REQUIRE(resp.http_code() == 204u); REQUIRE(resp.http_code() == 204u);
} }
{ {
auto req = net::request_builder("https://httpbin.org/delay/2").send(); auto req = net::request_builder("https://httpbin.org/delay/2").send();
REQUIRE(req.cancel()); REQUIRE(req.cancel());
REQUIRE_THROWS_AS(req.take(), net::exception); REQUIRE_THROWS_AS(req.take(), net::exception);
REQUIRE(req.status() == net::request::statuses::canceled); REQUIRE(req.status() == net::req_status::canceled);
} }
{ {
auto req = net::request_builder("https://httpbin.org/delay/2") auto req = net::request_builder("https://httpbin.org/delay/2")
.response_timeout(net::time_sec_t(0)) .response_timeout(net::time_sec_t(0))
.send(); .send();
REQUIRE(req.wait() == net::request::statuses::timeout); REQUIRE(req.wait() == net::req_status::timeout);
REQUIRE_THROWS_AS(req.take(), net::exception); REQUIRE_THROWS_AS(req.take(), net::exception);
REQUIRE(req.status() == net::request::statuses::timeout); REQUIRE(req.status() == net::req_status::timeout);
} }
} }
@@ -184,75 +184,75 @@ TEST_CASE("curly") {
{ {
auto req0 = net::request_builder() auto req0 = net::request_builder()
.url("https://httpbin.org/put") .url("https://httpbin.org/put")
.method(net::methods::put) .method(net::http_method::PUT)
.send(); .send();
REQUIRE(req0.take().http_code() == 200u); REQUIRE(req0.take().http_code() == 200u);
auto req1 = net::request_builder() auto req1 = net::request_builder()
.url("https://httpbin.org/put") .url("https://httpbin.org/put")
.method(net::methods::get) .method(net::http_method::GET)
.send(); .send();
REQUIRE(req1.take().http_code() == 405u); REQUIRE(req1.take().http_code() == 405u);
auto req2 = net::request_builder() auto req2 = net::request_builder()
.url("https://httpbin.org/put") .url("https://httpbin.org/put")
.method(net::methods::head) .method(net::http_method::HEAD)
.send(); .send();
REQUIRE(req2.take().http_code() == 405u); REQUIRE(req2.take().http_code() == 405u);
auto req3 = net::request_builder() auto req3 = net::request_builder()
.url("https://httpbin.org/put") .url("https://httpbin.org/put")
.method(net::methods::post) .method(net::http_method::POST)
.send(); .send();
REQUIRE(req3.take().http_code() == 405u); REQUIRE(req3.take().http_code() == 405u);
} }
{ {
auto req0 = net::request_builder() auto req0 = net::request_builder()
.url("https://httpbin.org/get") .url("https://httpbin.org/get")
.method(net::methods::put) .method(net::http_method::PUT)
.send(); .send();
REQUIRE(req0.take().http_code() == 405u); REQUIRE(req0.take().http_code() == 405u);
auto req1 = net::request_builder() auto req1 = net::request_builder()
.url("https://httpbin.org/get") .url("https://httpbin.org/get")
.method(net::methods::get) .method(net::http_method::GET)
.send(); .send();
REQUIRE(req1.take().http_code() == 200u); REQUIRE(req1.take().http_code() == 200u);
auto req2 = net::request_builder() auto req2 = net::request_builder()
.url("https://httpbin.org/get") .url("https://httpbin.org/get")
.method(net::methods::head) .method(net::http_method::HEAD)
.send(); .send();
REQUIRE(req2.take().http_code() == 200u); REQUIRE(req2.take().http_code() == 200u);
auto req3 = net::request_builder() auto req3 = net::request_builder()
.url("https://httpbin.org/get") .url("https://httpbin.org/get")
.method(net::methods::post) .method(net::http_method::POST)
.send(); .send();
REQUIRE(req3.take().http_code() == 405u); REQUIRE(req3.take().http_code() == 405u);
} }
{ {
auto req0 = net::request_builder() auto req0 = net::request_builder()
.url("https://httpbin.org/post") .url("https://httpbin.org/post")
.method(net::methods::put) .method(net::http_method::PUT)
.send(); .send();
REQUIRE(req0.take().http_code() == 405u); REQUIRE(req0.take().http_code() == 405u);
auto req1 = net::request_builder() auto req1 = net::request_builder()
.url("https://httpbin.org/post") .url("https://httpbin.org/post")
.method(net::methods::get) .method(net::http_method::GET)
.send(); .send();
REQUIRE(req1.take().http_code() == 405u); REQUIRE(req1.take().http_code() == 405u);
auto req2 = net::request_builder() auto req2 = net::request_builder()
.url("https://httpbin.org/post") .url("https://httpbin.org/post")
.method(net::methods::head) .method(net::http_method::HEAD)
.send(); .send();
REQUIRE(req2.take().http_code() == 405u); REQUIRE(req2.take().http_code() == 405u);
auto req3 = net::request_builder() auto req3 = net::request_builder()
.url("https://httpbin.org/post") .url("https://httpbin.org/post")
.method(net::methods::post) .method(net::http_method::POST)
.send(); .send();
REQUIRE(req3.take().http_code() == 200u); REQUIRE(req3.take().http_code() == 200u);
} }
@@ -262,28 +262,28 @@ TEST_CASE("curly") {
{ {
auto req = net::request_builder() auto req = net::request_builder()
.url("https://httpbin.org/status/200") .url("https://httpbin.org/status/200")
.method(net::methods::put) .method(net::http_method::PUT)
.send(); .send();
REQUIRE(req.take().http_code() == 200u); REQUIRE(req.take().http_code() == 200u);
} }
{ {
auto req = net::request_builder() auto req = net::request_builder()
.url("https://httpbin.org/status/201") .url("https://httpbin.org/status/201")
.method(net::methods::get) .method(net::http_method::GET)
.send(); .send();
REQUIRE(req.take().http_code() == 201u); REQUIRE(req.take().http_code() == 201u);
} }
{ {
auto req = net::request_builder() auto req = net::request_builder()
.url("https://httpbin.org/status/202") .url("https://httpbin.org/status/202")
.method(net::methods::head) .method(net::http_method::HEAD)
.send(); .send();
REQUIRE(req.take().http_code() == 202u); REQUIRE(req.take().http_code() == 202u);
} }
{ {
auto req = net::request_builder() auto req = net::request_builder()
.url("https://httpbin.org/status/203") .url("https://httpbin.org/status/203")
.method(net::methods::post) .method(net::http_method::POST)
.send(); .send();
REQUIRE(req.take().http_code() == 203u); REQUIRE(req.take().http_code() == 203u);
} }
@@ -307,7 +307,7 @@ TEST_CASE("curly") {
{ {
auto req = net::request_builder() auto req = net::request_builder()
.url("https://httpbin.org/response-headers?hello=world&world=hello") .url("https://httpbin.org/response-headers?hello=world&world=hello")
.method(net::methods::get) .method(net::http_method::GET)
.send(); .send();
const auto resp = req.take(); const auto resp = req.take();
const auto content_j = json_parse(resp.content.as_string_view()); const auto content_j = json_parse(resp.content.as_string_view());
@@ -317,7 +317,7 @@ TEST_CASE("curly") {
{ {
auto req = net::request_builder() auto req = net::request_builder()
.url("https://httpbin.org/response-headers?hello=world&world=hello") .url("https://httpbin.org/response-headers?hello=world&world=hello")
.method(net::methods::post) .method(net::http_method::POST)
.send(); .send();
const auto resp = req.take(); const auto resp = req.take();
const auto content_j = json_parse(resp.content.as_string_copy()); const auto content_j = json_parse(resp.content.as_string_copy());
@@ -340,14 +340,14 @@ TEST_CASE("curly") {
.url("https://httpbin.org/delay/10") .url("https://httpbin.org/delay/10")
.request_timeout(net::time_sec_t(0)) .request_timeout(net::time_sec_t(0))
.send(); .send();
REQUIRE(req0.wait() == net::request::statuses::timeout); REQUIRE(req0.wait() == net::req_status::timeout);
REQUIRE_FALSE(req0.get_error().empty()); REQUIRE_FALSE(req0.get_error().empty());
auto req1 = net::request_builder() auto req1 = net::request_builder()
.url("https://httpbin.org/delay/10") .url("https://httpbin.org/delay/10")
.response_timeout(net::time_sec_t(0)) .response_timeout(net::time_sec_t(0))
.send(); .send();
REQUIRE(req1.wait() == net::request::statuses::timeout); REQUIRE(req1.wait() == net::req_status::timeout);
REQUIRE_FALSE(req1.get_error().empty()); REQUIRE_FALSE(req1.get_error().empty());
} }
{ {
@@ -355,14 +355,14 @@ TEST_CASE("curly") {
.url("https://httpbin.org/delay/10") .url("https://httpbin.org/delay/10")
.request_timeout(net::time_sec_t(1)) .request_timeout(net::time_sec_t(1))
.send(); .send();
REQUIRE(req0.wait() == net::request::statuses::timeout); REQUIRE(req0.wait() == net::req_status::timeout);
REQUIRE_FALSE(req0.get_error().empty()); REQUIRE_FALSE(req0.get_error().empty());
auto req1 = net::request_builder() auto req1 = net::request_builder()
.url("https://httpbin.org/delay/10") .url("https://httpbin.org/delay/10")
.response_timeout(net::time_sec_t(1)) .response_timeout(net::time_sec_t(1))
.send(); .send();
REQUIRE(req1.wait() == net::request::statuses::timeout); REQUIRE(req1.wait() == net::req_status::timeout);
REQUIRE_FALSE(req1.get_error().empty()); REQUIRE_FALSE(req1.get_error().empty());
} }
} }
@@ -371,7 +371,7 @@ TEST_CASE("curly") {
{ {
auto resp = net::request_builder() auto resp = net::request_builder()
.url("https://httpbin.org/image/png") .url("https://httpbin.org/image/png")
.method(net::methods::get) .method(net::http_method::GET)
.send().take(); .send().take();
REQUIRE(resp.http_code() == 200u); REQUIRE(resp.http_code() == 200u);
REQUIRE(resp.headers.count("Content-Type")); REQUIRE(resp.headers.count("Content-Type"));
@@ -384,7 +384,7 @@ TEST_CASE("curly") {
{ {
auto resp = net::request_builder() auto resp = net::request_builder()
.url("https://httpbin.org/image/jpeg") .url("https://httpbin.org/image/jpeg")
.method(net::methods::get) .method(net::http_method::GET)
.send().take(); .send().take();
REQUIRE(resp.http_code() == 200u); REQUIRE(resp.http_code() == 200u);
REQUIRE(resp.headers.count("Content-Type")); REQUIRE(resp.headers.count("Content-Type"));
@@ -401,21 +401,21 @@ TEST_CASE("curly") {
{ {
auto req = net::request_builder() auto req = net::request_builder()
.url("https://httpbin.org/redirect/2") .url("https://httpbin.org/redirect/2")
.method(net::methods::get) .method(net::http_method::GET)
.send(); .send();
REQUIRE(req.take().http_code() == 200u); REQUIRE(req.take().http_code() == 200u);
} }
{ {
auto req = net::request_builder() auto req = net::request_builder()
.url("https://httpbin.org/absolute-redirect/2") .url("https://httpbin.org/absolute-redirect/2")
.method(net::methods::get) .method(net::http_method::GET)
.send(); .send();
REQUIRE(req.take().http_code() == 200u); REQUIRE(req.take().http_code() == 200u);
} }
{ {
auto req = net::request_builder() auto req = net::request_builder()
.url("https://httpbin.org/relative-redirect/2") .url("https://httpbin.org/relative-redirect/2")
.method(net::methods::get) .method(net::http_method::GET)
.send(); .send();
REQUIRE(req.take().http_code() == 200u); REQUIRE(req.take().http_code() == 200u);
} }
@@ -424,7 +424,7 @@ TEST_CASE("curly") {
{ {
auto req = net::request_builder() auto req = net::request_builder()
.url("https://httpbin.org/redirect/3") .url("https://httpbin.org/redirect/3")
.method(net::methods::get) .method(net::http_method::GET)
.redirections(0) .redirections(0)
.send(); .send();
REQUIRE(req.take().http_code() == 302u); REQUIRE(req.take().http_code() == 302u);
@@ -432,23 +432,23 @@ TEST_CASE("curly") {
{ {
auto req = net::request_builder() auto req = net::request_builder()
.url("https://httpbin.org/redirect/3") .url("https://httpbin.org/redirect/3")
.method(net::methods::get) .method(net::http_method::GET)
.redirections(1) .redirections(1)
.send(); .send();
REQUIRE(req.wait() == net::request::statuses::failed); REQUIRE(req.wait() == net::req_status::failed);
} }
{ {
auto req = net::request_builder() auto req = net::request_builder()
.url("https://httpbin.org/redirect/3") .url("https://httpbin.org/redirect/3")
.method(net::methods::get) .method(net::http_method::GET)
.redirections(2) .redirections(2)
.send(); .send();
REQUIRE(req.wait() == net::request::statuses::failed); REQUIRE(req.wait() == net::req_status::failed);
} }
{ {
auto req = net::request_builder() auto req = net::request_builder()
.url("https://httpbin.org/redirect/3") .url("https://httpbin.org/redirect/3")
.method(net::methods::get) .method(net::http_method::GET)
.redirections(3) .redirections(3)
.send(); .send();
REQUIRE(req.take().http_code() == 200u); REQUIRE(req.take().http_code() == 200u);
@@ -460,7 +460,7 @@ TEST_CASE("curly") {
{ {
auto resp = net::request_builder() auto resp = net::request_builder()
.url("https://httpbin.org/anything") .url("https://httpbin.org/anything")
.method(net::methods::put) .method(net::http_method::PUT)
.header("Content-Type", "application/json") .header("Content-Type", "application/json")
.content(R"({"hello":"world"})") .content(R"({"hello":"world"})")
.send().take(); .send().take();
@@ -470,7 +470,7 @@ TEST_CASE("curly") {
{ {
auto resp = net::request_builder() auto resp = net::request_builder()
.url("https://httpbin.org/anything") .url("https://httpbin.org/anything")
.method(net::methods::post) .method(net::http_method::POST)
.header("Content-Type", "application/json") .header("Content-Type", "application/json")
.content(R"({"hello":"world"})") .content(R"({"hello":"world"})")
.send().take(); .send().take();
@@ -480,7 +480,7 @@ TEST_CASE("curly") {
{ {
auto resp = net::request_builder() auto resp = net::request_builder()
.url("https://httpbin.org/anything") .url("https://httpbin.org/anything")
.method(net::methods::post) .method(net::http_method::POST)
.header("Content-Type", "application/x-www-form-urlencoded") .header("Content-Type", "application/x-www-form-urlencoded")
.content("hello=world&world=hello") .content("hello=world&world=hello")
.send().take(); .send().take();
@@ -493,53 +493,53 @@ TEST_CASE("curly") {
SECTION("ssl_verification") { SECTION("ssl_verification") {
{ {
auto req0 = net::request_builder("https://expired.badssl.com") auto req0 = net::request_builder("https://expired.badssl.com")
.method(net::methods::head) .method(net::http_method::HEAD)
.verification(true) .verification(true)
.send(); .send();
REQUIRE(req0.wait() == net::request::statuses::failed); REQUIRE(req0.wait() == net::req_status::failed);
auto req1 = net::request_builder("https://wrong.host.badssl.com") auto req1 = net::request_builder("https://wrong.host.badssl.com")
.method(net::methods::head) .method(net::http_method::HEAD)
.verification(true) .verification(true)
.send(); .send();
REQUIRE(req1.wait() == net::request::statuses::failed); REQUIRE(req1.wait() == net::req_status::failed);
auto req2 = net::request_builder("https://self-signed.badssl.com") auto req2 = net::request_builder("https://self-signed.badssl.com")
.method(net::methods::head) .method(net::http_method::HEAD)
.verification(true) .verification(true)
.send(); .send();
REQUIRE(req2.wait() == net::request::statuses::failed); REQUIRE(req2.wait() == net::req_status::failed);
auto req3 = net::request_builder("https://untrusted-root.badssl.com") auto req3 = net::request_builder("https://untrusted-root.badssl.com")
.method(net::methods::head) .method(net::http_method::HEAD)
.verification(true) .verification(true)
.send(); .send();
REQUIRE(req3.wait() == net::request::statuses::failed); REQUIRE(req3.wait() == net::req_status::failed);
} }
{ {
auto req0 = net::request_builder("https://expired.badssl.com") auto req0 = net::request_builder("https://expired.badssl.com")
.method(net::methods::head) .method(net::http_method::HEAD)
.verification(false) .verification(false)
.send(); .send();
REQUIRE(req0.wait() == net::request::statuses::done); REQUIRE(req0.wait() == net::req_status::done);
auto req1 = net::request_builder("https://wrong.host.badssl.com") auto req1 = net::request_builder("https://wrong.host.badssl.com")
.method(net::methods::head) .method(net::http_method::HEAD)
.verification(false) .verification(false)
.send(); .send();
REQUIRE(req1.wait() == net::request::statuses::done); REQUIRE(req1.wait() == net::req_status::done);
auto req2 = net::request_builder("https://self-signed.badssl.com") auto req2 = net::request_builder("https://self-signed.badssl.com")
.method(net::methods::head) .method(net::http_method::HEAD)
.verification(false) .verification(false)
.send(); .send();
REQUIRE(req2.wait() == net::request::statuses::done); REQUIRE(req2.wait() == net::req_status::done);
auto req3 = net::request_builder("https://untrusted-root.badssl.com") auto req3 = net::request_builder("https://untrusted-root.badssl.com")
.method(net::methods::head) .method(net::http_method::HEAD)
.verification(false) .verification(false)
.send(); .send();
REQUIRE(req3.wait() == net::request::statuses::done); REQUIRE(req3.wait() == net::req_status::done);
} }
} }
@@ -547,18 +547,18 @@ TEST_CASE("curly") {
{ {
auto req = net::request_builder("https://httpbin.org/anything") auto req = net::request_builder("https://httpbin.org/anything")
.verbose(true) .verbose(true)
.method(net::methods::post) .method(net::http_method::POST)
.uploader<canceled_uploader>() .uploader<canceled_uploader>()
.send(); .send();
REQUIRE(req.wait() == net::request::statuses::canceled); REQUIRE(req.wait() == net::req_status::canceled);
} }
{ {
auto req = net::request_builder("https://httpbin.org/anything") auto req = net::request_builder("https://httpbin.org/anything")
.verbose(true) .verbose(true)
.method(net::methods::get) .method(net::http_method::GET)
.downloader<canceled_downloader>() .downloader<canceled_downloader>()
.send(); .send();
REQUIRE(req.wait() == net::request::statuses::canceled); REQUIRE(req.wait() == net::req_status::canceled);
} }
} }
@@ -570,10 +570,10 @@ TEST_CASE("curly") {
std::this_thread::sleep_for(std::chrono::milliseconds(10)); std::this_thread::sleep_for(std::chrono::milliseconds(10));
++call_once; ++call_once;
REQUIRE(request.is_done()); REQUIRE(request.is_done());
REQUIRE(request.status() == net::request::statuses::done); REQUIRE(request.status() == net::req_status::done);
REQUIRE(request.take().http_code() == 200u); REQUIRE(request.take().http_code() == 200u);
}).send(); }).send();
REQUIRE(req.wait_callback() == net::request::statuses::empty); REQUIRE(req.wait_callback() == net::req_status::empty);
REQUIRE_FALSE(req.get_callback_exception()); REQUIRE_FALSE(req.get_callback_exception());
REQUIRE(call_once.load() == 1u); REQUIRE(call_once.load() == 1u);
} }
@@ -584,10 +584,10 @@ TEST_CASE("curly") {
std::this_thread::sleep_for(std::chrono::milliseconds(10)); std::this_thread::sleep_for(std::chrono::milliseconds(10));
++call_once; ++call_once;
REQUIRE_FALSE(request.is_done()); REQUIRE_FALSE(request.is_done());
REQUIRE(request.status() == net::request::statuses::failed); REQUIRE(request.status() == net::req_status::failed);
REQUIRE_FALSE(request.get_error().empty()); REQUIRE_FALSE(request.get_error().empty());
}).send(); }).send();
REQUIRE(req.wait_callback() == net::request::statuses::failed); REQUIRE(req.wait_callback() == net::req_status::failed);
REQUIRE_FALSE(req.get_callback_exception()); REQUIRE_FALSE(req.get_callback_exception());
REQUIRE(call_once.load() == 1u); REQUIRE(call_once.load() == 1u);
} }
@@ -599,10 +599,10 @@ TEST_CASE("curly") {
std::this_thread::sleep_for(std::chrono::milliseconds(10)); std::this_thread::sleep_for(std::chrono::milliseconds(10));
++call_once; ++call_once;
REQUIRE_FALSE(request.is_done()); REQUIRE_FALSE(request.is_done());
REQUIRE(request.status() == net::request::statuses::timeout); REQUIRE(request.status() == net::req_status::timeout);
REQUIRE_FALSE(request.get_error().empty()); REQUIRE_FALSE(request.get_error().empty());
}).send(); }).send();
REQUIRE(req.wait_callback() == net::request::statuses::timeout); REQUIRE(req.wait_callback() == net::req_status::timeout);
REQUIRE_FALSE(req.get_callback_exception()); REQUIRE_FALSE(req.get_callback_exception());
REQUIRE(call_once.load() == 1u); REQUIRE(call_once.load() == 1u);
} }
@@ -613,11 +613,11 @@ TEST_CASE("curly") {
std::this_thread::sleep_for(std::chrono::milliseconds(10)); std::this_thread::sleep_for(std::chrono::milliseconds(10));
++call_once; ++call_once;
REQUIRE_FALSE(request.is_done()); REQUIRE_FALSE(request.is_done());
REQUIRE(request.status() == net::request::statuses::canceled); REQUIRE(request.status() == net::req_status::canceled);
REQUIRE(request.get_error().empty()); REQUIRE(request.get_error().empty());
}).send(); }).send();
REQUIRE(req.cancel()); REQUIRE(req.cancel());
REQUIRE(req.wait_callback() == net::request::statuses::canceled); REQUIRE(req.wait_callback() == net::req_status::canceled);
REQUIRE_FALSE(req.get_callback_exception()); REQUIRE_FALSE(req.get_callback_exception());
REQUIRE(call_once.load() == 1u); REQUIRE(call_once.load() == 1u);
} }
@@ -631,7 +631,7 @@ TEST_CASE("curly") {
throw std::logic_error("my_logic_error"); throw std::logic_error("my_logic_error");
} }
}).send(); }).send();
REQUIRE(req.wait_callback() == net::request::statuses::empty); REQUIRE(req.wait_callback() == net::req_status::empty);
REQUIRE(req.get_callback_exception()); REQUIRE(req.get_callback_exception());
try { try {
std::rethrow_exception(req.get_callback_exception()); std::rethrow_exception(req.get_callback_exception());
@@ -647,7 +647,7 @@ TEST_CASE("curly_examples") {
SECTION("Get Requests") { SECTION("Get Requests") {
// makes a GET request and async send it // makes a GET request and async send it
auto request = net::request_builder() auto request = net::request_builder()
.method(net::methods::get) .method(net::http_method::GET)
.url("http://www.httpbin.org/get") .url("http://www.httpbin.org/get")
.send(); .send();
@@ -675,7 +675,7 @@ TEST_CASE("curly_examples") {
SECTION("Post Requests") { SECTION("Post Requests") {
auto request = net::request_builder() auto request = net::request_builder()
.method(net::methods::post) .method(net::http_method::POST)
.url("http://www.httpbin.org/post") .url("http://www.httpbin.org/post")
.header("Content-Type", "application/json") .header("Content-Type", "application/json")
.content(R"({"hello" : "world"})") .content(R"({"hello" : "world"})")
@@ -785,7 +785,7 @@ TEST_CASE("curly_examples") {
}; };
net::request_builder() net::request_builder()
.method(net::methods::post) .method(net::http_method::POST)
.url("https://httpbin.org/anything") .url("https://httpbin.org/anything")
.uploader<file_uploader>("image.jpeg") .uploader<file_uploader>("image.jpeg")
.send().take(); .send().take();