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   MockPrivetURLFetcherDelegate() : raw_mode_(false) {
  29   }
  30
  31   virtual ~MockPrivetURLFetcherDelegate() {
  32   }
  33
  34   virtual void OnError(PrivetURLFetcher* fetcher,
  35                        PrivetURLFetcher::ErrorType error) OVERRIDE {
  36     OnErrorInternal(error);
  37   }
  38
  39   MOCK_METHOD1(OnErrorInternal, void(PrivetURLFetcher::ErrorType error));
  40
  41   virtual void OnParsedJson(PrivetURLFetcher* fetcher,
  42                             const base::DictionaryValue* value,
  43                             bool has_error) OVERRIDE {
  44     saved_value_.reset(value->DeepCopy());
  45     OnParsedJsonInternal(has_error);
  46   }
  47
  48   MOCK_METHOD1(OnParsedJsonInternal, void(bool has_error));
  49
  50   virtual void OnNeedPrivetToken(
  51       PrivetURLFetcher* fetcher,
  52       const PrivetURLFetcher::TokenCallback& callback) {
  53   }
  54
  55   bool OnRawData(PrivetURLFetcher* fetcher,
  56                  bool response_is_file,
  57                  const std::string& data,
  58                  const base::FilePath& response_file) {
  59     if (!raw_mode_) return false;
  60
  61     if (response_is_file) {
  62       EXPECT_TRUE(response_file != base::FilePath());
  63       OnFileInternal();
  64     } else {
  65       OnRawDataInternal(data);
  66     }
  67
  68     return true;
  69   }
  70
  71   MOCK_METHOD1(OnRawDataInternal, void(std::string data));
  72
  73   MOCK_METHOD0(OnFileInternal, void());
  74
  75   const base::DictionaryValue* saved_value() { return saved_value_.get(); }
  76
  77   void SetRawMode(bool raw_mode) {
  78     raw_mode_ = raw_mode;
  79   }
  80
  81  private:
  82   scoped_ptr<base::DictionaryValue> saved_value_;
  83   bool raw_mode_;
  84 };
  85
  86 class PrivetURLFetcherTest : public ::testing::Test {
  87  public:
  88   PrivetURLFetcherTest() {
  89     request_context_= new net::TestURLRequestContextGetter(
  90         base::MessageLoopProxy::current());
  91     privet_urlfetcher_.reset(new PrivetURLFetcher(
  92         GURL(kSamplePrivetURL),
  93         net::URLFetcher::POST,
  94         request_context_.get(),
  95         &delegate_));
  96
  97     PrivetURLFetcher::SetTokenForHost(GURL(kSamplePrivetURL).GetOrigin().spec(),
  98                                       kSamplePrivetToken);
  99   }
 100   virtual ~PrivetURLFetcherTest() {
 101   }
 102
 103   void RunFor(base::TimeDelta time_period) {
 104     base::CancelableCallback<void()> callback(base::Bind(
 105         &PrivetURLFetcherTest::Stop, base::Unretained(this)));
 106     base::MessageLoop::current()->PostDelayedTask(
 107         FROM_HERE, callback.callback(), time_period);
 108
 109     base::MessageLoop::current()->Run();
 110     callback.Cancel();
 111   }
 112
 113   void Stop() {
 114     base::MessageLoop::current()->Quit();
 115   }
 116
 117  protected:
 118   base::MessageLoop loop_;
 119   scoped_refptr<net::TestURLRequestContextGetter> request_context_;
 120   net::TestURLFetcherFactory fetcher_factory_;
 121   scoped_ptr<PrivetURLFetcher> privet_urlfetcher_;
 122   StrictMock<MockPrivetURLFetcherDelegate> delegate_;
 123 };
 124
 125 TEST_F(PrivetURLFetcherTest, FetchSuccess) {
 126   privet_urlfetcher_->Start();
 127   net::TestURLFetcher* fetcher = fetcher_factory_.GetFetcherByID(0);
 128   ASSERT_TRUE(fetcher != NULL);
 129   fetcher->SetResponseString(kSampleParsableJSON);
 130   fetcher->set_status(net::URLRequestStatus(net::URLRequestStatus::SUCCESS,
 131                                             net::OK));
 132   fetcher->set_response_code(200);
 133
 134   EXPECT_CALL(delegate_, OnParsedJsonInternal(false));
 135   fetcher->delegate()->OnURLFetchComplete(fetcher);
 136
 137   const base::DictionaryValue* value = delegate_.saved_value();
 138   int hello_value;
 139   ASSERT_TRUE(value != NULL);
 140   ASSERT_TRUE(value->GetInteger("hello", &hello_value));
 141   EXPECT_EQ(2, hello_value);
 142 }
 143
 144 TEST_F(PrivetURLFetcherTest, HTTP503Retry) {
 145   privet_urlfetcher_->Start();
 146   net::TestURLFetcher* fetcher = fetcher_factory_.GetFetcherByID(0);
 147   ASSERT_TRUE(fetcher != NULL);
 148   fetcher->SetResponseString(kSampleParsableJSON);
 149   fetcher->set_status(net::URLRequestStatus(net::URLRequestStatus::SUCCESS,
 150                                             net::OK));
 151   fetcher->set_response_code(503);
 152
 153   fetcher->delegate()->OnURLFetchComplete(fetcher);
 154
 155   RunFor(base::TimeDelta::FromSeconds(7));
 156   fetcher = fetcher_factory_.GetFetcherByID(0);
 157
 158   ASSERT_TRUE(fetcher != NULL);
 159   fetcher->SetResponseString(kSampleParsableJSON);
 160   fetcher->set_status(net::URLRequestStatus(net::URLRequestStatus::SUCCESS,
 161                                             net::OK));
 162   fetcher->set_response_code(200);
 163
 164   EXPECT_CALL(delegate_, OnParsedJsonInternal(false));
 165   fetcher->delegate()->OnURLFetchComplete(fetcher);
 166 }
 167
 168 TEST_F(PrivetURLFetcherTest, ResponseCodeError) {
 169   privet_urlfetcher_->Start();
 170   net::TestURLFetcher* fetcher = fetcher_factory_.GetFetcherByID(0);
 171   ASSERT_TRUE(fetcher != NULL);
 172   fetcher->SetResponseString(kSampleParsableJSON);
 173   fetcher->set_status(net::URLRequestStatus(net::URLRequestStatus::SUCCESS,
 174                                             net::OK));
 175   fetcher->set_response_code(404);
 176
 177   EXPECT_CALL(delegate_,
 178               OnErrorInternal(PrivetURLFetcher::RESPONSE_CODE_ERROR));
 179   fetcher->delegate()->OnURLFetchComplete(fetcher);
 180 }
 181
 182 TEST_F(PrivetURLFetcherTest, JsonParseError) {
 183   privet_urlfetcher_->Start();
 184   net::TestURLFetcher* fetcher = fetcher_factory_.GetFetcherByID(0);
 185   ASSERT_TRUE(fetcher != NULL);
 186   fetcher->SetResponseString(kSampleUnparsableJSON);
 187   fetcher->set_status(net::URLRequestStatus(net::URLRequestStatus::SUCCESS,
 188                                             net::OK));
 189   fetcher->set_response_code(200);
 190
 191   EXPECT_CALL(delegate_,
 192               OnErrorInternal(PrivetURLFetcher::JSON_PARSE_ERROR));
 193   fetcher->delegate()->OnURLFetchComplete(fetcher);
 194 }
 195
 196 TEST_F(PrivetURLFetcherTest, Header) {
 197   privet_urlfetcher_->Start();
 198   net::TestURLFetcher* fetcher = fetcher_factory_.GetFetcherByID(0);
 199   ASSERT_TRUE(fetcher != NULL);
 200   net::HttpRequestHeaders headers;
 201   fetcher->GetExtraRequestHeaders(&headers);
 202
 203   std::string header_token;
 204   ASSERT_TRUE(headers.GetHeader("X-Privet-Token", &header_token));
 205   EXPECT_EQ(kSamplePrivetToken, header_token);
 206 }
 207
 208 TEST_F(PrivetURLFetcherTest, Header2) {
 209   PrivetURLFetcher::SetTokenForHost(GURL(kSamplePrivetURL).GetOrigin().spec(),
 210                                     "");
 211
 212   privet_urlfetcher_->SendEmptyPrivetToken();
 213   privet_urlfetcher_->Start();
 214
 215   net::TestURLFetcher* fetcher = fetcher_factory_.GetFetcherByID(0);
 216   ASSERT_TRUE(fetcher != NULL);
 217   net::HttpRequestHeaders headers;
 218   fetcher->GetExtraRequestHeaders(&headers);
 219
 220   std::string header_token;
 221   ASSERT_TRUE(headers.GetHeader("X-Privet-Token", &header_token));
 222   EXPECT_EQ(kEmptyPrivetToken, header_token);
 223 }
 224
 225 TEST_F(PrivetURLFetcherTest, AlwaysSendEmpty) {
 226   PrivetURLFetcher::SetTokenForHost(GURL(kSamplePrivetURL).GetOrigin().spec(),
 227                                     "SampleToken");
 228
 229   privet_urlfetcher_->SendEmptyPrivetToken();
 230   privet_urlfetcher_->Start();
 231
 232   net::TestURLFetcher* fetcher = fetcher_factory_.GetFetcherByID(0);
 233   ASSERT_TRUE(fetcher != NULL);
 234   net::HttpRequestHeaders headers;
 235   fetcher->GetExtraRequestHeaders(&headers);
 236
 237   std::string header_token;
 238   ASSERT_TRUE(headers.GetHeader("X-Privet-Token", &header_token));
 239   EXPECT_EQ(kEmptyPrivetToken, header_token);
 240 }
 241
 242 TEST_F(PrivetURLFetcherTest, FetchHasError) {
 243   privet_urlfetcher_->Start();
 244   net::TestURLFetcher* fetcher = fetcher_factory_.GetFetcherByID(0);
 245   ASSERT_TRUE(fetcher != NULL);
 246   fetcher->SetResponseString(kSampleJSONWithError);
 247   fetcher->set_status(net::URLRequestStatus(net::URLRequestStatus::SUCCESS,
 248                                             net::OK));
 249   fetcher->set_response_code(200);
 250
 251   EXPECT_CALL(delegate_, OnParsedJsonInternal(true));
 252   fetcher->delegate()->OnURLFetchComplete(fetcher);
 253 }
 254
 255 TEST_F(PrivetURLFetcherTest, FetcherRawData) {
 256   delegate_.SetRawMode(true);
 257   privet_urlfetcher_->Start();
 258   net::TestURLFetcher* fetcher = fetcher_factory_.GetFetcherByID(0);
 259   ASSERT_TRUE(fetcher != NULL);
 260   fetcher->SetResponseString(kSampleJSONWithError);
 261   fetcher->set_status(net::URLRequestStatus(net::URLRequestStatus::SUCCESS,
 262                                             net::OK));
 263   fetcher->set_response_code(200);
 264
 265   EXPECT_CALL(delegate_, OnRawDataInternal(kSampleJSONWithError));
 266   fetcher->delegate()->OnURLFetchComplete(fetcher);
 267 }
 268
 269 TEST_F(PrivetURLFetcherTest, RangeRequest) {
 270   delegate_.SetRawMode(true);
 271   privet_urlfetcher_->SetByteRange(200, 300);
 272   privet_urlfetcher_->Start();
 273   net::TestURLFetcher* fetcher = fetcher_factory_.GetFetcherByID(0);
 274   ASSERT_TRUE(fetcher != NULL);
 275   net::HttpRequestHeaders headers;
 276   fetcher->GetExtraRequestHeaders(&headers);
 277
 278   std::string header_range;
 279   ASSERT_TRUE(headers.GetHeader("Range", &header_range));
 280   EXPECT_EQ("bytes=200-300", header_range);
 281 }
 282
 283 TEST_F(PrivetURLFetcherTest, FetcherToFile) {
 284   delegate_.SetRawMode(true);
 285   privet_urlfetcher_->SaveResponseToFile();
 286   privet_urlfetcher_->Start();
 287   net::TestURLFetcher* fetcher = fetcher_factory_.GetFetcherByID(0);
 288   ASSERT_TRUE(fetcher != NULL);
 289   fetcher->SetResponseFilePath(
 290       base::FilePath(FILE_PATH_LITERAL("sample/file")));
 291   fetcher->set_status(net::URLRequestStatus(net::URLRequestStatus::SUCCESS,
 292                                             net::OK));
 293   fetcher->set_response_code(200);
 294
 295   EXPECT_CALL(delegate_, OnFileInternal());
 296   fetcher->delegate()->OnURLFetchComplete(fetcher);
 297 }
 298
 299 }  // namespace
 300
 301 }  // namespace local_discovery