- Renamed HttpClientInterface to HttpClientBase

- Added validation for Json parsing of connection config file.
- Cleaned up error messages and exceptions.

Author: avalerio-tkd

CMakeLists.txt

@@ -160,7 +160,7 @@ target_link_libraries(dbps_server_lib PUBLIC OpenSSL::SSL OpenSSL::Crypto)
 # Client components library (depends on httplib, nlohmann/json, and cppcodec)
 add_library(dbps_client_lib STATIC 
   src/client/dbps_api_client.cpp
-  src/client/http_client_interface.cpp
+  src/client/http_client_base.cpp
   src/client/httplib_client.cpp
   src/client/httplib_pool_registry.cpp
   src/client/httplib_pooled_client.cpp
@@ -366,8 +366,8 @@ if(BUILD_TESTS)
   )
 
   # Http client interface tests
-  add_executable(http_client_interface_test src/client/http_client_interface_test.cpp)
-  target_link_libraries(http_client_interface_test
+  add_executable(http_client_base_test src/client/http_client_base_test.cpp)
+  target_link_libraries(http_client_base_test
     dbps_client_lib
     dbps_common_lib
     gtest_main
@@ -402,7 +402,7 @@ if(BUILD_SHARED_LIBS)
     src/common/dbps_remote_shared_lib_wrapper.cpp
     src/common/dbpa_remote.cpp
     src/client/dbps_api_client.cpp
-    src/client/http_client_interface.cpp
+    src/client/http_client_base.cpp
     src/client/httplib_client.cpp
     src/common/json_request.cpp
   )
@@ -506,7 +506,7 @@ if(BUILD_TESTS)
       dbpa_local_test
       httplib_pool_registry_test
       httplib_pooled_client_test
-      http_client_interface_test
+      http_client_base_test
     COMMENT "Building all tests"
   )
 
@@ -528,7 +528,7 @@ if(BUILD_TESTS)
   gtest_discover_tests(dbpa_local_test)
   gtest_discover_tests(httplib_pool_registry_test)
   gtest_discover_tests(httplib_pooled_client_test)
-  gtest_discover_tests(http_client_interface_test)
+  gtest_discover_tests(http_client_base_test)
 endif()
 
 # All target (everything)

src/client/dbps_api_client.cpp

@@ -159,7 +159,7 @@ void DecryptApiResponse::SetJsonRequest(const DecryptJsonRequest& request) { jso
 bool DecryptApiResponse::HasJsonRequest() const { return json_request_.has_value(); }
 const JsonRequest& DecryptApiResponse::GetJsonRequest() const { return json_request_.value(); }
 
-DBPSApiClient::DBPSApiClient(std::shared_ptr<HttpClientInterface> http_client)
+DBPSApiClient::DBPSApiClient(std::shared_ptr<HttpClientBase> http_client)
     : http_client_(std::move(http_client)) {
 }
 

src/client/dbps_api_client.h

@@ -26,7 +26,7 @@
 #include "../common/enum_utils.h"
 #include "../common/json_request.h"
 #include "tcb/span.hpp"
-#include "http_client_interface.h"
+#include "http_client_base.h"
 
 using namespace dbps::external;
 using namespace dbps::enum_utils;
@@ -143,7 +143,7 @@ class DBPSApiClient {
      * The HTTP client is expected to be thread-safe.
      * @param http_client Custom HTTP client implementation
      */
-    explicit DBPSApiClient(std::shared_ptr<HttpClientInterface> http_client);
+    explicit DBPSApiClient(std::shared_ptr<HttpClientBase> http_client);
 
     /**
      * Destructor
@@ -223,5 +223,5 @@ class DBPSApiClient {
     );
 
 private:
-    const std::shared_ptr<HttpClientInterface> http_client_;
+    const std::shared_ptr<HttpClientBase> http_client_;
 };

src/client/dbps_api_client_test.cpp

@@ -22,7 +22,7 @@
 #include <algorithm>
 #include "tcb/span.hpp"
 #include "dbps_api_client.h"
-#include "http_client_interface.h"
+#include "http_client_base.h"
 #include "../common/enums.h"
 #include <nlohmann/json.hpp>
 #include <gtest/gtest.h>
@@ -56,10 +56,10 @@ bool CompareJsonStrings(const std::string& json1, const std::string& json2, cons
 }
 
 // Mock HTTP client for testing
-class MockHttpClient : public HttpClientInterface {
+class MockHttpClient : public HttpClientBase {
 public:
     MockHttpClient()
-        : HttpClientInterface(
+        : HttpClientBase(
               "mock://",
               ClientCredentials{{"client_id", "test_client_AAAA"}, {"api_key", "test_key_AAAA"}}) {
     }
@@ -310,7 +310,7 @@ TEST(DBPSApiClient, EncryptWithValidData) {
     })";
 
     mock_client->SetMockPostResponse("/encrypt", expected_request, 
-        HttpClientInterface::HttpResponse(200, mock_response));
+        HttpClientBase::HttpResponse(200, mock_response));
 
     // Create DBPSApiClient with mock client
     DBPSApiClient client(std::move(mock_client));
@@ -402,7 +402,7 @@ TEST(DBPSApiClient, DecryptWithValidData) {
     })";
 
     mock_client->SetMockPostResponse("/decrypt", expected_request, 
-        HttpClientInterface::HttpResponse(200, mock_response));
+        HttpClientBase::HttpResponse(200, mock_response));
 
     // Create DBPSApiClient with mock client
     DBPSApiClient client(std::move(mock_client));
@@ -545,7 +545,7 @@ TEST(DBPSApiClient, EncryptWithInvalidJsonResponse) {
     })";
 
     mock_client->SetMockPostResponse("/encrypt", expected_request, 
-        HttpClientInterface::HttpResponse(200, mock_response));
+        HttpClientBase::HttpResponse(200, mock_response));
 
     // Create DBPSApiClient with mock client
     DBPSApiClient client(std::move(mock_client));
@@ -611,7 +611,7 @@ TEST(DBPSApiClient, DecryptWithInvalidJsonResponse) {
     })";
 
     mock_client->SetMockPostResponse("/decrypt", expected_request, 
-        HttpClientInterface::HttpResponse(200, mock_response));
+        HttpClientBase::HttpResponse(200, mock_response));
 
     // Create DBPSApiClient with mock client
     DBPSApiClient client(std::move(mock_client));
@@ -688,7 +688,7 @@ TEST(DBPSApiClient, EncryptWithEncodingAttributes) {
     })";
 
     mock_client->SetMockPostResponse("/encrypt", expected_request, 
-        HttpClientInterface::HttpResponse(200, mock_response));
+        HttpClientBase::HttpResponse(200, mock_response));
 
     // Create DBPSApiClient with mock client
     DBPSApiClient client(std::move(mock_client));

src/client/http_client_base.cpp

@@ -15,28 +15,28 @@
 // specific language governing permissions and limitations
 // under the License.
 
-#include "http_client_interface.h"
+#include "http_client_base.h"
 
 #include <chrono>
 
 #include "json_request.h"
 
-HttpClientInterface::HeaderList HttpClientInterface::DefaultJsonGetHeaders() {
+HttpClientBase::HeaderList HttpClientBase::DefaultJsonGetHeaders() {
     HeaderList headers;
     headers.insert({"Accept", kJsonContentType});
     headers.insert({"User-Agent", kDefaultUserAgent});
     return headers;
 }
 
-HttpClientInterface::HeaderList HttpClientInterface::DefaultJsonPostHeaders() {
+HttpClientBase::HeaderList HttpClientBase::DefaultJsonPostHeaders() {
     HeaderList headers;
     headers.insert({"Content-Type", kJsonContentType});
     headers.insert({"Accept", kJsonContentType});
     headers.insert({"User-Agent", kDefaultUserAgent});
     return headers;
 }
 
-HttpClientInterface::HttpResponse HttpClientInterface::Get(const std::string& endpoint, bool auth_required) {
+HttpClientBase::HttpResponse HttpClientBase::Get(const std::string& endpoint, bool auth_required) {
     const auto attempt = [&]() -> HttpResponse {
         auto headers = DefaultJsonGetHeaders();
         if (auth_required) {
@@ -56,7 +56,7 @@ HttpClientInterface::HttpResponse HttpClientInterface::Get(const std::string& en
     return result;
 }
 
-HttpClientInterface::HttpResponse HttpClientInterface::Post(const std::string& endpoint,
+HttpClientBase::HttpResponse HttpClientBase::Post(const std::string& endpoint,
                                                             const std::string& json_body,
                                                             bool auth_required) {
     const auto attempt = [&]() -> HttpResponse {
@@ -78,7 +78,7 @@ HttpClientInterface::HttpResponse HttpClientInterface::Post(const std::string& e
     return result;
 }
 
-std::string HttpClientInterface::AddAuthorizationHeader(HeaderList& headers) {
+std::string HttpClientBase::AddAuthorizationHeader(HeaderList& headers) {
     std::string token_or_error;
     auto token_opt = EnsureValidToken(token_or_error);
     if (!token_opt.has_value()) {
@@ -95,7 +95,7 @@ std::string HttpClientInterface::AddAuthorizationHeader(HeaderList& headers) {
     return "";
 }
 
-std::optional<HttpClientInterface::CachedToken> HttpClientInterface::EnsureValidToken(std::string& error) {
+std::optional<HttpClientBase::CachedToken> HttpClientBase::EnsureValidToken(std::string& error) {
 
     const auto now_epoch_seconds = []() -> std::int64_t {
         const auto now = std::chrono::system_clock::now();
@@ -140,7 +140,7 @@ std::optional<HttpClientInterface::CachedToken> HttpClientInterface::EnsureValid
     return fetched;
 }
 
-std::optional<HttpClientInterface::CachedToken> HttpClientInterface::FetchToken(std::string& error) {
+std::optional<HttpClientBase::CachedToken> HttpClientBase::FetchToken(std::string& error) {
     error.clear();
     TokenRequest token_req;
     token_req.credential_values_ = credentials_;
@@ -169,7 +169,7 @@ std::optional<HttpClientInterface::CachedToken> HttpClientInterface::FetchToken(
     return result;
 }
 
-void HttpClientInterface::InvalidateCachedToken() {
+void HttpClientBase::InvalidateCachedToken() {
     std::lock_guard<std::mutex> lock(token_mutex_);
     cached_token_ = std::nullopt;
 }

src/client/http_client_base.h

@@ -31,9 +31,9 @@
  * Thread Safety: Implementations must be thread-safe for concurrent calls.
  * Multiple threads may call Get() and Post() methods simultaneously on the same instance.
  */
-class HttpClientInterface {
+class HttpClientBase {
 public:
-    virtual ~HttpClientInterface() = default;
+    virtual ~HttpClientBase() = default;
 
     using ClientCredentials = std::map<std::string, std::string>;
     using HeaderList = httplib::Headers;
@@ -61,7 +61,7 @@ class HttpClientInterface {
     HttpResponse Post(const std::string& endpoint, const std::string& json_body, bool auth_required = true);
 
 protected:
-    explicit HttpClientInterface(std::string base_url,
+    explicit HttpClientBase(std::string base_url,
                                  ClientCredentials credentials = {})
         : base_url_(std::move(base_url)),
           credentials_(std::move(credentials)) {

src/client/http_client_base_test.cpp

@@ -21,12 +21,12 @@
 #include <string>
 #include <vector>
 
-#include "http_client_interface.h"
+#include "http_client_base.h"
 
-class FakeHttpClient final : public HttpClientInterface {
+class FakeHttpClient final : public HttpClientBase {
 public:
     explicit FakeHttpClient(ClientCredentials credentials)
-        : HttpClientInterface("mock://", std::move(credentials)) {
+        : HttpClientBase("mock://", std::move(credentials)) {
     }
 
     void SetTokenResponse(std::string token, std::string token_type, std::int64_t expires_at) {
@@ -104,15 +104,15 @@ class FakeHttpClient final : public HttpClientInterface {
     std::int64_t expires_at_ = 4102444800; // 2100-01-01T00:00:00Z
 };
 
-TEST(HttpClientInterfaceTest, AuthRequiredDefaultFetchesTokenAndAddsAuthorizationHeader) {
+TEST(HttpClientBaseTest, AuthRequiredDefaultFetchesTokenAndAddsAuthorizationHeader) {
     FakeHttpClient client({{"client_id", "clientA"}, {"api_key", "keyA"}});
     client.SetTokenResponse("abc", "Bearer", 4102444800);
 
     auto r1 = client.Get("/statusz");
     ASSERT_TRUE(r1.error_message.empty());
     ASSERT_EQ(r1.status_code, 200);
 
-    auto auth_it = client.last_get_headers.find(HttpClientInterface::kAuthorizationHeader);
+    auto auth_it = client.last_get_headers.find(HttpClientBase::kAuthorizationHeader);
     ASSERT_NE(auth_it, client.last_get_headers.end());
     ASSERT_EQ(auth_it->second, "Bearer abc");
 
@@ -124,31 +124,31 @@ TEST(HttpClientInterfaceTest, AuthRequiredDefaultFetchesTokenAndAddsAuthorizatio
     ASSERT_EQ(client.get_calls.load(), 2);
 }
 
-TEST(HttpClientInterfaceTest, AuthRequiredFalseDoesNotFetchTokenOrSendAuthorizationHeader) {
+TEST(HttpClientBaseTest, AuthRequiredFalseDoesNotFetchTokenOrSendAuthorizationHeader) {
     FakeHttpClient client({{"client_id", "clientA"}, {"api_key", "keyA"}});
 
     auto r = client.Get("/healthz", false);
     ASSERT_TRUE(r.error_message.empty());
     ASSERT_EQ(r.status_code, 200);
     ASSERT_EQ(client.token_calls.load(), 0);
     ASSERT_EQ(client.get_calls.load(), 1);
-    ASSERT_EQ(client.last_get_headers.find(HttpClientInterface::kAuthorizationHeader),
+    ASSERT_EQ(client.last_get_headers.find(HttpClientBase::kAuthorizationHeader),
               client.last_get_headers.end());
 }
 
-TEST(HttpClientInterfaceTest, UsesTokenTypeFromTokenResponse) {
+TEST(HttpClientBaseTest, UsesTokenTypeFromTokenResponse) {
     FakeHttpClient client({{"client_id", "clientA"}, {"api_key", "keyA"}});
     client.SetTokenResponse("xyz", "JWT", 4102444800);
 
     auto r = client.Get("/statusz");
     ASSERT_TRUE(r.error_message.empty());
 
-    auto auth_it = client.last_get_headers.find(HttpClientInterface::kAuthorizationHeader);
+    auto auth_it = client.last_get_headers.find(HttpClientBase::kAuthorizationHeader);
     ASSERT_NE(auth_it, client.last_get_headers.end());
     ASSERT_EQ(auth_it->second, "JWT xyz");
 }
 
-TEST(HttpClientInterfaceTest, RetryOnceOn401FetchesNewTokenAndRetries) {
+TEST(HttpClientBaseTest, RetryOnceOn401FetchesNewTokenAndRetries) {
     FakeHttpClient client({{"client_id", "clientA"}, {"api_key", "keyA"}});
     client.SetTokenResponses({
         {"t1", "Bearer", 4102444800},
@@ -164,8 +164,8 @@ TEST(HttpClientInterfaceTest, RetryOnceOn401FetchesNewTokenAndRetries) {
     ASSERT_EQ(client.get_calls.load(), 2);
 
     ASSERT_GE(client.get_headers_history.size(), 2u);
-    auto auth1 = client.get_headers_history[0].find(HttpClientInterface::kAuthorizationHeader);
-    auto auth2 = client.get_headers_history[1].find(HttpClientInterface::kAuthorizationHeader);
+    auto auth1 = client.get_headers_history[0].find(HttpClientBase::kAuthorizationHeader);
+    auto auth2 = client.get_headers_history[1].find(HttpClientBase::kAuthorizationHeader);
     ASSERT_NE(auth1, client.get_headers_history[0].end());
     ASSERT_NE(auth2, client.get_headers_history[1].end());
     ASSERT_EQ(auth1->second, "Bearer t1");

src/client/httplib_client.cpp

@@ -18,10 +18,10 @@
 #include "httplib_client.h"
 
 HttplibClient::HttplibClient(const std::string& base_url, ClientCredentials credentials)
-    : HttpClientInterface(base_url, std::move(credentials)) {
+    : HttpClientBase(base_url, std::move(credentials)) {
 }
 
-HttpClientInterface::HttpResponse HttplibClient::DoGet(const std::string& endpoint, const HeaderList& headers) {
+HttpClientBase::HttpResponse HttplibClient::DoGet(const std::string& endpoint, const HeaderList& headers) {
     try {
         httplib::Client client(base_url_);
 
@@ -42,15 +42,15 @@ HttpClientInterface::HttpResponse HttplibClient::DoGet(const std::string& endpoi
     }
 }
 
-HttpClientInterface::HttpResponse HttplibClient::DoPost(const std::string& endpoint, const std::string& json_body, const HeaderList& headers) {
+HttpClientBase::HttpResponse HttplibClient::DoPost(const std::string& endpoint, const std::string& json_body, const HeaderList& headers) {
     try {
         httplib::Client client(base_url_);
 
         client.set_connection_timeout(10);
         client.set_read_timeout(30);
 
         // Make the POST request
-        auto result = client.Post(endpoint, headers, json_body, HttpClientInterface::kJsonContentType);
+        auto result = client.Post(endpoint, headers, json_body, HttpClientBase::kJsonContentType);
 
         if (!result) {
             return HttpResponse(0, "", "HTTP POST request failed: no response received");

src/client/httplib_client.h

@@ -17,16 +17,16 @@
 
 #pragma once
 
-#include "http_client_interface.h"
+#include "http_client_base.h"
 #include <httplib.h>
 
-class HttplibClient : public HttpClientInterface {
+class HttplibClient : public HttpClientBase {
 public:
     /**
      * Constructs an HTTP client for a given base URL.
      *
      * @param base_url The base URL (e.g., "http://127.0.0.1:18080")
-     * @param credentials Authentication key/value map used by HttpClientInterface to request JWTs from /token
+     * @param credentials Authentication key/value map used by HttpClientBase to request JWTs from /token
      */
     explicit HttplibClient(
         const std::string& base_url,
@@ -37,7 +37,7 @@ class HttplibClient : public HttpClientInterface {
      * Transport implementation for an HTTP GET to the specified endpoint.
      *
      * @param endpoint The endpoint path to request (e.g., "/healthz")
-     * @param headers Fully prepared headers from HttpClientInterface (may include Authorization)
+     * @param headers Fully prepared headers from HttpClientBase (may include Authorization)
      * @return HttpResponse containing status code, response body, and any error message
      *
      * @note Connections are not reused - a new connection is established for each request
@@ -50,7 +50,7 @@ class HttplibClient : public HttpClientInterface {
      *
      * @param endpoint The endpoint path to request (e.g., "/encrypt")
      * @param json_body The JSON payload to send in the request body
-     * @param headers Fully prepared headers from HttpClientInterface (may include Authorization)
+     * @param headers Fully prepared headers from HttpClientBase (may include Authorization)
      * @return HttpResponse containing status code, response body, and any error message
      *
      * @note Connections are not reused - a new connection is established for each request