Add unit-tests for HttpServerConnection and HTTP message classes

Author: jschmidt-icinga

test/CMakeLists.txt

@@ -87,7 +87,10 @@ set(base_test_SOURCES
   icinga-notification.cpp
   icinga-perfdata.cpp
   methods-pluginnotificationtask.cpp
+  remote-certificate-fixture.cpp
   remote-configpackageutility.cpp
+  remote-httpserverconnection.cpp
+  remote-httpmessage.cpp
   remote-url.cpp
   ${base_OBJS}
   $<TARGET_OBJECTS:config>
@@ -271,6 +274,33 @@ add_boost_test(base
     icinga_perfdata/parse_edgecases
     icinga_perfdata/empty_warn_crit_min_max
     methods_pluginnotificationtask/truncate_long_output
+    remote_certs_fixture/prepare_directory
+    remote_certs_fixture/cleanup_certs
+    remote_httpmessage/request_parse
+    remote_httpmessage/request_params
+    remote_httpmessage/response_clear
+    remote_httpmessage/response_flush_nothrow
+    remote_httpmessage/response_flush_throw
+    remote_httpmessage/response_write_empty
+    remote_httpmessage/response_write_fixed
+    remote_httpmessage/response_write_chunked
+    remote_httpmessage/response_sendjsonbody
+    remote_httpmessage/response_sendjsonerror
+    remote_httpmessage/response_sendfile
+    remote_httpserverconnection/expect_100_continue
+    remote_httpserverconnection/bad_request
+    remote_httpserverconnection/error_access_control
+    remote_httpserverconnection/error_accept_header
+    remote_httpserverconnection/authenticate_cn
+    remote_httpserverconnection/authenticate_passwd
+    remote_httpserverconnection/authenticate_error_wronguser
+    remote_httpserverconnection/authenticate_error_wrongpasswd
+    remote_httpserverconnection/reuse_connection
+    remote_httpserverconnection/wg_abort
+    remote_httpserverconnection/client_shutdown
+    remote_httpserverconnection/handler_throw_error
+    remote_httpserverconnection/handler_throw_streaming
+    remote_httpserverconnection/liveness_disconnect
     remote_configpackageutility/ValidateName
     remote_url/id_and_path
     remote_url/parameters
@@ -279,6 +309,46 @@ add_boost_test(base
     remote_url/illegal_legal_strings
 )
 
+if(BUILD_TESTING)
+  set_tests_properties(
+    base-remote_httpmessage/request_parse
+    base-remote_httpmessage/request_params
+    base-remote_httpmessage/response_clear
+    base-remote_httpmessage/response_flush_nothrow
+    base-remote_httpmessage/response_flush_throw
+    base-remote_httpmessage/response_write_empty
+    base-remote_httpmessage/response_write_fixed
+    base-remote_httpmessage/response_write_chunked
+    base-remote_httpmessage/response_sendjsonbody
+    base-remote_httpmessage/response_sendjsonerror
+    base-remote_httpmessage/response_sendfile
+    base-remote_httpserverconnection/expect_100_continue
+    base-remote_httpserverconnection/bad_request
+    base-remote_httpserverconnection/error_access_control
+    base-remote_httpserverconnection/error_accept_header
+    base-remote_httpserverconnection/authenticate_cn
+    base-remote_httpserverconnection/authenticate_passwd
+    base-remote_httpserverconnection/authenticate_error_wronguser
+    base-remote_httpserverconnection/authenticate_error_wrongpasswd
+    base-remote_httpserverconnection/reuse_connection
+    base-remote_httpserverconnection/wg_abort
+    base-remote_httpserverconnection/client_shutdown
+    base-remote_httpserverconnection/handler_throw_error
+    base-remote_httpserverconnection/handler_throw_streaming
+    base-remote_httpserverconnection/liveness_disconnect
+    PROPERTIES FIXTURES_REQUIRED ssl_certs)
+
+  set_tests_properties(
+    base-remote_certs_fixture/prepare_directory
+    PROPERTIES FIXTURES_SETUP ssl_certs
+  )
+
+  set_tests_properties(
+    base-remote_certs_fixture/cleanup_certs
+    PROPERTIES FIXTURES_CLEANUP ssl_certs
+  )
+endif()
+
 if(ICINGA2_WITH_LIVESTATUS)
   set(livestatus_test_SOURCES
     icingaapplication-fixture.cpp

test/base-configuration-fixture.hpp

@@ -0,0 +1,56 @@
+/* Icinga 2 | (c) 2025 Icinga GmbH | GPLv2+ */
+
+#ifndef CONFIGURATION_FIXTURE_H
+#define CONFIGURATION_FIXTURE_H
+
+#include "base/configuration.hpp"
+#include <boost/filesystem.hpp>
+#include <BoostTestTargetConfig.h>
+
+namespace icinga {
+
+struct ConfigurationDataDirFixture
+{
+	ConfigurationDataDirFixture()
+		: m_DataDir(boost::filesystem::current_path() / "data"), m_PrevDataDir(Configuration::DataDir.GetData())
+	{
+		boost::filesystem::create_directories(m_DataDir);
+		Configuration::DataDir = m_DataDir.string();
+	}
+
+	~ConfigurationDataDirFixture()
+	{
+		boost::filesystem::remove_all(m_DataDir);
+		Configuration::DataDir = m_PrevDataDir.string();
+	}
+
+	boost::filesystem::path m_DataDir;
+
+private:
+	boost::filesystem::path m_PrevDataDir;
+};
+
+struct ConfigurationCacheDirFixture
+{
+	ConfigurationCacheDirFixture()
+		: m_CacheDir(boost::filesystem::current_path() / "cache"), m_PrevCacheDir(Configuration::CacheDir.GetData())
+	{
+		boost::filesystem::create_directories(m_CacheDir);
+		Configuration::CacheDir = m_CacheDir.string();
+	}
+
+	~ConfigurationCacheDirFixture()
+	{
+		boost::filesystem::remove_all(m_CacheDir);
+		Configuration::CacheDir = m_PrevCacheDir.string();
+	}
+
+	boost::filesystem::path m_CacheDir;
+
+private:
+	boost::filesystem::path m_PrevCacheDir;
+};
+
+} // namespace icinga
+
+#endif // CONFIGURATION_FIXTURE_H

test/base-testloggerfixture.hpp

@@ -0,0 +1,127 @@
+/* Icinga 2 | (c) 2025 Icinga GmbH | GPLv2+ */
+
+#ifndef TEST_LOGGER_FIXTURE_H
+#define TEST_LOGGER_FIXTURE_H
+
+#include <BoostTestTargetConfig.h>
+#include "base/logger.hpp"
+#include <boost/range/algorithm.hpp>
+#include <boost/regex.hpp>
+#include <boost/test/test_tools.hpp>
+#include <future>
+
+namespace icinga {
+
+class TestLogger : public Logger
+{
+public:
+	DECLARE_PTR_TYPEDEFS(TestLogger);
+
+	struct Expect
+	{
+		std::string pattern;
+		std::promise<bool> prom;
+	};
+
+	auto ExpectLogPattern(const std::string& pattern,
+		const std::chrono::milliseconds& timeout = std::chrono::seconds(0))
+	{
+		std::unique_lock lock(m_Mutex);
+		for (const auto& logEntry : m_LogEntries) {
+			if (boost::regex_match(logEntry.Message.GetData(), boost::regex(pattern))) {
+				return boost::test_tools::assertion_result{true};
+			}
+		}
+
+		if (timeout == std::chrono::seconds(0)) {
+			return boost::test_tools::assertion_result{false};
+		}
+
+		auto expect = std::make_shared<Expect>(Expect{pattern, std::promise<bool>()});
+		m_Expects.emplace_back(expect);
+		lock.unlock();
+
+		auto future = expect->prom.get_future();
+		auto status = future.wait_for(timeout);
+		boost::test_tools::assertion_result ret{status == std::future_status::ready && future.get()};
+		ret.message() << "Pattern \"" << pattern << "\" in log within " << timeout.count() << "ms";
+
+		lock.lock();
+		m_Expects.erase(boost::range::remove(m_Expects, expect), m_Expects.end());
+
+		return ret;
+	}
+
+private:
+	void ProcessLogEntry(const LogEntry& entry) override
+	{
+		std::unique_lock lock(m_Mutex);
+		m_LogEntries.push_back(entry);
+
+		auto it = boost::range::remove_if(m_Expects, [&entry](const std::shared_ptr<Expect>& expect) {
+			if (boost::regex_match(entry.Message.GetData(), boost::regex(expect->pattern))) {
+				expect->prom.set_value(true);
+				return true;
+			}
+			return false;
+		});
+		m_Expects.erase(it, m_Expects.end());
+	}
+
+	void Flush() override {}
+
+	std::mutex m_Mutex;
+	std::vector<std::shared_ptr<Expect>> m_Expects;
+	std::vector<LogEntry> m_LogEntries;
+};
+
+/**
+ * A fixture to capture log entries and assert their presence in tests.
+ *
+ * Currently, this only supports checking existing entries and waiting for new ones
+ * using ExpectLogPattern(), but more functionality can easily be added in the future,
+ * like only asserting on past log messages, only waiting for new ones, asserting log
+ * entry metadata (severity etc.) and so on.
+ */
+struct TestLoggerFixture
+{
+	TestLoggerFixture()
+	{
+		testLogger->SetSeverity(testLogger->SeverityToString(LogDebug));
+		testLogger->Activate(true);
+		testLogger->SetActive(true);
+	}
+
+	~TestLoggerFixture()
+	{
+		testLogger->SetActive(false);
+		testLogger->Deactivate(true);
+	}
+
+	/**
+	 * Asserts the presence of a log entry that matches the given regex pattern.
+	 *
+	 * First, the existing log entries are searched for the pattern. If the pattern isn't found,
+	 * until the timeout is reached, the function will wait if a new log message is added that
+	 * matches the pattern.
+	 *
+	 * A boost assertion result object is returned, that evaluates to bool, but contains an
+	 * error message that is printed by the testing framework when the assert failed.
+	 *
+	 * @param pattern The regex pattern the log message needs to match
+	 * @param timeout The maximum amount of time to wait for the log message to arrive
+	 *
+	 * @return A @c boost::test_tools::assertion_result object that can be used in BOOST_REQUIRE
+	 */
+	auto ExpectLogPattern(const std::string& pattern,
+		const std::chrono::milliseconds& timeout = std::chrono::seconds(0))
+	{
+		return testLogger->ExpectLogPattern(pattern, timeout);
+	}
+
+	TestLogger::Ptr testLogger = new TestLogger;
+};
+
+} // namespace icinga
+
+#endif // TEST_LOGGER_FIXTURE_H

test/base-tlsstream-fixture.hpp

@@ -0,0 +1,114 @@
+/* Icinga 2 | (c) 2025 Icinga GmbH | GPLv2+ */
+
+#pragma once
+
+#include "base/io-engine.hpp"
+#include "base/tlsstream.hpp"
+#include "test/remote-certificate-fixture.hpp"
+#include <BoostTestTargetConfig.h>
+#include <future>
+
+namespace icinga {
+
+/**
+ * Creates a pair of TLS Streams on a random unused port.
+ */
+struct TlsStreamFixture : CertificateFixture
+{
+	TlsStreamFixture()
+	{
+		using namespace boost::asio::ip;
+		using handshake_type = boost::asio::ssl::stream_base::handshake_type;
+
+		auto serverCert = EnsureCertFor("server");
+		auto clientCert = EnsureCertFor("client");
+
+		auto& io = IoEngine::Get().GetIoContext();
+
+		m_ClientSslContext = SetupSslContext(clientCert.crtFile, clientCert.keyFile, m_CaCrtFile.string(), "",
+			DEFAULT_TLS_CIPHERS, DEFAULT_TLS_PROTOCOLMIN, DebugInfo());
+		client = Shared<AsioTlsStream>::Make(io, *m_ClientSslContext);
+
+		m_ServerSslContext = SetupSslContext(serverCert.crtFile, serverCert.keyFile, m_CaCrtFile.string(), "",
+			DEFAULT_TLS_CIPHERS, DEFAULT_TLS_PROTOCOLMIN, DebugInfo());
+		server = Shared<AsioTlsStream>::Make(io, *m_ServerSslContext);
+
+		std::promise<void> p;
+
+		tcp::acceptor acceptor{io, tcp::endpoint{address_v4::loopback(), 0}};
+		acceptor.listen();
+		acceptor.async_accept(server->lowest_layer(), [&](const boost::system::error_code& ec) {
+			if (ec) {
+				BOOST_TEST_MESSAGE("Server Accept Error: " + ec.message());
+				p.set_exception(std::make_exception_ptr(boost::system::system_error{ec}));
+				return;
+			}
+			server->next_layer().async_handshake(handshake_type::server, [&](const boost::system::error_code& ec) {
+				if (ec) {
+					BOOST_TEST_MESSAGE("Server Handshake Error: " + ec.message());
+					p.set_exception(std::make_exception_ptr(boost::system::system_error{ec}));
+					return;
+				}
+
+				if (!server->next_layer().IsVerifyOK()) {
+					p.set_exception(std::make_exception_ptr(std::runtime_error{"Verify failed on server-side."}));
+				}
+
+				p.set_value();
+			});
+		});
+
+		auto f = p.get_future();
+		boost::system::error_code ec;
+		if (client->lowest_layer().connect(acceptor.local_endpoint(), ec)) {
+			BOOST_TEST_MESSAGE("Client Connect error: " + ec.message());
+			f.get();
+			BOOST_THROW_EXCEPTION(boost::system::system_error{ec});
+		}
+
+		if (client->next_layer().handshake(handshake_type::client, ec)) {
+			BOOST_TEST_MESSAGE("Client Handshake error: " + ec.message());
+			f.get();
+			BOOST_THROW_EXCEPTION(boost::system::system_error{ec});
+		}
+
+		if (!client->next_layer().IsVerifyOK()) {
+			f.get();
+			BOOST_THROW_EXCEPTION(std::runtime_error{"Verify failed on client-side."});
+		}
+
+		f.get();
+	}
+
+	auto Shutdown(const Shared<AsioTlsStream>::Ptr& stream, std::optional<boost::asio::yield_context> yc = {})
+	{
+		boost::system::error_code ec;
+		if (yc) {
+			stream->next_layer().async_shutdown((*yc)[ec]);
+		} else {
+			stream->next_layer().shutdown(ec);
+		}
+#if BOOST_VERSION < 107000
+		/* On boost versions < 1.70, the end-of-file condition was propagated as an error,
+		 * even in case of a successful shutdown. This is information can be found in the
+		 * changelog for the boost Asio 1.14.0 / Boost 1.70 release.
+		 */
+		if (ec == boost::asio::error::eof) {
+			BOOST_TEST_MESSAGE("Shutdown completed successfully with 'boost::asio::error::eof'.");
+			return boost::test_tools::assertion_result{true};
+		}
+#endif
+		boost::test_tools::assertion_result ret{!ec};
+		ret.message() << "Error: " << ec.message();
+		return ret;
+	}
+
+	Shared<AsioTlsStream>::Ptr client;
+	Shared<AsioTlsStream>::Ptr server;
+
+private:
+	Shared<boost::asio::ssl::context>::Ptr m_ClientSslContext;
+	Shared<boost::asio::ssl::context>::Ptr m_ServerSslContext;
+};
+
+} // namespace icinga