testAsyncOpAwaitState.cpp

Go to the documentation of this file.

/**
 * @file
 * @ingroup daq_ocm_libdaq_test
 * @copyright 2022 ESO - European Southern Observatory
 *
 * @brief Unit test for op::AwaitStateAsync
 */
#include <daq/config.hpp>
 
#include <gtest/gtest.h>
#include <log4cplus/logger.h>
 
#include <daq/error.hpp>
#include <daq/op/awaitState.hpp>
#include <daq/op/initiate.hpp>
 
#include "utils.hpp"
 
using namespace daq;
using namespace ::testing;
using namespace std::chrono_literals;
 
/**
 * @ingroup daq_ocm_libdaq_test
 */
struct TestAsyncOpAwaitState : ::testing::Test {
    TestAsyncOpAwaitState()
        : m_io_ctx()
        , m_executor(m_io_ctx)
        , m_status()
        , m_logger(log4cplus::Logger::getInstance("test")) {
    }
 
    void SetUp() override {
        m_status = std::make_shared<ObservableStatus>("id", "fileid");
    }
    void TearDown() override {
    }
 
    boost::asio::io_context m_io_ctx;
    rad::IoExecutor m_executor;
    std::shared_ptr<daq::ObservableStatus> m_status;
    log4cplus::Logger m_logger;
};
 
TEST_F(TestAsyncOpAwaitState, ConditionAlreadySatisfiedReturnsReadyFuture) {
    // Test
    op::AwaitStateAsync op(m_io_ctx, m_status, State::NotStarted, 100ms, m_logger);
    auto fut = op.Initiate();
    ASSERT_TRUE(fut.is_ready());
    auto result = fut.get();
    EXPECT_FALSE(result.error);
    EXPECT_EQ(result.result, *m_status);
}
 
TEST_F(TestAsyncOpAwaitState, ConditionSatisfiedByStateChange) {
    // Setup
    // Test
    auto [fut, abort] = op::InitiateAbortableOperation<op::AwaitStateAsync>(
        m_executor, m_io_ctx, m_status, State::Acquiring, 100ms, m_logger);
    (void)abort;
 
    EXPECT_FALSE(fut.is_ready());
    m_io_ctx.poll();
    EXPECT_FALSE(fut.is_ready());
 
    m_status->SetState(State::Acquiring);
    MakeTestProgress(m_io_ctx, &fut);
    ASSERT_TRUE(fut.is_ready());
 
    auto result = fut.get();
    EXPECT_FALSE(result.error);
    EXPECT_EQ(result.result, *m_status);
}
 
TEST_F(TestAsyncOpAwaitState, ConditionTimesOut) {
    // Setup
    // Test
    auto [fut, abort] = op::InitiateAbortableOperation<op::AwaitStateAsync>(
        m_executor, m_io_ctx, m_status, State::Acquiring, 0ms, m_logger);
    (void)abort;
 
    MakeTestProgress(m_io_ctx, &fut);
    ASSERT_TRUE(fut.is_ready());
 
    auto result = fut.get();
    EXPECT_TRUE(result.error);
    EXPECT_EQ(result.result, *m_status);
}
 
TEST_F(TestAsyncOpAwaitState, OperationAborted) {
    // Setup
    // Test
    auto [fut, abort] = op::InitiateAbortableOperation<op::AwaitStateAsync>(
        m_executor, m_io_ctx, m_status, State::Acquiring, 100ms, m_logger);
 
    abort();
    MakeTestProgress(m_io_ctx, &fut);
    ASSERT_TRUE(fut.is_ready());
 
    EXPECT_THROW(fut.get(), DaqOperationAborted);
}
 
TEST_F(TestAsyncOpAwaitState, ConditionSatisfiedAtTimeout) {
    // Setup
    // Test
    auto [fut, abort] = op::InitiateAbortableOperation<op::AwaitStateAsync>(
        m_executor, m_io_ctx, m_status, State::Acquiring, 0ms, m_logger);
    (void)abort;
 
    // Hack to bypass observer notification
    auto& mut_status = const_cast<Status&>(m_status->GetStatus());
    mut_status.state = State::Acquiring;
 
    MakeTestProgress(m_io_ctx, &fut);
    ASSERT_TRUE(fut.is_ready());
 
    auto result = fut.get();
    EXPECT_FALSE(result.error);
    EXPECT_EQ(result.result, *m_status);
}