1 // Copyright 2011 Google Inc. All Rights Reserved
6 #include "talk/xmllite/qname.h"
7 #include "talk/xmllite/xmlelement.h"
8 #include "talk/xmpp/constants.h"
9 #include "talk/xmpp/fakexmppclient.h"
10 #include "talk/xmpp/hangoutpubsubclient.h"
11 #include "talk/xmpp/jid.h"
12 #include "webrtc/base/faketaskrunner.h"
13 #include "webrtc/base/gunit.h"
14 #include "webrtc/base/sigslot.h"
16 class TestHangoutPubSubListener : public sigslot::has_slots<> {
18 TestHangoutPubSubListener() :
19 request_error_count(0),
20 publish_audio_mute_error_count(0),
21 publish_video_mute_error_count(0),
22 publish_video_pause_error_count(0),
23 publish_presenter_error_count(0),
24 publish_recording_error_count(0),
25 remote_mute_error_count(0) {
28 void OnPresenterStateChange(
29 const std::string& nick, bool was_presenting, bool is_presenting) {
30 last_presenter_nick = nick;
31 last_was_presenting = was_presenting;
32 last_is_presenting = is_presenting;
35 void OnAudioMuteStateChange(
36 const std::string& nick, bool was_muted, bool is_muted) {
37 last_audio_muted_nick = nick;
38 last_was_audio_muted = was_muted;
39 last_is_audio_muted = is_muted;
42 void OnVideoMuteStateChange(
43 const std::string& nick, bool was_muted, bool is_muted) {
44 last_video_muted_nick = nick;
45 last_was_video_muted = was_muted;
46 last_is_video_muted = is_muted;
49 void OnVideoPauseStateChange(
50 const std::string& nick, bool was_paused, bool is_paused) {
51 last_video_paused_nick = nick;
52 last_was_video_paused = was_paused;
53 last_is_video_paused = is_paused;
56 void OnRecordingStateChange(
57 const std::string& nick, bool was_recording, bool is_recording) {
58 last_recording_nick = nick;
59 last_was_recording = was_recording;
60 last_is_recording = is_recording;
64 const std::string& mutee_nick,
65 const std::string& muter_nick,
66 bool should_mute_locally) {
67 last_mutee_nick = mutee_nick;
68 last_muter_nick = muter_nick;
69 last_should_mute = should_mute_locally;
73 const std::string& blockee_nick,
74 const std::string& blocker_nick) {
75 last_blockee_nick = blockee_nick;
76 last_blocker_nick = blocker_nick;
79 void OnRequestError(const std::string& node, const buzz::XmlElement* stanza) {
80 ++request_error_count;
81 request_error_node = node;
84 void OnPublishAudioMuteError(const std::string& task_id,
85 const buzz::XmlElement* stanza) {
86 ++publish_audio_mute_error_count;
87 error_task_id = task_id;
90 void OnPublishVideoMuteError(const std::string& task_id,
91 const buzz::XmlElement* stanza) {
92 ++publish_video_mute_error_count;
93 error_task_id = task_id;
96 void OnPublishVideoPauseError(const std::string& task_id,
97 const buzz::XmlElement* stanza) {
98 ++publish_video_pause_error_count;
99 error_task_id = task_id;
102 void OnPublishPresenterError(const std::string& task_id,
103 const buzz::XmlElement* stanza) {
104 ++publish_presenter_error_count;
105 error_task_id = task_id;
108 void OnPublishRecordingError(const std::string& task_id,
109 const buzz::XmlElement* stanza) {
110 ++publish_recording_error_count;
111 error_task_id = task_id;
114 void OnRemoteMuteResult(const std::string& task_id,
115 const std::string& mutee_nick) {
116 result_task_id = task_id;
117 remote_mute_mutee_nick = mutee_nick;
120 void OnRemoteMuteError(const std::string& task_id,
121 const std::string& mutee_nick,
122 const buzz::XmlElement* stanza) {
123 ++remote_mute_error_count;
124 error_task_id = task_id;
125 remote_mute_mutee_nick = mutee_nick;
128 void OnMediaBlockResult(const std::string& task_id,
129 const std::string& blockee_nick) {
130 result_task_id = task_id;
131 media_blockee_nick = blockee_nick;
134 void OnMediaBlockError(const std::string& task_id,
135 const std::string& blockee_nick,
136 const buzz::XmlElement* stanza) {
137 ++media_block_error_count;
138 error_task_id = task_id;
139 media_blockee_nick = blockee_nick;
142 std::string last_presenter_nick;
143 bool last_is_presenting;
144 bool last_was_presenting;
145 std::string last_audio_muted_nick;
146 bool last_is_audio_muted;
147 bool last_was_audio_muted;
148 std::string last_video_muted_nick;
149 bool last_is_video_muted;
150 bool last_was_video_muted;
151 std::string last_video_paused_nick;
152 bool last_is_video_paused;
153 bool last_was_video_paused;
154 std::string last_recording_nick;
155 bool last_is_recording;
156 bool last_was_recording;
157 std::string last_mutee_nick;
158 std::string last_muter_nick;
159 bool last_should_mute;
160 std::string last_blockee_nick;
161 std::string last_blocker_nick;
163 int request_error_count;
164 std::string request_error_node;
165 int publish_audio_mute_error_count;
166 int publish_video_mute_error_count;
167 int publish_video_pause_error_count;
168 int publish_presenter_error_count;
169 int publish_recording_error_count;
170 int remote_mute_error_count;
171 std::string result_task_id;
172 std::string error_task_id;
173 std::string remote_mute_mutee_nick;
174 int media_block_error_count;
175 std::string media_blockee_nick;
178 class HangoutPubSubClientTest : public testing::Test {
180 HangoutPubSubClientTest() :
181 pubsubjid("room@domain.com"),
184 runner.reset(new rtc::FakeTaskRunner());
185 xmpp_client = new buzz::FakeXmppClient(runner.get());
186 client.reset(new buzz::HangoutPubSubClient(xmpp_client, pubsubjid, nick));
187 listener.reset(new TestHangoutPubSubListener());
188 client->SignalPresenterStateChange.connect(
189 listener.get(), &TestHangoutPubSubListener::OnPresenterStateChange);
190 client->SignalAudioMuteStateChange.connect(
191 listener.get(), &TestHangoutPubSubListener::OnAudioMuteStateChange);
192 client->SignalVideoMuteStateChange.connect(
193 listener.get(), &TestHangoutPubSubListener::OnVideoMuteStateChange);
194 client->SignalVideoPauseStateChange.connect(
195 listener.get(), &TestHangoutPubSubListener::OnVideoPauseStateChange);
196 client->SignalRecordingStateChange.connect(
197 listener.get(), &TestHangoutPubSubListener::OnRecordingStateChange);
198 client->SignalRemoteMute.connect(
199 listener.get(), &TestHangoutPubSubListener::OnRemoteMute);
200 client->SignalMediaBlock.connect(
201 listener.get(), &TestHangoutPubSubListener::OnMediaBlock);
202 client->SignalRequestError.connect(
203 listener.get(), &TestHangoutPubSubListener::OnRequestError);
204 client->SignalPublishAudioMuteError.connect(
205 listener.get(), &TestHangoutPubSubListener::OnPublishAudioMuteError);
206 client->SignalPublishVideoMuteError.connect(
207 listener.get(), &TestHangoutPubSubListener::OnPublishVideoMuteError);
208 client->SignalPublishVideoPauseError.connect(
209 listener.get(), &TestHangoutPubSubListener::OnPublishVideoPauseError);
210 client->SignalPublishPresenterError.connect(
211 listener.get(), &TestHangoutPubSubListener::OnPublishPresenterError);
212 client->SignalPublishRecordingError.connect(
213 listener.get(), &TestHangoutPubSubListener::OnPublishRecordingError);
214 client->SignalRemoteMuteResult.connect(
215 listener.get(), &TestHangoutPubSubListener::OnRemoteMuteResult);
216 client->SignalRemoteMuteError.connect(
217 listener.get(), &TestHangoutPubSubListener::OnRemoteMuteError);
218 client->SignalMediaBlockResult.connect(
219 listener.get(), &TestHangoutPubSubListener::OnMediaBlockResult);
220 client->SignalMediaBlockError.connect(
221 listener.get(), &TestHangoutPubSubListener::OnMediaBlockError);
224 rtc::scoped_ptr<rtc::FakeTaskRunner> runner;
225 // xmpp_client deleted by deleting runner.
226 buzz::FakeXmppClient* xmpp_client;
227 rtc::scoped_ptr<buzz::HangoutPubSubClient> client;
228 rtc::scoped_ptr<TestHangoutPubSubListener> listener;
233 TEST_F(HangoutPubSubClientTest, TestRequest) {
234 ASSERT_EQ(0U, xmpp_client->sent_stanzas().size());
236 client->RequestAll();
237 std::string expected_presenter_request =
238 "<cli:iq type=\"get\" to=\"room@domain.com\" id=\"0\" "
239 "xmlns:cli=\"jabber:client\">"
240 "<pub:pubsub xmlns:pub=\"http://jabber.org/protocol/pubsub\">"
241 "<pub:items node=\"google:presenter\"/>"
245 std::string expected_media_request =
246 "<cli:iq type=\"get\" to=\"room@domain.com\" id=\"0\" "
247 "xmlns:cli=\"jabber:client\">"
248 "<pub:pubsub xmlns:pub=\"http://jabber.org/protocol/pubsub\">"
249 "<pub:items node=\"google:muc#media\"/>"
253 ASSERT_EQ(2U, xmpp_client->sent_stanzas().size());
254 EXPECT_EQ(expected_presenter_request, xmpp_client->sent_stanzas()[0]->Str());
255 EXPECT_EQ(expected_media_request, xmpp_client->sent_stanzas()[1]->Str());
257 std::string presenter_response =
258 "<iq xmlns='jabber:client' id='0' type='result' from='room@domain.com'>"
259 " <pubsub xmlns='http://jabber.org/protocol/pubsub'>"
260 " <items node='google:presenter'>"
262 " <presenter xmlns='google:presenter' nick='presenting-nick2'/>"
263 " <pre:presentation-item xmlns:pre='google:presenter'"
264 " pre:presentation-type='s'/>"
267 " <presenter xmlns='google:presenter' nick='presenting-nick'/>"
268 " <pre:presentation-item xmlns:pre='google:presenter'"
269 " pre:presentation-type='o'/>"
271 // Some clients are "bad" in that they'll jam multiple states in
272 // all at once. We have to deal with it.
274 " <presenter xmlns='google:presenter' nick='presenting-nick'/>"
275 " <pre:presentation-item xmlns:pre='google:presenter'"
276 " pre:presentation-type='s'/>"
282 xmpp_client->HandleStanza(buzz::XmlElement::ForStr(presenter_response));
283 EXPECT_EQ("presenting-nick", listener->last_presenter_nick);
284 EXPECT_FALSE(listener->last_was_presenting);
285 EXPECT_TRUE(listener->last_is_presenting);
287 std::string media_response =
288 "<iq xmlns='jabber:client' id='0' type='result' from='room@domain.com'>"
289 " <pubsub xmlns='http://jabber.org/protocol/pubsub'>"
290 " <items node='google:muc#media'>"
291 " <item id='audio-mute:muted-nick'>"
292 " <audio-mute nick='muted-nick' xmlns='google:muc#media'/>"
294 " <item id='video-mute:video-muted-nick'>"
295 " <video-mute nick='video-muted-nick' xmlns='google:muc#media'/>"
297 " <item id='video-pause:video-paused-nick'>"
298 " <video-pause nick='video-paused-nick' xmlns='google:muc#media'/>"
300 " <item id='recording:recording-nick'>"
301 " <recording nick='recording-nick' xmlns='google:muc#media'/>"
307 xmpp_client->HandleStanza(buzz::XmlElement::ForStr(media_response));
308 EXPECT_EQ("muted-nick", listener->last_audio_muted_nick);
309 EXPECT_FALSE(listener->last_was_audio_muted);
310 EXPECT_TRUE(listener->last_is_audio_muted);
312 EXPECT_EQ("video-muted-nick", listener->last_video_muted_nick);
313 EXPECT_FALSE(listener->last_was_video_muted);
314 EXPECT_TRUE(listener->last_is_video_muted);
316 EXPECT_EQ("video-paused-nick", listener->last_video_paused_nick);
317 EXPECT_FALSE(listener->last_was_video_paused);
318 EXPECT_TRUE(listener->last_is_video_paused);
320 EXPECT_EQ("recording-nick", listener->last_recording_nick);
321 EXPECT_FALSE(listener->last_was_recording);
322 EXPECT_TRUE(listener->last_is_recording);
324 std::string incoming_presenter_resets_message =
325 "<message xmlns='jabber:client' from='room@domain.com'>"
326 " <event xmlns='http://jabber.org/protocol/pubsub#event'>"
327 " <items node='google:presenter'>"
329 " <presenter xmlns='google:presenter' nick='presenting-nick'/>"
330 " <pre:presentation-item xmlns:pre='google:presenter'"
331 " pre:presentation-type='o'/>"
337 xmpp_client->HandleStanza(
338 buzz::XmlElement::ForStr(incoming_presenter_resets_message));
339 EXPECT_EQ("presenting-nick", listener->last_presenter_nick);
340 //EXPECT_TRUE(listener->last_was_presenting);
341 EXPECT_FALSE(listener->last_is_presenting);
343 std::string incoming_presenter_retracts_message =
344 "<message xmlns='jabber:client' from='room@domain.com'>"
345 " <event xmlns='http://jabber.org/protocol/pubsub#event'>"
346 " <items node='google:presenter'>"
347 " <retract id='12344'/>"
352 xmpp_client->HandleStanza(
353 buzz::XmlElement::ForStr(incoming_presenter_retracts_message));
354 EXPECT_EQ("presenting-nick2", listener->last_presenter_nick);
355 EXPECT_TRUE(listener->last_was_presenting);
356 EXPECT_FALSE(listener->last_is_presenting);
358 std::string incoming_media_retracts_message =
359 "<message xmlns='jabber:client' from='room@domain.com'>"
360 " <event xmlns='http://jabber.org/protocol/pubsub#event'>"
361 " <items node='google:muc#media'>"
362 " <item id='audio-mute:muted-nick'>"
364 " <retract id='video-mute:video-muted-nick'/>"
365 " <retract id='video-pause:video-paused-nick'/>"
366 " <retract id='recording:recording-nick'/>"
371 xmpp_client->HandleStanza(
372 buzz::XmlElement::ForStr(incoming_media_retracts_message));
373 EXPECT_EQ("muted-nick", listener->last_audio_muted_nick);
374 EXPECT_TRUE(listener->last_was_audio_muted);
375 EXPECT_FALSE(listener->last_is_audio_muted);
377 EXPECT_EQ("video-paused-nick", listener->last_video_paused_nick);
378 EXPECT_TRUE(listener->last_was_video_paused);
379 EXPECT_FALSE(listener->last_is_video_paused);
381 EXPECT_EQ("recording-nick", listener->last_recording_nick);
382 EXPECT_TRUE(listener->last_was_recording);
383 EXPECT_FALSE(listener->last_is_recording);
385 std::string incoming_presenter_changes_message =
386 "<message xmlns='jabber:client' from='room@domain.com'>"
387 " <event xmlns='http://jabber.org/protocol/pubsub#event'>"
388 " <items node='google:presenter'>"
389 " <item id='presenting-nick2'>"
390 " <presenter xmlns='google:presenter' nick='presenting-nick2'/>"
391 " <pre:presentation-item xmlns:pre='google:presenter'"
392 " pre:presentation-type='s'/>"
398 xmpp_client->HandleStanza(
399 buzz::XmlElement::ForStr(incoming_presenter_changes_message));
400 EXPECT_EQ("presenting-nick2", listener->last_presenter_nick);
401 EXPECT_FALSE(listener->last_was_presenting);
402 EXPECT_TRUE(listener->last_is_presenting);
404 xmpp_client->HandleStanza(
405 buzz::XmlElement::ForStr(incoming_presenter_changes_message));
406 EXPECT_EQ("presenting-nick2", listener->last_presenter_nick);
407 EXPECT_TRUE(listener->last_was_presenting);
408 EXPECT_TRUE(listener->last_is_presenting);
410 std::string incoming_media_changes_message =
411 "<message xmlns='jabber:client' from='room@domain.com'>"
412 " <event xmlns='http://jabber.org/protocol/pubsub#event'>"
413 " <items node='google:muc#media'>"
414 " <item id='audio-mute:muted-nick2'>"
415 " <audio-mute nick='muted-nick2' xmlns='google:muc#media'/>"
417 " <item id='video-pause:video-paused-nick2'>"
418 " <video-pause nick='video-paused-nick2' xmlns='google:muc#media'/>"
420 " <item id='recording:recording-nick2'>"
421 " <recording nick='recording-nick2' xmlns='google:muc#media'/>"
427 xmpp_client->HandleStanza(
428 buzz::XmlElement::ForStr(incoming_media_changes_message));
429 EXPECT_EQ("muted-nick2", listener->last_audio_muted_nick);
430 EXPECT_FALSE(listener->last_was_audio_muted);
431 EXPECT_TRUE(listener->last_is_audio_muted);
433 EXPECT_EQ("video-paused-nick2", listener->last_video_paused_nick);
434 EXPECT_FALSE(listener->last_was_video_paused);
435 EXPECT_TRUE(listener->last_is_video_paused);
437 EXPECT_EQ("recording-nick2", listener->last_recording_nick);
438 EXPECT_FALSE(listener->last_was_recording);
439 EXPECT_TRUE(listener->last_is_recording);
441 std::string incoming_remote_mute_message =
442 "<message xmlns='jabber:client' from='room@domain.com'>"
443 " <event xmlns='http://jabber.org/protocol/pubsub#event'>"
444 " <items node='google:muc#media'>"
445 " <item id='audio-mute:mutee' publisher='room@domain.com/muter'>"
446 " <audio-mute nick='mutee' xmlns='google:muc#media'/>"
452 listener->last_is_audio_muted = false;
453 xmpp_client->HandleStanza(
454 buzz::XmlElement::ForStr(incoming_remote_mute_message));
455 EXPECT_EQ("mutee", listener->last_mutee_nick);
456 EXPECT_EQ("muter", listener->last_muter_nick);
457 EXPECT_FALSE(listener->last_should_mute);
458 EXPECT_EQ("mutee", listener->last_audio_muted_nick);
459 EXPECT_TRUE(listener->last_is_audio_muted);
461 std::string incoming_remote_mute_me_message =
462 "<message xmlns='jabber:client' from='room@domain.com'>"
463 " <event xmlns='http://jabber.org/protocol/pubsub#event'>"
464 " <items node='google:muc#media'>"
465 " <item id='audio-mute:me' publisher='room@domain.com/muter'>"
466 " <audio-mute nick='me' xmlns='google:muc#media'/>"
472 listener->last_is_audio_muted = false;
473 xmpp_client->HandleStanza(
474 buzz::XmlElement::ForStr(incoming_remote_mute_me_message));
475 EXPECT_EQ("me", listener->last_mutee_nick);
476 EXPECT_EQ("muter", listener->last_muter_nick);
477 EXPECT_TRUE(listener->last_should_mute);
478 EXPECT_EQ("me", listener->last_audio_muted_nick);
479 EXPECT_TRUE(listener->last_is_audio_muted);
481 std::string incoming_media_block_message =
482 "<message xmlns='jabber:client' from='room@domain.com'>"
483 " <event xmlns='http://jabber.org/protocol/pubsub#event'>"
484 " <items node='google:muc#media'>"
485 " <item id='block:blocker:blockee'"
486 " publisher='room@domain.com/blocker'>"
487 " <block nick='blockee' xmlns='google:muc#media'/>"
493 xmpp_client->HandleStanza(
494 buzz::XmlElement::ForStr(incoming_media_block_message));
495 EXPECT_EQ("blockee", listener->last_blockee_nick);
496 EXPECT_EQ("blocker", listener->last_blocker_nick);
499 TEST_F(HangoutPubSubClientTest, TestRequestError) {
500 client->RequestAll();
501 std::string result_iq =
502 "<iq xmlns='jabber:client' id='0' type='error' from='room@domain.com'>"
503 " <error type='auth'>"
504 " <forbidden xmlns='urn:ietf:params:xml:ns:xmpp-stanzas'/>"
508 xmpp_client->HandleStanza(buzz::XmlElement::ForStr(result_iq));
509 EXPECT_EQ(1, listener->request_error_count);
510 EXPECT_EQ("google:presenter", listener->request_error_node);
513 TEST_F(HangoutPubSubClientTest, TestPublish) {
514 client->PublishPresenterState(true);
515 std::string expected_presenter_iq =
516 "<cli:iq type=\"set\" to=\"room@domain.com\" id=\"0\" "
517 "xmlns:cli=\"jabber:client\">"
518 "<pubsub xmlns=\"http://jabber.org/protocol/pubsub\">"
519 "<publish node=\"google:presenter\">"
521 "<presenter xmlns=\"google:presenter\""
523 "<pre:presentation-item"
524 " pre:presentation-type=\"s\" xmlns:pre=\"google:presenter\"/>"
530 ASSERT_EQ(1U, xmpp_client->sent_stanzas().size());
531 EXPECT_EQ(expected_presenter_iq,
532 xmpp_client->sent_stanzas()[0]->Str());
534 client->PublishAudioMuteState(true);
535 std::string expected_audio_mute_iq =
536 "<cli:iq type=\"set\" to=\"room@domain.com\" id=\"0\" "
537 "xmlns:cli=\"jabber:client\">"
538 "<pubsub xmlns=\"http://jabber.org/protocol/pubsub\">"
539 "<publish node=\"google:muc#media\">"
540 "<item id=\"audio-mute:me\">"
541 "<audio-mute xmlns=\"google:muc#media\" nick=\"me\"/>"
547 ASSERT_EQ(2U, xmpp_client->sent_stanzas().size());
548 EXPECT_EQ(expected_audio_mute_iq, xmpp_client->sent_stanzas()[1]->Str());
550 client->PublishVideoPauseState(true);
551 std::string expected_video_pause_iq =
552 "<cli:iq type=\"set\" to=\"room@domain.com\" id=\"0\" "
553 "xmlns:cli=\"jabber:client\">"
554 "<pubsub xmlns=\"http://jabber.org/protocol/pubsub\">"
555 "<publish node=\"google:muc#media\">"
556 "<item id=\"video-pause:me\">"
557 "<video-pause xmlns=\"google:muc#media\" nick=\"me\"/>"
563 ASSERT_EQ(3U, xmpp_client->sent_stanzas().size());
564 EXPECT_EQ(expected_video_pause_iq, xmpp_client->sent_stanzas()[2]->Str());
566 client->PublishRecordingState(true);
567 std::string expected_recording_iq =
568 "<cli:iq type=\"set\" to=\"room@domain.com\" id=\"0\" "
569 "xmlns:cli=\"jabber:client\">"
570 "<pubsub xmlns=\"http://jabber.org/protocol/pubsub\">"
571 "<publish node=\"google:muc#media\">"
572 "<item id=\"recording:me\">"
573 "<recording xmlns=\"google:muc#media\" nick=\"me\"/>"
579 ASSERT_EQ(4U, xmpp_client->sent_stanzas().size());
580 EXPECT_EQ(expected_recording_iq, xmpp_client->sent_stanzas()[3]->Str());
582 client->RemoteMute("mutee");
583 std::string expected_remote_mute_iq =
584 "<cli:iq type=\"set\" to=\"room@domain.com\" id=\"0\" "
585 "xmlns:cli=\"jabber:client\">"
586 "<pubsub xmlns=\"http://jabber.org/protocol/pubsub\">"
587 "<publish node=\"google:muc#media\">"
588 "<item id=\"audio-mute:mutee\">"
589 "<audio-mute xmlns=\"google:muc#media\" nick=\"mutee\"/>"
595 ASSERT_EQ(5U, xmpp_client->sent_stanzas().size());
596 EXPECT_EQ(expected_remote_mute_iq, xmpp_client->sent_stanzas()[4]->Str());
598 client->PublishPresenterState(false);
599 std::string expected_presenter_retract_iq =
600 "<cli:iq type=\"set\" to=\"room@domain.com\" id=\"0\" "
601 "xmlns:cli=\"jabber:client\">"
602 "<pubsub xmlns=\"http://jabber.org/protocol/pubsub\">"
603 "<publish node=\"google:presenter\">"
605 "<presenter xmlns=\"google:presenter\""
607 "<pre:presentation-item"
608 " pre:presentation-type=\"o\" xmlns:pre=\"google:presenter\"/>"
614 ASSERT_EQ(6U, xmpp_client->sent_stanzas().size());
615 EXPECT_EQ(expected_presenter_retract_iq,
616 xmpp_client->sent_stanzas()[5]->Str());
618 client->PublishAudioMuteState(false);
619 std::string expected_audio_mute_retract_iq =
620 "<cli:iq type=\"set\" to=\"room@domain.com\" id=\"0\" "
621 "xmlns:cli=\"jabber:client\">"
622 "<pubsub xmlns=\"http://jabber.org/protocol/pubsub\">"
623 "<retract node=\"google:muc#media\" notify=\"true\">"
624 "<item id=\"audio-mute:me\"/>"
629 ASSERT_EQ(7U, xmpp_client->sent_stanzas().size());
630 EXPECT_EQ(expected_audio_mute_retract_iq,
631 xmpp_client->sent_stanzas()[6]->Str());
633 client->PublishVideoPauseState(false);
634 std::string expected_video_pause_retract_iq =
635 "<cli:iq type=\"set\" to=\"room@domain.com\" id=\"0\" "
636 "xmlns:cli=\"jabber:client\">"
637 "<pubsub xmlns=\"http://jabber.org/protocol/pubsub\">"
638 "<retract node=\"google:muc#media\" notify=\"true\">"
639 "<item id=\"video-pause:me\"/>"
644 ASSERT_EQ(8U, xmpp_client->sent_stanzas().size());
645 EXPECT_EQ(expected_video_pause_retract_iq,
646 xmpp_client->sent_stanzas()[7]->Str());
648 client->BlockMedia("blockee");
649 std::string expected_media_block_iq =
650 "<cli:iq type=\"set\" to=\"room@domain.com\" id=\"0\" "
651 "xmlns:cli=\"jabber:client\">"
652 "<pubsub xmlns=\"http://jabber.org/protocol/pubsub\">"
653 "<publish node=\"google:muc#media\">"
654 "<item id=\"block:me:blockee\">"
655 "<block xmlns=\"google:muc#media\" nick=\"blockee\"/>"
661 ASSERT_EQ(9U, xmpp_client->sent_stanzas().size());
662 EXPECT_EQ(expected_media_block_iq, xmpp_client->sent_stanzas()[8]->Str());
665 TEST_F(HangoutPubSubClientTest, TestPublishPresenterError) {
666 std::string result_iq =
667 "<iq xmlns='jabber:client' id='0' type='error' from='room@domain.com'/>";
669 client->PublishPresenterState(true);
670 xmpp_client->HandleStanza(buzz::XmlElement::ForStr(result_iq));
671 EXPECT_EQ(1, listener->publish_presenter_error_count);
672 EXPECT_EQ("0", listener->error_task_id);
676 TEST_F(HangoutPubSubClientTest, TestPublishAudioMuteError) {
677 std::string result_iq =
678 "<iq xmlns='jabber:client' id='0' type='error' from='room@domain.com'/>";
680 client->PublishAudioMuteState(true);
681 xmpp_client->HandleStanza(buzz::XmlElement::ForStr(result_iq));
682 EXPECT_EQ(1, listener->publish_audio_mute_error_count);
683 EXPECT_EQ("0", listener->error_task_id);
686 TEST_F(HangoutPubSubClientTest, TestPublishVideoPauseError) {
687 std::string result_iq =
688 "<iq xmlns='jabber:client' id='0' type='error' from='room@domain.com'/>";
690 client->PublishVideoPauseState(true);
691 xmpp_client->HandleStanza(buzz::XmlElement::ForStr(result_iq));
692 EXPECT_EQ(1, listener->publish_video_pause_error_count);
693 EXPECT_EQ("0", listener->error_task_id);
696 TEST_F(HangoutPubSubClientTest, TestPublishRecordingError) {
697 std::string result_iq =
698 "<iq xmlns='jabber:client' id='0' type='error' from='room@domain.com'/>";
700 client->PublishRecordingState(true);
701 xmpp_client->HandleStanza(buzz::XmlElement::ForStr(result_iq));
702 EXPECT_EQ(1, listener->publish_recording_error_count);
703 EXPECT_EQ("0", listener->error_task_id);
706 TEST_F(HangoutPubSubClientTest, TestPublishRemoteMuteResult) {
707 std::string result_iq =
708 "<iq xmlns='jabber:client' id='0' type='result' from='room@domain.com'/>";
710 client->RemoteMute("joe");
711 xmpp_client->HandleStanza(buzz::XmlElement::ForStr(result_iq));
712 EXPECT_EQ("joe", listener->remote_mute_mutee_nick);
713 EXPECT_EQ("0", listener->result_task_id);
716 TEST_F(HangoutPubSubClientTest, TestRemoteMuteError) {
717 std::string result_iq =
718 "<iq xmlns='jabber:client' id='0' type='error' from='room@domain.com'/>";
720 client->RemoteMute("joe");
721 xmpp_client->HandleStanza(buzz::XmlElement::ForStr(result_iq));
722 EXPECT_EQ(1, listener->remote_mute_error_count);
723 EXPECT_EQ("joe", listener->remote_mute_mutee_nick);
724 EXPECT_EQ("0", listener->error_task_id);
727 TEST_F(HangoutPubSubClientTest, TestPublishMediaBlockResult) {
728 std::string result_iq =
729 "<iq xmlns='jabber:client' id='0' type='result' from='room@domain.com'/>";
731 client->BlockMedia("joe");
732 xmpp_client->HandleStanza(buzz::XmlElement::ForStr(result_iq));
733 EXPECT_EQ("joe", listener->media_blockee_nick);
734 EXPECT_EQ("0", listener->result_task_id);
737 TEST_F(HangoutPubSubClientTest, TestMediaBlockError) {
738 std::string result_iq =
739 "<iq xmlns='jabber:client' id='0' type='error' from='room@domain.com'/>";
741 client->BlockMedia("joe");
742 xmpp_client->HandleStanza(buzz::XmlElement::ForStr(result_iq));
743 EXPECT_EQ(1, listener->remote_mute_error_count);
744 EXPECT_EQ("joe", listener->media_blockee_nick);
745 EXPECT_EQ("0", listener->error_task_id);