Implemented CRTP for HttpRequests with body (POST/PUT), this way we can determine it at compile time ;) and there is no way we can do a .body(...) when we issue a get or a head

Author: ggcr

src/s3cpp/httpclient.cpp

@@ -18,6 +18,15 @@ HttpResponse HttpRequest::execute() {
   }
 }
 
+HttpResponse HttpBodyRequest::execute() {
+  switch (this->http_method_) {
+  case HttpMethod::Post:
+    return client_.execute_post(*this);
+  default:
+    throw std::runtime_error(std::format("No matching enum Http Method"));
+  }
+}
+
 HttpResponse HttpClient::execute_get(HttpRequest &request) {
   if (!curl_handle) {
     throw std::runtime_error(
@@ -112,6 +121,63 @@ HttpResponse HttpClient::execute_head(HttpRequest &request) {
   return HttpResponse(static_cast<int>(response_code), std::move(headers_buf));
 }
 
+HttpResponse HttpClient::execute_post(HttpBodyRequest &request) {
+  if (!curl_handle) {
+    throw std::runtime_error(
+        // this can happen both when cURL handle is not initialized or when it
+        // is invalidated in the HTTPClient copy constructor
+        "cURL handle is invalid");
+  }
+  std::string body_buf;
+  std::map<std::string, std::string> headers_buf;
+  std::string error_buf;
+
+  // TODO(cristian): from libcurl docs, they state that each curl handle has
+  // "sticky" params, this is why we are resetting at each get request
+  // However, I think we should only do this when moving a new handle the only
+  // thing that will change is the URL from now
+  //
+  // curl_easy_reset(curl_handle);
+
+  curl_easy_setopt(curl_handle, CURLOPT_URL, request.getURL().c_str());
+  // body callback
+  curl_easy_setopt(curl_handle, CURLOPT_WRITEFUNCTION, write_callback);
+  curl_easy_setopt(curl_handle, CURLOPT_WRITEDATA, &body_buf);
+  // headers callback
+  curl_easy_setopt(curl_handle, CURLOPT_HEADERFUNCTION, header_callback);
+  curl_easy_setopt(curl_handle, CURLOPT_HEADERDATA, &headers_buf);
+  // post/put body
+  curl_easy_setopt(curl_handle, CURLOPT_POST,
+                   1L); // sets CURLOPT_NOBODY CURLOPT_HTTPGET to 0
+  curl_easy_setopt(curl_handle, CURLOPT_POSTFIELDS, request.getBody().c_str());
+
+  curl_easy_setopt(curl_handle, CURLOPT_TIMEOUT, request.getTimeout());
+
+  // merge client and request headers
+  // https://stackoverflow.com/questions/34321719
+  auto headers = request.getHeaders();
+  headers.insert(this->getHeaders().begin(), this->getHeaders().end());
+  struct curl_slist *list = NULL;
+  for (const auto &[k, v] : headers) {
+    list = curl_slist_append(list, std::format("{}: {}", k, v).c_str());
+  }
+  curl_easy_setopt(curl_handle, CURLOPT_HTTPHEADER, list);
+
+  CURLcode code = curl_easy_perform(curl_handle);
+  curl_slist_free_all(list);
+  if (code != CURLE_OK) {
+    throw std::runtime_error(
+        std::format("libcurl error for request: {}", curl_easy_strerror(code)));
+  }
+
+  // get HTTP code
+  long response_code = 0;
+  curl_easy_getinfo(curl_handle, CURLINFO_HTTP_CODE, &response_code);
+
+  return HttpResponse(static_cast<int>(response_code), std::move(body_buf),
+                      std::move(headers_buf));
+}
+
 size_t HttpClient::write_callback(char *ptr, size_t size, size_t nmemb,
                                   void *userdata) {
   std::string *buffer = static_cast<std::string *>(userdata);

src/s3cpp/httpclient.h

@@ -47,46 +47,83 @@ class HttpResponse {
 };
 
 // HttpRequest will handle all the headers and request params
-class HttpRequest {
+//
+// Curiously Recurring Template Pattern (CRTP)
+//
+// POST/PUT must a have a body member variable that GET/HEAD don't
+// we want to do this at compile-time, however, because we are using a fluent
+// builder pattern, if we were to do regular inheritance, when using .body() we
+// would return a `&HttpBodyRequest : public HttpRequest`, which would not allow
+// us to chain useful methods on the HttpRequest class such as .timeout()
+
+template <typename T> class HttpRequestBase {
 public:
-  HttpRequest(HttpClient &client, std::string URL,
-              const HttpMethod &http_method)
+  HttpRequestBase(HttpClient &client, std::string URL,
+                  const HttpMethod &http_method)
       : client_(client), URL_(std::move(URL)),
         http_method_(std::move(http_method)), timeout_(0) {};
 
-  HttpRequest &timeout(const long long &seconds) {
+  T &timeout(const long long &seconds) {
     timeout_ = std::chrono::seconds(seconds);
-    return *this;
+    return static_cast<T &>(*this);
   }
-  HttpRequest &timeout(const std::chrono::seconds &seconds) {
+  T &timeout(const std::chrono::seconds &seconds) {
     timeout_ = seconds;
-    return *this;
+    return static_cast<T &>(*this);
   }
-  HttpRequest &header(const std::string &header_, const std::string &value) {
+  T &header(const std::string &header_, const std::string &value) {
     headers_[header_] = value;
-    return *this;
+    return static_cast<T &>(*this);
   }
 
-  HttpResponse execute();
-
   const std::string &getURL() const { return URL_; }
   const long long getTimeout() const { return timeout_.count(); }
   const std::unordered_map<std::string, std::string> &getHeaders() const {
     return headers_;
   }
 
-private:
+protected:
   HttpClient &client_;
   std::string URL_;
   std::unordered_map<std::string, std::string> headers_;
   std::chrono::seconds timeout_;
   HttpMethod http_method_;
 };
 
+// GET/HEAD
+class HttpRequest : public HttpRequestBase<HttpRequest> {
+public:
+  using HttpRequestBase::HttpRequestBase;
+	HttpResponse execute();
+};
+
+// POST/PUT
+class HttpBodyRequest : public HttpRequestBase<HttpBodyRequest> {
+public:
+  HttpBodyRequest(HttpClient &client, std::string URL,
+                  const HttpMethod &http_method)
+      : HttpRequestBase(client, std::move(URL), http_method) {}
+
+  HttpBodyRequest &body(const std::string &data) {
+    body_ = std::move(data);
+    return (*this);
+  }
+
+  const std::string &getBody() const { return body_; }
+
+	HttpResponse execute();
+
+private:
+  std::string body_;
+};
+
 // HttpClient should only focus on handling the cURL handle
 // and making the request (HttpRequest) and returning HttpResponse
 class HttpClient {
-  friend class HttpRequest; // `execute()` is invoked from the request only
+  // `execute()` is invoked from the request only
+  friend class HttpRequest;
+  friend class HttpBodyRequest;
+
 public:
   HttpClient() {
     curl_handle = curl_easy_init();
@@ -131,6 +168,9 @@ class HttpClient {
   [[nodiscard]] HttpRequest head(const std::string &URL) {
     return HttpRequest{*this, URL, HttpMethod::Head};
   };
+  [[nodiscard]] HttpBodyRequest post(const std::string &URL) {
+    return HttpBodyRequest{*this, URL, HttpMethod::Post};
+  };
 
 private:
   CURL *curl_handle = nullptr;
@@ -146,6 +186,7 @@ class HttpClient {
   // this is invoked by HttpRequest
   HttpResponse execute_get(HttpRequest &request);
   HttpResponse execute_head(HttpRequest &request);
+  HttpResponse execute_post(HttpBodyRequest &request);
 
   const std::unordered_map<std::string, std::string> &getHeaders() const {
     return headers_;

test/httpclient_test.cpp

@@ -198,3 +198,15 @@ TEST(HTTP, HTTPHeaderOrder) {
     it2++;
   }
 }
+
+TEST(HTTP, HTTPPost) {
+  HttpClient client{};
+	std::string data = "This is expected to be sent back as part of response body";
+	HttpBodyRequest req = client.post("https://postman-echo.com/post").body(data);
+  EXPECT_EQ(req.getBody(), data);
+  HttpResponse resp = req.execute();
+  EXPECT_TRUE(resp.is_ok());
+  EXPECT_EQ(resp.status(), 200);
+	EXPECT_THAT(resp.body(), testing::HasSubstr(data));
+}
+