+ CPPUNIT_TEST_SUITE(AvatarManagerImplTest);

+ CPPUNIT_TEST(testGetSetAvatar);

+ CPPUNIT_TEST_SUITE_END();

+

+ public:

+ void setUp() {

+ ownerJID = JID("owner@domain.com/theowner");

+ stanzaChannel = boost::make_shared<DummyStanzaChannel>();

+ iqRouter = boost::make_shared<IQRouter>(stanzaChannel.get());

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

+ vcardStorage = boost::make_shared<VCardMemoryStorage>(crypto.get());

+ vcardManager = boost::make_shared<VCardManager>(ownerJID, iqRouter.get(), vcardStorage.get());

+ avatarStorage = boost::make_shared<AvatarMemoryStorage>();

+ mucRegistry = boost::make_shared<DummyMUCRegistry>();

+ avatarManager = boost::make_shared<AvatarManagerImpl>(vcardManager.get(), stanzaChannel.get(), avatarStorage.get(), crypto.get(), mucRegistry.get());

+ }

+

+ void testGetSetAvatar() {

+ /* initially we have no knowledge of the user or their avatar */

+ JID personJID("person@domain.com/theperson");

+ ByteArray avatar = avatarManager->getAvatar(personJID.toBare());

+ CPPUNIT_ASSERT(!avatar.size());

+

+ /* notify the 'owner' JID that our avatar has changed */

+

+ ByteArray fullAvatar = createByteArray("abcdefg");

+ boost::shared_ptr<VCardUpdate> vcardUpdate = boost::make_shared<VCardUpdate>();

+ vcardUpdate->setPhotoHash(Hexify::hexify(crypto->getSHA1Hash(fullAvatar)));

+ boost::shared_ptr<Presence> presence = boost::make_shared<Presence>();

+ presence->setTo(ownerJID);

+ presence->setFrom(personJID);

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

+ presence->addPayload(vcardUpdate);

+ stanzaChannel->onPresenceReceived(presence);

+

+ /* reply to the avatar request with our new avatar */

+

+ CPPUNIT_ASSERT_EQUAL(size_t(1), stanzaChannel->sentStanzas.size());

+ boost::shared_ptr<IQ> request = boost::dynamic_pointer_cast<IQ>(stanzaChannel->sentStanzas[0]);

+ stanzaChannel->sentStanzas.pop_back();

+ CPPUNIT_ASSERT(!!request);

+ boost::shared_ptr<VCard> vcard = request->getPayload<VCard>();

+ CPPUNIT_ASSERT(!!vcard);

+

+ boost::shared_ptr<IQ> reply = boost::make_shared<IQ>(IQ::Result);

+ reply->setTo(request->getFrom());

+ reply->setFrom(request->getTo());

+ reply->setID(request->getID());

+ vcard->setPhoto(fullAvatar);

+ reply->addPayload(vcard);

+ stanzaChannel->onIQReceived(reply);

+

+ /* check hash through avatarManager that it received the correct photo */

+

+ ByteArray reportedAvatar = avatarManager->getAvatar(personJID.toBare());

+ CPPUNIT_ASSERT_EQUAL(byteArrayToString(fullAvatar), byteArrayToString(reportedAvatar));

+

+ /* send new presence to notify of blank avatar */

+

+ vcardUpdate = boost::make_shared<VCardUpdate>();

+ presence = boost::make_shared<Presence>();

+ presence->setTo(ownerJID);

+ presence->setFrom(personJID);

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

+ presence->addPayload(vcardUpdate);

+ stanzaChannel->onPresenceReceived(presence);

+

+ /* reply to the avatar request with our EMPTY avatar */

+

+ CPPUNIT_ASSERT_EQUAL(size_t(1), stanzaChannel->sentStanzas.size());

+ request = boost::dynamic_pointer_cast<IQ>(stanzaChannel->sentStanzas[0]);

+ stanzaChannel->sentStanzas.pop_back();

+ CPPUNIT_ASSERT(!!request);

+ vcard = request->getPayload<VCard>();

+ CPPUNIT_ASSERT(!!vcard);

+

+ ByteArray blankAvatar = createByteArray("");

+ reply = boost::make_shared<IQ>(IQ::Result);

+ reply->setTo(request->getFrom());

+ reply->setFrom(request->getTo());

+ reply->setID(request->getID());

+ vcard->setPhoto(blankAvatar);

+ reply->addPayload(vcard);

+ stanzaChannel->onIQReceived(reply);

+

+ /* check hash through avatarManager that it received the correct photo */

+

+ reportedAvatar = avatarManager->getAvatar(personJID.toBare());

+ CPPUNIT_ASSERT_EQUAL(byteArrayToString(blankAvatar), byteArrayToString(reportedAvatar));

+ }

+

+ struct DummyMUCRegistry : public MUCRegistry {

+ bool isMUC(const JID& jid) const { return std::find(mucs_.begin(), mucs_.end(), jid) != mucs_.end(); }

+ std::vector<JID> mucs_;

+ };

+

+ private:

+

+ JID ownerJID;

+ boost::shared_ptr<DummyStanzaChannel> stanzaChannel;

+ boost::shared_ptr<IQRouter> iqRouter;

+ boost::shared_ptr<CryptoProvider> crypto;

+ boost::shared_ptr<VCardMemoryStorage> vcardStorage;

+ boost::shared_ptr<VCardManager> vcardManager;

+ boost::shared_ptr<AvatarMemoryStorage> avatarStorage;

+ boost::shared_ptr<DummyMUCRegistry> mucRegistry;

+ boost::shared_ptr<AvatarManagerImpl> avatarManager;

+ CPPUNIT_TEST_SUITE(CombinedAvatarProviderTest);

+ CPPUNIT_TEST(testGetAvatarWithNoAvatarProviderReturnsEmpty);

+ CPPUNIT_TEST(testGetAvatarWithSingleAvatarProvider);

+ CPPUNIT_TEST(testGetAvatarWithMultipleAvatarProviderReturnsFirstAvatar);

+ CPPUNIT_TEST(testGetAvatarWithMultipleAvatarProviderAndFailingFirstProviderReturnsSecondAvatar);

+ CPPUNIT_TEST(testProviderUpdateTriggersChange);

+ CPPUNIT_TEST(testProviderUpdateWithoutChangeDoesNotTriggerChange);

+ CPPUNIT_TEST(testProviderSecondUpdateTriggersChange);

+ CPPUNIT_TEST(testProviderUpdateWithAvatarDisappearingTriggersChange);

+ CPPUNIT_TEST(testProviderUpdateAfterAvatarDisappearedTriggersChange);

+ CPPUNIT_TEST(testProviderUpdateAfterGetDoesNotTriggerChange);

+ CPPUNIT_TEST(testProviderUpdateBareJIDAfterGetFullJID);

+ CPPUNIT_TEST(testRemoveProviderDisconnectsUpdates);

+ CPPUNIT_TEST(testAddRemoveFallthrough);

+ CPPUNIT_TEST_SUITE_END();

+

+ public:

+ void setUp() {

+ avatarProvider1 = new DummyAvatarProvider();

+ avatarProvider2 = new DummyAvatarProvider();

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

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

+ avatarHash1 = "ABCDEFG";

+ avatarHash2 = "XYZU";

+ avatarHash3 = "IDGH";

+ }

+

+ void tearDown() {

+ delete avatarProvider1;

+ delete avatarProvider2;

+ }

+

+ void testGetAvatarWithNoAvatarProviderReturnsEmpty() {

+ boost::shared_ptr<CombinedAvatarProvider> testling(createProvider());

+

+ boost::optional<std::string> hash = testling->getAvatarHash(user1);

+ CPPUNIT_ASSERT(!hash);

+ }

+

+ void testGetAvatarWithSingleAvatarProvider() {

+ boost::shared_ptr<CombinedAvatarProvider> testling(createProvider());

+ avatarProvider1->avatars[user1] = avatarHash1;

+ testling->addProvider(avatarProvider1);

+

+ boost::optional<std::string> hash = testling->getAvatarHash(user1);

+ CPPUNIT_ASSERT(hash);

+ CPPUNIT_ASSERT_EQUAL(avatarHash1, *hash);

+ }

+

+ void testGetAvatarWithMultipleAvatarProviderReturnsFirstAvatar() {

+ boost::shared_ptr<CombinedAvatarProvider> testling(createProvider());

+ avatarProvider1->avatars[user1] = avatarHash1;

+ avatarProvider2->avatars[user1] = avatarHash2;

+ testling->addProvider(avatarProvider1);

+ testling->addProvider(avatarProvider2);

+

+ boost::optional<std::string> hash = testling->getAvatarHash(user1);

+ CPPUNIT_ASSERT(hash);

+ CPPUNIT_ASSERT_EQUAL(avatarHash1, *hash);

+ }

+

+ void testGetAvatarWithMultipleAvatarProviderAndFailingFirstProviderReturnsSecondAvatar() {

+ boost::shared_ptr<CombinedAvatarProvider> testling(createProvider());

+ avatarProvider2->avatars[user1] = avatarHash2;

+ testling->addProvider(avatarProvider1);

+ testling->addProvider(avatarProvider2);

+

+ boost::optional<std::string> hash = testling->getAvatarHash(user1);

+ CPPUNIT_ASSERT(hash);

+ CPPUNIT_ASSERT_EQUAL(avatarHash2, *hash);

+ }

+

+ void testProviderUpdateTriggersChange() {

+ boost::shared_ptr<CombinedAvatarProvider> testling(createProvider());

+ testling->addProvider(avatarProvider1);

+ avatarProvider1->avatars[user1] = avatarHash1;

+ avatarProvider1->onAvatarChanged(user1);

+

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

+ CPPUNIT_ASSERT_EQUAL(user1, changes[0]);

+ }

+

+ void testProviderUpdateWithoutChangeDoesNotTriggerChange() {

+ boost::shared_ptr<CombinedAvatarProvider> testling(createProvider());

+ testling->addProvider(avatarProvider1);

+ testling->addProvider(avatarProvider2);

+ avatarProvider1->avatars[user1] = avatarHash1;

+ avatarProvider1->onAvatarChanged(user1);

+ changes.clear();

+

+ avatarProvider2->avatars[user1] = avatarHash2;

+ avatarProvider2->onAvatarChanged(user1);

+

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

+ }

+

+ void testProviderSecondUpdateTriggersChange() {

+ boost::shared_ptr<CombinedAvatarProvider> testling(createProvider());

+ testling->addProvider(avatarProvider1);

+ avatarProvider1->avatars[user1] = avatarHash1;

+ avatarProvider1->onAvatarChanged(user1);

+ changes.clear();

+ avatarProvider1->avatars[user1] = avatarHash2;

+ avatarProvider1->onAvatarChanged(user1);

+

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

+ CPPUNIT_ASSERT_EQUAL(user1, changes[0]);

+ }

+

+

+ void testProviderUpdateWithAvatarDisappearingTriggersChange() {

+ boost::shared_ptr<CombinedAvatarProvider> testling(createProvider());

+ testling->addProvider(avatarProvider1);

+ avatarProvider1->avatars[user1] = avatarHash1;

+ avatarProvider1->onAvatarChanged(user1);

+ changes.clear();

+ avatarProvider1->avatars.clear();

+ avatarProvider1->onAvatarChanged(user1);

+

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

+ CPPUNIT_ASSERT_EQUAL(user1, changes[0]);

+ }

+

+ void testProviderUpdateAfterAvatarDisappearedTriggersChange() {

+ boost::shared_ptr<CombinedAvatarProvider> testling(createProvider());

+ testling->addProvider(avatarProvider1);

+ avatarProvider1->avatars[user1] = avatarHash1;

+ avatarProvider1->onAvatarChanged(user1);

+ avatarProvider1->avatars.clear();

+ avatarProvider1->onAvatarChanged(user1);

+ changes.clear();

+ avatarProvider1->avatars[user1] = avatarHash1;

+ avatarProvider1->onAvatarChanged(user1);

+

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

+ CPPUNIT_ASSERT_EQUAL(user1, changes[0]);

+ }

+

+

+ void testProviderUpdateAfterGetDoesNotTriggerChange() {

+ boost::shared_ptr<CombinedAvatarProvider> testling(createProvider());

+ testling->addProvider(avatarProvider1);

+ avatarProvider1->avatars[user1] = avatarHash1;

+

+ testling->getAvatarHash(user1);

+ avatarProvider1->onAvatarChanged(user1);

+

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

+ }

+

+ void testRemoveProviderDisconnectsUpdates() {

+ boost::shared_ptr<CombinedAvatarProvider> testling(createProvider());

+ testling->addProvider(avatarProvider1);

+ testling->addProvider(avatarProvider2);

+ testling->removeProvider(avatarProvider1);

+ avatarProvider1->avatars[user1] = avatarHash1;

+ avatarProvider2->avatars[user1] = avatarHash2;

+ avatarProvider1->onAvatarChanged(user1);

+

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

+ }

+

+ void testProviderUpdateBareJIDAfterGetFullJID() {

+ boost::shared_ptr<CombinedAvatarProvider> testling(createProvider());

+ avatarProvider1->useBare = true;

+ testling->addProvider(avatarProvider1);

+

+ avatarProvider1->avatars[user1.toBare()] = avatarHash1;

+ testling->getAvatarHash(user1);

+ avatarProvider1->avatars[user1.toBare()] = avatarHash2;

+ avatarProvider1->onAvatarChanged(user1.toBare());

+

+ boost::optional<std::string> hash = testling->getAvatarHash(user1);

+ CPPUNIT_ASSERT(hash);

+ CPPUNIT_ASSERT_EQUAL(avatarHash2, *hash);

+ }

+

+ void testAddRemoveFallthrough() {

+ JID ownJID = JID("user0@own.com/res");

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

+

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

+ DummyStanzaChannel* stanzaChannel = new DummyStanzaChannel();

+ stanzaChannel->setAvailable(true);

+ IQRouter* iqRouter = new IQRouter(stanzaChannel);

+ DummyMUCRegistry* mucRegistry = new DummyMUCRegistry();

+ AvatarMemoryStorage* avatarStorage = new AvatarMemoryStorage();

+ VCardMemoryStorage* vcardStorage = new VCardMemoryStorage(crypto.get());

+ VCardManager* vcardManager = new VCardManager(ownJID, iqRouter, vcardStorage);

+

+ boost::shared_ptr<VCardUpdateAvatarManager> updateManager(new VCardUpdateAvatarManager(vcardManager, stanzaChannel, avatarStorage, crypto.get(), mucRegistry));

+ updateManager->onAvatarChanged.connect(boost::bind(&CombinedAvatarProviderTest::handleAvatarChanged, this, _1));

+

+ boost::shared_ptr<VCardAvatarManager> manager(new VCardAvatarManager(vcardManager, avatarStorage, crypto.get(), mucRegistry));

+ manager->onAvatarChanged.connect(boost::bind(&CombinedAvatarProviderTest::handleAvatarChanged, this, _1));

+

+ boost::shared_ptr<OfflineAvatarManager> offlineManager(new OfflineAvatarManager(avatarStorage));

+ offlineManager->onAvatarChanged.connect(boost::bind(&CombinedAvatarProviderTest::handleAvatarChanged, this, _1));

+

+ boost::shared_ptr<CombinedAvatarProvider> testling(createProvider());

+ avatarProvider1->useBare = true;

+ testling->addProvider(updateManager.get());

+ testling->addProvider(manager.get());

+ testling->addProvider(offlineManager.get());

+

+ /* place an avatar in the cache, check that it reads back OK */

+

+ CPPUNIT_ASSERT_EQUAL(size_t(0), changes.size());

+

+ ByteArray avatar1 = createByteArray("abcdefg");

+ std::string avatar1Hash = Hexify::hexify(crypto->getSHA1Hash(avatar1));

+ VCard::ref vcard1(new VCard());

+ vcard1->setPhoto(avatar1);

+

+ vcardStorage->setVCard(user1.toBare(), vcard1);

+ boost::optional<std::string> testHash = testling->getAvatarHash(user1.toBare());

+ CPPUNIT_ASSERT(testHash);

+ CPPUNIT_ASSERT_EQUAL(avatar1Hash, *testHash);

+

+ VCard::ref storedVCard = vcardStorage->getVCard(user1.toBare());

+ CPPUNIT_ASSERT(!!storedVCard);

+ testHash = Hexify::hexify(crypto->getSHA1Hash(storedVCard->getPhoto()));

+ CPPUNIT_ASSERT_EQUAL(avatar1Hash, *testHash);

+

+ /* change the avatar by sending an VCard IQ */

+

+ vcardManager->requestVCard(user1.toBare());

+ CPPUNIT_ASSERT_EQUAL(size_t(1), stanzaChannel->sentStanzas.size());

+ IQ::ref request = boost::dynamic_pointer_cast<IQ>(stanzaChannel->sentStanzas.back());

+ VCard::ref payload = request->getPayload<VCard>();

+ CPPUNIT_ASSERT(!!payload);

+ stanzaChannel->sentStanzas.pop_back();

+

+ ByteArray avatar2 = createByteArray("1234567");

+ std::string avatar2Hash = Hexify::hexify(crypto->getSHA1Hash(avatar2));

+ VCard::ref vcard2(new VCard());

+ vcard2->setPhoto(avatar2);

+

+ IQ::ref reply = boost::make_shared<IQ>();

+ reply->setTo(request->getFrom());

+ reply->setFrom(request->getTo());

+ reply->setID(request->getID());

+ reply->addPayload(vcard2);

+ reply->setType(IQ::Result);

+

+ stanzaChannel->onIQReceived(reply);

+

+ /* check that we changed the avatar successfully and that we were notified about the changes */

+

+ testHash = testling->getAvatarHash(user1.toBare());

+ CPPUNIT_ASSERT(testHash);

+ CPPUNIT_ASSERT_EQUAL(avatar2Hash, *testHash);

+ CPPUNIT_ASSERT_EQUAL(size_t(3), changes.size());

+ CPPUNIT_ASSERT_EQUAL(user1.toBare(), changes[0]);

+ CPPUNIT_ASSERT_EQUAL(user1.toBare(), changes[1]);

+ CPPUNIT_ASSERT_EQUAL(user1.toBare(), changes[2]);

+ changes.clear();

+ storedVCard = vcardStorage->getVCard(user1.toBare());

+ CPPUNIT_ASSERT(!!storedVCard);

+ testHash = Hexify::hexify(crypto->getSHA1Hash(storedVCard->getPhoto()));

+ CPPUNIT_ASSERT_EQUAL(avatar2Hash, *testHash);

+

+ /* change the avatar to the empty avatar */

+

+ vcardManager->requestVCard(user1.toBare());

+ CPPUNIT_ASSERT_EQUAL(size_t(1), stanzaChannel->sentStanzas.size());

+ request = boost::dynamic_pointer_cast<IQ>(stanzaChannel->sentStanzas.back());

+ payload = request->getPayload<VCard>();

+ CPPUNIT_ASSERT(!!payload);

+ stanzaChannel->sentStanzas.pop_back();

+

+ VCard::ref vcard3(new VCard());

+ reply = boost::make_shared<IQ>();

+ reply->setTo(request->getFrom());

+ reply->setFrom(request->getTo());

+ reply->setID(request->getID());

+ reply->addPayload(vcard3);

+ reply->setType(IQ::Result);

+ stanzaChannel->onIQReceived(reply);

+

+ /* check that we changed the avatar successfully */

+

+ testHash = testling->getAvatarHash(user1.toBare());

+ CPPUNIT_ASSERT(testHash);

+ CPPUNIT_ASSERT_EQUAL(std::string(""), *testHash);

+ CPPUNIT_ASSERT_EQUAL(size_t(3), changes.size());

+ CPPUNIT_ASSERT_EQUAL(user1.toBare(), changes[0]);

+ CPPUNIT_ASSERT_EQUAL(user1.toBare(), changes[1]);

+ CPPUNIT_ASSERT_EQUAL(user1.toBare(), changes[2]);

+ changes.clear();

+ storedVCard = vcardStorage->getVCard(user1.toBare());

+ CPPUNIT_ASSERT(!!storedVCard);

+ CPPUNIT_ASSERT(!storedVCard->getPhoto().size());

+

+ delete vcardManager;

+ delete vcardStorage;

+ delete mucRegistry;

+ delete iqRouter;

+ delete stanzaChannel;

+ }

+

+ private:

+ boost::shared_ptr<CombinedAvatarProvider> createProvider() {

+ boost::shared_ptr<CombinedAvatarProvider> result(new CombinedAvatarProvider());

+ result->onAvatarChanged.connect(boost::bind(&CombinedAvatarProviderTest::handleAvatarChanged, this, _1));

+ return result;

+ }

+

+ void handleAvatarChanged(const JID& jid) {

+ changes.push_back(jid);

+ }

+

+ private:

+ struct DummyAvatarProvider : public AvatarProvider {

+ DummyAvatarProvider() : useBare(false) {

+ }

+

+ boost::optional<std::string> getAvatarHash(const JID& jid) const {

+ JID actualJID = useBare ? jid.toBare() : jid;

+ std::map<JID, std::string>::const_iterator i = avatars.find(actualJID);

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

+ return i->second;

+ }

+ else {

+ return boost::optional<std::string>();

+ }

+ }

+

+ bool useBare;

+ std::map<JID, std::string> avatars;

+ };

+

+ struct DummyMUCRegistry : public MUCRegistry {

+ bool isMUC(const JID& jid) const { return std::find(mucs_.begin(), mucs_.end(), jid) != mucs_.end(); }

+ std::vector<JID> mucs_;

+ };

+

+ DummyAvatarProvider* avatarProvider1;

+ DummyAvatarProvider* avatarProvider2;

+ JID user1;

+ JID user2;

+ std::string avatarHash1;

+ std::string avatarHash2;

+ std::string avatarHash3;

+ std::vector<JID> changes;

+ CPPUNIT_TEST_SUITE(VCardAvatarManagerTest);

+ CPPUNIT_TEST(testGetAvatarHashKnownAvatar);

+ CPPUNIT_TEST(testGetAvatarHashEmptyAvatar);

+ CPPUNIT_TEST(testGetAvatarHashUnknownAvatarKnownVCardStoresAvatar);

+ CPPUNIT_TEST(testGetAvatarHashUnknownAvatarUnknownVCard);

+ CPPUNIT_TEST(testVCardUpdateTriggersUpdate);

+ CPPUNIT_TEST(testGetAvatarHashKnownAvatarUnknownVCard);

+ CPPUNIT_TEST_SUITE_END();

+

+ public:

+ void setUp() {

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

+ ownJID = JID("foo@fum.com/bum");

+ stanzaChannel = new DummyStanzaChannel();

+ stanzaChannel->setAvailable(true);

+ iqRouter = new IQRouter(stanzaChannel);

+ mucRegistry = new DummyMUCRegistry();

+ avatarStorage = new AvatarMemoryStorage();

+ vcardStorage = new VCardMemoryStorage(crypto.get());

+ vcardManager = new VCardManager(ownJID, iqRouter, vcardStorage);

+ avatar1 = createByteArray("abcdefg");

+ avatar1Hash = Hexify::hexify(crypto->getSHA1Hash(avatar1));

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

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

+ }

+

+ void tearDown() {

+ delete vcardManager;

+ delete vcardStorage;

+ delete avatarStorage;

+ delete mucRegistry;

+ delete iqRouter;

+ delete stanzaChannel;

+ }

+

+ void testGetAvatarHashKnownAvatar() {

+ boost::shared_ptr<VCardAvatarManager> testling = createManager();

+ storeVCardWithPhoto(user1.toBare(), avatar1);

+ avatarStorage->addAvatar(avatar1Hash, avatar1);

+

+ boost::optional<std::string> result = testling->getAvatarHash(user1);

+

+ CPPUNIT_ASSERT(result);

+ CPPUNIT_ASSERT_EQUAL(avatar1Hash, *result);

+ }

+

+ void testGetAvatarHashEmptyAvatar() {

+ boost::shared_ptr<VCardAvatarManager> testling = createManager();

+ storeEmptyVCard(user1.toBare());

+

+ boost::optional<std::string> result = testling->getAvatarHash(user1);

+

+ CPPUNIT_ASSERT(result);

+ CPPUNIT_ASSERT_EQUAL(std::string(), *result);

+ }

+

+ void testGetAvatarHashUnknownAvatarKnownVCardStoresAvatar() {

+ boost::shared_ptr<VCardAvatarManager> testling = createManager();

+ storeVCardWithPhoto(user1.toBare(), avatar1);

+

+ boost::optional<std::string> result = testling->getAvatarHash(user1);

+

+ CPPUNIT_ASSERT(result);

+ CPPUNIT_ASSERT_EQUAL(avatar1Hash, *result);

+ CPPUNIT_ASSERT(avatarStorage->hasAvatar(avatar1Hash));

+ CPPUNIT_ASSERT_EQUAL(avatar1, avatarStorage->getAvatar(avatar1Hash));

+ }

+

+ void testGetAvatarHashUnknownAvatarUnknownVCard() {

+ boost::shared_ptr<VCardAvatarManager> testling = createManager();

+

+ boost::optional<std::string> result = testling->getAvatarHash(user1);

+

+ CPPUNIT_ASSERT(result);

+ CPPUNIT_ASSERT_EQUAL(std::string(), *result);

+ }

+

+ void testGetAvatarHashKnownAvatarUnknownVCard() {

+ boost::shared_ptr<VCardAvatarManager> testling = createManager();

+

+ avatarStorage->setAvatarForJID(user1, avatar1Hash);

+

+ boost::optional<std::string> result = testling->getAvatarHash(user1);

+

+ CPPUNIT_ASSERT(result);

+ CPPUNIT_ASSERT_EQUAL(std::string(), *result);

+ }

+

+

+ void testVCardUpdateTriggersUpdate() {

+ boost::shared_ptr<VCardAvatarManager> testling = createManager();

+ vcardManager->requestVCard(user1);

+ sendVCardResult();

+

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

+ }

+

+ private:

+ boost::shared_ptr<VCardAvatarManager> createManager() {

+ boost::shared_ptr<VCardAvatarManager> result(new VCardAvatarManager(vcardManager, avatarStorage, crypto.get(), mucRegistry));

+ result->onAvatarChanged.connect(boost::bind(&VCardAvatarManagerTest::handleAvatarChanged, this, _1));

+ return result;

+ }

+

+ void storeVCardWithPhoto(const JID& jid, const ByteArray& avatar) {

+ VCard::ref vcard(new VCard());

+ vcard->setPhoto(avatar);

+ vcardStorage->setVCard(jid, vcard);

+ }

+

+ void storeEmptyVCard(const JID& jid) {

+ VCard::ref vcard(new VCard());

+ vcardStorage->setVCard(jid, vcard);

+ }

+

+ void handleAvatarChanged(const JID& jid) {

+ changes.push_back(jid);

+ }

+

+ void sendVCardResult() {

+ VCard::ref vcard(new VCard());

+ vcard->setFullName("Foo Bar");

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

+ }

+

+ private:

+ struct DummyMUCRegistry : public MUCRegistry {

+ bool isMUC(const JID& jid) const { return std::find(mucs_.begin(), mucs_.end(), jid) != mucs_.end(); }

+ std::vector<JID> mucs_;

+ };

+

+ JID ownJID;

+ DummyStanzaChannel* stanzaChannel;

+ IQRouter* iqRouter;

+ DummyMUCRegistry* mucRegistry;

+ AvatarMemoryStorage* avatarStorage;

+ VCardManager* vcardManager;

+ VCardMemoryStorage* vcardStorage;

+ ByteArray avatar1;

+ std::string avatar1Hash;

+ std::vector<JID> changes;

+ JID user1;

+ JID user2;

+ boost::shared_ptr<CryptoProvider> crypto;

+ CPPUNIT_TEST_SUITE(VCardUpdateAvatarManagerTest);

+ CPPUNIT_TEST(testUpdate_NewHashNewVCardRequestsVCard);

+ CPPUNIT_TEST(testUpdate_NewHashStoresAvatarAndEmitsNotificationOnVCardReceive);

+ CPPUNIT_TEST(testUpdate_KnownHash);

+ CPPUNIT_TEST(testUpdate_KnownHashFromDifferentUserDoesNotRequestVCardButTriggersNotification);

+ CPPUNIT_TEST(testVCardWithEmptyPhoto);

+ CPPUNIT_TEST(testStanzaChannelReset_ClearsHash);

+ CPPUNIT_TEST(testStanzaChannelReset_ReceiveHashAfterResetUpdatesHash);

+ CPPUNIT_TEST_SUITE_END();

+

+ public:

+ void setUp() {

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

+ ownJID = JID("foo@fum.com/bum");

+ stanzaChannel = new DummyStanzaChannel();

+ stanzaChannel->setAvailable(true);

+ iqRouter = new IQRouter(stanzaChannel);

+ mucRegistry = new DummyMUCRegistry();

+ avatarStorage = new AvatarMemoryStorage();

+ vcardStorage = new VCardMemoryStorage(crypto.get());

+ vcardManager = new VCardManager(ownJID, iqRouter, vcardStorage);

+ avatar1 = createByteArray("abcdefg");

+ avatar1Hash = Hexify::hexify(crypto->getSHA1Hash(avatar1));

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

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

+ }

+

+

+ void tearDown() {

+ delete vcardManager;

+ delete vcardStorage;

+ delete avatarStorage;

+ delete mucRegistry;

+ delete iqRouter;

+ delete stanzaChannel;

+ }

+

+ void testUpdate_NewHashNewVCardRequestsVCard() {

+ boost::shared_ptr<VCardUpdateAvatarManager> testling = createManager();

+ stanzaChannel->onPresenceReceived(createPresenceWithPhotoHash(user1, avatar1Hash));

+

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

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

+ }

+

+ void testUpdate_NewHashStoresAvatarAndEmitsNotificationOnVCardReceive() {

+ boost::shared_ptr<VCardUpdateAvatarManager> testling = createManager();

+ stanzaChannel->onPresenceReceived(createPresenceWithPhotoHash(user1, avatar1Hash));

+ stanzaChannel->onIQReceived(createVCardResult(avatar1));

+

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

+ CPPUNIT_ASSERT_EQUAL(user1.toBare(), changes[0]);

+ boost::optional<std::string> hash = testling->getAvatarHash(user1.toBare());

+ CPPUNIT_ASSERT(hash);

+ CPPUNIT_ASSERT_EQUAL(avatar1Hash, *hash);

+ CPPUNIT_ASSERT(avatarStorage->hasAvatar(avatar1Hash));

+ CPPUNIT_ASSERT_EQUAL(avatar1, avatarStorage->getAvatar(avatar1Hash));

+ }

+

+ void testUpdate_KnownHash() {

+ boost::shared_ptr<VCardUpdateAvatarManager> testling = createManager();

+ stanzaChannel->onPresenceReceived(createPresenceWithPhotoHash(user1, avatar1Hash));

+ stanzaChannel->onIQReceived(createVCardResult(avatar1));

+ changes.clear();

+ stanzaChannel->sentStanzas.clear();

+

+ stanzaChannel->onPresenceReceived(createPresenceWithPhotoHash(user1, avatar1Hash));

+

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

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

+ }

+

+ void testUpdate_KnownHashFromDifferentUserDoesNotRequestVCardButTriggersNotification() {

+ boost::shared_ptr<VCardUpdateAvatarManager> testling = createManager();

+ stanzaChannel->onPresenceReceived(createPresenceWithPhotoHash(user1, avatar1Hash));

+ stanzaChannel->onIQReceived(createVCardResult(avatar1));

+ changes.clear();

+ stanzaChannel->sentStanzas.clear();

+

+ stanzaChannel->onPresenceReceived(createPresenceWithPhotoHash(user2, avatar1Hash));

+

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

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

+ CPPUNIT_ASSERT_EQUAL(user2.toBare(), changes[0]);

+ boost::optional<std::string> hash = testling->getAvatarHash(user2.toBare());

+ CPPUNIT_ASSERT(hash);

+ CPPUNIT_ASSERT_EQUAL(avatar1Hash, *hash);

+ }

+

+ void testVCardWithEmptyPhoto() {

+ boost::shared_ptr<VCardUpdateAvatarManager> testling = createManager();

+ vcardManager->requestVCard(JID("foo@bar.com"));

+ stanzaChannel->onIQReceived(createVCardResult(ByteArray()));

+

+ CPPUNIT_ASSERT(!avatarStorage->hasAvatar(Hexify::hexify(crypto->getSHA1Hash(ByteArray()))));

+ boost::optional<std::string> hash = testling->getAvatarHash(JID("foo@bar.com"));

+ CPPUNIT_ASSERT(hash);

+ CPPUNIT_ASSERT_EQUAL(std::string(), *hash);

+ }

+

+ void testStanzaChannelReset_ClearsHash() {

+ boost::shared_ptr<VCardUpdateAvatarManager> testling = createManager();

+ stanzaChannel->onPresenceReceived(createPresenceWithPhotoHash(user1, avatar1Hash));

+ stanzaChannel->onIQReceived(createVCardResult(avatar1));

+ changes.clear();

+ stanzaChannel->sentStanzas.clear();

+

+ stanzaChannel->setAvailable(false);

+ stanzaChannel->setAvailable(true);

+

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

+ CPPUNIT_ASSERT_EQUAL(user1.toBare(), changes[0]);

+ boost::optional<std::string> hash = testling->getAvatarHash(user1.toBare());

+ CPPUNIT_ASSERT(!hash);

+ //CPPUNIT_ASSERT_EQUAL(std::string(""), *hash);

+ }

+

+ void testStanzaChannelReset_ReceiveHashAfterResetUpdatesHash() {

+ boost::shared_ptr<VCardUpdateAvatarManager> testling = createManager();

+ stanzaChannel->onPresenceReceived(createPresenceWithPhotoHash(user1, avatar1Hash));

+ stanzaChannel->onIQReceived(createVCardResult(avatar1));

+ changes.clear();

+ stanzaChannel->sentStanzas.clear();

+

+ stanzaChannel->setAvailable(false);

+ stanzaChannel->setAvailable(true);

+ stanzaChannel->onPresenceReceived(createPresenceWithPhotoHash(user1, avatar1Hash));

+

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

+ CPPUNIT_ASSERT_EQUAL(user1.toBare(), changes[1]);

+ boost::optional<std::string> hash = testling->getAvatarHash(user1.toBare());

+ CPPUNIT_ASSERT(hash);

+ CPPUNIT_ASSERT_EQUAL(avatar1Hash, *hash);

+ }

+

+ private:

+ boost::shared_ptr<VCardUpdateAvatarManager> createManager() {

+ boost::shared_ptr<VCardUpdateAvatarManager> result(new VCardUpdateAvatarManager(vcardManager, stanzaChannel, avatarStorage, crypto.get(), mucRegistry));

+ result->onAvatarChanged.connect(boost::bind(&VCardUpdateAvatarManagerTest::handleAvatarChanged, this, _1));

+ return result;

+ }

+

+ boost::shared_ptr<Presence> createPresenceWithPhotoHash(const JID& jid, const std::string& hash) {

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

+ presence->setFrom(jid);

+ presence->addPayload(boost::make_shared<VCardUpdate>(hash));

+ return presence;

+ }

+

+ IQ::ref createVCardResult(const ByteArray& avatar) {

+ VCard::ref vcard(new VCard());

+ if (!avatar.empty()) {

+ vcard->setPhoto(avatar);

+ }

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

+ }

+

+ void handleAvatarChanged(const JID& jid) {

+ changes.push_back(jid);

+ }

+

+ private:

+ struct DummyMUCRegistry : public MUCRegistry {

+ bool isMUC(const JID& jid) const { return std::find(mucs_.begin(), mucs_.end(), jid) != mucs_.end(); }

+ std::vector<JID> mucs_;

+ };

+

+ JID ownJID;

+ DummyStanzaChannel* stanzaChannel;

+ IQRouter* iqRouter;

+ DummyMUCRegistry* mucRegistry;

+ AvatarMemoryStorage* avatarStorage;

+ VCardManager* vcardManager;

+ VCardMemoryStorage* vcardStorage;

+ ByteArray avatar1;

+ std::string avatar1Hash;

+ std::vector<JID> changes;

+ JID user1;

+ JID user2;

+ boost::shared_ptr<CryptoProvider> crypto;