From 50d5c163f2ca6444b18ec50db5208a8a8afc324d Mon Sep 17 00:00:00 2001 From: Jerzy Czarkowski Date: Mon, 15 Jun 2026 15:57:00 +0200 Subject: [PATCH] refactor: Events e2e testing, helper functions --- test/tests/CoreModuleEventsTest.cpp | 286 ++---- test/tests/InboxModuleEventsTest.cpp | 1086 ++++++++--------------- test/tests/KvdbModuleEventsTest.cpp | 1112 ++++++++--------------- test/tests/StoreModuleEventsTest.cpp | 1168 +++++++++---------------- test/tests/ThreadModuleEventsTest.cpp | 1010 ++++++++------------- 5 files changed, 1554 insertions(+), 3108 deletions(-) diff --git a/test/tests/CoreModuleEventsTest.cpp b/test/tests/CoreModuleEventsTest.cpp index db015a8a..3d1cfb62 100644 --- a/test/tests/CoreModuleEventsTest.cpp +++ b/test/tests/CoreModuleEventsTest.cpp @@ -1,250 +1,136 @@ -#include -#include -#include -#include "../utils/BaseTest.hpp" -#include +#include "../utils/BaseEndpointEventTest.hpp" #include -#include #include #include -#include -#include using namespace privmx::endpoint; -class CoreEventTest : public privmx::test::BaseTest { -protected: - CoreEventTest() : BaseTest(privmx::test::BaseTestMode::online) {} - void customSetUp() override { - reader = new Poco::Util::IniFileConfiguration(INI_FILE_PATH); - connection = std::make_shared( - core::Connection::connect( - reader->getString("Login.user_1_privKey"), - reader->getString("Login.solutionId"), - getPlatformUrl(reader->getString("Login.instanceUrl")) - ) - ); - } - void customTearDown() override { // tmp segfault fix - connection.reset(); - reader.reset(); - privmx::endpoint::core::EventQueueImpl::getInstance()->clear(); - } - std::shared_ptr connection; - core::EventQueue eventQueue = core::EventQueue::getInstance(); - Poco::Util::IniFileConfiguration::Ptr reader; +class CoreEventTest : public privmx::test::BaseEndpointEventTest { }; TEST_F(CoreEventTest, getEvent_libConnected) { - std::shared_ptr event = nullptr; - EXPECT_NO_THROW({ - eventQueue.waitEvent(); // pop libConnected form queue - }); - + eventQueue.waitEvent(); } TEST_F(CoreEventTest, getEvent_libConnected_different_instances) { - std::shared_ptr event = nullptr; - EXPECT_NO_THROW({ - eventQueue.waitEvent(); // pop libConnected form queue - }); - std::shared_ptr connection_2; - EXPECT_NO_THROW({ - connection_2 = std::make_shared( - core::Connection::connect( - reader->getString("Login.user_2_privKey"), - reader->getString("Login.solutionId"), - getPlatformUrl(reader->getString("Login.instanceUrl")) - ) - ); - }); - EXPECT_NO_THROW({ - std::optional eventHolder = eventQueue.getEvent(); - if(eventHolder.has_value()) { - event = eventHolder.value().get(); - } else { - event = nullptr; - } - }); - if(event != nullptr) { - EXPECT_EQ(event->connectionId, connection_2->getConnectionId()); - EXPECT_EQ(event->type, "libConnected"); - EXPECT_TRUE(core::Events::isLibConnectedEvent(event)); - } else { - FAIL(); - } + eventQueue.waitEvent(); + auto connection_2 = std::make_shared( + core::Connection::connect( + reader->getString("Login.user_2_privKey"), + reader->getString("Login.solutionId"), + getPlatformUrl(reader->getString("Login.instanceUrl")) + ) + ); + auto eventHolder = waitForEvent("libConnected", {connection_2->getConnectionId()}); + ASSERT_TRUE(eventHolder.has_value()); + auto event = eventHolder.value().get(); + ASSERT_NE(event, nullptr); + EXPECT_EQ(event->connectionId, connection_2->getConnectionId()); + EXPECT_EQ(event->type, "libConnected"); + EXPECT_TRUE(core::Events::isLibConnectedEvent(event)); } TEST_F(CoreEventTest, waitEvent_getEvent_libDisconnected) { - std::shared_ptr event = nullptr; - EXPECT_NO_THROW({ - eventQueue.waitEvent(); // pop libConnected form queue - }); - EXPECT_NO_THROW({ - connection->disconnect(); - }); - EXPECT_NO_THROW({ - std::optional eventHolder = eventQueue.getEvent(); - if(eventHolder.has_value()) { - event = eventHolder.value().get(); - } else { - event = nullptr; - } - }); - if(event != nullptr) { - EXPECT_EQ(event->connectionId, connection->getConnectionId()); - EXPECT_EQ(event->type, "libDisconnected"); - EXPECT_TRUE(core::Events::isLibDisconnectedEvent(event)); - } else { - FAIL(); - } + eventQueue.waitEvent(); + connection->disconnect(); + auto eventHolder = waitForEvent("libDisconnected", {connection->getConnectionId()}); + ASSERT_TRUE(eventHolder.has_value()); + auto event = eventHolder.value().get(); + ASSERT_NE(event, nullptr); + EXPECT_EQ(event->connectionId, connection->getConnectionId()); + EXPECT_EQ(event->type, "libDisconnected"); + EXPECT_TRUE(core::Events::isLibDisconnectedEvent(event)); } - TEST_F(CoreEventTest, waitEvent_getEvent_ContextUsersStatusChangedEvent_enabled) { - std::shared_ptr event = nullptr; - EXPECT_NO_THROW({ - eventQueue.waitEvent(); // pop libConnected form queue - }); - std::shared_ptr connection_2; - EXPECT_NO_THROW({ - connection_2 = std::make_shared( - core::Connection::connect( - reader->getString("Login.user_2_privKey"), - reader->getString("Login.solutionId"), - getPlatformUrl(reader->getString("Login.instanceUrl")) - ) - ); - }); - EXPECT_NO_THROW({ - eventQueue.waitEvent(); // pop libConnected form queue - }); + eventQueue.waitEvent(); + auto connection_2 = std::make_shared( + core::Connection::connect( + reader->getString("Login.user_2_privKey"), + reader->getString("Login.solutionId"), + getPlatformUrl(reader->getString("Login.instanceUrl")) + ) + ); + eventQueue.waitEvent(); // pop libConnected for connection_2 std::this_thread::sleep_for(std::chrono::milliseconds(1500)); - EXPECT_NO_THROW({ - connection->subscribeFor( - { - connection->buildSubscriptionQuery( - core::EventType::USER_STATUS, - core::EventSelectorType::CONTEXT_ID, - reader->getString("Context_1.contextId") - ) - } - ); - connection_2->disconnect(); - }); - EXPECT_NO_THROW({ - eventQueue.waitEvent(); // pop libDisconnected form queue - }); - EXPECT_NO_THROW({ - eventQueue.waitEvent(); // pop libPlatformDisconnected form queue - }); - EXPECT_NO_THROW({ - std::this_thread::sleep_for(std::chrono::milliseconds(1500)); - std::optional eventHolder = eventQueue.getEvent(); - if(eventHolder.has_value()) { - event = eventHolder.value().get(); - } else { - event = nullptr; - } - }); - if(event != nullptr) { - EXPECT_EQ(event->connectionId, connection->getConnectionId()); - EXPECT_EQ(event->type, "contextUserStatusChanged"); - EXPECT_EQ(event->channel, "context/userStatus"); - if(core::Events::isContextUsersStatusChangedEvent(event)) { - EXPECT_EQ(event->subscriptions.size(), 1); - core::ContextUsersStatusChangedEventData usersStatusChanged = core::Events::extractContextUsersStatusChangedEvent(event).data; - EXPECT_EQ(usersStatusChanged.contextId, reader->getString("Context_1.contextId")); - EXPECT_EQ(usersStatusChanged.users.size(), 1); - if(usersStatusChanged.users.size() > 0) { - auto userWithAction = usersStatusChanged.users[0]; - EXPECT_EQ(userWithAction.user.pubKey, reader->getString("Login.user_2_pubKey")); - EXPECT_EQ(userWithAction.user.userId, reader->getString("Login.user_2_id")); - EXPECT_EQ(userWithAction.action, "logout"); - } - } else { - FAIL(); + connection->subscribeFor( + { + connection->buildSubscriptionQuery( + core::EventType::USER_STATUS, + core::EventSelectorType::CONTEXT_ID, + reader->getString("Context_1.contextId") + ) } - } else { - FAIL(); + ); + connection_2->disconnect(); + eventQueue.waitEvent(); // pop libDisconnected + eventQueue.waitEvent(); // pop libPlatformDisconnected + auto eventHolder = waitForEvent("contextUserStatusChanged", {connection->getConnectionId()}); + ASSERT_TRUE(eventHolder.has_value()); + auto event = eventHolder.value().get(); + ASSERT_NE(event, nullptr); + EXPECT_EQ(event->connectionId, connection->getConnectionId()); + EXPECT_EQ(event->type, "contextUserStatusChanged"); + EXPECT_EQ(event->channel, "context/userStatus"); + ASSERT_TRUE(core::Events::isContextUsersStatusChangedEvent(event)); + EXPECT_EQ(event->subscriptions.size(), 1); + core::ContextUsersStatusChangedEventData usersStatusChanged = core::Events::extractContextUsersStatusChangedEvent(event).data; + EXPECT_EQ(usersStatusChanged.contextId, reader->getString("Context_1.contextId")); + EXPECT_EQ(usersStatusChanged.users.size(), 1); + if(usersStatusChanged.users.size() > 0) { + auto userWithAction = usersStatusChanged.users[0]; + EXPECT_EQ(userWithAction.user.pubKey, reader->getString("Login.user_2_pubKey")); + EXPECT_EQ(userWithAction.user.userId, reader->getString("Login.user_2_id")); + EXPECT_EQ(userWithAction.action, "logout"); } } TEST_F(CoreEventTest, waitEvent_getEvent_ContextUsersStatusChangedEvent_disabled) { - std::shared_ptr event = nullptr; - EXPECT_NO_THROW({ - eventQueue.waitEvent(); // pop libConnected form queue - }); - std::shared_ptr connection_2; - EXPECT_NO_THROW({ - connection_2 = std::make_shared( - core::Connection::connect( - reader->getString("Login.user_2_privKey"), - reader->getString("Login.solutionId"), - getPlatformUrl(reader->getString("Login.instanceUrl")) - ) - ); - }); - EXPECT_NO_THROW({ - eventQueue.waitEvent(); // pop libConnected form queue - }); - EXPECT_NO_THROW({ - connection_2->disconnect(); - }); - EXPECT_NO_THROW({ - eventQueue.waitEvent(); // pop libDisconnected form queue - }); - EXPECT_NO_THROW({ - eventQueue.waitEvent(); // pop libPlatformDisconnected form queue - }); - EXPECT_NO_THROW({ - std::this_thread::sleep_for(std::chrono::milliseconds(1500)); - std::optional eventHolder = eventQueue.getEvent(); - if(eventHolder.has_value()) { - event = eventHolder.value().get(); - } else { - event = nullptr; - } - }); - if(event == nullptr) { - - } else { - std::cout << "Received Event with type " << event->type << std::endl; - std::cout << "Expected null" << std::endl; - FAIL(); - } + eventQueue.waitEvent(); + auto connection_2 = std::make_shared( + core::Connection::connect( + reader->getString("Login.user_2_privKey"), + reader->getString("Login.solutionId"), + getPlatformUrl(reader->getString("Login.instanceUrl")) + ) + ); + eventQueue.waitEvent(); // pop libConnected for connection_2 + connection_2->disconnect(); + eventQueue.waitEvent(); // pop libDisconnected + eventQueue.waitEvent(); // pop libPlatformDisconnected + assertNoEventReceived(); } TEST_F(CoreEventTest, subscribeFor_unsubscribeFor) { std::vector valid_subscriptions; EXPECT_NO_THROW({ valid_subscriptions = connection->subscribeFor({ - connection->buildSubscriptionQuery( - core::EventType::USER_ADD, - core::EventSelectorType::CONTEXT_ID, - reader->getString("Context_1.contextId") + connection->buildSubscriptionQuery( + core::EventType::USER_ADD, + core::EventSelectorType::CONTEXT_ID, + reader->getString("Context_1.contextId") ) }); }); std::vector invalid_subscriptions; EXPECT_NO_THROW({ invalid_subscriptions = connection->subscribeFor({ - connection->buildSubscriptionQuery( - core::EventType::USER_ADD, - core::EventSelectorType::CONTEXT_ID, + connection->buildSubscriptionQuery( + core::EventType::USER_ADD, + core::EventSelectorType::CONTEXT_ID, "error" ) }); }); EXPECT_NO_THROW({ connection->unsubscribeFrom({ - valid_subscriptions + valid_subscriptions }); }); EXPECT_NO_THROW({ connection->unsubscribeFrom({ - invalid_subscriptions + invalid_subscriptions }); }); } diff --git a/test/tests/InboxModuleEventsTest.cpp b/test/tests/InboxModuleEventsTest.cpp index aaec9ee1..6a5ae143 100644 --- a/test/tests/InboxModuleEventsTest.cpp +++ b/test/tests/InboxModuleEventsTest.cpp @@ -1,9 +1,5 @@ -#include -#include -#include -#include "../utils/BaseTest.hpp" -#include +#include "../utils/BaseEndpointEventTest.hpp" #include #include #include @@ -14,651 +10,340 @@ #include #include #include -#include #include #include -#include -#include using namespace privmx::endpoint; -class InboxEventTest : public privmx::test::BaseTest { +class InboxEventTest : public privmx::test::BaseEndpointEventTest { protected: - InboxEventTest() : BaseTest(privmx::test::BaseTestMode::online) {} - void customSetUp() override { - reader = new Poco::Util::IniFileConfiguration(INI_FILE_PATH); - connection = std::make_shared( - core::Connection::connect( - reader->getString("Login.user_1_privKey"), - reader->getString("Login.solutionId"), - getPlatformUrl(reader->getString("Login.instanceUrl")) - ) - ); + void setUpModuleApis() override { threadApi = std::make_shared( - thread::ThreadApi::create( - *connection - ) + thread::ThreadApi::create(*connection) ); storeApi = std::make_shared( - store::StoreApi::create( - *connection - ) + store::StoreApi::create(*connection) ); inboxApi = std::make_shared( - inbox::InboxApi::create( - *connection, - *threadApi, - *storeApi - ) + inbox::InboxApi::create(*connection, *threadApi, *storeApi) ); } - void customTearDown() override { // tmp segfault fix - connection.reset(); - threadApi.reset(); - storeApi.reset(); + void tearDownModuleApis() override { inboxApi.reset(); - reader.reset(); - privmx::endpoint::core::EventQueueImpl::getInstance()->clear(); + storeApi.reset(); + threadApi.reset(); } - std::shared_ptr connection; std::shared_ptr threadApi; std::shared_ptr storeApi; std::shared_ptr inboxApi; - core::EventQueue eventQueue = core::EventQueue::getInstance(); - Poco::Util::IniFileConfiguration::Ptr reader; }; TEST_F(InboxEventTest, waitEvent_getEvent_inboxCreated_enabled) { - std::shared_ptr event = nullptr; - EXPECT_NO_THROW({ - eventQueue.waitEvent(); // pop libConnected form queue - }); - EXPECT_NO_THROW({ - inboxApi->subscribeFor({ - inboxApi->buildSubscriptionQuery( - inbox::EventType::INBOX_CREATE, - inbox::EventSelectorType::CONTEXT_ID, - reader->getString("Context_1.contextId") - ) - }); - }); - std::string inboxId; - EXPECT_NO_THROW({ - inboxId = inboxApi->createInbox( - reader->getString("Context_1.contextId"), - std::vector{core::UserWithPubKey{ - .userId=reader->getString("Login.user_1_id"), - .pubKey=reader->getString("Login.user_1_pubKey") - }}, - std::vector{core::UserWithPubKey{ - .userId=reader->getString("Login.user_1_id"), - .pubKey=reader->getString("Login.user_1_pubKey") - }}, - core::Buffer::from("public"), - core::Buffer::from("private"), - std::nullopt - ); - }); - EXPECT_NO_THROW({ - std::this_thread::sleep_for(std::chrono::milliseconds(1500)); - std::optional eventHolder = eventQueue.getEvent(); - if(eventHolder.has_value()) { - event = eventHolder.value().get(); - } else { - event = nullptr; - } - }); - if(event != nullptr) { - EXPECT_EQ(event->connectionId, connection->getConnectionId()); - EXPECT_EQ(event->type, "inboxCreated"); - EXPECT_EQ(event->channel, "inbox"); - if(inbox::Events::isInboxCreatedEvent(event)) { - EXPECT_EQ(event->subscriptions.size(), 1); - inbox::Inbox inbox = inbox::Events::extractInboxCreatedEvent(event).data; - EXPECT_EQ(inbox.contextId, reader->getString("Context_1.contextId")); - EXPECT_EQ(inbox.users.size(), 1); - if(inbox.users.size() == 1) { - EXPECT_EQ(inbox.users[0], reader->getString("Login.user_1_id")); - } - EXPECT_EQ(inbox.managers.size(), 1); - if(inbox.managers.size() == 1) { - EXPECT_EQ(inbox.managers[0], reader->getString("Login.user_1_id")); - } - EXPECT_EQ(inbox.publicMeta.stdString(), "public"); - EXPECT_EQ(inbox.privateMeta.stdString(), "private"); - } else { - FAIL(); - } - } else { - FAIL(); + eventQueue.waitEvent(); + inboxApi->subscribeFor({ + inboxApi->buildSubscriptionQuery( + inbox::EventType::INBOX_CREATE, + inbox::EventSelectorType::CONTEXT_ID, + reader->getString("Context_1.contextId") + ) + }); + inboxApi->createInbox( + reader->getString("Context_1.contextId"), + std::vector{core::UserWithPubKey{ + .userId=reader->getString("Login.user_1_id"), + .pubKey=reader->getString("Login.user_1_pubKey") + }}, + std::vector{core::UserWithPubKey{ + .userId=reader->getString("Login.user_1_id"), + .pubKey=reader->getString("Login.user_1_pubKey") + }}, + core::Buffer::from("public"), + core::Buffer::from("private"), + std::nullopt + ); + auto eventHolder = waitForEvent("inboxCreated", {connection->getConnectionId()}); + ASSERT_TRUE(eventHolder.has_value()); + auto event = eventHolder.value().get(); + ASSERT_NE(event, nullptr); + EXPECT_EQ(event->connectionId, connection->getConnectionId()); + EXPECT_EQ(event->type, "inboxCreated"); + EXPECT_EQ(event->channel, "inbox"); + ASSERT_TRUE(inbox::Events::isInboxCreatedEvent(event)); + EXPECT_EQ(event->subscriptions.size(), 1); + inbox::Inbox inbox = inbox::Events::extractInboxCreatedEvent(event).data; + EXPECT_EQ(inbox.contextId, reader->getString("Context_1.contextId")); + EXPECT_EQ(inbox.users.size(), 1); + if(inbox.users.size() == 1) { + EXPECT_EQ(inbox.users[0], reader->getString("Login.user_1_id")); } - EXPECT_NO_THROW({ - std::optional eventHolder = eventQueue.getEvent(); - if(eventHolder.has_value()) { - event = eventHolder.value().get(); - } else { - event = nullptr; - } - }); - if(event == nullptr) { - - } else { - std::cout << "Received Event with type " << event->type << std::endl; - std::cout << "Expected null" << std::endl; - FAIL(); + EXPECT_EQ(inbox.managers.size(), 1); + if(inbox.managers.size() == 1) { + EXPECT_EQ(inbox.managers[0], reader->getString("Login.user_1_id")); } + EXPECT_EQ(inbox.publicMeta.stdString(), "public"); + EXPECT_EQ(inbox.privateMeta.stdString(), "private"); + assertNoEventReceived(std::chrono::milliseconds(0)); } TEST_F(InboxEventTest, waitEvent_getEvent_inboxCreated_disabled) { - std::shared_ptr event = nullptr; - EXPECT_NO_THROW({ - eventQueue.waitEvent(); // pop libConnected form queue - }); - EXPECT_NO_THROW({ - auto tmp = inboxApi->subscribeFor({ - inboxApi->buildSubscriptionQuery( - inbox::EventType::INBOX_CREATE, - inbox::EventSelectorType::CONTEXT_ID, - reader->getString("Context_1.contextId") - ) - }); - inboxApi->unsubscribeFrom(tmp); - }); - std::string inboxId; - EXPECT_NO_THROW({ - inboxId = inboxApi->createInbox( - reader->getString("Context_1.contextId"), - std::vector{core::UserWithPubKey{ - .userId=reader->getString("Login.user_1_id"), - .pubKey=reader->getString("Login.user_1_pubKey") - }}, - std::vector{core::UserWithPubKey{ - .userId=reader->getString("Login.user_1_id"), - .pubKey=reader->getString("Login.user_1_pubKey") - }}, - core::Buffer::from("public"), - core::Buffer::from("private"), - std::nullopt - ); - }); - EXPECT_NO_THROW({ - std::this_thread::sleep_for(std::chrono::milliseconds(1500)); - std::optional eventHolder = eventQueue.getEvent(); - if(eventHolder.has_value()) { - event = eventHolder.value().get(); - } else { - event = nullptr; - } - }); - if(event == nullptr) { - - } else { - std::cout << "Received Event with type " << event->type << std::endl; - std::cout << "Expected null" << std::endl; - FAIL(); - } + eventQueue.waitEvent(); + auto tmp = inboxApi->subscribeFor({ + inboxApi->buildSubscriptionQuery( + inbox::EventType::INBOX_CREATE, + inbox::EventSelectorType::CONTEXT_ID, + reader->getString("Context_1.contextId") + ) + }); + inboxApi->unsubscribeFrom(tmp); + inboxApi->createInbox( + reader->getString("Context_1.contextId"), + std::vector{core::UserWithPubKey{ + .userId=reader->getString("Login.user_1_id"), + .pubKey=reader->getString("Login.user_1_pubKey") + }}, + std::vector{core::UserWithPubKey{ + .userId=reader->getString("Login.user_1_id"), + .pubKey=reader->getString("Login.user_1_pubKey") + }}, + core::Buffer::from("public"), + core::Buffer::from("private"), + std::nullopt + ); + assertNoEventReceived(); } TEST_F(InboxEventTest, waitEvent_getEvent_inboxUpdated_enabled) { - std::shared_ptr event = nullptr; - EXPECT_NO_THROW({ - eventQueue.waitEvent(); // pop libConnected form queue - }); - EXPECT_NO_THROW({ - inboxApi->subscribeFor({ - inboxApi->buildSubscriptionQuery( - inbox::EventType::INBOX_UPDATE, - inbox::EventSelectorType::CONTEXT_ID, - reader->getString("Context_1.contextId") - ) - }); - }); - EXPECT_NO_THROW({ - inboxApi->updateInbox( - reader->getString("Inbox_1.inboxId"), - std::vector{core::UserWithPubKey{ - .userId=reader->getString("Login.user_1_id"), - .pubKey=reader->getString("Login.user_1_pubKey") - }}, - std::vector{core::UserWithPubKey{ - .userId=reader->getString("Login.user_1_id"), - .pubKey=reader->getString("Login.user_1_pubKey") - }}, - core::Buffer::from("public"), - core::Buffer::from("private"), - std::nullopt, - 1, - true, - false - ); - }); - EXPECT_NO_THROW({ - std::this_thread::sleep_for(std::chrono::milliseconds(1500)); - std::optional eventHolder = eventQueue.getEvent(); - if(eventHolder.has_value()) { - event = eventHolder.value().get(); - } else { - event = nullptr; - } - }); - if(event != nullptr) { - EXPECT_EQ(event->connectionId, connection->getConnectionId()); - EXPECT_EQ(event->type, "inboxUpdated"); - EXPECT_EQ(event->channel, "inbox"); - if(inbox::Events::isInboxUpdatedEvent(event)) { - EXPECT_EQ(event->subscriptions.size(), 1); - inbox::Inbox inbox = inbox::Events::extractInboxUpdatedEvent(event).data; - EXPECT_EQ(inbox.contextId, reader->getString("Context_1.contextId")); - EXPECT_EQ(inbox.users.size(), 1); - if(inbox.users.size() == 1) { - EXPECT_EQ(inbox.users[0], reader->getString("Login.user_1_id")); - } - EXPECT_EQ(inbox.managers.size(), 1); - if(inbox.managers.size() == 1) { - EXPECT_EQ(inbox.managers[0], reader->getString("Login.user_1_id")); - } - EXPECT_EQ(inbox.publicMeta.stdString(), "public"); - EXPECT_EQ(inbox.privateMeta.stdString(), "private"); - } else { - FAIL(); - } - } else { - FAIL(); + eventQueue.waitEvent(); + inboxApi->subscribeFor({ + inboxApi->buildSubscriptionQuery( + inbox::EventType::INBOX_UPDATE, + inbox::EventSelectorType::CONTEXT_ID, + reader->getString("Context_1.contextId") + ) + }); + inboxApi->updateInbox( + reader->getString("Inbox_1.inboxId"), + std::vector{core::UserWithPubKey{ + .userId=reader->getString("Login.user_1_id"), + .pubKey=reader->getString("Login.user_1_pubKey") + }}, + std::vector{core::UserWithPubKey{ + .userId=reader->getString("Login.user_1_id"), + .pubKey=reader->getString("Login.user_1_pubKey") + }}, + core::Buffer::from("public"), + core::Buffer::from("private"), + std::nullopt, + 1, + true, + false + ); + auto eventHolder = waitForEvent("inboxUpdated", {connection->getConnectionId()}); + ASSERT_TRUE(eventHolder.has_value()); + auto event = eventHolder.value().get(); + ASSERT_NE(event, nullptr); + EXPECT_EQ(event->connectionId, connection->getConnectionId()); + EXPECT_EQ(event->type, "inboxUpdated"); + EXPECT_EQ(event->channel, "inbox"); + ASSERT_TRUE(inbox::Events::isInboxUpdatedEvent(event)); + EXPECT_EQ(event->subscriptions.size(), 1); + inbox::Inbox inbox = inbox::Events::extractInboxUpdatedEvent(event).data; + EXPECT_EQ(inbox.contextId, reader->getString("Context_1.contextId")); + EXPECT_EQ(inbox.users.size(), 1); + if(inbox.users.size() == 1) { + EXPECT_EQ(inbox.users[0], reader->getString("Login.user_1_id")); } - EXPECT_NO_THROW({ - std::optional eventHolder = eventQueue.getEvent(); - if(eventHolder.has_value()) { - event = eventHolder.value().get(); - } else { - event = nullptr; - } - }); - if(event == nullptr) { - - } else { - std::cout << "Received Event with type " << event->type << std::endl; - std::cout << "Expected null" << std::endl; - FAIL(); + EXPECT_EQ(inbox.managers.size(), 1); + if(inbox.managers.size() == 1) { + EXPECT_EQ(inbox.managers[0], reader->getString("Login.user_1_id")); } + EXPECT_EQ(inbox.publicMeta.stdString(), "public"); + EXPECT_EQ(inbox.privateMeta.stdString(), "private"); + assertNoEventReceived(std::chrono::milliseconds(0)); } TEST_F(InboxEventTest, waitEvent_getEvent_inboxUpdated_disabled) { - std::shared_ptr event = nullptr; - EXPECT_NO_THROW({ - eventQueue.waitEvent(); // pop libConnected form queue - }); - EXPECT_NO_THROW({ - auto tmp = inboxApi->subscribeFor({ - inboxApi->buildSubscriptionQuery( - inbox::EventType::INBOX_UPDATE, - inbox::EventSelectorType::CONTEXT_ID, - reader->getString("Context_1.contextId") - ) - }); - inboxApi->unsubscribeFrom(tmp); - }); - std::string inboxId; - EXPECT_NO_THROW({ - inboxApi->updateInbox( - reader->getString("Inbox_1.inboxId"), - std::vector{core::UserWithPubKey{ - .userId=reader->getString("Login.user_1_id"), - .pubKey=reader->getString("Login.user_1_pubKey") - }}, - std::vector{core::UserWithPubKey{ - .userId=reader->getString("Login.user_1_id"), - .pubKey=reader->getString("Login.user_1_pubKey") - }}, - core::Buffer::from("public"), - core::Buffer::from("private"), - std::nullopt, - 1, - true, - false - ); - }); - EXPECT_NO_THROW({ - std::this_thread::sleep_for(std::chrono::milliseconds(1500)); - std::optional eventHolder = eventQueue.getEvent(); - if(eventHolder.has_value()) { - event = eventHolder.value().get(); - } else { - event = nullptr; - } - }); - if(event == nullptr) { - - } else { - std::cout << "Received Event with type " << event->type << std::endl; - std::cout << "Expected null" << std::endl; - FAIL(); - } + eventQueue.waitEvent(); + auto tmp = inboxApi->subscribeFor({ + inboxApi->buildSubscriptionQuery( + inbox::EventType::INBOX_UPDATE, + inbox::EventSelectorType::CONTEXT_ID, + reader->getString("Context_1.contextId") + ) + }); + inboxApi->unsubscribeFrom(tmp); + inboxApi->updateInbox( + reader->getString("Inbox_1.inboxId"), + std::vector{core::UserWithPubKey{ + .userId=reader->getString("Login.user_1_id"), + .pubKey=reader->getString("Login.user_1_pubKey") + }}, + std::vector{core::UserWithPubKey{ + .userId=reader->getString("Login.user_1_id"), + .pubKey=reader->getString("Login.user_1_pubKey") + }}, + core::Buffer::from("public"), + core::Buffer::from("private"), + std::nullopt, + 1, + true, + false + ); + assertNoEventReceived(); } TEST_F(InboxEventTest, waitEvent_getEvent_inboxDeleted_enabled) { - std::shared_ptr event = nullptr; - EXPECT_NO_THROW({ - eventQueue.waitEvent(); // pop libConnected form queue - }); - EXPECT_NO_THROW({ - inboxApi->subscribeFor({ - inboxApi->buildSubscriptionQuery( - inbox::EventType::INBOX_DELETE, - inbox::EventSelectorType::CONTEXT_ID, - reader->getString("Context_1.contextId") - ) - }); - }); - EXPECT_NO_THROW({ - inboxApi->deleteInbox( - reader->getString("Inbox_1.inboxId") - ); - }); - EXPECT_NO_THROW({ - std::this_thread::sleep_for(std::chrono::milliseconds(1500)); - std::optional eventHolder = eventQueue.getEvent(); - if(eventHolder.has_value()) { - event = eventHolder.value().get(); - } else { - event = nullptr; - } - }); - if(event != nullptr) { - EXPECT_EQ(event->connectionId, connection->getConnectionId()); - EXPECT_EQ(event->type, "inboxDeleted"); - EXPECT_EQ(event->channel, "inbox"); - if(inbox::Events::isInboxDeletedEvent(event)) { - EXPECT_EQ(event->subscriptions.size(), 1); - inbox::InboxDeletedEventData inboxDeletedEventData = inbox::Events::extractInboxDeletedEvent(event).data; - EXPECT_EQ(inboxDeletedEventData.inboxId, reader->getString("Inbox_1.inboxId")); - } else { - FAIL(); - } - } else { - FAIL(); - } - EXPECT_NO_THROW({ - std::optional eventHolder = eventQueue.getEvent(); - if(eventHolder.has_value()) { - event = eventHolder.value().get(); - } else { - event = nullptr; - } - }); - if(event == nullptr) { - - } else { - std::cout << "Received Event with type " << event->type << std::endl; - std::cout << "Expected null" << std::endl; - FAIL(); - } + eventQueue.waitEvent(); + inboxApi->subscribeFor({ + inboxApi->buildSubscriptionQuery( + inbox::EventType::INBOX_DELETE, + inbox::EventSelectorType::CONTEXT_ID, + reader->getString("Context_1.contextId") + ) + }); + inboxApi->deleteInbox( + reader->getString("Inbox_1.inboxId") + ); + auto eventHolder = waitForEvent("inboxDeleted", {connection->getConnectionId()}); + ASSERT_TRUE(eventHolder.has_value()); + auto event = eventHolder.value().get(); + ASSERT_NE(event, nullptr); + EXPECT_EQ(event->connectionId, connection->getConnectionId()); + EXPECT_EQ(event->type, "inboxDeleted"); + EXPECT_EQ(event->channel, "inbox"); + ASSERT_TRUE(inbox::Events::isInboxDeletedEvent(event)); + EXPECT_EQ(event->subscriptions.size(), 1); + inbox::InboxDeletedEventData inboxDeletedEventData = inbox::Events::extractInboxDeletedEvent(event).data; + EXPECT_EQ(inboxDeletedEventData.inboxId, reader->getString("Inbox_1.inboxId")); + assertNoEventReceived(std::chrono::milliseconds(0)); } TEST_F(InboxEventTest, waitEvent_getEvent_inboxDeleted_disabled) { - std::shared_ptr event = nullptr; - EXPECT_NO_THROW({ - eventQueue.waitEvent(); // pop libConnected form queue - }); - EXPECT_NO_THROW({ - auto tmp = inboxApi->subscribeFor({ - inboxApi->buildSubscriptionQuery( - inbox::EventType::INBOX_DELETE, - inbox::EventSelectorType::CONTEXT_ID, - reader->getString("Context_1.contextId") - ) - }); - inboxApi->unsubscribeFrom(tmp); - }); - std::string inboxId; - EXPECT_NO_THROW({ - inboxApi->deleteInbox( - reader->getString("Inbox_1.inboxId") - ); - }); - EXPECT_NO_THROW({ - std::this_thread::sleep_for(std::chrono::milliseconds(1500)); - std::optional eventHolder = eventQueue.getEvent(); - if(eventHolder.has_value()) { - event = eventHolder.value().get(); - } else { - event = nullptr; - } - }); - if(event == nullptr) { - - } else { - std::cout << "Received Event with type " << event->type << std::endl; - std::cout << "Expected null" << std::endl; - FAIL(); - } + eventQueue.waitEvent(); + auto tmp = inboxApi->subscribeFor({ + inboxApi->buildSubscriptionQuery( + inbox::EventType::INBOX_DELETE, + inbox::EventSelectorType::CONTEXT_ID, + reader->getString("Context_1.contextId") + ) + }); + inboxApi->unsubscribeFrom(tmp); + inboxApi->deleteInbox( + reader->getString("Inbox_1.inboxId") + ); + assertNoEventReceived(); } TEST_F(InboxEventTest, waitEvent_getEvent_inboxEntryCreated_enabled) { - std::shared_ptr event = nullptr; - EXPECT_NO_THROW({ - eventQueue.waitEvent(); // pop libConnected form queue - }); - EXPECT_NO_THROW({ - inboxApi->subscribeFor({ - inboxApi->buildSubscriptionQuery( - inbox::EventType::ENTRY_CREATE, - inbox::EventSelectorType::INBOX_ID, - reader->getString("Inbox_1.inboxId") - ) - }); - }); - int64_t fileHandle = 0; - std::string file_total_data_send = ""; - EXPECT_NO_THROW({ - fileHandle = inboxApi->createFileHandle( - privmx::endpoint::core::Buffer::from("publicMeta"), - privmx::endpoint::core::Buffer::from("privateMeta"), - 0 - ); - }); - EXPECT_EQ(fileHandle, 1); - if(fileHandle == 1) { - int64_t inboxHandle = 0; - EXPECT_NO_THROW({ - inboxHandle = inboxApi->prepareEntry( - reader->getString("Inbox_1.inboxId"), - core::Buffer::from("test_inboxSendCommit"), - {fileHandle}, - reader->getString("Login.user_1_privKey") - ); - }); - EXPECT_EQ(inboxHandle, 2); - if(inboxHandle == 2) { - EXPECT_NO_THROW({ - inboxApi->sendEntry(inboxHandle); - }); - } else { - std::cout << "inboxSendPrepare Failed" << std::endl; - FAIL(); - } - } else { - std::cout << "inboxCreateFileHandle Failed" << std::endl; - FAIL(); - } - EXPECT_NO_THROW({ - std::this_thread::sleep_for(std::chrono::milliseconds(1500)); - std::optional eventHolder = eventQueue.getEvent(); - if(eventHolder.has_value()) { - event = eventHolder.value().get(); - } else { - event = nullptr; - } - }); - if(event != nullptr) { - EXPECT_EQ(event->connectionId, connection->getConnectionId()); - EXPECT_EQ(event->type, "inboxEntryCreated"); - EXPECT_EQ(event->channel, "inbox/" + reader->getString("Inbox_1.inboxId") + "/entries"); - if(inbox::Events::isInboxEntryCreatedEvent(event)) { - EXPECT_EQ(event->subscriptions.size(), 1); - inbox::InboxEntry inboxEntry = inbox::Events::extractInboxEntryCreatedEvent(event).data; - EXPECT_EQ(inboxEntry.inboxId, reader->getString("Inbox_1.inboxId")); - EXPECT_EQ(inboxEntry.data.stdString(), "test_inboxSendCommit"); - EXPECT_EQ(inboxEntry.files.size(), 1); - if(inboxEntry.files.size() == 1) { - EXPECT_EQ(inboxEntry.files[0].size, 0); - EXPECT_EQ(inboxEntry.files[0].publicMeta.stdString(), "publicMeta"); - EXPECT_EQ(inboxEntry.files[0].privateMeta.stdString(), "privateMeta"); - } - } else { - FAIL(); - } - } else { - FAIL(); + eventQueue.waitEvent(); + inboxApi->subscribeFor({ + inboxApi->buildSubscriptionQuery( + inbox::EventType::ENTRY_CREATE, + inbox::EventSelectorType::INBOX_ID, + reader->getString("Inbox_1.inboxId") + ) + }); + int64_t fileHandle = inboxApi->createFileHandle( + privmx::endpoint::core::Buffer::from("publicMeta"), + privmx::endpoint::core::Buffer::from("privateMeta"), + 0 + ); + ASSERT_EQ(fileHandle, 1) << "inboxCreateFileHandle Failed"; + int64_t inboxHandle = inboxApi->prepareEntry( + reader->getString("Inbox_1.inboxId"), + core::Buffer::from("test_inboxSendCommit"), + {fileHandle}, + reader->getString("Login.user_1_privKey") + ); + ASSERT_EQ(inboxHandle, 2) << "inboxSendPrepare Failed"; + inboxApi->sendEntry(inboxHandle); + auto eventHolder = waitForEvent("inboxEntryCreated", {connection->getConnectionId()}); + ASSERT_TRUE(eventHolder.has_value()); + auto event = eventHolder.value().get(); + ASSERT_NE(event, nullptr); + EXPECT_EQ(event->connectionId, connection->getConnectionId()); + EXPECT_EQ(event->type, "inboxEntryCreated"); + EXPECT_EQ(event->channel, "inbox/" + reader->getString("Inbox_1.inboxId") + "/entries"); + ASSERT_TRUE(inbox::Events::isInboxEntryCreatedEvent(event)); + EXPECT_EQ(event->subscriptions.size(), 1); + inbox::InboxEntry inboxEntry = inbox::Events::extractInboxEntryCreatedEvent(event).data; + EXPECT_EQ(inboxEntry.inboxId, reader->getString("Inbox_1.inboxId")); + EXPECT_EQ(inboxEntry.data.stdString(), "test_inboxSendCommit"); + EXPECT_EQ(inboxEntry.files.size(), 1); + if(inboxEntry.files.size() == 1) { + EXPECT_EQ(inboxEntry.files[0].size, 0); + EXPECT_EQ(inboxEntry.files[0].publicMeta.stdString(), "publicMeta"); + EXPECT_EQ(inboxEntry.files[0].privateMeta.stdString(), "privateMeta"); } } TEST_F(InboxEventTest, waitEvent_getEvent_inboxEntryCreated_disabled) { - std::shared_ptr event = nullptr; - EXPECT_NO_THROW({ - eventQueue.waitEvent(); // pop libConnected form queue - }); - EXPECT_NO_THROW({ - auto tmp = inboxApi->subscribeFor({ - inboxApi->buildSubscriptionQuery( - inbox::EventType::ENTRY_CREATE, - inbox::EventSelectorType::INBOX_ID, - reader->getString("Inbox_1.inboxId") - ) - }); - inboxApi->unsubscribeFrom(tmp); - }); - int64_t fileHandle = 0; - std::string file_total_data_send = ""; - EXPECT_NO_THROW({ - fileHandle = inboxApi->createFileHandle( - privmx::endpoint::core::Buffer::from("publicMeta"), - privmx::endpoint::core::Buffer::from("privateMeta"), - 0 - ); - }); - EXPECT_EQ(fileHandle, 1); - if(fileHandle == 1) { - int64_t inboxHandle = 0; - EXPECT_NO_THROW({ - inboxHandle = inboxApi->prepareEntry( - reader->getString("Inbox_1.inboxId"), - core::Buffer::from("test_inboxSendCommit"), - {fileHandle}, - reader->getString("Login.user_1_privKey") - ); - }); - EXPECT_EQ(inboxHandle, 2); - if(inboxHandle == 2) { - EXPECT_NO_THROW({ - inboxApi->sendEntry(inboxHandle); - }); - } else { - std::cout << "inboxSendPrepare Failed" << std::endl; - FAIL(); - } - } else { - std::cout << "inboxCreateFileHandle Failed" << std::endl; - FAIL(); - } - EXPECT_NO_THROW({ - std::this_thread::sleep_for(std::chrono::milliseconds(1500)); - std::optional eventHolder = eventQueue.getEvent(); - if(eventHolder.has_value()) { - event = eventHolder.value().get(); - } else { - event = nullptr; - } - }); - if(event == nullptr) { - - } else { - std::cout << "Received Event with type " << event->type << std::endl; - std::cout << "Expected null" << std::endl; - FAIL(); - } + eventQueue.waitEvent(); + auto tmp = inboxApi->subscribeFor({ + inboxApi->buildSubscriptionQuery( + inbox::EventType::ENTRY_CREATE, + inbox::EventSelectorType::INBOX_ID, + reader->getString("Inbox_1.inboxId") + ) + }); + inboxApi->unsubscribeFrom(tmp); + int64_t fileHandle = inboxApi->createFileHandle( + privmx::endpoint::core::Buffer::from("publicMeta"), + privmx::endpoint::core::Buffer::from("privateMeta"), + 0 + ); + ASSERT_EQ(fileHandle, 1) << "inboxCreateFileHandle Failed"; + int64_t inboxHandle = inboxApi->prepareEntry( + reader->getString("Inbox_1.inboxId"), + core::Buffer::from("test_inboxSendCommit"), + {fileHandle}, + reader->getString("Login.user_1_privKey") + ); + ASSERT_EQ(inboxHandle, 2) << "inboxSendPrepare Failed"; + inboxApi->sendEntry(inboxHandle); + assertNoEventReceived(); } TEST_F(InboxEventTest, waitEvent_getEvent_inboxEntryDeleted_enabled) { - std::shared_ptr event = nullptr; - EXPECT_NO_THROW({ - eventQueue.waitEvent(); // pop libConnected form queue - }); - EXPECT_NO_THROW({ - inboxApi->subscribeFor({ - inboxApi->buildSubscriptionQuery( - inbox::EventType::ENTRY_DELETE, - inbox::EventSelectorType::INBOX_ID, - reader->getString("Inbox_1.inboxId") - ) - }); - }); - EXPECT_NO_THROW({ - inboxApi->deleteEntry( - reader->getString("Entry_1.entryId") - ); - }); - EXPECT_NO_THROW({ - std::this_thread::sleep_for(std::chrono::milliseconds(1500)); - std::optional eventHolder = eventQueue.getEvent(); - if(eventHolder.has_value()) { - event = eventHolder.value().get(); - } else { - event = nullptr; - } - }); - if(event != nullptr) { - EXPECT_EQ(event->connectionId, connection->getConnectionId()); - EXPECT_EQ(event->type, "inboxEntryDeleted"); - EXPECT_EQ(event->channel, "inbox/" + reader->getString("Inbox_1.inboxId") + "/entries"); - if(inbox::Events::isInboxEntryDeletedEvent(event)) { - EXPECT_EQ(event->subscriptions.size(), 1); - inbox::InboxEntryDeletedEventData inboxEntryDeletedEventData = inbox::Events::extractInboxEntryDeletedEvent(event).data; - EXPECT_EQ(inboxEntryDeletedEventData.inboxId, reader->getString("Inbox_1.inboxId")); - EXPECT_EQ(inboxEntryDeletedEventData.entryId, reader->getString("Entry_1.entryId")); - } else { - FAIL(); - } - } else { - FAIL(); - } + eventQueue.waitEvent(); + inboxApi->subscribeFor({ + inboxApi->buildSubscriptionQuery( + inbox::EventType::ENTRY_DELETE, + inbox::EventSelectorType::INBOX_ID, + reader->getString("Inbox_1.inboxId") + ) + }); + inboxApi->deleteEntry( + reader->getString("Entry_1.entryId") + ); + auto eventHolder = waitForEvent("inboxEntryDeleted", {connection->getConnectionId()}); + ASSERT_TRUE(eventHolder.has_value()); + auto event = eventHolder.value().get(); + ASSERT_NE(event, nullptr); + EXPECT_EQ(event->connectionId, connection->getConnectionId()); + EXPECT_EQ(event->type, "inboxEntryDeleted"); + EXPECT_EQ(event->channel, "inbox/" + reader->getString("Inbox_1.inboxId") + "/entries"); + ASSERT_TRUE(inbox::Events::isInboxEntryDeletedEvent(event)); + EXPECT_EQ(event->subscriptions.size(), 1); + inbox::InboxEntryDeletedEventData inboxEntryDeletedEventData = inbox::Events::extractInboxEntryDeletedEvent(event).data; + EXPECT_EQ(inboxEntryDeletedEventData.inboxId, reader->getString("Inbox_1.inboxId")); + EXPECT_EQ(inboxEntryDeletedEventData.entryId, reader->getString("Entry_1.entryId")); } TEST_F(InboxEventTest, waitEvent_getEvent_inboxEntryDeleted_disabled) { - std::shared_ptr event = nullptr; - EXPECT_NO_THROW({ - eventQueue.waitEvent(); // pop libConnected form queue - }); - EXPECT_NO_THROW({ - auto tmp = inboxApi->subscribeFor({ - inboxApi->buildSubscriptionQuery( - inbox::EventType::ENTRY_DELETE, - inbox::EventSelectorType::INBOX_ID, - reader->getString("Inbox_1.inboxId") - ) - }); - inboxApi->unsubscribeFrom(tmp); - }); - EXPECT_NO_THROW({ - inboxApi->deleteEntry( - reader->getString("Entry_1.entryId") - ); - }); - EXPECT_NO_THROW({ - std::this_thread::sleep_for(std::chrono::milliseconds(1500)); - std::optional eventHolder = eventQueue.getEvent(); - if(eventHolder.has_value()) { - event = eventHolder.value().get(); - } else { - event = nullptr; - } + eventQueue.waitEvent(); + auto tmp = inboxApi->subscribeFor({ + inboxApi->buildSubscriptionQuery( + inbox::EventType::ENTRY_DELETE, + inbox::EventSelectorType::INBOX_ID, + reader->getString("Inbox_1.inboxId") + ) }); - if(event == nullptr) { - - } else { - std::cout << "Received Event with type " << event->type << std::endl; - std::cout << "Expected null" << std::endl; - FAIL(); - } + inboxApi->unsubscribeFrom(tmp); + inboxApi->deleteEntry( + reader->getString("Entry_1.entryId") + ); + assertNoEventReceived(); } TEST_F(InboxEventTest, subscribeFor_query_from_other_module) { @@ -678,170 +363,95 @@ TEST_F(InboxEventTest, subscribeFor_unsubscribeFor) { std::vector valid_subscriptions; EXPECT_NO_THROW({ valid_subscriptions = inboxApi->subscribeFor({ - inboxApi->buildSubscriptionQuery( - inbox::EventType::INBOX_CREATE, - inbox::EventSelectorType::CONTEXT_ID, - reader->getString("Context_1.contextId") + inboxApi->buildSubscriptionQuery( + inbox::EventType::INBOX_CREATE, + inbox::EventSelectorType::CONTEXT_ID, + reader->getString("Context_1.contextId") ) }); }); std::vector invalid_subscriptions; EXPECT_NO_THROW({ invalid_subscriptions = inboxApi->subscribeFor({ - inboxApi->buildSubscriptionQuery( - inbox::EventType::INBOX_CREATE, - inbox::EventSelectorType::CONTEXT_ID, + inboxApi->buildSubscriptionQuery( + inbox::EventType::INBOX_CREATE, + inbox::EventSelectorType::CONTEXT_ID, "error" ) }); }); EXPECT_NO_THROW({ inboxApi->unsubscribeFrom({ - valid_subscriptions + valid_subscriptions }); }); EXPECT_NO_THROW({ inboxApi->unsubscribeFrom({ - invalid_subscriptions + invalid_subscriptions }); }); } TEST_F(InboxEventTest, waitEvent_getEvent_collectionChanged_enabled) { - std::shared_ptr event = nullptr; - EXPECT_NO_THROW({ - eventQueue.waitEvent(); // pop libConnected form queue - }); - EXPECT_NO_THROW({ - inboxApi->subscribeFor({ - inboxApi->buildSubscriptionQuery( - inbox::EventType::COLLECTION_CHANGE, - inbox::EventSelectorType::INBOX_ID, - reader->getString("Inbox_1.inboxId") - ) - }); - }); - int64_t fileHandle = 0; - std::string file_total_data_send = ""; - EXPECT_NO_THROW({ - fileHandle = inboxApi->createFileHandle( - privmx::endpoint::core::Buffer::from("publicMeta"), - privmx::endpoint::core::Buffer::from("privateMeta"), - 0 - ); - }); - EXPECT_EQ(fileHandle, 1); - if(fileHandle == 1) { - int64_t inboxHandle = 0; - EXPECT_NO_THROW({ - inboxHandle = inboxApi->prepareEntry( - reader->getString("Inbox_1.inboxId"), - core::Buffer::from("test_inboxSendCommit"), - {fileHandle}, - reader->getString("Login.user_1_privKey") - ); - }); - EXPECT_EQ(inboxHandle, 2); - if(inboxHandle == 2) { - EXPECT_NO_THROW({ - inboxApi->sendEntry(inboxHandle); - }); - } else { - std::cout << "inboxSendPrepare Failed" << std::endl; - FAIL(); - } - } else { - std::cout << "inboxCreateFileHandle Failed" << std::endl; - FAIL(); - } - EXPECT_NO_THROW({ - std::this_thread::sleep_for(std::chrono::milliseconds(1500)); - std::optional eventHolder = eventQueue.getEvent(); - if(eventHolder.has_value()) { - event = eventHolder.value().get(); - } else { - event = nullptr; - } - }); - if(event != nullptr) { - EXPECT_EQ(event->connectionId, connection->getConnectionId()); - EXPECT_EQ(event->type, "collectionChanged"); - EXPECT_EQ(event->channel, "inbox/collectionChanged"); - if(core::Events::isCollectionChangedEvent(event)) { - EXPECT_EQ(event->subscriptions.size(), 1); - core::CollectionChangedEventData collectionChanged = core::Events::extractCollectionChangedEvent(event).data; - EXPECT_EQ(collectionChanged.moduleId, reader->getString("Inbox_1.inboxId")); - EXPECT_EQ(collectionChanged.affectedItemsCount, 1); - } else { - FAIL(); - } - } else { - FAIL(); - } + eventQueue.waitEvent(); + inboxApi->subscribeFor({ + inboxApi->buildSubscriptionQuery( + inbox::EventType::COLLECTION_CHANGE, + inbox::EventSelectorType::INBOX_ID, + reader->getString("Inbox_1.inboxId") + ) + }); + int64_t fileHandle = inboxApi->createFileHandle( + privmx::endpoint::core::Buffer::from("publicMeta"), + privmx::endpoint::core::Buffer::from("privateMeta"), + 0 + ); + ASSERT_EQ(fileHandle, 1) << "inboxCreateFileHandle Failed"; + int64_t inboxHandle = inboxApi->prepareEntry( + reader->getString("Inbox_1.inboxId"), + core::Buffer::from("test_inboxSendCommit"), + {fileHandle}, + reader->getString("Login.user_1_privKey") + ); + ASSERT_EQ(inboxHandle, 2) << "inboxSendPrepare Failed"; + inboxApi->sendEntry(inboxHandle); + auto eventHolder = waitForEvent("collectionChanged", {connection->getConnectionId()}); + ASSERT_TRUE(eventHolder.has_value()); + auto event = eventHolder.value().get(); + ASSERT_NE(event, nullptr); + EXPECT_EQ(event->connectionId, connection->getConnectionId()); + EXPECT_EQ(event->type, "collectionChanged"); + EXPECT_EQ(event->channel, "inbox/collectionChanged"); + ASSERT_TRUE(core::Events::isCollectionChangedEvent(event)); + EXPECT_EQ(event->subscriptions.size(), 1); + core::CollectionChangedEventData collectionChanged = core::Events::extractCollectionChangedEvent(event).data; + EXPECT_EQ(collectionChanged.moduleId, reader->getString("Inbox_1.inboxId")); + EXPECT_EQ(collectionChanged.affectedItemsCount, 1); } TEST_F(InboxEventTest, waitEvent_getEvent_collectionChanged_disabled) { - std::shared_ptr event = nullptr; - EXPECT_NO_THROW({ - eventQueue.waitEvent(); // pop libConnected form queue - }); - EXPECT_NO_THROW({ - auto tmp = inboxApi->subscribeFor({ - inboxApi->buildSubscriptionQuery( - inbox::EventType::ENTRY_CREATE, - inbox::EventSelectorType::INBOX_ID, - reader->getString("Inbox_1.inboxId") - ) - }); - inboxApi->unsubscribeFrom(tmp); - }); - int64_t fileHandle = 0; - std::string file_total_data_send = ""; - EXPECT_NO_THROW({ - fileHandle = inboxApi->createFileHandle( - privmx::endpoint::core::Buffer::from("publicMeta"), - privmx::endpoint::core::Buffer::from("privateMeta"), - 0 - ); - }); - EXPECT_EQ(fileHandle, 1); - if(fileHandle == 1) { - int64_t inboxHandle = 0; - EXPECT_NO_THROW({ - inboxHandle = inboxApi->prepareEntry( - reader->getString("Inbox_1.inboxId"), - core::Buffer::from("test_inboxSendCommit"), - {fileHandle}, - reader->getString("Login.user_1_privKey") - ); - }); - EXPECT_EQ(inboxHandle, 2); - if(inboxHandle == 2) { - EXPECT_NO_THROW({ - inboxApi->sendEntry(inboxHandle); - }); - } else { - std::cout << "inboxSendPrepare Failed" << std::endl; - FAIL(); - } - } else { - std::cout << "inboxCreateFileHandle Failed" << std::endl; - FAIL(); - } - EXPECT_NO_THROW({ - std::this_thread::sleep_for(std::chrono::milliseconds(1500)); - std::optional eventHolder = eventQueue.getEvent(); - if(eventHolder.has_value()) { - event = eventHolder.value().get(); - } else { - event = nullptr; - } - }); - if(event == nullptr) { - - } else { - std::cout << "Received Event with type " << event->type << std::endl; - std::cout << "Expected null" << std::endl; - FAIL(); - } + eventQueue.waitEvent(); + auto tmp = inboxApi->subscribeFor({ + inboxApi->buildSubscriptionQuery( + inbox::EventType::ENTRY_CREATE, + inbox::EventSelectorType::INBOX_ID, + reader->getString("Inbox_1.inboxId") + ) + }); + inboxApi->unsubscribeFrom(tmp); + int64_t fileHandle = inboxApi->createFileHandle( + privmx::endpoint::core::Buffer::from("publicMeta"), + privmx::endpoint::core::Buffer::from("privateMeta"), + 0 + ); + ASSERT_EQ(fileHandle, 1) << "inboxCreateFileHandle Failed"; + int64_t inboxHandle = inboxApi->prepareEntry( + reader->getString("Inbox_1.inboxId"), + core::Buffer::from("test_inboxSendCommit"), + {fileHandle}, + reader->getString("Login.user_1_privKey") + ); + ASSERT_EQ(inboxHandle, 2) << "inboxSendPrepare Failed"; + inboxApi->sendEntry(inboxHandle); + assertNoEventReceived(); } diff --git a/test/tests/KvdbModuleEventsTest.cpp b/test/tests/KvdbModuleEventsTest.cpp index 5c85f151..d2888be5 100644 --- a/test/tests/KvdbModuleEventsTest.cpp +++ b/test/tests/KvdbModuleEventsTest.cpp @@ -1,785 +1,443 @@ -#include -#include -#include -#include "../utils/BaseTest.hpp" -#include +#include "../utils/BaseEndpointEventTest.hpp" #include #include #include -#include #include #include -#include -#include using namespace privmx::endpoint; -class KvdbEventTest : public privmx::test::BaseTest { +class KvdbEventTest : public privmx::test::BaseEndpointEventTest { protected: - KvdbEventTest() : BaseTest(privmx::test::BaseTestMode::online) {} - void customSetUp() override { - reader = new Poco::Util::IniFileConfiguration(INI_FILE_PATH); - connection = std::make_shared( - core::Connection::connect( - reader->getString("Login.user_1_privKey"), - reader->getString("Login.solutionId"), - getPlatformUrl(reader->getString("Login.instanceUrl")) - ) - ); + void setUpModuleApis() override { kvdbApi = std::make_shared( - kvdb::KvdbApi::create( - *connection - ) + kvdb::KvdbApi::create(*connection) ); } - void customTearDown() override { // tmp segfault fix - connection.reset(); + void tearDownModuleApis() override { kvdbApi.reset(); - reader.reset(); - privmx::endpoint::core::EventQueueImpl::getInstance()->clear(); } - std::shared_ptr connection; std::shared_ptr kvdbApi; - core::EventQueue eventQueue = core::EventQueue::getInstance(); - Poco::Util::IniFileConfiguration::Ptr reader; }; TEST_F(KvdbEventTest, waitEvent_getEvent_kvdbCreated_enabled) { - std::shared_ptr event = nullptr; - EXPECT_NO_THROW({ - eventQueue.waitEvent(); // pop libConnected form queue - }); - EXPECT_NO_THROW({ - kvdbApi->subscribeFor({ - kvdbApi->buildSubscriptionQuery( - kvdb::EventType::KVDB_CREATE, - kvdb::EventSelectorType::CONTEXT_ID, - reader->getString("Context_1.contextId") - ) - }); - }); - - std::string kvdbId; - EXPECT_NO_THROW({ - kvdbId = kvdbApi->createKvdb( - reader->getString("Context_1.contextId"), - std::vector{core::UserWithPubKey{ - .userId=reader->getString("Login.user_1_id"), - .pubKey=reader->getString("Login.user_1_pubKey") - }}, - std::vector{core::UserWithPubKey{ - .userId=reader->getString("Login.user_1_id"), - .pubKey=reader->getString("Login.user_1_pubKey") - }}, - core::Buffer::from("public"), - core::Buffer::from("private") - ); - }); - EXPECT_NO_THROW({ - std::this_thread::sleep_for(std::chrono::milliseconds(1500)); - std::optional eventHolder = eventQueue.getEvent(); - if(eventHolder.has_value()) { - event = eventHolder.value().get(); - } else { - event = nullptr; - } - }); - if(event != nullptr) { - EXPECT_EQ(event->connectionId, connection->getConnectionId()); - EXPECT_EQ(event->type, "kvdbCreated"); - EXPECT_EQ(event->channel, "kvdb"); - if(kvdb::Events::isKvdbCreatedEvent(event)) { - EXPECT_EQ(event->subscriptions.size(), 1); - kvdb::Kvdb kvdb = kvdb::Events::extractKvdbCreatedEvent(event).data; - EXPECT_EQ(kvdb.contextId, reader->getString("Context_1.contextId")); - EXPECT_EQ(kvdb.publicMeta.stdString(), "public"); - EXPECT_EQ(kvdb.privateMeta.stdString(), "private"); - EXPECT_EQ(kvdb.users.size(), 1); - if(kvdb.users.size() == 1) { - EXPECT_EQ(kvdb.users[0], reader->getString("Login.user_1_id")); - } - EXPECT_EQ(kvdb.managers.size(), 1); - if(kvdb.managers.size() == 1) { - EXPECT_EQ(kvdb.managers[0], reader->getString("Login.user_1_id")); - } - } else { - FAIL(); - } - } else { - FAIL(); + eventQueue.waitEvent(); + kvdbApi->subscribeFor({ + kvdbApi->buildSubscriptionQuery( + kvdb::EventType::KVDB_CREATE, + kvdb::EventSelectorType::CONTEXT_ID, + reader->getString("Context_1.contextId") + ) + }); + kvdbApi->createKvdb( + reader->getString("Context_1.contextId"), + std::vector{core::UserWithPubKey{ + .userId=reader->getString("Login.user_1_id"), + .pubKey=reader->getString("Login.user_1_pubKey") + }}, + std::vector{core::UserWithPubKey{ + .userId=reader->getString("Login.user_1_id"), + .pubKey=reader->getString("Login.user_1_pubKey") + }}, + core::Buffer::from("public"), + core::Buffer::from("private") + ); + auto eventHolder = waitForEvent("kvdbCreated", {connection->getConnectionId()}); + ASSERT_TRUE(eventHolder.has_value()); + auto event = eventHolder.value().get(); + ASSERT_NE(event, nullptr); + EXPECT_EQ(event->connectionId, connection->getConnectionId()); + EXPECT_EQ(event->type, "kvdbCreated"); + EXPECT_EQ(event->channel, "kvdb"); + ASSERT_TRUE(kvdb::Events::isKvdbCreatedEvent(event)); + EXPECT_EQ(event->subscriptions.size(), 1); + kvdb::Kvdb kvdb = kvdb::Events::extractKvdbCreatedEvent(event).data; + EXPECT_EQ(kvdb.contextId, reader->getString("Context_1.contextId")); + EXPECT_EQ(kvdb.publicMeta.stdString(), "public"); + EXPECT_EQ(kvdb.privateMeta.stdString(), "private"); + EXPECT_EQ(kvdb.users.size(), 1); + if(kvdb.users.size() == 1) { + EXPECT_EQ(kvdb.users[0], reader->getString("Login.user_1_id")); + } + EXPECT_EQ(kvdb.managers.size(), 1); + if(kvdb.managers.size() == 1) { + EXPECT_EQ(kvdb.managers[0], reader->getString("Login.user_1_id")); } } TEST_F(KvdbEventTest, waitEvent_getEvent_kvdbCreated_disabled) { - std::shared_ptr event = nullptr; - EXPECT_NO_THROW({ - eventQueue.waitEvent(); // pop libConnected form queue - }); - EXPECT_NO_THROW({ - auto tmp = kvdbApi->subscribeFor({ - kvdbApi->buildSubscriptionQuery( - kvdb::EventType::KVDB_CREATE, - kvdb::EventSelectorType::CONTEXT_ID, - reader->getString("Context_1.contextId") - ) - }); - kvdbApi->unsubscribeFrom(tmp); - }); - - std::string kvdbId; - EXPECT_NO_THROW({ - kvdbId = kvdbApi->createKvdb( - reader->getString("Context_1.contextId"), - std::vector{core::UserWithPubKey{ - .userId=reader->getString("Login.user_1_id"), - .pubKey=reader->getString("Login.user_1_pubKey") - }}, - std::vector{core::UserWithPubKey{ - .userId=reader->getString("Login.user_1_id"), - .pubKey=reader->getString("Login.user_1_pubKey") - }}, - core::Buffer::from("public"), - core::Buffer::from("private") - ); - }); - EXPECT_NO_THROW({ - std::this_thread::sleep_for(std::chrono::milliseconds(1500)); - std::optional eventHolder = eventQueue.getEvent(); - if(eventHolder.has_value()) { - event = eventHolder.value().get(); - } else { - event = nullptr; - } - }); - if(event == nullptr) { - - } else { - std::cout << "Received Event with type " << event->type << std::endl; - std::cout << "Expected null" << std::endl; - FAIL(); - } + eventQueue.waitEvent(); + auto tmp = kvdbApi->subscribeFor({ + kvdbApi->buildSubscriptionQuery( + kvdb::EventType::KVDB_CREATE, + kvdb::EventSelectorType::CONTEXT_ID, + reader->getString("Context_1.contextId") + ) + }); + kvdbApi->unsubscribeFrom(tmp); + kvdbApi->createKvdb( + reader->getString("Context_1.contextId"), + std::vector{core::UserWithPubKey{ + .userId=reader->getString("Login.user_1_id"), + .pubKey=reader->getString("Login.user_1_pubKey") + }}, + std::vector{core::UserWithPubKey{ + .userId=reader->getString("Login.user_1_id"), + .pubKey=reader->getString("Login.user_1_pubKey") + }}, + core::Buffer::from("public"), + core::Buffer::from("private") + ); + assertNoEventReceived(); } TEST_F(KvdbEventTest, waitEvent_getEvent_kvdbUpdated_enabled) { - std::shared_ptr event = nullptr; - EXPECT_NO_THROW({ - eventQueue.waitEvent(); // pop libConnected form queue - }); - EXPECT_NO_THROW({ - kvdbApi->subscribeFor({ - kvdbApi->buildSubscriptionQuery( - kvdb::EventType::KVDB_UPDATE, - kvdb::EventSelectorType::CONTEXT_ID, - reader->getString("Context_1.contextId") - ) - }); - }); - - EXPECT_NO_THROW({ - kvdbApi->updateKvdb( - reader->getString("Kvdb_1.kvdbId"), - std::vector{core::UserWithPubKey{ - .userId=reader->getString("Login.user_1_id"), - .pubKey=reader->getString("Login.user_1_pubKey") - }}, - std::vector{core::UserWithPubKey{ - .userId=reader->getString("Login.user_1_id"), - .pubKey=reader->getString("Login.user_1_pubKey") - }}, - core::Buffer::from("public"), - core::Buffer::from("private"), - 1, - true, - true - ); - }); - EXPECT_NO_THROW({ - std::this_thread::sleep_for(std::chrono::milliseconds(1500)); - std::optional eventHolder = eventQueue.getEvent(); - if(eventHolder.has_value()) { - event = eventHolder.value().get(); - } else { - event = nullptr; - } - }); - if(event != nullptr) { - EXPECT_EQ(event->connectionId, connection->getConnectionId()); - EXPECT_EQ(event->type, "kvdbUpdated"); - EXPECT_EQ(event->channel, "kvdb"); - if(kvdb::Events::isKvdbUpdatedEvent(event)) { - EXPECT_EQ(event->subscriptions.size(), 1); - kvdb::Kvdb kvdb = kvdb::Events::extractKvdbUpdatedEvent(event).data; - EXPECT_EQ(kvdb.contextId, reader->getString("Context_1.contextId")); - EXPECT_EQ(kvdb.publicMeta.stdString(), "public"); - EXPECT_EQ(kvdb.privateMeta.stdString(), "private"); - EXPECT_EQ(kvdb.users.size(), 1); - if(kvdb.users.size() == 1) { - EXPECT_EQ(kvdb.users[0], reader->getString("Login.user_1_id")); - } - EXPECT_EQ(kvdb.managers.size(), 1); - if(kvdb.managers.size() == 1) { - EXPECT_EQ(kvdb.managers[0], reader->getString("Login.user_1_id")); - } - } else { - FAIL(); - } - } else { - FAIL(); + eventQueue.waitEvent(); + kvdbApi->subscribeFor({ + kvdbApi->buildSubscriptionQuery( + kvdb::EventType::KVDB_UPDATE, + kvdb::EventSelectorType::CONTEXT_ID, + reader->getString("Context_1.contextId") + ) + }); + kvdbApi->updateKvdb( + reader->getString("Kvdb_1.kvdbId"), + std::vector{core::UserWithPubKey{ + .userId=reader->getString("Login.user_1_id"), + .pubKey=reader->getString("Login.user_1_pubKey") + }}, + std::vector{core::UserWithPubKey{ + .userId=reader->getString("Login.user_1_id"), + .pubKey=reader->getString("Login.user_1_pubKey") + }}, + core::Buffer::from("public"), + core::Buffer::from("private"), + 1, + true, + true + ); + auto eventHolder = waitForEvent("kvdbUpdated", {connection->getConnectionId()}); + ASSERT_TRUE(eventHolder.has_value()); + auto event = eventHolder.value().get(); + ASSERT_NE(event, nullptr); + EXPECT_EQ(event->connectionId, connection->getConnectionId()); + EXPECT_EQ(event->type, "kvdbUpdated"); + EXPECT_EQ(event->channel, "kvdb"); + ASSERT_TRUE(kvdb::Events::isKvdbUpdatedEvent(event)); + EXPECT_EQ(event->subscriptions.size(), 1); + kvdb::Kvdb kvdb = kvdb::Events::extractKvdbUpdatedEvent(event).data; + EXPECT_EQ(kvdb.contextId, reader->getString("Context_1.contextId")); + EXPECT_EQ(kvdb.publicMeta.stdString(), "public"); + EXPECT_EQ(kvdb.privateMeta.stdString(), "private"); + EXPECT_EQ(kvdb.users.size(), 1); + if(kvdb.users.size() == 1) { + EXPECT_EQ(kvdb.users[0], reader->getString("Login.user_1_id")); + } + EXPECT_EQ(kvdb.managers.size(), 1); + if(kvdb.managers.size() == 1) { + EXPECT_EQ(kvdb.managers[0], reader->getString("Login.user_1_id")); } } TEST_F(KvdbEventTest, waitEvent_getEvent_kvdbUpdated_disabled) { - std::shared_ptr event = nullptr; - EXPECT_NO_THROW({ - eventQueue.waitEvent(); // pop libConnected form queue - }); - EXPECT_NO_THROW({ - auto tmp = kvdbApi->subscribeFor({ - kvdbApi->buildSubscriptionQuery( - kvdb::EventType::KVDB_UPDATE, - kvdb::EventSelectorType::CONTEXT_ID, - reader->getString("Context_1.contextId") - ) - }); - kvdbApi->unsubscribeFrom(tmp); - }); - - EXPECT_NO_THROW({ - kvdbApi->updateKvdb( - reader->getString("Kvdb_1.kvdbId"), - std::vector{core::UserWithPubKey{ - .userId=reader->getString("Login.user_1_id"), - .pubKey=reader->getString("Login.user_1_pubKey") - }}, - std::vector{core::UserWithPubKey{ - .userId=reader->getString("Login.user_1_id"), - .pubKey=reader->getString("Login.user_1_pubKey") - }}, - core::Buffer::from("public"), - core::Buffer::from("private"), - 1, - true, - true - ); - }); - EXPECT_NO_THROW({ - std::this_thread::sleep_for(std::chrono::milliseconds(1500)); - std::optional eventHolder = eventQueue.getEvent(); - if(eventHolder.has_value()) { - event = eventHolder.value().get(); - } else { - event = nullptr; - } - }); - if(event == nullptr) { - - } else { - std::cout << "Received Event with type " << event->type << std::endl; - std::cout << "Expected null" << std::endl; - FAIL(); - } + eventQueue.waitEvent(); + auto tmp = kvdbApi->subscribeFor({ + kvdbApi->buildSubscriptionQuery( + kvdb::EventType::KVDB_UPDATE, + kvdb::EventSelectorType::CONTEXT_ID, + reader->getString("Context_1.contextId") + ) + }); + kvdbApi->unsubscribeFrom(tmp); + kvdbApi->updateKvdb( + reader->getString("Kvdb_1.kvdbId"), + std::vector{core::UserWithPubKey{ + .userId=reader->getString("Login.user_1_id"), + .pubKey=reader->getString("Login.user_1_pubKey") + }}, + std::vector{core::UserWithPubKey{ + .userId=reader->getString("Login.user_1_id"), + .pubKey=reader->getString("Login.user_1_pubKey") + }}, + core::Buffer::from("public"), + core::Buffer::from("private"), + 1, + true, + true + ); + assertNoEventReceived(); } TEST_F(KvdbEventTest, waitEvent_getEvent_kvdbDeleted_enabled) { - std::shared_ptr event = nullptr; - EXPECT_NO_THROW({ - eventQueue.waitEvent(); // pop libConnected form queue - }); - EXPECT_NO_THROW({ - kvdbApi->subscribeFor({ - kvdbApi->buildSubscriptionQuery( - kvdb::EventType::KVDB_DELETE, - kvdb::EventSelectorType::CONTEXT_ID, - reader->getString("Context_1.contextId") - ) - }); - }); - - EXPECT_NO_THROW({ - kvdbApi->deleteKvdb( - reader->getString("Kvdb_1.kvdbId") - ); - }); - EXPECT_NO_THROW({ - std::this_thread::sleep_for(std::chrono::milliseconds(1500)); - std::optional eventHolder = eventQueue.getEvent(); - if(eventHolder.has_value()) { - event = eventHolder.value().get(); - } else { - event = nullptr; - } - }); - if(event != nullptr) { - EXPECT_EQ(event->connectionId, connection->getConnectionId()); - EXPECT_EQ(event->type, "kvdbDeleted"); - EXPECT_EQ(event->channel, "kvdb"); - if(kvdb::Events::isKvdbDeletedEvent(event)) { - EXPECT_EQ(event->subscriptions.size(), 1); - kvdb::KvdbDeletedEventData kvdbDeleted = kvdb::Events::extractKvdbDeletedEvent(event).data; - EXPECT_EQ(kvdbDeleted.kvdbId, reader->getString("Kvdb_1.kvdbId")); - } else { - FAIL(); - } - } else { - FAIL(); - } + eventQueue.waitEvent(); + kvdbApi->subscribeFor({ + kvdbApi->buildSubscriptionQuery( + kvdb::EventType::KVDB_DELETE, + kvdb::EventSelectorType::CONTEXT_ID, + reader->getString("Context_1.contextId") + ) + }); + kvdbApi->deleteKvdb( + reader->getString("Kvdb_1.kvdbId") + ); + auto eventHolder = waitForEvent("kvdbDeleted", {connection->getConnectionId()}); + ASSERT_TRUE(eventHolder.has_value()); + auto event = eventHolder.value().get(); + ASSERT_NE(event, nullptr); + EXPECT_EQ(event->connectionId, connection->getConnectionId()); + EXPECT_EQ(event->type, "kvdbDeleted"); + EXPECT_EQ(event->channel, "kvdb"); + ASSERT_TRUE(kvdb::Events::isKvdbDeletedEvent(event)); + EXPECT_EQ(event->subscriptions.size(), 1); + kvdb::KvdbDeletedEventData kvdbDeleted = kvdb::Events::extractKvdbDeletedEvent(event).data; + EXPECT_EQ(kvdbDeleted.kvdbId, reader->getString("Kvdb_1.kvdbId")); } TEST_F(KvdbEventTest, waitEvent_getEvent_kvdbDeleted_disabled) { - std::shared_ptr event = nullptr; - EXPECT_NO_THROW({ - eventQueue.waitEvent(); // pop libConnected form queue - }); - EXPECT_NO_THROW({ - auto tmp = kvdbApi->subscribeFor({ - kvdbApi->buildSubscriptionQuery( - kvdb::EventType::KVDB_DELETE, - kvdb::EventSelectorType::CONTEXT_ID, - reader->getString("Context_1.contextId") - ) - }); - kvdbApi->unsubscribeFrom(tmp); - }); - - EXPECT_NO_THROW({ - kvdbApi->deleteKvdb( - reader->getString("Kvdb_1.kvdbId") - ); - }); - EXPECT_NO_THROW({ - std::this_thread::sleep_for(std::chrono::milliseconds(1500)); - std::optional eventHolder = eventQueue.getEvent(); - if(eventHolder.has_value()) { - event = eventHolder.value().get(); - } else { - event = nullptr; - } - }); - if(event == nullptr) { - - } else { - std::cout << "Received Event with type " << event->type << std::endl; - std::cout << "Expected null" << std::endl; - FAIL(); - } + eventQueue.waitEvent(); + auto tmp = kvdbApi->subscribeFor({ + kvdbApi->buildSubscriptionQuery( + kvdb::EventType::KVDB_DELETE, + kvdb::EventSelectorType::CONTEXT_ID, + reader->getString("Context_1.contextId") + ) + }); + kvdbApi->unsubscribeFrom(tmp); + kvdbApi->deleteKvdb( + reader->getString("Kvdb_1.kvdbId") + ); + assertNoEventReceived(); } TEST_F(KvdbEventTest, waitEvent_getEvent_kvdbStats_enabled) { - std::shared_ptr event = nullptr; - EXPECT_NO_THROW({ - eventQueue.waitEvent(); // pop libConnected form queue - }); - EXPECT_NO_THROW({ - kvdbApi->subscribeFor({ - kvdbApi->buildSubscriptionQuery( - kvdb::EventType::KVDB_STATS, - kvdb::EventSelectorType::CONTEXT_ID, - reader->getString("Context_1.contextId") - ) - }); - }); - - EXPECT_NO_THROW({ - kvdbApi->deleteEntry( - reader->getString("Kvdb_1.kvdbId"), - reader->getString("KvdbEntry_1.info_key") - ); - }); - EXPECT_NO_THROW({ - std::this_thread::sleep_for(std::chrono::milliseconds(1500)); - std::optional eventHolder = eventQueue.getEvent(); - if(eventHolder.has_value()) { - event = eventHolder.value().get(); - } else { - event = nullptr; - } - }); - if(event != nullptr) { - EXPECT_EQ(event->connectionId, connection->getConnectionId()); - EXPECT_EQ(event->type, "kvdbStatsChanged"); - EXPECT_EQ(event->channel, "kvdb"); - if(kvdb::Events::isKvdbStatsEvent(event)) { - EXPECT_EQ(event->subscriptions.size(), 1); - kvdb::KvdbStatsEventData kvdbStat = kvdb::Events::extractKvdbStatsEvent(event).data; - EXPECT_EQ(kvdbStat.kvdbId, reader->getString("Kvdb_1.kvdbId")); - EXPECT_EQ(kvdbStat.entries, 1); - } else { - FAIL(); - } - } else { - FAIL(); - } + eventQueue.waitEvent(); + kvdbApi->subscribeFor({ + kvdbApi->buildSubscriptionQuery( + kvdb::EventType::KVDB_STATS, + kvdb::EventSelectorType::CONTEXT_ID, + reader->getString("Context_1.contextId") + ) + }); + kvdbApi->deleteEntry( + reader->getString("Kvdb_1.kvdbId"), + reader->getString("KvdbEntry_1.info_key") + ); + auto eventHolder = waitForEvent("kvdbStatsChanged", {connection->getConnectionId()}); + ASSERT_TRUE(eventHolder.has_value()); + auto event = eventHolder.value().get(); + ASSERT_NE(event, nullptr); + EXPECT_EQ(event->connectionId, connection->getConnectionId()); + EXPECT_EQ(event->type, "kvdbStatsChanged"); + EXPECT_EQ(event->channel, "kvdb"); + ASSERT_TRUE(kvdb::Events::isKvdbStatsEvent(event)); + EXPECT_EQ(event->subscriptions.size(), 1); + kvdb::KvdbStatsEventData kvdbStat = kvdb::Events::extractKvdbStatsEvent(event).data; + EXPECT_EQ(kvdbStat.kvdbId, reader->getString("Kvdb_1.kvdbId")); + EXPECT_EQ(kvdbStat.entries, 1); } TEST_F(KvdbEventTest, waitEvent_getEvent_kvdbStats_disabled) { - std::shared_ptr event = nullptr; - EXPECT_NO_THROW({ - eventQueue.waitEvent(); // pop libConnected form queue - }); - EXPECT_NO_THROW({ - auto tmp = kvdbApi->subscribeFor({ - kvdbApi->buildSubscriptionQuery( - kvdb::EventType::KVDB_STATS, - kvdb::EventSelectorType::CONTEXT_ID, - reader->getString("Context_1.contextId") - ) - }); - kvdbApi->unsubscribeFrom(tmp); - }); - - EXPECT_NO_THROW({ - kvdbApi->deleteEntry( - reader->getString("Kvdb_1.kvdbId"), - reader->getString("KvdbEntry_1.info_key") - ); - }); - EXPECT_NO_THROW({ - std::this_thread::sleep_for(std::chrono::milliseconds(1500)); - std::optional eventHolder = eventQueue.getEvent(); - if(eventHolder.has_value()) { - event = eventHolder.value().get(); - } else { - event = nullptr; - } - }); - if(event == nullptr) { - - } else { - std::cout << "Received Event with type " << event->type << std::endl; - std::cout << "Expected null" << std::endl; - FAIL(); - } + eventQueue.waitEvent(); + auto tmp = kvdbApi->subscribeFor({ + kvdbApi->buildSubscriptionQuery( + kvdb::EventType::KVDB_STATS, + kvdb::EventSelectorType::CONTEXT_ID, + reader->getString("Context_1.contextId") + ) + }); + kvdbApi->unsubscribeFrom(tmp); + kvdbApi->deleteEntry( + reader->getString("Kvdb_1.kvdbId"), + reader->getString("KvdbEntry_1.info_key") + ); + assertNoEventReceived(); } TEST_F(KvdbEventTest, waitEvent_getEvent_kvdbNewKvdbEntry_enabled) { - std::shared_ptr event = nullptr; - EXPECT_NO_THROW({ - eventQueue.waitEvent(); // pop libConnected form queue - }); - EXPECT_NO_THROW({ - kvdbApi->subscribeFor({ - kvdbApi->buildSubscriptionQuery( - kvdb::EventType::ENTRY_CREATE, - kvdb::EventSelectorType::KVDB_ID, - reader->getString("Kvdb_1.kvdbId") - ) - }); - }); - std::string key = "key"; - EXPECT_NO_THROW({ - kvdbApi->setEntry( - reader->getString("Kvdb_1.kvdbId"), - key, - core::Buffer::from("publicMeta"), - core::Buffer::from("privateMeta"), - core::Buffer::from("data"), - 0 - ); - }); - EXPECT_NO_THROW({ - std::this_thread::sleep_for(std::chrono::milliseconds(1500)); - std::optional eventHolder = eventQueue.getEvent(); - if(eventHolder.has_value()) { - event = eventHolder.value().get(); - } else { - event = nullptr; - } - }); - if(event != nullptr) { - EXPECT_EQ(event->connectionId, connection->getConnectionId()); - EXPECT_EQ(event->type, "kvdbNewEntry"); - EXPECT_EQ(event->channel, "kvdb/"+reader->getString("Kvdb_1.kvdbId")+"/entries"); - if(kvdb::Events::isKvdbNewEntryEvent(event)) { - EXPECT_EQ(event->subscriptions.size(), 1); - kvdb::KvdbEntry kvdbEntry = kvdb::Events::extractKvdbNewEntryEvent(event).data; - EXPECT_EQ(kvdbEntry.publicMeta.stdString(), "publicMeta"); - EXPECT_EQ(kvdbEntry.privateMeta.stdString(), "privateMeta"); - EXPECT_EQ(kvdbEntry.data.stdString(), "data"); - EXPECT_EQ(kvdbEntry.info.kvdbId, reader->getString("Kvdb_1.kvdbId")); - } else { - FAIL(); - } - } else { - FAIL(); - } + eventQueue.waitEvent(); + kvdbApi->subscribeFor({ + kvdbApi->buildSubscriptionQuery( + kvdb::EventType::ENTRY_CREATE, + kvdb::EventSelectorType::KVDB_ID, + reader->getString("Kvdb_1.kvdbId") + ) + }); + kvdbApi->setEntry( + reader->getString("Kvdb_1.kvdbId"), + "key", + core::Buffer::from("publicMeta"), + core::Buffer::from("privateMeta"), + core::Buffer::from("data"), + 0 + ); + auto eventHolder = waitForEvent("kvdbNewEntry", {connection->getConnectionId()}); + ASSERT_TRUE(eventHolder.has_value()); + auto event = eventHolder.value().get(); + ASSERT_NE(event, nullptr); + EXPECT_EQ(event->connectionId, connection->getConnectionId()); + EXPECT_EQ(event->type, "kvdbNewEntry"); + EXPECT_EQ(event->channel, "kvdb/"+reader->getString("Kvdb_1.kvdbId")+"/entries"); + ASSERT_TRUE(kvdb::Events::isKvdbNewEntryEvent(event)); + EXPECT_EQ(event->subscriptions.size(), 1); + kvdb::KvdbEntry kvdbEntry = kvdb::Events::extractKvdbNewEntryEvent(event).data; + EXPECT_EQ(kvdbEntry.publicMeta.stdString(), "publicMeta"); + EXPECT_EQ(kvdbEntry.privateMeta.stdString(), "privateMeta"); + EXPECT_EQ(kvdbEntry.data.stdString(), "data"); + EXPECT_EQ(kvdbEntry.info.kvdbId, reader->getString("Kvdb_1.kvdbId")); } TEST_F(KvdbEventTest, waitEvent_getEvent_kvdbNewKvdbEntry_disabled) { - std::shared_ptr event = nullptr; - EXPECT_NO_THROW({ - eventQueue.waitEvent(); // pop libConnected form queue - }); - EXPECT_NO_THROW({ - auto tmp = kvdbApi->subscribeFor({ - kvdbApi->buildSubscriptionQuery( - kvdb::EventType::ENTRY_CREATE, - kvdb::EventSelectorType::KVDB_ID, - reader->getString("Kvdb_1.kvdbId") - ) - }); - kvdbApi->unsubscribeFrom(tmp); - }); - std::string key = "key"; - EXPECT_NO_THROW({ - kvdbApi->setEntry( - reader->getString("Kvdb_1.kvdbId"), - key, - core::Buffer::from("publicMeta"), - core::Buffer::from("privateMeta"), - core::Buffer::from("data"), - 0 - ); - }); - EXPECT_NO_THROW({ - std::this_thread::sleep_for(std::chrono::milliseconds(1500)); - std::optional eventHolder = eventQueue.getEvent(); - if(eventHolder.has_value()) { - event = eventHolder.value().get(); - } else { - event = nullptr; - } - }); - if(event == nullptr) { - - } else { - std::cout << "Received Event with type " << event->type << std::endl; - std::cout << "Expected null" << std::endl; - FAIL(); - } + eventQueue.waitEvent(); + auto tmp = kvdbApi->subscribeFor({ + kvdbApi->buildSubscriptionQuery( + kvdb::EventType::ENTRY_CREATE, + kvdb::EventSelectorType::KVDB_ID, + reader->getString("Kvdb_1.kvdbId") + ) + }); + kvdbApi->unsubscribeFrom(tmp); + kvdbApi->setEntry( + reader->getString("Kvdb_1.kvdbId"), + "key", + core::Buffer::from("publicMeta"), + core::Buffer::from("privateMeta"), + core::Buffer::from("data"), + 0 + ); + assertNoEventReceived(); } TEST_F(KvdbEventTest, waitEvent_getEvent_kvdbUpdatedKvdbEntry_enabled) { - std::shared_ptr event = nullptr; - EXPECT_NO_THROW({ - eventQueue.waitEvent(); // pop libConnected form queue - }); - EXPECT_NO_THROW({ - kvdbApi->subscribeFor({ - kvdbApi->buildSubscriptionQuery( - kvdb::EventType::ENTRY_UPDATE, - kvdb::EventSelectorType::KVDB_ID, - reader->getString("Kvdb_1.kvdbId") - ) - }); - }); - EXPECT_NO_THROW({ - kvdbApi->setEntry( - reader->getString("Kvdb_1.kvdbId"), - reader->getString("KvdbEntry_1.info_key"), - core::Buffer::from("publicMeta"), - core::Buffer::from("privateMeta"), - core::Buffer::from("data"), - 1 - ); - }); - EXPECT_NO_THROW({ - std::this_thread::sleep_for(std::chrono::milliseconds(1500)); - std::optional eventHolder = eventQueue.getEvent(); - if(eventHolder.has_value()) { - event = eventHolder.value().get(); - } else { - event = nullptr; - } - }); - if(event != nullptr) { - EXPECT_EQ(event->connectionId, connection->getConnectionId()); - EXPECT_EQ(event->type, "kvdbEntryUpdated"); - EXPECT_EQ(event->channel, "kvdb/"+reader->getString("Kvdb_1.kvdbId")+"/entries"); - if(kvdb::Events::isKvdbEntryUpdatedEvent(event)) { - EXPECT_EQ(event->subscriptions.size(), 1); - kvdb::KvdbEntry kvdbEntry = kvdb::Events::extractKvdbEntryUpdatedEvent(event).data; - EXPECT_EQ(kvdbEntry.info.key, reader->getString("KvdbEntry_1.info_key")); - EXPECT_EQ(kvdbEntry.publicMeta.stdString(), "publicMeta"); - EXPECT_EQ(kvdbEntry.privateMeta.stdString(), "privateMeta"); - EXPECT_EQ(kvdbEntry.data.stdString(), "data"); - EXPECT_EQ(kvdbEntry.info.kvdbId, reader->getString("Kvdb_1.kvdbId")); - } else { - FAIL(); - } - } else { - FAIL(); - } + eventQueue.waitEvent(); + kvdbApi->subscribeFor({ + kvdbApi->buildSubscriptionQuery( + kvdb::EventType::ENTRY_UPDATE, + kvdb::EventSelectorType::KVDB_ID, + reader->getString("Kvdb_1.kvdbId") + ) + }); + kvdbApi->setEntry( + reader->getString("Kvdb_1.kvdbId"), + reader->getString("KvdbEntry_1.info_key"), + core::Buffer::from("publicMeta"), + core::Buffer::from("privateMeta"), + core::Buffer::from("data"), + 1 + ); + auto eventHolder = waitForEvent("kvdbEntryUpdated", {connection->getConnectionId()}); + ASSERT_TRUE(eventHolder.has_value()); + auto event = eventHolder.value().get(); + ASSERT_NE(event, nullptr); + EXPECT_EQ(event->connectionId, connection->getConnectionId()); + EXPECT_EQ(event->type, "kvdbEntryUpdated"); + EXPECT_EQ(event->channel, "kvdb/"+reader->getString("Kvdb_1.kvdbId")+"/entries"); + ASSERT_TRUE(kvdb::Events::isKvdbEntryUpdatedEvent(event)); + EXPECT_EQ(event->subscriptions.size(), 1); + kvdb::KvdbEntry kvdbEntry = kvdb::Events::extractKvdbEntryUpdatedEvent(event).data; + EXPECT_EQ(kvdbEntry.info.key, reader->getString("KvdbEntry_1.info_key")); + EXPECT_EQ(kvdbEntry.publicMeta.stdString(), "publicMeta"); + EXPECT_EQ(kvdbEntry.privateMeta.stdString(), "privateMeta"); + EXPECT_EQ(kvdbEntry.data.stdString(), "data"); + EXPECT_EQ(kvdbEntry.info.kvdbId, reader->getString("Kvdb_1.kvdbId")); } TEST_F(KvdbEventTest, waitEvent_getEvent_kvdbUpdatedKvdbEntry_disabled) { - std::shared_ptr event = nullptr; - EXPECT_NO_THROW({ - eventQueue.waitEvent(); // pop libConnected form queue - }); - EXPECT_NO_THROW({ - auto tmp = kvdbApi->subscribeFor({ - kvdbApi->buildSubscriptionQuery( - kvdb::EventType::ENTRY_UPDATE, - kvdb::EventSelectorType::KVDB_ID, - reader->getString("Kvdb_1.kvdbId") - ) - }); - kvdbApi->unsubscribeFrom(tmp); - }); - EXPECT_NO_THROW({ - kvdbApi->setEntry( - reader->getString("Kvdb_1.kvdbId"), - reader->getString("KvdbEntry_1.info_key"), - core::Buffer::from("publicMeta"), - core::Buffer::from("privateMeta"), - core::Buffer::from("data"), - 1 - ); - }); - EXPECT_NO_THROW({ - std::this_thread::sleep_for(std::chrono::milliseconds(1500)); - std::optional eventHolder = eventQueue.getEvent(); - if(eventHolder.has_value()) { - event = eventHolder.value().get(); - } else { - event = nullptr; - } - }); - if(event == nullptr) { - - } else { - std::cout << "Received Event with type " << event->type << std::endl; - std::cout << "Expected null" << std::endl; - FAIL(); - } + eventQueue.waitEvent(); + auto tmp = kvdbApi->subscribeFor({ + kvdbApi->buildSubscriptionQuery( + kvdb::EventType::ENTRY_UPDATE, + kvdb::EventSelectorType::KVDB_ID, + reader->getString("Kvdb_1.kvdbId") + ) + }); + kvdbApi->unsubscribeFrom(tmp); + kvdbApi->setEntry( + reader->getString("Kvdb_1.kvdbId"), + reader->getString("KvdbEntry_1.info_key"), + core::Buffer::from("publicMeta"), + core::Buffer::from("privateMeta"), + core::Buffer::from("data"), + 1 + ); + assertNoEventReceived(); } TEST_F(KvdbEventTest, waitEvent_getEvent_kvdbDeletedKvdbEntry_enabled) { - std::shared_ptr event = nullptr; - EXPECT_NO_THROW({ - eventQueue.waitEvent(); // pop libConnected form queue - }); - EXPECT_NO_THROW({ - kvdbApi->subscribeFor({ - kvdbApi->buildSubscriptionQuery( - kvdb::EventType::ENTRY_DELETE, - kvdb::EventSelectorType::KVDB_ID, - reader->getString("Kvdb_1.kvdbId") - ) - }); - }); - EXPECT_NO_THROW({ - kvdbApi->deleteEntry( - reader->getString("Kvdb_1.kvdbId"), - reader->getString("KvdbEntry_1.info_key") - ); - }); - EXPECT_NO_THROW({ - std::this_thread::sleep_for(std::chrono::milliseconds(1500)); - std::optional eventHolder = eventQueue.getEvent(); - if(eventHolder.has_value()) { - event = eventHolder.value().get(); - } else { - event = nullptr; - } - }); - if(event != nullptr) { - EXPECT_EQ(event->connectionId, connection->getConnectionId()); - EXPECT_EQ(event->type, "kvdbEntryDeleted"); - EXPECT_EQ(event->channel, "kvdb/"+reader->getString("Kvdb_1.kvdbId")+"/entries"); - if(kvdb::Events::isKvdbEntryDeletedEvent(event)) { - EXPECT_EQ(event->subscriptions.size(), 1); - kvdb::KvdbDeletedEntryEventData kvdbDeletedKvdbEntry = kvdb::Events::extractKvdbEntryDeletedEvent(event).data; - EXPECT_EQ(kvdbDeletedKvdbEntry.kvdbEntryKey, reader->getString("KvdbEntry_1.info_key")); - EXPECT_EQ(kvdbDeletedKvdbEntry.kvdbId, reader->getString("Kvdb_1.kvdbId")); - } else { - FAIL(); - } - } else { - FAIL(); - } + eventQueue.waitEvent(); + kvdbApi->subscribeFor({ + kvdbApi->buildSubscriptionQuery( + kvdb::EventType::ENTRY_DELETE, + kvdb::EventSelectorType::KVDB_ID, + reader->getString("Kvdb_1.kvdbId") + ) + }); + kvdbApi->deleteEntry( + reader->getString("Kvdb_1.kvdbId"), + reader->getString("KvdbEntry_1.info_key") + ); + auto eventHolder = waitForEvent("kvdbEntryDeleted", {connection->getConnectionId()}); + ASSERT_TRUE(eventHolder.has_value()); + auto event = eventHolder.value().get(); + ASSERT_NE(event, nullptr); + EXPECT_EQ(event->connectionId, connection->getConnectionId()); + EXPECT_EQ(event->type, "kvdbEntryDeleted"); + EXPECT_EQ(event->channel, "kvdb/"+reader->getString("Kvdb_1.kvdbId")+"/entries"); + ASSERT_TRUE(kvdb::Events::isKvdbEntryDeletedEvent(event)); + EXPECT_EQ(event->subscriptions.size(), 1); + kvdb::KvdbDeletedEntryEventData kvdbDeletedKvdbEntry = kvdb::Events::extractKvdbEntryDeletedEvent(event).data; + EXPECT_EQ(kvdbDeletedKvdbEntry.kvdbEntryKey, reader->getString("KvdbEntry_1.info_key")); + EXPECT_EQ(kvdbDeletedKvdbEntry.kvdbId, reader->getString("Kvdb_1.kvdbId")); } TEST_F(KvdbEventTest, waitEvent_getEvent_kvdbDeletedKvdbEntry_disabled) { - std::shared_ptr event = nullptr; - EXPECT_NO_THROW({ - eventQueue.waitEvent(); // pop libConnected form queue - }); - EXPECT_NO_THROW({ - auto tmp = kvdbApi->subscribeFor({ - kvdbApi->buildSubscriptionQuery( - kvdb::EventType::ENTRY_DELETE, - kvdb::EventSelectorType::KVDB_ID, - reader->getString("Kvdb_1.kvdbId") - ) - }); - kvdbApi->unsubscribeFrom(tmp); - }); - EXPECT_NO_THROW({ - kvdbApi->deleteEntry( - reader->getString("Kvdb_1.kvdbId"), - reader->getString("KvdbEntry_1.info_key") - ); - }); - EXPECT_NO_THROW({ - std::this_thread::sleep_for(std::chrono::milliseconds(1500)); - std::optional eventHolder = eventQueue.getEvent(); - if(eventHolder.has_value()) { - event = eventHolder.value().get(); - } else { - event = nullptr; - } - }); - if(event == nullptr) { - - } else { - std::cout << "Received Event with type " << event->type << std::endl; - std::cout << "Expected null" << std::endl; - FAIL(); - } + eventQueue.waitEvent(); + auto tmp = kvdbApi->subscribeFor({ + kvdbApi->buildSubscriptionQuery( + kvdb::EventType::ENTRY_DELETE, + kvdb::EventSelectorType::KVDB_ID, + reader->getString("Kvdb_1.kvdbId") + ) + }); + kvdbApi->unsubscribeFrom(tmp); + kvdbApi->deleteEntry( + reader->getString("Kvdb_1.kvdbId"), + reader->getString("KvdbEntry_1.info_key") + ); + assertNoEventReceived(); } TEST_F(KvdbEventTest, Subscribe_for_singel_entry) { - std::shared_ptr event = nullptr; - EXPECT_NO_THROW({ - eventQueue.waitEvent(); // pop libConnected form queue - }); - EXPECT_NO_THROW({ - kvdbApi->subscribeFor({ - kvdbApi->buildSubscriptionQueryForSelectedEntry( - kvdb::EventType::ENTRY_UPDATE, - reader->getString("Kvdb_1.kvdbId"), - reader->getString("KvdbEntry_1.info_key") - ) - }); - }); - EXPECT_NO_THROW({ - kvdbApi->setEntry( + eventQueue.waitEvent(); + kvdbApi->subscribeFor({ + kvdbApi->buildSubscriptionQueryForSelectedEntry( + kvdb::EventType::ENTRY_UPDATE, reader->getString("Kvdb_1.kvdbId"), - reader->getString("KvdbEntry_1.info_key"), - core::Buffer::from("publicMeta"), - core::Buffer::from("privateMeta"), - core::Buffer::from("data"), - 1 - ); - }); - EXPECT_NO_THROW({ - std::this_thread::sleep_for(std::chrono::milliseconds(1500)); - std::optional eventHolder = eventQueue.getEvent(); - if(eventHolder.has_value()) { - event = eventHolder.value().get(); - } else { - event = nullptr; - } - }); - if(event != nullptr) { - EXPECT_EQ(event->connectionId, connection->getConnectionId()); - EXPECT_EQ(event->type, "kvdbEntryUpdated"); - EXPECT_EQ(event->channel, "kvdb/"+reader->getString("Kvdb_1.kvdbId")+"/entries"); - if(kvdb::Events::isKvdbEntryUpdatedEvent(event)) { - kvdb::KvdbEntry kvdbEntry = kvdb::Events::extractKvdbEntryUpdatedEvent(event).data; - EXPECT_EQ(kvdbEntry.info.key, reader->getString("KvdbEntry_1.info_key")); - EXPECT_EQ(kvdbEntry.publicMeta.stdString(), "publicMeta"); - EXPECT_EQ(kvdbEntry.privateMeta.stdString(), "privateMeta"); - EXPECT_EQ(kvdbEntry.data.stdString(), "data"); - EXPECT_EQ(kvdbEntry.info.kvdbId, reader->getString("Kvdb_1.kvdbId")); - } else { - FAIL(); - } - } else { - FAIL(); - } + reader->getString("KvdbEntry_1.info_key") + ) + }); + kvdbApi->setEntry( + reader->getString("Kvdb_1.kvdbId"), + reader->getString("KvdbEntry_1.info_key"), + core::Buffer::from("publicMeta"), + core::Buffer::from("privateMeta"), + core::Buffer::from("data"), + 1 + ); + auto eventHolder = waitForEvent("kvdbEntryUpdated", {connection->getConnectionId()}); + ASSERT_TRUE(eventHolder.has_value()); + auto event = eventHolder.value().get(); + ASSERT_NE(event, nullptr); + EXPECT_EQ(event->connectionId, connection->getConnectionId()); + EXPECT_EQ(event->type, "kvdbEntryUpdated"); + EXPECT_EQ(event->channel, "kvdb/"+reader->getString("Kvdb_1.kvdbId")+"/entries"); + ASSERT_TRUE(kvdb::Events::isKvdbEntryUpdatedEvent(event)); + kvdb::KvdbEntry kvdbEntry = kvdb::Events::extractKvdbEntryUpdatedEvent(event).data; + EXPECT_EQ(kvdbEntry.info.key, reader->getString("KvdbEntry_1.info_key")); + EXPECT_EQ(kvdbEntry.publicMeta.stdString(), "publicMeta"); + EXPECT_EQ(kvdbEntry.privateMeta.stdString(), "privateMeta"); + EXPECT_EQ(kvdbEntry.data.stdString(), "data"); + EXPECT_EQ(kvdbEntry.info.kvdbId, reader->getString("Kvdb_1.kvdbId")); } TEST_F(KvdbEventTest, subscribeFor_query_from_other_module) { @@ -799,31 +457,31 @@ TEST_F(KvdbEventTest, subscribeFor_unsubscribeFor) { std::vector valid_subscriptions; EXPECT_NO_THROW({ valid_subscriptions = kvdbApi->subscribeFor({ - kvdbApi->buildSubscriptionQuery( - kvdb::EventType::KVDB_CREATE, - kvdb::EventSelectorType::CONTEXT_ID, - reader->getString("Context_1.contextId") + kvdbApi->buildSubscriptionQuery( + kvdb::EventType::KVDB_CREATE, + kvdb::EventSelectorType::CONTEXT_ID, + reader->getString("Context_1.contextId") ) }); }); std::vector invalid_subscriptions; EXPECT_NO_THROW({ invalid_subscriptions = kvdbApi->subscribeFor({ - kvdbApi->buildSubscriptionQuery( - kvdb::EventType::KVDB_CREATE, - kvdb::EventSelectorType::CONTEXT_ID, + kvdbApi->buildSubscriptionQuery( + kvdb::EventType::KVDB_CREATE, + kvdb::EventSelectorType::CONTEXT_ID, "error" ) }); }); EXPECT_NO_THROW({ kvdbApi->unsubscribeFrom({ - valid_subscriptions + valid_subscriptions }); }); EXPECT_NO_THROW({ kvdbApi->unsubscribeFrom({ - invalid_subscriptions + invalid_subscriptions }); }); } diff --git a/test/tests/StoreModuleEventsTest.cpp b/test/tests/StoreModuleEventsTest.cpp index 0f712947..17c6328a 100644 --- a/test/tests/StoreModuleEventsTest.cpp +++ b/test/tests/StoreModuleEventsTest.cpp @@ -1,834 +1,450 @@ -#include -#include -#include -#include "../utils/BaseTest.hpp" -#include +#include "../utils/BaseEndpointEventTest.hpp" #include #include #include #include -#include #include #include -#include -#include using namespace privmx::endpoint; -class StoreEventTest : public privmx::test::BaseTest { +class StoreEventTest : public privmx::test::BaseEndpointEventTest { protected: - StoreEventTest() : BaseTest(privmx::test::BaseTestMode::online) {} - void customSetUp() override { - reader = new Poco::Util::IniFileConfiguration(INI_FILE_PATH); - connection = std::make_shared( - core::Connection::connect( - reader->getString("Login.user_1_privKey"), - reader->getString("Login.solutionId"), - getPlatformUrl(reader->getString("Login.instanceUrl")) - ) - ); + void setUpModuleApis() override { storeApi = std::make_shared( - store::StoreApi::create( - *connection - ) + store::StoreApi::create(*connection) ); } - void customTearDown() override { // tmp segfault fix - connection.reset(); + void tearDownModuleApis() override { storeApi.reset(); - reader.reset(); - privmx::endpoint::core::EventQueueImpl::getInstance()->clear(); } - std::shared_ptr connection; std::shared_ptr storeApi; - core::EventQueue eventQueue = core::EventQueue::getInstance(); - Poco::Util::IniFileConfiguration::Ptr reader; }; TEST_F(StoreEventTest, waitEvent_getEvent_storeCreated_enabled) { - std::shared_ptr event = nullptr; - EXPECT_NO_THROW({ - eventQueue.waitEvent(); // pop libConnected form queue - }); - EXPECT_NO_THROW({ - storeApi->subscribeFor({ - storeApi->buildSubscriptionQuery( - store::EventType::STORE_CREATE, - store::EventSelectorType::CONTEXT_ID, - reader->getString("Context_1.contextId") - ) - }); - }); - std::string storeId; - EXPECT_NO_THROW({ - storeId = storeApi->createStore( - reader->getString("Context_1.contextId"), - std::vector{core::UserWithPubKey{ - .userId=reader->getString("Login.user_1_id"), - .pubKey=reader->getString("Login.user_1_pubKey") - }}, - std::vector{core::UserWithPubKey{ - .userId=reader->getString("Login.user_1_id"), - .pubKey=reader->getString("Login.user_1_pubKey") - }}, - core::Buffer::from("public"), - core::Buffer::from("private") - ); - }); - EXPECT_NO_THROW({ - std::this_thread::sleep_for(std::chrono::milliseconds(1500)); - std::optional eventHolder = eventQueue.getEvent(); - if(eventHolder.has_value()) { - event = eventHolder.value().get(); - } else { - event = nullptr; - } - }); - if(event != nullptr) { - EXPECT_EQ(event->connectionId, connection->getConnectionId()); - EXPECT_EQ(event->type, "storeCreated"); - EXPECT_EQ(event->channel, "store"); - if(store::Events::isStoreCreatedEvent(event)) { - EXPECT_EQ(event->subscriptions.size(), 1); - store::Store store = store::Events::extractStoreCreatedEvent(event).data; - EXPECT_EQ(store.contextId, reader->getString("Context_1.contextId")); - EXPECT_EQ(store.publicMeta.stdString(),"public"); - EXPECT_EQ(store.privateMeta.stdString(),"private"); - EXPECT_EQ(store.users.size(), 1); - if(store.users.size() == 1) { - EXPECT_EQ(store.users[0], reader->getString("Login.user_1_id")); - } - EXPECT_EQ(store.managers.size(), 1); - if(store.managers.size() == 1) { - EXPECT_EQ(store.managers[0], reader->getString("Login.user_1_id")); - } - } else { - FAIL(); - } - } else { - FAIL(); + eventQueue.waitEvent(); + storeApi->subscribeFor({ + storeApi->buildSubscriptionQuery( + store::EventType::STORE_CREATE, + store::EventSelectorType::CONTEXT_ID, + reader->getString("Context_1.contextId") + ) + }); + storeApi->createStore( + reader->getString("Context_1.contextId"), + std::vector{core::UserWithPubKey{ + .userId=reader->getString("Login.user_1_id"), + .pubKey=reader->getString("Login.user_1_pubKey") + }}, + std::vector{core::UserWithPubKey{ + .userId=reader->getString("Login.user_1_id"), + .pubKey=reader->getString("Login.user_1_pubKey") + }}, + core::Buffer::from("public"), + core::Buffer::from("private") + ); + auto eventHolder = waitForEvent("storeCreated", {connection->getConnectionId()}); + ASSERT_TRUE(eventHolder.has_value()); + auto event = eventHolder.value().get(); + ASSERT_NE(event, nullptr); + EXPECT_EQ(event->connectionId, connection->getConnectionId()); + EXPECT_EQ(event->type, "storeCreated"); + EXPECT_EQ(event->channel, "store"); + ASSERT_TRUE(store::Events::isStoreCreatedEvent(event)); + EXPECT_EQ(event->subscriptions.size(), 1); + store::Store store = store::Events::extractStoreCreatedEvent(event).data; + EXPECT_EQ(store.contextId, reader->getString("Context_1.contextId")); + EXPECT_EQ(store.publicMeta.stdString(), "public"); + EXPECT_EQ(store.privateMeta.stdString(), "private"); + EXPECT_EQ(store.users.size(), 1); + if(store.users.size() == 1) { + EXPECT_EQ(store.users[0], reader->getString("Login.user_1_id")); + } + EXPECT_EQ(store.managers.size(), 1); + if(store.managers.size() == 1) { + EXPECT_EQ(store.managers[0], reader->getString("Login.user_1_id")); } } TEST_F(StoreEventTest, waitEvent_getEvent_storeCreated_disabled) { - std::shared_ptr event = nullptr; - EXPECT_NO_THROW({ - eventQueue.waitEvent(); // pop libConnected form queue - }); - EXPECT_NO_THROW({ - auto tmp = storeApi->subscribeFor({ - storeApi->buildSubscriptionQuery( - store::EventType::STORE_CREATE, - store::EventSelectorType::CONTEXT_ID, - reader->getString("Context_1.contextId") - ) - }); - storeApi->unsubscribeFrom(tmp); - }); - std::string storeId; - EXPECT_NO_THROW({ - storeId = storeApi->createStore( - reader->getString("Context_1.contextId"), - std::vector{core::UserWithPubKey{ - .userId=reader->getString("Login.user_1_id"), - .pubKey=reader->getString("Login.user_1_pubKey") - }}, - std::vector{core::UserWithPubKey{ - .userId=reader->getString("Login.user_1_id"), - .pubKey=reader->getString("Login.user_1_pubKey") - }}, - core::Buffer::from("public"), - core::Buffer::from("private") - ); - }); - EXPECT_NO_THROW({ - std::this_thread::sleep_for(std::chrono::milliseconds(1500)); - std::optional eventHolder = eventQueue.getEvent(); - if(eventHolder.has_value()) { - event = eventHolder.value().get(); - } else { - event = nullptr; - } - }); - if(event == nullptr) { - - } else { - std::cout << "Received Event with type " << event->type << std::endl; - std::cout << "Expected null" << std::endl; - FAIL(); - } + eventQueue.waitEvent(); + auto tmp = storeApi->subscribeFor({ + storeApi->buildSubscriptionQuery( + store::EventType::STORE_CREATE, + store::EventSelectorType::CONTEXT_ID, + reader->getString("Context_1.contextId") + ) + }); + storeApi->unsubscribeFrom(tmp); + storeApi->createStore( + reader->getString("Context_1.contextId"), + std::vector{core::UserWithPubKey{ + .userId=reader->getString("Login.user_1_id"), + .pubKey=reader->getString("Login.user_1_pubKey") + }}, + std::vector{core::UserWithPubKey{ + .userId=reader->getString("Login.user_1_id"), + .pubKey=reader->getString("Login.user_1_pubKey") + }}, + core::Buffer::from("public"), + core::Buffer::from("private") + ); + assertNoEventReceived(); } TEST_F(StoreEventTest, waitEvent_getEvent_storeUpdated_enabled) { - std::shared_ptr event = nullptr; - EXPECT_NO_THROW({ - eventQueue.waitEvent(); // pop libConnected form queue - }); - EXPECT_NO_THROW({ - storeApi->subscribeFor({ - storeApi->buildSubscriptionQuery( - store::EventType::STORE_UPDATE, - store::EventSelectorType::CONTEXT_ID, - reader->getString("Context_1.contextId") - ) - }); - }); - EXPECT_NO_THROW({ - storeApi->updateStore( - reader->getString("Store_1.storeId"), - std::vector{core::UserWithPubKey{ - .userId=reader->getString("Login.user_1_id"), - .pubKey=reader->getString("Login.user_1_pubKey") - }}, - std::vector{core::UserWithPubKey{ - .userId=reader->getString("Login.user_1_id"), - .pubKey=reader->getString("Login.user_1_pubKey") - }}, - core::Buffer::from("public"), - core::Buffer::from("private"), - 1, - true, - true - ); - }); - EXPECT_NO_THROW({ - std::this_thread::sleep_for(std::chrono::milliseconds(1500)); - std::optional eventHolder = eventQueue.getEvent(); - if(eventHolder.has_value()) { - event = eventHolder.value().get(); - } else { - event = nullptr; - } - }); - if(event != nullptr) { - EXPECT_EQ(event->connectionId, connection->getConnectionId()); - EXPECT_EQ(event->type, "storeUpdated"); - EXPECT_EQ(event->channel, "store"); - if(store::Events::isStoreUpdatedEvent(event)) { - EXPECT_EQ(event->subscriptions.size(), 1); - store::Store store = store::Events::extractStoreUpdatedEvent(event).data; - EXPECT_EQ(store.contextId, reader->getString("Context_1.contextId")); - EXPECT_EQ(store.publicMeta.stdString(),"public"); - EXPECT_EQ(store.privateMeta.stdString(),"private"); - EXPECT_EQ(store.users.size(), 1); - if(store.users.size() == 1) { - EXPECT_EQ(store.users[0], reader->getString("Login.user_1_id")); - } - EXPECT_EQ(store.managers.size(), 1); - if(store.managers.size() == 1) { - EXPECT_EQ(store.managers[0], reader->getString("Login.user_1_id")); - } - } else { - FAIL(); - } - } else { - FAIL(); + eventQueue.waitEvent(); + storeApi->subscribeFor({ + storeApi->buildSubscriptionQuery( + store::EventType::STORE_UPDATE, + store::EventSelectorType::CONTEXT_ID, + reader->getString("Context_1.contextId") + ) + }); + storeApi->updateStore( + reader->getString("Store_1.storeId"), + std::vector{core::UserWithPubKey{ + .userId=reader->getString("Login.user_1_id"), + .pubKey=reader->getString("Login.user_1_pubKey") + }}, + std::vector{core::UserWithPubKey{ + .userId=reader->getString("Login.user_1_id"), + .pubKey=reader->getString("Login.user_1_pubKey") + }}, + core::Buffer::from("public"), + core::Buffer::from("private"), + 1, + true, + true + ); + auto eventHolder = waitForEvent("storeUpdated", {connection->getConnectionId()}); + ASSERT_TRUE(eventHolder.has_value()); + auto event = eventHolder.value().get(); + ASSERT_NE(event, nullptr); + EXPECT_EQ(event->connectionId, connection->getConnectionId()); + EXPECT_EQ(event->type, "storeUpdated"); + EXPECT_EQ(event->channel, "store"); + ASSERT_TRUE(store::Events::isStoreUpdatedEvent(event)); + EXPECT_EQ(event->subscriptions.size(), 1); + store::Store store = store::Events::extractStoreUpdatedEvent(event).data; + EXPECT_EQ(store.contextId, reader->getString("Context_1.contextId")); + EXPECT_EQ(store.publicMeta.stdString(), "public"); + EXPECT_EQ(store.privateMeta.stdString(), "private"); + EXPECT_EQ(store.users.size(), 1); + if(store.users.size() == 1) { + EXPECT_EQ(store.users[0], reader->getString("Login.user_1_id")); + } + EXPECT_EQ(store.managers.size(), 1); + if(store.managers.size() == 1) { + EXPECT_EQ(store.managers[0], reader->getString("Login.user_1_id")); } } TEST_F(StoreEventTest, waitEvent_getEvent_storeUpdated_disabled) { - std::shared_ptr event = nullptr; - EXPECT_NO_THROW({ - eventQueue.waitEvent(); // pop libConnected form queue - }); - EXPECT_NO_THROW({ - auto tmp = storeApi->subscribeFor({ - storeApi->buildSubscriptionQuery( - store::EventType::STORE_UPDATE, - store::EventSelectorType::CONTEXT_ID, - reader->getString("Context_1.contextId") - ) - }); - storeApi->unsubscribeFrom(tmp); - }); - EXPECT_NO_THROW({ - storeApi->updateStore( - reader->getString("Store_1.storeId"), - std::vector{core::UserWithPubKey{ - .userId=reader->getString("Login.user_1_id"), - .pubKey=reader->getString("Login.user_1_pubKey") - }}, - std::vector{core::UserWithPubKey{ - .userId=reader->getString("Login.user_1_id"), - .pubKey=reader->getString("Login.user_1_pubKey") - }}, - core::Buffer::from("public"), - core::Buffer::from("private"), - 1, - true, - true - ); - }); - EXPECT_NO_THROW({ - std::this_thread::sleep_for(std::chrono::milliseconds(1500)); - std::optional eventHolder = eventQueue.getEvent(); - if(eventHolder.has_value()) { - event = eventHolder.value().get(); - } else { - event = nullptr; - } - }); - if(event == nullptr) { - - } else { - std::cout << "Received Event with type " << event->type << std::endl; - std::cout << "Expected null" << std::endl; - FAIL(); - } + eventQueue.waitEvent(); + auto tmp = storeApi->subscribeFor({ + storeApi->buildSubscriptionQuery( + store::EventType::STORE_UPDATE, + store::EventSelectorType::CONTEXT_ID, + reader->getString("Context_1.contextId") + ) + }); + storeApi->unsubscribeFrom(tmp); + storeApi->updateStore( + reader->getString("Store_1.storeId"), + std::vector{core::UserWithPubKey{ + .userId=reader->getString("Login.user_1_id"), + .pubKey=reader->getString("Login.user_1_pubKey") + }}, + std::vector{core::UserWithPubKey{ + .userId=reader->getString("Login.user_1_id"), + .pubKey=reader->getString("Login.user_1_pubKey") + }}, + core::Buffer::from("public"), + core::Buffer::from("private"), + 1, + true, + true + ); + assertNoEventReceived(); } TEST_F(StoreEventTest, waitEvent_getEvent_storeDeleted_enabled) { - std::shared_ptr event = nullptr; - EXPECT_NO_THROW({ - eventQueue.waitEvent(); // pop libConnected form queue - }); - EXPECT_NO_THROW({ - storeApi->subscribeFor({ - storeApi->buildSubscriptionQuery( - store::EventType::STORE_DELETE, - store::EventSelectorType::CONTEXT_ID, - reader->getString("Context_1.contextId") - ) - }); - }); - EXPECT_NO_THROW({ - storeApi->deleteStore( - reader->getString("Store_1.storeId") - ); - }); - EXPECT_NO_THROW({ - std::this_thread::sleep_for(std::chrono::milliseconds(1500)); - std::optional eventHolder = eventQueue.getEvent(); - if(eventHolder.has_value()) { - event = eventHolder.value().get(); - } else { - event = nullptr; - } - }); - if(event != nullptr) { - EXPECT_EQ(event->connectionId, connection->getConnectionId()); - EXPECT_EQ(event->type, "storeDeleted"); - EXPECT_EQ(event->channel, "store"); - if(store::Events::isStoreDeletedEvent(event)) { - EXPECT_EQ(event->subscriptions.size(), 1); - store::StoreDeletedEventData storeDeleted = store::Events::extractStoreDeletedEvent(event).data; - EXPECT_EQ(storeDeleted.storeId, reader->getString("Store_1.storeId")); - } else { - FAIL(); - } - } else { - FAIL(); - } + eventQueue.waitEvent(); + storeApi->subscribeFor({ + storeApi->buildSubscriptionQuery( + store::EventType::STORE_DELETE, + store::EventSelectorType::CONTEXT_ID, + reader->getString("Context_1.contextId") + ) + }); + storeApi->deleteStore( + reader->getString("Store_1.storeId") + ); + auto eventHolder = waitForEvent("storeDeleted", {connection->getConnectionId()}); + ASSERT_TRUE(eventHolder.has_value()); + auto event = eventHolder.value().get(); + ASSERT_NE(event, nullptr); + EXPECT_EQ(event->connectionId, connection->getConnectionId()); + EXPECT_EQ(event->type, "storeDeleted"); + EXPECT_EQ(event->channel, "store"); + ASSERT_TRUE(store::Events::isStoreDeletedEvent(event)); + EXPECT_EQ(event->subscriptions.size(), 1); + store::StoreDeletedEventData storeDeleted = store::Events::extractStoreDeletedEvent(event).data; + EXPECT_EQ(storeDeleted.storeId, reader->getString("Store_1.storeId")); } TEST_F(StoreEventTest, waitEvent_getEvent_storeDeleted_disabled) { - std::shared_ptr event = nullptr; - EXPECT_NO_THROW({ - eventQueue.waitEvent(); // pop libConnected form queue - }); - EXPECT_NO_THROW({ - auto tmp = storeApi->subscribeFor({ - storeApi->buildSubscriptionQuery( - store::EventType::STORE_DELETE, - store::EventSelectorType::CONTEXT_ID, - reader->getString("Context_1.contextId") - ) - }); - storeApi->unsubscribeFrom(tmp); - }); - EXPECT_NO_THROW({ - storeApi->deleteStore( - reader->getString("Store_1.storeId") - ); - }); - EXPECT_NO_THROW({ - std::this_thread::sleep_for(std::chrono::milliseconds(1500)); - std::optional eventHolder = eventQueue.getEvent(); - if(eventHolder.has_value()) { - event = eventHolder.value().get(); - } else { - event = nullptr; - } - }); - if(event == nullptr) { - - } else { - std::cout << "Received Event with type " << event->type << std::endl; - std::cout << "Expected null" << std::endl; - FAIL(); - } + eventQueue.waitEvent(); + auto tmp = storeApi->subscribeFor({ + storeApi->buildSubscriptionQuery( + store::EventType::STORE_DELETE, + store::EventSelectorType::CONTEXT_ID, + reader->getString("Context_1.contextId") + ) + }); + storeApi->unsubscribeFrom(tmp); + storeApi->deleteStore( + reader->getString("Store_1.storeId") + ); + assertNoEventReceived(); } TEST_F(StoreEventTest, waitEvent_getEvent_storeStatsChanged_enabled) { - std::shared_ptr event = nullptr; - EXPECT_NO_THROW({ - eventQueue.waitEvent(); // pop libConnected form queue - }); - EXPECT_NO_THROW({ - storeApi->subscribeFor({ - storeApi->buildSubscriptionQuery( - store::EventType::STORE_STATS, - store::EventSelectorType::CONTEXT_ID, - reader->getString("Context_1.contextId") - ) - }); - }); - EXPECT_NO_THROW({ - storeApi->deleteFile( - reader->getString("File_1.info_fileId") - ); - }); - EXPECT_NO_THROW({ - std::this_thread::sleep_for(std::chrono::milliseconds(1500)); - std::optional eventHolder = eventQueue.getEvent(); - if(eventHolder.has_value()) { - event = eventHolder.value().get(); - } else { - event = nullptr; - } - }); - if(event != nullptr) { - EXPECT_EQ(event->connectionId, connection->getConnectionId()); - EXPECT_EQ(event->type, "storeStatsChanged"); - EXPECT_EQ(event->channel, "store"); - if(store::Events::isStoreStatsChangedEvent(event)) { - EXPECT_EQ(event->subscriptions.size(), 1); - store::StoreStatsChangedEventData storeStat = store::Events::extractStoreStatsChangedEvent(event).data; - EXPECT_EQ(storeStat.storeId, reader->getString("Store_1.storeId")); - EXPECT_EQ(storeStat.contextId, reader->getString("Context_1.contextId")); - EXPECT_EQ(storeStat.filesCount, 1); - } else { - FAIL(); - } - } else { - FAIL(); - } + eventQueue.waitEvent(); + storeApi->subscribeFor({ + storeApi->buildSubscriptionQuery( + store::EventType::STORE_STATS, + store::EventSelectorType::CONTEXT_ID, + reader->getString("Context_1.contextId") + ) + }); + storeApi->deleteFile( + reader->getString("File_1.info_fileId") + ); + auto eventHolder = waitForEvent("storeStatsChanged", {connection->getConnectionId()}); + ASSERT_TRUE(eventHolder.has_value()); + auto event = eventHolder.value().get(); + ASSERT_NE(event, nullptr); + EXPECT_EQ(event->connectionId, connection->getConnectionId()); + EXPECT_EQ(event->type, "storeStatsChanged"); + EXPECT_EQ(event->channel, "store"); + ASSERT_TRUE(store::Events::isStoreStatsChangedEvent(event)); + EXPECT_EQ(event->subscriptions.size(), 1); + store::StoreStatsChangedEventData storeStat = store::Events::extractStoreStatsChangedEvent(event).data; + EXPECT_EQ(storeStat.storeId, reader->getString("Store_1.storeId")); + EXPECT_EQ(storeStat.contextId, reader->getString("Context_1.contextId")); + EXPECT_EQ(storeStat.filesCount, 1); } TEST_F(StoreEventTest, waitEvent_getEvent_storeStatsChanged_disabled) { - std::shared_ptr event = nullptr; - EXPECT_NO_THROW({ - eventQueue.waitEvent(); // pop libConnected form queue - }); - EXPECT_NO_THROW({ - auto tmp = storeApi->subscribeFor({ - storeApi->buildSubscriptionQuery( - store::EventType::STORE_STATS, - store::EventSelectorType::CONTEXT_ID, - reader->getString("Context_1.contextId") - ) - }); - storeApi->unsubscribeFrom(tmp); - }); - EXPECT_NO_THROW({ - storeApi->deleteFile( - reader->getString("File_1.info_fileId") - ); - }); - EXPECT_NO_THROW({ - std::this_thread::sleep_for(std::chrono::milliseconds(1500)); - std::optional eventHolder = eventQueue.getEvent(); - if(eventHolder.has_value()) { - event = eventHolder.value().get(); - } else { - event = nullptr; - } - }); - if(event == nullptr) { - - } else { - std::cout << "Received Event with type " << event->type << std::endl; - std::cout << "Expected null" << std::endl; - FAIL(); - } + eventQueue.waitEvent(); + auto tmp = storeApi->subscribeFor({ + storeApi->buildSubscriptionQuery( + store::EventType::STORE_STATS, + store::EventSelectorType::CONTEXT_ID, + reader->getString("Context_1.contextId") + ) + }); + storeApi->unsubscribeFrom(tmp); + storeApi->deleteFile( + reader->getString("File_1.info_fileId") + ); + assertNoEventReceived(); } TEST_F(StoreEventTest, waitEvent_getEvent_storeFileCreated_enabled) { - std::shared_ptr event = nullptr; - EXPECT_NO_THROW({ - eventQueue.waitEvent(); // pop libConnected form queue - }); - EXPECT_NO_THROW({ - storeApi->subscribeFor({ - storeApi->buildSubscriptionQuery( - store::EventType::FILE_CREATE, - store::EventSelectorType::STORE_ID, - reader->getString("Store_1.storeId") - ) - }); - }); - int64_t handle; - EXPECT_NO_THROW({ - handle = storeApi->createFile( - reader->getString("Store_1.storeId"), - privmx::endpoint::core::Buffer::from("publicMeta"), - privmx::endpoint::core::Buffer::from("privateMeta"), - 0 - ); - }); - if(handle == 1) { - std::string fileId; - EXPECT_NO_THROW({ - fileId = storeApi->closeFile(handle); - }); - if(fileId.empty()) { - std::cout << "storeFileClose Failed" << std::endl; - FAIL(); - } - } else { - std::cout << "storeFileCreate Failed" << std::endl; - FAIL(); - } - EXPECT_NO_THROW({ - std::this_thread::sleep_for(std::chrono::milliseconds(1500)); - std::optional eventHolder = eventQueue.getEvent(); - if(eventHolder.has_value()) { - event = eventHolder.value().get(); - } else { - event = nullptr; - } - }); - if(event != nullptr) { - EXPECT_EQ(event->connectionId, connection->getConnectionId()); - EXPECT_EQ(event->type, "storeFileCreated"); - EXPECT_EQ(event->channel, "store/" + reader->getString("Store_1.storeId") + "/files"); - if(store::Events::isStoreFileCreatedEvent(event)) { - EXPECT_EQ(event->subscriptions.size(), 1); - store::File storeFile = store::Events::extractStoreFileCreatedEvent(event).data; - EXPECT_EQ(storeFile.info.storeId, reader->getString("Store_1.storeId")); - EXPECT_EQ(storeFile.size, 0); - EXPECT_EQ(storeFile.publicMeta.stdString(), "publicMeta"); - EXPECT_EQ(storeFile.privateMeta.stdString(), "privateMeta"); - } else { - FAIL(); - } - } else { - FAIL(); - } + eventQueue.waitEvent(); + storeApi->subscribeFor({ + storeApi->buildSubscriptionQuery( + store::EventType::FILE_CREATE, + store::EventSelectorType::STORE_ID, + reader->getString("Store_1.storeId") + ) + }); + int64_t handle = storeApi->createFile( + reader->getString("Store_1.storeId"), + privmx::endpoint::core::Buffer::from("publicMeta"), + privmx::endpoint::core::Buffer::from("privateMeta"), + 0 + ); + ASSERT_EQ(handle, 1) << "storeFileCreate Failed"; + std::string fileId = storeApi->closeFile(handle); + ASSERT_FALSE(fileId.empty()) << "storeFileClose Failed"; + auto eventHolder = waitForEvent("storeFileCreated", {connection->getConnectionId()}); + ASSERT_TRUE(eventHolder.has_value()); + auto event = eventHolder.value().get(); + ASSERT_NE(event, nullptr); + EXPECT_EQ(event->connectionId, connection->getConnectionId()); + EXPECT_EQ(event->type, "storeFileCreated"); + EXPECT_EQ(event->channel, "store/" + reader->getString("Store_1.storeId") + "/files"); + ASSERT_TRUE(store::Events::isStoreFileCreatedEvent(event)); + EXPECT_EQ(event->subscriptions.size(), 1); + store::File storeFile = store::Events::extractStoreFileCreatedEvent(event).data; + EXPECT_EQ(storeFile.info.storeId, reader->getString("Store_1.storeId")); + EXPECT_EQ(storeFile.size, 0); + EXPECT_EQ(storeFile.publicMeta.stdString(), "publicMeta"); + EXPECT_EQ(storeFile.privateMeta.stdString(), "privateMeta"); } TEST_F(StoreEventTest, waitEvent_getEvent_storeFileCreated_disabled) { - std::shared_ptr event = nullptr; - EXPECT_NO_THROW({ - eventQueue.waitEvent(); // pop libConnected form queue - }); - EXPECT_NO_THROW({ - auto tmp = storeApi->subscribeFor({ - storeApi->buildSubscriptionQuery( - store::EventType::FILE_CREATE, - store::EventSelectorType::STORE_ID, - reader->getString("Store_1.storeId") - ) - }); - storeApi->unsubscribeFrom(tmp); - }); - int64_t handle; - EXPECT_NO_THROW({ - handle = storeApi->createFile( - reader->getString("Store_1.storeId"), - privmx::endpoint::core::Buffer::from("publicMeta"), - privmx::endpoint::core::Buffer::from("privateMeta"), - 0 - ); - }); - if(handle == 1) { - std::string fileId; - EXPECT_NO_THROW({ - fileId = storeApi->closeFile(handle); - }); - if(fileId.empty()) { - std::cout << "storeFileClose Failed" << std::endl; - FAIL(); - } - } else { - std::cout << "storeFileCreate Failed" << std::endl; - FAIL(); - } - EXPECT_NO_THROW({ - std::this_thread::sleep_for(std::chrono::milliseconds(1500)); - std::optional eventHolder = eventQueue.getEvent(); - if(eventHolder.has_value()) { - event = eventHolder.value().get(); - } else { - event = nullptr; - } - }); - if(event == nullptr) { - - } else { - std::cout << "Received Event with type " << event->type << std::endl; - std::cout << "Expected null" << std::endl; - FAIL(); - } + eventQueue.waitEvent(); + auto tmp = storeApi->subscribeFor({ + storeApi->buildSubscriptionQuery( + store::EventType::FILE_CREATE, + store::EventSelectorType::STORE_ID, + reader->getString("Store_1.storeId") + ) + }); + storeApi->unsubscribeFrom(tmp); + int64_t handle = storeApi->createFile( + reader->getString("Store_1.storeId"), + privmx::endpoint::core::Buffer::from("publicMeta"), + privmx::endpoint::core::Buffer::from("privateMeta"), + 0 + ); + ASSERT_EQ(handle, 1) << "storeFileCreate Failed"; + std::string fileId = storeApi->closeFile(handle); + ASSERT_FALSE(fileId.empty()) << "storeFileClose Failed"; + assertNoEventReceived(); } TEST_F(StoreEventTest, waitEvent_getEvent_storeFileUpdated_enabled) { - std::shared_ptr event = nullptr; - EXPECT_NO_THROW({ - eventQueue.waitEvent(); // pop libConnected form queue - }); - EXPECT_NO_THROW({ - storeApi->subscribeFor({ - storeApi->buildSubscriptionQuery( - store::EventType::FILE_UPDATE, - store::EventSelectorType::FILE_ID, - reader->getString("File_1.info_fileId") - ) - }); - }); - int64_t handle; - EXPECT_NO_THROW({ - handle = storeApi->updateFile( - reader->getString("File_1.info_fileId"), - privmx::endpoint::core::Buffer::from("publicMeta"), - privmx::endpoint::core::Buffer::from("privateMeta"), - 0 - ); - }); - if(handle == 1) { - - std::string fileId; - EXPECT_NO_THROW({ - fileId = storeApi->closeFile(handle); - }); - if(fileId.empty()) { - std::cout << "storeFileClose Failed" << std::endl; - FAIL(); - } - } else { - std::cout << "storeFileCreate Failed" << std::endl; - FAIL(); - } - EXPECT_NO_THROW({ - std::this_thread::sleep_for(std::chrono::milliseconds(1500)); - std::optional eventHolder = eventQueue.getEvent(); - if(eventHolder.has_value()) { - event = eventHolder.value().get(); - } else { - event = nullptr; - } - }); - if(event != nullptr) { - EXPECT_EQ(event->connectionId, connection->getConnectionId()); - EXPECT_EQ(event->type, "storeFileUpdated"); - EXPECT_EQ(event->channel, "store/" + reader->getString("Store_1.storeId") + "/files"); - if(store::Events::isStoreFileUpdatedEvent(event)) { - EXPECT_EQ(event->subscriptions.size(), 1); - store::File storeFile = store::Events::extractStoreFileUpdatedEvent(event).data.file; - EXPECT_EQ(storeFile.info.storeId, reader->getString("Store_1.storeId")); - EXPECT_EQ(storeFile.size, 0); - EXPECT_EQ(storeFile.publicMeta.stdString(), "publicMeta"); - EXPECT_EQ(storeFile.privateMeta.stdString(), "privateMeta"); - } else { - FAIL(); - } - } else { - FAIL(); - } + eventQueue.waitEvent(); + storeApi->subscribeFor({ + storeApi->buildSubscriptionQuery( + store::EventType::FILE_UPDATE, + store::EventSelectorType::FILE_ID, + reader->getString("File_1.info_fileId") + ) + }); + int64_t handle = storeApi->updateFile( + reader->getString("File_1.info_fileId"), + privmx::endpoint::core::Buffer::from("publicMeta"), + privmx::endpoint::core::Buffer::from("privateMeta"), + 0 + ); + ASSERT_EQ(handle, 1) << "storeFileCreate Failed"; + std::string fileId = storeApi->closeFile(handle); + ASSERT_FALSE(fileId.empty()) << "storeFileClose Failed"; + auto eventHolder = waitForEvent("storeFileUpdated", {connection->getConnectionId()}); + ASSERT_TRUE(eventHolder.has_value()); + auto event = eventHolder.value().get(); + ASSERT_NE(event, nullptr); + EXPECT_EQ(event->connectionId, connection->getConnectionId()); + EXPECT_EQ(event->type, "storeFileUpdated"); + EXPECT_EQ(event->channel, "store/" + reader->getString("Store_1.storeId") + "/files"); + ASSERT_TRUE(store::Events::isStoreFileUpdatedEvent(event)); + EXPECT_EQ(event->subscriptions.size(), 1); + store::File storeFile = store::Events::extractStoreFileUpdatedEvent(event).data.file; + EXPECT_EQ(storeFile.info.storeId, reader->getString("Store_1.storeId")); + EXPECT_EQ(storeFile.size, 0); + EXPECT_EQ(storeFile.publicMeta.stdString(), "publicMeta"); + EXPECT_EQ(storeFile.privateMeta.stdString(), "privateMeta"); } TEST_F(StoreEventTest, waitEvent_getEvent_storeFileUpdated_disabled) { - std::shared_ptr event = nullptr; - EXPECT_NO_THROW({ - eventQueue.waitEvent(); // pop libConnected form queue - }); - EXPECT_NO_THROW({ - auto tmp = storeApi->subscribeFor({ - storeApi->buildSubscriptionQuery( - store::EventType::FILE_UPDATE, - store::EventSelectorType::FILE_ID, - reader->getString("File_1.info_fileId") - ) - }); - storeApi->unsubscribeFrom(tmp); - }); - int64_t handle; - EXPECT_NO_THROW({ - handle = storeApi->updateFile( - reader->getString("File_1.info_fileId"), - privmx::endpoint::core::Buffer::from("publicMeta"), - privmx::endpoint::core::Buffer::from("privateMeta"), - 0 - ); - }); - if(handle == 1) { - - std::string fileId; - EXPECT_NO_THROW({ - fileId = storeApi->closeFile(handle); - }); - if(fileId.empty()) { - std::cout << "storeFileClose Failed" << std::endl; - FAIL(); - } - } else { - std::cout << "storeFileCreate Failed" << std::endl; - FAIL(); - } - EXPECT_NO_THROW({ - std::this_thread::sleep_for(std::chrono::milliseconds(1500)); - std::optional eventHolder = eventQueue.getEvent(); - if(eventHolder.has_value()) { - event = eventHolder.value().get(); - } else { - event = nullptr; - } - }); - if(event == nullptr) { - - } else { - std::cout << "Received Event with type " << event->type << std::endl; - std::cout << "Expected null" << std::endl; - FAIL(); - } + eventQueue.waitEvent(); + auto tmp = storeApi->subscribeFor({ + storeApi->buildSubscriptionQuery( + store::EventType::FILE_UPDATE, + store::EventSelectorType::FILE_ID, + reader->getString("File_1.info_fileId") + ) + }); + storeApi->unsubscribeFrom(tmp); + int64_t handle = storeApi->updateFile( + reader->getString("File_1.info_fileId"), + privmx::endpoint::core::Buffer::from("publicMeta"), + privmx::endpoint::core::Buffer::from("privateMeta"), + 0 + ); + ASSERT_EQ(handle, 1) << "storeFileCreate Failed"; + std::string fileId = storeApi->closeFile(handle); + ASSERT_FALSE(fileId.empty()) << "storeFileClose Failed"; + assertNoEventReceived(); } TEST_F(StoreEventTest, waitEvent_getEvent_storeFileDeleted_enabled) { - std::shared_ptr event = nullptr; - EXPECT_NO_THROW({ - eventQueue.waitEvent(); // pop libConnected form queue - }); - EXPECT_NO_THROW({ - storeApi->subscribeFor({ - storeApi->buildSubscriptionQuery( - store::EventType::FILE_DELETE, - store::EventSelectorType::STORE_ID, - reader->getString("Store_1.storeId") - ) - }); - }); - EXPECT_NO_THROW({ - storeApi->deleteFile( - reader->getString("File_1.info_fileId") - ); - }); - EXPECT_NO_THROW({ - std::this_thread::sleep_for(std::chrono::milliseconds(1500)); - std::optional eventHolder = eventQueue.getEvent(); - if(eventHolder.has_value()) { - event = eventHolder.value().get(); - } else { - event = nullptr; - } - }); - if(event != nullptr) { - EXPECT_EQ(event->connectionId, connection->getConnectionId()); - EXPECT_EQ(event->type, "storeFileDeleted"); - EXPECT_EQ(event->channel, "store/" + reader->getString("Store_1.storeId") + "/files"); - if(store::Events::isStoreFileDeletedEvent(event)) { - EXPECT_EQ(event->subscriptions.size(), 1); - store::StoreFileDeletedEventData storeFileDeleted = store::Events::extractStoreFileDeletedEvent(event).data; - EXPECT_EQ(storeFileDeleted.fileId, reader->getString("File_1.info_fileId")); - EXPECT_EQ(storeFileDeleted.storeId, reader->getString("File_1.info_storeId")); - EXPECT_EQ(storeFileDeleted.contextId, reader->getString("Context_1.contextId")); - } else { - FAIL(); - } - } else { - FAIL(); - } + eventQueue.waitEvent(); + storeApi->subscribeFor({ + storeApi->buildSubscriptionQuery( + store::EventType::FILE_DELETE, + store::EventSelectorType::STORE_ID, + reader->getString("Store_1.storeId") + ) + }); + storeApi->deleteFile( + reader->getString("File_1.info_fileId") + ); + auto eventHolder = waitForEvent("storeFileDeleted", {connection->getConnectionId()}); + ASSERT_TRUE(eventHolder.has_value()); + auto event = eventHolder.value().get(); + ASSERT_NE(event, nullptr); + EXPECT_EQ(event->connectionId, connection->getConnectionId()); + EXPECT_EQ(event->type, "storeFileDeleted"); + EXPECT_EQ(event->channel, "store/" + reader->getString("Store_1.storeId") + "/files"); + ASSERT_TRUE(store::Events::isStoreFileDeletedEvent(event)); + EXPECT_EQ(event->subscriptions.size(), 1); + store::StoreFileDeletedEventData storeFileDeleted = store::Events::extractStoreFileDeletedEvent(event).data; + EXPECT_EQ(storeFileDeleted.fileId, reader->getString("File_1.info_fileId")); + EXPECT_EQ(storeFileDeleted.storeId, reader->getString("File_1.info_storeId")); + EXPECT_EQ(storeFileDeleted.contextId, reader->getString("Context_1.contextId")); } TEST_F(StoreEventTest, waitEvent_getEvent_storeFileDeleted_disabled) { - std::shared_ptr event = nullptr; - EXPECT_NO_THROW({ - eventQueue.waitEvent(); // pop libConnected form queue - }); - EXPECT_NO_THROW({ - auto tmp = storeApi->subscribeFor({ - storeApi->buildSubscriptionQuery( - store::EventType::FILE_DELETE, - store::EventSelectorType::STORE_ID, - reader->getString("Store_1.storeId") - ) - }); - storeApi->unsubscribeFrom(tmp); - }); - EXPECT_NO_THROW({ - storeApi->deleteFile( - reader->getString("File_1.info_fileId") - ); - }); - EXPECT_NO_THROW({ - std::this_thread::sleep_for(std::chrono::milliseconds(1500)); - std::optional eventHolder = eventQueue.getEvent(); - if(eventHolder.has_value()) { - event = eventHolder.value().get(); - } else { - event = nullptr; - } + eventQueue.waitEvent(); + auto tmp = storeApi->subscribeFor({ + storeApi->buildSubscriptionQuery( + store::EventType::FILE_DELETE, + store::EventSelectorType::STORE_ID, + reader->getString("Store_1.storeId") + ) }); - if(event == nullptr) { - - } else { - std::cout << "Received Event with type " << event->type << std::endl; - std::cout << "Expected null" << std::endl; - FAIL(); - } + storeApi->unsubscribeFrom(tmp); + storeApi->deleteFile( + reader->getString("File_1.info_fileId") + ); + assertNoEventReceived(); } TEST_F(StoreEventTest, waitEvent_getEvent_storeFileUpdated_changes) { - std::shared_ptr event = nullptr; - EXPECT_NO_THROW({ - eventQueue.waitEvent(); // pop libConnected form queue - }); - EXPECT_NO_THROW({ - storeApi->subscribeFor({ - storeApi->buildSubscriptionQuery( - store::EventType::FILE_UPDATE, - store::EventSelectorType::STORE_ID, - reader->getString("Store_1.storeId") - ) - }); - }); - std::string fileId; - - EXPECT_NO_THROW({ - auto writeHandle = storeApi->createFile(reader->getString("Store_1.storeId"), core::Buffer::from("pub"), core::Buffer::from("priv"), 2*128*1024, true); - storeApi->writeToFile(writeHandle, core::Buffer::from(std::string(2*128*1024, 'H'))); - fileId = storeApi->closeFile(writeHandle); - auto RWHandle = storeApi->openFile(fileId); - storeApi->seekInFile(RWHandle, 128*1024); - storeApi->writeToFile(RWHandle, core::Buffer::from(std::string(64*1024, 'J')), true); - storeApi->closeFile(RWHandle); - }); - EXPECT_NO_THROW({ - std::this_thread::sleep_for(std::chrono::milliseconds(1500)); - std::optional eventHolder = eventQueue.getEvent(); - if(eventHolder.has_value()) { - event = eventHolder.value().get(); - } else { - event = nullptr; - } - }); - if(event != nullptr) { - EXPECT_EQ(event->connectionId, connection->getConnectionId()); - EXPECT_EQ(event->type, "storeFileUpdated"); - EXPECT_EQ(event->channel, "store/" + reader->getString("Store_1.storeId") + "/files"); - if(store::Events::isStoreFileUpdatedEvent(event)) { - EXPECT_EQ(event->subscriptions.size(), 1); - auto eventData = store::Events::extractStoreFileUpdatedEvent(event).data; - store::File storeFile = eventData.file; - EXPECT_EQ(storeFile.info.storeId, reader->getString("Store_1.storeId")); - EXPECT_EQ(storeFile.size, (128+64)*1024); - EXPECT_EQ(storeFile.publicMeta.stdString(), "pub"); - EXPECT_EQ(storeFile.privateMeta.stdString(), "priv"); - EXPECT_EQ(eventData.changes.size(), 1); - if(eventData.changes.size() >= 1) { - auto change = eventData.changes[0]; - EXPECT_EQ(change.pos, 128*1024); - EXPECT_EQ(change.length, 64*1024); - EXPECT_EQ(change.truncate, true); - } else { - FAIL(); - } - } else { - FAIL(); - } - } else { - FAIL(); - } + eventQueue.waitEvent(); + storeApi->subscribeFor({ + storeApi->buildSubscriptionQuery( + store::EventType::FILE_UPDATE, + store::EventSelectorType::STORE_ID, + reader->getString("Store_1.storeId") + ) + }); + auto writeHandle = storeApi->createFile(reader->getString("Store_1.storeId"), core::Buffer::from("pub"), core::Buffer::from("priv"), 2*128*1024, true); + storeApi->writeToFile(writeHandle, core::Buffer::from(std::string(2*128*1024, 'H'))); + std::string fileId = storeApi->closeFile(writeHandle); + auto RWHandle = storeApi->openFile(fileId); + storeApi->seekInFile(RWHandle, 128*1024); + storeApi->writeToFile(RWHandle, core::Buffer::from(std::string(64*1024, 'J')), true); + storeApi->closeFile(RWHandle); + auto eventHolder = waitForEvent("storeFileUpdated", {connection->getConnectionId()}); + ASSERT_TRUE(eventHolder.has_value()); + auto event = eventHolder.value().get(); + ASSERT_NE(event, nullptr); + EXPECT_EQ(event->connectionId, connection->getConnectionId()); + EXPECT_EQ(event->type, "storeFileUpdated"); + EXPECT_EQ(event->channel, "store/" + reader->getString("Store_1.storeId") + "/files"); + ASSERT_TRUE(store::Events::isStoreFileUpdatedEvent(event)); + EXPECT_EQ(event->subscriptions.size(), 1); + auto eventData = store::Events::extractStoreFileUpdatedEvent(event).data; + store::File storeFile = eventData.file; + EXPECT_EQ(storeFile.info.storeId, reader->getString("Store_1.storeId")); + EXPECT_EQ(storeFile.size, (128+64)*1024); + EXPECT_EQ(storeFile.publicMeta.stdString(), "pub"); + EXPECT_EQ(storeFile.privateMeta.stdString(), "priv"); + ASSERT_GE(eventData.changes.size(), 1u); + auto change = eventData.changes[0]; + EXPECT_EQ(change.pos, 128*1024); + EXPECT_EQ(change.length, 64*1024); + EXPECT_EQ(change.truncate, true); } TEST_F(StoreEventTest, subscribeFor_query_from_other_module) { @@ -848,31 +464,31 @@ TEST_F(StoreEventTest, subscribeFor_unsubscribeFor) { std::vector valid_subscriptions; EXPECT_NO_THROW({ valid_subscriptions = storeApi->subscribeFor({ - storeApi->buildSubscriptionQuery( - store::EventType::STORE_CREATE, - store::EventSelectorType::CONTEXT_ID, - reader->getString("Context_1.contextId") + storeApi->buildSubscriptionQuery( + store::EventType::STORE_CREATE, + store::EventSelectorType::CONTEXT_ID, + reader->getString("Context_1.contextId") ) }); }); std::vector invalid_subscriptions; EXPECT_NO_THROW({ invalid_subscriptions = storeApi->subscribeFor({ - storeApi->buildSubscriptionQuery( - store::EventType::STORE_CREATE, - store::EventSelectorType::CONTEXT_ID, - "error" + storeApi->buildSubscriptionQuery( + store::EventType::STORE_CREATE, + store::EventSelectorType::CONTEXT_ID, + "error" ) }); }); EXPECT_NO_THROW({ storeApi->unsubscribeFrom({ - valid_subscriptions + valid_subscriptions }); }); EXPECT_NO_THROW({ storeApi->unsubscribeFrom({ - invalid_subscriptions + invalid_subscriptions }); }); } diff --git a/test/tests/ThreadModuleEventsTest.cpp b/test/tests/ThreadModuleEventsTest.cpp index 6e5549c5..f439de83 100644 --- a/test/tests/ThreadModuleEventsTest.cpp +++ b/test/tests/ThreadModuleEventsTest.cpp @@ -1,722 +1,398 @@ -#include -#include -#include -#include "../utils/BaseTest.hpp" -#include +#include "../utils/BaseEndpointEventTest.hpp" #include #include #include -#include #include #include -#include -#include using namespace privmx::endpoint; -class ThreadEventTest : public privmx::test::BaseTest { +class ThreadEventTest : public privmx::test::BaseEndpointEventTest { protected: - ThreadEventTest() : BaseTest(privmx::test::BaseTestMode::online) {} - void customSetUp() override { - reader = new Poco::Util::IniFileConfiguration(INI_FILE_PATH); - connection = std::make_shared( - core::Connection::connect( - reader->getString("Login.user_1_privKey"), - reader->getString("Login.solutionId"), - getPlatformUrl(reader->getString("Login.instanceUrl")) - ) - ); + void setUpModuleApis() override { threadApi = std::make_shared( - thread::ThreadApi::create( - *connection - ) + thread::ThreadApi::create(*connection) ); } - void customTearDown() override { // tmp segfault fix - connection.reset(); + void tearDownModuleApis() override { threadApi.reset(); - reader.reset(); - privmx::endpoint::core::EventQueueImpl::getInstance()->clear(); } - std::shared_ptr connection; std::shared_ptr threadApi; - core::EventQueue eventQueue = core::EventQueue::getInstance(); - Poco::Util::IniFileConfiguration::Ptr reader; }; TEST_F(ThreadEventTest, waitEvent_getEvent_threadCreated_enabled) { - std::shared_ptr event = nullptr; - EXPECT_NO_THROW({ - eventQueue.waitEvent(); // pop libConnected form queue - }); - EXPECT_NO_THROW({ - threadApi->subscribeFor({ - threadApi->buildSubscriptionQuery( - thread::EventType::THREAD_CREATE, - thread::EventSelectorType::CONTEXT_ID, - reader->getString("Context_1.contextId") - ) - }); - }); - std::string threadId; - EXPECT_NO_THROW({ - threadId = threadApi->createThread( - reader->getString("Context_1.contextId"), - std::vector{core::UserWithPubKey{ - .userId=reader->getString("Login.user_1_id"), - .pubKey=reader->getString("Login.user_1_pubKey") - }}, - std::vector{core::UserWithPubKey{ - .userId=reader->getString("Login.user_1_id"), - .pubKey=reader->getString("Login.user_1_pubKey") - }}, - core::Buffer::from("public"), - core::Buffer::from("private") - ); - }); - EXPECT_NO_THROW({ - std::this_thread::sleep_for(std::chrono::milliseconds(1500)); - std::optional eventHolder = eventQueue.getEvent(); - if(eventHolder.has_value()) { - event = eventHolder.value().get(); - } else { - event = nullptr; - } - }); - if(event != nullptr) { - EXPECT_EQ(event->connectionId, connection->getConnectionId()); - EXPECT_EQ(event->type, "threadCreated"); - EXPECT_EQ(event->channel, "thread"); - if(thread::Events::isThreadCreatedEvent(event)) { - EXPECT_EQ(event->subscriptions.size(), 1); - thread::Thread thread = thread::Events::extractThreadCreatedEvent(event).data; - EXPECT_EQ(thread.contextId, reader->getString("Context_1.contextId")); - EXPECT_EQ(thread.publicMeta.stdString(), "public"); - EXPECT_EQ(thread.privateMeta.stdString(), "private"); - EXPECT_EQ(thread.users.size(), 1); - if(thread.users.size() == 1) { - EXPECT_EQ(thread.users[0], reader->getString("Login.user_1_id")); - } - EXPECT_EQ(thread.managers.size(), 1); - if(thread.managers.size() == 1) { - EXPECT_EQ(thread.managers[0], reader->getString("Login.user_1_id")); - } - } else { - FAIL(); - } - } else { - FAIL(); + eventQueue.waitEvent(); + threadApi->subscribeFor({ + threadApi->buildSubscriptionQuery( + thread::EventType::THREAD_CREATE, + thread::EventSelectorType::CONTEXT_ID, + reader->getString("Context_1.contextId") + ) + }); + threadApi->createThread( + reader->getString("Context_1.contextId"), + std::vector{core::UserWithPubKey{ + .userId=reader->getString("Login.user_1_id"), + .pubKey=reader->getString("Login.user_1_pubKey") + }}, + std::vector{core::UserWithPubKey{ + .userId=reader->getString("Login.user_1_id"), + .pubKey=reader->getString("Login.user_1_pubKey") + }}, + core::Buffer::from("public"), + core::Buffer::from("private") + ); + auto eventHolder = waitForEvent("threadCreated", {connection->getConnectionId()}); + ASSERT_TRUE(eventHolder.has_value()); + auto event = eventHolder.value().get(); + ASSERT_NE(event, nullptr); + EXPECT_EQ(event->connectionId, connection->getConnectionId()); + EXPECT_EQ(event->type, "threadCreated"); + EXPECT_EQ(event->channel, "thread"); + ASSERT_TRUE(thread::Events::isThreadCreatedEvent(event)); + EXPECT_EQ(event->subscriptions.size(), 1); + thread::Thread thread = thread::Events::extractThreadCreatedEvent(event).data; + EXPECT_EQ(thread.contextId, reader->getString("Context_1.contextId")); + EXPECT_EQ(thread.publicMeta.stdString(), "public"); + EXPECT_EQ(thread.privateMeta.stdString(), "private"); + EXPECT_EQ(thread.users.size(), 1); + if(thread.users.size() == 1) { + EXPECT_EQ(thread.users[0], reader->getString("Login.user_1_id")); + } + EXPECT_EQ(thread.managers.size(), 1); + if(thread.managers.size() == 1) { + EXPECT_EQ(thread.managers[0], reader->getString("Login.user_1_id")); } } TEST_F(ThreadEventTest, waitEvent_getEvent_threadCreated_disabled) { - std::shared_ptr event = nullptr; - EXPECT_NO_THROW({ - eventQueue.waitEvent(); // pop libConnected form queue - }); - EXPECT_NO_THROW({ - auto tmp = threadApi->subscribeFor({ - threadApi->buildSubscriptionQuery( - thread::EventType::THREAD_CREATE, - thread::EventSelectorType::CONTEXT_ID, - reader->getString("Context_1.contextId") - ) - }); - threadApi->unsubscribeFrom(tmp); - }); - - std::string threadId; - EXPECT_NO_THROW({ - threadId = threadApi->createThread( - reader->getString("Context_1.contextId"), - std::vector{core::UserWithPubKey{ - .userId=reader->getString("Login.user_1_id"), - .pubKey=reader->getString("Login.user_1_pubKey") - }}, - std::vector{core::UserWithPubKey{ - .userId=reader->getString("Login.user_1_id"), - .pubKey=reader->getString("Login.user_1_pubKey") - }}, - core::Buffer::from("public"), - core::Buffer::from("private") - ); - }); - EXPECT_NO_THROW({ - std::this_thread::sleep_for(std::chrono::milliseconds(1500)); - std::optional eventHolder = eventQueue.getEvent(); - if(eventHolder.has_value()) { - event = eventHolder.value().get(); - } else { - event = nullptr; - } - }); - if(event == nullptr) { - - } else { - std::cout << "Received Event with type " << event->type << std::endl; - std::cout << "Expected null" << std::endl; - FAIL(); - } + eventQueue.waitEvent(); + auto tmp = threadApi->subscribeFor({ + threadApi->buildSubscriptionQuery( + thread::EventType::THREAD_CREATE, + thread::EventSelectorType::CONTEXT_ID, + reader->getString("Context_1.contextId") + ) + }); + threadApi->unsubscribeFrom(tmp); + threadApi->createThread( + reader->getString("Context_1.contextId"), + std::vector{core::UserWithPubKey{ + .userId=reader->getString("Login.user_1_id"), + .pubKey=reader->getString("Login.user_1_pubKey") + }}, + std::vector{core::UserWithPubKey{ + .userId=reader->getString("Login.user_1_id"), + .pubKey=reader->getString("Login.user_1_pubKey") + }}, + core::Buffer::from("public"), + core::Buffer::from("private") + ); + assertNoEventReceived(); } TEST_F(ThreadEventTest, waitEvent_getEvent_threadUpdated_enabled) { - std::shared_ptr event = nullptr; - EXPECT_NO_THROW({ - eventQueue.waitEvent(); // pop libConnected form queue - }); - EXPECT_NO_THROW({ - threadApi->subscribeFor({ - threadApi->buildSubscriptionQuery( - thread::EventType::THREAD_UPDATE, - thread::EventSelectorType::CONTEXT_ID, - reader->getString("Context_1.contextId") - ) - }); - }); - - - EXPECT_NO_THROW({ - threadApi->updateThread( - reader->getString("Thread_1.threadId"), - std::vector{core::UserWithPubKey{ - .userId=reader->getString("Login.user_1_id"), - .pubKey=reader->getString("Login.user_1_pubKey") - }}, - std::vector{core::UserWithPubKey{ - .userId=reader->getString("Login.user_1_id"), - .pubKey=reader->getString("Login.user_1_pubKey") - }}, - core::Buffer::from("public"), - core::Buffer::from("private"), - 1, - true, - true - ); - }); - EXPECT_NO_THROW({ - std::this_thread::sleep_for(std::chrono::milliseconds(1500)); - std::optional eventHolder = eventQueue.getEvent(); - if(eventHolder.has_value()) { - event = eventHolder.value().get(); - } else { - event = nullptr; - } - }); - if(event != nullptr) { - EXPECT_EQ(event->connectionId, connection->getConnectionId()); - EXPECT_EQ(event->type, "threadUpdated"); - EXPECT_EQ(event->channel, "thread"); - if(thread::Events::isThreadUpdatedEvent(event)) { - EXPECT_EQ(event->subscriptions.size(), 1); - thread::Thread thread = thread::Events::extractThreadUpdatedEvent(event).data; - EXPECT_EQ(thread.contextId, reader->getString("Context_1.contextId")); - EXPECT_EQ(thread.publicMeta.stdString(), "public"); - EXPECT_EQ(thread.privateMeta.stdString(), "private"); - EXPECT_EQ(thread.users.size(), 1); - if(thread.users.size() == 1) { - EXPECT_EQ(thread.users[0], reader->getString("Login.user_1_id")); - } - EXPECT_EQ(thread.managers.size(), 1); - if(thread.managers.size() == 1) { - EXPECT_EQ(thread.managers[0], reader->getString("Login.user_1_id")); - } - } else { - FAIL(); - } - } else { - FAIL(); + eventQueue.waitEvent(); + threadApi->subscribeFor({ + threadApi->buildSubscriptionQuery( + thread::EventType::THREAD_UPDATE, + thread::EventSelectorType::CONTEXT_ID, + reader->getString("Context_1.contextId") + ) + }); + threadApi->updateThread( + reader->getString("Thread_1.threadId"), + std::vector{core::UserWithPubKey{ + .userId=reader->getString("Login.user_1_id"), + .pubKey=reader->getString("Login.user_1_pubKey") + }}, + std::vector{core::UserWithPubKey{ + .userId=reader->getString("Login.user_1_id"), + .pubKey=reader->getString("Login.user_1_pubKey") + }}, + core::Buffer::from("public"), + core::Buffer::from("private"), + 1, + true, + true + ); + auto eventHolder = waitForEvent("threadUpdated", {connection->getConnectionId()}); + ASSERT_TRUE(eventHolder.has_value()); + auto event = eventHolder.value().get(); + ASSERT_NE(event, nullptr); + EXPECT_EQ(event->connectionId, connection->getConnectionId()); + EXPECT_EQ(event->type, "threadUpdated"); + EXPECT_EQ(event->channel, "thread"); + ASSERT_TRUE(thread::Events::isThreadUpdatedEvent(event)); + EXPECT_EQ(event->subscriptions.size(), 1); + thread::Thread thread = thread::Events::extractThreadUpdatedEvent(event).data; + EXPECT_EQ(thread.contextId, reader->getString("Context_1.contextId")); + EXPECT_EQ(thread.publicMeta.stdString(), "public"); + EXPECT_EQ(thread.privateMeta.stdString(), "private"); + EXPECT_EQ(thread.users.size(), 1); + if(thread.users.size() == 1) { + EXPECT_EQ(thread.users[0], reader->getString("Login.user_1_id")); + } + EXPECT_EQ(thread.managers.size(), 1); + if(thread.managers.size() == 1) { + EXPECT_EQ(thread.managers[0], reader->getString("Login.user_1_id")); } } TEST_F(ThreadEventTest, waitEvent_getEvent_threadUpdated_disabled) { - std::shared_ptr event = nullptr; - EXPECT_NO_THROW({ - eventQueue.waitEvent(); // pop libConnected form queue - }); - EXPECT_NO_THROW({ - auto tmp = threadApi->subscribeFor({ - threadApi->buildSubscriptionQuery( - thread::EventType::THREAD_UPDATE, - thread::EventSelectorType::CONTEXT_ID, - reader->getString("Context_1.contextId") - ) - }); - threadApi->unsubscribeFrom(tmp); - }); - - EXPECT_NO_THROW({ - threadApi->updateThread( - reader->getString("Thread_1.threadId"), - std::vector{core::UserWithPubKey{ - .userId=reader->getString("Login.user_1_id"), - .pubKey=reader->getString("Login.user_1_pubKey") - }}, - std::vector{core::UserWithPubKey{ - .userId=reader->getString("Login.user_1_id"), - .pubKey=reader->getString("Login.user_1_pubKey") - }}, - core::Buffer::from("public"), - core::Buffer::from("private"), - 1, - true, - true - ); - }); - EXPECT_NO_THROW({ - std::this_thread::sleep_for(std::chrono::milliseconds(1500)); - std::optional eventHolder = eventQueue.getEvent(); - if(eventHolder.has_value()) { - event = eventHolder.value().get(); - } else { - event = nullptr; - } - }); - if(event == nullptr) { - - } else { - std::cout << "Received Event with type " << event->type << std::endl; - std::cout << "Expected null" << std::endl; - FAIL(); - } + eventQueue.waitEvent(); + auto tmp = threadApi->subscribeFor({ + threadApi->buildSubscriptionQuery( + thread::EventType::THREAD_UPDATE, + thread::EventSelectorType::CONTEXT_ID, + reader->getString("Context_1.contextId") + ) + }); + threadApi->unsubscribeFrom(tmp); + threadApi->updateThread( + reader->getString("Thread_1.threadId"), + std::vector{core::UserWithPubKey{ + .userId=reader->getString("Login.user_1_id"), + .pubKey=reader->getString("Login.user_1_pubKey") + }}, + std::vector{core::UserWithPubKey{ + .userId=reader->getString("Login.user_1_id"), + .pubKey=reader->getString("Login.user_1_pubKey") + }}, + core::Buffer::from("public"), + core::Buffer::from("private"), + 1, + true, + true + ); + assertNoEventReceived(); } TEST_F(ThreadEventTest, waitEvent_getEvent_threadDeleted_enabled) { - std::shared_ptr event = nullptr; - EXPECT_NO_THROW({ - eventQueue.waitEvent(); // pop libConnected form queue - }); - EXPECT_NO_THROW({ - threadApi->subscribeFor({ - threadApi->buildSubscriptionQuery( - thread::EventType::THREAD_DELETE, - thread::EventSelectorType::CONTEXT_ID, - reader->getString("Context_1.contextId") - ) - }); - }); - - EXPECT_NO_THROW({ - threadApi->deleteThread( - reader->getString("Thread_1.threadId") - ); - }); - EXPECT_NO_THROW({ - std::this_thread::sleep_for(std::chrono::milliseconds(1500)); - std::optional eventHolder = eventQueue.getEvent(); - if(eventHolder.has_value()) { - event = eventHolder.value().get(); - } else { - event = nullptr; - } - }); - if(event != nullptr) { - EXPECT_EQ(event->connectionId, connection->getConnectionId()); - EXPECT_EQ(event->type, "threadDeleted"); - EXPECT_EQ(event->channel, "thread"); - if(thread::Events::isThreadDeletedEvent(event)) { - EXPECT_EQ(event->subscriptions.size(), 1); - thread::ThreadDeletedEventData threadDeleted = thread::Events::extractThreadDeletedEvent(event).data; - EXPECT_EQ(threadDeleted.threadId, reader->getString("Thread_1.threadId")); - } else { - FAIL(); - } - } else { - FAIL(); - } + eventQueue.waitEvent(); + threadApi->subscribeFor({ + threadApi->buildSubscriptionQuery( + thread::EventType::THREAD_DELETE, + thread::EventSelectorType::CONTEXT_ID, + reader->getString("Context_1.contextId") + ) + }); + threadApi->deleteThread( + reader->getString("Thread_1.threadId") + ); + auto eventHolder = waitForEvent("threadDeleted", {connection->getConnectionId()}); + ASSERT_TRUE(eventHolder.has_value()); + auto event = eventHolder.value().get(); + ASSERT_NE(event, nullptr); + EXPECT_EQ(event->connectionId, connection->getConnectionId()); + EXPECT_EQ(event->type, "threadDeleted"); + EXPECT_EQ(event->channel, "thread"); + ASSERT_TRUE(thread::Events::isThreadDeletedEvent(event)); + EXPECT_EQ(event->subscriptions.size(), 1); + thread::ThreadDeletedEventData threadDeleted = thread::Events::extractThreadDeletedEvent(event).data; + EXPECT_EQ(threadDeleted.threadId, reader->getString("Thread_1.threadId")); } TEST_F(ThreadEventTest, waitEvent_getEvent_threadDeleted_disabled) { - std::shared_ptr event = nullptr; - EXPECT_NO_THROW({ - eventQueue.waitEvent(); // pop libConnected form queue - }); - EXPECT_NO_THROW({ - auto tmp = threadApi->subscribeFor({ - threadApi->buildSubscriptionQuery( - thread::EventType::THREAD_DELETE, - thread::EventSelectorType::CONTEXT_ID, - reader->getString("Context_1.contextId") - ) - }); - threadApi->unsubscribeFrom(tmp); - }); - - EXPECT_NO_THROW({ - threadApi->deleteThread( - reader->getString("Thread_1.threadId") - ); - }); - EXPECT_NO_THROW({ - std::this_thread::sleep_for(std::chrono::milliseconds(1500)); - std::optional eventHolder = eventQueue.getEvent(); - if(eventHolder.has_value()) { - event = eventHolder.value().get(); - } else { - event = nullptr; - } - }); - if(event == nullptr) { - - } else { - std::cout << "Received Event with type " << event->type << std::endl; - std::cout << "Expected null" << std::endl; - FAIL(); - } + eventQueue.waitEvent(); + auto tmp = threadApi->subscribeFor({ + threadApi->buildSubscriptionQuery( + thread::EventType::THREAD_DELETE, + thread::EventSelectorType::CONTEXT_ID, + reader->getString("Context_1.contextId") + ) + }); + threadApi->unsubscribeFrom(tmp); + threadApi->deleteThread( + reader->getString("Thread_1.threadId") + ); + assertNoEventReceived(); } TEST_F(ThreadEventTest, waitEvent_getEvent_threadStats_enabled) { - std::shared_ptr event = nullptr; - EXPECT_NO_THROW({ - eventQueue.waitEvent(); // pop libConnected form queue - }); - EXPECT_NO_THROW({ - threadApi->subscribeFor({ - threadApi->buildSubscriptionQuery( - thread::EventType::THREAD_STATS, - thread::EventSelectorType::CONTEXT_ID, - reader->getString("Context_1.contextId") - ) - }); - }); - - EXPECT_NO_THROW({ - threadApi->deleteMessage( - reader->getString("Message_1.info_messageId") - ); - }); - EXPECT_NO_THROW({ - std::this_thread::sleep_for(std::chrono::milliseconds(1500)); - std::optional eventHolder = eventQueue.getEvent(); - if(eventHolder.has_value()) { - event = eventHolder.value().get(); - } else { - event = nullptr; - } - }); - if(event != nullptr) { - EXPECT_EQ(event->connectionId, connection->getConnectionId()); - EXPECT_EQ(event->type, "threadStatsChanged"); - EXPECT_EQ(event->channel, "thread"); - if(thread::Events::isThreadStatsEvent(event)) { - EXPECT_EQ(event->subscriptions.size(), 1); - thread::ThreadStatsEventData threadStat = thread::Events::extractThreadStatsEvent(event).data; - EXPECT_EQ(threadStat.threadId, reader->getString("Thread_1.threadId")); - EXPECT_EQ(threadStat.messagesCount, 1); - } else { - FAIL(); - } - } else { - FAIL(); - } + eventQueue.waitEvent(); + threadApi->subscribeFor({ + threadApi->buildSubscriptionQuery( + thread::EventType::THREAD_STATS, + thread::EventSelectorType::CONTEXT_ID, + reader->getString("Context_1.contextId") + ) + }); + threadApi->deleteMessage( + reader->getString("Message_1.info_messageId") + ); + auto eventHolder = waitForEvent("threadStatsChanged", {connection->getConnectionId()}); + ASSERT_TRUE(eventHolder.has_value()); + auto event = eventHolder.value().get(); + ASSERT_NE(event, nullptr); + EXPECT_EQ(event->connectionId, connection->getConnectionId()); + EXPECT_EQ(event->type, "threadStatsChanged"); + EXPECT_EQ(event->channel, "thread"); + ASSERT_TRUE(thread::Events::isThreadStatsEvent(event)); + EXPECT_EQ(event->subscriptions.size(), 1); + thread::ThreadStatsEventData threadStat = thread::Events::extractThreadStatsEvent(event).data; + EXPECT_EQ(threadStat.threadId, reader->getString("Thread_1.threadId")); + EXPECT_EQ(threadStat.messagesCount, 1); } TEST_F(ThreadEventTest, waitEvent_getEvent_threadStats_disabled) { - std::shared_ptr event = nullptr; - EXPECT_NO_THROW({ - eventQueue.waitEvent(); // pop libConnected form queue - }); - EXPECT_NO_THROW({ - auto tmp = threadApi->subscribeFor({ - threadApi->buildSubscriptionQuery( - thread::EventType::THREAD_STATS, - thread::EventSelectorType::CONTEXT_ID, - reader->getString("Context_1.contextId") - ) - }); - threadApi->unsubscribeFrom(tmp); - }); - - EXPECT_NO_THROW({ - threadApi->deleteMessage( - reader->getString("Message_1.info_messageId") - ); - }); - EXPECT_NO_THROW({ - std::this_thread::sleep_for(std::chrono::milliseconds(1500)); - std::optional eventHolder = eventQueue.getEvent(); - if(eventHolder.has_value()) { - event = eventHolder.value().get(); - } else { - event = nullptr; - } - }); - if(event == nullptr) { - - } else { - std::cout << "Received Event with type " << event->type << std::endl; - std::cout << "Expected null" << std::endl; - FAIL(); - } + eventQueue.waitEvent(); + auto tmp = threadApi->subscribeFor({ + threadApi->buildSubscriptionQuery( + thread::EventType::THREAD_STATS, + thread::EventSelectorType::CONTEXT_ID, + reader->getString("Context_1.contextId") + ) + }); + threadApi->unsubscribeFrom(tmp); + threadApi->deleteMessage( + reader->getString("Message_1.info_messageId") + ); + assertNoEventReceived(); } TEST_F(ThreadEventTest, waitEvent_getEvent_threadNewMessage_enabled) { - std::shared_ptr event = nullptr; - EXPECT_NO_THROW({ - eventQueue.waitEvent(); // pop libConnected form queue - }); - EXPECT_NO_THROW({ - threadApi->subscribeFor({ - threadApi->buildSubscriptionQuery( - thread::EventType::MESSAGE_CREATE, - thread::EventSelectorType::THREAD_ID, - reader->getString("Thread_1.threadId") - ) - }); - }); - std::string messageId; - EXPECT_NO_THROW({ - messageId = threadApi->sendMessage( - reader->getString("Thread_1.threadId"), - core::Buffer::from("publicMeta"), - core::Buffer::from("privateMeta"), - core::Buffer::from("data") - ); - }); - EXPECT_NO_THROW({ - std::this_thread::sleep_for(std::chrono::milliseconds(1500)); - std::optional eventHolder = eventQueue.getEvent(); - if(eventHolder.has_value()) { - event = eventHolder.value().get(); - } else { - event = nullptr; - } - }); - if(event != nullptr) { - EXPECT_EQ(event->connectionId, connection->getConnectionId()); - EXPECT_EQ(event->type, "threadNewMessage"); - EXPECT_EQ(event->channel, "thread/"+reader->getString("Thread_1.threadId")+"/messages"); - if(thread::Events::isThreadNewMessageEvent(event)) { - EXPECT_EQ(event->subscriptions.size(), 1); - thread::Message message = thread::Events::extractThreadNewMessageEvent(event).data; - EXPECT_EQ(message.publicMeta.stdString(), "publicMeta"); - EXPECT_EQ(message.privateMeta.stdString(), "privateMeta"); - EXPECT_EQ(message.data.stdString(), "data"); - EXPECT_EQ(message.info.threadId, reader->getString("Thread_1.threadId")); - } else { - FAIL(); - } - } else { - FAIL(); - } + eventQueue.waitEvent(); + threadApi->subscribeFor({ + threadApi->buildSubscriptionQuery( + thread::EventType::MESSAGE_CREATE, + thread::EventSelectorType::THREAD_ID, + reader->getString("Thread_1.threadId") + ) + }); + threadApi->sendMessage( + reader->getString("Thread_1.threadId"), + core::Buffer::from("publicMeta"), + core::Buffer::from("privateMeta"), + core::Buffer::from("data") + ); + auto eventHolder = waitForEvent("threadNewMessage", {connection->getConnectionId()}); + ASSERT_TRUE(eventHolder.has_value()); + auto event = eventHolder.value().get(); + ASSERT_NE(event, nullptr); + EXPECT_EQ(event->connectionId, connection->getConnectionId()); + EXPECT_EQ(event->type, "threadNewMessage"); + EXPECT_EQ(event->channel, "thread/"+reader->getString("Thread_1.threadId")+"/messages"); + ASSERT_TRUE(thread::Events::isThreadNewMessageEvent(event)); + EXPECT_EQ(event->subscriptions.size(), 1); + thread::Message message = thread::Events::extractThreadNewMessageEvent(event).data; + EXPECT_EQ(message.publicMeta.stdString(), "publicMeta"); + EXPECT_EQ(message.privateMeta.stdString(), "privateMeta"); + EXPECT_EQ(message.data.stdString(), "data"); + EXPECT_EQ(message.info.threadId, reader->getString("Thread_1.threadId")); } TEST_F(ThreadEventTest, waitEvent_getEvent_threadNewMessage_disabled) { - std::shared_ptr event = nullptr; - EXPECT_NO_THROW({ - eventQueue.waitEvent(); // pop libConnected form queue - }); - EXPECT_NO_THROW({ - auto tmp = threadApi->subscribeFor({ - threadApi->buildSubscriptionQuery( - thread::EventType::MESSAGE_CREATE, - thread::EventSelectorType::THREAD_ID, - reader->getString("Thread_1.threadId") - ) - }); - threadApi->unsubscribeFrom(tmp); - }); - std::string messageId; - EXPECT_NO_THROW({ - messageId = threadApi->sendMessage( - reader->getString("Thread_1.threadId"), - core::Buffer::from("publicMeta"), - core::Buffer::from("privateMeta"), - core::Buffer::from("data") - ); - }); - EXPECT_NO_THROW({ - std::this_thread::sleep_for(std::chrono::milliseconds(1500)); - std::optional eventHolder = eventQueue.getEvent(); - if(eventHolder.has_value()) { - event = eventHolder.value().get(); - } else { - event = nullptr; - } - }); - if(event == nullptr) { - - } else { - std::cout << "Received Event with type " << event->type << std::endl; - std::cout << "Expected null" << std::endl; - FAIL(); - } + eventQueue.waitEvent(); + auto tmp = threadApi->subscribeFor({ + threadApi->buildSubscriptionQuery( + thread::EventType::MESSAGE_CREATE, + thread::EventSelectorType::THREAD_ID, + reader->getString("Thread_1.threadId") + ) + }); + threadApi->unsubscribeFrom(tmp); + threadApi->sendMessage( + reader->getString("Thread_1.threadId"), + core::Buffer::from("publicMeta"), + core::Buffer::from("privateMeta"), + core::Buffer::from("data") + ); + assertNoEventReceived(); } TEST_F(ThreadEventTest, waitEvent_getEvent_threadUpdatedMessage_enabled) { - std::shared_ptr event = nullptr; - EXPECT_NO_THROW({ - eventQueue.waitEvent(); // pop libConnected form queue - }); - EXPECT_NO_THROW({ - threadApi->subscribeFor({ - threadApi->buildSubscriptionQuery( - thread::EventType::MESSAGE_UPDATE, - thread::EventSelectorType::THREAD_ID, - reader->getString("Thread_1.threadId") - ) - }); - }); - EXPECT_NO_THROW({ - threadApi->updateMessage( - reader->getString("Message_1.info_messageId"), - core::Buffer::from("publicMeta"), - core::Buffer::from("privateMeta"), - core::Buffer::from("data") - ); - }); - EXPECT_NO_THROW({ - std::this_thread::sleep_for(std::chrono::milliseconds(1500)); - std::optional eventHolder = eventQueue.getEvent(); - if(eventHolder.has_value()) { - event = eventHolder.value().get(); - } else { - event = nullptr; - } - }); - if(event != nullptr) { - EXPECT_EQ(event->connectionId, connection->getConnectionId()); - EXPECT_EQ(event->type, "threadUpdatedMessage"); - EXPECT_EQ(event->channel, "thread/"+reader->getString("Thread_1.threadId")+"/messages"); - if(thread::Events::isThreadMessageUpdatedEvent(event)) { - EXPECT_EQ(event->subscriptions.size(), 1); - thread::Message message = thread::Events::extractThreadMessageUpdatedEvent(event).data; - EXPECT_EQ(message.info.messageId, reader->getString("Message_1.info_messageId")); - EXPECT_EQ(message.publicMeta.stdString(), "publicMeta"); - EXPECT_EQ(message.privateMeta.stdString(), "privateMeta"); - EXPECT_EQ(message.data.stdString(), "data"); - EXPECT_EQ(message.info.threadId, reader->getString("Thread_1.threadId")); - } else { - FAIL(); - } - } else { - FAIL(); - } + eventQueue.waitEvent(); + threadApi->subscribeFor({ + threadApi->buildSubscriptionQuery( + thread::EventType::MESSAGE_UPDATE, + thread::EventSelectorType::THREAD_ID, + reader->getString("Thread_1.threadId") + ) + }); + threadApi->updateMessage( + reader->getString("Message_1.info_messageId"), + core::Buffer::from("publicMeta"), + core::Buffer::from("privateMeta"), + core::Buffer::from("data") + ); + auto eventHolder = waitForEvent("threadUpdatedMessage", {connection->getConnectionId()}); + ASSERT_TRUE(eventHolder.has_value()); + auto event = eventHolder.value().get(); + ASSERT_NE(event, nullptr); + EXPECT_EQ(event->connectionId, connection->getConnectionId()); + EXPECT_EQ(event->type, "threadUpdatedMessage"); + EXPECT_EQ(event->channel, "thread/"+reader->getString("Thread_1.threadId")+"/messages"); + ASSERT_TRUE(thread::Events::isThreadMessageUpdatedEvent(event)); + EXPECT_EQ(event->subscriptions.size(), 1); + thread::Message message = thread::Events::extractThreadMessageUpdatedEvent(event).data; + EXPECT_EQ(message.info.messageId, reader->getString("Message_1.info_messageId")); + EXPECT_EQ(message.publicMeta.stdString(), "publicMeta"); + EXPECT_EQ(message.privateMeta.stdString(), "privateMeta"); + EXPECT_EQ(message.data.stdString(), "data"); + EXPECT_EQ(message.info.threadId, reader->getString("Thread_1.threadId")); } TEST_F(ThreadEventTest, waitEvent_getEvent_threadUpdatedMessage_disabled) { - std::shared_ptr event = nullptr; - EXPECT_NO_THROW({ - eventQueue.waitEvent(); // pop libConnected form queue - }); - EXPECT_NO_THROW({ - auto tmp = threadApi->subscribeFor({ - threadApi->buildSubscriptionQuery( - thread::EventType::MESSAGE_UPDATE, - thread::EventSelectorType::THREAD_ID, - reader->getString("Thread_1.threadId") - ) - }); - threadApi->unsubscribeFrom(tmp); - }); - EXPECT_NO_THROW({ - threadApi->updateMessage( - reader->getString("Message_1.info_messageId"), - core::Buffer::from("publicMeta"), - core::Buffer::from("privateMeta"), - core::Buffer::from("data") - ); - }); - EXPECT_NO_THROW({ - std::this_thread::sleep_for(std::chrono::milliseconds(1500)); - std::optional eventHolder = eventQueue.getEvent(); - if(eventHolder.has_value()) { - event = eventHolder.value().get(); - } else { - event = nullptr; - } - }); - if(event == nullptr) { - - } else { - std::cout << "Received Event with type " << event->type << std::endl; - std::cout << "Expected null" << std::endl; - FAIL(); - } + eventQueue.waitEvent(); + auto tmp = threadApi->subscribeFor({ + threadApi->buildSubscriptionQuery( + thread::EventType::MESSAGE_UPDATE, + thread::EventSelectorType::THREAD_ID, + reader->getString("Thread_1.threadId") + ) + }); + threadApi->unsubscribeFrom(tmp); + threadApi->updateMessage( + reader->getString("Message_1.info_messageId"), + core::Buffer::from("publicMeta"), + core::Buffer::from("privateMeta"), + core::Buffer::from("data") + ); + assertNoEventReceived(); } TEST_F(ThreadEventTest, waitEvent_getEvent_threadDeletedMessage_enabled) { - std::shared_ptr event = nullptr; - EXPECT_NO_THROW({ - eventQueue.waitEvent(); // pop libConnected form queue - }); - EXPECT_NO_THROW({ - threadApi->subscribeFor({ - threadApi->buildSubscriptionQuery( - thread::EventType::MESSAGE_DELETE, - thread::EventSelectorType::THREAD_ID, - reader->getString("Thread_1.threadId") - ) - }); - }); - EXPECT_NO_THROW({ - threadApi->deleteMessage( - reader->getString("Message_1.info_messageId") - ); - }); - EXPECT_NO_THROW({ - std::this_thread::sleep_for(std::chrono::milliseconds(1500)); - std::optional eventHolder = eventQueue.getEvent(); - if(eventHolder.has_value()) { - event = eventHolder.value().get(); - } else { - event = nullptr; - } - }); - if(event != nullptr) { - EXPECT_EQ(event->connectionId, connection->getConnectionId()); - EXPECT_EQ(event->type, "threadMessageDeleted"); - EXPECT_EQ(event->channel, "thread/"+reader->getString("Thread_1.threadId")+"/messages"); - if(thread::Events::isThreadMessageDeletedEvent(event)) { - EXPECT_EQ(event->subscriptions.size(), 1); - thread::ThreadDeletedMessageEventData threadDeletedMessage = thread::Events::extractThreadMessageDeletedEvent(event).data; - EXPECT_EQ(threadDeletedMessage.messageId, reader->getString("Message_1.info_messageId")); - EXPECT_EQ(threadDeletedMessage.threadId, reader->getString("Thread_1.threadId")); - } else { - FAIL(); - } - } else { - FAIL(); - } + eventQueue.waitEvent(); + threadApi->subscribeFor({ + threadApi->buildSubscriptionQuery( + thread::EventType::MESSAGE_DELETE, + thread::EventSelectorType::THREAD_ID, + reader->getString("Thread_1.threadId") + ) + }); + threadApi->deleteMessage( + reader->getString("Message_1.info_messageId") + ); + auto eventHolder = waitForEvent("threadMessageDeleted", {connection->getConnectionId()}); + ASSERT_TRUE(eventHolder.has_value()); + auto event = eventHolder.value().get(); + ASSERT_NE(event, nullptr); + EXPECT_EQ(event->connectionId, connection->getConnectionId()); + EXPECT_EQ(event->type, "threadMessageDeleted"); + EXPECT_EQ(event->channel, "thread/"+reader->getString("Thread_1.threadId")+"/messages"); + ASSERT_TRUE(thread::Events::isThreadMessageDeletedEvent(event)); + EXPECT_EQ(event->subscriptions.size(), 1); + thread::ThreadDeletedMessageEventData threadDeletedMessage = thread::Events::extractThreadMessageDeletedEvent(event).data; + EXPECT_EQ(threadDeletedMessage.messageId, reader->getString("Message_1.info_messageId")); + EXPECT_EQ(threadDeletedMessage.threadId, reader->getString("Thread_1.threadId")); } TEST_F(ThreadEventTest, waitEvent_getEvent_threadDeletedMessage_disabled) { - std::shared_ptr event = nullptr; - EXPECT_NO_THROW({ - eventQueue.waitEvent(); // pop libConnected form queue - }); - - EXPECT_NO_THROW({ - auto tmp = threadApi->subscribeFor({ - threadApi->buildSubscriptionQuery( - thread::EventType::MESSAGE_DELETE, - thread::EventSelectorType::THREAD_ID, - reader->getString("Thread_1.threadId") - ) - }); - threadApi->unsubscribeFrom(tmp); - }); - EXPECT_NO_THROW({ - threadApi->deleteMessage( - reader->getString("Message_1.info_messageId") - ); - }); - EXPECT_NO_THROW({ - std::this_thread::sleep_for(std::chrono::milliseconds(1500)); - std::optional eventHolder = eventQueue.getEvent(); - if(eventHolder.has_value()) { - event = eventHolder.value().get(); - } else { - event = nullptr; - } + eventQueue.waitEvent(); + auto tmp = threadApi->subscribeFor({ + threadApi->buildSubscriptionQuery( + thread::EventType::MESSAGE_DELETE, + thread::EventSelectorType::THREAD_ID, + reader->getString("Thread_1.threadId") + ) }); - if(event == nullptr) { - - } else { - std::cout << "Received Event with type " << event->type << std::endl; - std::cout << "Expected null" << std::endl; - FAIL(); - } + threadApi->unsubscribeFrom(tmp); + threadApi->deleteMessage( + reader->getString("Message_1.info_messageId") + ); + assertNoEventReceived(); } TEST_F(ThreadEventTest, subscribeFor_query_from_other_module) { @@ -736,31 +412,31 @@ TEST_F(ThreadEventTest, subscribeFor_unsubscribeFor) { std::vector valid_subscriptions; EXPECT_NO_THROW({ valid_subscriptions = threadApi->subscribeFor({ - threadApi->buildSubscriptionQuery( - thread::EventType::THREAD_CREATE, - thread::EventSelectorType::CONTEXT_ID, - reader->getString("Context_1.contextId") + threadApi->buildSubscriptionQuery( + thread::EventType::THREAD_CREATE, + thread::EventSelectorType::CONTEXT_ID, + reader->getString("Context_1.contextId") ) }); }); std::vector invalid_subscriptions; EXPECT_NO_THROW({ invalid_subscriptions = threadApi->subscribeFor({ - threadApi->buildSubscriptionQuery( - thread::EventType::THREAD_CREATE, - thread::EventSelectorType::CONTEXT_ID, + threadApi->buildSubscriptionQuery( + thread::EventType::THREAD_CREATE, + thread::EventSelectorType::CONTEXT_ID, "error" ) }); }); EXPECT_NO_THROW({ threadApi->unsubscribeFrom({ - valid_subscriptions + valid_subscriptions }); }); EXPECT_NO_THROW({ threadApi->unsubscribeFrom({ - invalid_subscriptions + invalid_subscriptions }); }); }