diff --git a/CMakeLists.txt b/CMakeLists.txt index f536e45a9..d980f5856 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -1,7 +1,7 @@ cmake_minimum_required(VERSION 3.16) project(jami-core - VERSION 13.11.0 + VERSION 14.0.0 LANGUAGES C CXX) set(PACKAGE_NAME "Jami Daemon") set (CMAKE_CXX_STANDARD 17) diff --git a/bin/dbus/cx.ring.Ring.ConfigurationManager.xml b/bin/dbus/cx.ring.Ring.ConfigurationManager.xml index c1643d2d8..e7f7aa897 100644 --- a/bin/dbus/cx.ring.Ring.ConfigurationManager.xml +++ b/bin/dbus/cx.ring.Ring.ConfigurationManager.xml @@ -1848,9 +1848,21 @@ - - - + + + + Load messages from a conversation + + + + + + + + + + + Load messages from a conversation @@ -1873,6 +1885,15 @@ + + + + Clear interactions loaded from daemon. Used by dbus to reload interactions + + + + + @@ -1992,9 +2013,37 @@ - - - + + + + Notify clients when a conversation is loaded + + + + Id of the related loadConversationMessages's request + + + + + Account id related + + + + + Conversation id + + + + + + Messages of the conversation + + + + + + + Notify clients when messages matching a regex are found @@ -2043,9 +2092,111 @@ - - - + + + + Notify clients when a conversation receives a new message + + + + Account id related + + + + + Conversation id + + + + + + The new message + + + + + + + + Notify clients when a conversation receives a new message + + + + Account id related + + + + + Conversation id + + + + + + The new message + + + + + + + + Notify clients when a conversation receives a new message + + + + Account id related + + + + + Conversation id + + + + + Conversation id + + + + + + The new message + + + + + + + + Notify clients when a conversation receives a new message + + + + Account id related + + + + + Conversation id + + + + + Message's id + + + + + Reaction's id + + + + + + + + Notify clients when a conversation got its profile changed. diff --git a/bin/dbus/dbusconfigurationmanager.hpp b/bin/dbus/dbusconfigurationmanager.hpp index 8fddb461b..638d08fad 100644 --- a/bin/dbus/dbusconfigurationmanager.hpp +++ b/bin/dbus/dbusconfigurationmanager.hpp @@ -29,6 +29,7 @@ class DBusConfigurationManager : public sdbus::AdaptorInterfaces { public: + using DBusSwarmMessage = sdbus::Struct, std::vector>, std::vector>>; DBusConfigurationManager(sdbus::IConnection& connection) : AdaptorInterfaces(connection, "/cx/ring/Ring/ConfigurationManager") { @@ -931,6 +932,15 @@ public: return libjami::loadConversationMessages(accountId, conversationId, fromMessage, n); } + uint32_t + loadConversation(const std::string& accountId, + const std::string& conversationId, + const std::string& fromMessage, + const uint32_t& n) + { + return libjami::loadConversation(accountId, conversationId, fromMessage, n); + } + uint32_t loadConversationUntil(const std::string& accountId, const std::string& conversationId, @@ -950,6 +960,13 @@ public: return libjami::countInteractions(accountId, conversationId, toId, fromId, authorUri); } + void + clearCache(const std::string& accountId, + const std::string& conversationId) + { + return libjami::clearCache(accountId, conversationId); + } + uint32_t searchConversation(const std::string& accountId, const std::string& conversationId, @@ -1122,10 +1139,30 @@ private: const std::map convEvHandlers = { exportable_serialized_callback( std::bind(&DBusConfigurationManager::emitConversationLoaded, this, _1, _2, _3, _4)), + exportable_serialized_callback([this](const uint32_t& id, const std::string& account_id, const std::string& conversation_id, const std::vector& messages) { + std::vector msgList; + for (const auto& message: messages) { + DBusSwarmMessage msg {message.id, message.type, message.linearizedParent, message.body, message.reactions, message.editions}; + msgList.push_back(msg); + } + DBusConfigurationManager::emitSwarmLoaded(id, account_id, conversation_id, msgList); + }), exportable_serialized_callback( std::bind(&DBusConfigurationManager::emitMessagesFound, this, _1, _2, _3, _4)), exportable_serialized_callback( std::bind(&DBusConfigurationManager::emitMessageReceived, this, _1, _2, _3)), + exportable_serialized_callback([this](const std::string& account_id, const std::string& conversation_id, const libjami::SwarmMessage& message) { + DBusSwarmMessage msg {message.id, message.type, message.linearizedParent, message.body, message.reactions, message.editions}; + DBusConfigurationManager::emitSwarmMessageReceived(account_id, conversation_id, msg); + }), + exportable_serialized_callback([this](const std::string& account_id, const std::string& conversation_id, const libjami::SwarmMessage& message) { + DBusSwarmMessage msg {message.id, message.type, message.linearizedParent, message.body, message.reactions, message.editions}; + DBusConfigurationManager::emitSwarmMessageUpdated(account_id, conversation_id, msg); + }), + exportable_serialized_callback( + std::bind(&DBusConfigurationManager::emitReactionAdded, this, _1, _2, _3, _4)), + exportable_serialized_callback( + std::bind(&DBusConfigurationManager::emitReactionRemoved, this, _1, _2, _3, _4)), exportable_serialized_callback( std::bind(&DBusConfigurationManager::emitConversationProfileUpdated, this, _1, _2, _3)), exportable_serialized_callback( diff --git a/bin/jni/conversation.i b/bin/jni/conversation.i index 30c10efde..fdecb07e2 100644 --- a/bin/jni/conversation.i +++ b/bin/jni/conversation.i @@ -26,8 +26,13 @@ class ConversationCallback { public: virtual ~ConversationCallback(){} virtual void conversationLoaded(uint32_t /* id */, const std::string& /*accountId*/, const std::string& /* conversationId */, std::vector> /*messages*/){} + virtual void swarmLoaded(uint32_t /* id */, const std::string& /*accountId*/, const std::string& /* conversationId */, std::vector /*messages*/){} virtual void messagesFound(uint32_t /* id */, const std::string& /*accountId*/, const std::string& /* conversationId */, std::vector> /*messages*/){} virtual void messageReceived(const std::string& /*accountId*/, const std::string& /* conversationId */, std::map /*message*/){} + virtual void swarmMessageReceived(const std::string& /*accountId*/, const std::string& /* conversationId */, const libjami::SwarmMessage& /*message*/){} + virtual void swarmMessageUpdated(const std::string& /*accountId*/, const std::string& /* conversationId */, const libjami::SwarmMessage& /*message*/){} + virtual void reactionAdded(const std::string& /*accountId*/, const std::string& /* conversationId */, const std::string& /* messageId */, std::map /*reaction*/){} + virtual void reactionRemoved(const std::string& /*accountId*/, const std::string& /* conversationId */, const std::string& /* messageId */, const std::string& /* reactionId */){} virtual void conversationProfileUpdated(const std::string& /*accountId*/, const std::string& /* conversationId */, std::map /*profile*/){} virtual void conversationRequestReceived(const std::string& /*accountId*/, const std::string& /* conversationId */, std::map /*metadatas*/){} virtual void conversationRequestDeclined(const std::string& /*accountId*/, const std::string& /* conversationId */){} @@ -43,6 +48,16 @@ public: namespace libjami { +struct SwarmMessage +{ + std::string id; + std::string type; + std::string linearizedParent; + std::map body; + std::vector> reactions; + std::vector> editions; +}; + // Conversation management std::string startConversation(const std::string& accountId); void acceptConversationRequest(const std::string& accountId, const std::string& conversationId); @@ -64,8 +79,10 @@ namespace libjami { // Message send/load void sendMessage(const std::string& accountId, const std::string& conversationId, const std::string& message, const std::string& replyTo, const int32_t& flag); uint32_t loadConversationMessages(const std::string& accountId, const std::string& conversationId, const std::string& fromMessage, size_t n); + uint32_t loadConversation(const std::string& accountId, const std::string& conversationId, const std::string& fromMessage, size_t n); uint32_t loadConversationUntil(const std::string& accountId, const std::string& conversationId, const std::string& fromMessage, const std::string& toMessage); uint32_t countInteractions(const std::string& accountId, const std::string& conversationId, const std::string& toId, const std::string& fromId, const std::string& authorUri); + void clearCache(const std::string& accountId, const std::string& conversationId); uint32_t searchConversation(const std::string& accountId, const std::string& conversationId, const std::string& author, @@ -82,8 +99,13 @@ class ConversationCallback { public: virtual ~ConversationCallback(){} virtual void conversationLoaded(uint32_t /* id */, const std::string& /*accountId*/, const std::string& /* conversationId */, std::vector> /*messages*/){} + virtual void swarmLoaded(uint32_t /* id */, const std::string& /*accountId*/, const std::string& /* conversationId */, std::vector /*messages*/){} virtual void messagesFound(uint32_t /* id */, const std::string& /*accountId*/, const std::string& /* conversationId */, std::vector> /*messages*/){} virtual void messageReceived(const std::string& /*accountId*/, const std::string& /* conversationId */, std::map /*message*/){} + virtual void swarmMessageReceived(const std::string& /*accountId*/, const std::string& /* conversationId */, const libjami::SwarmMessage& /*message*/){} + virtual void swarmMessageUpdated(const std::string& /*accountId*/, const std::string& /* conversationId */, const libjami::SwarmMessage& /*message*/){} + virtual void reactionAdded(const std::string& /*accountId*/, const std::string& /* conversationId */, const std::string& /* messageId */, std::map /*messageId*/){} + virtual void reactionRemoved(const std::string& /*accountId*/, const std::string& /* conversationId */, const std::string& /* messageId */, const std::string& /* reactionId */){} virtual void conversationProfileUpdated(const std::string& /*accountId*/, const std::string& /* conversationId */, std::map /*profile*/){} virtual void conversationRequestReceived(const std::string& /*accountId*/, const std::string& /* conversationId */, std::map /*metadatas*/){} virtual void conversationRequestDeclined(const std::string& /*accountId*/, const std::string& /* conversationId */){} diff --git a/bin/jni/jni_interface.i b/bin/jni/jni_interface.i index 6b549324d..9e54cda75 100644 --- a/bin/jni/jni_interface.i +++ b/bin/jni/jni_interface.i @@ -325,8 +325,13 @@ void init(ConfigurationCallback* confM, Callback* callM, PresenceCallback* presM const std::map conversationHandlers = { exportable_callback(bind(&ConversationCallback::conversationLoaded, convM, _1, _2, _3, _4)), + exportable_callback(bind(&ConversationCallback::swarmLoaded, convM, _1, _2, _3, _4)), exportable_callback(bind(&ConversationCallback::messagesFound, convM, _1, _2, _3, _4)), exportable_callback(bind(&ConversationCallback::messageReceived, convM, _1, _2, _3)), + exportable_callback(bind(&ConversationCallback::swarmMessageReceived, convM, _1, _2, _3)), + exportable_callback(bind(&ConversationCallback::swarmMessageUpdated, convM, _1, _2, _3)), + exportable_callback(bind(&ConversationCallback::reactionAdded, convM, _1, _2, _3, _4)), + exportable_callback(bind(&ConversationCallback::reactionRemoved, convM, _1, _2, _3, _4)), exportable_callback(bind(&ConversationCallback::conversationProfileUpdated, convM, _1, _2, _3)), exportable_callback(bind(&ConversationCallback::conversationRequestReceived, convM, _1, _2, _3)), exportable_callback(bind(&ConversationCallback::conversationRequestDeclined, convM, _1, _2)), diff --git a/bin/nodejs/callback.h b/bin/nodejs/callback.h index 7b2a4d69b..154d6d77d 100644 --- a/bin/nodejs/callback.h +++ b/bin/nodejs/callback.h @@ -31,8 +31,10 @@ Persistent incomingMessageCb; Persistent incomingCallCb; Persistent incomingCallWithMediaCb; Persistent conversationLoadedCb; +Persistent swarmLoadedCb; Persistent messagesFoundCb; Persistent messageReceivedCb; +Persistent swarmMessageReceivedCb; Persistent conversationProfileUpdatedCb; Persistent conversationRequestReceivedCb; Persistent conversationRequestDeclinedCb; @@ -99,10 +101,14 @@ getPresistentCb(std::string_view signal) return &incomingCallWithMediaCb; else if (signal == "ConversationLoaded") return &conversationLoadedCb; + else if (signal == "SwarmLoaded") + return &swarmLoadedCb; else if (signal == "MessagesFound") return &messagesFoundCb; else if (signal == "MessageReceived") return &messageReceivedCb; + else if (signal == "SwarmMessageReceived") + return &swarmMessageReceivedCb; else if (signal == "ConversationProfileUpdated") return &conversationProfileUpdatedCb; else if (signal == "ConversationReady") diff --git a/bin/nodejs/conversation.i b/bin/nodejs/conversation.i index 803fcd3b2..6673a8c4e 100644 --- a/bin/nodejs/conversation.i +++ b/bin/nodejs/conversation.i @@ -26,8 +26,13 @@ class ConversationCallback { public: virtual ~ConversationCallback(){} virtual void conversationLoaded(uint32_t /* id */, const std::string& /*accountId*/, const std::string& /* conversationId */, std::vector> /*messages*/){} + virtual void swarmLoaded(uint32_t /* id */, const std::string& /*accountId*/, const std::string& /* conversationId */, std::vector /*messages*/){} virtual void messagesFound(uint32_t /* id */, const std::string& /*accountId*/, const std::string& /* conversationId */, std::vector> /*messages*/){} virtual void messageReceived(const std::string& /*accountId*/, const std::string& /* conversationId */, std::map /*message*/){} + virtual void swarmMessageReceived(const std::string& /*accountId*/, const std::string& /* conversationId */, const libjami::SwarmMessage& /*message*/){} + virtual void swarmMessageUpdated(const std::string& /*accountId*/, const std::string& /* conversationId */, const libjami::SwarmMessage& /*message*/){} + virtual void reactionAdded(const std::string& /*accountId*/, const std::string& /* conversationId */, const std::string& /* messageId */, std::map /*reaction*/){} + virtual void reactionRemoved(const std::string& /*accountId*/, const std::string& /* conversationId */, const std::string& /* messageId */, const std::string& /* reactionId */){} virtual void conversationProfileUpdated(const std::string& /*accountId*/, const std::string& /* conversationId */, std::map /*profile*/){} virtual void conversationRequestReceived(const std::string& /*accountId*/, const std::string& /* conversationId */, std::map /*metadatas*/){} virtual void conversationRequestDeclined(const std::string& /*accountId*/, const std::string& /* conversationId */){} @@ -43,6 +48,16 @@ public: namespace libjami { +struct SwarmMessage +{ + std::string id; + std::string type; + std::string linearizedParent; + std::map body; + std::vector> reactions; + std::vector> editions; +}; + // Conversation management std::string startConversation(const std::string& accountId); void acceptConversationRequest(const std::string& accountId, const std::string& conversationId); @@ -64,7 +79,9 @@ namespace libjami { // Message send/load void sendMessage(const std::string& accountId, const std::string& conversationId, const std::string& message, const std::string& replyTo, const int32_t& flag); uint32_t loadConversationMessages(const std::string& accountId, const std::string& conversationId, const std::string& fromMessage, size_t n); + uint32_t loadConversation(const std::string& accountId, const std::string& conversationId, const std::string& fromMessage, size_t n); uint32_t loadConversationUntil(const std::string& accountId, const std::string& conversationId, const std::string& fromMessage, const std::string& toMessage); + void clearCache(const std::string& accountId, const std::string& conversationId); uint32_t countInteractions(const std::string& accountId, const std::string& conversationId, const std::string& toId, const std::string& fromId, const std::string& authorUri); uint32_t searchConversation(const std::string& accountId, const std::string& conversationId, @@ -83,8 +100,13 @@ class ConversationCallback { public: virtual ~ConversationCallback(){} virtual void conversationLoaded(uint32_t /* id */, const std::string& /*accountId*/, const std::string& /* conversationId */, std::vector> /*messages*/){} + virtual void swarmLoaded(uint32_t /* id */, const std::string& /*accountId*/, const std::string& /* conversationId */, std::vector /*messages*/){} virtual void messagesFound(uint32_t /* id */, const std::string& /*accountId*/, const std::string& /* conversationId */, std::vector> /*messages*/){} virtual void messageReceived(const std::string& /*accountId*/, const std::string& /* conversationId */, std::map /*message*/){} + virtual void swarmMessageReceived(const std::string& /*accountId*/, const std::string& /* conversationId */, const libjami::SwarmMessage& /*message*/){} + virtual void swarmMessageUpdated(const std::string& /*accountId*/, const std::string& /* conversationId */, const libjami::SwarmMessage& /*message*/){} + virtual void reactionAdded(const std::string& /*accountId*/, const std::string& /* conversationId */, const std::string& /* messageId */, std::map /*reaction*/){} + virtual void reactionRemoved(const std::string& /*accountId*/, const std::string& /* conversationId */, const std::string& /* messageId */, const std::string& /* reactionId */){} virtual void conversationProfileUpdated(const std::string& /*accountId*/, const std::string& /* conversationId */, std::map /*profile*/){} virtual void conversationRequestReceived(const std::string& /*accountId*/, const std::string& /* conversationId */, std::map /*metadatas*/){} virtual void conversationRequestDeclined(const std::string& /*accountId*/, const std::string& /* conversationId */){} diff --git a/bin/nodejs/nodejs_interface.i b/bin/nodejs/nodejs_interface.i index 13a3d911c..42a73c39e 100644 --- a/bin/nodejs/nodejs_interface.i +++ b/bin/nodejs/nodejs_interface.i @@ -150,8 +150,13 @@ void init(const SWIGV8_VALUE& funcMap){ const std::map conversationHandlers = { exportable_callback(bind(&conversationLoaded, _1, _2, _3, _4)), + exportable_callback(bind(&swarmLoaded, _1, _2, _3, _4)), exportable_callback(bind(&messagesFound, _1, _2, _3, _4)), exportable_callback(bind(&messageReceived, _1, _2, _3)), + exportable_callback(bind(&swarmMessageReceived, _1, _2, _3)), + exportable_callback(bind(&swarmMessageUpdated, _1, _2, _3)), + exportable_callback(bind(&reactionAdded, _1, _2, _3, _4)), + exportable_callback(bind(&reactionRemoved, _1, _2, _3, _4)), exportable_callback(bind(&conversationProfileUpdated, _1, _2, _3)), exportable_callback(bind(&conversationRequestReceived, _1, _2, _3)), exportable_callback(bind(&conversationRequestDeclined, _1, _2)), diff --git a/configure.ac b/configure.ac index f94bf70f7..5c7467037 100644 --- a/configure.ac +++ b/configure.ac @@ -2,7 +2,7 @@ dnl Jami - configure.ac dnl Process this file with autoconf to produce a configure script. AC_PREREQ([2.69]) -AC_INIT([Jami Daemon],[13.11.0],[jami@gnu.org],[jami]) +AC_INIT([Jami Daemon],[14.0.0],[jami@gnu.org],[jami]) dnl Clear the implicit flags that default to '-g -O2', otherwise they dnl take precedence over the values we set via the diff --git a/meson.build b/meson.build index 73c16b774..97ae791a1 100644 --- a/meson.build +++ b/meson.build @@ -1,5 +1,5 @@ project('jami-daemon', ['c', 'cpp'], - version: '13.11.0', + version: '14.0.0', license: 'GPL3+', default_options: ['cpp_std=gnu++17', 'buildtype=debugoptimized'], meson_version:'>= 0.56' diff --git a/src/client/conversation_interface.cpp b/src/client/conversation_interface.cpp index 661832b96..0fb86ab66 100644 --- a/src/client/conversation_interface.cpp +++ b/src/client/conversation_interface.cpp @@ -195,6 +195,18 @@ loadConversationMessages(const std::string& accountId, return 0; } +uint32_t +loadConversation(const std::string& accountId, + const std::string& conversationId, + const std::string& fromMessage, + size_t n) +{ + if (auto acc = jami::Manager::instance().getAccount(accountId)) + if (auto convModule = acc->convModule()) + return convModule->loadConversation(conversationId, fromMessage, n); + return 0; +} + uint32_t loadConversationUntil(const std::string& accountId, const std::string& conversationId, @@ -220,6 +232,14 @@ countInteractions(const std::string& accountId, return 0; } +void +clearCache(const std::string& accountId, const std::string& conversationId) +{ + if (auto acc = jami::Manager::instance().getAccount(accountId)) + if (auto convModule = acc->convModule()) + convModule->clearCache(conversationId); +} + uint32_t searchConversation(const std::string& accountId, const std::string& conversationId, diff --git a/src/client/ring_signal.cpp b/src/client/ring_signal.cpp index 5576d32b3..9d86696ca 100644 --- a/src/client/ring_signal.cpp +++ b/src/client/ring_signal.cpp @@ -129,8 +129,13 @@ getSignalHandlers() /* Conversation */ exported_callback(), + exported_callback(), exported_callback(), exported_callback(), + exported_callback(), + exported_callback(), + exported_callback(), + exported_callback(), exported_callback(), exported_callback(), exported_callback(), diff --git a/src/jami/conversation_interface.h b/src/jami/conversation_interface.h index aed802231..26d932c77 100644 --- a/src/jami/conversation_interface.h +++ b/src/jami/conversation_interface.h @@ -26,11 +26,28 @@ #include #include #include +#include #include "jami.h" namespace libjami { +struct SwarmMessage +{ + std::string id; + std::string type; + std::string linearizedParent; + std::map body; + std::vector> reactions; + std::vector> editions; + + void fromMapStringString(const std::map& commit) { + id = commit.at("id"); + type = commit.at("type"); + body = commit; // TODO erase type/id? + } +}; + // Conversation management LIBJAMI_PUBLIC std::string startConversation(const std::string& accountId); LIBJAMI_PUBLIC void acceptConversationRequest(const std::string& accountId, @@ -79,6 +96,10 @@ LIBJAMI_PUBLIC uint32_t loadConversationMessages(const std::string& accountId, const std::string& conversationId, const std::string& fromMessage, size_t n); +LIBJAMI_PUBLIC uint32_t loadConversation(const std::string& accountId, + const std::string& conversationId, + const std::string& fromMessage, + size_t n); LIBJAMI_PUBLIC uint32_t loadConversationUntil(const std::string& accountId, const std::string& conversationId, const std::string& fromMessage, @@ -88,6 +109,7 @@ LIBJAMI_PUBLIC uint32_t countInteractions(const std::string& accountId, const std::string& toId, const std::string& fromId, const std::string& authorUri); +LIBJAMI_PUBLIC void clearCache(const std::string& accountId, const std::string& conversationId); LIBJAMI_PUBLIC uint32_t searchConversation(const std::string& accountId, const std::string& conversationId, const std::string& author, @@ -110,6 +132,14 @@ struct LIBJAMI_PUBLIC ConversationSignal const std::string& /* conversationId */, std::vector> /*messages*/); }; + struct LIBJAMI_PUBLIC SwarmLoaded + { + constexpr static const char* name = "SwarmLoaded"; + using cb_type = void(uint32_t /* id */, + const std::string& /*accountId*/, + const std::string& /* conversationId */, + std::vector /*messages*/); + }; struct LIBJAMI_PUBLIC MessagesFound { constexpr static const char* name = "MessagesFound"; @@ -125,6 +155,36 @@ struct LIBJAMI_PUBLIC ConversationSignal const std::string& /* conversationId */, std::map /*message*/); }; + struct LIBJAMI_PUBLIC SwarmMessageReceived + { + constexpr static const char* name = "SwarmMessageReceived"; + using cb_type = void(const std::string& /*accountId*/, + const std::string& /* conversationId */, + const SwarmMessage& /*message*/); + }; + struct LIBJAMI_PUBLIC SwarmMessageUpdated + { + constexpr static const char* name = "SwarmMessageUpdated"; + using cb_type = void(const std::string& /*accountId*/, + const std::string& /* conversationId */, + const SwarmMessage& /*message*/); + }; + struct LIBJAMI_PUBLIC ReactionAdded + { + constexpr static const char* name = "ReactionAdded"; + using cb_type = void(const std::string& /*accountId*/, + const std::string& /* conversationId */, + const std::string& /* messageId */, + std::map /*reaction*/); + }; + struct LIBJAMI_PUBLIC ReactionRemoved + { + constexpr static const char* name = "ReactionRemoved"; + using cb_type = void(const std::string& /*accountId*/, + const std::string& /* conversationId */, + const std::string& /* messageId */, + const std::string& /* reactionId */); + }; struct LIBJAMI_PUBLIC ConversationProfileUpdated { constexpr static const char* name = "ConversationProfileUpdated"; diff --git a/src/jamidht/conversation.cpp b/src/jamidht/conversation.cpp index 629c115d8..0d72a0e5b 100644 --- a/src/jamidht/conversation.cpp +++ b/src/jamidht/conversation.cpp @@ -29,12 +29,14 @@ #include #include #include +#include #include "swarm/swarm_manager.h" #ifdef ENABLE_PLUGIN #include "manager.h" #include "plugin/jamipluginmanager.h" #include "plugin/streamdata.h" #endif +#include "jami/conversation_interface.h" namespace jami { @@ -119,6 +121,16 @@ ConversationRequest::toMap() const return result; } +using MessageList = std::list>; + +struct History +{ + MessageList messageList {}; + std::map> quickAccess {}; + std::map>> pendingEditions {}; + std::map>> pendingReactions {}; +}; + class Conversation::Impl { public: @@ -369,6 +381,7 @@ public: auto convId = repository_->id(); auto ok = !commits.empty(); auto lastId = ok ? commits.rbegin()->at(ConversationMapKeys::ID) : ""; + addToHistory(commits, true); if (ok) { bool announceMember = false; for (const auto& c : commits) { @@ -602,6 +615,7 @@ public: std::weak_ptr account_; std::atomic_bool isRemoving_ {false}; std::vector> loadMessages(const LogOptions& options); + std::vector loadMessages2(const LogOptions& options, History* optHistory = nullptr); void pull(); std::vector> mergeHistory(const std::string& uri); @@ -642,6 +656,24 @@ public: std::unique_ptr fallbackTimer_; bool isMobile {false}; + + /** + * Loaded history represents the linearized history to show for clients + */ + mutable History loadedHistory_ {}; + std::vector addToHistory(const std::vector>& commits, + bool messageReceived = false, + History* history = nullptr) const; + // While loading the history, we need to avoid: + // - reloading history (can just be ignored) + // - adding new commits (should wait for history to be loaded) + bool isLoadingHistory_ {false}; + mutable std::mutex historyMtx_ {}; + mutable std::condition_variable historyCv_ {}; + + void handleReaction(History& history, const std::shared_ptr& sharedCommit) const; + void handleEdition(History& history, const std::shared_ptr& sharedCommit, bool messageReceived) const; + bool handleMessage(History& history, const std::shared_ptr& sharedCommit, bool messageReceived) const; }; bool @@ -738,9 +770,280 @@ Conversation::Impl::loadMessages(const LogOptions& options) { if (!repository_) return {}; - std::vector convCommits; - convCommits = repository_->log(options); - return repository_->convCommitToMap(convCommits); + std::vector commits; + auto startLogging = options.from == ""; + auto breakLogging = false; + repository_->log([&](const auto& id, const auto& author, const auto& commit) { + if (!commits.empty()) { + // Set linearized parent + commits.rbegin()->linearized_parent = id; + } + if (options.skipMerge && git_commit_parentcount(commit.get()) > 1) { + return CallbackResult::Skip; + } + if ((options.nbOfCommits != 0 + && commits.size() == options.nbOfCommits)) + return CallbackResult::Break; // Stop logging + if (breakLogging) + return CallbackResult::Break; // Stop logging + if (id == options.to) { + if (options.includeTo) + breakLogging = true; // For the next commit + else + return CallbackResult::Break; // Stop logging + } + + if (!startLogging && options.from != "" && options.from == id) + startLogging = true; + if (!startLogging) + return CallbackResult::Skip; // Start logging after this one + + if (options.fastLog) { + if (options.authorUri != "") { + if (options.authorUri == repository_->uriFromDevice(author.email)) { + return CallbackResult::Break; // Found author, stop + } + } + // Used to only count commit + commits.emplace(commits.end(), ConversationCommit {}); + return CallbackResult::Skip; + } + + return CallbackResult::Ok; // Continue + }, + [&](auto&& cc) { + commits.emplace(commits.end(), std::forward(cc)); + }, + [](auto, auto, auto) { return false; }, + options.from, + options.logIfNotFound); + return repository_->convCommitToMap(commits); +} + +std::vector +Conversation::Impl::loadMessages2(const LogOptions& options, History* optHistory) +{ + { + std::lock_guard lock(historyMtx_); + if (!repository_ || (!optHistory && isLoadingHistory_)) + return {}; + if (!optHistory) + isLoadingHistory_ = true; + } + + auto startLogging = options.from == ""; + auto breakLogging = false; + auto currentHistorySize = loadedHistory_.messageList.size(); + std::vector replies; + std::vector ret; + repository_->log([&](const auto& id, const auto& author, const auto& commit) { + if (options.skipMerge && git_commit_parentcount(commit.get()) > 1) { + return CallbackResult::Skip; + } + if (replies.empty()) { // This avoid load until + // NOTE: in the future, we may want to add "Reply-Body" in commit to avoid to load until this commit + if ((options.nbOfCommits != 0 + && (loadedHistory_.messageList.size() - currentHistorySize) == options.nbOfCommits)) + return CallbackResult::Break; // Stop logging + if (breakLogging) + return CallbackResult::Break; // Stop logging + if (id == options.to) { + if (options.includeTo) + breakLogging = true; // For the next commit + else + return CallbackResult::Break; // Stop logging + } + } + + if (!startLogging && options.from != "" && options.from == id) + startLogging = true; + if (!startLogging) + return CallbackResult::Skip; // Start logging after this one + + if (options.fastLog) { + if (options.authorUri != "") { + if (options.authorUri == repository_->uriFromDevice(author.email)) { + return CallbackResult::Break; // Found author, stop + } + } + } + + return CallbackResult::Ok; // Continue + }, + [&](auto&& cc) { + std::map map = *repository_->convCommitToMap(cc); + if (map.find("reply-to") != map.end()) { + replies.emplace_back(map.at("reply-to")); + } + auto it = std::find(replies.begin(), replies.end(), map.at("id")); + if (it != replies.end()) { + replies.erase(it); + } + auto added = addToHistory({map}, false, optHistory); + ret.insert(ret.end(), added.begin(), added.end()); + }, + [](auto, auto, auto) { return false; }, + options.from, + options.logIfNotFound); + + if (!optHistory) { + std::lock_guard lock(historyMtx_); + isLoadingHistory_ = false; + historyCv_.notify_all(); + } + + return ret; +} + +void +Conversation::Impl::handleReaction(History& history, const std::shared_ptr& sharedCommit) const +{ + auto it = history.quickAccess.find(sharedCommit->body.at("react-to")); + auto peditIt = history.pendingEditions.find(sharedCommit->id); + if (peditIt != history.pendingEditions.end()) { + auto oldBody = sharedCommit->body; + sharedCommit->body["body"] = peditIt->second.front()->body["body"]; + if (sharedCommit->body.at("body").empty()) + return; + history.pendingEditions.erase(peditIt); + } + if (it != history.quickAccess.end()) { + it->second->reactions.emplace_back(sharedCommit->body); + emitSignal(accountId_, repository_->id(), it->second->id, sharedCommit->body); + } else { + history.pendingReactions[sharedCommit->body.at("react-to")].emplace_back(sharedCommit->body); + } +} + +void +Conversation::Impl::handleEdition(History& history, const std::shared_ptr& sharedCommit, bool messageReceived) const +{ + auto editId = sharedCommit->body.at("edit"); + auto it = history.quickAccess.find(editId); + if (it != history.quickAccess.end()) { + auto baseCommit = it->second; + if (baseCommit) { + auto itReact = baseCommit->body.find("react-to"); + auto body = sharedCommit->body.at("body"); + // Edit reaction + if (itReact != baseCommit->body.end()) { + baseCommit->body["body"] = body; // Replace body if pending + it = history.quickAccess.find(itReact->second); + auto itPending = history.pendingReactions.find(itReact->second); + if (it != history.quickAccess.end()) { + baseCommit = it->second; // Base commit + auto itPreviousReact = std::find_if(baseCommit->reactions.begin(), baseCommit->reactions.end(), [&](const auto& reaction) { + return reaction.at("id") == editId; + }); + if (itPreviousReact != baseCommit->reactions.end()) { + (*itPreviousReact)["body"] = body; + if (body.empty()) { + baseCommit->reactions.erase(itPreviousReact); + emitSignal(accountId_, repository_->id(), baseCommit->id, editId); + } + } + } else if (itPending != history.pendingReactions.end()) { + // Else edit if pending + auto itReaction = std::find_if(itPending->second.begin(), itPending->second.end(), [&](const auto& reaction) { + return reaction.at("id") == editId; + }); + if (itReaction != itPending->second.end()) { + (*itReaction)["body"] = body; + if (body.empty()) + itPending->second.erase(itReaction); + } + } else { + // Add to pending edtions + messageReceived? history.pendingEditions[editId].emplace_front(sharedCommit) + : history.pendingEditions[editId].emplace_back(sharedCommit); + } + } else { + // Normal message + it->second->editions.emplace(it->second->editions.begin(), it->second->body); + it->second->body["body"] = sharedCommit->body["body"]; + emitSignal(accountId_, repository_->id(), *it->second); + } + } + } else { + messageReceived? history.pendingEditions[editId].emplace_front(sharedCommit) + : history.pendingEditions[editId].emplace_back(sharedCommit); + } +} + +bool +Conversation::Impl::handleMessage(History& history, const std::shared_ptr& sharedCommit, bool messageReceived) const +{ + if (messageReceived) { + // For a received message, we place it at the beginning of the list + if (!history.messageList.empty()) + sharedCommit->linearizedParent = (*history.messageList.begin())->id; + history.messageList.emplace_front(sharedCommit); + } else { + // For a loaded message, we load from newest to oldest + // So we change the parent of the last message. + if (!history.messageList.empty()) + (*history.messageList.rbegin())->linearizedParent = sharedCommit->id; + history.messageList.emplace_back(sharedCommit); + } + // Handle pending reactions/editions + auto reactIt = history.pendingReactions.find(sharedCommit->id); + if (reactIt != history.pendingReactions.end()) { + for (const auto& commitBody: reactIt->second) + sharedCommit->reactions.emplace_back(commitBody); + history.pendingReactions.erase(reactIt); + } + auto peditIt = history.pendingEditions.find(sharedCommit->id); + if (peditIt != history.pendingEditions.end()) { + auto oldBody = sharedCommit->body; + sharedCommit->body["body"] = peditIt->second.front()->body["body"]; + peditIt->second.pop_front(); + for (const auto& commit: peditIt->second) { + sharedCommit->editions.emplace_back(commit->body); + } + sharedCommit->editions.emplace_back(oldBody); + history.pendingEditions.erase(peditIt); + } + // Announce to client + if (messageReceived) + emitSignal(accountId_, repository_->id(), *sharedCommit); + return !messageReceived; +} + +std::vector +Conversation::Impl::addToHistory(const std::vector>& commits, bool messageReceived, History* optHistory) const +{ + if (messageReceived && (!optHistory && isLoadingHistory_)) { + std::unique_lock lk(historyMtx_); + historyCv_.wait(lk, [&] { return !isLoadingHistory_; }); + } + std::vector messages; + auto addCommit = [&](const auto& commit) { + auto* history = optHistory ? optHistory : &loadedHistory_; + auto commitId = commit.at("id"); + if (history->quickAccess.find(commitId) != history->quickAccess.end()) + return; // Already present + auto typeIt = commit.find("type"); + auto reactToIt = commit.find("react-to"); + auto editIt = commit.find("edit"); + // Nothing to show for the client, skip + if (typeIt != commit.end() && typeIt->second == "merge") + return; + + auto sharedCommit = std::make_shared(); + sharedCommit->fromMapStringString(commit); + history->quickAccess[commitId] = sharedCommit; + + if (reactToIt != commit.end() && !reactToIt->second.empty()) { + handleReaction(*history, sharedCommit); + } else if (editIt != commit.end() && !editIt->second.empty()) { + handleEdition(*history, sharedCommit, messageReceived); + } else if (handleMessage(*history, sharedCommit, messageReceived)) { + messages.emplace_back(*sharedCommit); + } + }; + std::for_each(commits.begin(), commits.end(), addCommit); + + return messages; } Conversation::Conversation(const std::shared_ptr& account, @@ -1178,7 +1481,7 @@ Conversation::getCommit(const std::string& commitId) const } void -Conversation::loadMessages(const OnLoadMessages& cb, const LogOptions& options) +Conversation::loadMessages(OnLoadMessages cb, const LogOptions& options) { if (!cb) return; @@ -1189,6 +1492,27 @@ Conversation::loadMessages(const OnLoadMessages& cb, const LogOptions& options) }); } +void +Conversation::loadMessages2(const OnLoadMessages2& cb, const LogOptions& options) +{ + if (!cb) + return; + dht::ThreadPool::io().run([w = weak(), cb = std::move(cb), options] { + if (auto sthis = w.lock()) { + cb(sthis->pimpl_->loadMessages2(options)); + } + }); +} + +void +Conversation::clearCache() +{ + pimpl_->loadedHistory_.messageList.clear(); + pimpl_->loadedHistory_.quickAccess.clear(); + pimpl_->loadedHistory_.pendingEditions.clear(); + pimpl_->loadedHistory_.pendingReactions.clear(); +} + std::string Conversation::lastCommitId() const { @@ -1976,14 +2300,15 @@ Conversation::countInteractions(const std::string& toId, const std::string& fromId, const std::string& authorUri) const { - // Log but without content to avoid costly convertions. LogOptions options; options.to = toId; options.from = fromId; options.authorUri = authorUri; options.logIfNotFound = false; options.fastLog = true; - return pimpl_->repository_->log(options).size(); + History history; + auto res = pimpl_->loadMessages2(options, &history); + return res.size(); } void @@ -1998,7 +2323,74 @@ Conversation::search(uint32_t req, auto acc = sthis->pimpl_->account_.lock(); if (!acc) return; - auto commits = sthis->pimpl_->repository_->search(filter); + + History history; + std::vector> commits {}; + // std::regex_constants::ECMAScript is the default flag. + auto re = std::regex(filter.regexSearch, + filter.caseSensitive ? std::regex_constants::ECMAScript + : std::regex_constants::icase); + sthis->pimpl_->repository_->log([&](const auto& id, const auto& author, auto& commit) { + if (!filter.author.empty() && filter.author != sthis->uriFromDevice(author.email)) { + // Filter author + return CallbackResult::Skip; + } + auto commitTime = git_commit_time(commit.get()); + if (filter.before && filter.before < commitTime) { + // Only get commits before this date + return CallbackResult::Skip; + } + if (filter.after && filter.after > commitTime) { + // Only get commits before this date + if (git_commit_parentcount(commit.get()) <= 1) + return CallbackResult::Break; + else + return CallbackResult::Skip; // Because we are sorting it with + // GIT_SORT_TOPOLOGICAL | GIT_SORT_TIME + } + + return CallbackResult::Ok; // Continue + }, + [&](auto&& cc) { + sthis->pimpl_->addToHistory({*sthis->pimpl_->repository_->convCommitToMap(cc)}, false, &history); + }, + [&](auto id, auto, auto) { + if (id == filter.lastId) + return true; + return false; + }, + "", + false); + // Search on generated history + for (auto& message : history.messageList) { + auto contentType = message->type; + auto isSearchable = contentType == "text/plain" + || contentType == "application/data-transfer+json"; + if (filter.type.empty() && !isSearchable) { + // Not searchable, at least for now + continue; + } else if (contentType == filter.type || filter.type.empty()) { + if (isSearchable) { + // If it's a text match the body, else the display name + auto body = contentType == "text/plain" ? message->body.at("body") + : message->body.at("displayName"); + std::smatch body_match; + if (std::regex_search(body, body_match, re)) { + auto commit = message->body; + commit["id"] = message->id; + commit["type"] = message->type; + commits.emplace_back(commit); + } + } else { + // Matching type, just add it to the results + commits.emplace_back(message->body); + } + + if (filter.maxResult != 0 && commits.size() == filter.maxResult) + break; + } + } + if (commits.size() > 0) emitSignal(req, acc->getAccountID(), diff --git a/src/jamidht/conversation.h b/src/jamidht/conversation.h index 3d883ad5c..55c4b44c7 100644 --- a/src/jamidht/conversation.h +++ b/src/jamidht/conversation.h @@ -22,6 +22,7 @@ #include "jamidht/conversationrepository.h" #include "conversationrepository.h" #include "swarm/swarm_protocol.h" +#include "jami/conversation_interface.h" #include #include @@ -134,6 +135,8 @@ enum class ConversationMode; using OnPullCb = std::function; using OnLoadMessages = std::function>&& messages)>; +using OnLoadMessages2 + = std::function&& messages)>; using OnCommitCb = std::function; using OnDoneCb = std::function; using OnMultiDoneCb = std::function&)>; @@ -296,7 +299,17 @@ public: * @param cb The callback when loaded * @param options The log options */ - void loadMessages(const OnLoadMessages& cb, const LogOptions& options); + void loadMessages(OnLoadMessages cb, const LogOptions& options); + /** + * Get a range of messages + * @param cb The callback when loaded + * @param options The log options + */ + void loadMessages2(const OnLoadMessages2& cb, const LogOptions& options); + /** + * Clear all cached messages + */ + void clearCache(); /** * Retrieve one commit * @param commitId @@ -474,7 +487,6 @@ public: * @return displayed */ std::map displayed() const; - /** * Retrieve how many interactions there is from HEAD to interactionId * @param toId "" for getting the whole history @@ -485,7 +497,6 @@ public: uint32_t countInteractions(const std::string& toId, const std::string& fromId = "", const std::string& authorUri = "") const; - /** * Search in the conversation via a filter * @param req Id of the request diff --git a/src/jamidht/conversation_module.cpp b/src/jamidht/conversation_module.cpp index 5372378c1..e2712371c 100644 --- a/src/jamidht/conversation_module.cpp +++ b/src/jamidht/conversation_module.cpp @@ -2009,6 +2009,44 @@ ConversationModule::loadConversationMessages(const std::string& conversationId, return 0; } +void +ConversationModule::clearCache(const std::string& conversationId) +{ + if (auto conv = pimpl_->getConversation(conversationId)) { + std::lock_guard lk(conv->mtx); + if (conv->conversation) { + conv->conversation->clearCache(); + } + } +} + +uint32_t +ConversationModule::loadConversation(const std::string& conversationId, + const std::string& fromMessage, + size_t n) +{ + auto acc = pimpl_->account_.lock(); + if (auto conv = pimpl_->getConversation(conversationId)) { + std::lock_guard lk(conv->mtx); + if (conv->conversation) { + const uint32_t id = std::uniform_int_distribution {}(acc->rand); + LogOptions options; + options.from = fromMessage; + options.nbOfCommits = n; + conv->conversation->loadMessages2( + [accountId = pimpl_->accountId_, conversationId, id](auto&& messages) { + emitSignal(id, + accountId, + conversationId, + messages); + }, + options); + return id; + } + } + return 0; +} + uint32_t ConversationModule::loadConversationUntil(const std::string& conversationId, const std::string& fromMessage, diff --git a/src/jamidht/conversation_module.h b/src/jamidht/conversation_module.h index 0feaad896..f7e3cba94 100644 --- a/src/jamidht/conversation_module.h +++ b/src/jamidht/conversation_module.h @@ -226,9 +226,17 @@ public: uint32_t loadConversationMessages(const std::string& conversationId, const std::string& fromMessage = "", size_t n = 0); + uint32_t loadConversation(const std::string& conversationId, + const std::string& fromMessage = "", + size_t n = 0); uint32_t loadConversationUntil(const std::string& conversationId, const std::string& fromMessage, const std::string& to); + /** + * Clear loaded interactions + * @param conversationId + */ + void clearCache(const std::string& conversationId); // File transfer /** diff --git a/src/jamidht/conversationrepository.cpp b/src/jamidht/conversationrepository.cpp index 881296029..f05b7bc2e 100644 --- a/src/jamidht/conversationrepository.cpp +++ b/src/jamidht/conversationrepository.cpp @@ -54,13 +54,6 @@ as_view(const GitObject& blob) return as_view(reinterpret_cast(blob.get())); } -enum class CallbackResult { Skip, Break, Ok }; - -using PreConditionCb - = std::function; -using PostConditionCb - = std::function; - class ConversationRepository::Impl { public: @@ -158,7 +151,6 @@ public: const std::string& from = "", bool logIfNotFound = true) const; std::vector log(const LogOptions& options) const; - std::vector> search(const Filter& filter) const; GitObject fileAtTree(const std::string& path, const GitTree& tree) const; GitObject memberCertificate(std::string_view memberUri, const GitTree& tree) const; @@ -2184,74 +2176,6 @@ ConversationRepository::Impl::log(const LogOptions& options) const return commits; } -std::vector> -ConversationRepository::Impl::search(const Filter& filter) const -{ - std::vector> commits {}; - // std::regex_constants::ECMAScript is the default flag. - auto re = std::regex(filter.regexSearch, - filter.caseSensitive ? std::regex_constants::ECMAScript - : std::regex_constants::icase); - forEachCommit( - [&](const auto& id, const auto& author, auto& commit) { - if (!commits.empty()) { - // Set linearized parent - commits.rbegin()->at("linearizedParent") = id; - } - - if (!filter.author.empty() && filter.author != uriFromDevice(author.email)) { - // Filter author - return CallbackResult::Skip; - } - auto commitTime = git_commit_time(commit.get()); - if (filter.before && filter.before < commitTime) { - // Only get commits before this date - return CallbackResult::Skip; - } - if (filter.after && filter.after > commitTime) { - // Only get commits before this date - if (git_commit_parentcount(commit.get()) <= 1) - return CallbackResult::Break; - else - return CallbackResult::Skip; // Because we are sorting it with - // GIT_SORT_TOPOLOGICAL | GIT_SORT_TIME - } - - return CallbackResult::Ok; // Continue - }, - [&](auto&& cc) { - auto content = convCommitToMap(cc); - auto contentType = content ? content->at("type") : ""; - auto isSearchable = contentType == "text/plain" - || contentType == "application/data-transfer+json"; - if (filter.type.empty() && !isSearchable) { - // Not searchable, at least for now - return; - } else if (contentType == filter.type || filter.type.empty()) { - if (isSearchable) { - // If it's a text match the body, else the display name - auto body = contentType == "text/plain" ? content->at("body") - : content->at("displayName"); - std::smatch body_match; - if (std::regex_search(body, body_match, re)) { - commits.emplace(commits.end(), std::move(*content)); - } - } else { - // Matching type, just add it to the results - commits.emplace(commits.end(), std::move(*content)); - } - } - }, - [&](auto id, auto, auto) { - if (filter.maxResult != 0 && commits.size() == filter.maxResult) - return true; - if (id == filter.lastId) - return true; - return false; - }); - return commits; -} - GitObject ConversationRepository::Impl::fileAtTree(const std::string& path, const GitTree& tree) const { @@ -3123,10 +3047,14 @@ ConversationRepository::log(const LogOptions& options) const return pimpl_->log(options); } -std::vector> -ConversationRepository::search(const Filter& filter) const +void +ConversationRepository::log(PreConditionCb&& preCondition, + std::function&& emplaceCb, + PostConditionCb&& postCondition, + const std::string& from, + bool logIfNotFound) const { - return pimpl_->search(filter); + pimpl_->forEachCommit(std::move(preCondition), std::move(emplaceCb), std::move(postCondition), from, logIfNotFound); } std::optional diff --git a/src/jamidht/conversationrepository.h b/src/jamidht/conversationrepository.h index 60e585286..de96ebd8d 100644 --- a/src/jamidht/conversationrepository.h +++ b/src/jamidht/conversationrepository.h @@ -127,6 +127,13 @@ struct ConversationMember } }; +enum class CallbackResult { Skip, Break, Ok }; + +using PreConditionCb + = std::function; +using PostConditionCb + = std::function; + /** * This class gives access to the git repository that represents the conversation */ @@ -219,16 +226,14 @@ public: * @return a list of commits */ std::vector log(const LogOptions& options = {}) const; + void log(PreConditionCb&& preCondition, + std::function&& emplaceCb, + PostConditionCb&& postCondition, + const std::string& from = "", + bool logIfNotFound = true) const; std::optional getCommit(const std::string& commitId, bool logIfNotFound = true) const; - /** - * Search in the conversation via a filter - * @param filter Parameters for the search - * @return matching commits - */ - std::vector> search(const Filter& filter) const; - /** * Get parent via topological + date sort in branch main of a commit * @param commitId id to choice diff --git a/test/unitTest/conversation/call.cpp b/test/unitTest/conversation/call.cpp index c25b2ce29..dd92c8fe8 100644 --- a/test/unitTest/conversation/call.cpp +++ b/test/unitTest/conversation/call.cpp @@ -46,7 +46,7 @@ struct ConvData bool conferenceRemoved {false}; std::string hostState {}; std::string state {}; - std::vector> messages {}; + std::vector messages {}; }; class ConversationCallTest : public CppUnit::TestFixture @@ -157,10 +157,10 @@ ConversationCallTest::connectSignals() carlaData_.id = conversationId; cv.notify_one(); })); - confHandlers.insert(libjami::exportable_callback( + confHandlers.insert(libjami::exportable_callback( [&](const std::string& accountId, const std::string& conversationId, - std::map message) { + const libjami::SwarmMessage& message) { if (accountId == aliceId && aliceData_.id == conversationId) aliceData_.messages.emplace_back(message); if (accountId == bobId && bobData_.id == conversationId) @@ -295,7 +295,7 @@ ConversationCallTest::testActiveCalls() auto callId = libjami::placeCallWithMedia(aliceId, "swarm:" + aliceData_.id, {}); // should get message cv.wait_for(lk, 30s, [&]() { return !aliceData_.messages.empty(); }); - CPPUNIT_ASSERT(aliceData_.messages[0]["type"] == "application/call-history+json"); + CPPUNIT_ASSERT(aliceData_.messages[0].type == "application/call-history+json"); // get active calls = 1 CPPUNIT_ASSERT(libjami::getActiveCalls(aliceId, aliceData_.id).size() == 1); @@ -306,7 +306,7 @@ ConversationCallTest::testActiveCalls() // should get message cv.wait_for(lk, 30s, [&]() { return !aliceData_.messages.empty(); }); - CPPUNIT_ASSERT(aliceData_.messages[0].find("duration") != aliceData_.messages[0].end()); + CPPUNIT_ASSERT(aliceData_.messages[0].body.find("duration") != aliceData_.messages[0].body.end()); // get active calls = 0 CPPUNIT_ASSERT(libjami::getActiveCalls(aliceId, aliceData_.id).size() == 0); @@ -352,18 +352,18 @@ ConversationCallTest::testActiveCalls3Peers() auto callId = libjami::placeCallWithMedia(aliceId, "swarm:" + aliceData_.id, {}); auto lastCommitIsCall = [&](const auto& data) { return !data.messages.empty() - && data.messages.rbegin()->at("type") == "application/call-history+json"; + && data.messages.rbegin()->body.at("type") == "application/call-history+json"; }; // should get message cv.wait_for(lk, 30s, [&]() { return lastCommitIsCall(aliceData_) && lastCommitIsCall(bobData_) && lastCommitIsCall(carlaData_); }); - auto confId = bobData_.messages.rbegin()->at("confId"); + auto confId = bobData_.messages.rbegin()->body.at("confId"); auto destination = fmt::format("rdv:{}/{}/{}/{}", bobData_.id, - bobData_.messages.rbegin()->at("uri"), - bobData_.messages.rbegin()->at("device"), + bobData_.messages.rbegin()->body.at("uri"), + bobData_.messages.rbegin()->body.at("device"), confId); aliceData_.conferenceChanged = false; @@ -392,9 +392,9 @@ ConversationCallTest::testActiveCalls3Peers() return !aliceData_.messages.empty() && !bobData_.messages.empty() && !carlaData_.messages.empty(); }); - CPPUNIT_ASSERT(aliceData_.messages[0].find("duration") != aliceData_.messages[0].end()); - CPPUNIT_ASSERT(bobData_.messages[0].find("duration") != bobData_.messages[0].end()); - CPPUNIT_ASSERT(carlaData_.messages[0].find("duration") != carlaData_.messages[0].end()); + CPPUNIT_ASSERT(aliceData_.messages[0].body.find("duration") != aliceData_.messages[0].body.end()); + CPPUNIT_ASSERT(bobData_.messages[0].body.find("duration") != bobData_.messages[0].body.end()); + CPPUNIT_ASSERT(carlaData_.messages[0].body.find("duration") != carlaData_.messages[0].body.end()); // get active calls = 0 CPPUNIT_ASSERT(libjami::getActiveCalls(aliceId, aliceData_.id).size() == 0); @@ -440,7 +440,7 @@ ConversationCallTest::testRejoinCall() auto callId = libjami::placeCallWithMedia(aliceId, "swarm:" + aliceData_.id, {}); auto lastCommitIsCall = [&](const auto& data) { return !data.messages.empty() - && data.messages.rbegin()->at("type") == "application/call-history+json"; + && data.messages.rbegin()->body.at("type") == "application/call-history+json"; }; // should get message cv.wait_for(lk, 30s, [&]() { @@ -448,11 +448,11 @@ ConversationCallTest::testRejoinCall() && lastCommitIsCall(carlaData_); }); - auto confId = bobData_.messages.rbegin()->at("confId"); + auto confId = bobData_.messages.rbegin()->body.at("confId"); auto destination = fmt::format("rdv:{}/{}/{}/{}", bobData_.id, - bobData_.messages.rbegin()->at("uri"), - bobData_.messages.rbegin()->at("device"), + bobData_.messages.rbegin()->body.at("uri"), + bobData_.messages.rbegin()->body.at("device"), confId); aliceData_.conferenceChanged = false; @@ -500,9 +500,9 @@ ConversationCallTest::testRejoinCall() return !aliceData_.messages.empty() && !bobData_.messages.empty() && !carlaData_.messages.empty(); }); - CPPUNIT_ASSERT(aliceData_.messages[0].find("duration") != aliceData_.messages[0].end()); - CPPUNIT_ASSERT(bobData_.messages[0].find("duration") != bobData_.messages[0].end()); - CPPUNIT_ASSERT(carlaData_.messages[0].find("duration") != carlaData_.messages[0].end()); + CPPUNIT_ASSERT(aliceData_.messages[0].body.find("duration") != aliceData_.messages[0].body.end()); + CPPUNIT_ASSERT(bobData_.messages[0].body.find("duration") != bobData_.messages[0].body.end()); + CPPUNIT_ASSERT(carlaData_.messages[0].body.find("duration") != carlaData_.messages[0].body.end()); // get active calls = 0 CPPUNIT_ASSERT(libjami::getActiveCalls(aliceId, aliceData_.id).size() == 0); @@ -536,7 +536,7 @@ ConversationCallTest::testParticipantHangupConfNotRemoved() auto callId = libjami::placeCallWithMedia(aliceId, "swarm:" + aliceData_.id, {}); auto lastCommitIsCall = [&](const auto& data) { return !data.messages.empty() - && data.messages.rbegin()->at("type") == "application/call-history+json"; + && data.messages.rbegin()->body.at("type") == "application/call-history+json"; }; // should get message cv.wait_for(lk, 30s, [&]() { @@ -545,9 +545,9 @@ ConversationCallTest::testParticipantHangupConfNotRemoved() auto destination = fmt::format("rdv:{}/{}/{}/{}", bobData_.id, - bobData_.messages.rbegin()->at("uri"), - bobData_.messages.rbegin()->at("device"), - bobData_.messages.rbegin()->at("confId")); + bobData_.messages.rbegin()->body.at("uri"), + bobData_.messages.rbegin()->body.at("device"), + bobData_.messages.rbegin()->body.at("confId")); aliceData_.conferenceChanged = false; auto bobCallId = libjami::placeCallWithMedia(bobId, destination, {}); @@ -600,19 +600,19 @@ ConversationCallTest::testJoinFinishedCall() auto callId = libjami::placeCallWithMedia(aliceId, "swarm:" + aliceData_.id, {}); auto lastCommitIsCall = [&](const auto& data) { return !data.messages.empty() - && data.messages.rbegin()->at("type") == "application/call-history+json"; + && data.messages.rbegin()->body.at("type") == "application/call-history+json"; }; // should get message cv.wait_for(lk, 30s, [&]() { return lastCommitIsCall(aliceData_) && lastCommitIsCall(bobData_) && lastCommitIsCall(carlaData_); }); - auto confId = bobData_.messages.rbegin()->at("confId"); + auto confId = bobData_.messages.rbegin()->body.at("confId"); auto destination = fmt::format("rdv:{}/{}/{}/{}", bobData_.id, - bobData_.messages.rbegin()->at("uri"), - bobData_.messages.rbegin()->at("device"), - bobData_.messages.rbegin()->at("confId")); + bobData_.messages.rbegin()->body.at("uri"), + bobData_.messages.rbegin()->body.at("device"), + bobData_.messages.rbegin()->body.at("confId")); // hangup aliceData_.messages.clear(); bobData_.messages.clear(); @@ -635,7 +635,7 @@ ConversationCallTest::testJoinFinishedCall() return lastCommitIsCall(aliceData_) && lastCommitIsCall(bobData_) && lastCommitIsCall(carlaData_) && bobData_.hostState == "CURRENT"; }); - confId = bobData_.messages.rbegin()->at("confId"); + confId = bobData_.messages.rbegin()->body.at("confId"); CPPUNIT_ASSERT(libjami::getActiveCalls(aliceId, aliceData_.id).size() == 1); // hangup aliceData_.messages.clear(); @@ -647,9 +647,9 @@ ConversationCallTest::testJoinFinishedCall() return !aliceData_.messages.empty() && !bobData_.messages.empty() && !carlaData_.messages.empty(); }); - CPPUNIT_ASSERT(aliceData_.messages[0].find("duration") != aliceData_.messages[0].end()); - CPPUNIT_ASSERT(bobData_.messages[0].find("duration") != bobData_.messages[0].end()); - CPPUNIT_ASSERT(carlaData_.messages[0].find("duration") != carlaData_.messages[0].end()); + CPPUNIT_ASSERT(aliceData_.messages[0].body.find("duration") != aliceData_.messages[0].body.end()); + CPPUNIT_ASSERT(bobData_.messages[0].body.find("duration") != bobData_.messages[0].body.end()); + CPPUNIT_ASSERT(carlaData_.messages[0].body.find("duration") != carlaData_.messages[0].body.end()); // get active calls = 0 CPPUNIT_ASSERT(libjami::getActiveCalls(aliceId, aliceData_.id).size() == 0); } @@ -697,7 +697,7 @@ ConversationCallTest::testJoinFinishedCallForbidden() auto callId = libjami::placeCallWithMedia(aliceId, "swarm:" + aliceData_.id, {}); auto lastCommitIsCall = [&](const auto& data) { return !data.messages.empty() - && data.messages.rbegin()->at("type") == "application/call-history+json"; + && data.messages.rbegin()->body.at("type") == "application/call-history+json"; }; // should get message cv.wait_for(lk, 30s, [&]() { @@ -705,12 +705,12 @@ ConversationCallTest::testJoinFinishedCallForbidden() && lastCommitIsCall(carlaData_); }); - auto confId = bobData_.messages.rbegin()->at("confId"); + auto confId = bobData_.messages.rbegin()->body.at("confId"); auto destination = fmt::format("rdv:{}/{}/{}/{}", bobData_.id, - bobData_.messages.rbegin()->at("uri"), - bobData_.messages.rbegin()->at("device"), - bobData_.messages.rbegin()->at("confId")); + bobData_.messages.rbegin()->body.at("uri"), + bobData_.messages.rbegin()->body.at("device"), + bobData_.messages.rbegin()->body.at("confId")); // hangup aliceData_.messages.clear(); @@ -738,7 +738,7 @@ ConversationCallTest::testJoinFinishedCallForbidden() && lastCommitIsCall(carlaData_) && bobData_.hostState == "CURRENT"; }); - confId = bobData_.messages.rbegin()->at("confId"); + confId = bobData_.messages.rbegin()->body.at("confId"); CPPUNIT_ASSERT(libjami::getActiveCalls(aliceId, aliceData_.id).size() == 1); @@ -753,9 +753,9 @@ ConversationCallTest::testJoinFinishedCallForbidden() return !aliceData_.messages.empty() && !bobData_.messages.empty() && !carlaData_.messages.empty(); }); - CPPUNIT_ASSERT(aliceData_.messages[0].find("duration") != aliceData_.messages[0].end()); - CPPUNIT_ASSERT(bobData_.messages[0].find("duration") != bobData_.messages[0].end()); - CPPUNIT_ASSERT(carlaData_.messages[0].find("duration") != carlaData_.messages[0].end()); + CPPUNIT_ASSERT(aliceData_.messages[0].body.find("duration") != aliceData_.messages[0].body.end()); + CPPUNIT_ASSERT(bobData_.messages[0].body.find("duration") != bobData_.messages[0].body.end()); + CPPUNIT_ASSERT(carlaData_.messages[0].body.find("duration") != carlaData_.messages[0].body.end()); // get active calls = 0 CPPUNIT_ASSERT(libjami::getActiveCalls(aliceId, aliceData_.id).size() == 0); @@ -787,7 +787,7 @@ ConversationCallTest::testUsePreference() bobData_.messages.clear(); auto lastCommitIsProfile = [&](const auto& data) { return !data.messages.empty() - && data.messages.rbegin()->at("type") == "application/update-profile"; + && data.messages.rbegin()->body.at("type") == "application/update-profile"; }; libjami::updateConversationInfos(aliceId, aliceData_.id, @@ -806,13 +806,13 @@ ConversationCallTest::testUsePreference() auto callId = libjami::placeCallWithMedia(bobId, "swarm:" + aliceData_.id, {}); auto lastCommitIsCall = [&](const auto& data) { return !data.messages.empty() - && data.messages.rbegin()->at("type") == "application/call-history+json"; + && data.messages.rbegin()->body.at("type") == "application/call-history+json"; }; // should get message cv.wait_for(lk, 30s, [&]() { return lastCommitIsCall(aliceData_) && lastCommitIsCall(bobData_); }); - auto confId = bobData_.messages.rbegin()->at("confId"); + auto confId = bobData_.messages.rbegin()->body.at("confId"); // Alice should be the host CPPUNIT_ASSERT(aliceAccount->getConference(confId)); @@ -837,12 +837,12 @@ ConversationCallTest::testJoinWhileActiveCall() auto callId = libjami::placeCallWithMedia(aliceId, "swarm:" + aliceData_.id, {}); auto lastCommitIsCall = [&](const auto& data) { return !data.messages.empty() - && data.messages.rbegin()->at("type") == "application/call-history+json"; + && data.messages.rbegin()->body.at("type") == "application/call-history+json"; }; // should get message CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return lastCommitIsCall(aliceData_); })); - auto confId = aliceData_.messages.rbegin()->at("confId"); + auto confId = aliceData_.messages.rbegin()->body.at("confId"); libjami::addConversationMember(aliceId, aliceData_.id, bobUri); CPPUNIT_ASSERT(cv.wait_for(lk, 60s, [&]() { return bobData_.requestReceived; })); @@ -887,7 +887,7 @@ ConversationCallTest::testCallSelfIfDefaultHost() bobData_.messages.clear(); auto lastCommitIsProfile = [&](const auto& data) { return !data.messages.empty() - && data.messages.rbegin()->at("type") == "application/update-profile"; + && data.messages.rbegin()->body.at("type") == "application/update-profile"; }; libjami::updateConversationInfos(aliceId, aliceData_.id, @@ -906,13 +906,13 @@ ConversationCallTest::testCallSelfIfDefaultHost() auto callId = libjami::placeCallWithMedia(aliceId, "swarm:" + aliceData_.id, {}); auto lastCommitIsCall = [&](const auto& data) { return !data.messages.empty() - && data.messages.rbegin()->at("type") == "application/call-history+json"; + && data.messages.rbegin()->body.at("type") == "application/call-history+json"; }; // should get message CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return lastCommitIsCall(aliceData_) && lastCommitIsCall(bobData_); })); - auto confId = aliceData_.messages.rbegin()->at("confId"); + auto confId = aliceData_.messages.rbegin()->body.at("confId"); // Alice should be the host CPPUNIT_ASSERT(aliceAccount->getConference(confId)); Manager::instance().hangupConference(aliceId, confId); @@ -945,7 +945,7 @@ ConversationCallTest::testNeedsHost() bobData_.messages.clear(); auto lastCommitIsProfile = [&](const auto& data) { return !data.messages.empty() - && data.messages.rbegin()->at("type") == "application/update-profile"; + && data.messages.rbegin()->body.at("type") == "application/update-profile"; }; libjami::updateConversationInfos(aliceId, aliceData_.id, @@ -996,7 +996,7 @@ ConversationCallTest::testAudioOnly() auto callId = libjami::placeCallWithMedia(aliceId, "swarm:" + aliceData_.id, mediaList); // should get message cv.wait_for(lk, 30s, [&]() { return !aliceData_.messages.empty() && !pInfos_.empty(); }); - CPPUNIT_ASSERT(aliceData_.messages[0]["type"] == "application/call-history+json"); + CPPUNIT_ASSERT(aliceData_.messages[0].type == "application/call-history+json"); CPPUNIT_ASSERT(pInfos_.size() == 1); CPPUNIT_ASSERT(pInfos_[0]["videoMuted"] == "true"); @@ -1006,7 +1006,7 @@ ConversationCallTest::testAudioOnly() // should get message cv.wait_for(lk, 30s, [&]() { return !aliceData_.messages.empty(); }); - CPPUNIT_ASSERT(aliceData_.messages[0].find("duration") != aliceData_.messages[0].end()); + CPPUNIT_ASSERT(aliceData_.messages[0].body.find("duration") != aliceData_.messages[0].body.end()); // get active calls = 0 CPPUNIT_ASSERT(libjami::getActiveCalls(aliceId, aliceData_.id).size() == 0); @@ -1052,13 +1052,13 @@ ConversationCallTest::testJoinAfterMuteHost() auto callId = libjami::placeCallWithMedia(aliceId, "swarm:" + aliceData_.id, mediaList); auto lastCommitIsCall = [&](const auto& data) { return !data.messages.empty() - && data.messages.rbegin()->at("type") == "application/call-history+json"; + && data.messages.rbegin()->type == "application/call-history+json"; }; // should get message CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return lastCommitIsCall(aliceData_) && lastCommitIsCall(bobData_) && !pInfos_.empty(); })); - auto confId = bobData_.messages.rbegin()->at("confId"); + auto confId = bobData_.messages.rbegin()->body.at("confId"); // Mute host auto call = std::dynamic_pointer_cast(aliceAccount->getCall(callId)); @@ -1071,8 +1071,8 @@ ConversationCallTest::testJoinAfterMuteHost() // Bob join, alice must stay muted auto destination = fmt::format("rdv:{}/{}/{}/{}", bobData_.id, - bobData_.messages.rbegin()->at("uri"), - bobData_.messages.rbegin()->at("device"), + bobData_.messages.rbegin()->body.at("uri"), + bobData_.messages.rbegin()->body.at("device"), confId); aliceData_.conferenceChanged = false; diff --git a/test/unitTest/conversation/conversation.cpp b/test/unitTest/conversation/conversation.cpp index a092886c7..4fbf617af 100644 --- a/test/unitTest/conversation/conversation.cpp +++ b/test/unitTest/conversation/conversation.cpp @@ -56,6 +56,29 @@ struct ConvInfoTest namespace jami { namespace test { +struct UserData { + std::string conversationId; + bool removed {false}; + bool requestReceived {false}; + bool errorDetected {false}; + bool registered {false}; + bool stopped {false}; + bool deviceAnnounced {false}; + bool composing {false}; + bool sending {false}; + bool sent {false}; + bool searchFinished {false}; + std::string profilePath; + std::string payloadTrustRequest; + std::map profile; + std::vector messages; + std::vector messagesUpdated; + std::vector> reactions; + std::vector> messagesFound; + std::vector reactionRemoved; + std::map preferences; +}; + class ConversationTest : public CppUnit::TestFixture { public: @@ -67,15 +90,22 @@ public: const std::string& fakeCert = ""); std::string aliceId; + UserData aliceData; std::string alice2Id; + UserData alice2Data; std::string bobId; + UserData bobData; std::string bob2Id; + UserData bob2Data; std::string carlaId; + UserData carlaData; std::mutex mtx; std::unique_lock lk {mtx}; std::condition_variable cv; + void connectSignals(); + private: void testCreateConversation(); void testCreateConversationInvalidDisplayName(); @@ -200,10 +230,266 @@ ConversationTest::setUp() bobId = actors["bob"]; carlaId = actors["carla"]; + aliceData = {}; + alice2Data = {}; + bobData = {}; + bob2Data = {}; + carlaData = {}; + Manager::instance().sendRegister(carlaId, false); wait_for_announcement_of({aliceId, bobId}); } +void +ConversationTest::connectSignals() +{ + std::map> confHandlers; + confHandlers.insert( + libjami::exportable_callback( + [&](const std::string& accountId, const std::map&) { + if (accountId == aliceId) { + auto aliceAccount = Manager::instance().getAccount(aliceId); + auto details = aliceAccount->getVolatileAccountDetails(); + auto daemonStatus = details[libjami::Account::ConfProperties::Registration::STATUS]; + if (daemonStatus == "REGISTERED") { + aliceData.registered = true; + } else if (daemonStatus == "UNREGISTERED") { + aliceData.stopped = true; + } + auto deviceAnnounced = details[libjami::Account::VolatileProperties::DEVICE_ANNOUNCED]; + aliceData.deviceAnnounced = deviceAnnounced == "true"; + } else if (accountId == bobId) { + auto bobAccount = Manager::instance().getAccount(bobId); + auto details = bobAccount->getVolatileAccountDetails(); + auto daemonStatus = details[libjami::Account::ConfProperties::Registration::STATUS]; + if (daemonStatus == "REGISTERED") { + bobData.registered = true; + } else if (daemonStatus == "UNREGISTERED") { + bobData.stopped = true; + } + auto deviceAnnounced = details[libjami::Account::VolatileProperties::DEVICE_ANNOUNCED]; + bobData.deviceAnnounced = deviceAnnounced == "true"; + } else if (accountId == bob2Id) { + auto bob2Account = Manager::instance().getAccount(bob2Id); + auto details = bob2Account->getVolatileAccountDetails(); + auto daemonStatus = details[libjami::Account::ConfProperties::Registration::STATUS]; + if (daemonStatus == "REGISTERED") { + bob2Data.registered = true; + } else if (daemonStatus == "UNREGISTERED") { + bob2Data.stopped = true; + } + auto deviceAnnounced = details[libjami::Account::VolatileProperties::DEVICE_ANNOUNCED]; + bob2Data.deviceAnnounced = deviceAnnounced == "true"; + } else if (accountId == carlaId) { + auto carlaAccount = Manager::instance().getAccount(carlaId); + auto details = carlaAccount->getVolatileAccountDetails(); + auto daemonStatus = details[libjami::Account::ConfProperties::Registration::STATUS]; + if (daemonStatus == "REGISTERED") { + carlaData.registered = true; + } else if (daemonStatus == "UNREGISTERED") { + carlaData.stopped = true; + } + auto deviceAnnounced = details[libjami::Account::VolatileProperties::DEVICE_ANNOUNCED]; + carlaData.deviceAnnounced = deviceAnnounced == "true"; + } + cv.notify_one(); + })); + confHandlers.insert(libjami::exportable_callback( + [&](const std::string& accountId, const std::string& conversationId) { + if (accountId == aliceId) { + aliceData.conversationId = conversationId; + } else if (accountId == alice2Id) { + alice2Data.conversationId = conversationId; + } else if (accountId == bobId) { + bobData.conversationId = conversationId; + } else if (accountId == bob2Id) { + bob2Data.conversationId = conversationId; + } else if (accountId == carlaId) { + carlaData.conversationId = conversationId; + } + cv.notify_one(); + })); + confHandlers.insert( + libjami::exportable_callback( + [&](const std::string& account_id, + const std::string& /*from*/, + const std::string& /*conversationId*/, + const std::vector& payload, + time_t /*received*/) { + auto payloadStr = std::string(payload.data(), payload.data() + payload.size()); + if (account_id == aliceId) + aliceData.payloadTrustRequest = payloadStr; + else if (account_id == bobId) + bobData.payloadTrustRequest = payloadStr; + cv.notify_one(); + })); + confHandlers.insert( + libjami::exportable_callback( + [&](const std::string& accountId, + const std::string& /* conversationId */, + std::map /*metadatas*/) { + if (accountId == aliceId) { + aliceData.requestReceived = true; + } else if (accountId == bobId) { + bobData.requestReceived = true; + } else if (accountId == bob2Id) { + bob2Data.requestReceived = true; + } else if (accountId == carlaId) { + carlaData.requestReceived = true; + } + cv.notify_one(); + })); + confHandlers.insert(libjami::exportable_callback( + [&](const std::string& accountId, + const std::string& /* conversationId */, + libjami::SwarmMessage message) { + if (accountId == aliceId) { + aliceData.messages.emplace_back(message); + } else if (accountId == bobId) { + bobData.messages.emplace_back(message); + } else if (accountId == carlaId) { + carlaData.messages.emplace_back(message); + } + cv.notify_one(); + })); + confHandlers.insert(libjami::exportable_callback( + [&](const std::string& accountId, + const std::string& /* conversationId */, + libjami::SwarmMessage message) { + if (accountId == aliceId) { + aliceData.messagesUpdated.emplace_back(message); + } else if (accountId == bobId) { + bobData.messagesUpdated.emplace_back(message); + } else if (accountId == carlaId) { + carlaData.messagesUpdated.emplace_back(message); + } + cv.notify_one(); + })); + confHandlers.insert(libjami::exportable_callback( + [&](const std::string& accountId, + const std::string& /* conversationId */, + const std::string& /* messageId */, + std::map reaction) { + if (accountId == aliceId) { + aliceData.reactions.emplace_back(reaction); + } else if (accountId == bobId) { + bobData.reactions.emplace_back(reaction); + } else if (accountId == carlaId) { + carlaData.reactions.emplace_back(reaction); + } + cv.notify_one(); + })); + confHandlers.insert(libjami::exportable_callback( + [&](const std::string& accountId, + const std::string& /* conversationId */, + const std::string& /* messageId */, + const std::string& reactionId) { + if (accountId == aliceId) { + aliceData.reactionRemoved.emplace_back(reactionId); + } else if (accountId == bobId) { + bobData.reactionRemoved.emplace_back(reactionId); + } else if (accountId == carlaId) { + carlaData.reactionRemoved.emplace_back(reactionId); + } + cv.notify_one(); + })); + confHandlers.insert( + libjami::exportable_callback( + [&](const std::string& accountId, + const std::string& /* conversationId */, + int /*code*/, + const std::string& /* what */) { + if (accountId == aliceId) + aliceData.errorDetected = true; + else if (accountId == bobId) + bobData.errorDetected = true; + else if (accountId == carlaId) + carlaData.errorDetected = true; + cv.notify_one(); + })); + confHandlers.insert( + libjami::exportable_callback( + [&](const std::string& accountId, + const std::string& /*conversationId*/, + const std::string& /*peer*/, + bool state) { + if (accountId == bobId) { + bobData.composing = state; + } + cv.notify_one(); + })); + confHandlers.insert( + libjami::exportable_callback( + [&](const std::string& accountId, + const std::string& /*conversationId*/, + const std::string& /*peer*/, + const std::string& /*msgId*/, + int status) { + if (accountId == aliceId) { + if (status == 2) + aliceData.sending = true; + if (status == 3) + aliceData.sent = true; + } else if (accountId == bobId) { + if (status == 2) + bobData.sending = true; + if (status == 3) + bobData.sent = true; + } + cv.notify_one(); + })); + confHandlers.insert( + libjami::exportable_callback( + [&](const auto& accountId, const auto& /* conversationId */, const auto& profile) { + if (accountId == aliceId) { + aliceData.profile = profile; + } else if (accountId == bobId) { + bobData.profile = profile; + } + cv.notify_one(); + })); + confHandlers.insert( + libjami::exportable_callback( + [&](const std::string& accountId, const std::string&) { + if (accountId == aliceId) + aliceData.removed = true; + else if (accountId == bobId) + bobData.removed = true; + else if (accountId == bob2Id) + bob2Data.removed = true; + cv.notify_one(); + })); + confHandlers.insert(libjami::exportable_callback( + [&](const std::string& accountId, const std::string& peerId, const std::string& path) { + if (accountId == bobId) + bobData.profilePath = path; + cv.notify_one(); + })); + confHandlers.insert( + libjami::exportable_callback( + [&](const std::string& accountId, + const std::string& conversationId, + std::map preferences) { + if (accountId == bobId) + bobData.preferences = preferences; + else if (accountId == bob2Id) + bob2Data.preferences = preferences; + cv.notify_one(); + })); + confHandlers.insert(libjami::exportable_callback( + [&](uint32_t, + const std::string& accountId, + const std::string& conversationId, + std::vector> msg) { + if (accountId == aliceId) { + aliceData.messagesFound.insert(aliceData.messagesFound.end(), msg.begin(), msg.end()); + aliceData.searchFinished = conversationId.empty(); + } + cv.notify_one(); + })); + libjami::registerSignalHandlers(confHandlers); +} + void ConversationTest::tearDown() { @@ -226,31 +512,20 @@ void ConversationTest::testCreateConversation() { std::cout << "\nRunning test: " << __func__ << std::endl; + connectSignals(); auto aliceAccount = Manager::instance().getAccount(aliceId); auto aliceDeviceId = aliceAccount->currentDeviceId(); auto uri = aliceAccount->getUsername(); - std::map> confHandlers; - bool conversationReady = false; - confHandlers.insert(libjami::exportable_callback( - [&](const std::string& accountId, const std::string& /* conversationId */) { - if (accountId == aliceId) { - conversationReady = true; - cv.notify_one(); - } - })); - libjami::registerSignalHandlers(confHandlers); - // Start conversation auto convId = libjami::startConversation(aliceId); - cv.wait_for(lk, 30s, [&]() { return conversationReady; }); - CPPUNIT_ASSERT(conversationReady); + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return !aliceData.conversationId.empty(); })); ConversationRepository repo(aliceAccount, convId); CPPUNIT_ASSERT(repo.mode() == ConversationMode::INVITES_ONLY); // Assert that repository exists - auto repoPath = fileutils::get_data_dir() / aliceAccount->getAccountID() + auto repoPath = fileutils::get_data_dir() / aliceId / "conversations" / convId; CPPUNIT_ASSERT(std::filesystem::is_directory(repoPath)); // Check created files @@ -341,24 +616,14 @@ void ConversationTest::testGetConversationsAfterRm() { std::cout << "\nRunning test: " << __func__ << std::endl; + connectSignals(); auto aliceAccount = Manager::instance().getAccount(aliceId); auto uri = aliceAccount->getUsername(); - std::map> confHandlers; - bool conversationReady = false; - confHandlers.insert(libjami::exportable_callback( - [&](const std::string& accountId, const std::string& /* conversationId */) { - if (accountId == aliceId) { - conversationReady = true; - cv.notify_one(); - } - })); - libjami::registerSignalHandlers(confHandlers); - // Start conversation auto convId = libjami::startConversation(aliceId); - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return conversationReady; })); + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return !aliceData.conversationId.empty(); })); auto conversations = libjami::getConversations(aliceId); CPPUNIT_ASSERT(conversations.size() == 1); @@ -371,24 +636,11 @@ void ConversationTest::testRemoveInvalidConversation() { std::cout << "\nRunning test: " << __func__ << std::endl; - - auto aliceAccount = Manager::instance().getAccount(aliceId); - auto uri = aliceAccount->getUsername(); - - std::map> confHandlers; - bool conversationReady = false; - confHandlers.insert(libjami::exportable_callback( - [&](const std::string& accountId, const std::string& /* conversationId */) { - if (accountId == aliceId) { - conversationReady = true; - cv.notify_one(); - } - })); - libjami::registerSignalHandlers(confHandlers); + connectSignals(); // Start conversation auto convId = libjami::startConversation(aliceId); - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return conversationReady; })); + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return !aliceData.conversationId.empty(); })); auto conversations = libjami::getConversations(aliceId); CPPUNIT_ASSERT(conversations.size() == 1); @@ -401,203 +653,86 @@ void ConversationTest::testSendMessage() { std::cout << "\nRunning test: " << __func__ << std::endl; + connectSignals(); - auto aliceAccount = Manager::instance().getAccount(aliceId); auto bobAccount = Manager::instance().getAccount(bobId); auto bobUri = bobAccount->getUsername(); - std::map> confHandlers; - auto messageBobReceived = 0, messageAliceReceived = 0; - bool requestReceived = false; - bool conversationReady = false; - confHandlers.insert(libjami::exportable_callback( - [&](const std::string& accountId, - const std::string& /* conversationId */, - std::map /*message*/) { - if (accountId == bobId) { - messageBobReceived += 1; - } else { - messageAliceReceived += 1; - } - cv.notify_one(); - })); - confHandlers.insert( - libjami::exportable_callback( - [&](const std::string& /*accountId*/, - const std::string& /* conversationId */, - std::map /*metadatas*/) { - requestReceived = true; - cv.notify_one(); - })); - confHandlers.insert(libjami::exportable_callback( - [&](const std::string& accountId, const std::string& /* conversationId */) { - if (accountId == bobId) { - conversationReady = true; - cv.notify_one(); - } - })); - libjami::registerSignalHandlers(confHandlers); - auto convId = libjami::startConversation(aliceId); - libjami::addConversationMember(aliceId, convId, bobUri); - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return requestReceived; })); + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return bobData.requestReceived; })); libjami::acceptConversationRequest(bobId, convId); - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return conversationReady; })); + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return !bobData.conversationId.empty(); })); // Assert that repository exists - auto repoPath = fileutils::get_data_dir() / bobAccount->getAccountID() + auto repoPath = fileutils::get_data_dir() / bobId / "conversations" / convId; CPPUNIT_ASSERT(std::filesystem::is_directory(repoPath)); // Wait that alice sees Bob - cv.wait_for(lk, 30s, [&]() { return messageAliceReceived == 2; }); + cv.wait_for(lk, 30s, [&]() { return aliceData.messages.size() == 2; }); + auto bobMsgSize = bobData.messages.size(); libjami::sendMessage(aliceId, convId, "hi"s, ""); - cv.wait_for(lk, 30s, [&]() { return messageBobReceived == 1; }); + cv.wait_for(lk, 30s, [&]() { return bobData.messages.size() == bobMsgSize + 1; }); } void ConversationTest::testSendMessageWithBadDisplayName() { std::cout << "\nRunning test: " << __func__ << std::endl; + connectSignals(); - auto aliceAccount = Manager::instance().getAccount(aliceId); auto bobAccount = Manager::instance().getAccount(bobId); auto bobUri = bobAccount->getUsername(); - std::map> confHandlers; - auto messageBobReceived = 0, messageAliceReceived = 0; - bool requestReceived = false; - bool conversationReady = false; - confHandlers.insert(libjami::exportable_callback( - [&](const std::string& accountId, - const std::string& /* conversationId */, - std::map /*message*/) { - if (accountId == bobId) { - messageBobReceived += 1; - } else { - messageAliceReceived += 1; - } - cv.notify_one(); - })); - confHandlers.insert( - libjami::exportable_callback( - [&](const std::string& /*accountId*/, - const std::string& /* conversationId */, - std::map /*metadatas*/) { - requestReceived = true; - cv.notify_one(); - })); - confHandlers.insert(libjami::exportable_callback( - [&](const std::string& accountId, const std::string& /* conversationId */) { - if (accountId == bobId) { - conversationReady = true; - cv.notify_one(); - } - })); - bool aliceRegistered = false; - confHandlers.insert( - libjami::exportable_callback( - [&](const std::string&, const std::map&) { - auto details = aliceAccount->getVolatileAccountDetails(); - auto daemonStatus = details[libjami::Account::ConfProperties::Registration::STATUS]; - if (daemonStatus == "REGISTERED") { - aliceRegistered = true; - cv.notify_one(); - } - })); - libjami::registerSignalHandlers(confHandlers); - std::map details; details[ConfProperties::DISPLAYNAME] = ""; libjami::setAccountDetails(aliceId, details); - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return aliceRegistered; })); + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return aliceData.registered; })); auto convId = libjami::startConversation(aliceId); - libjami::addConversationMember(aliceId, convId, bobUri); - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return requestReceived; })); + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return bobData.requestReceived; })); libjami::acceptConversationRequest(bobId, convId); - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return conversationReady; })); + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return !bobData.conversationId.empty(); })); // Assert that repository exists - auto repoPath = fileutils::get_data_dir() / bobAccount->getAccountID() + auto repoPath = fileutils::get_data_dir() / bobId / "conversations" / convId; CPPUNIT_ASSERT(std::filesystem::is_directory(repoPath)); // Wait that alice sees Bob - cv.wait_for(lk, 30s, [&]() { return messageAliceReceived == 2; }); + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return aliceData.messages.size() == 2; })); + auto bobMsgSize = bobData.messages.size(); libjami::sendMessage(aliceId, convId, "hi"s, ""); - cv.wait_for(lk, 30s, [&]() { return messageBobReceived == 1; }); + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return bobData.messages.size() == bobMsgSize + 1; })); } void ConversationTest::testReplaceWithBadCertificate() { std::cout << "\nRunning test: " << __func__ << std::endl; + connectSignals(); auto aliceAccount = Manager::instance().getAccount(aliceId); auto bobAccount = Manager::instance().getAccount(bobId); auto bobUri = bobAccount->getUsername(); - std::map> confHandlers; - auto messageBobReceived = 0, messageAliceReceived = 0; - confHandlers.insert(libjami::exportable_callback( - [&](const std::string& accountId, - const std::string& /* conversationId */, - std::map /*message*/) { - if (accountId == bobId) { - messageBobReceived += 1; - } else { - messageAliceReceived += 1; - } - cv.notify_one(); - })); - auto requestReceived = false; - confHandlers.insert( - libjami::exportable_callback( - [&](const std::string& /*accountId*/, - const std::string& /* conversationId */, - std::map /*metadatas*/) { - requestReceived = true; - cv.notify_one(); - })); - auto conversationReady = false; - confHandlers.insert(libjami::exportable_callback( - [&](const std::string& accountId, const std::string& /* conversationId */) { - if (accountId == bobId) { - conversationReady = true; - cv.notify_one(); - } - })); - auto errorDetected = false; - confHandlers.insert( - libjami::exportable_callback( - [&](const std::string& /* accountId */, - const std::string& /* conversationId */, - int code, - const std::string& /* what */) { - if (code == 3) - errorDetected = true; - cv.notify_one(); - })); - libjami::registerSignalHandlers(confHandlers); - auto convId = libjami::startConversation(aliceId); libjami::addConversationMember(aliceId, convId, bobUri); - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return requestReceived; })); + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return bobData.requestReceived; })); libjami::acceptConversationRequest(bobId, convId); - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return conversationReady; })); + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return !bobData.conversationId.empty(); })); // Wait that alice sees Bob - cv.wait_for(lk, 30s, [&]() { return messageAliceReceived == 2; }); + cv.wait_for(lk, 30s, [&]() { return aliceData.messages.size() == 2; }); // Replace alice's certificate with a bad one. - auto repoPath = fileutils::get_data_dir() / aliceAccount->getAccountID() / "conversations" / convId; + auto repoPath = fileutils::get_data_dir() / aliceId / "conversations" / convId; auto aliceDevicePath = repoPath / "devices" / fmt::format("{}.crt", aliceAccount->currentDeviceId()); auto bobDevicePath = repoPath / "devices" / fmt::format("{}.crt", bobAccount->currentDeviceId()); std::filesystem::copy(bobDevicePath, @@ -613,50 +748,33 @@ ConversationTest::testReplaceWithBadCertificate() wbuilder["commentStyle"] = "None"; wbuilder["indentation"] = ""; auto message = Json::writeString(wbuilder, root); - messageBobReceived = 0; commitInRepo(repoPath, aliceAccount, message); // now we need to sync! + bobData.errorDetected = false; libjami::sendMessage(aliceId, convId, "trigger sync!"s, ""); // We should detect the incorrect commit! - cv.wait_for(lk, 30s, [&]() { return errorDetected; }); + cv.wait_for(lk, 30s, [&]() { return bobData.errorDetected; }); } void ConversationTest::testSendMessageTriggerMessageReceived() { std::cout << "\nRunning test: " << __func__ << std::endl; - - auto aliceAccount = Manager::instance().getAccount(aliceId); - std::map> confHandlers; - auto messageReceived = 0; - bool conversationReady = false; - confHandlers.insert(libjami::exportable_callback( - [&](const std::string& /* accountId */, - const std::string& /* conversationId */, - std::map /*message*/) { - messageReceived += 1; - cv.notify_one(); - })); - confHandlers.insert(libjami::exportable_callback( - [&](const std::string& /* accountId */, const std::string& /* conversationId */) { - conversationReady = true; - cv.notify_one(); - })); - libjami::registerSignalHandlers(confHandlers); + connectSignals(); auto convId = libjami::startConversation(aliceId); - cv.wait_for(lk, 30s, [&] { return conversationReady; }); + cv.wait_for(lk, 30s, [&] { return !aliceData.conversationId.empty(); }); + auto msgSize = aliceData.messages.size(); libjami::sendMessage(aliceId, convId, "hi"s, ""); - cv.wait_for(lk, 30s, [&] { return messageReceived == 1; }); - CPPUNIT_ASSERT(messageReceived == 1); - libjami::unregisterSignalHandlers(); + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&] { return aliceData.messages.size() == msgSize + 1; })); } void ConversationTest::testMergeTwoDifferentHeads() { std::cout << "\nRunning test: " << __func__ << std::endl; + connectSignals(); auto aliceAccount = Manager::instance().getAccount(aliceId); auto carlaAccount = Manager::instance().getAccount(carlaId); @@ -666,33 +784,15 @@ ConversationTest::testMergeTwoDifferentHeads() carlaAccount->trackBuddyPresence(aliceUri, true); auto convId = libjami::startConversation(aliceId); - std::map> confHandlers; - bool conversationReady = false, carlaGotMessage = false; - confHandlers.insert(libjami::exportable_callback( - [&](const std::string& accountId, const std::string& /* conversationId */) { - if (accountId == carlaId) { - conversationReady = true; - cv.notify_one(); - } - })); - confHandlers.insert(libjami::exportable_callback( - [&](const std::string& accountId, - const std::string& conversationId, - std::map /* message */) { - if (accountId == carlaId && conversationId == convId) { - carlaGotMessage = true; - } - cv.notify_one(); - })); - libjami::registerSignalHandlers(confHandlers); - + auto msgSize = aliceData.messages.size(); aliceAccount->convModule()->addConversationMember(convId, carlaUri, false); + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return aliceData.messages.size() == msgSize + 1; })); // Cp conversations & convInfo - auto repoPathAlice = fileutils::get_data_dir() / aliceAccount->getAccountID() / "conversations"; + auto repoPathAlice = fileutils::get_data_dir() / aliceId / "conversations"; auto repoPathCarla = fileutils::get_data_dir() / carlaAccount->getAccountID() / "conversations"; std::filesystem::copy(repoPathAlice, repoPathCarla, std::filesystem::copy_options::recursive); - auto ciPathAlice = fileutils::get_data_dir() / aliceAccount->getAccountID() + auto ciPathAlice = fileutils::get_data_dir() / aliceId / "convInfo"; auto ciPathCarla = fileutils::get_data_dir() / carlaAccount->getAccountID() / "convInfo"; @@ -710,9 +810,7 @@ ConversationTest::testMergeTwoDifferentHeads() // Start Carla, should merge and all messages should be there Manager::instance().sendRegister(carlaId, true); - carlaGotMessage = false; - CPPUNIT_ASSERT(cv.wait_for(lk, 60s, [&] { return carlaGotMessage; })); - libjami::unregisterSignalHandlers(); + CPPUNIT_ASSERT(cv.wait_for(lk, 60s, [&] { return !carlaData.messages.empty(); })); } void @@ -797,7 +895,7 @@ ConversationTest::testSendMessageToMultipleParticipants() })); // Assert that repository exists - auto repoPath = fileutils::get_data_dir() / bobAccount->getAccountID() + auto repoPath = fileutils::get_data_dir() / bobId / "conversations" / convId; CPPUNIT_ASSERT(std::filesystem::is_directory(repoPath)); repoPath = fileutils::get_data_dir() / carlaAccount->getAccountID() @@ -815,288 +913,124 @@ void ConversationTest::testPingPongMessages() { std::cout << "\nRunning test: " << __func__ << std::endl; + connectSignals(); - auto aliceAccount = Manager::instance().getAccount(aliceId); auto bobAccount = Manager::instance().getAccount(bobId); auto bobUri = bobAccount->getUsername(); - std::map> confHandlers; - auto messageBobReceived = 0, messageAliceReceived = 0; - bool requestReceived = false; - bool conversationReady = false; - confHandlers.insert(libjami::exportable_callback( - [&](const std::string& accountId, - const std::string& /* conversationId */, - std::map /*message*/) { - if (accountId == bobId) - messageBobReceived += 1; - if (accountId == aliceId) - messageAliceReceived += 1; - cv.notify_one(); - })); - confHandlers.insert( - libjami::exportable_callback( - [&](const std::string& /*accountId*/, - const std::string& /* conversationId */, - std::map /*metadatas*/) { - requestReceived = true; - cv.notify_one(); - })); - confHandlers.insert(libjami::exportable_callback( - [&](const std::string& accountId, const std::string& /* conversationId */) { - if (accountId == bobId) { - conversationReady = true; - cv.notify_one(); - } - })); - libjami::registerSignalHandlers(confHandlers); auto convId = libjami::startConversation(aliceId); libjami::addConversationMember(aliceId, convId, bobUri); - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return requestReceived; })); - messageAliceReceived = 0; + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return bobData.requestReceived; })); + auto aliceMsgSize = aliceData.messages.size(); libjami::acceptConversationRequest(bobId, convId); CPPUNIT_ASSERT( - cv.wait_for(lk, 60s, [&]() { return conversationReady && messageAliceReceived == 1; })); + cv.wait_for(lk, 60s, [&]() { return !bobData.conversationId.empty() && aliceMsgSize + 1 == aliceData.messages.size(); })); // Assert that repository exists - auto repoPath = fileutils::get_data_dir() / bobAccount->getAccountID() + auto repoPath = fileutils::get_data_dir() / bobId / "conversations" / convId; CPPUNIT_ASSERT(std::filesystem::is_directory(repoPath)); - messageBobReceived = 0; - messageAliceReceived = 0; + aliceMsgSize = aliceData.messages.size(); + auto bobMsgSize = bobData.messages.size(); libjami::sendMessage(aliceId, convId, "ping"s, ""); CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { - return messageBobReceived == 1 && messageAliceReceived == 1; + return bobMsgSize + 1 == bobData.messages.size() && aliceMsgSize + 1 == aliceData.messages.size(); })); libjami::sendMessage(bobId, convId, "pong"s, ""); CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { - return messageBobReceived == 2 && messageAliceReceived == 2; + return bobMsgSize + 2 == bobData.messages.size() && aliceMsgSize + 2 == aliceData.messages.size(); })); libjami::sendMessage(bobId, convId, "ping"s, ""); CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { - return messageBobReceived == 3 && messageAliceReceived == 3; + return bobMsgSize + 3 == bobData.messages.size() && aliceMsgSize + 3 == aliceData.messages.size(); })); libjami::sendMessage(aliceId, convId, "pong"s, ""); CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { - return messageBobReceived == 4 && messageAliceReceived == 4; + return bobMsgSize + 4 == bobData.messages.size() && aliceMsgSize + 4 == aliceData.messages.size(); })); - libjami::unregisterSignalHandlers(); } void ConversationTest::testIsComposing() { std::cout << "\nRunning test: " << __func__ << std::endl; + connectSignals(); auto aliceAccount = Manager::instance().getAccount(aliceId); auto bobAccount = Manager::instance().getAccount(bobId); - auto aliceUri = aliceAccount->getUsername(); auto bobUri = bobAccount->getUsername(); auto convId = libjami::startConversation(aliceId); - std::map> confHandlers; - bool conversationReady = false, requestReceived = false, memberMessageGenerated = false, - aliceComposing = false; - confHandlers.insert( - libjami::exportable_callback( - [&](const std::string& /*accountId*/, - const std::string& /* conversationId */, - std::map /*metadatas*/) { - requestReceived = true; - cv.notify_one(); - })); - confHandlers.insert(libjami::exportable_callback( - [&](const std::string& accountId, const std::string& conversationId) { - if (accountId == bobId && conversationId == convId) { - conversationReady = true; - cv.notify_one(); - } - })); - confHandlers.insert(libjami::exportable_callback( - [&](const std::string& accountId, - const std::string& conversationId, - std::map message) { - if (accountId == aliceId && conversationId == convId && message["type"] == "member") { - memberMessageGenerated = true; - cv.notify_one(); - } - })); - confHandlers.insert( - libjami::exportable_callback( - [&](const std::string& accountId, - const std::string& conversationId, - const std::string& peer, - bool state) { - if (accountId == bobId && conversationId == convId && peer == aliceUri) { - aliceComposing = state; - cv.notify_one(); - } - })); - libjami::registerSignalHandlers(confHandlers); + auto aliceMsgSize = aliceData.messages.size(); libjami::addConversationMember(aliceId, convId, bobUri); - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return memberMessageGenerated; })); + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return aliceMsgSize + 1 == aliceData.messages.size(); })); // Assert that repository exists - auto repoPath = fileutils::get_data_dir() / aliceAccount->getAccountID() + auto repoPath = fileutils::get_data_dir() / aliceId / "conversations" / convId; CPPUNIT_ASSERT(std::filesystem::is_directory(repoPath)); // Check created files auto bobInvited = repoPath / "invited" / bobUri; CPPUNIT_ASSERT(std::filesystem::is_regular_file(bobInvited)); - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return requestReceived; })); - memberMessageGenerated = false; + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return bobData.requestReceived; })); libjami::acceptConversationRequest(bobId, convId); - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return memberMessageGenerated; })); + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return aliceMsgSize + 2 == aliceData.messages.size(); })); aliceAccount->setIsComposing("swarm:" + convId, true); - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return aliceComposing; })); - + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return bobData.composing; })); aliceAccount->setIsComposing("swarm:" + convId, false); - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return !aliceComposing; })); + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return !bobData.composing; })); } void ConversationTest::testMessageStatus() { std::cout << "\nRunning test: " << __func__ << std::endl; + connectSignals(); - auto aliceAccount = Manager::instance().getAccount(aliceId); auto bobAccount = Manager::instance().getAccount(bobId); - auto aliceUri = aliceAccount->getUsername(); auto bobUri = bobAccount->getUsername(); auto convId = libjami::startConversation(aliceId); - std::map> confHandlers; - bool conversationReady = false, requestReceived = false, memberMessageGenerated = false; - confHandlers.insert( - libjami::exportable_callback( - [&](const std::string& /*accountId*/, - const std::string& /* conversationId */, - std::map /*metadatas*/) { - requestReceived = true; - cv.notify_one(); - })); - confHandlers.insert(libjami::exportable_callback( - [&](const std::string& accountId, const std::string& conversationId) { - if (accountId == bobId && conversationId == convId) { - conversationReady = true; - cv.notify_one(); - } - })); - confHandlers.insert(libjami::exportable_callback( - [&](const std::string& accountId, - const std::string& conversationId, - std::map message) { - if (accountId == aliceId && conversationId == convId) { - if (message["type"] == "member") - memberMessageGenerated = true; - cv.notify_one(); - } - })); - bool sending = false, sent = false; - confHandlers.insert( - libjami::exportable_callback( - [&](const std::string& accountId, - const std::string& conversationId, - const std::string& peer, - const std::string& msgId, - int status) { - if (accountId == aliceId && convId == conversationId) { - if (status == 2) - sending = true; - if (status == 3) - sent = true; - cv.notify_one(); - } - })); - libjami::registerSignalHandlers(confHandlers); + auto aliceMsgSize = aliceData.messages.size(); libjami::addConversationMember(aliceId, convId, bobUri); - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return memberMessageGenerated; })); + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return aliceMsgSize + 1 == aliceData.messages.size(); })); // Assert that repository exists - auto repoPath = fileutils::get_data_dir() / aliceAccount->getAccountID() + auto repoPath = fileutils::get_data_dir() / aliceId / "conversations" / convId; CPPUNIT_ASSERT(std::filesystem::is_directory(repoPath)); // Check created files auto bobInvited = repoPath / "invited" / bobUri; CPPUNIT_ASSERT(std::filesystem::is_regular_file(bobInvited)); - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return requestReceived; })); - memberMessageGenerated = false; + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return bobData.requestReceived; })); libjami::acceptConversationRequest(bobId, convId); - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return memberMessageGenerated; })); + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return aliceMsgSize + 2 == aliceData.messages.size(); })); - sending = false; - sent = false; + aliceData.sending = false; + aliceData.sent = false; libjami::sendMessage(aliceId, convId, "hi"s, ""); - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return sending && sent; })); - - libjami::unregisterSignalHandlers(); + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return aliceData.sending && aliceData.sent; })); } void ConversationTest::testSetMessageDisplayed() { std::cout << "\nRunning test: " << __func__ << std::endl; + connectSignals(); auto aliceAccount = Manager::instance().getAccount(aliceId); auto bobAccount = Manager::instance().getAccount(bobId); auto aliceUri = aliceAccount->getUsername(); auto bobUri = bobAccount->getUsername(); auto convId = libjami::startConversation(aliceId); - std::map> confHandlers; - bool conversationReady = false, requestReceived = false, memberMessageGenerated = false, - msgDisplayed = false; - confHandlers.insert( - libjami::exportable_callback( - [&](const std::string& /*accountId*/, - const std::string& /* conversationId */, - std::map /*metadatas*/) { - requestReceived = true; - cv.notify_one(); - })); - confHandlers.insert(libjami::exportable_callback( - [&](const std::string& accountId, const std::string& conversationId) { - if (accountId == bobId && conversationId == convId) { - conversationReady = true; - cv.notify_one(); - } - })); - confHandlers.insert(libjami::exportable_callback( - [&](const std::string& accountId, - const std::string& conversationId, - std::map message) { - if (accountId == aliceId && conversationId == convId) { - if (message["type"] == "member") - memberMessageGenerated = true; - cv.notify_one(); - } - })); - std::string aliceLastMsg; - confHandlers.insert( - libjami::exportable_callback( - [&](const std::string& accountId, - const std::string& conversationId, - const std::string& peer, - const std::string& msgId, - int status) { - if (conversationId == convId && peer == aliceUri && status == 3) { - if (accountId == bobId && msgId == conversationId) - msgDisplayed = true; - else if (accountId == aliceId) - aliceLastMsg = msgId; - cv.notify_one(); - } - })); - libjami::registerSignalHandlers(confHandlers); - aliceLastMsg = ""; + auto aliceMsgSize = aliceData.messages.size(); libjami::addConversationMember(aliceId, convId, bobUri); - CPPUNIT_ASSERT( - cv.wait_for(lk, 30s, [&]() { return memberMessageGenerated && !aliceLastMsg.empty(); })); + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return aliceMsgSize + 1 == aliceData.messages.size(); })); // Assert that repository exists - auto repoPath = fileutils::get_data_dir() / aliceAccount->getAccountID() + auto repoPath = fileutils::get_data_dir() / aliceId / "conversations" / convId; CPPUNIT_ASSERT(std::filesystem::is_directory(repoPath)); // Check created files auto bobInvited = repoPath / "invited" / bobUri; CPPUNIT_ASSERT(std::filesystem::is_regular_file(bobInvited)); - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return requestReceived; })); - memberMessageGenerated = false; + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return bobData.requestReceived; })); libjami::acceptConversationRequest(bobId, convId); - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return memberMessageGenerated; })); + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return aliceMsgSize + 2 == aliceData.messages.size(); })); // Last displayed messages should not be set yet auto membersInfos = libjami::getConversationMembers(bobId, convId); @@ -1112,12 +1046,12 @@ ConversationTest::testSetMessageDisplayed() [&](auto infos) { // Last read for alice is when bob is added to the members return infos["uri"] == aliceUri - && infos["lastDisplayed"] == aliceLastMsg; + && infos["lastDisplayed"] == aliceData.messages[0].id; }) != membersInfos.end()); - + bobData.sent = false; aliceAccount->setMessageDisplayed("swarm:" + convId, convId, 3); - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return msgDisplayed; })); + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return bobData.sent; })); // Now, the last displayed message should be updated in member's infos (both sides) membersInfos = libjami::getConversationMembers(bobId, convId); @@ -1136,170 +1070,65 @@ ConversationTest::testSetMessageDisplayed() && infos["lastDisplayed"] == convId; }) != membersInfos.end()); - - libjami::unregisterSignalHandlers(); } void ConversationTest::testSetMessageDisplayedTwice() { std::cout << "\nRunning test: " << __func__ << std::endl; + connectSignals(); auto aliceAccount = Manager::instance().getAccount(aliceId); auto bobAccount = Manager::instance().getAccount(bobId); - auto aliceUri = aliceAccount->getUsername(); auto bobUri = bobAccount->getUsername(); auto convId = libjami::startConversation(aliceId); - std::map> confHandlers; - bool conversationReady = false, requestReceived = false, memberMessageGenerated = false, - msgDisplayed = false; - confHandlers.insert( - libjami::exportable_callback( - [&](const std::string& /*accountId*/, - const std::string& /* conversationId */, - std::map /*metadatas*/) { - requestReceived = true; - cv.notify_one(); - })); - confHandlers.insert(libjami::exportable_callback( - [&](const std::string& accountId, const std::string& conversationId) { - if (accountId == bobId && conversationId == convId) { - conversationReady = true; - cv.notify_one(); - } - })); - confHandlers.insert(libjami::exportable_callback( - [&](const std::string& accountId, - const std::string& conversationId, - std::map message) { - if (accountId == aliceId && conversationId == convId) { - if (message["type"] == "member") - memberMessageGenerated = true; - cv.notify_one(); - } - })); - std::string aliceLastMsg; - confHandlers.insert( - libjami::exportable_callback( - [&](const std::string& accountId, - const std::string& conversationId, - const std::string& peer, - const std::string& msgId, - int status) { - if (conversationId == convId && peer == aliceUri && status == 3) { - if (accountId == bobId && msgId == conversationId) - msgDisplayed = true; - else if (accountId == aliceId) - aliceLastMsg = msgId; - cv.notify_one(); - } - })); - libjami::registerSignalHandlers(confHandlers); - aliceLastMsg = ""; + auto aliceMsgSize = aliceData.messages.size(); libjami::addConversationMember(aliceId, convId, bobUri); - CPPUNIT_ASSERT( - cv.wait_for(lk, 30s, [&]() { return memberMessageGenerated && !aliceLastMsg.empty(); })); + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return aliceMsgSize + 1 == aliceData.messages.size(); })); // Assert that repository exists - auto repoPath = fileutils::get_data_dir() / aliceAccount->getAccountID() + auto repoPath = fileutils::get_data_dir() / aliceId / "conversations" / convId; CPPUNIT_ASSERT(std::filesystem::is_directory(repoPath)); // Check created files auto bobInvited = repoPath / "invited" / bobUri; CPPUNIT_ASSERT(std::filesystem::is_regular_file(bobInvited)); - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return requestReceived; })); - memberMessageGenerated = false; + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return bobData.requestReceived; })); libjami::acceptConversationRequest(bobId, convId); - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return memberMessageGenerated; })); + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return aliceMsgSize + 2 == aliceData.messages.size(); })); + bobData.sent = false; aliceAccount->setMessageDisplayed("swarm:" + convId, convId, 3); - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return msgDisplayed; })); + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return bobData.sent; })); - msgDisplayed = false; + bobData.sent = false; aliceAccount->setMessageDisplayed("swarm:" + convId, convId, 3); - CPPUNIT_ASSERT(!cv.wait_for(lk, 10s, [&]() { return msgDisplayed; })); - - libjami::unregisterSignalHandlers(); + CPPUNIT_ASSERT(!cv.wait_for(lk, 10s, [&]() { return bobData.sent; })); } void ConversationTest::testSetMessageDisplayedPreference() { std::cout << "\nRunning test: " << __func__ << std::endl; + connectSignals(); auto aliceAccount = Manager::instance().getAccount(aliceId); auto bobAccount = Manager::instance().getAccount(bobId); auto aliceUri = aliceAccount->getUsername(); auto bobUri = bobAccount->getUsername(); auto convId = libjami::startConversation(aliceId); - std::map> confHandlers; - bool conversationReady = false, requestReceived = false, memberMessageGenerated = false, - msgDisplayed = false, aliceRegistered = false; - confHandlers.insert( - libjami::exportable_callback( - [&](const std::string& /*accountId*/, - const std::string& /* conversationId */, - std::map /*metadatas*/) { - requestReceived = true; - cv.notify_one(); - })); - confHandlers.insert(libjami::exportable_callback( - [&](const std::string& accountId, const std::string& conversationId) { - if (accountId == bobId && conversationId == convId) { - conversationReady = true; - cv.notify_one(); - } - })); - confHandlers.insert(libjami::exportable_callback( - [&](const std::string& accountId, - const std::string& conversationId, - std::map message) { - if (accountId == aliceId && conversationId == convId && message["type"] == "member") { - memberMessageGenerated = true; - cv.notify_one(); - } - })); - std::string aliceLastMsg; - confHandlers.insert( - libjami::exportable_callback( - [&](const std::string& accountId, - const std::string& conversationId, - const std::string& peer, - const std::string& msgId, - int status) { - if (conversationId == convId && peer == aliceUri && status == 3) { - if (accountId == bobId && msgId == conversationId) - msgDisplayed = true; - else if (accountId == aliceId) - aliceLastMsg = msgId; - cv.notify_one(); - } - })); - confHandlers.insert( - libjami::exportable_callback( - [&](const std::string&, const std::map&) { - auto details = aliceAccount->getVolatileAccountDetails(); - auto daemonStatus = details[libjami::Account::ConfProperties::Registration::STATUS]; - if (daemonStatus == "REGISTERED") { - aliceRegistered = true; - cv.notify_one(); - } - })); - libjami::registerSignalHandlers(confHandlers); auto details = aliceAccount->getAccountDetails(); CPPUNIT_ASSERT(details[ConfProperties::SENDREADRECEIPT] == "true"); details[ConfProperties::SENDREADRECEIPT] = "false"; libjami::setAccountDetails(aliceId, details); - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return aliceRegistered; })); + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return aliceData.registered; })); - aliceLastMsg = ""; + auto aliceMsgSize = aliceData.messages.size(); libjami::addConversationMember(aliceId, convId, bobUri); - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { - return requestReceived && memberMessageGenerated && !aliceLastMsg.empty(); - })); - memberMessageGenerated = false; + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return bobData.requestReceived && aliceMsgSize + 1 == aliceData.messages.size(); })); + libjami::acceptConversationRequest(bobId, convId); - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return memberMessageGenerated; })); + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return aliceMsgSize + 2 == aliceData.messages.size(); })); // Last displayed messages should not be set yet auto membersInfos = libjami::getConversationMembers(aliceId, convId); @@ -1308,13 +1137,13 @@ ConversationTest::testSetMessageDisplayedPreference() [&](auto infos) { // Last read for alice is when bob is added to the members return infos["uri"] == aliceUri - && infos["lastDisplayed"] == aliceLastMsg; + && infos["lastDisplayed"] == aliceData.messages[0].id; }) != membersInfos.end()); aliceAccount->setMessageDisplayed("swarm:" + convId, convId, 3); // Bob should not receive anything here, as sendMessageDisplayed is disabled for Alice - CPPUNIT_ASSERT(!cv.wait_for(lk, 10s, [&]() { return msgDisplayed; })); + CPPUNIT_ASSERT(!cv.wait_for(lk, 10s, [&]() { return bobData.sent; })); // Assert that message is set as displayed for self (for the read status) membersInfos = libjami::getConversationMembers(aliceId, convId); @@ -1325,85 +1154,25 @@ ConversationTest::testSetMessageDisplayedPreference() && infos["lastDisplayed"] == convId; }) != membersInfos.end()); - libjami::unregisterSignalHandlers(); } void ConversationTest::testSetMessageDisplayedAfterClone() { std::cout << "\nRunning test: " << __func__ << std::endl; + connectSignals(); auto aliceAccount = Manager::instance().getAccount(aliceId); auto bobAccount = Manager::instance().getAccount(bobId); auto aliceUri = aliceAccount->getUsername(); auto bobUri = bobAccount->getUsername(); auto convId = libjami::startConversation(aliceId); - std::map> confHandlers; - bool requestReceived = false, memberMessageGenerated = false, msgDisplayed = false, - aliceRegistered = false; - confHandlers.insert( - libjami::exportable_callback( - [&](const std::string& /*accountId*/, - const std::string& /* conversationId */, - std::map /*metadatas*/) { - requestReceived = true; - cv.notify_one(); - })); - bool conversationReady = false, conversationAlice2Ready = false; - confHandlers.insert(libjami::exportable_callback( - [&](const std::string& accountId, const std::string& conversationId) { - if (accountId == bobId && conversationId == convId) { - conversationReady = true; - } else if (accountId == alice2Id) { - conversationAlice2Ready = true; - } - cv.notify_one(); - })); - confHandlers.insert(libjami::exportable_callback( - [&](const std::string& accountId, - const std::string& conversationId, - std::map message) { - if (accountId == aliceId && conversationId == convId && message["type"] == "member") { - memberMessageGenerated = true; - cv.notify_one(); - } - })); - std::string aliceLastMsg; - confHandlers.insert( - libjami::exportable_callback( - [&](const std::string& accountId, - const std::string& conversationId, - const std::string& peer, - const std::string& msgId, - int status) { - if (conversationId == convId && peer == aliceUri && status == 3) { - if (accountId == bobId && msgId == conversationId) - msgDisplayed = true; - else if (accountId == aliceId) - aliceLastMsg = msgId; - cv.notify_one(); - } - })); - confHandlers.insert( - libjami::exportable_callback( - [&](const std::string&, const std::map&) { - auto details = aliceAccount->getVolatileAccountDetails(); - auto daemonStatus = details[libjami::Account::ConfProperties::Registration::STATUS]; - if (daemonStatus == "REGISTERED") { - aliceRegistered = true; - cv.notify_one(); - } - })); - libjami::registerSignalHandlers(confHandlers); - aliceLastMsg = ""; + auto aliceMsgSize = aliceData.messages.size(); libjami::addConversationMember(aliceId, convId, bobUri); - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { - return requestReceived && memberMessageGenerated && !aliceLastMsg.empty(); - })); - memberMessageGenerated = false; + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return bobData.requestReceived && aliceMsgSize + 1 == aliceData.messages.size(); })); libjami::acceptConversationRequest(bobId, convId); - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return memberMessageGenerated; })); + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return aliceMsgSize + 2 == aliceData.messages.size(); })); aliceAccount->setMessageDisplayed("swarm:" + convId, convId, 3); @@ -1422,7 +1191,7 @@ ConversationTest::testSetMessageDisplayedAfterClone() alice2Id = Manager::instance().addAccount(details); // Disconnect alice2, to create a valid conv betwen Alice and alice1 - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return conversationAlice2Ready; })); + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return !alice2Data.conversationId.empty(); })); // Assert that message is set as displayed for self (for the read status) auto membersInfos = libjami::getConversationMembers(aliceId, convId); @@ -1433,8 +1202,6 @@ ConversationTest::testSetMessageDisplayedAfterClone() && infos["lastDisplayed"] == convId; }) != membersInfos.end()); - - libjami::unregisterSignalHandlers(); } void @@ -1510,8 +1277,6 @@ std::string ConversationTest::createFakeConversation(std::shared_ptr account, const std::string& fakeCert) { - std::cout << "\nRunning test: " << __func__ << std::endl; - auto repoPath = fileutils::get_data_dir() / account->getAccountID() / "conversations" / "tmp"; @@ -1678,6 +1443,7 @@ void ConversationTest::testVoteNonEmpty() { std::cout << "\nRunning test: " << __func__ << std::endl; + connectSignals(); auto aliceAccount = Manager::instance().getAccount(aliceId); auto bobAccount = Manager::instance().getAccount(bobId); @@ -1688,158 +1454,53 @@ ConversationTest::testVoteNonEmpty() auto carlaUri = carlaAccount->getUsername(); aliceAccount->trackBuddyPresence(carlaUri, true); - std::map> confHandlers; - bool conversationReady = false, requestReceived = false, memberMessageGenerated = false, - voteMessageGenerated = false, messageBobReceived = false, errorDetected = false, - carlaConnected = false; - confHandlers.insert( - libjami::exportable_callback( - [&](const std::string& /*accountId*/, - const std::string& /* conversationId */, - std::map /*metadatas*/) { - requestReceived = true; - cv.notify_one(); - })); - confHandlers.insert(libjami::exportable_callback( - [&](const std::string& accountId, const std::string& conversationId) { - if (accountId == bobId && conversationId == convId) { - conversationReady = true; - cv.notify_one(); - } - })); - confHandlers.insert( - libjami::exportable_callback( - [&](const std::string&, const std::map&) { - auto details = carlaAccount->getVolatileAccountDetails(); - auto deviceAnnounced - = details[libjami::Account::VolatileProperties::DEVICE_ANNOUNCED]; - if (deviceAnnounced == "true") { - carlaConnected = true; - cv.notify_one(); - } - })); - confHandlers.insert(libjami::exportable_callback( - [&](const std::string& accountId, - const std::string& conversationId, - std::map message) { - if (accountId == aliceId && conversationId == convId && message["type"] == "vote") { - voteMessageGenerated = true; - } else if (accountId == aliceId && conversationId == convId - && message["type"] == "member") { - memberMessageGenerated = true; - } else if (accountId == bobId && conversationId == convId) { - messageBobReceived = true; - } - cv.notify_one(); - })); - confHandlers.insert( - libjami::exportable_callback( - [&](const std::string& /* accountId */, - const std::string& /* conversationId */, - int code, - const std::string& /* what */) { - if (code == 3) - errorDetected = true; - cv.notify_one(); - })); - libjami::registerSignalHandlers(confHandlers); Manager::instance().sendRegister(carlaId, true); - CPPUNIT_ASSERT(cv.wait_for(lk, 60s, [&] { return carlaConnected; })); + CPPUNIT_ASSERT(cv.wait_for(lk, 60s, [&] { return carlaData.deviceAnnounced; })); + + auto aliceMsgSize = aliceData.messages.size(); libjami::addConversationMember(aliceId, convId, bobUri); - CPPUNIT_ASSERT( - cv.wait_for(lk, 30s, [&]() { return requestReceived && memberMessageGenerated; })); - memberMessageGenerated = false; + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return bobData.requestReceived && aliceMsgSize + 1 == aliceData.messages.size(); })); libjami::acceptConversationRequest(bobId, convId); - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return memberMessageGenerated; })); - requestReceived = false; + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return aliceMsgSize + 2 == aliceData.messages.size(); })); + + aliceMsgSize = aliceData.messages.size(); + auto bobMsgSize = bobData.messages.size(); libjami::addConversationMember(aliceId, convId, carlaUri); - CPPUNIT_ASSERT( - cv.wait_for(lk, 30s, [&]() { return requestReceived && memberMessageGenerated; })); - memberMessageGenerated = false; - messageBobReceived = false; + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return carlaData.requestReceived && aliceMsgSize + 1 == aliceData.messages.size() && bobMsgSize + 1 == bobData.messages.size(); })); libjami::acceptConversationRequest(carlaId, convId); - CPPUNIT_ASSERT( - cv.wait_for(lk, 30s, [&]() { return memberMessageGenerated && messageBobReceived; })); + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return aliceMsgSize + 2 == aliceData.messages.size() && bobMsgSize + 2 == bobData.messages.size(); })); // Now Alice removes Carla with a non empty file - errorDetected = false; addVote(aliceAccount, convId, carlaUri, "CONTENT"); simulateRemoval(aliceAccount, convId, carlaUri); - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return errorDetected; })); + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return carlaData.errorDetected; })); } void ConversationTest::testNoBadFileInInitialCommit() { std::cout << "\nRunning test: " << __func__ << std::endl; + connectSignals(); auto aliceAccount = Manager::instance().getAccount(aliceId); auto carlaAccount = Manager::instance().getAccount(carlaId); - auto carlaUri = carlaAccount->getUsername(); auto aliceUri = aliceAccount->getUsername(); auto convId = createFakeConversation(carlaAccount); - - std::map> confHandlers; - auto messageBobReceived = 0, messageAliceReceived = 0; - bool requestReceived = false; - bool carlaConnected = false; - bool errorDetected = false; - confHandlers.insert(libjami::exportable_callback( - [&](const std::string& accountId, - const std::string& /* conversationId */, - std::map /*message*/) { - if (accountId == bobId) { - messageBobReceived += 1; - } else { - messageAliceReceived += 1; - } - cv.notify_one(); - })); - confHandlers.insert( - libjami::exportable_callback( - [&](const std::string& /*accountId*/, - const std::string& /* conversationId */, - std::map /*metadatas*/) { - requestReceived = true; - cv.notify_one(); - })); - confHandlers.insert( - libjami::exportable_callback( - [&](const std::string&, const std::map&) { - auto details = carlaAccount->getVolatileAccountDetails(); - auto deviceAnnounced - = details[libjami::Account::VolatileProperties::DEVICE_ANNOUNCED]; - if (deviceAnnounced == "true") { - carlaConnected = true; - cv.notify_one(); - } - })); - confHandlers.insert( - libjami::exportable_callback( - [&](const std::string& /* accountId */, - const std::string& /* conversationId */, - int code, - const std::string& /* what */) { - if (code == 3) - errorDetected = true; - cv.notify_one(); - })); - libjami::registerSignalHandlers(confHandlers); - Manager::instance().sendRegister(carlaId, true); - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&] { return carlaConnected; })); + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&] { return carlaData.deviceAnnounced; })); libjami::addConversationMember(carlaId, convId, aliceUri); - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return requestReceived; })); + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return aliceData.requestReceived; })); libjami::acceptConversationRequest(aliceId, convId); - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return errorDetected; })); + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return aliceData.errorDetected; })); } void ConversationTest::testNoBadCertInInitialCommit() { std::cout << "\nRunning test: " << __func__ << std::endl; + connectSignals(); auto aliceAccount = Manager::instance().getAccount(aliceId); auto carlaAccount = Manager::instance().getAccount(carlaId); @@ -1854,141 +1515,47 @@ ConversationTest::testNoBadCertInInitialCommit() // Create a conversation from Carla with Alice's device auto convId = createFakeConversation(carlaAccount, fakeCert->toString(false)); - std::map> confHandlers; - auto messageBobReceived = 0, messageAliceReceived = 0; - bool requestReceived = false; - bool carlaConnected = false; - bool errorDetected = false; - confHandlers.insert(libjami::exportable_callback( - [&](const std::string& accountId, - const std::string& /* conversationId */, - std::map /*message*/) { - if (accountId == bobId) { - messageBobReceived += 1; - } else { - messageAliceReceived += 1; - } - cv.notify_one(); - })); - confHandlers.insert( - libjami::exportable_callback( - [&](const std::string& /*accountId*/, - const std::string& /* conversationId */, - std::map /*metadatas*/) { - requestReceived = true; - cv.notify_one(); - })); - confHandlers.insert( - libjami::exportable_callback( - [&](const std::string&, const std::map&) { - auto details = carlaAccount->getVolatileAccountDetails(); - auto deviceAnnounced - = details[libjami::Account::VolatileProperties::DEVICE_ANNOUNCED]; - if (deviceAnnounced == "true") { - carlaConnected = true; - cv.notify_one(); - } - })); - confHandlers.insert( - libjami::exportable_callback( - [&](const std::string& /* accountId */, - const std::string& /* conversationId */, - int code, - const std::string& /* what */) { - if (code == 3) - errorDetected = true; - cv.notify_one(); - })); - libjami::registerSignalHandlers(confHandlers); - Manager::instance().sendRegister(carlaId, true); - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&] { return carlaConnected; })); + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&] { return carlaData.deviceAnnounced; })); libjami::addConversationMember(carlaId, convId, aliceUri); - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return requestReceived; })); + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return aliceData.requestReceived; })); libjami::acceptConversationRequest(aliceId, convId); - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return errorDetected; })); + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return aliceData.errorDetected; })); } void ConversationTest::testPlainTextNoBadFile() { std::cout << "\nRunning test: " << __func__ << std::endl; + connectSignals(); auto aliceAccount = Manager::instance().getAccount(aliceId); auto bobAccount = Manager::instance().getAccount(bobId); auto bobUri = bobAccount->getUsername(); - std::map> confHandlers; - auto messageBobReceived = 0; - bool memberMessageGenerated = false; - bool requestReceived = false; - bool conversationReady = false; - bool errorDetected = false; std::string convId = libjami::startConversation(aliceId); - confHandlers.insert(libjami::exportable_callback( - [&](const std::string& accountId, - const std::string& conversationId, - std::map message) { - if (accountId == bobId) { - messageBobReceived += 1; - } else if (accountId == aliceId && conversationId == convId - && message["type"] == "member") { - memberMessageGenerated = true; - } - cv.notify_one(); - })); - confHandlers.insert( - libjami::exportable_callback( - [&](const std::string& /*accountId*/, - const std::string& /* conversationId */, - std::map /*metadatas*/) { - requestReceived = true; - cv.notify_one(); - })); - confHandlers.insert(libjami::exportable_callback( - [&](const std::string& accountId, const std::string& /* conversationId */) { - if (accountId == bobId) { - conversationReady = true; - cv.notify_one(); - } - })); - confHandlers.insert( - libjami::exportable_callback( - [&](const std::string& /* accountId */, - const std::string& /* conversationId */, - int code, - const std::string& /* what */) { - if (code == 3) - errorDetected = true; - cv.notify_one(); - })); - libjami::registerSignalHandlers(confHandlers); - + auto aliceMsgSize = aliceData.messages.size(); libjami::addConversationMember(aliceId, convId, bobUri); - CPPUNIT_ASSERT( - cv.wait_for(lk, 30s, [&]() { return requestReceived && memberMessageGenerated; })); - memberMessageGenerated = false; - + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return bobData.requestReceived && aliceMsgSize + 1 == aliceData.messages.size(); })); libjami::acceptConversationRequest(bobId, convId); - cv.wait_for(lk, 30s, [&] { return conversationReady && memberMessageGenerated; }); + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return aliceMsgSize + 2 == aliceData.messages.size(); })); addFile(aliceAccount, convId, "BADFILE"); Json::Value root; root["type"] = "text/plain"; root["body"] = "hi"; commit(aliceAccount, convId, root); - errorDetected = false; libjami::sendMessage(aliceId, convId, "hi"s, ""); // Check not received due to the unwanted file - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return errorDetected; })); - libjami::unregisterSignalHandlers(); + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return bobData.errorDetected; })); } void ConversationTest::testVoteNoBadFile() { std::cout << "\nRunning test: " << __func__ << std::endl; + connectSignals(); auto aliceAccount = Manager::instance().getAccount(aliceId); auto bobAccount = Manager::instance().getAccount(bobId); @@ -1999,146 +1566,47 @@ ConversationTest::testVoteNoBadFile() auto carlaUri = carlaAccount->getUsername(); aliceAccount->trackBuddyPresence(carlaUri, true); - std::map> confHandlers; - bool conversationReady = false, requestReceived = false, memberMessageGenerated = false, - voteMessageGenerated = false, messageBobReceived = false, messageCarlaReceived = false, - carlaConnected = false; - ; - confHandlers.insert( - libjami::exportable_callback( - [&](const std::string& /*accountId*/, - const std::string& /* conversationId */, - std::map /*metadatas*/) { - requestReceived = true; - cv.notify_one(); - })); - confHandlers.insert(libjami::exportable_callback( - [&](const std::string& accountId, const std::string& conversationId) { - if (accountId == bobId && conversationId == convId) { - conversationReady = true; - cv.notify_one(); - } - })); - confHandlers.insert( - libjami::exportable_callback( - [&](const std::string&, const std::map&) { - auto details = carlaAccount->getVolatileAccountDetails(); - auto deviceAnnounced - = details[libjami::Account::VolatileProperties::DEVICE_ANNOUNCED]; - if (deviceAnnounced == "true") { - carlaConnected = true; - cv.notify_one(); - } - })); - confHandlers.insert(libjami::exportable_callback( - [&](const std::string& accountId, - const std::string& conversationId, - std::map message) { - std::string body = ""; - auto it = message.find("body"); - if (it != message.end()) { - body = it->second; - } - if (accountId == aliceId && conversationId == convId && message["type"] == "vote") { - voteMessageGenerated = true; - } else if (accountId == aliceId && conversationId == convId - && message["type"] == "member") { - memberMessageGenerated = true; - } else if (accountId == bobId && conversationId == convId) { - messageBobReceived = true; - } else if (accountId == carlaId && conversationId == convId && body == "final") { - messageCarlaReceived = true; - } - cv.notify_one(); - })); - libjami::registerSignalHandlers(confHandlers); Manager::instance().sendRegister(carlaId, true); - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return carlaConnected; })); + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return carlaData.deviceAnnounced; })); + auto aliceMsgSize = aliceData.messages.size(); libjami::addConversationMember(aliceId, convId, bobUri); - CPPUNIT_ASSERT( - cv.wait_for(lk, 30s, [&]() { return requestReceived && memberMessageGenerated; })); - memberMessageGenerated = false; + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return bobData.requestReceived && aliceMsgSize + 1 == aliceData.messages.size(); })); libjami::acceptConversationRequest(bobId, convId); - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return memberMessageGenerated; })); - requestReceived = false; + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return aliceMsgSize + 2 == aliceData.messages.size(); })); + + aliceMsgSize = aliceData.messages.size(); + auto bobMsgSize = bobData.messages.size(); libjami::addConversationMember(aliceId, convId, carlaUri); - CPPUNIT_ASSERT( - cv.wait_for(lk, 30s, [&]() { return requestReceived && memberMessageGenerated; })); - memberMessageGenerated = false; - messageBobReceived = false; + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return carlaData.requestReceived && aliceMsgSize + 1 == aliceData.messages.size() && bobMsgSize + 1 == bobData.messages.size(); })); libjami::acceptConversationRequest(carlaId, convId); - CPPUNIT_ASSERT( - cv.wait_for(lk, 30s, [&]() { return memberMessageGenerated && messageBobReceived; })); + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return aliceMsgSize + 2 == aliceData.messages.size() && bobMsgSize + 2 == bobData.messages.size(); })); // Now Alice remove Carla without a vote. Bob will not receive the message - messageBobReceived = false; addFile(aliceAccount, convId, "BADFILE"); + aliceMsgSize = aliceData.messages.size(); libjami::removeConversationMember(aliceId, convId, bobUri); - CPPUNIT_ASSERT( - cv.wait_for(lk, 30s, [&]() { return memberMessageGenerated && voteMessageGenerated; })); + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return aliceMsgSize + 2 == aliceData.messages.size(); })); - messageCarlaReceived = false; + auto carlaMsgSize = carlaData.messages.size(); libjami::sendMessage(bobId, convId, "final"s, ""); - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return messageCarlaReceived; })); + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return carlaMsgSize + 1 == carlaData.messages.size(); })); } void ConversationTest::testETooBigClone() { std::cout << "\nRunning test: " << __func__ << std::endl; + connectSignals(); auto aliceAccount = Manager::instance().getAccount(aliceId); auto bobAccount = Manager::instance().getAccount(bobId); auto bobUri = bobAccount->getUsername(); - std::map> confHandlers; - auto messageBobReceived = 0, messageAliceReceived = 0; - bool requestReceived = false; - bool conversationReady = false; - bool errorDetected = false; - confHandlers.insert(libjami::exportable_callback( - [&](const std::string& accountId, - const std::string& /* conversationId */, - std::map /*message*/) { - if (accountId == bobId) { - messageBobReceived += 1; - } else { - messageAliceReceived += 1; - } - cv.notify_one(); - })); - confHandlers.insert( - libjami::exportable_callback( - [&](const std::string& /*accountId*/, - const std::string& /* conversationId */, - std::map /*metadatas*/) { - requestReceived = true; - cv.notify_one(); - })); - confHandlers.insert(libjami::exportable_callback( - [&](const std::string& accountId, const std::string& /* conversationId */) { - if (accountId == bobId) { - conversationReady = true; - cv.notify_one(); - } - })); - confHandlers.insert( - libjami::exportable_callback( - [&](const std::string& /* accountId */, - const std::string& /* conversationId */, - int code, - const std::string& /* what */) { - if (code == 3) - errorDetected = true; - cv.notify_one(); - })); - libjami::registerSignalHandlers(confHandlers); - auto convId = libjami::startConversation(aliceId); // Assert that repository exists - auto repoPath = fileutils::get_data_dir() / aliceAccount->getAccountID() + auto repoPath = fileutils::get_data_dir() / aliceId / "conversations" / convId; std::ofstream bad(repoPath / "BADFILE"); CPPUNIT_ASSERT(bad.is_open()); @@ -2147,84 +1615,38 @@ ConversationTest::testETooBigClone() bad.close(); addAll(aliceAccount, convId); - libjami::addConversationMember(aliceId, convId, bobUri); - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return requestReceived; })); - - errorDetected = false; + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return bobData.requestReceived; })); libjami::acceptConversationRequest(bobId, convId); - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return errorDetected; })); - libjami::unregisterSignalHandlers(); + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return bobData.errorDetected; })); } void ConversationTest::testETooBigFetch() { std::cout << "\nRunning test: " << __func__ << std::endl; + connectSignals(); auto aliceAccount = Manager::instance().getAccount(aliceId); auto bobAccount = Manager::instance().getAccount(bobId); auto bobUri = bobAccount->getUsername(); - std::map> confHandlers; - auto messageBobReceived = 0, messageAliceReceived = 0; - bool requestReceived = false; - bool conversationReady = false; - bool errorDetected = false; - confHandlers.insert(libjami::exportable_callback( - [&](const std::string& accountId, - const std::string& /* conversationId */, - std::map /*message*/) { - if (accountId == bobId) { - messageBobReceived += 1; - } else { - messageAliceReceived += 1; - } - cv.notify_one(); - })); - confHandlers.insert( - libjami::exportable_callback( - [&](const std::string& /*accountId*/, - const std::string& /* conversationId */, - std::map /*metadatas*/) { - requestReceived = true; - cv.notify_one(); - })); - confHandlers.insert(libjami::exportable_callback( - [&](const std::string& accountId, const std::string& /* conversationId */) { - if (accountId == bobId) { - conversationReady = true; - cv.notify_one(); - } - })); - confHandlers.insert( - libjami::exportable_callback( - [&](const std::string& /* accountId */, - const std::string& /* conversationId */, - int code, - const std::string& /* what */) { - if (code == 3) - errorDetected = true; - cv.notify_one(); - })); - libjami::registerSignalHandlers(confHandlers); - auto convId = libjami::startConversation(aliceId); + auto aliceMsgSize = aliceData.messages.size(); libjami::addConversationMember(aliceId, convId, bobUri); - cv.wait_for(lk, 30s, [&]() { return requestReceived; }); + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return bobData.requestReceived; })); libjami::acceptConversationRequest(bobId, convId); - cv.wait_for(lk, 30s, [&]() { return conversationReady; }); + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return !bobData.conversationId.empty(); })); // Wait that alice sees Bob - cv.wait_for(lk, 30s, [&]() { return messageAliceReceived == 2; }); + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return aliceMsgSize + 2 == aliceData.messages.size(); })); - auto repoPath = fileutils::get_data_dir() / aliceAccount->getAccountID() + auto repoPath = fileutils::get_data_dir() / aliceId / "conversations" / convId; std::ofstream bad(repoPath / "BADFILE"); CPPUNIT_ASSERT(bad.is_open()); - errorDetected = false; for (int i = 0; i < 300 * 1024 * 1024; ++i) bad << "A"; bad.close(); @@ -2236,14 +1658,14 @@ ConversationTest::testETooBigFetch() commit(aliceAccount, convId, json); libjami::sendMessage(aliceId, convId, "hi"s, ""); - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return errorDetected; })); - libjami::unregisterSignalHandlers(); + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return bobData.errorDetected; })); } void ConversationTest::testUnknownModeDetected() { std::cout << "\nRunning test: " << __func__ << std::endl; + connectSignals(); auto aliceAccount = Manager::instance().getAccount(aliceId); auto bobAccount = Manager::instance().getAccount(bobId); @@ -2257,405 +1679,144 @@ ConversationTest::testUnknownModeDetected() wbuilder["commentStyle"] = "None"; wbuilder["indentation"] = ""; repo.amend(convId, Json::writeString(wbuilder, json)); - std::map> confHandlers; - bool conversationReady = false, requestReceived = false, memberMessageGenerated = false, - errorDetected = false; - confHandlers.insert( - libjami::exportable_callback( - [&](const std::string& /*accountId*/, - const std::string& /* conversationId */, - std::map /*metadatas*/) { - requestReceived = true; - cv.notify_one(); - })); - confHandlers.insert(libjami::exportable_callback( - [&](const std::string& accountId, const std::string& /* conversationId */) { - if (accountId == bobId) { - conversationReady = true; - cv.notify_one(); - } - })); - confHandlers.insert(libjami::exportable_callback( - [&](const std::string& accountId, - const std::string& conversationId, - std::map message) { - if (accountId == aliceId && conversationId == convId && message["type"] == "member") { - memberMessageGenerated = true; - cv.notify_one(); - } - })); - confHandlers.insert( - libjami::exportable_callback( - [&](const std::string& /* accountId */, - const std::string& /* conversationId */, - int code, - const std::string& /* what */) { - if (code == 2) - errorDetected = true; - cv.notify_one(); - })); - libjami::registerSignalHandlers(confHandlers); libjami::addConversationMember(aliceId, convId, bobUri); - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return requestReceived; })); - errorDetected = false; + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return bobData.requestReceived; })); libjami::acceptConversationRequest(bobId, convId); - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return errorDetected; })); + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return bobData.errorDetected; })); } void ConversationTest::testUpdateProfile() { std::cout << "\nRunning test: " << __func__ << std::endl; + connectSignals(); auto aliceAccount = Manager::instance().getAccount(aliceId); auto bobAccount = Manager::instance().getAccount(bobId); auto bobUri = bobAccount->getUsername(); - std::map> confHandlers; - auto messageBobReceived = 0, messageAliceReceived = 0; - confHandlers.insert(libjami::exportable_callback( - [&](const std::string& accountId, - const std::string& /* conversationId */, - std::map /*message*/) { - if (accountId == bobId) { - messageBobReceived += 1; - } else { - messageAliceReceived += 1; - } - cv.notify_one(); - })); - bool requestReceived = false; - confHandlers.insert( - libjami::exportable_callback( - [&](const std::string& /*accountId*/, - const std::string& /* conversationId */, - std::map /*metadatas*/) { - requestReceived = true; - cv.notify_one(); - })); - bool conversationReady = false; - confHandlers.insert(libjami::exportable_callback( - [&](const std::string& accountId, const std::string& /* conversationId */) { - if (accountId == bobId) { - conversationReady = true; - cv.notify_one(); - } - })); - std::map profileAlice, profileBob; - confHandlers.insert( - libjami::exportable_callback( - [&](const auto& accountId, const auto& /* conversationId */, const auto& profile) { - if (accountId == aliceId) { - profileAlice = profile; - } else if (accountId == bobId) { - profileBob = profile; - } - cv.notify_one(); - })); - libjami::registerSignalHandlers(confHandlers); - auto convId = libjami::startConversation(aliceId); - + auto aliceMsgSize = aliceData.messages.size(); libjami::addConversationMember(aliceId, convId, bobUri); - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return requestReceived; })); - - messageAliceReceived = 0; + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return bobData.requestReceived; })); libjami::acceptConversationRequest(bobId, convId); - CPPUNIT_ASSERT( - cv.wait_for(lk, 30s, [&]() { return conversationReady && messageAliceReceived == 1; })); + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return aliceMsgSize + 2 == aliceData.messages.size() && !bobData.conversationId.empty(); })); - messageBobReceived = 0; + auto bobMsgSize = bobData.messages.size(); aliceAccount->convModule()->updateConversationInfos(convId, {{"title", "My awesome swarm"}}); CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { - return messageBobReceived == 1 && !profileAlice.empty() && !profileBob.empty(); + return bobMsgSize + 1 == bobData.messages.size() && !aliceData.profile.empty() && !bobData.profile.empty(); })); auto infos = libjami::conversationInfos(bobId, convId); // Verify that we have the same profile everywhere CPPUNIT_ASSERT(infos["title"] == "My awesome swarm"); - CPPUNIT_ASSERT(profileAlice["title"] == "My awesome swarm"); - CPPUNIT_ASSERT(profileBob["title"] == "My awesome swarm"); + CPPUNIT_ASSERT(aliceData.profile["title"] == "My awesome swarm"); + CPPUNIT_ASSERT(bobData.profile["title"] == "My awesome swarm"); CPPUNIT_ASSERT(infos["description"].empty()); - CPPUNIT_ASSERT(profileAlice["description"].empty()); - CPPUNIT_ASSERT(profileBob["description"].empty()); - - libjami::unregisterSignalHandlers(); + CPPUNIT_ASSERT(aliceData.profile["description"].empty()); + CPPUNIT_ASSERT(bobData.profile["description"].empty()); } void ConversationTest::testGetProfileRequest() { std::cout << "\nRunning test: " << __func__ << std::endl; + connectSignals(); auto aliceAccount = Manager::instance().getAccount(aliceId); auto bobAccount = Manager::instance().getAccount(bobId); auto bobUri = bobAccount->getUsername(); - std::map> confHandlers; - auto messageAliceReceived = 0; - confHandlers.insert(libjami::exportable_callback( - [&](const std::string& accountId, - const std::string& /* conversationId */, - std::map /*message*/) { - if (accountId == aliceId) - messageAliceReceived += 1; - cv.notify_one(); - })); - bool requestReceived = false; - confHandlers.insert( - libjami::exportable_callback( - [&](const std::string& /*accountId*/, - const std::string& /* conversationId */, - std::map /*metadatas*/) { - requestReceived = true; - cv.notify_one(); - })); - libjami::registerSignalHandlers(confHandlers); - auto convId = libjami::startConversation(aliceId); - - messageAliceReceived = 0; + auto aliceMsgSize = aliceData.messages.size(); aliceAccount->convModule()->updateConversationInfos(convId, {{"title", "My awesome swarm"}}); - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return messageAliceReceived == 1; })); + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return aliceMsgSize + 1 == aliceData.messages.size(); })); libjami::addConversationMember(aliceId, convId, bobUri); - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return requestReceived; })); + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return bobData.requestReceived; })); auto infos = libjami::conversationInfos(bobId, convId); CPPUNIT_ASSERT(infos["title"] == "My awesome swarm"); CPPUNIT_ASSERT(infos["description"].empty()); - - libjami::unregisterSignalHandlers(); } void ConversationTest::testCheckProfileInConversationRequest() { std::cout << "\nRunning test: " << __func__ << std::endl; + connectSignals(); auto aliceAccount = Manager::instance().getAccount(aliceId); auto bobAccount = Manager::instance().getAccount(bobId); auto bobUri = bobAccount->getUsername(); - std::map> confHandlers; - auto messageBobReceived = 0, messageAliceReceived = 0; - bool requestReceived = false; - bool conversationReady = false; - confHandlers.insert(libjami::exportable_callback( - [&](const std::string& accountId, - const std::string& /* conversationId */, - std::map /*message*/) { - if (accountId == bobId) { - messageBobReceived += 1; - } else { - messageAliceReceived += 1; - } - cv.notify_one(); - })); - confHandlers.insert( - libjami::exportable_callback( - [&](const std::string& /*accountId*/, - const std::string& /* conversationId */, - std::map /*metadatas*/) { - requestReceived = true; - cv.notify_one(); - })); - confHandlers.insert(libjami::exportable_callback( - [&](const std::string& accountId, const std::string& /* conversationId */) { - if (accountId == bobId) { - conversationReady = true; - cv.notify_one(); - } - })); - libjami::registerSignalHandlers(confHandlers); - auto convId = libjami::startConversation(aliceId); aliceAccount->convModule()->updateConversationInfos(convId, {{"title", "My awesome swarm"}}); libjami::addConversationMember(aliceId, convId, bobUri); - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return requestReceived; })); + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return bobData.requestReceived; })); auto requests = libjami::getConversationRequests(bobId); CPPUNIT_ASSERT(requests.size() == 1); CPPUNIT_ASSERT(requests.front()["title"] == "My awesome swarm"); - - libjami::unregisterSignalHandlers(); } void ConversationTest::testCheckProfileInTrustRequest() { std::cout << "\nRunning test: " << __func__ << std::endl; + connectSignals(); auto aliceAccount = Manager::instance().getAccount(aliceId); auto bobAccount = Manager::instance().getAccount(bobId); auto bobUri = bobAccount->getUsername(); - auto aliceUri = aliceAccount->getUsername(); - std::map> confHandlers; - bool conversationReady = false, requestReceived = false; - std::string convId = ""; std::string vcard = "BEGIN:VCARD\n\ VERSION:2.1\n\ FN:TITLE\n\ DESCRIPTION:DESC\n\ END:VCARD"; - confHandlers.insert( - libjami::exportable_callback( - [&](const std::string& account_id, - const std::string& /*from*/, - const std::string& /*conversationId*/, - const std::vector& payload, - time_t /*received*/) { - auto pstr = std::string(payload.begin(), payload.begin() + payload.size()); - if (account_id == bobId - && std::string(payload.data(), payload.data() + payload.size()) == vcard) - requestReceived = true; - cv.notify_one(); - })); - confHandlers.insert(libjami::exportable_callback( - [&](const std::string& accountId, const std::string& conversationId) { - if (accountId == aliceId) { - convId = conversationId; - } else if (accountId == bobId) { - conversationReady = true; - } - cv.notify_one(); - })); - libjami::registerSignalHandlers(confHandlers); aliceAccount->addContact(bobUri); std::vector payload(vcard.begin(), vcard.end()); aliceAccount->sendTrustRequest(bobUri, payload); - CPPUNIT_ASSERT(cv.wait_for(lk, 10s, [&]() { return !convId.empty() && requestReceived; })); + CPPUNIT_ASSERT(cv.wait_for(lk, 10s, [&]() { return bobData.payloadTrustRequest == vcard; })); } void ConversationTest::testMemberCannotUpdateProfile() { std::cout << "\nRunning test: " << __func__ << std::endl; + connectSignals(); - auto aliceAccount = Manager::instance().getAccount(aliceId); auto bobAccount = Manager::instance().getAccount(bobId); auto bobUri = bobAccount->getUsername(); auto convId = libjami::startConversation(aliceId); - - std::map> confHandlers; - auto messageBobReceived = 0, messageAliceReceived = 0; - bool requestReceived = false; - bool conversationReady = false; - bool errorDetected = false; - confHandlers.insert(libjami::exportable_callback( - [&](const std::string& accountId, - const std::string& /* conversationId */, - std::map /*message*/) { - if (accountId == bobId) { - messageBobReceived += 1; - } else { - messageAliceReceived += 1; - } - cv.notify_one(); - })); - confHandlers.insert( - libjami::exportable_callback( - [&](const std::string& /*accountId*/, - const std::string& /* conversationId */, - std::map /*metadatas*/) { - requestReceived = true; - cv.notify_one(); - })); - confHandlers.insert(libjami::exportable_callback( - [&](const std::string& accountId, const std::string& /* conversationId */) { - if (accountId == bobId) { - conversationReady = true; - cv.notify_one(); - } - })); - confHandlers.insert( - libjami::exportable_callback( - [&](const std::string& accountId, - const std::string& conversationId, - int code, - const std::string& /* what */) { - if (accountId == bobId && conversationId == convId && code == 4) - errorDetected = true; - cv.notify_one(); - })); - libjami::registerSignalHandlers(confHandlers); - + auto aliceMsgSize = aliceData.messages.size(); libjami::addConversationMember(aliceId, convId, bobUri); - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return requestReceived; })); - - messageAliceReceived = 0; + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return bobData.requestReceived; })); libjami::acceptConversationRequest(bobId, convId); - CPPUNIT_ASSERT( - cv.wait_for(lk, 30s, [&]() { return conversationReady && messageAliceReceived == 1; })); + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return aliceMsgSize + 2 == aliceData.messages.size() && !bobData.conversationId.empty(); })); - messageBobReceived = 0; bobAccount->convModule()->updateConversationInfos(convId, {{"title", "My awesome swarm"}}); - CPPUNIT_ASSERT(cv.wait_for(lk, 5s, [&]() { return errorDetected; })); - - libjami::unregisterSignalHandlers(); + CPPUNIT_ASSERT(cv.wait_for(lk, 5s, [&]() { return bobData.errorDetected; })); } void ConversationTest::testUpdateProfileWithBadFile() { std::cout << "\nRunning test: " << __func__ << std::endl; + connectSignals(); auto aliceAccount = Manager::instance().getAccount(aliceId); auto bobAccount = Manager::instance().getAccount(bobId); auto bobUri = bobAccount->getUsername(); + auto convId = libjami::startConversation(aliceId); - - std::map> confHandlers; - auto messageBobReceived = 0, messageAliceReceived = 0; - bool requestReceived = false; - bool conversationReady = false; - bool errorDetected = false; - confHandlers.insert(libjami::exportable_callback( - [&](const std::string& accountId, - const std::string& /* conversationId */, - std::map /*message*/) { - if (accountId == bobId) { - messageBobReceived += 1; - } else { - messageAliceReceived += 1; - } - cv.notify_one(); - })); - confHandlers.insert( - libjami::exportable_callback( - [&](const std::string& /*accountId*/, - const std::string& /* conversationId */, - std::map /*metadatas*/) { - requestReceived = true; - cv.notify_one(); - })); - confHandlers.insert(libjami::exportable_callback( - [&](const std::string& accountId, const std::string& /* conversationId */) { - if (accountId == bobId) { - conversationReady = true; - cv.notify_one(); - } - })); - confHandlers.insert( - libjami::exportable_callback( - [&](const std::string& accountId, - const std::string& conversationId, - int code, - const std::string& /* what */) { - if (accountId == bobId && conversationId == convId && code == 3) - errorDetected = true; - cv.notify_one(); - })); - libjami::registerSignalHandlers(confHandlers); - + auto aliceMsgSize = aliceData.messages.size(); libjami::addConversationMember(aliceId, convId, bobUri); - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return requestReceived; })); - - messageAliceReceived = 0; + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return bobData.requestReceived; })); libjami::acceptConversationRequest(bobId, convId); - CPPUNIT_ASSERT( - cv.wait_for(lk, 30s, [&]() { return conversationReady && messageAliceReceived == 1; })); + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return aliceMsgSize + 2 == aliceData.messages.size() && !bobData.conversationId.empty(); })); // Update profile but with bad file addFile(aliceAccount, convId, "BADFILE"); @@ -2668,73 +1829,25 @@ END:VCARD"; Json::Value root; root["type"] = "application/update-profile"; commit(aliceAccount, convId, root); - errorDetected = false; libjami::sendMessage(aliceId, convId, "hi"s, ""); - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return errorDetected; })); - - libjami::unregisterSignalHandlers(); + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return bobData.errorDetected; })); } void ConversationTest::testFetchProfileUnauthorized() { std::cout << "\nRunning test: " << __func__ << std::endl; + connectSignals(); - auto aliceAccount = Manager::instance().getAccount(aliceId); auto bobAccount = Manager::instance().getAccount(bobId); auto bobUri = bobAccount->getUsername(); + auto convId = libjami::startConversation(aliceId); - - std::map> confHandlers; - auto messageBobReceived = 0, messageAliceReceived = 0; - bool requestReceived = false; - bool conversationReady = false; - bool errorDetected = false; - confHandlers.insert(libjami::exportable_callback( - [&](const std::string& accountId, - const std::string& /* conversationId */, - std::map /*message*/) { - if (accountId == bobId) { - messageBobReceived += 1; - } else { - messageAliceReceived += 1; - } - cv.notify_one(); - })); - confHandlers.insert( - libjami::exportable_callback( - [&](const std::string& /*accountId*/, - const std::string& /* conversationId */, - std::map /*metadatas*/) { - requestReceived = true; - cv.notify_one(); - })); - confHandlers.insert(libjami::exportable_callback( - [&](const std::string& accountId, const std::string& /* conversationId */) { - if (accountId == bobId) { - conversationReady = true; - cv.notify_one(); - } - })); - confHandlers.insert( - libjami::exportable_callback( - [&](const std::string& accountId, - const std::string& conversationId, - int code, - const std::string& /* what */) { - if (accountId == aliceId && conversationId == convId && code == 3) - errorDetected = true; - cv.notify_one(); - })); - libjami::registerSignalHandlers(confHandlers); - + auto aliceMsgSize = aliceData.messages.size(); libjami::addConversationMember(aliceId, convId, bobUri); - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return requestReceived; })); - - messageAliceReceived = 0; + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return bobData.requestReceived; })); libjami::acceptConversationRequest(bobId, convId); - CPPUNIT_ASSERT( - cv.wait_for(lk, 30s, [&]() { return conversationReady && messageAliceReceived == 1; })); + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return aliceMsgSize + 2 == aliceData.messages.size() && !bobData.conversationId.empty(); })); // Fake realist profile update std::string vcard = "BEGIN:VCARD\n\ @@ -2746,61 +1859,36 @@ END:VCARD"; Json::Value root; root["type"] = "application/update-profile"; commit(bobAccount, convId, root); - errorDetected = false; libjami::sendMessage(bobId, convId, "hi"s, ""); - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return errorDetected; })); - - libjami::unregisterSignalHandlers(); + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return aliceData.errorDetected; })); } void ConversationTest::testSyncingWhileAccepting() { std::cout << "\nRunning test: " << __func__ << std::endl; + connectSignals(); auto aliceAccount = Manager::instance().getAccount(aliceId); auto bobAccount = Manager::instance().getAccount(bobId); auto bobUri = bobAccount->getUsername(); auto aliceUri = aliceAccount->getUsername(); - std::map> confHandlers; - bool conversationReady = false, requestReceived = false; - std::string convId = ""; - confHandlers.insert( - libjami::exportable_callback( - [&](const std::string& account_id, - const std::string& /*from*/, - const std::string& /*conversationId*/, - const std::vector& /*payload*/, - time_t /*received*/) { - if (account_id == bobId) - requestReceived = true; - cv.notify_one(); - })); - confHandlers.insert(libjami::exportable_callback( - [&](const std::string& accountId, const std::string& conversationId) { - if (accountId == aliceId) { - convId = conversationId; - } else if (accountId == bobId) { - conversationReady = true; - } - cv.notify_one(); - })); - libjami::registerSignalHandlers(confHandlers); + aliceAccount->addContact(bobUri); aliceAccount->sendTrustRequest(bobUri, {}); - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return requestReceived; })); + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return bobData.requestReceived; })); Manager::instance().sendRegister(aliceId, false); // This avoid to sync immediately CPPUNIT_ASSERT(bobAccount->acceptTrustRequest(aliceUri)); - auto convInfos = libjami::conversationInfos(bobId, convId); + auto convInfos = libjami::conversationInfos(bobId, aliceData.conversationId); CPPUNIT_ASSERT(convInfos["syncing"] == "true"); CPPUNIT_ASSERT(convInfos.find("created") != convInfos.end()); Manager::instance().sendRegister(aliceId, true); // This avoid to sync immediately - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return conversationReady; })); + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return !bobData.conversationId.empty(); })); - convInfos = libjami::conversationInfos(bobId, convId); + convInfos = libjami::conversationInfos(bobId, bobData.conversationId); CPPUNIT_ASSERT(convInfos.find("syncing") == convInfos.end()); } @@ -2843,85 +1931,44 @@ void ConversationTest::testReplayConversation() { std::cout << "\nRunning test: " << __func__ << std::endl; + connectSignals(); auto aliceAccount = Manager::instance().getAccount(aliceId); auto bobAccount = Manager::instance().getAccount(bobId); auto bobUri = bobAccount->getUsername(); auto aliceUri = aliceAccount->getUsername(); - std::map> confHandlers; - bool conversationReady = false, requestReceived = false, memberMessageGenerated = false, - conversationRemoved = false, messageReceived = false; - std::vector bobMessages; - std::string convId = ""; - confHandlers.insert( - libjami::exportable_callback( - [&](const std::string& account_id, - const std::string& /*from*/, - const std::string& /*conversationId*/, - const std::vector& /*payload*/, - time_t /*received*/) { - if (account_id == bobId) - requestReceived = true; - cv.notify_one(); - })); - confHandlers.insert(libjami::exportable_callback( - [&](const std::string& accountId, const std::string& conversationId) { - if (accountId == aliceId) { - convId = conversationId; - } else if (accountId == bobId) { - conversationReady = true; - } - cv.notify_one(); - })); - confHandlers.insert( - libjami::exportable_callback( - [&](const std::string& accountId, const std::string&) { - if (accountId == aliceId) - conversationRemoved = true; - cv.notify_one(); - })); - confHandlers.insert(libjami::exportable_callback( - [&](const std::string& accountId, - const std::string& conversationId, - std::map message) { - if (accountId == aliceId && conversationId == convId) { - messageReceived = true; - if (message["type"] == "member") - memberMessageGenerated = true; - } else if (accountId == bobId && message["type"] == "text/plain") { - bobMessages.emplace_back(message["body"]); - } - cv.notify_one(); - })); - libjami::registerSignalHandlers(confHandlers); - requestReceived = false; + aliceAccount->addContact(bobUri); aliceAccount->sendTrustRequest(bobUri, {}); - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return requestReceived; })); + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return bobData.requestReceived; })); + auto aliceMsgSize = aliceData.messages.size(); CPPUNIT_ASSERT(bobAccount->acceptTrustRequest(aliceUri)); CPPUNIT_ASSERT( - cv.wait_for(lk, 30s, [&]() { return conversationReady && memberMessageGenerated; })); + cv.wait_for(lk, 30s, [&]() { + return !bobData.conversationId.empty() && aliceMsgSize + 1 == aliceData.messages.size(); })); // removeContact aliceAccount->removeContact(bobUri, false); - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return conversationRemoved; })); + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return aliceData.removed; })); + std::this_thread::sleep_for(5s); // re-add - CPPUNIT_ASSERT(convId != ""); - auto oldConvId = convId; - convId = ""; + CPPUNIT_ASSERT(bobData.conversationId != ""); + auto oldConvId = bobData.conversationId; + aliceData.conversationId = ""; aliceAccount->addContact(bobUri); - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return !convId.empty(); })); - messageReceived = false; - libjami::sendMessage(aliceId, convId, "foo"s, ""); - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return messageReceived; })); - messageReceived = false; - libjami::sendMessage(aliceId, convId, "bar"s, ""); - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return messageReceived; })); - convId = ""; - bobMessages.clear(); + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return !aliceData.conversationId.empty(); })); + aliceMsgSize = aliceData.messages.size(); + libjami::sendMessage(aliceId, aliceData.conversationId, "foo"s, ""); + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return aliceMsgSize + 1 == aliceData.messages.size(); })); + libjami::sendMessage(aliceId, aliceData.conversationId, "bar"s, ""); + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return aliceMsgSize + 2 == aliceData.messages.size(); })); + bobData.messages.clear(); aliceAccount->sendTrustRequest(bobUri, {}); // Should retrieve previous conversation CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { - return bobMessages.size() == 2 && bobMessages[0] == "foo" && bobMessages[1] == "bar"; + JAMI_ERROR("@@@ {}", bobData.messages.size()); + if (bobData.messages.size() > 0) + JAMI_ERROR("@@@ {}", bobData.messages[0].body["body"]); + return bobData.messages.size() == 2 && bobData.messages[0].body["body"] == "foo" && bobData.messages[1].body["body"] == "bar"; })); } @@ -2929,69 +1976,13 @@ void ConversationTest::testSyncWithoutPinnedCert() { std::cout << "\nRunning test: " << __func__ << std::endl; + connectSignals(); auto aliceAccount = Manager::instance().getAccount(aliceId); auto bobAccount = Manager::instance().getAccount(bobId); auto bobUri = bobAccount->getUsername(); auto aliceUri = aliceAccount->getUsername(); - std::map> confHandlers; - std::string convId = ""; - auto requestReceived = false, conversationReady = false, memberMessageGenerated = false, - aliceMessageReceived = false; - confHandlers.insert( - libjami::exportable_callback( - [&](const std::string& account_id, - const std::string& /*from*/, - const std::string& /*conversationId*/, - const std::vector& /*payload*/, - time_t /*received*/) { - if (account_id == bobId) - requestReceived = true; - cv.notify_one(); - })); - confHandlers.insert(libjami::exportable_callback( - [&](const std::string& accountId, const std::string& conversationId) { - if (accountId == aliceId) { - convId = conversationId; - } else { - conversationReady = true; - } - cv.notify_one(); - })); - confHandlers.insert(libjami::exportable_callback( - [&](const std::string& accountId, - const std::string& conversationId, - std::map message) { - if (accountId == aliceId && conversationId == convId) { - if (message["type"] == "member") - memberMessageGenerated = true; - else if (message["type"] == "text/plain") - aliceMessageReceived = true; - } - cv.notify_one(); - })); - auto bob2Started = false, aliceStopped = false, bob2Stopped = false; - confHandlers.insert( - libjami::exportable_callback( - [&](const std::string&, const std::map&) { - auto bob2Account = Manager::instance().getAccount(bob2Id); - if (!bob2Account) - return; - auto details = bob2Account->getVolatileAccountDetails(); - auto daemonStatus = details[libjami::Account::ConfProperties::Registration::STATUS]; - if (daemonStatus == "REGISTERED") - bob2Started = true; - if (daemonStatus == "UNREGISTERED") - bob2Stopped = true; - details = aliceAccount->getVolatileAccountDetails(); - daemonStatus = details[libjami::Account::ConfProperties::Registration::STATUS]; - if (daemonStatus == "UNREGISTERED") - aliceStopped = true; - cv.notify_one(); - })); - libjami::registerSignalHandlers(confHandlers); - // Bob creates a second device auto bobArchive = std::filesystem::current_path().string() + "/bob.gz"; std::remove(bobArchive.c_str()); @@ -3007,33 +1998,31 @@ ConversationTest::testSyncWithoutPinnedCert() bob2Id = Manager::instance().addAccount(details); // Disconnect bob2, to create a valid conv betwen Alice and Bob1 - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return bob2Started; })); - bob2Stopped = false; + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return bob2Data.registered; })); Manager::instance().sendRegister(bob2Id, false); - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return bob2Stopped; })); + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return bob2Data.stopped; })); // Alice adds bob - requestReceived = false; aliceAccount->addContact(bobUri); aliceAccount->sendTrustRequest(bobUri, {}); - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return requestReceived; })); + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return bobData.requestReceived; })); + auto aliceMsgSize = aliceData.messages.size(); CPPUNIT_ASSERT(bobAccount->acceptTrustRequest(aliceUri)); CPPUNIT_ASSERT( - cv.wait_for(lk, 30s, [&]() { return conversationReady && memberMessageGenerated; })); + cv.wait_for(lk, 30s, [&]() { + return !bobData.conversationId.empty() && aliceMsgSize + 1 == aliceData.messages.size(); })); // Bob send a message - libjami::sendMessage(bobId, convId, "hi"s, ""); - cv.wait_for(lk, 30s, [&]() { return aliceMessageReceived; }); + libjami::sendMessage(bobId, bobData.conversationId, "hi"s, ""); + cv.wait_for(lk, 30s, [&]() { return aliceMsgSize + 2 == aliceData.messages.size(); }); // Alice off, bob2 On - conversationReady = false; - aliceStopped = false; Manager::instance().sendRegister(aliceId, false); - cv.wait_for(lk, 10s, [&]() { return aliceStopped; }); + cv.wait_for(lk, 10s, [&]() { return aliceData.stopped; }); Manager::instance().sendRegister(bob2Id, true); // Sync + validate - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return conversationReady; })); + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return !bob2Data.conversationId.empty(); })); } void @@ -3065,6 +2054,7 @@ void ConversationTest::testRemoveReaddMultipleDevice() { std::cout << "\nRunning test: " << __func__ << std::endl; + connectSignals(); auto aliceAccount = Manager::instance().getAccount(aliceId); auto bobAccount = Manager::instance().getAccount(bobId); @@ -3086,67 +2076,6 @@ END:VCARD"; file.close(); } - std::map> confHandlers; - auto requestReceived = false, requestReceivedBob2 = false; - confHandlers.insert( - libjami::exportable_callback( - [&](const std::string& accountId, - const std::string& conversationId, - std::map /*metadatas*/) { - if (accountId == bobId) - requestReceived = true; - else if (accountId == bob2Id) - requestReceivedBob2 = true; - cv.notify_one(); - })); - std::string convId = ""; - auto conversationReadyBob = false, conversationReadyBob2 = false; - confHandlers.insert(libjami::exportable_callback( - [&](const std::string& accountId, const std::string& conversationId) { - if (accountId == aliceId) { - convId = conversationId; - } else if (accountId == bobId) { - conversationReadyBob = true; - } else if (accountId == bob2Id) { - conversationReadyBob2 = true; - } - cv.notify_one(); - })); - auto memberMessageGenerated = false; - confHandlers.insert(libjami::exportable_callback( - [&](const std::string& accountId, - const std::string& conversationId, - std::map message) { - if (accountId == aliceId && conversationId == convId) { - if (message["type"] == "member") - memberMessageGenerated = true; - } - cv.notify_one(); - })); - auto bob2Started = false; - confHandlers.insert( - libjami::exportable_callback( - [&](const std::string& accountId, const std::map& details) { - if (accountId == bob2Id) { - auto daemonStatus = details.at( - libjami::Account::VolatileProperties::DEVICE_ANNOUNCED); - if (daemonStatus == "true") - bob2Started = true; - } - cv.notify_one(); - })); - auto conversationRmBob = false, conversationRmBob2 = false; - confHandlers.insert( - libjami::exportable_callback( - [&](const std::string& accountId, const std::string&) { - if (accountId == bobId) - conversationRmBob = true; - else if (accountId == bob2Id) - conversationRmBob2 = true; - cv.notify_one(); - })); - libjami::registerSignalHandlers(confHandlers); - // Bob creates a second device auto bobArchive = std::filesystem::current_path().string() + "/bob.gz"; std::remove(bobArchive.c_str()); @@ -3161,110 +2090,40 @@ END:VCARD"; details[ConfProperties::ARCHIVE_PATH] = bobArchive; bob2Id = Manager::instance().addAccount(details); - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return bob2Started; })); + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return bob2Data.deviceAnnounced; })); // Alice adds bob - requestReceived = false, requestReceivedBob2 = false; aliceAccount->addContact(bobUri); aliceAccount->sendTrustRequest(bobUri, {}); - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return requestReceived && requestReceivedBob2; })); - libjami::acceptConversationRequest(bobId, convId); + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return bobData.requestReceived && bob2Data.requestReceived; })); + auto aliceMsgSize = aliceData.messages.size(); + libjami::acceptConversationRequest(bobId, aliceData.conversationId); CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { - return conversationReadyBob && conversationReadyBob2 && memberMessageGenerated; + return !bobData.conversationId.empty() && !bob2Data.conversationId.empty() && aliceMsgSize + 1 == aliceData.messages.size(); })); // Remove contact bobAccount->removeContact(aliceUri, false); - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return conversationRmBob && conversationRmBob2; })); + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return bobData.removed && bob2Data.removed; })); // wait that connections are closed. - std::this_thread::sleep_for(10s); + std::this_thread::sleep_for(5s); - // Alice send a message. This will not trigger any request, because contact was removed. - requestReceived = false, requestReceivedBob2 = false; - libjami::sendMessage(aliceId, convId, "hi"s, ""); - CPPUNIT_ASSERT(!cv.wait_for(lk, 30s, [&]() { return requestReceived || requestReceivedBob2; })); + // Alice send a message + bobData.requestReceived = false; bob2Data.requestReceived = false; + libjami::sendMessage(aliceId, aliceData.conversationId, "hi"s, ""); + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return bobData.requestReceived && bob2Data.requestReceived; })); } void ConversationTest::testCloneFromMultipleDevice() { std::cout << "\nRunning test: " << __func__ << std::endl; + connectSignals(); auto aliceAccount = Manager::instance().getAccount(aliceId); auto bobAccount = Manager::instance().getAccount(bobId); auto bobUri = bobAccount->getUsername(); - auto aliceUri = aliceAccount->getUsername(); - - std::map> confHandlers; - auto requestReceived = false, requestReceivedBob2 = false; - confHandlers.insert( - libjami::exportable_callback( - [&](const std::string& accountId, - const std::string& conversationId, - std::map /*metadatas*/) { - if (accountId == bobId) - requestReceived = true; - else if (accountId == bob2Id) - requestReceivedBob2 = true; - cv.notify_one(); - })); - std::string convId = ""; - auto conversationReadyBob = false, conversationReadyBob2 = false; - confHandlers.insert(libjami::exportable_callback( - [&](const std::string& accountId, const std::string& conversationId) { - if (accountId == aliceId) { - convId = conversationId; - } else if (accountId == bobId) { - conversationReadyBob = true; - } else if (accountId == bob2Id) { - conversationReadyBob2 = true; - } - cv.notify_one(); - })); - auto memberMessageGenerated = false; - confHandlers.insert(libjami::exportable_callback( - [&](const std::string& accountId, - const std::string& conversationId, - std::map message) { - if (accountId == aliceId && conversationId == convId) { - if (message["type"] == "member") - memberMessageGenerated = true; - } - cv.notify_one(); - })); - auto bob2Started = false; - confHandlers.insert( - libjami::exportable_callback( - [&](const std::string& accountId, const std::map& details) { - if (accountId == bob2Id) { - auto daemonStatus = details.at( - libjami::Account::VolatileProperties::DEVICE_ANNOUNCED); - if (daemonStatus == "true") - bob2Started = true; - } - cv.notify_one(); - })); - auto conversationRmAlice = false; - confHandlers.insert( - libjami::exportable_callback( - [&](const std::string& accountId, const std::string&) { - if (accountId == aliceId) - conversationRmAlice = true; - cv.notify_one(); - })); - auto errorDetected = false; - confHandlers.insert( - libjami::exportable_callback( - [&](const std::string& /* accountId */, - const std::string& /* conversationId */, - int code, - const std::string& /* what */) { - if (code == 1) - errorDetected = true; - cv.notify_one(); - })); - libjami::registerSignalHandlers(confHandlers); // Bob creates a second device auto bobArchive = std::filesystem::current_path().string() + "/bob.gz"; @@ -3280,227 +2139,116 @@ ConversationTest::testCloneFromMultipleDevice() details[ConfProperties::ARCHIVE_PATH] = bobArchive; bob2Id = Manager::instance().addAccount(details); - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return bob2Started; })); + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return bob2Data.deviceAnnounced; })); // Alice adds bob - requestReceived = false, requestReceivedBob2 = false; aliceAccount->addContact(bobUri); aliceAccount->sendTrustRequest(bobUri, {}); - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return requestReceived && requestReceivedBob2; })); - libjami::acceptConversationRequest(bobId, convId); + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return bobData.requestReceived && bob2Data.requestReceived; })); + auto aliceMsgSize = aliceData.messages.size(); + libjami::acceptConversationRequest(bobId, aliceData.conversationId); CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { - return conversationReadyBob && conversationReadyBob2 && memberMessageGenerated; + return !bobData.conversationId.empty() && !bob2Data.conversationId.empty() && aliceMsgSize + 1 == aliceData.messages.size(); })); // Remove contact aliceAccount->removeContact(bobUri, false); - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return conversationRmAlice; })); + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return aliceData.removed; })); // wait that connections are closed. std::this_thread::sleep_for(10s); // Alice re-adds Bob - auto oldConv = convId; - conversationRmAlice = false; + auto oldConv = bobData.conversationId; aliceAccount->addContact(bobUri); aliceAccount->sendTrustRequest(bobUri, {}); // This should retrieve the conversation from Bob and don't show any error - CPPUNIT_ASSERT(!cv.wait_for(lk, 10s, [&]() { return errorDetected; })); - CPPUNIT_ASSERT(conversationRmAlice); - CPPUNIT_ASSERT(oldConv == convId); // Check that convId didn't change and conversation is ready. + CPPUNIT_ASSERT(!cv.wait_for(lk, 10s, [&]() { return aliceData.errorDetected; })); + CPPUNIT_ASSERT(oldConv == aliceData.conversationId); // Check that convId didn't change and conversation is ready. } void ConversationTest::testSendReply() { std::cout << "\nRunning test: " << __func__ << std::endl; + connectSignals(); - auto aliceAccount = Manager::instance().getAccount(aliceId); auto bobAccount = Manager::instance().getAccount(bobId); auto bobUri = bobAccount->getUsername(); - - std::map> confHandlers; - std::vector> messageBobReceived = {}, - messageAliceReceived = {}; - confHandlers.insert(libjami::exportable_callback( - [&](const std::string& accountId, - const std::string& /* conversationId */, - std::map message) { - if (accountId == bobId) { - messageBobReceived.emplace_back(message); - } else { - messageAliceReceived.emplace_back(message); - } - cv.notify_one(); - })); - bool requestReceived = false; - confHandlers.insert( - libjami::exportable_callback( - [&](const std::string& /*accountId*/, - const std::string& /* conversationId */, - std::map /*metadatas*/) { - requestReceived = true; - cv.notify_one(); - })); - bool conversationReady = false; - confHandlers.insert(libjami::exportable_callback( - [&](const std::string& accountId, const std::string& /* conversationId */) { - if (accountId == bobId) { - conversationReady = true; - cv.notify_one(); - } - })); - libjami::registerSignalHandlers(confHandlers); - auto convId = libjami::startConversation(aliceId); libjami::addConversationMember(aliceId, convId, bobUri); - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return requestReceived; })); - + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return bobData.requestReceived; })); + auto aliceMsgSize = aliceData.messages.size(); libjami::acceptConversationRequest(bobId, convId); - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return conversationReady; })); + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return !bobData.conversationId.empty() && aliceMsgSize + 1 == aliceData.messages.size(); })); - // Assert that repository exists - auto repoPath = fileutils::get_data_dir() / bobAccount->getAccountID() - / "conversations" / convId; - CPPUNIT_ASSERT(std::filesystem::is_directory(repoPath)); - // Wait that alice sees Bob - cv.wait_for(lk, 30s, [&]() { return messageAliceReceived.size() == 2; }); - - messageBobReceived.clear(); + auto bobMsgSize = bobData.messages.size(); libjami::sendMessage(aliceId, convId, "hi"s, ""); - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return messageBobReceived.size() == 1; })); + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return bobData.messages.size() == bobMsgSize + 1; })); - auto validId = messageBobReceived.at(0).at("id"); + auto validId = bobData.messages.at(0).id; libjami::sendMessage(aliceId, convId, "foo"s, validId); - CPPUNIT_ASSERT(cv.wait_for(lk, 10s, [&]() { return messageBobReceived.size() == 2; })); - CPPUNIT_ASSERT(messageBobReceived.rbegin()->at("reply-to") == validId); + CPPUNIT_ASSERT(cv.wait_for(lk, 10s, [&]() { return bobData.messages.size() == bobMsgSize + 2; })); + CPPUNIT_ASSERT(bobData.messages.rbegin()->body.at("reply-to") == validId); // Check if parent doesn't exists, no message is generated libjami::sendMessage(aliceId, convId, "foo"s, "invalid"); - CPPUNIT_ASSERT(!cv.wait_for(lk, 10s, [&]() { return messageBobReceived.size() == 3; })); + CPPUNIT_ASSERT(!cv.wait_for(lk, 10s, [&]() { return bobData.messages.size() == bobMsgSize + 3; })); } void ConversationTest::testSearchInConv() { std::cout << "\nRunning test: " << __func__ << std::endl; + connectSignals(); auto aliceAccount = Manager::instance().getAccount(aliceId); auto bobAccount = Manager::instance().getAccount(bobId); auto bobUri = bobAccount->getUsername(); auto aliceUri = aliceAccount->getUsername(); - std::map> confHandlers; - bool conversationReady = false, requestReceived = false, memberMessageGenerated = false, - messageReceived = false; - std::vector bobMessages; - std::string convId = ""; - confHandlers.insert( - libjami::exportable_callback( - [&](const std::string& account_id, - const std::string& /*from*/, - const std::string& /*conversationId*/, - const std::vector& /*payload*/, - time_t /*received*/) { - if (account_id == bobId) - requestReceived = true; - cv.notify_one(); - })); - confHandlers.insert(libjami::exportable_callback( - [&](const std::string& accountId, const std::string& conversationId) { - if (accountId == aliceId) { - convId = conversationId; - } else if (accountId == bobId) { - conversationReady = true; - } - cv.notify_one(); - })); - confHandlers.insert(libjami::exportable_callback( - [&](const std::string& accountId, - const std::string& conversationId, - std::map message) { - if (accountId == aliceId && conversationId == convId) { - if (message["type"] == "member") - memberMessageGenerated = true; - } else if (accountId == bobId) { - messageReceived = true; - } - cv.notify_one(); - })); - std::vector> messages; - bool finished = false; - confHandlers.insert(libjami::exportable_callback( - [&](uint32_t, - const std::string&, - const std::string& conversationId, - std::vector> msg) { - if (conversationId == convId) - messages = msg; - finished = conversationId.empty(); - cv.notify_one(); - })); - libjami::registerSignalHandlers(confHandlers); - requestReceived = false; + + auto aliceMsgSize = aliceData.messages.size(); aliceAccount->addContact(bobUri); aliceAccount->sendTrustRequest(bobUri, {}); - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return requestReceived; })); + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return bobData.requestReceived; })); CPPUNIT_ASSERT(bobAccount->acceptTrustRequest(aliceUri)); CPPUNIT_ASSERT( - cv.wait_for(lk, 30s, [&]() { return conversationReady && memberMessageGenerated; })); + cv.wait_for(lk, 30s, [&]() { return !bobData.conversationId.empty() && aliceMsgSize + 1 == aliceData.messages.size(); })); // Add some messages - messageReceived = false; - libjami::sendMessage(aliceId, convId, "message 1"s, ""); - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return messageReceived; })); - messageReceived = false; - libjami::sendMessage(aliceId, convId, "message 2"s, ""); - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return messageReceived; })); - messageReceived = false; - libjami::sendMessage(aliceId, convId, "Message 3"s, ""); - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return messageReceived; })); + auto bobMsgSize = bobData.messages.size(); + libjami::sendMessage(aliceId, aliceData.conversationId, "message 1"s, ""); + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return bobMsgSize + 1 == bobData.messages.size(); })); + libjami::sendMessage(aliceId, aliceData.conversationId, "message 2"s, ""); + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return bobMsgSize + 2 == bobData.messages.size(); })); + libjami::sendMessage(aliceId, aliceData.conversationId, "Message 3"s, ""); + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return bobMsgSize + 3 == bobData.messages.size(); })); - libjami::searchConversation(aliceId, convId, "", "", "message", "", 0, 0, 0, 0); - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return messages.size() == 3 && finished; })); - messages.clear(); - finished = false; - libjami::searchConversation(aliceId, convId, "", "", "Message", "", 0, 0, 0, 1); - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return messages.size() == 1 && finished; })); - messages.clear(); - finished = false; - libjami::searchConversation(aliceId, convId, "", "", "message 2", "", 0, 0, 0, 0); - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return messages.size() == 1 && finished; })); - messages.clear(); - finished = false; - libjami::searchConversation(aliceId, convId, "", "", "foo", "", 0, 0, 0, 0); - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return messages.size() == 0 && finished; })); + libjami::searchConversation(aliceId, aliceData.conversationId, "", "", "message", "", 0, 0, 0, 0); + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return aliceData.messagesFound.size() == 3 && aliceData.searchFinished; })); + aliceData.messagesFound.clear(); + aliceData.searchFinished = false; + libjami::searchConversation(aliceId, aliceData.conversationId, "", "", "Message", "", 0, 0, 0, 1); + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return aliceData.messagesFound.size() == 1 && aliceData.searchFinished; })); + aliceData.messagesFound.clear(); + aliceData.searchFinished = false; + libjami::searchConversation(aliceId, aliceData.conversationId, "", "", "message 2", "", 0, 0, 0, 0); + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return aliceData.messagesFound.size() == 1 && aliceData.searchFinished; })); + aliceData.messagesFound.clear(); + aliceData.searchFinished = false; + libjami::searchConversation(aliceId, aliceData.conversationId, "", "", "foo", "", 0, 0, 0, 0); + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return aliceData.messagesFound.size() == 0 && aliceData.searchFinished; })); } void ConversationTest::testConversationPreferences() { std::cout << "\nRunning test: " << __func__ << std::endl; + connectSignals(); - auto aliceAccount = Manager::instance().getAccount(aliceId); - auto uri = aliceAccount->getUsername(); - std::map> confHandlers; - bool conversationReady = false, conversationRemoved = false; - confHandlers.insert(libjami::exportable_callback( - [&](const std::string& accountId, const std::string& /* conversationId */) { - if (accountId == aliceId) { - conversationReady = true; - cv.notify_one(); - } - })); - confHandlers.insert( - libjami::exportable_callback( - [&](const std::string& accountId, const std::string&) { - if (accountId == aliceId) - conversationRemoved = true; - cv.notify_one(); - })); - libjami::registerSignalHandlers(confHandlers); // Start conversation and set preferences auto convId = libjami::startConversation(aliceId); - cv.wait_for(lk, 30s, [&]() { return conversationReady; }); + cv.wait_for(lk, 30s, [&]() { return !aliceData.conversationId.empty(); }); CPPUNIT_ASSERT(libjami::getConversationPreferences(aliceId, convId).size() == 0); libjami::setConversationPreferences(aliceId, convId, {{"foo", "bar"}}); auto preferences = libjami::getConversationPreferences(aliceId, convId); @@ -3514,7 +2262,7 @@ ConversationTest::testConversationPreferences() CPPUNIT_ASSERT(preferences["bar"] == "foo"); // Remove conversations removes its preferences. CPPUNIT_ASSERT(libjami::removeConversation(aliceId, convId)); - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return conversationRemoved; })); + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return aliceData.removed; })); CPPUNIT_ASSERT(libjami::getConversationPreferences(aliceId, convId).size() == 0); } @@ -3522,79 +2270,27 @@ void ConversationTest::testConversationPreferencesBeforeClone() { std::cout << "\nRunning test: " << __func__ << std::endl; + connectSignals(); auto aliceAccount = Manager::instance().getAccount(aliceId); auto bobAccount = Manager::instance().getAccount(bobId); auto bobUri = bobAccount->getUsername(); - auto aliceUri = aliceAccount->getUsername(); - std::map> confHandlers; - auto requestReceived = false, requestReceivedBob2 = false; - confHandlers.insert( - libjami::exportable_callback( - [&](const std::string& accountId, - const std::string& conversationId, - std::map /*metadatas*/) { - if (accountId == bobId) - requestReceived = true; - else if (accountId == bob2Id) - requestReceivedBob2 = true; - cv.notify_one(); - })); - std::string convId = ""; - auto conversationReadyBob = false, conversationReadyBob2 = false; - confHandlers.insert(libjami::exportable_callback( - [&](const std::string& accountId, const std::string& conversationId) { - if (accountId == aliceId) { - convId = conversationId; - } else if (accountId == bobId) { - conversationReadyBob = true; - } else if (accountId == bob2Id) { - conversationReadyBob2 = true; - } - cv.notify_one(); - })); - auto bob2Started = false; - confHandlers.insert( - libjami::exportable_callback( - [&](const std::string& accountId, const std::map& details) { - if (accountId == bob2Id) { - auto daemonStatus = details.at( - libjami::Account::VolatileProperties::DEVICE_ANNOUNCED); - if (daemonStatus == "true") - bob2Started = true; - } - cv.notify_one(); - })); - std::map preferencesBob, preferencesBob2; - confHandlers.insert( - libjami::exportable_callback( - [&](const std::string& accountId, - const std::string& conversationId, - std::map preferences) { - if (accountId == bobId) - preferencesBob = preferences; - else if (accountId == bob2Id) - preferencesBob2 = preferences; - cv.notify_one(); - })); - libjami::registerSignalHandlers(confHandlers); // Bob creates a second device auto bobArchive = std::filesystem::current_path().string() + "/bob.gz"; std::remove(bobArchive.c_str()); bobAccount->exportArchive(bobArchive); // Alice adds bob - requestReceived = false; aliceAccount->addContact(bobUri); aliceAccount->sendTrustRequest(bobUri, {}); - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return requestReceived; })); - libjami::acceptConversationRequest(bobId, convId); - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return conversationReadyBob; })); + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return bobData.requestReceived; })); + libjami::acceptConversationRequest(bobId, aliceData.conversationId); + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return !bobData.conversationId.empty(); })); // Set preferences Manager::instance().sendRegister(aliceId, false); - libjami::setConversationPreferences(bobId, convId, {{"foo", "bar"}, {"bar", "foo"}}); - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return preferencesBob.size() == 2; })); - CPPUNIT_ASSERT(preferencesBob["foo"] == "bar" && preferencesBob["bar"] == "foo"); + libjami::setConversationPreferences(bobId, bobData.conversationId, {{"foo", "bar"}, {"bar", "foo"}}); + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return bobData.preferences.size() == 2; })); + CPPUNIT_ASSERT(bobData.preferences["foo"] == "bar" && bobData.preferences["bar"] == "foo"); // Bob2 should sync preferences std::map details = libjami::getAccountTemplate("RING"); @@ -3607,71 +2303,20 @@ ConversationTest::testConversationPreferencesBeforeClone() details[ConfProperties::ARCHIVE_PATH] = bobArchive; bob2Id = Manager::instance().addAccount(details); CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { - return bob2Started && conversationReadyBob2 && !preferencesBob2.empty(); + return bob2Data.deviceAnnounced && !bob2Data.conversationId.empty() && !bob2Data.preferences.empty(); })); - CPPUNIT_ASSERT(preferencesBob2["foo"] == "bar" && preferencesBob2["bar"] == "foo"); + CPPUNIT_ASSERT(bob2Data.preferences["foo"] == "bar" && bob2Data.preferences["bar"] == "foo"); } void ConversationTest::testConversationPreferencesMultiDevices() { std::cout << "\nRunning test: " << __func__ << std::endl; + connectSignals(); auto aliceAccount = Manager::instance().getAccount(aliceId); auto bobAccount = Manager::instance().getAccount(bobId); auto bobUri = bobAccount->getUsername(); - auto aliceUri = aliceAccount->getUsername(); - std::map> confHandlers; - auto requestReceived = false, requestReceivedBob2 = false; - confHandlers.insert( - libjami::exportable_callback( - [&](const std::string& accountId, - const std::string& conversationId, - std::map /*metadatas*/) { - if (accountId == bobId) - requestReceived = true; - else if (accountId == bob2Id) - requestReceivedBob2 = true; - cv.notify_one(); - })); - std::string convId = ""; - auto conversationReadyBob = false, conversationReadyBob2 = false; - confHandlers.insert(libjami::exportable_callback( - [&](const std::string& accountId, const std::string& conversationId) { - if (accountId == aliceId) { - convId = conversationId; - } else if (accountId == bobId) { - conversationReadyBob = true; - } else if (accountId == bob2Id) { - conversationReadyBob2 = true; - } - cv.notify_one(); - })); - auto bob2Started = false; - confHandlers.insert( - libjami::exportable_callback( - [&](const std::string& accountId, const std::map& details) { - if (accountId == bob2Id) { - auto daemonStatus = details.at( - libjami::Account::VolatileProperties::DEVICE_ANNOUNCED); - if (daemonStatus == "true") - bob2Started = true; - } - cv.notify_one(); - })); - std::map preferencesBob, preferencesBob2; - confHandlers.insert( - libjami::exportable_callback( - [&](const std::string& accountId, - const std::string& conversationId, - std::map preferences) { - if (accountId == bobId) - preferencesBob = preferences; - else if (accountId == bob2Id) - preferencesBob2 = preferences; - cv.notify_one(); - })); - libjami::registerSignalHandlers(confHandlers); // Bob creates a second device auto bobArchive = std::filesystem::current_path().string() + "/bob.gz"; std::remove(bobArchive.c_str()); @@ -3685,50 +2330,39 @@ ConversationTest::testConversationPreferencesMultiDevices() details[ConfProperties::ARCHIVE_PIN] = ""; details[ConfProperties::ARCHIVE_PATH] = bobArchive; bob2Id = Manager::instance().addAccount(details); - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return bob2Started; })); + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return bob2Data.deviceAnnounced; })); // Alice adds bob - requestReceived = false; aliceAccount->addContact(bobUri); aliceAccount->sendTrustRequest(bobUri, {}); - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return requestReceived && requestReceivedBob2; })); - libjami::acceptConversationRequest(bobId, convId); + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return bobData.requestReceived && bob2Data.requestReceived; })); + libjami::acceptConversationRequest(bobId, aliceData.conversationId); CPPUNIT_ASSERT( - cv.wait_for(lk, 30s, [&]() { return conversationReadyBob && conversationReadyBob2; })); - libjami::setConversationPreferences(bobId, convId, {{"foo", "bar"}, {"bar", "foo"}}); + cv.wait_for(lk, 30s, [&]() { return !bobData.conversationId.empty() && !bob2Data.conversationId.empty(); })); + libjami::setConversationPreferences(bobId, bobData.conversationId, {{"foo", "bar"}, {"bar", "foo"}}); CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { - return preferencesBob.size() == 2 && preferencesBob2.size() == 2; + return bobData.preferences.size() == 2 && bob2Data.preferences.size() == 2; })); - CPPUNIT_ASSERT(preferencesBob["foo"] == "bar" && preferencesBob["bar"] == "foo"); - CPPUNIT_ASSERT(preferencesBob2["foo"] == "bar" && preferencesBob2["bar"] == "foo"); + CPPUNIT_ASSERT(bobData.preferences["foo"] == "bar" && bobData.preferences["bar"] == "foo"); + CPPUNIT_ASSERT(bob2Data.preferences["foo"] == "bar" && bob2Data.preferences["bar"] == "foo"); } void ConversationTest::testFixContactDetails() { std::cout << "\nRunning test: " << __func__ << std::endl; + connectSignals(); auto aliceAccount = Manager::instance().getAccount(aliceId); auto bobAccount = Manager::instance().getAccount(bobId); auto bobUri = bobAccount->getUsername(); - std::map> confHandlers; - std::string convId = ""; - confHandlers.insert(libjami::exportable_callback( - [&](const std::string& accountId, const std::string& conversationId) { - if (accountId == aliceId) { - convId = conversationId; - } - cv.notify_one(); - })); - libjami::registerSignalHandlers(confHandlers); - aliceAccount->addContact(bobUri); - CPPUNIT_ASSERT(cv.wait_for(lk, 10s, [&]() { return !convId.empty(); })); + CPPUNIT_ASSERT(cv.wait_for(lk, 10s, [&]() { return !aliceData.conversationId.empty(); })); auto details = aliceAccount->getContactDetails(bobUri); - CPPUNIT_ASSERT(details["conversationId"] == convId); + CPPUNIT_ASSERT(details["conversationId"] == aliceData.conversationId); // Erase convId from contact details, this should be fixed by next reload. - CPPUNIT_ASSERT(aliceAccount->updateConvForContact(bobUri, convId, "")); + CPPUNIT_ASSERT(aliceAccount->updateConvForContact(bobUri, aliceData.conversationId, "")); details = aliceAccount->getContactDetails(bobUri); CPPUNIT_ASSERT(details["conversationId"].empty()); @@ -3737,136 +2371,77 @@ ConversationTest::testFixContactDetails() std::this_thread::sleep_for(5s); // Let the daemon fix the structures details = aliceAccount->getContactDetails(bobUri); - CPPUNIT_ASSERT(details["conversationId"] == convId); + CPPUNIT_ASSERT(details["conversationId"] == aliceData.conversationId); } void ConversationTest::testRemoveOneToOneNotInDetails() { std::cout << "\nRunning test: " << __func__ << std::endl; + connectSignals(); auto aliceAccount = Manager::instance().getAccount(aliceId); auto bobAccount = Manager::instance().getAccount(bobId); auto bobUri = bobAccount->getUsername(); - std::map> confHandlers; - std::string convId = "", secondConv; - confHandlers.insert(libjami::exportable_callback( - [&](const std::string& accountId, const std::string& conversationId) { - if (accountId == aliceId) { - if (convId.empty()) - convId = conversationId; - else - secondConv = conversationId; - } - cv.notify_one(); - })); - bool conversationRemoved = false; - confHandlers.insert( - libjami::exportable_callback( - [&](const std::string& accountId, const std::string& cid) { - if (accountId == aliceId && cid == secondConv) - conversationRemoved = true; - cv.notify_one(); - })); - libjami::registerSignalHandlers(confHandlers); - aliceAccount->addContact(bobUri); - CPPUNIT_ASSERT(cv.wait_for(lk, 10s, [&]() { return !convId.empty(); })); + CPPUNIT_ASSERT(cv.wait_for(lk, 10s, [&]() { return !aliceData.conversationId.empty(); })); auto details = aliceAccount->getContactDetails(bobUri); - CPPUNIT_ASSERT(details["conversationId"] == convId); + CPPUNIT_ASSERT(details["conversationId"] == aliceData.conversationId); + auto firstConv = aliceData.conversationId; // Create a duplicate std::this_thread::sleep_for(2s); // Avoid to get same id aliceAccount->convModule()->startConversation(ConversationMode::ONE_TO_ONE, bobUri); - CPPUNIT_ASSERT(cv.wait_for(lk, 10s, [&]() { return !secondConv.empty(); })); + CPPUNIT_ASSERT(cv.wait_for(lk, 10s, [&]() { return firstConv != aliceData.conversationId; })); // Assert that repository exists - auto repoPath = fileutils::get_data_dir() / aliceAccount->getAccountID() - / "conversations" / secondConv; + auto repoPath = fileutils::get_data_dir() / aliceId + / "conversations" / aliceData.conversationId; CPPUNIT_ASSERT(std::filesystem::is_directory(repoPath)); aliceAccount->convModule()->loadConversations(); // Check that conv is removed - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return conversationRemoved; })); + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return aliceData.removed; })); } void ConversationTest::testMessageEdition() { std::cout << "\nRunning test: " << __func__ << std::endl; + connectSignals(); auto aliceAccount = Manager::instance().getAccount(aliceId); auto bobAccount = Manager::instance().getAccount(bobId); auto bobUri = bobAccount->getUsername(); - std::map> confHandlers; - std::vector> messageBobReceived; - bool conversationReady = false, memberMessageGenerated = false; - confHandlers.insert(libjami::exportable_callback( - [&](const std::string& accountId, - const std::string& /* conversationId */, - std::map message) { - if (accountId == bobId) { - messageBobReceived.emplace_back(message); - } else if (accountId == aliceId && message["type"] == "member") { - memberMessageGenerated = true; - } - cv.notify_one(); - })); - bool requestReceived = false; - confHandlers.insert( - libjami::exportable_callback( - [&](const std::string& /*accountId*/, - const std::string& /* conversationId */, - std::map /*metadatas*/) { - requestReceived = true; - cv.notify_one(); - })); - confHandlers.insert(libjami::exportable_callback( - [&](const std::string& accountId, const std::string& /* conversationId */) { - if (accountId == bobId) { - conversationReady = true; - cv.notify_one(); - } - })); - auto errorDetected = false; - confHandlers.insert( - libjami::exportable_callback( - [&](const std::string& /* accountId */, - const std::string& /* conversationId */, - int code, - const std::string& /* what */) { - if (code == 3) - errorDetected = true; - cv.notify_one(); - })); - libjami::registerSignalHandlers(confHandlers); auto convId = libjami::startConversation(aliceId); libjami::addConversationMember(aliceId, convId, bobUri); - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return requestReceived; })); - memberMessageGenerated = false; + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return bobData.requestReceived; })); + + auto aliceMsgSize = aliceData.messages.size(); libjami::acceptConversationRequest(bobId, convId); CPPUNIT_ASSERT( - cv.wait_for(lk, 30s, [&]() { return conversationReady && memberMessageGenerated; })); - auto msgSize = messageBobReceived.size(); + cv.wait_for(lk, 30s, [&]() { return !bobData.conversationId.empty() && aliceData.messages.size() == aliceMsgSize + 1; })); + + auto bobMsgSize = bobData.messages.size(); libjami::sendMessage(aliceId, convId, "hi"s, ""); - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return messageBobReceived.size() == msgSize + 1; })); - msgSize = messageBobReceived.size(); - auto editedId = messageBobReceived.rbegin()->at("id"); + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return bobData.messages.size() == bobMsgSize + 1; })); + auto editedId = bobData.messages.rbegin()->id; + // Should trigger MessageUpdated + bobMsgSize = bobData.messagesUpdated.size(); libjami::sendMessage(aliceId, convId, "New body"s, editedId, 1); - CPPUNIT_ASSERT(cv.wait_for(lk, 10s, [&]() { return messageBobReceived.size() == msgSize + 1; })); - CPPUNIT_ASSERT(messageBobReceived.rbegin()->at("edit") == editedId); - CPPUNIT_ASSERT(messageBobReceived.rbegin()->at("body") == "New body"); + CPPUNIT_ASSERT(cv.wait_for(lk, 10s, [&]() { return bobData.messagesUpdated.size() == bobMsgSize + 1; })); + CPPUNIT_ASSERT(bobData.messagesUpdated.rbegin()->body.at("body") == "New body"); // Not an existing message - msgSize = messageBobReceived.size(); + bobMsgSize = bobData.messagesUpdated.size(); libjami::sendMessage(aliceId, convId, "New body"s, "invalidId", 1); CPPUNIT_ASSERT( - !cv.wait_for(lk, 10s, [&]() { return messageBobReceived.size() == msgSize + 1; })); + !cv.wait_for(lk, 10s, [&]() { return bobData.messagesUpdated.size() == bobMsgSize + 1; })); // Invalid author libjami::sendMessage(aliceId, convId, "New body"s, convId, 1); CPPUNIT_ASSERT( - !cv.wait_for(lk, 10s, [&]() { return messageBobReceived.size() == msgSize + 1; })); + !cv.wait_for(lk, 10s, [&]() { return bobData.messagesUpdated.size() == bobMsgSize + 1; })); // Add invalid edition Json::Value root; root["type"] = "application/edited-message"; @@ -3875,113 +2450,71 @@ ConversationTest::testMessageEdition() Json::StreamWriterBuilder wbuilder; wbuilder["commentStyle"] = "None"; wbuilder["indentation"] = ""; - auto repoPath = fileutils::get_data_dir() / aliceAccount->getAccountID() + auto repoPath = fileutils::get_data_dir() / aliceId / "conversations" / convId; auto message = Json::writeString(wbuilder, root); commitInRepo(repoPath, aliceAccount, message); - errorDetected = false; + bobData.errorDetected = false; libjami::sendMessage(aliceId, convId, "trigger"s, ""); - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return errorDetected; })); + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return bobData.errorDetected; })); + } void ConversationTest::testMessageReaction() { std::cout << "\nRunning test: " << __func__ << std::endl; - - auto aliceAccount = Manager::instance().getAccount(aliceId); - auto bobAccount = Manager::instance().getAccount(bobId); - auto bobUri = bobAccount->getUsername(); - std::map> confHandlers; - std::vector> messageAliceReceived; - bool conversationReady = false; - confHandlers.insert(libjami::exportable_callback( - [&](const std::string& accountId, - const std::string& /* conversationId */, - std::map message) { - if (accountId == aliceId) - messageAliceReceived.emplace_back(message); - cv.notify_one(); - })); - confHandlers.insert(libjami::exportable_callback( - [&](const std::string& accountId, const std::string& /* conversationId */) { - if (accountId == aliceId) - conversationReady = true; - cv.notify_one(); - })); - libjami::registerSignalHandlers(confHandlers); + connectSignals(); auto convId = libjami::startConversation(aliceId); - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return conversationReady; })); - auto msgSize = messageAliceReceived.size(); + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return !aliceData.conversationId.empty(); })); + auto msgSize = aliceData.messages.size(); libjami::sendMessage(aliceId, convId, "hi"s, ""); CPPUNIT_ASSERT( - cv.wait_for(lk, 30s, [&]() { return messageAliceReceived.size() == msgSize + 1; })); - msgSize = messageAliceReceived.size(); - - auto reactId = messageAliceReceived.rbegin()->at("id"); + cv.wait_for(lk, 30s, [&]() { return aliceData.messages.size() == msgSize + 1; })); + msgSize = aliceData.messages.size(); + // Add reaction + auto reactId = aliceData.messages.rbegin()->id; libjami::sendMessage(aliceId, convId, "👋"s, reactId, 2); CPPUNIT_ASSERT( - cv.wait_for(lk, 10s, [&]() { return messageAliceReceived.size() == msgSize + 1; })); - CPPUNIT_ASSERT(messageAliceReceived.rbegin()->at("react-to") == reactId); - CPPUNIT_ASSERT(messageAliceReceived.rbegin()->at("body") == "👋"); + cv.wait_for(lk, 10s, [&]() { return aliceData.reactions.size() == 1; })); + CPPUNIT_ASSERT(aliceData.reactions.rbegin()->at("react-to") == reactId); + CPPUNIT_ASSERT(aliceData.reactions.rbegin()->at("body") == "👋"); + auto emojiId = aliceData.reactions.rbegin()->at("id"); + + // Remove reaction + libjami::sendMessage(aliceId, convId, ""s, emojiId, 1); + CPPUNIT_ASSERT( + cv.wait_for(lk, 10s, [&]() { return aliceData.reactionRemoved.size() == 1; })); + CPPUNIT_ASSERT(emojiId == aliceData.reactionRemoved[0]); } void ConversationTest::testLoadPartiallyRemovedConversation() { std::cout << "\nRunning test: " << __func__ << std::endl; + connectSignals(); auto aliceAccount = Manager::instance().getAccount(aliceId); auto bobAccount = Manager::instance().getAccount(bobId); auto bobUri = bobAccount->getUsername(); - auto aliceUri = aliceAccount->getUsername(); - std::map> confHandlers; - bool requestReceived = false; - confHandlers.insert( - libjami::exportable_callback( - [&](const std::string& account_id, - const std::string& /*from*/, - const std::string& /*conversationId*/, - const std::vector& /*payload*/, - time_t /*received*/) { - if (account_id == bobId) - requestReceived = true; - cv.notify_one(); - })); - std::string convId = ""; - confHandlers.insert(libjami::exportable_callback( - [&](const std::string& accountId, const std::string& conversationId) { - if (accountId == aliceId) { - convId = conversationId; - } - cv.notify_one(); - })); - bool conversationRemoved = false; - confHandlers.insert( - libjami::exportable_callback( - [&](const std::string& accountId, const std::string&) { - if (accountId == aliceId) - conversationRemoved = true; - cv.notify_one(); - })); - libjami::registerSignalHandlers(confHandlers); + aliceAccount->addContact(bobUri); aliceAccount->sendTrustRequest(bobUri, {}); - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return requestReceived; })); + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return bobData.requestReceived; })); // Copy alice's conversation temporary - auto repoPathAlice = fileutils::get_data_dir() / aliceAccount->getAccountID() / "conversations" / convId; - std::filesystem::copy(repoPathAlice, fmt::format("./{}", convId), std::filesystem::copy_options::recursive); + auto repoPathAlice = fileutils::get_data_dir() / aliceId / "conversations" / aliceData.conversationId; + std::filesystem::copy(repoPathAlice, fmt::format("./{}", aliceData.conversationId), std::filesystem::copy_options::recursive); // removeContact aliceAccount->removeContact(bobUri, false); - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return conversationRemoved; })); + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return aliceData.removed; })); std::this_thread::sleep_for(10s); // Wait for connection to close and async tasks to finish // Copy back alice's conversation - std::filesystem::copy(fmt::format("./{}", convId), repoPathAlice, std::filesystem::copy_options::recursive); - std::filesystem::remove_all(fmt::format("./{}", convId)); + std::filesystem::copy(fmt::format("./{}", aliceData.conversationId), repoPathAlice, std::filesystem::copy_options::recursive); + std::filesystem::remove_all(fmt::format("./{}", aliceData.conversationId)); // Reloading conversation should remove directory CPPUNIT_ASSERT(std::filesystem::is_directory(repoPathAlice)); diff --git a/test/unitTest/conversation/conversationMembersEvent.cpp b/test/unitTest/conversation/conversationMembersEvent.cpp index e3730f103..8efab0997 100644 --- a/test/unitTest/conversation/conversationMembersEvent.cpp +++ b/test/unitTest/conversation/conversationMembersEvent.cpp @@ -44,6 +44,21 @@ using namespace libjami::Account; namespace jami { namespace test { +struct UserData { + std::string conversationId; + bool removed {false}; + bool requestReceived {false}; + bool requestRemoved {false}; + bool errorDetected {false}; + bool registered {false}; + bool stopped {false}; + bool deviceAnnounced {false}; + bool contactRemoved {false}; + std::string payloadTrustRequest; + std::vector messages; + std::vector messagesUpdated; +}; + class ConversationMembersEventTest : public CppUnit::TestFixture { public: @@ -90,15 +105,22 @@ public: void testBanHostWhileHosting(); void testRemoveContactTwice(); void testAddContactTwice(); + void testBanFromNewDevice(); std::string aliceId; + UserData aliceData; std::string bobId; + UserData bobData; std::string bob2Id; + UserData bob2Data; std::string carlaId; + UserData carlaData; std::mutex mtx; std::unique_lock lk {mtx}; std::condition_variable cv; + void connectSignals(); + private: CPPUNIT_TEST_SUITE(ConversationMembersEventTest); CPPUNIT_TEST(testRemoveConversationNoMember); @@ -136,6 +158,7 @@ private: CPPUNIT_TEST(testBanHostWhileHosting); CPPUNIT_TEST(testRemoveContactTwice); CPPUNIT_TEST(testAddContactTwice); + CPPUNIT_TEST(testBanFromNewDevice); CPPUNIT_TEST_SUITE_END(); }; @@ -145,6 +168,8 @@ CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(ConversationMembersEventTest, void ConversationMembersEventTest::setUp() { + connectSignals(); + // Init daemon libjami::init( libjami::InitFlag(libjami::LIBJAMI_FLAG_DEBUG | libjami::LIBJAMI_FLAG_CONSOLE_LOG)); @@ -156,6 +181,11 @@ ConversationMembersEventTest::setUp() bobId = actors["bob"]; carlaId = actors["carla"]; + aliceData = {}; + bobData = {}; + bob2Data = {}; + carlaData = {}; + Manager::instance().sendRegister(carlaId, false); wait_for_announcement_of({aliceId, bobId}); } @@ -163,6 +193,8 @@ ConversationMembersEventTest::setUp() void ConversationMembersEventTest::tearDown() { + connectSignals(); + auto bobArchive = std::filesystem::current_path().string() + "/bob.gz"; std::remove(bobArchive.c_str()); if (bob2Id.empty()) { @@ -172,6 +204,178 @@ ConversationMembersEventTest::tearDown() } } +void +ConversationMembersEventTest::connectSignals() +{ + std::map> confHandlers; + confHandlers.insert( + libjami::exportable_callback( + [&](const std::string& accountId, const std::map&) { + if (accountId == aliceId) { + auto aliceAccount = Manager::instance().getAccount(aliceId); + auto details = aliceAccount->getVolatileAccountDetails(); + auto daemonStatus = details[libjami::Account::ConfProperties::Registration::STATUS]; + if (daemonStatus == "REGISTERED") { + aliceData.registered = true; + } else if (daemonStatus == "UNREGISTERED") { + aliceData.stopped = true; + } + auto deviceAnnounced = details[libjami::Account::VolatileProperties::DEVICE_ANNOUNCED]; + aliceData.deviceAnnounced = deviceAnnounced == "true"; + } else if (accountId == bobId) { + auto bobAccount = Manager::instance().getAccount(bobId); + auto details = bobAccount->getVolatileAccountDetails(); + auto daemonStatus = details[libjami::Account::ConfProperties::Registration::STATUS]; + if (daemonStatus == "REGISTERED") { + bobData.registered = true; + } else if (daemonStatus == "UNREGISTERED") { + bobData.stopped = true; + } + auto deviceAnnounced = details[libjami::Account::VolatileProperties::DEVICE_ANNOUNCED]; + bobData.deviceAnnounced = deviceAnnounced == "true"; + } else if (accountId == bob2Id) { + auto bob2Account = Manager::instance().getAccount(bob2Id); + auto details = bob2Account->getVolatileAccountDetails(); + auto daemonStatus = details[libjami::Account::ConfProperties::Registration::STATUS]; + if (daemonStatus == "REGISTERED") { + bob2Data.registered = true; + } else if (daemonStatus == "UNREGISTERED") { + bob2Data.stopped = true; + } + auto deviceAnnounced = details[libjami::Account::VolatileProperties::DEVICE_ANNOUNCED]; + bob2Data.deviceAnnounced = deviceAnnounced == "true"; + } else if (accountId == carlaId) { + auto carlaAccount = Manager::instance().getAccount(carlaId); + auto details = carlaAccount->getVolatileAccountDetails(); + auto daemonStatus = details[libjami::Account::ConfProperties::Registration::STATUS]; + if (daemonStatus == "REGISTERED") { + carlaData.registered = true; + } else if (daemonStatus == "UNREGISTERED") { + carlaData.stopped = true; + } + auto deviceAnnounced = details[libjami::Account::VolatileProperties::DEVICE_ANNOUNCED]; + carlaData.deviceAnnounced = deviceAnnounced == "true"; + } + cv.notify_one(); + })); + confHandlers.insert(libjami::exportable_callback( + [&](const std::string& accountId, const std::string& conversationId) { + if (accountId == aliceId) { + aliceData.conversationId = conversationId; + } else if (accountId == bobId) { + bobData.conversationId = conversationId; + } else if (accountId == bob2Id) { + bob2Data.conversationId = conversationId; + } else if (accountId == carlaId) { + carlaData.conversationId = conversationId; + } + cv.notify_one(); + })); + confHandlers.insert( + libjami::exportable_callback( + [&](const std::string& account_id, + const std::string& /*from*/, + const std::string& /*conversationId*/, + const std::vector& payload, + time_t /*received*/) { + auto payloadStr = std::string(payload.data(), payload.data() + payload.size()); + if (account_id == aliceId) + aliceData.payloadTrustRequest = payloadStr; + else if (account_id == bobId) + bobData.payloadTrustRequest = payloadStr; + cv.notify_one(); + })); + confHandlers.insert( + libjami::exportable_callback( + [&](const std::string& accountId, + const std::string& /* conversationId */, + std::map /*metadatas*/) { + if (accountId == aliceId) { + aliceData.requestReceived = true; + } else if (accountId == bobId) { + bobData.requestReceived = true; + } else if (accountId == bob2Id) { + bob2Data.requestReceived = true; + } else if (accountId == carlaId) { + carlaData.requestReceived = true; + } + cv.notify_one(); + })); + confHandlers.insert( + libjami::exportable_callback( + [&](const std::string& accountId, const std::string&) { + if (accountId == bobId) { + bobData.requestRemoved = true; + } else if (accountId == bob2Id) { + bob2Data.requestRemoved = true; + } + cv.notify_one(); + })); + confHandlers.insert(libjami::exportable_callback( + [&](const std::string& accountId, + const std::string& /* conversationId */, + libjami::SwarmMessage message) { + if (accountId == aliceId) { + aliceData.messages.emplace_back(message); + } else if (accountId == bobId) { + bobData.messages.emplace_back(message); + } else if (accountId == bob2Id) { + bob2Data.messages.emplace_back(message); + } else if (accountId == carlaId) { + carlaData.messages.emplace_back(message); + } + cv.notify_one(); + })); + confHandlers.insert(libjami::exportable_callback( + [&](const std::string& accountId, + const std::string& /* conversationId */, + libjami::SwarmMessage message) { + if (accountId == aliceId) { + aliceData.messagesUpdated.emplace_back(message); + } else if (accountId == bobId) { + bobData.messagesUpdated.emplace_back(message); + } else if (accountId == carlaId) { + carlaData.messagesUpdated.emplace_back(message); + } + cv.notify_one(); + })); + confHandlers.insert( + libjami::exportable_callback( + [&](const std::string& accountId, + const std::string& /* conversationId */, + int /*code*/, + const std::string& /* what */) { + if (accountId == aliceId) + aliceData.errorDetected = true; + else if (accountId == bobId) + bobData.errorDetected = true; + else if (accountId == carlaId) + carlaData.errorDetected = true; + cv.notify_one(); + })); + confHandlers.insert( + libjami::exportable_callback( + [&](const std::string& accountId, const std::string&) { + if (accountId == aliceId) + aliceData.removed = true; + else if (accountId == bobId) + bobData.removed = true; + else if (accountId == bob2Id) + bob2Data.removed = true; + cv.notify_one(); + })); + confHandlers.insert(libjami::exportable_callback( + [&](const std::string& accountId, const std::string&, bool) { + if (accountId == bobId) { + bobData.contactRemoved = true; + } else if (accountId == bob2Id) { + bob2Data.contactRemoved = true; + } + cv.notify_one(); + })); + libjami::registerSignalHandlers(confHandlers); +} + void ConversationMembersEventTest::generateFakeInvite(std::shared_ptr account, const std::string& convId, @@ -221,28 +425,16 @@ ConversationMembersEventTest::generateFakeInvite(std::shared_ptr ac void ConversationMembersEventTest::testRemoveConversationNoMember() { - auto aliceAccount = Manager::instance().getAccount(aliceId); - auto uri = aliceAccount->getUsername(); - - std::map> confHandlers; - bool conversationReady = false; - confHandlers.insert(libjami::exportable_callback( - [&](const std::string& accountId, const std::string& /* conversationId */) { - if (accountId == aliceId) { - conversationReady = true; - cv.notify_one(); - } - })); - libjami::registerSignalHandlers(confHandlers); + connectSignals(); // Start conversation auto convId = libjami::startConversation(aliceId); - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return conversationReady; })); + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return !aliceData.conversationId.empty(); })); // Assert that repository exists - auto repoPath = fileutils::get_data_dir() / aliceAccount->getAccountID() + auto repoPath = fileutils::get_data_dir() / aliceId / "conversations" / convId; - auto dataPath = fileutils::get_data_dir() / aliceAccount->getAccountID() + auto dataPath = fileutils::get_data_dir() / aliceId / "conversation_data" / convId; CPPUNIT_ASSERT(std::filesystem::is_directory(repoPath)); CPPUNIT_ASSERT(std::filesystem::is_directory(dataPath)); @@ -260,73 +452,35 @@ ConversationMembersEventTest::testRemoveConversationNoMember() void ConversationMembersEventTest::testRemoveConversationWithMember() { - auto aliceAccount = Manager::instance().getAccount(aliceId); + connectSignals(); + auto bobAccount = Manager::instance().getAccount(bobId); auto bobUri = bobAccount->getUsername(); auto convId = libjami::startConversation(aliceId); - std::map> confHandlers; - bool conversationReady = false, requestReceived = false, memberMessageGenerated = false, - bobSeeAliceRemoved = false; - confHandlers.insert( - libjami::exportable_callback( - [&](const std::string& /*accountId*/, - const std::string& /* conversationId */, - std::map /*metadatas*/) { - requestReceived = true; - cv.notify_one(); - })); - confHandlers.insert(libjami::exportable_callback( - [&](const std::string& accountId, const std::string& /* conversationId */) { - if (accountId == bobId) { - conversationReady = true; - cv.notify_one(); - } - })); - confHandlers.insert(libjami::exportable_callback( - [&](const std::string& accountId, - const std::string& conversationId, - std::map message) { - auto itFind = message.find("type"); - if (itFind == message.end()) - return; - if (accountId == aliceId && conversationId == convId && itFind->second == "member") { - memberMessageGenerated = true; - cv.notify_one(); - } else if (accountId == bobId && conversationId == convId - && itFind->second == "member") { - bobSeeAliceRemoved = true; - cv.notify_one(); - } - })); - libjami::registerSignalHandlers(confHandlers); - libjami::addConversationMember(aliceId, convId, bobUri); - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return memberMessageGenerated; })); + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return bobData.requestReceived; })); // Assert that repository exists - auto repoPath = fileutils::get_data_dir() / aliceAccount->getAccountID() + auto repoPath = fileutils::get_data_dir() / aliceId / "conversations" / convId; CPPUNIT_ASSERT(std::filesystem::is_directory(repoPath)); // Check created files auto bobInvitedFile = repoPath / "invited" / bobUri; CPPUNIT_ASSERT(std::filesystem::is_regular_file(bobInvitedFile)); - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return requestReceived; })); - memberMessageGenerated = false; + auto aliceMsgSize = aliceData.messages.size(); libjami::acceptConversationRequest(bobId, convId); - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return conversationReady; })); - auto clonedPath = fileutils::get_data_dir() / bobAccount->getAccountID() + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return aliceMsgSize + 1 == aliceData.messages.size(); })); + auto clonedPath = fileutils::get_data_dir() / bobId / "conversations" / convId; - CPPUNIT_ASSERT(std::filesystem::is_directory(clonedPath)); bobInvitedFile = clonedPath / "invited" / bobUri; CPPUNIT_ASSERT(!std::filesystem::is_regular_file(bobInvitedFile)); // Remove conversation from alice once member confirmed - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return memberMessageGenerated; })); - bobSeeAliceRemoved = false; + auto bobMsgSize = bobData.messages.size(); libjami::removeConversation(aliceId, convId); - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return bobSeeAliceRemoved; })); + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return bobMsgSize + 1 == bobData.messages.size() && bobData.messages.rbegin()->type == "member"; })); std::this_thread::sleep_for(3s); CPPUNIT_ASSERT(!std::filesystem::is_directory(repoPath)); } @@ -334,50 +488,24 @@ ConversationMembersEventTest::testRemoveConversationWithMember() void ConversationMembersEventTest::testAddMember() { - auto aliceAccount = Manager::instance().getAccount(aliceId); + connectSignals(); + auto bobAccount = Manager::instance().getAccount(bobId); auto bobUri = bobAccount->getUsername(); auto convId = libjami::startConversation(aliceId); - std::map> confHandlers; - bool conversationReady = false, requestReceived = false, memberMessageGenerated = false; - confHandlers.insert( - libjami::exportable_callback( - [&](const std::string& /*accountId*/, - const std::string& /* conversationId */, - std::map /*metadatas*/) { - requestReceived = true; - cv.notify_one(); - })); - confHandlers.insert(libjami::exportable_callback( - [&](const std::string& accountId, const std::string& /* conversationId */) { - if (accountId == bobId) { - conversationReady = true; - cv.notify_one(); - } - })); - confHandlers.insert(libjami::exportable_callback( - [&](const std::string& accountId, - const std::string& conversationId, - std::map message) { - if (accountId == aliceId && conversationId == convId && message["type"] == "member") { - memberMessageGenerated = true; - cv.notify_one(); - } - })); - libjami::registerSignalHandlers(confHandlers); + libjami::addConversationMember(aliceId, convId, bobUri); - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return memberMessageGenerated; })); + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return bobData.requestReceived; })); // Assert that repository exists - auto repoPath = fileutils::get_data_dir() / aliceAccount->getAccountID() + auto repoPath = fileutils::get_data_dir() / aliceId / "conversations" / convId; CPPUNIT_ASSERT(std::filesystem::is_directory(repoPath)); // Check created files auto bobInvited = repoPath / "invited" / bobUri; CPPUNIT_ASSERT(std::filesystem::is_regular_file(bobInvited)); - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return requestReceived; })); libjami::acceptConversationRequest(bobId, convId); - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return conversationReady; })); - auto clonedPath = fileutils::get_data_dir() / bobAccount->getAccountID() + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return !bobData.conversationId.empty(); })); + auto clonedPath = fileutils::get_data_dir() / bobId / "conversations" / convId; CPPUNIT_ASSERT(std::filesystem::is_directory(clonedPath)); bobInvited = clonedPath / "invited" / bobUri; @@ -389,38 +517,13 @@ ConversationMembersEventTest::testAddMember() void ConversationMembersEventTest::testMemberAddedNoBadFile() { + connectSignals(); + auto aliceAccount = Manager::instance().getAccount(aliceId); auto bobAccount = Manager::instance().getAccount(bobId); auto bobUri = bobAccount->getUsername(); auto convId = libjami::startConversation(aliceId); - std::map> confHandlers; - bool conversationReady = false, requestReceived = false, errorDetected = false; - confHandlers.insert( - libjami::exportable_callback( - [&](const std::string& /*accountId*/, - const std::string& /* conversationId */, - std::map /*metadatas*/) { - requestReceived = true; - cv.notify_one(); - })); - confHandlers.insert(libjami::exportable_callback( - [&](const std::string& accountId, const std::string& /* conversationId */) { - if (accountId == bobId) { - conversationReady = true; - cv.notify_one(); - } - })); - confHandlers.insert( - libjami::exportable_callback( - [&](const std::string& accountId, - const std::string& conversationId, - int code, - const std::string& /* what */) { - if (accountId == bobId && conversationId == convId && code == 3) - errorDetected = true; - cv.notify_one(); - })); - libjami::registerSignalHandlers(confHandlers); + addFile(aliceAccount, convId, "BADFILE"); // NOTE: Add certificate because no DHT lookup aliceAccount->certStore().pinCertificate(bobAccount->identity().second); @@ -430,51 +533,31 @@ ConversationMembersEventTest::testMemberAddedNoBadFile() std::string(bobAccount->currentDeviceId()), {{"application/invite+json", "{\"conversationId\":\"" + convId + "\"}"}}); - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return requestReceived; })); - errorDetected = false; + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return bobData.requestReceived; })); libjami::acceptConversationRequest(bobId, convId); - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return errorDetected; })); - libjami::unregisterSignalHandlers(); + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return bobData.errorDetected; })); } void ConversationMembersEventTest::testAddOfflineMemberThenConnects() { + connectSignals(); + auto aliceAccount = Manager::instance().getAccount(aliceId); auto carlaAccount = Manager::instance().getAccount(carlaId); auto carlaUri = carlaAccount->getUsername(); aliceAccount->trackBuddyPresence(carlaUri, true); auto convId = libjami::startConversation(aliceId); - std::map> confHandlers; - bool conversationReady = false, requestReceived = false; - confHandlers.insert(libjami::exportable_callback( - [&](const std::string& accountId, const std::string& /* conversationId */) { - if (accountId == carlaId) { - conversationReady = true; - cv.notify_one(); - } - })); - confHandlers.insert( - libjami::exportable_callback( - [&](const std::string& /*accountId*/, - const std::string& /* conversationId */, - std::map /*metadatas*/) { - requestReceived = true; - cv.notify_one(); - })); - libjami::registerSignalHandlers(confHandlers); - libjami::addConversationMember(aliceId, convId, carlaUri); Manager::instance().sendRegister(carlaId, true); - CPPUNIT_ASSERT(cv.wait_for(lk, 60s, [&] { return requestReceived; })); + CPPUNIT_ASSERT(cv.wait_for(lk, 60s, [&] { return carlaData.requestReceived; })); libjami::acceptConversationRequest(carlaId, convId); - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return conversationReady; })); - auto clonedPath = fileutils::get_data_dir() / carlaAccount->getAccountID() + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return !carlaData.conversationId.empty(); })); + auto clonedPath = fileutils::get_data_dir() / carlaId / "conversations" / convId; CPPUNIT_ASSERT(std::filesystem::is_directory(clonedPath)); - libjami::unregisterSignalHandlers(); } void @@ -521,48 +604,19 @@ ConversationMembersEventTest::testAddAcceptOfflineThenConnects() void ConversationMembersEventTest::testGetMembers() { + connectSignals(); + auto aliceAccount = Manager::instance().getAccount(aliceId); auto bobAccount = Manager::instance().getAccount(bobId); auto bobUri = bobAccount->getUsername(); - auto aliceUri = aliceAccount->getUsername(); - std::map> confHandlers; - auto messageReceived = false; - bool requestReceived = false; - bool conversationReady = false; - confHandlers.insert(libjami::exportable_callback( - [&](const std::string& accountId, - const std::string& /* conversationId */, - std::map /*message*/) { - if (accountId == aliceId) { - messageReceived = true; - cv.notify_one(); - } - })); - confHandlers.insert( - libjami::exportable_callback( - [&](const std::string& /*accountId*/, - const std::string& /* conversationId */, - std::map /*metadatas*/) { - requestReceived = true; - cv.notify_one(); - })); - confHandlers.insert(libjami::exportable_callback( - [&](const std::string& accountId, const std::string& /* conversationId */) { - if (accountId == bobId) { - conversationReady = true; - cv.notify_one(); - } - })); - libjami::registerSignalHandlers(confHandlers); // Start a conversation and add member auto convId = libjami::startConversation(aliceId); - messageReceived = false; libjami::addConversationMember(aliceId, convId, bobUri); - CPPUNIT_ASSERT(cv.wait_for(lk, 60s, [&]() { return messageReceived; })); + CPPUNIT_ASSERT(cv.wait_for(lk, 60s, [&]() { return bobData.requestReceived; })); // Assert that repository exists - auto repoPath = fileutils::get_data_dir() / aliceAccount->getAccountID() + auto repoPath = fileutils::get_data_dir() / aliceId / "conversations" / convId; CPPUNIT_ASSERT(std::filesystem::is_directory(repoPath)); @@ -573,74 +627,39 @@ ConversationMembersEventTest::testGetMembers() CPPUNIT_ASSERT(members[1]["uri"] == bobUri); CPPUNIT_ASSERT(members[1]["role"] == "invited"); - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return requestReceived; })); - messageReceived = false; + auto aliceMsgSize = aliceData.messages.size(); libjami::acceptConversationRequest(bobId, convId); - cv.wait_for(lk, 30s, [&]() { return conversationReady; }); + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return !bobData.conversationId.empty(); })); members = libjami::getConversationMembers(bobId, convId); CPPUNIT_ASSERT(members.size() == 2); - CPPUNIT_ASSERT(cv.wait_for(lk, 60s, [&]() { return messageReceived; })); + CPPUNIT_ASSERT(cv.wait_for(lk, 60s, [&]() { return aliceMsgSize + 1 == aliceData.messages.size(); })); members = libjami::getConversationMembers(aliceId, convId); CPPUNIT_ASSERT(members.size() == 2); CPPUNIT_ASSERT(members[0]["uri"] == aliceAccount->getUsername()); CPPUNIT_ASSERT(members[0]["role"] == "admin"); CPPUNIT_ASSERT(members[1]["uri"] == bobUri); CPPUNIT_ASSERT(members[1]["role"] == "member"); - libjami::unregisterSignalHandlers(); } void ConversationMembersEventTest::testRemoveMember() { - auto aliceAccount = Manager::instance().getAccount(aliceId); + connectSignals(); + auto bobAccount = Manager::instance().getAccount(bobId); - auto aliceUri = aliceAccount->getUsername(); auto bobUri = bobAccount->getUsername(); auto convId = libjami::startConversation(aliceId); - std::map> confHandlers; - bool conversationReady = false, requestReceived = false, memberMessageGenerated = false, - voteMessageGenerated = false; - confHandlers.insert( - libjami::exportable_callback( - [&](const std::string& /*accountId*/, - const std::string& /* conversationId */, - std::map /*metadatas*/) { - requestReceived = true; - cv.notify_one(); - })); - confHandlers.insert(libjami::exportable_callback( - [&](const std::string& accountId, const std::string& conversationId) { - if (accountId == bobId && conversationId == convId) { - conversationReady = true; - cv.notify_one(); - } - })); - confHandlers.insert(libjami::exportable_callback( - [&](const std::string& accountId, - const std::string& conversationId, - std::map message) { - if (accountId == aliceId && conversationId == convId && message["type"] == "vote") { - voteMessageGenerated = true; - cv.notify_one(); - } else if (accountId == aliceId && conversationId == convId - && message["type"] == "member") { - memberMessageGenerated = true; - cv.notify_one(); - } - })); - libjami::registerSignalHandlers(confHandlers); + libjami::addConversationMember(aliceId, convId, bobUri); - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return requestReceived; })); - memberMessageGenerated = false; + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return bobData.requestReceived; })); + auto aliceMsgSize = aliceData.messages.size(); libjami::acceptConversationRequest(bobId, convId); - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return memberMessageGenerated; })); + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return aliceMsgSize + 1 == aliceData.messages.size(); })); // Now check that alice, has the only admin, can remove bob - memberMessageGenerated = false; - voteMessageGenerated = false; libjami::removeConversationMember(aliceId, convId, bobUri); CPPUNIT_ASSERT( - cv.wait_for(lk, 30s, [&]() { return memberMessageGenerated && voteMessageGenerated; })); + cv.wait_for(lk, 30s, [&]() { return aliceData.messages.size() == aliceMsgSize + 3 /* vote + ban */; })); auto members = libjami::getConversationMembers(aliceId, convId); auto bobBanned = false; for (auto& member : members) { @@ -648,146 +667,65 @@ ConversationMembersEventTest::testRemoveMember() bobBanned = member["role"] == "banned"; } CPPUNIT_ASSERT(bobBanned); - libjami::unregisterSignalHandlers(); } void ConversationMembersEventTest::testRemovedMemberDoesNotReceiveMessage() { - auto aliceAccount = Manager::instance().getAccount(aliceId); + connectSignals(); + auto bobAccount = Manager::instance().getAccount(bobId); - auto aliceUri = aliceAccount->getUsername(); auto bobUri = bobAccount->getUsername(); auto convId = libjami::startConversation(aliceId); - std::map> confHandlers; - bool conversationReady = false, requestReceived = false; - confHandlers.insert( - libjami::exportable_callback( - [&](const std::string& /*accountId*/, - const std::string& /* conversationId */, - std::map /*metadatas*/) { - requestReceived = true; - cv.notify_one(); - })); - confHandlers.insert(libjami::exportable_callback( - [&](const std::string& accountId, const std::string& conversationId) { - if (accountId == bobId && conversationId == convId) { - conversationReady = true; - cv.notify_one(); - } - })); - bool memberMessageGenerated = false, voteMessageGenerated = false, messageBobReceived = false; - confHandlers.insert(libjami::exportable_callback( - [&](const std::string& accountId, - const std::string& conversationId, - std::map message) { - if (accountId == aliceId && conversationId == convId && message["type"] == "vote") - voteMessageGenerated = true; - else if (accountId == aliceId && conversationId == convId && message["type"] == "member") - memberMessageGenerated = true; - else if (accountId == bobId && conversationId == convId) - messageBobReceived = true; - cv.notify_one(); - })); - libjami::registerSignalHandlers(confHandlers); + libjami::addConversationMember(aliceId, convId, bobUri); - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return requestReceived; })); - memberMessageGenerated = false; + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return bobData.requestReceived; })); + auto aliceMsgSize = aliceData.messages.size(); libjami::acceptConversationRequest(bobId, convId); - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return memberMessageGenerated; })); + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return aliceMsgSize + 1 == aliceData.messages.size(); })); // Now check that alice, has the only admin, can remove bob - memberMessageGenerated = false; - voteMessageGenerated = false; libjami::removeConversationMember(aliceId, convId, bobUri); CPPUNIT_ASSERT( - cv.wait_for(lk, 30s, [&]() { return memberMessageGenerated && voteMessageGenerated; })); + cv.wait_for(lk, 30s, [&]() { return aliceData.messages.size() == aliceMsgSize + 3 /* vote + ban */; })); // Now, bob is banned so they shoud not receive any message - messageBobReceived = false; + auto bobMsgSize = bobData.messages.size(); libjami::sendMessage(aliceId, convId, "hi"s, ""); - CPPUNIT_ASSERT(!cv.wait_for(lk, 10s, [&]() { return messageBobReceived; })); - libjami::unregisterSignalHandlers(); + CPPUNIT_ASSERT(!cv.wait_for(lk, 10s, [&]() { return bobMsgSize + 1 == bobData.messages.size(); })); } void ConversationMembersEventTest::testRemoveInvitedMember() { - auto aliceAccount = Manager::instance().getAccount(aliceId); + connectSignals(); + auto bobAccount = Manager::instance().getAccount(bobId); auto carlaAccount = Manager::instance().getAccount(carlaId); - auto aliceUri = aliceAccount->getUsername(); auto bobUri = bobAccount->getUsername(); auto carlaUri = carlaAccount->getUsername(); auto convId = libjami::startConversation(aliceId); - std::map> confHandlers; - bool conversationReady = false, requestReceived = false; - confHandlers.insert( - libjami::exportable_callback( - [&](const std::string& /*accountId*/, - const std::string& /* conversationId */, - std::map /*metadatas*/) { - requestReceived = true; - cv.notify_one(); - })); - bool carlaConnected = false; - confHandlers.insert( - libjami::exportable_callback( - [&](const std::string&, const std::map&) { - auto details = carlaAccount->getVolatileAccountDetails(); - auto deviceAnnounced - = details[libjami::Account::VolatileProperties::DEVICE_ANNOUNCED]; - if (deviceAnnounced == "true") { - carlaConnected = true; - cv.notify_one(); - } - })); - confHandlers.insert(libjami::exportable_callback( - [&](const std::string& accountId, const std::string& conversationId) { - if (accountId == bobId && conversationId == convId) { - conversationReady = true; - cv.notify_one(); - } - })); - bool voteMessageGenerated = false, memberMessageGenerated = false, carlaMessageReceived; - confHandlers.insert(libjami::exportable_callback( - [&](const std::string& accountId, - const std::string& conversationId, - std::map message) { - if (accountId == aliceId && conversationId == convId && message["type"] == "vote") - voteMessageGenerated = true; - else if (accountId == aliceId && conversationId == convId && message["type"] == "member") - memberMessageGenerated = true; - else if (accountId == carlaId && message["type"] == "text/plain" - && message["body"] == "hi") - carlaMessageReceived = true; - cv.notify_one(); - })); - libjami::registerSignalHandlers(confHandlers); - // Add carla Manager::instance().sendRegister(carlaId, true); - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return carlaConnected; })); + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return carlaData.deviceAnnounced; })); libjami::addConversationMember(aliceId, convId, carlaUri); - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return requestReceived; })); - memberMessageGenerated = false; + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return carlaData.requestReceived; })); + auto aliceMsgSize = aliceData.messages.size(); libjami::acceptConversationRequest(carlaId, convId); - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return memberMessageGenerated; })); + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return aliceMsgSize + 1 == aliceData.messages.size(); })); // Invite Alice - requestReceived = false; libjami::addConversationMember(aliceId, convId, bobUri); - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return requestReceived; })); + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return bobData.requestReceived; })); auto members = libjami::getConversationMembers(aliceId, convId); CPPUNIT_ASSERT(members.size() == 3); // Now check that alice, has the only admin, can remove bob - memberMessageGenerated = false; - voteMessageGenerated = false; + aliceMsgSize = aliceData.messages.size(); libjami::removeConversationMember(aliceId, convId, bobUri); CPPUNIT_ASSERT( - cv.wait_for(lk, 30s, [&]() { return memberMessageGenerated && voteMessageGenerated; })); + cv.wait_for(lk, 30s, [&]() { return aliceMsgSize + 2 == aliceData.messages.size(); })); members = libjami::getConversationMembers(aliceId, convId); auto bobBanned = false; for (auto& member : members) { @@ -797,14 +735,16 @@ ConversationMembersEventTest::testRemoveInvitedMember() CPPUNIT_ASSERT(bobBanned); // Check that Carla is still able to sync + auto carlaMsgSize = carlaData.messages.size(); libjami::sendMessage(aliceId, convId, "hi"s, ""); - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return carlaMessageReceived; })); - libjami::unregisterSignalHandlers(); + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return carlaMsgSize + 1 == carlaData.messages.size(); })); } void ConversationMembersEventTest::testMemberBanNoBadFile() { + connectSignals(); + auto aliceAccount = Manager::instance().getAccount(aliceId); auto bobAccount = Manager::instance().getAccount(bobId); auto aliceUri = aliceAccount->getUsername(); @@ -814,190 +754,69 @@ ConversationMembersEventTest::testMemberBanNoBadFile() auto carlaUri = carlaAccount->getUsername(); aliceAccount->trackBuddyPresence(carlaUri, true); - std::map> confHandlers; - bool conversationReady = false, requestReceived = false, memberMessageGenerated = false, - voteMessageGenerated = false, messageBobReceived = false, errorDetected = false, - carlaConnected = false; - confHandlers.insert( - libjami::exportable_callback( - [&](const std::string& /*accountId*/, - const std::string& /* conversationId */, - std::map /*metadatas*/) { - requestReceived = true; - cv.notify_one(); - })); - confHandlers.insert( - libjami::exportable_callback( - [&](const std::string&, const std::map&) { - auto details = carlaAccount->getVolatileAccountDetails(); - auto deviceAnnounced - = details[libjami::Account::VolatileProperties::DEVICE_ANNOUNCED]; - if (deviceAnnounced == "true") { - carlaConnected = true; - cv.notify_one(); - } - })); - confHandlers.insert(libjami::exportable_callback( - [&](const std::string& accountId, const std::string& conversationId) { - if (accountId == bobId && conversationId == convId) { - conversationReady = true; - cv.notify_one(); - } - })); - confHandlers.insert(libjami::exportable_callback( - [&](const std::string& accountId, - const std::string& conversationId, - std::map message) { - if (accountId == aliceId && conversationId == convId && message["type"] == "vote") { - voteMessageGenerated = true; - } else if (accountId == aliceId && conversationId == convId - && message["type"] == "member") { - memberMessageGenerated = true; - } else if (accountId == bobId && conversationId == convId) { - messageBobReceived = true; - } - cv.notify_one(); - })); - confHandlers.insert( - libjami::exportable_callback( - [&](const std::string& accountId, - const std::string& conversationId, - int code, - const std::string& /* what */) { - if (accountId == bobId && conversationId == convId && code == 3) - errorDetected = true; - cv.notify_one(); - })); - libjami::registerSignalHandlers(confHandlers); Manager::instance().sendRegister(carlaId, true); - CPPUNIT_ASSERT(cv.wait_for(lk, 60s, [&] { return carlaConnected; })); + CPPUNIT_ASSERT(cv.wait_for(lk, 60s, [&] { return carlaData.deviceAnnounced; })); libjami::addConversationMember(aliceId, convId, bobUri); CPPUNIT_ASSERT( - cv.wait_for(lk, 30s, [&]() { return requestReceived && memberMessageGenerated; })); - memberMessageGenerated = false; + cv.wait_for(lk, 30s, [&]() { return bobData.requestReceived; })); + auto aliceMsgSize = aliceData.messages.size(); libjami::acceptConversationRequest(bobId, convId); - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return memberMessageGenerated; })); - requestReceived = false; + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return aliceMsgSize + 1 == aliceData.messages.size(); })); libjami::addConversationMember(aliceId, convId, carlaUri); CPPUNIT_ASSERT( - cv.wait_for(lk, 30s, [&]() { return requestReceived && memberMessageGenerated; })); - memberMessageGenerated = false; - messageBobReceived = false; + cv.wait_for(lk, 30s, [&]() { return carlaData.requestReceived; })); + aliceMsgSize = aliceData.messages.size(); + auto bobMsgSize = bobData.messages.size(); libjami::acceptConversationRequest(carlaId, convId); - CPPUNIT_ASSERT( - cv.wait_for(lk, 30s, [&]() { return memberMessageGenerated && messageBobReceived; })); + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return aliceMsgSize + 1 == aliceData.messages.size() && bobMsgSize + 1 == bobData.messages.size(); })); - memberMessageGenerated = false; - voteMessageGenerated = false; addFile(aliceAccount, convId, "BADFILE"); libjami::removeConversationMember(aliceId, convId, carlaUri); - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return errorDetected; })); - libjami::unregisterSignalHandlers(); + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return bobData.errorDetected; })); } void ConversationMembersEventTest::testMemberTryToRemoveAdmin() { + connectSignals(); + auto aliceAccount = Manager::instance().getAccount(aliceId); auto bobAccount = Manager::instance().getAccount(bobId); auto aliceUri = aliceAccount->getUsername(); auto bobUri = bobAccount->getUsername(); auto convId = libjami::startConversation(aliceId); - std::map> confHandlers; - bool conversationReady = false, requestReceived = false, memberMessageGenerated = false; - confHandlers.insert( - libjami::exportable_callback( - [&](const std::string& /*accountId*/, - const std::string& /* conversationId */, - std::map /*metadatas*/) { - requestReceived = true; - cv.notify_one(); - })); - confHandlers.insert(libjami::exportable_callback( - [&](const std::string& accountId, const std::string& conversationId) { - if (accountId == bobId && conversationId == convId) { - conversationReady = true; - cv.notify_one(); - } - })); - confHandlers.insert(libjami::exportable_callback( - [&](const std::string& accountId, - const std::string& conversationId, - std::map message) { - if (accountId == aliceId && conversationId == convId && message["type"] == "member") - memberMessageGenerated = true; - cv.notify_one(); - })); - libjami::registerSignalHandlers(confHandlers); libjami::addConversationMember(aliceId, convId, bobUri); CPPUNIT_ASSERT( - cv.wait_for(lk, 30s, [&]() { return requestReceived && memberMessageGenerated; })); - memberMessageGenerated = false; + cv.wait_for(lk, 30s, [&]() { return bobData.requestReceived; })); + auto aliceMsgSize = aliceData.messages.size(); libjami::acceptConversationRequest(bobId, convId); - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return memberMessageGenerated; })); + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return aliceMsgSize + 1 == aliceData.messages.size(); })); // Now check that alice, has the only admin, can remove bob - memberMessageGenerated = false; libjami::removeConversationMember(bobId, convId, aliceUri); auto members = libjami::getConversationMembers(aliceId, convId); - CPPUNIT_ASSERT(members.size() == 2 && !memberMessageGenerated); - libjami::unregisterSignalHandlers(); + CPPUNIT_ASSERT(members.size() == 2 && aliceMsgSize + 2 != aliceData.messages.size()); } void ConversationMembersEventTest::testBannedMemberCannotSendMessage() { - auto aliceAccount = Manager::instance().getAccount(aliceId); + connectSignals(); + auto bobAccount = Manager::instance().getAccount(bobId); - auto aliceUri = aliceAccount->getUsername(); auto bobUri = bobAccount->getUsername(); auto convId = libjami::startConversation(aliceId); - std::map> confHandlers; - bool conversationReady = false, requestReceived = false, memberMessageGenerated = false, - voteMessageGenerated = false, aliceMessageReceived = false; - confHandlers.insert( - libjami::exportable_callback( - [&](const std::string& /*accountId*/, - const std::string& /* conversationId */, - std::map /*metadatas*/) { - requestReceived = true; - cv.notify_one(); - })); - confHandlers.insert(libjami::exportable_callback( - [&](const std::string& accountId, const std::string& conversationId) { - if (accountId == bobId && conversationId == convId) { - conversationReady = true; - cv.notify_one(); - } - })); - confHandlers.insert(libjami::exportable_callback( - [&](const std::string& accountId, - const std::string& conversationId, - std::map message) { - if (accountId == aliceId && conversationId == convId && message["type"] == "vote") { - voteMessageGenerated = true; - } else if (accountId == aliceId && conversationId == convId - && message["type"] == "member") { - memberMessageGenerated = true; - } else if (accountId == aliceId && conversationId == convId - && message["type"] == "text/plain") { - aliceMessageReceived = true; - } - cv.notify_one(); - })); - libjami::registerSignalHandlers(confHandlers); + libjami::addConversationMember(aliceId, convId, bobUri); CPPUNIT_ASSERT( - cv.wait_for(lk, 30s, [&]() { return requestReceived && memberMessageGenerated; })); - memberMessageGenerated = false; + cv.wait_for(lk, 30s, [&]() { return bobData.requestReceived; })); + auto aliceMsgSize = aliceData.messages.size(); libjami::acceptConversationRequest(bobId, convId); - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return memberMessageGenerated; })); + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return aliceMsgSize + 1 == aliceData.messages.size(); })); - memberMessageGenerated = false; - voteMessageGenerated = false; libjami::removeConversationMember(aliceId, convId, bobUri); CPPUNIT_ASSERT( - cv.wait_for(lk, 30s, [&]() { return memberMessageGenerated && voteMessageGenerated; })); + cv.wait_for(lk, 30s, [&]() { return aliceMsgSize + 3 == aliceData.messages.size(); })); auto members = libjami::getConversationMembers(aliceId, convId); auto bobBanned = false; @@ -1008,65 +827,33 @@ ConversationMembersEventTest::testBannedMemberCannotSendMessage() CPPUNIT_ASSERT(bobBanned); // Now check that alice doesn't receive a message from Bob - aliceMessageReceived = false; libjami::sendMessage(bobId, convId, "hi"s, ""); - CPPUNIT_ASSERT(!cv.wait_for(lk, 30s, [&]() { return aliceMessageReceived; })); + CPPUNIT_ASSERT(!cv.wait_for(lk, 30s, [&]() { return aliceMsgSize + 4 == aliceData.messages.size(); })); libjami::unregisterSignalHandlers(); } void ConversationMembersEventTest::testAdminCanReAddMember() { + connectSignals(); + auto aliceAccount = Manager::instance().getAccount(aliceId); auto bobAccount = Manager::instance().getAccount(bobId); auto aliceUri = aliceAccount->getUsername(); auto bobUri = bobAccount->getUsername(); auto convId = libjami::startConversation(aliceId); - std::map> confHandlers; - bool conversationReady = false, requestReceived = false, memberMessageGenerated = false, - voteMessageGenerated = false; - confHandlers.insert( - libjami::exportable_callback( - [&](const std::string& /*accountId*/, - const std::string& /* conversationId */, - std::map /*metadatas*/) { - requestReceived = true; - cv.notify_one(); - })); - confHandlers.insert(libjami::exportable_callback( - [&](const std::string& accountId, const std::string& conversationId) { - if (accountId == bobId && conversationId == convId) { - conversationReady = true; - cv.notify_one(); - } - })); - confHandlers.insert(libjami::exportable_callback( - [&](const std::string& accountId, - const std::string& conversationId, - std::map message) { - if (accountId == aliceId && conversationId == convId && message["type"] == "vote") { - voteMessageGenerated = true; - cv.notify_one(); - } else if (accountId == aliceId && conversationId == convId - && message["type"] == "member") { - memberMessageGenerated = true; - cv.notify_one(); - } - })); - libjami::registerSignalHandlers(confHandlers); + libjami::addConversationMember(aliceId, convId, bobUri); CPPUNIT_ASSERT( - cv.wait_for(lk, 30s, [&]() { return requestReceived && memberMessageGenerated; })); - memberMessageGenerated = false; + cv.wait_for(lk, 30s, [&]() { return bobData.requestReceived; })); + auto aliceMsgSize = aliceData.messages.size(); libjami::acceptConversationRequest(bobId, convId); - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return memberMessageGenerated; })); + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return aliceMsgSize + 1 == aliceData.messages.size(); })); // Now check that alice, has the only admin, can remove bob - memberMessageGenerated = false; - voteMessageGenerated = false; libjami::removeConversationMember(aliceId, convId, bobUri); CPPUNIT_ASSERT( - cv.wait_for(lk, 30s, [&]() { return memberMessageGenerated && voteMessageGenerated; })); + cv.wait_for(lk, 30s, [&]() { return aliceMsgSize + 3 == aliceData.messages.size(); })); auto members = libjami::getConversationMembers(aliceId, convId); @@ -1078,211 +865,96 @@ ConversationMembersEventTest::testAdminCanReAddMember() CPPUNIT_ASSERT(bobBanned); // Then check that bobUri can be re-added - memberMessageGenerated = false, voteMessageGenerated = false; + aliceMsgSize = aliceData.messages.size(); libjami::addConversationMember(aliceId, convId, bobUri); CPPUNIT_ASSERT( - cv.wait_for(lk, 30s, [&]() { return memberMessageGenerated && voteMessageGenerated; })); + cv.wait_for(lk, 30s, [&]() { return aliceMsgSize + 2 == aliceData.messages.size(); })); members = libjami::getConversationMembers(aliceId, convId); CPPUNIT_ASSERT(members.size() == 2); - libjami::unregisterSignalHandlers(); } void ConversationMembersEventTest::testMemberCannotBanOther() { + connectSignals(); + auto aliceAccount = Manager::instance().getAccount(aliceId); auto bobAccount = Manager::instance().getAccount(bobId); - auto aliceUri = aliceAccount->getUsername(); auto bobUri = bobAccount->getUsername(); auto convId = libjami::startConversation(aliceId); auto carlaAccount = Manager::instance().getAccount(carlaId); auto carlaUri = carlaAccount->getUsername(); aliceAccount->trackBuddyPresence(carlaUri, true); - std::map> confHandlers; - bool conversationReady = false, requestReceived = false, memberMessageGenerated = false, - voteMessageGenerated = false, messageBobReceived = false, errorDetected = false, - carlaConnected = false; - confHandlers.insert( - libjami::exportable_callback( - [&](const std::string&, const std::string&, std::map) { - requestReceived = true; - cv.notify_one(); - })); - confHandlers.insert( - libjami::exportable_callback( - [&](const std::string&, const std::map&) { - auto details = carlaAccount->getVolatileAccountDetails(); - auto deviceAnnounced - = details[libjami::Account::VolatileProperties::DEVICE_ANNOUNCED]; - if (deviceAnnounced == "true") { - carlaConnected = true; - cv.notify_one(); - } - })); - confHandlers.insert(libjami::exportable_callback( - [&](const std::string& accountId, const std::string& conversationId) { - if (accountId == bobId && conversationId == convId) { - conversationReady = true; - cv.notify_one(); - } - })); - confHandlers.insert(libjami::exportable_callback( - [&](const std::string& accountId, - const std::string& conversationId, - std::map message) { - if (accountId == aliceId && conversationId == convId && message["type"] == "vote") { - voteMessageGenerated = true; - } else if (accountId == aliceId && conversationId == convId - && message["type"] == "member") { - memberMessageGenerated = true; - } else if (accountId == bobId && conversationId == convId) { - messageBobReceived = true; - } - cv.notify_one(); - })); - confHandlers.insert( - libjami::exportable_callback( - [&](const std::string& /* accountId */, - const std::string& /* conversationId */, - int code, - const std::string& /* what */) { - if (code == 3) - errorDetected = true; - cv.notify_one(); - })); - libjami::registerSignalHandlers(confHandlers); Manager::instance().sendRegister(carlaId, true); - CPPUNIT_ASSERT(cv.wait_for(lk, 60s, [&] { return carlaConnected; })); + CPPUNIT_ASSERT(cv.wait_for(lk, 60s, [&] { return carlaData.deviceAnnounced; })); libjami::addConversationMember(aliceId, convId, bobUri); CPPUNIT_ASSERT( - cv.wait_for(lk, 30s, [&]() { return requestReceived && memberMessageGenerated; })); - memberMessageGenerated = false; + cv.wait_for(lk, 30s, [&]() { return bobData.requestReceived; })); + auto aliceMsgSize = aliceData.messages.size(); libjami::acceptConversationRequest(bobId, convId); - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return memberMessageGenerated; })); - requestReceived = false; - memberMessageGenerated = false; + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return aliceMsgSize + 1 == aliceData.messages.size(); })); libjami::addConversationMember(aliceId, convId, carlaUri); CPPUNIT_ASSERT( - cv.wait_for(lk, 30s, [&]() { return requestReceived && memberMessageGenerated; })); - memberMessageGenerated = false; - messageBobReceived = false; + cv.wait_for(lk, 30s, [&]() { return carlaData.requestReceived; })); + aliceMsgSize = aliceData.messages.size(); + auto bobMsgSize = bobData.messages.size(); libjami::acceptConversationRequest(carlaId, convId); CPPUNIT_ASSERT( - cv.wait_for(lk, 30s, [&]() { return memberMessageGenerated && messageBobReceived; })); + cv.wait_for(lk, 30s, [&]() { return aliceMsgSize + 1 == aliceData.messages.size() && bobMsgSize + 1 == bobData.messages.size(); })); // Now Carla remove Bob as a member - errorDetected = false; - messageBobReceived = false; // remove from member & add into banned without voting for the ban simulateRemoval(carlaAccount, convId, bobUri); - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return errorDetected; })); + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return aliceData.errorDetected; })); + bobMsgSize = bobData.messages.size(); libjami::sendMessage(aliceId, convId, "hi"s, ""); - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return messageBobReceived; })); + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return bobMsgSize + 1 == bobData.messages.size(); })); } void ConversationMembersEventTest::testMemberCannotUnBanOther() { + connectSignals(); + auto aliceAccount = Manager::instance().getAccount(aliceId); auto bobAccount = Manager::instance().getAccount(bobId); - auto aliceUri = aliceAccount->getUsername(); auto bobUri = bobAccount->getUsername(); auto convId = libjami::startConversation(aliceId); auto carlaAccount = Manager::instance().getAccount(carlaId); auto carlaUri = carlaAccount->getUsername(); aliceAccount->trackBuddyPresence(carlaUri, true); - std::map> confHandlers; - bool conversationReady = false, requestReceived = false, memberMessageGenerated = false, - voteMessageGenerated = false, messageBobReceived = false, errorDetected = false, - carlaConnected = false, messageCarlaReceived = false; - confHandlers.insert( - libjami::exportable_callback( - [&](const std::string&, const std::string&, std::map) { - requestReceived = true; - cv.notify_one(); - })); - confHandlers.insert( - libjami::exportable_callback( - [&](const std::string&, const std::map&) { - auto details = carlaAccount->getVolatileAccountDetails(); - auto deviceAnnounced - = details[libjami::Account::VolatileProperties::DEVICE_ANNOUNCED]; - if (deviceAnnounced == "true") { - carlaConnected = true; - cv.notify_one(); - } - })); - confHandlers.insert(libjami::exportable_callback( - [&](const std::string& accountId, const std::string& conversationId) { - if (accountId == bobId && conversationId == convId) { - conversationReady = true; - cv.notify_one(); - } - })); - confHandlers.insert(libjami::exportable_callback( - [&](const std::string& accountId, - const std::string& conversationId, - std::map message) { - if (accountId == aliceId && conversationId == convId && message["type"] == "vote") { - voteMessageGenerated = true; - } else if (accountId == aliceId && conversationId == convId - && message["type"] == "member") { - memberMessageGenerated = true; - } else if (accountId == bobId && conversationId == convId) { - messageBobReceived = true; - } else if (accountId == carlaId && conversationId == convId) { - messageCarlaReceived = true; - } - cv.notify_one(); - })); - confHandlers.insert( - libjami::exportable_callback( - [&](const std::string& /* accountId */, - const std::string& /* conversationId */, - int code, - const std::string& /* what */) { - if (code == 3) - errorDetected = true; - cv.notify_one(); - })); - libjami::registerSignalHandlers(confHandlers); Manager::instance().sendRegister(carlaId, true); - CPPUNIT_ASSERT(cv.wait_for(lk, 60s, [&] { return carlaConnected; })); + CPPUNIT_ASSERT(cv.wait_for(lk, 60s, [&] { return carlaData.deviceAnnounced; })); libjami::addConversationMember(aliceId, convId, bobUri); CPPUNIT_ASSERT( - cv.wait_for(lk, 30s, [&]() { return requestReceived && memberMessageGenerated; })); - memberMessageGenerated = false; + cv.wait_for(lk, 30s, [&]() { return bobData.requestReceived; })); + auto aliceMsgSize = aliceData.messages.size(); libjami::acceptConversationRequest(bobId, convId); - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return memberMessageGenerated; })); - requestReceived = false; - memberMessageGenerated = false; + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return aliceMsgSize + 1 == aliceData.messages.size(); })); libjami::addConversationMember(aliceId, convId, carlaUri); CPPUNIT_ASSERT( - cv.wait_for(lk, 30s, [&]() { return requestReceived && memberMessageGenerated; })); - memberMessageGenerated = false; - messageBobReceived = false; + cv.wait_for(lk, 30s, [&]() { return carlaData.requestReceived; })); + aliceMsgSize = aliceData.messages.size(); + auto bobMsgSize = bobData.messages.size(); libjami::acceptConversationRequest(carlaId, convId); CPPUNIT_ASSERT( - cv.wait_for(lk, 30s, [&]() { return memberMessageGenerated && messageBobReceived; })); + cv.wait_for(lk, 30s, [&]() { return aliceMsgSize + 1 == aliceData.messages.size() && bobMsgSize + 1 == bobData.messages.size(); })); // Now check that alice, has the only admin, can remove bob - memberMessageGenerated = false; - messageCarlaReceived = false; - voteMessageGenerated = false; + auto carlaMsgSize = carlaData.messages.size(); libjami::removeConversationMember(aliceId, convId, bobUri); CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { - return memberMessageGenerated && voteMessageGenerated && messageCarlaReceived; + return carlaMsgSize + 2 == carlaData.messages.size();; })); - memberMessageGenerated = false; - voteMessageGenerated = false; + aliceMsgSize = aliceData.messages.size(); libjami::addConversationMember(carlaId, convId, bobUri); CPPUNIT_ASSERT( - !cv.wait_for(lk, 30s, [&]() { return memberMessageGenerated && voteMessageGenerated; })); + !cv.wait_for(lk, 30s, [&]() { return aliceMsgSize + 2 == aliceData.messages.size();; })); auto members = libjami::getConversationMembers(aliceId, convId); auto bobBanned = false; for (auto& member : members) { @@ -1295,134 +967,46 @@ ConversationMembersEventTest::testMemberCannotUnBanOther() void ConversationMembersEventTest::testCheckAdminFakeAVoteIsDetected() { + connectSignals(); + auto aliceAccount = Manager::instance().getAccount(aliceId); auto bobAccount = Manager::instance().getAccount(bobId); - auto aliceUri = aliceAccount->getUsername(); auto bobUri = bobAccount->getUsername(); auto convId = libjami::startConversation(aliceId); auto carlaAccount = Manager::instance().getAccount(carlaId); auto carlaUri = carlaAccount->getUsername(); aliceAccount->trackBuddyPresence(carlaUri, true); - std::map> confHandlers; - bool conversationReady = false, requestReceived = false, memberMessageGenerated = false, - voteMessageGenerated = false, messageBobReceived = false, errorDetected = false, - carlaConnected = false; - confHandlers.insert( - libjami::exportable_callback( - [&](const std::string& /*accountId*/, - const std::string& /* conversationId */, - std::map /*metadatas*/) { - requestReceived = true; - cv.notify_one(); - })); - confHandlers.insert(libjami::exportable_callback( - [&](const std::string& accountId, const std::string& conversationId) { - if (accountId == bobId && conversationId == convId) { - conversationReady = true; - cv.notify_one(); - } - })); - confHandlers.insert(libjami::exportable_callback( - [&](const std::string& accountId, - const std::string& conversationId, - std::map message) { - if (accountId == aliceId && conversationId == convId && message["type"] == "vote") { - voteMessageGenerated = true; - } else if (accountId == aliceId && conversationId == convId - && message["type"] == "member") { - memberMessageGenerated = true; - } else if (accountId == bobId && conversationId == convId) { - messageBobReceived = true; - } - cv.notify_one(); - })); - confHandlers.insert( - libjami::exportable_callback( - [&](const std::string&, const std::map&) { - auto details = carlaAccount->getVolatileAccountDetails(); - auto deviceAnnounced - = details[libjami::Account::VolatileProperties::DEVICE_ANNOUNCED]; - if (deviceAnnounced == "true") { - carlaConnected = true; - cv.notify_one(); - } - })); - confHandlers.insert( - libjami::exportable_callback( - [&](const std::string& /* accountId */, - const std::string& /* conversationId */, - int code, - const std::string& /* what */) { - if (code == 3) - errorDetected = true; - cv.notify_one(); - })); - libjami::registerSignalHandlers(confHandlers); Manager::instance().sendRegister(carlaId, true); - CPPUNIT_ASSERT(cv.wait_for(lk, 60s, [&] { return carlaConnected; })); + CPPUNIT_ASSERT(cv.wait_for(lk, 60s, [&] { return carlaData.deviceAnnounced; })); libjami::addConversationMember(aliceId, convId, bobUri); CPPUNIT_ASSERT( - cv.wait_for(lk, 30s, [&]() { return requestReceived && memberMessageGenerated; })); - memberMessageGenerated = false; + cv.wait_for(lk, 30s, [&]() { return bobData.requestReceived; })); + auto aliceMsgSize = aliceData.messages.size(); libjami::acceptConversationRequest(bobId, convId); - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return memberMessageGenerated; })); - requestReceived = false; + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return aliceMsgSize + 1 == aliceData.messages.size(); })); libjami::addConversationMember(aliceId, convId, carlaUri); CPPUNIT_ASSERT( - cv.wait_for(lk, 30s, [&]() { return requestReceived && memberMessageGenerated; })); - memberMessageGenerated = false; - messageBobReceived = false; + cv.wait_for(lk, 30s, [&]() { return carlaData.requestReceived; })); + aliceMsgSize = aliceData.messages.size(); + auto bobMsgSize = bobData.messages.size(); libjami::acceptConversationRequest(carlaId, convId); CPPUNIT_ASSERT( - cv.wait_for(lk, 30s, [&]() { return memberMessageGenerated && messageBobReceived; })); + cv.wait_for(lk, 30s, [&]() { return aliceMsgSize + 1 == aliceData.messages.size() && bobMsgSize + 1 == bobData.messages.size(); })); // Now Alice remove Carla without a vote. Bob will not receive the message - errorDetected = false; simulateRemoval(aliceAccount, convId, carlaUri); - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return errorDetected; })); + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return bobData.errorDetected; })); } void ConversationMembersEventTest::testAdminCannotKickTheirself() { + connectSignals(); + auto aliceAccount = Manager::instance().getAccount(aliceId); auto aliceUri = aliceAccount->getUsername(); auto convId = libjami::startConversation(aliceId); - std::map> confHandlers; - bool conversationReady = false, requestReceived = false, memberMessageGenerated = false, - voteMessageGenerated = false, aliceMessageReceived = false; - confHandlers.insert( - libjami::exportable_callback( - [&](const std::string& /*accountId*/, - const std::string& /* conversationId */, - std::map /*metadatas*/) { - requestReceived = true; - cv.notify_one(); - })); - confHandlers.insert(libjami::exportable_callback( - [&](const std::string& accountId, const std::string& conversationId) { - if (accountId == bobId && conversationId == convId) { - conversationReady = true; - cv.notify_one(); - } - })); - confHandlers.insert(libjami::exportable_callback( - [&](const std::string& accountId, - const std::string& conversationId, - std::map message) { - if (accountId == aliceId && conversationId == convId && message["type"] == "vote") { - voteMessageGenerated = true; - } else if (accountId == aliceId && conversationId == convId - && message["type"] == "member") { - memberMessageGenerated = true; - } else if (accountId == aliceId && conversationId == convId - && message["type"] == "text/plain") { - aliceMessageReceived = true; - } - cv.notify_one(); - })); - libjami::registerSignalHandlers(confHandlers); auto members = libjami::getConversationMembers(aliceId, convId); CPPUNIT_ASSERT(members.size() == 1); libjami::removeConversationMember(aliceId, convId, aliceUri); @@ -1433,68 +1017,26 @@ ConversationMembersEventTest::testAdminCannotKickTheirself() void ConversationMembersEventTest::testCommitUnauthorizedUser() { + connectSignals(); + auto aliceAccount = Manager::instance().getAccount(aliceId); auto bobAccount = Manager::instance().getAccount(bobId); auto carlaAccount = Manager::instance().getAccount(carlaId); auto bobUri = bobAccount->getUsername(); - std::map> confHandlers; - auto messageBobReceived = 0, messageAliceReceived = 0; - bool requestReceived = false; - bool conversationReady = false; - bool errorDetected = false; - confHandlers.insert(libjami::exportable_callback( - [&](const std::string& accountId, - const std::string& /* conversationId */, - std::map /*message*/) { - if (accountId == bobId) { - messageBobReceived += 1; - } else { - messageAliceReceived += 1; - } - cv.notify_one(); - })); - confHandlers.insert( - libjami::exportable_callback( - [&](const std::string& /*accountId*/, - const std::string& /* conversationId */, - std::map /*metadatas*/) { - requestReceived = true; - cv.notify_one(); - })); - confHandlers.insert(libjami::exportable_callback( - [&](const std::string& accountId, const std::string& /* conversationId */) { - if (accountId == bobId) { - conversationReady = true; - cv.notify_one(); - } - })); - confHandlers.insert( - libjami::exportable_callback( - [&](const std::string& /* accountId */, - const std::string& /* conversationId */, - int code, - const std::string& /* what */) { - if (code == 3) - errorDetected = true; - cv.notify_one(); - })); - libjami::registerSignalHandlers(confHandlers); - auto convId = libjami::startConversation(aliceId); libjami::addConversationMember(aliceId, convId, bobUri); - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return requestReceived; })); + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return bobData.requestReceived; })); + auto aliceMsgSize = aliceData.messages.size(); libjami::acceptConversationRequest(bobId, convId); - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return conversationReady; })); + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return aliceMsgSize + 1 == aliceData.messages.size();; })); // Assert that repository exists - auto repoPath = fileutils::get_data_dir() / bobAccount->getAccountID() + auto repoPath = fileutils::get_data_dir() / bobId / "conversations" / convId; CPPUNIT_ASSERT(std::filesystem::is_directory(repoPath)); - // Wait that alice sees Bob - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return messageAliceReceived == 2; })); // Add commit from invalid user Json::Value root; @@ -1506,73 +1048,33 @@ ConversationMembersEventTest::testCommitUnauthorizedUser() auto message = Json::writeString(wbuilder, root); commitInRepo(repoPath, carlaAccount, message); - errorDetected = false; libjami::sendMessage(bobId, convId, "hi"s, ""); - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return errorDetected; })); + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return aliceData.errorDetected; })); libjami::unregisterSignalHandlers(); } void ConversationMembersEventTest::testMemberJoinsNoBadFile() { + connectSignals(); + auto aliceAccount = Manager::instance().getAccount(aliceId); auto carlaAccount = Manager::instance().getAccount(carlaId); auto carlaUri = carlaAccount->getUsername(); aliceAccount->trackBuddyPresence(carlaUri, true); auto convId = libjami::startConversation(aliceId); - std::map> confHandlers; - bool conversationReady = false, errorDetected = false, carlaConnected = false, - memberMessageGenerated = false; - confHandlers.insert(libjami::exportable_callback( - [&](const std::string& accountId, const std::string& /* conversationId */) { - if (accountId == carlaId) { - conversationReady = true; - cv.notify_one(); - } - })); - confHandlers.insert(libjami::exportable_callback( - [&](const std::string& accountId, - const std::string& conversationId, - std::map message) { - if (accountId == aliceId && conversationId == convId && message["type"] == "member") { - memberMessageGenerated = true; - cv.notify_one(); - } - })); - confHandlers.insert( - libjami::exportable_callback( - [&](const std::string&, const std::map&) { - auto details = carlaAccount->getVolatileAccountDetails(); - auto deviceAnnounced - = details[libjami::Account::VolatileProperties::DEVICE_ANNOUNCED]; - if (deviceAnnounced == "true") { - carlaConnected = true; - cv.notify_one(); - } - })); - confHandlers.insert( - libjami::exportable_callback( - [&](const std::string& /* accountId */, - const std::string& /* conversationId */, - int code, - const std::string& /* what */) { - if (code == 3) - errorDetected = true; - cv.notify_one(); - })); - libjami::registerSignalHandlers(confHandlers); - + auto aliceMsgSize = aliceData.messages.size(); aliceAccount->convModule()->addConversationMember(convId, carlaUri, false); - CPPUNIT_ASSERT(cv.wait_for(lk, 5s, [&] { return memberMessageGenerated; })); + CPPUNIT_ASSERT(cv.wait_for(lk, 5s, [&] { return aliceMsgSize + 1 == aliceData.messages.size(); })); // Cp conversations & convInfo - auto repoPathAlice = fileutils::get_data_dir() / aliceAccount->getAccountID() / "conversations"; - auto repoPathCarla = fileutils::get_data_dir() / carlaAccount->getAccountID() / "conversations"; + auto repoPathAlice = fileutils::get_data_dir() / aliceId / "conversations"; + auto repoPathCarla = fileutils::get_data_dir() / carlaId / "conversations"; std::filesystem::copy(repoPathAlice, repoPathCarla, std::filesystem::copy_options::recursive); - auto ciPathAlice = fileutils::get_data_dir() / aliceAccount->getAccountID() + auto ciPathAlice = fileutils::get_data_dir() / aliceId / "convInfo"; - auto ciPathCarla = fileutils::get_data_dir() / carlaAccount->getAccountID() + auto ciPathCarla = fileutils::get_data_dir() / carlaId / "convInfo"; std::remove(ciPathCarla.c_str()); std::filesystem::copy(ciPathAlice, ciPathCarla); @@ -1603,76 +1105,35 @@ ConversationMembersEventTest::testMemberJoinsNoBadFile() // Start Carla, should merge and all messages should be there carlaAccount->convModule()->loadConversations(); // Because of the copy Manager::instance().sendRegister(carlaId, true); - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&] { return carlaConnected; })); + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&] { return carlaData.deviceAnnounced; })); - errorDetected = false; libjami::sendMessage(carlaId, convId, "hi"s, ""); - CPPUNIT_ASSERT(cv.wait_for(lk, 60s, [&] { return errorDetected; })); - libjami::unregisterSignalHandlers(); + CPPUNIT_ASSERT(cv.wait_for(lk, 60s, [&] { return aliceData.errorDetected; })); } void ConversationMembersEventTest::testMemberAddedNoCertificate() { + connectSignals(); + auto aliceAccount = Manager::instance().getAccount(aliceId); auto carlaAccount = Manager::instance().getAccount(carlaId); auto carlaUri = carlaAccount->getUsername(); aliceAccount->trackBuddyPresence(carlaUri, true); auto convId = libjami::startConversation(aliceId); - std::map> confHandlers; - bool conversationReady = false, errorDetected = false, carlaConnected = false, - memberMessageGenerated = false; - confHandlers.insert(libjami::exportable_callback( - [&](const std::string& accountId, const std::string& /* conversationId */) { - if (accountId == carlaId) { - conversationReady = true; - cv.notify_one(); - } - })); - confHandlers.insert(libjami::exportable_callback( - [&](const std::string& accountId, - const std::string& conversationId, - std::map message) { - if (accountId == aliceId && conversationId == convId && message["type"] == "member") { - memberMessageGenerated = true; - cv.notify_one(); - } - })); - confHandlers.insert( - libjami::exportable_callback( - [&](const std::string&, const std::map&) { - auto details = carlaAccount->getVolatileAccountDetails(); - auto deviceAnnounced - = details[libjami::Account::VolatileProperties::DEVICE_ANNOUNCED]; - if (deviceAnnounced == "true") { - carlaConnected = true; - cv.notify_one(); - } - })); - confHandlers.insert( - libjami::exportable_callback( - [&](const std::string& /* accountId */, - const std::string& /* conversationId */, - int code, - const std::string& /* what */) { - if (code == 3) - errorDetected = true; - cv.notify_one(); - })); - libjami::registerSignalHandlers(confHandlers); - + auto aliceMsgSize = aliceData.messages.size(); aliceAccount->convModule()->addConversationMember(convId, carlaUri, false); - CPPUNIT_ASSERT(cv.wait_for(lk, 5s, [&] { return memberMessageGenerated; })); + CPPUNIT_ASSERT(cv.wait_for(lk, 5s, [&] { return aliceMsgSize + 1 == aliceData.messages.size(); })); // Cp conversations & convInfo - auto repoPathAlice = fileutils::get_data_dir() / aliceAccount->getAccountID() / "conversations"; - auto repoPathCarla = fileutils::get_data_dir() / carlaAccount->getAccountID() / "conversations"; + auto repoPathAlice = fileutils::get_data_dir() / aliceId / "conversations"; + auto repoPathCarla = fileutils::get_data_dir() / carlaId / "conversations"; std::filesystem::copy(repoPathAlice, repoPathCarla, std::filesystem::copy_options::recursive); - auto ciPathAlice = fileutils::get_data_dir() / aliceAccount->getAccountID() + auto ciPathAlice = fileutils::get_data_dir() / aliceId / "convInfo"; - auto ciPathCarla = fileutils::get_data_dir() / carlaAccount->getAccountID() + auto ciPathCarla = fileutils::get_data_dir() / carlaId / "convInfo"; std::remove(ciPathCarla.c_str()); std::filesystem::copy(ciPathAlice, ciPathCarla); @@ -1694,75 +1155,34 @@ ConversationMembersEventTest::testMemberAddedNoCertificate() // Start Carla, should merge and all messages should be there carlaAccount->convModule()->loadConversations(); // Because of the copy Manager::instance().sendRegister(carlaId, true); - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&] { return carlaConnected; })); + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&] { return carlaData.deviceAnnounced; })); libjami::sendMessage(carlaId, convId, "hi"s, ""); - errorDetected = false; - CPPUNIT_ASSERT(cv.wait_for(lk, 60s, [&] { return errorDetected; })); - libjami::unregisterSignalHandlers(); + CPPUNIT_ASSERT(cv.wait_for(lk, 60s, [&] { return aliceData.errorDetected; })); } void ConversationMembersEventTest::testMemberJoinsInviteRemoved() { + connectSignals(); + auto aliceAccount = Manager::instance().getAccount(aliceId); auto carlaAccount = Manager::instance().getAccount(carlaId); auto carlaUri = carlaAccount->getUsername(); aliceAccount->trackBuddyPresence(carlaUri, true); auto convId = libjami::startConversation(aliceId); - std::map> confHandlers; - bool conversationReady = false, errorDetected = false, carlaConnected = false, - memberMessageGenerated = false; - confHandlers.insert(libjami::exportable_callback( - [&](const std::string& accountId, const std::string& /* conversationId */) { - if (accountId == carlaId) { - conversationReady = true; - cv.notify_one(); - } - })); - confHandlers.insert(libjami::exportable_callback( - [&](const std::string& accountId, - const std::string& conversationId, - std::map message) { - if (accountId == aliceId && conversationId == convId && message["type"] == "member") { - memberMessageGenerated = true; - cv.notify_one(); - } - })); - confHandlers.insert( - libjami::exportable_callback( - [&](const std::string&, const std::map&) { - auto details = carlaAccount->getVolatileAccountDetails(); - auto deviceAnnounced - = details[libjami::Account::VolatileProperties::DEVICE_ANNOUNCED]; - if (deviceAnnounced == "true") { - carlaConnected = true; - cv.notify_one(); - } - })); - confHandlers.insert( - libjami::exportable_callback( - [&](const std::string& /* accountId */, - const std::string& /* conversationId */, - int code, - const std::string& /* what */) { - if (code == 3) - errorDetected = true; - cv.notify_one(); - })); - libjami::registerSignalHandlers(confHandlers); - + auto aliceMsgSize = aliceData.messages.size(); aliceAccount->convModule()->addConversationMember(convId, carlaUri, false); - CPPUNIT_ASSERT(cv.wait_for(lk, 5s, [&] { return memberMessageGenerated; })); + CPPUNIT_ASSERT(cv.wait_for(lk, 5s, [&] { return aliceMsgSize + 1 == aliceData.messages.size(); })); // Cp conversations & convInfo - auto repoPathAlice = fileutils::get_data_dir() / aliceAccount->getAccountID() / "conversations"; - auto repoPathCarla = fileutils::get_data_dir() / carlaAccount->getAccountID() / "conversations"; + auto repoPathAlice = fileutils::get_data_dir() / aliceId / "conversations"; + auto repoPathCarla = fileutils::get_data_dir() / carlaId / "conversations"; std::filesystem::copy(repoPathAlice, repoPathCarla, std::filesystem::copy_options::recursive); - auto ciPathAlice = fileutils::get_data_dir() / aliceAccount->getAccountID() / "convInfo"; - auto ciPathCarla = fileutils::get_data_dir() / carlaAccount->getAccountID() / "convInfo"; + auto ciPathAlice = fileutils::get_data_dir() / aliceId / "convInfo"; + auto ciPathCarla = fileutils::get_data_dir() / carlaId / "convInfo"; std::remove(ciPathCarla.c_str()); std::filesystem::copy(ciPathAlice, ciPathCarla); @@ -1792,186 +1212,78 @@ ConversationMembersEventTest::testMemberJoinsInviteRemoved() // Start Carla, should merge and all messages should be there carlaAccount->convModule()->loadConversations(); // Because of the copy Manager::instance().sendRegister(carlaId, true); - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&] { return carlaConnected; })); + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&] { return carlaData.deviceAnnounced; })); libjami::sendMessage(carlaId, convId, "hi"s, ""); - errorDetected = false; - - CPPUNIT_ASSERT(cv.wait_for(lk, 60s, [&] { return errorDetected; })); - libjami::unregisterSignalHandlers(); + CPPUNIT_ASSERT(cv.wait_for(lk, 60s, [&] { return aliceData.errorDetected; })); } void ConversationMembersEventTest::testFailAddMemberInOneToOne() { + connectSignals(); + auto aliceAccount = Manager::instance().getAccount(aliceId); auto bobAccount = Manager::instance().getAccount(bobId); auto carlaAccount = Manager::instance().getAccount(carlaId); auto bobUri = bobAccount->getUsername(); - auto aliceUri = aliceAccount->getUsername(); auto carlaUri = carlaAccount->getUsername(); - std::map> confHandlers; - bool conversationReady = false, requestReceived = false, memberMessageGenerated = false; - std::string convId = ""; - confHandlers.insert( - libjami::exportable_callback( - [&](const std::string& account_id, - const std::string& /*from*/, - const std::string& /*conversationId*/, - const std::vector& /*payload*/, - time_t /*received*/) { - if (account_id == bobId) - requestReceived = true; - cv.notify_one(); - })); - confHandlers.insert(libjami::exportable_callback( - [&](const std::string& accountId, const std::string& conversationId) { - if (accountId == aliceId) { - convId = conversationId; - } else if (accountId == bobId) { - conversationReady = true; - } - cv.notify_one(); - })); - confHandlers.insert(libjami::exportable_callback( - [&](const std::string& accountId, - const std::string& conversationId, - std::map message) { - if (accountId == aliceId && conversationId == convId && message["type"] == "member") { - memberMessageGenerated = true; - cv.notify_one(); - } - })); - libjami::registerSignalHandlers(confHandlers); + aliceAccount->addContact(bobUri); aliceAccount->sendTrustRequest(bobUri, {}); - CPPUNIT_ASSERT(cv.wait_for(lk, 5s, [&]() { return !convId.empty(); })); - memberMessageGenerated = false; - libjami::addConversationMember(aliceId, convId, carlaUri); - CPPUNIT_ASSERT(!cv.wait_for(lk, 5s, [&]() { return memberMessageGenerated; })); + CPPUNIT_ASSERT(cv.wait_for(lk, 5s, [&]() { return bobData.requestReceived; })); + auto aliceMsgSize = aliceData.messages.size(); + libjami::addConversationMember(aliceId, aliceData.conversationId, carlaUri); + CPPUNIT_ASSERT(!cv.wait_for(lk, 5s, [&]() { return aliceMsgSize + 1 == aliceData.messages.size(); })); } void ConversationMembersEventTest::testOneToOneFetchWithNewMemberRefused() { + connectSignals(); + auto aliceAccount = Manager::instance().getAccount(aliceId); auto bobAccount = Manager::instance().getAccount(bobId); auto carlaAccount = Manager::instance().getAccount(carlaId); auto bobUri = bobAccount->getUsername(); auto aliceUri = aliceAccount->getUsername(); auto carlaUri = carlaAccount->getUsername(); - std::map> confHandlers; - bool conversationReady = false, requestReceived = false, memberMessageGenerated = false, - messageBob = false, errorDetected = false; - std::string convId = ""; - confHandlers.insert( - libjami::exportable_callback( - [&](const std::string& account_id, - const std::string& /*from*/, - const std::string& /*conversationId*/, - const std::vector& /*payload*/, - time_t /*received*/) { - if (account_id == bobId) - requestReceived = true; - cv.notify_one(); - })); - confHandlers.insert(libjami::exportable_callback( - [&](const std::string& accountId, const std::string& conversationId) { - if (accountId == aliceId) { - convId = conversationId; - } else if (accountId == bobId) { - conversationReady = true; - } - cv.notify_one(); - })); - confHandlers.insert(libjami::exportable_callback( - [&](const std::string& accountId, - const std::string& conversationId, - std::map message) { - if (accountId == aliceId && conversationId == convId && message["type"] == "member") { - memberMessageGenerated = true; - } else if (accountId == bobId && conversationId == convId - && message["type"] == "member") { - messageBob = true; - } - cv.notify_one(); - })); - confHandlers.insert( - libjami::exportable_callback( - [&](const std::string& /* accountId */, - const std::string& /* conversationId */, - int code, - const std::string& /* what */) { - if (code == 3) - errorDetected = true; - cv.notify_one(); - })); - libjami::registerSignalHandlers(confHandlers); + aliceAccount->addContact(bobUri); aliceAccount->sendTrustRequest(bobUri, {}); - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return !convId.empty() && requestReceived; })); + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return bobData.requestReceived; })); + auto aliceMsgSize = aliceData.messages.size(); CPPUNIT_ASSERT(bobAccount->acceptTrustRequest(aliceUri)); - memberMessageGenerated = false; CPPUNIT_ASSERT( - cv.wait_for(lk, 30s, [&]() { return conversationReady && memberMessageGenerated; })); + cv.wait_for(lk, 30s, [&]() { return aliceMsgSize + 1 == aliceData.messages.size();; })); - errorDetected = false; // NOTE: Add certificate because no DHT lookup aliceAccount->certStore().pinCertificate(carlaAccount->identity().second); - generateFakeInvite(aliceAccount, convId, carlaUri); - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return errorDetected; })); + generateFakeInvite(aliceAccount, aliceData.conversationId, carlaUri); + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return bobData.errorDetected; })); } void ConversationMembersEventTest::testConversationMemberEvent() { + connectSignals(); + auto aliceAccount = Manager::instance().getAccount(aliceId); auto bobAccount = Manager::instance().getAccount(bobId); auto bobUri = bobAccount->getUsername(); auto convId = libjami::startConversation(aliceId); - std::map> confHandlers; - bool conversationReady = false, requestReceived = false, memberAddGenerated = false; - confHandlers.insert( - libjami::exportable_callback( - [&](const std::string& /*accountId*/, - const std::string& /* conversationId */, - std::map /*metadatas*/) { - requestReceived = true; - cv.notify_one(); - })); - confHandlers.insert(libjami::exportable_callback( - [&](const std::string& accountId, const std::string& /* conversationId */) { - if (accountId == bobId) { - conversationReady = true; - cv.notify_one(); - } - })); - confHandlers.insert( - libjami::exportable_callback( - [&](const std::string& accountId, - const std::string& conversationId, - const std::string& uri, - int event) { - if (accountId == aliceId && conversationId == convId && uri == bobUri - && event == 0) { - memberAddGenerated = true; - } - cv.notify_one(); - })); - libjami::registerSignalHandlers(confHandlers); libjami::addConversationMember(aliceId, convId, bobUri); - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return memberAddGenerated; })); + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return bobData.requestReceived; })); // Assert that repository exists - auto repoPath = fileutils::get_data_dir() / aliceAccount->getAccountID() + auto repoPath = fileutils::get_data_dir() / aliceId / "conversations" / convId; CPPUNIT_ASSERT(std::filesystem::is_directory(repoPath)); // Check created files auto bobInvited = repoPath / "invited" / bobUri; CPPUNIT_ASSERT(std::filesystem::is_regular_file(bobInvited)); - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return requestReceived; })); libjami::acceptConversationRequest(bobId, convId); - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return conversationReady; })); - auto clonedPath = fileutils::get_data_dir() / bobAccount->getAccountID() + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return !bobData.conversationId.empty(); })); + auto clonedPath = fileutils::get_data_dir() / bobId / "conversations" / convId; CPPUNIT_ASSERT(std::filesystem::is_directory(clonedPath)); bobInvited = clonedPath / "invited" / bobUri; @@ -1983,42 +1295,20 @@ ConversationMembersEventTest::testConversationMemberEvent() void ConversationMembersEventTest::testGetConversationsMembersWhileSyncing() { + connectSignals(); + auto aliceAccount = Manager::instance().getAccount(aliceId); auto bobAccount = Manager::instance().getAccount(bobId); auto bobUri = bobAccount->getUsername(); auto aliceUri = aliceAccount->getUsername(); - std::map> confHandlers; - bool conversationReady = false, requestReceived = false; - std::string convId = ""; - confHandlers.insert( - libjami::exportable_callback( - [&](const std::string& account_id, - const std::string& /*from*/, - const std::string& /*conversationId*/, - const std::vector& /*payload*/, - time_t /*received*/) { - if (account_id == bobId) - requestReceived = true; - cv.notify_one(); - })); - confHandlers.insert(libjami::exportable_callback( - [&](const std::string& accountId, const std::string& conversationId) { - if (accountId == aliceId) { - convId = conversationId; - } else if (accountId == bobId) { - conversationReady = true; - } - cv.notify_one(); - })); - libjami::registerSignalHandlers(confHandlers); aliceAccount->addContact(bobUri); aliceAccount->sendTrustRequest(bobUri, {}); - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return requestReceived; })); + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return bobData.requestReceived; })); Manager::instance().sendRegister(aliceId, false); // This avoid to sync immediately CPPUNIT_ASSERT(bobAccount->acceptTrustRequest(aliceUri)); - auto members = libjami::getConversationMembers(bobId, convId); + auto members = libjami::getConversationMembers(bobId, aliceData.conversationId); CPPUNIT_ASSERT(std::find_if(members.begin(), members.end(), [&](auto memberInfo) { return memberInfo["uri"] == aliceUri; }) @@ -2032,6 +1322,8 @@ ConversationMembersEventTest::testGetConversationsMembersWhileSyncing() void ConversationMembersEventTest::testGetConversationMembersWithSelfOneOne() { + connectSignals(); + auto aliceAccount = Manager::instance().getAccount(aliceId); auto aliceUri = aliceAccount->getUsername(); std::map> confHandlers; @@ -2054,66 +1346,25 @@ ConversationMembersEventTest::testGetConversationMembersWithSelfOneOne() void ConversationMembersEventTest::testAvoidTwoOneToOne() { + connectSignals(); + auto aliceAccount = Manager::instance().getAccount(aliceId); auto bobAccount = Manager::instance().getAccount(bobId); auto bobUri = bobAccount->getUsername(); auto aliceUri = aliceAccount->getUsername(); - std::map> confHandlers; - auto requestReceived = false; - confHandlers.insert( - libjami::exportable_callback( - [&](const std::string& accountId, - const std::string& conversationId, - std::map /*metadatas*/) { - if (accountId == bobId) - requestReceived = true; - cv.notify_one(); - })); - std::string convId = ""; - auto conversationReadyBob = false; - confHandlers.insert(libjami::exportable_callback( - [&](const std::string& accountId, const std::string& conversationId) { - if (accountId == aliceId) { - convId = conversationId; - } else if (accountId == bobId && conversationId == convId) { - conversationReadyBob = true; - } - cv.notify_one(); - })); - auto memberMessageGenerated = false; - confHandlers.insert(libjami::exportable_callback( - [&](const std::string& accountId, - const std::string& conversationId, - std::map message) { - if (accountId == aliceId && conversationId == convId) { - if (message["type"] == "member") - memberMessageGenerated = true; - } - cv.notify_one(); - })); - auto conversationRmBob = false; - confHandlers.insert( - libjami::exportable_callback( - [&](const std::string& accountId, const std::string&) { - if (accountId == bobId) - conversationRmBob = true; - cv.notify_one(); - })); - libjami::registerSignalHandlers(confHandlers); - // Alice adds bob - requestReceived = false; aliceAccount->addContact(bobUri); aliceAccount->sendTrustRequest(bobUri, {}); - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return requestReceived; })); - libjami::acceptConversationRequest(bobId, convId); + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return bobData.requestReceived; })); + auto aliceMsgSize = aliceData.messages.size(); + libjami::acceptConversationRequest(bobId, aliceData.conversationId); CPPUNIT_ASSERT( - cv.wait_for(lk, 30s, [&]() { return conversationReadyBob && memberMessageGenerated; })); + cv.wait_for(lk, 30s, [&]() { return aliceData.messages.size() == aliceMsgSize + 1; })); // Remove contact bobAccount->removeContact(aliceUri, false); - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return conversationRmBob; })); + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return bobData.removed; })); // wait that connections are closed. std::this_thread::sleep_for(10s); @@ -2121,78 +1372,19 @@ ConversationMembersEventTest::testAvoidTwoOneToOne() // Bob add Alice, this should re-add old conversation bobAccount->addContact(aliceUri); bobAccount->sendTrustRequest(aliceUri, {}); - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return conversationReadyBob; })); + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return bobData.conversationId == aliceData.conversationId; })); } void ConversationMembersEventTest::testAvoidTwoOneToOneMultiDevices() { + connectSignals(); + auto aliceAccount = Manager::instance().getAccount(aliceId); auto bobAccount = Manager::instance().getAccount(bobId); auto bobUri = bobAccount->getUsername(); auto aliceUri = aliceAccount->getUsername(); - std::map> confHandlers; - auto requestReceived = false, requestReceivedBob2 = false; - confHandlers.insert( - libjami::exportable_callback( - [&](const std::string& accountId, - const std::string& conversationId, - std::map /*metadatas*/) { - if (accountId == bobId) - requestReceived = true; - else if (accountId == bob2Id) - requestReceivedBob2 = true; - cv.notify_one(); - })); - std::string convId = ""; - auto conversationReadyBob = false, conversationReadyBob2 = false; - confHandlers.insert(libjami::exportable_callback( - [&](const std::string& accountId, const std::string& conversationId) { - if (accountId == aliceId) { - convId = conversationId; - } else if (accountId == bobId && conversationId == convId) { - conversationReadyBob = true; - } else if (accountId == bob2Id && conversationId == convId) { - conversationReadyBob2 = true; - } - cv.notify_one(); - })); - auto memberMessageGenerated = false; - confHandlers.insert(libjami::exportable_callback( - [&](const std::string& accountId, - const std::string& conversationId, - std::map message) { - if (accountId == aliceId && conversationId == convId) { - if (message["type"] == "member") - memberMessageGenerated = true; - } - cv.notify_one(); - })); - auto bob2Started = false; - confHandlers.insert( - libjami::exportable_callback( - [&](const std::string& accountId, const std::map& details) { - if (accountId == bob2Id) { - auto daemonStatus = details.at( - libjami::Account::VolatileProperties::DEVICE_ANNOUNCED); - if (daemonStatus == "true") - bob2Started = true; - } - cv.notify_one(); - })); - auto conversationRmBob = false, conversationRmBob2 = false; - confHandlers.insert( - libjami::exportable_callback( - [&](const std::string& accountId, const std::string&) { - if (accountId == bobId) - conversationRmBob = true; - else if (accountId == bob2Id) - conversationRmBob2 = true; - cv.notify_one(); - })); - libjami::registerSignalHandlers(confHandlers); - // Bob creates a second device auto bobArchive = std::filesystem::current_path().string() + "/bob.gz"; std::remove(bobArchive.c_str()); @@ -2207,21 +1399,21 @@ ConversationMembersEventTest::testAvoidTwoOneToOneMultiDevices() details[ConfProperties::ARCHIVE_PATH] = bobArchive; bob2Id = Manager::instance().addAccount(details); - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return bob2Started; })); + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return bob2Data.deviceAnnounced; })); // Alice adds bob - requestReceived = false; aliceAccount->addContact(bobUri); aliceAccount->sendTrustRequest(bobUri, {}); - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return requestReceived && requestReceivedBob2; })); - libjami::acceptConversationRequest(bobId, convId); + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return bobData.requestReceived && bob2Data.requestReceived; })); + auto aliceMsgSize = aliceData.messages.size(); + libjami::acceptConversationRequest(bobId, aliceData.conversationId); CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { - return conversationReadyBob && conversationReadyBob2 && memberMessageGenerated; + return !bobData.conversationId.empty() && !bob2Data.conversationId.empty() && aliceMsgSize + 1 == aliceData.messages.size(); })); // Remove contact bobAccount->removeContact(aliceUri, false); - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return conversationRmBob && conversationRmBob2; })); + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return bobData.removed && bob2Data.removed; })); // wait that connections are closed. std::this_thread::sleep_for(10s); @@ -2230,52 +1422,19 @@ ConversationMembersEventTest::testAvoidTwoOneToOneMultiDevices() bobAccount->addContact(aliceUri); bobAccount->sendTrustRequest(aliceUri, {}); CPPUNIT_ASSERT( - cv.wait_for(lk, 30s, [&]() { return conversationReadyBob && conversationReadyBob2; })); + cv.wait_for(lk, 30s, [&]() { return bobData.conversationId == aliceData.conversationId && bob2Data.conversationId == aliceData.conversationId; })); } void ConversationMembersEventTest::testRemoveRequestBannedMultiDevices() { + connectSignals(); + auto aliceAccount = Manager::instance().getAccount(aliceId); auto bobAccount = Manager::instance().getAccount(bobId); auto bobUri = bobAccount->getUsername(); auto aliceUri = aliceAccount->getUsername(); - std::map> confHandlers; - auto requestReceived = false, requestReceivedBob2 = false; - confHandlers.insert( - libjami::exportable_callback( - [&](const std::string& accountId, - const std::string& conversationId, - std::map /*metadatas*/) { - if (accountId == bobId) - requestReceived = true; - else if (accountId == bob2Id) - requestReceivedBob2 = true; - cv.notify_one(); - })); - auto bob2Started = false; - confHandlers.insert( - libjami::exportable_callback( - [&](const std::string& accountId, const std::map& details) { - if (accountId == bob2Id) { - auto daemonStatus = details.at( - libjami::Account::VolatileProperties::DEVICE_ANNOUNCED); - if (daemonStatus == "true") - bob2Started = true; - } - cv.notify_one(); - })); - auto bob2ContactRemoved = false; - confHandlers.insert(libjami::exportable_callback( - [&](const std::string& accountId, const std::string& uri, bool banned) { - if (accountId == bob2Id && uri == aliceUri && banned) { - bob2ContactRemoved = true; - } - cv.notify_one(); - })); - libjami::registerSignalHandlers(confHandlers); - // Bob creates a second device auto bobArchive = std::filesystem::current_path().string() + "/bob.gz"; std::remove(bobArchive.c_str()); @@ -2290,92 +1449,29 @@ ConversationMembersEventTest::testRemoveRequestBannedMultiDevices() details[ConfProperties::ARCHIVE_PATH] = bobArchive; bob2Id = Manager::instance().addAccount(details); - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return bob2Started; })); + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return bob2Data.deviceAnnounced; })); // Alice adds bob - requestReceived = false; aliceAccount->addContact(bobUri); aliceAccount->sendTrustRequest(bobUri, {}); - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return requestReceived && requestReceivedBob2; })); + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return bobData.requestReceived && bob2Data.requestReceived; })); CPPUNIT_ASSERT(libjami::getConversationRequests(bob2Id).size() == 1); // Bob bans alice, should update bob2 bobAccount->removeContact(aliceUri, true); - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return bob2ContactRemoved; })); + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return bob2Data.contactRemoved; })); CPPUNIT_ASSERT(libjami::getConversationRequests(bob2Id).size() == 0); } void ConversationMembersEventTest::testBanUnbanMultiDevice() { - auto aliceAccount = Manager::instance().getAccount(aliceId); + connectSignals(); + auto bobAccount = Manager::instance().getAccount(bobId); auto bobUri = bobAccount->getUsername(); - auto aliceUri = aliceAccount->getUsername(); - auto convId = libjami::startConversation(aliceId); - std::map> confHandlers; - auto requestReceived = false, requestReceivedBob2 = false; - confHandlers.insert( - libjami::exportable_callback( - [&](const std::string& accountId, - const std::string& conversationId, - std::map /*metadatas*/) { - if (accountId == bobId) - requestReceived = true; - else if (accountId == bob2Id) - requestReceivedBob2 = true; - cv.notify_one(); - })); - auto bob2Started = false; - confHandlers.insert( - libjami::exportable_callback( - [&](const std::string& accountId, const std::map& details) { - if (accountId == bob2Id) { - auto daemonStatus = details.at( - libjami::Account::VolatileProperties::DEVICE_ANNOUNCED); - if (daemonStatus == "true") - bob2Started = true; - } - cv.notify_one(); - })); - auto bob2ContactRemoved = false; - confHandlers.insert(libjami::exportable_callback( - [&](const std::string& accountId, const std::string& uri, bool banned) { - if (accountId == bob2Id && uri == aliceUri && banned) { - bob2ContactRemoved = true; - } - cv.notify_one(); - })); - auto memberMessageGenerated = false, voteMessageGenerated = false; - confHandlers.insert(libjami::exportable_callback( - [&](const std::string& accountId, - const std::string& conversationId, - std::map message) { - auto itFind = message.find("type"); - if (itFind == message.end()) - return; - if (accountId == aliceId && conversationId == convId) { - if (itFind->second == "member") - memberMessageGenerated = true; - if (itFind->second == "vote") - voteMessageGenerated = true; - } - cv.notify_one(); - })); - auto conversationReadyBob = false, conversationReadyBob2 = false; - confHandlers.insert(libjami::exportable_callback( - [&](const std::string& accountId, const std::string& conversationId) { - if (accountId == bobId && conversationId == convId) { - conversationReadyBob = true; - } else if (accountId == bob2Id && conversationId == convId) { - conversationReadyBob2 = true; - } - cv.notify_one(); - })); - libjami::registerSignalHandlers(confHandlers); - // Bob creates a second device auto bobArchive = std::filesystem::current_path().string() + "/bob.gz"; std::remove(bobArchive.c_str()); @@ -2390,117 +1486,40 @@ ConversationMembersEventTest::testBanUnbanMultiDevice() details[ConfProperties::ARCHIVE_PATH] = bobArchive; bob2Id = Manager::instance().addAccount(details); - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return bob2Started; })); + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return bob2Data.deviceAnnounced; })); // Alice adds bob - requestReceived = false; libjami::addConversationMember(aliceId, convId, bobUri); - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { - return memberMessageGenerated && requestReceived && requestReceivedBob2; - })); + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return bobData.requestReceived && bob2Data.requestReceived; })); // Alice kick Bob while invited - memberMessageGenerated = false; - voteMessageGenerated = false; + auto aliceMsgSize = aliceData.messages.size(); libjami::removeConversationMember(aliceId, convId, bobUri); CPPUNIT_ASSERT( - cv.wait_for(lk, 30s, [&]() { return memberMessageGenerated && voteMessageGenerated; })); + cv.wait_for(lk, 30s, [&]() { return aliceMsgSize + 2 == aliceData.messages.size(); })); // Alice re-add Bob while invited - memberMessageGenerated = false; - voteMessageGenerated = false; + aliceMsgSize = aliceData.messages.size(); libjami::addConversationMember(aliceId, convId, bobUri); CPPUNIT_ASSERT( - cv.wait_for(lk, 30s, [&]() { return memberMessageGenerated && voteMessageGenerated; })); + cv.wait_for(lk, 30s, [&]() { return aliceMsgSize + 2 == aliceData.messages.size(); })); // bob accepts libjami::acceptConversationRequest(bobId, convId); CPPUNIT_ASSERT( - cv.wait_for(lk, 30s, [&]() { return conversationReadyBob && conversationReadyBob2; })); + cv.wait_for(lk, 30s, [&]() { return bobData.conversationId == aliceData.conversationId && bob2Data.conversationId == aliceData.conversationId; })); } void ConversationMembersEventTest::testBanUnbanGotFirstConv() { + connectSignals(); + auto aliceAccount = Manager::instance().getAccount(aliceId); auto bobAccount = Manager::instance().getAccount(bobId); auto bobUri = bobAccount->getUsername(); auto aliceUri = aliceAccount->getUsername(); - std::map> confHandlers; - auto requestReceived = false, requestReceivedBob2 = false; - confHandlers.insert( - libjami::exportable_callback( - [&](const std::string& accountId, - const std::string& conversationId, - std::map /*metadatas*/) { - if (accountId == bobId) - requestReceived = true; - else if (accountId == bob2Id) - requestReceivedBob2 = true; - cv.notify_one(); - })); - std::string convId; - auto conversationReadyBob = false, conversationReadyBob2 = false; - confHandlers.insert(libjami::exportable_callback( - [&](const std::string& accountId, const std::string& conversationId) { - if (accountId == aliceId) { - convId = conversationId; - } else if (accountId == bobId && conversationId == convId) { - conversationReadyBob = true; - } else if (accountId == bob2Id && conversationId == convId) { - conversationReadyBob2 = true; - } - cv.notify_one(); - })); - auto bob2Started = false; - confHandlers.insert( - libjami::exportable_callback( - [&](const std::string& accountId, const std::map& details) { - if (accountId == bob2Id) { - auto daemonStatus = details.at( - libjami::Account::VolatileProperties::DEVICE_ANNOUNCED); - if (daemonStatus == "true") - bob2Started = true; - } - cv.notify_one(); - })); - auto bob2ContactRemoved = false; - confHandlers.insert(libjami::exportable_callback( - [&](const std::string& accountId, const std::string& uri, bool banned) { - if (accountId == bob2Id && uri == aliceUri && banned) { - bob2ContactRemoved = true; - } - cv.notify_one(); - })); - auto bobMsgReceived = false, bob2MsgReceived = false, memberMessageGenerated = false; - confHandlers.insert(libjami::exportable_callback( - [&](const std::string& accountId, - const std::string& conversationId, - std::map message) { - if (accountId == aliceId && conversationId == convId) { - auto itFind = message.find("type"); - if (itFind != message.end() && itFind->second == "member") - memberMessageGenerated = true; - } else if (accountId == bobId && conversationId == convId) - bobMsgReceived = true; - else if (accountId == bob2Id && conversationId == convId) - bob2MsgReceived = true; - cv.notify_one(); - })); - auto contactAddedBob = false, contactAddedBob2 = false; - confHandlers.insert(libjami::exportable_callback( - [&](const std::string& accountId, const std::string& uri, bool) { - if (accountId == bobId && uri == aliceUri) { - contactAddedBob = true; - } else if (accountId == bob2Id && uri == aliceUri) { - contactAddedBob2 = true; - } - cv.notify_one(); - })); - - libjami::registerSignalHandlers(confHandlers); - // Bob creates a second device auto bobArchive = std::filesystem::current_path().string() + "/bob.gz"; std::remove(bobArchive.c_str()); @@ -2515,105 +1534,72 @@ ConversationMembersEventTest::testBanUnbanGotFirstConv() details[ConfProperties::ARCHIVE_PATH] = bobArchive; bob2Id = Manager::instance().addAccount(details); - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return bob2Started; })); + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return bob2Data.deviceAnnounced; })); // Alice adds bob - requestReceived = false; aliceAccount->addContact(bobUri); aliceAccount->sendTrustRequest(bobUri, {}); - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return requestReceived && requestReceivedBob2; })); + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return bobData.requestReceived && bob2Data.requestReceived; })); CPPUNIT_ASSERT(libjami::getConversationRequests(bob2Id).size() == 1); // Accepts requests - libjami::acceptConversationRequest(bobId, convId); + auto aliceMsgSize = aliceData.messages.size(); + libjami::acceptConversationRequest(bobId, aliceData.conversationId); CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { - return conversationReadyBob && conversationReadyBob2 && memberMessageGenerated; + return !bobData.conversationId.empty() && !bob2Data.conversationId.empty() && aliceMsgSize + 1 == aliceData.messages.size(); })); // Bob bans alice, should update bob2 bobAccount->removeContact(aliceUri, true); - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return bob2ContactRemoved; })); + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return bob2Data.contactRemoved; })); // Alice sends messages, bob & bob2 should not get it! - bobMsgReceived = false, bob2MsgReceived = false; - libjami::sendMessage(aliceId, convId, "hi"s, ""); - CPPUNIT_ASSERT(!cv.wait_for(lk, 30s, [&]() { return bobMsgReceived && bob2MsgReceived; })); + auto bobMsgSize = bobData.messages.size(); + auto bob2MsgSize = bob2Data.messages.size(); + libjami::sendMessage(aliceId, aliceData.conversationId, "hi"s, ""); + CPPUNIT_ASSERT(!cv.wait_for(lk, 30s, [&]() { return bobMsgSize != bobData.messages.size() && bob2MsgSize != bob2Data.messages.size(); })); // Bobs re-add Alice - contactAddedBob = false, contactAddedBob2 = false; bobAccount->addContact(aliceUri); bobAccount->sendTrustRequest(aliceUri, {}); - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return contactAddedBob && contactAddedBob2; })); + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return bobData.conversationId == aliceData.conversationId && bob2Data.conversationId == aliceData.conversationId; })); // Alice can sends some messages now - bobMsgReceived = false, bob2MsgReceived = false; - libjami::sendMessage(aliceId, convId, "hi"s, ""); - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return bobMsgReceived && bob2MsgReceived; })); + bobMsgSize = bobData.messages.size(); + bob2MsgSize = bob2Data.messages.size(); + libjami::sendMessage(aliceId, aliceData.conversationId, "hi"s, ""); + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return bobMsgSize != bobData.messages.size() && bob2MsgSize != bob2Data.messages.size(); })); } void ConversationMembersEventTest::testBanHostWhileHosting() { - auto aliceAccount = Manager::instance().getAccount(aliceId); + connectSignals(); + auto bobAccount = Manager::instance().getAccount(bobId); - auto aliceUri = aliceAccount->getUsername(); auto bobUri = bobAccount->getUsername(); auto convId = libjami::startConversation(aliceId); - std::map> confHandlers; - bool conversationReady = false, requestReceived = false; - confHandlers.insert( - libjami::exportable_callback( - [&](const std::string& /*accountId*/, - const std::string& /* conversationId */, - std::map /*metadatas*/) { - requestReceived = true; - cv.notify_one(); - })); - confHandlers.insert(libjami::exportable_callback( - [&](const std::string& accountId, const std::string& conversationId) { - if (accountId == bobId && conversationId == convId) { - conversationReady = true; - cv.notify_one(); - } - })); - bool memberMessageGenerated = false, callMessageGenerated = false, voteMessageGenerated = false; - confHandlers.insert(libjami::exportable_callback( - [&](const std::string& accountId, - const std::string& conversationId, - std::map message) { - if (accountId == aliceId && conversationId == convId && message["type"] == "vote") { - voteMessageGenerated = true; - cv.notify_one(); - } else if (accountId == aliceId && conversationId == convId) { - if (message["type"] == "application/call-history+json") { - callMessageGenerated = true; - } else if (message["type"] == "member") { - memberMessageGenerated = true; - } - cv.notify_one(); - } - })); - libjami::registerSignalHandlers(confHandlers); + libjami::addConversationMember(aliceId, convId, bobUri); - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return requestReceived; })); - memberMessageGenerated = false; + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return bobData.requestReceived; })); + auto aliceMsgSize = aliceData.messages.size(); libjami::acceptConversationRequest(bobId, convId); - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return memberMessageGenerated; })); + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return aliceMsgSize + 1 == aliceData.messages.size(); })); // Now, Bob starts a call + aliceMsgSize = aliceData.messages.size(); auto callId = libjami::placeCallWithMedia(bobId, "swarm:" + convId, {}); // should get message - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return callMessageGenerated; })); + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return aliceMsgSize != aliceData.messages.size(); })); // get active calls = 1 CPPUNIT_ASSERT(libjami::getActiveCalls(aliceId, convId).size() == 1); // Now check that alice, has the only admin, can remove bob - memberMessageGenerated = false; - voteMessageGenerated = false; + aliceMsgSize = aliceData.messages.size(); libjami::removeConversationMember(aliceId, convId, bobUri); CPPUNIT_ASSERT( - cv.wait_for(lk, 30s, [&]() { return memberMessageGenerated && voteMessageGenerated; })); + cv.wait_for(lk, 30s, [&]() { return aliceMsgSize + 2 == aliceData.messages.size(); })); auto members = libjami::getConversationMembers(aliceId, convId); auto bobBanned = false; for (auto& member : members) { @@ -2621,141 +1607,120 @@ ConversationMembersEventTest::testBanHostWhileHosting() bobBanned = member["role"] == "banned"; } CPPUNIT_ASSERT(bobBanned); - - libjami::unregisterSignalHandlers(); } void ConversationMembersEventTest::testRemoveContactTwice() { + connectSignals(); + std::cout << "\nRunning test: " << __func__ << std::endl; auto aliceAccount = Manager::instance().getAccount(aliceId); auto bobAccount = Manager::instance().getAccount(bobId); auto bobUri = bobAccount->getUsername(); auto aliceUri = aliceAccount->getUsername(); - std::map> confHandlers; - bool requestReceived = false; - confHandlers.insert( - libjami::exportable_callback( - [&](const std::string& accountId, - const std::string&, - std::map /*metadatas*/) { - if (accountId == bobId) - requestReceived = true; - cv.notify_one(); - })); - std::string convId = ""; auto conversationReady = false; - confHandlers.insert(libjami::exportable_callback( - [&](const std::string& accountId, const std::string& conversationId) { - if (accountId == aliceId) - convId = conversationId; - else if (accountId == bobId) - conversationReady = true; - cv.notify_one(); - })); - auto conversationRemoved = false; - confHandlers.insert( - libjami::exportable_callback( - [&](const std::string& accountId, const std::string&) { - if (accountId == bobId) - conversationRemoved = true; - cv.notify_one(); - })); - auto contactRemoved = false; - confHandlers.insert(libjami::exportable_callback( - [&](const std::string& accountId, const std::string& uri, bool) { - if (accountId == bobId && uri == aliceUri) - contactRemoved = true; - cv.notify_one(); - })); - auto memberMessageGenerated = false; - confHandlers.insert(libjami::exportable_callback( - [&](const std::string& accountId, - const std::string& /* conversationId */, - std::map message) { - if (accountId == aliceId && message["type"] == "member") - memberMessageGenerated = true; - cv.notify_one(); - })); - libjami::registerSignalHandlers(confHandlers); - requestReceived = false; + aliceAccount->addContact(bobUri); aliceAccount->sendTrustRequest(bobUri, {}); - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return requestReceived; })); + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return bobData.requestReceived; })); + auto aliceMsgSize = aliceData.messages.size(); CPPUNIT_ASSERT(bobAccount->acceptTrustRequest(aliceUri)); CPPUNIT_ASSERT( - cv.wait_for(lk, 30s, [&]() { return conversationReady && memberMessageGenerated; })); + cv.wait_for(lk, 30s, [&]() { return aliceMsgSize + 1 == aliceData.messages.size(); })); // removeContact bobAccount->removeContact(aliceUri, false); - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return contactRemoved; })); + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return bobData.removed; })); // wait that connections are closed. std::this_thread::sleep_for(10s); // re-add via a new message. Trigger a new request - requestReceived = false; - libjami::sendMessage(aliceId, convId, "foo"s, ""); - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return requestReceived; })); + bobData.requestReceived = false; + libjami::sendMessage(aliceId, aliceData.conversationId, "foo"s, ""); + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return bobData.requestReceived; })); // removeContact again (should remove the trust request/conversation) - contactRemoved = false; + bobData.removed = false; bobAccount->removeContact(aliceUri, false); - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return contactRemoved; })); + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return bobData.removed; })); } void ConversationMembersEventTest::testAddContactTwice() { + connectSignals(); std::cout << "\nRunning test: " << __func__ << std::endl; auto aliceAccount = Manager::instance().getAccount(aliceId); auto bobAccount = Manager::instance().getAccount(bobId); auto bobUri = bobAccount->getUsername(); - auto aliceUri = aliceAccount->getUsername(); - std::map> confHandlers; - bool requestReceived = false; - confHandlers.insert( - libjami::exportable_callback( - [&](const std::string& accountId, - const std::string&, - std::map /*metadatas*/) { - if (accountId == bobId) - requestReceived = true; - cv.notify_one(); - })); - std::string convId = ""; - confHandlers.insert(libjami::exportable_callback( - [&](const std::string& accountId, const std::string& conversationId) { - if (accountId == aliceId) - convId = conversationId; - cv.notify_one(); - })); - auto requestDeclined = false; - confHandlers.insert( - libjami::exportable_callback( - [&](const std::string& accountId, const std::string&) { - if (accountId == bobId) - requestDeclined = true; - cv.notify_one(); - })); - auto contactRemoved = false; - confHandlers.insert(libjami::exportable_callback( - [&](const std::string& accountId, const std::string& uri, bool) { - if (accountId == aliceId && uri == bobUri) - contactRemoved = true; - cv.notify_one(); - })); - libjami::registerSignalHandlers(confHandlers); - requestReceived = false; + aliceAccount->addContact(bobUri); aliceAccount->sendTrustRequest(bobUri, {}); - CPPUNIT_ASSERT(cv.wait_for(lk, 10s, [&]() { return requestReceived; })); - requestReceived = false; + CPPUNIT_ASSERT(cv.wait_for(lk, 10s, [&]() { return bobData.requestReceived; })); aliceAccount->removeContact(bobUri, false); - CPPUNIT_ASSERT(cv.wait_for(lk, 10s, [&]() { return contactRemoved; })); + CPPUNIT_ASSERT(cv.wait_for(lk, 10s, [&]() { return aliceData.removed; })); // wait that connections are closed. std::this_thread::sleep_for(10s); + bobData.requestReceived = false; aliceAccount->addContact(bobUri); aliceAccount->sendTrustRequest(bobUri, {}); - CPPUNIT_ASSERT(cv.wait_for(lk, 10s, [&]() { return requestDeclined && requestReceived; })); + CPPUNIT_ASSERT(cv.wait_for(lk, 10s, [&]() { return bobData.requestRemoved && bobData.requestReceived; })); +} + +void +ConversationMembersEventTest::testBanFromNewDevice() +{ + connectSignals(); + + auto aliceAccount = Manager::instance().getAccount(aliceId); + auto bobAccount = Manager::instance().getAccount(bobId); + auto carlaAccount = Manager::instance().getAccount(carlaId); + auto aliceUri = aliceAccount->getUsername(); + auto bobUri = bobAccount->getUsername(); + auto carlaUri = carlaAccount->getUsername(); + + Manager::instance().sendRegister(carlaId, true); + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&] { return carlaData.deviceAnnounced; })); + + auto convId = libjami::startConversation(bobId); + + libjami::addConversationMember(bobId, convId, aliceUri); + libjami::addConversationMember(bobId, convId, carlaUri); + CPPUNIT_ASSERT(cv.wait_for(lk, 60s, [&] { return carlaData.requestReceived; })); + + libjami::acceptConversationRequest(carlaId, convId); + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return !carlaData.conversationId.empty(); })); + + Manager::instance().sendRegister(carlaId, false); + + // Bob creates a second device + auto bobArchive = std::filesystem::current_path().string() + "/bob.gz"; + std::remove(bobArchive.c_str()); + bobAccount->exportArchive(bobArchive); + std::map details = libjami::getAccountTemplate("RING"); + details[ConfProperties::TYPE] = "RING"; + details[ConfProperties::DISPLAYNAME] = "BOB2"; + details[ConfProperties::ALIAS] = "BOB2"; + details[ConfProperties::UPNP_ENABLED] = "true"; + details[ConfProperties::ARCHIVE_PASSWORD] = ""; + details[ConfProperties::ARCHIVE_PIN] = ""; + details[ConfProperties::ARCHIVE_PATH] = bobArchive; + bob2Id = Manager::instance().addAccount(details); + + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return bob2Data.deviceAnnounced; })); + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return !bob2Data.conversationId.empty(); })); + + + auto bobMsgSize = bobData.messages.size(); + libjami::removeConversationMember(bob2Id, convId, aliceUri); + CPPUNIT_ASSERT( + cv.wait_for(lk, 30s, [&]() { return bobData.messages.size() == bobMsgSize + 2 /* vote + ban */; })); + + Manager::instance().sendRegister(bob2Id, false); + auto carlaMsgSize = carlaData.messages.size(); + Manager::instance().sendRegister(carlaId, true); + // Should sync! + CPPUNIT_ASSERT( + cv.wait_for(lk, 30s, [&]() { return carlaData.messages.size() > carlaMsgSize; })); } } // namespace test diff --git a/test/unitTest/conversation/conversationRequest.cpp b/test/unitTest/conversation/conversationRequest.cpp index 646ddfc7a..4bb753fd8 100644 --- a/test/unitTest/conversation/conversationRequest.cpp +++ b/test/unitTest/conversation/conversationRequest.cpp @@ -46,6 +46,22 @@ using namespace libjami::Account; namespace jami { namespace test { +struct UserData { + std::string conversationId; + bool removed {false}; + bool requestReceived {false}; + bool requestRemoved {false}; + bool registered {false}; + bool stopped {false}; + bool deviceAnnounced {false}; + bool contactAdded {false}; + bool contactRemoved {false}; + std::string profilePath; + std::string payloadTrustRequest; + std::vector messages; + std::vector messagesUpdated; +}; + class ConversationRequestTest : public CppUnit::TestFixture { public: @@ -62,7 +78,6 @@ public: void testDeclineConversationRequestRemoveTrustRequest(); void testMalformedTrustRequest(); void testAddContactDeleteAndReAdd(); - void testInviteFromMessageAfterRemoved(); void testRemoveContact(); void testRemoveContactMultiDevice(); void testRemoveSelfDoesntRemoveConversation(); @@ -79,9 +94,19 @@ public: void testRemoveContactRemoveTrustRequest(); void testAddConversationNoPresenceThenConnects(); std::string aliceId; + UserData aliceData; std::string bobId; + UserData bobData; std::string bob2Id; + UserData bob2Data; std::string carlaId; + UserData carlaData; + + std::mutex mtx; + std::unique_lock lk {mtx}; + std::condition_variable cv; + + void connectSignals(); private: CPPUNIT_TEST_SUITE(ConversationRequestTest); @@ -93,7 +118,6 @@ private: CPPUNIT_TEST(testDeclineConversationRequestRemoveTrustRequest); CPPUNIT_TEST(testMalformedTrustRequest); CPPUNIT_TEST(testAddContactDeleteAndReAdd); - CPPUNIT_TEST(testInviteFromMessageAfterRemoved); CPPUNIT_TEST(testRemoveContact); CPPUNIT_TEST(testRemoveContactMultiDevice); CPPUNIT_TEST(testRemoveSelfDoesntRemoveConversation); @@ -127,10 +151,178 @@ ConversationRequestTest::setUp() aliceId = actors["alice"]; bobId = actors["bob"]; carlaId = actors["carla"]; + aliceData = {}; + bobData = {}; + bob2Data = {}; + carlaData = {}; Manager::instance().sendRegister(carlaId, false); wait_for_announcement_of({aliceId, bobId}); } +void +ConversationRequestTest::connectSignals() +{ + std::map> confHandlers; + confHandlers.insert( + libjami::exportable_callback( + [&](const std::string& accountId, const std::map&) { + if (accountId == aliceId) { + auto aliceAccount = Manager::instance().getAccount(aliceId); + auto details = aliceAccount->getVolatileAccountDetails(); + auto daemonStatus = details[libjami::Account::ConfProperties::Registration::STATUS]; + if (daemonStatus == "REGISTERED") { + aliceData.registered = true; + } else if (daemonStatus == "UNREGISTERED") { + aliceData.stopped = true; + } + auto deviceAnnounced = details[libjami::Account::VolatileProperties::DEVICE_ANNOUNCED]; + aliceData.deviceAnnounced = deviceAnnounced == "true"; + } else if (accountId == bobId) { + auto bobAccount = Manager::instance().getAccount(bobId); + auto details = bobAccount->getVolatileAccountDetails(); + auto daemonStatus = details[libjami::Account::ConfProperties::Registration::STATUS]; + if (daemonStatus == "REGISTERED") { + bobData.registered = true; + } else if (daemonStatus == "UNREGISTERED") { + bobData.stopped = true; + } + auto deviceAnnounced = details[libjami::Account::VolatileProperties::DEVICE_ANNOUNCED]; + bobData.deviceAnnounced = deviceAnnounced == "true"; + } else if (accountId == bob2Id) { + auto bob2Account = Manager::instance().getAccount(bob2Id); + auto details = bob2Account->getVolatileAccountDetails(); + auto daemonStatus = details[libjami::Account::ConfProperties::Registration::STATUS]; + if (daemonStatus == "REGISTERED") { + bob2Data.registered = true; + } else if (daemonStatus == "UNREGISTERED") { + bob2Data.stopped = true; + } + auto deviceAnnounced = details[libjami::Account::VolatileProperties::DEVICE_ANNOUNCED]; + bob2Data.deviceAnnounced = deviceAnnounced == "true"; + } else if (accountId == carlaId) { + auto carlaAccount = Manager::instance().getAccount(carlaId); + auto details = carlaAccount->getVolatileAccountDetails(); + auto daemonStatus = details[libjami::Account::ConfProperties::Registration::STATUS]; + if (daemonStatus == "REGISTERED") { + carlaData.registered = true; + } else if (daemonStatus == "UNREGISTERED") { + carlaData.stopped = true; + } + auto deviceAnnounced = details[libjami::Account::VolatileProperties::DEVICE_ANNOUNCED]; + carlaData.deviceAnnounced = deviceAnnounced == "true"; + } + cv.notify_one(); + })); + confHandlers.insert(libjami::exportable_callback( + [&](const std::string& accountId, const std::string& conversationId) { + if (accountId == aliceId) { + aliceData.conversationId = conversationId; + } else if (accountId == bobId) { + bobData.conversationId = conversationId; + } else if (accountId == bob2Id) { + bob2Data.conversationId = conversationId; + } else if (accountId == carlaId) { + carlaData.conversationId = conversationId; + } + cv.notify_one(); + })); + confHandlers.insert( + libjami::exportable_callback( + [&](const std::string& account_id, + const std::string& /*from*/, + const std::string& /*conversationId*/, + const std::vector& payload, + time_t /*received*/) { + auto payloadStr = std::string(payload.data(), payload.data() + payload.size()); + if (account_id == aliceId) + aliceData.payloadTrustRequest = payloadStr; + else if (account_id == bobId) + bobData.payloadTrustRequest = payloadStr; + cv.notify_one(); + })); + confHandlers.insert( + libjami::exportable_callback( + [&](const std::string& accountId, + const std::string& /* conversationId */, + std::map /*metadatas*/) { + if (accountId == aliceId) { + aliceData.requestReceived = true; + } else if (accountId == bobId) { + bobData.requestReceived = true; + } else if (accountId == bob2Id) { + bob2Data.requestReceived = true; + } else if (accountId == carlaId) { + carlaData.requestReceived = true; + } + cv.notify_one(); + })); + confHandlers.insert( + libjami::exportable_callback( + [&](const std::string& accountId, const std::string&) { + if (accountId == bobId) { + bobData.requestRemoved = true; + } else if (accountId == bob2Id) { + bob2Data.requestRemoved = true; + } + cv.notify_one(); + })); + confHandlers.insert(libjami::exportable_callback( + [&](const std::string& accountId, + const std::string& /* conversationId */, + libjami::SwarmMessage message) { + if (accountId == aliceId) { + aliceData.messages.emplace_back(message); + } else if (accountId == bobId) { + bobData.messages.emplace_back(message); + } else if (accountId == carlaId) { + carlaData.messages.emplace_back(message); + } + cv.notify_one(); + })); + confHandlers.insert(libjami::exportable_callback( + [&](const std::string& accountId, + const std::string& /* conversationId */, + libjami::SwarmMessage message) { + if (accountId == aliceId) { + aliceData.messagesUpdated.emplace_back(message); + } else if (accountId == bobId) { + bobData.messagesUpdated.emplace_back(message); + } else if (accountId == carlaId) { + carlaData.messagesUpdated.emplace_back(message); + } + cv.notify_one(); + })); + confHandlers.insert( + libjami::exportable_callback( + [&](const std::string& accountId, const std::string&) { + if (accountId == aliceId) + aliceData.removed = true; + else if (accountId == bobId) + bobData.removed = true; + else if (accountId == bob2Id) + bob2Data.removed = true; + cv.notify_one(); + })); + confHandlers.insert(libjami::exportable_callback( + [&](const std::string& accountId, const std::string&, bool) { + if (accountId == bobId) { + bobData.contactAdded = true; + } + cv.notify_one(); + })); + confHandlers.insert(libjami::exportable_callback( + [&](const std::string& accountId, const std::string&, bool) { + if (accountId == bobId) { + bobData.contactRemoved = true; + } else if (accountId == bob2Id) { + bob2Data.contactRemoved = true; + } + cv.notify_one(); + })); + + libjami::registerSignalHandlers(confHandlers); +} + void ConversationRequestTest::tearDown() @@ -148,224 +340,109 @@ ConversationRequestTest::tearDown() void ConversationRequestTest::testAcceptTrustRemoveConvReq() { + connectSignals(); auto aliceAccount = Manager::instance().getAccount(aliceId); auto bobAccount = Manager::instance().getAccount(bobId); auto bobUri = bobAccount->getUsername(); - auto aliceUri = aliceAccount->getUsername(); - std::mutex mtx; - std::unique_lock lk {mtx}; - std::condition_variable cv; - std::map> confHandlers; - bool conversationReady = false, requestReceived = false; - std::string convId = ""; - confHandlers.insert( - libjami::exportable_callback( - [&](const std::string& /*accountId*/, - const std::string& /* conversationId */, - std::map /*metadatas*/) { - requestReceived = true; - cv.notify_one(); - })); - confHandlers.insert(libjami::exportable_callback( - [&](const std::string& accountId, const std::string& conversationId) { - if (accountId == aliceId) { - convId = conversationId; - } else if (accountId == bobId) { - conversationReady = true; - } - cv.notify_one(); - })); - libjami::registerSignalHandlers(confHandlers); + aliceAccount->addContact(bobUri); aliceAccount->sendTrustRequest(bobUri, {}); - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return requestReceived; })); + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return bobData.requestReceived; })); CPPUNIT_ASSERT(bobAccount->getTrustRequests().size() == 1); - libjami::acceptConversationRequest(bobId, convId); - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return conversationReady; })); + libjami::acceptConversationRequest(bobId, aliceData.conversationId); + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return !bobData.conversationId.empty(); })); CPPUNIT_ASSERT(bobAccount->getTrustRequests().size() == 0); } void ConversationRequestTest::acceptConvReqAlsoAddContact() { + connectSignals(); auto aliceAccount = Manager::instance().getAccount(aliceId); auto bobAccount = Manager::instance().getAccount(bobId); auto bobUri = bobAccount->getUsername(); - auto aliceUri = aliceAccount->getUsername(); - std::mutex mtx; - std::unique_lock lk {mtx}; - std::condition_variable cv; - std::map> confHandlers; - bool requestReceived = false, memberMessageGenerated = false; - int conversationReady = 0; - std::string convId = ""; - confHandlers.insert( - libjami::exportable_callback( - [&](const std::string& /*accountId*/, - const std::string& /* conversationId */, - std::map /*metadatas*/) { - requestReceived = true; - cv.notify_one(); - })); - confHandlers.insert(libjami::exportable_callback( - [&](const std::string& accountId, const std::string& conversationId) { - if (accountId == aliceId) { - convId = conversationId; - } else if (accountId == bobId) { - conversationReady += 1; - } - cv.notify_one(); - })); - confHandlers.insert(libjami::exportable_callback( - [&](const std::string& accountId, - const std::string& conversationId, - std::map message) { - if (accountId == aliceId && conversationId == convId && message["type"] == "member") { - memberMessageGenerated = true; - cv.notify_one(); - } - })); - libjami::registerSignalHandlers(confHandlers); + aliceAccount->addContact(bobUri); aliceAccount->sendTrustRequest(bobUri, {}); - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return requestReceived; })); + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return bobData.requestReceived; })); + bobData.requestReceived = false; auto convId2 = libjami::startConversation(aliceId); - requestReceived = false; libjami::addConversationMember(aliceId, convId2, bobUri); - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return requestReceived; })); + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return bobData.requestReceived; })); libjami::acceptConversationRequest(bobId, convId2); - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return conversationReady == 2; })); + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return !bobData.conversationId.empty(); })); + std::this_thread::sleep_for(5s); CPPUNIT_ASSERT(bobAccount->getTrustRequests().size() == 0); } void ConversationRequestTest::testGetRequests() { - auto aliceAccount = Manager::instance().getAccount(aliceId); + connectSignals(); + auto bobAccount = Manager::instance().getAccount(bobId); auto bobUri = bobAccount->getUsername(); - std::mutex mtx; - std::unique_lock lk {mtx}; - std::condition_variable cv; - std::map> confHandlers; - bool requestReceived = false; - confHandlers.insert( - libjami::exportable_callback( - [&](const std::string& /*accountId*/, - const std::string& /* conversationId */, - std::map /*metadatas*/) { - requestReceived = true; - cv.notify_one(); - })); - libjami::registerSignalHandlers(confHandlers); auto convId = libjami::startConversation(aliceId); libjami::addConversationMember(aliceId, convId, bobUri); - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return requestReceived; })); + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return bobData.requestReceived; })); auto requests = libjami::getConversationRequests(bobId); CPPUNIT_ASSERT(requests.size() == 1); CPPUNIT_ASSERT(requests.front()["id"] == convId); - libjami::unregisterSignalHandlers(); } void ConversationRequestTest::testDeclineRequest() { + connectSignals(); + auto aliceAccount = Manager::instance().getAccount(aliceId); auto bobAccount = Manager::instance().getAccount(bobId); auto bobUri = bobAccount->getUsername(); - std::mutex mtx; - std::unique_lock lk {mtx}; - std::condition_variable cv; - std::map> confHandlers; - bool requestReceived = false; - confHandlers.insert( - libjami::exportable_callback( - [&](const std::string& /*accountId*/, - const std::string& /* conversationId */, - std::map /*metadatas*/) { - requestReceived = true; - cv.notify_one(); - })); - libjami::registerSignalHandlers(confHandlers); - auto convId = libjami::startConversation(aliceId); libjami::addConversationMember(aliceId, convId, bobUri); - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return requestReceived; })); + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return bobData.requestReceived; })); libjami::declineConversationRequest(bobId, convId); // Decline request auto requests = libjami::getConversationRequests(bobId); CPPUNIT_ASSERT(requests.size() == 0); - libjami::unregisterSignalHandlers(); } void ConversationRequestTest::testAddContact() { + connectSignals(); + auto aliceAccount = Manager::instance().getAccount(aliceId); auto bobAccount = Manager::instance().getAccount(bobId); auto bobUri = bobAccount->getUsername(); auto aliceUri = aliceAccount->getUsername(); - std::mutex mtx; - std::unique_lock lk {mtx}; - std::condition_variable cv; - std::map> confHandlers; - bool conversationReady = false, requestReceived = false, memberMessageGenerated = false; - std::string convId = ""; - confHandlers.insert( - libjami::exportable_callback( - [&](const std::string& account_id, - const std::string& /*from*/, - const std::string& /*conversationId*/, - const std::vector& /*payload*/, - time_t /*received*/) { - if (account_id == bobId) - requestReceived = true; - cv.notify_one(); - })); - confHandlers.insert(libjami::exportable_callback( - [&](const std::string& accountId, const std::string& conversationId) { - if (accountId == aliceId) { - convId = conversationId; - } else if (accountId == bobId) { - conversationReady = true; - } - cv.notify_one(); - })); - confHandlers.insert(libjami::exportable_callback( - [&](const std::string& accountId, - const std::string& conversationId, - std::map message) { - if (accountId == aliceId && conversationId == convId && message["type"] == "member") { - memberMessageGenerated = true; - cv.notify_one(); - } - })); - libjami::registerSignalHandlers(confHandlers); + aliceAccount->addContact(bobUri); aliceAccount->sendTrustRequest(bobUri, {}); - CPPUNIT_ASSERT(cv.wait_for(lk, 5s, [&]() { return !convId.empty(); })); - ConversationRepository repo(aliceAccount, convId); + CPPUNIT_ASSERT(cv.wait_for(lk, 5s, [&]() { return !aliceData.conversationId.empty(); })); + ConversationRepository repo(aliceAccount, aliceData.conversationId); // Mode must be one to one CPPUNIT_ASSERT(repo.mode() == ConversationMode::ONE_TO_ONE); // Assert that repository exists - auto repoPath = fileutils::get_data_dir() / aliceAccount->getAccountID() - / "conversations" / convId; + auto repoPath = fileutils::get_data_dir() / aliceId + / "conversations" / aliceData.conversationId; CPPUNIT_ASSERT(std::filesystem::is_directory(repoPath)); - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return requestReceived; })); + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return bobData.requestReceived; })); + auto aliceMsgSize = aliceData.messages.size(); CPPUNIT_ASSERT(bobAccount->acceptTrustRequest(aliceUri)); CPPUNIT_ASSERT( - cv.wait_for(lk, 30s, [&]() { return conversationReady && memberMessageGenerated; })); - auto clonedPath = fileutils::get_data_dir() / bobAccount->getAccountID() - / "conversations" / convId; + cv.wait_for(lk, 30s, [&]() { return !bobData.conversationId.empty() && aliceMsgSize + 1 == aliceData.messages.size(); })); + auto clonedPath = fileutils::get_data_dir() / bobId + / "conversations" / aliceData.conversationId; CPPUNIT_ASSERT(std::filesystem::is_directory(clonedPath)); auto bobMember = clonedPath / "members" / (bobUri + ".crt"); CPPUNIT_ASSERT(std::filesystem::is_regular_file(bobMember)); @@ -374,56 +451,22 @@ ConversationRequestTest::testAddContact() void ConversationRequestTest::testDeclineConversationRequestRemoveTrustRequest() { + connectSignals(); + auto aliceAccount = Manager::instance().getAccount(aliceId); auto bobAccount = Manager::instance().getAccount(bobId); auto bobUri = bobAccount->getUsername(); - auto aliceUri = aliceAccount->getUsername(); - std::mutex mtx; - std::unique_lock lk {mtx}; - std::condition_variable cv; - std::map> confHandlers; - bool conversationReady = false, requestReceived = false, memberMessageGenerated = false; - std::string convId = ""; - confHandlers.insert( - libjami::exportable_callback( - [&](const std::string& account_id, - const std::string& /*from*/, - const std::string& /*conversationId*/, - const std::vector& /*payload*/, - time_t /*received*/) { - if (account_id == bobId) - requestReceived = true; - cv.notify_one(); - })); - confHandlers.insert(libjami::exportable_callback( - [&](const std::string& accountId, const std::string& conversationId) { - if (accountId == aliceId) { - convId = conversationId; - } else if (accountId == bobId) { - conversationReady = true; - } - cv.notify_one(); - })); - confHandlers.insert(libjami::exportable_callback( - [&](const std::string& accountId, - const std::string& conversationId, - std::map message) { - if (accountId == aliceId && conversationId == convId && message["type"] == "member") { - memberMessageGenerated = true; - cv.notify_one(); - } - })); - libjami::registerSignalHandlers(confHandlers); + aliceAccount->addContact(bobUri); aliceAccount->sendTrustRequest(bobUri, {}); - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return !convId.empty() && requestReceived; })); + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return bobData.requestReceived; })); // Decline request auto requests = libjami::getConversationRequests(bobId); CPPUNIT_ASSERT(requests.size() == 1); auto trustRequests = libjami::getTrustRequests(bobId); CPPUNIT_ASSERT(trustRequests.size() == 1); - libjami::declineConversationRequest(bobId, convId); + libjami::declineConversationRequest(bobId, aliceData.conversationId); requests = libjami::getConversationRequests(bobId); CPPUNIT_ASSERT(requests.size() == 0); trustRequests = libjami::getTrustRequests(bobId); @@ -433,51 +476,15 @@ ConversationRequestTest::testDeclineConversationRequestRemoveTrustRequest() void ConversationRequestTest::testMalformedTrustRequest() { + connectSignals(); + auto aliceAccount = Manager::instance().getAccount(aliceId); auto bobAccount = Manager::instance().getAccount(bobId); auto bobUri = bobAccount->getUsername(); - auto aliceUri = aliceAccount->getUsername(); - std::mutex mtx; - std::unique_lock lk {mtx}; - std::condition_variable cv; - std::map> confHandlers; - bool conversationReady = false, requestReceived = false, memberMessageGenerated = false, - requestDeclined = false; - std::string convId = ""; - confHandlers.insert( - libjami::exportable_callback( - [&](const std::string& account_id, - const std::string& /*from*/, - const std::string& /*conversationId*/, - const std::vector& /*payload*/, - time_t /*received*/) { - if (account_id == bobId) - requestReceived = true; - cv.notify_one(); - })); - confHandlers.insert(libjami::exportable_callback( - [&](const std::string& accountId, const std::string& conversationId) { - if (accountId == aliceId) { - convId = conversationId; - } else if (accountId == bobId) { - conversationReady = true; - } - cv.notify_one(); - })); - confHandlers.insert(libjami::exportable_callback( - [&](const std::string& accountId, - const std::string& conversationId, - std::map message) { - if (accountId == aliceId && conversationId == convId && message["type"] == "member") { - memberMessageGenerated = true; - cv.notify_one(); - } - })); - libjami::registerSignalHandlers(confHandlers); aliceAccount->addContact(bobUri); aliceAccount->sendTrustRequest(bobUri, {}); - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return !convId.empty() && requestReceived; })); + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return bobData.requestReceived; })); // Decline request auto requests = libjami::getConversationRequests(bobId); @@ -485,7 +492,7 @@ ConversationRequestTest::testMalformedTrustRequest() auto trustRequests = libjami::getTrustRequests(bobId); CPPUNIT_ASSERT(trustRequests.size() == 1); // This will let the trust request (not libjami::declineConversationRequest) - bobAccount->convModule()->declineConversationRequest(convId); + bobAccount->convModule()->declineConversationRequest(aliceData.conversationId); requests = libjami::getConversationRequests(bobId); CPPUNIT_ASSERT(requests.size() == 0); trustRequests = libjami::getTrustRequests(bobId); @@ -497,6 +504,7 @@ ConversationRequestTest::testMalformedTrustRequest() auto start = std::chrono::steady_clock::now(); + auto requestDeclined = false; do { trustRequests = libjami::getTrustRequests(bobId); requestDeclined = trustRequests.size() == 0; @@ -510,227 +518,83 @@ ConversationRequestTest::testMalformedTrustRequest() void ConversationRequestTest::testAddContactDeleteAndReAdd() { + connectSignals(); + auto aliceAccount = Manager::instance().getAccount(aliceId); auto bobAccount = Manager::instance().getAccount(bobId); auto bobUri = bobAccount->getUsername(); auto aliceUri = aliceAccount->getUsername(); - std::mutex mtx; - std::unique_lock lk {mtx}; - std::condition_variable cv; - std::map> confHandlers; - bool conversationReady = false, requestReceived = false, memberMessageGenerated = false; - std::string convId = ""; - confHandlers.insert( - libjami::exportable_callback( - [&](const std::string& account_id, - const std::string& /*from*/, - const std::string& /*conversationId*/, - const std::vector& /*payload*/, - time_t /*received*/) { - if (account_id == bobId) - requestReceived = true; - cv.notify_one(); - })); - confHandlers.insert(libjami::exportable_callback( - [&](const std::string& accountId, const std::string& conversationId) { - if (accountId == aliceId) { - convId = conversationId; - } else if (accountId == bobId) { - conversationReady = true; - } - cv.notify_one(); - })); - confHandlers.insert(libjami::exportable_callback( - [&](const std::string& accountId, - const std::string& conversationId, - std::map message) { - if (accountId == aliceId && conversationId == convId && message["type"] == "member") { - memberMessageGenerated = true; - cv.notify_one(); - } - })); - libjami::registerSignalHandlers(confHandlers); - requestReceived = false; + aliceAccount->addContact(bobUri); aliceAccount->sendTrustRequest(bobUri, {}); - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return requestReceived; })); + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return bobData.requestReceived; })); + auto aliceMsgSize = aliceData.messages.size(); CPPUNIT_ASSERT(bobAccount->acceptTrustRequest(aliceUri)); CPPUNIT_ASSERT( - cv.wait_for(lk, 30s, [&]() { return conversationReady && memberMessageGenerated; })); + cv.wait_for(lk, 30s, [&]() { return !bobData.conversationId.empty() && aliceMsgSize + 1 == aliceData.messages.size(); })); // removeContact aliceAccount->removeContact(bobUri, false); std::this_thread::sleep_for(5s); // wait a bit that connections are closed // re-add - CPPUNIT_ASSERT(convId != ""); - auto oldConvId = convId; - convId = ""; + CPPUNIT_ASSERT(aliceData.conversationId != ""); + auto oldConvId = aliceData.conversationId; aliceAccount->addContact(bobUri); aliceAccount->sendTrustRequest(bobUri, {}); // Should retrieve previous conversation - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return oldConvId == convId; })); -} - -void -ConversationRequestTest::testInviteFromMessageAfterRemoved() -{ - auto aliceAccount = Manager::instance().getAccount(aliceId); - auto bobAccount = Manager::instance().getAccount(bobId); - auto bobUri = bobAccount->getUsername(); - auto aliceUri = aliceAccount->getUsername(); - std::mutex mtx; - std::unique_lock lk {mtx}; - std::condition_variable cv; - std::map> confHandlers; - bool conversationReady = false, requestReceived = false, memberMessageGenerated = false; - std::string convId = ""; - confHandlers.insert( - libjami::exportable_callback( - [&](const std::string& accountId, - const std::string&, - std::map /*metadatas*/) { - if (accountId == bobId) - requestReceived = true; - cv.notify_one(); - })); - confHandlers.insert(libjami::exportable_callback( - [&](const std::string& accountId, const std::string& conversationId) { - if (accountId == aliceId) { - convId = conversationId; - } else if (accountId == bobId) { - conversationReady = true; - } - cv.notify_one(); - })); - confHandlers.insert(libjami::exportable_callback( - [&](const std::string& accountId, - const std::string& conversationId, - std::map message) { - if (accountId == aliceId && conversationId == convId && message["type"] == "member") { - memberMessageGenerated = true; - cv.notify_one(); - } - })); - libjami::registerSignalHandlers(confHandlers); - requestReceived = false; - aliceAccount->addContact(bobUri); - aliceAccount->sendTrustRequest(bobUri, {}); - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return requestReceived; })); - CPPUNIT_ASSERT(bobAccount->acceptTrustRequest(aliceUri)); - CPPUNIT_ASSERT( - cv.wait_for(lk, 30s, [&]() { return conversationReady && memberMessageGenerated; })); - - // removeContact - bobAccount->removeContact(aliceUri, false); - std::this_thread::sleep_for(10s); // wait a bit that connections are closed - - // bob sends a message, this should generate a new request for Alice - requestReceived = false; - libjami::sendMessage(aliceId, convId, "hi"s, ""); - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return requestReceived; })); - conversationReady = false; - CPPUNIT_ASSERT(bobAccount->getContacts().size() == 0); - libjami::acceptConversationRequest(bobId, convId); - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return conversationReady; })); - CPPUNIT_ASSERT(bobAccount->getContacts().size() == 1); + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return oldConvId == aliceData.conversationId; })); } void ConversationRequestTest::testRemoveContact() { + connectSignals(); + auto aliceAccount = Manager::instance().getAccount(aliceId); auto bobAccount = Manager::instance().getAccount(bobId); auto bobUri = bobAccount->getUsername(); auto aliceUri = aliceAccount->getUsername(); - std::mutex mtx; - std::unique_lock lk {mtx}; - std::condition_variable cv; - std::map> confHandlers; - bool conversationReady = false, requestReceived = false, memberMessageGenerated = false; - std::string convId = ""; - confHandlers.insert( - libjami::exportable_callback( - [&](const std::string& account_id, - const std::string& /*from*/, - const std::string& /*conversationId*/, - const std::vector& /*payload*/, - time_t /*received*/) { - if (account_id == bobId) - requestReceived = true; - cv.notify_one(); - })); - confHandlers.insert(libjami::exportable_callback( - [&](const std::string& accountId, const std::string& conversationId) { - if (accountId == aliceId) { - convId = conversationId; - } else if (accountId == bobId) { - conversationReady = true; - } - cv.notify_one(); - })); - bool conversationRemovedAlice = false, conversationRemovedBob = false; - confHandlers.insert( - libjami::exportable_callback( - [&](const std::string& accountId, const std::string&) { - if (accountId == aliceId) - conversationRemovedAlice = true; - else if (accountId == bobId) - conversationRemovedBob = true; - cv.notify_one(); - })); - confHandlers.insert(libjami::exportable_callback( - [&](const std::string& accountId, - const std::string& conversationId, - std::map message) { - if (accountId == aliceId && conversationId == convId && message["type"] == "member") { - memberMessageGenerated = true; - } - cv.notify_one(); - })); - libjami::registerSignalHandlers(confHandlers); + aliceAccount->addContact(bobUri); aliceAccount->sendTrustRequest(bobUri, {}); // Check created files - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return !convId.empty() && requestReceived; })); - memberMessageGenerated = false; + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return bobData.requestReceived; })); + auto aliceMsgSize = aliceData.messages.size(); CPPUNIT_ASSERT(bobAccount->acceptTrustRequest(aliceUri)); CPPUNIT_ASSERT( - cv.wait_for(lk, 30s, [&]() { return conversationReady && memberMessageGenerated; })); + cv.wait_for(lk, 30s, [&]() { return aliceMsgSize + 1 == aliceData.messages.size(); })); - conversationRemovedBob = false; bobAccount->removeContact(aliceUri, false); - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return conversationRemovedBob; })); + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return bobData.removed; })); auto details = bobAccount->getContactDetails(aliceUri); - CPPUNIT_ASSERT(details.size() == 0); + CPPUNIT_ASSERT(details.find("removed") != details.end() && details["removed"] != "0"); - conversationRemovedAlice = false; aliceAccount->removeContact(bobUri, false); - CPPUNIT_ASSERT(cv.wait_for(lk, 20s, [&]() { return conversationRemovedAlice; })); + CPPUNIT_ASSERT(cv.wait_for(lk, 20s, [&]() { return aliceData.removed; })); std::this_thread::sleep_for( 10s); // There is no signal, but daemon should then erase the repository - auto repoPath = fileutils::get_data_dir() / aliceAccount->getAccountID() - / "conversations" / convId; + auto repoPath = fileutils::get_data_dir() / aliceId + / "conversations" / aliceData.conversationId; CPPUNIT_ASSERT(!std::filesystem::is_directory(repoPath)); - repoPath = fileutils::get_data_dir() / bobAccount->getAccountID() - / "conversations" / convId; + repoPath = fileutils::get_data_dir() / bobId + / "conversations" / bobData.conversationId; CPPUNIT_ASSERT(!std::filesystem::is_directory(repoPath)); } void ConversationRequestTest::testRemoveContactMultiDevice() { + connectSignals(); + auto aliceAccount = Manager::instance().getAccount(aliceId); auto bobAccount = Manager::instance().getAccount(bobId); auto bobUri = bobAccount->getUsername(); auto aliceUri = aliceAccount->getUsername(); - std::mutex mtx; - std::unique_lock lk {mtx}; - std::condition_variable cv; // Add second device for Bob std::map> confHandlers; @@ -749,179 +613,69 @@ ConversationRequestTest::testRemoveContactMultiDevice() bob2Id = Manager::instance().addAccount(details); - wait_for_announcement_of(bob2Id); - auto bob2Account = Manager::instance().getAccount(bob2Id); - - bool requestB1Removed = false, requestB2Removed = false, requestB1Received = false, requestB2Received = false; - confHandlers.insert( - libjami::exportable_callback( - [&](const std::string& account_id, - const std::string& /*from*/, - const std::string& /*conversationId*/, - const std::vector& /*payload*/, - time_t /*received*/) { - if (account_id == bobId) - requestB1Received = true; - else if (account_id == bob2Id) - requestB2Received = true; - cv.notify_one(); - })); - confHandlers.insert( - libjami::exportable_callback( - [&](const std::string& accountId, const std::string&) { - if (accountId == bobId) { - requestB1Removed = true; - } else if (accountId == bob2Id) { - requestB2Removed = true; - } - cv.notify_one(); - })); - libjami::registerSignalHandlers(confHandlers); - + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { + return bob2Data.deviceAnnounced; + })); // First, Alice adds Bob aliceAccount->addContact(bobUri); aliceAccount->sendTrustRequest(bobUri, {}); CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { - return requestB1Received && requestB2Received; + return bobData.requestReceived && bob2Data.requestReceived; })); // Bob1 decline via removeContact, both device should remove the request bobAccount->removeContact(aliceUri, false); CPPUNIT_ASSERT( - cv.wait_for(lk, 30s, [&]() { return requestB1Removed && requestB2Removed; })); + cv.wait_for(lk, 30s, [&]() { return bobData.requestRemoved && bob2Data.requestRemoved; })); } void ConversationRequestTest::testRemoveSelfDoesntRemoveConversation() { + connectSignals(); + auto aliceAccount = Manager::instance().getAccount(aliceId); auto bobAccount = Manager::instance().getAccount(bobId); auto bobUri = bobAccount->getUsername(); auto aliceUri = aliceAccount->getUsername(); - std::mutex mtx; - std::unique_lock lk {mtx}; - std::condition_variable cv; - std::map> confHandlers; - bool conversationReady = false, requestReceived = false, memberMessageGenerated = false, - conversationRemoved = false; - std::string convId = ""; - confHandlers.insert( - libjami::exportable_callback( - [&](const std::string& account_id, - const std::string& /*from*/, - const std::string& /*conversationId*/, - const std::vector& /*payload*/, - time_t /*received*/) { - if (account_id == bobId) - requestReceived = true; - cv.notify_one(); - })); - confHandlers.insert(libjami::exportable_callback( - [&](const std::string& accountId, const std::string& conversationId) { - if (accountId == aliceId) { - convId = conversationId; - } else if (accountId == bobId) { - conversationReady = true; - } - cv.notify_one(); - })); - confHandlers.insert( - libjami::exportable_callback( - [&](const std::string& accountId, const std::string&) { - if (accountId == bobId) - conversationRemoved = true; - cv.notify_one(); - })); - confHandlers.insert(libjami::exportable_callback( - [&](const std::string& accountId, - const std::string& conversationId, - std::map message) { - if (accountId == aliceId && conversationId == convId && message["type"] == "member") { - memberMessageGenerated = true; - } - cv.notify_one(); - })); - libjami::registerSignalHandlers(confHandlers); + aliceAccount->addContact(bobUri); aliceAccount->sendTrustRequest(bobUri, {}); // Check created files - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return !convId.empty() && requestReceived; })); - memberMessageGenerated = false; + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return bobData.requestReceived; })); + auto aliceMsgSize = aliceData.messages.size(); CPPUNIT_ASSERT(bobAccount->acceptTrustRequest(aliceUri)); CPPUNIT_ASSERT( - cv.wait_for(lk, 30s, [&]() { return conversationReady && memberMessageGenerated; })); + cv.wait_for(lk, 30s, [&]() { return aliceMsgSize + 1 == aliceData.messages.size(); })); - conversationRemoved = false; aliceAccount->removeContact(aliceUri, false); - CPPUNIT_ASSERT(!cv.wait_for(lk, 10s, [&]() { return conversationRemoved; })); - auto repoPath = fileutils::get_data_dir() / aliceAccount->getAccountID() - / "conversations" / convId; + CPPUNIT_ASSERT(!cv.wait_for(lk, 10s, [&]() { return aliceData.removed; })); + auto repoPath = fileutils::get_data_dir() / aliceId + / "conversations" / aliceData.conversationId; CPPUNIT_ASSERT(std::filesystem::is_directory(repoPath)); } void ConversationRequestTest::testRemoveConversationUpdateContactDetails() { + connectSignals(); + auto aliceAccount = Manager::instance().getAccount(aliceId); auto bobAccount = Manager::instance().getAccount(bobId); auto bobUri = bobAccount->getUsername(); auto aliceUri = aliceAccount->getUsername(); - std::mutex mtx; - std::unique_lock lk {mtx}; - std::condition_variable cv; - std::map> confHandlers; - bool conversationReady = false, requestReceived = false, memberMessageGenerated = false, - conversationRemoved = false; - std::string convId = ""; - confHandlers.insert( - libjami::exportable_callback( - [&](const std::string& account_id, - const std::string& /*from*/, - const std::string& /*conversationId*/, - const std::vector& /*payload*/, - time_t /*received*/) { - if (account_id == bobId) - requestReceived = true; - cv.notify_one(); - })); - confHandlers.insert(libjami::exportable_callback( - [&](const std::string& accountId, const std::string& conversationId) { - if (accountId == aliceId) { - convId = conversationId; - } else if (accountId == bobId) { - conversationReady = true; - } - cv.notify_one(); - })); - confHandlers.insert( - libjami::exportable_callback( - [&](const std::string& accountId, const std::string&) { - if (accountId == bobId) - conversationRemoved = true; - cv.notify_one(); - })); - confHandlers.insert(libjami::exportable_callback( - [&](const std::string& accountId, - const std::string& conversationId, - std::map message) { - if (accountId == aliceId && conversationId == convId && message["type"] == "member") { - memberMessageGenerated = true; - } - cv.notify_one(); - })); - libjami::registerSignalHandlers(confHandlers); + aliceAccount->addContact(bobUri); aliceAccount->sendTrustRequest(bobUri, {}); // Check created files - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return !convId.empty() && requestReceived; })); - memberMessageGenerated = false; + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return bobData.requestReceived; })); + auto aliceMsgSize = aliceData.messages.size(); CPPUNIT_ASSERT(bobAccount->acceptTrustRequest(aliceUri)); CPPUNIT_ASSERT( - cv.wait_for(lk, 30s, [&]() { return conversationReady && memberMessageGenerated; })); + cv.wait_for(lk, 30s, [&]() { return aliceMsgSize + 1 == aliceData.messages.size(); })); - conversationRemoved = false; - libjami::removeConversation(bobId, convId); - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return conversationRemoved; })); + libjami::removeConversation(bobId, bobData.conversationId); + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return bobData.removed; })); auto details = bobAccount->getContactDetails(aliceUri); CPPUNIT_ASSERT(details[libjami::Account::TrustRequest::CONVERSATIONID] == ""); @@ -930,61 +684,25 @@ ConversationRequestTest::testRemoveConversationUpdateContactDetails() void ConversationRequestTest::testBanContact() { + connectSignals(); + auto aliceAccount = Manager::instance().getAccount(aliceId); auto bobAccount = Manager::instance().getAccount(bobId); auto bobUri = bobAccount->getUsername(); auto aliceUri = aliceAccount->getUsername(); - std::mutex mtx; - std::unique_lock lk {mtx}; - std::condition_variable cv; - std::map> confHandlers; - bool conversationReady = false, requestReceived = false, memberMessageGenerated = false; - std::string convId = ""; - confHandlers.insert( - libjami::exportable_callback( - [&](const std::string& account_id, - const std::string& /*from*/, - const std::string& /*conversationId*/, - const std::vector& /*payload*/, - time_t /*received*/) { - if (account_id == bobId) - requestReceived = true; - cv.notify_one(); - })); - confHandlers.insert(libjami::exportable_callback( - [&](const std::string& accountId, const std::string& conversationId) { - if (accountId == aliceId) { - convId = conversationId; - } else if (accountId == bobId) { - conversationReady = true; - } - cv.notify_one(); - })); - confHandlers.insert(libjami::exportable_callback( - [&](const std::string& accountId, - const std::string& conversationId, - std::map message) { - if (accountId == aliceId && conversationId == convId && message["type"] == "member") { - memberMessageGenerated = true; - } - cv.notify_one(); - })); - libjami::registerSignalHandlers(confHandlers); + aliceAccount->addContact(bobUri); aliceAccount->sendTrustRequest(bobUri, {}); - CPPUNIT_ASSERT(cv.wait_for(lk, 5s, [&]() { return !convId.empty(); })); // Check created files - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return requestReceived; })); - memberMessageGenerated = false; + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return bobData.requestReceived; })); + auto aliceMsgSize = aliceData.messages.size(); CPPUNIT_ASSERT(bobAccount->acceptTrustRequest(aliceUri)); - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return conversationReady; })); - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return memberMessageGenerated; })); + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return aliceMsgSize + 1 == aliceData.messages.size(); })); - memberMessageGenerated = false; bobAccount->removeContact(aliceUri, true); - CPPUNIT_ASSERT(!cv.wait_for(lk, 30s, [&]() { return memberMessageGenerated; })); - auto repoPath = fileutils::get_data_dir() / bobAccount->getAccountID() - / "conversations" / convId; + CPPUNIT_ASSERT(!cv.wait_for(lk, 30s, [&]() { return aliceMsgSize + 2 == aliceData.messages.size(); })); + auto repoPath = fileutils::get_data_dir() / bobId + / "conversations" / bobData.conversationId; CPPUNIT_ASSERT(std::filesystem::is_directory(repoPath)); } @@ -1088,50 +806,19 @@ ConversationRequestTest::testBanContactRestartAccount() void ConversationRequestTest::testBanContactRemoveTrustRequest() { + connectSignals(); + auto aliceAccount = Manager::instance().getAccount(aliceId); auto bobAccount = Manager::instance().getAccount(bobId); auto bobUri = bobAccount->getUsername(); auto aliceUri = aliceAccount->getUsername(); - std::mutex mtx; - std::unique_lock lk {mtx}; - std::condition_variable cv; - std::map> confHandlers; - bool conversationReady = false, requestReceived = false, requestDeclined = true; - std::string convId = ""; - confHandlers.insert( - libjami::exportable_callback( - [&](const std::string& account_id, - const std::string& /*from*/, - const std::string& /*conversationId*/, - const std::vector& /*payload*/, - time_t /*received*/) { - if (account_id == bobId) - requestReceived = true; - cv.notify_one(); - })); - confHandlers.insert(libjami::exportable_callback( - [&](const std::string& accountId, const std::string& conversationId) { - if (accountId == aliceId) { - convId = conversationId; - } else if (accountId == bobId) { - conversationReady = true; - } - cv.notify_one(); - })); - confHandlers.insert( - libjami::exportable_callback( - [&](const std::string& accountId, const std::string&) { - if (accountId == bobId) - requestDeclined = true; - cv.notify_one(); - })); - libjami::registerSignalHandlers(confHandlers); + aliceAccount->addContact(bobUri); aliceAccount->sendTrustRequest(bobUri, {}); // Check created files - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return requestReceived; })); + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return bobData.requestReceived; })); bobAccount->removeContact(aliceUri, true); - CPPUNIT_ASSERT(cv.wait_for(lk, 5s, [&]() { return requestDeclined; })); + CPPUNIT_ASSERT(cv.wait_for(lk, 5s, [&]() { return bobData.requestRemoved; })); auto requests = libjami::getConversationRequests(bobId); CPPUNIT_ASSERT(requests.size() == 0); } @@ -1139,194 +826,71 @@ ConversationRequestTest::testBanContactRemoveTrustRequest() void ConversationRequestTest::testAddOfflineContactThenConnect() { + connectSignals(); + auto aliceAccount = Manager::instance().getAccount(aliceId); auto carlaAccount = Manager::instance().getAccount(carlaId); auto carlaUri = carlaAccount->getUsername(); auto aliceUri = aliceAccount->getUsername(); aliceAccount->trackBuddyPresence(carlaUri, true); - std::mutex mtx; - std::unique_lock lk {mtx}; - std::condition_variable cv; - std::map> confHandlers; - bool conversationReady = false, requestReceived = false, memberMessageGenerated = false; - std::string convId = ""; - confHandlers.insert( - libjami::exportable_callback( - [&](const std::string& account_id, - const std::string& /*from*/, - const std::string& /*conversationId*/, - const std::vector& /*payload*/, - time_t /*received*/) { - if (account_id == carlaId) - requestReceived = true; - cv.notify_one(); - })); - confHandlers.insert(libjami::exportable_callback( - [&](const std::string& accountId, const std::string& conversationId) { - if (accountId == aliceId) { - convId = conversationId; - } else if (accountId == carlaId) { - conversationReady = true; - } - cv.notify_one(); - })); - confHandlers.insert(libjami::exportable_callback( - [&](const std::string& accountId, - const std::string& conversationId, - std::map message) { - if (accountId == aliceId && conversationId == convId && message["type"] == "member") { - memberMessageGenerated = true; - cv.notify_one(); - } - })); - libjami::registerSignalHandlers(confHandlers); aliceAccount->addContact(carlaUri); aliceAccount->sendTrustRequest(carlaUri, {}); cv.wait_for(lk, 5s); // Wait 5 secs for the put to happen - CPPUNIT_ASSERT(!convId.empty()); Manager::instance().sendRegister(carlaId, true); - CPPUNIT_ASSERT(cv.wait_for(lk, std::chrono::seconds(60), [&]() { return requestReceived; })); - memberMessageGenerated = false; + CPPUNIT_ASSERT(cv.wait_for(lk, std::chrono::seconds(60), [&]() { return carlaData.requestReceived; })); + auto aliceMsgSize = aliceData.messages.size(); CPPUNIT_ASSERT(carlaAccount->acceptTrustRequest(aliceUri)); CPPUNIT_ASSERT( - cv.wait_for(lk, 30s, [&]() { return conversationReady && memberMessageGenerated; })); + cv.wait_for(lk, 30s, [&]() { return aliceData.messages.size() == aliceMsgSize + 1; })); } void ConversationRequestTest::testDeclineTrustRequestDoNotGenerateAnother() { + connectSignals(); + auto aliceAccount = Manager::instance().getAccount(aliceId); auto bobAccount = Manager::instance().getAccount(bobId); auto bobUri = bobAccount->getUsername(); auto aliceUri = aliceAccount->getUsername(); aliceAccount->trackBuddyPresence(bobUri, true); - std::mutex mtx; - std::unique_lock lk {mtx}; - std::condition_variable cv; - std::map> confHandlers; - bool conversationReady = false, requestReceived = false, memberMessageGenerated = false; - std::string convId = ""; - auto bobConnected = false; - confHandlers.insert( - libjami::exportable_callback( - [&](const std::string& account_id, - const std::string& /*from*/, - const std::string& /*conversationId*/, - const std::vector& /*payload*/, - time_t /*received*/) { - if (account_id == bobId) - requestReceived = true; - cv.notify_one(); - })); - confHandlers.insert(libjami::exportable_callback( - [&](const std::string& accountId, const std::string& conversationId) { - if (accountId == aliceId) { - convId = conversationId; - } else if (accountId == bobId) { - conversationReady = true; - } - cv.notify_one(); - })); - confHandlers.insert(libjami::exportable_callback( - [&](const std::string& accountId, - const std::string& conversationId, - std::map message) { - if (accountId == aliceId && conversationId == convId && message["type"] == "member") { - memberMessageGenerated = true; - cv.notify_one(); - } - })); - confHandlers.insert( - libjami::exportable_callback( - [&](const std::string&, const std::map&) { - auto details = bobAccount->getVolatileAccountDetails(); - auto daemonStatus = details[libjami::Account::ConfProperties::Registration::STATUS]; - if (daemonStatus == "REGISTERED") { - bobConnected = true; - cv.notify_one(); - } else if (daemonStatus == "UNREGISTERED") { - bobConnected = false; - cv.notify_one(); - } - })); - libjami::registerSignalHandlers(confHandlers); aliceAccount->addContact(bobUri); aliceAccount->sendTrustRequest(bobUri, {}); - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return requestReceived; })); + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return bobData.requestReceived; })); CPPUNIT_ASSERT(bobAccount->discardTrustRequest(aliceUri)); cv.wait_for(lk, 10s); // Wait a bit - bobConnected = true; Manager::instance().sendRegister(bobId, false); - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return !bobConnected; })); + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return bobData.stopped; })); // Trigger on peer online - requestReceived = false; + bobData.deviceAnnounced = false; bobData.requestReceived = false; Manager::instance().sendRegister(bobId, true); - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return bobConnected; })); - CPPUNIT_ASSERT(!cv.wait_for(lk, 30s, [&]() { return requestReceived; })); + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return bobData.deviceAnnounced; })); + CPPUNIT_ASSERT(!cv.wait_for(lk, 30s, [&]() { return bobData.requestReceived; })); } void ConversationRequestTest::testRemoveContactRemoveSyncing() { + connectSignals(); + auto aliceAccount = Manager::instance().getAccount(aliceId); auto bobAccount = Manager::instance().getAccount(bobId); auto bobUri = bobAccount->getUsername(); auto aliceUri = aliceAccount->getUsername(); - std::mutex mtx; - std::unique_lock lk {mtx}; - std::condition_variable cv; - std::map> confHandlers; - bool conversationReady = false, contactAdded = false, requestReceived = false; - std::string convId = ""; - confHandlers.insert( - libjami::exportable_callback( - [&](const std::string& account_id, - const std::string& /*from*/, - const std::string& convId, - const std::vector& /*payload*/, - time_t /*received*/) { - if (account_id == bobId && !convId.empty()) - requestReceived = true; - cv.notify_one(); - })); - confHandlers.insert(libjami::exportable_callback( - [&](const std::string& accountId, const std::string& conversationId) { - if (accountId == aliceId) { - convId = conversationId; - } else if (accountId == bobId) { - conversationReady = true; - } - cv.notify_one(); - })); - confHandlers.insert(libjami::exportable_callback( - [&](const std::string& accountId, const std::string& uri, bool) { - if (accountId == bobId && uri == aliceUri) { - contactAdded = true; - } - cv.notify_one(); - })); - bool contactRemoved = false; - confHandlers.insert(libjami::exportable_callback( - [&](const std::string& accountId, const std::string& uri, bool) { - if (accountId == bobId && uri == aliceUri) { - contactRemoved = true; - } - cv.notify_one(); - })); - libjami::registerSignalHandlers(confHandlers); + aliceAccount->addContact(bobUri); aliceAccount->sendTrustRequest(bobUri, {}); - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return requestReceived; })); + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return bobData.requestReceived; })); Manager::instance().sendRegister(aliceId, false); // This avoid to sync immediately CPPUNIT_ASSERT(bobAccount->acceptTrustRequest(aliceUri)); - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return contactAdded; })); + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return bobData.contactAdded; })); CPPUNIT_ASSERT(libjami::getConversations(bobId).size() == 1); bobAccount->removeContact(aliceUri, false); - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return contactRemoved; })); + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return bobData.contactRemoved; })); CPPUNIT_ASSERT(libjami::getConversations(bobId).size() == 0); } @@ -1334,65 +898,25 @@ ConversationRequestTest::testRemoveContactRemoveSyncing() void ConversationRequestTest::testRemoveConversationRemoveSyncing() { + connectSignals(); + auto aliceAccount = Manager::instance().getAccount(aliceId); auto bobAccount = Manager::instance().getAccount(bobId); auto bobUri = bobAccount->getUsername(); auto aliceUri = aliceAccount->getUsername(); - std::mutex mtx; - std::unique_lock lk {mtx}; - std::condition_variable cv; - std::map> confHandlers; - bool conversationReady = false, contactAdded = false, requestReceived = false, - conversationRemoved = false; - std::string convId = ""; - confHandlers.insert( - libjami::exportable_callback( - [&](const std::string& account_id, - const std::string& /*from*/, - const std::string& convId, - const std::vector& /*payload*/, - time_t /*received*/) { - if (account_id == bobId && !convId.empty()) - requestReceived = true; - cv.notify_one(); - })); - confHandlers.insert(libjami::exportable_callback( - [&](const std::string& accountId, const std::string& conversationId) { - if (accountId == aliceId) { - convId = conversationId; - } else if (accountId == bobId) { - conversationReady = true; - } - cv.notify_one(); - })); - confHandlers.insert( - libjami::exportable_callback( - [&](const std::string& accountId, const std::string&) { - if (accountId == bobId) { - conversationRemoved = true; - } - cv.notify_one(); - })); - confHandlers.insert(libjami::exportable_callback( - [&](const std::string& accountId, const std::string& uri, bool) { - if (accountId == bobId && uri == aliceUri) { - contactAdded = true; - } - cv.notify_one(); - })); - libjami::registerSignalHandlers(confHandlers); + aliceAccount->addContact(bobUri); aliceAccount->sendTrustRequest(bobUri, {}); - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return requestReceived; })); + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return bobData.requestReceived; })); Manager::instance().sendRegister(aliceId, false); // This avoid to sync immediately CPPUNIT_ASSERT(bobAccount->acceptTrustRequest(aliceUri)); - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return contactAdded; })); + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return bobData.contactAdded; })); // At this point the conversation should be there and syncing. CPPUNIT_ASSERT(libjami::getConversations(bobId).size() == 1); - libjami::removeConversation(bobId, convId); - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return conversationRemoved; })); + libjami::removeConversation(bobId, aliceData.conversationId); + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return bobData.removed; })); CPPUNIT_ASSERT(libjami::getConversations(bobId).size() == 0); } @@ -1400,91 +924,47 @@ ConversationRequestTest::testRemoveConversationRemoveSyncing() void ConversationRequestTest::testCacheRequestFromClient() { + connectSignals(); + auto aliceAccount = Manager::instance().getAccount(aliceId); auto bobAccount = Manager::instance().getAccount(bobId); auto bobUri = bobAccount->getUsername(); - auto aliceUri = aliceAccount->getUsername(); - std::mutex mtx; - std::unique_lock lk {mtx}; - std::condition_variable cv; - std::map> confHandlers; - bool conversationReady = false, requestReceived = false; - std::string convId = ""; - confHandlers.insert( - libjami::exportable_callback( - [&](const std::string& /*accountId*/, - const std::string& /* conversationId */, - std::map /*metadatas*/) { - requestReceived = true; - cv.notify_one(); - })); - confHandlers.insert(libjami::exportable_callback( - [&](const std::string& accountId, const std::string& conversationId) { - if (accountId == aliceId) { - convId = conversationId; - } else if (accountId == bobId) { - conversationReady = true; - } - cv.notify_one(); - })); - libjami::registerSignalHandlers(confHandlers); + aliceAccount->addContact(bobUri); std::vector payload = {0x64, 0x64, 0x64}; aliceAccount->sendTrustRequest(bobUri, payload); // Random payload, just care with the file - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return requestReceived; })); - auto cachedPath = fileutils::get_cache_dir() / aliceAccount->getAccountID() + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return bobData.requestReceived; })); + auto cachedPath = fileutils::get_cache_dir() / aliceId / "requests" / bobUri; CPPUNIT_ASSERT(std::filesystem::is_regular_file(cachedPath)); CPPUNIT_ASSERT(fileutils::loadFile(cachedPath) == payload); CPPUNIT_ASSERT(bobAccount->getTrustRequests().size() == 1); - libjami::acceptConversationRequest(bobId, convId); - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return conversationReady; })); + libjami::acceptConversationRequest(bobId, aliceData.conversationId); + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return !bobData.conversationId.empty(); })); CPPUNIT_ASSERT(!std::filesystem::is_regular_file(cachedPath)); } void ConversationRequestTest::testNeedsSyncingWithForCloning() { + connectSignals(); + auto aliceAccount = Manager::instance().getAccount(aliceId); auto bobAccount = Manager::instance().getAccount(bobId); auto bobUri = bobAccount->getUsername(); auto aliceUri = aliceAccount->getUsername(); auto aliceDevice = std::string(aliceAccount->currentDeviceId()); - std::mutex mtx; - std::unique_lock lk {mtx}; - std::condition_variable cv; - std::map> confHandlers; - bool contactAdded = false, requestReceived = false; - std::string convId = ""; - confHandlers.insert( - libjami::exportable_callback( - [&](const std::string& account_id, - const std::string& /*from*/, - const std::string& convId, - const std::vector& /*payload*/, - time_t /*received*/) { - if (account_id == bobId && !convId.empty()) - requestReceived = true; - cv.notify_one(); - })); - confHandlers.insert(libjami::exportable_callback( - [&](const std::string& accountId, const std::string& uri, bool) { - if (accountId == bobId && uri == aliceUri) { - contactAdded = true; - } - cv.notify_one(); - })); - libjami::registerSignalHandlers(confHandlers); + CPPUNIT_ASSERT(!bobAccount->convModule()->needsSyncingWith(aliceUri, aliceDevice)); aliceAccount->addContact(bobUri); aliceAccount->sendTrustRequest(bobUri, {}); - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return requestReceived; })); + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return bobData.requestReceived; })); Manager::instance().sendRegister(aliceId, false); // This avoid to sync immediately CPPUNIT_ASSERT(bobAccount->acceptTrustRequest(aliceUri)); - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return contactAdded; })); + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return bobData.contactAdded; })); // At this point the conversation should be there and syncing. CPPUNIT_ASSERT(libjami::getConversations(bobId).size() == 1); @@ -1494,13 +974,12 @@ ConversationRequestTest::testNeedsSyncingWithForCloning() void ConversationRequestTest::testRemoveContactRemoveTrustRequest() { + connectSignals(); + auto aliceAccount = Manager::instance().getAccount(aliceId); auto bobAccount = Manager::instance().getAccount(bobId); auto bobUri = bobAccount->getUsername(); auto aliceUri = aliceAccount->getUsername(); - std::mutex mtx; - std::unique_lock lk {mtx}; - std::condition_variable cv; // Add second device for Bob std::map> confHandlers; @@ -1519,75 +998,29 @@ ConversationRequestTest::testRemoveContactRemoveTrustRequest() bob2Id = Manager::instance().addAccount(details); - wait_for_announcement_of(bob2Id); + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { + return bob2Data.deviceAnnounced; + })); auto bob2Account = Manager::instance().getAccount(bob2Id); - bool conversationB1Ready = false, conversationB2Ready = false, conversationB1Removed = false, - conversationB2Removed = false, requestB1Received = false, requestB2Received = false, - memberMessageGenerated = false; - std::string convId = ""; - confHandlers.insert( - libjami::exportable_callback( - [&](const std::string& account_id, - const std::string& /*from*/, - const std::string& /*conversationId*/, - const std::vector& /*payload*/, - time_t /*received*/) { - if (account_id == bobId) - requestB1Received = true; - else if (account_id == bob2Id) - requestB2Received = true; - cv.notify_one(); - })); - confHandlers.insert(libjami::exportable_callback( - [&](const std::string& accountId, const std::string& conversationId) { - if (accountId == aliceId) { - convId = conversationId; - } else if (accountId == bobId) { - conversationB1Ready = true; - } else if (accountId == bob2Id) { - conversationB2Ready = true; - } - cv.notify_one(); - })); - confHandlers.insert( - libjami::exportable_callback( - [&](const std::string& accountId, const std::string&) { - if (accountId == bobId) { - conversationB1Removed = true; - } else if (accountId == bob2Id) { - conversationB2Removed = true; - } - cv.notify_one(); - })); - confHandlers.insert(libjami::exportable_callback( - [&](const std::string& accountId, - const std::string& conversationId, - std::map message) { - if (accountId == aliceId && conversationId == convId && message["type"] == "member") { - memberMessageGenerated = true; - cv.notify_one(); - } - })); - libjami::registerSignalHandlers(confHandlers); - // First, Alice adds Bob aliceAccount->addContact(bobUri); aliceAccount->sendTrustRequest(bobUri, {}); CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { - return !convId.empty() && requestB1Received && requestB2Received; + return bobData.requestReceived && bob2Data.requestReceived; })); // Bob1 accepts, both device should get it + auto aliceMsgSize = aliceData.messages.size(); CPPUNIT_ASSERT(bobAccount->acceptTrustRequest(aliceUri)); CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { - return conversationB1Ready && conversationB2Ready && memberMessageGenerated; + return !bobData.conversationId.empty() && !bob2Data.conversationId.empty() && aliceMsgSize + 1 == aliceData.messages.size(); })); // Bob2 remove Alice ; Bob1 should not have any trust requests bob2Account->removeContact(aliceUri, false); CPPUNIT_ASSERT( - cv.wait_for(lk, 30s, [&]() { return conversationB1Removed && conversationB2Removed; })); + cv.wait_for(lk, 30s, [&]() { return bobData.contactRemoved && bob2Data.contactRemoved; })); std::this_thread::sleep_for(10s); // Wait a bit to ensure that everything is update (via synced) CPPUNIT_ASSERT(bobAccount->getTrustRequests().size() == 0); CPPUNIT_ASSERT(bob2Account->getTrustRequests().size() == 0); diff --git a/test/unitTest/syncHistory/syncHistory.cpp b/test/unitTest/syncHistory/syncHistory.cpp index 7c2d52469..9d58e8388 100644 --- a/test/unitTest/syncHistory/syncHistory.cpp +++ b/test/unitTest/syncHistory/syncHistory.cpp @@ -41,6 +41,24 @@ using namespace std::literals::chrono_literals; namespace jami { namespace test { +struct UserData { + std::string conversationId; + bool removed {false}; + bool requestReceived {false}; + bool requestRemoved {false}; + bool errorDetected {false}; + bool registered {false}; + bool stopped {false}; + bool deviceAnnounced {false}; + bool sending {false}; + bool sent {false}; + std::string profilePath; + std::string payloadTrustRequest; + std::vector messages; + std::vector messagesLoaded; + std::vector messagesUpdated; +}; + class SyncHistoryTest : public CppUnit::TestFixture { public: @@ -57,8 +75,16 @@ public: void tearDown(); std::string aliceId; + UserData aliceData; std::string bobId; + UserData bobData; std::string alice2Id; + UserData alice2Data; + + std::mutex mtx; + std::unique_lock lk {mtx}; + std::condition_variable cv; + void connectSignals(); private: void testCreateConversationThenSync(); @@ -103,6 +129,9 @@ SyncHistoryTest::setUp() aliceId = actors["alice"]; bobId = actors["bob"]; alice2Id = ""; + aliceData = {}; + bobData = {}; + alice2Data = {}; } void @@ -117,9 +146,201 @@ SyncHistoryTest::tearDown() } } +void +SyncHistoryTest::connectSignals() +{ + std::map> confHandlers; + confHandlers.insert( + libjami::exportable_callback( + [&](const std::string& accountId, const std::map&) { + if (accountId == aliceId) { + auto aliceAccount = Manager::instance().getAccount(aliceId); + auto details = aliceAccount->getVolatileAccountDetails(); + auto daemonStatus = details[libjami::Account::ConfProperties::Registration::STATUS]; + if (daemonStatus == "REGISTERED") { + aliceData.registered = true; + } else if (daemonStatus == "UNREGISTERED") { + aliceData.stopped = true; + } + auto deviceAnnounced = details[libjami::Account::VolatileProperties::DEVICE_ANNOUNCED]; + aliceData.deviceAnnounced = deviceAnnounced == "true"; + } else if (accountId == bobId) { + auto bobAccount = Manager::instance().getAccount(bobId); + auto details = bobAccount->getVolatileAccountDetails(); + auto daemonStatus = details[libjami::Account::ConfProperties::Registration::STATUS]; + if (daemonStatus == "REGISTERED") { + bobData.registered = true; + } else if (daemonStatus == "UNREGISTERED") { + bobData.stopped = true; + } + auto deviceAnnounced = details[libjami::Account::VolatileProperties::DEVICE_ANNOUNCED]; + bobData.deviceAnnounced = deviceAnnounced == "true"; + } else if (accountId == alice2Id) { + auto alice2Account = Manager::instance().getAccount(alice2Id); + auto details = alice2Account->getVolatileAccountDetails(); + auto daemonStatus = details[libjami::Account::ConfProperties::Registration::STATUS]; + if (daemonStatus == "REGISTERED") { + alice2Data.registered = true; + } else if (daemonStatus == "UNREGISTERED") { + alice2Data.stopped = true; + } + auto deviceAnnounced = details[libjami::Account::VolatileProperties::DEVICE_ANNOUNCED]; + alice2Data.deviceAnnounced = deviceAnnounced == "true"; + } + cv.notify_one(); + })); + confHandlers.insert(libjami::exportable_callback( + [&](const std::string& accountId, const std::string& conversationId) { + if (accountId == aliceId) { + aliceData.conversationId = conversationId; + } else if (accountId == bobId) { + bobData.conversationId = conversationId; + } else if (accountId == alice2Id) { + alice2Data.conversationId = conversationId; + } + cv.notify_one(); + })); + confHandlers.insert(libjami::exportable_callback( + [&](const std::string& accountId, const std::string& peerId, const std::string& path) { + if (accountId == bobId) + bobData.profilePath = path; + else if (accountId == aliceId) + aliceData.profilePath = path; + else if (accountId == alice2Id) + alice2Data.profilePath = path; + cv.notify_one(); + })); + confHandlers.insert( + libjami::exportable_callback( + [&](const std::string& accountId, + const std::string& /*conversationId*/, + const std::string& /*peer*/, + const std::string& /*msgId*/, + int status) { + if (accountId == aliceId) { + if (status == 2) + aliceData.sending = true; + if (status == 3) + aliceData.sent = true; + } else if (accountId == alice2Id) { + if (status == 2) + alice2Data.sending = true; + if (status == 3) + alice2Data.sent = true; + } else if (accountId == bobId) { + if (status == 2) + bobData.sending = true; + if (status == 3) + bobData.sent = true; + } + cv.notify_one(); + })); + confHandlers.insert( + libjami::exportable_callback( + [&](const std::string& account_id, + const std::string& /*from*/, + const std::string& /*conversationId*/, + const std::vector& payload, + time_t /*received*/) { + auto payloadStr = std::string(payload.data(), payload.data() + payload.size()); + if (account_id == aliceId) + aliceData.payloadTrustRequest = payloadStr; + else if (account_id == bobId) + bobData.payloadTrustRequest = payloadStr; + cv.notify_one(); + })); + confHandlers.insert( + libjami::exportable_callback( + [&](const std::string& accountId, + const std::string& /* conversationId */, + std::map /*metadatas*/) { + if (accountId == aliceId) { + aliceData.requestReceived = true; + } else if (accountId == bobId) { + bobData.requestReceived = true; + } else if (accountId == alice2Id) { + alice2Data.requestReceived = true; + } + cv.notify_one(); + })); + confHandlers.insert( + libjami::exportable_callback( + [&](const std::string& accountId, const std::string&) { + if (accountId == bobId) { + bobData.requestRemoved = true; + } else if (accountId == aliceId) { + aliceData.requestRemoved = true; + } else if (accountId == alice2Id) { + alice2Data.requestRemoved = true; + } + cv.notify_one(); + })); + confHandlers.insert(libjami::exportable_callback( + [&](const std::string& accountId, + const std::string& /* conversationId */, + libjami::SwarmMessage message) { + if (accountId == aliceId) { + aliceData.messages.emplace_back(message); + } else if (accountId == bobId) { + bobData.messages.emplace_back(message); + } + cv.notify_one(); + })); + confHandlers.insert(libjami::exportable_callback( + [&](uint32_t, const std::string& accountId, + const std::string& /* conversationId */, + std::vector messages) { + if (accountId == aliceId) { + aliceData.messagesLoaded.insert(aliceData.messagesLoaded.end(), messages.begin(), messages.end()); + } else if (accountId == alice2Id) { + alice2Data.messagesLoaded.insert(alice2Data.messagesLoaded.end(), messages.begin(), messages.end()); + } else if (accountId == bobId) { + bobData.messagesLoaded.insert(bobData.messagesLoaded.end(), messages.begin(), messages.end()); + } + cv.notify_one(); + })); + confHandlers.insert(libjami::exportable_callback( + [&](const std::string& accountId, + const std::string& /* conversationId */, + libjami::SwarmMessage message) { + if (accountId == aliceId) { + aliceData.messagesUpdated.emplace_back(message); + } else if (accountId == bobId) { + bobData.messagesUpdated.emplace_back(message); + } + cv.notify_one(); + })); + confHandlers.insert( + libjami::exportable_callback( + [&](const std::string& accountId, + const std::string& /* conversationId */, + int /*code*/, + const std::string& /* what */) { + if (accountId == aliceId) + aliceData.errorDetected = true; + else if (accountId == bobId) + bobData.errorDetected = true; + cv.notify_one(); + })); + confHandlers.insert( + libjami::exportable_callback( + [&](const std::string& accountId, const std::string&) { + if (accountId == aliceId) + aliceData.removed = true; + else if (accountId == bobId) + bobData.removed = true; + else if (accountId == alice2Id) + alice2Data.removed = true; + cv.notify_one(); + })); + libjami::registerSignalHandlers(confHandlers); +} + void SyncHistoryTest::testCreateConversationThenSync() { + connectSignals(); + auto aliceAccount = Manager::instance().getAccount(aliceId); // Start conversation auto convId = libjami::startConversation(aliceId); @@ -136,37 +357,14 @@ SyncHistoryTest::testCreateConversationThenSync() details[ConfProperties::ARCHIVE_PIN] = ""; details[ConfProperties::ARCHIVE_PATH] = aliceArchive; - std::mutex mtx; - std::unique_lock lk {mtx}; - std::condition_variable cv; - std::map> confHandlers; - auto conversationReady = false, alice2Ready = false; - confHandlers.insert(libjami::exportable_callback( - [&](const std::string& accountId, const std::string& conversationId) { - if (accountId == alice2Id && conversationId == convId) { - conversationReady = true; - cv.notify_one(); - } - })); - confHandlers.insert( - libjami::exportable_callback( - [&](const std::string& accountId, const std::map& details) { - if (alice2Id != accountId) { - return; - } - alice2Ready = details.at(libjami::Account::VolatileProperties::DEVICE_ANNOUNCED) - == "true"; - cv.notify_one(); - })); - libjami::registerSignalHandlers(confHandlers); alice2Id = Manager::instance().addAccount(details); - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&] { return alice2Ready && conversationReady; })); - libjami::unregisterSignalHandlers(); + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&] { return !alice2Data.conversationId.empty(); })); } void SyncHistoryTest::testCreateConversationWithOnlineDevice() { + connectSignals(); auto aliceAccount = Manager::instance().getAccount(aliceId); // Now create alice2 @@ -180,77 +378,26 @@ SyncHistoryTest::testCreateConversationWithOnlineDevice() details[ConfProperties::ARCHIVE_PASSWORD] = ""; details[ConfProperties::ARCHIVE_PIN] = ""; details[ConfProperties::ARCHIVE_PATH] = aliceArchive; - - std::mutex mtx; - std::unique_lock lk {mtx}; - std::condition_variable cv; - std::map> confHandlers; - - // Start conversation now auto convId = libjami::startConversation(aliceId); - auto conversationReady = false, alice2Ready = false; - confHandlers.insert(libjami::exportable_callback( - [&](const std::string& accountId, const std::string& conversationId) { - if (accountId == alice2Id && conversationId == convId) { - conversationReady = true; - cv.notify_one(); - } - })); - confHandlers.insert( - libjami::exportable_callback( - [&](const std::string& accountId, const std::map& details) { - if (alice2Id != accountId) { - return; - } - alice2Ready = details.at(libjami::Account::VolatileProperties::DEVICE_ANNOUNCED) - == "true"; - cv.notify_one(); - })); - libjami::registerSignalHandlers(confHandlers); alice2Id = Manager::instance().addAccount(details); - CPPUNIT_ASSERT(cv.wait_for(lk, 60s, [&] { return alice2Ready && conversationReady; })); - libjami::unregisterSignalHandlers(); + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&] { return !alice2Data.conversationId.empty(); })); } void SyncHistoryTest::testCreateConversationWithMessagesThenAddDevice() { + connectSignals(); auto aliceAccount = Manager::instance().getAccount(aliceId); auto convId = libjami::startConversation(aliceId); - std::mutex mtx; - std::unique_lock lk {mtx}; - std::condition_variable cv; - std::map> confHandlers; - auto conversationReady = false; - auto messageReceived = false; - confHandlers.insert(libjami::exportable_callback( - [&](const std::string& /* accountId */, - const std::string& /* conversationId */, - std::map /*message*/) { - messageReceived = true; - cv.notify_one(); - })); - confHandlers.insert(libjami::exportable_callback( - [&](const std::string& accountId, const std::string& conversationId) { - if (accountId == alice2Id && conversationId == convId) { - conversationReady = true; - cv.notify_one(); - } - })); - libjami::registerSignalHandlers(confHandlers); - confHandlers.clear(); - // Start conversation - messageReceived = false; + auto aliceMsgSize = aliceData.messages.size(); libjami::sendMessage(aliceId, convId, std::string("Message 1"), ""); - CPPUNIT_ASSERT(cv.wait_for(lk, 10s, [&] { return messageReceived; })); - messageReceived = false; + CPPUNIT_ASSERT(cv.wait_for(lk, 10s, [&] { return aliceMsgSize + 1 == aliceData.messages.size(); })); libjami::sendMessage(aliceId, convId, std::string("Message 2"), ""); - CPPUNIT_ASSERT(cv.wait_for(lk, 10s, [&] { return messageReceived; })); - messageReceived = false; + CPPUNIT_ASSERT(cv.wait_for(lk, 10s, [&] { return aliceMsgSize + 2 == aliceData.messages.size(); })); libjami::sendMessage(aliceId, convId, std::string("Message 3"), ""); - CPPUNIT_ASSERT(cv.wait_for(lk, 10s, [&] { return messageReceived; })); + CPPUNIT_ASSERT(cv.wait_for(lk, 10s, [&] { return aliceMsgSize + 3 == aliceData.messages.size(); })); // Now create alice2 auto aliceArchive = std::filesystem::current_path().string() + "/alice.gz"; @@ -264,31 +411,15 @@ SyncHistoryTest::testCreateConversationWithMessagesThenAddDevice() details[ConfProperties::ARCHIVE_PIN] = ""; details[ConfProperties::ARCHIVE_PATH] = aliceArchive; alice2Id = Manager::instance().addAccount(details); + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&] { return !alice2Data.conversationId.empty(); })); - // Check if conversation is ready - CPPUNIT_ASSERT(cv.wait_for(lk, 60s, [&]() { return conversationReady; })); - std::vector> messages; - confHandlers.insert(libjami::exportable_callback( - [&](uint32_t, - const std::string& accountId, - const std::string& conversationId, - std::vector> msg) { - if (accountId == alice2Id && conversationId == convId) { - messages = msg; - cv.notify_one(); - } - })); - libjami::registerSignalHandlers(confHandlers); - libjami::loadConversationMessages(alice2Id, convId, "", 0); - cv.wait_for(lk, 30s); - libjami::unregisterSignalHandlers(); - confHandlers.clear(); + libjami::loadConversation(alice2Id, convId, "", 0); + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&] { return alice2Data.messagesLoaded.size() == 4; })); // Check messages - CPPUNIT_ASSERT(messages.size() == 4 /* 3 + initial */); - CPPUNIT_ASSERT(messages[0]["body"] == "Message 3"); - CPPUNIT_ASSERT(messages[1]["body"] == "Message 2"); - CPPUNIT_ASSERT(messages[2]["body"] == "Message 1"); + CPPUNIT_ASSERT(alice2Data.messagesLoaded[0].body["body"] == "Message 3"); + CPPUNIT_ASSERT(alice2Data.messagesLoaded[1].body["body"] == "Message 2"); + CPPUNIT_ASSERT(alice2Data.messagesLoaded[2].body["body"] == "Message 1"); } void @@ -346,56 +477,25 @@ SyncHistoryTest::testCreateMultipleConversationThenAddDevice() // Check if conversation is ready CPPUNIT_ASSERT(cv.wait_for(lk, 60s, [&]() { return conversationReady == 4; })); - libjami::unregisterSignalHandlers(); } void SyncHistoryTest::testReceivesInviteThenAddDevice() { + connectSignals(); auto aliceAccount = Manager::instance().getAccount(aliceId); // Export alice auto aliceArchive = std::filesystem::current_path().string() + "/alice.gz"; aliceAccount->exportArchive(aliceArchive); - auto bobAccount = Manager::instance().getAccount(bobId); auto uri = aliceAccount->getUsername(); // Start conversation for Alice auto convId = libjami::startConversation(bobId); - // Check that alice receives the request - std::mutex mtx; - std::unique_lock lk {mtx}; - std::condition_variable cv; - std::map> confHandlers; - auto requestReceived = false, memberEvent = false; - confHandlers.insert( - libjami::exportable_callback( - [&](const std::string& accountId, - const std::string& conversationId, - std::map /*metadatas*/) { - if (accountId == aliceId && conversationId == convId) { - requestReceived = true; - cv.notify_one(); - } - })); - confHandlers.insert( - libjami::exportable_callback( - [&](const std::string& /*accountId*/, - const std::string& /*conversationId*/, - const std::string& /*memberUri*/, - int /*event*/) { - memberEvent = true; - cv.notify_one(); - })); - libjami::registerSignalHandlers(confHandlers); - - memberEvent = false; libjami::addConversationMember(bobId, convId, uri); - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&] { return memberEvent && requestReceived; })); - libjami::unregisterSignalHandlers(); - confHandlers.clear(); + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&] { return aliceData.requestReceived; })); // Now create alice2 std::map details = libjami::getAccountTemplate("RING"); @@ -408,26 +508,13 @@ SyncHistoryTest::testReceivesInviteThenAddDevice() details[ConfProperties::ARCHIVE_PATH] = aliceArchive; alice2Id = Manager::instance().addAccount(details); - requestReceived = false; - confHandlers.insert( - libjami::exportable_callback( - [&](const std::string& accountId, - const std::string& conversationId, - std::map /*metadatas*/) { - if (accountId == alice2Id && conversationId == convId) { - requestReceived = true; - cv.notify_one(); - } - })); - libjami::registerSignalHandlers(confHandlers); - - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&] { return requestReceived; })); - libjami::unregisterSignalHandlers(); + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&] { return alice2Data.requestReceived; })); } void SyncHistoryTest::testRemoveConversationOnAllDevices() { + connectSignals(); auto aliceAccount = Manager::instance().getAccount(aliceId); // Now create alice2 @@ -441,53 +528,18 @@ SyncHistoryTest::testRemoveConversationOnAllDevices() details[ConfProperties::ARCHIVE_PASSWORD] = ""; details[ConfProperties::ARCHIVE_PIN] = ""; details[ConfProperties::ARCHIVE_PATH] = aliceArchive; - - std::mutex mtx; - std::unique_lock lk {mtx}; - std::condition_variable cv; - std::map> confHandlers; - - // Start conversation now auto convId = libjami::startConversation(aliceId); - bool alice2Ready = false; - auto conversationReady = false, conversationRemoved = false; - confHandlers.insert(libjami::exportable_callback( - [&](const std::string& accountId, const std::string& conversationId) { - if (accountId == alice2Id && conversationId == convId) { - conversationReady = true; - cv.notify_one(); - } - })); - confHandlers.insert(libjami::exportable_callback( - [&](const std::string& accountId, const std::string& conversationId) { - if (accountId == alice2Id && conversationId == convId) { - conversationRemoved = true; - cv.notify_one(); - } - })); - confHandlers.insert( - libjami::exportable_callback( - [&](const std::string& accountId, const std::map& details) { - if (alice2Id != accountId) { - return; - } - alice2Ready = details.at(libjami::Account::VolatileProperties::DEVICE_ANNOUNCED) - == "true"; - cv.notify_one(); - })); - libjami::registerSignalHandlers(confHandlers); alice2Id = Manager::instance().addAccount(details); - CPPUNIT_ASSERT(cv.wait_for(lk, 60s, [&] { return alice2Ready && conversationReady; })); - libjami::removeConversation(aliceId, convId); - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&] { return conversationRemoved; })); - - libjami::unregisterSignalHandlers(); + CPPUNIT_ASSERT(cv.wait_for(lk, 60s, [&] { return !alice2Data.conversationId.empty(); })); + libjami::removeConversation(aliceId, aliceData.conversationId); + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&] { return alice2Data.removed; })); } void SyncHistoryTest::testSyncCreateAccountExportDeleteReimportOldBackup() { + connectSignals(); auto aliceAccount = Manager::instance().getAccount(aliceId); auto bobAccount = Manager::instance().getAccount(bobId); auto bobUri = bobAccount->getUsername(); @@ -499,65 +551,11 @@ SyncHistoryTest::testSyncCreateAccountExportDeleteReimportOldBackup() // Start conversation auto convId = libjami::startConversation(aliceId); - std::mutex mtx; - std::unique_lock lk {mtx}; - std::condition_variable cv; - std::map> confHandlers; - auto messageBobReceived = 0, messageAliceReceived = 0; - bool requestReceived = false; - bool conversationReady = false; - bool alice2Ready = false; - confHandlers.insert(libjami::exportable_callback( - [&](const std::string& accountId, - const std::string& /* conversationId */, - std::map /*message*/) { - if (accountId == bobId) { - messageBobReceived += 1; - } else { - messageAliceReceived += 1; - } - cv.notify_one(); - })); - confHandlers.insert( - libjami::exportable_callback( - [&](const std::string& /*accountId*/, - const std::string& /* conversationId */, - std::map /*metadatas*/) { - requestReceived = true; - cv.notify_one(); - })); - confHandlers.insert(libjami::exportable_callback( - [&](const std::string& accountId, const std::string& conversationId) { - if (accountId == bobId) { - conversationReady = true; - cv.notify_one(); - } - - if (accountId == alice2Id && conversationId == convId) { - conversationReady = true; - cv.notify_one(); - } - })); - confHandlers.insert( - libjami::exportable_callback( - [&](const std::string& accountId, const std::map& details) { - if (alice2Id != accountId) { - return; - } - alice2Ready = details.at(libjami::Account::VolatileProperties::DEVICE_ANNOUNCED) - == "true"; - cv.notify_one(); - })); - libjami::registerSignalHandlers(confHandlers); - libjami::addConversationMember(aliceId, convId, bobUri); - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return requestReceived; })); - + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return bobData.requestReceived; })); + auto aliceMsgSize = aliceData.messages.size(); libjami::acceptConversationRequest(bobId, convId); - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return conversationReady; })); - - // Wait that alice sees Bob - cv.wait_for(lk, 30s, [&]() { return messageAliceReceived == 1; }); + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return aliceMsgSize + 1 == aliceData.messages.size() && !bobData.conversationId.empty(); })); // disable account (same as removed) Manager::instance().sendRegister(aliceId, false); @@ -571,27 +569,25 @@ SyncHistoryTest::testSyncCreateAccountExportDeleteReimportOldBackup() details[ConfProperties::ARCHIVE_PASSWORD] = ""; details[ConfProperties::ARCHIVE_PIN] = ""; details[ConfProperties::ARCHIVE_PATH] = aliceArchive; - requestReceived = false; - conversationReady = false; alice2Id = Manager::instance().addAccount(details); - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&] { return alice2Ready; })); + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&] { return alice2Data.deviceAnnounced; })); // This will trigger a conversation request. Cause alice2 can't know first conversation libjami::sendMessage(bobId, convId, std::string("hi"), ""); - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&] { return requestReceived; })); + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&] { return alice2Data.requestReceived; })); libjami::acceptConversationRequest(alice2Id, convId); - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&] { return conversationReady; })); + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&] { return !alice2Data.conversationId.empty(); })); - messageBobReceived = 0; + auto bobMsgSize = bobData.messages.size(); libjami::sendMessage(alice2Id, convId, std::string("hi"), ""); - cv.wait_for(lk, 30s, [&]() { return messageBobReceived == 1; }); - libjami::unregisterSignalHandlers(); + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return bobMsgSize + 1 == bobData.messages.size(); })); } void SyncHistoryTest::testSyncCreateAccountExportDeleteReimportWithConvId() { + connectSignals(); auto aliceAccount = Manager::instance().getAccount(aliceId); auto bobAccount = Manager::instance().getAccount(bobId); auto aliceUri = aliceAccount->getUsername(); @@ -600,76 +596,16 @@ SyncHistoryTest::testSyncCreateAccountExportDeleteReimportWithConvId() // Start conversation auto convId = libjami::startConversation(aliceId); - std::mutex mtx; - std::unique_lock lk {mtx}; - std::condition_variable cv; - std::map> confHandlers; - auto messageBobReceived = 0; - bool requestReceived = false; - bool conversationReady = false; - bool alice2Ready = false; - bool memberAddGenerated = false; - confHandlers.insert(libjami::exportable_callback( - [&](const std::string& accountId, - const std::string& /* conversationId */, - std::map /*message*/) { - if (accountId == bobId) { - messageBobReceived += 1; - } - cv.notify_one(); - })); - confHandlers.insert( - libjami::exportable_callback( - [&](const std::string& accountId, - const std::string& conversationId, - const std::string& uri, - int event) { - if (accountId == aliceId && conversationId == convId && uri == bobUri - && event == 0) { - memberAddGenerated = true; - } - cv.notify_one(); - })); - confHandlers.insert( - libjami::exportable_callback( - [&](const std::string& /*accountId*/, - const std::string& /* conversationId */, - std::map /*metadatas*/) { - requestReceived = true; - cv.notify_one(); - })); - confHandlers.insert(libjami::exportable_callback( - [&](const std::string& accountId, const std::string& conversationId) { - if (conversationId != convId) - return; - if (accountId == bobId || accountId == alice2Id) - conversationReady = true; - cv.notify_one(); - })); - confHandlers.insert( - libjami::exportable_callback( - [&](const std::string& accountId, const std::map& details) { - if (alice2Id != accountId) { - return; - } - alice2Ready = details.at(libjami::Account::VolatileProperties::DEVICE_ANNOUNCED) - == "true"; - cv.notify_one(); - })); - libjami::registerSignalHandlers(confHandlers); - libjami::addConversationMember(aliceId, convId, bobUri); - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return requestReceived; })); + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return bobData.requestReceived; })); + auto aliceMsgSize = aliceData.messages.size(); libjami::acceptConversationRequest(bobId, convId); - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return conversationReady; })); + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return aliceMsgSize + 1 == aliceData.messages.size(); })); // We need to track presence to know when to sync bobAccount->trackBuddyPresence(aliceUri, true); - // Wait that alice sees Bob - cv.wait_for(lk, 30s, [&]() { return memberAddGenerated; }); - // Backup alice after startConversation with member auto aliceArchive = std::filesystem::current_path().string() + "/alice.gz"; aliceAccount->exportArchive(aliceArchive); @@ -686,83 +622,27 @@ SyncHistoryTest::testSyncCreateAccountExportDeleteReimportWithConvId() details[ConfProperties::ARCHIVE_PASSWORD] = ""; details[ConfProperties::ARCHIVE_PIN] = ""; details[ConfProperties::ARCHIVE_PATH] = aliceArchive; - requestReceived = false; - conversationReady = false; alice2Id = Manager::instance().addAccount(details); // Should retrieve conversation, no need for action as the convInfos is in the archive - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&] { return alice2Ready && conversationReady; })); + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&] { return !alice2Data.conversationId.empty(); })); - messageBobReceived = 0; + auto bobMsgSize = bobData.messages.size(); libjami::sendMessage(alice2Id, convId, std::string("hi"), ""); - cv.wait_for(lk, 30s, [&]() { return messageBobReceived == 1; }); - libjami::unregisterSignalHandlers(); + cv.wait_for(lk, 30s, [&]() { return bobMsgSize + 1 == bobData.messages.size(); }); } void SyncHistoryTest::testSyncCreateAccountExportDeleteReimportWithConvReq() { + connectSignals(); auto aliceAccount = Manager::instance().getAccount(aliceId); - auto bobAccount = Manager::instance().getAccount(bobId); - auto bobUri = bobAccount->getUsername(); auto aliceUri = aliceAccount->getUsername(); // Start conversation auto convId = libjami::startConversation(bobId); - std::mutex mtx; - std::unique_lock lk {mtx}; - std::condition_variable cv; - std::map> confHandlers; - auto messageBobReceived = 0, messageAliceReceived = 0; - bool requestReceived = false; - bool conversationReady = false; - bool alice2Ready = false; - confHandlers.insert(libjami::exportable_callback( - [&](const std::string& accountId, - const std::string& /* conversationId */, - std::map /*message*/) { - if (accountId == bobId) { - messageBobReceived += 1; - } else { - messageAliceReceived += 1; - } - cv.notify_one(); - })); - confHandlers.insert( - libjami::exportable_callback( - [&](const std::string& accountId, - const std::string& /* conversationId */, - std::map /*metadatas*/) { - if (accountId == aliceId) - requestReceived = true; - cv.notify_one(); - })); - confHandlers.insert(libjami::exportable_callback( - [&](const std::string& accountId, const std::string& conversationId) { - if (accountId == bobId) { - conversationReady = true; - cv.notify_one(); - } - - if (accountId == alice2Id && conversationId == convId) { - conversationReady = true; - cv.notify_one(); - } - })); - confHandlers.insert( - libjami::exportable_callback( - [&](const std::string& accountId, const std::map& details) { - if (alice2Id != accountId) { - return; - } - alice2Ready = details.at(libjami::Account::VolatileProperties::DEVICE_ANNOUNCED) - == "true"; - cv.notify_one(); - })); - libjami::registerSignalHandlers(confHandlers); - libjami::addConversationMember(bobId, convId, aliceUri); - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return requestReceived; })); + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return aliceData.requestReceived; })); // Backup alice after startConversation with member auto aliceArchive = std::filesystem::current_path().string() + "/alice.gz"; @@ -780,54 +660,24 @@ SyncHistoryTest::testSyncCreateAccountExportDeleteReimportWithConvReq() details[ConfProperties::ARCHIVE_PASSWORD] = ""; details[ConfProperties::ARCHIVE_PIN] = ""; details[ConfProperties::ARCHIVE_PATH] = aliceArchive; - conversationReady = false; alice2Id = Manager::instance().addAccount(details); - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&] { return alice2Ready; })); + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&] { return alice2Data.deviceAnnounced; })); // Should get the same request as before. - messageBobReceived = 0; + auto bobMsgSize = bobData.messages.size(); libjami::acceptConversationRequest(alice2Id, convId); CPPUNIT_ASSERT( - cv.wait_for(lk, 30s, [&]() { return conversationReady && messageBobReceived == 1; })); - libjami::unregisterSignalHandlers(); + cv.wait_for(lk, 30s, [&]() { return bobMsgSize + 1 == bobData.messages.size(); })); } void SyncHistoryTest::testSyncOneToOne() { + connectSignals(); auto aliceAccount = Manager::instance().getAccount(aliceId); auto bobAccount = Manager::instance().getAccount(bobId); - // Start conversation - std::string convId; - - std::mutex mtx; - std::unique_lock lk {mtx}; - std::condition_variable cv; - std::map> confHandlers; - auto conversationReady = false, alice2Ready = false; - confHandlers.insert(libjami::exportable_callback( - [&](const std::string& accountId, const std::string& conversationId) { - if (accountId == aliceId) - convId = conversationId; - else if (accountId == alice2Id && conversationId == convId) - conversationReady = true; - cv.notify_one(); - })); - confHandlers.insert( - libjami::exportable_callback( - [&](const std::string& accountId, const std::map& details) { - if (alice2Id != accountId) { - return; - } - alice2Ready = details.at(libjami::Account::VolatileProperties::DEVICE_ANNOUNCED) - == "true"; - cv.notify_one(); - })); - libjami::registerSignalHandlers(confHandlers); aliceAccount->addContact(bobAccount->getUsername()); - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&] { return !convId.empty(); })); - // Now create alice2 auto aliceArchive = std::filesystem::current_path().string() + "/alice.gz"; aliceAccount->exportArchive(aliceArchive); @@ -841,47 +691,28 @@ SyncHistoryTest::testSyncOneToOne() details[ConfProperties::ARCHIVE_PATH] = aliceArchive; alice2Id = Manager::instance().addAccount(details); - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&] { return alice2Ready && conversationReady; })); - libjami::unregisterSignalHandlers(); + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&] { return !alice2Data.conversationId.empty(); })); } void SyncHistoryTest::testConversationRequestRemoved() { + connectSignals(); auto aliceAccount = Manager::instance().getAccount(aliceId); + auto uri = aliceAccount->getUsername(); // Export alice auto aliceArchive = std::filesystem::current_path().string() + "/alice.gz"; aliceAccount->exportArchive(aliceArchive); auto bobAccount = Manager::instance().getAccount(bobId); - auto uri = aliceAccount->getUsername(); // Start conversation for Alice auto convId = libjami::startConversation(bobId); // Check that alice receives the request - std::mutex mtx; - std::unique_lock lk {mtx}; - std::condition_variable cv; - std::map> confHandlers; - auto requestReceived = false; - confHandlers.insert( - libjami::exportable_callback( - [&](const std::string& accountId, - const std::string& conversationId, - std::map /*metadatas*/) { - if (accountId == aliceId && conversationId == convId) { - requestReceived = true; - cv.notify_one(); - } - })); - libjami::registerSignalHandlers(confHandlers); - libjami::addConversationMember(bobId, convId, uri); - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&] { return requestReceived; })); - libjami::unregisterSignalHandlers(); - confHandlers.clear(); + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&] { return aliceData.requestReceived; })); // Now create alice2 std::map details = libjami::getAccountTemplate("RING"); @@ -894,43 +725,17 @@ SyncHistoryTest::testConversationRequestRemoved() details[ConfProperties::ARCHIVE_PATH] = aliceArchive; alice2Id = Manager::instance().addAccount(details); - requestReceived = false; - bool requestDeclined = false, requestDeclined2 = false; - confHandlers.insert( - libjami::exportable_callback( - [&](const std::string& accountId, - const std::string& conversationId, - std::map /*metadatas*/) { - if (accountId == alice2Id && conversationId == convId) { - requestReceived = true; - cv.notify_one(); - } - })); - confHandlers.insert( - libjami::exportable_callback( - [&](const std::string& accountId, const std::string& conversationId) { - if (conversationId != convId) - return; - if (accountId == aliceId) - requestDeclined = true; - if (accountId == alice2Id) - requestDeclined2 = true; - cv.notify_one(); - })); - libjami::registerSignalHandlers(confHandlers); - - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&] { return requestReceived; })); + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&] { return aliceData.requestReceived; })); // Now decline trust request, this should trigger ConversationRequestDeclined both sides for Alice libjami::declineConversationRequest(aliceId, convId); - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&] { return requestDeclined && requestDeclined2; })); - - libjami::unregisterSignalHandlers(); + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&] { return aliceData.requestRemoved && alice2Data.requestRemoved; })); } void SyncHistoryTest::testProfileReceivedMultiDevice() { + connectSignals(); auto aliceAccount = Manager::instance().getAccount(aliceId); auto bobAccount = Manager::instance().getAccount(bobId); auto aliceUri = aliceAccount->getUsername(); @@ -946,9 +751,9 @@ VERSION:2.1\n\ FN:TITLE\n\ DESCRIPTION:DESC\n\ END:VCARD"; - auto alicePath = fileutils::get_data_dir() / aliceAccount->getAccountID() + auto alicePath = fileutils::get_data_dir() / aliceId / "profile.vcf"; - auto bobPath = fileutils::get_data_dir() / bobAccount->getAccountID() + auto bobPath = fileutils::get_data_dir() / bobId / "profile.vcf"; // Save VCard auto p = std::filesystem::path(alicePath); @@ -966,59 +771,15 @@ END:VCARD"; bobFile.close(); } - std::mutex mtx; - std::unique_lock lk {mtx}; - std::condition_variable cv; - std::map> confHandlers; - bool conversationReady = false, requestReceived = false, bobProfileReceived = false, - aliceProfileReceived = false, bobProfileReceivedAlice2 = false; - std::string convId = ""; - std::string bobDest = aliceAccount->dataTransfer()->profilePath(bobUri); - confHandlers.insert(libjami::exportable_callback( - [&](const std::string& account_id, - const std::string& /*from*/, - const std::string& /*conversationId*/, - const std::vector& /*payload*/, - time_t /*received*/) { - if (account_id == bobId) - requestReceived = true; - cv.notify_one(); - })); - confHandlers.insert(libjami::exportable_callback( - [&](const std::string& accountId, const std::string& conversationId) { - if (accountId == aliceId) { - convId = conversationId; - } else if (accountId == bobId) { - conversationReady = true; - } - cv.notify_one(); - })); - confHandlers.insert(libjami::exportable_callback( - [&](const std::string& accountId, const std::string& peerId, const std::string& path) { - if (accountId == aliceId && peerId == bobUri) { - bobProfileReceived = true; - auto p = std::filesystem::path(bobDest); - dhtnet::fileutils::recursive_mkdir(p.parent_path()); - std::rename(path.c_str(), bobDest.c_str()); - } else if (accountId == bobId && peerId == aliceUri) { - aliceProfileReceived = true; - } else if (accountId == alice2Id && peerId == bobUri) { - bobProfileReceivedAlice2 = true; - } else if (accountId == alice2Id && peerId == aliceUri) { - aliceProfileReceived = true; - } - cv.notify_one(); - })); - libjami::registerSignalHandlers(confHandlers); aliceAccount->addContact(bobUri); aliceAccount->sendTrustRequest(bobUri, {}); - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return requestReceived; })); + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return bobData.requestReceived; })); CPPUNIT_ASSERT(bobAccount->acceptTrustRequest(aliceUri)); CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { - return conversationReady && bobProfileReceived && aliceProfileReceived; + return !bobData.profilePath.empty() && !aliceData.profilePath.empty() && !bobData.conversationId.empty(); })); - CPPUNIT_ASSERT(std::filesystem::is_regular_file(bobDest)); + CPPUNIT_ASSERT(std::filesystem::is_regular_file(bobData.profilePath)); // Now create alice2 std::map details = libjami::getAccountTemplate("RING"); @@ -1029,96 +790,44 @@ END:VCARD"; details[ConfProperties::ARCHIVE_PASSWORD] = ""; details[ConfProperties::ARCHIVE_PIN] = ""; details[ConfProperties::ARCHIVE_PATH] = aliceArchive; - bobProfileReceived = false, aliceProfileReceived = false; + bobData.profilePath = {}; + alice2Data.profilePath = {}; alice2Id = Manager::instance().addAccount(details); - CPPUNIT_ASSERT(cv.wait_for(lk, 60s, [&] { return aliceProfileReceived && bobProfileReceivedAlice2; })); - libjami::unregisterSignalHandlers(); + CPPUNIT_ASSERT(cv.wait_for(lk, 60s, [&] { + return alice2Data.deviceAnnounced && !bobData.profilePath.empty() && !alice2Data.profilePath.empty(); })); } void SyncHistoryTest::testLastInteractionAfterClone() { + connectSignals(); auto aliceAccount = Manager::instance().getAccount(aliceId); auto aliceUri = aliceAccount->getUsername(); auto bobAccount = Manager::instance().getAccount(bobId); auto bobUri = bobAccount->getUsername(); - std::string convId; - - std::mutex mtx; - std::unique_lock lk {mtx}; - std::condition_variable cv; - std::map> confHandlers; - auto messageReceived = false; - std::string msgId = ""; - confHandlers.insert(libjami::exportable_callback( - [&](const std::string& accountId , - const std::string& /* conversationId */, - std::map message) { - if (accountId == bobId) { - messageReceived = true; - msgId = message["id"]; - cv.notify_one(); - } - })); - auto conversationReady = false; - confHandlers.insert(libjami::exportable_callback( - [&](const std::string& accountId, const std::string& conversationId) { - if (accountId == bobId || accountId == alice2Id) { - convId = conversationId; - conversationReady = true; - } - cv.notify_one(); - })); - auto requestReceived = false; - confHandlers.insert( - libjami::exportable_callback( - [&](const std::string& accountId, - const std::string& /*conversationId*/, - std::map /*metadatas*/) { - if (accountId == bobId) - requestReceived = true; - cv.notify_one(); - })); - auto messageDisplayed = false; - confHandlers.insert( - libjami::exportable_callback( - [&](const std::string& accountId, - const std::string& /* conversationId */, - const std::string& /* username */, - const std::string& /* msgId */, - int status) { - if (bobId == accountId && status == 3) - messageDisplayed = true; - cv.notify_one(); - })); - libjami::registerSignalHandlers(confHandlers); - confHandlers.clear(); aliceAccount->addContact(bobUri); aliceAccount->sendTrustRequest(bobUri, {}); - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return requestReceived; })); + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return bobData.requestReceived; })); + auto aliceMsgSize = aliceData.messages.size(); CPPUNIT_ASSERT(bobAccount->acceptTrustRequest(aliceUri)); - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return conversationReady; })); + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return aliceMsgSize + 1 == aliceData.messages.size(); })); // Start conversation - messageReceived = false; - libjami::sendMessage(bobId, convId, std::string("Message 1"), ""); - CPPUNIT_ASSERT(cv.wait_for(lk, 10s, [&] { return messageReceived; })); - messageReceived = false; - libjami::sendMessage(bobId, convId, std::string("Message 2"), ""); - CPPUNIT_ASSERT(cv.wait_for(lk, 10s, [&] { return messageReceived; })); - messageReceived = false; - libjami::sendMessage(bobId, convId, std::string("Message 3"), ""); - CPPUNIT_ASSERT(cv.wait_for(lk, 10s, [&] { return messageReceived; })); + libjami::sendMessage(bobId, aliceData.conversationId, std::string("Message 1"), ""); + CPPUNIT_ASSERT(cv.wait_for(lk, 10s, [&] { return aliceMsgSize + 2 == aliceData.messages.size(); })); + libjami::sendMessage(bobId, aliceData.conversationId, std::string("Message 2"), ""); + CPPUNIT_ASSERT(cv.wait_for(lk, 10s, [&] { return aliceMsgSize + 3 == aliceData.messages.size(); })); + libjami::sendMessage(bobId, aliceData.conversationId, std::string("Message 3"), ""); + CPPUNIT_ASSERT(cv.wait_for(lk, 10s, [&] { return aliceMsgSize + 4 == aliceData.messages.size(); })); - messageDisplayed = false; - libjami::setMessageDisplayed(aliceId, "swarm:" + convId, msgId, 3); - CPPUNIT_ASSERT(cv.wait_for(lk, 10s, [&] { return messageDisplayed; })); + auto msgId = aliceData.messages.rbegin()->id; + libjami::setMessageDisplayed(aliceId, "swarm:" + aliceData.conversationId, msgId, 3); + CPPUNIT_ASSERT(cv.wait_for(lk, 10s, [&] { return aliceData.sent; })); // Now create alice2 - conversationReady = false; auto aliceArchive = std::filesystem::current_path().string() + "/alice.gz"; aliceAccount->exportArchive(aliceArchive); std::map details = libjami::getAccountTemplate("RING"); @@ -1132,9 +841,9 @@ SyncHistoryTest::testLastInteractionAfterClone() alice2Id = Manager::instance().addAccount(details); // Check if conversation is ready - CPPUNIT_ASSERT(cv.wait_for(lk, 60s, [&]() { return conversationReady; })); + CPPUNIT_ASSERT(cv.wait_for(lk, 60s, [&]() { return !alice2Data.conversationId.empty(); })); // Check that last displayed is synched - auto membersInfos = libjami::getConversationMembers(alice2Id, convId); + auto membersInfos = libjami::getConversationMembers(alice2Id, alice2Data.conversationId); CPPUNIT_ASSERT(std::find_if(membersInfos.begin(), membersInfos.end(), [&](auto infos) { @@ -1147,65 +856,11 @@ SyncHistoryTest::testLastInteractionAfterClone() void SyncHistoryTest::testLastInteractionAfterSomeMessages() { + connectSignals(); auto aliceAccount = Manager::instance().getAccount(aliceId); auto aliceUri = aliceAccount->getUsername(); auto bobAccount = Manager::instance().getAccount(bobId); auto bobUri = bobAccount->getUsername(); - std::string convId; - - std::mutex mtx; - std::unique_lock lk {mtx}; - std::condition_variable cv; - std::map> confHandlers; - auto messageReceived = false; - std::string msgId = ""; - confHandlers.insert(libjami::exportable_callback( - [&](const std::string& /* accountId */, - const std::string& /* conversationId */, - std::map message) { - messageReceived = true; - msgId = message["id"]; - cv.notify_one(); - })); - auto conversationReady = false, conversationAlice2Ready = false; - confHandlers.insert(libjami::exportable_callback( - [&](const std::string& accountId, const std::string& conversationId) { - if (accountId == bobId) { - convId = conversationId; - conversationReady = true; - } else if (accountId == alice2Id) { - conversationAlice2Ready = true; - } - cv.notify_one(); - })); - auto requestReceived = false; - confHandlers.insert( - libjami::exportable_callback( - [&](const std::string& accountId, - const std::string& /*conversationId*/, - std::map /*metadatas*/) { - if (accountId == bobId) - requestReceived = true; - cv.notify_one(); - })); - auto messageDisplayed = false, messageDisplayedAlice2 = false; - confHandlers.insert( - libjami::exportable_callback( - [&](const std::string& accountId, - const std::string& /* conversationId */, - const std::string& /* username */, - const std::string& msgId, - int status) { - if (status == 3) { - if (accountId == aliceId) - messageDisplayed = true; - else if (accountId == alice2Id) - messageDisplayedAlice2 = true; - } - cv.notify_one(); - })); - libjami::registerSignalHandlers(confHandlers); - confHandlers.clear(); // Creates alice2 auto aliceArchive = std::filesystem::current_path().string() + "/alice.gz"; @@ -1222,30 +877,26 @@ SyncHistoryTest::testLastInteractionAfterSomeMessages() aliceAccount->addContact(bobUri); aliceAccount->sendTrustRequest(bobUri, {}); - CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return requestReceived; })); + CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&]() { return bobData.requestReceived && !alice2Data.conversationId.empty(); })); + auto aliceMsgSize = aliceData.messages.size(); CPPUNIT_ASSERT(bobAccount->acceptTrustRequest(aliceUri)); CPPUNIT_ASSERT( - cv.wait_for(lk, 30s, [&]() { return conversationReady && conversationAlice2Ready; })); + cv.wait_for(lk, 30s, [&]() { return aliceMsgSize + 1 == aliceData.messages.size(); })); // Start conversation - messageReceived = false; - libjami::sendMessage(bobId, convId, std::string("Message 1"), ""); - CPPUNIT_ASSERT(cv.wait_for(lk, 10s, [&] { return messageReceived; })); - messageReceived = false; - libjami::sendMessage(bobId, convId, std::string("Message 2"), ""); - CPPUNIT_ASSERT(cv.wait_for(lk, 10s, [&] { return messageReceived; })); - messageReceived = false; - libjami::sendMessage(bobId, convId, std::string("Message 3"), ""); - CPPUNIT_ASSERT(cv.wait_for(lk, 10s, [&] { return messageReceived; })); + libjami::sendMessage(bobId, aliceData.conversationId, std::string("Message 1"), ""); + CPPUNIT_ASSERT(cv.wait_for(lk, 10s, [&] { return aliceMsgSize + 2 == aliceData.messages.size(); })); + libjami::sendMessage(bobId, aliceData.conversationId, std::string("Message 2"), ""); + CPPUNIT_ASSERT(cv.wait_for(lk, 10s, [&] { return aliceMsgSize + 3 == aliceData.messages.size(); })); + libjami::sendMessage(bobId, aliceData.conversationId, std::string("Message 3"), ""); + CPPUNIT_ASSERT(cv.wait_for(lk, 10s, [&] { return aliceMsgSize + 4 == aliceData.messages.size(); })); - messageDisplayed = false; - messageDisplayedAlice2 = false; - auto displayedId = msgId; - libjami::setMessageDisplayed(aliceId, "swarm:" + convId, displayedId, 3); - CPPUNIT_ASSERT(cv.wait_for(lk, 20s, [&] { return messageDisplayed && messageDisplayedAlice2; })); + auto displayedId = aliceData.messages.rbegin()->id; + libjami::setMessageDisplayed(aliceId, "swarm:" + aliceData.conversationId, displayedId, 3); + CPPUNIT_ASSERT(cv.wait_for(lk, 20s, [&] { return aliceData.sent && alice2Data.sent; })); - auto membersInfos = libjami::getConversationMembers(alice2Id, convId); + auto membersInfos = libjami::getConversationMembers(alice2Id, alice2Data.conversationId); CPPUNIT_ASSERT(std::find_if(membersInfos.begin(), membersInfos.end(), [&](auto infos) {