remoting/host/heartbeat_sender_unittest.cc

   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
   5 #include "remoting/host/heartbeat_sender.h"
   6
   7 #include <set>
   8
   9 #include "base/memory/ref_counted.h"
  10 #include "base/message_loop/message_loop.h"
  11 #include "base/message_loop/message_loop_proxy.h"
  12 #include "base/strings/string_number_conversions.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/jingle_glue/iq_sender.h"
  17 #include "remoting/jingle_glue/mock_objects.h"
  18 #include "testing/gmock/include/gmock/gmock.h"
  19 #include "testing/gtest/include/gtest/gtest.h"
  20 #include "third_party/libjingle/source/talk/xmllite/xmlelement.h"
  21 #include "third_party/libjingle/source/talk/xmpp/constants.h"
  22
  23 using buzz::QName;
  24 using buzz::XmlElement;
  25
  26 using testing::_;
  27 using testing::DeleteArg;
  28 using testing::DoAll;
  29 using testing::Invoke;
  30 using testing::NotNull;
  31 using testing::Return;
  32 using testing::SaveArg;
  33
  34 namespace remoting {
  35
  36 namespace {
  37
  38 const char kTestBotJid[] = "remotingunittest@bot.talk.google.com";
  39 const char kHostId[] = "0";
  40 const char kTestJid[] = "user@gmail.com/chromoting123";
  41 const char kStanzaId[] = "123";
  42
  43 class MockListener : public HeartbeatSender::Listener {
  44  public:
  45   // Overridden from HeartbeatSender::Listener
  46   virtual void OnUnknownHostIdError() OVERRIDE {
  47     NOTREACHED();
  48   }
  49
  50   // Overridden from HeartbeatSender::Listener
  51   MOCK_METHOD0(OnHeartbeatSuccessful, void());
  52 };
  53
  54 }  // namespace
  55
  56 ACTION_P(AddListener, list) {
  57   list->insert(arg0);
  58 }
  59 ACTION_P(RemoveListener, list) {
  60   EXPECT_TRUE(list->find(arg0) != list->end());
  61   list->erase(arg0);
  62 }
  63
  64 class HeartbeatSenderTest
  65     : public testing::Test {
  66  protected:
  67   virtual void SetUp() OVERRIDE {
  68     key_pair_ = RsaKeyPair::FromString(kTestRsaKeyPair);
  69     ASSERT_TRUE(key_pair_.get());
  70
  71     EXPECT_CALL(signal_strategy_, GetState())
  72         .WillOnce(Return(SignalStrategy::DISCONNECTED));
  73     EXPECT_CALL(signal_strategy_, AddListener(NotNull()))
  74         .WillRepeatedly(AddListener(&signal_strategy_listeners_));
  75     EXPECT_CALL(signal_strategy_, RemoveListener(NotNull()))
  76         .WillRepeatedly(RemoveListener(&signal_strategy_listeners_));
  77     EXPECT_CALL(signal_strategy_, GetLocalJid())
  78         .WillRepeatedly(Return(kTestJid));
  79
  80     heartbeat_sender_.reset(new HeartbeatSender(
  81         &mock_listener_, kHostId, &signal_strategy_, key_pair_, kTestBotJid));
  82   }
  83
  84   virtual void TearDown() OVERRIDE {
  85     heartbeat_sender_.reset();
  86     EXPECT_TRUE(signal_strategy_listeners_.empty());
  87   }
  88
  89   void ValidateHeartbeatStanza(XmlElement* stanza,
  90                                const char* expectedSequenceId);
  91
  92   base::MessageLoop message_loop_;
  93   MockSignalStrategy signal_strategy_;
  94   MockListener mock_listener_;
  95   std::set<SignalStrategy::Listener*> signal_strategy_listeners_;
  96   scoped_refptr<RsaKeyPair> key_pair_;
  97   scoped_ptr<HeartbeatSender> heartbeat_sender_;
  98 };
  99
 100 // Call Start() followed by Stop(), and make sure a valid heartbeat is sent.
 101 TEST_F(HeartbeatSenderTest, DoSendStanza) {
 102   XmlElement* sent_iq = NULL;
 103   EXPECT_CALL(signal_strategy_, GetLocalJid())
 104       .WillRepeatedly(Return(kTestJid));
 105   EXPECT_CALL(signal_strategy_, GetNextId())
 106       .WillOnce(Return(kStanzaId));
 107   EXPECT_CALL(signal_strategy_, SendStanzaPtr(NotNull()))
 108       .WillOnce(DoAll(SaveArg<0>(&sent_iq), Return(true)));
 109
 110   heartbeat_sender_->OnSignalStrategyStateChange(SignalStrategy::CONNECTED);
 111   message_loop_.RunUntilIdle();
 112
 113   scoped_ptr<XmlElement> stanza(sent_iq);
 114   ASSERT_TRUE(stanza != NULL);
 115   ValidateHeartbeatStanza(stanza.get(), "0");
 116
 117   heartbeat_sender_->OnSignalStrategyStateChange(SignalStrategy::DISCONNECTED);
 118   message_loop_.RunUntilIdle();
 119 }
 120
 121 // Call Start() followed by Stop(), twice, and make sure two valid heartbeats
 122 // are sent, with the correct sequence IDs.
 123 TEST_F(HeartbeatSenderTest, DoSendStanzaTwice) {
 124   XmlElement* sent_iq = NULL;
 125   EXPECT_CALL(signal_strategy_, GetLocalJid())
 126       .WillRepeatedly(Return(kTestJid));
 127   EXPECT_CALL(signal_strategy_, GetNextId())
 128       .WillOnce(Return(kStanzaId));
 129   EXPECT_CALL(signal_strategy_, SendStanzaPtr(NotNull()))
 130       .WillOnce(DoAll(SaveArg<0>(&sent_iq), Return(true)));
 131
 132   heartbeat_sender_->OnSignalStrategyStateChange(SignalStrategy::CONNECTED);
 133   message_loop_.RunUntilIdle();
 134
 135   scoped_ptr<XmlElement> stanza(sent_iq);
 136   ASSERT_TRUE(stanza != NULL);
 137   ValidateHeartbeatStanza(stanza.get(), "0");
 138
 139   heartbeat_sender_->OnSignalStrategyStateChange(SignalStrategy::DISCONNECTED);
 140   message_loop_.RunUntilIdle();
 141
 142   EXPECT_CALL(signal_strategy_, GetLocalJid())
 143       .WillRepeatedly(Return(kTestJid));
 144   EXPECT_CALL(signal_strategy_, GetNextId())
 145       .WillOnce(Return(kStanzaId + 1));
 146   EXPECT_CALL(signal_strategy_, SendStanzaPtr(NotNull()))
 147       .WillOnce(DoAll(SaveArg<0>(&sent_iq), Return(true)));
 148
 149   heartbeat_sender_->OnSignalStrategyStateChange(SignalStrategy::CONNECTED);
 150   message_loop_.RunUntilIdle();
 151
 152   scoped_ptr<XmlElement> stanza2(sent_iq);
 153   ValidateHeartbeatStanza(stanza2.get(), "1");
 154
 155   heartbeat_sender_->OnSignalStrategyStateChange(SignalStrategy::DISCONNECTED);
 156   message_loop_.RunUntilIdle();
 157 }
 158
 159 // Call Start() followed by Stop(), make sure a valid Iq stanza is sent,
 160 // reply with an expected sequence ID, and make sure two valid heartbeats
 161 // are sent, with the correct sequence IDs.
 162 TEST_F(HeartbeatSenderTest, DoSendStanzaWithExpectedSequenceId) {
 163   XmlElement* sent_iq = NULL;
 164   EXPECT_CALL(signal_strategy_, GetLocalJid())
 165       .WillRepeatedly(Return(kTestJid));
 166   EXPECT_CALL(signal_strategy_, GetNextId())
 167       .WillOnce(Return(kStanzaId));
 168   EXPECT_CALL(signal_strategy_, SendStanzaPtr(NotNull()))
 169       .WillOnce(DoAll(SaveArg<0>(&sent_iq), Return(true)));
 170
 171   heartbeat_sender_->OnSignalStrategyStateChange(SignalStrategy::CONNECTED);
 172   message_loop_.RunUntilIdle();
 173
 174   scoped_ptr<XmlElement> stanza(sent_iq);
 175   ASSERT_TRUE(stanza != NULL);
 176   ValidateHeartbeatStanza(stanza.get(), "0");
 177
 178   XmlElement* sent_iq2 = NULL;
 179   EXPECT_CALL(signal_strategy_, GetLocalJid())
 180       .WillRepeatedly(Return(kTestJid));
 181   EXPECT_CALL(signal_strategy_, GetNextId())
 182       .WillOnce(Return(kStanzaId + 1));
 183   EXPECT_CALL(signal_strategy_, SendStanzaPtr(NotNull()))
 184       .WillOnce(DoAll(SaveArg<0>(&sent_iq2), Return(true)));
 185   EXPECT_CALL(mock_listener_, OnHeartbeatSuccessful());
 186
 187   scoped_ptr<XmlElement> response(new XmlElement(buzz::QN_IQ));
 188   response->AddAttr(QName(std::string(), "type"), "result");
 189   XmlElement* result =
 190       new XmlElement(QName(kChromotingXmlNamespace, "heartbeat-result"));
 191   response->AddElement(result);
 192   XmlElement* expected_sequence_id = new XmlElement(
 193       QName(kChromotingXmlNamespace, "expected-sequence-id"));
 194   result->AddElement(expected_sequence_id);
 195   const int kExpectedSequenceId = 456;
 196   expected_sequence_id->AddText(base::IntToString(kExpectedSequenceId));
 197   heartbeat_sender_->ProcessResponse(NULL, response.get());
 198   message_loop_.RunUntilIdle();
 199
 200   scoped_ptr<XmlElement> stanza2(sent_iq2);
 201   ASSERT_TRUE(stanza2 != NULL);
 202   ValidateHeartbeatStanza(stanza2.get(),
 203                           base::IntToString(kExpectedSequenceId).c_str());
 204
 205   heartbeat_sender_->OnSignalStrategyStateChange(SignalStrategy::DISCONNECTED);
 206   message_loop_.RunUntilIdle();
 207 }
 208
 209 // Verify that ProcessResponse parses set-interval result.
 210 TEST_F(HeartbeatSenderTest, ProcessResponseSetInterval) {
 211   EXPECT_CALL(mock_listener_, OnHeartbeatSuccessful());
 212
 213   scoped_ptr<XmlElement> response(new XmlElement(buzz::QN_IQ));
 214   response->AddAttr(QName(std::string(), "type"), "result");
 215
 216   XmlElement* result = new XmlElement(
 217       QName(kChromotingXmlNamespace, "heartbeat-result"));
 218   response->AddElement(result);
 219
 220   XmlElement* set_interval = new XmlElement(
 221       QName(kChromotingXmlNamespace, "set-interval"));
 222   result->AddElement(set_interval);
 223
 224   const int kTestInterval = 123;
 225   set_interval->AddText(base::IntToString(kTestInterval));
 226
 227   heartbeat_sender_->ProcessResponse(NULL, response.get());
 228
 229   EXPECT_EQ(kTestInterval * 1000, heartbeat_sender_->interval_ms_);
 230 }
 231
 232 // Validate a heartbeat stanza.
 233 void HeartbeatSenderTest::ValidateHeartbeatStanza(
 234     XmlElement* stanza, const char* expectedSequenceId) {
 235   EXPECT_EQ(stanza->Attr(buzz::QName(std::string(), "to")),
 236             std::string(kTestBotJid));
 237   EXPECT_EQ(stanza->Attr(buzz::QName(std::string(), "type")), "set");
 238   XmlElement* heartbeat_stanza =
 239       stanza->FirstNamed(QName(kChromotingXmlNamespace, "heartbeat"));
 240   ASSERT_TRUE(heartbeat_stanza != NULL);
 241   EXPECT_EQ(expectedSequenceId, heartbeat_stanza->Attr(
 242       buzz::QName(kChromotingXmlNamespace, "sequence-id")));
 243   EXPECT_EQ(std::string(kHostId),
 244             heartbeat_stanza->Attr(QName(kChromotingXmlNamespace, "hostid")));
 245
 246   QName signature_tag(kChromotingXmlNamespace, "signature");
 247   XmlElement* signature = heartbeat_stanza->FirstNamed(signature_tag);
 248   ASSERT_TRUE(signature != NULL);
 249   EXPECT_TRUE(heartbeat_stanza->NextNamed(signature_tag) == NULL);
 250
 251   scoped_refptr<RsaKeyPair> key_pair = RsaKeyPair::FromString(kTestRsaKeyPair);
 252   ASSERT_TRUE(key_pair.get());
 253   std::string expected_signature =
 254       key_pair->SignMessage(std::string(kTestJid) + ' ' + expectedSequenceId);
 255   EXPECT_EQ(expected_signature, signature->BodyText());
 256 }
 257
 258 }  // namespace remoting