refactor event system

repertory/librepertory/src/providers/base_provider.cpp

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

repertory/repertory_test/include/test_common.hpp

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

repertory/repertory_test/include/utils/event_capture.hpp

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

repertory/repertory_test/src/file_manager_test.cpp

@@ -22,6 +22,11 @@
 #include "test_common.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_end.hpp"
 #include "events/types/service_stop_begin.hpp"
@@ -75,9 +80,7 @@ protected:
     cache_size_mgr::instance().initialize(cfg.get());
   }
 
-  void TearDown() override {
-    event_system2::instance().stop();
-  }
+  void TearDown() override { event_system2::instance().stop(); }
 };
 
 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) {
   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);
     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);
     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);
     EXPECT_STREQ("file_manager", evt2.service_name.c_str());
   });
 
   event_capture capture({
-      "service_start_begin",
-      "service_stop_begin",
-      "service_stop_end",
+      service_start_begin::name,
+      service_start_end::name,
+      service_stop_begin::name,
+      service_stop_end::name,
   });
 
   file_manager mgr(*cfg, mp);
@@ -123,10 +131,10 @@ TEST_F(file_manager_test, can_create_and_close_file) {
 
   event_capture capture({
       "item_timeout",
-      "filesystem_item_opened",
-      "filesystem_item_handle_opened",
-      "filesystem_item_handle_closed",
-      "filesystem_item_closed",
+      filesystem_item_opened::name,
+      filesystem_item_handle_opened::name,
+      filesystem_item_handle_closed::name,
+      filesystem_item_closed::name,
   });
 
   auto source_path = utils::path::combine(cfg->get_cache_directory(),
@@ -156,7 +164,8 @@ TEST_F(file_manager_test, can_create_and_close_file) {
           return api_error::success;
         });
 
-    event_consumer consumer("filesystem_item_opened", [&](const i_event &evt) {
+    event_consumer consumer(
+        filesystem_item_opened::name, [&](const i_event &evt) {
           const auto &evt2 = dynamic_cast<const filesystem_item_opened &>(evt);
           EXPECT_STREQ("/test_create.txt", evt2.api_path.c_str());
           EXPECT_STREQ(source_path.c_str(), evt2.source_path.c_str());
@@ -164,7 +173,7 @@ TEST_F(file_manager_test, can_create_and_close_file) {
         });
 
     event_consumer ec2(
-        "filesystem_item_handle_opened", [&](const i_event &evt) {
+        filesystem_item_handle_opened::name, [&](const i_event &evt) {
           const auto &evt2 =
               dynamic_cast<const filesystem_item_handle_opened &>(evt);
           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);
   }
 
-  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);
     EXPECT_STREQ("/test_create.txt",
                  evt2.get_api_path().get<std::string>().c_str());
@@ -194,8 +203,10 @@ TEST_F(file_manager_test, can_create_and_close_file) {
     EXPECT_STREQ("0", evt2.get_directory().get<std::string>().c_str());
   });
 
-  event_consumer ec4("filesystem_item_handle_closed", [&](const i_event &evt) {
-    const auto &evt2 = dynamic_cast<const filesystem_item_handle_closed &>(evt);
+  event_consumer ec4(
+      filesystem_item_handle_closed::name, [&](const i_event &evt) {
+        const auto &evt2 =
+            dynamic_cast<const filesystem_item_handle_closed &>(evt);
         EXPECT_STREQ("/test_create.txt",
                      evt2.get_api_path().get<std::string>().c_str());
         EXPECT_STREQ(source_path.c_str(),
@@ -229,10 +240,10 @@ TEST_F(file_manager_test, can_open_and_close_file) {
 
   event_capture capture({
       "item_timeout",
-      "filesystem_item_opened",
-      "filesystem_item_handle_opened",
-      "filesystem_item_handle_closed",
-      "filesystem_item_closed",
+      filesystem_item_opened::name,
+      filesystem_item_handle_opened::name,
+      filesystem_item_handle_closed::name,
+      filesystem_item_closed::name,
   });
   auto source_path = utils::path::combine(cfg->get_cache_directory(),
                                           {utils::create_uuid_string()});
@@ -260,7 +271,8 @@ TEST_F(file_manager_test, can_open_and_close_file) {
           return api_error::success;
         });
 
-    event_consumer consumer("filesystem_item_opened", [&](const i_event &evt) {
+    event_consumer consumer(
+        filesystem_item_opened::name, [&](const i_event &evt) {
           const auto &evt2 = dynamic_cast<const filesystem_item_opened &>(evt);
           EXPECT_STREQ("/test_open.txt",
                        evt2.get_api_path().get<std::string>().c_str());
@@ -270,7 +282,7 @@ TEST_F(file_manager_test, can_open_and_close_file) {
         });
 
     event_consumer ec2(
-        "filesystem_item_handle_opened", [&](const i_event &evt) {
+        filesystem_item_handle_opened::name, [&](const i_event &evt) {
           const auto &evt2 =
               dynamic_cast<const filesystem_item_handle_opened &>(evt);
           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);
   }
 
-  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);
     EXPECT_STREQ("/test_open.txt",
                  evt2.get_api_path().get<std::string>().c_str());
@@ -303,8 +315,10 @@ TEST_F(file_manager_test, can_open_and_close_file) {
     EXPECT_STREQ("0", evt2.get_directory().get<std::string>().c_str());
   });
 
-  event_consumer ec4("filesystem_item_handle_closed", [&](const i_event &evt) {
-    const auto &evt2 = dynamic_cast<const filesystem_item_handle_closed &>(evt);
+  event_consumer ec4(
+      filesystem_item_handle_closed::name, [&](const i_event &evt) {
+        const auto &evt2 =
+            dynamic_cast<const filesystem_item_handle_closed &>(evt);
         EXPECT_STREQ("/test_open.txt",
                      evt2.get_api_path().get<std::string>().c_str());
         EXPECT_STREQ(source_path.c_str(),
@@ -407,9 +421,10 @@ TEST_F(file_manager_test,
                      evt2.get_dest_path().get<std::string>().c_str());
       });
 
-  event_capture capture({"download_resume_added"}, {
-                                                       "file_upload_completed",
-                                                       "file_upload_queued",
+  event_capture capture({"download_resume_added"},
+                        {
+                            file_upload_completed::name,
+                            file_upload_queued::name,
                         });
 
   auto now = utils::time::get_time_now();
@@ -499,8 +514,8 @@ TEST_F(file_manager_test,
 
   event_capture ec2({"download_restored", "download_resume_added"},
                     {
-                        "file_upload_completed",
-                        "file_upload_queued",
+                        file_upload_completed::name,
+                        file_upload_queued::name,
                     });
   EXPECT_EQ(std::size_t(0u), mgr.get_open_file_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());
       });
   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);
         EXPECT_STREQ("/test_write_full_download.txt",
                      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({
       "item_timeout",
       "file_upload_queued",
-      "file_upload_completed",
+      file_upload_completed::name,
   });
 
   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();
 
   event_capture capture({
-      "filesystem_item_opened",
-      "filesystem_item_handle_opened",
-      "filesystem_item_handle_closed",
-      "filesystem_item_closed",
-      "file_upload_completed",
+      filesystem_item_opened::name,
+      filesystem_item_handle_opened::name,
+      filesystem_item_handle_closed::name,
+      filesystem_item_closed::name,
+      file_upload_completed::name,
   });
 
   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();
 
   event_capture capture({
-      "filesystem_item_opened",
-      "filesystem_item_handle_opened",
-      "filesystem_item_handle_closed",
-      "filesystem_item_closed",
-      "file_upload_completed",
+      filesystem_item_opened::name,
+      filesystem_item_handle_opened::name,
+      filesystem_item_handle_closed::name,
+      filesystem_item_closed::name,
+      file_upload_completed::name,
   });
 
   auto source_path = utils::path::combine(cfg->get_cache_directory(),
@@ -1573,10 +1588,10 @@ TEST_F(file_manager_test,
 
   event_capture capture({
       "item_timeout",
-      "filesystem_item_opened",
-      "filesystem_item_handle_opened",
-      "filesystem_item_handle_closed",
-      "filesystem_item_closed",
+      filesystem_item_opened::name,
+      filesystem_item_handle_opened::name,
+      filesystem_item_handle_closed::name,
+      filesystem_item_closed::name,
   });
 
   std::uint64_t handle{};

repertory/repertory_test/src/open_file_test.cpp

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

repertory/repertory_test/src/upload_test.cpp

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