+ * Copyright (c) 2010-2018 Isode Limited.

+ChatController::ChatController(const JID& self, StanzaChannel* stanzaChannel, IQRouter* iqRouter, ChatWindowFactory* chatWindowFactory, const JID &contact, NickResolver* nickResolver, PresenceOracle* presenceOracle, AvatarManager* avatarManager, bool isInMUC, bool useDelayForLatency, UIEventStream* eventStream, TimerFactory* timerFactory, EventController* eventController, EntityCapsProvider* entityCapsProvider, bool userWantsReceipts, HistoryController* historyController, MUCRegistry* mucRegistry, HighlightManager* highlightManager, ClientBlockListManager* clientBlockListManager, std::shared_ptr<ChatMessageParser> chatMessageParser, AutoAcceptMUCInviteDecider* autoAcceptMUCInviteDecider, SettingsProvider* settings, Chattables& chattables)

+ : ChatControllerBase(self, stanzaChannel, iqRouter, chatWindowFactory, contact, nickResolver, presenceOracle, avatarManager, useDelayForLatency, eventStream, eventController, entityCapsProvider, historyController, mucRegistry, highlightManager, chatMessageParser, autoAcceptMUCInviteDecider, settings, chattables), userWantsReceipts_(userWantsReceipts), clientBlockListManager_(clientBlockListManager) {

+ failedStanzas_[stanzaIdPair.second] = stanzaIdPair.first;

+ * Copyright (c) 2010-2018 Isode Limited.

+ ChatController(const JID& self, StanzaChannel* stanzaChannel, IQRouter* iqRouter, ChatWindowFactory* chatWindowFactory, const JID &contact, NickResolver* nickResolver, PresenceOracle* presenceOracle, AvatarManager* avatarManager, bool isInMUC, bool useDelayForLatency, UIEventStream* eventStream, TimerFactory* timerFactory, EventController* eventController, EntityCapsProvider* entityCapsProvider, bool userWantsReceipts, HistoryController* historyController, MUCRegistry* mucRegistry, HighlightManager* highlightManager, ClientBlockListManager* clientBlockListManager, std::shared_ptr<ChatMessageParser> chatMessageParser, AutoAcceptMUCInviteDecider* autoAcceptMUCInviteDecider, SettingsProvider* settings, Chattables& chattables);

+ virtual ~ChatController() override;

+ virtual void setToJID(const JID& jid) override;

+ virtual void setAvailableServerFeatures(std::shared_ptr<DiscoInfo> info) override;

+ virtual void setOnline(bool online) override;

+ virtual void setContactIsReceivingPresence(bool /*isReceivingPresence*/) override;

+ virtual ChatWindow* detachChatWindow() override;

+ virtual void handleIncomingOwnMessage(std::shared_ptr<Message> message) override;

+ virtual void cancelReplaces() override;

+ virtual JID getBaseJID() override;

+ virtual void logMessage(const std::string& message, const JID& fromJID, const JID& toJID, const boost::posix_time::ptime& timeStamp, bool isIncoming) override;

+ virtual bool shouldIgnoreMessage(std::shared_ptr<Message> message) override;

+ virtual JID messageCorrectionJID(const JID& fromJID) override;

+ virtual bool isIncomingMessageFromMe(std::shared_ptr<Message> message) override;

+ virtual void postSendMessage(const std::string &body, std::shared_ptr<Stanza> sentStanza) override;

+ virtual void preHandleIncomingMessage(std::shared_ptr<MessageEvent> messageEvent) override;

+ virtual void addMessageHandleIncomingMessage(const JID& from, const ChatWindow::ChatMessage& message, const std::string& messageID, bool senderIsSelf, std::shared_ptr<SecurityLabel> label, const boost::posix_time::ptime& timeStamp) override;

+ virtual void handleIncomingReplaceMessage(const JID& from, const ChatWindow::ChatMessage& message, const std::string& messageID, const std::string& idToReplace, bool senderIsSelf, std::shared_ptr<SecurityLabel> label, const boost::posix_time::ptime& timeStamp) override;

+ virtual void postHandleIncomingMessage(std::shared_ptr<MessageEvent> messageEvent, const ChatWindow::ChatMessage& chatMessage) override;

+ virtual void preSendMessageRequest(std::shared_ptr<Message>) override;

+ virtual std::string senderHighlightNameFromMessage(const JID& from) override;

+ virtual std::string senderDisplayNameFromMessage(const JID& from) override;

+ virtual boost::optional<boost::posix_time::ptime> getMessageTimestamp(std::shared_ptr<Message>) const override;

+ virtual void dayTicked() override { lastWasPresence_ = false; }

+ virtual void handleBareJIDCapsChanged(const JID& jid) override;

+ * Copyright (c) 2010-2018 Isode Limited.

+#include <Swiften/Elements/DeliveryReceipt.h>

+#include <Swiften/Elements/DeliveryReceiptRequest.h>

+#include <Swift/Controllers/Chat/Chattables.h>

+ChatControllerBase::ChatControllerBase(const JID& self, StanzaChannel* stanzaChannel, IQRouter* iqRouter, ChatWindowFactory* chatWindowFactory, const JID &toJID, NickResolver* nickResolver, PresenceOracle* presenceOracle, AvatarManager* avatarManager, bool useDelayForLatency, UIEventStream* eventStream, EventController* eventController, EntityCapsProvider* entityCapsProvider, HistoryController* historyController, MUCRegistry* mucRegistry, HighlightManager* highlightManager, std::shared_ptr<ChatMessageParser> chatMessageParser, AutoAcceptMUCInviteDecider* autoAcceptMUCInviteDecider, SettingsProvider* settings, Chattables& chattables) : selfJID_(self), stanzaChannel_(stanzaChannel), iqRouter_(iqRouter), chatWindowFactory_(chatWindowFactory), toJID_(toJID), labelsEnabled_(false), presenceOracle_(presenceOracle), avatarManager_(avatarManager), useDelayForLatency_(useDelayForLatency), eventController_(eventController), entityCapsProvider_(entityCapsProvider), historyController_(historyController), mucRegistry_(mucRegistry), chatMessageParser_(chatMessageParser), autoAcceptMUCInviteDecider_(autoAcceptMUCInviteDecider), eventStream_(eventStream), roomSecurityMarking_(""), previousMessageSecurityMarking_(""), settings_(settings), chattables_(chattables) {

+ scopedConnectionResendMessage_ = chatWindow_->onResendMessageRequest.connect(boost::bind(&ChatControllerBase::handleResendMessageRequest, this, _1));

+ scopedConnectionResendMessage_.disconnect();

+size_t ChatControllerBase::getUnreadCount() {

+ return targetedUnreadMessages_.size();

+ auto baseJID = getBaseJID();

+ auto state = chattables_.getState(baseJID);

+ state.unreadCount = unreadMessages_.size();

+ chatWindow_->setUnreadMessageCount(state.unreadCount);

+ chattables_.setState(baseJID, state);

+#ifndef NOT_YET

+#endif

+ auto displayedLabel = label;

+

+ if (settings_->getSetting(SettingConstants::MUC_MARKING_ELISION)) {

+ if (roomSecurityMarking_ != "") {

+

+ if (label && label->getDisplayMarking() == roomSecurityMarking_) {

+ if (label->getDisplayMarking() == previousMessageSecurityMarking_) {

+ displayedLabel = std::make_shared<SecurityLabel>();

+ }

+ previousMessageSecurityMarking_ = label->getDisplayMarking();

+ }

+ else if (!label || label->getDisplayMarking().empty()) {

+ displayedLabel = std::make_shared<SecurityLabel>();

+ displayedLabel->setDisplayMarking("Unmarked");

+ previousMessageSecurityMarking_ = "Unmarked";

+ }

+ else {

+ previousMessageSecurityMarking_ = displayedLabel->getDisplayMarking();

+ }

+ }

+ }

+

+ return chatWindow_->addAction(chatMessage, senderName, senderIsSelf, displayedLabel, pathToString(avatarPath), time);

+ return chatWindow_->addMessage(chatMessage, senderName, senderIsSelf, displayedLabel, pathToString(avatarPath), time);

+#ifdef SWIFT_EXPERIMENTAL_HISTORY

+#endif

+ eventStream_->send(std::make_shared<JoinMUCUIEvent>(invite->getJID(), boost::optional<std::string>(), boost::optional<std::string>(), false, true));

+void ChatControllerBase::handleResendMessageRequest(const std::string& id) {

+ if (failedStanzas_.find(id) != failedStanzas_.end()) {

+ if (auto resendMsg = std::dynamic_pointer_cast<Message>(failedStanzas_[id])) {

+ stanzaChannel_->sendMessage(resendMsg);

+ if (stanzaChannel_->getStreamManagementEnabled()) {

+ chatWindow_->setAckState(id, ChatWindow::Pending);

+ unackedStanzas_[failedStanzas_[id]] = id;

+ }

+ if (resendMsg->getPayload<DeliveryReceiptRequest>()) {

+ requestedReceipts_[resendMsg->getID()] = id;

+ chatWindow_->setMessageReceiptState(id, ChatWindow::ReceiptRequested);

+ }

+ lastWasPresence_ = false;

+ failedStanzas_.erase(id);

+ }

+ }

+}

+

+ * Copyright (c) 2010-2018 Isode Limited.

+#include <Swift/Controllers/Settings/SettingsProvider.h>

+ class Chattables;

+ class HighlightManager;

+ size_t getUnreadCount();

+ ChatControllerBase(const JID& self, StanzaChannel* stanzaChannel, IQRouter* iqRouter, ChatWindowFactory* chatWindowFactory, const JID &toJID, NickResolver* nickResolver, PresenceOracle* presenceOracle, AvatarManager* avatarManager, bool useDelayForLatency, UIEventStream* eventStream, EventController* eventController, EntityCapsProvider* entityCapsProvider, HistoryController* historyController, MUCRegistry* mucRegistry, HighlightManager* highlightManager, std::shared_ptr<ChatMessageParser> chatMessageParser, AutoAcceptMUCInviteDecider* autoAcceptMUCInviteDecider, SettingsProvider* settings, Chattables& chattables);

+ virtual void handleResendMessageRequest(const std::string& id);

+ std::string roomSecurityMarking_;

+ std::string previousMessageSecurityMarking_;

+ SettingsProvider* settings_;

+ boost::signals2::scoped_connection scopedConnectionResendMessage_;

+ std::map<std::string, std::string> requestedReceipts_;

+ std::map<std::shared_ptr<Stanza>, std::string> unackedStanzas_;

+ std::map<std::string, std::shared_ptr<Stanza>> failedStanzas_;

+ Chattables& chattables_;

+#include <Swift/Controllers/Chat/Chattables.h>

+#ifndef NOT_YET

+#endif

+#ifndef NOT_YET

+#endif

+ VCardManager* vcardManager,

+ Chattables& chattables) :

+ vcardManager_(vcardManager),

+ chattables_(chattables) {

+#ifndef NOT_YET

+#endif

+ chattables_.onActivated.connect(boost::bind(&ChatsManager::handleChattableActivated, this, _1));

+

+#ifndef NOT_YET

+#endif

+ chattables_.onActivated.disconnect(boost::bind(&ChatsManager::handleChattableActivated, this, _1));

+#ifndef NOT_YET

+#endif

+#ifndef NOT_YET

+#endif

+#ifndef NOT_YET

+#endif

+#ifndef NOT_YET

+#endif

+ handleJoinMUCRequest(bookmark.getRoom(), bookmark.getPassword(), bookmark.getNick(), false, false);

+#ifndef NOT_YET

+ //Only one entry of the bookmark should exist

+ chatListWindow_->removeMUCBookmark(bookmark);

+#endif

+ chattables_.addJID(bookmark.getRoom(), Chattables::State::Type::Room);

+#ifndef NOT_YET

+#endif

+#ifndef NOT_YET

+ size_t unreadCount = 0;

+#endif

+#ifndef NOT_YET

+#endif

+#ifndef NOT_YET

+#endif

+#ifndef NOT_YET

+

+ size_t unreadTotal = 0;

+#endif

+#ifndef NOT_YET

+#endif

+#ifndef NOT_YET

+#endif

+ const auto& jid = it->first;

+ auto state = chattables_.getState(jid);

+ state.status = StatusShow::None;

+ chattables_.setState(jid, state);

+ //If user deletes bookmark from chatListWindow_ and then decides to leave the room, or if the server doesn't support bookmarks, the bookmark will not exist.

+ if (auto bookmarkFound = mucBookmarkManager_->lookupBookmark(jid)) {

+ MUCBookmark newBookmark(bookmarkFound.get());

+ newBookmark.setAutojoin(false);

+ mucBookmarkManager_->replaceBookmark(bookmarkFound.get(), newBookmark);

+ }

+#ifndef NOT_YET

+#endif

+ MUC::ref muc = handleJoinMUCRequest(roomJID, boost::optional<std::string>(), nickResolver_->jidToNick(jid_), true, true);

+ handleJoinMUCRequest(joinEvent->getJID(), joinEvent->getPassword(), joinEvent->getNick(), joinEvent->getCreateAsReservedRoomIfNew(), joinEvent->isImpromptu());

+#ifndef NOT_YET

+#endif

+ MUC::ref muc = handleJoinMUCRequest(roomJID, boost::optional<std::string>(), nickResolver_->jidToNick(jid_), true, true, chatWindow);

+#ifndef NOT_YET

+#endif

+

+#ifndef NOT_YET

+#endif

+#ifndef NOT_YET

+#endif

+#ifndef NOT_YET

+#endif

+ auto controller = new ChatController(jid_, stanzaChannel_, iqRouter_, chatWindowFactory_, contact, nickResolver_, presenceOracle_, avatarManager_, mucRegistry_->isMUC(contact.toBare()), useDelayForLatency_, uiEventStream_, timerFactory_, eventController_, entityCapsProvider_, userWantsReceipts_, historyController_, mucRegistry_, highlightManager_, clientBlockListManager_, chatMessageParser, autoAcceptMUCInviteDecider_, settings_, chattables_);

+#ifndef NOT_YET

+#endif

+MUC::ref ChatsManager::handleJoinMUCRequest(const JID &mucJID, const boost::optional<std::string>& password, const boost::optional<std::string>& nickMaybe, bool createAsReservedIfNew, bool isImpromptu, ChatWindow* reuseChatwindow) {

+ controller = new MUCController(jid_, muc, password, nick, stanzaChannel_, iqRouter_, reuseChatwindow ? chatWindowFactoryAdapter : chatWindowFactory_, nickResolver_, presenceOracle_, avatarManager_, uiEventStream_, false, timerFactory_, eventController_, entityCapsProvider_, roster_, historyController_, mucRegistry_, highlightManager_, clientBlockListManager_, chatMessageParser, isImpromptu, autoAcceptMUCInviteDecider_, vcardManager_, mucBookmarkManager_, settings_, chattables_);

+ chattables_.addJID(muc->getJID(), Chattables::State::Type::Room);

+ auto state = chattables_.getState(muc->getJID());

+ state.status = StatusShow::Online;

+ chattables_.setState(muc->getJID(), state);

+#ifndef NOT_YET

+ controller->onUnreadCountChanged.connect(boost::bind(&ChatsManager::handleUnreadCountChanged, this, controller));

+#endif

+#ifndef NOT_YET

+#endif

+ if (auto existingBookmark = mucBookmarkManager_->lookupBookmark(mucJID)) {

+ if (!existingBookmark->getAutojoin()) {

+ MUCBookmark newbookmark(existingBookmark.get());

+ newbookmark.setAutojoin(true);

+ mucBookmarkManager_->replaceBookmark(*existingBookmark, newbookmark);

+ }

+ }

+ else {

+ MUCBookmark bookmark(mucJID, mucJID.getNode());

+ bookmark.setAutojoin(true);

+ if (nickMaybe) {

+ bookmark.setNick(*nickMaybe);

+ }

+ if (password) {

+ bookmark.setPassword(*password);

+ }

+ mucBookmarkManager_->addBookmark(bookmark);

+ }

+ handleJoinMUCRequest(invite->getJID(), boost::optional<std::string>(), boost::optional<std::string>(), false, true, window);

+ handleJoinMUCRequest(invite->getJID(), boost::optional<std::string>(), boost::optional<std::string>(), false, true);

+#ifndef NOT_YET

+ uiEventStream_->send(std::make_shared<JoinMUCUIEvent>(chat.jid, boost::optional<std::string>(), chat.nick, false, isImpromptu));

+#endif

+

+void ChatsManager::handleChattableActivated(const JID& jid) {

+ auto state = chattables_.getState(jid);

+ if (state.type == Chattables::State::Type::Person) {

+ uiEventStream_->send(std::make_shared<RequestChatUIEvent>(jid));

+ }

+ else if (state.type == Chattables::State::Type::Room) {

+ if (auto foundBookmark = mucBookmarkManager_->lookupBookmark(jid)) {

+ handleMUCBookmarkActivated(foundBookmark.get());

+ }

+ else {

+ uiEventStream_->send(std::make_shared<JoinMUCUIEvent>(jid, boost::optional<std::string>(), boost::optional<std::string>())); // Just a quick hack to reuse already open MUCs

+ }

+ }

+}

+

+#ifndef NOT_YET

+#endif

+#ifndef NOT_YET

+#endif

+ * Copyright (c) 2010-2018 Isode Limited.

+ class AutoAcceptMUCInviteDecider;

+ class AvatarManager;

+ class ChatListWindowFactory;

+ class ChatMessageParser;

+ class Chattables;

+ class ClientBlockListManager;

+ class DirectedPresenceSender;

+ class DiscoServiceWalker;

+ class EntityCapsProvider;

+ class EventController;

+ class FileTransferController;

+ class FileTransferOverview;

+ class HighlightManager;

+ class HistoryController;

+ class IQRouter;

+ class MUCBookmarkManager;

+ class MUCController;

+ class MUCManager;

+ class MUCSearchController;

+ class MUCSearchWindowFactory;

+ class StanzaChannel;

+ class TimerFactory;

+ class WhiteboardManager;

+ class XMPPRoster;

+ ChatsManager(JID jid, StanzaChannel* stanzaChannel, IQRouter* iqRouter, EventController* eventController, ChatWindowFactory* chatWindowFactory, JoinMUCWindowFactory* joinMUCWindowFactory, NickResolver* nickResolver, PresenceOracle* presenceOracle, PresenceSender* presenceSender, UIEventStream* uiEventStream, ChatListWindowFactory* chatListWindowFactory, bool useDelayForLatency, TimerFactory* timerFactory, MUCRegistry* mucRegistry, EntityCapsProvider* entityCapsProvider, MUCManager* mucManager, MUCSearchWindowFactory* mucSearchWindowFactory, ProfileSettingsProvider* profileSettings, FileTransferOverview* ftOverview, XMPPRoster* roster, bool eagleMode, SettingsProvider* settings, HistoryController* historyController_, WhiteboardManager* whiteboardManager, HighlightManager* highlightManager, ClientBlockListManager* clientBlockListManager, const std::map<std::string, std::string>& emoticons, VCardManager* vcardManager, Chattables& chattables);

+#ifndef NOT_YET

+#endif

+#ifndef NOT_YET

+#endif

+ MUC::ref handleJoinMUCRequest(const JID& muc, const boost::optional<std::string>& password, const boost::optional<std::string>& nick, bool createAsReservedIfNew, bool isImpromptu, ChatWindow* reuseChatwindow = nullptr);

+#ifndef NOT_YET

+#endif

+#ifndef NOT_YET

+#endif

+#ifndef NOT_YET

+#endif

+ void handleChattableActivated(const JID& jid);

+#ifndef NOT_YET

+#endif

+

+ protected:

+ MUCBookmarkManager* mucBookmarkManager_;

+

+#ifndef NOT_YET

+#endif

+#ifndef NOT_YET

+#endif

+ Chattables& chattables_;

+/*

+ * Copyright (c) 2018 Isode Limited.

+ * All rights reserved.

+ * See the COPYING file for more information.

+ */

+

+#include <Swift/Controllers/Chat/Chattables.h>

+

+namespace Swift {

+

+const std::vector<JID>& Chattables::get() const {

+ return list_;

+}

+

+const Chattables::State& Chattables::getState(const JID& jid) const {

+ auto it = states_.find(jid);

+ return it != states_.end() ? it->second : unknown_;

+}

+

+void Chattables::addJID(const JID& jid, State::Type type) {

+ if (states_.find(jid) != states_.end()) {

+ return;

+ }

+ State state;

+ state.type = type;

+ state.jid = jid;

+ onBeginAdd(static_cast<int>(list_.size()));

+ list_.push_back(jid);

+ states_[jid] = state;

+ onAdded();

+}

+

+void Chattables::setState(const JID& jid, State state) {

+ auto stateIter = states_.find(jid);

+ if (stateIter == states_.end()) {

+ return;

+ }

+ stateIter->second = state;

+ auto listPos = static_cast<int>(std::distance(list_.begin(), std::find(list_.begin(), list_.end(), jid)));

+ onChanged(jid, listPos);

+}

+

+}

+/*

+ * Copyright (c) 2018 Isode Limited.

+ * All rights reserved.

+ * See the COPYING file for more information.

+ */

+

+#pragma once

+

+#include <map>

+#include <vector>

+

+#include <boost/signals2.hpp>

+

+#include <Swiften/Elements/StatusShow.h>

+#include <Swiften/JID/JID.h>

+

+namespace Swift {

+class Chattables {

+ public:

+ struct State {

+ enum class Type {Room, Person};

+ JID jid;

+ /// Empty for no name

+ std::string name;

+ size_t unreadCount = 0;

+ Type type;

+ StatusShow::Type status = StatusShow::None;

+ //avatar

+ //status

+ };

+ const std::vector<JID>& get() const;

+ const State& getState(const JID& jid) const;

+

+ void addJID(const JID& jid, State::Type type);

+ void setState(const JID& jid, State state);

+

+ boost::signals2::signal<void (int)> onBeginAdd;

+ boost::signals2::signal<void ()> onAdded;

+ boost::signals2::signal<void (const JID&, int)> onChanged;

+ /// The UI has activated a chattable item (e.g. clicked in the roster)

+ boost::signals2::signal<void (const JID&)> onActivated;

+ private:

+ std::vector<JID> list_;

+ std::map<JID, State> states_;

+ State unknown_;

+};

+}

+ * Copyright (c) 2010-2018 Isode Limited.

+#include <Swiften/Disco/GetDiscoInfoRequest.h>

+#include <Swift/Controllers/Chat/Chattables.h>

+ MUCBookmarkManager* mucBookmarkManager,

+ SettingsProvider* settings,

+ Chattables& chattables) :

+ ChatControllerBase(self, stanzaChannel, iqRouter, chatWindowFactory, muc->getJID(), nickResolver, presenceOracle, avatarManager, useDelayForLatency, uiEventStream, eventController, entityCapsProvider, historyController, mucRegistry, highlightManager, chatMessageParser, autoAcceptMUCInviteDecider, settings, chattables), muc_(muc), nick_(nick), desiredNick_(nick), password_(password), renameCounter_(0), isImpromptu_(isImpromptu), isImpromptuAlreadyConfigured_(false), clientBlockListManager_(clientBlockListManager), mucBookmarkManager_(mucBookmarkManager) {

+ roster_ = std::make_unique<Roster>(false, true);

+ updateChatWindowBookmarkStatus(mucBookmarkManager_->lookupBookmark(muc->getJID()));

+

+ requestSecurityMarking();

+

+ actions.push_back(ChatWindow::Leave);

+void MUCController::requestSecurityMarking() {

+ auto discoInfoRequest = GetDiscoInfoRequest::create(muc_->getJID(), iqRouter_);

+ discoInfoRequest->onResponse.connect(

+ [this](std::shared_ptr<DiscoInfo> discoInfoRef, ErrorPayload::ref errorPayloadRef) {

+ if (!discoInfoRef || errorPayloadRef) {

+ return;

+ }

+ const std::vector<Form::ref>& extensionsList = discoInfoRef->getExtensions();

+ if (extensionsList.empty()) {

+ return;

+ }

+ // Get the correct form if it exists

+ Form::ref roomInfoForm;

+ for (const auto& form : extensionsList) {

+ if (form->getFormType() == "http://jabber.org/protocol/muc#roominfo") {

+ roomInfoForm = form;

+ break;

+ }

+ }

+ if (!roomInfoForm) {

+ return;

+ }

+ // It exists, now examine the security marking data

+ auto marking = roomInfoForm->getField("x-isode#roominfo_marking");

+ if (!marking) {

+ return;

+ }

+ // Now we know the marking is valid

+ auto markingValue = marking->getTextSingleValue();

+ if (markingValue == "") {

+ setMUCSecurityMarkingDefault();

+ return;

+ }

+ auto markingForegroundColor = roomInfoForm->getField("x-isode#roominfo_marking_fg_color");

+ auto markingBackgroundColor = roomInfoForm->getField("x-isode#roominfo_marking_bg_color");

+ std::string markingForegroundColorValue = "Black";

+ std::string markingBackgroundColorValue = "White";

+ if (markingForegroundColor && markingForegroundColor->getTextSingleValue() != "") {

+ markingForegroundColorValue = markingForegroundColor->getTextSingleValue();

+ }

+ if (markingBackgroundColor && markingBackgroundColor->getTextSingleValue() != "") {

+ markingBackgroundColorValue = markingBackgroundColor->getTextSingleValue();

+ }

+ setMUCSecurityMarking(markingValue, markingForegroundColorValue, markingBackgroundColorValue);

+ }

+ );

+ discoInfoRequest->send();

+}

+

+void MUCController::setMUCSecurityMarking(const std::string& markingValue, const std::string& markingForegroundColorValue, const std::string& markingBackgroundColorValue) {

+ roomSecurityMarking_ = markingValue;

+ chatWindow_->setChatSecurityMarking(markingValue, markingForegroundColorValue, markingBackgroundColorValue);

+}

+

+void MUCController::setMUCSecurityMarkingDefault() {

+ roomSecurityMarking_ = "";

+ chatWindow_->removeChatSecurityMarking();

+}

+

+ * Copyright (c) 2010-2018 Isode Limited.

+ MUCController(const JID& self, MUC::ref muc, const boost::optional<std::string>& password, const std::string &nick, StanzaChannel* stanzaChannel, IQRouter* iqRouter, ChatWindowFactory* chatWindowFactory, NickResolver* nickResolver, PresenceOracle* presenceOracle, AvatarManager* avatarManager, UIEventStream* events, bool useDelayForLatency, TimerFactory* timerFactory, EventController* eventController, EntityCapsProvider* entityCapsProvider, XMPPRoster* xmppRoster, HistoryController* historyController, MUCRegistry* mucRegistry, HighlightManager* highlightManager, ClientBlockListManager* clientBlockListManager, std::shared_ptr<ChatMessageParser> chatMessageParser, bool isImpromptu, AutoAcceptMUCInviteDecider* autoAcceptMUCInviteDecider, VCardManager* vcardManager, MUCBookmarkManager* mucBookmarkManager, SettingsProvider* settings, Chattables& chattables);

+ virtual ~MUCController() override;

+ virtual void setOnline(bool online) override;

+ virtual void setAvailableServerFeatures(std::shared_ptr<DiscoInfo> info) override;

+ virtual void preSendMessageRequest(std::shared_ptr<Message> message) override;

+ virtual bool isIncomingMessageFromMe(std::shared_ptr<Message> message) override;

+ virtual std::string senderHighlightNameFromMessage(const JID& from) override;

+ virtual std::string senderDisplayNameFromMessage(const JID& from) override;

+ virtual boost::optional<boost::posix_time::ptime> getMessageTimestamp(std::shared_ptr<Message> message) const override;

+ virtual void preHandleIncomingMessage(std::shared_ptr<MessageEvent>) override;

+ virtual void addMessageHandleIncomingMessage(const JID& from, const ChatWindow::ChatMessage& message, const std::string& messageID, bool senderIsSelf, std::shared_ptr<SecurityLabel> label, const boost::posix_time::ptime& time) override;

+ virtual void handleIncomingReplaceMessage(const JID& from, const ChatWindow::ChatMessage& message, const std::string& messageID, const std::string& idToReplace, bool senderIsSelf, std::shared_ptr<SecurityLabel> label, const boost::posix_time::ptime& timeStamp) override;

+ virtual void postHandleIncomingMessage(std::shared_ptr<MessageEvent>, const ChatWindow::ChatMessage& chatMessage) override;

+ virtual void cancelReplaces() override;

+ virtual void logMessage(const std::string& message, const JID& fromJID, const JID& toJID, const boost::posix_time::ptime& timeStamp, bool isIncoming) override;

+ virtual JID messageCorrectionJID(const JID& fromJID) override;

+ virtual void dayTicked() override { clearPresenceQueue(); }

+ virtual void handleBareJIDCapsChanged(const JID& jid) override;

+ void requestSecurityMarking();

+ void setMUCSecurityMarking(const std::string& markingValue, const std::string& markingForegroundColorValue, const std::string& markingBackgroundColorValue);

+ void setMUCSecurityMarkingDefault();

+

+/*

+ * Copyright (c) 2018 Isode Limited.

+ * All rights reserved.

+ * See the COPYING file for more information.

+ */

+

+#include <memory>

+#include <string>

+

+#include <gtest/gtest.h>

+#include <hippomocks.h>

+

+#include <Swiften/Avatars/NullAvatarManager.h>

+#include <Swiften/Client/ClientBlockListManager.h>

+#include <Swiften/Client/DummyStanzaChannel.h>

+#include <Swiften/Client/NickResolver.h>

+#include <Swiften/Disco/DummyEntityCapsProvider.h>

+#include <Swiften/Network/DummyTimerFactory.h>

+#include <Swiften/Queries/DummyIQChannel.h>

+#include <Swiften/Roster/XMPPRoster.h>

+#include <Swiften/Roster/XMPPRosterImpl.h>

+#include <Swiften/VCards/VCardManager.h>

+#include <Swiften/VCards/VCardMemoryStorage.h>

+

+#include <Swift/Controllers/Chat/AutoAcceptMUCInviteDecider.h>

+#include <Swift/Controllers/Chat/ChatController.h>

+#include <Swift/Controllers/Chat/ChatMessageParser.h>

+#include <Swift/Controllers/Chat/Chattables.h>

+#include <Swift/Controllers/Settings/DummySettingsProvider.h>

+#include <Swift/Controllers/UIEvents/UIEventStream.h>

+#include <Swift/Controllers/UIInterfaces/ChatWindowFactory.h>

+#include <Swift/Controllers/UnitTest/MockChatWindow.h>

+#include <Swift/Controllers/XMPPEvents/EventController.h>

+

+using namespace Swift;

+

+/**

+ * Most of the ChatController tests are in ChatsManagerTest.

+ * New tests related with ChatController should be added here,

+ * and old tests should be migrated when possible.

+ */

+

+class ExtendedChatController : public ChatController {

+public:

+ ExtendedChatController(const JID& self, StanzaChannel* stanzaChannel, IQRouter* iqRouter, ChatWindowFactory* chatWindowFactory, const JID &contact, NickResolver* nickResolver, PresenceOracle* presenceOracle, AvatarManager* avatarManager, bool isInMUC, bool useDelayForLatency, UIEventStream* eventStream, TimerFactory* timerFactory, EventController* eventController, EntityCapsProvider* entityCapsProvider, bool userWantsReceipts, HistoryController* historyController, MUCRegistry* mucRegistry, HighlightManager* highlightManager, ClientBlockListManager* clientBlockListManager, std::shared_ptr<ChatMessageParser> chatMessageParser, AutoAcceptMUCInviteDecider* autoAcceptMUCInviteDecider, SettingsProvider* settings, Chattables& chattables) :

+ ChatController(self, stanzaChannel, iqRouter, chatWindowFactory, contact, nickResolver, presenceOracle, avatarManager, isInMUC, useDelayForLatency, eventStream, timerFactory, eventController, entityCapsProvider, userWantsReceipts, historyController, mucRegistry, highlightManager, clientBlockListManager, chatMessageParser, autoAcceptMUCInviteDecider, settings, chattables) {

+ }

+

+ std::map<std::shared_ptr<Stanza>, std::string> getUnackedStanzas() { return unackedStanzas_; }

+ std::map<std::string, std::shared_ptr<Stanza>> getFailedStanzas() { return failedStanzas_; }

+};

+

+class ChatControllerTest : public ::testing::Test {

+protected:

+ virtual void SetUp() {

+ self_ = JID("alice@wonderland.lit");

+ other_ = JID("whiterabbit@wonderland.lit");

+ stanzaChannel_ = new DummyStanzaChannel();

+ iqChannel_ = new DummyIQChannel();

+ iqRouter_ = new IQRouter(iqChannel_);

+ eventController_ = new EventController();

+ xmppRoster_ = new XMPPRosterImpl();

+ vCardManager_ = new VCardManager(self_, iqRouter_, vCardMemoryStorage_);

+ mucRegistry_ = new MUCRegistry();

+ nickResolver_ = new NickResolver(self_, xmppRoster_, vCardManager_, mucRegistry_);

+ presenceOracle_ = new PresenceOracle(stanzaChannel_, xmppRoster_);

+ avatarManager_ = new NullAvatarManager();

+ uiEventStream_ = new UIEventStream();

+ timerFactory_ = new DummyTimerFactory();

+ entityCapsProvider_ = new DummyEntityCapsProvider();

+ settings_ = new DummySettingsProvider();

+ highlightManager_ = new HighlightManager(settings_);

+ highlightManager_->resetToDefaultConfiguration();

+ clientBlockListManager_ = new ClientBlockListManager(iqRouter_);

+ autoAcceptMUCInviteDecider_ = new AutoAcceptMUCInviteDecider(self_.getDomain(), xmppRoster_, settings_);

+ chatMessageParser_ = std::make_shared<ChatMessageParser>(std::map<std::string, std::string>(), highlightManager_->getConfiguration(), ChatMessageParser::Mode::GroupChat);

+ mocks_ = new MockRepository();

+ window_ = new MockChatWindow();

+ chatWindowFactory_ = mocks_->InterfaceMock<ChatWindowFactory>();

+ mocks_->ExpectCall(chatWindowFactory_, ChatWindowFactory::createChatWindow).With(other_, uiEventStream_).Return(window_);

+ chattables_ = std::make_unique<Chattables>();

+

+ controller_ = new ExtendedChatController(self_, stanzaChannel_, iqRouter_, chatWindowFactory_, other_, nickResolver_, presenceOracle_, avatarManager_, false, false, uiEventStream_, timerFactory_, eventController_, entityCapsProvider_, false, nullptr, mucRegistry_, highlightManager_, clientBlockListManager_, chatMessageParser_, nullptr, settings_, *chattables_);

+ }

+ virtual void TearDown() {

+ delete controller_;

+ chattables_.reset();

+ chatMessageParser_.reset();

+ delete autoAcceptMUCInviteDecider_;

+ delete clientBlockListManager_;

+ delete highlightManager_;

+ delete settings_;

+ delete entityCapsProvider_;

+ delete timerFactory_;

+ delete uiEventStream_;

+ delete avatarManager_;

+ delete presenceOracle_;

+ delete nickResolver_;

+ delete mucRegistry_;

+ delete vCardManager_;

+ delete xmppRoster_;

+ delete eventController_;

+ delete iqRouter_;

+ delete iqChannel_;

+ delete stanzaChannel_;

+ }

+

+ JID self_, other_;

+ AvatarManager* avatarManager_ = nullptr;

+ ExtendedChatController* controller_ = nullptr;

+ ChatWindowFactory* chatWindowFactory_;

+ ClientBlockListManager* clientBlockListManager_;

+ EventController* eventController_ = nullptr;

+ EntityCapsProvider* entityCapsProvider_ = nullptr;

+ IQChannel* iqChannel_ = nullptr;

+ IQRouter* iqRouter_ = nullptr;

+ MockRepository* mocks_;

+ MockChatWindow* window_;

+ MUCRegistry* mucRegistry_ = nullptr;

+ NickResolver* nickResolver_ = nullptr;

+ PresenceOracle* presenceOracle_ = nullptr;

+ DummyStanzaChannel* stanzaChannel_ = nullptr;

+ TimerFactory* timerFactory_;

+ XMPPRosterImpl* xmppRoster_ = nullptr;

+ UIEventStream* uiEventStream_;

+ VCardManager* vCardManager_ = nullptr;

+ VCardMemoryStorage* vCardMemoryStorage_ = nullptr;

+ DummySettingsProvider* settings_;

+ HighlightManager* highlightManager_;

+ std::shared_ptr<ChatMessageParser> chatMessageParser_;

+ AutoAcceptMUCInviteDecider* autoAcceptMUCInviteDecider_;

+ std::unique_ptr<Chattables> chattables_;

+

+};

+

+TEST_F(ChatControllerTest, testResendMessage) {

+ std::string msgBody("TestMsg");

+ stanzaChannel_->setStreamManagementEnabled(true);

+ window_->onSendMessageRequest(msgBody, false);

+ {

+ auto failedStanzas = controller_->getFailedStanzas();

+ auto unackedStanzas = controller_->getUnackedStanzas();

+ ASSERT_EQ(failedStanzas.size(), 0);

+ ASSERT_EQ(unackedStanzas.size(), 1);

+ }

+ //Disconnecting to fail the stanza

+ controller_->setOnline(false);

+ controller_->setOnline(true);

+ {

+ auto failedStanzas = controller_->getFailedStanzas();

+ auto unackedStanzas = controller_->getUnackedStanzas();

+ ASSERT_EQ(failedStanzas.size(), 1);

+ ASSERT_EQ(unackedStanzas.size(), 0);

+ }

+ window_->onResendMessageRequest("id");

+ {

+ auto failedStanzas = controller_->getFailedStanzas();

+ auto unackedStanzas = controller_->getUnackedStanzas();

+ ASSERT_EQ(failedStanzas.size(), 0);

+ ASSERT_EQ(unackedStanzas.size(), 1);

+ }

+}

+#include <Swiften/MUC/MUCBookmarkManager.h>

+#include <Swift/Controllers/Chat/Chattables.h>

+#include <Swift/Controllers/UIEvents/AddMUCBookmarkUIEvent.h>

+class ExtendedChatsManager : public ChatsManager {

+public:

+ ExtendedChatsManager(JID jid, StanzaChannel* stanzaChannel, IQRouter* iqRouter, EventController* eventController, ChatWindowFactory* chatWindowFactory, JoinMUCWindowFactory* joinMUCWindowFactory, NickResolver* nickResolver, PresenceOracle* presenceOracle, PresenceSender* presenceSender, UIEventStream* uiEventStream, ChatListWindowFactory* chatListWindowFactory, bool useDelayForLatency, TimerFactory* timerFactory, MUCRegistry* mucRegistry, EntityCapsProvider* entityCapsProvider, MUCManager* mucManager, MUCSearchWindowFactory* mucSearchWindowFactory, ProfileSettingsProvider* profileSettings, FileTransferOverview* ftOverview, XMPPRoster* roster, bool eagleMode, SettingsProvider* settings, HistoryController* historyController_, WhiteboardManager* whiteboardManager, HighlightManager* highlightManager, ClientBlockListManager* clientBlockListManager, const std::map<std::string, std::string>& emoticons, VCardManager* vcardManager, Chattables& chattables) :

+ ChatsManager(jid, stanzaChannel, iqRouter, eventController, chatWindowFactory, joinMUCWindowFactory, nickResolver, presenceOracle, presenceSender, uiEventStream, chatListWindowFactory, useDelayForLatency, timerFactory, mucRegistry, entityCapsProvider, mucManager, mucSearchWindowFactory, profileSettings, ftOverview, roster, eagleMode, settings, historyController_, whiteboardManager, highlightManager, clientBlockListManager, emoticons, vcardManager, chattables) {

+ }

+ MUCBookmarkManager* getBookmarkManager() {

+ return mucBookmarkManager_;

+ }

+};

+

+ CPPUNIT_TEST(testAutoJoinBookmarksAndChattables);

+ CPPUNIT_TEST(testJoinNoAutojoinBookmark);

+ CPPUNIT_TEST(testJoinAndBookmarkMUC);

+ CPPUNIT_TEST(testReceivingNoBookmarks);

+ CPPUNIT_TEST(testReceivingNullBookmarks);

+ CPPUNIT_TEST(testReceivingBookmarksError);

+ notifier_ = std::make_unique<DummyNotifier>();

+ chattables_ = std::make_unique<Chattables>();

+ manager_ = new ExtendedChatsManager(jid_, stanzaChannel_, iqRouter_, eventController_, chatWindowFactory_, joinMUCWindowFactory_, nickResolver_, presenceOracle_, directedPresenceSender_, uiEventStream_, chatListWindowFactory_, true, timerFactory_, mucRegistry_, entityCapsProvider_, mucManager_, mucSearchWindowFactory_, profileSettings_, ftOverview_, xmppRoster_, false, settings_, nullptr, wbManager_, highlightManager_, clientBlockListManager_, emoticons_, vcardManager_, *chattables_);

+ auto sendMessageStanza = stanzaChannel_->getStanzaAtIndex<Message>(3);

+ // Check the MUC security marking request

+ auto mucInfoRequest = std::dynamic_pointer_cast<IQ>(stanzaChannel_->sentStanzas[2]);

+ CPPUNIT_ASSERT(mucInfoRequest);

+

+ auto mucJoinPresence = std::dynamic_pointer_cast<Presence>(stanzaChannel_->sentStanzas[3]);

+ std::shared_ptr<Storage> createBookmarkStorageWithJID(std::shared_ptr<IQ> bookmarkRequest, const JID& jid, const bool autojoin) {

+ auto roomsStorage = std::make_shared<Storage>();

+ if (jid.isValid()) {

+ auto room = Storage::Room();

+ room.jid = jid;

+ room.autoJoin = autojoin;

+ roomsStorage->addRoom(room);

+ }

+ return roomsStorage;

+ }

+

+ void testReceivingBookmarksWithDomainJID() {

+ auto bookmarkRequest = std::dynamic_pointer_cast<IQ>(stanzaChannel_->sentStanzas[0]);

+ std::make_shared<PrivateStorage>(createBookmarkStorageWithJID(bookmarkRequest, "montague.lit", true))

+ auto response = IQ::createResult(

+ bookmarkRequest->getFrom(),

+ bookmarkRequest->getTo(),

+ bookmarkRequest->getID(),

+ std::make_shared<PrivateStorage>(createBookmarkStorageWithJID(bookmarkRequest, "example@montague.lit", true))

+ );

+ stanzaChannel_->onIQReceived(response);

+ }

+ void testReceivingNoBookmarks() {

+ auto bookmarkRequest = std::dynamic_pointer_cast<IQ>(stanzaChannel_->sentStanzas[0]);

+ std::make_shared<PrivateStorage>()

+ );

+ stanzaChannel_->onIQReceived(response);

+ }

+

+ void testReceivingNullBookmarks() {

+ auto bookmarkRequest = std::dynamic_pointer_cast<IQ>(stanzaChannel_->sentStanzas[0]);

+ auto response = IQ::createResult(

+ bookmarkRequest->getFrom(),

+ bookmarkRequest->getTo(),

+ bookmarkRequest->getID(),

+ nullptr

+ );

+ stanzaChannel_->onIQReceived(response);

+ }

+

+ void testReceivingBookmarksError() {

+ auto bookmarkRequest = std::dynamic_pointer_cast<IQ>(stanzaChannel_->sentStanzas[0]);

+ auto response = IQ::createError(

+ bookmarkRequest->getFrom(),

+ bookmarkRequest->getTo(),

+ bookmarkRequest->getID(),

+ ErrorPayload::Condition::ServiceUnavailable,

+ ErrorPayload::Type::Cancel,

+ nullptr

+ auto response = IQ::createResult(

+ bookmarkRequest->getFrom(),

+ bookmarkRequest->getTo(),

+ bookmarkRequest->getID(),

+ std::make_shared<PrivateStorage>(createBookmarkStorageWithJID(bookmarkRequest, "example@montague.lit/someresource", true))

+ );

+ stanzaChannel_->onIQReceived(response);

+ }

+ void testAutoJoinBookmarksAndChattables() {

+ auto bookmarkRequest = std::dynamic_pointer_cast<IQ>(stanzaChannel_->sentStanzas[0]);

+ auto roomsStorage = createBookmarkStorageWithJID(bookmarkRequest, "autojoin@bookmark.lit", true);

+ auto room = Storage::Room();

+ room.jid = "noAutojoin@bookmark.lit";

+ roomsStorage->addRoom(room);

+

+ //Only autojoin@bookmark.lit window should open.

+ MockChatWindow* autojoinBookmarkWindow = new MockChatWindow();

+ mocks_->ExpectCall(chatWindowFactory_, ChatWindowFactory::createChatWindow).With(JID("autojoin@bookmark.lit"), uiEventStream_).Return(autojoinBookmarkWindow);

+ std::make_shared<PrivateStorage>(roomsStorage)

+ //Both bookmarks should be added to the chattables.

+ CPPUNIT_ASSERT_EQUAL(size_t(2), chattables_->get().size());

+ auto autoJoinState = chattables_->getState("autojoin@bookmark.lit");

+ CPPUNIT_ASSERT(autoJoinState.type == Chattables::State::Type::Room);

+ CPPUNIT_ASSERT_EQUAL(autoJoinState.status, StatusShow::Online);

+ auto noAutoJoinState = chattables_->getState("noAutojoin@bookmark.lit");

+ CPPUNIT_ASSERT(noAutoJoinState.type == Chattables::State::Type::Room);

+ CPPUNIT_ASSERT_EQUAL(noAutoJoinState.status, StatusShow::None);

+ }

+

+ void testJoinNoAutojoinBookmark() {

+

+ auto bookmarkRequest = std::dynamic_pointer_cast<IQ>(stanzaChannel_->sentStanzas[0]);

+ auto roomsStorage = createBookmarkStorageWithJID(bookmarkRequest, "example@montague.lit", false);

+

+ auto response = IQ::createResult(

+ bookmarkRequest->getFrom(),

+ bookmarkRequest->getTo(),

+ bookmarkRequest->getID(),

+ std::make_shared<PrivateStorage>(roomsStorage)

+ );

+ stanzaChannel_->onIQReceived(response);

+

+ //Join previous bookmarked room, expecting no increase in chattables and change of autojoin in bookmark to true

+ MockChatWindow* newExampleChatWindow = new MockChatWindow();

+ mocks_->ExpectCall(chatWindowFactory_, ChatWindowFactory::createChatWindow).With(JID("example@montague.lit"), uiEventStream_).Return(newExampleChatWindow);

+ uiEventStream_->send(std::make_shared<JoinMUCUIEvent>("example@montague.lit", boost::optional<std::string>(), boost::optional<std::string>()));

+ CPPUNIT_ASSERT_EQUAL(size_t(1), chattables_->get().size());

+ auto state = chattables_->getState("example@montague.lit");

+ CPPUNIT_ASSERT(state.type == Chattables::State::Type::Room);

+ CPPUNIT_ASSERT_EQUAL(state.status, StatusShow::Online);

+

+ auto bookmarks = manager_->getBookmarkManager()->getBookmarks();

+ CPPUNIT_ASSERT_EQUAL(bookmarks.size(), size_t(1));

+ CPPUNIT_ASSERT(bookmarks[0].getRoom() == JID("example@montague.lit"));

+ CPPUNIT_ASSERT(bookmarks[0].getAutojoin());

+ }

+

+ void testJoinAndBookmarkMUC() {

+ auto bookmarkRequest = std::dynamic_pointer_cast<IQ>(stanzaChannel_->sentStanzas[0]);

+ auto roomsStorage = createBookmarkStorageWithJID(bookmarkRequest, "", true);

+ auto response = IQ::createResult(

+ bookmarkRequest->getFrom(),

+ bookmarkRequest->getTo(),

+ bookmarkRequest->getID(),

+ std::make_shared<PrivateStorage>(roomsStorage)

+ );

+ stanzaChannel_->onIQReceived(response);

+

+ //Join non-bookmarked room expecting for the room to get bookmarked with autojoin to true

+ MockChatWindow* exampleChatWindow = new MockChatWindow();

+ mocks_->ExpectCall(chatWindowFactory_, ChatWindowFactory::createChatWindow).With("example@montague.lit", uiEventStream_).Return(exampleChatWindow);

+ uiEventStream_->send(std::make_shared<JoinMUCUIEvent>("example@montague.lit", boost::optional<std::string>(), boost::optional<std::string>()));

+ {

+ CPPUNIT_ASSERT_EQUAL(size_t(1), chattables_->get().size());

+ auto state = chattables_->getState("example@montague.lit");

+ CPPUNIT_ASSERT(state.type == Chattables::State::Type::Room);

+ CPPUNIT_ASSERT_EQUAL(state.status, StatusShow::Online);

+

+ auto bookmarks = manager_->getBookmarkManager()->getBookmarks();

+ CPPUNIT_ASSERT_EQUAL(bookmarks.size(), size_t(1));

+ CPPUNIT_ASSERT(bookmarks[0].getRoom() == JID("example@montague.lit"));

+ CPPUNIT_ASSERT(bookmarks[0].getAutojoin());

+

+ }

+ //Exiting room that is bookmarked, expecting chattable to stay but bookmark autojoin change to false.

+ exampleChatWindow->onClosed();

+ {

+ CPPUNIT_ASSERT_EQUAL(size_t(1), chattables_->get().size());

+ auto bookmarks = manager_->getBookmarkManager()->getBookmarks();

+ CPPUNIT_ASSERT_EQUAL(bookmarks.size(), size_t(1));

+ CPPUNIT_ASSERT(bookmarks[0].getRoom() == JID("example@montague.lit"));

+ CPPUNIT_ASSERT(!bookmarks[0].getAutojoin());

+ }

+ ExtendedChatsManager* manager_;

+ std::unique_ptr<Chattables> chattables_;

+/*

+ * Copyright (c) 2018 Isode Limited.

+ * All rights reserved.

+ * See the COPYING file for more information.

+ */

+

+#include <gtest/gtest.h>

+#include <hippomocks.h>

+

+#include <Swift/Controllers/Chat/Chattables.h>

+

+// Clang wrongly things that tests for 0 are using 0 as null.

+#pragma clang diagnostic ignored "-Wzero-as-null-pointer-constant"

+

+using namespace Swift;

+

+class ChattablesTest : public ::testing::Test {

+ protected:

+ void SetUp() {

+ beginListSize_ = 0;

+ endListSize_ = 0;

+ callsToBegin_ = 0;

+ callsToEnd_ = 0;

+ }

+

+ void TearDown() {

+ }

+

+ void updateBeginListSize(int listSize);

+ void updateEndListSize();

+

+ Chattables chattables_;

+ int beginListSize_;

+ int endListSize_;

+ int callsToBegin_;

+ int callsToEnd_;

+};

+

+void ChattablesTest::updateBeginListSize(int listSize) {

+ beginListSize_ = listSize;

+ callsToBegin_++;

+}

+

+void ChattablesTest::updateEndListSize() {

+ endListSize_ = chattables_.get().size();

+ callsToEnd_++;

+}

+

+TEST_F(ChattablesTest, testAddJID) {

+ chattables_.onBeginAdd.connect([this](int listSize){ updateBeginListSize(listSize); });

+ chattables_.onAdded.connect([this](){ updateEndListSize(); });

+ JID jid("user@swift.jid");

+

+ chattables_.addJID(jid, Chattables::State::Type::Person);

+ ASSERT_EQ(0, beginListSize_);

+ ASSERT_EQ(1, endListSize_);

+ ASSERT_EQ(1, callsToBegin_);

+ ASSERT_EQ(1, callsToEnd_);

+

+ ASSERT_EQ(jid, chattables_.get()[0]);

+ Chattables::State state = chattables_.getState(jid);

+ ASSERT_EQ(jid, state.jid);

+ ASSERT_EQ(Chattables::State::Type::Person, state.type);

+}

+

+TEST_F(ChattablesTest, testAddMultipleJIDs) {

+ chattables_.onBeginAdd.connect([this](int listSize){ updateBeginListSize(listSize); });

+ chattables_.onAdded.connect([this](){ updateEndListSize(); });

+ JID jid0("user0@swift.jid");

+ JID jid1("user1@swift.jid");

+ JID jid2("user2@swift.jid");

+

+ chattables_.addJID(jid0, Chattables::State::Type::Person);

+ ASSERT_EQ(0, beginListSize_);

+ ASSERT_EQ(1, endListSize_);

+ ASSERT_EQ(1, callsToBegin_);

+ ASSERT_EQ(1, callsToEnd_);

+ chattables_.addJID(jid1, Chattables::State::Type::Person);

+ ASSERT_EQ(1, beginListSize_);

+ ASSERT_EQ(2, endListSize_);

+ ASSERT_EQ(2, callsToBegin_);

+ ASSERT_EQ(2, callsToEnd_);

+ chattables_.addJID(jid2, Chattables::State::Type::Person);

+ ASSERT_EQ(2, beginListSize_);

+ ASSERT_EQ(3, endListSize_);

+ ASSERT_EQ(3, callsToBegin_);

+ ASSERT_EQ(3, callsToEnd_);

+}

+

+TEST_F(ChattablesTest, testAddRoomJID) {

+ chattables_.onBeginAdd.connect([this](int listSize){ updateBeginListSize(listSize); });

+ chattables_.onAdded.connect([this](){ updateEndListSize(); });

+ JID jid("room@swift.jid");

+

+ chattables_.addJID(jid, Chattables::State::Type::Room);

+ ASSERT_EQ(0, beginListSize_);

+ ASSERT_EQ(1, endListSize_);

+ ASSERT_EQ(1, callsToBegin_);

+ ASSERT_EQ(1, callsToEnd_);

+

+ ASSERT_EQ(jid, chattables_.get()[0]);

+ Chattables::State state = chattables_.getState(jid);

+ ASSERT_EQ(jid, state.jid);

+ ASSERT_EQ(Chattables::State::Type::Room, state.type);

+}

+

+TEST_F(ChattablesTest, testSetState) {

+ JID jid("user@swift.jid");

+ chattables_.addJID(jid, Chattables::State::Type::Person);

+ ASSERT_EQ(1, chattables_.get().size());

+ ASSERT_EQ(jid, chattables_.get()[0]);

+ ASSERT_EQ(Chattables::State::Type::Person, chattables_.getState(jid).type);

+ ASSERT_EQ(StatusShow::None, chattables_.getState(jid).status);

+

+ JID returnedJID;

+ int returnedIndex;

+ int callsToChanged = 0;

+ chattables_.onChanged.connect([&returnedJID, &returnedIndex, &callsToChanged](const JID& jid, int index){

+ returnedJID = jid;

+ returnedIndex = index;

+ callsToChanged++;

+ });

+

+ Chattables::State newState;

+ newState.jid = jid;

+ newState.type = Chattables::State::Type::Room;

+ newState.status = StatusShow::Online;

+ chattables_.setState(jid, newState);

+

+ auto storedState = chattables_.getState(jid);

+

+ ASSERT_EQ(1, chattables_.get().size());

+ ASSERT_EQ(jid, chattables_.get()[0]);

+ ASSERT_EQ(jid, returnedJID);

+ ASSERT_EQ(0, returnedIndex);

+ ASSERT_EQ(1, callsToChanged);

+ ASSERT_EQ(jid, storedState.jid);

+ ASSERT_EQ(Chattables::State::Type::Room, storedState.type);

+ ASSERT_EQ(StatusShow::Online, storedState.status);

+}

+ * Copyright (c) 2010-2018 Isode Limited.

+#include <memory>

+

+#include <gtest/gtest.h>

+#include <Swift/Controllers/Chat/Chattables.h>

+#include <Swift/Controllers/SettingConstants.h>

+// Clang wrongly things that tests for 0 are using 0 as null.

+#pragma clang diagnostic ignored "-Wzero-as-null-pointer-constant"

+

+class MUCControllerTest : public ::testing::Test {

+

+ protected:

+ void SetUp() {

+ crypto_ = std::shared_ptr<CryptoProvider>(PlatformCryptoProvider::create());

+ self_ = JID("girl@wonderland.lit/rabbithole");

+ nick_ = "aLiCe";

+ mucJID_ = JID("teaparty@rooms.wonderland.lit");

+ mocks_ = new MockRepository();

+ stanzaChannel_ = new DummyStanzaChannel();

+ iqChannel_ = new DummyIQChannel();

+ iqRouter_ = new IQRouter(iqChannel_);

+ eventController_ = new EventController();

+ chatWindowFactory_ = mocks_->InterfaceMock<ChatWindowFactory>();

+ userSearchWindowFactory_ = mocks_->InterfaceMock<UserSearchWindowFactory>();

+ xmppRoster_ = new XMPPRosterImpl();

+ presenceOracle_ = new PresenceOracle(stanzaChannel_, xmppRoster_);

+ presenceSender_ = new StanzaChannelPresenceSender(stanzaChannel_);

+ directedPresenceSender_ = new DirectedPresenceSender(presenceSender_);

+ uiEventStream_ = new UIEventStream();

+ avatarManager_ = new NullAvatarManager();

+ TimerFactory* timerFactory = nullptr;

+ window_ = new MockChatWindow();

+ mucRegistry_ = new MUCRegistry();

+ entityCapsProvider_ = new DummyEntityCapsProvider();

+ settings_ = new DummySettingsProvider();

+ highlightManager_ = new HighlightManager(settings_);

+ highlightManager_->resetToDefaultConfiguration();

+ muc_ = std::make_shared<MockMUC>(mucJID_);

+ mocks_->ExpectCall(chatWindowFactory_, ChatWindowFactory::createChatWindow).With(muc_->getJID(), uiEventStream_).Return(window_);

+ chatMessageParser_ = std::make_shared<ChatMessageParser>(std::map<std::string, std::string>(), highlightManager_->getConfiguration(), ChatMessageParser::Mode::GroupChat);

+ vcardStorage_ = new VCardMemoryStorage(crypto_.get());

+ vcardManager_ = new VCardManager(self_, iqRouter_, vcardStorage_);

+ nickResolver_ = new NickResolver(self_, xmppRoster_, vcardManager_, mucRegistry_);

+ clientBlockListManager_ = new ClientBlockListManager(iqRouter_);

+ mucBookmarkManager_ = new MUCBookmarkManager(iqRouter_);

+ chattables_ = std::make_unique<Chattables>();

+ controller_ = new MUCController (self_, muc_, boost::optional<std::string>(), nick_, stanzaChannel_, iqRouter_, chatWindowFactory_, nickResolver_, presenceOracle_, avatarManager_, uiEventStream_, false, timerFactory, eventController_, entityCapsProvider_, nullptr, nullptr, mucRegistry_, highlightManager_, clientBlockListManager_, chatMessageParser_, false, nullptr, vcardManager_, mucBookmarkManager_, settings_, *chattables_);

+ }

+ void TearDown() {

+ delete controller_;

+ delete mucBookmarkManager_;

+ delete clientBlockListManager_;

+ delete nickResolver_;

+ delete vcardManager_;

+ delete vcardStorage_;

+ delete highlightManager_;

+ delete settings_;

+ delete entityCapsProvider_;

+ delete eventController_;

+ delete presenceOracle_;

+ delete xmppRoster_;

+ delete mocks_;

+ delete uiEventStream_;

+ delete stanzaChannel_;

+ delete presenceSender_;

+ delete directedPresenceSender_;

+ delete iqRouter_;

+ delete iqChannel_;

+ delete mucRegistry_;

+ delete avatarManager_;

+ }

+ void finishJoin() {

+ Presence::ref presence(new Presence());

+ presence->setFrom(JID(muc_->getJID().toString() + "/" + nick_));

+ MUCUserPayload::ref status(new MUCUserPayload());

+ MUCUserPayload::StatusCode code;

+ code.code = 110;

+ status->addStatusCode(code);

+ presence->addPayload(status);

+ stanzaChannel_->onPresenceReceived(presence);

+ }

+ void joinCompleted() {

+ std::string messageBody("test message");

+ window_->onSendMessageRequest(messageBody, false);

+ std::shared_ptr<Stanza> rawStanza = stanzaChannel_->sentStanzas[stanzaChannel_->sentStanzas.size() - 1];

+ Message::ref message = std::dynamic_pointer_cast<Message>(rawStanza);

+ ASSERT_TRUE(stanzaChannel_->isAvailable()); /* Otherwise will prevent sends. */

+ ASSERT_TRUE(message);

+ ASSERT_EQ(messageBody, message->getBody().get_value_or(""));

+

+ {

+ Message::ref message = std::make_shared<Message>();

+ message->setType(Message::Groupchat);

+ message->setTo(self_);

+ message->setFrom(mucJID_.withResource("SomeNickname"));

+ message->setID(iqChannel_->getNewIQID());

+ message->setSubject("Initial");

+

+ controller_->handleIncomingMessage(std::make_shared<MessageEvent>(message));

+ }

+ }

+ void checkEqual(const std::vector<NickJoinPart>& expected, const std::vector<NickJoinPart>& actual) {

+ ASSERT_EQ(expected.size(), actual.size());

+ for (size_t i = 0; i < expected.size(); i++) {

+ ASSERT_EQ(expected[i].nick, actual[i].nick);

+ ASSERT_EQ(expected[i].type, actual[i].type);

+ }

+ }

+

+ JID jidFromOccupant(const MUCOccupant& occupant) {

+ return JID(mucJID_.toString()+"/"+occupant.getNick());

+ void testRoleAffiliationStatesVerify(const std::map<std::string, MUCOccupant> &occupants) {

+ /* verify that the roster is in sync */

+ GroupRosterItem* group = window_->getRosterModel()->getRoot();

+ for (auto rosterItem : group->getChildren()) {

+ GroupRosterItem* child = dynamic_cast<GroupRosterItem*>(rosterItem);

+ ASSERT_TRUE(child);

+ for (auto childItem : child->getChildren()) {

+ ContactRosterItem* item = dynamic_cast<ContactRosterItem*>(childItem);

+ ASSERT_TRUE(item);

+ std::map<std::string, MUCOccupant>::const_iterator occupant = occupants.find(item->getJID().getResource());

+ ASSERT_TRUE(occupant != occupants.end());

+ ASSERT_TRUE(item->getMUCRole() == occupant->second.getRole());

+ ASSERT_TRUE(item->getMUCAffiliation() == occupant->second.getAffiliation());

+ }

+ }

+ }

+ void setMUCSecurityMarking(const std::string& markingValue, const std::string& markingForegroundColorValue, const std::string& markingBackgroundColorValue, const bool includeFormTypeField = true) {

+ auto form = std::make_shared<Form>(Form::Type::ResultType);

+ if (includeFormTypeField) {

+ std::shared_ptr<FormField> formTypeField = std::make_shared<FormField>(FormField::Type::HiddenType, "http://jabber.org/protocol/muc#roominfo");

+ formTypeField->setName("FORM_TYPE");

+ form->addField(formTypeField);

+ }

+ auto markingField = std::make_shared<FormField>(FormField::Type::TextSingleType, markingValue);

+ auto markingForegroundColorField = std::make_shared<FormField>(FormField::Type::TextSingleType, markingForegroundColorValue);

+ auto markingBackgroundColorField = std::make_shared<FormField>(FormField::Type::TextSingleType, markingBackgroundColorValue);

+ markingField->setName("x-isode#roominfo_marking");

+ markingForegroundColorField->setName("x-isode#roominfo_marking_fg_color");

+ markingBackgroundColorField->setName("x-isode#roominfo_marking_bg_color");

+ form->addField(markingField);

+ form->addField(markingForegroundColorField);

+ form->addField(markingBackgroundColorField);

+ auto discoInfoRef = std::make_shared<DiscoInfo>();

+ discoInfoRef->addExtension(form);

+ auto infoResponse = IQ::createResult(self_, mucJID_, "test-id", discoInfoRef);

+ iqChannel_->onIQReceived(infoResponse);

+ }

+

+ Message::ref createTestMessageWithoutSecurityLabel() {

+ auto message = std::make_shared<Message>();

+ message->setType(Message::Type::Groupchat);

+ message->setID("test-id");

+ message->setTo(self_);

+ message->setFrom(mucJID_.withResource("TestNickname"));

+ message->setBody("Do Not Read This Message");

+ return message;

+ }

+

+ JID self_;

+ JID mucJID_;

+ MockMUC::ref muc_;

+ std::string nick_;

+ DummyStanzaChannel* stanzaChannel_;

+ DummyIQChannel* iqChannel_;

+ IQRouter* iqRouter_;

+ EventController* eventController_;

+ ChatWindowFactory* chatWindowFactory_;

+ UserSearchWindowFactory* userSearchWindowFactory_;

+ MUCController* controller_;

+ NickResolver* nickResolver_;

+ PresenceOracle* presenceOracle_;

+ AvatarManager* avatarManager_;

+ StanzaChannelPresenceSender* presenceSender_;

+ DirectedPresenceSender* directedPresenceSender_;

+ MockRepository* mocks_;

+ UIEventStream* uiEventStream_;

+ MockChatWindow* window_;

+ MUCRegistry* mucRegistry_;

+ DummyEntityCapsProvider* entityCapsProvider_;

+ DummySettingsProvider* settings_;

+ HighlightManager* highlightManager_;

+ std::shared_ptr<ChatMessageParser> chatMessageParser_;

+ std::shared_ptr<CryptoProvider> crypto_;

+ VCardManager* vcardManager_;

+ VCardMemoryStorage* vcardStorage_;

+ ClientBlockListManager* clientBlockListManager_;

+ MUCBookmarkManager* mucBookmarkManager_;

+ XMPPRoster* xmppRoster_;

+ std::unique_ptr<Chattables> chattables_;

+};

+

+TEST_F(MUCControllerTest, testAddressedToSelf) {

+ finishJoin();

+ Message::ref message(new Message());

+

+ message = Message::ref(new Message());

+ message->setFrom(JID(muc_->getJID().toString() + "/otherperson"));

+ message->setBody("basic " + nick_ + " test.");

+ message->setType(Message::Groupchat);

+ controller_->handleIncomingMessage(MessageEvent::ref(new MessageEvent(message)));

+ ASSERT_EQ(1, eventController_->getEvents().size());

+

+ message = Message::ref(new Message());

+ message->setFrom(JID(muc_->getJID().toString() + "/otherperson"));

+ message->setBody(nick_ + ": hi there");

+ message->setType(Message::Groupchat);

+ controller_->handleIncomingMessage(MessageEvent::ref(new MessageEvent(message)));

+ ASSERT_EQ(2, eventController_->getEvents().size());

+

+ message->setFrom(JID(muc_->getJID().toString() + "/other"));

+ message->setBody("Hi there " + nick_);

+ message->setType(Message::Groupchat);

+ controller_->handleIncomingMessage(MessageEvent::ref(new MessageEvent(message)));

+ ASSERT_EQ(3, eventController_->getEvents().size());

+

+ message = Message::ref(new Message());

+ message->setFrom(JID(muc_->getJID().toString() + "/other2"));

+ message->setBody("Hi " + boost::to_lower_copy(nick_) + ".");

+ message->setType(Message::Groupchat);

+ controller_->handleIncomingMessage(MessageEvent::ref(new MessageEvent(message)));

+

+ // The last message is ignored because self-mention highlights are matched case

+ // sensitive against the nickname.

+ ASSERT_EQ(3, eventController_->getEvents().size());

+

+ message = Message::ref(new Message());

+ message->setFrom(JID(muc_->getJID().toString() + "/other3"));

+ message->setBody("Hi bert.");

+ message->setType(Message::Groupchat);

+ controller_->handleIncomingMessage(MessageEvent::ref(new MessageEvent(message)));

+ ASSERT_EQ(3, eventController_->getEvents().size());

+

+ message = Message::ref(new Message());

+ message->setFrom(JID(muc_->getJID().toString() + "/other2"));

+ message->setBody("Hi " + boost::to_lower_copy(nick_) + "ie.");

+ message->setType(Message::Groupchat);

+ controller_->handleIncomingMessage(MessageEvent::ref(new MessageEvent(message)));

+ ASSERT_EQ(3, eventController_->getEvents().size());

+}

+

+TEST_F(MUCControllerTest, testNotAddressedToSelf) {

+ finishJoin();

+ Message::ref message(new Message());

+ message->setFrom(JID(muc_->getJID().toString() + "/other3"));

+ message->setBody("Hi there Hatter");

+ message->setType(Message::Groupchat);

+ controller_->handleIncomingMessage(MessageEvent::ref(new MessageEvent(message)));

+ ASSERT_EQ(0, eventController_->getEvents().size());

+}

+

+TEST_F(MUCControllerTest, testAddressedToSelfBySelf) {

+ finishJoin();

+ Message::ref message(new Message());

+ message->setFrom(JID(muc_->getJID().toString() + "/" + nick_));

+ message->setBody("Hi there " + nick_);

+ message->setType(Message::Groupchat);

+ controller_->handleIncomingMessage(MessageEvent::ref(new MessageEvent(message)));

+ ASSERT_EQ(0, eventController_->getEvents().size());

+}

+

+TEST_F(MUCControllerTest, testMessageWithEmptyLabelItem) {

+ SecurityLabelsCatalog::Item label;

+ label.setSelector("Bob");

+ window_->label_ = label;

+ std::shared_ptr<DiscoInfo> features = std::make_shared<DiscoInfo>();

+ features->addFeature(DiscoInfo::SecurityLabelsCatalogFeature);

+ controller_->setAvailableServerFeatures(features);

+ IQ::ref iq = iqChannel_->iqs_[iqChannel_->iqs_.size() - 1];

+ SecurityLabelsCatalog::ref labelPayload = std::make_shared<SecurityLabelsCatalog>();

+ labelPayload->addItem(label);

+ IQ::ref result = IQ::createResult(self_, iq->getID(), labelPayload);

+ iqChannel_->onIQReceived(result);

+ std::string messageBody("agamemnon");

+ window_->onSendMessageRequest(messageBody, false);

+ std::shared_ptr<Stanza> rawStanza = stanzaChannel_->sentStanzas[stanzaChannel_->sentStanzas.size() - 1];

+ Message::ref message = std::dynamic_pointer_cast<Message>(rawStanza);

+ ASSERT_EQ(iq->getTo(), result->getFrom());

+ ASSERT_TRUE(window_->labelsEnabled_);

+ ASSERT_TRUE(stanzaChannel_->isAvailable()); /* Otherwise will prevent sends. */

+ ASSERT_TRUE(message);

+ ASSERT_EQ(messageBody, message->getBody().get());

+ ASSERT_FALSE(message->getPayload<SecurityLabel>());

+}

+

+TEST_F(MUCControllerTest, testMessageWithLabelItem) {

+ std::shared_ptr<SecurityLabel> label = std::make_shared<SecurityLabel>();

+ label->setLabel("a");

+ SecurityLabelsCatalog::Item labelItem;

+ labelItem.setSelector("Bob");

+ labelItem.setLabel(label);

+ window_->label_ = labelItem;

+ std::shared_ptr<DiscoInfo> features = std::make_shared<DiscoInfo>();

+ features->addFeature(DiscoInfo::SecurityLabelsCatalogFeature);

+ controller_->setAvailableServerFeatures(features);

+ IQ::ref iq = iqChannel_->iqs_[iqChannel_->iqs_.size() - 1];

+ SecurityLabelsCatalog::ref labelPayload = std::make_shared<SecurityLabelsCatalog>();

+ labelPayload->addItem(labelItem);

+ IQ::ref result = IQ::createResult(self_, iq->getID(), labelPayload);

+ iqChannel_->onIQReceived(result);

+ std::string messageBody("agamemnon");

+ window_->onSendMessageRequest(messageBody, false);

+ std::shared_ptr<Stanza> rawStanza = stanzaChannel_->sentStanzas[stanzaChannel_->sentStanzas.size() - 1];

+ Message::ref message = std::dynamic_pointer_cast<Message>(rawStanza);

+ ASSERT_EQ(iq->getTo(), result->getFrom());

+ ASSERT_TRUE(window_->labelsEnabled_);

+ ASSERT_TRUE(stanzaChannel_->isAvailable()); /* Otherwise will prevent sends. */

+ ASSERT_TRUE(message);

+ ASSERT_EQ(messageBody, message->getBody().get());

+ ASSERT_EQ(label, message->getPayload<SecurityLabel>());

+}

+

+TEST_F(MUCControllerTest, testCorrectMessageWithLabelItem) {

+ std::shared_ptr<SecurityLabel> label = std::make_shared<SecurityLabel>();

+ label->setLabel("a");

+ SecurityLabelsCatalog::Item labelItem;

+ labelItem.setSelector("Bob");

+ labelItem.setLabel(label);

+ std::shared_ptr<SecurityLabel> label2 = std::make_shared<SecurityLabel>();

+ label->setLabel("b");

+ SecurityLabelsCatalog::Item labelItem2;

+ labelItem2.setSelector("Charlie");

+ labelItem2.setLabel(label2);

+ window_->label_ = labelItem;

+ std::shared_ptr<DiscoInfo> features = std::make_shared<DiscoInfo>();

+ features->addFeature(DiscoInfo::SecurityLabelsCatalogFeature);

+ controller_->setAvailableServerFeatures(features);

+ IQ::ref iq = iqChannel_->iqs_[iqChannel_->iqs_.size() - 1];

+ SecurityLabelsCatalog::ref labelPayload = std::make_shared<SecurityLabelsCatalog>();

+ labelPayload->addItem(labelItem);

+ IQ::ref result = IQ::createResult(self_, iq->getID(), labelPayload);

+ iqChannel_->onIQReceived(result);

+ std::string messageBody("agamemnon");

+ window_->onSendMessageRequest(messageBody, false);

+ std::shared_ptr<Stanza> rawStanza = stanzaChannel_->sentStanzas[stanzaChannel_->sentStanzas.size() - 1];

+ Message::ref message = std::dynamic_pointer_cast<Message>(rawStanza);

+ ASSERT_EQ(iq->getTo(), result->getFrom());

+ ASSERT_TRUE(window_->labelsEnabled_);

+ ASSERT_TRUE(stanzaChannel_->isAvailable()); /* Otherwise will prevent sends. */

+ ASSERT_TRUE(message);

+ ASSERT_EQ(messageBody, message->getBody().get());

+ ASSERT_EQ(label, message->getPayload<SecurityLabel>());

+ window_->label_ = labelItem2;

+ window_->onSendMessageRequest(messageBody, true);

+ rawStanza = stanzaChannel_->sentStanzas[stanzaChannel_->sentStanzas.size() - 1];

+ message = std::dynamic_pointer_cast<Message>(rawStanza);

+ ASSERT_EQ(messageBody, message->getBody().get());

+ ASSERT_EQ(label, message->getPayload<SecurityLabel>());

+}

+

+TEST_F(MUCControllerTest, testAppendToJoinParts) {

+ std::vector<NickJoinPart> list;

+ std::vector<NickJoinPart> gold;

+ MUCController::appendToJoinParts(list, NickJoinPart("Kev", Join));

+ gold.push_back(NickJoinPart("Kev", Join));

+ checkEqual(gold, list);

+ MUCController::appendToJoinParts(list, NickJoinPart("Remko", Join));

+ gold.push_back(NickJoinPart("Remko", Join));

+ checkEqual(gold, list);

+ MUCController::appendToJoinParts(list, NickJoinPart("Bert", Join));

+ gold.push_back(NickJoinPart("Bert", Join));

+ checkEqual(gold, list);

+ MUCController::appendToJoinParts(list, NickJoinPart("Bert", Part));

+ gold[2].type = JoinThenPart;

+ checkEqual(gold, list);

+ MUCController::appendToJoinParts(list, NickJoinPart("Kev", Part));

+ gold[0].type = JoinThenPart;

+ checkEqual(gold, list);

+ MUCController::appendToJoinParts(list, NickJoinPart("Remko", Part));

+ gold[1].type = JoinThenPart;

+ checkEqual(gold, list);

+ MUCController::appendToJoinParts(list, NickJoinPart("Ernie", Part));

+ gold.push_back(NickJoinPart("Ernie", Part));

+ checkEqual(gold, list);

+ MUCController::appendToJoinParts(list, NickJoinPart("Ernie", Join));

+ gold[3].type = PartThenJoin;

+ checkEqual(gold, list);

+ MUCController::appendToJoinParts(list, NickJoinPart("Kev", Join));

+ gold[0].type = Join;

+ checkEqual(gold, list);

+ MUCController::appendToJoinParts(list, NickJoinPart("Ernie", Part));

+ gold[3].type = Part;

+ checkEqual(gold, list);

+

+}

+

+TEST_F(MUCControllerTest, testJoinPartStringContructionSimple) {

+ std::vector<NickJoinPart> list;

+ list.push_back(NickJoinPart("Kev", Join));

+ ASSERT_EQ(std::string("Kev has entered the room"), MUCController::generateJoinPartString(list, false));

+ list.push_back(NickJoinPart("Remko", Part));

+ ASSERT_EQ(std::string("Kev has entered the room and Remko has left the room"), MUCController::generateJoinPartString(list, false));

+ list.push_back(NickJoinPart("Bert", Join));

+ ASSERT_EQ(std::string("Kev and Bert have entered the room and Remko has left the room"), MUCController::generateJoinPartString(list, false));

+ list.push_back(NickJoinPart("Ernie", Join));

+ ASSERT_EQ(std::string("Kev, Bert and Ernie have entered the room and Remko has left the room"), MUCController::generateJoinPartString(list, false));

+}

+

+TEST_F(MUCControllerTest, testJoinPartStringContructionMixed) {

+ std::vector<NickJoinPart> list;

+ list.push_back(NickJoinPart("Kev", JoinThenPart));

+ ASSERT_EQ(std::string("Kev has entered then left the room"), MUCController::generateJoinPartString(list, false));

+ list.push_back(NickJoinPart("Remko", Part));

+ ASSERT_EQ(std::string("Remko has left the room and Kev has entered then left the room"), MUCController::generateJoinPartString(list, false));

+ list.push_back(NickJoinPart("Bert", PartThenJoin));

+ ASSERT_EQ(std::string("Remko has left the room, Kev has entered then left the room and Bert has left then returned to the room"), MUCController::generateJoinPartString(list, false));

+ list.push_back(NickJoinPart("Ernie", JoinThenPart));

+ ASSERT_EQ(std::string("Remko has left the room, Kev and Ernie have entered then left the room and Bert has left then returned to the room"), MUCController::generateJoinPartString(list, false));

+}

+

+TEST_F(MUCControllerTest, testRoleAffiliationStates) {

+

+ typedef std::map<std::string, MUCOccupant> occupant_map;

+ occupant_map occupants;

+ occupants.insert(occupant_map::value_type("Kev", MUCOccupant("Kev", MUCOccupant::Participant, MUCOccupant::Owner)));

+ occupants.insert(occupant_map::value_type("Remko", MUCOccupant("Remko", MUCOccupant::Participant, MUCOccupant::Owner)));

+ occupants.insert(occupant_map::value_type("Bert", MUCOccupant("Bert", MUCOccupant::Participant, MUCOccupant::Owner)));

+ occupants.insert(occupant_map::value_type("Ernie", MUCOccupant("Ernie", MUCOccupant::Participant, MUCOccupant::Owner)));

+

+ /* populate the MUC with fake users */

+ for (auto&& occupant : occupants) {

+ muc_->insertOccupant(occupant.second);

+ std::vector<MUCOccupant> alterations;

+ alterations.push_back(MUCOccupant("Kev", MUCOccupant::Visitor, MUCOccupant::Admin));

+ alterations.push_back(MUCOccupant("Remko", MUCOccupant::Moderator, MUCOccupant::Member));

+ alterations.push_back(MUCOccupant("Bert", MUCOccupant::Visitor, MUCOccupant::Outcast));

+ alterations.push_back(MUCOccupant("Ernie", MUCOccupant::NoRole, MUCOccupant::Member));

+ alterations.push_back(MUCOccupant("Bert", MUCOccupant::Moderator, MUCOccupant::Owner));

+ alterations.push_back(MUCOccupant("Kev", MUCOccupant::Participant, MUCOccupant::Outcast));

+ alterations.push_back(MUCOccupant("Bert", MUCOccupant::Visitor, MUCOccupant::NoAffiliation));

+ alterations.push_back(MUCOccupant("Remko", MUCOccupant::NoRole, MUCOccupant::NoAffiliation));

+ alterations.push_back(MUCOccupant("Ernie", MUCOccupant::Visitor, MUCOccupant::Outcast));

+

+ for (const auto& alteration : alterations) {

+ /* perform an alteration to a user's role and affiliation */

+ occupant_map::iterator occupant = occupants.find(alteration.getNick());

+ ASSERT_TRUE(occupant != occupants.end());

+ const JID jid = jidFromOccupant(occupant->second);

+ /* change the affiliation, leave the role in place */

+ muc_->changeAffiliation(jid, alteration.getAffiliation());

+ occupant->second = MUCOccupant(occupant->first, occupant->second.getRole(), alteration.getAffiliation());

+ testRoleAffiliationStatesVerify(occupants);

+ /* change the role, leave the affiliation in place */

+ muc_->changeOccupantRole(jid, alteration.getRole());

+ occupant->second = MUCOccupant(occupant->first, alteration.getRole(), occupant->second.getAffiliation());

+ testRoleAffiliationStatesVerify(occupants);

+}

+

+TEST_F(MUCControllerTest, testSubjectChangeCorrect) {

+ joinCompleted();

+ {

+ Message::ref message = std::make_shared<Message>();

+ message->setTo(self_);

+ message->setFrom(mucJID_.withResource("SomeNickname"));

+ message->setID("3FB99C56-7C92-4755-91B0-9C0098BC7AE0");

+ message->setSubject("New Room Subject");

+ controller_->handleIncomingMessage(std::make_shared<MessageEvent>(message));

+ ASSERT_EQ(std::string("The room subject is now: New Room Subject"), std::dynamic_pointer_cast<ChatWindow::ChatTextMessagePart>(window_->lastAddedSystemMessage_.getParts()[0])->text);

+}

+/*

+ * Test that message stanzas with subject element and non-empty body element do not cause a subject change.

+ */

+TEST_F(MUCControllerTest, testSubjectChangeIncorrectA) {

+ joinCompleted();

+ {

+ Message::ref message = std::make_shared<Message>();

+ message->setType(Message::Groupchat);

+ message->setTo(self_);

+ message->setFrom(mucJID_.withResource("SomeNickname"));

+ message->setID(iqChannel_->getNewIQID());

+ message->setSubject("New Room Subject");

+ message->setBody("Some body text that prevents this stanza from being a subject change.");

+

+ controller_->handleIncomingMessage(std::make_shared<MessageEvent>(message));

+ ASSERT_EQ(std::string("Trying to enter room teaparty@rooms.wonderland.lit"), std::dynamic_pointer_cast<ChatWindow::ChatTextMessagePart>(window_->lastAddedSystemMessage_.getParts()[0])->text);

+}

+/*

+ * Test that message stanzas with subject element and thread element do not cause a subject change.

+ */

+TEST_F(MUCControllerTest, testSubjectChangeIncorrectB) {

+ joinCompleted();

+

+ {

+ Message::ref message = std::make_shared<Message>();

+ message->setType(Message::Groupchat);

+ message->setTo(self_);

+ message->setFrom(mucJID_.withResource("SomeNickname"));

+ message->setID(iqChannel_->getNewIQID());

+ message->setSubject("New Room Subject");

+ message->addPayload(std::make_shared<Thread>("Thread that prevents the subject change."));

+

+ controller_->handleIncomingMessage(std::make_shared<MessageEvent>(message));

+ ASSERT_EQ(std::string("Trying to enter room teaparty@rooms.wonderland.lit"), std::dynamic_pointer_cast<ChatWindow::ChatTextMessagePart>(window_->lastAddedSystemMessage_.getParts()[0])->text);

+}

+/*

+ * Test that message stanzas with subject element and empty body element do not cause a subject change.

+ */

+TEST_F(MUCControllerTest, testSubjectChangeIncorrectC) {

+ joinCompleted();

+ {

+ Message::ref message = std::make_shared<Message>();

+ message->setType(Message::Groupchat);

+ message->setTo(self_);

+ message->setFrom(mucJID_.withResource("SomeNickname"));

+ message->setID(iqChannel_->getNewIQID());

+ message->setSubject("New Room Subject");

+ message->setBody("");

+

+ controller_->handleIncomingMessage(std::make_shared<MessageEvent>(message));

+ ASSERT_EQ(std::string("Trying to enter room teaparty@rooms.wonderland.lit"), std::dynamic_pointer_cast<ChatWindow::ChatTextMessagePart>(window_->lastAddedSystemMessage_.getParts()[0])->text);

+}

+

+TEST_F(MUCControllerTest, testHandleOccupantNicknameChanged) {

+ const auto occupantCount = [&](const std::string & nick) {

+ auto roster = window_->getRosterModel();

+ const auto currentOccupantsJIDs = roster->getJIDs();

+ int count = 0;

+ for (auto & p : currentOccupantsJIDs) {

+ if (p.getResource() == nick) {

+ ++count;

+ }

+ }

+ return count;

+ };

+

+ muc_->insertOccupant(MUCOccupant("TestUserOne", MUCOccupant::Participant, MUCOccupant::Owner));

+ muc_->insertOccupant(MUCOccupant("TestUserTwo", MUCOccupant::Participant, MUCOccupant::Owner));

+ muc_->insertOccupant(MUCOccupant("TestUserThree", MUCOccupant::Participant, MUCOccupant::Owner));

+

+ muc_->onOccupantNicknameChanged("TestUserOne", "TestUserTwo");

+

+ ASSERT_EQ(0, occupantCount("TestUserOne"));

+ ASSERT_EQ(1, occupantCount("TestUserTwo"));

+ ASSERT_EQ(1, occupantCount("TestUserThree"));

+}

+

+TEST_F(MUCControllerTest, testHandleOccupantNicknameChangedRoster) {

+ const auto occupantCount = [&](const std::string & nick) {

+ auto roster = window_->getRosterModel();

+ const auto participants = roster->getGroup("Participants");

+ const auto displayedParticipants = participants->getDisplayedChildren();

+ int count = 0;

+ for (auto & p : displayedParticipants) {

+ if (p->getDisplayName() == nick) {

+ ++count;

+ }

+ }

+ return count;

+ };

+

+ muc_->insertOccupant(MUCOccupant("TestUserOne", MUCOccupant::Participant, MUCOccupant::Owner));

+ muc_->insertOccupant(MUCOccupant("TestUserTwo", MUCOccupant::Participant, MUCOccupant::Owner));

+ muc_->insertOccupant(MUCOccupant("TestUserThree", MUCOccupant::Participant, MUCOccupant::Owner));

+ ASSERT_EQ(1, occupantCount("TestUserOne"));

+ ASSERT_EQ(1, occupantCount("TestUserTwo"));

+ ASSERT_EQ(1, occupantCount("TestUserThree"));

+

+ muc_->onOccupantNicknameChanged("TestUserOne", "TestUserTwo");

+

+ ASSERT_EQ(0, occupantCount("TestUserOne"));

+ ASSERT_EQ(1, occupantCount("TestUserTwo"));

+ ASSERT_EQ(1, occupantCount("TestUserThree"));

+}

+

+TEST_F(MUCControllerTest, testHandleChangeSubjectRequest) {

+ std::string testStr("New Subject");

+ ASSERT_EQ(std::string(""), muc_->newSubjectSet_);

+ window_->onChangeSubjectRequest(testStr);

+ ASSERT_EQ(testStr, muc_->newSubjectSet_);

+}

+

+TEST_F(MUCControllerTest, testNonImpromptuMUCWindowTitle) {

+ ASSERT_EQ(muc_->getJID().getNode(), window_->name_);

+}

+

+TEST_F(MUCControllerTest, testSecurityMarkingRequestCompleteMarking) {

+ setMUCSecurityMarking("Test|Highest Possible Security", "Black", "Red", true);

+

+ ASSERT_EQ(std::string("Test|Highest Possible Security"), window_->markingValue_);

+ ASSERT_EQ(std::string("Black"), window_->markingForegroundColorValue_);

+ ASSERT_EQ(std::string("Red"), window_->markingBackgroundColorValue_);

+}

+

+TEST_F(MUCControllerTest, testSecurityMarkingRequestCompleteMarkingWithExtraForm) {

+ auto formTypeField = std::make_shared<FormField>(FormField::Type::HiddenType, "http://jabber.org/protocol/muc#roominfo");

+ auto markingField = std::make_shared<FormField>(FormField::Type::TextSingleType, "Test|Highest Possible Security");

+ auto markingForegroundColorField = std::make_shared<FormField>(FormField::Type::TextSingleType, "Black");

+ auto markingBackgroundColorField = std::make_shared<FormField>(FormField::Type::TextSingleType, "Red");

+ formTypeField->setName("FORM_TYPE");

+ markingField->setName("x-isode#roominfo_marking");

+ markingForegroundColorField->setName("x-isode#roominfo_marking_fg_color");

+ markingBackgroundColorField->setName("x-isode#roominfo_marking_bg_color");

+

+ auto extraForm = std::make_shared<Form>(Form::Type::ResultType);

+ auto form = std::make_shared<Form>(Form::Type::ResultType);

+ form->addField(formTypeField);

+ form->addField(markingField);

+ form->addField(markingForegroundColorField);

+ form->addField(markingBackgroundColorField);

+

+ auto discoInfoRef = std::make_shared<DiscoInfo>();

+ discoInfoRef->addExtension(extraForm);

+ discoInfoRef->addExtension(form);

+

+ auto infoResponse = IQ::createResult(self_, mucJID_, "test-id", discoInfoRef);

+ iqChannel_->onIQReceived(infoResponse);

+ ASSERT_EQ(std::string("Test|Highest Possible Security"), window_->markingValue_);

+ ASSERT_EQ(std::string("Black"), window_->markingForegroundColorValue_);

+ ASSERT_EQ(std::string("Red"), window_->markingBackgroundColorValue_);

+}

+

+TEST_F(MUCControllerTest, testSecurityMarkingRequestNoColorsInMarking) {

+ auto formTypeField = std::make_shared<FormField>(FormField::Type::HiddenType, "http://jabber.org/protocol/muc#roominfo");

+ auto markingField = std::make_shared<FormField>(FormField::Type::TextSingleType, "Test|Highest Possible Security");

+ auto markingForegroundColorField = std::make_shared<FormField>(FormField::Type::TextSingleType, "");

+ auto markingBackgroundColorField = std::make_shared<FormField>(FormField::Type::TextSingleType, "");

+ formTypeField->setName("FORM_TYPE");

+ markingField->setName("x-isode#roominfo_marking");

+ markingForegroundColorField->setName("x-isode#roominfo_marking_fg_color");

+ markingBackgroundColorField->setName("x-isode#roominfo_marking_bg_color");

+

+ auto form = std::make_shared<Form>(Form::Type::ResultType);

+ form->addField(formTypeField);

+ form->addField(markingField);

+ form->addField(markingForegroundColorField);

+ form->addField(markingBackgroundColorField);

+

+ auto discoInfoRef = std::make_shared<DiscoInfo>();

+ discoInfoRef->addExtension(form);

+

+ auto infoResponse = IQ::createResult(self_, mucJID_, "test-id", discoInfoRef);

+ iqChannel_->onIQReceived(infoResponse);

+ ASSERT_EQ(std::string("Test|Highest Possible Security"), window_->markingValue_);

+ ASSERT_EQ(std::string("Black"), window_->markingForegroundColorValue_);

+ ASSERT_EQ(std::string("White"), window_->markingBackgroundColorValue_);

+}

+

+TEST_F(MUCControllerTest, testSecurityMarkingRequestEmptyMarking) {

+ setMUCSecurityMarking("", "", "", true);

+

+ ASSERT_EQ(std::string(""), window_->markingValue_);

+ ASSERT_EQ(std::string(""), window_->markingForegroundColorValue_);

+ ASSERT_EQ(std::string(""), window_->markingBackgroundColorValue_);

+}

+

+TEST_F(MUCControllerTest, testSecurityMarkingRequestWithMarkingNoFormType) {

+ setMUCSecurityMarking("Test|Highest Possible Security", "Black", "Red", false);

+

+ ASSERT_EQ(std::string(""), window_->markingValue_);

+ ASSERT_EQ(std::string(""), window_->markingForegroundColorValue_);

+ ASSERT_EQ(std::string(""), window_->markingBackgroundColorValue_);

+}

+

+TEST_F(MUCControllerTest, testSecurityMarkingRequestNoMarking) {

+ auto form = std::make_shared<Form>(Form::Type::ResultType);

+

+ auto discoInfoRef = std::make_shared<DiscoInfo>();

+ discoInfoRef->addExtension(form);

+

+ auto infoResponse = IQ::createResult(self_, mucJID_, "test-id", discoInfoRef);

+ iqChannel_->onIQReceived(infoResponse);

+ ASSERT_EQ(std::string(""), window_->markingValue_);

+ ASSERT_EQ(std::string(""), window_->markingForegroundColorValue_);

+ ASSERT_EQ(std::string(""), window_->markingBackgroundColorValue_);

+}

+

+TEST_F(MUCControllerTest, testSecurityMarkingRequestNoForm) {

+ auto discoInfoRef = std::make_shared<DiscoInfo>();

+

+ auto infoResponse = IQ::createResult( self_, mucJID_, "test-id", discoInfoRef);

+ iqChannel_->onIQReceived(infoResponse);

+ ASSERT_EQ(std::string(""), window_->markingValue_);

+ ASSERT_EQ(std::string(""), window_->markingForegroundColorValue_);

+ ASSERT_EQ(std::string(""), window_->markingBackgroundColorValue_);

+}

+

+TEST_F(MUCControllerTest, testSecurityMarkingRequestError) {

+ auto errorPayload = std::make_shared<ErrorPayload>(ErrorPayload::Condition::NotAuthorized, ErrorPayload::Type::Auth);

+

+ auto infoResponse = IQ::createResult( self_, mucJID_, "test-id", errorPayload);

+ iqChannel_->onIQReceived(infoResponse);

+ ASSERT_EQ(std::string(""), window_->markingValue_);

+ ASSERT_EQ(std::string(""), window_->markingForegroundColorValue_);

+ ASSERT_EQ(std::string(""), window_->markingBackgroundColorValue_);

+}

+TEST_F(MUCControllerTest, testSecurityMarkingAddedToMessage_Elision_NoRoomMarkingA) {

+ settings_->storeSetting(SettingConstants::MUC_MARKING_ELISION, true);

+ setMUCSecurityMarking("", "Black", "Red");

+ auto messageLabel = std::make_shared<SecurityLabel>();

+ messageLabel->setDisplayMarking("Test|Highest Possible Security");

+ auto sentMessage = createTestMessageWithoutSecurityLabel();

+ sentMessage->addPayload(messageLabel);

+ auto sentMessageEvent = std::make_shared<MessageEvent>(sentMessage);

+ controller_->handleIncomingMessage(sentMessageEvent);

+ auto storedSecurityLabel = window_->lastAddedMessageSecurityLabel_;

+ ASSERT_EQ(false, storedSecurityLabel == nullptr);

+ // This is the potentially altered security label that is displayed on the screen

+ ASSERT_EQ(std::string("Test|Highest Possible Security"), storedSecurityLabel->getDisplayMarking());

+}

+TEST_F(MUCControllerTest, testSecurityMarkingAddedToMessage_Elision_NoRoomMarkingB) {

+ settings_->storeSetting(SettingConstants::MUC_MARKING_ELISION, true);

+ setMUCSecurityMarking("", "Black", "Red");

+ auto messageLabel = std::make_shared<SecurityLabel>();

+ messageLabel->setDisplayMarking("");

+ auto sentMessage = createTestMessageWithoutSecurityLabel();

+ sentMessage->addPayload(messageLabel);

+ auto sentMessageEvent = std::make_shared<MessageEvent>(sentMessage);

+ controller_->handleIncomingMessage(sentMessageEvent);

+ auto storedSecurityLabel = window_->lastAddedMessageSecurityLabel_;

+ ASSERT_EQ(false, storedSecurityLabel == nullptr);

+ // This is the potentially altered security label that is displayed on the screen

+ ASSERT_EQ(std::string(""), storedSecurityLabel->getDisplayMarking());

+}

+TEST_F(MUCControllerTest, testSecurityMarkingAddedToMessage_Elision_WithRoomMarkingA) {

+ settings_->storeSetting(SettingConstants::MUC_MARKING_ELISION, true);

+ setMUCSecurityMarking("Test|Highest Possible Security", "Black", "Red");

+ auto messageLabel = std::make_shared<SecurityLabel>();

+ messageLabel->setDisplayMarking("Test|Highest Possible Security");

+ auto sentMessage = createTestMessageWithoutSecurityLabel();

+ sentMessage->addPayload(messageLabel);

+ // Test the first message matching MUC marking. This message SHOULD have a marking

+ auto sentMessageEvent1 = std::make_shared<MessageEvent>(sentMessage);

+ controller_->handleIncomingMessage(sentMessageEvent1);

+ auto storedSecurityLabel1 = window_->lastAddedMessageSecurityLabel_;

+ ASSERT_EQ(false, storedSecurityLabel1 == nullptr);

+ // This is the potentially altered security label that is displayed on the screen

+ ASSERT_EQ(std::string("Test|Highest Possible Security"), storedSecurityLabel1->getDisplayMarking());

+ // Test a consecutive message matching MUC marking. This message SHOULD NOT have a marking

+ auto sentMessageEvent2 = std::make_shared<MessageEvent>(sentMessage);

+ controller_->handleIncomingMessage(sentMessageEvent2);

+ auto storedSecurityLabel2 = window_->lastAddedMessageSecurityLabel_;

+ ASSERT_EQ(false, storedSecurityLabel2 == nullptr);

+ // This is the potentially altered security label that is displayed on the screen

+ ASSERT_EQ(std::string(""), storedSecurityLabel2->getDisplayMarking());

+}

+TEST_F(MUCControllerTest, testSecurityMarkingAddedToMessage_Elision_WithRoomMarkingB) {

+ settings_->storeSetting(SettingConstants::MUC_MARKING_ELISION, true);

+ setMUCSecurityMarking("Test|Lower Security Marking", "Black", "Red");

+ auto messageLabel = std::make_shared<SecurityLabel>();

+ messageLabel->setDisplayMarking("Test|Highest Possible Security");

+ auto sentMessage = createTestMessageWithoutSecurityLabel();

+ sentMessage->addPayload(messageLabel);

+ auto sentMessageEvent = std::make_shared<MessageEvent>(sentMessage);

+ controller_->handleIncomingMessage(sentMessageEvent);

+ auto storedSecurityLabel = window_->lastAddedMessageSecurityLabel_;

+ ASSERT_EQ(false, storedSecurityLabel == nullptr);

+ // This is the potentially altered security label that is displayed on the screen

+ ASSERT_EQ(std::string("Test|Highest Possible Security"), storedSecurityLabel->getDisplayMarking());

+}

+TEST_F(MUCControllerTest, testSecurityMarkingAddedToMessage_Elision_WithRoomMarkingC) {

+ settings_->storeSetting(SettingConstants::MUC_MARKING_ELISION, true);

+ setMUCSecurityMarking("Test|Highest Possible Security", "Black", "Red");

+ auto messageLabel = std::make_shared<SecurityLabel>();

+ messageLabel->setDisplayMarking("");

+

+ auto sentMessage = createTestMessageWithoutSecurityLabel();

+ sentMessage->addPayload(messageLabel);

+

+ auto sentMessageEvent = std::make_shared<MessageEvent>(sentMessage);

+ controller_->handleIncomingMessage(sentMessageEvent);

+

+ auto storedSecurityLabel = window_->lastAddedMessageSecurityLabel_;

+

+ ASSERT_EQ(false, storedSecurityLabel == nullptr);

+ // This is the potentially altered security label that is displayed on the screen

+ ASSERT_EQ(std::string("Unmarked"), storedSecurityLabel->getDisplayMarking());

+}

+

+TEST_F(MUCControllerTest, testSecurityMarkingAddedToMessage_NoElision_NoRoomMarkingA) {

+ settings_->storeSetting(SettingConstants::MUC_MARKING_ELISION, false);

+ setMUCSecurityMarking("", "Black", "Red");

+

+ auto messageLabel = std::make_shared<SecurityLabel>();

+ messageLabel->setDisplayMarking("Test|Highest Possible Security");

+

+ auto sentMessage = createTestMessageWithoutSecurityLabel();

+ sentMessage->addPayload(messageLabel);

+

+ auto sentMessageEvent = std::make_shared<MessageEvent>(sentMessage);

+ controller_->handleIncomingMessage(sentMessageEvent);

+

+ auto storedSecurityLabel = window_->lastAddedMessageSecurityLabel_;

+

+ ASSERT_EQ(false, storedSecurityLabel == nullptr);

+ // This is the potentially altered security label that is displayed on the screen

+ ASSERT_EQ(std::string("Test|Highest Possible Security"), storedSecurityLabel->getDisplayMarking());

+}

+

+TEST_F(MUCControllerTest, testSecurityMarkingAddedToMessage_NoElision_NoRoomMarkingB) {

+ settings_->storeSetting(SettingConstants::MUC_MARKING_ELISION, false);

+ setMUCSecurityMarking("", "Black", "Red");

+

+ auto messageLabel = std::make_shared<SecurityLabel>();

+ messageLabel->setDisplayMarking("");

+

+ auto sentMessage = createTestMessageWithoutSecurityLabel();

+ sentMessage->addPayload(messageLabel);

+

+ auto sentMessageEvent = std::make_shared<MessageEvent>(sentMessage);

+ controller_->handleIncomingMessage(sentMessageEvent);

+

+ auto storedSecurityLabel = window_->lastAddedMessageSecurityLabel_;

+

+ ASSERT_EQ(false, storedSecurityLabel == nullptr);

+ // This is the potentially altered security label that is displayed on the screen

+ ASSERT_EQ(std::string(""), storedSecurityLabel->getDisplayMarking());

+}

+

+TEST_F(MUCControllerTest, testSecurityMarkingAddedToMessage_NoElision_WithRoomMarkingA) {

+ settings_->storeSetting(SettingConstants::MUC_MARKING_ELISION, false);

+ setMUCSecurityMarking("Test|Highest Possible Security", "Black", "Red");

+

+ auto messageLabel = std::make_shared<SecurityLabel>();

+ messageLabel->setDisplayMarking("Test|Highest Possible Security");

+

+ auto sentMessage = createTestMessageWithoutSecurityLabel();

+ sentMessage->addPayload(messageLabel);

+

+ // Test the first message matching MUC marking. This message SHOULD have a marking

+

+ auto sentMessageEvent1 = std::make_shared<MessageEvent>(sentMessage);

+ controller_->handleIncomingMessage(sentMessageEvent1);

+

+ auto storedSecurityLabel1 = window_->lastAddedMessageSecurityLabel_;

+

+ ASSERT_EQ(false, storedSecurityLabel1 == nullptr);

+ // This is the potentially altered security label that is displayed on the screen

+ ASSERT_EQ(std::string("Test|Highest Possible Security"), storedSecurityLabel1->getDisplayMarking());

+

+ // Test a consecutive message matching MUC marking. This message SHOULD ALSO have a marking

+

+ auto sentMessageEvent2 = std::make_shared<MessageEvent>(sentMessage);

+ controller_->handleIncomingMessage(sentMessageEvent2);

+

+ auto storedSecurityLabel2 = window_->lastAddedMessageSecurityLabel_;

+

+ ASSERT_EQ(false, storedSecurityLabel2 == nullptr);

+ // This is the potentially altered security label that is displayed on the screen

+ ASSERT_EQ(std::string("Test|Highest Possible Security"), storedSecurityLabel2->getDisplayMarking());

+}

+

+TEST_F(MUCControllerTest, testSecurityMarkingAddedToMessage_NoElision_WithRoomMarkingB) {

+ settings_->storeSetting(SettingConstants::MUC_MARKING_ELISION, false);

+ setMUCSecurityMarking("", "Black", "Red");

+

+ auto messageLabel = std::make_shared<SecurityLabel>();

+ messageLabel->setDisplayMarking("");

+

+ auto sentMessage = createTestMessageWithoutSecurityLabel();

+ sentMessage->addPayload(messageLabel);

+

+ auto sentMessageEvent = std::make_shared<MessageEvent>(sentMessage);

+ controller_->handleIncomingMessage(sentMessageEvent);

+ auto storedSecurityLabel = window_->lastAddedMessageSecurityLabel_;

+ ASSERT_EQ(false, storedSecurityLabel == nullptr);

+ // This is the potentially altered security label that is displayed on the screen

+ ASSERT_EQ(std::string(""), storedSecurityLabel->getDisplayMarking());

+}

+ void setUnreadCount(size_t /*unread*/) {}