+ CPPUNIT_TEST_SUITE(ChatMessageParserTest);

+ CPPUNIT_TEST(testFullBody);

+ CPPUNIT_TEST(testOneEmoticon);

+ CPPUNIT_TEST(testBareEmoticon);

+ CPPUNIT_TEST(testHiddenEmoticon);

+ CPPUNIT_TEST(testEndlineEmoticon);

+ CPPUNIT_TEST(testBoundedEmoticons);

+ CPPUNIT_TEST(testNoColourNoHighlight);

+ CPPUNIT_TEST_SUITE_END();

+

+ void setUp() {

+ smile1_ = ":)";

+ smile1Path_ = "/blah/smile1.png";

+ smile2_ = ":(";

+ smile2Path_ = "/blah/smile2.jpg";

+ emoticons_[smile1_] = smile1Path_;

+ emoticons_[smile2_] = smile2Path_;

+ }

+

+ void tearDown() {

+ emoticons_.clear();

+ }

+

+ void assertText(const ChatWindow::ChatMessage& result, size_t index, const std::string& text) {

+ boost::shared_ptr<ChatWindow::ChatTextMessagePart> part = boost::dynamic_pointer_cast<ChatWindow::ChatTextMessagePart>(result.getParts()[index]);

+ CPPUNIT_ASSERT_EQUAL(text, part->text);

+ }

+

+ void assertEmoticon(const ChatWindow::ChatMessage& result, size_t index, const std::string& text, const std::string& path) {

+ boost::shared_ptr<ChatWindow::ChatEmoticonMessagePart> part = boost::dynamic_pointer_cast<ChatWindow::ChatEmoticonMessagePart>(result.getParts()[index]);

+ CPPUNIT_ASSERT(!!part);

+ CPPUNIT_ASSERT_EQUAL(text, part->alternativeText);

+ CPPUNIT_ASSERT_EQUAL(path, part->imagePath);

+ }

+ { \

+ boost::shared_ptr<ChatWindow::ChatHighlightingMessagePart> part = boost::dynamic_pointer_cast<ChatWindow::ChatHighlightingMessagePart>(RESULT.getParts()[INDEX]); \

+ CPPUNIT_ASSERT_EQUAL(std::string(TEXT), part->text); \

+ CPPUNIT_ASSERT(EXPECTED_HIGHLIGHT == part->action); \

+ }

+

+ void assertURL(const ChatWindow::ChatMessage& result, size_t index, const std::string& text) {

+ boost::shared_ptr<ChatWindow::ChatURIMessagePart> part = boost::dynamic_pointer_cast<ChatWindow::ChatURIMessagePart>(result.getParts()[index]);

+ CPPUNIT_ASSERT_EQUAL(text, part->target);

+ }

+

+ static HighlightRule ruleFromKeyword(const std::string& keyword, bool matchCase, bool matchWholeWord)

+ {

+ HighlightRule rule;

+ std::vector<std::string> keywords;

+ keywords.push_back(keyword);

+ rule.setKeywords(keywords);

+ rule.setMatchCase(matchCase);

+ rule.setMatchWholeWords(matchWholeWord);

+ rule.setMatchChat(true);

+ rule.getAction().setTextBackground("white");

+ return rule;

+ }

+

+ static const HighlightRulesListPtr ruleListFromKeyword(const std::string& keyword, bool matchCase, bool matchWholeWord)

+ {

+ boost::shared_ptr<HighlightManager::HighlightRulesList> list = boost::make_shared<HighlightManager::HighlightRulesList>();

+ list->addRule(ruleFromKeyword(keyword, matchCase, matchWholeWord));

+ return list;

+ }

+

+ static const HighlightRulesListPtr ruleListFromKeywords(const HighlightRule &rule1, const HighlightRule &rule2)

+ {

+ boost::shared_ptr<HighlightManager::HighlightRulesList> list = boost::make_shared<HighlightManager::HighlightRulesList>();

+ list->addRule(rule1);

+ list->addRule(rule2);

+ return list;

+ }

+

+ static HighlightRulesListPtr ruleListWithNickHighlight(bool withHighlightColour = true)

+ {

+ HighlightRule rule;

+ rule.setMatchChat(true);

+ rule.setNickIsKeyword(true);

+ rule.setMatchCase(true);

+ rule.setMatchWholeWords(true);

+ if (withHighlightColour) {

+ rule.getAction().setTextBackground("white");

+ }

+ boost::shared_ptr<HighlightManager::HighlightRulesList> list = boost::make_shared<HighlightManager::HighlightRulesList>();

+ list->addRule(rule);

+ return list;

+ }

+

+ void testFullBody() {

+ const std::string no_special_message = "a message with no special content";

+ ChatMessageParser testling(emoticons_, boost::make_shared<HighlightManager::HighlightRulesList>());

+ ChatWindow::ChatMessage result = testling.parseMessageBody(no_special_message);

+ assertText(result, 0, no_special_message);

+

+ HighlightRulesListPtr highlightRuleList = ruleListFromKeyword("trigger", false, false);

+ testling = ChatMessageParser(emoticons_, highlightRuleList);

+ result = testling.parseMessageBody(":) shiny :( trigger :) http://wonderland.lit/blah http://denmark.lit boom boom");

+ assertEmoticon(result, 0, smile1_, smile1Path_);

+ assertText(result, 1, " shiny ");

+ assertEmoticon(result, 2, smile2_, smile2Path_);

+ assertText(result, 3, " ");

+ assertHighlight(result, 4, "trigger", highlightRuleList->getRule(0).getAction());

+ assertText(result, 5, " ");

+ assertEmoticon(result, 6, smile1_, smile1Path_);

+ assertText(result, 7, " ");

+ assertURL(result, 8, "http://wonderland.lit/blah");

+ assertText(result, 9, " ");

+ assertURL(result, 10, "http://denmark.lit");

+ assertText(result, 11, " boom boom");

+

+ testling = ChatMessageParser(emoticons_, ruleListFromKeyword("trigger", false, false));

+ result = testling.parseMessageBody("testtriggermessage");

+ assertText(result, 0, "test");

+ assertHighlight(result, 1, "trigger", highlightRuleList->getRule(0).getAction());

+ assertText(result, 2, "message");

+

+ testling = ChatMessageParser(emoticons_, ruleListFromKeyword("trigger", false, true));

+ result = testling.parseMessageBody("testtriggermessage");

+ assertText(result, 0, "testtriggermessage");

+

+ testling = ChatMessageParser(emoticons_, ruleListFromKeyword("trigger", true, false));

+ result = testling.parseMessageBody("TrIgGeR");

+ assertText(result, 0, "TrIgGeR");

+

+ testling = ChatMessageParser(emoticons_, ruleListFromKeyword("trigger", false, false));

+ result = testling.parseMessageBody("TrIgGeR");

+ assertHighlight(result, 0, "TrIgGeR", highlightRuleList->getRule(0).getAction());

+

+ testling = ChatMessageParser(emoticons_, ruleListFromKeyword("trigger", false, false));

+ result = testling.parseMessageBody("partialTrIgGeRmatch");

+ assertText(result, 0, "partial");

+ assertHighlight(result, 1, "TrIgGeR", highlightRuleList->getRule(0).getAction());

+ assertText(result, 2, "match");

+

+ testling = ChatMessageParser(emoticons_, ruleListFromKeywords(ruleFromKeyword("one", false, false), ruleFromKeyword("three", false, false)));

+ result = testling.parseMessageBody("zero one two three");

+ assertText(result, 0, "zero ");

+ assertHighlight(result, 1, "one", highlightRuleList->getRule(0).getAction());

+ assertText(result, 2, " two ");

+ assertHighlight(result, 3, "three", highlightRuleList->getRule(0).getAction());

+

+ testling = ChatMessageParser(emoticons_, ruleListFromKeywords(ruleFromKeyword("one", false, false), ruleFromKeyword("three", false, false)));

+ result = testling.parseMessageBody("zero oNe two tHrEe");

+ assertText(result, 0, "zero ");

+ assertHighlight(result, 1, "oNe", highlightRuleList->getRule(0).getAction());

+ assertText(result, 2, " two ");

+ assertHighlight(result, 3, "tHrEe", highlightRuleList->getRule(0).getAction());

+

+ testling = ChatMessageParser(emoticons_, ruleListFromKeywords(ruleFromKeyword("one", false, false), ruleFromKeyword("three", true, false)));

+ result = testling.parseMessageBody("zero oNe two tHrEe");

+ assertText(result, 0, "zero ");

+ assertHighlight(result, 1, "oNe", highlightRuleList->getRule(0).getAction());

+ assertText(result, 2, " two tHrEe");

+

+ testling = ChatMessageParser(emoticons_, ruleListFromKeywords(ruleFromKeyword("one", true, false), ruleFromKeyword("three", true, false)));

+ result = testling.parseMessageBody("zero oNe two tHrEe");

+ assertText(result, 0, "zero oNe two tHrEe");

+

+ testling = ChatMessageParser(emoticons_, ruleListFromKeywords(ruleFromKeyword("one", false, false), ruleFromKeyword("three", false, false)));

+ result = testling.parseMessageBody("zeroonetwothree");

+ assertText(result, 0, "zero");

+ assertHighlight(result, 1, "one", highlightRuleList->getRule(0).getAction());

+ assertText(result, 2, "two");

+ assertHighlight(result, 3, "three", highlightRuleList->getRule(0).getAction());

+

+ testling = ChatMessageParser(emoticons_, ruleListFromKeywords(ruleFromKeyword("one", true, false), ruleFromKeyword("three", false, false)));

+ result = testling.parseMessageBody("zeroOnEtwoThReE");

+ assertText(result, 0, "zeroOnEtwo");

+ assertHighlight(result, 1, "ThReE", highlightRuleList->getRule(0).getAction());

+

+ testling = ChatMessageParser(emoticons_, ruleListFromKeywords(ruleFromKeyword("one", false, true), ruleFromKeyword("three", false, false)));

+ result = testling.parseMessageBody("zeroonetwothree");

+ assertText(result, 0, "zeroonetwo");

+ assertHighlight(result, 1, "three", highlightRuleList->getRule(0).getAction());

+

+ testling = ChatMessageParser(emoticons_, ruleListFromKeywords(ruleFromKeyword("one", false, true), ruleFromKeyword("three", false, true)));

+ result = testling.parseMessageBody("zeroonetwothree");

+ assertText(result, 0, "zeroonetwothree");

+

+ testling = ChatMessageParser(emoticons_, ruleListWithNickHighlight());

+ result = testling.parseMessageBody("Alice", "Alice");

+ assertHighlight(result, 0, "Alice", highlightRuleList->getRule(0).getAction());

+

+ testling = ChatMessageParser(emoticons_, ruleListWithNickHighlight());

+ result = testling.parseMessageBody("TextAliceText", "Alice");

+ assertText(result, 0, "TextAliceText");

+

+ testling = ChatMessageParser(emoticons_, ruleListWithNickHighlight());

+ result = testling.parseMessageBody("Text Alice Text", "Alice");

+ assertText(result, 0, "Text ");

+ assertHighlight(result, 1, "Alice", highlightRuleList->getRule(0).getAction());

+ assertText(result, 2, " Text");

+

+ testling = ChatMessageParser(emoticons_, ruleListWithNickHighlight());

+ result = testling.parseMessageBody("Alice Text", "Alice");

+ assertHighlight(result, 0, "Alice", highlightRuleList->getRule(0).getAction());

+ assertText(result, 1, " Text");

+

+ testling = ChatMessageParser(emoticons_, ruleListWithNickHighlight());

+ result = testling.parseMessageBody("Text Alice", "Alice");

+ assertText(result, 0, "Text ");

+ assertHighlight(result, 1, "Alice", highlightRuleList->getRule(0).getAction());

+ }

+

+ void testOneEmoticon() {

+ ChatMessageParser testling(emoticons_, boost::make_shared<HighlightManager::HighlightRulesList>());

+ ChatWindow::ChatMessage result = testling.parseMessageBody(" :) ");

+ assertText(result, 0, " ");

+ assertEmoticon(result, 1, smile1_, smile1Path_);

+ assertText(result, 2, " ");

+ }

+

+

+ void testBareEmoticon() {

+ ChatMessageParser testling(emoticons_, boost::make_shared<HighlightManager::HighlightRulesList>());

+ ChatWindow::ChatMessage result = testling.parseMessageBody(":)");

+ assertEmoticon(result, 0, smile1_, smile1Path_);

+ }

+

+ void testHiddenEmoticon() {

+ ChatMessageParser testling(emoticons_, boost::make_shared<HighlightManager::HighlightRulesList>());

+ ChatWindow::ChatMessage result = testling.parseMessageBody("b:)a");

+ assertText(result, 0, "b:)a");

+ }

+

+ void testEndlineEmoticon() {

+ ChatMessageParser testling(emoticons_, boost::make_shared<HighlightManager::HighlightRulesList>());

+ ChatWindow::ChatMessage result = testling.parseMessageBody("Lazy:)");

+ assertText(result, 0, "Lazy");

+ assertEmoticon(result, 1, smile1_, smile1Path_);

+ }

+

+ void testBoundedEmoticons() {

+ ChatMessageParser testling(emoticons_, boost::make_shared<HighlightManager::HighlightRulesList>());

+ ChatWindow::ChatMessage result = testling.parseMessageBody(":)Lazy:(");

+ assertEmoticon(result, 0, smile1_, smile1Path_);

+ assertText(result, 1, "Lazy");

+ assertEmoticon(result, 2, smile2_, smile2Path_);

+ }

+

+ void testEmoticonParenthesis() {

+ ChatMessageParser testling(emoticons_, boost::make_shared<HighlightManager::HighlightRulesList>());

+ ChatWindow::ChatMessage result = testling.parseMessageBody("(Like this :))");

+ assertText(result, 0, "(Like this ");

+ assertEmoticon(result, 1, smile1_, smile1Path_);

+ assertText(result, 2, ")");

+ }

+

+ void testNoColourNoHighlight() {

+ ChatMessageParser testling(emoticons_, ruleListWithNickHighlight(false));

+ ChatWindow::ChatMessage result = testling.parseMessageBody("Alice", "Alice");

+ assertText(result, 0, "Alice");

+ }

+ std::map<std::string, std::string> emoticons_;

+ std::string smile1_;

+ std::string smile1Path_;

+ std::string smile2_;

+ std::string smile2Path_;

+ 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(testChatControllerPMPresenceHandling);

+ CPPUNIT_TEST(testLocalMUCServiceDiscoveryResetOnDisconnect);

+ CPPUNIT_TEST(testChatControllerHighlightingNotificationTesting);

+ CPPUNIT_TEST(testChatControllerHighlightingNotificationDeduplicateSounds);

+ CPPUNIT_TEST_SUITE_END();

+ void setUp() {

+ mocks_ = new MockRepository();

+ jid_ = JID("test@test.com/resource");

+ stanzaChannel_ = new DummyStanzaChannel();

+ iqChannel_ = new DummyIQChannel();

+ iqRouter_ = new IQRouter(iqChannel_);

+// capsProvider_ = new DummyCapsProvider();

+ eventController_ = new EventController();

+ chatWindowFactory_ = mocks_->InterfaceMock<ChatWindowFactory>();

+ joinMUCWindowFactory_ = mocks_->InterfaceMock<JoinMUCWindowFactory>();

+ xmppRoster_ = new XMPPRosterImpl();

+ mucRegistry_ = new MUCRegistry();

+ nickResolver_ = new NickResolver(jid_.toBare(), xmppRoster_, NULL, mucRegistry_);

+ presenceOracle_ = new PresenceOracle(stanzaChannel_, xmppRoster_);

+ serverDiscoInfo_ = boost::make_shared<DiscoInfo>();

+ presenceSender_ = new StanzaChannelPresenceSender(stanzaChannel_);

+ directedPresenceSender_ = new DirectedPresenceSender(presenceSender_);

+ mucManager_ = new MUCManager(stanzaChannel_, iqRouter_, directedPresenceSender_, mucRegistry_);

+ uiEventStream_ = new UIEventStream();

+// entityCapsManager_ = new EntityCapsManager(capsProvider_, stanzaChannel_);

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

+ 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, NULL, mucRegistry_, entityCapsProvider_, mucManager_, mucSearchWindowFactory_, profileSettings_, ftOverview_, xmppRoster_, false, settings_, NULL, wbManager_, highlightManager_, clientBlockListManager_, emoticons_, vcardManager_);

+

+ manager_->setAvatarManager(avatarManager_);

+ }

+

+ void tearDown() {

+ delete highlightManager_;

+ //delete chatListWindowFactory

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

+ delete nickResolver_;

+ delete mucRegistry_;

+ delete stanzaChannel_;

+ delete eventController_;

+ delete iqRouter_;

+ delete iqChannel_;

+ 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);

+

+ boost::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, window->lastMessageBody_);

+ }

+

+ void testSecondOpenWindowIncoming() {

+ JID messageJID1("testling@test.com/resource1");

+

+ MockChatWindow* window1 = new MockChatWindow();//mocks_->InterfaceMock<ChatWindow>();

+ mocks_->ExpectCall(chatWindowFactory_, ChatWindowFactory::createChatWindow).With(messageJID1, uiEventStream_).Return(window1);

+

+ boost::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, window1->lastMessageBody_);

+

+ JID messageJID2("testling@test.com/resource2");

+

+ //MockChatWindow* window2 = new MockChatWindow();//mocks_->InterfaceMock<ChatWindow>();

+ //mocks_->ExpectCall(chatWindowFactory_, ChatWindowFactory::createChatWindow).With(messageJID2, uiEventStream_).Return(window2);

+

+ boost::shared_ptr<Message> message2(new Message());

+ message2->setFrom(messageJID2);

+ std::string body2("This is a legible message. .cmaulm.chul");

+ message2->setBody(body2);

+ manager_->handleIncomingMessage(message2);

+ CPPUNIT_ASSERT_EQUAL(body2, window1->lastMessageBody_);

+ }

+

+ void testFirstOpenWindowOutgoing() {

+ std::string messageJIDString("testling@test.com");

+

+ ChatWindow* window = new MockChatWindow();//mocks_->InterfaceMock<ChatWindow>();

+ mocks_->ExpectCall(chatWindowFactory_, ChatWindowFactory::createChatWindow).With(JID(messageJIDString), uiEventStream_).Return(window);

+

+ uiEventStream_->send(boost::shared_ptr<UIEvent>(new RequestChatUIEvent(JID(messageJIDString))));

+ }

+

+

+ void testFirstOpenWindowBareToFull() {

+ std::string bareJIDString("testling@test.com");

+ std::string fullJIDString("testling@test.com/resource1");

+

+ MockChatWindow* window = new MockChatWindow();//mocks_->InterfaceMock<ChatWindow>();

+ mocks_->ExpectCall(chatWindowFactory_, ChatWindowFactory::createChatWindow).With(JID(bareJIDString), uiEventStream_).Return(window);

+ uiEventStream_->send(boost::shared_ptr<UIEvent>(new RequestChatUIEvent(JID(bareJIDString))));

+

+ boost::shared_ptr<Message> message(new Message());

+ message->setFrom(JID(fullJIDString));

+ std::string body("This is a legible message. mjuga3089gm8G(*>M)@*(");

+ message->setBody(body);

+ manager_->handleIncomingMessage(message);

+ CPPUNIT_ASSERT_EQUAL(body, window->lastMessageBody_);

+ }

+

+ void testSecondWindow() {

+ std::string messageJIDString1("testling1@test.com");

+ ChatWindow* window1 = new MockChatWindow();//mocks_->InterfaceMock<ChatWindow>();

+ mocks_->ExpectCall(chatWindowFactory_, ChatWindowFactory::createChatWindow).With(JID(messageJIDString1), uiEventStream_).Return(window1);

+ uiEventStream_->send(boost::shared_ptr<UIEvent>(new RequestChatUIEvent(JID(messageJIDString1))));

+

+ std::string messageJIDString2("testling2@test.com");

+ ChatWindow* window2 = new MockChatWindow();//mocks_->InterfaceMock<ChatWindow>();

+ mocks_->ExpectCall(chatWindowFactory_, ChatWindowFactory::createChatWindow).With(JID(messageJIDString2), uiEventStream_).Return(window2);

+

+ uiEventStream_->send(boost::shared_ptr<UIEvent>(new RequestChatUIEvent(JID(messageJIDString2))));

+ }

+

+ /** Complete cycle.

+ Create unbound window.

+ Bind it.

+ Unbind it.

+ Rebind it.

+ */

+ void testUnbindRebind() {

+ std::string bareJIDString("testling@test.com");

+ std::string fullJIDString1("testling@test.com/resource1");

+ std::string fullJIDString2("testling@test.com/resource2");

+

+ MockChatWindow* window = new MockChatWindow();//mocks_->InterfaceMock<ChatWindow>();

+ mocks_->ExpectCall(chatWindowFactory_, ChatWindowFactory::createChatWindow).With(JID(bareJIDString), uiEventStream_).Return(window);

+ uiEventStream_->send(boost::shared_ptr<UIEvent>(new RequestChatUIEvent(JID(bareJIDString))));

+

+ boost::shared_ptr<Message> message1(new Message());

+ message1->setFrom(JID(fullJIDString1));

+ std::string messageBody1("This is a legible message.");

+ message1->setBody(messageBody1);

+ manager_->handleIncomingMessage(message1);

+ CPPUNIT_ASSERT_EQUAL(messageBody1, window->lastMessageBody_);

+

+ boost::shared_ptr<Presence> jid1Online(new Presence());

+ jid1Online->setFrom(JID(fullJIDString1));

+ boost::shared_ptr<Presence> jid1Offline(new Presence());

+ jid1Offline->setFrom(JID(fullJIDString1));

+ jid1Offline->setType(Presence::Unavailable);

+ presenceOracle_->onPresenceChange(jid1Offline);

+

+ boost::shared_ptr<Message> message2(new Message());

+ message2->setFrom(JID(fullJIDString2));

+ std::string messageBody2("This is another legible message.");

+ message2->setBody(messageBody2);

+ manager_->handleIncomingMessage(message2);

+ CPPUNIT_ASSERT_EQUAL(messageBody2, window->lastMessageBody_);

+ }

+

+ /**

+ * Test that MUC PMs get opened in the right windows

+ */

+ void testThreeMUCWindows() {

+ JID muc("testling@test.com");

+ ChatWindow* mucWindow = new MockChatWindow();

+ mocks_->ExpectCall(chatWindowFactory_, ChatWindowFactory::createChatWindow).With(muc, uiEventStream_).Return(mucWindow);

+ uiEventStream_->send(boost::make_shared<JoinMUCUIEvent>(muc, std::string("nick")));

+

+

+ std::string messageJIDString1("testling@test.com/1");

+ ChatWindow* window1 = new MockChatWindow();//mocks_->InterfaceMock<ChatWindow>();

+ mocks_->ExpectCall(chatWindowFactory_, ChatWindowFactory::createChatWindow).With(JID(messageJIDString1), uiEventStream_).Return(window1);

+ uiEventStream_->send(boost::shared_ptr<UIEvent>(new RequestChatUIEvent(JID(messageJIDString1))));

+

+ std::string messageJIDString2("testling@test.com/2");

+ ChatWindow* window2 = new MockChatWindow();//mocks_->InterfaceMock<ChatWindow>();

+ mocks_->ExpectCall(chatWindowFactory_, ChatWindowFactory::createChatWindow).With(JID(messageJIDString2), uiEventStream_).Return(window2);

+

+ uiEventStream_->send(boost::shared_ptr<UIEvent>(new RequestChatUIEvent(JID(messageJIDString2))));

+

+ std::string messageJIDString3("testling@test.com/3");

+ ChatWindow* window3 = new MockChatWindow();//mocks_->InterfaceMock<ChatWindow>();

+ mocks_->ExpectCall(chatWindowFactory_, ChatWindowFactory::createChatWindow).With(JID(messageJIDString3), uiEventStream_).Return(window3);

+

+ uiEventStream_->send(boost::shared_ptr<UIEvent>(new RequestChatUIEvent(JID(messageJIDString3))));

+

+ /* Refetch an earlier window */

+ /* We do not expect a new window to be created */

+ uiEventStream_->send(boost::shared_ptr<UIEvent>(new RequestChatUIEvent(JID(messageJIDString1))));

+

+ }

+

+ /**

+ Test that a second window isn't unbound where there's already an unbound one.

+ Bind 1

+ Bind 2

+ Unbind 1

+ Unbind 2 (but it doesn't)

+ Sent to bound 2

+ Rebind 1

+ */

+ void testNoDuplicateUnbind() {

+ JID messageJID1("testling@test.com/resource1");

+

+ MockChatWindow* window1 = new MockChatWindow();//mocks_->InterfaceMock<ChatWindow>();

+ mocks_->ExpectCall(chatWindowFactory_, ChatWindowFactory::createChatWindow).With(messageJID1, uiEventStream_).Return(window1);

+

+ boost::shared_ptr<Message> message1(new Message());

+ message1->setFrom(messageJID1);

+ message1->setBody("This is a legible message1.");

+ manager_->handleIncomingMessage(message1);

+

+ JID messageJID2("testling@test.com/resource2");

+

+ //MockChatWindow* window2 = new MockChatWindow();//mocks_->InterfaceMock<ChatWindow>();

+ //mocks_->ExpectCall(chatWindowFactory_, ChatWindowFactory::createChatWindow).With(messageJID2, uiEventStream_).Return(window2);

+

+ boost::shared_ptr<Message> message2(new Message());

+ message2->setFrom(messageJID2);

+ message2->setBody("This is a legible message2.");

+ manager_->handleIncomingMessage(message2);

+

+ boost::shared_ptr<Presence> jid1Online(new Presence());

+ jid1Online->setFrom(JID(messageJID1));

+ boost::shared_ptr<Presence> jid1Offline(new Presence());

+ jid1Offline->setFrom(JID(messageJID1));

+ jid1Offline->setType(Presence::Unavailable);

+ presenceOracle_->onPresenceChange(jid1Offline);

+

+ boost::shared_ptr<Presence> jid2Online(new Presence());

+ jid2Online->setFrom(JID(messageJID2));

+ boost::shared_ptr<Presence> jid2Offline(new Presence());

+ jid2Offline->setFrom(JID(messageJID2));

+ jid2Offline->setType(Presence::Unavailable);

+ presenceOracle_->onPresenceChange(jid2Offline);

+

+ JID messageJID3("testling@test.com/resource3");

+

+ boost::shared_ptr<Message> message3(new Message());

+ message3->setFrom(messageJID3);

+ std::string body3("This is a legible message3.");

+ message3->setBody(body3);

+ manager_->handleIncomingMessage(message3);

+ CPPUNIT_ASSERT_EQUAL(body3, window1->lastMessageBody_);

+

+ boost::shared_ptr<Message> message2b(new Message());

+ message2b->setFrom(messageJID2);

+ std::string body2b("This is a legible message2b.");

+ message2b->setBody(body2b);

+ manager_->handleIncomingMessage(message2b);

+ CPPUNIT_ASSERT_EQUAL(body2b, window1->lastMessageBody_);

+ }

+

+ /**

+ * Test that ChatController doesn't send receipts anymore after removal of the contact from the roster.

+ */

+ void testChatControllerPresenceAccessUpdatedOnRemoveFromRoster() {

+ JID messageJID("testling@test.com/resource1");

+ xmppRoster_->addContact(messageJID, "foo", std::vector<std::string>(), RosterItemPayload::Both);

+

+ MockChatWindow* window = new MockChatWindow();//mocks_->InterfaceMock<ChatWindow>();

+ mocks_->ExpectCall(chatWindowFactory_, ChatWindowFactory::createChatWindow).With(messageJID, uiEventStream_).Return(window);

+ settings_->storeSetting(SettingConstants::REQUEST_DELIVERYRECEIPTS, true);

+

+ boost::shared_ptr<Message> message = makeDeliveryReceiptTestMessage(messageJID, "1");

+ manager_->handleIncomingMessage(message);

+ Stanza::ref stanzaContactOnRoster = stanzaChannel_->getStanzaAtIndex<Stanza>(0);

+ CPPUNIT_ASSERT_EQUAL(st(1), stanzaChannel_->sentStanzas.size());

+ CPPUNIT_ASSERT(stanzaContactOnRoster->getPayload<DeliveryReceipt>() != 0);

+

+ xmppRoster_->removeContact(messageJID);

+

+ message->setID("2");

+ manager_->handleIncomingMessage(message);

+ CPPUNIT_ASSERT_EQUAL(st(1), stanzaChannel_->sentStanzas.size());

+ }

+

+ /**

+ * Test that ChatController sends receipts after the contact has been added to the roster.

+ */

+ void testChatControllerPresenceAccessUpdatedOnAddToRoster() {

+ JID messageJID("testling@test.com/resource1");

+

+ MockChatWindow* window = new MockChatWindow();//mocks_->InterfaceMock<ChatWindow>();

+ mocks_->ExpectCall(chatWindowFactory_, ChatWindowFactory::createChatWindow).With(messageJID, uiEventStream_).Return(window);

+ settings_->storeSetting(SettingConstants::REQUEST_DELIVERYRECEIPTS, true);

+

+ boost::shared_ptr<Message> message = makeDeliveryReceiptTestMessage(messageJID, "1");

+ manager_->handleIncomingMessage(message);

+

+ CPPUNIT_ASSERT_EQUAL(st(0), stanzaChannel_->sentStanzas.size());

+

+ xmppRoster_->addContact(messageJID, "foo", std::vector<std::string>(), RosterItemPayload::Both);

+ message->setID("2");

+ manager_->handleIncomingMessage(message);

+

+ CPPUNIT_ASSERT_EQUAL(st(1), stanzaChannel_->sentStanzas.size());

+ Stanza::ref stanzaContactOnRoster = stanzaChannel_->getStanzaAtIndex<Stanza>(0);

+ CPPUNIT_ASSERT(stanzaContactOnRoster->getPayload<DeliveryReceipt>() != 0);

+ }

+

+ /**

+ * Test that ChatController sends receipts if requested after change from subscription state To to subscription state Both.

+ */

+ void testChatControllerPresenceAccessUpdatedOnSubscriptionChangeToBoth() {

+ testhelperChatControllerPresenceAccessUpdatedOnSubscriptionChangeReceiptsAllowed(RosterItemPayload::To, RosterItemPayload::Both);

+ }

+

+ /**

+ * Test that ChatController sends receipts if requested after change from subscription state To to subscription state From.

+ */

+ void testChatControllerPresenceAccessUpdatedOnSubscriptionChangeToFrom() {

+ testhelperChatControllerPresenceAccessUpdatedOnSubscriptionChangeReceiptsAllowed(RosterItemPayload::To, RosterItemPayload::From);

+ }

+

+ void testChatControllerFullJIDBindingOnMessageAndNotReceipt() {

+ JID ownJID("test@test.com/resource");

+ JID sender("foo@test.com");

+ std::vector<JID> senderResource;

+ senderResource.push_back(sender.withResource("resourceA"));

+ senderResource.push_back(sender.withResource("resourceB"));

+

+ // We support delivery receipts.

+ settings_->storeSetting(SettingConstants::REQUEST_DELIVERYRECEIPTS, true);

+

+ // Open chat window to a sender.

+ MockChatWindow* window = new MockChatWindow();

+ mocks_->ExpectCall(chatWindowFactory_, ChatWindowFactory::createChatWindow).With(sender, uiEventStream_).Return(window);

+

+ uiEventStream_->send(boost::make_shared<RequestChatUIEvent>(sender));

+

+ foreach(const JID& senderJID, senderResource) {

+ // The sender supports delivery receipts.

+ DiscoInfo::ref disco = boost::make_shared<DiscoInfo>();

+ disco->addFeature(DiscoInfo::MessageDeliveryReceiptsFeature);

+ entityCapsProvider_->caps[senderJID] = disco;

+

+ // The sender is online.

+ Presence::ref senderPresence = boost::make_shared<Presence>();

+ senderPresence->setFrom(senderJID);

+ senderPresence->setTo(ownJID);

+ stanzaChannel_->onPresenceReceived(senderPresence);

+

+ entityCapsProvider_->onCapsChanged(senderJID);

+ }

+

+ // Send first message.

+ window->onSendMessageRequest("hello there", false);

+

+ // A bare message is send because no resources is bound.

+ CPPUNIT_ASSERT_EQUAL(sender, stanzaChannel_->getStanzaAtIndex<Message>(0)->getTo());

+ CPPUNIT_ASSERT(stanzaChannel_->getStanzaAtIndex<Message>(0)->getPayload<DeliveryReceiptRequest>());

+

+ // Two resources respond with message receipts.

+ foreach(const JID& senderJID, senderResource) {

+ Message::ref receiptReply = boost::make_shared<Message>();

+ receiptReply->setFrom(senderJID);

+ receiptReply->setTo(ownJID);

+

+ boost::shared_ptr<DeliveryReceipt> receipt = boost::make_shared<DeliveryReceipt>();

+ receipt->setReceivedID(stanzaChannel_->getStanzaAtIndex<Message>(0)->getID());

+ receiptReply->addPayload(receipt);

+ manager_->handleIncomingMessage(receiptReply);

+ }

+

+ // Send second message.

+ window->onSendMessageRequest("how are you?", false);

+

+ // A bare message is send because no resources is bound.

+ CPPUNIT_ASSERT_EQUAL(sender, stanzaChannel_->getStanzaAtIndex<Message>(1)->getTo());

+ CPPUNIT_ASSERT(stanzaChannel_->getStanzaAtIndex<Message>(1)->getPayload<DeliveryReceiptRequest>());

+

+ // Two resources respond with message receipts.

+ foreach(const JID& senderJID, senderResource) {

+ Message::ref receiptReply = boost::make_shared<Message>();

+ receiptReply->setFrom(senderJID);

+ receiptReply->setTo(ownJID);

+

+ boost::shared_ptr<DeliveryReceipt> receipt = boost::make_shared<DeliveryReceipt>();

+ receipt->setReceivedID(stanzaChannel_->getStanzaAtIndex<Message>(1)->getID());

+ receiptReply->addPayload(receipt);

+ manager_->handleIncomingMessage(receiptReply);

+ }

+

+ // Reply with a message including a body text.

+ Message::ref reply = boost::make_shared<Message>();

+ reply->setFrom(senderResource[0]);

+ reply->setTo(ownJID);

+ reply->setBody("fine.");

+ manager_->handleIncomingMessage(reply);

+

+ // Send third message.

+ window->onSendMessageRequest("great to hear.", false);

+

+ // The chat session is bound to the full JID of the first resource.

+ CPPUNIT_ASSERT_EQUAL(senderResource[0], stanzaChannel_->getStanzaAtIndex<Message>(2)->getTo());

+ CPPUNIT_ASSERT(stanzaChannel_->getStanzaAtIndex<Message>(2)->getPayload<DeliveryReceiptRequest>());

+

+ // Receive random receipt from second sender resource.

+ reply = boost::make_shared<Message>();

+ reply->setFrom(senderResource[1]);

+ reply->setTo(ownJID);

+

+ boost::shared_ptr<DeliveryReceipt> receipt = boost::make_shared<DeliveryReceipt>();

+ receipt->setReceivedID(stanzaChannel_->getStanzaAtIndex<Message>(2)->getID());

+ reply->addPayload(receipt);

+ manager_->handleIncomingMessage(reply);

+

+ // Send forth message.

+ window->onSendMessageRequest("what else is new?", false);

+

+ // The chat session is bound to the full JID of the first resource.

+ CPPUNIT_ASSERT_EQUAL(senderResource[0], stanzaChannel_->getStanzaAtIndex<Message>(3)->getTo());

+ CPPUNIT_ASSERT(stanzaChannel_->getStanzaAtIndex<Message>(3)->getPayload<DeliveryReceiptRequest>());

+

+ // Reply with a message including a body text from second resource.

+ reply = boost::make_shared<Message>();

+ reply->setFrom(senderResource[1]);

+ reply->setTo(ownJID);

+ reply->setBody("nothing.");

+ manager_->handleIncomingMessage(reply);

+

+ // Send fifth message.

+ window->onSendMessageRequest("okay", false);

+

+ // The chat session is now bound to the full JID of the second resource.

+ CPPUNIT_ASSERT_EQUAL(senderResource[1], stanzaChannel_->getStanzaAtIndex<Message>(4)->getTo());

+ CPPUNIT_ASSERT(stanzaChannel_->getStanzaAtIndex<Message>(4)->getPayload<DeliveryReceiptRequest>());

+ }

+

+ void testChatControllerFullJIDBindingOnTypingAndNotActive() {

+ JID ownJID("test@test.com/resource");

+ JID sender("foo@test.com");

+ std::vector<JID> senderResource;

+ senderResource.push_back(sender.withResource("resourceA"));

+ senderResource.push_back(sender.withResource("resourceB"));

+

+ // We support delivery receipts.

+ settings_->storeSetting(SettingConstants::REQUEST_DELIVERYRECEIPTS, true);

+

+ // Open chat window to a sender.

+ MockChatWindow* window = new MockChatWindow();

+ mocks_->ExpectCall(chatWindowFactory_, ChatWindowFactory::createChatWindow).With(sender, uiEventStream_).Return(window);

+

+ uiEventStream_->send(boost::make_shared<RequestChatUIEvent>(sender));

+

+ foreach(const JID& senderJID, senderResource) {

+ // The sender supports delivery receipts.

+ DiscoInfo::ref disco = boost::make_shared<DiscoInfo>();

+ disco->addFeature(DiscoInfo::MessageDeliveryReceiptsFeature);

+ entityCapsProvider_->caps[senderJID] = disco;

+

+ // The sender is online.

+ Presence::ref senderPresence = boost::make_shared<Presence>();

+ senderPresence->setFrom(senderJID);

+ senderPresence->setTo(ownJID);

+ stanzaChannel_->onPresenceReceived(senderPresence);

+

+ entityCapsProvider_->onCapsChanged(senderJID);

+ }

+

+ // Send first message.

+ window->onSendMessageRequest("hello there", false);

+

+ // A bare message is send because no resources is bound.

+ CPPUNIT_ASSERT_EQUAL(sender, stanzaChannel_->getStanzaAtIndex<Message>(0)->getTo());

+ CPPUNIT_ASSERT(stanzaChannel_->getStanzaAtIndex<Message>(0)->getPayload<DeliveryReceiptRequest>());

+

+ // Two resources respond with message receipts.

+ foreach(const JID& senderJID, senderResource) {

+ Message::ref reply = boost::make_shared<Message>();

+ reply->setFrom(senderJID);

+ reply->setTo(ownJID);

+

+ boost::shared_ptr<ChatState> csn = boost::make_shared<ChatState>();

+ csn->setChatState(ChatState::Active);

+ reply->addPayload(csn);

+ manager_->handleIncomingMessage(reply);

+ }

+

+ // Send second message.

+ window->onSendMessageRequest("how are you?", false);

+

+ // A bare message is send because no resources is bound.

+ CPPUNIT_ASSERT_EQUAL(sender, stanzaChannel_->getStanzaAtIndex<Message>(1)->getTo());

+ CPPUNIT_ASSERT(stanzaChannel_->getStanzaAtIndex<Message>(1)->getPayload<DeliveryReceiptRequest>());

+

+ // Two resources respond with message receipts.

+ foreach(const JID& senderJID, senderResource) {

+ Message::ref receiptReply = boost::make_shared<Message>();

+ receiptReply->setFrom(senderJID);

+ receiptReply->setTo(ownJID);

+

+ boost::shared_ptr<DeliveryReceipt> receipt = boost::make_shared<DeliveryReceipt>();

+ receipt->setReceivedID(stanzaChannel_->getStanzaAtIndex<Message>(1)->getID());

+ receiptReply->addPayload(receipt);

+ manager_->handleIncomingMessage(receiptReply);

+ }

+

+ // Reply with a message including a CSN.

+ Message::ref reply = boost::make_shared<Message>();

+ reply->setFrom(senderResource[0]);

+ reply->setTo(ownJID);

+

+ boost::shared_ptr<ChatState> csn = boost::make_shared<ChatState>();

+ csn->setChatState(ChatState::Composing);

+ reply->addPayload(csn);

+ manager_->handleIncomingMessage(reply);

+

+ // Send third message.

+ window->onSendMessageRequest("great to hear.", false);

+

+ // The chat session is now bound to the full JID of the first resource due to its recent composing message.

+ CPPUNIT_ASSERT_EQUAL(senderResource[0], stanzaChannel_->getStanzaAtIndex<Message>(2)->getTo());

+ CPPUNIT_ASSERT(stanzaChannel_->getStanzaAtIndex<Message>(2)->getPayload<DeliveryReceiptRequest>());

+

+ // Reply with a message including a CSN from the other resource.

+ reply = boost::make_shared<Message>();

+ reply->setFrom(senderResource[1]);

+ reply->setTo(ownJID);

+

+ csn = boost::make_shared<ChatState>();

+ csn->setChatState(ChatState::Composing);

+ reply->addPayload(csn);

+ manager_->handleIncomingMessage(reply);

+

+ // Send third message.

+ window->onSendMessageRequest("ping.", false);

+

+ // The chat session is now bound to the full JID of the second resource due to its recent composing message.

+ CPPUNIT_ASSERT_EQUAL(senderResource[1], stanzaChannel_->getStanzaAtIndex<Message>(3)->getTo());

+ CPPUNIT_ASSERT(stanzaChannel_->getStanzaAtIndex<Message>(3)->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(boost::shared_ptr<UIEvent>(new 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_));

+ }

+

+ void testLocalMUCServiceDiscoveryResetOnDisconnect() {

+ JID ownJID("test@test.com/resource");

+ JID sender("foo@test.com");

+

+ manager_->setOnline(true);

+

+ // Open chat window to a sender.

+ MockChatWindow* window = new MockChatWindow();

+ mocks_->ExpectCall(chatWindowFactory_, ChatWindowFactory::createChatWindow).With(sender, uiEventStream_).Return(window);

+

+ uiEventStream_->send(boost::make_shared<RequestChatUIEvent>(sender));

+

+ CPPUNIT_ASSERT_EQUAL(false, window->impromptuMUCSupported_);

+

+ boost::shared_ptr<IQ> infoRequest= iqChannel_->iqs_[1];

+ boost::shared_ptr<IQ> infoResponse = IQ::createResult(infoRequest->getFrom(), infoRequest->getTo(), infoRequest->getID());

+

+ DiscoInfo info;

+ info.addIdentity(DiscoInfo::Identity("Shakespearean Chat Service", "conference", "text"));

+ info.addFeature("http://jabber.org/protocol/muc");

+ infoResponse->addPayload(boost::make_shared<DiscoInfo>(info));

+ iqChannel_->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);

+

+ boost::shared_ptr<Message> message = makeDeliveryReceiptTestMessage(messageJID, "1");

+ manager_->handleIncomingMessage(message);

+

+ CPPUNIT_ASSERT_EQUAL(st(0), stanzaChannel_->sentStanzas.size());

+

+ xmppRoster_->addContact(messageJID, "foo", std::vector<std::string>(), to);

+ message->setID("2");

+ manager_->handleIncomingMessage(message);

+

+ CPPUNIT_ASSERT_EQUAL(st(1), stanzaChannel_->sentStanzas.size());

+ Stanza::ref stanzaContactOnRoster = stanzaChannel_->getStanzaAtIndex<Stanza>(0);

+ CPPUNIT_ASSERT(stanzaContactOnRoster->getPayload<DeliveryReceipt>() != 0);

+ }

+

+ 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);

+

+ JID messageJID = JID("testling@test.com");

+

+ MockChatWindow* window = new MockChatWindow();

+ mocks_->ExpectCall(chatWindowFactory_, ChatWindowFactory::createChatWindow).With(messageJID, uiEventStream_).Return(window);

+

+ boost::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());

+ }

+

+ 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);

+

+ JID messageJID = JID("testling@test.com");

+

+ MockChatWindow* window = new MockChatWindow();

+ mocks_->ExpectCall(chatWindowFactory_, ChatWindowFactory::createChatWindow).With(messageJID, uiEventStream_).Return(window);

+

+ boost::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());

+ }

+ boost::shared_ptr<Message> makeDeliveryReceiptTestMessage(const JID& from, const std::string& id) {

+ boost::shared_ptr<Message> message = boost::make_shared<Message>();

+ message->setFrom(from);

+ message->setID(id);

+ message->setBody("This will cause the window to open");

+ message->addPayload(boost::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());

+ }

+ }

+ JID jid_;

+ ChatsManager* manager_;

+ DummyStanzaChannel* stanzaChannel_;

+ DummyIQChannel* iqChannel_;

+ IQRouter* iqRouter_;

+ EventController* eventController_;

+ ChatWindowFactory* chatWindowFactory_;

+ JoinMUCWindowFactory* joinMUCWindowFactory_;

+ NickResolver* nickResolver_;

+ PresenceOracle* presenceOracle_;

+ AvatarManager* avatarManager_;

+ boost::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_;

+ FileTransferManager* ftManager_;

+ WhiteboardSessionManager* wbSessionManager_;

+ WhiteboardManager* wbManager_;

+ HighlightManager* highlightManager_;

+ ClientBlockListManager* clientBlockListManager_;

+ VCardManager* vcardManager_;

+ CryptoProvider* crypto_;

+ VCardStorage* vcardStorage_;

+ std::map<std::string, std::string> emoticons_;

+ int handledHighlightActions_;

+ std::set<std::string> soundsPlayed_;

+ 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_SUITE_END();

+ void setUp() {

+ crypto_ = boost::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 = NULL;

+ window_ = new MockChatWindow();

+ mucRegistry_ = new MUCRegistry();

+ entityCapsProvider_ = new DummyEntityCapsProvider();

+ settings_ = new DummySettingsProvider();

+ highlightManager_ = new HighlightManager(settings_);

+ muc_ = boost::make_shared<MockMUC>(mucJID_);

+ mocks_->ExpectCall(chatWindowFactory_, ChatWindowFactory::createChatWindow).With(muc_->getJID(), uiEventStream_).Return(window_);

+ chatMessageParser_ = boost::make_shared<ChatMessageParser>(std::map<std::string, std::string>(), highlightManager_->getRules(), true);

+ vcardStorage_ = new VCardMemoryStorage(crypto_.get());

+ vcardManager_ = new VCardManager(self_, iqRouter_, vcardStorage_);

+ clientBlockListManager_ = new ClientBlockListManager(iqRouter_);

+ mucBookmarkManager_ = new MUCBookmarkManager(iqRouter_);

+ controller_ = new MUCController (self_, muc_, boost::optional<std::string>(), nick_, stanzaChannel_, iqRouter_, chatWindowFactory_, presenceOracle_, avatarManager_, uiEventStream_, false, timerFactory, eventController_, entityCapsProvider_, NULL, NULL, mucRegistry_, highlightManager_, clientBlockListManager_, chatMessageParser_, false, NULL, vcardManager_, mucBookmarkManager_);

+ }

+

+ void tearDown() {

+ delete controller_;

+ delete mucBookmarkManager_;

+ delete clientBlockListManager_;

+ 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 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());

+

+ message = Message::ref(new Message());

+ message->setFrom(JID(muc_->getJID().toString() + "/other3"));

+ message->setBody("Hi bert.");

+ message->setType(Message::Groupchat);

+ controller_->handleIncomingMessage(MessageEvent::ref(new MessageEvent(message)));

+ CPPUNIT_ASSERT_EQUAL((size_t)4, eventController_->getEvents().size());

+

+ message = Message::ref(new Message());

+ message->setFrom(JID(muc_->getJID().toString() + "/other2"));

+ message->setBody("Hi " + boost::to_lower_copy(nick_) + "ie.");

+ message->setType(Message::Groupchat);

+ controller_->handleIncomingMessage(MessageEvent::ref(new MessageEvent(message)));

+ CPPUNIT_ASSERT_EQUAL((size_t)4, eventController_->getEvents().size());

+ }

+

+ void testNotAddressedToSelf() {

+ finishJoin();

+ Message::ref message(new Message());

+ message->setFrom(JID(muc_->getJID().toString() + "/other3"));

+ message->setBody("Hi there Hatter");

+ message->setType(Message::Groupchat);

+ controller_->handleIncomingMessage(MessageEvent::ref(new MessageEvent(message)));

+ CPPUNIT_ASSERT_EQUAL((size_t)0, eventController_->getEvents().size());

+ }

+

+ void testAddressedToSelfBySelf() {

+ finishJoin();

+ Message::ref message(new Message());

+ message->setFrom(JID(muc_->getJID().toString() + "/" + nick_));

+ message->setBody("Hi there " + nick_);

+ message->setType(Message::Groupchat);

+ controller_->handleIncomingMessage(MessageEvent::ref(new MessageEvent(message)));

+ CPPUNIT_ASSERT_EQUAL((size_t)0, eventController_->getEvents().size());

+ }

+

+ void testMessageWithEmptyLabelItem() {

+ SecurityLabelsCatalog::Item label;

+ label.setSelector("Bob");

+ window_->label_ = label;

+ boost::shared_ptr<DiscoInfo> features = boost::make_shared<DiscoInfo>();

+ features->addFeature(DiscoInfo::SecurityLabelsCatalogFeature);

+ controller_->setAvailableServerFeatures(features);

+ IQ::ref iq = iqChannel_->iqs_[iqChannel_->iqs_.size() - 1];

+ SecurityLabelsCatalog::ref labelPayload = boost::make_shared<SecurityLabelsCatalog>();

+ labelPayload->addItem(label);

+ IQ::ref result = IQ::createResult(self_, iq->getID(), labelPayload);

+ iqChannel_->onIQReceived(result);

+ std::string messageBody("agamemnon");

+ window_->onSendMessageRequest(messageBody, false);

+ boost::shared_ptr<Stanza> rawStanza = stanzaChannel_->sentStanzas[stanzaChannel_->sentStanzas.size() - 1];

+ Message::ref message = boost::dynamic_pointer_cast<Message>(rawStanza);

+ CPPUNIT_ASSERT_EQUAL(iq->getTo(), result->getFrom());

+ CPPUNIT_ASSERT(window_->labelsEnabled_);

+ CPPUNIT_ASSERT(stanzaChannel_->isAvailable()); /* Otherwise will prevent sends. */

+ CPPUNIT_ASSERT(message);

+ CPPUNIT_ASSERT_EQUAL(messageBody, message->getBody().get());

+ CPPUNIT_ASSERT(!message->getPayload<SecurityLabel>());

+ }

+

+ void testMessageWithLabelItem() {

+ boost::shared_ptr<SecurityLabel> label = boost::make_shared<SecurityLabel>();

+ label->setLabel("a");

+ SecurityLabelsCatalog::Item labelItem;

+ labelItem.setSelector("Bob");

+ labelItem.setLabel(label);

+ window_->label_ = labelItem;

+ boost::shared_ptr<DiscoInfo> features = boost::make_shared<DiscoInfo>();

+ features->addFeature(DiscoInfo::SecurityLabelsCatalogFeature);

+ controller_->setAvailableServerFeatures(features);

+ IQ::ref iq = iqChannel_->iqs_[iqChannel_->iqs_.size() - 1];

+ SecurityLabelsCatalog::ref labelPayload = boost::make_shared<SecurityLabelsCatalog>();

+ labelPayload->addItem(labelItem);

+ IQ::ref result = IQ::createResult(self_, iq->getID(), labelPayload);

+ iqChannel_->onIQReceived(result);

+ std::string messageBody("agamemnon");

+ window_->onSendMessageRequest(messageBody, false);

+ boost::shared_ptr<Stanza> rawStanza = stanzaChannel_->sentStanzas[stanzaChannel_->sentStanzas.size() - 1];

+ Message::ref message = boost::dynamic_pointer_cast<Message>(rawStanza);

+ CPPUNIT_ASSERT_EQUAL(iq->getTo(), result->getFrom());

+ CPPUNIT_ASSERT(window_->labelsEnabled_);

+ CPPUNIT_ASSERT(stanzaChannel_->isAvailable()); /* Otherwise will prevent sends. */

+ CPPUNIT_ASSERT(message);

+ CPPUNIT_ASSERT_EQUAL(messageBody, message->getBody().get());

+ CPPUNIT_ASSERT_EQUAL(label, message->getPayload<SecurityLabel>());

+ }

+

+ void testCorrectMessageWithLabelItem() {

+ boost::shared_ptr<SecurityLabel> label = boost::make_shared<SecurityLabel>();

+ label->setLabel("a");

+ SecurityLabelsCatalog::Item labelItem;

+ labelItem.setSelector("Bob");

+ labelItem.setLabel(label);

+ boost::shared_ptr<SecurityLabel> label2 = boost::make_shared<SecurityLabel>();

+ label->setLabel("b");

+ SecurityLabelsCatalog::Item labelItem2;

+ labelItem2.setSelector("Charlie");

+ labelItem2.setLabel(label2);

+ window_->label_ = labelItem;

+ boost::shared_ptr<DiscoInfo> features = boost::make_shared<DiscoInfo>();

+ features->addFeature(DiscoInfo::SecurityLabelsCatalogFeature);

+ controller_->setAvailableServerFeatures(features);

+ IQ::ref iq = iqChannel_->iqs_[iqChannel_->iqs_.size() - 1];

+ SecurityLabelsCatalog::ref labelPayload = boost::make_shared<SecurityLabelsCatalog>();

+ labelPayload->addItem(labelItem);

+ IQ::ref result = IQ::createResult(self_, iq->getID(), labelPayload);

+ iqChannel_->onIQReceived(result);

+ std::string messageBody("agamemnon");

+ window_->onSendMessageRequest(messageBody, false);

+ boost::shared_ptr<Stanza> rawStanza = stanzaChannel_->sentStanzas[stanzaChannel_->sentStanzas.size() - 1];

+ Message::ref message = boost::dynamic_pointer_cast<Message>(rawStanza);

+ CPPUNIT_ASSERT_EQUAL(iq->getTo(), result->getFrom());

+ CPPUNIT_ASSERT(window_->labelsEnabled_);

+ CPPUNIT_ASSERT(stanzaChannel_->isAvailable()); /* Otherwise will prevent sends. */

+ CPPUNIT_ASSERT(message);

+ CPPUNIT_ASSERT_EQUAL(messageBody, message->getBody().get());

+ CPPUNIT_ASSERT_EQUAL(label, message->getPayload<SecurityLabel>());

+ window_->label_ = labelItem2;

+ window_->onSendMessageRequest(messageBody, true);

+ rawStanza = stanzaChannel_->sentStanzas[stanzaChannel_->sentStanzas.size() - 1];

+ message = boost::dynamic_pointer_cast<Message>(rawStanza);

+ CPPUNIT_ASSERT_EQUAL(messageBody, message->getBody().get());

+ CPPUNIT_ASSERT_EQUAL(label, message->getPayload<SecurityLabel>());

+ }

+

+ void checkEqual(const std::vector<NickJoinPart>& expected, const std::vector<NickJoinPart>& actual) {

+ CPPUNIT_ASSERT_EQUAL(expected.size(), actual.size());

+ for (size_t i = 0; i < expected.size(); i++) {

+ CPPUNIT_ASSERT_EQUAL(expected[i].nick, actual[i].nick);

+ CPPUNIT_ASSERT_EQUAL(expected[i].type, actual[i].type);

+ }

+ }

+

+ void testAppendToJoinParts() {

+ std::vector<NickJoinPart> list;

+ std::vector<NickJoinPart> gold;

+ MUCController::appendToJoinParts(list, NickJoinPart("Kev", Join));

+ gold.push_back(NickJoinPart("Kev", Join));

+ checkEqual(gold, list);

+ MUCController::appendToJoinParts(list, NickJoinPart("Remko", Join));

+ gold.push_back(NickJoinPart("Remko", Join));

+ checkEqual(gold, list);

+ MUCController::appendToJoinParts(list, NickJoinPart("Bert", Join));

+ gold.push_back(NickJoinPart("Bert", Join));

+ checkEqual(gold, list);

+ MUCController::appendToJoinParts(list, NickJoinPart("Bert", Part));

+ gold[2].type = JoinThenPart;

+ checkEqual(gold, list);

+ MUCController::appendToJoinParts(list, NickJoinPart("Kev", Part));

+ gold[0].type = JoinThenPart;

+ checkEqual(gold, list);

+ MUCController::appendToJoinParts(list, NickJoinPart("Remko", Part));

+ gold[1].type = JoinThenPart;

+ checkEqual(gold, list);

+ MUCController::appendToJoinParts(list, NickJoinPart("Ernie", Part));

+ gold.push_back(NickJoinPart("Ernie", Part));

+ checkEqual(gold, list);

+ MUCController::appendToJoinParts(list, NickJoinPart("Ernie", Join));

+ gold[3].type = PartThenJoin;

+ checkEqual(gold, list);

+ MUCController::appendToJoinParts(list, NickJoinPart("Kev", Join));

+ gold[0].type = Join;

+ checkEqual(gold, list);

+ MUCController::appendToJoinParts(list, NickJoinPart("Ernie", Part));

+ gold[3].type = Part;

+ checkEqual(gold, list);

+

+ }

+

+ void testJoinPartStringContructionSimple() {

+ std::vector<NickJoinPart> list;

+ list.push_back(NickJoinPart("Kev", Join));

+ CPPUNIT_ASSERT_EQUAL(std::string("Kev has entered the room"), MUCController::generateJoinPartString(list, false));

+ list.push_back(NickJoinPart("Remko", Part));

+ CPPUNIT_ASSERT_EQUAL(std::string("Kev has entered the room and Remko has left the room"), MUCController::generateJoinPartString(list, false));

+ list.push_back(NickJoinPart("Bert", Join));

+ CPPUNIT_ASSERT_EQUAL(std::string("Kev and Bert have entered the room and Remko has left the room"), MUCController::generateJoinPartString(list, false));

+ list.push_back(NickJoinPart("Ernie", Join));

+ CPPUNIT_ASSERT_EQUAL(std::string("Kev, Bert and Ernie have entered the room and Remko has left the room"), MUCController::generateJoinPartString(list, false));

+ }

+

+ void testJoinPartStringContructionMixed() {

+ std::vector<NickJoinPart> list;

+ list.push_back(NickJoinPart("Kev", JoinThenPart));

+ CPPUNIT_ASSERT_EQUAL(std::string("Kev has entered then left the room"), MUCController::generateJoinPartString(list, false));

+ list.push_back(NickJoinPart("Remko", Part));

+ CPPUNIT_ASSERT_EQUAL(std::string("Remko has left the room and Kev has entered then left the room"), MUCController::generateJoinPartString(list, false));

+ list.push_back(NickJoinPart("Bert", PartThenJoin));

+ CPPUNIT_ASSERT_EQUAL(std::string("Remko has left the room, Kev has entered then left the room and Bert has left then returned to the room"), MUCController::generateJoinPartString(list, false));

+ list.push_back(NickJoinPart("Ernie", JoinThenPart));

+ CPPUNIT_ASSERT_EQUAL(std::string("Remko has left the room, Kev and Ernie have entered then left the room and Bert has left then returned to the room"), MUCController::generateJoinPartString(list, false));

+ }

+

+ JID jidFromOccupant(const MUCOccupant& occupant) {

+ return JID(mucJID_.toString()+"/"+occupant.getNick());

+ }

+

+ void testRoleAffiliationStates() {

+

+ typedef std::map<std::string, MUCOccupant> occupant_map;

+ occupant_map occupants;

+ occupants.insert(occupant_map::value_type("Kev", MUCOccupant("Kev", MUCOccupant::Participant, MUCOccupant::Owner)));

+ occupants.insert(occupant_map::value_type("Remko", MUCOccupant("Remko", MUCOccupant::Participant, MUCOccupant::Owner)));

+ occupants.insert(occupant_map::value_type("Bert", MUCOccupant("Bert", MUCOccupant::Participant, MUCOccupant::Owner)));

+ occupants.insert(occupant_map::value_type("Ernie", MUCOccupant("Ernie", MUCOccupant::Participant, MUCOccupant::Owner)));

+

+ /* populate the MUC with fake users */

+ typedef const std::pair<std::string,MUCOccupant> occupantIterator;

+ foreach(occupantIterator &occupant, occupants) {

+ muc_->insertOccupant(occupant.second);

+ }

+

+ 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));

+

+ foreach(const MUCOccupant& 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);

+ boost::shared_ptr<Stanza> rawStanza = stanzaChannel_->sentStanzas[stanzaChannel_->sentStanzas.size() - 1];

+ Message::ref message = boost::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 = boost::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(boost::make_shared<MessageEvent>(message));

+ CPPUNIT_ASSERT_EQUAL(std::string("The room subject is now: New Room Subject"), boost::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);

+ boost::shared_ptr<Stanza> rawStanza = stanzaChannel_->sentStanzas[stanzaChannel_->sentStanzas.size() - 1];

+ Message::ref message = boost::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 = boost::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(boost::make_shared<MessageEvent>(message));

+ CPPUNIT_ASSERT_EQUAL(std::string("Trying to enter room teaparty@rooms.wonderland.lit"), boost::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);

+ boost::shared_ptr<Stanza> rawStanza = stanzaChannel_->sentStanzas[stanzaChannel_->sentStanzas.size() - 1];

+ Message::ref message = boost::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 = boost::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(boost::make_shared<Thread>("Thread that prevents the subject change."));

+

+ controller_->handleIncomingMessage(boost::make_shared<MessageEvent>(message));

+ CPPUNIT_ASSERT_EQUAL(std::string("Trying to enter room teaparty@rooms.wonderland.lit"), boost::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);

+ boost::shared_ptr<Stanza> rawStanza = stanzaChannel_->sentStanzas[stanzaChannel_->sentStanzas.size() - 1];

+ Message::ref message = boost::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 = boost::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(boost::make_shared<MessageEvent>(message));

+ CPPUNIT_ASSERT_EQUAL(std::string("Trying to enter room teaparty@rooms.wonderland.lit"), boost::dynamic_pointer_cast<ChatWindow::ChatTextMessagePart>(window_->lastAddedSystemMessage_.getParts()[0])->text);

+ }

+ }

+

+ void testRoleAffiliationStatesVerify(const std::map<std::string, MUCOccupant> &occupants) {

+ /* verify that the roster is in sync */

+ GroupRosterItem* group = window_->getRosterModel()->getRoot();

+ foreach(RosterItem* rosterItem, group->getChildren()) {

+ GroupRosterItem* child = dynamic_cast<GroupRosterItem*>(rosterItem);

+ CPPUNIT_ASSERT(child);

+ foreach(RosterItem* 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());

+ }

+ }

+ }

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

+ boost::shared_ptr<ChatMessageParser> chatMessageParser_;

+ boost::shared_ptr<CryptoProvider> crypto_;

+ VCardManager* vcardManager_;

+ VCardMemoryStorage* vcardStorage_;

+ ClientBlockListManager* clientBlockListManager_;

+ MUCBookmarkManager* mucBookmarkManager_;

+ XMPPRoster* xmppRoster_;

+ class MockChatListWindow : public ChatListWindow {

+ public:

+ MockChatListWindow() {}

+ virtual ~MockChatListWindow() {}

+ void addMUCBookmark(const MUCBookmark& /*bookmark*/) {}

+ void removeMUCBookmark(const MUCBookmark& /*bookmark*/) {}

+ void addWhiteboardSession(const ChatListWindow::Chat& /*chat*/) {}

+ void removeWhiteboardSession(const JID& /*jid*/) {}

+ void setBookmarksEnabled(bool /*enabled*/) {}

+ void setRecents(const std::list<ChatListWindow::Chat>& /*recents*/) {}

+ void setUnreadCount(int /*unread*/) {}

+ void clearBookmarks() {}

+ void setOnline(bool /*isOnline*/) {}

+ };