Added test file for Token

2 files changed, 46 insertions, 56 deletions

diff --git a/battleNetApi/src/hearthstoneTokenBuilder.cpp b/battleNetApi/src/hearthstoneTokenBuilder.cpp
index 8403f46..9509aa6 100644
--- a/battleNetApi/src/hearthstoneTokenBuilder.cpp
+++ b/battleNetApi/src/hearthstoneTokenBuilder.cpp
@@ -1,29 +1,20 @@
+#include <algorithm>
 #include <curl/curl.h>
+#include <fstream>
 #include <hearthstoneTokenBuilder.hpp>
 #include <iostream>
 #include <memory>
 
-HearthstoneTokenBuilder::HearthstoneTokenBuilder(const std::string &iJsonPath) {
-    mJsonPaths.push_back(iJsonPath);
-}
-HearthstoneTokenBuilder::HearthstoneTokenBuilder(
-    const std::span<std::string> &iJsonPaths) {
-    mJsonPaths.append_range(iJsonPaths);
-}
-HearthstoneTokenBuilder &
-HearthstoneTokenBuilder::addJsonPath(const std::string &iJsonPath) {
-    mJsonPaths.push_back(iJsonPath);
-    return *this;
-}
-HearthstoneTokenBuilder &
-HearthstoneTokenBuilder::addJsonPaths(const std::string &iJsonPath) {
-    mJsonPaths.push_back(iJsonPath);
-    return *this;
+HearthstoneTokenBuilder::HearthstoneTokenBuilder(const std::span<std::string> &iJsonPaths) {
+    _credentialJsonPaths.append_range(iJsonPaths);
 }
 HearthstoneTokenBuilder &HearthstoneTokenBuilder::buildToken() {
+    std::ranges::find_if(_credentialJsonPaths,
+                         [](const std::string &iCredentialJsonPath) { return true; });
     if (hasExpired()) {
-        const std::pair<std::string, std::uint64_t> kTokenContent{
-            getTokenWithApi()};
+        if (isUpdateSourceFileAllowed()) {
+        }
+        const std::pair<std::string, std::uint64_t> kTokenContent{getTokenWithApi()};
         writeTokenToLocalFile(kTokenContent);
     }
     // return getTokenFromLocalFile();
@@ -35,38 +26,31 @@ HearthstoneTokenBuilder &HearthstoneTokenBuilder::buildToken() {
     // mCurrentToken = std::make_unique<Token>(...);
     return *this;
 }
-std::shared_ptr<Token> HearthstoneTokenBuilder::getToken() {
-    return mCurrentToken;
-}
+std::shared_ptr<Token> HearthstoneTokenBuilder::getToken() { return mCurrentToken; }
 HearthstoneTokenBuilder &HearthstoneTokenBuilder::allowUpdateSourceFile() {
     mUpdateSourceFile = true;
     return *this;
 }
-bool HearthstoneTokenBuilder::isUpdateSourceFileAllowed() const {
-    return mUpdateSourceFile;
-}
+bool HearthstoneTokenBuilder::isUpdateSourceFileAllowed() const { return mUpdateSourceFile; }
 
-const bool HearthstoneTokenBuilder::hasExpired(json iCredentials) const {
-    if (not iCredentials.contains("Token") or
-        not iCredentials["Token"].contains("ExpirationTime") or
-        not iCredentials["Token"].contains("Content")) {
+const bool HearthstoneTokenBuilder::hasExpired(json iTokenJson) const {
+    if (not iTokenJson.contains("Token") or not iTokenJson["Token"].contains("ExpirationTime") or
+        not iTokenJson["Token"].contains("Content")) {
         return true;
     }
-    if (iCredentials["Token"]["Content"].dump().length() <
-        kTOKEN_CONTENT_MIN_LENGTH) {
+    if (iTokenJson["Token"]["Content"].dump().length() < kTOKEN_CONTENT_MIN_LENGTH) {
         return true;
     }
-    const std::uint64_t kExpirationTime{
-        iCredentials["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())
-            .count())};
+    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())
+                                       .count())};
     return kCurrentTime >= kExpirationTime;
 }
 
-size_t HearthstoneTokenBuilder::curlCallbackStringOutput(
-    void *iPtr, size_t iSize, size_t iNmemb, std::string *iUserData) {
+size_t HearthstoneTokenBuilder::curlCallbackStringOutput(void *iPtr, size_t iSize, size_t iNmemb,
+                                                         std::string *iUserData) {
     size_t newLength{iSize * iNmemb};
     try {
         iUserData->append(static_cast<char *>(iPtr), newLength);
@@ -83,11 +67,10 @@ std::chrono::seconds HearthstoneTokenBuilder::getCurrentTime() const {
 }
 
 std::pair<std::string, std::uint64_t>
-HearthstoneTokenBuilder::getTokenWithApi() const {
-    std::ifstream aCredentialsFile{mFilePath};
-    json aCredentials = json::parse(aCredentialsFile);
-    if (not aCredentials.contains("Agent") or
-        not aCredentials["Agent"].contains("Username") or
+HearthstoneTokenBuilder::getTokenWithApi(const std::string &iAgentJsonFilePath) const {
+    std::ifstream aAgentJsonFile{iAgentJsonFilePath};
+    json aCredentials = json::parse(aAgentJsonFile);
+    if (not aCredentials.contains("Agent") or not aCredentials["Agent"].contains("Username") or
         not aCredentials["Agent"].contains("Password")) {
         std::cerr << "Please define Agent/Username and Agent/Password in the "
                      "JSON credentials file\n";
@@ -101,18 +84,15 @@ HearthstoneTokenBuilder::getTokenWithApi() const {
         curl_easy_setopt(aCurl, CURLOPT_URL, "https://oauth.battle.net/token");
         curl_easy_setopt(aCurl, CURLOPT_SSL_VERIFYPEER, 0L);
         curl_easy_setopt(aCurl, CURLOPT_SSL_VERIFYHOST, 0L);
-        curl_easy_setopt(aCurl, CURLOPT_WRITEFUNCTION,
-                         curlCallbackStringOutput);
+        curl_easy_setopt(aCurl, CURLOPT_WRITEFUNCTION, curlCallbackStringOutput);
         curl_easy_setopt(aCurl, CURLOPT_WRITEDATA, &aTokenInfo);
-        curl_easy_setopt(
-            aCurl, CURLOPT_USERPWD,
-            std::format("{}:{}", kAgentUsername, kAgentPassword).data());
-        curl_easy_setopt(aCurl, CURLOPT_POSTFIELDS,
-                         "grant_type=client_credentials");
+        curl_easy_setopt(aCurl, CURLOPT_USERPWD,
+                         std::format("{}:{}", kAgentUsername, kAgentPassword).data());
+        curl_easy_setopt(aCurl, CURLOPT_POSTFIELDS, "grant_type=client_credentials");
         CURLcode result_code{curl_easy_perform(aCurl)};
         curl_easy_cleanup(aCurl);
         if (result_code != CURLE_OK) {
-            std::cerr << "ERROR: token request failed" << std::endl;
+            std::cerr << "ERROR: token request failed\n";
             std::exit(EXIT_FAILURE);
         }
     }
@@ -131,8 +111,8 @@ void HearthstoneTokenBuilder::writeTokenToLocalFile(
     json aCredentialsFile = json::parse(aTokenFileInput);
     aCredentialsFile["Token"]["Content"] = iToken.first;
     aCredentialsFile["Token"]["ExpirationTime"] =
-        std::chrono::duration_cast<std::chrono::seconds>(
-            getCurrentTime() + std::chrono::seconds(iToken.second))
+        std::chrono::duration_cast<std::chrono::seconds>(getCurrentTime() +
+                                                         std::chrono::seconds(iToken.second))
             .count();
 
     std::ofstream aTokenFileOutput{mFilePath};
diff --git a/battleNetApi/src/token.cpp b/battleNetApi/src/token.cpp
index b312cc1..6fcef1a 100644
--- a/battleNetApi/src/token.cpp
+++ b/battleNetApi/src/token.cpp
@@ -1,7 +1,17 @@
 #include "token.hpp"
 
-Token::Token(const std::string &iTokenText) : mTokenText{iTokenText} {}
+Token::Token(const std::string &iTokenText, const std::chrono::seconds &iExpirationTime)
+    : _tokenText{iTokenText}, _expirationTime{iExpirationTime} {}
 
-std::string Token::text() const { return mTokenText; }
+std::string Token::text() const { return _tokenText; }
 
-void Token::setText(const std::string &iTokenText) { mTokenText = iTokenText; }
+void Token::setText(const std::string &iTokenText) { _tokenText = iTokenText; }
+
+void Token::setExpirationTime(const std::chrono::seconds &iExpirationTime) {
+    _expirationTime = iExpirationTime;
+}
+
+bool Token::isExpired() {
+    return _expirationTime <= std::chrono::duration_cast<std::chrono::seconds>(
+                                  std::chrono::steady_clock::now().time_since_epoch());
+}