test_fixture.hpp

Go to the documentation of this file.

 
#ifndef CAMCOM_TEST_FIXTURE_HPP
#define CAMCOM_TEST_FIXTURE_HPP
 
#include <gtest/gtest.h>
#include <memory>
#include <string>
#include <thread>
#include <chrono>
#include <filesystem>
#include <cstdlib>
#include <sys/socket.h>
#include <netinet/in.h>
#include <unistd.h>
 
#include "camcom/testbench/config.hpp"
#include "camcom/testbench/server.hpp"
#include "camcom/common/errors.hpp"
#include "camcom/third_party/httplib.h"
 
#include <ifw/fnd/defs/base.hpp>
 
namespace camcom::test {
 
// ---------------------------------------------------------------------------
// Logger installation — install a null logger so tests don't pollute
// stdout with FND* output. Idempotent across fixtures.
// ---------------------------------------------------------------------------
inline void initLogger() {
  static bool done = false;
  if (!done) {
    ifw::fnd::InstallLogger(ifw::fnd::MakeNullLogger());
    done = true;
  }
}
 
// ---------------------------------------------------------------------------
// Helpers
// ---------------------------------------------------------------------------

inline int findFreePort() {
  int sock = socket(AF_INET, SOCK_STREAM, 0);
  struct sockaddr_in addr {};
  addr.sin_family = AF_INET;
  addr.sin_addr.s_addr = INADDR_ANY;
  addr.sin_port = 0;
  bind(sock, reinterpret_cast<struct sockaddr*>(&addr), sizeof(addr));
 
  socklen_t len = sizeof(addr);
  getsockname(sock, reinterpret_cast<struct sockaddr*>(&addr), &len);
  int port = ntohs(addr.sin_port);
  close(sock);
  return port;
}

template <typename Pred>
bool waitFor(Pred pred, int timeout_ms = 3000, int poll_ms = 50) {
  auto deadline =
      std::chrono::steady_clock::now() + std::chrono::milliseconds(timeout_ms);
  while (std::chrono::steady_clock::now() < deadline) {
    if (pred()) return true;
    std::this_thread::sleep_for(std::chrono::milliseconds(poll_ms));
  }
  return pred();  // last chance
}

inline server::ServerConfig buildTestConfig(int port,
                                            const std::string& rec_dir) {
  server::ServerConfig cfg;
  cfg.camera_name = "TestSimCamera";
  cfg.uri = "sim://localhost";
  cfg.timeout = 10;
 
  cfg.adapter.library = "libcamcom_sim.so";
  cfg.adapter.factory_symbol = "CreateAdapter";
  cfg.adapter.auto_connect = false;
 
  // SimAdapter uses snake_case parameter names internally
  // Set initial parameter values directly
  cfg.set_values = {
      {"acquisition_mode", "Continuous"},
      {"exposure_time", "0.01"},
      {"frame_rate", "0.0"},
      {"width", "64"},
      {"height", "64"},
      {"offset_x", "0"},
      {"offset_y", "0"},
      {"binning_horizontal", "1"},
      {"binning_vertical", "1"},
      {"gain", "4.0"},
      {"sim_type", "Gaussian"},
      {"sim_data_type", "UInt16"},
      {"sim_nb_planes", "11"},
      {"sim_amplitude", "1000.0"},
      {"sim_sigma", "5.0"},
      {"sim_noise_level", "50"},
  };
 
  cfg.http_server.host = "127.0.0.1";
  cfg.http_server.port = port;
 
  cfg.web_interface.enabled = true;
  cfg.web_interface.compression = "raw";
  cfg.web_interface.max_fps = 20;
  cfg.web_interface.max_image_width = 0;   // no downscaling
  cfg.web_interface.max_image_height = 0;
 
  cfg.streaming.enabled = true;
  cfg.streaming.protocol = "websocket";
 
  cfg.acquisition.frame_queue_size = 10;
  cfg.acquisition.skip_silently = true;
 
  cfg.recording.directory = rec_dir;
  cfg.recording.format = "fits:cube";
  cfg.recording.compression = "none";
  cfg.recording.nb_of_frames = 10;
  cfg.recording.max_frames_buffer = 100;
  cfg.recording.skip_silently = true;
  cfg.recording.overwrite_policy = "increment";
  cfg.recording.cube_timestamp_table = true;
  cfg.recording.trigger = "immediate";
 
  cfg.telemetry.enabled = true;
  cfg.telemetry.sampling_period = 0.5;  // fast for tests
  cfg.telemetry.sample_read_only_pars = true;
 
  cfg.statistics.enabled = true;
  cfg.statistics.window_size = 100;
 
  cfg.logging.level = "OFF";
 
  return cfg;
}

inline server::ServerConfig buildGenICamEmuTestConfig(int port,
                                                      const std::string& rec_dir) {
  server::ServerConfig cfg;
  cfg.camera_name = "TestGenICamEmu";
  cfg.uri = "genicam-emu://localhost";
  cfg.timeout = 10;
 
  cfg.adapter.library = "libcamcom_genicam_emu.so";
  cfg.adapter.factory_symbol = "CreateAdapter";
  cfg.adapter.auto_connect = false;
 
  // GenICam emulator uses SFNC parameter names directly
  // Set initial parameter values using native names
  cfg.set_values = {
      {"AcquisitionMode", "Continuous"},
      {"ExposureTime", "1000.0"},
      {"AcquisitionFrameRate", "30.0"},
      {"Width", "64"},
      {"Height", "64"},
      {"OffsetX", "0"},
      {"OffsetY", "0"},
      {"BinningHorizontal", "1"},
      {"BinningVertical", "1"},
      {"Gain", "1.0"},
      {"TriggerMode", "Off"},
      {"PixelFormat", "Mono8"},
  };
 
  cfg.http_server.host = "127.0.0.1";
  cfg.http_server.port = port;
 
  cfg.web_interface.enabled = true;
  cfg.web_interface.compression = "raw";
  cfg.web_interface.max_fps = 20;
  cfg.web_interface.max_image_width = 0;
  cfg.web_interface.max_image_height = 0;
 
  cfg.streaming.enabled = true;
  cfg.streaming.protocol = "websocket";
 
  cfg.acquisition.frame_queue_size = 10;
  cfg.acquisition.skip_silently = true;
 
  cfg.recording.directory = rec_dir;
  cfg.recording.format = "fits:cube";
  cfg.recording.compression = "none";
  cfg.recording.nb_of_frames = 10;
  cfg.recording.max_frames_buffer = 100;
  cfg.recording.skip_silently = true;
  cfg.recording.overwrite_policy = "increment";
  cfg.recording.cube_timestamp_table = true;
  cfg.recording.trigger = "immediate";
 
  cfg.telemetry.enabled = true;
  cfg.telemetry.sampling_period = 0.5;
  cfg.telemetry.sample_read_only_pars = true;
 
  cfg.statistics.enabled = true;
  cfg.statistics.window_size = 100;
 
  cfg.logging.level = "OFF";
 
  return cfg;
}
 
// ---------------------------------------------------------------------------
// CameraServerFixture — base fixture: starts server, provides HTTP client
// ---------------------------------------------------------------------------
class CameraServerFixture : public ::testing::Test {
protected:
  void SetUp() override {
    initLogger();
 
    port_ = findFreePort();
 
    // Create temp directory for recordings
    rec_dir_ = std::filesystem::temp_directory_path() /
               ("camcom_test_" + std::to_string(port_));
    std::filesystem::create_directories(rec_dir_);
 
    config_ = buildTestConfig(port_, rec_dir_.string());
    server_ = std::make_unique<server::CameraServer>(config_);
    ASSERT_TRUE(server_->start()) << "Server failed to start on port " << port_;
 
    client_ = std::make_unique<httplib::Client>("127.0.0.1", port_);
    client_->set_connection_timeout(3);
    client_->set_read_timeout(5);
 
    // Wait for /health to respond
    bool healthy = waitFor([this]() {
      auto res = client_->Get("/health");
      return res && res->status == 200;
    });
    ASSERT_TRUE(healthy) << "Server did not become healthy within timeout";
  }
 
  void TearDown() override {
    if (server_) {
      server_->stop();
    }
    // Clean up temp recording directory
    std::error_code ec;
    std::filesystem::remove_all(rec_dir_, ec);
  }
 
  httplib::Client& client() { return *client_; }
  const server::ServerConfig& config() const { return config_; }
  server::CameraServer& server() { return *server_; }
  int port() const { return port_; }
  const std::filesystem::path& recDir() const { return rec_dir_; }

  static std::string jsonStr(const std::string& body, const std::string& key) {
    std::string needle = "\"" + key + "\":\"";
    auto pos = body.find(needle);
    if (pos == std::string::npos) return "";
    pos += needle.size();
    auto end = body.find('"', pos);
    if (end == std::string::npos) return "";
    return body.substr(pos, end - pos);
  }

  static bool jsonBool(const std::string& body, const std::string& key) {
    std::string needle = "\"" + key + "\":";
    auto pos = body.find(needle);
    if (pos == std::string::npos) return false;
    pos += needle.size();
    return body.substr(pos, 4) == "true";
  }

  static int jsonInt(const std::string& body, const std::string& key) {
    std::string needle = "\"" + key + "\":";
    auto pos = body.find(needle);
    if (pos == std::string::npos) return -1;
    pos += needle.size();
    return std::stoi(body.substr(pos));
  }

  static double jsonDouble(const std::string& body, const std::string& key) {
    std::string needle = "\"" + key + "\":";
    auto pos = body.find(needle);
    if (pos == std::string::npos) return 0.0;
    pos += needle.size();
    return std::stod(body.substr(pos));
  }
 
private:
  int port_{0};
  std::filesystem::path rec_dir_;
  server::ServerConfig config_;
  std::unique_ptr<server::CameraServer> server_;
  std::unique_ptr<httplib::Client> client_;
};
 
// ---------------------------------------------------------------------------
// ConnectedServerFixture — camera connected
// ---------------------------------------------------------------------------
class ConnectedServerFixture : public CameraServerFixture {
protected:
  void SetUp() override {
    CameraServerFixture::SetUp();
    auto res = client().Get("/connect");
    ASSERT_TRUE(res) << "Failed to send /connect request";
    ASSERT_EQ(res->status, 200) << "Connect failed: " << res->body;
  }
 
  void TearDown() override {
    client().Get("/disconnect");
    CameraServerFixture::TearDown();
  }
};
 
// ---------------------------------------------------------------------------
// AcquiringServerFixture — camera connected + acquisition running
// ---------------------------------------------------------------------------
class AcquiringServerFixture : public ConnectedServerFixture {
protected:
  void SetUp() override {
    ConnectedServerFixture::SetUp();
    auto res = client().Get("/acquisition/start");
    ASSERT_TRUE(res) << "Failed to send /acquisition/start";
    ASSERT_EQ(res->status, 200) << "Start acquisition failed: " << res->body;
 
    // Wait until at least one frame is available
    bool got_frame = waitFor([this]() {
      auto r = client().Get("/image");
      if (!r || r->status != 200) return false;
      return r->body.find("\"frame_id\":0") == std::string::npos &&
             r->body.find("\"changed\":true") != std::string::npos;
    }, 5000);
    ASSERT_TRUE(got_frame) << "No frame received within timeout";
  }
 
  void TearDown() override {
    client().Get("/acquisition/stop");
    ConnectedServerFixture::TearDown();
  }
};
 
// ---------------------------------------------------------------------------
// GenICam Emulator fixtures — same tiers, different adapter
// ---------------------------------------------------------------------------
 
class GenICamEmuServerFixture : public ::testing::Test {
protected:
  void SetUp() override {
    initLogger();
 
    port_ = findFreePort();
 
    rec_dir_ = std::filesystem::temp_directory_path() /
               ("camcom_emu_test_" + std::to_string(port_));
    std::filesystem::create_directories(rec_dir_);
 
    config_ = buildGenICamEmuTestConfig(port_, rec_dir_.string());
    server_ = std::make_unique<server::CameraServer>(config_);
    ASSERT_TRUE(server_->start()) << "Server failed to start on port " << port_;
 
    client_ = std::make_unique<httplib::Client>("127.0.0.1", port_);
    client_->set_connection_timeout(3);
    client_->set_read_timeout(5);
 
    bool healthy = waitFor([this]() {
      auto res = client_->Get("/health");
      return res && res->status == 200;
    });
    ASSERT_TRUE(healthy) << "Server did not become healthy within timeout";
  }
 
  void TearDown() override {
    if (server_) {
      server_->stop();
    }
    std::error_code ec;
    std::filesystem::remove_all(rec_dir_, ec);
  }
 
  httplib::Client& client() { return *client_; }
  const server::ServerConfig& config() const { return config_; }
  server::CameraServer& server() { return *server_; }
  int port() const { return port_; }
  const std::filesystem::path& recDir() const { return rec_dir_; }
 
  static std::string jsonStr(const std::string& body, const std::string& key) {
    std::string needle = "\"" + key + "\":\"";
    auto pos = body.find(needle);
    if (pos == std::string::npos) return "";
    pos += needle.size();
    auto end = body.find('"', pos);
    if (end == std::string::npos) return "";
    return body.substr(pos, end - pos);
  }
 
  static bool jsonBool(const std::string& body, const std::string& key) {
    std::string needle = "\"" + key + "\":";
    auto pos = body.find(needle);
    if (pos == std::string::npos) return false;
    pos += needle.size();
    return body.substr(pos, 4) == "true";
  }
 
  static int jsonInt(const std::string& body, const std::string& key) {
    std::string needle = "\"" + key + "\":";
    auto pos = body.find(needle);
    if (pos == std::string::npos) return -1;
    pos += needle.size();
    return std::stoi(body.substr(pos));
  }
 
  static double jsonDouble(const std::string& body, const std::string& key) {
    std::string needle = "\"" + key + "\":";
    auto pos = body.find(needle);
    if (pos == std::string::npos) return 0.0;
    pos += needle.size();
    return std::stod(body.substr(pos));
  }
 
private:
  int port_{0};
  std::filesystem::path rec_dir_;
  server::ServerConfig config_;
  std::unique_ptr<server::CameraServer> server_;
  std::unique_ptr<httplib::Client> client_;
};
 
class ConnectedGenICamEmuFixture : public GenICamEmuServerFixture {
protected:
  void SetUp() override {
    GenICamEmuServerFixture::SetUp();
    auto res = client().Get("/connect");
    ASSERT_TRUE(res) << "Failed to send /connect request";
    ASSERT_EQ(res->status, 200) << "Connect failed: " << res->body;
  }
 
  void TearDown() override {
    client().Get("/disconnect");
    GenICamEmuServerFixture::TearDown();
  }
};
 
class AcquiringGenICamEmuFixture : public ConnectedGenICamEmuFixture {
protected:
  void SetUp() override {
    ConnectedGenICamEmuFixture::SetUp();
    auto res = client().Get("/acquisition/start");
    ASSERT_TRUE(res) << "Failed to send /acquisition/start";
    ASSERT_EQ(res->status, 200) << "Start acquisition failed: " << res->body;
 
    bool got_frame = waitFor([this]() {
      auto r = client().Get("/image");
      if (!r || r->status != 200) return false;
      return r->body.find("\"frame_id\":0") == std::string::npos &&
             r->body.find("\"changed\":true") != std::string::npos;
    }, 5000);
    ASSERT_TRUE(got_frame) << "No frame received within timeout";
  }
 
  void TearDown() override {
    client().Get("/acquisition/stop");
    ConnectedGenICamEmuFixture::TearDown();
  }
};
 
}  // namespace camcom::test
 
#endif  // CAMCOM_TEST_FIXTURE_HPP