| // Copyright 2011 Google Inc. All Rights Reserved |
| |
| |
| #include <string> |
| |
| #include "talk/base/faketaskrunner.h" |
| #include "talk/base/gunit.h" |
| #include "talk/base/sigslot.h" |
| #include "talk/xmllite/qname.h" |
| #include "talk/xmllite/xmlelement.h" |
| #include "talk/xmpp/constants.h" |
| #include "talk/xmpp/iqtask.h" |
| #include "talk/xmpp/fakexmppclient.h" |
| #include "talk/xmpp/jid.h" |
| #include "talk/xmpp/pubsubtasks.h" |
| |
| struct HandledPubSubItem { |
| std::string itemid; |
| std::string payload; |
| }; |
| |
| class TestPubSubTasksListener : public sigslot::has_slots<> { |
| public: |
| TestPubSubTasksListener() : result_count(0), error_count(0) {} |
| |
| void OnReceiveUpdate(buzz::PubSubReceiveTask* task, |
| const std::vector<buzz::PubSubItem>& items) { |
| OnItems(items); |
| } |
| |
| void OnRequestResult(buzz::PubSubRequestTask* task, |
| const std::vector<buzz::PubSubItem>& items) { |
| OnItems(items); |
| } |
| |
| void OnItems(const std::vector<buzz::PubSubItem>& items) { |
| for (std::vector<buzz::PubSubItem>::const_iterator item = items.begin(); |
| item != items.end(); ++item) { |
| HandledPubSubItem handled_item; |
| handled_item.itemid = item->itemid; |
| if (item->elem->FirstElement() != NULL) { |
| handled_item.payload = item->elem->FirstElement()->Str(); |
| } |
| this->items.push_back(handled_item); |
| } |
| } |
| |
| void OnPublishResult(buzz::PubSubPublishTask* task) { |
| ++result_count; |
| } |
| |
| void OnRetractResult(buzz::PubSubRetractTask* task) { |
| ++result_count; |
| } |
| |
| void OnError(buzz::IqTask* task, const buzz::XmlElement* stanza) { |
| ++error_count; |
| } |
| |
| std::vector<HandledPubSubItem> items; |
| int result_count; |
| int error_count; |
| }; |
| |
| class PubSubTasksTest : public testing::Test { |
| public: |
| PubSubTasksTest() : |
| pubsubjid("room@domain.com"), |
| node("topic"), |
| itemid("key") { |
| runner.reset(new talk_base::FakeTaskRunner()); |
| client = new buzz::FakeXmppClient(runner.get()); |
| listener.reset(new TestPubSubTasksListener()); |
| } |
| |
| talk_base::scoped_ptr<talk_base::FakeTaskRunner> runner; |
| // Client deleted by deleting runner. |
| buzz::FakeXmppClient* client; |
| talk_base::scoped_ptr<TestPubSubTasksListener> listener; |
| buzz::Jid pubsubjid; |
| std::string node; |
| std::string itemid; |
| }; |
| |
| TEST_F(PubSubTasksTest, TestRequest) { |
| buzz::PubSubRequestTask* task = |
| new buzz::PubSubRequestTask(client, pubsubjid, node); |
| task->SignalResult.connect( |
| listener.get(), &TestPubSubTasksListener::OnRequestResult); |
| task->Start(); |
| |
| std::string expected_iq = |
| "<cli:iq type=\"get\" to=\"room@domain.com\" id=\"0\" " |
| "xmlns:cli=\"jabber:client\">" |
| "<pub:pubsub xmlns:pub=\"http://jabber.org/protocol/pubsub\">" |
| "<pub:items node=\"topic\"/>" |
| "</pub:pubsub>" |
| "</cli:iq>"; |
| |
| ASSERT_EQ(1U, client->sent_stanzas().size()); |
| EXPECT_EQ(expected_iq, client->sent_stanzas()[0]->Str()); |
| |
| std::string result_iq = |
| "<iq xmlns='jabber:client' id='0' type='result' from='room@domain.com'>" |
| " <pubsub xmlns='http://jabber.org/protocol/pubsub'>" |
| " <items node='topic'>" |
| " <item id='key0'>" |
| " <value0/>" |
| " </item>" |
| " <item id='key1'>" |
| " <value1/>" |
| " </item>" |
| " </items>" |
| " </pubsub>" |
| "</iq>"; |
| |
| client->HandleStanza(buzz::XmlElement::ForStr(result_iq)); |
| |
| ASSERT_EQ(2U, listener->items.size()); |
| EXPECT_EQ("key0", listener->items[0].itemid); |
| EXPECT_EQ("<pub:value0 xmlns:pub=\"http://jabber.org/protocol/pubsub\"/>", |
| listener->items[0].payload); |
| EXPECT_EQ("key1", listener->items[1].itemid); |
| EXPECT_EQ("<pub:value1 xmlns:pub=\"http://jabber.org/protocol/pubsub\"/>", |
| listener->items[1].payload); |
| } |
| |
| TEST_F(PubSubTasksTest, TestRequestError) { |
| std::string result_iq = |
| "<iq xmlns='jabber:client' id='0' type='error' from='room@domain.com'>" |
| " <error type='auth'>" |
| " <forbidden xmlns='urn:ietf:params:xml:ns:xmpp-stanzas'/>" |
| " </error>" |
| "</iq>"; |
| |
| buzz::PubSubRequestTask* task = |
| new buzz::PubSubRequestTask(client, pubsubjid, node); |
| task->SignalResult.connect( |
| listener.get(), &TestPubSubTasksListener::OnRequestResult); |
| task->SignalError.connect( |
| listener.get(), &TestPubSubTasksListener::OnError); |
| task->Start(); |
| client->HandleStanza(buzz::XmlElement::ForStr(result_iq)); |
| |
| EXPECT_EQ(0, listener->result_count); |
| EXPECT_EQ(1, listener->error_count); |
| } |
| |
| TEST_F(PubSubTasksTest, TestReceive) { |
| std::string items_message = |
| "<message xmlns='jabber:client' from='room@domain.com'>" |
| " <event xmlns='http://jabber.org/protocol/pubsub#event'>" |
| " <items node='topic'>" |
| " <item id='key0'>" |
| " <value0/>" |
| " </item>" |
| " <item id='key1'>" |
| " <value1/>" |
| " </item>" |
| " </items>" |
| " </event>" |
| "</message>"; |
| |
| buzz::PubSubReceiveTask* task = |
| new buzz::PubSubReceiveTask(client, pubsubjid, node); |
| task->SignalUpdate.connect( |
| listener.get(), &TestPubSubTasksListener::OnReceiveUpdate); |
| task->Start(); |
| client->HandleStanza(buzz::XmlElement::ForStr(items_message)); |
| |
| ASSERT_EQ(2U, listener->items.size()); |
| EXPECT_EQ("key0", listener->items[0].itemid); |
| EXPECT_EQ( |
| "<eve:value0 xmlns:eve=\"http://jabber.org/protocol/pubsub#event\"/>", |
| listener->items[0].payload); |
| EXPECT_EQ("key1", listener->items[1].itemid); |
| EXPECT_EQ( |
| "<eve:value1 xmlns:eve=\"http://jabber.org/protocol/pubsub#event\"/>", |
| listener->items[1].payload); |
| } |
| |
| TEST_F(PubSubTasksTest, TestPublish) { |
| buzz::XmlElement* payload = |
| new buzz::XmlElement(buzz::QName(buzz::NS_PUBSUB, "value")); |
| std::string expected_iq = |
| "<cli:iq type=\"set\" to=\"room@domain.com\" id=\"0\" " |
| "xmlns:cli=\"jabber:client\">" |
| "<pubsub xmlns=\"http://jabber.org/protocol/pubsub\">" |
| "<publish node=\"topic\">" |
| "<item id=\"key\">" |
| "<value/>" |
| "</item>" |
| "</publish>" |
| "</pubsub>" |
| "</cli:iq>"; |
| |
| std::vector<buzz::XmlElement*> children; |
| children.push_back(payload); |
| buzz::PubSubPublishTask* task = |
| new buzz::PubSubPublishTask(client, pubsubjid, node, itemid, children); |
| task->SignalResult.connect( |
| listener.get(), &TestPubSubTasksListener::OnPublishResult); |
| task->Start(); |
| |
| ASSERT_EQ(1U, client->sent_stanzas().size()); |
| EXPECT_EQ(expected_iq, client->sent_stanzas()[0]->Str()); |
| |
| std::string result_iq = |
| "<iq xmlns='jabber:client' id='0' type='result' from='room@domain.com'/>"; |
| |
| client->HandleStanza(buzz::XmlElement::ForStr(result_iq)); |
| |
| EXPECT_EQ(1, listener->result_count); |
| EXPECT_EQ(0, listener->error_count); |
| } |
| |
| TEST_F(PubSubTasksTest, TestPublishError) { |
| buzz::XmlElement* payload = |
| new buzz::XmlElement(buzz::QName(buzz::NS_PUBSUB, "value")); |
| |
| std::vector<buzz::XmlElement*> children; |
| children.push_back(payload); |
| buzz::PubSubPublishTask* task = |
| new buzz::PubSubPublishTask(client, pubsubjid, node, itemid, children); |
| task->SignalResult.connect( |
| listener.get(), &TestPubSubTasksListener::OnPublishResult); |
| task->SignalError.connect( |
| listener.get(), &TestPubSubTasksListener::OnError); |
| task->Start(); |
| |
| std::string result_iq = |
| "<iq xmlns='jabber:client' id='0' type='error' from='room@domain.com'>" |
| " <error type='auth'>" |
| " <forbidden xmlns='urn:ietf:params:xml:ns:xmpp-stanzas'/>" |
| " </error>" |
| "</iq>"; |
| |
| client->HandleStanza(buzz::XmlElement::ForStr(result_iq)); |
| |
| EXPECT_EQ(0, listener->result_count); |
| EXPECT_EQ(1, listener->error_count); |
| } |
| |
| TEST_F(PubSubTasksTest, TestRetract) { |
| buzz::PubSubRetractTask* task = |
| new buzz::PubSubRetractTask(client, pubsubjid, node, itemid); |
| task->SignalResult.connect( |
| listener.get(), &TestPubSubTasksListener::OnRetractResult); |
| task->SignalError.connect( |
| listener.get(), &TestPubSubTasksListener::OnError); |
| task->Start(); |
| |
| std::string expected_iq = |
| "<cli:iq type=\"set\" to=\"room@domain.com\" id=\"0\" " |
| "xmlns:cli=\"jabber:client\">" |
| "<pubsub xmlns=\"http://jabber.org/protocol/pubsub\">" |
| "<retract node=\"topic\" notify=\"true\">" |
| "<item id=\"key\"/>" |
| "</retract>" |
| "</pubsub>" |
| "</cli:iq>"; |
| |
| ASSERT_EQ(1U, client->sent_stanzas().size()); |
| EXPECT_EQ(expected_iq, client->sent_stanzas()[0]->Str()); |
| |
| std::string result_iq = |
| "<iq xmlns='jabber:client' id='0' type='result' from='room@domain.com'/>"; |
| |
| client->HandleStanza(buzz::XmlElement::ForStr(result_iq)); |
| |
| EXPECT_EQ(1, listener->result_count); |
| EXPECT_EQ(0, listener->error_count); |
| } |