class DummyCapsProvider : public CapsProvider {

DiscoInfo::ref getCaps(const std::string&) const {return DiscoInfo::ref(new DiscoInfo());}

};

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

public:

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

presenceSender_ = new StanzaChannelPresenceSender(stanzaChannel_);

directedPresenceSender_ = new DirectedPresenceSender(presenceSender_);

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

uiEventStream_ = new UIEventStream();

entityCapsManager_ = new EntityCapsManager(capsProvider_, stanzaChannel_);

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

mocks_->ExpectCall(chatListWindowFactory_, ChatListWindowFactory::createChatListWindow).With(uiEventStream_).Return(chatListWindow_);

manager_ = new ChatsManager(jid_, stanzaChannel_, iqRouter_, eventController_, chatWindowFactory_, joinMUCWindowFactory_, nickResolver_, presenceOracle_, directedPresenceSender_, uiEventStream_, chatListWindowFactory_, true, NULL, mucRegistry_, entityCapsManager_, mucManager_, mucSearchWindowFactory_, profileSettings_, ftOverview_, xmppRoster_, false, settings_);

avatarManager_ = new NullAvatarManager();

manager_->setAvatarManager(avatarManager_);

};

void tearDown() {

//delete chatListWindowFactory

delete profileSettings_;

delete avatarManager_;

delete manager_;

delete ftOverview_;

delete ftManager_;

delete directedPresenceSender_;

delete presenceSender_;

delete presenceOracle_;

delete nickResolver_;

delete mucRegistry_;

delete stanzaChannel_;

delete eventController_;

delete iqRouter_;

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

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