Add unit-tests for PerfdataWriterConnection

There's a set of two tests for each perfdatawriter, just
to make sure they can connect and send data that looks reasonably
correct, and to make sure pausing actually works while the connection
is stuck.

Then there's a more in-depth suite of tests for PerfdataWriterConnection
itself, to verify that connection handling works well in all types
of scenarios.

Author: jschmidt-icinga

test/CMakeLists.txt

@@ -140,6 +140,18 @@ if(ICINGA2_WITH_NOTIFICATION)
   )
 endif()
 
+if(ICINGA2_WITH_PERFDATA)
+  list(APPEND base_test_SOURCES
+    perfdata-elasticsearchwriter.cpp
+    perfdata-gelfwriter.cpp
+    perfdata-graphitewriter.cpp
+    perfdata-influxdbwriter.cpp
+    perfdata-opentsdbwriter.cpp
+    perfdata-perfdatawriterconnection.cpp
+    $<TARGET_OBJECTS:perfdata>
+  )
+endif()
+
 if(ICINGA2_UNITY_BUILD)
   mkunity_target(base test base_test_SOURCES)
 endif()

test/perfdata-elasticsearchwriter.cpp

@@ -0,0 +1,54 @@
+// SPDX-FileCopyrightText: 2026 Icinga GmbH <https://icinga.com>
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#include <BoostTestTargetConfig.h>
+#include "perfdata/elasticsearchwriter.hpp"
+#include "test/base-testloggerfixture.hpp"
+#include "test/perfdata-perfdatawriterfixture.hpp"
+#include "test/utils.hpp"
+
+using namespace icinga;
+
+BOOST_FIXTURE_TEST_SUITE(perfdata_elasticsearchwriter, PerfdataWriterFixture<ElasticsearchWriter>,
+	*boost::unit_test::label("perfdata"))
+
+BOOST_AUTO_TEST_CASE(connect)
+{
+	ResumeWriter();
+
+	ReceiveCheckResults(1, ServiceState::ServiceCritical);
+
+	Accept();
+	auto resp = GetSplitDecodedRequestBody();
+	SendResponse();
+
+	// Just some basic sanity tests. It's not important to check if everything is entirely
+	// correct here.
+	BOOST_REQUIRE_GT(resp->GetLength(), 1);
+	Dictionary::Ptr cr = resp->Get(1);
+	BOOST_CHECK(cr->Contains("@timestamp"));
+	BOOST_CHECK_EQUAL(cr->Get("check_command"), "dummy");
+	BOOST_CHECK_EQUAL(cr->Get("host"), "h1");
+	PauseWriter();
+}
+
+BOOST_AUTO_TEST_CASE(pause_with_pending_work)
+{
+	ResumeWriter();
+
+	ReceiveCheckResults(1, ServiceState::ServiceCritical, [](const CheckResult::Ptr& cr) {
+		cr->SetOutput(GetRandomString("####", 1024UL * 1024));
+	});
+
+	// Accept the connection, but don't read from it to leave the client hanging.
+	Accept();
+	GetDataUntil("####");
+
+	// Now try to pause.
+	PauseWriter();
+
+	REQUIRE_LOG_MESSAGE("Operation cancelled\\.", 10s);
+	REQUIRE_LOG_MESSAGE("'ElasticsearchWriter' paused\\.", 10s);
+}
+
+BOOST_AUTO_TEST_SUITE_END()

test/perfdata-gelfwriter.cpp

@@ -0,0 +1,52 @@
+// SPDX-FileCopyrightText: 2026 Icinga GmbH <https://icinga.com>
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#include <BoostTestTargetConfig.h>
+#include "perfdata/gelfwriter.hpp"
+#include "test/base-testloggerfixture.hpp"
+#include "test/perfdata-perfdatawriterfixture.hpp"
+#include "test/utils.hpp"
+
+using namespace icinga;
+
+BOOST_FIXTURE_TEST_SUITE(perfdata_gelfwriter, PerfdataWriterFixture<GelfWriter>,
+	*boost::unit_test::label("perfdata"))
+
+BOOST_AUTO_TEST_CASE(connect)
+{
+	ResumeWriter();
+
+	ReceiveCheckResults(1, ServiceState::ServiceCritical);
+
+	Accept();
+	Dictionary::Ptr resp = JsonDecode(GetDataUntil('\0'));
+
+	// Just some basic sanity tests. It's not important to check if everything is entirely
+	// correct here.
+	BOOST_CHECK_CLOSE(resp->Get("timestamp").Get<double>(), Utility::GetTime(), 0.5);
+	BOOST_CHECK_EQUAL(resp->Get("_check_command"), "dummy");
+	BOOST_CHECK_EQUAL(resp->Get("_hostname"), "h1");
+	PauseWriter();
+}
+
+BOOST_AUTO_TEST_CASE(pause_with_pending_work)
+{
+	ResumeWriter();
+
+	// Make GelfWriter fill up the connection's buffer with a huge check-result.
+	ReceiveCheckResults(1, ServiceState::ServiceCritical, [](const CheckResult::Ptr& cr) {
+		cr->SetOutput(GetRandomString("####", 1024UL * 1024));
+	});
+
+	// Accept the connection, but only read far enough so we know the writer is now stuck.
+	Accept();
+	GetDataUntil("####");
+
+	// Now try to pause.
+	PauseWriter();
+
+	REQUIRE_LOG_MESSAGE("Operation cancelled\\.", 1s);
+	REQUIRE_LOG_MESSAGE("'GelfWriter' paused\\.", 1s);
+}
+
+BOOST_AUTO_TEST_SUITE_END()

test/perfdata-graphitewriter.cpp

@@ -0,0 +1,53 @@
+// SPDX-FileCopyrightText: 2026 Icinga GmbH <https://icinga.com>
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#include <BoostTestTargetConfig.h>
+#include "perfdata/graphitewriter.hpp"
+#include "test/base-testloggerfixture.hpp"
+#include "test/perfdata-perfdatawriterfixture.hpp"
+#include "test/utils.hpp"
+
+using namespace icinga;
+
+BOOST_FIXTURE_TEST_SUITE(
+	perfdata_graphitewriter,
+	PerfdataWriterFixture<GraphiteWriter>,
+	*boost::unit_test::label("perfdata")
+)
+
+BOOST_AUTO_TEST_CASE(connect)
+{
+	ResumeWriter();
+
+	ReceiveCheckResults(1, ServiceState::ServiceCritical);
+
+	Accept();
+	auto msg = GetDataUntil('\n');
+
+	// Just some basic sanity tests. It's not important to check if everything is entirely correct here.
+	std::string_view cmpStr{"icinga2.h1.host.dummy.perfdata.thing.value 42"};
+	BOOST_REQUIRE_EQUAL(msg.substr(0, cmpStr.length()), cmpStr);
+	PauseWriter();
+}
+
+BOOST_AUTO_TEST_CASE(pause_with_pending_work)
+{
+	ResumeWriter();
+
+	// Make GraphiteWriter send a huge message that fills up the connection's buffer.
+	ReceiveCheckResults(1, ServiceState::ServiceCritical, [&](const CheckResult::Ptr& cr) {
+		cr->GetPerformanceData()->Add(new PerfdataValue{GetRandomString("aaaa", 24UL * 1024 * 1024), 1});
+	});
+
+	// Accept the connection, but don't read from it to leave the client hanging.
+	Accept();
+	GetDataUntil("aaaa");
+
+	// Now try to pause.
+	PauseWriter();
+
+	REQUIRE_LOG_MESSAGE("Operation Cancelled\\.", 10s);
+	REQUIRE_LOG_MESSAGE("'GraphiteWriter' paused\\.", 10s);
+}
+
+BOOST_AUTO_TEST_SUITE_END()

test/perfdata-influxdbwriter.cpp

@@ -0,0 +1,51 @@
+// SPDX-FileCopyrightText: 2026 Icinga GmbH <https://icinga.com>
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#include <BoostTestTargetConfig.h>
+#include "perfdata/influxdb2writer.hpp"
+#include "test/base-testloggerfixture.hpp"
+#include "test/perfdata-perfdatawriterfixture.hpp"
+
+using namespace icinga;
+
+BOOST_FIXTURE_TEST_SUITE(perfdata_influxdbwriter, PerfdataWriterFixture<Influxdb2Writer>,
+	*boost::unit_test::label("perfdata"))
+
+BOOST_AUTO_TEST_CASE(connect)
+{
+	ResumeWriter();
+
+	ReceiveCheckResults(1, ServiceState::ServiceCritical);
+
+	Accept();
+	auto req = GetSplitRequestBody(',');
+	SendResponse(boost::beast::http::status::no_content);
+
+	// Just some basic sanity tests. It's not important to check if everything is entirely
+	// correct here.
+	BOOST_REQUIRE_EQUAL(req.size(), 3);
+	BOOST_CHECK_EQUAL(req[0], "dummy");
+	BOOST_CHECK_EQUAL(req[1], "hostname=h1");
+	std::string_view perfData = "metric=thing value=42";
+	BOOST_CHECK_EQUAL(req[2].substr(0, perfData.length()), perfData);
+	PauseWriter();
+}
+
+BOOST_AUTO_TEST_CASE(pause_with_pending_work)
+{
+	ResumeWriter();
+
+	// Make Influxdb2Writer fill up the connection's buffer with a huge check-result.
+	ReceiveCheckResults(1, ServiceState::ServiceCritical);
+
+	// Accept the connection, but only read far enough so we know the writer is now stuck.
+	Accept();
+
+	// Now try to pause.
+	PauseWriter();
+
+	REQUIRE_LOG_MESSAGE("Operation cancelled\\.", 1s);
+	REQUIRE_LOG_MESSAGE("'Influxdb2Writer' paused\\.", 1s);
+}
+
+BOOST_AUTO_TEST_SUITE_END()

test/perfdata-opentsdbwriter.cpp

@@ -0,0 +1,57 @@
+// SPDX-FileCopyrightText: 2026 Icinga GmbH <https://icinga.com>
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#include <BoostTestTargetConfig.h>
+#include "perfdata/opentsdbwriter.hpp"
+#include "test/base-testloggerfixture.hpp"
+#include "test/perfdata-perfdatawriterfixture.hpp"
+#include "test/utils.hpp"
+
+using namespace icinga;
+
+BOOST_FIXTURE_TEST_SUITE(perfdata_opentsdbwriter, PerfdataWriterFixture<OpenTsdbWriter>,
+	*boost::unit_test::label("perfdata"))
+
+BOOST_AUTO_TEST_CASE(connect)
+{
+	ResumeWriter();
+
+	ReceiveCheckResults(1, ServiceState::ServiceCritical);
+
+	Accept();
+	auto msg = GetDataUntil('\n');
+	std::vector<std::string> splitMsg;
+	boost::split(splitMsg, msg, boost::is_any_of(" "));
+
+	// Just some basic sanity tests. It's not important to check if everything is entirely correct here.
+	BOOST_REQUIRE_EQUAL(splitMsg.size(), 5);
+	BOOST_REQUIRE_EQUAL(splitMsg[0], "put");
+	BOOST_REQUIRE_EQUAL(splitMsg[1], "icinga.host.state");
+	BOOST_REQUIRE_CLOSE(boost::lexical_cast<double>(splitMsg[2]), Utility::GetTime(), 1);
+	BOOST_REQUIRE_EQUAL(splitMsg[3], "1");
+	BOOST_REQUIRE_EQUAL(splitMsg[4], "host=h1");
+	PauseWriter();
+}
+
+BOOST_AUTO_TEST_CASE(pause_with_pending_work)
+{
+	ResumeWriter();
+
+	// Make OpenTsdbWriter send a huge message that fills up the connection's buffer.
+	ReceiveCheckResults(1, ServiceState::ServiceCritical, [&](const CheckResult::Ptr& cr) {
+		cr->GetPerformanceData()->Add(new PerfdataValue{GetRandomString("aaaaa", 24 * 1024 * 1024), 1});
+	});
+
+	// Accept the connection, and read until OpenTsdbWriter has started sending the large part
+	// of the PerfdataValue sent above.
+	Accept();
+	GetDataUntil("aaaaa");
+
+	// Now stop reading and try to pause OpenTsdbWriter.
+	PauseWriter();
+
+	REQUIRE_LOG_MESSAGE("Operation canceled\\.", 10s);
+	REQUIRE_LOG_MESSAGE("'OpenTsdbWriter' paused\\.", 10s);
+}
+
+BOOST_AUTO_TEST_SUITE_END()