xmpp_register_support_host_request_unittest.cc 6.8 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191
  1. // Copyright (c) 2012 The Chromium Authors. All rights reserved.
  2. // Use of this source code is governed by a BSD-style license that can be
  3. // found in the LICENSE file.
  4. #include "remoting/host/xmpp_register_support_host_request.h"
  5. #include <stdint.h>
  6. #include "base/bind.h"
  7. #include "base/memory/ref_counted.h"
  8. #include "base/observer_list.h"
  9. #include "base/strings/string_number_conversions.h"
  10. #include "base/strings/stringize_macros.h"
  11. #include "base/test/mock_callback.h"
  12. #include "base/test/task_environment.h"
  13. #include "remoting/base/constants.h"
  14. #include "remoting/base/rsa_key_pair.h"
  15. #include "remoting/base/test_rsa_key_pair.h"
  16. #include "remoting/host/host_details.h"
  17. #include "remoting/protocol/errors.h"
  18. #include "remoting/signaling/iq_sender.h"
  19. #include "remoting/signaling/mock_signal_strategy.h"
  20. #include "remoting/signaling/signaling_address.h"
  21. #include "remoting/signaling/xmpp_constants.h"
  22. #include "testing/gmock/include/gmock/gmock.h"
  23. #include "testing/gtest/include/gtest/gtest.h"
  24. #include "third_party/libjingle_xmpp/xmllite/xmlelement.h"
  25. using jingle_xmpp::QName;
  26. using jingle_xmpp::XmlElement;
  27. using testing::_;
  28. using testing::DeleteArg;
  29. using testing::DoAll;
  30. using testing::Invoke;
  31. using testing::NotNull;
  32. using testing::Return;
  33. using testing::SaveArg;
  34. namespace remoting {
  35. using protocol::ErrorCode;
  36. namespace {
  37. const char kTestBotJid[] = "remotingunittest@bot.talk.google.com";
  38. const char kTestJid[] = "User@gmail.com/chromotingABC123";
  39. const char kTestJidNormalized[] = "user@gmail.com/chromotingABC123";
  40. const char kSupportId[] = "AB4RF3";
  41. const char kSupportIdLifetime[] = "300";
  42. const char kStanzaId[] = "123";
  43. ACTION_P(AddListener, list) {
  44. list->AddObserver(arg0);
  45. }
  46. ACTION_P(RemoveListener, list) {
  47. list->RemoveObserver(arg0);
  48. }
  49. } // namespace
  50. class XmppRegisterSupportHostRequestTest : public testing::Test {
  51. public:
  52. protected:
  53. XmppRegisterSupportHostRequestTest()
  54. : signal_strategy_(SignalingAddress(kTestJid)) {}
  55. void SetUp() override {
  56. key_pair_ = RsaKeyPair::FromString(kTestRsaKeyPair);
  57. ASSERT_TRUE(key_pair_.get());
  58. EXPECT_CALL(signal_strategy_, AddListener(NotNull()))
  59. .WillRepeatedly(AddListener(&signal_strategy_listeners_));
  60. EXPECT_CALL(signal_strategy_, RemoveListener(NotNull()))
  61. .WillRepeatedly(RemoveListener(&signal_strategy_listeners_));
  62. }
  63. base::test::TaskEnvironment task_environment_{
  64. base::test::TaskEnvironment::TimeSource::MOCK_TIME};
  65. MockSignalStrategy signal_strategy_;
  66. base::ObserverList<SignalStrategy::Listener, true> signal_strategy_listeners_;
  67. scoped_refptr<RsaKeyPair> key_pair_;
  68. base::MockCallback<RegisterSupportHostRequest::RegisterCallback> callback_;
  69. };
  70. TEST_F(XmppRegisterSupportHostRequestTest, Timeout) {
  71. auto request = std::make_unique<XmppRegisterSupportHostRequest>(kTestBotJid);
  72. request->StartRequest(&signal_strategy_, key_pair_, callback_.Get());
  73. EXPECT_CALL(signal_strategy_, GetNextId()).WillOnce(Return(kStanzaId));
  74. EXPECT_CALL(signal_strategy_, SendStanzaPtr(NotNull()))
  75. .WillOnce(DoAll(DeleteArg<0>(), Return(true)));
  76. request->OnSignalStrategyStateChange(SignalStrategy::CONNECTED);
  77. // Generate response and verify that callback is called.
  78. EXPECT_CALL(callback_,
  79. Run("", base::Seconds(0), ErrorCode::SIGNALING_TIMEOUT));
  80. task_environment_.FastForwardBy(base::Seconds(15));
  81. }
  82. TEST_F(XmppRegisterSupportHostRequestTest, Send) {
  83. // |iq_request| is freed by XmppRegisterSupportHostRequest.
  84. int64_t start_time = static_cast<int64_t>(base::Time::Now().ToDoubleT());
  85. auto request = std::make_unique<XmppRegisterSupportHostRequest>(kTestBotJid);
  86. request->StartRequest(&signal_strategy_, key_pair_, callback_.Get());
  87. XmlElement* sent_iq = nullptr;
  88. EXPECT_CALL(signal_strategy_, GetNextId()).WillOnce(Return(kStanzaId));
  89. EXPECT_CALL(signal_strategy_, SendStanzaPtr(NotNull()))
  90. .WillOnce(DoAll(SaveArg<0>(&sent_iq), Return(true)));
  91. request->OnSignalStrategyStateChange(SignalStrategy::CONNECTED);
  92. task_environment_.RunUntilIdle();
  93. // Verify format of the query.
  94. std::unique_ptr<XmlElement> stanza(sent_iq);
  95. ASSERT_TRUE(stanza != nullptr);
  96. EXPECT_EQ(stanza->Attr(jingle_xmpp::QName(std::string(), "to")),
  97. std::string(kTestBotJid));
  98. EXPECT_EQ(stanza->Attr(jingle_xmpp::QName(std::string(), "type")), "set");
  99. EXPECT_EQ(QName(kChromotingXmlNamespace, "register-support-host"),
  100. stanza->FirstElement()->Name());
  101. QName signature_tag(kChromotingXmlNamespace, "signature");
  102. XmlElement* signature = stanza->FirstElement()->FirstNamed(signature_tag);
  103. ASSERT_TRUE(signature != nullptr);
  104. EXPECT_TRUE(stanza->NextNamed(signature_tag) == nullptr);
  105. std::string time_str =
  106. signature->Attr(QName(kChromotingXmlNamespace, "time"));
  107. int64_t time;
  108. EXPECT_TRUE(base::StringToInt64(time_str, &time));
  109. int64_t now = static_cast<int64_t>(base::Time::Now().ToDoubleT());
  110. EXPECT_LE(start_time, time);
  111. EXPECT_GE(now, time);
  112. XmlElement* host_version = stanza->FirstElement()->FirstNamed(
  113. QName(kChromotingXmlNamespace, "host-version"));
  114. EXPECT_EQ(STRINGIZE(VERSION), host_version->BodyText());
  115. XmlElement* host_os_name = stanza->FirstElement()->FirstNamed(
  116. QName(kChromotingXmlNamespace, "host-os-name"));
  117. EXPECT_EQ(GetHostOperatingSystemName(), host_os_name->BodyText());
  118. XmlElement* host_os_version = stanza->FirstElement()->FirstNamed(
  119. QName(kChromotingXmlNamespace, "host-os-version"));
  120. EXPECT_EQ(GetHostOperatingSystemVersion(), host_os_version->BodyText());
  121. scoped_refptr<RsaKeyPair> key_pair = RsaKeyPair::FromString(kTestRsaKeyPair);
  122. ASSERT_TRUE(key_pair.get());
  123. std::string expected_signature =
  124. key_pair->SignMessage(std::string(kTestJidNormalized) + ' ' + time_str);
  125. EXPECT_EQ(expected_signature, signature->BodyText());
  126. // Generate response and verify that callback is called.
  127. EXPECT_CALL(callback_, Run(kSupportId, base::Seconds(300), ErrorCode::OK));
  128. std::unique_ptr<XmlElement> response(new XmlElement(kQNameIq));
  129. response->AddAttr(QName(std::string(), "from"), kTestBotJid);
  130. response->AddAttr(QName(std::string(), "type"), "result");
  131. response->AddAttr(QName(std::string(), "id"), kStanzaId);
  132. XmlElement* result = new XmlElement(
  133. QName(kChromotingXmlNamespace, "register-support-host-result"));
  134. response->AddElement(result);
  135. XmlElement* support_id =
  136. new XmlElement(QName(kChromotingXmlNamespace, "support-id"));
  137. support_id->AddText(kSupportId);
  138. result->AddElement(support_id);
  139. XmlElement* support_id_lifetime =
  140. new XmlElement(QName(kChromotingXmlNamespace, "support-id-lifetime"));
  141. support_id_lifetime->AddText(kSupportIdLifetime);
  142. result->AddElement(support_id_lifetime);
  143. int consumed = 0;
  144. for (auto& listener : signal_strategy_listeners_) {
  145. if (listener.OnSignalStrategyIncomingStanza(response.get()))
  146. consumed++;
  147. }
  148. EXPECT_EQ(1, consumed);
  149. task_environment_.RunUntilIdle();
  150. }
  151. } // namespace remoting