chrome/browser/local_discovery/privet_url_fetcher_unittest.cc

   1 // Copyright 2013 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 "chrome/browser/local_discovery/privet_url_fetcher.h"
   6 #include "net/url_request/test_url_fetcher_factory.h"
   7 #include "net/url_request/url_request_test_util.h"
   8 #include "testing/gmock/include/gmock/gmock.h"
   9 #include "testing/gtest/include/gtest/gtest.h"
  10
  11 using testing::StrictMock;
  12
  13 namespace local_discovery {
  14
  15 namespace {
  16
  17 const char kSamplePrivetURL[] =
  18     "http://10.0.0.8:7676/privet/register?action=start";
  19 const char kSamplePrivetToken[] = "MyToken";
  20 const char kEmptyPrivetToken[] = "\"\"";
  21
  22 const char kSampleParsableJSON[] = "{ \"hello\" : 2 }";
  23 const char kSampleUnparsableJSON[] = "{ \"hello\" : }";
  24 const char kSampleJSONWithError[] = "{ \"error\" : \"unittest_example\" }";
  25
  26 class MockPrivetURLFetcherDelegate : public PrivetURLFetcher::Delegate {
  27  public:
  28   virtual void OnError(PrivetURLFetcher* fetcher,
  29                        PrivetURLFetcher::ErrorType error) OVERRIDE {
  30     OnErrorInternal(error);
  31   }
  32
  33   MOCK_METHOD1(OnErrorInternal, void(PrivetURLFetcher::ErrorType error));
  34
  35   virtual void OnParsedJson(PrivetURLFetcher* fetcher,
  36                             const base::DictionaryValue* value,
  37                             bool has_error) OVERRIDE {
  38     saved_value_.reset(value->DeepCopy());
  39     OnParsedJsonInternal(has_error);
  40   }
  41
  42   MOCK_METHOD1(OnParsedJsonInternal, void(bool has_error));
  43
  44   virtual void OnNeedPrivetToken(
  45       PrivetURLFetcher* fetcher,
  46       const PrivetURLFetcher::TokenCallback& callback) {
  47   }
  48
  49   const base::DictionaryValue* saved_value() { return saved_value_.get(); }
  50
  51  private:
  52   scoped_ptr<base::DictionaryValue> saved_value_;
  53 };
  54
  55 class PrivetURLFetcherTest : public ::testing::Test {
  56  public:
  57   PrivetURLFetcherTest() {
  58     request_context_= new net::TestURLRequestContextGetter(
  59         base::MessageLoopProxy::current());
  60     privet_urlfetcher_.reset(new PrivetURLFetcher(
  61         kSamplePrivetToken,
  62         GURL(kSamplePrivetURL),
  63         net::URLFetcher::POST,
  64         request_context_.get(),
  65         &delegate_));
  66   }
  67   virtual ~PrivetURLFetcherTest() {
  68   }
  69
  70   void RunFor(base::TimeDelta time_period) {
  71     base::CancelableCallback<void()> callback(base::Bind(
  72         &PrivetURLFetcherTest::Stop, base::Unretained(this)));
  73     base::MessageLoop::current()->PostDelayedTask(
  74         FROM_HERE, callback.callback(), time_period);
  75
  76     base::MessageLoop::current()->Run();
  77     callback.Cancel();
  78   }
  79
  80   void Stop() {
  81     base::MessageLoop::current()->Quit();
  82   }
  83
  84  protected:
  85   base::MessageLoop loop_;
  86   scoped_refptr<net::TestURLRequestContextGetter> request_context_;
  87   net::TestURLFetcherFactory fetcher_factory_;
  88   scoped_ptr<PrivetURLFetcher> privet_urlfetcher_;
  89   StrictMock<MockPrivetURLFetcherDelegate> delegate_;
  90 };
  91
  92 TEST_F(PrivetURLFetcherTest, FetchSuccess) {
  93   privet_urlfetcher_->Start();
  94   net::TestURLFetcher* fetcher = fetcher_factory_.GetFetcherByID(0);
  95   ASSERT_TRUE(fetcher != NULL);
  96   fetcher->SetResponseString(kSampleParsableJSON);
  97   fetcher->set_status(net::URLRequestStatus(net::URLRequestStatus::SUCCESS,
  98                                             net::OK));
  99   fetcher->set_response_code(200);
 100
 101   EXPECT_CALL(delegate_, OnParsedJsonInternal(false));
 102   fetcher->delegate()->OnURLFetchComplete(fetcher);
 103
 104   const base::DictionaryValue* value = delegate_.saved_value();
 105   int hello_value;
 106   ASSERT_TRUE(value != NULL);
 107   ASSERT_TRUE(value->GetInteger("hello", &hello_value));
 108   EXPECT_EQ(2, hello_value);
 109 }
 110
 111 TEST_F(PrivetURLFetcherTest, HTTP503Retry) {
 112   privet_urlfetcher_->Start();
 113   net::TestURLFetcher* fetcher = fetcher_factory_.GetFetcherByID(0);
 114   ASSERT_TRUE(fetcher != NULL);
 115   fetcher->SetResponseString(kSampleParsableJSON);
 116   fetcher->set_status(net::URLRequestStatus(net::URLRequestStatus::SUCCESS,
 117                                             net::OK));
 118   fetcher->set_response_code(503);
 119
 120   fetcher->delegate()->OnURLFetchComplete(fetcher);
 121
 122   RunFor(base::TimeDelta::FromSeconds(7));
 123   fetcher = fetcher_factory_.GetFetcherByID(0);
 124
 125   ASSERT_TRUE(fetcher != NULL);
 126   fetcher->SetResponseString(kSampleParsableJSON);
 127   fetcher->set_status(net::URLRequestStatus(net::URLRequestStatus::SUCCESS,
 128                                             net::OK));
 129   fetcher->set_response_code(200);
 130
 131   EXPECT_CALL(delegate_, OnParsedJsonInternal(false));
 132   fetcher->delegate()->OnURLFetchComplete(fetcher);
 133 }
 134
 135 TEST_F(PrivetURLFetcherTest, ResponseCodeError) {
 136   privet_urlfetcher_->Start();
 137   net::TestURLFetcher* fetcher = fetcher_factory_.GetFetcherByID(0);
 138   ASSERT_TRUE(fetcher != NULL);
 139   fetcher->SetResponseString(kSampleParsableJSON);
 140   fetcher->set_status(net::URLRequestStatus(net::URLRequestStatus::SUCCESS,
 141                                             net::OK));
 142   fetcher->set_response_code(404);
 143
 144   EXPECT_CALL(delegate_,
 145               OnErrorInternal(PrivetURLFetcher::RESPONSE_CODE_ERROR));
 146   fetcher->delegate()->OnURLFetchComplete(fetcher);
 147 }
 148
 149 TEST_F(PrivetURLFetcherTest, JsonParseError) {
 150   privet_urlfetcher_->Start();
 151   net::TestURLFetcher* fetcher = fetcher_factory_.GetFetcherByID(0);
 152   ASSERT_TRUE(fetcher != NULL);
 153   fetcher->SetResponseString(kSampleUnparsableJSON);
 154   fetcher->set_status(net::URLRequestStatus(net::URLRequestStatus::SUCCESS,
 155                                             net::OK));
 156   fetcher->set_response_code(200);
 157
 158   EXPECT_CALL(delegate_,
 159               OnErrorInternal(PrivetURLFetcher::JSON_PARSE_ERROR));
 160   fetcher->delegate()->OnURLFetchComplete(fetcher);
 161 }
 162
 163 TEST_F(PrivetURLFetcherTest, Header) {
 164   privet_urlfetcher_->Start();
 165   net::TestURLFetcher* fetcher = fetcher_factory_.GetFetcherByID(0);
 166   ASSERT_TRUE(fetcher != NULL);
 167   net::HttpRequestHeaders headers;
 168   fetcher->GetExtraRequestHeaders(&headers);
 169
 170   std::string header_token;
 171   ASSERT_TRUE(headers.GetHeader("X-Privet-Token", &header_token));
 172   EXPECT_EQ(kSamplePrivetToken, header_token);
 173 }
 174
 175 TEST_F(PrivetURLFetcherTest, Header2) {
 176   privet_urlfetcher_.reset(new PrivetURLFetcher(
 177       "",
 178       GURL(kSamplePrivetURL),
 179       net::URLFetcher::POST,
 180       request_context_.get(),
 181       &delegate_));
 182
 183   privet_urlfetcher_->AllowEmptyPrivetToken();
 184   privet_urlfetcher_->Start();
 185
 186   net::TestURLFetcher* fetcher = fetcher_factory_.GetFetcherByID(0);
 187   ASSERT_TRUE(fetcher != NULL);
 188   net::HttpRequestHeaders headers;
 189   fetcher->GetExtraRequestHeaders(&headers);
 190
 191   std::string header_token;
 192   ASSERT_TRUE(headers.GetHeader("X-Privet-Token", &header_token));
 193   EXPECT_EQ(kEmptyPrivetToken, header_token);
 194 }
 195
 196 TEST_F(PrivetURLFetcherTest, FetchHasError) {
 197   privet_urlfetcher_->Start();
 198   net::TestURLFetcher* fetcher = fetcher_factory_.GetFetcherByID(0);
 199   ASSERT_TRUE(fetcher != NULL);
 200   fetcher->SetResponseString(kSampleJSONWithError);
 201   fetcher->set_status(net::URLRequestStatus(net::URLRequestStatus::SUCCESS,
 202                                             net::OK));
 203   fetcher->set_response_code(200);
 204
 205   EXPECT_CALL(delegate_, OnParsedJsonInternal(true));
 206   fetcher->delegate()->OnURLFetchComplete(fetcher);
 207 }
 208
 209 }  // namespace
 210
 211 }  // namespace local_discovery