fix: fixes tests after adding https_enabled option

wazuh · Oct 1, 2024 · 11e84f6 · 11e84f6
1 parent 1b00ad7
commit 11e84f6
Show file tree

Hide file tree

Showing 7 changed files with 73 additions and 42 deletions.
diff --git a/src/agent/communicator/include/ihttp_socket_factory.hpp b/src/agent/communicator/include/ihttp_socket_factory.hpp
@@ -12,6 +12,7 @@ namespace http_client
     {
     public:
         virtual ~IHttpSocketFactory() = default;
-        virtual std::unique_ptr<IHttpSocket> Create(const boost::asio::any_io_executor& executor, const bool use_https) = 0;
+        virtual std::unique_ptr<IHttpSocket> Create(
+            const boost::asio::any_io_executor& executor, const bool use_https) = 0;
     };
 } // namespace http_client
diff --git a/src/agent/communicator/tests/communicator_test.cpp b/src/agent/communicator/tests/communicator_test.cpp
@@ -80,12 +80,13 @@ TEST(CommunicatorTest, WaitForTokenExpirationAndAuthenticate_FailedAuthenticatio
         std::make_shared<communicator::Communicator>(std::move(mockHttpClient), "uuid", "key", nullptr);
 
     // A failed authentication won't return a token
-    EXPECT_CALL(*mockHttpClientPtr, AuthenticateWithUuidAndKey(_, _, _, _))
+    EXPECT_CALL(*mockHttpClientPtr, AuthenticateWithUuidAndKey(_, _, _, _, _))
         .WillOnce(Invoke(
             [communicatorPtr]([[maybe_unused]] const std::string& host,
                               [[maybe_unused]] const std::string& port,
                               [[maybe_unused]] const std::string& uuid,
-                              [[maybe_unused]] const std::string& key) -> std::optional<std::string>
+                              [[maybe_unused]] const std::string& key,
+                              [[maybe_unused]] const bool useHttps) -> std::optional<std::string>
             {
                 communicatorPtr->Stop();
                 return std::nullopt;
@@ -138,7 +139,7 @@ TEST(CommunicatorTest, StatelessMessageProcessingTask_CallsWithValidToken)
         std::make_shared<communicator::Communicator>(std::move(mockHttpClient), "uuid", "key", nullptr);
 
     const auto mockedToken = CreateToken();
-    EXPECT_CALL(*mockHttpClientPtr, AuthenticateWithUuidAndKey(_, _, _, _)).WillOnce(Return(mockedToken));
+    EXPECT_CALL(*mockHttpClientPtr, AuthenticateWithUuidAndKey(_, _, _, _, _)).WillOnce(Return(mockedToken));
 
     std::string capturedToken;
     EXPECT_CALL(*mockHttpClientPtr, Co_PerformHttpRequest(_, _, _, _, _, _))

diff --git a/src/agent/communicator/tests/http_client_test.cpp b/src/agent/communicator/tests/http_client_test.cpp
@@ -42,9 +42,10 @@ class HttpClientTest : public Test
 
     void SetupMockSocketFactory()
     {
-        EXPECT_CALL(*mockSocketFactory, Create(_))
+        EXPECT_CALL(*mockSocketFactory, Create(_, _))
             .WillOnce(Invoke(
-                [&](const auto& executor) -> std::unique_ptr<http_client::IHttpSocket>
+                [&](const auto& executor,
+                    [[maybe_unused]] const bool useHttps) -> std::unique_ptr<http_client::IHttpSocket>
                 {
                     EXPECT_TRUE(executor);
                     return std::move(mockSocket);
@@ -54,10 +55,10 @@ class HttpClientTest : public Test
     void SetupMockResolverExpectations()
     {
         EXPECT_CALL(*mockResolver, AsyncResolve(_, _))
-            .WillOnce(
-                Invoke([](const std::string&,
-                          const std::string&) -> boost::asio::awaitable<boost::asio::ip::tcp::resolver::results_type>
-                       { co_return boost::asio::ip::tcp::resolver::results_type {}; }));
+            .WillOnce(Invoke(
+                [](const std::string&,
+                   const std::string&) -> boost::asio::awaitable<boost::asio::ip::tcp::resolver::results_type>
+                { co_return boost::asio::ip::tcp::resolver::results_type {}; }));
     }
 
     void SetupMockSocketConnectExpectations(boost::system::error_code connectEc = {})
@@ -106,7 +107,8 @@ class HttpClientTest : public Test
 TEST(CreateHttpRequestTest, BasicGetRequest)
 {
     auto httpClient = http_client::HttpClient();
-    const auto reqParams = http_client::HttpRequestParams(boost::beast::http::verb::get, "localhost", "8080", "/test");
+    const auto reqParams =
+        http_client::HttpRequestParams(boost::beast::http::verb::get, "localhost", "8080", "/test", true);
     const auto req = httpClient.CreateHttpRequest(reqParams);
 
     EXPECT_EQ(req.method(), boost::beast::http::verb::get);
@@ -121,8 +123,8 @@ TEST(CreateHttpRequestTest, PostRequestWithBody)
 {
     auto httpClient = http_client::HttpClient();
     const std::string body = R"({"key": "value"})";
-    const auto reqParams =
-        http_client::HttpRequestParams(boost::beast::http::verb::post, "localhost", "8080", "/submit", "", "", body);
+    const auto reqParams = http_client::HttpRequestParams(
+        boost::beast::http::verb::post, "localhost", "8080", "/submit", false, "", "", body);
     const auto req = httpClient.CreateHttpRequest(reqParams);
 
     EXPECT_EQ(req.method(), boost::beast::http::verb::post);
@@ -140,7 +142,7 @@ TEST(CreateHttpRequestTest, AuthorizationBearerToken)
     auto httpClient = http_client::HttpClient();
     const std::string token = "dummy_token";
     const auto reqParams =
-        http_client::HttpRequestParams(boost::beast::http::verb::get, "localhost", "8080", "/secure", token);
+        http_client::HttpRequestParams(boost::beast::http::verb::get, "localhost", "8080", "/secure", true, token);
     const auto req = httpClient.CreateHttpRequest(reqParams);
 
     EXPECT_EQ(req[boost::beast::http::field::authorization], "Bearer dummy_token");
@@ -150,8 +152,8 @@ TEST(CreateHttpRequestTest, AuthorizationBasic)
 {
     auto httpClient = http_client::HttpClient();
     const std::string user_pass = "username:password";
-    const auto reqParams =
-        http_client::HttpRequestParams(boost::beast::http::verb::get, "localhost", "8080", "/secure", "", user_pass);
+    const auto reqParams = http_client::HttpRequestParams(
+        boost::beast::http::verb::get, "localhost", "8080", "/secure", true, "", user_pass);
     const auto req = httpClient.CreateHttpRequest(reqParams);
 
     EXPECT_EQ(req[boost::beast::http::field::authorization], "Basic username:password");
@@ -167,7 +169,7 @@ TEST_F(HttpClientTest, PerformHttpRequest_Success)
     EXPECT_CALL(*mockSocket, Write(_)).Times(1);
     EXPECT_CALL(*mockSocket, Read(_)).WillOnce([](auto& res) { res.result(boost::beast::http::status::ok); });
 
-    const http_client::HttpRequestParams params(boost::beast::http::verb::get, "localhost", "80", "/");
+    const http_client::HttpRequestParams params(boost::beast::http::verb::get, "localhost", "80", "/", true);
     const auto response = client->PerformHttpRequest(params);
 
     EXPECT_EQ(response.result(), boost::beast::http::status::ok);
@@ -179,7 +181,7 @@ TEST_F(HttpClientTest, PerformHttpRequest_ExceptionThrown)
 
     EXPECT_CALL(*mockResolver, Resolve(_, _)).WillOnce(Throw(std::runtime_error("Simulated resolution failure")));
 
-    const http_client::HttpRequestParams params(boost::beast::http::verb::get, "localhost", "80", "/");
+    const http_client::HttpRequestParams params(boost::beast::http::verb::get, "localhost", "80", "/", true);
     const auto response = client->PerformHttpRequest(params);
 
     EXPECT_EQ(response.result(), boost::beast::http::status::internal_server_error);
@@ -216,7 +218,9 @@ TEST_F(HttpClientTest, Co_PerformHttpRequest_Success)
         unauthorizedCalled = true;
     };
 
-    const auto reqParams = http_client::HttpRequestParams(boost::beast::http::verb::get, "localhost", "8080", "/");
+    const auto reqParams =
+        http_client::HttpRequestParams(boost::beast::http::verb::get, "localhost", "8080", "/", true);
+
     auto task = client->Co_PerformHttpRequest(
         std::make_shared<std::string>("token"), reqParams, getMessages, onUnauthorized, onSuccess, nullptr);
 
@@ -256,7 +260,8 @@ TEST_F(HttpClientTest, Co_PerformHttpRequest_CallbacksNotCalledIfCannotConnect)
         unauthorizedCalled = true;
     };
 
-    const auto reqParams = http_client::HttpRequestParams(boost::beast::http::verb::get, "localhost", "8080", "/");
+    const auto reqParams =
+        http_client::HttpRequestParams(boost::beast::http::verb::get, "localhost", "8080", "/", true);
     auto task = client->Co_PerformHttpRequest(
         std::make_shared<std::string>("token"), reqParams, getMessages, onUnauthorized, onSuccess, nullptr);
 
@@ -297,7 +302,8 @@ TEST_F(HttpClientTest, Co_PerformHttpRequest_OnSuccessNotCalledIfAsyncWriteFails
         unauthorizedCalled = true;
     };
 
-    const auto reqParams = http_client::HttpRequestParams(boost::beast::http::verb::get, "localhost", "8080", "/");
+    const auto reqParams =
+        http_client::HttpRequestParams(boost::beast::http::verb::get, "localhost", "8080", "/", true);
     auto task = client->Co_PerformHttpRequest(
         std::make_shared<std::string>("token"), reqParams, getMessages, onUnauthorized, onSuccess, nullptr);
 
@@ -340,7 +346,8 @@ TEST_F(HttpClientTest, Co_PerformHttpRequest_OnSuccessNotCalledIfAsyncReadFails)
         unauthorizedCalled = true;
     };
 
-    const auto reqParams = http_client::HttpRequestParams(boost::beast::http::verb::get, "localhost", "8080", "/");
+    const auto reqParams =
+        http_client::HttpRequestParams(boost::beast::http::verb::get, "localhost", "8080", "/", true);
     auto task = client->Co_PerformHttpRequest(
         std::make_shared<std::string>("token"), reqParams, getMessages, onUnauthorized, onSuccess, nullptr);
 
@@ -382,7 +389,8 @@ TEST_F(HttpClientTest, Co_PerformHttpRequest_UnauthorizedCalledWhenAuthorization
         unauthorizedCalled = true;
     };
 
-    const auto reqParams = http_client::HttpRequestParams(boost::beast::http::verb::get, "localhost", "8080", "/");
+    const auto reqParams =
+        http_client::HttpRequestParams(boost::beast::http::verb::get, "localhost", "8080", "/", true);
     auto task = client->Co_PerformHttpRequest(
         std::make_shared<std::string>("token"), reqParams, getMessages, onUnauthorized, onSuccess, nullptr);
 
@@ -411,7 +419,7 @@ TEST_F(HttpClientTest, AuthenticateWithUuidAndKey_Success)
                 boost::beast::ostream(res.body()) << R"({"token":"valid_token"})";
             });
 
-    const auto token = client->AuthenticateWithUuidAndKey("localhost", "8080", "test-uuid", "test-key");
+    const auto token = client->AuthenticateWithUuidAndKey("localhost", "8080", "test-uuid", "test-key", true);
 
     ASSERT_TRUE(token.has_value());
 
@@ -429,7 +437,7 @@ TEST_F(HttpClientTest, AuthenticateWithUuidAndKey_Failure)
     EXPECT_CALL(*mockSocket, Write(_)).Times(1);
     EXPECT_CALL(*mockSocket, Read(_)).WillOnce([](auto& res) { res.result(boost::beast::http::status::unauthorized); });
 
-    const auto token = client->AuthenticateWithUuidAndKey("localhost", "8080", "test-uuid", "test-key");
+    const auto token = client->AuthenticateWithUuidAndKey("localhost", "8080", "test-uuid", "test-key", true);
 
     EXPECT_FALSE(token.has_value());
 }
@@ -450,7 +458,7 @@ TEST_F(HttpClientTest, AuthenticateWithUserPassword_Success)
                 boost::beast::ostream(res.body()) << R"({"data":{"token":"valid_token"}})";
             });
 
-    const auto token = client->AuthenticateWithUserPassword("localhost", "8080", "user", "password");
+    const auto token = client->AuthenticateWithUserPassword("localhost", "8080", "user", "password", true);
 
     ASSERT_TRUE(token.has_value());
 
@@ -468,7 +476,7 @@ TEST_F(HttpClientTest, AuthenticateWithUserPassword_Failure)
     EXPECT_CALL(*mockSocket, Write(_)).Times(1);
     EXPECT_CALL(*mockSocket, Read(_)).WillOnce([](auto& res) { res.result(boost::beast::http::status::unauthorized); });
 
-    const auto token = client->AuthenticateWithUserPassword("localhost", "8080", "user", "password");
+    const auto token = client->AuthenticateWithUserPassword("localhost", "8080", "user", "password", true);
 
     EXPECT_FALSE(token.has_value());
 }

diff --git a/src/agent/communicator/tests/mocks/mock_http_client.hpp b/src/agent/communicator/tests/mocks/mock_http_client.hpp
@@ -27,12 +27,12 @@ class MockHttpClient : public http_client::IHttpClient
 
     MOCK_METHOD(std::optional<std::string>,
                 AuthenticateWithUuidAndKey,
-                (const std::string& host, const std::string& port, const std::string& uuid, const std::string& key),
+                (const std::string& host, const std::string& port, const std::string& uuid, const std::string& key, const bool useHttps),
                 (override));
 
     MOCK_METHOD(
         std::optional<std::string>,
         AuthenticateWithUserPassword,
-        (const std::string& host, const std::string& port, const std::string& user, const std::string& password),
+        (const std::string& host, const std::string& port, const std::string& user, const std::string& password, const bool useHttps),
         (override));
 };
diff --git a/src/agent/communicator/tests/mocks/mock_http_socket_factory.hpp b/src/agent/communicator/tests/mocks/mock_http_socket_factory.hpp
@@ -8,6 +8,6 @@ class MockHttpSocketFactory : public http_client::IHttpSocketFactory
 public:
     MOCK_METHOD(std::unique_ptr<http_client::IHttpSocket>,
                 Create,
-                (const boost::asio::any_io_executor& executor),
+                (const boost::asio::any_io_executor& executor, const bool use_https),
                 (override));
 };
diff --git a/src/agent/src/register.cpp b/src/agent/src/register.cpp
@@ -16,7 +16,8 @@ namespace registration
         const configuration::ConfigurationParser configurationParser;
         const auto managerIp = configurationParser.GetConfig<std::string>("agent", "manager_ip");
         const auto managerPort = configurationParser.GetConfig<std::string>("agent", "server_mgmt_api_port");
-        const bool useHttps = (configurationParser.GetConfig<std::string>("agent", "https_enabled") == "no") ? false : true;
+        const bool useHttps =
+            (configurationParser.GetConfig<std::string>("agent", "https_enabled") == "no") ? false : true;
 
         const auto token = httpClient.AuthenticateWithUserPassword(
             managerIp, managerPort, userCredentials.user, userCredentials.password, useHttps);

diff --git a/src/agent/tests/register_test.cpp b/src/agent/tests/register_test.cpp
@@ -39,14 +39,21 @@ class MockHttpClient : public http_client::IHttpClient
 
     MOCK_METHOD(std::optional<std::string>,
                 AuthenticateWithUuidAndKey,
-                (const std::string& host, const std::string& port, const std::string& uuid, const std::string& key),
+                (const std::string& host,
+                 const std::string& port,
+                 const std::string& uuid,
+                 const std::string& key,
+                 const bool useHttps),
                 (override));
 
-    MOCK_METHOD(
-        std::optional<std::string>,
-        AuthenticateWithUserPassword,
-        (const std::string& host, const std::string& port, const std::string& user, const std::string& password),
-        (override));
+    MOCK_METHOD(std::optional<std::string>,
+                AuthenticateWithUserPassword,
+                (const std::string& host,
+                 const std::string& port,
+                 const std::string& user,
+                 const std::string& password,
+                 const bool useHttps),
+                (override));
 };
 
 class RegisterTest : public ::testing::Test
@@ -65,7 +72,11 @@ class RegisterTest : public ::testing::Test
 TEST_F(RegisterTest, RegistrationTestSuccess)
 {
     EXPECT_CALL(mockHttpClient,
-                AuthenticateWithUserPassword(testing::_, testing::_, userCredentials.user, userCredentials.password))
+                AuthenticateWithUserPassword(testing::_,
+                                             testing::_,
+                                             userCredentials.user,
+                                             userCredentials.password,
+                                             testing::_))
         .WillOnce(testing::Return("token"));
 
     nlohmann::json bodyJson = {{"id", agent->GetUUID()}, {"key", agent->GetKey()}};
@@ -76,7 +87,7 @@ TEST_F(RegisterTest, RegistrationTestSuccess)
     }
 
     http_client::HttpRequestParams reqParams(
-        boost::beast::http::verb::post, "localhost", "55000", "/agents", "token", "", bodyJson.dump());
+        boost::beast::http::verb::post, "localhost", "55000", "/agents", true, "token", "", bodyJson.dump());
 
     boost::beast::http::response<boost::beast::http::dynamic_body> expectedResponse;
     expectedResponse.result(boost::beast::http::status::ok);
@@ -90,7 +101,11 @@ TEST_F(RegisterTest, RegistrationTestSuccess)
 
 TEST_F(RegisterTest, RegistrationFailsIfAuthenticationFails)
 {
-    EXPECT_CALL(mockHttpClient, AuthenticateWithUserPassword(testing::_, testing::_, testing::_, testing::_))
+    EXPECT_CALL(mockHttpClient, AuthenticateWithUserPassword(testing::_,
+                                                             testing::_,
+                                                             testing::_,
+                                                             testing::_,
+                                                             testing::_))
         .WillOnce(testing::Return(std::nullopt));
 
     // NOLINTNEXTLINE(cppcoreguidelines-init-variables)
@@ -101,13 +116,18 @@ TEST_F(RegisterTest, RegistrationFailsIfAuthenticationFails)
 TEST_F(RegisterTest, RegistrationFailsIfServerResponseIsNotOk)
 {
     EXPECT_CALL(mockHttpClient,
-                AuthenticateWithUserPassword(testing::_, testing::_, userCredentials.user, userCredentials.password))
+                AuthenticateWithUserPassword(testing::_,
+                                             testing::_,
+                                             userCredentials.user,
+                                             userCredentials.password,
+                                             testing::_))
         .WillOnce(testing::Return("token"));
 
     boost::beast::http::response<boost::beast::http::dynamic_body> expectedResponse;
     expectedResponse.result(boost::beast::http::status::bad_request);
 
-    EXPECT_CALL(mockHttpClient, PerformHttpRequest(testing::_)).WillOnce(testing::Return(expectedResponse));
+    EXPECT_CALL(mockHttpClient, PerformHttpRequest(testing::_))
+        .WillOnce(testing::Return(expectedResponse));
 
     // NOLINTNEXTLINE(cppcoreguidelines-init-variables)
     const bool res = registration::RegisterAgent(userCredentials, mockHttpClient);