Support Last Message Correction in multi client scenarios

Previously Last Message Correction edits are only applied if they came from the same resource. This makes sense in MUC scenarios but does not in 1-to-1 chats. This changes the Last Message Correction behaviour for MUC and 1-to-1 chats so that different clients from the same bare JID can edit each others messages. Test-Information: Added unit test to verify Last Message Corrections work as expected when coming from the same client and from different clients. Manually verified that the receiving client correctly shows a corrected message if the sending client reconnected between first message and edit. All unit tests pass on OS X 10.11.6 with Qt 5.5.1. Change-Id: If533ecc7032e59e324979c577726f2da739012e6
author: Tobias Markmann <tm@ayena.de> 2016-08-17 09:02:24 (GMT)
committer: Tobias Markmann <tm@ayena.de> 2017-04-18 15:38:43 (GMT)
commit: 57a611f942f2387e497334888a4bc4f68b9275c9 (patch)
tree: 4785288a4aca2ac31f1de50c71a1d782b7d5ae6a /Swift/Controllers/Chat/UnitTest
parent: 476e2b32106449dc52a0b237caeb0492fe6c9c32 (diff)
download: swift-57a611f942f2387e497334888a4bc4f68b9275c9.zip
swift-57a611f942f2387e497334888a4bc4f68b9275c9.tar.bz2
1 files changed, 70 insertions, 14 deletions
diff --git a/Swift/Controllers/Chat/UnitTest/ChatsManagerTest.cpp b/Swift/Controllers/Chat/UnitTest/ChatsManagerTest.cpp
index d104fbd..0356c6a 100644
--- a/Swift/Controllers/Chat/UnitTest/ChatsManagerTest.cpp
+++ b/Swift/Controllers/Chat/UnitTest/ChatsManagerTest.cpp
@@ -110,60 +110,65 @@ class ChatsManagerTest : public CppUnit::TestFixture {
     CPPUNIT_TEST(testNoDuplicateUnbind);
     CPPUNIT_TEST(testThreeMUCWindows);
     CPPUNIT_TEST(testChatControllerPresenceAccessUpdatedOnRemoveFromRoster);
     CPPUNIT_TEST(testChatControllerPresenceAccessUpdatedOnAddToRoster);
     CPPUNIT_TEST(testChatControllerPresenceAccessUpdatedOnSubscriptionChangeToBoth);
     CPPUNIT_TEST(testChatControllerPresenceAccessUpdatedOnSubscriptionChangeToFrom);
     CPPUNIT_TEST(testChatControllerFullJIDBindingOnMessageAndNotReceipt);
     CPPUNIT_TEST(testChatControllerFullJIDBindingOnTypingAndNotActive);
     CPPUNIT_TEST(testLocalMUCServiceDiscoveryResetOnDisconnect);
     CPPUNIT_TEST(testPresenceChangeDoesNotReplaceMUCInvite);
     CPPUNIT_TEST(testNotSplittingMUCPresenceJoinLeaveLinesOnChatStateNotifications);
 
     // MUC PM Tests
     CPPUNIT_TEST(testChatControllerPMPresenceHandling);
     CPPUNIT_TEST(testChatControllerMucPmUnavailableErrorHandling);
 
     // Highlighting tests
     CPPUNIT_TEST(testChatControllerHighlightingNotificationTesting);
     CPPUNIT_TEST(testChatControllerHighlightingNotificationDeduplicateSounds);
     CPPUNIT_TEST(testChatControllerHighlightingNotificationKeyword);
 
     CPPUNIT_TEST(testChatControllerMeMessageHandling);
     CPPUNIT_TEST(testRestartingMUCComponentCrash);
     CPPUNIT_TEST(testChatControllerMeMessageHandlingInMUC);
 
     // Carbons tests
     CPPUNIT_TEST(testCarbonsForwardedIncomingMessageToSecondResource);
     CPPUNIT_TEST(testCarbonsForwardedOutgoingMessageFromSecondResource);
     CPPUNIT_TEST(testCarbonsForwardedIncomingDuplicates);
 
+
+    // Message correction tests
+    CPPUNIT_TEST(testChatControllerMessageCorrectionReplaceBySameResource);
+    CPPUNIT_TEST(testChatControllerMessageCorrectionReplaceByOtherResource);
+
     CPPUNIT_TEST_SUITE_END();
 
 public:
     void setUp() {
         mocks_ = new MockRepository();
         notifier_ = std::unique_ptr<DummyNotifier>(new DummyNotifier());
         jid_ = JID("test@test.com/resource");
         stanzaChannel_ = new DummyStanzaChannel();
         iqRouter_ = new IQRouter(stanzaChannel_);
         eventController_ = new EventController();
         chatWindowFactory_ = mocks_->InterfaceMock<ChatWindowFactory>();
         joinMUCWindowFactory_ = mocks_->InterfaceMock<JoinMUCWindowFactory>();
         xmppRoster_ = new XMPPRosterImpl();
         mucRegistry_ = new MUCRegistry();
         nickResolver_ = new NickResolver(jid_.toBare(), xmppRoster_, nullptr, mucRegistry_);
         presenceOracle_ = new PresenceOracle(stanzaChannel_, xmppRoster_);
         serverDiscoInfo_ = std::make_shared<DiscoInfo>();
         presenceSender_ = new StanzaChannelPresenceSender(stanzaChannel_);
         directedPresenceSender_ = new DirectedPresenceSender(presenceSender_);
         mucManager_ = new MUCManager(stanzaChannel_, iqRouter_, directedPresenceSender_, mucRegistry_);
         uiEventStream_ = new UIEventStream();
         entityCapsProvider_ = new DummyEntityCapsProvider();
         chatListWindowFactory_ = mocks_->InterfaceMock<ChatListWindowFactory>();
         mucSearchWindowFactory_ = mocks_->InterfaceMock<MUCSearchWindowFactory>();
         settings_ = new DummySettingsProvider();
         profileSettings_ = new ProfileSettingsProvider("a", settings_);
         chatListWindow_ = new MockChatListWindow();
         ftManager_ = new DummyFileTransferManager();
         ftOverview_ = new FileTransferOverview(ftManager_);
         avatarManager_ = new NullAvatarManager();
@@ -190,61 +195,60 @@ public:
     void tearDown() {
         delete highlightManager_;
         delete profileSettings_;
         delete eventNotifier_;
         delete avatarManager_;
         delete manager_;
         delete timerFactory_;
         delete clientBlockListManager_;
         delete vcardManager_;
         delete vcardStorage_;
         delete crypto_;
         delete ftOverview_;
         delete ftManager_;
         delete wbSessionManager_;
         delete wbManager_;
         delete directedPresenceSender_;
         delete presenceSender_;
         delete presenceOracle_;
         delete nickResolver_;
         delete mucRegistry_;
         delete iqRouter_;
         delete stanzaChannel_;
         delete eventController_;
         delete uiEventStream_;
         delete mucManager_;
         delete xmppRoster_;
         delete entityCapsProvider_;
         delete chatListWindow_;
         delete mocks_;
         delete settings_;
-
     }
 
     void testFirstOpenWindowIncoming() {
         JID messageJID("testling@test.com/resource1");
 
         MockChatWindow* window = new MockChatWindow();
         mocks_->ExpectCall(chatWindowFactory_, ChatWindowFactory::createChatWindow).With(messageJID, uiEventStream_).Return(window);
 
         std::shared_ptr<Message> message(new Message());
         message->setFrom(messageJID);
         std::string body("This is a legible message. >HEH@)oeueu");
         message->setBody(body);
         manager_->handleIncomingMessage(message);
         CPPUNIT_ASSERT_EQUAL(body, MockChatWindow::bodyFromMessage(window->lastAddedMessage_));
     }
 
     void testSecondOpenWindowIncoming() {
         JID messageJID1("testling@test.com/resource1");
 
         MockChatWindow* window1 = new MockChatWindow();
         mocks_->ExpectCall(chatWindowFactory_, ChatWindowFactory::createChatWindow).With(messageJID1, uiEventStream_).Return(window1);
 
         std::shared_ptr<Message> message1(new Message());
         message1->setFrom(messageJID1);
         std::string body1("This is a legible message. >HEH@)oeueu");
         message1->setBody(body1);
         manager_->handleIncomingMessage(message1);
         CPPUNIT_ASSERT_EQUAL(body1, MockChatWindow::bodyFromMessage(window1->lastAddedMessage_));
 
         JID messageJID2("testling@test.com/resource2");
@@ -705,61 +709,61 @@ public:
         CPPUNIT_ASSERT(stanzaChannel_->getStanzaAtIndex<Message>(4)->getPayload<DeliveryReceiptRequest>());
     }
 
     void testChatControllerPMPresenceHandling() {
         JID participantA = JID("test@rooms.test.com/participantA");
         JID participantB = JID("test@rooms.test.com/participantB");
 
         mucRegistry_->addMUC("test@rooms.test.com");
 
         MockChatWindow* window = new MockChatWindow();
         mocks_->ExpectCall(chatWindowFactory_, ChatWindowFactory::createChatWindow).With(participantA, uiEventStream_).Return(window);
 
         uiEventStream_->send(std::make_shared<RequestChatUIEvent>(JID(participantA)));
 
         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_));
 
         presence = Presence::create();
         presence->setFrom(participantB);
         presence->setShow(StatusShow::Away);
         stanzaChannel_->onPresenceReceived(presence);
 
         presence = Presence::create();
         presence->setFrom(participantA);
         presence->setShow(StatusShow::None);
         presence->setType(Presence::Unavailable);
         stanzaChannel_->onPresenceReceived(presence);
-        CPPUNIT_ASSERT_EQUAL(std::string("participantA has gone offline."), MockChatWindow::bodyFromMessage(window->lastReplacedMessage_));
+        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);
         CPPUNIT_ASSERT_EQUAL(messageBody, *sendMessageStanza->getBody());
 
         // receive reply with error
@@ -1070,129 +1074,129 @@ public:
         };
 
         stanzaChannel_->onPresenceReceived(generateIncomingPresence(Presence::Available));
 
         MockChatWindow* window = new MockChatWindow();
         mocks_->ExpectCall(chatWindowFactory_, ChatWindowFactory::createChatWindow).With(messageJID, uiEventStream_).Return(window);
 
         std::shared_ptr<Message> message(new Message());
         message->setFrom(messageJID);
         std::string body("This is a legible message. >HEH@)oeueu");
         message->setBody(body);
         manager_->handleIncomingMessage(message);
         CPPUNIT_ASSERT_EQUAL(body, MockChatWindow::bodyFromMessage(window->lastAddedMessage_));
 
         auto incomingMUCInvite = std::make_shared<Message>();
         incomingMUCInvite->setFrom(messageJID);
 
         auto invitePayload = std::make_shared<MUCInvitationPayload>();
         invitePayload->setJID("room@muc.service.com");
         incomingMUCInvite->addPayload(invitePayload);
 
         stanzaChannel_->onPresenceReceived(generateIncomingPresence(Presence::Unavailable));
         stanzaChannel_->onPresenceReceived(generateIncomingPresence(Presence::Available));
 
         window->resetLastMessages();
 
         manager_->handleIncomingMessage(incomingMUCInvite);
         CPPUNIT_ASSERT_EQUAL(JID("room@muc.service.com"), window->lastMUCInvitationJID_);
 
         stanzaChannel_->onPresenceReceived(generateIncomingPresence(Presence::Unavailable));
-        CPPUNIT_ASSERT_EQUAL(std::string(""), MockChatWindow::bodyFromMessage(window->lastReplacedMessage_));
+        CPPUNIT_ASSERT_EQUAL(std::string(""), MockChatWindow::bodyFromMessage(window->lastReplacedLastMessage_));
         CPPUNIT_ASSERT_EQUAL(std::string("testling@test.com has gone offline."), MockChatWindow::bodyFromMessage(window->lastAddedPresence_));
     }
 
     void testNotSplittingMUCPresenceJoinLeaveLinesOnChatStateNotifications() {
         JID mucJID("mucroom@rooms.test.com");
         std::string nickname = "toodles";
 
         MockChatWindow* window = new MockChatWindow();
         mocks_->ExpectCall(chatWindowFactory_, ChatWindowFactory::createChatWindow).With(mucJID, uiEventStream_).Return(window);
 
         uiEventStream_->send(std::make_shared<JoinMUCUIEvent>(mucJID, boost::optional<std::string>(), nickname));
 
         auto genRemoteMUCPresence = [=]() {
             auto presence = Presence::create();
             presence->setFrom(mucJID.withResource(nickname));
             presence->setTo(jid_);
             return presence;
         };
 
         {
             auto presence = genRemoteMUCPresence();
             auto userPayload = std::make_shared<MUCUserPayload>();
             userPayload->addStatusCode(110);
             userPayload->addItem(MUCItem(MUCOccupant::Owner, jid_, MUCOccupant::Moderator));
             presence->addPayload(userPayload);
             stanzaChannel_->onPresenceReceived(presence);
         }
 
         {
             auto presence = genRemoteMUCPresence();
             presence->setFrom(mucJID.withResource("someDifferentNickname"));
             auto userPayload = std::make_shared<MUCUserPayload>();
             presence->addPayload(userPayload);
             stanzaChannel_->onPresenceReceived(presence);
         }
         CPPUNIT_ASSERT_EQUAL(std::string("someDifferentNickname has entered the room."), window->bodyFromMessage(window->lastAddedPresence_));
-        CPPUNIT_ASSERT_EQUAL(std::string(), window->bodyFromMessage(window->lastReplacedMessage_));
+        CPPUNIT_ASSERT_EQUAL(std::string(), window->bodyFromMessage(window->lastReplacedLastMessage_));
         window->resetLastMessages();
 
         {
             auto presence = genRemoteMUCPresence();
             presence->setFrom(mucJID.withResource("Romeo"));
             auto userPayload = std::make_shared<MUCUserPayload>();
             presence->addPayload(userPayload);
             stanzaChannel_->onPresenceReceived(presence);
         }
         CPPUNIT_ASSERT_EQUAL(std::string(), window->bodyFromMessage(window->lastAddedPresence_));
-        CPPUNIT_ASSERT_EQUAL(std::string("someDifferentNickname and Romeo have entered the room"), window->bodyFromMessage(window->lastReplacedMessage_));
+        CPPUNIT_ASSERT_EQUAL(std::string("someDifferentNickname and Romeo have entered the room"), window->bodyFromMessage(window->lastReplacedLastMessage_));
         window->resetLastMessages();
 
         {
             auto message = std::make_shared<Message>();
             message->setFrom(mucJID.withResource("Romeo"));
             message->setTo(mucJID);
             message->setType(Message::Groupchat);
             message->addPayload(std::make_shared<ChatState>(ChatState::Composing));
             manager_->handleIncomingMessage(message);
         }
 
         {
             auto presence = genRemoteMUCPresence();
             presence->setFrom(mucJID.withResource("Juliet"));
             auto userPayload = std::make_shared<MUCUserPayload>();
             presence->addPayload(userPayload);
             stanzaChannel_->onPresenceReceived(presence);
         }
         CPPUNIT_ASSERT_EQUAL(std::string(), window->bodyFromMessage(window->lastAddedPresence_));
-        CPPUNIT_ASSERT_EQUAL(std::string("someDifferentNickname, Romeo and Juliet have entered the room"), window->bodyFromMessage(window->lastReplacedMessage_));
+        CPPUNIT_ASSERT_EQUAL(std::string("someDifferentNickname, Romeo and Juliet have entered the room"), window->bodyFromMessage(window->lastReplacedLastMessage_));
     }
 
     template <typename CarbonsType>
     Message::ref createCarbonsMessage(std::shared_ptr<CarbonsType> carbons, std::shared_ptr<Message> forwardedMessage) {
         auto messageWrapper = std::make_shared<Message>();
         messageWrapper->setFrom(jid_.toBare());
         messageWrapper->setTo(jid_);
         messageWrapper->setType(Message::Chat);
 
         messageWrapper->addPayload(carbons);
         auto forwarded = std::make_shared<Forwarded>();
         carbons->setForwarded(forwarded);
         forwarded->setStanza(forwardedMessage);
         return messageWrapper;
     }
 
     void testCarbonsForwardedIncomingMessageToSecondResource() {
         JID messageJID("testling@test.com/resource1");
         JID jid2 = jid_.toBare().withResource("someOtherResource");
 
         MockChatWindow* window = new MockChatWindow();
         mocks_->ExpectCall(chatWindowFactory_, ChatWindowFactory::createChatWindow).With(messageJID, uiEventStream_).Return(window);
 
         std::shared_ptr<Message> message(new Message());
         message->setFrom(messageJID);
         std::string body("This is a legible message. >HEH@)oeueu");
         message->setBody(body);
         manager_->handleIncomingMessage(message);
         CPPUNIT_ASSERT_EQUAL(body, MockChatWindow::bodyFromMessage(window->lastAddedMessage_));
 
@@ -1238,100 +1242,152 @@ public:
             std::string forwardedBody = "Some text my other resource sent.";
             originalMessage->setBody(forwardedBody);
             originalMessage->addPayload(std::make_shared<DeliveryReceiptRequest>());
 
             auto messageWrapper = createCarbonsMessage(std::make_shared<CarbonsSent>(), originalMessage);
 
             manager_->handleIncomingMessage(messageWrapper);
 
             CPPUNIT_ASSERT_EQUAL(forwardedBody, MockChatWindow::bodyFromMessage(window->lastAddedMessage_));
             CPPUNIT_ASSERT_EQUAL(true, window->lastAddedMessageSenderIsSelf_);
             CPPUNIT_ASSERT_EQUAL(size_t(1), window->receiptChanges_.size());
             CPPUNIT_ASSERT_EQUAL(ChatWindow::ReceiptRequested, window->receiptChanges_[0].second);
         }
 
         // incoming carbons message for the received delivery receipt to the other resource
         {
             auto originalMessage = std::make_shared<Message>();
             originalMessage->setFrom(messageJID);
             originalMessage->setTo(jid2);
             originalMessage->setType(Message::Chat);
             originalMessage->addPayload(std::make_shared<DeliveryReceipt>("abcdefg123456"));
 
             auto messageWrapper = createCarbonsMessage(std::make_shared<CarbonsReceived>(), originalMessage);
 
             manager_->handleIncomingMessage(messageWrapper);
 
             CPPUNIT_ASSERT_EQUAL(size_t(2), window->receiptChanges_.size());
             CPPUNIT_ASSERT_EQUAL(ChatWindow::ReceiptReceived, window->receiptChanges_[1].second);
         }
     }
-
+    
     void testCarbonsForwardedIncomingDuplicates() {
         JID messageJID("testling@test.com/resource1");
         JID jid2 = jid_.toBare().withResource("someOtherResource");
-
+        
         MockChatWindow* window = new MockChatWindow();
         mocks_->ExpectCall(chatWindowFactory_, ChatWindowFactory::createChatWindow).With(messageJID, uiEventStream_).Return(window);
-
+        
         std::shared_ptr<Message> message(new Message());
         message->setFrom(messageJID);
         std::string body("This is a legible message. >HEH@)oeueu");
         message->setBody(body);
         manager_->handleIncomingMessage(message);
         CPPUNIT_ASSERT_EQUAL(body, MockChatWindow::bodyFromMessage(window->lastAddedMessage_));
-
+        
         // incoming carbons message from another resource and duplicate of it
         {
             auto originalMessage = std::make_shared<Message>();
             originalMessage->setFrom(messageJID);
             originalMessage->setTo(jid2);
             originalMessage->setID("BDD82F0B-2523-48BF-B8CA-17B23A314BC2");
             originalMessage->setType(Message::Chat);
             std::string forwardedBody = "Some further text.";
             originalMessage->setBody(forwardedBody);
-
+            
             auto messageWrapper = createCarbonsMessage(std::make_shared<CarbonsReceived>(), originalMessage);
-
+            
             manager_->handleIncomingMessage(messageWrapper);
-
+            
             CPPUNIT_ASSERT_EQUAL(forwardedBody, MockChatWindow::bodyFromMessage(window->lastAddedMessage_));
             CPPUNIT_ASSERT_EQUAL(false, window->lastAddedMessageSenderIsSelf_);
             window->resetLastMessages();
-
+            
             messageWrapper = createCarbonsMessage(std::make_shared<CarbonsReceived>(), originalMessage);
             manager_->handleIncomingMessage(messageWrapper);
             CPPUNIT_ASSERT_EQUAL(std::string(), MockChatWindow::bodyFromMessage(window->lastAddedMessage_));
             CPPUNIT_ASSERT_EQUAL(false, window->lastAddedMessageSenderIsSelf_);
         }
     }
 
+    void testChatControllerMessageCorrectionReplaceBySameResource() {
+        JID messageJID("testling@test.com/resource1");
+
+        MockChatWindow* window = new MockChatWindow();
+        mocks_->ExpectCall(chatWindowFactory_, ChatWindowFactory::createChatWindow).With(messageJID, uiEventStream_).Return(window);
+
+        auto message = std::make_shared<Message>();
+        message->setFrom(messageJID);
+        message->setTo(jid_);
+        message->setType(Message::Chat);
+        message->setBody("text before edit");
+        manager_->handleIncomingMessage(message);
+
+        CPPUNIT_ASSERT_EQUAL(std::string("text before edit"), MockChatWindow::bodyFromMessage(window->lastAddedMessage_));
+
+        message = std::make_shared<Message>();
+        message->setFrom(messageJID);
+        message->setTo(jid_);
+        message->setType(Message::Chat);
+        message->setBody("text after edit");
+        message->addPayload(std::make_shared<Replace>("someID"));
+        manager_->handleIncomingMessage(message);
+
+        CPPUNIT_ASSERT_EQUAL(std::string("text after edit"), MockChatWindow::bodyFromMessage(window->lastReplacedMessage_));
+    }
+
+    void testChatControllerMessageCorrectionReplaceByOtherResource() {
+        JID messageJID("testling@test.com/resource1");
+
+        MockChatWindow* window = new MockChatWindow();
+        mocks_->ExpectCall(chatWindowFactory_, ChatWindowFactory::createChatWindow).With(messageJID, uiEventStream_).Return(window);
+
+        auto message = std::make_shared<Message>();
+        message->setFrom(messageJID);
+        message->setTo(jid_);
+        message->setType(Message::Chat);
+        message->setBody("text before edit");
+        manager_->handleIncomingMessage(message);
+
+        CPPUNIT_ASSERT_EQUAL(std::string("text before edit"), MockChatWindow::bodyFromMessage(window->lastAddedMessage_));
+
+        message = std::make_shared<Message>();
+        message->setFrom(messageJID.toBare().withResource("resource2"));
+        message->setTo(jid_);
+        message->setType(Message::Chat);
+        message->setBody("text after edit");
+        message->addPayload(std::make_shared<Replace>("someID"));
+        manager_->handleIncomingMessage(message);
+
+        CPPUNIT_ASSERT_EQUAL(std::string("text after edit"), MockChatWindow::bodyFromMessage(window->lastReplacedMessage_));
+    }
+
 private:
     std::shared_ptr<Message> makeDeliveryReceiptTestMessage(const JID& from, const std::string& id) {
         std::shared_ptr<Message> message = std::make_shared<Message>();
         message->setFrom(from);
         message->setID(id);
         message->setBody("This will cause the window to open");
         message->addPayload(std::make_shared<DeliveryReceiptRequest>());
         return message;
     }
 
     size_t st(int i) {
         return static_cast<size_t>(i);
     }
 
     void handleHighlightAction(const HighlightAction& action) {
         handledHighlightActions_++;
         if (action.getSoundFilePath()) {
             soundsPlayed_.insert(action.getSoundFilePath().get_value_or(""));
         }
     }
 
 private:
     JID jid_;
     std::unique_ptr<DummyNotifier> notifier_;
     ChatsManager* manager_;
     DummyStanzaChannel* stanzaChannel_;
     IQRouter* iqRouter_;
     EventController* eventController_;
     ChatWindowFactory* chatWindowFactory_;
     JoinMUCWindowFactory* joinMUCWindowFactory_;
author	Tobias Markmann <tm@ayena.de>	2016-08-17 09:02:24 (GMT)
committer	Tobias Markmann <tm@ayena.de>	2017-04-18 15:38:43 (GMT)
commit	57a611f942f2387e497334888a4bc4f68b9275c9 (patch)
tree	4785288a4aca2ac31f1de50c71a1d782b7d5ae6a /Swift/Controllers/Chat/UnitTest
parent	476e2b32106449dc52a0b237caeb0492fe6c9c32 (diff)
download	swift-57a611f942f2387e497334888a4bc4f68b9275c9.zip swift-57a611f942f2387e497334888a4bc4f68b9275c9.tar.bz2