00001 #define BOOST_TEST_MODULE (databaseinterface test)
00002
00003 #include "boost/test/auto_unit_test.hpp"
00004
00005 #include <time.h>
00006 #include <cassert>
00007 #include <cstdlib>
00008 #include <iostream>
00009 #include <memory>
00010 #include <string>
00011
00012 #include "otsdaq-core/ConfigurationInterface/DatabaseConfigurationInterface.h"
00013
00014 #include "artdaq-database/JsonDocument/JSONDocument.h"
00015
00016 #include "artdaq-database/ConfigurationDB/configuration_common.h"
00017 #include "artdaq-database/ConfigurationDB/dispatch_common.h"
00018
00019 #include "artdaq-database/JsonDocument/JSONDocument.h"
00020 #include "artdaq-database/JsonDocument/JSONDocumentBuilder.h"
00021 #include "artdaq-database/StorageProviders/FileSystemDB/provider_filedb.h"
00022 #include "artdaq-database/StorageProviders/MongoDB/provider_mongodb.h"
00023
00024 #include "artdaq-database/DataFormats/Json/json_reader.h"
00025
00026
00027
00028 namespace ots {
00029 struct ConfigurationViewEx: public ConfigurationView {
00030 void printJSON(std::stringstream& ss) const { ss << _json; }
00031 int fillFromJSON(std::string const& newjson) {
00032 _json = newjson;
00033 return 0;
00034 }
00035 std::string _json = "{ \"testJSON\" : 123 }";
00036 };
00037
00038 struct TestConfiguration001 final : public ConfigurationBase {
00039 TestConfiguration001():ConfigurationBase( "TestConfiguration001") {init(0);}
00040 void init(ConfigurationManager *configManager) {activeConfigurationView_=&view; }
00041 ConfigurationViewEx view;
00042 };
00043
00044 struct TestConfiguration002 final : public ConfigurationBase {
00045 TestConfiguration002():ConfigurationBase( "TestConfiguration002") {init(0);}
00046 void init(ConfigurationManager *configManager){activeConfigurationView_=&view; }
00047 ConfigurationViewEx view;
00048
00049 };
00050 }
00051
00052
00053 struct TestData {
00054 TestData() {
00055
00056
00057
00058
00059
00060
00061
00062
00063
00064
00065
00066
00067
00068
00069
00070
00071
00072
00073
00074
00075
00076 std::cout << "setup fixture\n";
00077 }
00078
00079 ~TestData() {
00080 std::cout << "setup fixture\n";
00081 }
00082
00083 void updateConfigCount(int count) { _oldConfigCount = count; }
00084
00085 int version() { return _version; }
00086 int oldConfigCount() { return _oldConfigCount; }
00087
00088 const int _version = (srand(time(NULL)), rand() % 99999 + 100000);
00089
00090 int _oldConfigCount = 0;
00091 };
00092
00093 using namespace ots;
00094
00095 TestData fixture;
00096
00097 BOOST_AUTO_TEST_SUITE(databaseinterface_test)
00098
00099 BOOST_AUTO_TEST_CASE(configure_tests) {
00100 std::cout << "TestData::version=" << fixture.version() << "\n";
00101 return;
00102 }
00103
00104 BOOST_AUTO_TEST_CASE(store_configuration) {
00105 std::shared_ptr<ConfigurationBase> cfg1 = std::make_shared<TestConfiguration001>();
00106 auto ifc = DatabaseConfigurationInterface();
00107
00108 cfg1->getViewP()->setVersion(fixture.version());
00109
00110 BOOST_CHECK_EQUAL(cfg1->getViewP()->getVersion(), fixture.version());
00111
00112
00113
00114 ifc.saveActiveVersion(cfg1.get());
00115
00116 return;
00117 }
00118
00119 BOOST_AUTO_TEST_CASE(load_configuration) {
00120 std::shared_ptr<ConfigurationBase> cfg1 = std::make_shared<TestConfiguration001>();
00121 auto ifc = DatabaseConfigurationInterface();
00122
00123 ifc.fill(cfg1.get(), ConfigurationVersion(fixture.version()));
00124
00125 return;
00126 }
00127
00128 BOOST_AUTO_TEST_CASE(store_global_configuration) {
00129 std::shared_ptr<ConfigurationBase> cfg1 = std::make_shared<TestConfiguration001>();
00130 std::shared_ptr<ConfigurationBase> cfg2 = std::make_shared<TestConfiguration002>();
00131
00132 auto ifc = DatabaseConfigurationInterface();
00133
00134 cfg1->getViewP()->setVersion(fixture.version() + 1);
00135 cfg2->getViewP()->setVersion(fixture.version() + 2);
00136
00137 ifc.saveActiveVersion(cfg1.get());
00138
00139 ifc.saveActiveVersion(cfg2.get());
00140
00141 auto map = DatabaseConfigurationInterface::config_version_map_t{};
00142 map[cfg1->getConfigurationName()] = cfg1->getView().getVersion();
00143 map[cfg2->getConfigurationName()] = cfg2->getView().getVersion();
00144
00145 auto configName = std::string{"config"} + std::to_string(fixture.version());
00146
00147 auto list = ifc.getAllConfigurationGroupNames();
00148
00149 fixture.updateConfigCount(list.size());
00150
00151 ifc.saveConfigurationGroup(map, configName);
00152
00153 return;
00154 }
00155
00156 BOOST_AUTO_TEST_CASE(load_global_configuration) {
00157 auto ifc = DatabaseConfigurationInterface();
00158
00159 auto configName = std::string{"config"} + std::to_string(fixture.version());
00160
00161 auto map = ifc.getConfigurationGroupMembers(configName);
00162
00163 BOOST_CHECK_EQUAL(map.size(), 2);
00164
00165 std::shared_ptr<ConfigurationBase> cfg1 = std::make_shared<TestConfiguration001>();
00166 std::shared_ptr<ConfigurationBase> cfg2 = std::make_shared<TestConfiguration002>();
00167
00168 BOOST_CHECK_EQUAL(map.at(cfg1->getConfigurationName()), fixture.version() + 1);
00169 BOOST_CHECK_EQUAL(map.at(cfg2->getConfigurationName()), fixture.version() + 2);
00170
00171 return;
00172 }
00173
00174 BOOST_AUTO_TEST_CASE(find_all_global_configurations) {
00175 auto ifc = DatabaseConfigurationInterface();
00176
00177 auto list = ifc.getAllConfigurationGroupNames();
00178
00179 BOOST_CHECK_EQUAL(list.size(), fixture.oldConfigCount() + 1);
00180
00181 auto configName = std::string{"config"} + std::to_string(fixture.version());
00182
00183 auto found = (std::find(list.begin(), list.end(), configName) != list.end());
00184
00185 BOOST_CHECK_EQUAL(found, true);
00186
00187 return;
00188 }
00189
00190 BOOST_AUTO_TEST_CASE(list_configuration_types) {
00191 auto ifc = DatabaseConfigurationInterface();
00192
00193 auto list = ifc.getAllConfigurationNames();
00194
00195 BOOST_CHECK_EQUAL(list.size(), 2);
00196
00197 std::shared_ptr<ConfigurationBase> cfg1 = std::make_shared<TestConfiguration001>();
00198 std::shared_ptr<ConfigurationBase> cfg2 = std::make_shared<TestConfiguration002>();
00199
00200 auto found1 = (std::find(list.begin(), list.end(), cfg1->getConfigurationName()) != list.end());
00201
00202 BOOST_CHECK_EQUAL(found1, true);
00203
00204 auto found2 = (std::find(list.begin(), list.end(), cfg2->getConfigurationName()) != list.end());
00205
00206 BOOST_CHECK_EQUAL(found2, true);
00207
00208 return;
00209 }
00210
00211 BOOST_AUTO_TEST_CASE(find_configuration_version) {
00212 auto ifc = DatabaseConfigurationInterface();
00213
00214 std::shared_ptr<ConfigurationBase> cfg1 = std::make_shared<TestConfiguration001>();
00215
00216 auto list = ifc.getVersions(cfg1.get());
00217
00218 auto found1 = (std::find(list.begin(), list.end(), fixture.version()) != list.end());
00219
00220 BOOST_CHECK_EQUAL(found1, true);
00221
00222 auto found2 = (std::find(list.begin(), list.end(), fixture.version() + 1) != list.end());
00223
00224 BOOST_CHECK_EQUAL(found2, true);
00225
00226 return;
00227 }
00228
00229 BOOST_AUTO_TEST_CASE(find_latest_configuration_version) {
00230 auto ifc = DatabaseConfigurationInterface();
00231
00232 std::shared_ptr<ConfigurationBase> cfg1 = std::make_shared<TestConfiguration001>();
00233
00234 auto version = ifc.findLatestVersion(cfg1.get());
00235
00236 auto list = ifc.getVersions(cfg1.get());
00237
00238 std::cout << "Found versions\n";
00239
00240 for(auto version:list) { std::cout << version << ", "; }
00241
00242 std::cout << "\nGot latest version: " << version << "\n";
00243
00244 return;
00245 }
00246
00247 BOOST_AUTO_TEST_SUITE_END()
00248