Add some unit tests

Author: Molter73

collector/lib/CollectorConfig.h

@@ -6,6 +6,7 @@
 #include <shared_mutex>
 #include <vector>
 
+#include <gtest/gtest_prod.h>
 #include <json/json.h>
 #include <yaml-cpp/yaml.h>
 
@@ -191,6 +192,8 @@ class CollectorConfig {
   }
 
  protected:
+  FRIEND_TEST(SensorClientFormatterTest, NoProcessArguments);
+
   int scrape_interval_;
   CollectionMethod collection_method_;
   bool turn_off_scrape_;

collector/lib/CollectorOutput.h

@@ -26,7 +26,16 @@ class CollectorOutput {
 
   ~CollectorOutput() {
     stream_interrupted_.notify_one();
-    thread_.Stop();
+    if (thread_.running()) {
+      thread_.Stop();
+    }
+  }
+
+  // Constructor for tests
+  CollectorOutput(std::unique_ptr<ISensorClient>&& sensor_client,
+                  std::unique_ptr<ISignalServiceClient>&& signal_client) {
+    sensor_clients_.emplace_back(std::move(sensor_client));
+    signal_clients_.emplace_back(std::move(signal_client));
   }
 
   SignalHandler::Result SendMsg(const MessageType& msg);

collector/lib/SensorClientFormatter.h

@@ -44,8 +44,8 @@ class SensorClientFormatter : public ProtoSignalFormatter<sensor::MsgFromCollect
   void GetProcessLineage(sinsp_threadinfo* tinfo, std::vector<LineageInfo>& lineage);
 
  private:
-  FRIEND_TEST(ProcessSignalFormatterTest, NoProcessArguments);
-  FRIEND_TEST(ProcessSignalFormatterTest, ProcessArguments);
+  FRIEND_TEST(SensorClientFormatterTest, NoProcessArguments);
+  FRIEND_TEST(SensorClientFormatterTest, ProcessArguments);
 
   ProcessSignal* CreateProcessSignal(sinsp_evt* event);
   Signal* CreateSignal(sinsp_evt* event);

collector/test/CollectorOutputTest.cpp

@@ -0,0 +1,63 @@
+#include <gmock/gmock.h>
+#include <gtest/gtest.h>
+
+#include "internalapi/sensor/collector_iservice.pb.h"
+
+#include "CollectorOutput.h"
+#include "SensorClient.h"
+#include "SignalServiceClient.h"
+
+namespace collector {
+class MockSensorClient : public ISensorClient {
+ public:
+  MOCK_METHOD(bool, Refresh, ());
+  MOCK_METHOD(SignalHandler::Result, SendMsg, (const sensor::MsgFromCollector&));
+};
+
+class MockSignalClient : public ISignalServiceClient {
+ public:
+  MOCK_METHOD(bool, Refresh, ());
+  MOCK_METHOD(SignalHandler::Result, PushSignals, (const sensor::SignalStreamMessage&));
+};
+
+class CollectorOutputTest : public testing::Test {
+ public:
+  CollectorOutputTest()
+      : sensor_client(std::make_unique<MockSensorClient>()),
+        signal_client(std::make_unique<MockSignalClient>()) {}
+
+ protected:
+  std::unique_ptr<MockSensorClient> sensor_client;
+  std::unique_ptr<MockSignalClient> signal_client;
+};
+
+TEST_F(CollectorOutputTest, Register) {
+  EXPECT_CALL(*sensor_client, SendMsg).Times(1).WillOnce(testing::Return(SignalHandler::PROCESSED));
+
+  CollectorOutput output{std::move(sensor_client), std::move(signal_client)};
+  output.Register();
+}
+
+TEST_F(CollectorOutputTest, SensorClient) {
+  sensor::MsgFromCollector msg;
+
+  EXPECT_CALL(*sensor_client, SendMsg).Times(1).WillOnce(testing::Return(SignalHandler::PROCESSED));
+
+  CollectorOutput output{std::move(sensor_client), std::move(signal_client)};
+  auto result = output.SendMsg(msg);
+
+  EXPECT_EQ(result, SignalHandler::PROCESSED);
+}
+
+TEST_F(CollectorOutputTest, SignalClient) {
+  sensor::SignalStreamMessage msg;
+
+  EXPECT_CALL(*signal_client, PushSignals).Times(1).WillOnce(testing::Return(SignalHandler::PROCESSED));
+
+  CollectorOutput output{std::move(sensor_client), std::move(signal_client)};
+
+  auto result = output.SendMsg(msg);
+
+  EXPECT_EQ(result, SignalHandler::PROCESSED);
+}
+}  // namespace collector