testWorkspace.cpp

Go to the documentation of this file.

/**
 * @file
 * @ingroup daq_test
 * @copyright (c) Copyright ESO 2022
 * All Rights Reserved
 * ESO (eso.org) is an Intergovernmental Organisation, and therefore special legal conditions apply.
 *
 * @brief daq::dpm::Workspace integration tests
 */
#include <fstream>
#include <thread>
 
#include <gtest/gtest.h>
 
#include <daq/dpm/workspace.hpp>
#include <daq/error/report.hpp>
 
namespace fs = std::filesystem;
 
class WorkspaceTest : public ::testing::Test {
public:
    WorkspaceTest() {
    }
    void SetUp() override {
        std::string tpl("daqLibdpmTest-workspace-XXXXXX");
        mkdtemp(tpl.data());
        m_root = fs::current_path() / tpl;
 
        ASSERT_FALSE(m_root.empty());
 
        m_spec = R"(
            {
              "id": "TEST.ID",
              "target": {
                "fileId": "TEST.FILEID",
                "source": {
                  "sourceName": "dcs",
                  "location": "dcs-host:/path/to/somefile.fits",
                  "path": "dcs/somefile.fits"
                }
              },
              "sources": [
              ]
            }
        )"_json;
    }
 
    void TearDown() override {
        if (!m_root.empty()) {
            fs::remove_all(m_root);
        }
    }
 
protected:
    fs::path m_root;
    nlohmann::json m_spec;
};
 
class DaqWorkspaceTest : public WorkspaceTest {};
 
TEST_F(WorkspaceTest, GetPath) {
    daq::dpm::WorkspaceImpl ws(m_root);
    EXPECT_EQ(m_root, ws.GetPath());
}
 
TEST_F(WorkspaceTest, ConstructionInitializeWorkspaceWithExistingRoot) {
    ASSERT_FALSE(fs::exists(m_root / "in-progress"));
    ASSERT_FALSE(fs::exists(m_root / "archive"));
    daq::dpm::WorkspaceImpl workspace(m_root);
 
    ASSERT_TRUE(fs::exists(m_root / "in-progress"));
    ASSERT_TRUE(fs::exists(m_root / "archive"));
}
 
TEST_F(WorkspaceTest, ConstructionInitializeWorkspaceWithNonexistingRoot) {
    fs::remove(m_root);
    ASSERT_FALSE(fs::exists(m_root / "in-progress"));
    ASSERT_FALSE(fs::exists(m_root / "archive"));
    daq::dpm::WorkspaceImpl workspace(m_root);
 
    ASSERT_TRUE(fs::exists(m_root / "in-progress"));
    ASSERT_TRUE(fs::exists(m_root / "archive"));
}
 
TEST_F(WorkspaceTest, ConstructionFailsIfRootIsAfile) {
    fs::remove(m_root);
    std::ofstream(m_root).put('z');
    EXPECT_THROW(daq::dpm::WorkspaceImpl{m_root}, std::invalid_argument);
}
 
TEST_F(WorkspaceTest, InitializeDaq) {
    try {
        daq::dpm::WorkspaceImpl ws(m_root);
        auto daq_ws = ws.InitializeDaq("DAQ");
        auto daq_ws_root = m_root / "in-progress" / "DAQ";
        EXPECT_EQ(daq_ws->GetPath(), daq_ws_root);
        EXPECT_TRUE(fs::exists(daq_ws_root)) << "Path: " << daq_ws_root;
    } catch (...) {
        daq::error::NestedExceptionReporter r(std::current_exception());
        throw std::runtime_error(r.Str());
    }
}
 
TEST_F(WorkspaceTest, ArchiveDaq) {
    try {
        {
            daq::dpm::WorkspaceImpl ws(m_root);
            auto daq_ws = ws.InitializeDaq("DAQ");
            daq::Status status("DAQ", "1");
            daq_ws->StoreStatus(status);
            ws.ArchiveDaq("DAQ");
            auto daq_ws_root = m_root / "archive" / "DAQ";
            EXPECT_TRUE(fs::exists(daq_ws_root)) << "Path: " << daq_ws_root;
            EXPECT_TRUE(fs::exists(daq_ws_root / "status.json"));
            EXPECT_FALSE(fs::exists(m_root / "in-progress" / "DAQ"));
 
            EXPECT_EQ(ws.LoadArchivedStatus("DAQ")->file_id, "1");
        }
        {
            // Reuse DAQ id and archive it again. It should rename previously archived DAQ to make
            // room for new such that <archive>/<daq> always refer to the newest archived DAQ.
            daq::dpm::WorkspaceImpl ws(m_root);
            auto daq_ws = ws.InitializeDaq("DAQ");
            daq::Status status("DAQ", "2");
            daq_ws->StoreStatus(status);
            ws.ArchiveDaq("DAQ");
            auto daq_ws_root = m_root / "archive" / "DAQ";
            EXPECT_TRUE(fs::exists(daq_ws_root)) << "Path: " << daq_ws_root;
            EXPECT_TRUE(fs::exists(daq_ws_root / "status.json"));
            EXPECT_FALSE(fs::exists(m_root / "in-progress" / "DAQ"));
 
            EXPECT_EQ(ws.LoadArchivedStatus("DAQ")->file_id, "2");
        }
 
    } catch (...) {
        daq::error::NestedExceptionReporter r(std::current_exception());
        throw std::runtime_error(r.Str());
    }
}
 
TEST_F(WorkspaceTest, RemoveDaq) {
    try {
        daq::dpm::WorkspaceImpl ws(m_root);
        auto daq_ws = ws.InitializeDaq("DAQ");
        ws.RemoveDaq("DAQ");
        EXPECT_FALSE(fs::exists(m_root / "in-progress" / "DAQ"));
        EXPECT_FALSE(fs::exists(m_root / "archive" / "DAQ"));
    } catch (...) {
        daq::error::NestedExceptionReporter r(std::current_exception());
        throw std::runtime_error(r.Str());
    }
}
 
TEST_F(DaqWorkspaceTest, LoadStoreSpecification) {
    try {
        daq::dpm::DaqWorkspaceImpl ws(m_root, m_root);
        EXPECT_FALSE(fs::exists(m_root / "specification.json"));
        ws.StoreSpecification(m_spec.dump());
        EXPECT_TRUE(fs::exists(m_root / "specification.json"));
 
        auto spec = ws.LoadSpecification();
        EXPECT_EQ(spec.id, "TEST.ID");
    } catch (...) {
        daq::error::NestedExceptionReporter r(std::current_exception());
        throw std::runtime_error(r.Str());
    }
}
 
TEST_F(DaqWorkspaceTest, LoadStoreStatus) {
    try {
        daq::dpm::DaqWorkspaceImpl ws(m_root, m_root);
        EXPECT_FALSE(fs::exists(m_root / "status.json"));
        daq::Status store_status = {};
        store_status.id = "DAQ";
        store_status.state = daq::State::Merging;
        ws.StoreStatus(store_status);
        EXPECT_TRUE(fs::exists(m_root / "status.json"));
        EXPECT_EQ(store_status, ws.LoadStatus());
    } catch (...) {
        daq::error::NestedExceptionReporter r(std::current_exception());
        throw std::runtime_error(r.Str());
    }
}
 
TEST_F(DaqWorkspaceTest, LoadStoreLookup) {
    try {
        daq::dpm::DaqWorkspaceImpl ws(m_root, m_root);
        EXPECT_FALSE(fs::exists(m_root / "sources.json"));
        daq::dpm::SourceResolver::Mapping store;
        ws.StoreSourceLookup(store);
        EXPECT_TRUE(fs::exists(m_root / "sources.json"));
        EXPECT_EQ(store, ws.LoadSourceLookup());
    } catch (...) {
        daq::error::NestedExceptionReporter r(std::current_exception());
        throw std::runtime_error(r.Str());
    }
}