jingle/notifier/communicator/single_login_attempt_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 "jingle/notifier/communicator/single_login_attempt.h"
   6
   7 #include <cstddef>
   8
   9 #include "base/compiler_specific.h"
  10 #include "base/memory/scoped_ptr.h"
  11 #include "base/message_loop/message_loop.h"
  12 #include "base/thread_task_runner_handle.h"
  13 #include "jingle/notifier/base/const_communicator.h"
  14 #include "jingle/notifier/base/fake_base_task.h"
  15 #include "jingle/notifier/communicator/login_settings.h"
  16 #include "net/dns/mock_host_resolver.h"
  17 #include "net/url_request/url_request_test_util.h"
  18 #include "testing/gtest/include/gtest/gtest.h"
  19 #include "third_party/webrtc/libjingle/xmllite/xmlelement.h"
  20 #include "webrtc/libjingle/xmpp/constants.h"
  21 #include "webrtc/libjingle/xmpp/xmppengine.h"
  22
  23 namespace buzz {
  24 class XmppTaskParentInterface;
  25 }  // namespace buzz
  26
  27 namespace notifier {
  28
  29 namespace {
  30
  31 enum DelegateState {
  32   IDLE, CONNECTED, REDIRECTED, CREDENTIALS_REJECTED, SETTINGS_EXHAUSTED
  33 };
  34
  35 class FakeDelegate : public SingleLoginAttempt::Delegate {
  36  public:
  37   FakeDelegate() : state_(IDLE) {}
  38
  39   void OnConnect(
  40       base::WeakPtr<buzz::XmppTaskParentInterface> base_task) override {
  41     state_ = CONNECTED;
  42     base_task_ = base_task;
  43   }
  44
  45   void OnRedirect(const ServerInformation& redirect_server) override {
  46     state_ = REDIRECTED;
  47     redirect_server_ = redirect_server;
  48   }
  49
  50   void OnCredentialsRejected() override { state_ = CREDENTIALS_REJECTED; }
  51
  52   void OnSettingsExhausted() override { state_ = SETTINGS_EXHAUSTED; }
  53
  54   DelegateState state() const { return state_; }
  55
  56   base::WeakPtr<buzz::XmppTaskParentInterface> base_task() const {
  57     return base_task_;
  58   }
  59
  60   const ServerInformation& redirect_server() const {
  61     return redirect_server_;
  62   }
  63
  64  private:
  65   DelegateState state_;
  66   base::WeakPtr<buzz::XmppTaskParentInterface> base_task_;
  67   ServerInformation redirect_server_;
  68 };
  69
  70 class MyTestURLRequestContext : public net::TestURLRequestContext {
  71  public:
  72   MyTestURLRequestContext() : TestURLRequestContext(true) {
  73     context_storage_.set_host_resolver(
  74         scoped_ptr<net::HostResolver>(new net::HangingHostResolver()));
  75     Init();
  76   }
  77   ~MyTestURLRequestContext() override {}
  78 };
  79
  80 class SingleLoginAttemptTest : public ::testing::Test {
  81  protected:
  82   SingleLoginAttemptTest()
  83       : login_settings_(
  84           buzz::XmppClientSettings(),
  85           new net::TestURLRequestContextGetter(
  86               base::ThreadTaskRunnerHandle::Get(),
  87               scoped_ptr<net::TestURLRequestContext>(
  88                   new MyTestURLRequestContext())),
  89           ServerList(
  90               1,
  91               ServerInformation(
  92                   net::HostPortPair("example.com", 100), SUPPORTS_SSLTCP)),
  93           false /* try_ssltcp_first */,
  94           "auth_mechanism"),
  95         attempt_(new SingleLoginAttempt(login_settings_, &fake_delegate_)) {}
  96
  97   void TearDown() override { message_loop_.RunUntilIdle(); }
  98
  99   void FireRedirect(buzz::XmlElement* redirect_error) {
 100     attempt_->OnError(buzz::XmppEngine::ERROR_STREAM, 0, redirect_error);
 101   }
 102
 103   ~SingleLoginAttemptTest() override {
 104     attempt_.reset();
 105     message_loop_.RunUntilIdle();
 106   }
 107
 108  private:
 109   base::MessageLoop message_loop_;
 110   const LoginSettings login_settings_;
 111
 112  protected:
 113   scoped_ptr<SingleLoginAttempt> attempt_;
 114   FakeDelegate fake_delegate_;
 115   FakeBaseTask fake_base_task_;
 116 };
 117
 118 // Fire OnConnect and make sure the base task gets passed to the
 119 // delegate properly.
 120 TEST_F(SingleLoginAttemptTest, Basic) {
 121   attempt_->OnConnect(fake_base_task_.AsWeakPtr());
 122   EXPECT_EQ(CONNECTED, fake_delegate_.state());
 123   EXPECT_EQ(fake_base_task_.AsWeakPtr().get(),
 124             fake_delegate_.base_task().get());
 125 }
 126
 127 // Fire OnErrors and make sure the delegate gets the
 128 // OnSettingsExhausted() event.
 129 TEST_F(SingleLoginAttemptTest, Error) {
 130   for (int i = 0; i < 2; ++i) {
 131     EXPECT_EQ(IDLE, fake_delegate_.state());
 132     attempt_->OnError(buzz::XmppEngine::ERROR_NONE, 0, NULL);
 133   }
 134   EXPECT_EQ(SETTINGS_EXHAUSTED, fake_delegate_.state());
 135 }
 136
 137 // Fire OnErrors but replace the last one with OnConnect, and make
 138 // sure the delegate still gets the OnConnect message.
 139 TEST_F(SingleLoginAttemptTest, ErrorThenSuccess) {
 140   attempt_->OnError(buzz::XmppEngine::ERROR_NONE, 0, NULL);
 141   attempt_->OnConnect(fake_base_task_.AsWeakPtr());
 142   EXPECT_EQ(CONNECTED, fake_delegate_.state());
 143   EXPECT_EQ(fake_base_task_.AsWeakPtr().get(),
 144             fake_delegate_.base_task().get());
 145 }
 146
 147 buzz::XmlElement* MakeRedirectError(const std::string& redirect_server) {
 148   buzz::XmlElement* stream_error =
 149       new buzz::XmlElement(buzz::QN_STREAM_ERROR, true);
 150   stream_error->AddElement(
 151       new buzz::XmlElement(buzz::QN_XSTREAM_SEE_OTHER_HOST, true));
 152   buzz::XmlElement* text =
 153       new buzz::XmlElement(buzz::QN_XSTREAM_TEXT, true);
 154   stream_error->AddElement(text);
 155   text->SetBodyText(redirect_server);
 156   return stream_error;
 157 }
 158
 159 // Fire a redirect and make sure the delegate gets the proper redirect
 160 // server info.
 161 TEST_F(SingleLoginAttemptTest, Redirect) {
 162   const ServerInformation redirect_server(
 163       net::HostPortPair("example.com", 1000),
 164       SUPPORTS_SSLTCP);
 165
 166   scoped_ptr<buzz::XmlElement> redirect_error(
 167       MakeRedirectError(redirect_server.server.ToString()));
 168   FireRedirect(redirect_error.get());
 169
 170   EXPECT_EQ(REDIRECTED, fake_delegate_.state());
 171   EXPECT_TRUE(fake_delegate_.redirect_server().Equals(redirect_server));
 172 }
 173
 174 // Fire a redirect with the host only and make sure the delegate gets
 175 // the proper redirect server info with the default XMPP port.
 176 TEST_F(SingleLoginAttemptTest, RedirectHostOnly) {
 177   const ServerInformation redirect_server(
 178       net::HostPortPair("example.com", kDefaultXmppPort),
 179       SUPPORTS_SSLTCP);
 180
 181   scoped_ptr<buzz::XmlElement> redirect_error(
 182       MakeRedirectError(redirect_server.server.host()));
 183   FireRedirect(redirect_error.get());
 184
 185   EXPECT_EQ(REDIRECTED, fake_delegate_.state());
 186   EXPECT_TRUE(fake_delegate_.redirect_server().Equals(redirect_server));
 187 }
 188
 189 // Fire a redirect with a zero port and make sure the delegate gets
 190 // the proper redirect server info with the default XMPP port.
 191 TEST_F(SingleLoginAttemptTest, RedirectZeroPort) {
 192   const ServerInformation redirect_server(
 193       net::HostPortPair("example.com", kDefaultXmppPort),
 194       SUPPORTS_SSLTCP);
 195
 196   scoped_ptr<buzz::XmlElement> redirect_error(
 197       MakeRedirectError(redirect_server.server.host() + ":0"));
 198   FireRedirect(redirect_error.get());
 199
 200   EXPECT_EQ(REDIRECTED, fake_delegate_.state());
 201   EXPECT_TRUE(fake_delegate_.redirect_server().Equals(redirect_server));
 202 }
 203
 204 // Fire a redirect with an invalid port and make sure the delegate
 205 // gets the proper redirect server info with the default XMPP port.
 206 TEST_F(SingleLoginAttemptTest, RedirectInvalidPort) {
 207   const ServerInformation redirect_server(
 208       net::HostPortPair("example.com", kDefaultXmppPort),
 209       SUPPORTS_SSLTCP);
 210
 211   scoped_ptr<buzz::XmlElement> redirect_error(
 212       MakeRedirectError(redirect_server.server.host() + ":invalidport"));
 213   FireRedirect(redirect_error.get());
 214
 215   EXPECT_EQ(REDIRECTED, fake_delegate_.state());
 216   EXPECT_TRUE(fake_delegate_.redirect_server().Equals(redirect_server));
 217 }
 218
 219 // Fire an empty redirect and make sure the delegate does not get a
 220 // redirect.
 221 TEST_F(SingleLoginAttemptTest, RedirectEmpty) {
 222   scoped_ptr<buzz::XmlElement> redirect_error(MakeRedirectError(std::string()));
 223   FireRedirect(redirect_error.get());
 224   EXPECT_EQ(IDLE, fake_delegate_.state());
 225 }
 226
 227 // Fire a redirect with a missing text element and make sure the
 228 // delegate does not get a redirect.
 229 TEST_F(SingleLoginAttemptTest, RedirectMissingText) {
 230   scoped_ptr<buzz::XmlElement> redirect_error(MakeRedirectError(std::string()));
 231   redirect_error->RemoveChildAfter(redirect_error->FirstChild());
 232   FireRedirect(redirect_error.get());
 233   EXPECT_EQ(IDLE, fake_delegate_.state());
 234 }
 235
 236 // Fire a redirect with a missing see-other-host element and make sure
 237 // the delegate does not get a redirect.
 238 TEST_F(SingleLoginAttemptTest, RedirectMissingSeeOtherHost) {
 239   scoped_ptr<buzz::XmlElement> redirect_error(MakeRedirectError(std::string()));
 240   redirect_error->RemoveChildAfter(NULL);
 241   FireRedirect(redirect_error.get());
 242   EXPECT_EQ(IDLE, fake_delegate_.state());
 243 }
 244
 245 // Fire 'Unauthorized' errors and make sure the delegate gets the
 246 // OnCredentialsRejected() event.
 247 TEST_F(SingleLoginAttemptTest, CredentialsRejected) {
 248   attempt_->OnError(buzz::XmppEngine::ERROR_UNAUTHORIZED, 0, NULL);
 249   EXPECT_EQ(CREDENTIALS_REJECTED, fake_delegate_.state());
 250 }
 251
 252 }  // namespace
 253
 254 }  // namespace notifier