remoting/client/client_status_logger_unittest.cc

   1 // Copyright 2014 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/client/client_status_logger.h"
   6
   7 #include "base/message_loop/message_loop.h"
   8 #include "base/message_loop/message_loop_proxy.h"
   9 #include "remoting/client/chromoting_stats.h"
  10 #include "remoting/signaling/mock_signal_strategy.h"
  11 #include "remoting/signaling/server_log_entry_unittest.h"
  12 #include "testing/gmock/include/gmock/gmock.h"
  13 #include "testing/gtest/include/gtest/gtest.h"
  14 #include "third_party/webrtc/libjingle/xmllite/xmlelement.h"
  15
  16 using buzz::XmlElement;
  17 using buzz::QName;
  18 using remoting::protocol::ConnectionToHost;
  19 using testing::_;
  20 using testing::DeleteArg;
  21 using testing::InSequence;
  22 using testing::Return;
  23
  24 namespace remoting {
  25
  26 namespace {
  27
  28 ACTION_P(QuitMainMessageLoop, message_loop) {
  29   message_loop->PostTask(FROM_HERE, base::MessageLoop::QuitClosure());
  30 }
  31
  32 const char kTestBotJid[] = "remotingunittest@bot.talk.google.com";
  33 const char kClientJid[] = "host@domain.com/1234";
  34
  35 MATCHER_P2(IsStateChange, new_state, error, "") {
  36   XmlElement* entry = GetSingleLogEntryFromStanza(arg);
  37   if (!entry) {
  38     return false;
  39   }
  40
  41   bool is_state_change = (
  42       entry->Attr(QName(std::string(), "event-name")) == "session-state" &&
  43       entry->Attr(QName(std::string(), "session-state")) == new_state &&
  44       entry->Attr(QName(std::string(), "role")) == "client" &&
  45       entry->Attr(QName(std::string(), "mode")) == "me2me");
  46   if (!std::string(error).empty()) {
  47     is_state_change = is_state_change &&
  48         entry->Attr(QName(std::string(), "connection-error")) == error;
  49   }
  50   return is_state_change;
  51 }
  52
  53 MATCHER(IsStatisticsLog, "") {
  54   XmlElement* entry = GetSingleLogEntryFromStanza(arg);
  55   if (!entry) {
  56     return false;
  57   }
  58
  59   return entry->Attr(QName(std::string(), "event-name")) ==
  60       "connection-statistics";
  61 }
  62
  63 }  // namespace
  64
  65 class ClientStatusLoggerTest : public testing::Test {
  66  public:
  67   ClientStatusLoggerTest() {}
  68   virtual void SetUp() OVERRIDE {
  69     EXPECT_CALL(signal_strategy_, AddListener(_));
  70     EXPECT_CALL(signal_strategy_, RemoveListener(_));
  71     message_loop_proxy_ = base::MessageLoopProxy::current();
  72     client_status_logger_.reset(
  73         new ClientStatusLogger(ServerLogEntry::ME2ME,
  74                                &signal_strategy_,
  75                                kTestBotJid));
  76   }
  77
  78  protected:
  79   base::MessageLoop message_loop_;
  80   scoped_refptr<base::MessageLoopProxy> message_loop_proxy_;
  81   MockSignalStrategy signal_strategy_;
  82   scoped_ptr<ClientStatusLogger> client_status_logger_;
  83 };
  84
  85 TEST_F(ClientStatusLoggerTest, LogStateChange) {
  86   {
  87     InSequence s;
  88     EXPECT_CALL(signal_strategy_, GetLocalJid())
  89         .WillRepeatedly(Return(kClientJid));
  90     EXPECT_CALL(signal_strategy_, AddListener(_));
  91     EXPECT_CALL(signal_strategy_, GetNextId());
  92     EXPECT_CALL(signal_strategy_, SendStanzaPtr(
  93         IsStateChange("connected", std::string())))
  94         .WillOnce(DoAll(DeleteArg<0>(), Return(true)));
  95     EXPECT_CALL(signal_strategy_, RemoveListener(_))
  96         .WillOnce(QuitMainMessageLoop(&message_loop_))
  97         .RetiresOnSaturation();
  98   }
  99   client_status_logger_->LogSessionStateChange(ConnectionToHost::CONNECTED,
 100                                                protocol::OK);
 101
 102   // Setting the state to CONNECTED causes the log to be sent. Setting the
 103   // state to DISCONNECTED causes |signal_strategy_| to be cleaned up,
 104   // which removes the listener and terminates the test.
 105   client_status_logger_->SetSignalingStateForTest(SignalStrategy::CONNECTED);
 106   client_status_logger_->SetSignalingStateForTest(SignalStrategy::DISCONNECTED);
 107   message_loop_.Run();
 108 }
 109
 110 TEST_F(ClientStatusLoggerTest, LogStateChangeError) {
 111   {
 112     InSequence s;
 113     EXPECT_CALL(signal_strategy_, GetLocalJid())
 114         .WillRepeatedly(Return(kClientJid));
 115     EXPECT_CALL(signal_strategy_, AddListener(_));
 116     EXPECT_CALL(signal_strategy_, GetNextId());
 117     EXPECT_CALL(signal_strategy_, SendStanzaPtr(
 118         IsStateChange("connection-failed", "host-is-offline")))
 119         .WillOnce(DoAll(DeleteArg<0>(), Return(true)));
 120     EXPECT_CALL(signal_strategy_, RemoveListener(_))
 121         .WillOnce(QuitMainMessageLoop(&message_loop_))
 122         .RetiresOnSaturation();
 123   }
 124   client_status_logger_->LogSessionStateChange(ConnectionToHost::FAILED,
 125                                                protocol::PEER_IS_OFFLINE);
 126
 127   client_status_logger_->SetSignalingStateForTest(SignalStrategy::CONNECTED);
 128   client_status_logger_->SetSignalingStateForTest(SignalStrategy::DISCONNECTED);
 129   message_loop_.Run();
 130 }
 131
 132 TEST_F(ClientStatusLoggerTest, LogStatistics) {
 133   {
 134     InSequence s;
 135     EXPECT_CALL(signal_strategy_, GetLocalJid())
 136         .WillRepeatedly(Return(kClientJid));
 137     EXPECT_CALL(signal_strategy_, AddListener(_));
 138     EXPECT_CALL(signal_strategy_, GetNextId());
 139     EXPECT_CALL(signal_strategy_, SendStanzaPtr(
 140         IsStatisticsLog()))
 141         .WillOnce(DoAll(DeleteArg<0>(), Return(true)));
 142     EXPECT_CALL(signal_strategy_, RemoveListener(_))
 143         .WillOnce(QuitMainMessageLoop(&message_loop_))
 144         .RetiresOnSaturation();
 145   }
 146
 147   ChromotingStats stats;
 148   client_status_logger_->LogStatistics(&stats);
 149
 150   client_status_logger_->SetSignalingStateForTest(SignalStrategy::CONNECTED);
 151   client_status_logger_->SetSignalingStateForTest(SignalStrategy::DISCONNECTED);
 152   message_loop_.Run();
 153 }
 154
 155 }  // namespace remoting