MUC::ref muc,

const boost::optional<std::string>& password,

const std::string &nick,

StanzaChannel* stanzaChannel,

IQRouter* iqRouter,

ChatWindowFactory* chatWindowFactory,

PresenceOracle* presenceOracle,

AvatarManager* avatarManager,

UIEventStream* uiEventStream,

bool useDelayForLatency,

TimerFactory* timerFactory,

EventController* eventController,

EntityCapsProvider* entityCapsProvider,

XMPPRoster* xmppRoster,

HistoryController* historyController,

MUCRegistry* mucRegistry,

HighlightManager* highlightManager,

ClientBlockListManager* clientBlockListManager,

std::shared_ptr<ChatMessageParser> chatMessageParser,

bool isImpromptu,

AutoAcceptMUCInviteDecider* autoAcceptMUCInviteDecider,

VCardManager* vcardManager,

MUCBookmarkManager* mucBookmarkManager) :

ChatControllerBase(self, stanzaChannel, iqRouter, chatWindowFactory, muc->getJID(), presenceOracle, avatarManager, useDelayForLatency, uiEventStream, eventController, timerFactory, entityCapsProvider, historyController, mucRegistry, highlightManager, chatMessageParser, autoAcceptMUCInviteDecider), muc_(muc), nick_(nick), desiredNick_(nick), password_(password), renameCounter_(0), isImpromptu_(isImpromptu), isImpromptuAlreadyConfigured_(false), clientBlockListManager_(clientBlockListManager), mucBookmarkManager_(mucBookmarkManager) {

parting_ = true;

joined_ = false;

lastWasPresence_ = false;

shouldJoinOnReconnect_ = true;

doneGettingHistory_ = false;

xmppRoster_ = xmppRoster;

roster_ = std::unique_ptr<Roster>(new Roster(false, true));

rosterVCardProvider_ = new RosterVCardProvider(roster_.get(), vcardManager, JID::WithResource);

completer_ = new TabComplete();

chatWindow_->setRosterModel(roster_.get());

chatWindow_->setTabComplete(completer_);

chatWindow_->onClosed.connect(boost::bind(&MUCController::handleWindowClosed, this));

chatWindow_->onOccupantSelectionChanged.connect(boost::bind(&MUCController::handleWindowOccupantSelectionChanged, this, _1));

chatWindow_->onOccupantActionSelected.connect(boost::bind(&MUCController::handleActionRequestedOnOccupant, this, _1, _2));

chatWindow_->onChangeSubjectRequest.connect(boost::bind(&MUCController::handleChangeSubjectRequest, this, _1));

chatWindow_->onBookmarkRequest.connect(boost::bind(&MUCController::handleBookmarkRequest, this));

chatWindow_->onConfigureRequest.connect(boost::bind(&MUCController::handleConfigureRequest, this, _1));

chatWindow_->onConfigurationFormCancelled.connect(boost::bind(&MUCController::handleConfigurationCancelled, this));

chatWindow_->onDestroyRequest.connect(boost::bind(&MUCController::handleDestroyRoomRequest, this));

chatWindow_->onInviteToChat.connect(boost::bind(&MUCController::handleInvitePersonToThisMUCRequest, this, _1));

chatWindow_->onGetAffiliationsRequest.connect(boost::bind(&MUCController::handleGetAffiliationsRequest, this));

chatWindow_->onChangeAffiliationsRequest.connect(boost::bind(&MUCController::handleChangeAffiliationsRequest, this, _1));

chatWindow_->onUnblockUserRequest.connect(boost::bind(&MUCController::handleUnblockUserRequest, this));

muc_->onJoinComplete.connect(boost::bind(&MUCController::handleJoinComplete, this, _1));

muc_->onJoinFailed.connect(boost::bind(&MUCController::handleJoinFailed, this, _1));

muc_->onOccupantJoined.connect(boost::bind(&MUCController::handleOccupantJoined, this, _1));

muc_->onOccupantNicknameChanged.connect(boost::bind(&MUCController::handleOccupantNicknameChanged, this, _1, _2));

muc_->onOccupantPresenceChange.connect(boost::bind(&MUCController::handleOccupantPresenceChange, this, _1));

muc_->onOccupantLeft.connect(boost::bind(&MUCController::handleOccupantLeft, this, _1, _2, _3));

muc_->onRoleChangeFailed.connect(boost::bind(&MUCController::handleOccupantRoleChangeFailed, this, _1, _2, _3));

muc_->onAffiliationListReceived.connect(boost::bind(&MUCController::handleAffiliationListReceived, this, _1, _2));

muc_->onConfigurationFailed.connect(boost::bind(&MUCController::handleConfigurationFailed, this, _1));

muc_->onConfigurationFormReceived.connect(boost::bind(&MUCController::handleConfigurationFormReceived, this, _1));

highlighter_->setMode(isImpromptu_ ? Highlighter::ChatMode : Highlighter::MUCMode);

highlighter_->setNick(nick_);

boost::regex myRegexp(stringRegexp);

return boost::regex_match(boost::to_lower_copy(message->getBody().get_value_or("")), myRegexp);

}

void MUCController::preHandleIncomingMessage(std::shared_ptr<MessageEvent> messageEvent) {

if (messageEvent->getStanza()->getType() == Message::Groupchat) {

lastActivity_ = boost::posix_time::microsec_clock::universal_time();

}

clearPresenceQueue();

std::shared_ptr<Message> message = messageEvent->getStanza();

if (joined_ && messageEvent->getStanza()->getFrom().getResource() != nick_ && messageTargetsMe(message) && !message->getPayload<Delay>() && messageEvent->isReadable()) {

chatWindow_->flash();

}

else {

messageEvent->setTargetsMe(false);

}

if (messageEvent->isReadable() && isImpromptu_) {

chatWindow_->flash(); /* behave like a regular char*/

}

if (joined_) {

std::string nick = message->getFrom().getResource();

if (nick != nick_ && currentOccupants_.find(nick) != currentOccupants_.end()) {

completer_->addWord(nick);

}

}

/*Buggy implementations never send the status code, so use an incoming message as a hint that joining's done (e.g. the old ejabberd on psi-im.org).*/

receivedActivity();

joined_ = true;

if (message->hasSubject() && !message->getPayload<Body>() && !message->getPayload<Thread>()) {

chatWindow_->setSubject(message->getSubject());

doneGettingHistory_ = true;

}

if (!doneGettingHistory_ && !message->getPayload<Delay>()) {

doneGettingHistory_ = true;

}

if (!doneGettingHistory_) {

checkDuplicates(message);

messageEvent->conclude();

}

}

void MUCController::addMessageHandleIncomingMessage(const JID& from, const ChatWindow::ChatMessage& message, bool senderIsSelf, std::shared_ptr<SecurityLabel> label, const boost::posix_time::ptime& time) {

if (from.isBare()) {

chatWindow_->addSystemMessage(message, ChatWindow::DefaultDirection);

}

else {

ChatControllerBase::addMessageHandleIncomingMessage(from, message, senderIsSelf, label, time);

}

}

void MUCController::postHandleIncomingMessage(std::shared_ptr<MessageEvent> messageEvent, const ChatWindow::ChatMessage& chatMessage) {

std::shared_ptr<Message> message = messageEvent->getStanza();

if (joined_ && messageEvent->getStanza()->getFrom().getResource() != nick_ && !message->getPayload<Delay>()) {

if (messageTargetsMe(message) || isImpromptu_) {

eventController_->handleIncomingEvent(messageEvent);

}

if (!messageEvent->getConcluded()) {

handleHighlightActions(chatMessage);

}

}

}

void MUCController::handleMUCBookmarkAdded(const MUCBookmark& bookmark) {

if (bookmark.getRoom() == muc_->getJID()) {

updateChatWindowBookmarkStatus(bookmark);

}

}

void MUCController::handleMUCBookmarkRemoved(const MUCBookmark& bookmark) {

if (bookmark.getRoom() == muc_->getJID()) {

updateChatWindowBookmarkStatus(boost::optional<MUCBookmark>());

}

}

void MUCController::updateChatWindowBookmarkStatus(const boost::optional<MUCBookmark>& bookmark) {

assert(chatWindow_);

if (bookmark) {

if (bookmark->getAutojoin()) {

chatWindow_->setBookmarkState(ChatWindow::RoomAutoJoined);

}

else {

chatWindow_->setBookmarkState(ChatWindow::RoomBookmarked);

}

}

else {

chatWindow_->setBookmarkState(ChatWindow::RoomNotBookmarked);

}

}

}

void processUserPart();

virtual void handleBareJIDCapsChanged(const JID& jid) SWIFTEN_OVERRIDE;

void handleConfigureRequest(Form::ref);

void handleConfigurationFailed(ErrorPayload::ref);

void handleConfigurationFormReceived(Form::ref);

void handleDestroyRoomRequest();

void handleInvitePersonToThisMUCRequest(const std::vector<JID>& jidsToInvite);

void handleConfigurationCancelled();

void handleOccupantRoleChangeFailed(ErrorPayload::ref, const JID&, MUCOccupant::Role);

void handleGetAffiliationsRequest();

void handleAffiliationListReceived(MUCOccupant::Affiliation affiliation, const std::vector<JID>& jids);

void handleChangeAffiliationsRequest(const std::vector<std::pair<MUCOccupant::Affiliation, JID> >& changes);

void handleInviteToMUCWindowDismissed();

void handleInviteToMUCWindowCompleted();

void handleUIEvent(std::shared_ptr<UIEvent> event);

void addRecentLogs();

void checkDuplicates(std::shared_ptr<Message> newMessage);

void setNick(const std::string& nick);

void setImpromptuWindowTitle();

void handleRoomUnlocked();

void configureAsImpromptuRoom(Form::ref form);

Form::ref buildImpromptuRoomConfiguration(Form::ref roomConfigurationForm);

void handleUnblockUserRequest();

void handleBlockingStateChanged();

void handleMUCBookmarkAdded(const MUCBookmark& bookmark);

void handleMUCBookmarkRemoved(const MUCBookmark& bookmark);

void updateChatWindowBookmarkStatus(const boost::optional<MUCBookmark>& bookmark);

private:

MUC::ref muc_;

std::string nick_;

std::string desiredNick_;

TabComplete* completer_;

bool parting_;

bool joined_;

bool shouldJoinOnReconnect_;

bool doneGettingHistory_;

boost::signals2::scoped_connection avatarChangedConnection_;

std::shared_ptr<Timer> loginCheckTimer_;

std::set<std::string> currentOccupants_;

std::vector<NickJoinPart> joinParts_;

boost::posix_time::ptime lastActivity_;

boost::optional<std::string> password_;

XMPPRoster* xmppRoster_;

std::unique_ptr<Roster> roster_;

std::vector<HistoryMessage> joinContext_;

size_t renameCounter_;

bool isImpromptu_;

bool isImpromptuAlreadyConfigured_;

RosterVCardProvider* rosterVCardProvider_;

std::string lastJoinMessageUID_;

ClientBlockListManager* clientBlockListManager_;

boost::signals2::scoped_connection blockingOnStateChangedConnection_;

boost::signals2::scoped_connection blockingOnItemAddedConnection_;

boost::signals2::scoped_connection blockingOnItemRemovedConnection_;

boost::optional<ChatWindow::AlertID> blockedContactAlert_;

MUCBookmarkManager* mucBookmarkManager_;

boost::signals2::scoped_connection mucBookmarkManagerBookmarkAddedConnection_;

boost::signals2::scoped_connection mucBookmarkManagerBookmarkRemovedConnection_;

};

}

#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>

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

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

using namespace Swift;

class MUCControllerTest : public CppUnit::TestFixture {

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

CPPUNIT_TEST(testHandleOccupantNicknameChangedRoster);

CPPUNIT_TEST_SUITE_END();

public:

void setUp() {

crypto_ = std::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 = nullptr;

window_ = new MockChatWindow();

mucRegistry_ = new MUCRegistry();

entityCapsProvider_ = new DummyEntityCapsProvider();

settings_ = new DummySettingsProvider();

highlightManager_ = new HighlightManager(settings_);

muc_ = std::make_shared<MockMUC>(mucJID_);

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

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

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

}

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

for (const auto& 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() {

{

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

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

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

{

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("Some body text that prevents this stanza from being a subject change.");

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

}

}

/*

* Test that message stanzas with subject element and thread element do not cause a subject change.

*/

void testSubjectChangeIncorrectB() {

{

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->addPayload(std::make_shared<Thread>("Thread that prevents the subject change."));

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

}

}

/*

* Test that message stanzas with subject element and empty body element do not cause a subject change.

*/

void testSubjectChangeIncorrectC() {

{

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 testHandleOccupantNicknameChanged() {

const auto occupantCount = [&](const std::string & nick) {

auto roster = window_->getRosterModel();

CPPUNIT_ASSERT(roster != nullptr);

const auto currentOccupantsJIDs = roster->getJIDs();

int count = 0;

for (auto & p : currentOccupantsJIDs) {

if (p.getResource() == nick) {

++count;

}

}

return count;

};

muc_->insertOccupant(MUCOccupant("TestUserOne", MUCOccupant::Participant, MUCOccupant::Owner));

muc_->insertOccupant(MUCOccupant("TestUserTwo", MUCOccupant::Participant, MUCOccupant::Owner));

muc_->insertOccupant(MUCOccupant("TestUserThree", MUCOccupant::Participant, MUCOccupant::Owner));

CPPUNIT_ASSERT_EQUAL(1, occupantCount("TestUserOne"));

CPPUNIT_ASSERT_EQUAL(1, occupantCount("TestUserTwo"));

CPPUNIT_ASSERT_EQUAL(1, occupantCount("TestUserThree"));

muc_->onOccupantNicknameChanged("TestUserOne", "TestUserTwo");

CPPUNIT_ASSERT_EQUAL(0, occupantCount("TestUserOne"));

CPPUNIT_ASSERT_EQUAL(1, occupantCount("TestUserTwo"));

CPPUNIT_ASSERT_EQUAL(1, occupantCount("TestUserThree"));

}

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

/* verify that the roster is in sync */

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

for (auto rosterItem : group->getChildren()) {

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

CPPUNIT_ASSERT(child);

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

}

}

}

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

MUCRegistry* mucRegistry_;

DummyEntityCapsProvider* entityCapsProvider_;

DummySettingsProvider* settings_;

HighlightManager* highlightManager_;

std::shared_ptr<ChatMessageParser> chatMessageParser_;

std::shared_ptr<CryptoProvider> crypto_;

VCardManager* vcardManager_;

VCardMemoryStorage* vcardStorage_;

ClientBlockListManager* clientBlockListManager_;

MUCBookmarkManager* mucBookmarkManager_;

/*

* Copyright (c) 2013 Isode Limited.

* All rights reserved.

* See the COPYING file for more information.

*/

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

namespace Swift {

MockMUC::MockMUC(const JID &muc)

: ownMUCJID(muc)

{

}

MockMUC::~MockMUC() {

}

void MockMUC::insertOccupant(const MUCOccupant& occupant)

{

occupants_.insert(std::make_pair(occupant.getNick(), occupant));

onOccupantJoined(occupant);

}

const MUCOccupant& MockMUC::getOccupant(const std::string& nick) {

return occupants_.find(nick)->second;

}

bool MockMUC::hasOccupant(const std::string& nick) {

return occupants_.find(nick) != occupants_.end();

}

void MockMUC::changeAffiliation(const JID &jid, MUCOccupant::Affiliation newAffilation) {

std::map<std::string, MUCOccupant>::iterator i = occupants_.find(jid.getResource());

if (i != occupants_.end()) {

const MUCOccupant old = i->second;

i->second = MUCOccupant(old.getNick(), old.getRole(), newAffilation);

onOccupantAffiliationChanged(i->first, newAffilation, old.getAffiliation());

}

}

void MockMUC::changeOccupantRole(const JID &jid, MUCOccupant::Role newRole) {

std::map<std::string, MUCOccupant>::iterator i = occupants_.find(jid.getResource());

if (i != occupants_.end()) {

const MUCOccupant old = i->second;

i->second = MUCOccupant(old.getNick(), newRole, old.getAffiliation());

onOccupantRoleChanged(i->first, i->second, old.getRole());

}

}

}

/**

* Returns the (bare) JID of the MUC.

*/

virtual JID getJID() const {

return ownMUCJID.toBare();

}

/**

* Returns if the room is unlocked and other people can join the room.

* @return True if joinable by others; false otherwise.

*/

virtual bool isUnlocked() const { return true; }

virtual void joinAs(const std::string&) {}

virtual void joinWithContextSince(const std::string&, const boost::posix_time::ptime&) {}

/*virtual void queryRoomInfo(); */

/*virtual void queryRoomItems(); */

/*virtual std::string getCurrentNick() = 0; */

virtual std::map<std::string, MUCOccupant> getOccupants() const { return occupants_; }

virtual void changeNickname(const std::string&) { }

virtual void part() {}

/*virtual void handleIncomingMessage(Message::ref message) = 0; */

/** Expose public so it can be called when e.g. user goes offline */

virtual void handleUserLeft(LeavingType) {}

/** Get occupant information*/

virtual const MUCOccupant& getOccupant(const std::string&);

virtual bool hasOccupant(const std::string&);

virtual void kickOccupant(const JID&) {}

virtual void changeOccupantRole(const JID&, MUCOccupant::Role);

virtual void requestAffiliationList(MUCOccupant::Affiliation) {}

virtual void changeAffiliation(const JID&, MUCOccupant::Affiliation);

virtual void requestConfigurationForm() {}

virtual void configureRoom(Form::ref) {}

virtual void cancelConfigureRoom() {}

virtual void destroyRoom() {}

/** Send an invite for the person to join the MUC */

virtual void invitePerson(const JID&, const std::string&, bool, bool) {}

virtual void setCreateAsReservedIfNew() {}

virtual void setPassword(const boost::optional<std::string>&) {}

protected:

virtual bool isFromMUC(const JID& j) const {

return ownMUCJID.equals(j, JID::WithoutResource);

}

virtual const std::string& getOwnNick() const {

return ownMUCJID.getResource();

}

private:

JID ownMUCJID;

std::map<std::string, MUCOccupant> occupants_;

};

}