+ failedStanzas_[stanzaIdPair.second] = stanzaIdPair.first;

+#include <Swiften/Elements/DeliveryReceipt.h>

+#include <Swiften/Elements/DeliveryReceiptRequest.h>

+ scopedConnectionResendMessage_ = chatWindow_->onResendMessageRequest.connect(boost::bind(&ChatControllerBase::handleResendMessageRequest, this, _1));

+ scopedConnectionResendMessage_.disconnect();

+void ChatControllerBase::handleResendMessageRequest(const std::string& id) {

+ if (failedStanzas_.find(id) != failedStanzas_.end()) {

+ if (auto resendMsg = std::dynamic_pointer_cast<Message>(failedStanzas_[id])) {

+ stanzaChannel_->sendMessage(resendMsg);

+ if (stanzaChannel_->getStreamManagementEnabled()) {

+ chatWindow_->setAckState(id, ChatWindow::Pending);

+ unackedStanzas_[failedStanzas_[id]] = id;

+ }

+ if (resendMsg->getPayload<DeliveryReceiptRequest>()) {

+ requestedReceipts_[resendMsg->getID()] = id;

+ chatWindow_->setMessageReceiptState(id, ChatWindow::ReceiptRequested);

+ }

+ lastWasPresence_ = false;

+ failedStanzas_.erase(id);

+ }

+ }

+}

+

+ virtual void handleResendMessageRequest(const std::string& id);

+ boost::signals2::scoped_connection scopedConnectionResendMessage_;

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

+ std::map<std::shared_ptr<Stanza>, std::string> unackedStanzas_;

+ std::map<std::string, std::shared_ptr<Stanza>> failedStanzas_;

+/*

+ * Copyright (c) 2018 Isode Limited.

+ * All rights reserved.

+ * See the COPYING file for more information.

+ */

+

+#include <memory>

+#include <string>

+

+#include <gtest/gtest.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/Disco/DummyEntityCapsProvider.h>

+#include <Swiften/Network/DummyTimerFactory.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/AutoAcceptMUCInviteDecider.h>

+#include <Swift/Controllers/Chat/ChatController.h>

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

+#include <Swift/Controllers/Chat/Chattables.h>

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

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

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

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

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

+

+using namespace Swift;

+

+/**

+ * Most of the ChatController tests are in ChatsManagerTest.

+ * New tests related with ChatController should be added here,

+ * and old tests should be migrated when possible.

+ */

+

+class ExtendedChatController : public ChatController {

+public:

+ ExtendedChatController(const JID& self, StanzaChannel* stanzaChannel, IQRouter* iqRouter, ChatWindowFactory* chatWindowFactory, const JID &contact, NickResolver* nickResolver, PresenceOracle* presenceOracle, AvatarManager* avatarManager, bool isInMUC, bool useDelayForLatency, UIEventStream* eventStream, TimerFactory* timerFactory, EventController* eventController, EntityCapsProvider* entityCapsProvider, bool userWantsReceipts, HistoryController* historyController, MUCRegistry* mucRegistry, HighlightManager* highlightManager, ClientBlockListManager* clientBlockListManager, std::shared_ptr<ChatMessageParser> chatMessageParser, AutoAcceptMUCInviteDecider* autoAcceptMUCInviteDecider, SettingsProvider* settings, Chattables& chattables) :

+ ChatController(self, stanzaChannel, iqRouter, chatWindowFactory, contact, nickResolver, presenceOracle, avatarManager, isInMUC, useDelayForLatency, eventStream, timerFactory, eventController, entityCapsProvider, userWantsReceipts, historyController, mucRegistry, highlightManager, clientBlockListManager, chatMessageParser, autoAcceptMUCInviteDecider, settings, chattables) {

+ }

+

+ std::map<std::shared_ptr<Stanza>, std::string> getUnackedStanzas() { return unackedStanzas_; }

+ std::map<std::string, std::shared_ptr<Stanza>> getFailedStanzas() { return failedStanzas_; }

+};

+

+class ChatControllerTest : public ::testing::Test {

+protected:

+ virtual void SetUp() {

+ self_ = JID("alice@wonderland.lit");

+ other_ = JID("whiterabbit@wonderland.lit");

+ stanzaChannel_ = new DummyStanzaChannel();

+ iqChannel_ = new DummyIQChannel();

+ iqRouter_ = new IQRouter(iqChannel_);

+ eventController_ = new EventController();

+ xmppRoster_ = new XMPPRosterImpl();

+ vCardManager_ = new VCardManager(self_, iqRouter_, vCardMemoryStorage_);

+ mucRegistry_ = new MUCRegistry();

+ nickResolver_ = new NickResolver(self_, xmppRoster_, vCardManager_, mucRegistry_);

+ presenceOracle_ = new PresenceOracle(stanzaChannel_, xmppRoster_);

+ avatarManager_ = new NullAvatarManager();

+ uiEventStream_ = new UIEventStream();

+ timerFactory_ = new DummyTimerFactory();

+ entityCapsProvider_ = new DummyEntityCapsProvider();

+ settings_ = new DummySettingsProvider();

+ highlightManager_ = new HighlightManager(settings_);

+ highlightManager_->resetToDefaultConfiguration();

+ clientBlockListManager_ = new ClientBlockListManager(iqRouter_);

+ autoAcceptMUCInviteDecider_ = new AutoAcceptMUCInviteDecider(self_.getDomain(), xmppRoster_, settings_);

+ chatMessageParser_ = std::make_shared<ChatMessageParser>(std::map<std::string, std::string>(), highlightManager_->getConfiguration(), ChatMessageParser::Mode::GroupChat);

+ mocks_ = new MockRepository();

+ window_ = new MockChatWindow();

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

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

+ chattables_ = std::make_unique<Chattables>();

+

+ controller_ = new ExtendedChatController(self_, stanzaChannel_, iqRouter_, chatWindowFactory_, other_, nickResolver_, presenceOracle_, avatarManager_, false, false, uiEventStream_, timerFactory_, eventController_, entityCapsProvider_, false, nullptr, mucRegistry_, highlightManager_, clientBlockListManager_, chatMessageParser_, nullptr, settings_, *chattables_);

+ }

+ virtual void TearDown() {

+ delete controller_;

+ chattables_.reset();

+ chatMessageParser_.reset();

+ delete autoAcceptMUCInviteDecider_;

+ delete clientBlockListManager_;

+ delete highlightManager_;

+ delete settings_;

+ delete entityCapsProvider_;

+ delete timerFactory_;

+ delete uiEventStream_;

+ delete avatarManager_;

+ delete presenceOracle_;

+ delete nickResolver_;

+ delete mucRegistry_;

+ delete vCardManager_;

+ delete xmppRoster_;

+ delete eventController_;

+ delete iqRouter_;

+ delete iqChannel_;

+ delete stanzaChannel_;

+ }

+

+ JID self_, other_;

+ AvatarManager* avatarManager_ = nullptr;

+ ExtendedChatController* controller_ = nullptr;

+ ChatWindowFactory* chatWindowFactory_;

+ ClientBlockListManager* clientBlockListManager_;

+ EventController* eventController_ = nullptr;

+ EntityCapsProvider* entityCapsProvider_ = nullptr;

+ IQChannel* iqChannel_ = nullptr;

+ IQRouter* iqRouter_ = nullptr;

+ MockRepository* mocks_;

+ MockChatWindow* window_;

+ MUCRegistry* mucRegistry_ = nullptr;

+ NickResolver* nickResolver_ = nullptr;

+ PresenceOracle* presenceOracle_ = nullptr;

+ DummyStanzaChannel* stanzaChannel_ = nullptr;

+ TimerFactory* timerFactory_;

+ XMPPRosterImpl* xmppRoster_ = nullptr;

+ UIEventStream* uiEventStream_;

+ VCardManager* vCardManager_ = nullptr;

+ VCardMemoryStorage* vCardMemoryStorage_ = nullptr;

+ DummySettingsProvider* settings_;

+ HighlightManager* highlightManager_;

+ std::shared_ptr<ChatMessageParser> chatMessageParser_;

+ AutoAcceptMUCInviteDecider* autoAcceptMUCInviteDecider_;

+ std::unique_ptr<Chattables> chattables_;

+

+};

+

+TEST_F(ChatControllerTest, testResendMessage) {

+ std::string msgBody("TestMsg");

+ stanzaChannel_->setStreamManagementEnabled(true);

+ window_->onSendMessageRequest(msgBody, false);

+ {

+ auto failedStanzas = controller_->getFailedStanzas();

+ auto unackedStanzas = controller_->getUnackedStanzas();

+ ASSERT_EQ(failedStanzas.size(), 0);

+ ASSERT_EQ(unackedStanzas.size(), 1);

+ }

+ //Disconnecting to fail the stanza

+ controller_->setOnline(false);

+ controller_->setOnline(true);

+ {

+ auto failedStanzas = controller_->getFailedStanzas();

+ auto unackedStanzas = controller_->getUnackedStanzas();

+ ASSERT_EQ(failedStanzas.size(), 1);

+ ASSERT_EQ(unackedStanzas.size(), 0);

+ }

+ window_->onResendMessageRequest("id");

+ {

+ auto failedStanzas = controller_->getFailedStanzas();

+ auto unackedStanzas = controller_->getUnackedStanzas();

+ ASSERT_EQ(failedStanzas.size(), 0);

+ ASSERT_EQ(unackedStanzas.size(), 1);

+ }

+}

+ File("Chat/UnitTest/ChatControllerTest.cpp"),

+ boost::signals2::signal<void (const std::string&)> onResendMessageRequest;