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_;