| /* |
| * Copyright 2004 The WebRTC Project Authors. All rights reserved. |
| * |
| * Use of this source code is governed by a BSD-style license |
| * that can be found in the LICENSE file in the root of the source |
| * tree. An additional intellectual property rights grant can be found |
| * in the file PATENTS. All contributing project authors may |
| * be found in the AUTHORS file in the root of the source tree. |
| */ |
| |
| #include <iostream> |
| #include <memory> |
| #include <sstream> |
| #include <string> |
| |
| #include "webrtc/libjingle/xmllite/xmlelement.h" |
| #include "webrtc/libjingle/xmpp/constants.h" |
| #include "webrtc/libjingle/xmpp/rostermodule.h" |
| #include "webrtc/libjingle/xmpp/util_unittest.h" |
| #include "webrtc/libjingle/xmpp/xmppengine.h" |
| #include "webrtc/base/gunit.h" |
| |
| #define TEST_OK(x) EXPECT_EQ((x),XMPP_RETURN_OK) |
| #define TEST_BADARGUMENT(x) EXPECT_EQ((x),XMPP_RETURN_BADARGUMENT) |
| |
| |
| namespace buzz { |
| |
| class RosterModuleTest; |
| |
| static void |
| WriteString(std::ostream& os, const std::string& str) { |
| os<<str; |
| } |
| |
| static void |
| WriteSubscriptionState(std::ostream& os, XmppSubscriptionState state) |
| { |
| switch (state) { |
| case XMPP_SUBSCRIPTION_NONE: |
| os<<"none"; |
| break; |
| case XMPP_SUBSCRIPTION_NONE_ASKED: |
| os<<"none_asked"; |
| break; |
| case XMPP_SUBSCRIPTION_TO: |
| os<<"to"; |
| break; |
| case XMPP_SUBSCRIPTION_FROM: |
| os<<"from"; |
| break; |
| case XMPP_SUBSCRIPTION_FROM_ASKED: |
| os<<"from_asked"; |
| break; |
| case XMPP_SUBSCRIPTION_BOTH: |
| os<<"both"; |
| break; |
| default: |
| os<<"unknown"; |
| break; |
| } |
| } |
| |
| static void |
| WriteSubscriptionRequestType(std::ostream& os, |
| XmppSubscriptionRequestType type) { |
| switch(type) { |
| case XMPP_REQUEST_SUBSCRIBE: |
| os<<"subscribe"; |
| break; |
| case XMPP_REQUEST_UNSUBSCRIBE: |
| os<<"unsubscribe"; |
| break; |
| case XMPP_REQUEST_SUBSCRIBED: |
| os<<"subscribed"; |
| break; |
| case XMPP_REQUEST_UNSUBSCRIBED: |
| os<<"unsubscribe"; |
| break; |
| default: |
| os<<"unknown"; |
| break; |
| } |
| } |
| |
| static void |
| WritePresenceShow(std::ostream& os, XmppPresenceShow show) { |
| switch(show) { |
| case XMPP_PRESENCE_AWAY: |
| os<<"away"; |
| break; |
| case XMPP_PRESENCE_CHAT: |
| os<<"chat"; |
| break; |
| case XMPP_PRESENCE_DND: |
| os<<"dnd"; |
| break; |
| case XMPP_PRESENCE_XA: |
| os<<"xa"; |
| break; |
| case XMPP_PRESENCE_DEFAULT: |
| os<<"[default]"; |
| break; |
| default: |
| os<<"[unknown]"; |
| break; |
| } |
| } |
| |
| static void |
| WritePresence(std::ostream& os, const XmppPresence* presence) { |
| if (presence == NULL) { |
| os<<"NULL"; |
| return; |
| } |
| |
| os<<"[Presence jid:"; |
| WriteString(os, presence->jid().Str()); |
| os<<" available:"<<presence->available(); |
| os<<" presence_show:"; |
| WritePresenceShow(os, presence->presence_show()); |
| os<<" priority:"<<presence->priority(); |
| os<<" status:"; |
| WriteString(os, presence->status()); |
| os<<"]"<<presence->raw_xml()->Str(); |
| } |
| |
| static void |
| WriteContact(std::ostream& os, const XmppRosterContact* contact) { |
| if (contact == NULL) { |
| os<<"NULL"; |
| return; |
| } |
| |
| os<<"[Contact jid:"; |
| WriteString(os, contact->jid().Str()); |
| os<<" name:"; |
| WriteString(os, contact->name()); |
| os<<" subscription_state:"; |
| WriteSubscriptionState(os, contact->subscription_state()); |
| os<<" groups:["; |
| for(size_t i=0; i < contact->GetGroupCount(); ++i) { |
| os<<(i==0?"":", "); |
| WriteString(os, contact->GetGroup(i)); |
| } |
| os<<"]]"<<contact->raw_xml()->Str(); |
| } |
| |
| //! This session handler saves all calls to a string. These are events and |
| //! data delivered form the engine to application code. |
| class XmppTestRosterHandler : public XmppRosterHandler { |
| public: |
| XmppTestRosterHandler() {} |
| virtual ~XmppTestRosterHandler() {} |
| |
| virtual void SubscriptionRequest(XmppRosterModule*, |
| const Jid& requesting_jid, |
| XmppSubscriptionRequestType type, |
| const XmlElement* raw_xml) { |
| ss_<<"[SubscriptionRequest Jid:" << requesting_jid.Str()<<" type:"; |
| WriteSubscriptionRequestType(ss_, type); |
| ss_<<"]"<<raw_xml->Str(); |
| } |
| |
| //! Some type of presence error has occured |
| virtual void SubscriptionError(XmppRosterModule*, |
| const Jid& from, |
| const XmlElement* raw_xml) { |
| ss_<<"[SubscriptionError from:"<<from.Str()<<"]"<<raw_xml->Str(); |
| } |
| |
| virtual void RosterError(XmppRosterModule*, |
| const XmlElement* raw_xml) { |
| ss_<<"[RosterError]"<<raw_xml->Str(); |
| } |
| |
| //! New presence information has come in |
| //! The user is notified with the presence object directly. This info is also |
| //! added to the store accessable from the engine. |
| virtual void IncomingPresenceChanged(XmppRosterModule*, |
| const XmppPresence* presence) { |
| ss_<<"[IncomingPresenceChanged presence:"; |
| WritePresence(ss_, presence); |
| ss_<<"]"; |
| } |
| |
| //! A contact has changed |
| //! This indicates that the data for a contact may have changed. No |
| //! contacts have been added or removed. |
| virtual void ContactChanged(XmppRosterModule* roster, |
| const XmppRosterContact* old_contact, |
| size_t index) { |
| ss_<<"[ContactChanged old_contact:"; |
| WriteContact(ss_, old_contact); |
| ss_<<" index:"<<index<<" new_contact:"; |
| WriteContact(ss_, roster->GetRosterContact(index)); |
| ss_<<"]"; |
| } |
| |
| //! A set of contacts have been added |
| //! These contacts may have been added in response to the original roster |
| //! request or due to a "roster push" from the server. |
| virtual void ContactsAdded(XmppRosterModule* roster, |
| size_t index, size_t number) { |
| ss_<<"[ContactsAdded index:"<<index<<" number:"<<number; |
| for (size_t i = 0; i < number; ++i) { |
| ss_<<" "<<(index+i)<<":"; |
| WriteContact(ss_, roster->GetRosterContact(index+i)); |
| } |
| ss_<<"]"; |
| } |
| |
| //! A contact has been removed |
| //! This contact has been removed form the list. |
| virtual void ContactRemoved(XmppRosterModule*, |
| const XmppRosterContact* removed_contact, |
| size_t index) { |
| ss_<<"[ContactRemoved old_contact:"; |
| WriteContact(ss_, removed_contact); |
| ss_<<" index:"<<index<<"]"; |
| } |
| |
| std::string Str() { |
| return ss_.str(); |
| } |
| |
| std::string StrClear() { |
| std::string result = ss_.str(); |
| ss_.str(""); |
| return result; |
| } |
| |
| private: |
| std::stringstream ss_; |
| }; |
| |
| //! This is the class that holds all of the unit test code for the |
| //! roster module |
| class RosterModuleTest : public testing::Test { |
| public: |
| RosterModuleTest() {} |
| static void RunLogin(RosterModuleTest* obj, XmppEngine* engine, |
| XmppTestHandler* handler) { |
| // Needs to be similar to XmppEngineTest::RunLogin |
| } |
| }; |
| |
| TEST_F(RosterModuleTest, TestPresence) { |
| XmlElement* status = new XmlElement(QN_GOOGLE_PSTN_CONFERENCE_STATUS); |
| status->AddAttr(QN_STATUS, STR_PSTN_CONFERENCE_STATUS_CONNECTING); |
| XmlElement presence_xml(QN_PRESENCE); |
| presence_xml.AddElement(status); |
| std::unique_ptr<XmppPresence> presence(XmppPresence::Create()); |
| presence->set_raw_xml(&presence_xml); |
| EXPECT_EQ(presence->connection_status(), XMPP_CONNECTION_STATUS_CONNECTING); |
| } |
| |
| TEST_F(RosterModuleTest, TestOutgoingPresence) { |
| std::stringstream dump; |
| |
| std::unique_ptr<XmppEngine> engine(XmppEngine::Create()); |
| XmppTestHandler handler(engine.get()); |
| XmppTestRosterHandler roster_handler; |
| |
| std::unique_ptr<XmppRosterModule> roster(XmppRosterModule::Create()); |
| roster->set_roster_handler(&roster_handler); |
| |
| // Configure the roster module |
| roster->RegisterEngine(engine.get()); |
| |
| // Set up callbacks |
| engine->SetOutputHandler(&handler); |
| engine->AddStanzaHandler(&handler); |
| engine->SetSessionHandler(&handler); |
| |
| // Set up minimal login info |
| engine->SetUser(Jid("david@my-server")); |
| // engine->SetPassword("david"); |
| |
| // Do the whole login handshake |
| RunLogin(this, engine.get(), &handler); |
| EXPECT_EQ("", handler.OutputActivity()); |
| |
| // Set some presence and broadcast it |
| TEST_OK(roster->outgoing_presence()-> |
| set_available(XMPP_PRESENCE_AVAILABLE)); |
| TEST_OK(roster->outgoing_presence()->set_priority(-37)); |
| TEST_OK(roster->outgoing_presence()->set_presence_show(XMPP_PRESENCE_DND)); |
| TEST_OK(roster->outgoing_presence()-> |
| set_status("I'm off to the races!<>&")); |
| TEST_OK(roster->BroadcastPresence()); |
| |
| EXPECT_EQ(roster_handler.StrClear(), ""); |
| EXPECT_EQ(handler.OutputActivity(), |
| "<presence>" |
| "<priority>-37</priority>" |
| "<show>dnd</show>" |
| "<status>I'm off to the races!<>&</status>" |
| "</presence>"); |
| EXPECT_EQ(handler.SessionActivity(), ""); |
| |
| // Try some more |
| TEST_OK(roster->outgoing_presence()-> |
| set_available(XMPP_PRESENCE_UNAVAILABLE)); |
| TEST_OK(roster->outgoing_presence()->set_priority(0)); |
| TEST_OK(roster->outgoing_presence()->set_presence_show(XMPP_PRESENCE_XA)); |
| TEST_OK(roster->outgoing_presence()->set_status("Gone fishin'")); |
| TEST_OK(roster->BroadcastPresence()); |
| |
| EXPECT_EQ(roster_handler.StrClear(), ""); |
| EXPECT_EQ(handler.OutputActivity(), |
| "<presence type=\"unavailable\">" |
| "<show>xa</show>" |
| "<status>Gone fishin'</status>" |
| "</presence>"); |
| EXPECT_EQ(handler.SessionActivity(), ""); |
| |
| // Okay -- we are back on |
| TEST_OK(roster->outgoing_presence()-> |
| set_available(XMPP_PRESENCE_AVAILABLE)); |
| TEST_BADARGUMENT(roster->outgoing_presence()->set_priority(128)); |
| TEST_OK(roster->outgoing_presence()-> |
| set_presence_show(XMPP_PRESENCE_DEFAULT)); |
| TEST_OK(roster->outgoing_presence()->set_status("Cookin' wit gas")); |
| TEST_OK(roster->BroadcastPresence()); |
| |
| EXPECT_EQ(roster_handler.StrClear(), ""); |
| EXPECT_EQ(handler.OutputActivity(), |
| "<presence>" |
| "<status>Cookin' wit gas</status>" |
| "</presence>"); |
| EXPECT_EQ(handler.SessionActivity(), ""); |
| |
| // Set it via XML |
| XmlElement presence_input(QN_PRESENCE); |
| presence_input.AddAttr(QN_TYPE, "unavailable"); |
| presence_input.AddElement(new XmlElement(QN_PRIORITY)); |
| presence_input.AddText("42", 1); |
| presence_input.AddElement(new XmlElement(QN_STATUS)); |
| presence_input.AddAttr(QN_XML_LANG, "es", 1); |
| presence_input.AddText("Hola Amigos!", 1); |
| presence_input.AddElement(new XmlElement(QN_STATUS)); |
| presence_input.AddText("Hey there, friend!", 1); |
| TEST_OK(roster->outgoing_presence()->set_raw_xml(&presence_input)); |
| TEST_OK(roster->BroadcastPresence()); |
| |
| WritePresence(dump, roster->outgoing_presence()); |
| EXPECT_EQ(dump.str(), |
| "[Presence jid: available:0 presence_show:[default] " |
| "priority:42 status:Hey there, friend!]" |
| "<cli:presence type=\"unavailable\" xmlns:cli=\"jabber:client\">" |
| "<cli:priority>42</cli:priority>" |
| "<cli:status xml:lang=\"es\">Hola Amigos!</cli:status>" |
| "<cli:status>Hey there, friend!</cli:status>" |
| "</cli:presence>"); |
| dump.str(""); |
| EXPECT_EQ(roster_handler.StrClear(), ""); |
| EXPECT_EQ(handler.OutputActivity(), |
| "<presence type=\"unavailable\">" |
| "<priority>42</priority>" |
| "<status xml:lang=\"es\">Hola Amigos!</status>" |
| "<status>Hey there, friend!</status>" |
| "</presence>"); |
| EXPECT_EQ(handler.SessionActivity(), ""); |
| |
| // Construct a directed presence |
| std::unique_ptr<XmppPresence> directed_presence(XmppPresence::Create()); |
| TEST_OK(directed_presence->set_available(XMPP_PRESENCE_AVAILABLE)); |
| TEST_OK(directed_presence->set_priority(120)); |
| TEST_OK(directed_presence->set_status("*very* available")); |
| TEST_OK(roster->SendDirectedPresence(directed_presence.get(), |
| Jid("myhoney@honey.net"))); |
| |
| EXPECT_EQ(roster_handler.StrClear(), ""); |
| EXPECT_EQ(handler.OutputActivity(), |
| "<presence to=\"myhoney@honey.net\">" |
| "<priority>120</priority>" |
| "<status>*very* available</status>" |
| "</presence>"); |
| EXPECT_EQ(handler.SessionActivity(), ""); |
| } |
| |
| TEST_F(RosterModuleTest, TestIncomingPresence) { |
| std::unique_ptr<XmppEngine> engine(XmppEngine::Create()); |
| XmppTestHandler handler(engine.get()); |
| XmppTestRosterHandler roster_handler; |
| |
| std::unique_ptr<XmppRosterModule> roster(XmppRosterModule::Create()); |
| roster->set_roster_handler(&roster_handler); |
| |
| // Configure the roster module |
| roster->RegisterEngine(engine.get()); |
| |
| // Set up callbacks |
| engine->SetOutputHandler(&handler); |
| engine->AddStanzaHandler(&handler); |
| engine->SetSessionHandler(&handler); |
| |
| // Set up minimal login info |
| engine->SetUser(Jid("david@my-server")); |
| // engine->SetPassword("david"); |
| |
| // Do the whole login handshake |
| RunLogin(this, engine.get(), &handler); |
| EXPECT_EQ("", handler.OutputActivity()); |
| |
| // Load up with a bunch of data |
| std::string input; |
| input = "<presence from='maude@example.net/studio' " |
| "to='david@my-server/test'/>" |
| "<presence from='walter@example.net/home' " |
| "to='david@my-server/test'>" |
| "<priority>-10</priority>" |
| "<show>xa</show>" |
| "<status>Off bowling</status>" |
| "</presence>" |
| "<presence from='walter@example.net/alley' " |
| "to='david@my-server/test'>" |
| "<priority>20</priority>" |
| "<status>Looking for toes...</status>" |
| "</presence>" |
| "<presence from='donny@example.net/alley' " |
| "to='david@my-server/test'>" |
| "<priority>10</priority>" |
| "<status>Throwing rocks</status>" |
| "</presence>"; |
| TEST_OK(engine->HandleInput(input.c_str(), input.length())); |
| |
| EXPECT_EQ(roster_handler.StrClear(), |
| "[IncomingPresenceChanged " |
| "presence:[Presence jid:maude@example.net/studio available:1 " |
| "presence_show:[default] priority:0 status:]" |
| "<cli:presence from=\"maude@example.net/studio\" " |
| "to=\"david@my-server/test\" " |
| "xmlns:cli=\"jabber:client\"/>]" |
| "[IncomingPresenceChanged " |
| "presence:[Presence jid:walter@example.net/home available:1 " |
| "presence_show:xa priority:-10 status:Off bowling]" |
| "<cli:presence from=\"walter@example.net/home\" " |
| "to=\"david@my-server/test\" " |
| "xmlns:cli=\"jabber:client\">" |
| "<cli:priority>-10</cli:priority>" |
| "<cli:show>xa</cli:show>" |
| "<cli:status>Off bowling</cli:status>" |
| "</cli:presence>]" |
| "[IncomingPresenceChanged " |
| "presence:[Presence jid:walter@example.net/alley available:1 " |
| "presence_show:[default] " |
| "priority:20 status:Looking for toes...]" |
| "<cli:presence from=\"walter@example.net/alley\" " |
| "to=\"david@my-server/test\" " |
| "xmlns:cli=\"jabber:client\">" |
| "<cli:priority>20</cli:priority>" |
| "<cli:status>Looking for toes...</cli:status>" |
| "</cli:presence>]" |
| "[IncomingPresenceChanged " |
| "presence:[Presence jid:donny@example.net/alley available:1 " |
| "presence_show:[default] priority:10 status:Throwing rocks]" |
| "<cli:presence from=\"donny@example.net/alley\" " |
| "to=\"david@my-server/test\" " |
| "xmlns:cli=\"jabber:client\">" |
| "<cli:priority>10</cli:priority>" |
| "<cli:status>Throwing rocks</cli:status>" |
| "</cli:presence>]"); |
| EXPECT_EQ(handler.OutputActivity(), ""); |
| handler.SessionActivity(); // Ignore the session output |
| |
| // Now look at the data structure we've built |
| EXPECT_EQ(roster->GetIncomingPresenceCount(), static_cast<size_t>(4)); |
| EXPECT_EQ(roster->GetIncomingPresenceForJidCount(Jid("maude@example.net")), |
| static_cast<size_t>(1)); |
| EXPECT_EQ(roster->GetIncomingPresenceForJidCount(Jid("walter@example.net")), |
| static_cast<size_t>(2)); |
| |
| const XmppPresence * presence; |
| presence = roster->GetIncomingPresenceForJid(Jid("walter@example.net"), 1); |
| |
| std::stringstream dump; |
| WritePresence(dump, presence); |
| EXPECT_EQ(dump.str(), |
| "[Presence jid:walter@example.net/alley available:1 " |
| "presence_show:[default] priority:20 status:Looking for toes...]" |
| "<cli:presence from=\"walter@example.net/alley\" " |
| "to=\"david@my-server/test\" " |
| "xmlns:cli=\"jabber:client\">" |
| "<cli:priority>20</cli:priority>" |
| "<cli:status>Looking for toes...</cli:status>" |
| "</cli:presence>"); |
| dump.str(""); |
| |
| // Maude took off... |
| input = "<presence from='maude@example.net/studio' " |
| "to='david@my-server/test' " |
| "type='unavailable'>" |
| "<status>Stealing my rug back</status>" |
| "<priority>-10</priority>" |
| "</presence>"; |
| TEST_OK(engine->HandleInput(input.c_str(), input.length())); |
| |
| EXPECT_EQ(roster_handler.StrClear(), |
| "[IncomingPresenceChanged " |
| "presence:[Presence jid:maude@example.net/studio available:0 " |
| "presence_show:[default] priority:-10 " |
| "status:Stealing my rug back]" |
| "<cli:presence from=\"maude@example.net/studio\" " |
| "to=\"david@my-server/test\" type=\"unavailable\" " |
| "xmlns:cli=\"jabber:client\">" |
| "<cli:status>Stealing my rug back</cli:status>" |
| "<cli:priority>-10</cli:priority>" |
| "</cli:presence>]"); |
| EXPECT_EQ(handler.OutputActivity(), ""); |
| handler.SessionActivity(); // Ignore the session output |
| } |
| |
| TEST_F(RosterModuleTest, TestPresenceSubscription) { |
| std::unique_ptr<XmppEngine> engine(XmppEngine::Create()); |
| XmppTestHandler handler(engine.get()); |
| XmppTestRosterHandler roster_handler; |
| |
| std::unique_ptr<XmppRosterModule> roster(XmppRosterModule::Create()); |
| roster->set_roster_handler(&roster_handler); |
| |
| // Configure the roster module |
| roster->RegisterEngine(engine.get()); |
| |
| // Set up callbacks |
| engine->SetOutputHandler(&handler); |
| engine->AddStanzaHandler(&handler); |
| engine->SetSessionHandler(&handler); |
| |
| // Set up minimal login info |
| engine->SetUser(Jid("david@my-server")); |
| // engine->SetPassword("david"); |
| |
| // Do the whole login handshake |
| RunLogin(this, engine.get(), &handler); |
| EXPECT_EQ("", handler.OutputActivity()); |
| |
| // Test incoming requests |
| std::string input; |
| input = |
| "<presence from='maude@example.net' type='subscribe'/>" |
| "<presence from='maude@example.net' type='unsubscribe'/>" |
| "<presence from='maude@example.net' type='subscribed'/>" |
| "<presence from='maude@example.net' type='unsubscribed'/>"; |
| TEST_OK(engine->HandleInput(input.c_str(), input.length())); |
| |
| EXPECT_EQ(roster_handler.StrClear(), |
| "[SubscriptionRequest Jid:maude@example.net type:subscribe]" |
| "<cli:presence from=\"maude@example.net\" type=\"subscribe\" " |
| "xmlns:cli=\"jabber:client\"/>" |
| "[SubscriptionRequest Jid:maude@example.net type:unsubscribe]" |
| "<cli:presence from=\"maude@example.net\" type=\"unsubscribe\" " |
| "xmlns:cli=\"jabber:client\"/>" |
| "[SubscriptionRequest Jid:maude@example.net type:subscribed]" |
| "<cli:presence from=\"maude@example.net\" type=\"subscribed\" " |
| "xmlns:cli=\"jabber:client\"/>" |
| "[SubscriptionRequest Jid:maude@example.net type:unsubscribe]" |
| "<cli:presence from=\"maude@example.net\" type=\"unsubscribed\" " |
| "xmlns:cli=\"jabber:client\"/>"); |
| EXPECT_EQ(handler.OutputActivity(), ""); |
| handler.SessionActivity(); // Ignore the session output |
| |
| TEST_OK(roster->RequestSubscription(Jid("maude@example.net"))); |
| TEST_OK(roster->CancelSubscription(Jid("maude@example.net"))); |
| TEST_OK(roster->ApproveSubscriber(Jid("maude@example.net"))); |
| TEST_OK(roster->CancelSubscriber(Jid("maude@example.net"))); |
| |
| EXPECT_EQ(roster_handler.StrClear(), ""); |
| EXPECT_EQ(handler.OutputActivity(), |
| "<presence to=\"maude@example.net\" type=\"subscribe\"/>" |
| "<presence to=\"maude@example.net\" type=\"unsubscribe\"/>" |
| "<presence to=\"maude@example.net\" type=\"subscribed\"/>" |
| "<presence to=\"maude@example.net\" type=\"unsubscribed\"/>"); |
| EXPECT_EQ(handler.SessionActivity(), ""); |
| } |
| |
| TEST_F(RosterModuleTest, TestRosterReceive) { |
| std::unique_ptr<XmppEngine> engine(XmppEngine::Create()); |
| XmppTestHandler handler(engine.get()); |
| XmppTestRosterHandler roster_handler; |
| |
| std::unique_ptr<XmppRosterModule> roster(XmppRosterModule::Create()); |
| roster->set_roster_handler(&roster_handler); |
| |
| // Configure the roster module |
| roster->RegisterEngine(engine.get()); |
| |
| // Set up callbacks |
| engine->SetOutputHandler(&handler); |
| engine->AddStanzaHandler(&handler); |
| engine->SetSessionHandler(&handler); |
| |
| // Set up minimal login info |
| engine->SetUser(Jid("david@my-server")); |
| // engine->SetPassword("david"); |
| |
| // Do the whole login handshake |
| RunLogin(this, engine.get(), &handler); |
| EXPECT_EQ("", handler.OutputActivity()); |
| |
| // Request a roster update |
| TEST_OK(roster->RequestRosterUpdate()); |
| |
| EXPECT_EQ(roster_handler.StrClear(),""); |
| EXPECT_EQ(handler.OutputActivity(), |
| "<iq type=\"get\" id=\"2\">" |
| "<query xmlns=\"jabber:iq:roster\"/>" |
| "</iq>"); |
| EXPECT_EQ(handler.SessionActivity(), ""); |
| |
| // Prime the roster with a starting set |
| std::string input = |
| "<iq to='david@myserver/test' type='result' id='2'>" |
| "<query xmlns='jabber:iq:roster'>" |
| "<item jid='maude@example.net' " |
| "name='Maude Lebowski' " |
| "subscription='none' " |
| "ask='subscribe'>" |
| "<group>Business Partners</group>" |
| "</item>" |
| "<item jid='walter@example.net' " |
| "name='Walter Sobchak' " |
| "subscription='both'>" |
| "<group>Friends</group>" |
| "<group>Bowling Team</group>" |
| "<group>Bowling League</group>" |
| "</item>" |
| "<item jid='donny@example.net' " |
| "name='Donny' " |
| "subscription='both'>" |
| "<group>Friends</group>" |
| "<group>Bowling Team</group>" |
| "<group>Bowling League</group>" |
| "</item>" |
| "<item jid='jeffrey@example.net' " |
| "name='The Big Lebowski' " |
| "subscription='to'>" |
| "<group>Business Partners</group>" |
| "</item>" |
| "<item jid='jesus@example.net' " |
| "name='Jesus Quintana' " |
| "subscription='from'>" |
| "<group>Bowling League</group>" |
| "</item>" |
| "</query>" |
| "</iq>"; |
| |
| TEST_OK(engine->HandleInput(input.c_str(), input.length())); |
| |
| EXPECT_EQ(roster_handler.StrClear(), |
| "[ContactsAdded index:0 number:5 " |
| "0:[Contact jid:maude@example.net name:Maude Lebowski " |
| "subscription_state:none_asked " |
| "groups:[Business Partners]]" |
| "<ros:item jid=\"maude@example.net\" name=\"Maude Lebowski\" " |
| "subscription=\"none\" ask=\"subscribe\" " |
| "xmlns:ros=\"jabber:iq:roster\">" |
| "<ros:group>Business Partners</ros:group>" |
| "</ros:item> " |
| "1:[Contact jid:walter@example.net name:Walter Sobchak " |
| "subscription_state:both " |
| "groups:[Friends, Bowling Team, Bowling League]]" |
| "<ros:item jid=\"walter@example.net\" name=\"Walter Sobchak\" " |
| "subscription=\"both\" " |
| "xmlns:ros=\"jabber:iq:roster\">" |
| "<ros:group>Friends</ros:group>" |
| "<ros:group>Bowling Team</ros:group>" |
| "<ros:group>Bowling League</ros:group>" |
| "</ros:item> " |
| "2:[Contact jid:donny@example.net name:Donny " |
| "subscription_state:both " |
| "groups:[Friends, Bowling Team, Bowling League]]" |
| "<ros:item jid=\"donny@example.net\" name=\"Donny\" " |
| "subscription=\"both\" " |
| "xmlns:ros=\"jabber:iq:roster\">" |
| "<ros:group>Friends</ros:group>" |
| "<ros:group>Bowling Team</ros:group>" |
| "<ros:group>Bowling League</ros:group>" |
| "</ros:item> " |
| "3:[Contact jid:jeffrey@example.net name:The Big Lebowski " |
| "subscription_state:to " |
| "groups:[Business Partners]]" |
| "<ros:item jid=\"jeffrey@example.net\" name=\"The Big Lebowski\" " |
| "subscription=\"to\" " |
| "xmlns:ros=\"jabber:iq:roster\">" |
| "<ros:group>Business Partners</ros:group>" |
| "</ros:item> " |
| "4:[Contact jid:jesus@example.net name:Jesus Quintana " |
| "subscription_state:from groups:[Bowling League]]" |
| "<ros:item jid=\"jesus@example.net\" name=\"Jesus Quintana\" " |
| "subscription=\"from\" xmlns:ros=\"jabber:iq:roster\">" |
| "<ros:group>Bowling League</ros:group>" |
| "</ros:item>]"); |
| EXPECT_EQ(handler.OutputActivity(), ""); |
| EXPECT_EQ(handler.SessionActivity(), ""); |
| |
| // Request that someone be added |
| std::unique_ptr<XmppRosterContact> contact(XmppRosterContact::Create()); |
| TEST_OK(contact->set_jid(Jid("brandt@example.net"))); |
| TEST_OK(contact->set_name("Brandt")); |
| TEST_OK(contact->AddGroup("Business Partners")); |
| TEST_OK(contact->AddGroup("Watchers")); |
| TEST_OK(contact->AddGroup("Friends")); |
| TEST_OK(contact->RemoveGroup("Friends")); // Maybe not... |
| TEST_OK(roster->RequestRosterChange(contact.get())); |
| |
| EXPECT_EQ(roster_handler.StrClear(), ""); |
| EXPECT_EQ(handler.OutputActivity(), |
| "<iq type=\"set\" id=\"3\">" |
| "<query xmlns=\"jabber:iq:roster\">" |
| "<item jid=\"brandt@example.net\" " |
| "name=\"Brandt\">" |
| "<group>Business Partners</group>" |
| "<group>Watchers</group>" |
| "</item>" |
| "</query>" |
| "</iq>"); |
| EXPECT_EQ(handler.SessionActivity(), ""); |
| |
| // Get the push from the server |
| input = |
| "<iq type='result' to='david@my-server/test' id='3'/>" |
| "<iq type='set' id='server_1'>" |
| "<query xmlns='jabber:iq:roster'>" |
| "<item jid='brandt@example.net' " |
| "name='Brandt' " |
| "subscription='none'>" |
| "<group>Business Partners</group>" |
| "<group>Watchers</group>" |
| "</item>" |
| "</query>" |
| "</iq>"; |
| TEST_OK(engine->HandleInput(input.c_str(), input.length())); |
| |
| EXPECT_EQ(roster_handler.StrClear(), |
| "[ContactsAdded index:5 number:1 " |
| "5:[Contact jid:brandt@example.net name:Brandt " |
| "subscription_state:none " |
| "groups:[Business Partners, Watchers]]" |
| "<ros:item jid=\"brandt@example.net\" name=\"Brandt\" " |
| "subscription=\"none\" " |
| "xmlns:ros=\"jabber:iq:roster\">" |
| "<ros:group>Business Partners</ros:group>" |
| "<ros:group>Watchers</ros:group>" |
| "</ros:item>]"); |
| EXPECT_EQ(handler.OutputActivity(), |
| "<iq type=\"result\" id=\"server_1\"/>"); |
| EXPECT_EQ(handler.SessionActivity(), ""); |
| |
| // Get a contact update |
| input = |
| "<iq type='set' id='server_2'>" |
| "<query xmlns='jabber:iq:roster'>" |
| "<item jid='walter@example.net' " |
| "name='Walter Sobchak' " |
| "subscription='both'>" |
| "<group>Friends</group>" |
| "<group>Bowling Team</group>" |
| "<group>Bowling League</group>" |
| "<group>Not wrong, just an...</group>" |
| "</item>" |
| "</query>" |
| "</iq>"; |
| |
| TEST_OK(engine->HandleInput(input.c_str(), input.length())); |
| |
| EXPECT_EQ(roster_handler.StrClear(), |
| "[ContactChanged " |
| "old_contact:[Contact jid:walter@example.net name:Walter Sobchak " |
| "subscription_state:both " |
| "groups:[Friends, Bowling Team, Bowling League]]" |
| "<ros:item jid=\"walter@example.net\" name=\"Walter Sobchak\" " |
| "subscription=\"both\" xmlns:ros=\"jabber:iq:roster\">" |
| "<ros:group>Friends</ros:group>" |
| "<ros:group>Bowling Team</ros:group>" |
| "<ros:group>Bowling League</ros:group>" |
| "</ros:item> " |
| "index:1 " |
| "new_contact:[Contact jid:walter@example.net name:Walter Sobchak " |
| "subscription_state:both " |
| "groups:[Friends, Bowling Team, Bowling League, " |
| "Not wrong, just an...]]" |
| "<ros:item jid=\"walter@example.net\" name=\"Walter Sobchak\" " |
| "subscription=\"both\" xmlns:ros=\"jabber:iq:roster\">" |
| "<ros:group>Friends</ros:group>" |
| "<ros:group>Bowling Team</ros:group>" |
| "<ros:group>Bowling League</ros:group>" |
| "<ros:group>Not wrong, just an...</ros:group>" |
| "</ros:item>]"); |
| EXPECT_EQ(handler.OutputActivity(), |
| "<iq type=\"result\" id=\"server_2\"/>"); |
| EXPECT_EQ(handler.SessionActivity(), ""); |
| |
| // Remove a contact |
| TEST_OK(roster->RequestRosterRemove(Jid("jesus@example.net"))); |
| |
| EXPECT_EQ(roster_handler.StrClear(), ""); |
| EXPECT_EQ(handler.OutputActivity(), |
| "<iq type=\"set\" id=\"4\">" |
| "<query xmlns=\"jabber:iq:roster\" jid=\"jesus@example.net\" " |
| "subscription=\"remove\"/>" |
| "</iq>"); |
| EXPECT_EQ(handler.SessionActivity(), ""); |
| |
| // Response from the server |
| input = |
| "<iq type='result' to='david@my-server/test' id='4'/>" |
| "<iq type='set' id='server_3'>" |
| "<query xmlns='jabber:iq:roster'>" |
| "<item jid='jesus@example.net' " |
| "subscription='remove'>" |
| "</item>" |
| "</query>" |
| "</iq>"; |
| TEST_OK(engine->HandleInput(input.c_str(), input.length())); |
| |
| EXPECT_EQ(roster_handler.StrClear(), |
| "[ContactRemoved " |
| "old_contact:[Contact jid:jesus@example.net name:Jesus Quintana " |
| "subscription_state:from groups:[Bowling League]]" |
| "<ros:item jid=\"jesus@example.net\" name=\"Jesus Quintana\" " |
| "subscription=\"from\" " |
| "xmlns:ros=\"jabber:iq:roster\">" |
| "<ros:group>Bowling League</ros:group>" |
| "</ros:item> index:4]"); |
| EXPECT_EQ(handler.OutputActivity(), |
| "<iq type=\"result\" id=\"server_3\"/>"); |
| EXPECT_EQ(handler.SessionActivity(), ""); |
| } |
| |
| } |
