process_manager_test_fixture.h

Go to the documentation of this file.

// Copyright (c) Space-ng, inc. All rights reserved.
#pragma once
 
#include "sol3/asio/strand.h"
#include "sol3/core/logging.h"
 
#include <boost/asio/any_io_executor.hpp>
#include <boost/asio/dispatch.hpp>
#include <boost/asio/io_context.hpp>
#include <boost/asio/steady_timer.hpp>
#include <boost/asio/strand.hpp>
#include <boost/system/detail/error_code.hpp>
#include <gtest/gtest.h>
 
#include <atomic>
#include <chrono>
#include <condition_variable>
#include <functional>
#include <memory>
#include <mutex>
#include <thread>
 
namespace sol3::process_manager {
 
class StrandTestFixture : public ::testing::Test {
 protected:
  void runAfter(std::chrono::milliseconds delay, std::function<void()> func) {
    runAfterOn(io_.get_executor(), delay, std::move(func));
  }
 
  void runAfterInStrand(
      std::chrono::milliseconds delay, std::function<void()> func) {
    runAfterOn(strand_, delay, std::move(func));
  }
 
  void runWithWatchdog(
      std::chrono::milliseconds timeout,
      std::function<void()> on_success_in_strand) {
    std::atomic<bool> done{false};
    std::mutex mutex;
    std::condition_variable cv;
 
    std::thread watchdog([&] {
      std::unique_lock lock(mutex);
      bool timed_out =
          !cv.wait_for(lock, timeout, [&done] { return done.load(); });
      if (timed_out) {
        ADD_FAILURE() << "io loop did not exit within " << timeout.count()
                      << "ms";
        io_.stop();
      }
    });
 
    try {
      io_.run();
    } catch (...) {
      done = true;
      cv.notify_one();
      if (watchdog.joinable()) {
        watchdog.join();
      }
      throw;
    }
    done = true;
    cv.notify_one();
    watchdog.join();
    io_.restart();
    if (io_.stopped()) {
      ADD_FAILURE() << "Watchdog timed out. Cannot run final checks";
      return;
    }
    boost::asio::dispatch(strand_, on_success_in_strand);
    io_.restart();
    io_.run_one();
  }
 
  void SetUp() override {
    sol3::core::setupLogging();
    strand_ = boost::asio::make_strand(io_);
  }
 
  boost::asio::io_context io_;
  asio::Strand strand_{boost::asio::make_strand(io_)};
 
 private:
  static void runAfterOn(
      boost::asio::any_io_executor ctx,
      std::chrono::milliseconds delay,
      std::function<void()> func) {
    auto timer = std::make_shared<boost::asio::steady_timer>(ctx, delay);
    timer->async_wait(
        [timer, func = std::move(func)](boost::system::error_code ec) {
          if (ec) {
            ADD_FAILURE() << "Unexpected error in timer: " << ec.message();
            return;
          }
          func();
        });
  }
};
 
}  // namespace sol3::process_manager