BlockStorage/repertory
1
0
Fork 0
Code Issues 8 Pull Requests Releases 6 Wiki Activity

refactor event system
Some checks failed
BlockStorage/repertory/pipeline/head There was a failure building this commit
Details

Browse Source
This commit is contained in:
Scott E. Graves
2025-01-23 15:19:37 -06:00
parent 7309ca477a
commit 8272ec2f8a
6 changed files with 179 additions and 168 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
repertory/librepertory/src/providers/base_provider.cpp
View File

@ -798,7 +798,7 @@ auto base_provider::start(api_item_added_callback api_item_added,
const auto &cfg = get_config(); const auto &cfg = get_config();
repertory::event_consumer consumer( repertory::event_consumer consumer(
"unmount_requested", [&unmount_requested](const event & /* evt */) { "unmount_requested", [&unmount_requested](const i_event & /* evt */) {
unmount_requested = true; unmount_requested = true;
}); });

1
repertory/repertory_test/include/test_common.hpp
View File

@ -28,5 +28,6 @@ REPERTORY_IGNORE_WARNINGS_DISABLE()
#include "events/consumers/console_consumer.hpp" #include "events/consumers/console_consumer.hpp"
#include "events/event_system2.hpp" #include "events/event_system2.hpp"
#include "events/i_event.hpp"
#endif // REPERTORY_TEST_INCLUDE_TEST_COMMON_HPP_ #endif // REPERTORY_TEST_INCLUDE_TEST_COMMON_HPP_

44
repertory/repertory_test/include/utils/event_capture.hpp
View File

@ -32,8 +32,9 @@ class event_capture final {
E_CONSUMER2(); E_CONSUMER2();
public: public:
explicit event_capture(std::vector<std::string> event_names, explicit event_capture(
std::vector<std::string> non_fired_event_names = {}) std::vector<std::string_view> event_names,
std::vector<std::string_view> non_fired_event_names = {})
: event_names_(std::move(event_names)), : event_names_(std::move(event_names)),
non_fired_event_names_(std::move(non_fired_event_names)) { non_fired_event_names_(std::move(non_fired_event_names)) {
E_SUBSCRIBE2_ALL(process_event); E_SUBSCRIBE2_ALL(process_event);
@ -51,56 +52,55 @@ public:
} }
private: private:
std::vector<std::string> event_names_; std::vector<std::string_view> event_names_;
std::vector<std::string> fired_event_names_; std::vector<std::string_view> fired_event_names_;
std::vector<std::string> non_fired_event_names_; std::vector<std::string_view> non_fired_event_names_;
std::mutex mutex_; std::mutex mutex_;
std::condition_variable notify_; std::condition_variable notify_;
public: public:
void process_event(const event &event) { void process_event(const i_event &event) {
unique_mutex_lock l(mutex_); unique_mutex_lock lock(mutex_);
utils::collection::remove_element(event_names_, event.get_name()); utils::collection::remove_element(event_names_, event.get_name());
fired_event_names_.emplace_back(event.get_name()); fired_event_names_.emplace_back(event.get_name());
notify_.notify_all(); notify_.notify_all();
l.unlock(); lock.unlock();
for (size_t i = 0; i < non_fired_event_names_.size(); i++) { for (size_t i = 0; i < non_fired_event_names_.size(); i++) {
const auto it = std::find(non_fired_event_names_.begin(), const auto iter =
non_fired_event_names_.end(), event.get_name()); std::ranges::find(non_fired_event_names_, event.get_name());
EXPECT_EQ(non_fired_event_names_.end(), it); EXPECT_EQ(non_fired_event_names_.end(), iter);
if (it != non_fired_event_names_.end()) { if (iter != non_fired_event_names_.end()) {
std::cerr << '\t' << *it << std::endl; std::cerr << '\t' << *iter << std::endl;
} }
} }
} }
void wait_for_empty() { void wait_for_empty() {
const auto start_time = std::chrono::system_clock::now(); const auto start_time = std::chrono::system_clock::now();
unique_mutex_lock l(mutex_); unique_mutex_lock lock(mutex_);
while (not event_names_.empty() && while (not event_names_.empty() &&
(std::chrono::duration_cast<std::chrono::seconds>( (std::chrono::duration_cast<std::chrono::seconds>(
std::chrono::system_clock::now() - start_time) std::chrono::system_clock::now() - start_time)
.count() < 10)) { .count() < 10)) {
notify_.wait_for(l, 1s); notify_.wait_for(lock, 1s);
} }
l.unlock(); lock.unlock();
} }
[[nodiscard]] auto wait_for_event(const std::string &event_name) -> bool { [[nodiscard]] auto wait_for_event(const std::string &event_name) -> bool {
auto missing = true; auto missing = true;
const auto start_time = std::chrono::system_clock::now(); const auto start_time = std::chrono::system_clock::now();
unique_mutex_lock l(mutex_); unique_mutex_lock lock(mutex_);
while ((std::chrono::duration_cast<std::chrono::seconds>( while ((std::chrono::duration_cast<std::chrono::seconds>(
std::chrono::system_clock::now() - start_time) std::chrono::system_clock::now() - start_time)
.count() < 10) && .count() < 10) &&
(missing = (missing = (std::ranges::find(fired_event_names_, event_name) ==
(std::find(fired_event_names_.begin(), fired_event_names_.end(), fired_event_names_.end()))) {
event_name) == fired_event_names_.end()))) { notify_.wait_for(lock, 1s);
notify_.wait_for(l, 1s);
} }
l.unlock(); lock.unlock();
return not missing; return not missing;
} }
}; };

165
repertory/repertory_test/src/file_manager_test.cpp
View File

@ -22,6 +22,11 @@
#include "test_common.hpp" #include "test_common.hpp"
#include "app_config.hpp" #include "app_config.hpp"
#include "events/types/file_upload_completed.hpp"
#include "events/types/filesystem_item_closed.hpp"
#include "events/types/filesystem_item_handle_closed.hpp"
#include "events/types/filesystem_item_handle_opened.hpp"
#include "events/types/filesystem_item_opened.hpp"
#include "events/types/service_start_begin.hpp" #include "events/types/service_start_begin.hpp"
#include "events/types/service_start_end.hpp" #include "events/types/service_start_end.hpp"
#include "events/types/service_stop_begin.hpp" #include "events/types/service_stop_begin.hpp"
@ -75,9 +80,7 @@ protected:
cache_size_mgr::instance().initialize(cfg.get()); cache_size_mgr::instance().initialize(cfg.get());
} }
void TearDown() override { void TearDown() override { event_system2::instance().stop(); }
event_system2::instance().stop();
}
}; };
std::atomic<std::size_t> file_manager_test::inst{0U}; std::atomic<std::size_t> file_manager_test::inst{0U};
@ -85,23 +88,28 @@ std::atomic<std::size_t> file_manager_test::inst{0U};
TEST_F(file_manager_test, can_start_and_stop) { TEST_F(file_manager_test, can_start_and_stop) {
EXPECT_CALL(mp, is_read_only()).WillRepeatedly(Return(false)); EXPECT_CALL(mp, is_read_only()).WillRepeatedly(Return(false));
event_consumer consumer("service_start_begin", [](const i_event &evt) { event_consumer consumer(service_start_begin::name, [](const i_event &evt) {
const auto &evt2 = dynamic_cast<const service_start_begin &>(evt); const auto &evt2 = dynamic_cast<const service_start_begin &>(evt);
EXPECT_STREQ("file_manager", evt2.service_name.c_str()); EXPECT_STREQ("file_manager", evt2.service_name.c_str());
}); });
event_consumer consumer2("service_stop_begin", [](const i_event &evt) { event_consumer consumer2(service_start_end::name, [](const i_event &evt) {
const auto &evt2 = dynamic_cast<const service_start_end &>(evt);
EXPECT_STREQ("file_manager", evt2.service_name.c_str());
});
event_consumer consumer3(service_stop_begin::name, [](const i_event &evt) {
const auto &evt2 = dynamic_cast<const service_stop_begin &>(evt); const auto &evt2 = dynamic_cast<const service_stop_begin &>(evt);
EXPECT_STREQ("file_manager", evt2.service_name.c_str()); EXPECT_STREQ("file_manager", evt2.service_name.c_str());
}); });
event_consumer consumer3("service_stop_end", [](const i_event &evt) { event_consumer consumer4(service_stop_end::name, [](const i_event &evt) {
const auto &evt2 = dynamic_cast<const service_stop_end &>(evt); const auto &evt2 = dynamic_cast<const service_stop_end &>(evt);
EXPECT_STREQ("file_manager", evt2.service_name.c_str()); EXPECT_STREQ("file_manager", evt2.service_name.c_str());
}); });
event_capture capture({ event_capture capture({
"service_start_begin", service_start_begin::name,
"service_stop_begin", service_start_end::name,
"service_stop_end", service_stop_begin::name,
service_stop_end::name,
}); });
file_manager mgr(*cfg, mp); file_manager mgr(*cfg, mp);
@ -123,10 +131,10 @@ TEST_F(file_manager_test, can_create_and_close_file) {
event_capture capture({ event_capture capture({
"item_timeout", "item_timeout",
"filesystem_item_opened", filesystem_item_opened::name,
"filesystem_item_handle_opened", filesystem_item_handle_opened::name,
"filesystem_item_handle_closed", filesystem_item_handle_closed::name,
"filesystem_item_closed", filesystem_item_closed::name,
}); });
auto source_path = utils::path::combine(cfg->get_cache_directory(), auto source_path = utils::path::combine(cfg->get_cache_directory(),
@ -156,15 +164,16 @@ TEST_F(file_manager_test, can_create_and_close_file) {
return api_error::success; return api_error::success;
}); });
event_consumer consumer("filesystem_item_opened", [&](const i_event &evt) { event_consumer consumer(
const auto &evt2 = dynamic_cast<const filesystem_item_opened &>(evt); filesystem_item_opened::name, [&](const i_event &evt) {
EXPECT_STREQ("/test_create.txt", evt2.api_path.c_str()); const auto &evt2 = dynamic_cast<const filesystem_item_opened &>(evt);
EXPECT_STREQ(source_path.c_str(), evt2.source_path.c_str()); EXPECT_STREQ("/test_create.txt", evt2.api_path.c_str());
EXPECT_FALSE(evt2.directory); EXPECT_STREQ(source_path.c_str(), evt2.source_path.c_str());
}); EXPECT_FALSE(evt2.directory);
});
event_consumer ec2( event_consumer ec2(
"filesystem_item_handle_opened", [&](const i_event &evt) { filesystem_item_handle_opened::name, [&](const i_event &evt) {
const auto &evt2 = const auto &evt2 =
dynamic_cast<const filesystem_item_handle_opened &>(evt); dynamic_cast<const filesystem_item_handle_opened &>(evt);
EXPECT_STREQ("/test_create.txt", evt2.api_path.c_str()); EXPECT_STREQ("/test_create.txt", evt2.api_path.c_str());
@ -185,7 +194,7 @@ TEST_F(file_manager_test, can_create_and_close_file) {
EXPECT_EQ(std::uint64_t(1U), handle); EXPECT_EQ(std::uint64_t(1U), handle);
} }
event_consumer ec3("filesystem_item_closed", [&](const i_event &evt) { event_consumer ec3(filesystem_item_closed::name, [&](const i_event &evt) {
const auto &evt2 = dynamic_cast<const filesystem_item_closed &>(evt); const auto &evt2 = dynamic_cast<const filesystem_item_closed &>(evt);
EXPECT_STREQ("/test_create.txt", EXPECT_STREQ("/test_create.txt",
evt2.get_api_path().get<std::string>().c_str()); evt2.get_api_path().get<std::string>().c_str());
@ -194,15 +203,17 @@ TEST_F(file_manager_test, can_create_and_close_file) {
EXPECT_STREQ("0", evt2.get_directory().get<std::string>().c_str()); EXPECT_STREQ("0", evt2.get_directory().get<std::string>().c_str());
}); });
event_consumer ec4("filesystem_item_handle_closed", [&](const i_event &evt) { event_consumer ec4(
const auto &evt2 = dynamic_cast<const filesystem_item_handle_closed &>(evt); filesystem_item_handle_closed::name, [&](const i_event &evt) {
EXPECT_STREQ("/test_create.txt", const auto &evt2 =
evt2.get_api_path().get<std::string>().c_str()); dynamic_cast<const filesystem_item_handle_closed &>(evt);
EXPECT_STREQ(source_path.c_str(), EXPECT_STREQ("/test_create.txt",
evt2.get_source().get<std::string>().c_str()); evt2.get_api_path().get<std::string>().c_str());
EXPECT_STREQ("0", evt2.get_directory().get<std::string>().c_str()); EXPECT_STREQ(source_path.c_str(),
EXPECT_STREQ("1", evt2.get_handle().get<std::string>().c_str()); evt2.get_source().get<std::string>().c_str());
}); EXPECT_STREQ("0", evt2.get_directory().get<std::string>().c_str());
EXPECT_STREQ("1", evt2.get_handle().get<std::string>().c_str());
});
mgr.close(handle); mgr.close(handle);
@ -229,10 +240,10 @@ TEST_F(file_manager_test, can_open_and_close_file) {
event_capture capture({ event_capture capture({
"item_timeout", "item_timeout",
"filesystem_item_opened", filesystem_item_opened::name,
"filesystem_item_handle_opened", filesystem_item_handle_opened::name,
"filesystem_item_handle_closed", filesystem_item_handle_closed::name,
"filesystem_item_closed", filesystem_item_closed::name,
}); });
auto source_path = utils::path::combine(cfg->get_cache_directory(), auto source_path = utils::path::combine(cfg->get_cache_directory(),
{utils::create_uuid_string()}); {utils::create_uuid_string()});
@ -260,17 +271,18 @@ TEST_F(file_manager_test, can_open_and_close_file) {
return api_error::success; return api_error::success;
}); });
event_consumer consumer("filesystem_item_opened", [&](const i_event &evt) { event_consumer consumer(
const auto &evt2 = dynamic_cast<const filesystem_item_opened &>(evt); filesystem_item_opened::name, [&](const i_event &evt) {
EXPECT_STREQ("/test_open.txt", const auto &evt2 = dynamic_cast<const filesystem_item_opened &>(evt);
evt2.get_api_path().get<std::string>().c_str()); EXPECT_STREQ("/test_open.txt",
EXPECT_STREQ(source_path.c_str(), evt2.get_api_path().get<std::string>().c_str());
evt2.get_source().get<std::string>().c_str()); EXPECT_STREQ(source_path.c_str(),
EXPECT_STREQ("0", evt2.get_directory().get<std::string>().c_str()); evt2.get_source().get<std::string>().c_str());
}); EXPECT_STREQ("0", evt2.get_directory().get<std::string>().c_str());
});
event_consumer ec2( event_consumer ec2(
"filesystem_item_handle_opened", [&](const i_event &evt) { filesystem_item_handle_opened::name, [&](const i_event &evt) {
const auto &evt2 = const auto &evt2 =
dynamic_cast<const filesystem_item_handle_opened &>(evt); dynamic_cast<const filesystem_item_handle_opened &>(evt);
EXPECT_STREQ("/test_open.txt", EXPECT_STREQ("/test_open.txt",
@ -294,7 +306,7 @@ TEST_F(file_manager_test, can_open_and_close_file) {
EXPECT_EQ(std::uint64_t(1U), handle); EXPECT_EQ(std::uint64_t(1U), handle);
} }
event_consumer ec3("filesystem_item_closed", [&](const i_event &evt) { event_consumer ec3(filesystem_item_closed::name, [&](const i_event &evt) {
const auto &evt2 = dynamic_cast<const filesystem_item_closed &>(evt); const auto &evt2 = dynamic_cast<const filesystem_item_closed &>(evt);
EXPECT_STREQ("/test_open.txt", EXPECT_STREQ("/test_open.txt",
evt2.get_api_path().get<std::string>().c_str()); evt2.get_api_path().get<std::string>().c_str());
@ -303,15 +315,17 @@ TEST_F(file_manager_test, can_open_and_close_file) {
EXPECT_STREQ("0", evt2.get_directory().get<std::string>().c_str()); EXPECT_STREQ("0", evt2.get_directory().get<std::string>().c_str());
}); });
event_consumer ec4("filesystem_item_handle_closed", [&](const i_event &evt) { event_consumer ec4(
const auto &evt2 = dynamic_cast<const filesystem_item_handle_closed &>(evt); filesystem_item_handle_closed::name, [&](const i_event &evt) {
EXPECT_STREQ("/test_open.txt", const auto &evt2 =
evt2.get_api_path().get<std::string>().c_str()); dynamic_cast<const filesystem_item_handle_closed &>(evt);
EXPECT_STREQ(source_path.c_str(), EXPECT_STREQ("/test_open.txt",
evt2.get_source().get<std::string>().c_str()); evt2.get_api_path().get<std::string>().c_str());
EXPECT_STREQ("0", evt2.get_directory().get<std::string>().c_str()); EXPECT_STREQ(source_path.c_str(),
EXPECT_STREQ("1", evt2.get_handle().get<std::string>().c_str()); evt2.get_source().get<std::string>().c_str());
}); EXPECT_STREQ("0", evt2.get_directory().get<std::string>().c_str());
EXPECT_STREQ("1", evt2.get_handle().get<std::string>().c_str());
});
mgr.close(handle); mgr.close(handle);
@ -407,10 +421,11 @@ TEST_F(file_manager_test,
evt2.get_dest_path().get<std::string>().c_str()); evt2.get_dest_path().get<std::string>().c_str());
}); });
event_capture capture({"download_resume_added"}, { event_capture capture({"download_resume_added"},
"file_upload_completed", {
"file_upload_queued", file_upload_completed::name,
}); file_upload_queued::name,
});
auto now = utils::time::get_time_now(); auto now = utils::time::get_time_now();
auto meta = create_meta_attributes( auto meta = create_meta_attributes(
@ -499,8 +514,8 @@ TEST_F(file_manager_test,
event_capture ec2({"download_restored", "download_resume_added"}, event_capture ec2({"download_restored", "download_resume_added"},
{ {
"file_upload_completed", file_upload_completed::name,
"file_upload_queued", file_upload_queued::name,
}); });
EXPECT_EQ(std::size_t(0u), mgr.get_open_file_count()); EXPECT_EQ(std::size_t(0u), mgr.get_open_file_count());
EXPECT_EQ(std::size_t(0u), mgr.get_open_handle_count()); EXPECT_EQ(std::size_t(0u), mgr.get_open_handle_count());
@ -562,7 +577,7 @@ TEST_F(file_manager_test, upload_occurs_after_write_if_fully_downloaded) {
evt2.get_source().get<std::string>().c_str()); evt2.get_source().get<std::string>().c_str());
}); });
event_consumer es2( event_consumer es2(
"file_upload_completed", [&source_path](const i_event &evt) { file_upload_completed::name, [&source_path](const i_event &evt) {
const auto &evt2 = dynamic_cast<const file_upload_completed &>(evt); const auto &evt2 = dynamic_cast<const file_upload_completed &>(evt);
EXPECT_STREQ("/test_write_full_download.txt", EXPECT_STREQ("/test_write_full_download.txt",
evt2.get_api_path().get<std::string>().c_str()); evt2.get_api_path().get<std::string>().c_str());
@ -631,7 +646,7 @@ TEST_F(file_manager_test, upload_occurs_after_write_if_fully_downloaded) {
event_capture capture({ event_capture capture({
"item_timeout", "item_timeout",
"file_upload_queued", "file_upload_queued",
"file_upload_completed", file_upload_completed::name,
}); });
EXPECT_CALL(mp, upload_file("/test_write_full_download.txt", source_path, _)) EXPECT_CALL(mp, upload_file("/test_write_full_download.txt", source_path, _))
@ -668,11 +683,11 @@ TEST_F(file_manager_test, can_evict_file) {
mgr.start(); mgr.start();
event_capture capture({ event_capture capture({
"filesystem_item_opened", filesystem_item_opened::name,
"filesystem_item_handle_opened", filesystem_item_handle_opened::name,
"filesystem_item_handle_closed", filesystem_item_handle_closed::name,
"filesystem_item_closed", filesystem_item_closed::name,
"file_upload_completed", file_upload_completed::name,
}); });
auto source_path = utils::path::combine(cfg->get_cache_directory(), auto source_path = utils::path::combine(cfg->get_cache_directory(),
@ -859,11 +874,11 @@ TEST_F(file_manager_test, evict_file_fails_if_file_is_uploading) {
mgr.start(); mgr.start();
event_capture capture({ event_capture capture({
"filesystem_item_opened", filesystem_item_opened::name,
"filesystem_item_handle_opened", filesystem_item_handle_opened::name,
"filesystem_item_handle_closed", filesystem_item_handle_closed::name,
"filesystem_item_closed", filesystem_item_closed::name,
"file_upload_completed", file_upload_completed::name,
}); });
auto source_path = utils::path::combine(cfg->get_cache_directory(), auto source_path = utils::path::combine(cfg->get_cache_directory(),
@ -1573,10 +1588,10 @@ TEST_F(file_manager_test,
event_capture capture({ event_capture capture({
"item_timeout", "item_timeout",
"filesystem_item_opened", filesystem_item_opened::name,
"filesystem_item_handle_opened", filesystem_item_handle_opened::name,
"filesystem_item_handle_closed", filesystem_item_handle_closed::name,
"filesystem_item_closed", filesystem_item_closed::name,
}); });
std::uint64_t handle{}; std::uint64_t handle{};

76
repertory/repertory_test/src/open_file_test.cpp
View File

@ -22,6 +22,10 @@
#include "test_common.hpp" #include "test_common.hpp"
#include "app_config.hpp" #include "app_config.hpp"
#include "events/types/filesystem_item_closed.hpp"
#include "events/types/filesystem_item_handle_closed.hpp"
#include "events/types/filesystem_item_handle_opened.hpp"
#include "events/types/filesystem_item_opened.hpp"
#include "file_manager/cache_size_mgr.hpp" #include "file_manager/cache_size_mgr.hpp"
#include "file_manager/open_file.hpp" #include "file_manager/open_file.hpp"
#include "mocks/mock_provider.hpp" #include "mocks/mock_provider.hpp"
@ -56,9 +60,7 @@ protected:
cache_size_mgr::instance().initialize(cfg.get()); cache_size_mgr::instance().initialize(cfg.get());
} }
void TearDown() override { void TearDown() override { event_system2::instance().stop(); }
event_system2::instance().stop();
}
}; };
std::atomic<std::size_t> open_file_test::inst{0U}; std::atomic<std::size_t> open_file_test::inst{0U};
@ -603,24 +605,21 @@ TEST_F(open_file_test, can_add_handle) {
fsi.size = test_chunk_size * 4u; fsi.size = test_chunk_size * 4u;
fsi.source_path = source_path; fsi.source_path = source_path;
event_consumer ec("filesystem_item_opened", [&fsi](const event &e) { event_consumer ec(filesystem_item_opened::name, [&fsi](const i_event &e) {
const auto &ee = dynamic_cast<const filesystem_item_opened &>(e); const auto &ee = dynamic_cast<const filesystem_item_opened &>(e);
EXPECT_STREQ(fsi.api_path.c_str(), EXPECT_STREQ(fsi.api_path.c_str(), ee.api_path.c_str());
ee.get_api_path().get<std::string>().c_str()); EXPECT_STREQ(fsi.source_path.c_str(), ee.source_path.c_str());
EXPECT_STREQ(fsi.source_path.c_str(), EXPECT_FALSE(ee.directory);
ee.get_source().get<std::string>().c_str());
EXPECT_STREQ("0", ee.get_directory().get<std::string>().c_str());
}); });
event_consumer ec2("filesystem_item_handle_opened", [&fsi](const event &e) { event_consumer ec2(
const auto &ee = dynamic_cast<const filesystem_item_handle_opened &>(e); filesystem_item_handle_opened::name, [&fsi](const i_event &e) {
EXPECT_STREQ(fsi.api_path.c_str(), const auto &ee = dynamic_cast<const filesystem_item_handle_opened &>(e);
ee.get_api_path().get<std::string>().c_str()); EXPECT_STREQ(fsi.api_path.c_str(), ee.api_path.c_str());
EXPECT_STREQ(fsi.source_path.c_str(), EXPECT_STREQ(fsi.source_path.c_str(), ee.source_path.c_str());
ee.get_source().get<std::string>().c_str()); EXPECT_FALSE(ee.directory);
EXPECT_STREQ("0", ee.get_directory().get<std::string>().c_str()); EXPECT_EQ(std::uint64_t(1U), ee.handle);
EXPECT_STREQ("1", ee.get_handle().get<std::string>().c_str()); });
});
EXPECT_CALL(provider, set_item_meta(fsi.api_path, META_SOURCE, _)) EXPECT_CALL(provider, set_item_meta(fsi.api_path, META_SOURCE, _))
.WillOnce(Return(api_error::success)); .WillOnce(Return(api_error::success));
@ -631,8 +630,10 @@ TEST_F(open_file_test, can_add_handle) {
EXPECT_EQ(fsi.source_path, source_path2); EXPECT_EQ(fsi.source_path, source_path2);
}); });
event_capture capture( event_capture capture({
{"filesystem_item_opened", "filesystem_item_handle_opened"}); filesystem_item_opened::name,
filesystem_item_handle_opened::name,
});
open_file o(test_chunk_size, 0U, fsi, provider, upload_mgr); open_file o(test_chunk_size, 0U, fsi, provider, upload_mgr);
#if defined(_WIN32) #if defined(_WIN32)
@ -663,24 +664,21 @@ TEST_F(open_file_test, can_remove_handle) {
fsi.size = test_chunk_size * 4u; fsi.size = test_chunk_size * 4u;
fsi.source_path = source_path; fsi.source_path = source_path;
event_consumer ec("filesystem_item_closed", [&fsi](const event &e) { event_consumer ec(filesystem_item_closed::name, [&fsi](const i_event &e) {
const auto &ee = dynamic_cast<const filesystem_item_closed &>(e); const auto &ee = dynamic_cast<const filesystem_item_closed &>(e);
EXPECT_STREQ(fsi.api_path.c_str(), EXPECT_STREQ(fsi.api_path.c_str(), ee.api_path.c_str());
ee.get_api_path().get<std::string>().c_str()); EXPECT_STREQ(fsi.source_path.c_str(), ee.source_path.c_str());
EXPECT_STREQ(fsi.source_path.c_str(), EXPECT_FALSE(ee.directory);
ee.get_source().get<std::string>().c_str());
EXPECT_STREQ("0", ee.get_directory().get<std::string>().c_str());
}); });
event_consumer ec2("filesystem_item_handle_closed", [&fsi](const event &e) { event_consumer ec2(
const auto &ee = dynamic_cast<const filesystem_item_handle_closed &>(e); filesystem_item_handle_closed::name, [&fsi](const i_event &e) {
EXPECT_STREQ(fsi.api_path.c_str(), const auto &ee = dynamic_cast<const filesystem_item_handle_closed &>(e);
ee.get_api_path().get<std::string>().c_str()); EXPECT_STREQ(fsi.api_path.c_str(), ee.api_path.c_str());
EXPECT_STREQ(fsi.source_path.c_str(), EXPECT_STREQ(fsi.source_path.c_str(), ee.source_path.c_str());
ee.get_source().get<std::string>().c_str()); EXPECT_FALSE(ee.directory);
EXPECT_STREQ("0", ee.get_directory().get<std::string>().c_str()); EXPECT_EQ(std::uint64_t(1U), ee.handle);
EXPECT_STREQ("1", ee.get_handle().get<std::string>().c_str()); });
});
EXPECT_CALL(upload_mgr, remove_resume) EXPECT_CALL(upload_mgr, remove_resume)
.WillOnce( .WillOnce(
@ -692,10 +690,10 @@ TEST_F(open_file_test, can_remove_handle) {
.WillOnce(Return(api_error::success)); .WillOnce(Return(api_error::success));
event_capture capture({ event_capture capture({
"filesystem_item_opened", filesystem_item_opened::name,
"filesystem_item_handle_opened", filesystem_item_handle_opened::name,
"filesystem_item_handle_closed", filesystem_item_handle_closed::name,
"filesystem_item_closed", filesystem_item_closed::name,
}); });
open_file o(test_chunk_size, 0U, fsi, provider, upload_mgr); open_file o(test_chunk_size, 0U, fsi, provider, upload_mgr);

59
repertory/repertory_test/src/upload_test.cpp
View File

@ -21,6 +21,7 @@
*/ */
#include "test_common.hpp" #include "test_common.hpp"
#include "events/types/file_upload_completed.hpp"
#include "file_manager/upload.hpp" #include "file_manager/upload.hpp"
#include "mocks/mock_provider.hpp" #include "mocks/mock_provider.hpp"
#include "utils/event_capture.hpp" #include "utils/event_capture.hpp"
@ -44,15 +45,14 @@ TEST(upload, can_upload_a_valid_file) {
fsi.size = test_chunk_size * 4U; fsi.size = test_chunk_size * 4U;
fsi.source_path = source_path; fsi.source_path = source_path;
event_consumer evt_com("file_upload_completed", [&fsi](const event &evt) { event_consumer evt_com(
const auto &comp_evt = dynamic_cast<const file_upload_completed &>(evt); file_upload_completed::name, [&fsi](const i_event &evt) {
EXPECT_STREQ(fsi.api_path.c_str(), const auto &comp_evt = dynamic_cast<const file_upload_completed &>(evt);
comp_evt.get_api_path().get<std::string>().c_str()); EXPECT_STREQ(fsi.api_path.c_str(), comp_evt.api_path.c_str());
EXPECT_STREQ(fsi.source_path.c_str(), EXPECT_STREQ(fsi.source_path.c_str(), comp_evt.source_path.c_str());
comp_evt.get_source().get<std::string>().c_str()); EXPECT_EQ(api_error::success, comp_evt.error);
EXPECT_STREQ("success", comp_evt.get_result().get<std::string>().c_str()); EXPECT_FALSE(comp_evt.cancelled);
EXPECT_STREQ("0", comp_evt.get_cancelled().get<std::string>().c_str()); });
});
EXPECT_CALL(mock_prov, upload_file(fsi.api_path, fsi.source_path, _)) EXPECT_CALL(mock_prov, upload_file(fsi.api_path, fsi.source_path, _))
.WillOnce([](const std::string &, const std::string &, .WillOnce([](const std::string &, const std::string &,
@ -62,7 +62,7 @@ TEST(upload, can_upload_a_valid_file) {
}); });
upload upload(fsi, mock_prov); upload upload(fsi, mock_prov);
event_capture evt_cap({"file_upload_completed"}); event_capture evt_cap({file_upload_completed::name});
evt_cap.wait_for_empty(); evt_cap.wait_for_empty();
EXPECT_EQ(api_error::success, upload.get_api_error()); EXPECT_EQ(api_error::success, upload.get_api_error());
@ -87,16 +87,14 @@ TEST(upload, can_cancel_upload) {
fsi.size = test_chunk_size * 4U; fsi.size = test_chunk_size * 4U;
fsi.source_path = source_path; fsi.source_path = source_path;
event_consumer evt_con("file_upload_completed", [&fsi](const event &evt) { event_consumer evt_con(
const auto &comp_evt = dynamic_cast<const file_upload_completed &>(evt); file_upload_completed::name, [&fsi](const i_event &evt) {
EXPECT_STREQ(fsi.api_path.c_str(), const auto &comp_evt = dynamic_cast<const file_upload_completed &>(evt);
comp_evt.get_api_path().get<std::string>().c_str()); EXPECT_STREQ(fsi.api_path.c_str(), comp_evt.api_path.c_str());
EXPECT_STREQ(fsi.source_path.c_str(), EXPECT_STREQ(fsi.source_path.c_str(), comp_evt.source_path.c_str());
comp_evt.get_source().get<std::string>().c_str()); EXPECT_EQ(api_error::comm_error, comp_evt.error);
EXPECT_STREQ("comm_error", EXPECT_TRUE(comp_evt.cancelled);
comp_evt.get_result().get<std::string>().c_str()); });
EXPECT_STREQ("1", comp_evt.get_cancelled().get<std::string>().c_str());
});
std::mutex mtx; std::mutex mtx;
std::condition_variable notify; std::condition_variable notify;
@ -128,7 +126,7 @@ TEST(upload, can_cancel_upload) {
notify.notify_one(); notify.notify_one();
lock.unlock(); lock.unlock();
event_capture evt_cap({"file_upload_completed"}); event_capture evt_cap({file_upload_completed::name});
evt_cap.wait_for_empty(); evt_cap.wait_for_empty();
EXPECT_EQ(api_error::comm_error, upload.get_api_error()); EXPECT_EQ(api_error::comm_error, upload.get_api_error());
@ -153,15 +151,14 @@ TEST(upload, can_stop_upload) {
fsi.size = test_chunk_size * 4U; fsi.size = test_chunk_size * 4U;
fsi.source_path = source_path; fsi.source_path = source_path;
event_consumer evt_con("file_upload_completed", [&fsi](const event &evt) { event_consumer evt_con(
const auto &evt_com = dynamic_cast<const file_upload_completed &>(evt); file_upload_completed::name, [&fsi](const i_event &evt) {
EXPECT_STREQ(fsi.api_path.c_str(), const auto &evt_com = dynamic_cast<const file_upload_completed &>(evt);
evt_com.get_api_path().get<std::string>().c_str()); EXPECT_STREQ(fsi.api_path.c_str(), evt_com.api_path.c_str());
EXPECT_STREQ(fsi.source_path.c_str(), EXPECT_STREQ(fsi.source_path.c_str(), evt_com.source_path.c_str());
evt_com.get_source().get<std::string>().c_str()); EXPECT_EQ(api_error::comm_error, evt_com.error);
EXPECT_STREQ("comm_error", evt_com.get_result().get<std::string>().c_str()); EXPECT_FALSE(evt_com.cancelled);
EXPECT_STREQ("0", evt_com.get_cancelled().get<std::string>().c_str()); });
});
EXPECT_CALL(mock_provider, upload_file(fsi.api_path, fsi.source_path, _)) EXPECT_CALL(mock_provider, upload_file(fsi.api_path, fsi.source_path, _))
.WillOnce([](const std::string &, const std::string &, .WillOnce([](const std::string &, const std::string &,
@ -171,7 +168,7 @@ TEST(upload, can_stop_upload) {
return api_error::comm_error; return api_error::comm_error;
}); });
event_capture evt_cap({"file_upload_completed"}); event_capture evt_cap({file_upload_completed::name});
{ {
upload upload(fsi, mock_provider); upload upload(fsi, mock_provider);