1 files changed, 68 insertions, 0 deletions
diff --git a/Swift/Controllers/Chat/UnitTest/ChatsManagerTest.cpp b/Swift/Controllers/Chat/UnitTest/ChatsManagerTest.cpp
index 00df3da..1958408 100644
--- a/Swift/Controllers/Chat/UnitTest/ChatsManagerTest.cpp
+++ b/Swift/Controllers/Chat/UnitTest/ChatsManagerTest.cpp
@@ -89,60 +89,61 @@ class DummyNotifier : public Notifier {
             Type type;
             std::string subject;
             std::string description;
             boost::filesystem::path picture;
             boost::function<void()> callback;
         };
 
     public:
         std::vector<Notification> notifications;
 };
 
 
 class ChatsManagerTest : public CppUnit::TestFixture {
     CPPUNIT_TEST_SUITE(ChatsManagerTest);
     CPPUNIT_TEST(testFirstOpenWindowIncoming);
     CPPUNIT_TEST(testSecondOpenWindowIncoming);
     CPPUNIT_TEST(testFirstOpenWindowOutgoing);
     CPPUNIT_TEST(testFirstOpenWindowBareToFull);
     CPPUNIT_TEST(testSecondWindow);
     CPPUNIT_TEST(testUnbindRebind);
     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_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>();
@@ -1068,60 +1069,127 @@ public:
         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("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_));
+        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_));
+        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_));
+    }
+
     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_));
 
         // incoming carbons message from another resource
         {