testAsyncOpStart.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::StartAsync
 */
#include <daq/config.hpp>
 
#include <gmock/gmock.h>
#include <gtest/gtest.h>
#include <log4cplus/logger.h>
 
#include <daq/op/initiate.hpp>
#include <daq/op/start.hpp>
#include <daq/error.hpp>
 
#include "mock/metadaqifMock.hpp"
#include "mock/recifMock.hpp"
#include "testAsyncOpBase.hpp"
 
using namespace daq;
using namespace ::testing;
 
/**
 * @ingroup daq_ocm_libdaq_test
 */
struct TestAsyncOpStart : TestAsyncOpBase {
 
};
 
TEST_F(TestAsyncOpStart, Start) {
    // Setup
    boost::promise<std::shared_ptr<metadaqif::DaqReply>> reply_promise;
    auto reply_mock = std::make_shared<DaqReplyMock>();
    boost::promise<std::shared_ptr<metadaqif::DaqReply>> reply_promise2;
    auto reply_mock2 = std::make_shared<DaqReplyMock>();
    // Set up mock so that StartDaq invocation returns the future from our promise.
    EXPECT_CALL(*m_meta_rr_client, StartDaq("id"))
        .WillOnce(Return(ByMove(reply_promise.get_future())));
    EXPECT_CALL(*m_meta_rr_client2, StartDaq("id"))
        .WillOnce(Return(ByMove(reply_promise2.get_future())));
    
    boost::promise<std::shared_ptr<recif::RecStatus>> prim_promise_1;
    boost::promise<std::shared_ptr<recif::RecStatus>> prim_promise_2;
    auto prim_reply_mock_1 = std::make_shared<RecStatusMock>();
    EXPECT_CALL(*m_prim_rr_client, RecStart(RecPropertyIdEq("id")))
        .WillOnce(Return(ByMove(prim_promise_1.get_future())));
    EXPECT_CALL(*m_prim_rr_client2, RecStart(RecPropertyIdEq("id")))
        .WillOnce(Return(ByMove(prim_promise_2.get_future())));
 
    // Run
    boost::future<void> fut = op::InitiateOperation<op::StartAsync>(MakeParams());
    EXPECT_FALSE(fut.is_ready());
 
    // "Send reply"
    reply_promise.set_value(reply_mock);
    reply_promise2.set_value(reply_mock2);
    prim_promise_1.set_value(prim_reply_mock_1);
    prim_promise_2.set_value(prim_reply_mock_1);
 
    // Execute scheduled handlers
    MakeTestProgress(m_io_ctx, &fut);
 
    ASSERT_TRUE(fut.is_ready());
    ASSERT_FALSE(fut.has_exception());
}
 
 
TEST_F(TestAsyncOpStart, StartingFailsToSendStartDaqWillAbortAndSetErrorFlagAndStayInStarting) {
    // Setup
    // Set up mock so that StartDaq throws exception.
    EXPECT_CALL(*m_meta_rr_client, StartDaq(_))
        .WillOnce(Throw(std::runtime_error("Fake test failure")));
 
    // Second client is never started since first fails
    EXPECT_CALL(*m_meta_rr_client2, StartDaq(_)).Times(0);
 
    // Run
    boost::future<void> fut = op::InitiateOperation<op::StartAsync>(MakeParams());
    EXPECT_FALSE(fut.is_ready());
 
    // Make source 2 ready
    // Run async handlers
    MakeTestProgress(m_io_ctx, &fut);
 
    ASSERT_TRUE(fut.is_ready());
    EXPECT_TRUE(fut.has_exception()) << "Expected future to contain exception";
    EXPECT_THROW(fut.get(), std::exception) << "Expected exception to derive from std::exception";
}
 
 
TEST_F(TestAsyncOpStart, StartAsyncFutureHasExceptionIfStartDaqReturnsError) {
    // Setup
    boost::promise<std::shared_ptr<metadaqif::DaqReply>> reply_promise;
    auto reply_mock = std::make_shared<DaqReplyMock>();
    EXPECT_CALL(*reply_mock, getMessage()).WillRepeatedly(Return(std::string("some message")));
 
    boost::promise<std::shared_ptr<metadaqif::DaqReply>> reply_promise2;
    auto reply_mock2 = std::make_shared<DaqReplyMock>();
    EXPECT_CALL(*reply_mock2, getMessage()).WillRepeatedly(Return(std::string("some message")));
 
    // Set up mock so that StartDaq invocation returns the future from our promise.
    EXPECT_CALL(*m_meta_rr_client, StartDaq(_))
        .WillOnce(Return(ByMove(reply_promise.get_future())));
 
    EXPECT_CALL(*m_meta_rr_client2, StartDaq(_))
        .WillOnce(Return(ByMove(reply_promise2.get_future())));
 
    // Run
    boost::future<void> fut = op::InitiateOperation<op::StartAsync>(MakeParams());
    EXPECT_FALSE(fut.is_ready());
 
    // "Send error reply"
    reply_promise.set_exception(metadaqif::DaqException("foo", "baz"));
    reply_promise2.set_value(reply_mock2);
 
    // Execute scheduled handlers
    MakeTestProgress(m_io_ctx, &fut);
 
    ASSERT_TRUE(fut.is_ready());
    EXPECT_THROW(fut.get(), DaqSourceErrors);
}