testDpmClient.cpp

Go to the documentation of this file.

/**
 * @file
 * @ingroup daq_ocm_libdaq_test
 * @copyright 2023 ESO - European Southern Observatory
 *
 * @brief `daq::DpmClientImpl` tests
 */
#include <daq/config.hpp>
 
#include <optional>
 
#include <gmock/gmock.h>
#include <gtest/gtest.h>
 
#include "mock/daqifMock.hpp"
#include "mock/malMock.hpp"
 
#include <daq/dpmClient.hpp>
#include <daq/json.hpp>
 
using namespace ::testing;
 
namespace daq {
class TestDpmClient : public Test {
public:
    void SetUp() {
        m_params.ps_uri = "zpb.ps://127.0.0.1:1234";
        m_params.rr_uri = "zpb.rr://127.0.0.1:1234";
        m_params.timeout = std::chrono::seconds(0);
        m_params.status_retry_interval = std::chrono::seconds(0);
 
        Status s("id", "id");
        {
            nlohmann::json j = s;
            m_status_1 = j.dump(2);
        }
        m_status_2 = m_status_1;
    }
 
    void PostSetUp() {
        m_daqif_client = new DpmDaqControlAsyncMock();
        m_status_subscriber = new SubscriberMock<daqif::InternalDaqStatus>();
        m_storage_subscriber = new SubscriberMock<daqif::StorageStatus>();
 
        // DpmClient constructor sets up subscriptions for DaqStatus and StorageStatus.
        EXPECT_CALL(
            *m_status_subscriber,
            subscribeAsync(
                _, Matcher<SubscriberMock<daqif::InternalDaqStatus>::DataEventListener>(_)));
        EXPECT_CALL(
            *m_storage_subscriber,
            subscribeAsync(_, Matcher<SubscriberMock<daqif::StorageStatus>::DataEventListener>(_)));
        EXPECT_CALL(m_mal, getClientUnsafe(_, _, _, _, _)).WillOnce(Return(m_daqif_client));
        EXPECT_CALL(m_mal, getSubscriberUnsafe(_, "daqif_InternalDaqStatus", _, _, _))
            .WillOnce(Return(m_status_subscriber));
        EXPECT_CALL(m_mal, getSubscriberUnsafe(_, "daqif_StorageStatus", _, _, _))
            .WillOnce(Return(m_storage_subscriber));
 
        m_client.emplace(m_io_ctx, m_mal, m_params);
    }
 
    void PollOnce() {
        m_io_ctx.restart();
        m_io_ctx.poll();
    }
 
protected:
    boost::asio::io_context m_io_ctx;
    DpmClientParams m_params;
    MalMock m_mal;
    DpmDaqControlAsyncMock* m_daqif_client;  // Ownership transferred via MalMock to DpmClientImpl
    SubscriberMock<daqif::InternalDaqStatus>* m_status_subscriber;
    SubscriberMock<daqif::StorageStatus>* m_storage_subscriber;
 
    std::string m_status_1;
    std::string m_status_2;
    std::optional<DpmClientImpl> m_client;
};
 
TEST_F(TestDpmClient, StartMonitoringSendsRequestAndReceivesReply) {
    // Setup
    PostSetUp();
 
    boost::promise<std::string> reply;
 
    EXPECT_CALL(*m_daqif_client, GetInternalDaqStatus("id"))
        .WillOnce(Return(ByMove(reply.get_future())));
 
    // Run
    m_client->StartMonitorStatus("id");
    PollOnce();
 
    reply.set_value(m_status_1);
 
    PollOnce();
}
 
TEST_F(TestDpmClient, StartMonitoringSendsRequestAndRetriesOnTimeout) {
    // Setup
    PostSetUp();
 
    boost::promise<std::string> reply1;
    boost::promise<std::string> reply2;
    InSequence s;
 
    {
        EXPECT_CALL(*m_daqif_client, GetInternalDaqStatus("id"))
            .WillOnce(Return(ByMove(reply1.get_future())));
 
        // Run
        m_client->StartMonitorStatus("id");
        PollOnce();
    }
 
    {
        EXPECT_CALL(*m_daqif_client, GetInternalDaqStatus("id"))
            .WillOnce(Return(ByMove(reply2.get_future())));
        reply1.set_exception(elt::mal::TimeoutException("timeout"));
        PollOnce();
 
        reply2.set_value(m_status_1);
        PollOnce();
    }
}
 
}  // namespace daq