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