Improve EventManager class

- add additional error checks to EventManager class
- improve test coverage for EventManager class
- improve naming convention in EventManager class

include/ls_std/event/EventManager.hpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-11-27
- * Changed:         2021-05-01
+ * Changed:         2021-05-27
  *
  * */
 
@@ -33,16 +33,16 @@ namespace ls_std
 
       // additional functionality
 
-      void addEventHandler(const std::shared_ptr<ls_std::EventHandler> &_eventHandler);
+      bool addEventHandler(const std::shared_ptr<ls_std::EventHandler> &_eventHandler);
       void fire(ls_std::Event _event);
-      void removeEventHandler(const std::shared_ptr<ls_std::EventHandler> &_eventHandler);
+      bool removeEventHandler(const std::shared_ptr<ls_std::EventHandler> &_eventHandler);
 
     private:
 
       std::map<ls_std::event_id, std::shared_ptr<ls_std::EventHandler>> eventHandlers{};
 
       bool _hasEventHandler(const ls_std::event_id &_id);
-      void _removeEventHandler(const std::shared_ptr<ls_std::EventHandler> &_eventHandler);
+      bool _removeEventHandler(const std::shared_ptr<ls_std::EventHandler> &_eventHandler);
   };
 }
 

source/ls_std/event/EventManager.cpp

@@ -3,38 +3,64 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-11-27
- * Changed:         2021-05-01
+ * Changed:         2021-05-27
  *
  * */
 
 #include <ls_std/event/EventManager.hpp>
+#include <ls_std/exception/EventNotSubscribedException.hpp>
+#include <ls_std/exception/EventNotHandledException.hpp>
+#include <ls_std/exception/IllegalArgumentException.hpp>
 
 ls_std::EventManager::EventManager() : ls_std::Class("EventManager")
 {}
 
 void ls_std::EventManager::subscribe(const ls_std::event_id &_id, const std::shared_ptr<ls_std::IListener> &_listener)
 {
+  if (_id.empty() || _listener == nullptr)
+  {
+    throw ls_std::IllegalArgumentException{};
+  }
+
   if (this->_hasEventHandler(_id))
   {
     this->eventHandlers.at(_id)->addListener(_listener);
   }
+  else
+  {
+    throw ls_std::EventNotSubscribedException{};
+  }
 }
 
 void ls_std::EventManager::unsubscribe(const ls_std::event_id &_id, const std::shared_ptr<ls_std::IListener> &_listener)
 {
+  if (_id.empty() || _listener == nullptr)
+  {
+    throw ls_std::IllegalArgumentException{};
+  }
+
   if (this->_hasEventHandler(_id))
   {
     this->eventHandlers.at(_id)->removeListener(_listener);
   }
 }
 
-void ls_std::EventManager::addEventHandler(const std::shared_ptr<ls_std::EventHandler> &_eventHandler)
+bool ls_std::EventManager::addEventHandler(const std::shared_ptr<ls_std::EventHandler> &_eventHandler)
 {
+  bool wasAdded{};
+
+  if (_eventHandler == nullptr)
+  {
+    throw ls_std::IllegalArgumentException{};
+  }
+
   if (!this->_hasEventHandler(_eventHandler->getId()))
   {
     std::pair<ls_std::event_id, std::shared_ptr<ls_std::EventHandler>> element = std::make_pair(_eventHandler->getId(), _eventHandler);
-    this->eventHandlers.insert(element);
+    wasAdded = this->eventHandlers.insert(element).second;
   }
+
+  return wasAdded;
 }
 
 void ls_std::EventManager::fire(ls_std::Event _event)
@@ -43,11 +69,20 @@ void ls_std::EventManager::fire(ls_std::Event _event)
   {
     this->eventHandlers.at(_event.getId())->tell(_event);
   }
+  else
+  {
+    throw ls_std::EventNotHandledException{};
+  }
 }
 
-void ls_std::EventManager::removeEventHandler(const std::shared_ptr<ls_std::EventHandler> &_eventHandler)
+bool ls_std::EventManager::removeEventHandler(const std::shared_ptr<ls_std::EventHandler> &_eventHandler)
 {
-  this->_removeEventHandler(_eventHandler);
+  if (_eventHandler == nullptr)
+  {
+    throw ls_std::IllegalArgumentException{};
+  }
+
+  return this->_removeEventHandler(_eventHandler);
 }
 
 bool ls_std::EventManager::_hasEventHandler(const ls_std::event_id &_id)
@@ -55,7 +90,7 @@ bool ls_std::EventManager::_hasEventHandler(const ls_std::event_id &_id)
   return this->eventHandlers.find(_id) != this->eventHandlers.end();
 }
 
-void ls_std::EventManager::_removeEventHandler(const std::shared_ptr<ls_std::EventHandler> &_eventHandler)
+bool ls_std::EventManager::_removeEventHandler(const std::shared_ptr<ls_std::EventHandler> &_eventHandler)
 {
-  this->eventHandlers.erase(_eventHandler->getId());
+  return this->eventHandlers.erase(_eventHandler->getId()) == 1;
 }

test/cases/event/EventManagerTest.cpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-11-27
- * Changed:         2021-04-23
+ * Changed:         2021-05-27
  *
  * */
 
@@ -33,6 +33,154 @@ namespace
     ASSERT_STREQ("EventManager", eventManager.getClassName().c_str());
   }
 
+  TEST_F(EventManagerTest, subscribe_empty_id)
+  {
+    EXPECT_THROW({
+                   try
+                   {
+                     ls_std::EventManager eventManager{};
+                     eventManager.subscribe("", std::make_shared<ls_std_test::DailyNewsAgency>());
+                   }
+                   catch (const ls_std::IllegalArgumentException &_exception)
+                   {
+                     throw;
+                   }
+                 }, ls_std::IllegalArgumentException);
+  }
+
+  TEST_F(EventManagerTest, subscribe_no_listener)
+  {
+    EXPECT_THROW({
+                   try
+                   {
+                     ls_std::EventManager eventManager{};
+                     eventManager.subscribe("TMP_ID", nullptr);
+                   }
+                   catch (const ls_std::IllegalArgumentException &_exception)
+                   {
+                     throw;
+                   }
+                 }, ls_std::IllegalArgumentException);
+  }
+
+  TEST_F(EventManagerTest, subscribe_no_event_handler_available)
+  {
+    EXPECT_THROW({
+                   try
+                   {
+                     ls_std::EventManager eventManager{};
+                     eventManager.subscribe("TMP_DIR", std::make_shared<ls_std_test::DailyNewsAgency>());
+                   }
+                   catch (const ls_std::EventNotSubscribedException &_exception)
+                   {
+                     throw;
+                   }
+                 }, ls_std::EventNotSubscribedException);
+  }
+
+  TEST_F(EventManagerTest, unsubscribe_empty_id)
+  {
+    EXPECT_THROW({
+                   try
+                   {
+                     ls_std::EventManager eventManager{};
+                     eventManager.unsubscribe("", std::make_shared<ls_std_test::DailyNewsAgency>());
+                   }
+                   catch (const ls_std::IllegalArgumentException &_exception)
+                   {
+                     throw;
+                   }
+                 }, ls_std::IllegalArgumentException);
+  }
+
+  TEST_F(EventManagerTest, unsubscribe_no_listener)
+  {
+    EXPECT_THROW({
+                   try
+                   {
+                     ls_std::EventManager eventManager{};
+                     eventManager.unsubscribe("TMP_ID", nullptr);
+                   }
+                   catch (const ls_std::IllegalArgumentException &_exception)
+                   {
+                     throw;
+                   }
+                 }, ls_std::IllegalArgumentException);
+  }
+
+  TEST_F(EventManagerTest, addEventHandler)
+  {
+    ls_std::EventManager eventManager{};
+    ASSERT_TRUE(eventManager.addEventHandler(std::make_shared<ls_std::EventHandler>("TMP_ID")));
+  }
+
+  TEST_F(EventManagerTest, addEventHandler_event_handler_already_exists)
+  {
+    ls_std::EventManager eventManager{};
+    ASSERT_TRUE(eventManager.addEventHandler(std::make_shared<ls_std::EventHandler>("TMP_ID")));
+    ASSERT_FALSE(eventManager.addEventHandler(std::make_shared<ls_std::EventHandler>("TMP_ID")));
+  }
+
+  TEST_F(EventManagerTest, addEventHandler_no_reference)
+  {
+    EXPECT_THROW({
+                   try
+                   {
+                     ls_std::EventManager eventManager{};
+                     eventManager.addEventHandler(nullptr);
+                   }
+                   catch (const ls_std::IllegalArgumentException &_exception)
+                   {
+                     throw;
+                   }
+                 }, ls_std::IllegalArgumentException);
+  }
+
+  TEST_F(EventManagerTest, fire_event_handler_not_available)
+  {
+    EXPECT_THROW({
+                   try
+                   {
+                     ls_std::EventManager eventManager{};
+                     eventManager.fire(ls_std::Event{"TMP_ID"});
+                   }
+                   catch (const ls_std::EventNotHandledException &_exception)
+                   {
+                     throw;
+                   }
+                 }, ls_std::EventNotHandledException);
+  }
+
+  TEST_F(EventManagerTest, removeEventHandler)
+  {
+    ls_std::EventManager eventManager{};
+    std::shared_ptr<ls_std::EventHandler> eventHandler = std::make_shared<ls_std::EventHandler>("TMP_ID");
+    eventManager.addEventHandler(eventHandler);
+
+    ASSERT_TRUE(eventManager.removeEventHandler(eventHandler));
+  }
+
+  TEST_F(EventManagerTest, removeEventHandler_no_event_handler_available)
+  {
+    ls_std::EventManager eventManager{};
+    ASSERT_FALSE(eventManager.removeEventHandler(std::make_shared<ls_std::EventHandler>("TMP_ID")));
+  }
+
+  TEST_F(EventManagerTest, removeEventHandler_no_reference)
+  {
+    EXPECT_THROW({
+                   try
+                   {
+                     ls_std::EventManager eventManager{};
+                     eventManager.removeEventHandler(nullptr);
+                   }
+                   catch (const ls_std::IllegalArgumentException &_exception)
+                   {
+                     throw;
+                   }
+                 }, ls_std::IllegalArgumentException);
+  }
+
   TEST_F(EventManagerTest, production_example)
   {
     std::string news, expectedNews{};