testFitsController.cpp

Go to the documentation of this file.

/**
 * @file
 * @ingroup daq_ocm_libdaq_test
 * @copyright 2021 ESO - European Southern Observatory
 *
 * @brief Unit test for `daq::FitsControllerImpl`
 */
#include <daq/fitsController.hpp>
#include <gtest/gtest.h>
#include <gmock/gmock.h>
 
using namespace daq;
using namespace ::testing;
using namespace std::chrono;
 
//namespace {
static daq::fits::UniqueFitsFile s_reclaimed =
    fits::UniqueFitsFile(nullptr, daq::fits::DefaultClose);
 
void FitsfileReclaimer(fitsfile* ptr) noexcept {
    s_reclaimed.reset();
    fitsfile* newptr = nullptr;
    int status = 0;
    // We have to reopen the fitsfile, otherwise certain fits functions (e.g. fits_get_hdu_nums)
    // will not report the correct state.
    fits_reopen_file(ptr, &newptr, &status);
    fits_close_file(ptr, &status);
    s_reclaimed.reset(newptr);
}
 
constexpr size_t FITS_INITIAL_BUFFER_SIZE = 4 * 2880;
 
//}  // namespace
 
/**
 * Fixture for daq::FitsControllerImpl test
 *
 * @ingroup daq_ocm_libdaq_test
 */
class TestFitsController : public ::testing::Test {
public:
    /**
     * Creates an in-memory FITS file that is reclaimed into @c s_reclaimed when released by
     * FitsController. This fitsfile is finally closed when @c s_reclaimed is reset.
     */
    void SetUp() override {
        m_properties.dp_name_prefix = "";
        m_properties.ocm_dppart_root = "/tmp";
        m_properties.id = "test";
 
        s_reclaimed.reset();
        m_event_log = std::make_shared<ObservableEventLog>();
        m_fitsbuf = malloc(FITS_INITIAL_BUFFER_SIZE);
        memset(m_fitsbuf, 0, FITS_INITIAL_BUFFER_SIZE);
        m_ctl =
            std::make_unique<FitsControllerImpl>(m_properties, m_event_log, [&](char const* path) {
                fitsfile* ptr = nullptr;
                int status = 0;
                m_fitsbufsize = FITS_INITIAL_BUFFER_SIZE;
                // note: function will keep references to m_fitsbuf and m_fitsbufsize pointers, so
                // they must outlive the fitsfile.
                fits_create_memfile(&ptr, &m_fitsbuf, &m_fitsbufsize, 0, realloc, &status);
                if (status != 0) {
                    std::cerr<< "Failed to create fits_memfile";
                    std::terminate();
                }
                return fits::UniqueFitsFile(ptr, FitsfileReclaimer);
            });
        ASSERT_EQ(State::NotStarted, m_ctl->GetState());
    }
 
    void TearDown() override {
        m_ctl.reset();
        s_reclaimed.reset();
        int status = 0;
        fits_free_memory(m_fitsbuf, &status);
        m_fitsbuf = nullptr;
    }
 
protected:
    DaqProperties m_properties;
    void* m_fitsbuf;
    size_t m_fitsbufsize;
    std::shared_ptr<ObservableEventLog> m_event_log;
    std::unique_ptr<FitsControllerImpl> m_ctl;
};
 
 
TEST_F(TestFitsController, AbortNotStartedSucceeds) {
    // Run
    m_ctl->Abort(ErrorPolicy::Strict);
    EXPECT_EQ(State::Aborted, m_ctl->GetState());
    ASSERT_FALSE(s_reclaimed) << "There should have been no FITS file to reclaim since not started";
}
 
TEST_F(TestFitsController, UpdateKeywordsFailsIfAborted) {
    // Setup
    m_ctl->Abort(ErrorPolicy::Strict);
    ASSERT_EQ(State::Aborted, m_ctl->GetState());
    // Run
    EXPECT_THROW(m_ctl->UpdateKeywords({}),
                 std::runtime_error);
}
 
TEST_F(TestFitsController, AddCommentFailsIfAborted) {
    // Setup
    m_ctl->Abort(ErrorPolicy::Strict);
    ASSERT_EQ(State::Aborted, m_ctl->GetState());
    // Run
    EXPECT_THROW(m_ctl->AddComment({}),
                 std::runtime_error);
}
 
TEST_F(TestFitsController, UpdateKeywordsFailsIfStopped) {
    // Setup
    m_ctl->Start();
    m_ctl->Stop(ErrorPolicy::Strict);
    ASSERT_EQ(State::Stopped, m_ctl->GetState());
    // Run
    EXPECT_THROW(m_ctl->UpdateKeywords({}),
                 std::runtime_error);
}
 
TEST_F(TestFitsController, AddCommentFailsIfStopped) {
    // Setup
    m_ctl->Start();
    m_ctl->Stop(ErrorPolicy::Strict);
    ASSERT_EQ(State::Stopped, m_ctl->GetState());
    // Run
    EXPECT_THROW(m_ctl->AddComment({}),
                 std::runtime_error);
}
 
TEST_F(TestFitsController, StartAlreadyStartedFails) {
    // Setup
    m_ctl->Start();
    // Run
    EXPECT_THROW(m_ctl->Start(),
                 std::runtime_error);
}
 
TEST_F(TestFitsController, StopAlreadyStoppedFails) {
    // Setup
    m_ctl->Start();
    m_ctl->Stop(ErrorPolicy::Strict);
 
    // Run
    EXPECT_THROW(m_ctl->Stop(ErrorPolicy::Strict),
                 std::runtime_error);
}
 
TEST_F(TestFitsController, AbortAlreadyStoppedFails) {
    // Setup
    m_ctl->Start();
    m_ctl->Stop(ErrorPolicy::Strict);
 
    // Run
    EXPECT_THROW(m_ctl->Abort(ErrorPolicy::Strict),
                 std::runtime_error);
}
 
 
TEST_F(TestFitsController, AbortAcquiringSucceeds) {
    // Setup
    m_ctl->Start();
 
    // Run
    m_ctl->Abort(ErrorPolicy::Strict);
    EXPECT_EQ(State::Aborted, m_ctl->GetState());
    // There should be no result
    auto res = m_ctl->GetResult();
    ASSERT_FALSE(res);
    ASSERT_TRUE(s_reclaimed) << "Abort() should have closed FITS file";
}
 
TEST_F(TestFitsController, StartCreatesFitsfile) {
    // Run
    EXPECT_FALSE(m_ctl->GetFitsfile());
 
    m_ctl->Start();
    EXPECT_EQ(State::Acquiring, m_ctl->GetState());
 
    EXPECT_TRUE(m_ctl->GetFitsfile());
    // There should be no result yet
    auto res = m_ctl->GetResult();
    ASSERT_FALSE(res);
}
 
TEST_F(TestFitsController, StopClosesFitsfileAndProduceResult) {
    // Setup
    m_ctl->Start();
    ASSERT_EQ(State::Acquiring, m_ctl->GetState());
 
    // Run
    m_ctl->Stop(ErrorPolicy::Strict);
    EXPECT_EQ(State::Stopped, m_ctl->GetState());
 
    // There should be a result at this point
    auto res = m_ctl->GetResult();
    ASSERT_TRUE(res);
    EXPECT_NE(res->origin, "");
    ASSERT_TRUE(std::holds_alternative<std::string>(res->info));
    EXPECT_THAT(std::get<std::string>(res->info), EndsWith(":/tmp/test_ocm.fits"));
    ASSERT_TRUE(s_reclaimed.get());
 
    // Check content of FITS file
    int status = 0;
    {
 
        int hdu_num = -1;
        EXPECT_EQ(0, fits_get_num_hdus(s_reclaimed.get(), &hdu_num, &status));
        EXPECT_EQ(1, hdu_num);
    }
    {
        int hdu_type = -1;
        EXPECT_EQ(0, fits_get_hdu_type(s_reclaimed.get(), &hdu_type, &status));
        EXPECT_EQ(IMAGE_HDU, hdu_type);
    }
    // @todo Validate keywords using dictionary system (when that is available)
}