#include <Swift/Controllers/UnitTest/MockChatWindow.h>

#include <Swift/Controllers/WhiteboardManager.h>

#include <Swift/Controllers/XMPPEvents/EventController.h>

using namespace Swift;

class ChatsManagerTest : public CppUnit::TestFixture {

CPPUNIT_TEST_SUITE(ChatsManagerTest);

CPPUNIT_TEST(testFirstOpenWindowIncoming);

CPPUNIT_TEST(testSecondOpenWindowIncoming);

CPPUNIT_TEST(testFirstOpenWindowOutgoing);

CPPUNIT_TEST(testFirstOpenWindowBareToFull);

CPPUNIT_TEST(testSecondWindow);

CPPUNIT_TEST(testUnbindRebind);

CPPUNIT_TEST(testNoDuplicateUnbind);

CPPUNIT_TEST(testThreeMUCWindows);

CPPUNIT_TEST(testChatControllerPresenceAccessUpdatedOnRemoveFromRoster);

CPPUNIT_TEST(testChatControllerPresenceAccessUpdatedOnAddToRoster);

CPPUNIT_TEST(testChatControllerPresenceAccessUpdatedOnSubscriptionChangeToBoth);

CPPUNIT_TEST(testChatControllerPresenceAccessUpdatedOnSubscriptionChangeToFrom);

CPPUNIT_TEST(testChatControllerFullJIDBindingOnMessageAndNotReceipt);

CPPUNIT_TEST(testChatControllerFullJIDBindingOnTypingAndNotActive);

CPPUNIT_TEST(testChatControllerPMPresenceHandling);

CPPUNIT_TEST(testLocalMUCServiceDiscoveryResetOnDisconnect);

CPPUNIT_TEST(testPresenceChangeDoesNotReplaceMUCInvite);

// Highlighting tests

CPPUNIT_TEST(testChatControllerHighlightingNotificationTesting);

CPPUNIT_TEST(testChatControllerHighlightingNotificationDeduplicateSounds);

CPPUNIT_TEST(testChatControllerMeMessageHandling);

CPPUNIT_TEST(testChatControllerMeMessageHandlingInMUC);

// Carbons tests

CPPUNIT_TEST(testCarbonsForwardedIncomingMessageToSecondResource);

CPPUNIT_TEST(testCarbonsForwardedOutgoingMessageFromSecondResource);

CPPUNIT_TEST_SUITE_END();

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

/**

* 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(std::make_shared<RequestChatUIEvent>(sender));

// The sender supports delivery receipts.

DiscoInfo::ref disco = std::make_shared<DiscoInfo>();

disco->addFeature(DiscoInfo::MessageDeliveryReceiptsFeature);

entityCapsProvider_->caps[senderJID] = disco;

// The sender is online.

Presence::ref senderPresence = std::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>(1)->getTo());

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

// Two resources respond with message receipts.

Message::ref receiptReply = std::make_shared<Message>();

receiptReply->setFrom(senderJID);

receiptReply->setTo(ownJID);

std::shared_ptr<DeliveryReceipt> receipt = std::make_shared<DeliveryReceipt>();

receipt->setReceivedID(stanzaChannel_->getStanzaAtIndex<Message>(1)->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.

Message::ref receiptReply = std::make_shared<Message>();

receiptReply->setFrom(senderJID);

receiptReply->setTo(ownJID);

std::shared_ptr<DeliveryReceipt> receipt = std::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 = std::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>(3)->getTo());

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

// Receive random receipt from second sender resource.

reply = std::make_shared<Message>();

reply->setFrom(senderResource[1]);

reply->setTo(ownJID);

std::shared_ptr<DeliveryReceipt> receipt = std::make_shared<DeliveryReceipt>();

reply = std::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>(5)->getTo());

CPPUNIT_ASSERT(stanzaChannel_->getStanzaAtIndex<Message>(5)->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(std::make_shared<RequestChatUIEvent>(sender));

// The sender supports delivery receipts.

DiscoInfo::ref disco = std::make_shared<DiscoInfo>();

disco->addFeature(DiscoInfo::MessageDeliveryReceiptsFeature);

entityCapsProvider_->caps[senderJID] = disco;

// The sender is online.

Presence::ref senderPresence = std::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>(1)->getTo());

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

// Two resources respond with message receipts.

Message::ref reply = std::make_shared<Message>();

reply->setFrom(senderJID);

reply->setTo(ownJID);

std::shared_ptr<ChatState> csn = std::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.

Message::ref receiptReply = std::make_shared<Message>();

receiptReply->setFrom(senderJID);

receiptReply->setTo(ownJID);

std::shared_ptr<DeliveryReceipt> receipt = std::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 = std::make_shared<Message>();

reply->setFrom(senderResource[0]);

reply->setTo(ownJID);

std::shared_ptr<ChatState> csn = std::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>(3)->getTo());

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

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

reply = std::make_shared<Message>();

reply->setFrom(senderResource[1]);

/*

* Copyright (c) 2010-2016 Isode Limited.

* All rights reserved.

* See the COPYING file for more information.

*/

#include <boost/algorithm/string.hpp>

#include <cppunit/extensions/HelperMacros.h>

#include <cppunit/extensions/TestFactoryRegistry.h>

#include <hippomocks.h>

#include <Swiften/Avatars/NullAvatarManager.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/MUCUserPayload.h>

#include <Swiften/Elements/Thread.h>

#include <Swiften/MUC/MUCBookmarkManager.h>

#include <Swiften/MUC/UnitTest/MockMUC.h>

#include <Swiften/Network/TimerFactory.h>

#include <Swiften/Presence/DirectedPresenceSender.h>

#include <Swiften/Presence/PresenceOracle.h>

#include <Swiften/Presence/StanzaChannelPresenceSender.h>

#include <Swiften/Queries/DummyIQChannel.h>

#include <Swiften/Roster/XMPPRoster.h>

#include <Swiften/Roster/XMPPRosterImpl.h>

#include <Swiften/VCards/VCardManager.h>

#include <Swiften/VCards/VCardMemoryStorage.h>

#include <Swift/Controllers/Chat/ChatMessageParser.h>

#include <Swift/Controllers/Chat/MUCController.h>

#include <Swift/Controllers/Chat/UserSearchController.h>

#include <Swift/Controllers/Roster/GroupRosterItem.h>

#include <Swift/Controllers/Roster/Roster.h>

#include <Swift/Controllers/Settings/DummySettingsProvider.h>

#include <Swift/Controllers/UIEvents/UIEventStream.h>

#include <Swift/Controllers/UIInterfaces/ChatWindow.h>

#include <Swift/Controllers/UIInterfaces/ChatWindowFactory.h>

#include <Swift/Controllers/UIInterfaces/UserSearchWindowFactory.h>

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 */

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

/* 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);

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

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

message->setType(Message::Groupchat);

message->setTo(self_);

message->setFrom(mucJID_.withResource("SomeNickname"));

message->setID(iqChannel_->getNewIQID());

/*

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

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

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

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

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

CPPUNIT_ASSERT(child);

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

}

}

}

private:

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