Refactor message handling: remove MessageDispatcher, MessageFilter, and related classes to streamline codebase

This commit is contained in:
scawful
2024-11-09 19:17:36 -05:00
parent b06d632ef9
commit d9243b26f7
3 changed files with 0 additions and 389 deletions

View File

@@ -1,124 +0,0 @@
#include "core/message.h"
#include <gtest/gtest.h>
namespace yaze {
namespace test {
namespace message {
using app::core::IMessageListener;
using app::core::IMessageProtocol;
using app::core::Message;
using app::core::MessageDispatcher;
using app::core::MessageFilter;
class TestListener : public IMessageListener {
public:
~TestListener() = default;
absl::Status OnMessageReceived(const Message& message) override {
last_message_ = message;
message_count_++;
return absl::OkStatus();
}
const Message& last_message() const { return last_message_; }
int message_count() const { return message_count_; }
private:
Message last_message_;
int message_count_ = 0;
};
class TestProtocol : public IMessageProtocol {
public:
bool CanHandleMessage(const Message& message) const override {
return message.type == "TestMessage";
}
};
class TestFilter : public MessageFilter {
public:
bool ShouldReceiveMessage(const Message& message) const override {
return std::any_cast<int>(message.payload) > 10;
}
};
class MessageDispatcherTest : public ::testing::Test {
protected:
void SetUp() override {
message_count_ = 0;
protocol_ = std::make_unique<TestProtocol>();
filter_ = std::make_unique<TestFilter>();
}
void TearDown() override {
protocol_.reset();
filter_.reset();
}
int message_count_ = 0;
int message_count1_ = 0;
int message_count2_ = 0;
TestListener listener1_;
TestListener listener2_;
std::unique_ptr<TestProtocol> protocol_;
std::unique_ptr<TestFilter> filter_;
};
TEST_F(MessageDispatcherTest, RegisterAndSendMessage) {
MessageDispatcher dispatcher;
dispatcher.RegisterListener("TestMessage", &listener1_);
Message message("TestMessage", nullptr, 42);
dispatcher.SendMessage(message);
EXPECT_EQ(listener1_.message_count(), 1);
EXPECT_EQ(std::any_cast<int>(listener1_.last_message().payload), 42);
}
TEST_F(MessageDispatcherTest, UnregisterListener) {
MessageDispatcher dispatcher;
dispatcher.RegisterListener("TestMessage", &listener1_);
dispatcher.UnregisterListener("TestMessage", &listener1_);
Message message("TestMessage", nullptr, 42);
dispatcher.SendMessage(message);
EXPECT_EQ(listener1_.message_count(), 0);
}
TEST_F(MessageDispatcherTest, MultipleListeners) {
MessageDispatcher dispatcher;
dispatcher.RegisterListener("TestMessage", &listener1_);
dispatcher.RegisterListener("TestMessage", &listener2_);
Message message("TestMessage", nullptr, 42);
dispatcher.SendMessage(message);
EXPECT_EQ(listener1_.message_count(), 1);
EXPECT_EQ(listener2_.message_count(), 1);
EXPECT_EQ(std::any_cast<int>(listener1_.last_message().payload), 42);
EXPECT_EQ(std::any_cast<int>(listener2_.last_message().payload), 42);
}
TEST_F(MessageDispatcherTest, FilteredMessageHandling) {
MessageDispatcher dispatcher;
dispatcher.RegisterFilteredListener("TestMessage", &listener1_,
std::move(filter_));
Message valid_message("TestMessage", nullptr, 15);
dispatcher.DispatchMessage(valid_message);
EXPECT_EQ(listener1_.message_count(), 1);
Message invalid_message("TestMessage", nullptr, 5);
dispatcher.DispatchMessage(invalid_message);
EXPECT_EQ(listener1_.message_count(), 1);
}
} // namespace message
} // namespace test
} // namespace yaze