Fixed tests for HearthstoneApi

1 files changed, 25 insertions, 31 deletions

diff --git a/battleNetApi/src/hearthstoneApi.cpp b/battleNetApi/src/hearthstoneApi.cpp
index 1341f74..4dd8fac 100644
--- a/battleNetApi/src/hearthstoneApi.cpp
+++ b/battleNetApi/src/hearthstoneApi.cpp
@@ -5,13 +5,14 @@
 #include <curl/multi.h>
 #include <format>
 #include <iostream>
+#include <stdexcept>
 
+namespace bnet {
 std::string HearthstoneApi::authorizationHeader(const std::string &iTokenText) {
     return std::format("Authorization: Bearer {}", iTokenText);
 }
 
-size_t HearthstoneApi::curlCallbackStringOutput(void *iContent, size_t iSize,
-                                                size_t iNmemb,
+size_t HearthstoneApi::curlCallbackStringOutput(void *iContent, size_t iSize, size_t iNmemb,
                                                 std::string *iS) {
     const size_t kNewLength = iSize * iNmemb;
     try {
@@ -23,8 +24,7 @@ size_t HearthstoneApi::curlCallbackStringOutput(void *iContent, size_t iSize,
     return kNewLength;
 }
 
-json HearthstoneApi::makeApiRequest(const ApiUrl &iApiUrl,
-                                    const std::string &iTokenText) {
+json HearthstoneApi::makeApiRequest(const ApiUrl &iApiUrl, const std::string &iTokenText) {
     CURL *curl = curl_easy_init();
     std::string aRequestOutput;
     if (curl) {
@@ -34,8 +34,7 @@ json HearthstoneApi::makeApiRequest(const ApiUrl &iApiUrl,
         curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, curlCallbackStringOutput);
         curl_easy_setopt(curl, CURLOPT_WRITEDATA, &aRequestOutput);
         struct curl_slist *chunk = nullptr;
-        chunk =
-            curl_slist_append(chunk, authorizationHeader(iTokenText).c_str());
+        chunk = curl_slist_append(chunk, authorizationHeader(iTokenText).c_str());
         curl_easy_setopt(curl, CURLOPT_HTTPHEADER, chunk);
         curl_easy_perform(curl);
         curl_easy_cleanup(curl);
@@ -44,34 +43,28 @@ json HearthstoneApi::makeApiRequest(const ApiUrl &iApiUrl,
     return aOutputJson;
 }
 
-std::vector<json>
-HearthstoneApi::makeApiRequest(const std::vector<ApiUrl> &iApiUrls,
-                               const std::string &iTokenText) {
+std::vector<json> HearthstoneApi::makeApiRequest(const std::vector<ApiUrl> &iApiUrls,
+                                                 const std::string &iTokenText) {
     std::vector<std::string> aApiUrls(iApiUrls.size());
-    std::ranges::transform(
-        iApiUrls, aApiUrls.begin(),
-        [](const ApiUrl &iApiUrl) { return iApiUrl.text(); });
+    std::ranges::transform(iApiUrls, aApiUrls.begin(),
+                           [](const ApiUrl &iApiUrl) { return iApiUrl.text(); });
     return makeApiRequest(aApiUrls, iTokenText);
 }
 
-std::vector<json>
-HearthstoneApi::makeApiRequest(const std::vector<std::string> &iUrls,
-                               const std::string &iTokenText) {
+std::vector<json> HearthstoneApi::makeApiRequest(const std::vector<std::string> &iUrls,
+                                                 const std::string &iTokenText) {
     std::vector<std::string> aResponses(iUrls.size());
     CURLM *curlm = curl_multi_init();
     if (curlm) {
-        for (std::vector<std::string>::size_type i{0}; i < aResponses.size();
-             ++i) {
+        for (std::vector<std::string>::size_type i{0}; i < aResponses.size(); ++i) {
             CURL *curl = curl_easy_init();
             curl_easy_setopt(curl, CURLOPT_URL, iUrls[i].c_str());
             curl_easy_setopt(curl, CURLOPT_SSL_VERIFYPEER, 0L);
             curl_easy_setopt(curl, CURLOPT_SSL_VERIFYHOST, 0L);
-            curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION,
-                             curlCallbackStringOutput);
+            curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, curlCallbackStringOutput);
             curl_easy_setopt(curl, CURLOPT_WRITEDATA, &(aResponses[i]));
             struct curl_slist *chunk = nullptr;
-            chunk = curl_slist_append(chunk,
-                                      authorizationHeader(iTokenText).c_str());
+            chunk = curl_slist_append(chunk, authorizationHeader(iTokenText).c_str());
             curl_easy_setopt(curl, CURLOPT_HTTPHEADER, chunk);
             curl_multi_add_handle(curlm, curl);
         }
@@ -82,8 +75,7 @@ HearthstoneApi::makeApiRequest(const std::vector<std::string> &iUrls,
             int numfds = 0;
             int res = curl_multi_wait(curlm, NULL, 0, kMaxWaitMs, &numfds);
             if (res != CURLM_OK) {
-                std::cerr << std::format(
-                    "error: curl_multi_wait() returned {}\n", res);
+                std::cerr << std::format("error: curl_multi_wait() returned {}\n", res);
             }
             curl_multi_perform(curlm, &aStillRunning);
         } while (aStillRunning);
@@ -98,17 +90,15 @@ HearthstoneApi::makeApiRequest(const std::vector<std::string> &iUrls,
                 aHandle = aMessage->easy_handle;
                 aReturnCode = aMessage->data.result;
                 if (aReturnCode != CURLE_OK) {
-                    fprintf(stderr, "CURL error code: %d\n",
-                            aMessage->data.result);
+                    fprintf(stderr, "CURL error code: %d\n", aMessage->data.result);
                     continue;
                 }
                 curl_multi_remove_handle(curlm, aHandle);
                 curl_easy_cleanup(aHandle);
                 aHandle = nullptr;
             } else {
-                std::cerr << std::format(
-                    "error: after curl_multi_info_read(), CURLMsg={}\n",
-                    static_cast<int>(aMessage->msg));
+                std::cerr << std::format("error: after curl_multi_info_read(), CURLMsg={}\n",
+                                         static_cast<int>(aMessage->msg));
             }
         }
         curl_multi_cleanup(curlm);
@@ -121,20 +111,23 @@ HearthstoneApi::makeApiRequest(const std::vector<std::string> &iUrls,
 }
 
 json HearthstoneApi::downloadCards(ApiUrl iApiUrl, const Token &iToken) {
+    if (!iToken.text().has_value() || iToken.text().value().empty()) {
+        throw std::invalid_argument("Token text does not exist or is empty");
+    }
     if (iApiUrl.hasPage()) {
-        return makeApiRequest(iApiUrl, iToken.text());
+        return makeApiRequest(iApiUrl, *iToken.text());
     }
     iApiUrl.setPage("1");
     std::vector<std::string> aRequests;
 
-    json aFirstPageJson = makeApiRequest(iApiUrl, iToken.text());
+    json aFirstPageJson = makeApiRequest(iApiUrl, *iToken.text());
     int kNumberOfPages{aFirstPageJson["pageCount"]};
     for (int i{1}; i < kNumberOfPages; ++i) {
         iApiUrl.setPage(std::to_string(i + 1));
         aRequests.push_back(iApiUrl.text());
     }
     json::reference &aOutputJson = aFirstPageJson["cards"];
-    std::vector<json> kApiResponses = makeApiRequest(aRequests, iToken.text());
+    std::vector<json> kApiResponses = makeApiRequest(aRequests, *iToken.text());
     for (json &aPage : kApiResponses) {
         for (json::reference &aCard : aPage["cards"]) {
             aOutputJson.push_back(std::move(aCard));
@@ -142,3 +135,4 @@ json HearthstoneApi::downloadCards(ApiUrl iApiUrl, const Token &iToken) {
     }
     return aOutputJson;
 }
+}; // namespace bnet