testMerge.cpp

Go to the documentation of this file.

/**
 * @file
 * @ingroup daq_dpm_merge_test
 * @copyright ESO - European Southern Observatory
 */
#include "merge.hpp"
 
#include <fmt/format.h>
#include <gmock/gmock.h>
#include <gtest/gtest.h>
#include <log4cplus/loggingmacros.h>
 
#include <daq/fits/cfitsio.hpp>
 
using namespace ::testing;
 
namespace daq::dpm::merge {
 
struct MockReporter : StatusReporter {
    MOCK_METHOD(void, PostAlert, (std::string const& id, std::string const& message), (override));
};
 
struct MockFormatter : KeywordFormatter {
    MOCK_METHOD(fits::LiteralKeyword, FormatKeyword, (fits::KeywordVariant const& keyword), ());
};
 
struct MockSorter : KeywordSorter {
    MOCK_METHOD(void, SortKeywords, (std::vector<fits::LiteralKeyword> & keywords), ());
};
 
struct MockKeywordProcessor : KeywordRuleProcessor {
    MOCK_METHOD(fits::KeywordVector,
                Process,
                (fits::KeywordVector const&, KeywordRuleProcessor::DefaultRule),
                (const, override));
};
 
/**
 * Fixture that sets up a in-place target FITS file with standard HDU keywords
 * - SIMPLE
 * - BITPIX
 * - NAXIS
 * - EXTEND
 */
class TestMergeKeywords : public Test {
public:
    TestMergeKeywords()
        : Test()
        , m_dry_run(false)
        , m_mock_reporter()
        , m_mock_formatter()
        , m_mock_sorter()
        , m_logger(log4cplus::Logger::getInstance("test.dpm.merge"))
        , m_ops{m_mock_reporter, m_mock_formatter, m_mock_sorter, m_logger}
        , m_params{"arcfile.fits", "origfile.fits"}
        , m_target_buffer(4096u)
        , m_target("target",
                   "fakefile.fits",
                   std::nullopt,
                   std::make_unique<StandardKeywordRuleProcessor>(),
                   std::move(m_target_buffer).GetOwnedFile()) {
    }
 
    void SetUp() override {
        fits::InitPrimaryHduNoImage(m_target.GetFitsFile());
 
        // clang-format off
        ON_CALL(m_mock_formatter, FormatKeyword(_))
            .WillByDefault(
                Invoke([](auto const& kw) {
                    return fits::Format(kw);
                    }
                )
            );
        // clang-format on
    }
    void TearDown() override {
    }
    void ExpectStandardKeywords(std::vector<fits::LiteralKeyword>& kws) {
        auto datasum = kws.back();
        kws.pop_back();
        auto checksum = kws.back();
        kws.pop_back();
        EXPECT_EQ("DATASUM", datasum.GetName().name);
        EXPECT_EQ("CHECKSUM", checksum.GetName().name);
 
        auto arcfile = kws.back();
        kws.pop_back();
        auto origfile = kws.back();
        kws.pop_back();
 
        EXPECT_EQ("ORIGFILE", origfile.GetName().name);
        EXPECT_EQ(fmt::format("'{}'", m_params.origfile), origfile.GetComponents().value);
        EXPECT_EQ("ARCFILE", arcfile.GetName().name);
        EXPECT_EQ(fmt::format("'{}'", m_params.arcfile), arcfile.GetComponents().value);
    }
 
    bool m_dry_run;
    MockReporter m_mock_reporter;
    MockFormatter m_mock_formatter;
    MockSorter m_mock_sorter;
 
    log4cplus::Logger m_logger;
 
    Operations m_ops;
    Params m_params;
    fits::MemoryFitsFile m_target_buffer;
 
    TargetSource m_target;
};
 
TEST_F(TestMergeKeywords, MergeEmptyStillSortsKeywords) {
    // Setup
    std::vector<SourceTypes> sources;
 
    auto before = fits::ReadKeywords(m_target.GetFitsFile(), 1);
    EXPECT_CALL(m_mock_formatter, FormatKeyword(_)).WillRepeatedly(DoDefault());
    EXPECT_CALL(m_mock_sorter, SortKeywords(_));
 
    // Test
    Merge(m_ops, m_params, m_target, sources, m_dry_run);
    auto after = fits::ReadKeywords(m_target.GetFitsFile(), 1);
    ASSERT_EQ(after.size(), before.size() + 4u)
        << "4 keywords should be added by DPM (2x checksum, ARCFILE, ORIFILE)";
    ExpectStandardKeywords(after);
    EXPECT_THAT(after, ContainerEq(before));
}
 
/** Test that primary HDU keywords are sorted */
TEST_F(TestMergeKeywords, NoSourceStillSortsPrimaryHdu) {
    // Setup
    std::vector<SourceTypes> sources;
    auto before = fits::ReadKeywords(m_target.GetFitsFile(), 1);
 
    EXPECT_CALL(m_mock_formatter, FormatKeyword(_)).WillRepeatedly(DoDefault());
    EXPECT_CALL(m_mock_sorter, SortKeywords(_));
 
    // Test
    Merge(m_ops, m_params, m_target, sources, m_dry_run);
    auto after = fits::ReadKeywords(m_target.GetFitsFile(), 1);
    ASSERT_EQ(after.size(), before.size() + 4u)
        << "4 keywords should be added by DPM (2x checksum, ARCFILE, ORIFILE)";
    ExpectStandardKeywords(after);
 
    EXPECT_THAT(after, ContainerEq(before));
}
 
/** Test merging some keywords from a single source */
TEST_F(TestMergeKeywords, MergeSingleKeywordList) {
    // Setup
    std::vector<SourceTypes> sources;
    auto kw1 = fits::LiteralKeyword("HIERARCH ESO UNKN A = T / Comment");
    auto kw2 = fits::LiteralKeyword("HIERARCH ESO UNKN B = T / Comment");
    fits::KeywordVector kws = {kw1, kw2};
 
    sources.emplace_back(std::in_place_type<FitsKeywordsSource>,
                         "tcs",
                         kws,
                         std::nullopt,
                         std::make_unique<StandardKeywordRuleProcessor>());
    auto expected_kws = fits::ReadKeywords(m_target.GetFitsFile(), 1);
    expected_kws.push_back(kw1);
    expected_kws.push_back(kw2);
 
    EXPECT_CALL(m_mock_formatter, FormatKeyword(_)).WillRepeatedly(DoDefault());
    EXPECT_CALL(m_mock_sorter, SortKeywords(_));
 
    // Test
    Merge(m_ops, m_params, m_target, sources, m_dry_run);
 
    auto after = fits::ReadKeywords(m_target.GetFitsFile(), 1);
    // Two checksum keywords are added
    ASSERT_EQ(after.size(), expected_kws.size() + 4u);
    ExpectStandardKeywords(after);
 
    EXPECT_THAT(after, ContainerEq(expected_kws));
}
 
TEST_F(TestMergeKeywords, MergeFailsIfTransformsCauseInvalidKeyword) {
    // Setup
    std::vector<SourceTypes> sources;
    auto kw1 = fits::LiteralKeyword("HIERARCH ESO UNKN A = T / Comment");
    fits::KeywordVector kws = {kw1};
 
    auto kw_processor = std::make_unique<MockKeywordProcessor>();
    EXPECT_CALL(*kw_processor, Process(_, _))
        .WillRepeatedly(Throw(std::invalid_argument("keyword too long")));
    sources.emplace_back(
        std::in_place_type<FitsKeywordsSource>, "tcs", kws, std::nullopt, std::move(kw_processor));
    auto expected_kws = fits::ReadKeywords(m_target.GetFitsFile(), 1);
    expected_kws.push_back(kw1);
 
    EXPECT_CALL(m_mock_formatter, FormatKeyword(_)).Times(0);
    EXPECT_CALL(m_mock_sorter, SortKeywords(_)).Times(0);
 
    // Test
    EXPECT_THROW(Merge(m_ops, m_params, m_target, sources, m_dry_run), std::runtime_error);
}
 
}  // namespace daq::dpm::merge