testDpmService.cpp

Go to the documentation of this file.

/**
 * @file
 * @ingroup daq_common_libdpm
 * @copyright (c) Copyright ESO 2022
 * All Rights Reserved
 * ESO (eso.org) is an Intergovernmental Organisation, and therefore special legal conditions apply.
 *
 * @brief Unit tests for daq::dpm::DpmService
 */
 
#include <daq/dpm/scheduler.hpp>
 
#include <utility>
 
#include <gmock/gmock.h>
#include <gtest/gtest.h>
 
#include <daq/test/progress.hpp>
 
#include "daqifFake.hpp"
#include "mock/mockMal.hpp"
#include "mock/mockScheduler.hpp"
#include "mock/mockWorkspace.hpp"
#include <daq/dpm/dpmService.hpp>
 
namespace daq::dpm {
 
class TestDpmService : public ::testing::Test {
public:
    TestDpmService() : m_io_ctx(), m_executor(m_io_ctx) {
    }
 
    void SetUp() override {
        m_service =
            std::make_unique<DpmService>(m_executor, m_mal_mock, m_ws_mock, m_scheduler_mock);
    }
    void TearDown() override {
        // Execute possibly pending completions handlers.
        EXPECT_NO_THROW(m_io_ctx.poll());
    }
 
protected:
    boost::asio::io_context m_io_ctx;
    rad::IoExecutor m_executor;
 
    MockMal m_mal_mock;
    daq::dpm::MockWorkspace m_ws_mock;
    daq::dpm::MockScheduler m_scheduler_mock;
 
    std::unique_ptr<DpmService> m_service;
};
 
using namespace ::testing;
 
TEST_F(TestDpmService, QueryStorageStatusSuceeds) {
    // Setup
    std::filesystem::space_info status = {};
    status.available = 123;
    status.free = 456;
    status.capacity = 789;
 
    EXPECT_CALL(m_ws_mock, QueryStorageStatus()).WillOnce(Return(status));
 
    auto* fake_reply(new daqif::StorageStatusFake);
    EXPECT_CALL(m_mal_mock, getDataEntityUnsafe(_, "daqif_StorageStatus"))
        .WillOnce(Return(fake_reply))
        .RetiresOnSaturation();
 
    // Run
    auto fut = m_service->QueryStorageStatus();
    m_io_ctx.poll();
 
    ASSERT_TRUE(fut.is_ready());
    auto daqif_status = fut.get();
    EXPECT_EQ(daqif_status->getCapacity(), status.capacity);
    EXPECT_EQ(daqif_status->getFree(), status.free);
    EXPECT_EQ(daqif_status->getAvailable(), status.available);
}
 
TEST_F(TestDpmService, QueryStorageStatusFails) {
    // Setup
    EXPECT_CALL(m_ws_mock, QueryStorageStatus()).WillOnce(Throw(std::runtime_error("ERROR")));
 
    // Run
    auto fut = m_service->QueryStorageStatus();
    m_io_ctx.poll();
 
    ASSERT_TRUE(fut.is_ready());
    EXPECT_THROW(fut.get(), daqif::Exception);
}
 
TEST_F(TestDpmService, QueueDaqSucceeds) {
    // Setup
    auto* fake_reply(new daqif::DaqReplyFake);
    EXPECT_CALL(m_mal_mock, getDataEntityUnsafe(_, "daqif_DaqReply"))
        .WillOnce(Return(fake_reply))
        .RetiresOnSaturation();
    EXPECT_CALL(m_scheduler_mock, QueueDaq("SPEC")).WillOnce(Return("ID"));
 
    // Run
    auto fut = m_service->QueueDaq("SPEC");
    m_io_ctx.poll();
 
    ASSERT_TRUE(fut.is_ready());
    auto reply = fut.get();
    EXPECT_EQ(reply->getId(), "ID");
}
 
TEST_F(TestDpmService, QueueDaqThrows) {
    // Setup
    EXPECT_CALL(m_scheduler_mock, QueueDaq("SPEC")).WillOnce(Throw(std::runtime_error("ID")));
 
    // Run
    auto fut = m_service->QueueDaq("SPEC");
    m_io_ctx.poll();
 
    ASSERT_TRUE(fut.is_ready());
    EXPECT_THROW(fut.get(), daqif::DaqException);
}
 
TEST_F(TestDpmService, AbortDaqSucceeds) {
    // Setup
    auto* fake_reply(new daqif::DaqReplyFake);
    EXPECT_CALL(m_mal_mock, getDataEntityUnsafe(_, "daqif_DaqReply"))
        .WillOnce(Return(fake_reply))
        .RetiresOnSaturation();
    EXPECT_CALL(m_scheduler_mock, AbortDaq("TEST.ID")).Times(1);
 
    // Run
    auto fut = m_service->AbortDaq("TEST.ID");
    m_io_ctx.poll();
 
    ASSERT_TRUE(fut.is_ready());
    auto reply = fut.get();
    EXPECT_EQ(reply->getId(), "TEST.ID");
    EXPECT_FALSE(reply->getError());
}
 
TEST_F(TestDpmService, AbortDaqThrows) {
    // Setup
    EXPECT_CALL(m_scheduler_mock, AbortDaq("ID")).WillOnce(Throw(std::runtime_error("ID")));
 
    // Run
    auto fut = m_service->AbortDaq("ID");
    m_io_ctx.poll();
 
    ASSERT_TRUE(fut.is_ready());
    EXPECT_THROW(fut.get(), daqif::DaqException);
}
 
TEST_F(TestDpmService, GetDaqStatusSucceeds) {
    // Setup
    auto* fake_reply(new daqif::DaqStatusFake);
    EXPECT_CALL(m_mal_mock, getDataEntityUnsafe(_, "daqif_DaqStatus"))
        .WillOnce(Return(fake_reply))
        .RetiresOnSaturation();
 
    Status status = {};
    status.id = "TEST.ID";
    status.state = State::Merging;
    EXPECT_CALL(m_scheduler_mock, GetDaqStatus("TEST.ID")).WillOnce(Return(status));
 
    // Run
    auto fut = m_service->GetDaqStatus("TEST.ID");
    m_io_ctx.poll();
 
    ASSERT_TRUE(fut.is_ready());
    auto reply = fut.get();
    EXPECT_EQ(reply->getId(), "TEST.ID");
    EXPECT_EQ(reply->getState(), daqif::StateMerging);
    EXPECT_EQ(reply->getSubState(), daqif::Merging);
    EXPECT_FALSE(reply->getError());
}
 
TEST_F(TestDpmService, GetDaqStatusThrows) {
    // Setup
    EXPECT_CALL(m_scheduler_mock, GetDaqStatus("TEST.ID"))
        .WillOnce(Throw(std::runtime_error("oops")));
 
    // Run
    auto fut = m_service->GetDaqStatus("TEST.ID");
    m_io_ctx.poll();
 
    ASSERT_TRUE(fut.is_ready());
    EXPECT_THROW(fut.get(), daqif::DaqException);
}
 
TEST_F(TestDpmService, GetActiveDaqsSucceeds) {
    // Setup
    auto* fake_reply1(new daqif::DaqStatusFake);
    auto* fake_reply2(new daqif::DaqStatusFake);
    EXPECT_CALL(m_mal_mock, getDataEntityUnsafe(_, "daqif_DaqStatus"))
        .WillOnce(Return(fake_reply1))
        .WillOnce(Return(fake_reply2))
        .RetiresOnSaturation();
 
    Status status1 = {};
    status1.id = "TEST.ID";
    status1.state = State::Transferring;
 
    Status status2 = {};
    status2.id = "TEST.ID2";
    status2.state = State::AbortingMerging;
 
    std::vector<std::string> ids = {"TEST.ID", "TEST.ID2"};
    EXPECT_CALL(m_scheduler_mock, GetQueue()).WillOnce(Return(ids));
    EXPECT_CALL(m_scheduler_mock, GetDaqStatus("TEST.ID")).WillOnce(Return(status1));
    EXPECT_CALL(m_scheduler_mock, GetDaqStatus("TEST.ID2")).WillOnce(Return(status2));
 
    // Run
    auto fut = m_service->GetActiveDaqs();
    m_io_ctx.poll();
 
    ASSERT_TRUE(fut.is_ready());
    std::vector<std::shared_ptr<::daqif::DaqStatus>> reply = fut.get();
    ASSERT_EQ(reply.size(), 2u);
 
    EXPECT_EQ(reply[0]->getId(), "TEST.ID");
    EXPECT_EQ(reply[0]->getState(), daqif::StateMerging);
    EXPECT_EQ(reply[0]->getSubState(), daqif::Transferring);
    EXPECT_FALSE(reply[0]->getError());
 
    EXPECT_EQ(reply[1]->getId(), "TEST.ID2");
    EXPECT_EQ(reply[1]->getState(), daqif::StateMerging);
    EXPECT_EQ(reply[1]->getSubState(), daqif::Aborting);
    EXPECT_FALSE(reply[1]->getError());
}
 
TEST_F(TestDpmService, GetActiveDaqsThrowws) {
    // Setup
    std::vector<std::string> ids = {"TEST.ID", "TEST.ID2"};
    EXPECT_CALL(m_scheduler_mock, GetQueue()).WillOnce(Return(ids));
    EXPECT_CALL(m_scheduler_mock, GetDaqStatus("TEST.ID"))
        .WillOnce(Throw(std::runtime_error("oops")));
 
    // Run
    auto fut = m_service->GetActiveDaqs();
    m_io_ctx.poll();
 
    ASSERT_TRUE(fut.is_ready());
    EXPECT_THROW(fut.get(), daqif::DaqException);
}
}  // namespace daq::dpm