DatabaseInterfaceTest_t.cc

#define BOOST_TEST_MODULE (databaseinterface test)
 
#include "boost/test/auto_unit_test.hpp"
 
#include <time.h> /* time */
#include <cassert>
#include <cstdlib>
#include <iostream>
#include <memory>
#include <string>
 
#include "otsdaq/ConfigurationInterface/DatabaseConfigurationInterface.h"
 
#include "artdaq-database/JsonDocument/JSONDocument.h"
 
#include "artdaq-database/ConfigurationDB/configuration_common.h"
#include "artdaq-database/ConfigurationDB/dispatch_common.h"
 
#include "artdaq-database/JsonDocument/JSONDocument.h"
#include "artdaq-database/JsonDocument/JSONDocumentBuilder.h"
#include "artdaq-database/StorageProviders/FileSystemDB/provider_filedb.h"
#include "artdaq-database/StorageProviders/MongoDB/provider_mongodb.h"
 
#include "artdaq-database/DataFormats/Json/json_reader.h"
// #include "artdaq-database/DataFormats/common/helper_functions.h"
// #include "artdaq-database/DataFormats/common/shared_literals.h"
 
namespace ots
{
struct TableViewEx : public TableView
{
    void printJSON(std::stringstream& ss) const { ss << _json; }
    int  fillFromJSON(std::string const& newjson)
    {
        _json = newjson;
        return 0;
    }
    std::string _json = "{ \"testJSON\" : 123 }";
};
 
struct TestConfiguration001 final : public TableBase
{
    TestConfiguration001() : TableBase("TestConfiguration001") { init(0); }
    void        init(ConfigurationManager* configManager) { activeTableView_ = &view; }
    TableViewEx view;
};
 
struct TestConfiguration002 final : public TableBase
{
    TestConfiguration002() : TableBase("TestConfiguration002") { init(0); }
    void        init(ConfigurationManager* configManager) { activeTableView_ = &view; }
    TableViewEx view;
};
}  // namespace ots
 
struct TestData
{
    TestData()
    {
        /*
    artdaq::database::filesystem::debug::enable();
    artdaq::database::mongo::debug::enable();
    // artdaq::database::jsonutils::debug::enableJSONDocument();
    // artdaq::database::jsonutils::debug::enableJSONDocumentBuilder();
 
    artdaq::database::configuration::debug::enableFindConfigsOperation();
    artdaq::database::configuration::debug::enableCreateConfigsOperation();
 
    artdaq::database::configuration::debug::options::enableOperationBase();
    artdaq::database::configuration::debug::options::enableOperationManageConfigs();
    artdaq::database::configuration::debug::detail::enableCreateConfigsOperation();
    artdaq::database::configuration::debug::detail::enableFindConfigsOperation();
 
    artdaq::database::configuration::debug::enableDBOperationMongo();
    artdaq::database::configuration::debug::enableDBOperationFileSystem();
 
    artdaq::database::dataformats::useFakeTime(true);
 */
        std::cout << "setup fixture\n";
    }
 
    ~TestData() { std::cout << "setup fixture\n"; }
 
    void updateConfigCount(int count) { _oldConfigCount = count; }
 
    int version() { return _version; }
    int oldConfigCount() { return _oldConfigCount; }
 
    const int _version = (srand(time(NULL)), rand() % 99999 + 100000);
 
    int _oldConfigCount = 0;
};
 
using namespace ots;
 
TestData fixture;
 
BOOST_AUTO_TEST_SUITE(databaseinterface_test)
 
BOOST_AUTO_TEST_CASE(configure_tests)
{
    std::cout << "TestData::version=" << fixture.version() << "\n";
    return;
}
 
BOOST_AUTO_TEST_CASE(store_configuration)
{
    std::shared_ptr<TableBase> cfg1 = std::make_shared<TestConfiguration001>();
    auto                       ifc  = DatabaseConfigurationInterface();
 
    cfg1->getViewP()->setVersion(fixture.version());
 
    BOOST_CHECK_EQUAL(cfg1->getViewP()->getVersion(), fixture.version());
 
    //  std::cout << "Table Version " <<
    //  std::to_string(cfg1->getViewP()->getVersion() ) << "\n";
 
    ifc.saveActiveVersion(cfg1.get());
 
    return;
}
 
BOOST_AUTO_TEST_CASE(load_configuration)
{
    std::shared_ptr<TableBase> cfg1 = std::make_shared<TestConfiguration001>();
    auto                       ifc  = DatabaseConfigurationInterface();
 
    ifc.fill(cfg1.get(), TableVersion(fixture.version()));
 
    return;
}
 
BOOST_AUTO_TEST_CASE(store_global_configuration)
{
    std::shared_ptr<TableBase> cfg1 = std::make_shared<TestConfiguration001>();
    std::shared_ptr<TableBase> cfg2 = std::make_shared<TestConfiguration002>();
 
    auto ifc = DatabaseConfigurationInterface();
 
    cfg1->getViewP()->setVersion(fixture.version() + 1);
    cfg2->getViewP()->setVersion(fixture.version() + 2);
 
    ifc.saveActiveVersion(cfg1.get());
 
    ifc.saveActiveVersion(cfg2.get());
 
    auto map                  = DatabaseConfigurationInterface::config_version_map_t{};
    map[cfg1->getTableName()] = cfg1->getView().getVersion();
    map[cfg2->getTableName()] = cfg2->getView().getVersion();
 
    auto tableName = std::string{"config"} + std::to_string(fixture.version());
 
    auto list = ifc.getAllTableGroupNames();
 
    fixture.updateConfigCount(list.size());
 
    ifc.saveTableGroup(map, tableName);
 
    return;
}
 
BOOST_AUTO_TEST_CASE(load_global_configuration)
{
    auto ifc = DatabaseConfigurationInterface();
 
    auto tableName = std::string{"config"} + std::to_string(fixture.version());
 
    auto map = ifc.getTableGroupMembers(tableName);
 
    BOOST_CHECK_EQUAL(map.size(), 2);
 
    std::shared_ptr<TableBase> cfg1 = std::make_shared<TestConfiguration001>();
    std::shared_ptr<TableBase> cfg2 = std::make_shared<TestConfiguration002>();
 
    BOOST_CHECK_EQUAL(map.at(cfg1->getTableName()), fixture.version() + 1);
    BOOST_CHECK_EQUAL(map.at(cfg2->getTableName()), fixture.version() + 2);
 
    return;
}
 
BOOST_AUTO_TEST_CASE(find_all_global_configurations)
{
    auto ifc = DatabaseConfigurationInterface();
 
    auto list = ifc.getAllTableGroupNames();
 
    BOOST_CHECK_EQUAL(list.size(), fixture.oldConfigCount() + 1);
 
    auto tableName = std::string{"config"} + std::to_string(fixture.version());
 
    auto found = (std::find(list.begin(), list.end(), tableName) != list.end());
 
    BOOST_CHECK_EQUAL(found, true);
 
    return;
}
 
BOOST_AUTO_TEST_CASE(list_configuration_types)
{
    auto ifc = DatabaseConfigurationInterface();
 
    auto list = ifc.getAllTableNames();
 
    BOOST_CHECK_EQUAL(list.size(), 2);
 
    std::shared_ptr<TableBase> cfg1 = std::make_shared<TestConfiguration001>();
    std::shared_ptr<TableBase> cfg2 = std::make_shared<TestConfiguration002>();
 
    auto found1 =
        (std::find(list.begin(), list.end(), cfg1->getTableName()) != list.end());
 
    BOOST_CHECK_EQUAL(found1, true);
 
    auto found2 =
        (std::find(list.begin(), list.end(), cfg2->getTableName()) != list.end());
 
    BOOST_CHECK_EQUAL(found2, true);
 
    return;
}
 
BOOST_AUTO_TEST_CASE(find_configuration_version)
{
    auto ifc = DatabaseConfigurationInterface();
 
    std::shared_ptr<TableBase> cfg1 = std::make_shared<TestConfiguration001>();
 
    auto list = ifc.getVersions(cfg1.get());
 
    auto found1 = (std::find(list.begin(), list.end(), fixture.version()) != list.end());
 
    BOOST_CHECK_EQUAL(found1, true);
 
    auto found2 =
        (std::find(list.begin(), list.end(), fixture.version() + 1) != list.end());
 
    BOOST_CHECK_EQUAL(found2, true);
 
    return;
}
 
BOOST_AUTO_TEST_CASE(find_latest_configuration_version)
{
    auto ifc = DatabaseConfigurationInterface();
 
    std::shared_ptr<TableBase> cfg1 = std::make_shared<TestConfiguration001>();
 
    auto version = ifc.findLatestVersion(cfg1.get());
 
    auto list = ifc.getVersions(cfg1.get());
 
    std::cout << "Found versions\n";
 
    for(auto version : list)
    {
        std::cout << version << ", ";
    }
 
    std::cout << "\nGot latest version: " << version << "\n";
 
    return;
}
 
BOOST_AUTO_TEST_SUITE_END()