Request and display security markings for MUC chat windows

Disco#info requested and handled by MUCController on rejoin(). UI display of disco#info implemented for QtChatWindow. Test-Information: Tests written for new MUCController features, and all tests passed. Swift runs with changes and security markings show as and when expected in local isode MUC windows. Change-Id: Ibef4a31f6f8c4cff5f518a66106266a7f961d103
author: Peter Burgess <pete.burgess@isode.com> 2018-01-19 14:01:53 (GMT)
committer: Kevin Smith <kevin.smith@isode.com> 2018-02-22 17:41:26 (GMT)
commit: 85a144fe80d0fe89b5fed852013b6986b44978d4 (patch)
tree: ce5509ff53353b70cdce9332fa42bb464539e530 /Swift/Controllers/Chat
parent: 5eed7fcd3c8d42837a013855114deb6cdcaf47d0 (diff)
download: swift-85a144fe80d0fe89b5fed852013b6986b44978d4.zip
swift-85a144fe80d0fe89b5fed852013b6986b44978d4.tar.bz2
4 files changed, 233 insertions, 4 deletions
diff --git a/Swift/Controllers/Chat/MUCController.cpp b/Swift/Controllers/Chat/MUCController.cpp
index ff8efa2..9e12a66 100644
--- a/Swift/Controllers/Chat/MUCController.cpp
+++ b/Swift/Controllers/Chat/MUCController.cpp
@@ -1,55 +1,56 @@
 /*
- * Copyright (c) 2010-2017 Isode Limited.
+ * Copyright (c) 2010-2018 Isode Limited.
  * All rights reserved.
  * See the COPYING file for more information.
  */
 
 #include <Swift/Controllers/Chat/MUCController.h>
 
 #include <algorithm>
 #include <cassert>
 #include <memory>
 
 #include <boost/bind.hpp>
 #include <boost/regex.hpp>
 #include <boost/algorithm/string.hpp>
 #include <boost/range/adaptor/reversed.hpp>
 
 #include <Swiften/Avatars/AvatarManager.h>
 #include <Swiften/Base/Log.h>
 #include <Swiften/Base/format.h>
 #include <Swiften/Base/Tristate.h>
 #include <Swiften/Client/BlockList.h>
 #include <Swiften/Client/ClientBlockListManager.h>
 #include <Swiften/Client/StanzaChannel.h>
 #include <Swiften/Disco/EntityCapsProvider.h>
+#include <Swiften/Disco/GetDiscoInfoRequest.h>
 #include <Swiften/Elements/Delay.h>
 #include <Swiften/Elements/Thread.h>
 #include <Swiften/MUC/MUC.h>
 #include <Swiften/MUC/MUCBookmark.h>
 #include <Swiften/MUC/MUCBookmarkManager.h>
 #include <Swiften/Network/Timer.h>
 #include <Swiften/Network/TimerFactory.h>
 #include <Swiften/Roster/XMPPRoster.h>
 
 #include <SwifTools/TabComplete.h>
 
 #include <Swift/Controllers/Chat/ChatMessageParser.h>
 #include <Swift/Controllers/Highlighting/Highlighter.h>
 #include <Swift/Controllers/Intl.h>
 #include <Swift/Controllers/Roster/ContactRosterItem.h>
 #include <Swift/Controllers/Roster/GroupRosterItem.h>
 #include <Swift/Controllers/Roster/ItemOperations/SetAvatar.h>
 #include <Swift/Controllers/Roster/ItemOperations/SetMUC.h>
 #include <Swift/Controllers/Roster/ItemOperations/SetPresence.h>
 #include <Swift/Controllers/Roster/Roster.h>
 #include <Swift/Controllers/Roster/RosterVCardProvider.h>
 #include <Swift/Controllers/UIEvents/InviteToMUCUIEvent.h>
 #include <Swift/Controllers/UIEvents/RequestAddUserDialogUIEvent.h>
 #include <Swift/Controllers/UIEvents/RequestChangeBlockStateUIEvent.h>
 #include <Swift/Controllers/UIEvents/RequestChatUIEvent.h>
 #include <Swift/Controllers/UIEvents/RequestInviteToMUCUIEvent.h>
 #include <Swift/Controllers/UIEvents/ShowProfileForRosterItemUIEvent.h>
 #include <Swift/Controllers/UIEvents/UIEventStream.h>
 #include <Swift/Controllers/UIInterfaces/ChatWindow.h>
 #include <Swift/Controllers/UIInterfaces/ChatWindowFactory.h>
@@ -246,60 +247,63 @@ void MUCController::handleBareJIDCapsChanged(const JID& /*jid*/) {
     for (const auto& nick : currentOccupants_) {
         DiscoInfo::ref disco = entityCapsProvider_->getCapsCached(toJID_.toBare().toString() + "/" + nick);
         if (disco && disco->hasFeature(DiscoInfo::MessageCorrectionFeature)) {
             any = true;
         } else {
             support = Maybe;
         }
     }
     if (!any) {
         support = No;
     }
     chatWindow_->setCorrectionEnabled(support);
 }
 
 /**
  * Join the MUC if not already in it.
  */
 void MUCController::rejoin() {
     if (parting_) {
         joined_ = false;
         parting_ = false;
         if (password_) {
             muc_->setPassword(*password_);
         }
         //FIXME: check for received activity
 #ifdef SWIFT_EXPERIMENTAL_HISTORY
         if (lastActivity_ == boost::posix_time::not_a_date_time && historyController_) {
             lastActivity_ = historyController_->getLastTimeStampFromMUC(selfJID_, toJID_);
         }
 #endif
+
+        requestSecurityMarking();
+
         if (lastActivity_ == boost::posix_time::not_a_date_time) {
             muc_->joinAs(nick_);
         }
         else {
             muc_->joinWithContextSince(nick_, lastActivity_);
         }
     }
 }
 
 bool MUCController::isJoined() {
     return joined_;
 }
 
 const std::string& MUCController::getNick() {
     return nick_;
 }
 
 const boost::optional<std::string> MUCController::getPassword() const {
     return password_;
 }
 
 bool MUCController::isImpromptu() const {
     return isImpromptu_;
 }
 
 std::map<std::string, JID> MUCController::getParticipantJIDs() const {
     std::map<std::string, JID> participants;
     std::map<std::string, MUCOccupant> occupants = muc_->getOccupants();
     for (const auto& occupant : occupants) {
         if (occupant.first != nick_) {
@@ -1216,31 +1220,80 @@ void MUCController::updateChatWindowBookmarkStatus(const boost::optional<MUCBook
         else {
             chatWindow_->setBookmarkState(ChatWindow::RoomBookmarked);
         }
     }
     else {
         chatWindow_->setBookmarkState(ChatWindow::RoomNotBookmarked);
     }
 }
 
 void MUCController::displaySubjectIfChanged(const std::string& subject) {
     if (subject_ != subject) {
         if (!subject.empty()) {
             chatWindow_->addSystemMessage(chatMessageParser_->parseMessageBody(str(format(QT_TRANSLATE_NOOP("", "The room subject is now: %1%")) % subject)), ChatWindow::DefaultDirection);
         }
         else {
             chatWindow_->addSystemMessage(chatMessageParser_->parseMessageBody(str(format(QT_TRANSLATE_NOOP("", "The room subject has been removed")))), ChatWindow::DefaultDirection);
         }
         subject_ = subject;
     }
 }
 
 void MUCController::addChatSystemMessage() {
     lastJoinMessageUID_ = chatWindow_->addSystemMessage(chatMessageParser_->parseMessageBody(lastStartMessage_), ChatWindow::DefaultDirection);
 }
 
 void MUCController::setChatWindowTitle(const std::string& title) {
     chatWindowTitle_ = title;
     chatWindow_->setName(chatWindowTitle_);
 }
 
+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 == "") {
+                chatWindow_->removeChatSecurityMarking();
+                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) {
+                markingForegroundColorValue = markingForegroundColor->getTextSingleValue();
+            }
+            if (markingBackgroundColor) {
+                markingBackgroundColorValue = markingBackgroundColor->getTextSingleValue();
+            }
+            chatWindow_->setChatSecurityMarking(markingValue, markingForegroundColorValue, markingBackgroundColorValue);
+        }
+    );
+    discoInfoRequest->send();
+}
+
 }
diff --git a/Swift/Controllers/Chat/MUCController.h b/Swift/Controllers/Chat/MUCController.h
index 4b39f54..949f530 100644
--- a/Swift/Controllers/Chat/MUCController.h
+++ b/Swift/Controllers/Chat/MUCController.h
@@ -1,32 +1,32 @@
 /*
- * Copyright (c) 2010-2017 Isode Limited.
+ * Copyright (c) 2010-2018 Isode Limited.
  * All rights reserved.
  * See the COPYING file for more information.
  */
 
 #pragma once
 
 #include <map>
 #include <memory>
 #include <set>
 #include <string>
 
 #include <boost/signals2.hpp>
 #include <boost/signals2/connection.hpp>
 
 #include <Swiften/Elements/DiscoInfo.h>
 #include <Swiften/Elements/MUCOccupant.h>
 #include <Swiften/Elements/Message.h>
 #include <Swiften/JID/JID.h>
 #include <Swiften/MUC/MUC.h>
 #include <Swiften/Network/Timer.h>
 
 #include <Swift/Controllers/Chat/ChatControllerBase.h>
 #include <Swift/Controllers/Roster/RosterItem.h>
 #include <Swift/Controllers/UIInterfaces/ChatWindow.h>
 
 namespace Swift {
     class StanzaChannel;
     class IQRouter;
     class ChatWindowFactory;
     class Roster;
@@ -121,60 +121,62 @@ namespace Swift {
             void handleConfigureRequest(Form::ref);
             void handleConfigurationFailed(ErrorPayload::ref);
             void handleConfigurationFormReceived(Form::ref);
             void handleDestroyRoomRequest();
             void handleInvitePersonToThisMUCRequest(const std::vector<JID>& jidsToInvite);
             void handleConfigurationCancelled();
             void handleOccupantRoleChangeFailed(ErrorPayload::ref, const JID&, MUCOccupant::Role);
             void handleGetAffiliationsRequest();
             void handleAffiliationListReceived(MUCOccupant::Affiliation affiliation, const std::vector<JID>& jids);
             void handleChangeAffiliationsRequest(const std::vector<std::pair<MUCOccupant::Affiliation, JID> >& changes);
             void handleInviteToMUCWindowDismissed();
             void handleInviteToMUCWindowCompleted();
             void handleUIEvent(std::shared_ptr<UIEvent> event);
             void addRecentLogs();
             void checkDuplicates(std::shared_ptr<Message> newMessage);
             void setNick(const std::string& nick);
             void handleRoomUnlocked();
             void configureAsImpromptuRoom(Form::ref form);
             Form::ref buildImpromptuRoomConfiguration(Form::ref roomConfigurationForm);
 
             void handleUnblockUserRequest();
             void handleBlockingStateChanged();
 
             void handleMUCBookmarkAdded(const MUCBookmark& bookmark);
             void handleMUCBookmarkRemoved(const MUCBookmark& bookmark);
             void updateChatWindowBookmarkStatus(const boost::optional<MUCBookmark>& bookmark);
 
             void displaySubjectIfChanged(const std::string& sucject);
             void addChatSystemMessage();
 
+            void requestSecurityMarking();
+
         private:
             MUC::ref muc_;
             std::string nick_;
             std::string desiredNick_;
             TabComplete* completer_;
             bool parting_;
             bool joined_;
             bool shouldJoinOnReconnect_;
             bool doneGettingHistory_;
             boost::signals2::scoped_connection avatarChangedConnection_;
             std::shared_ptr<Timer> loginCheckTimer_;
             std::set<std::string> currentOccupants_;
             std::vector<NickJoinPart> joinParts_;
             boost::posix_time::ptime lastActivity_;
             boost::optional<std::string> password_;
             XMPPRoster* xmppRoster_;
             std::unique_ptr<Roster> roster_;
             std::vector<HistoryMessage> joinContext_;
             size_t renameCounter_;
             bool isImpromptu_;
             bool isImpromptuAlreadyConfigured_;
             RosterVCardProvider* rosterVCardProvider_;
             std::string lastJoinMessageUID_;
             std::string lastStartMessage_;
 
             ClientBlockListManager* clientBlockListManager_;
             boost::signals2::scoped_connection blockingOnStateChangedConnection_;
             boost::signals2::scoped_connection blockingOnItemAddedConnection_;
             boost::signals2::scoped_connection blockingOnItemRemovedConnection_;
 
diff --git a/Swift/Controllers/Chat/UnitTest/ChatsManagerTest.cpp b/Swift/Controllers/Chat/UnitTest/ChatsManagerTest.cpp
index 8f6c3a8..e06a3c7 100644
--- a/Swift/Controllers/Chat/UnitTest/ChatsManagerTest.cpp
+++ b/Swift/Controllers/Chat/UnitTest/ChatsManagerTest.cpp
@@ -749,61 +749,61 @@ public:
         presence->setShow(StatusShow::None);
         presence->setType(Presence::Unavailable);
         stanzaChannel_->onPresenceReceived(presence);
         CPPUNIT_ASSERT_EQUAL(std::string("participantA has gone offline."), MockChatWindow::bodyFromMessage(window->lastReplacedLastMessage_));
     }
 
     void testChatControllerMucPmUnavailableErrorHandling() {
         auto mucJID = JID("test@rooms.test.com");
         auto participantA = mucJID.withResource("participantA");
         auto participantB = mucJID.withResource("participantB");
 
         auto mucWindow = new MockChatWindow();
         mocks_->ExpectCall(chatWindowFactory_, ChatWindowFactory::createChatWindow).With(mucJID, uiEventStream_).Return(mucWindow);
         uiEventStream_->send(std::make_shared<JoinMUCUIEvent>(mucJID, participantB.getResource()));
         CPPUNIT_ASSERT_EQUAL(true, mucWindow->mucType_.is_initialized());
 
         auto window = new MockChatWindow();
         mocks_->ExpectCall(chatWindowFactory_, ChatWindowFactory::createChatWindow).With(participantA, uiEventStream_).Return(window);
         uiEventStream_->send(std::make_shared<RequestChatUIEvent>(participantA));
         CPPUNIT_ASSERT_EQUAL(false, window->mucType_.is_initialized());
 
         Presence::ref presence = Presence::create();
         presence->setFrom(participantA);
         presence->setShow(StatusShow::Online);
         stanzaChannel_->onPresenceReceived(presence);
         CPPUNIT_ASSERT_EQUAL(std::string("participantA has become available."), MockChatWindow::bodyFromMessage(window->lastAddedPresence_));
 
         // send message to participantA
         auto messageBody = std::string("message body to send");
         window->onSendMessageRequest(messageBody, false);
-        auto sendMessageStanza = stanzaChannel_->getStanzaAtIndex<Message>(2);
+        auto sendMessageStanza = stanzaChannel_->getStanzaAtIndex<Message>(3);
         CPPUNIT_ASSERT_EQUAL(messageBody, *sendMessageStanza->getBody());
 
         // receive reply with error
         auto messageErrorReply = std::make_shared<Message>();
         messageErrorReply->setID(stanzaChannel_->getNewIQID());
         messageErrorReply->setType(Message::Error);
         messageErrorReply->setFrom(participantA);
         messageErrorReply->setTo(jid_);
         messageErrorReply->addPayload(std::make_shared<ErrorPayload>(ErrorPayload::ItemNotFound, ErrorPayload::Cancel, "Recipient not in room"));
 
         auto lastMUCWindowErrorMessageBeforeError = MockChatWindow::bodyFromMessage(mucWindow->lastAddedErrorMessage_);
         manager_->handleIncomingMessage(messageErrorReply);
 
         // assert that error is not routed to MUC window
         CPPUNIT_ASSERT_EQUAL(lastMUCWindowErrorMessageBeforeError,  MockChatWindow::bodyFromMessage(mucWindow->lastAddedErrorMessage_));
         // assert that error is routed to PM
         CPPUNIT_ASSERT_EQUAL(std::string("This user could not be found in the room."), MockChatWindow::bodyFromMessage(window->lastAddedErrorMessage_));
     }
 
     void testLocalMUCServiceDiscoveryResetOnDisconnect() {
         JID ownJID("test@test.com/resource");
         JID sender("foo@test.com");
 
         manager_->setOnline(true);
 
         // Open chat window to a sender.
         MockChatWindow* window = new MockChatWindow();
         mocks_->ExpectCall(chatWindowFactory_, ChatWindowFactory::createChatWindow).With(sender, uiEventStream_).Return(window);
 
         uiEventStream_->send(std::make_shared<RequestChatUIEvent>(sender));
@@ -1510,61 +1510,65 @@ public:
             mucMirrored->addPayload(std::make_shared<Replace>("fooBlaID_2"));
             manager_->handleIncomingMessage(mucMirrored);
         }
         CPPUNIT_ASSERT_EQUAL(std::string("Some correctly spelled message."), window->bodyFromMessage(window->lastReplacedMessage_));
     }
 
     void impromptuChatSetup(MockChatWindow* window) {
         stanzaChannel_->uniqueIDs_ = true;
         JID mucJID("795B7BBE-9099-4A0D-81BA-C816F78E275C@test.com");
         manager_->setOnline(true);
 
         std::shared_ptr<IQ> infoRequest = std::dynamic_pointer_cast<IQ>(stanzaChannel_->sentStanzas[1]);
         CPPUNIT_ASSERT(infoRequest);
 
         std::shared_ptr<IQ> infoResponse = IQ::createResult(infoRequest->getFrom(), infoRequest->getTo(), infoRequest->getID());
 
         DiscoInfo info;
         info.addIdentity(DiscoInfo::Identity("Shakespearean Chat Service", "conference", "text"));
         info.addFeature("http://jabber.org/protocol/muc");
         infoResponse->addPayload(std::make_shared<DiscoInfo>(info));
         stanzaChannel_->onIQReceived(infoResponse);
 
         std::vector<JID> jids;
         jids.emplace_back("foo@test.com");
         jids.emplace_back("bar@test.com");
 
         mocks_->ExpectCall(chatWindowFactory_, ChatWindowFactory::createChatWindow).With(mucJID, uiEventStream_).Return(window);
         uiEventStream_->send(std::make_shared<CreateImpromptuMUCUIEvent>(jids, mucJID, ""));
         CPPUNIT_ASSERT_EQUAL(std::string("bar@test.com, foo@test.com"), manager_->getRecentChats()[0].getTitle());
 
-        auto mucJoinPresence = std::dynamic_pointer_cast<Presence>(stanzaChannel_->sentStanzas[2]);
+        // 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]);
         CPPUNIT_ASSERT(mucJoinPresence);
 
         // MUC presence reply
         auto mucResponse = Presence::create();
         mucResponse->setTo(jid_);
         mucResponse->setFrom(mucJoinPresence->getTo());
         mucResponse->addPayload([]() {
             auto mucUser = std::make_shared<MUCUserPayload>();
             mucUser->addItem(MUCItem(MUCOccupant::Member, MUCOccupant::Participant));
             mucUser->addStatusCode(MUCUserPayload::StatusCode(110));
             mucUser->addStatusCode(MUCUserPayload::StatusCode(210));
             return mucUser;
         }());
         stanzaChannel_->onPresenceReceived(mucResponse);
 
         // Before people join the impromptu room, the title is based on names coming from Roster
         CPPUNIT_ASSERT_EQUAL(std::string("bar@test.com, foo@test.com"), manager_->getRecentChats()[0].getTitle());
 
         auto mucParticipantJoined = [&](const JID& jid) {
             auto participantJoinedPresence = Presence::create();
             participantJoinedPresence->setTo(jid_);
             participantJoinedPresence->setFrom(mucJID.withResource(jid.toString()));
             auto mucUser = std::make_shared<MUCUserPayload>();
             mucUser->addItem(MUCItem(MUCOccupant::Member, MUCOccupant::Participant));
             participantJoinedPresence->addPayload(mucUser);
             return participantJoinedPresence;
         };
 
         for (const auto& participantJID : jids) {
             stanzaChannel_->onPresenceReceived(mucParticipantJoined(participantJID));
diff --git a/Swift/Controllers/Chat/UnitTest/MUCControllerTest.cpp b/Swift/Controllers/Chat/UnitTest/MUCControllerTest.cpp
index 1f69f4f..06486d3 100644
--- a/Swift/Controllers/Chat/UnitTest/MUCControllerTest.cpp
+++ b/Swift/Controllers/Chat/UnitTest/MUCControllerTest.cpp
@@ -41,60 +41,68 @@
 #include <Swift/Controllers/UIInterfaces/ChatWindow.h>
 #include <Swift/Controllers/UIInterfaces/ChatWindowFactory.h>
 #include <Swift/Controllers/UIInterfaces/UserSearchWindowFactory.h>
 #include <Swift/Controllers/UnitTest/MockChatWindow.h>
 #include <Swift/Controllers/XMPPEvents/EventController.h>
 
 using namespace Swift;
 
 class MUCControllerTest : public CppUnit::TestFixture {
     CPPUNIT_TEST_SUITE(MUCControllerTest);
     CPPUNIT_TEST(testJoinPartStringContructionSimple);
     CPPUNIT_TEST(testJoinPartStringContructionMixed);
     CPPUNIT_TEST(testAppendToJoinParts);
     CPPUNIT_TEST(testAddressedToSelf);
     CPPUNIT_TEST(testNotAddressedToSelf);
     CPPUNIT_TEST(testAddressedToSelfBySelf);
     CPPUNIT_TEST(testMessageWithEmptyLabelItem);
     CPPUNIT_TEST(testMessageWithLabelItem);
     CPPUNIT_TEST(testCorrectMessageWithLabelItem);
     CPPUNIT_TEST(testRoleAffiliationStates);
     CPPUNIT_TEST(testSubjectChangeCorrect);
     CPPUNIT_TEST(testSubjectChangeIncorrectA);
     CPPUNIT_TEST(testSubjectChangeIncorrectB);
     CPPUNIT_TEST(testSubjectChangeIncorrectC);
     CPPUNIT_TEST(testHandleOccupantNicknameChanged);
     CPPUNIT_TEST(testHandleOccupantNicknameChangedRoster);
     CPPUNIT_TEST(testHandleChangeSubjectRequest);
 
     CPPUNIT_TEST(testNonImpromptuMUCWindowTitle);
 
+    CPPUNIT_TEST(testSecurityMarkingRequestCompleteMarking);
+    CPPUNIT_TEST(testSecurityMarkingRequestCompleteMarkingWithExtraForm);
+    CPPUNIT_TEST(testSecurityMarkingRequestEmptyMarking);
+    CPPUNIT_TEST(testSecurityMarkingRequestWithMarkingNoFormType);
+    CPPUNIT_TEST(testSecurityMarkingRequestNoMarking);
+    CPPUNIT_TEST(testSecurityMarkingRequestNoForm);
+    CPPUNIT_TEST(testSecurityMarkingRequestError);
+
     CPPUNIT_TEST_SUITE_END();
 
 public:
     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_);
@@ -566,60 +574,222 @@ public:
     }
 
     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);
             CPPUNIT_ASSERT(child);
             for (auto childItem : child->getChildren()) {
                 ContactRosterItem* item = dynamic_cast<ContactRosterItem*>(childItem);
                 CPPUNIT_ASSERT(item);
                 std::map<std::string, MUCOccupant>::const_iterator occupant = occupants.find(item->getJID().getResource());
                 CPPUNIT_ASSERT(occupant != occupants.end());
                 CPPUNIT_ASSERT(item->getMUCRole() == occupant->second.getRole());
                 CPPUNIT_ASSERT(item->getMUCAffiliation() == occupant->second.getAffiliation());
             }
         }
     }
 
     void testHandleChangeSubjectRequest() {
         std::string testStr("New Subject");
         CPPUNIT_ASSERT_EQUAL(std::string(""), muc_->newSubjectSet_);
         window_->onChangeSubjectRequest(testStr);
         CPPUNIT_ASSERT_EQUAL(testStr, muc_->newSubjectSet_);
     }
 
     void testNonImpromptuMUCWindowTitle() {
         CPPUNIT_ASSERT_EQUAL(muc_->getJID().getNode(), window_->name_);
     }
 
+    void testSecurityMarkingRequestCompleteMarking() {
+        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 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);
+        CPPUNIT_ASSERT_EQUAL(std::string("Test | Highest Possible Security"), window_->markingValue_);
+        CPPUNIT_ASSERT_EQUAL(std::string("Black"), window_->markingForegroundColorValue_);
+        CPPUNIT_ASSERT_EQUAL(std::string("Red"), window_->markingBackgroundColorValue_);
+    }
+
+    void 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);
+        CPPUNIT_ASSERT_EQUAL(std::string("Test | Highest Possible Security"), window_->markingValue_);
+        CPPUNIT_ASSERT_EQUAL(std::string("Black"), window_->markingForegroundColorValue_);
+        CPPUNIT_ASSERT_EQUAL(std::string("Red"), window_->markingBackgroundColorValue_);
+    }
+
+    void 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);
+        CPPUNIT_ASSERT_EQUAL(std::string("Test | Highest Possible Security"), window_->markingValue_);
+        CPPUNIT_ASSERT_EQUAL(std::string("Black"), window_->markingForegroundColorValue_);
+        CPPUNIT_ASSERT_EQUAL(std::string("White"), window_->markingBackgroundColorValue_);
+    }
+
+    void testSecurityMarkingRequestEmptyMarking() {
+        auto formTypeField = std::make_shared<FormField>(FormField::Type::HiddenType, "http://jabber.org/protocol/muc#roominfo");
+        auto markingField = std::make_shared<FormField>(FormField::Type::TextSingleType, "");
+        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);
+        CPPUNIT_ASSERT_EQUAL(std::string(""), window_->markingValue_);
+        CPPUNIT_ASSERT_EQUAL(std::string(""), window_->markingForegroundColorValue_);
+        CPPUNIT_ASSERT_EQUAL(std::string(""), window_->markingBackgroundColorValue_);
+    }
+
+    void testSecurityMarkingRequestWithMarkingNoFormType() {
+        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");
+        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(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);
+        CPPUNIT_ASSERT_EQUAL(std::string(""), window_->markingValue_);
+        CPPUNIT_ASSERT_EQUAL(std::string(""), window_->markingForegroundColorValue_);
+        CPPUNIT_ASSERT_EQUAL(std::string(""), window_->markingBackgroundColorValue_);
+    }
+
+    void 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);
+        CPPUNIT_ASSERT_EQUAL(std::string(""), window_->markingValue_);
+        CPPUNIT_ASSERT_EQUAL(std::string(""), window_->markingForegroundColorValue_);
+        CPPUNIT_ASSERT_EQUAL(std::string(""), window_->markingBackgroundColorValue_);
+    }
+
+    void testSecurityMarkingRequestNoForm() {
+        auto discoInfoRef = std::make_shared<DiscoInfo>();
+
+        auto infoResponse = IQ::createResult( self_, mucJID_, "test-id", discoInfoRef);
+        iqChannel_->onIQReceived(infoResponse);
+        CPPUNIT_ASSERT_EQUAL(std::string(""), window_->markingValue_);
+        CPPUNIT_ASSERT_EQUAL(std::string(""), window_->markingForegroundColorValue_);
+        CPPUNIT_ASSERT_EQUAL(std::string(""), window_->markingBackgroundColorValue_);
+    }
+
+    void 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);
+        CPPUNIT_ASSERT_EQUAL(std::string(""), window_->markingValue_);
+        CPPUNIT_ASSERT_EQUAL(std::string(""), window_->markingForegroundColorValue_);
+        CPPUNIT_ASSERT_EQUAL(std::string(""), window_->markingBackgroundColorValue_);
+    }
+
 private:
     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_;
author	Peter Burgess <pete.burgess@isode.com>	2018-01-19 14:01:53 (GMT)
committer	Kevin Smith <kevin.smith@isode.com>	2018-02-22 17:41:26 (GMT)
commit	85a144fe80d0fe89b5fed852013b6986b44978d4 (patch)
tree	ce5509ff53353b70cdce9332fa42bb464539e530 /Swift/Controllers/Chat
parent	5eed7fcd3c8d42837a013855114deb6cdcaf47d0 (diff)
download	swift-85a144fe80d0fe89b5fed852013b6986b44978d4.zip swift-85a144fe80d0fe89b5fed852013b6986b44978d4.tar.bz2