+ * Copyright (c) 2010-2016 Isode Limited.

+#include <Swiften/Disco/CapsInfoGenerator.h>

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

+ CPPUNIT_TEST_SUITE(CapsInfoGeneratorTest);

+ CPPUNIT_TEST(testGenerate_XEP0115SimpleExample);

+ CPPUNIT_TEST(testGenerate_XEP0115ComplexExample);

+ CPPUNIT_TEST_SUITE_END();

+

+ public:

+ void setUp() {

+ crypto = std::shared_ptr<CryptoProvider>(PlatformCryptoProvider::create());

+ }

+ void testGenerate_XEP0115SimpleExample() {

+ DiscoInfo discoInfo;

+ discoInfo.addIdentity(DiscoInfo::Identity("Exodus 0.9.1", "client", "pc"));

+ discoInfo.addFeature("http://jabber.org/protocol/disco#items");

+ discoInfo.addFeature("http://jabber.org/protocol/caps");

+ discoInfo.addFeature("http://jabber.org/protocol/disco#info");

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

+ CapsInfoGenerator testling("http://code.google.com/p/exodus", crypto.get());

+ CapsInfo result = testling.generateCapsInfo(discoInfo);

+ CPPUNIT_ASSERT_EQUAL(std::string("http://code.google.com/p/exodus"), result.getNode());

+ CPPUNIT_ASSERT_EQUAL(std::string("sha-1"), result.getHash());

+ CPPUNIT_ASSERT_EQUAL(std::string("QgayPKawpkPSDYmwT/WM94uAlu0="), result.getVersion());

+ }

+ void testGenerate_XEP0115ComplexExample() {

+ DiscoInfo discoInfo;

+ discoInfo.addIdentity(DiscoInfo::Identity("Psi 0.11", "client", "pc", "en"));

+ discoInfo.addIdentity(DiscoInfo::Identity("\xce\xa8 0.11", "client", "pc", "el"));

+ discoInfo.addFeature("http://jabber.org/protocol/disco#items");

+ discoInfo.addFeature("http://jabber.org/protocol/caps");

+ discoInfo.addFeature("http://jabber.org/protocol/disco#info");

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

+ Form::ref extension(new Form(Form::ResultType));

+ FormField::ref field = std::make_shared<FormField>(FormField::HiddenType, "urn:xmpp:dataforms:softwareinfo");

+ field->setName("FORM_TYPE");

+ extension->addField(field);

+ field = std::make_shared<FormField>(FormField::ListMultiType);

+ field->addValue("ipv6");

+ field->addValue("ipv4");

+ field->setName("ip_version");

+ extension->addField(field);

+ field = std::make_shared<FormField>(FormField::TextSingleType, "Psi");

+ field->setName("software");

+ extension->addField(field);

+ field = std::make_shared<FormField>(FormField::TextSingleType, "0.11");

+ field->setName("software_version");

+ extension->addField(field);

+ field = std::make_shared<FormField>(FormField::TextSingleType, "Mac");

+ field->setName("os");

+ extension->addField(field);

+ field = std::make_shared<FormField>(FormField::TextSingleType, "10.5.1");

+ field->setName("os_version");

+ extension->addField(field);

+ discoInfo.addExtension(extension);

+ CapsInfoGenerator testling("http://psi-im.org", crypto.get());

+ CapsInfo result = testling.generateCapsInfo(discoInfo);

+ CPPUNIT_ASSERT_EQUAL(std::string("q07IKJEyjvHSyhy//CH0CxmKi8w="), result.getVersion());

+ }

+ private:

+ std::shared_ptr<CryptoProvider> crypto;

+ * Copyright (c) 2010-2016 Isode Limited.

+#include <memory>

+

+#include <cppunit/extensions/HelperMacros.h>

+#include <cppunit/extensions/TestFactoryRegistry.h>

+

+#include <Swiften/Client/DummyStanzaChannel.h>

+#include <Swiften/Crypto/CryptoProvider.h>

+#include <Swiften/Crypto/PlatformCryptoProvider.h>

+#include <Swiften/Disco/CapsInfoGenerator.h>

+#include <Swiften/Queries/IQRouter.h>

+ CPPUNIT_TEST_SUITE(CapsManagerTest);

+ CPPUNIT_TEST(testReceiveNewHashRequestsDisco);

+ CPPUNIT_TEST(testReceiveSameHashDoesNotRequestDisco);

+ CPPUNIT_TEST(testReceiveLegacyCapsDoesNotRequestDisco);

+ CPPUNIT_TEST(testReceiveSameHashFromSameUserAfterFailedDiscoDoesNotRequestDisco);

+ CPPUNIT_TEST(testReceiveSameHashFromDifferentUserAfterFailedDiscoRequestsDisco);

+ CPPUNIT_TEST(testReceiveSameHashFromDifferentUserAfterIncorrectVerificationRequestsDisco);

+ CPPUNIT_TEST(testReceiveDifferentHashFromSameUserAfterFailedDiscoDoesNotRequestDisco);

+ CPPUNIT_TEST(testReceiveSameHashAfterSuccesfulDiscoDoesNotRequestDisco);

+ CPPUNIT_TEST(testReceiveSuccesfulDiscoStoresCaps);

+ CPPUNIT_TEST(testReceiveIncorrectVerificationDiscoDoesNotStoreCaps);

+ CPPUNIT_TEST(testReceiveFailingDiscoFallsBack);

+ CPPUNIT_TEST(testReceiveNoDiscoFallsBack);

+ CPPUNIT_TEST(testReceiveFailingFallbackDiscoFallsBack);

+ CPPUNIT_TEST(testReceiveSameHashFromFailingUserAfterReconnectRequestsDisco);

+ CPPUNIT_TEST(testReconnectResetsFallback);

+ CPPUNIT_TEST(testReconnectResetsRequests);

+ CPPUNIT_TEST_SUITE_END();

+

+ public:

+ void setUp() {

+ crypto = std::shared_ptr<CryptoProvider>(PlatformCryptoProvider::create());

+ stanzaChannel = std::unique_ptr<DummyStanzaChannel>(new DummyStanzaChannel());

+ iqRouter = std::unique_ptr<IQRouter>(new IQRouter(stanzaChannel.get()));

+ storage = std::unique_ptr<CapsMemoryStorage>(new CapsMemoryStorage());

+ user1 = JID("user1@bar.com/bla");

+ discoInfo1 = std::make_shared<DiscoInfo>();

+ discoInfo1->addFeature("http://swift.im/feature1");

+ capsInfo1 = std::make_shared<CapsInfo>(CapsInfoGenerator("http://node1.im", crypto.get()).generateCapsInfo(*discoInfo1.get()));

+ capsInfo1alt = std::make_shared<CapsInfo>(CapsInfoGenerator("http://node2.im", crypto.get()).generateCapsInfo(*discoInfo1.get()));

+ user2 = JID("user2@foo.com/baz");

+ discoInfo2 = std::make_shared<DiscoInfo>();

+ discoInfo2->addFeature("http://swift.im/feature2");

+ capsInfo2 = std::make_shared<CapsInfo>(CapsInfoGenerator("http://node2.im", crypto.get()).generateCapsInfo(*discoInfo2.get()));

+ user3 = JID("user3@foo.com/baz");

+ legacyCapsInfo = std::make_shared<CapsInfo>("http://swift.im", "ver1", "");

+ }

+

+ void tearDown() {

+ iqRouter.reset();

+ }

+

+ void testReceiveNewHashRequestsDisco() {

+ std::shared_ptr<CapsManager> testling = createManager();

+ sendPresenceWithCaps(user1, capsInfo1);

+

+ CPPUNIT_ASSERT(stanzaChannel->isRequestAtIndex<DiscoInfo>(0, user1, IQ::Get));

+ std::shared_ptr<DiscoInfo> discoInfo(stanzaChannel->sentStanzas[0]->getPayload<DiscoInfo>());

+ CPPUNIT_ASSERT(discoInfo);

+ CPPUNIT_ASSERT_EQUAL("http://node1.im#" + capsInfo1->getVersion(), discoInfo->getNode());

+ }

+

+ void testReceiveSameHashDoesNotRequestDisco() {

+ std::shared_ptr<CapsManager> testling = createManager();

+ sendPresenceWithCaps(user1, capsInfo1);

+ stanzaChannel->sentStanzas.clear();

+ sendPresenceWithCaps(user1, capsInfo1);

+

+ CPPUNIT_ASSERT_EQUAL(0, static_cast<int>(stanzaChannel->sentStanzas.size()));

+ }

+

+ void testReceiveLegacyCapsDoesNotRequestDisco() {

+ std::shared_ptr<CapsManager> testling = createManager();

+ sendPresenceWithCaps(user1, legacyCapsInfo);

+

+ CPPUNIT_ASSERT_EQUAL(0, static_cast<int>(stanzaChannel->sentStanzas.size()));

+ }

+

+ void testReceiveSameHashAfterSuccesfulDiscoDoesNotRequestDisco() {

+ std::shared_ptr<CapsManager> testling = createManager();

+ sendPresenceWithCaps(user1, capsInfo1);

+ sendDiscoInfoResult(discoInfo1);

+

+ stanzaChannel->sentStanzas.clear();

+ sendPresenceWithCaps(user1, capsInfo1);

+

+ CPPUNIT_ASSERT_EQUAL(0, static_cast<int>(stanzaChannel->sentStanzas.size()));

+ }

+

+ void testReceiveSameHashFromSameUserAfterFailedDiscoDoesNotRequestDisco() {

+ std::shared_ptr<CapsManager> testling = createManager();

+ sendPresenceWithCaps(user1, capsInfo1);

+ stanzaChannel->onIQReceived(IQ::createError(JID("baz@fum.com/foo"), stanzaChannel->sentStanzas[0]->getID()));

+

+ stanzaChannel->sentStanzas.clear();

+ sendPresenceWithCaps(user1, capsInfo1);

+

+ CPPUNIT_ASSERT_EQUAL(0, static_cast<int>(stanzaChannel->sentStanzas.size()));

+ }

+

+ void testReceiveSameHashFromSameUserAfterIncorrectVerificationDoesNotRequestDisco() {

+ std::shared_ptr<CapsManager> testling = createManager();

+ sendPresenceWithCaps(user1, capsInfo1);

+ sendDiscoInfoResult(discoInfo2);

+

+ stanzaChannel->sentStanzas.clear();

+ sendPresenceWithCaps(user1, capsInfo1);

+

+ CPPUNIT_ASSERT_EQUAL(0, static_cast<int>(stanzaChannel->sentStanzas.size()));

+ }

+

+ void testReceiveSameHashFromDifferentUserAfterFailedDiscoRequestsDisco() {

+ std::shared_ptr<CapsManager> testling = createManager();

+ sendPresenceWithCaps(user1, capsInfo1);

+ stanzaChannel->onIQReceived(IQ::createError(JID("baz@fum.com/foo"), stanzaChannel->sentStanzas[0]->getTo(), stanzaChannel->sentStanzas[0]->getID()));

+

+ stanzaChannel->sentStanzas.clear();

+ sendPresenceWithCaps(user2, capsInfo1);

+ CPPUNIT_ASSERT(stanzaChannel->isRequestAtIndex<DiscoInfo>(0, user2, IQ::Get));

+ }

+

+ void testReceiveSameHashFromDifferentUserAfterIncorrectVerificationRequestsDisco() {

+ std::shared_ptr<CapsManager> testling = createManager();

+ sendPresenceWithCaps(user1, capsInfo1);

+ sendDiscoInfoResult(discoInfo2);

+

+ stanzaChannel->sentStanzas.clear();

+ sendPresenceWithCaps(user2, capsInfo1);

+ CPPUNIT_ASSERT(stanzaChannel->isRequestAtIndex<DiscoInfo>(0, user2, IQ::Get));

+ }

+

+ void testReceiveDifferentHashFromSameUserAfterFailedDiscoDoesNotRequestDisco() {

+ std::shared_ptr<CapsManager> testling = createManager();

+ sendPresenceWithCaps(user1, capsInfo1);

+ stanzaChannel->onIQReceived(IQ::createError(JID("baz@fum.com/foo"), stanzaChannel->sentStanzas[0]->getID()));

+

+ stanzaChannel->sentStanzas.clear();

+ sendPresenceWithCaps(user1, capsInfo2);

+

+ CPPUNIT_ASSERT(stanzaChannel->isRequestAtIndex<DiscoInfo>(0, user1, IQ::Get));

+ }

+

+ void testReceiveSuccesfulDiscoStoresCaps() {

+ std::shared_ptr<CapsManager> testling = createManager();

+ sendPresenceWithCaps(user1, capsInfo1);

+ sendDiscoInfoResult(discoInfo1);

+

+ std::shared_ptr<DiscoInfo> discoInfo(storage->getDiscoInfo(capsInfo1->getVersion()));

+ CPPUNIT_ASSERT(discoInfo);

+ CPPUNIT_ASSERT(discoInfo->hasFeature("http://swift.im/feature1"));

+ }

+

+ void testReceiveIncorrectVerificationDiscoDoesNotStoreCaps() {

+ std::shared_ptr<CapsManager> testling = createManager();

+ sendPresenceWithCaps(user1, capsInfo1);

+ sendDiscoInfoResult(discoInfo2);

+

+ std::shared_ptr<DiscoInfo> discoInfo(storage->getDiscoInfo(capsInfo1->getVersion()));

+ CPPUNIT_ASSERT(!discoInfo);

+ }

+

+ void testReceiveFailingDiscoFallsBack() {

+ std::shared_ptr<CapsManager> testling = createManager();

+ sendPresenceWithCaps(user1, capsInfo1);

+ sendPresenceWithCaps(user2, capsInfo1alt);

+ stanzaChannel->onIQReceived(IQ::createError(JID("baz@fum.com/foo"), stanzaChannel->sentStanzas[0]->getTo(), stanzaChannel->sentStanzas[0]->getID()));

+

+ CPPUNIT_ASSERT(stanzaChannel->isRequestAtIndex<DiscoInfo>(1, user2, IQ::Get));

+ std::shared_ptr<DiscoInfo> discoInfo(stanzaChannel->sentStanzas[1]->getPayload<DiscoInfo>());

+ CPPUNIT_ASSERT(discoInfo);

+ CPPUNIT_ASSERT_EQUAL("http://node2.im#" + capsInfo1alt->getVersion(), discoInfo->getNode());

+ }

+

+ void testReceiveNoDiscoFallsBack() {

+ std::shared_ptr<CapsManager> testling = createManager();

+ sendPresenceWithCaps(user1, capsInfo1);

+ sendPresenceWithCaps(user2, capsInfo1alt);

+ stanzaChannel->onIQReceived(IQ::createResult(JID("baz@fum.com/dum"), stanzaChannel->sentStanzas[0]->getTo(), stanzaChannel->sentStanzas[0]->getID(), std::shared_ptr<DiscoInfo>()));

+

+ CPPUNIT_ASSERT(stanzaChannel->isRequestAtIndex<DiscoInfo>(1, user2, IQ::Get));

+ std::shared_ptr<DiscoInfo> discoInfo(stanzaChannel->sentStanzas[1]->getPayload<DiscoInfo>());

+ CPPUNIT_ASSERT(discoInfo);

+ CPPUNIT_ASSERT_EQUAL("http://node2.im#" + capsInfo1alt->getVersion(), discoInfo->getNode());

+ }

+

+ void testReceiveFailingFallbackDiscoFallsBack() {

+ std::shared_ptr<CapsManager> testling = createManager();

+ sendPresenceWithCaps(user1, capsInfo1);

+ sendPresenceWithCaps(user2, capsInfo1alt);

+ sendPresenceWithCaps(user3, capsInfo1);

+ stanzaChannel->onIQReceived(IQ::createError(JID("baz@fum.com/foo"), stanzaChannel->sentStanzas[0]->getTo(), stanzaChannel->sentStanzas[0]->getID()));

+ stanzaChannel->onIQReceived(IQ::createError(JID("baz@fum.com/foo"), stanzaChannel->sentStanzas[1]->getTo(), stanzaChannel->sentStanzas[1]->getID()));

+

+ CPPUNIT_ASSERT(stanzaChannel->isRequestAtIndex<DiscoInfo>(2, user3, IQ::Get));

+ }

+

+ void testReceiveSameHashFromFailingUserAfterReconnectRequestsDisco() {

+ std::shared_ptr<CapsManager> testling = createManager();

+ sendPresenceWithCaps(user1, capsInfo1);

+ stanzaChannel->onIQReceived(IQ::createError(JID("baz@fum.com/foo"), stanzaChannel->sentStanzas[0]->getTo(), stanzaChannel->sentStanzas[0]->getID()));

+ stanzaChannel->setAvailable(false);

+ stanzaChannel->setAvailable(true);

+ stanzaChannel->sentStanzas.clear();

+

+ sendPresenceWithCaps(user1, capsInfo1);

+

+ CPPUNIT_ASSERT(stanzaChannel->isRequestAtIndex<DiscoInfo>(0, user1, IQ::Get));

+ }

+

+ void testReconnectResetsFallback() {

+ std::shared_ptr<CapsManager> testling = createManager();

+ sendPresenceWithCaps(user1, capsInfo1);

+ sendPresenceWithCaps(user2, capsInfo1alt);

+ stanzaChannel->setAvailable(false);

+ stanzaChannel->setAvailable(true);

+ stanzaChannel->sentStanzas.clear();

+ sendPresenceWithCaps(user1, capsInfo1);

+ stanzaChannel->onIQReceived(IQ::createError(JID("baz@fum.com/foo"), stanzaChannel->sentStanzas[0]->getTo(), stanzaChannel->sentStanzas[0]->getID()));

+

+ CPPUNIT_ASSERT_EQUAL(1, static_cast<int>(stanzaChannel->sentStanzas.size()));

+ }

+

+ void testReconnectResetsRequests() {

+ std::shared_ptr<CapsManager> testling = createManager();

+ sendPresenceWithCaps(user1, capsInfo1);

+ stanzaChannel->sentStanzas.clear();

+ stanzaChannel->setAvailable(false);

+ stanzaChannel->setAvailable(true);

+ sendPresenceWithCaps(user1, capsInfo1);

+

+ CPPUNIT_ASSERT(stanzaChannel->isRequestAtIndex<DiscoInfo>(0, user1, IQ::Get));

+ }

+

+ private:

+ std::shared_ptr<CapsManager> createManager() {

+ std::shared_ptr<CapsManager> manager(new CapsManager(storage.get(), stanzaChannel.get(), iqRouter.get(), crypto.get()));

+ manager->setWarnOnInvalidHash(false);

+ //manager->onCapsChanged.connect(boost::bind(&CapsManagerTest::handleCapsChanged, this, _1));

+ return manager;

+ }

+

+ void handleCapsChanged(const JID& jid) {

+ changes.push_back(jid);

+ }

+

+ void sendPresenceWithCaps(const JID& jid, std::shared_ptr<CapsInfo> caps) {

+ std::shared_ptr<Presence> presence(new Presence());

+ presence->setFrom(jid);

+ presence->addPayload(caps);

+ stanzaChannel->onPresenceReceived(presence);

+ }

+

+ void sendDiscoInfoResult(std::shared_ptr<DiscoInfo> discoInfo) {

+ stanzaChannel->onIQReceived(IQ::createResult(JID("baz@fum.com/dum"), stanzaChannel->sentStanzas[0]->getTo(), stanzaChannel->sentStanzas[0]->getID(), discoInfo));

+ }

+

+ private:

+ std::unique_ptr<DummyStanzaChannel> stanzaChannel;

+ std::unique_ptr<IQRouter> iqRouter;

+ std::unique_ptr<CapsStorage> storage;

+ std::vector<JID> changes;

+ JID user1;

+ std::shared_ptr<DiscoInfo> discoInfo1;

+ std::shared_ptr<CapsInfo> capsInfo1;

+ std::shared_ptr<CapsInfo> capsInfo1alt;

+ JID user2;

+ std::shared_ptr<DiscoInfo> discoInfo2;

+ std::shared_ptr<CapsInfo> capsInfo2;

+ std::shared_ptr<CapsInfo> legacyCapsInfo;

+ JID user3;

+ std::shared_ptr<CryptoProvider> crypto;

+ * Copyright (c) 2010-2016 Isode Limited.

+#include <typeinfo>

+

+#include <Swiften/Queries/IQRouter.h>

+ CPPUNIT_TEST_SUITE(DiscoInfoResponderTest);

+ CPPUNIT_TEST(testHandleRequest_GetToplevelInfo);

+ CPPUNIT_TEST(testHandleRequest_GetNodeInfo);

+ CPPUNIT_TEST(testHandleRequest_GetInvalidNodeInfo);

+ CPPUNIT_TEST_SUITE_END();

+

+ public:

+ void setUp() {

+ channel_ = new DummyIQChannel();

+ router_ = new IQRouter(channel_);

+ }

+

+ void tearDown() {

+ delete router_;

+ delete channel_;

+ }

+

+ void testHandleRequest_GetToplevelInfo() {

+ DiscoInfoResponder testling(router_);

+ testling.start();

+ DiscoInfo discoInfo;

+ discoInfo.addFeature("foo");

+ testling.setDiscoInfo(discoInfo);

+

+ std::shared_ptr<DiscoInfo> query(new DiscoInfo());

+ channel_->onIQReceived(IQ::createRequest(IQ::Get, JID("foo@bar.com"), "id-1", query));

+

+ CPPUNIT_ASSERT_EQUAL(1, static_cast<int>(channel_->iqs_.size()));

+ std::shared_ptr<DiscoInfo> payload(channel_->iqs_[0]->getPayload<DiscoInfo>());

+ CPPUNIT_ASSERT(payload);

+ CPPUNIT_ASSERT_EQUAL(std::string(""), payload->getNode());

+ CPPUNIT_ASSERT(payload->hasFeature("foo"));

+

+ testling.stop();

+ }

+

+ void testHandleRequest_GetNodeInfo() {

+ DiscoInfoResponder testling(router_);

+ testling.start();

+ DiscoInfo discoInfo;

+ discoInfo.addFeature("foo");

+ testling.setDiscoInfo(discoInfo);

+ DiscoInfo discoInfoBar;

+ discoInfoBar.addFeature("bar");

+ testling.setDiscoInfo("bar-node", discoInfoBar);

+

+ std::shared_ptr<DiscoInfo> query(new DiscoInfo());

+ query->setNode("bar-node");

+ channel_->onIQReceived(IQ::createRequest(IQ::Get, JID("foo@bar.com"), "id-1", query));

+

+ CPPUNIT_ASSERT_EQUAL(1, static_cast<int>(channel_->iqs_.size()));

+ std::shared_ptr<DiscoInfo> payload(channel_->iqs_[0]->getPayload<DiscoInfo>());

+ CPPUNIT_ASSERT(payload);

+ CPPUNIT_ASSERT_EQUAL(std::string("bar-node"), payload->getNode());

+ CPPUNIT_ASSERT(payload->hasFeature("bar"));

+

+ testling.stop();

+ }

+

+ void testHandleRequest_GetInvalidNodeInfo() {

+ DiscoInfoResponder testling(router_);

+ std::shared_ptr<DiscoInfo> query(new DiscoInfo());

+ query->setNode("bar-node");

+ channel_->onIQReceived(IQ::createRequest(IQ::Get, JID("foo@bar.com"), "id-1", query));

+ testling.start();

+

+ CPPUNIT_ASSERT_EQUAL(1, static_cast<int>(channel_->iqs_.size()));

+ std::shared_ptr<ErrorPayload> payload(channel_->iqs_[0]->getPayload<ErrorPayload>());

+ CPPUNIT_ASSERT(payload);

+

+ testling.stop();

+ }

+

+ private:

+ IQRouter* router_;

+ DummyIQChannel* channel_;

+ * Copyright (c) 2010-2016 Isode Limited.

+#include <memory>

+

+#include <cppunit/extensions/HelperMacros.h>

+#include <cppunit/extensions/TestFactoryRegistry.h>

+

+#include <Swiften/Disco/CapsInfoGenerator.h>

+#include <Swiften/Disco/CapsProvider.h>

+#include <Swiften/Disco/EntityCapsManager.h>

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

+ CPPUNIT_TEST_SUITE(EntityCapsManagerTest);

+ CPPUNIT_TEST(testReceiveKnownHash);

+ CPPUNIT_TEST(testReceiveKnownHashTwiceDoesNotTriggerChange);

+ CPPUNIT_TEST(testReceiveUnknownHashDoesNotTriggerChange);

+ CPPUNIT_TEST(testReceiveUnknownHashAfterKnownHashTriggersChangeAndClearsCaps);

+ CPPUNIT_TEST(testReceiveUnavailablePresenceAfterKnownHashTriggersChangeAndClearsCaps);

+ CPPUNIT_TEST(testReconnectTriggersChangeAndClearsCaps);

+ CPPUNIT_TEST(testHashAvailable);

+ CPPUNIT_TEST_SUITE_END();

+

+ public:

+ void setUp() {

+ crypto = std::shared_ptr<CryptoProvider>(PlatformCryptoProvider::create());

+

+ stanzaChannel = std::unique_ptr<DummyStanzaChannel>(new DummyStanzaChannel());

+ capsProvider = std::unique_ptr<DummyCapsProvider>(new DummyCapsProvider());

+

+ user1 = JID("user1@bar.com/bla");

+ discoInfo1 = std::make_shared<DiscoInfo>();

+ discoInfo1->addFeature("http://swift.im/feature1");

+ capsInfo1 = std::make_shared<CapsInfo>(CapsInfoGenerator("http://node1.im", crypto.get()).generateCapsInfo(*discoInfo1.get()));

+ capsInfo1alt = std::make_shared<CapsInfo>(CapsInfoGenerator("http://node2.im", crypto.get()).generateCapsInfo(*discoInfo1.get()));

+ user2 = JID("user2@foo.com/baz");

+ discoInfo2 = std::make_shared<DiscoInfo>();

+ discoInfo2->addFeature("http://swift.im/feature2");

+ capsInfo2 = std::make_shared<CapsInfo>(CapsInfoGenerator("http://node2.im", crypto.get()).generateCapsInfo(*discoInfo2.get()));

+ user3 = JID("user3@foo.com/baz");

+ legacyCapsInfo = std::make_shared<CapsInfo>("http://swift.im", "ver1", "");

+ }

+

+ void testReceiveKnownHash() {

+ std::shared_ptr<EntityCapsManager> testling = createManager();

+ capsProvider->caps[capsInfo1->getVersion()] = discoInfo1;

+ sendPresenceWithCaps(user1, capsInfo1);

+

+ CPPUNIT_ASSERT_EQUAL(1, static_cast<int>(changes.size()));

+ CPPUNIT_ASSERT_EQUAL(user1, changes[0]);

+ CPPUNIT_ASSERT_EQUAL(discoInfo1, testling->getCaps(user1));

+ }

+

+ void testReceiveKnownHashTwiceDoesNotTriggerChange() {

+ std::shared_ptr<EntityCapsManager> testling = createManager();

+ capsProvider->caps[capsInfo1->getVersion()] = discoInfo1;

+ sendPresenceWithCaps(user1, capsInfo1);

+ changes.clear();

+

+ sendPresenceWithCaps(user1, capsInfo1);

+

+ CPPUNIT_ASSERT_EQUAL(0, static_cast<int>(changes.size()));

+ }

+

+ void testReceiveUnknownHashDoesNotTriggerChange() {

+ std::shared_ptr<EntityCapsManager> testling = createManager();

+ sendPresenceWithCaps(user1, capsInfo1);

+

+ CPPUNIT_ASSERT_EQUAL(0, static_cast<int>(changes.size()));

+ }

+

+ void testHashAvailable() {

+ std::shared_ptr<EntityCapsManager> testling = createManager();

+ sendPresenceWithCaps(user1, capsInfo1);

+

+ capsProvider->caps[capsInfo1->getVersion()] = discoInfo1;

+ capsProvider->onCapsAvailable(capsInfo1->getVersion());

+

+ CPPUNIT_ASSERT_EQUAL(1, static_cast<int>(changes.size()));

+ CPPUNIT_ASSERT_EQUAL(user1, changes[0]);

+ CPPUNIT_ASSERT_EQUAL(discoInfo1, testling->getCaps(user1));

+ }

+

+ void testReceiveUnknownHashAfterKnownHashTriggersChangeAndClearsCaps() {

+ std::shared_ptr<EntityCapsManager> testling = createManager();

+ capsProvider->caps[capsInfo1->getVersion()] = discoInfo1;

+ sendPresenceWithCaps(user1, capsInfo1);

+ changes.clear();

+ sendPresenceWithCaps(user1, capsInfo2);

+

+ CPPUNIT_ASSERT_EQUAL(1, static_cast<int>(changes.size()));

+ CPPUNIT_ASSERT_EQUAL(user1, changes[0]);

+ CPPUNIT_ASSERT(!testling->getCaps(user1));

+ }

+

+ void testReceiveUnavailablePresenceAfterKnownHashTriggersChangeAndClearsCaps() {

+ std::shared_ptr<EntityCapsManager> testling = createManager();

+ capsProvider->caps[capsInfo1->getVersion()] = discoInfo1;

+ sendPresenceWithCaps(user1, capsInfo1);

+ changes.clear();

+ sendUnavailablePresence(user1);

+

+ CPPUNIT_ASSERT_EQUAL(1, static_cast<int>(changes.size()));

+ CPPUNIT_ASSERT_EQUAL(user1, changes[0]);

+ CPPUNIT_ASSERT(!testling->getCaps(user1));

+ }

+

+ void testReconnectTriggersChangeAndClearsCaps() {

+ std::shared_ptr<EntityCapsManager> testling = createManager();

+ capsProvider->caps[capsInfo1->getVersion()] = discoInfo1;

+ capsProvider->caps[capsInfo2->getVersion()] = discoInfo2;

+ sendPresenceWithCaps(user1, capsInfo1);

+ sendPresenceWithCaps(user2, capsInfo2);

+ changes.clear();

+ stanzaChannel->setAvailable(false);

+ stanzaChannel->setAvailable(true);

+

+ CPPUNIT_ASSERT_EQUAL(2, static_cast<int>(changes.size()));

+ CPPUNIT_ASSERT_EQUAL(user1, changes[0]);

+ CPPUNIT_ASSERT(!testling->getCaps(user1));

+ CPPUNIT_ASSERT_EQUAL(user2, changes[1]);

+ CPPUNIT_ASSERT(!testling->getCaps(user2));

+ }

+

+ private:

+ std::shared_ptr<EntityCapsManager> createManager() {

+ std::shared_ptr<EntityCapsManager> manager(new EntityCapsManager(capsProvider.get(), stanzaChannel.get()));

+ manager->onCapsChanged.connect(boost::bind(&EntityCapsManagerTest::handleCapsChanged, this, _1));

+ return manager;

+ }

+

+ void handleCapsChanged(const JID& jid) {

+ changes.push_back(jid);

+ }

+

+ void sendPresenceWithCaps(const JID& jid, std::shared_ptr<CapsInfo> caps) {

+ std::shared_ptr<Presence> presence(new Presence());

+ presence->setFrom(jid);

+ presence->addPayload(caps);

+ stanzaChannel->onPresenceReceived(presence);

+ }

+

+ void sendUnavailablePresence(const JID& jid) {

+ std::shared_ptr<Presence> presence(new Presence());

+ presence->setFrom(jid);

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

+ stanzaChannel->onPresenceReceived(presence);

+ }

+

+ private:

+ struct DummyCapsProvider : public CapsProvider {

+ virtual DiscoInfo::ref getCaps(const std::string& hash) const {

+ std::map<std::string, DiscoInfo::ref>::const_iterator i = caps.find(hash);

+ if (i != caps.end()) {

+ return i->second;

+ }

+ return DiscoInfo::ref();

+ }

+

+ std::map<std::string, DiscoInfo::ref> caps;

+ };

+

+ private:

+ std::unique_ptr<DummyStanzaChannel> stanzaChannel;

+ std::unique_ptr<DummyCapsProvider> capsProvider;

+ JID user1;

+ std::shared_ptr<DiscoInfo> discoInfo1;

+ std::shared_ptr<CapsInfo> capsInfo1;

+ std::shared_ptr<CapsInfo> capsInfo1alt;

+ JID user2;

+ std::shared_ptr<DiscoInfo> discoInfo2;

+ std::shared_ptr<CapsInfo> capsInfo2;

+ std::shared_ptr<CapsInfo> legacyCapsInfo;

+ JID user3;

+ std::vector<JID> changes;

+ std::shared_ptr<CryptoProvider> crypto;

+/*

+ * Copyright (c) 2016 Isode Limited.

+ * All rights reserved.

+ * See the COPYING file for more information.

+ */

+

+#include <vector>

+

+#include <boost/bind.hpp>

+

+#include <cppunit/extensions/HelperMacros.h>

+#include <cppunit/extensions/TestFactoryRegistry.h>

+

+#include <Swiften/Base/Tristate.h>

+#include <Swiften/Client/DummyStanzaChannel.h>

+#include <Swiften/Crypto/CryptoProvider.h>

+#include <Swiften/Crypto/PlatformCryptoProvider.h>

+#include <Swiften/Disco/CapsInfoGenerator.h>

+#include <Swiften/Disco/CapsProvider.h>

+#include <Swiften/Disco/EntityCapsManager.h>

+#include <Swiften/Disco/FeatureOracle.h>

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

+#include <Swiften/Presence/PresenceOracle.h>

+#include <Swiften/Roster/XMPPRosterImpl.h>

+

+using namespace Swift;

+

+class FeatureOracleTest : public CppUnit::TestFixture {

+ CPPUNIT_TEST_SUITE(FeatureOracleTest);

+ CPPUNIT_TEST(testMergeAvailableResourcesForFeatures);

+ CPPUNIT_TEST(testMostAvailableFileTransferClient);

+ CPPUNIT_TEST_SUITE_END();

+

+ public:

+ void setUp() {

+ crypto_ = std::shared_ptr<CryptoProvider>(PlatformCryptoProvider::create());

+ dummyStanzaChannel_ = new DummyStanzaChannel();

+ xmppRosterImpl_ = new XMPPRosterImpl();

+ dummyCapsProvider_ = new DummyCapsProvider();

+ entityCapsManager_ = new EntityCapsManager(dummyCapsProvider_, dummyStanzaChannel_);

+ presenceOracle_ = new PresenceOracle(dummyStanzaChannel_, xmppRosterImpl_);

+ featureOracle_ = new FeatureOracle(entityCapsManager_, presenceOracle_);

+ }

+

+ void tearDown() {

+ delete featureOracle_;

+ delete presenceOracle_;

+ delete entityCapsManager_;

+ delete dummyCapsProvider_;

+ delete xmppRosterImpl_;

+ delete dummyStanzaChannel_;

+ }

+

+ void simulateIncomingPresence(const JID& from, Presence::Type type, StatusShow::Type status, const DiscoInfo::ref& disco, const std::vector<Payload::ref>& additionalPayloads = {}) {

+ auto capsInfo = std::make_shared<CapsInfo>(CapsInfoGenerator("http://example.com", crypto_.get()).generateCapsInfo(*disco.get()));

+ dummyCapsProvider_->caps[capsInfo->getVersion()] = disco;

+

+ Presence::ref capsNotifyPresence = std::make_shared<Presence>();

+ capsNotifyPresence->setType(type);

+ capsNotifyPresence->setFrom(from);

+ capsNotifyPresence->setShow(status);

+ capsNotifyPresence->addPayload(capsInfo);

+

+ capsNotifyPresence->addPayloads(additionalPayloads);

+

+ xmppRosterImpl_->addContact(from, "Foo", {}, RosterItemPayload::Both);

+ dummyStanzaChannel_->onPresenceReceived(capsNotifyPresence);

+ }

+

+ DiscoInfo::ref fileTransferSupportingDisco() {

+ DiscoInfo::ref discoInfo = std::make_shared<DiscoInfo>();

+ discoInfo->addFeature(DiscoInfo::JingleFeature);

+ discoInfo->addFeature(DiscoInfo::JingleFTFeature);

+ discoInfo->addFeature(DiscoInfo::JingleTransportsS5BFeature);

+ discoInfo->addFeature(DiscoInfo::JingleTransportsIBBFeature);

+ return discoInfo;

+ }

+

+ DiscoInfo::ref noFileTransferSupportingDisco() {

+ DiscoInfo::ref discoInfo = std::make_shared<DiscoInfo>();

+ discoInfo->addFeature(DiscoInfo::JingleFeature);

+ return discoInfo;

+ }

+

+ void testMergeAvailableResourcesForFeatures() {

+ CPPUNIT_ASSERT_EQUAL(No, featureOracle_->isFileTransferSupported(baseJID));

+

+ simulateIncomingPresence(noFileTransferJID, Presence::Available, StatusShow::Online, noFileTransferSupportingDisco());

+

+ CPPUNIT_ASSERT_EQUAL(size_t(1), presenceOracle_->getAllPresence(baseJID).size());

+ CPPUNIT_ASSERT_EQUAL(No, featureOracle_->isFileTransferSupported(baseJID));

+

+ simulateIncomingPresence(fileTransferJID, Presence::Available, StatusShow::Online, fileTransferSupportingDisco());

+

+ CPPUNIT_ASSERT_EQUAL(size_t(2), presenceOracle_->getAllPresence(baseJID).size());

+ CPPUNIT_ASSERT_EQUAL(Maybe, featureOracle_->isFileTransferSupported(baseJID));

+

+ simulateIncomingPresence(noFileTransferJID, Presence::Unavailable, StatusShow::None, noFileTransferSupportingDisco());

+

+ CPPUNIT_ASSERT_EQUAL(size_t(1), presenceOracle_->getAllPresence(baseJID).size());

+ CPPUNIT_ASSERT_EQUAL(Yes, featureOracle_->isFileTransferSupported(baseJID));

+

+ simulateIncomingPresence(fileTransferJID, Presence::Unavailable, StatusShow::None, fileTransferSupportingDisco());

+

+ CPPUNIT_ASSERT_EQUAL(size_t(1), presenceOracle_->getAllPresence(baseJID).size());

+ CPPUNIT_ASSERT_EQUAL(No, featureOracle_->isFileTransferSupported(baseJID));

+ }

+

+ void testMostAvailableFileTransferClient() {

+ simulateIncomingPresence(fileTransferJID, Presence::Available, StatusShow::DND, fileTransferSupportingDisco());

+

+ CPPUNIT_ASSERT_EQUAL(fileTransferJID, featureOracle_->getMostAvailableClientForFileTrasfer(baseJID));

+

+ simulateIncomingPresence(noFileTransferJID, Presence::Available, StatusShow::Online, noFileTransferSupportingDisco());

+

+ CPPUNIT_ASSERT_EQUAL(fileTransferJID, featureOracle_->getMostAvailableClientForFileTrasfer(baseJID));

+

+ auto moreAvailableJID = baseJID.withResource("moreAvailableFt");

+ simulateIncomingPresence(moreAvailableJID, Presence::Available, StatusShow::Online, fileTransferSupportingDisco());

+

+ CPPUNIT_ASSERT_EQUAL(moreAvailableJID, featureOracle_->getMostAvailableClientForFileTrasfer(baseJID));

+ }

+

+ private:

+ struct DummyCapsProvider : public CapsProvider {

+ virtual DiscoInfo::ref getCaps(const std::string& hash) const {

+ std::map<std::string, DiscoInfo::ref>::const_iterator i = caps.find(hash);

+ if (i != caps.end()) {

+ return i->second;

+ }

+ return DiscoInfo::ref();

+ }

+

+ std::map<std::string, DiscoInfo::ref> caps;

+ };

+

+ private:

+ JID baseJID = "test@example.com";

+ JID fileTransferJID = baseJID.withResource("fileTransfer");

+ JID noFileTransferJID = baseJID.withResource("noFileTransfer");

+

+ std::shared_ptr<CryptoProvider> crypto_;

+ DummyCapsProvider* dummyCapsProvider_;

+ DummyStanzaChannel* dummyStanzaChannel_;

+ EntityCapsManager* entityCapsManager_;

+ FeatureOracle* featureOracle_;

+ PresenceOracle* presenceOracle_;

+ XMPPRosterImpl* xmppRosterImpl_;

+};

+

+CPPUNIT_TEST_SUITE_REGISTRATION(FeatureOracleTest);

+ * Copyright (c) 2010-2016 Isode Limited.

+#include <typeinfo>

+

+#include <Swiften/Queries/IQRouter.h>

+ CPPUNIT_TEST_SUITE(JIDDiscoInfoResponderTest);

+ CPPUNIT_TEST(testHandleRequest_GetToplevelInfo);

+ CPPUNIT_TEST(testHandleRequest_GetNodeInfo);

+ CPPUNIT_TEST(testHandleRequest_GetInvalidNodeInfo);

+ CPPUNIT_TEST(testHandleRequest_GetUnknownJID);

+ CPPUNIT_TEST_SUITE_END();

+

+ public:

+ void setUp() {

+ channel_ = new DummyIQChannel();

+ router_ = new IQRouter(channel_);

+ }

+

+ void tearDown() {

+ delete router_;

+ delete channel_;

+ }

+

+ void testHandleRequest_GetToplevelInfo() {

+ JIDDiscoInfoResponder testling(router_);

+ testling.start();

+ DiscoInfo discoInfo;

+ discoInfo.addFeature("foo");

+ testling.setDiscoInfo(JID("foo@bar.com/baz"), discoInfo);

+

+ std::shared_ptr<DiscoInfo> query(new DiscoInfo());

+ channel_->onIQReceived(IQ::createRequest(IQ::Get, JID("foo@bar.com/baz"), "id-1", query));

+

+ CPPUNIT_ASSERT_EQUAL(1, static_cast<int>(channel_->iqs_.size()));

+ std::shared_ptr<DiscoInfo> payload(channel_->iqs_[0]->getPayload<DiscoInfo>());

+ CPPUNIT_ASSERT(payload);

+ CPPUNIT_ASSERT_EQUAL(std::string(""), payload->getNode());

+ CPPUNIT_ASSERT(payload->hasFeature("foo"));

+

+ testling.stop();

+ }

+

+ void testHandleRequest_GetNodeInfo() {

+ JIDDiscoInfoResponder testling(router_);

+ testling.start();

+ DiscoInfo discoInfo;

+ discoInfo.addFeature("foo");

+ testling.setDiscoInfo(JID("foo@bar.com/baz"), discoInfo);

+ DiscoInfo discoInfoBar;

+ discoInfoBar.addFeature("bar");

+ testling.setDiscoInfo(JID("foo@bar.com/baz"), "bar-node", discoInfoBar);

+

+ std::shared_ptr<DiscoInfo> query(new DiscoInfo());

+ query->setNode("bar-node");

+ channel_->onIQReceived(IQ::createRequest(IQ::Get, JID("foo@bar.com/baz"), "id-1", query));

+

+ CPPUNIT_ASSERT_EQUAL(1, static_cast<int>(channel_->iqs_.size()));

+ std::shared_ptr<DiscoInfo> payload(channel_->iqs_[0]->getPayload<DiscoInfo>());

+ CPPUNIT_ASSERT(payload);

+ CPPUNIT_ASSERT_EQUAL(std::string("bar-node"), payload->getNode());

+ CPPUNIT_ASSERT(payload->hasFeature("bar"));

+

+ testling.stop();

+ }

+

+ void testHandleRequest_GetInvalidNodeInfo() {

+ JIDDiscoInfoResponder testling(router_);

+ DiscoInfo discoInfo;

+ discoInfo.addFeature("foo");

+ testling.setDiscoInfo(JID("foo@bar.com/baz"), discoInfo);

+ testling.start();

+

+ std::shared_ptr<DiscoInfo> query(new DiscoInfo());

+ query->setNode("bar-node");

+ channel_->onIQReceived(IQ::createRequest(IQ::Get, JID("foo@bar.com/baz"), "id-1", query));

+

+ CPPUNIT_ASSERT_EQUAL(1, static_cast<int>(channel_->iqs_.size()));

+ std::shared_ptr<ErrorPayload> payload(channel_->iqs_[0]->getPayload<ErrorPayload>());

+ CPPUNIT_ASSERT(payload);

+

+ testling.stop();

+ }

+

+ void testHandleRequest_GetUnknownJID() {

+ JIDDiscoInfoResponder testling(router_);

+ DiscoInfo discoInfo;

+ discoInfo.addFeature("foo");

+ testling.setDiscoInfo(JID("foo@bar.com/baz"), discoInfo);

+ testling.start();

+

+ std::shared_ptr<DiscoInfo> query(new DiscoInfo());

+ channel_->onIQReceived(IQ::createRequest(IQ::Get, JID("foo@bar.com/fum"), "id-1", query));

+

+ CPPUNIT_ASSERT_EQUAL(1, static_cast<int>(channel_->iqs_.size()));

+ std::shared_ptr<ErrorPayload> payload(channel_->iqs_[0]->getPayload<ErrorPayload>());

+ CPPUNIT_ASSERT(payload);

+

+ testling.stop();

+ }

+

+ private:

+ IQRouter* router_;

+ DummyIQChannel* channel_;