Change the logic of displaying chat room subject

Test-Information: Run Swift and join any MUC room, on join there is no information displayed regarding room subject. Choose "Change subject", the following information is displayed in the chat window: "The room subject has been removed" after the subject was removed, or "The room subject is now: some subject" after the room subject was set to "some subject". Run Swift join any MUC room, disconnect from server (using another Swift client change subject to "Test") after reconnecting the following information is displayed in chat window: "The room subject is now: Test" Change-Id: Ice901697a6a381464d694147b17830b4e62c8198
author: Joanna Hulboj <joanna.hulboj@isode.com> 2017-02-15 16:21:26 (GMT)
committer: Kevin Smith <kevin.smith@isode.com> 2017-02-23 18:07:40 (GMT)
commit: 3861c418f95555a623d3e8005c75da9b9bbcd1e1 (patch)
tree: d8fbfb1bb6a1a3b1c5d620f0e25d41df215467d1
parent: 8803538bc29a3b68d3c69d900f41ddd1b383cec6 (diff)
download: swift-3861c418f95555a623d3e8005c75da9b9bbcd1e1.zip
swift-3861c418f95555a623d3e8005c75da9b9bbcd1e1.tar.bz2
5 files changed, 65 insertions, 30 deletions
diff --git a/Swift/Controllers/Chat/MUCController.cpp b/Swift/Controllers/Chat/MUCController.cpp
index 9d1459d..df54d73 100644
--- a/Swift/Controllers/Chat/MUCController.cpp
+++ b/Swift/Controllers/Chat/MUCController.cpp
@@ -77,60 +77,62 @@ MUCController::MUCController (
         MUC::ref muc,
         const boost::optional<std::string>& password,
         const std::string &nick,
         StanzaChannel* stanzaChannel,
         IQRouter* iqRouter,
         ChatWindowFactory* chatWindowFactory,
         PresenceOracle* presenceOracle,
         AvatarManager* avatarManager,
         UIEventStream* uiEventStream,
         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) :
     ChatControllerBase(self, stanzaChannel, iqRouter, chatWindowFactory, muc->getJID(), presenceOracle, avatarManager, useDelayForLatency, uiEventStream, eventController, timerFactory, entityCapsProvider, historyController, mucRegistry, highlightManager, chatMessageParser, autoAcceptMUCInviteDecider), muc_(muc), nick_(nick), desiredNick_(nick), password_(password), renameCounter_(0), isImpromptu_(isImpromptu), isImpromptuAlreadyConfigured_(false), clientBlockListManager_(clientBlockListManager), mucBookmarkManager_(mucBookmarkManager) {
     parting_ = true;
     joined_ = false;
     lastWasPresence_ = false;
     shouldJoinOnReconnect_ = true;
     doneGettingHistory_ = false;
     xmppRoster_ = xmppRoster;
+    subject_ = "";
+    isInitialJoin_ = true;
 
     roster_ = std::unique_ptr<Roster>(new Roster(false, true));
     rosterVCardProvider_ = new RosterVCardProvider(roster_.get(), vcardManager, JID::WithResource);
     completer_ = new TabComplete();
     chatWindow_->setRosterModel(roster_.get());
     chatWindow_->setTabComplete(completer_);
     chatWindow_->onClosed.connect(boost::bind(&MUCController::handleWindowClosed, this));
     chatWindow_->onOccupantSelectionChanged.connect(boost::bind(&MUCController::handleWindowOccupantSelectionChanged, this, _1));
     chatWindow_->onOccupantActionSelected.connect(boost::bind(&MUCController::handleActionRequestedOnOccupant, this, _1, _2));
     chatWindow_->onChangeSubjectRequest.connect(boost::bind(&MUCController::handleChangeSubjectRequest, this, _1));
     chatWindow_->onBookmarkRequest.connect(boost::bind(&MUCController::handleBookmarkRequest, this));
     chatWindow_->onConfigureRequest.connect(boost::bind(&MUCController::handleConfigureRequest, this, _1));
     chatWindow_->onConfigurationFormCancelled.connect(boost::bind(&MUCController::handleConfigurationCancelled, this));
     chatWindow_->onDestroyRequest.connect(boost::bind(&MUCController::handleDestroyRoomRequest, this));
     chatWindow_->onInviteToChat.connect(boost::bind(&MUCController::handleInvitePersonToThisMUCRequest, this, _1));
     chatWindow_->onGetAffiliationsRequest.connect(boost::bind(&MUCController::handleGetAffiliationsRequest, this));
     chatWindow_->onChangeAffiliationsRequest.connect(boost::bind(&MUCController::handleChangeAffiliationsRequest, this, _1));
     chatWindow_->onUnblockUserRequest.connect(boost::bind(&MUCController::handleUnblockUserRequest, this));
     muc_->onJoinComplete.connect(boost::bind(&MUCController::handleJoinComplete, this, _1));
     muc_->onJoinFailed.connect(boost::bind(&MUCController::handleJoinFailed, this, _1));
     muc_->onOccupantJoined.connect(boost::bind(&MUCController::handleOccupantJoined, this, _1));
     muc_->onOccupantNicknameChanged.connect(boost::bind(&MUCController::handleOccupantNicknameChanged, this, _1, _2));
     muc_->onOccupantPresenceChange.connect(boost::bind(&MUCController::handleOccupantPresenceChange, this, _1));
     muc_->onOccupantLeft.connect(boost::bind(&MUCController::handleOccupantLeft, this, _1, _2, _3));
     muc_->onRoleChangeFailed.connect(boost::bind(&MUCController::handleOccupantRoleChangeFailed, this, _1, _2, _3));
     muc_->onAffiliationListReceived.connect(boost::bind(&MUCController::handleAffiliationListReceived, this, _1, _2));
     muc_->onConfigurationFailed.connect(boost::bind(&MUCController::handleConfigurationFailed, this, _1));
     muc_->onConfigurationFormReceived.connect(boost::bind(&MUCController::handleConfigurationFormReceived, this, _1));
     highlighter_->setMode(isImpromptu_ ? Highlighter::ChatMode : Highlighter::MUCMode);
     highlighter_->setNick(nick_);
@@ -532,63 +534,67 @@ bool MUCController::messageTargetsMe(std::shared_ptr<Message> message) {
     boost::regex myRegexp(stringRegexp);
     return boost::regex_match(boost::to_lower_copy(message->getBody().get_value_or("")), myRegexp);
 }
 
 void MUCController::preHandleIncomingMessage(std::shared_ptr<MessageEvent> messageEvent) {
     if (messageEvent->getStanza()->getType() == Message::Groupchat) {
         lastActivity_ = boost::posix_time::microsec_clock::universal_time();
     }
     clearPresenceQueue();
     std::shared_ptr<Message> message = messageEvent->getStanza();
     if (joined_ && messageEvent->getStanza()->getFrom().getResource() != nick_ && messageTargetsMe(message) && !message->getPayload<Delay>() && messageEvent->isReadable()) {
         chatWindow_->flash();
     }
     else {
         messageEvent->setTargetsMe(false);
     }
     if (messageEvent->isReadable() && isImpromptu_) {
         chatWindow_->flash(); /* behave like a regular char*/
     }
     if (joined_) {
         std::string nick = message->getFrom().getResource();
         if (nick != nick_ && currentOccupants_.find(nick) != currentOccupants_.end()) {
             completer_->addWord(nick);
         }
     }
     /*Buggy implementations never send the status code, so use an incoming message as a hint that joining's done (e.g. the old ejabberd on psi-im.org).*/
     receivedActivity();
     joined_ = true;
 
     if (message->hasSubject() && !message->getPayload<Body>() && !message->getPayload<Thread>()) {
-        chatWindow_->addSystemMessage(chatMessageParser_->parseMessageBody(str(format(QT_TRANSLATE_NOOP("", "The room subject is now: %1%")) % message->getSubject())), ChatWindow::DefaultDirection);
+        if (!isInitialJoin_) {
+            displaySubjectIfChanged(message->getSubject());
+        }
+        isInitialJoin_ = false;
         chatWindow_->setSubject(message->getSubject());
         doneGettingHistory_ = true;
+        subject_ = message->getSubject();
     }
 
     if (!doneGettingHistory_ && !message->getPayload<Delay>()) {
         doneGettingHistory_ = true;
     }
 
     if (!doneGettingHistory_) {
         checkDuplicates(message);
         messageEvent->conclude();
     }
 }
 
 void MUCController::addMessageHandleIncomingMessage(const JID& from, const ChatWindow::ChatMessage& message, bool senderIsSelf, std::shared_ptr<SecurityLabel> label, const boost::posix_time::ptime& time) {
     if (from.isBare()) {
         chatWindow_->addSystemMessage(message, ChatWindow::DefaultDirection);
     }
     else {
         ChatControllerBase::addMessageHandleIncomingMessage(from, message, senderIsSelf, label, time);
     }
 }
 
 void MUCController::postHandleIncomingMessage(std::shared_ptr<MessageEvent> messageEvent, const ChatWindow::ChatMessage& chatMessage) {
     std::shared_ptr<Message> message = messageEvent->getStanza();
     if (joined_ && messageEvent->getStanza()->getFrom().getResource() != nick_ && !message->getPayload<Delay>()) {
         if (messageTargetsMe(message) || isImpromptu_) {
             eventController_->handleIncomingEvent(messageEvent);
         }
         if (!messageEvent->getConcluded()) {
             handleHighlightActions(chatMessage);
         }
@@ -1189,31 +1195,43 @@ void MUCController::setAvailableServerFeatures(std::shared_ptr<DiscoInfo> info)
     }
 }
 
 void MUCController::handleMUCBookmarkAdded(const MUCBookmark& bookmark) {
     if (bookmark.getRoom() == muc_->getJID()) {
         updateChatWindowBookmarkStatus(bookmark);
     }
 }
 
 void MUCController::handleMUCBookmarkRemoved(const MUCBookmark& bookmark) {
     if (bookmark.getRoom() == muc_->getJID()) {
         updateChatWindowBookmarkStatus(boost::optional<MUCBookmark>());
     }
 }
 
 void MUCController::updateChatWindowBookmarkStatus(const boost::optional<MUCBookmark>& bookmark) {
     assert(chatWindow_);
     if (bookmark) {
         if (bookmark->getAutojoin()) {
             chatWindow_->setBookmarkState(ChatWindow::RoomAutoJoined);
         }
         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;
+    }
+}
+
 }
diff --git a/Swift/Controllers/Chat/MUCController.h b/Swift/Controllers/Chat/MUCController.h
index 7aff627..7ec2eb4 100644
--- a/Swift/Controllers/Chat/MUCController.h
+++ b/Swift/Controllers/Chat/MUCController.h
@@ -117,67 +117,72 @@ namespace Swift {
             void processUserPart();
             virtual void handleBareJIDCapsChanged(const JID& jid) SWIFTEN_OVERRIDE;
             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 setImpromptuWindowTitle();
             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);
+
         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_;
 
             ClientBlockListManager* clientBlockListManager_;
             boost::signals2::scoped_connection blockingOnStateChangedConnection_;
             boost::signals2::scoped_connection blockingOnItemAddedConnection_;
             boost::signals2::scoped_connection blockingOnItemRemovedConnection_;
 
             boost::optional<ChatWindow::AlertID> blockedContactAlert_;
 
             MUCBookmarkManager* mucBookmarkManager_;
             boost::signals2::scoped_connection mucBookmarkManagerBookmarkAddedConnection_;
             boost::signals2::scoped_connection mucBookmarkManagerBookmarkRemovedConnection_;
+
+            std::string subject_;
+            bool isInitialJoin_;
     };
 }
 
diff --git a/Swift/Controllers/Chat/UnitTest/MUCControllerTest.cpp b/Swift/Controllers/Chat/UnitTest/MUCControllerTest.cpp
index 59dcd77..dad021f 100644
--- a/Swift/Controllers/Chat/UnitTest/MUCControllerTest.cpp
+++ b/Swift/Controllers/Chat/UnitTest/MUCControllerTest.cpp
@@ -37,60 +37,61 @@
 #include <Swift/Controllers/Roster/GroupRosterItem.h>
 #include <Swift/Controllers/Roster/Roster.h>
 #include <Swift/Controllers/Settings/DummySettingsProvider.h>
 #include <Swift/Controllers/UIEvents/UIEventStream.h>
 #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_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_);
         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_->getRules(), true);
@@ -108,60 +109,81 @@ public:
         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);
+        CPPUNIT_ASSERT(stanzaChannel_->isAvailable()); /* Otherwise will prevent sends. */
+        CPPUNIT_ASSERT(message);
+        CPPUNIT_ASSERT_EQUAL(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 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)));
         CPPUNIT_ASSERT_EQUAL((size_t)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)));
         CPPUNIT_ASSERT_EQUAL((size_t)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)));
         CPPUNIT_ASSERT_EQUAL((size_t)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)));
         CPPUNIT_ASSERT_EQUAL((size_t)4, eventController_->getEvents().size());
@@ -377,144 +399,120 @@ public:
         }
 
         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());
             CPPUNIT_ASSERT(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);
         }
     }
 
     void testSubjectChangeCorrect() {
-        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);
-        CPPUNIT_ASSERT(stanzaChannel_->isAvailable()); /* Otherwise will prevent sends. */
-        CPPUNIT_ASSERT(message);
-        CPPUNIT_ASSERT_EQUAL(messageBody, message->getBody().get_value_or(""));
+        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");
 
             controller_->handleIncomingMessage(std::make_shared<MessageEvent>(message));
             CPPUNIT_ASSERT_EQUAL(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.
      */
     void testSubjectChangeIncorrectA() {
-        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);
-        CPPUNIT_ASSERT(stanzaChannel_->isAvailable()); /* Otherwise will prevent sends. */
-        CPPUNIT_ASSERT(message);
-        CPPUNIT_ASSERT_EQUAL(messageBody, message->getBody().get_value_or(""));
+        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));
             CPPUNIT_ASSERT_EQUAL(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.
      */
     void testSubjectChangeIncorrectB() {
-        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);
-        CPPUNIT_ASSERT(stanzaChannel_->isAvailable()); /* Otherwise will prevent sends. */
-        CPPUNIT_ASSERT(message);
-        CPPUNIT_ASSERT_EQUAL(messageBody, message->getBody().get_value_or(""));
+        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));
             CPPUNIT_ASSERT_EQUAL(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.
      */
     void testSubjectChangeIncorrectC() {
-        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);
-        CPPUNIT_ASSERT(stanzaChannel_->isAvailable()); /* Otherwise will prevent sends. */
-        CPPUNIT_ASSERT(message);
-        CPPUNIT_ASSERT_EQUAL(messageBody, message->getBody().get_value_or(""));
+        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));
             CPPUNIT_ASSERT_EQUAL(std::string("Trying to enter room teaparty@rooms.wonderland.lit"), std::dynamic_pointer_cast<ChatWindow::ChatTextMessagePart>(window_->lastAddedSystemMessage_.getParts()[0])->text);
         }
     }
 
     void testHandleOccupantNicknameChanged() {
         const auto occupantCount = [&](const std::string & nick) {
             auto roster = window_->getRosterModel();
             CPPUNIT_ASSERT(roster != nullptr);
             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));
@@ -548,60 +546,67 @@ public:
         muc_->insertOccupant(MUCOccupant("TestUserTwo", MUCOccupant::Participant, MUCOccupant::Owner));
         muc_->insertOccupant(MUCOccupant("TestUserThree", MUCOccupant::Participant, MUCOccupant::Owner));
         CPPUNIT_ASSERT_EQUAL(1, occupantCount("TestUserOne"));
         CPPUNIT_ASSERT_EQUAL(1, occupantCount("TestUserTwo"));
         CPPUNIT_ASSERT_EQUAL(1, occupantCount("TestUserThree"));
 
         muc_->onOccupantNicknameChanged("TestUserOne", "TestUserTwo");
 
         CPPUNIT_ASSERT_EQUAL(0, occupantCount("TestUserOne"));
         CPPUNIT_ASSERT_EQUAL(1, occupantCount("TestUserTwo"));
         CPPUNIT_ASSERT_EQUAL(1, occupantCount("TestUserThree"));
     }
 
     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_);
+    }
+
 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_;
diff --git a/Swiften/MUC/UnitTest/MockMUC.cpp b/Swiften/MUC/UnitTest/MockMUC.cpp
index 93e7d0b..d9bf348 100644
--- a/Swiften/MUC/UnitTest/MockMUC.cpp
+++ b/Swiften/MUC/UnitTest/MockMUC.cpp
@@ -1,51 +1,55 @@
 /*
  * Copyright (c) 2013 Isode Limited.
  * All rights reserved.
  * See the COPYING file for more information.
  */
 
 #include <Swiften/MUC/UnitTest/MockMUC.h>
 
 namespace Swift {
 
 MockMUC::MockMUC(const JID &muc)
 : ownMUCJID(muc)
+, newSubjectSet_("")
 {
 }
 
 MockMUC::~MockMUC() {
 }
 
 void MockMUC::insertOccupant(const MUCOccupant& occupant)
 {
     occupants_.insert(std::make_pair(occupant.getNick(), occupant));
     onOccupantJoined(occupant);
 }
 
 const MUCOccupant& MockMUC::getOccupant(const std::string& nick) {
     return occupants_.find(nick)->second;
 }
 
 bool MockMUC::hasOccupant(const std::string& nick) {
     return occupants_.find(nick) != occupants_.end();
 }
 
 void MockMUC::changeAffiliation(const JID &jid, MUCOccupant::Affiliation newAffilation) {
     std::map<std::string, MUCOccupant>::iterator i = occupants_.find(jid.getResource());
     if (i != occupants_.end()) {
         const MUCOccupant old = i->second;
         i->second = MUCOccupant(old.getNick(), old.getRole(), newAffilation);
         onOccupantAffiliationChanged(i->first, newAffilation, old.getAffiliation());
     }
 }
 
 void MockMUC::changeOccupantRole(const JID &jid, MUCOccupant::Role newRole) {
     std::map<std::string, MUCOccupant>::iterator i = occupants_.find(jid.getResource());
     if (i != occupants_.end()) {
         const MUCOccupant old = i->second;
         i->second = MUCOccupant(old.getNick(), newRole, old.getAffiliation());
         onOccupantRoleChanged(i->first, i->second, old.getRole());
     }
 }
+void MockMUC::changeSubject(const std::string& newSubject) {
+    newSubjectSet_ = newSubject;
+}
 
 }
diff --git a/Swiften/MUC/UnitTest/MockMUC.h b/Swiften/MUC/UnitTest/MockMUC.h
index becfa72..4c5ce8d 100644
--- a/Swiften/MUC/UnitTest/MockMUC.h
+++ b/Swiften/MUC/UnitTest/MockMUC.h
@@ -45,54 +45,57 @@ namespace Swift {
             /**
              * Returns the (bare) JID of the MUC.
              */
             virtual JID getJID() const {
                 return ownMUCJID.toBare();
             }
             /**
              * Returns if the room is unlocked and other people can join the room.
              * @return True if joinable by others; false otherwise.
              */
             virtual bool isUnlocked() const { return true; }
 
             virtual void joinAs(const std::string&) {}
             virtual void joinWithContextSince(const std::string&, const boost::posix_time::ptime&) {}
             /*virtual void queryRoomInfo(); */
             /*virtual void queryRoomItems(); */
             /*virtual std::string getCurrentNick() = 0; */
             virtual std::map<std::string, MUCOccupant> getOccupants() const { return occupants_; }
             virtual void changeNickname(const std::string&) { }
             virtual void part() {}
             /*virtual void handleIncomingMessage(Message::ref message) = 0; */
             /** Expose public so it can be called when e.g. user goes offline */
             virtual void handleUserLeft(LeavingType) {}
             /** Get occupant information*/
             virtual const MUCOccupant& getOccupant(const std::string&);
             virtual bool hasOccupant(const std::string&);
             virtual void kickOccupant(const JID&) {}
             virtual void changeOccupantRole(const JID&, MUCOccupant::Role);
             virtual void requestAffiliationList(MUCOccupant::Affiliation) {}
             virtual void changeAffiliation(const JID&, MUCOccupant::Affiliation);
-            virtual void changeSubject(const std::string&) {}
+            virtual void changeSubject(const std::string&);
             virtual void requestConfigurationForm() {}
             virtual void configureRoom(Form::ref) {}
             virtual void cancelConfigureRoom() {}
             virtual void destroyRoom() {}
             /** Send an invite for the person to join the MUC */
             virtual void invitePerson(const JID&, const std::string&, bool, bool) {}
             virtual void setCreateAsReservedIfNew() {}
             virtual void setPassword(const boost::optional<std::string>&) {}
 
         protected:
             virtual bool isFromMUC(const JID& j) const {
                 return ownMUCJID.equals(j, JID::WithoutResource);
             }
 
             virtual const std::string& getOwnNick() const {
                 return ownMUCJID.getResource();
             }
 
         private:
             JID ownMUCJID;
             std::map<std::string, MUCOccupant> occupants_;
+
+        public:
+            std::string newSubjectSet_;
     };
 }
author	Joanna Hulboj <joanna.hulboj@isode.com>	2017-02-15 16:21:26 (GMT)
committer	Kevin Smith <kevin.smith@isode.com>	2017-02-23 18:07:40 (GMT)
commit	3861c418f95555a623d3e8005c75da9b9bbcd1e1 (patch)
tree	d8fbfb1bb6a1a3b1c5d620f0e25d41df215467d1
parent	8803538bc29a3b68d3c69d900f41ddd1b383cec6 (diff)
download	swift-3861c418f95555a623d3e8005c75da9b9bbcd1e1.zip swift-3861c418f95555a623d3e8005c75da9b9bbcd1e1.tar.bz2