Redesign highlight logic and processing

The new highlight logic follows a simpler model. It supports: * highlighting of whole words in a message * highlighting messages by sender name * highlighting if the user’s name is mentioned Possible actions for these highlights are text colouring, sound playback of WAV files, and system notifications. In addition the user can decide to receive sound and system notification on general incoming direct and group messages. Redesigned the highlight configuration UI dialog for this new model. ChatMessageParser class now deals with all parsing and marking up the chat message with the matching HighlightActions. Highlighter class has been extended to deal with all sound and system notification highlights that should be emitted by a specified chat message. Moved some tests over to gtest in the process. Test-Information: Tested UI on macOS 10.12.3 with Qt 5.7.1. Manually tested that correct system notification are emitted on mentions, keyword highlights and general messages. Added new unit tests to cover new highlighting behaviour. Change-Id: I1c89e29d81022174187fb44af0d384036ec51594
author: Tobias Markmann <tm@ayena.de> 2017-01-31 14:57:22 (GMT)
committer: Edwin Mons <edwin.mons@isode.com> 2017-02-27 14:07:13 (GMT)
commit: fc8f5b31c22ed7af4f0e2473f269601a87a0438c (patch)
tree: 0c59a9debf72247c7409947a3a4cccb6c616dd06 /Swift/Controllers/Chat/UnitTest/ChatsManagerTest.cpp
parent: abd81d4a3cf08ffaa1e5265d204cdd80c8c0583b (diff)
download: swift-fc8f5b31c22ed7af4f0e2473f269601a87a0438c.zip
swift-fc8f5b31c22ed7af4f0e2473f269601a87a0438c.tar.bz2
1 files changed, 36 insertions, 48 deletions
diff --git a/Swift/Controllers/Chat/UnitTest/ChatsManagerTest.cpp b/Swift/Controllers/Chat/UnitTest/ChatsManagerTest.cpp
index cff54f8..80f8346 100644
--- a/Swift/Controllers/Chat/UnitTest/ChatsManagerTest.cpp
+++ b/Swift/Controllers/Chat/UnitTest/ChatsManagerTest.cpp
@@ -1,32 +1,32 @@
 /*
- * Copyright (c) 2010-2016 Isode Limited.
+ * Copyright (c) 2010-2017 Isode Limited.
  * All rights reserved.
  * See the COPYING file for more information.
  */
 
 #include <map>
 #include <set>
 
 #include <boost/bind.hpp>
 
 #include <cppunit/extensions/HelperMacros.h>
 #include <cppunit/extensions/TestFactoryRegistry.h>
 #include <hippomocks.h>
 
 #include <Swiften/Avatars/AvatarMemoryStorage.h>
 #include <Swiften/Avatars/NullAvatarManager.h>
 #include <Swiften/Base/Algorithm.h>
 #include <Swiften/Client/Client.h>
 #include <Swiften/Client/ClientBlockListManager.h>
 #include <Swiften/Client/DummyStanzaChannel.h>
 #include <Swiften/Client/NickResolver.h>
 #include <Swiften/Crypto/CryptoProvider.h>
 #include <Swiften/Crypto/PlatformCryptoProvider.h>
 #include <Swiften/Disco/DummyEntityCapsProvider.h>
 #include <Swiften/Elements/CarbonsReceived.h>
 #include <Swiften/Elements/CarbonsSent.h>
 #include <Swiften/Elements/DeliveryReceipt.h>
 #include <Swiften/Elements/DeliveryReceiptRequest.h>
 #include <Swiften/Elements/Forwarded.h>
 #include <Swiften/Elements/MUCInvitationPayload.h>
 #include <Swiften/Elements/MUCUserPayload.h>
@@ -104,61 +104,61 @@ class ChatsManagerTest : public CppUnit::TestFixture {
 public:
     void setUp() {
         mocks_ = new MockRepository();
         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();
         wbSessionManager_ = new WhiteboardSessionManager(iqRouter_, stanzaChannel_, presenceOracle_, entityCapsProvider_);
         wbManager_ = new WhiteboardManager(whiteboardWindowFactory_, uiEventStream_, nickResolver_, wbSessionManager_);
         highlightManager_ = new HighlightManager(settings_);
-        highlightManager_->resetToDefaultRulesList();
+        highlightManager_->resetToDefaultConfiguration();
         handledHighlightActions_ = 0;
         soundsPlayed_.clear();
         highlightManager_->onHighlight.connect(boost::bind(&ChatsManagerTest::handleHighlightAction, this, _1));
 
         crypto_ = PlatformCryptoProvider::create();
         vcardStorage_ = new VCardMemoryStorage(crypto_);
         vcardManager_ = new VCardManager(jid_, iqRouter_, vcardStorage_);
         mocks_->ExpectCall(chatListWindowFactory_, ChatListWindowFactory::createChatListWindow).With(uiEventStream_).Return(chatListWindow_);
         clientBlockListManager_ = new ClientBlockListManager(iqRouter_);
         manager_ = new ChatsManager(jid_, stanzaChannel_, iqRouter_, eventController_, chatWindowFactory_, joinMUCWindowFactory_, nickResolver_, presenceOracle_, directedPresenceSender_, uiEventStream_, chatListWindowFactory_, true, nullptr, mucRegistry_, entityCapsProvider_, mucManager_, mucSearchWindowFactory_, profileSettings_, ftOverview_, xmppRoster_, false, settings_, nullptr, wbManager_, highlightManager_, clientBlockListManager_, emoticons_, vcardManager_);
 
         manager_->setAvatarManager(avatarManager_);
     }
 
     void tearDown() {
         delete highlightManager_;
         delete profileSettings_;
         delete avatarManager_;
         delete manager_;
         delete clientBlockListManager_;
         delete vcardManager_;
         delete vcardStorage_;
         delete crypto_;
         delete ftOverview_;
         delete ftManager_;
         delete wbSessionManager_;
         delete wbManager_;
         delete directedPresenceSender_;
         delete presenceSender_;
         delete presenceOracle_;
@@ -759,128 +759,115 @@ public:
         stanzaChannel_->onIQReceived(infoResponse);
 
         CPPUNIT_ASSERT_EQUAL(true, window->impromptuMUCSupported_);
         manager_->setOnline(false);
         CPPUNIT_ASSERT_EQUAL(false, window->impromptuMUCSupported_);
     }
 
     void testhelperChatControllerPresenceAccessUpdatedOnSubscriptionChangeReceiptsAllowed(RosterItemPayload::Subscription from, RosterItemPayload::Subscription to) {
         JID messageJID("testling@test.com/resource1");
         xmppRoster_->addContact(messageJID, "foo", std::vector<std::string>(), from);
 
         MockChatWindow* window = new MockChatWindow();//mocks_->InterfaceMock<ChatWindow>();
         mocks_->ExpectCall(chatWindowFactory_, ChatWindowFactory::createChatWindow).With(messageJID, uiEventStream_).Return(window);
         settings_->storeSetting(SettingConstants::REQUEST_DELIVERYRECEIPTS, true);
 
         std::shared_ptr<Message> message = makeDeliveryReceiptTestMessage(messageJID, "1");
         manager_->handleIncomingMessage(message);
 
         CPPUNIT_ASSERT_EQUAL(st(0), stanzaChannel_->countSentStanzaOfType<Message>());
 
         xmppRoster_->addContact(messageJID, "foo", std::vector<std::string>(), to);
         message->setID("2");
         manager_->handleIncomingMessage(message);
 
         CPPUNIT_ASSERT_EQUAL(st(1), stanzaChannel_->countSentStanzaOfType<Message>());
         Stanza::ref stanzaContactOnRoster = stanzaChannel_->getStanzaAtIndex<Stanza>(1);
         CPPUNIT_ASSERT(stanzaContactOnRoster->getPayload<DeliveryReceipt>() != nullptr);
     }
 
     void testChatControllerHighlightingNotificationTesting() {
-        HighlightRule keywordRuleA;
-        keywordRuleA.setMatchChat(true);
-        std::vector<std::string> keywordsA;
-        keywordsA.push_back("Romeo");
-        keywordRuleA.setKeywords(keywordsA);
-        keywordRuleA.getAction().setTextColor("yellow");
-        keywordRuleA.getAction().setPlaySound(true);
-        highlightManager_->insertRule(0, keywordRuleA);
-
-        HighlightRule keywordRuleB;
-        keywordRuleB.setMatchChat(true);
-        std::vector<std::string> keywordsB;
-        keywordsB.push_back("Juliet");
-        keywordRuleB.setKeywords(keywordsB);
-        keywordRuleB.getAction().setTextColor("green");
-        keywordRuleB.getAction().setPlaySound(true);
-        keywordRuleB.getAction().setSoundFile("/tmp/someotherfile.wav");
-        highlightManager_->insertRule(0, keywordRuleB);
+        HighlightConfiguration::KeywordHightlight keywordRuleA;
+        keywordRuleA.keyword = "Romeo";
+        keywordRuleA.action.setFrontColor(boost::optional<std::string>("yellow"));
+        keywordRuleA.action.setSoundFilePath(boost::optional<std::string>(""));
+        highlightManager_->getConfiguration()->keywordHighlights.push_back(keywordRuleA);
+
+        HighlightConfiguration::KeywordHightlight keywordRuleB;
+        keywordRuleB.keyword = "Juliet";
+        keywordRuleB.action.setFrontColor(boost::optional<std::string>("green"));
+        keywordRuleB.action.setSoundFilePath(boost::optional<std::string>("/tmp/someotherfile.wav"));
+        highlightManager_->getConfiguration()->keywordHighlights.push_back(keywordRuleB);
 
         JID messageJID = JID("testling@test.com");
 
         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 message should cause two sounds: Juliet and Romeo.");
         message->setBody(body);
         manager_->handleIncomingMessage(message);
 
         CPPUNIT_ASSERT_EQUAL(2, handledHighlightActions_);
-        CPPUNIT_ASSERT(soundsPlayed_.find(keywordRuleA.getAction().getSoundFile()) != soundsPlayed_.end());
-        CPPUNIT_ASSERT(soundsPlayed_.find(keywordRuleB.getAction().getSoundFile()) != soundsPlayed_.end());
+        CPPUNIT_ASSERT(soundsPlayed_.find(keywordRuleA.action.getSoundFilePath().get_value_or("")) != soundsPlayed_.end());
+        CPPUNIT_ASSERT(soundsPlayed_.find(keywordRuleB.action.getSoundFilePath().get_value_or("")) != soundsPlayed_.end());
     }
 
     void testChatControllerHighlightingNotificationDeduplicateSounds() {
-        HighlightRule keywordRuleA;
-        keywordRuleA.setMatchChat(true);
-        std::vector<std::string> keywordsA;
-        keywordsA.push_back("Romeo");
-        keywordRuleA.setKeywords(keywordsA);
-        keywordRuleA.getAction().setTextColor("yellow");
-        keywordRuleA.getAction().setPlaySound(true);
-        highlightManager_->insertRule(0, keywordRuleA);
-
-        HighlightRule keywordRuleB;
-        keywordRuleB.setMatchChat(true);
-        std::vector<std::string> keywordsB;
-        keywordsB.push_back("Juliet");
-        keywordRuleB.setKeywords(keywordsB);
-        keywordRuleB.getAction().setTextColor("green");
-        keywordRuleB.getAction().setPlaySound(true);
-        highlightManager_->insertRule(0, keywordRuleB);
+        auto keywordRuleA = HighlightConfiguration::KeywordHightlight();
+        keywordRuleA.keyword = "Romeo";
+        keywordRuleA.action.setFrontColor(boost::optional<std::string>("yellow"));
+        keywordRuleA.action.setSoundFilePath(boost::optional<std::string>(""));
+        highlightManager_->getConfiguration()->keywordHighlights.push_back(keywordRuleA);
+
+        auto keywordRuleB = HighlightConfiguration::KeywordHightlight();
+        keywordRuleB.keyword = "Juliet";
+        keywordRuleB.action.setFrontColor(boost::optional<std::string>("green"));
+        keywordRuleB.action.setSoundFilePath(boost::optional<std::string>(""));
+        highlightManager_->getConfiguration()->keywordHighlights.push_back(keywordRuleB);
 
         JID messageJID = JID("testling@test.com");
 
         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 message should cause one sound, because both actions have the same sound: Juliet and Romeo.");
         message->setBody(body);
         manager_->handleIncomingMessage(message);
 
         CPPUNIT_ASSERT_EQUAL(1, handledHighlightActions_);
-        CPPUNIT_ASSERT(soundsPlayed_.find(keywordRuleA.getAction().getSoundFile()) != soundsPlayed_.end());
-        CPPUNIT_ASSERT(soundsPlayed_.find(keywordRuleB.getAction().getSoundFile()) != soundsPlayed_.end());
+        CPPUNIT_ASSERT(soundsPlayed_.find(keywordRuleA.action.getSoundFilePath().get_value_or("")) != soundsPlayed_.end());
+        CPPUNIT_ASSERT(soundsPlayed_.find(keywordRuleB.action.getSoundFilePath().get_value_or("")) != soundsPlayed_.end());
     }
 
     void testChatControllerMeMessageHandling() {
         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("/me is feeling delighted.");
         message->setBody(body);
         manager_->handleIncomingMessage(message);
         CPPUNIT_ASSERT_EQUAL(std::string("is feeling delighted."), window->bodyFromMessage(window->lastAddedAction_));
     }
 
    void testRestartingMUCComponentCrash() {
         JID mucJID = JID("teaparty@rooms.wonderland.lit");
         JID self = JID("girl@wonderland.lit/rabbithole");
         std::string nick = "aLiCe";
 
         MockChatWindow* window;
 
         auto genRemoteMUCPresence = [=]() {
             auto presence = Presence::create();
             presence->setFrom(mucJID.withResource(nick));
             presence->setTo(self);
             return presence;
         };
 
@@ -895,66 +882,67 @@ public:
         }
 
         {
             auto firstPresence = genRemoteMUCPresence();
             firstPresence->setType(Presence::Unavailable);
             auto userPayload = std::make_shared<MUCUserPayload>();
             userPayload->addItem(MUCItem(MUCOccupant::Owner, MUCOccupant::NoRole));
             firstPresence->addPayload(userPayload);
             stanzaChannel_->onPresenceReceived(firstPresence);
         }
         CPPUNIT_ASSERT_EQUAL(std::string("Couldn't enter room: Unable to enter this room."), MockChatWindow::bodyFromMessage(window->lastAddedErrorMessage_));
 
         {
             auto presence = genRemoteMUCPresence();
             presence->setType(Presence::Unavailable);
             auto userPayload = std::make_shared<MUCUserPayload>();
             userPayload->addStatusCode(303);
             auto item = MUCItem(MUCOccupant::Owner, self, MUCOccupant::Moderator);
             item.nick = nick;
             userPayload->addItem(item);
             userPayload->addStatusCode(110);
             presence->addPayload(userPayload);
             stanzaChannel_->onPresenceReceived(presence);
         }
     }
 
     void testChatControllerMeMessageHandlingInMUC() {
         JID mucJID("mucroom@rooms.test.com");
         std::string nickname = "toodles";
 
+        //highlightManager_->resetToDefaultConfiguration();
+
         // add highlight rule for 'foo'
-        HighlightRule fooHighlight;
-        fooHighlight.setKeywords({"foo"});
-        fooHighlight.setMatchMUC(true);
-        fooHighlight.getAction().setTextBackground("green");
-        highlightManager_->insertRule(0, fooHighlight);
+        HighlightConfiguration::KeywordHightlight keywordHighlight;
+        keywordHighlight.keyword = "foo";
+        keywordHighlight.action.setBackColor(boost::optional<std::string>("green"));
+        highlightManager_->getConfiguration()->keywordHighlights.push_back(keywordHighlight);
 
         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>();
             userPayload->addItem(MUCItem(MUCOccupant::Member, JID("foo@bar.com"), MUCOccupant::Moderator));
             presence->addPayload(userPayload);
             stanzaChannel_->onPresenceReceived(presence);
         }
@@ -1114,62 +1102,62 @@ public:
             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);
         }
     }
 
 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.playSound()) {
-            soundsPlayed_.insert(action.getSoundFile());
+        if (action.getSoundFilePath()) {
+            soundsPlayed_.insert(action.getSoundFilePath().get_value_or(""));
         }
     }
 
 private:
     JID jid_;
     ChatsManager* manager_;
     DummyStanzaChannel* stanzaChannel_;
     IQRouter* iqRouter_;
     EventController* eventController_;
     ChatWindowFactory* chatWindowFactory_;
     JoinMUCWindowFactory* joinMUCWindowFactory_;
     NickResolver* nickResolver_;
     PresenceOracle* presenceOracle_;
     AvatarManager* avatarManager_;
     std::shared_ptr<DiscoInfo> serverDiscoInfo_;
     XMPPRosterImpl* xmppRoster_;
     PresenceSender* presenceSender_;
     MockRepository* mocks_;
     UIEventStream* uiEventStream_;
     ChatListWindowFactory* chatListWindowFactory_;
     WhiteboardWindowFactory* whiteboardWindowFactory_;
     MUCSearchWindowFactory* mucSearchWindowFactory_;
     MUCRegistry* mucRegistry_;
     DirectedPresenceSender* directedPresenceSender_;
     DummyEntityCapsProvider* entityCapsProvider_;
     MUCManager* mucManager_;
     DummySettingsProvider* settings_;
     ProfileSettingsProvider* profileSettings_;
     ChatListWindow* chatListWindow_;
     FileTransferOverview* ftOverview_;
author	Tobias Markmann <tm@ayena.de>	2017-01-31 14:57:22 (GMT)
committer	Edwin Mons <edwin.mons@isode.com>	2017-02-27 14:07:13 (GMT)
commit	fc8f5b31c22ed7af4f0e2473f269601a87a0438c (patch)
tree	0c59a9debf72247c7409947a3a4cccb6c616dd06 /Swift/Controllers/Chat/UnitTest/ChatsManagerTest.cpp
parent	abd81d4a3cf08ffaa1e5265d204cdd80c8c0583b (diff)
download	swift-fc8f5b31c22ed7af4f0e2473f269601a87a0438c.zip swift-fc8f5b31c22ed7af4f0e2473f269601a87a0438c.tar.bz2