Fixed tests for HearthstoneApi

3 files changed, 51 insertions, 52 deletions

diff --git a/battleNetApi/src/apiUrl.cpp b/battleNetApi/src/apiUrl.cpp
index fa07372..5ef109c 100644
--- a/battleNetApi/src/apiUrl.cpp
+++ b/battleNetApi/src/apiUrl.cpp
@@ -2,6 +2,20 @@
 #include <cstdint>
 #include <format>
 
+namespace bnet {
+namespace {
+std::string gamemodeToString(const GameMode &iGameMode) {
+    switch (iGameMode) {
+    case GameMode::constructed:
+        return "constructed";
+    case GameMode::battlegrounds:
+        return "battlegrounds";
+    case GameMode::mercenaries:
+        return "mercenaries";
+    }
+}
+}; // namespace
+
 ApiUrl::ApiUrl(const std::string &iContentType, const std::string &iRegion)
     : mContentType{iContentType}, mRegion{iRegion} {}
 void ApiUrl::setRegion(const std::string &iRegion) {
@@ -16,13 +30,11 @@ void ApiUrl::setLocale(const std::string &iLocale) {
         setValue(kLOCALE_KEY, iLocale);
     }
 }
-void ApiUrl::setGameMode(const std::string &iGameMode) {
-    if (not iGameMode.empty()) {
-        //!< A recognized game mode, e.g. "constructed"
-        //!< @see
-        //!< https://community.developer.battle.net/documentation/hearthstone/guides/game-modes
-        setValue(kGAME_MODE_KEY, iGameMode);
-    }
+void ApiUrl::setGameMode(const GameMode &iGameMode) {
+    //!< A recognized game mode, e.g. "constructed"
+    //!< @see
+    //!< https://community.developer.battle.net/documentation/hearthstone/guides/game-modes
+    setValue(kGAME_MODE_KEY, gamemodeToString(iGameMode));
 }
 void ApiUrl::setPage(const std::string &iPage) {
     if (not iPage.empty()) {
@@ -31,14 +43,8 @@ void ApiUrl::setPage(const std::string &iPage) {
     }
 }
 void ApiUrl::setPage(uint64_t iPage) { setPage(std::to_string(iPage)); }
-void ApiUrl::setPageSize(const std::string &iPageSize) {
-    if (not iPageSize.empty()) {
-        //!< The number of results to choose per page, e.g. "40"
-        setValue(kPAGE_SIZE_KEY, iPageSize);
-    }
-}
 void ApiUrl::setPageSize(uint64_t iPageSize) {
-    return setPageSize(std::to_string(iPageSize));
+    setValue(kPAGE_SIZE_KEY, std::to_string(iPageSize));
 }
 bool ApiUrl::hasLocale() const { return hasValue(kLOCALE_KEY); }
 bool ApiUrl::hasGameMode() const { return hasValue(kGAME_MODE_KEY); }
@@ -47,9 +53,7 @@ bool ApiUrl::hasPageSize() const { return hasValue(kPAGE_SIZE_KEY); }
 void ApiUrl::setValue(const std::string &iKey, const std::string &iValue) {
     aParameters[iKey] = iValue;
 }
-bool ApiUrl::hasValue(const std::string &iKey) const {
-    return aParameters.count(iKey) > 0;
-}
+bool ApiUrl::hasValue(const std::string &iKey) const { return aParameters.count(iKey) > 0; }
 std::string ApiUrl::text() const {
     std::string aFormattedParameters;
     for (const auto &[key, value] : aParameters) {
@@ -58,8 +62,8 @@ std::string ApiUrl::text() const {
     if (not aFormattedParameters.empty()) {
         aFormattedParameters[0] = '?';
     }
-    aFormattedParameters =
-        std::format("https://{}.api.blizzard.com/hearthstone/{}/{}", mRegion,
-                    mContentType, aFormattedParameters);
+    aFormattedParameters = std::format("https://{}.api.blizzard.com/hearthstone/{}/{}", mRegion,
+                                       mContentType, aFormattedParameters);
     return aFormattedParameters;
 }
+}; // namespace bnet
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
diff --git a/battleNetApi/src/hearthstoneTokenBuilder.cpp b/battleNetApi/src/hearthstoneTokenBuilder.cpp
index 668aaa5..96e3aa8 100644
--- a/battleNetApi/src/hearthstoneTokenBuilder.cpp
+++ b/battleNetApi/src/hearthstoneTokenBuilder.cpp
@@ -1,3 +1,4 @@
+#include <chrono>
 #include <curl/curl.h>
 #include <fstream>
 #include <hearthstoneTokenBuilder.hpp>
@@ -69,7 +70,7 @@ bool HearthstoneTokenBuilder::isTokenValid(const json &iTokenJson) const {
     const std::uint64_t kExpirationTime{iTokenJson["Token"]["ExpirationTime"]};
     const std::uint64_t kCurrentTime{
         static_cast<std::uint64_t>(std::chrono::duration_cast<std::chrono::seconds>(
-                                       std::chrono::high_resolution_clock::now().time_since_epoch())
+                                       std::chrono::system_clock::now().time_since_epoch())
                                        .count())};
     return kCurrentTime <= kExpirationTime;
 }