| OLD | NEW |
|---|
| (Empty) | |
| 1 // Copyright 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 #import "ios/chrome/browser/omaha/omaha_service.h" |
| 6 |
| 7 #include <regex.h> |
| 8 #include <sys/types.h> |
| 9 |
| 10 #include "base/bind.h" |
| 11 #include "base/logging.h" |
| 12 #include "base/message_loop/message_loop.h" |
| 13 #include "base/run_loop.h" |
| 14 #include "base/strings/stringprintf.h" |
| 15 #include "components/metrics/metrics_pref_names.h" |
| 16 #include "components/prefs/pref_registry_simple.h" |
| 17 #include "components/version_info/version_info.h" |
| 18 #include "ios/chrome/browser/application_context.h" |
| 19 #include "ios/chrome/browser/browser_state/test_chrome_browser_state_manager.h" |
| 20 #include "ios/chrome/browser/install_time_util.h" |
| 21 #include "ios/chrome/common/channel_info.h" |
| 22 #include "ios/chrome/test/testing_application_context.h" |
| 23 #include "ios/public/provider/chrome/browser/chrome_browser_provider.h" |
| 24 #include "ios/public/provider/chrome/browser/omaha/omaha_service_provider.h" |
| 25 #include "ios/web/public/test/test_web_thread.h" |
| 26 #include "net/url_request/test_url_fetcher_factory.h" |
| 27 #include "testing/gtest/include/gtest/gtest.h" |
| 28 #include "testing/gtest_mac.h" |
| 29 #include "testing/platform_test.h" |
| 30 |
| 31 namespace { |
| 32 |
| 33 const char kUserDataDir[] = "."; |
| 34 |
| 35 } // namespace |
| 36 |
| 37 class OmahaServiceTest : public PlatformTest { |
| 38 public: |
| 39 OmahaServiceTest() |
| 40 : need_update_(false), |
| 41 loop_(base::MessageLoop::TYPE_IO), |
| 42 browser_state_manager_(base::FilePath(kUserDataDir)), |
| 43 ui_thread_(web::WebThread::UI, &loop_), |
| 44 io_thread_(web::WebThread::IO, &loop_) { |
| 45 GetApplicationContext()->GetLocalState()->SetInt64( |
| 46 metrics::prefs::kInstallDate, install_time_util::kUnknownInstallDate); |
| 47 OmahaService::ClearPersistentStateForTests(); |
| 48 test_application_id_ = ios::GetChromeBrowserProvider() |
| 49 ->GetOmahaServiceProvider() |
| 50 ->GetApplicationID(); |
| 51 } |
| 52 |
| 53 ~OmahaServiceTest() override {} |
| 54 |
| 55 void OnNeedUpdate(const UpgradeRecommendedDetails& details) { |
| 56 need_update_ = true; |
| 57 } |
| 58 |
| 59 bool NeedUpdate() { |
| 60 DCHECK_CURRENTLY_ON(web::WebThread::UI); |
| 61 if (!need_update_) { |
| 62 base::RunLoop().RunUntilIdle(); |
| 63 } |
| 64 return need_update_; |
| 65 } |
| 66 |
| 67 void CleanService(OmahaService* service, |
| 68 const std::string& last_sent_version) { |
| 69 service->ClearInstallRetryRequestId(); |
| 70 service->number_of_tries_ = 0; |
| 71 if (last_sent_version.length() == 0) |
| 72 service->last_sent_version_ = base::Version("0.0.0.0"); |
| 73 else |
| 74 service->last_sent_version_ = base::Version(last_sent_version); |
| 75 service->current_ping_time_ = base::Time(); |
| 76 service->last_sent_time_ = base::Time(); |
| 77 service->locale_lang_ = std::string(); |
| 78 } |
| 79 |
| 80 protected: |
| 81 std::string test_application_id_; |
| 82 bool need_update_; |
| 83 base::MessageLoop loop_; |
| 84 TestChromeBrowserStateManager browser_state_manager_; |
| 85 |
| 86 private: |
| 87 web::TestWebThread ui_thread_; |
| 88 web::TestWebThread io_thread_; |
| 89 }; |
| 90 |
| 91 TEST_F(OmahaServiceTest, PingMessageTest) { |
| 92 const char* expectedResult = |
| 93 "<request protocol=\"3.0\" version=\"iOS-1.0.0.0\" ismachine=\"1\" " |
| 94 "requestid=\"requestId\" sessionid=\"sessionId\"" |
| 95 " hardware_class=\"[^\"]*\">" |
| 96 "<os platform=\"ios\" version=\"[0-9][0-9]*\\(\\.[0-9][0-9]*\\)*\"" |
| 97 " arch=\"[^\"]*\"/>" |
| 98 "<app version=\"[^\"]*\" nextversion=\"\" lang=\"[^\"]*\"" |
| 99 " brand=\"[A-Z][A-Z][A-Z][A-Z]\" client=\"\" appid=\"{[^}]*}\"" |
| 100 " installage=\"0\">" |
| 101 "<updatecheck tag=\"[^\"]*\"/>" |
| 102 "<ping active=\"1\"/></app></request>"; |
| 103 |
| 104 OmahaService service(false); |
| 105 service.set_upgrade_recommended_callback( |
| 106 base::Bind(&OmahaServiceTest::OnNeedUpdate, base::Unretained(this))); |
| 107 std::string content = service.GetPingContent( |
| 108 "requestId", "sessionId", version_info::GetVersionNumber(), |
| 109 GetChannelString(), base::Time::Now(), OmahaService::USAGE_PING); |
| 110 regex_t regex; |
| 111 regcomp(®ex, expectedResult, REG_NOSUB); |
| 112 int result = regexec(®ex, content.c_str(), 0, NULL, 0); |
| 113 regfree(®ex); |
| 114 EXPECT_EQ(0, result); |
| 115 EXPECT_FALSE(NeedUpdate()); |
| 116 } |
| 117 |
| 118 TEST_F(OmahaServiceTest, PingMessageTestWithUnknownInstallDate) { |
| 119 const char* expectedResult = |
| 120 "<request protocol=\"3.0\" version=\"iOS-1.0.0.0\" ismachine=\"1\" " |
| 121 "requestid=\"requestId\" sessionid=\"sessionId\"" |
| 122 " hardware_class=\"[^\"]*\">" |
| 123 "<os platform=\"ios\" version=\"[0-9][0-9]*\\(\\.[0-9][0-9]*\\)*\"" |
| 124 " arch=\"[^\"]*\"/>" |
| 125 "<app version=\"[^\"]*\" nextversion=\"\" lang=\"[^\"]*\"" |
| 126 " brand=\"[A-Z][A-Z][A-Z][A-Z]\" client=\"\" appid=\"{[^}]*}\">" |
| 127 "<updatecheck tag=\"[^\"]*\"/>" |
| 128 "<ping active=\"1\"/></app></request>"; |
| 129 |
| 130 OmahaService service(false); |
| 131 service.set_upgrade_recommended_callback( |
| 132 base::Bind(&OmahaServiceTest::OnNeedUpdate, base::Unretained(this))); |
| 133 std::string content = service.GetPingContent( |
| 134 "requestId", "sessionId", version_info::GetVersionNumber(), |
| 135 GetChannelString(), |
| 136 base::Time::FromTimeT(install_time_util::kUnknownInstallDate), |
| 137 OmahaService::USAGE_PING); |
| 138 regex_t regex; |
| 139 regcomp(®ex, expectedResult, REG_NOSUB); |
| 140 int result = regexec(®ex, content.c_str(), 0, NULL, 0); |
| 141 regfree(®ex); |
| 142 EXPECT_EQ(0, result); |
| 143 EXPECT_FALSE(NeedUpdate()); |
| 144 } |
| 145 |
| 146 TEST_F(OmahaServiceTest, InstallEventMessageTest) { |
| 147 const char* kExpectedResultFormat = |
| 148 "<request protocol=\"3.0\" version=\"iOS-1.0.0.0\" ismachine=\"1\" " |
| 149 "requestid=\"requestId\" sessionid=\"sessionId\"" |
| 150 " hardware_class=\"[^\"]*\">" |
| 151 "<os platform=\"ios\" version=\"[0-9][0-9]*(\\.[0-9][0-9]*)*\"" |
| 152 " arch=\"[^\"]*\"/>" |
| 153 "<app version=\"%s\" nextversion=\"[^\"]*\" lang=\"[^\"]*\"" |
| 154 " brand=\"[A-Z][A-Z][A-Z][A-Z]\" client=\"\" appid=\"{[^}]*}\"" |
| 155 " installage=\"%d\">" |
| 156 "<event eventtype=\"%d\" eventresult=\"1\"/>" |
| 157 "</app></request>"; |
| 158 |
| 159 // First install. |
| 160 OmahaService service(false); |
| 161 service.set_upgrade_recommended_callback( |
| 162 base::Bind(&OmahaServiceTest::OnNeedUpdate, base::Unretained(this))); |
| 163 CleanService(&service, ""); |
| 164 std::string content = service.GetPingContent( |
| 165 "requestId", "sessionId", version_info::GetVersionNumber(), |
| 166 GetChannelString(), base::Time::Now(), OmahaService::INSTALL_EVENT); |
| 167 regmatch_t matches[2]; |
| 168 regex_t regex; |
| 169 std::string expected_result = |
| 170 base::StringPrintf(kExpectedResultFormat, "" /* previous version */, |
| 171 -1 /* install age */, 2 /* event type */); |
| 172 regcomp(®ex, expected_result.c_str(), REG_EXTENDED); |
| 173 int result = regexec(®ex, content.c_str(), arraysize(matches), matches, 0); |
| 174 regfree(®ex); |
| 175 EXPECT_EQ(0, result) << "Actual contents: " << content; |
| 176 EXPECT_FALSE(NeedUpdate()); |
| 177 |
| 178 // Update install. |
| 179 const char* kPreviousVersion = "0.5"; |
| 180 CleanService(&service, kPreviousVersion); |
| 181 content = service.GetPingContent( |
| 182 "requestId", "sessionId", version_info::GetVersionNumber(), |
| 183 GetChannelString(), base::Time::Now(), OmahaService::INSTALL_EVENT); |
| 184 expected_result = base::StringPrintf(kExpectedResultFormat, kPreviousVersion, |
| 185 0 /* install age */, 3 /* event type */); |
| 186 regcomp(®ex, expected_result.c_str(), REG_EXTENDED); |
| 187 result = regexec(®ex, content.c_str(), arraysize(matches), matches, 0); |
| 188 regfree(®ex); |
| 189 EXPECT_EQ(0, result) << "Actual contents: " << content; |
| 190 EXPECT_FALSE(NeedUpdate()); |
| 191 } |
| 192 |
| 193 TEST_F(OmahaServiceTest, SendPingSuccess) { |
| 194 base::Time now = base::Time::Now(); |
| 195 OmahaService service(false); |
| 196 service.set_upgrade_recommended_callback( |
| 197 base::Bind(&OmahaServiceTest::OnNeedUpdate, base::Unretained(this))); |
| 198 CleanService(&service, version_info::GetVersionNumber()); |
| 199 net::TestURLFetcherFactory factory_; |
| 200 |
| 201 service.SendPing(); |
| 202 EXPECT_EQ(1, service.number_of_tries_); |
| 203 EXPECT_TRUE(service.current_ping_time_.is_null()); |
| 204 EXPECT_GE(service.next_tries_time_, now + base::TimeDelta::FromMinutes(54)); |
| 205 EXPECT_LE(service.next_tries_time_, now + base::TimeDelta::FromHours(7)); |
| 206 |
| 207 net::TestURLFetcher* fetcher = factory_.GetFetcherByID(0); |
| 208 DCHECK(fetcher); |
| 209 DCHECK(fetcher->delegate()); |
| 210 fetcher->set_status(net::URLRequestStatus()); |
| 211 fetcher->set_response_code(200); |
| 212 std::string response = |
| 213 std::string( |
| 214 "<?xml version=\"1.0\"?><response protocol=\"3.0\" server=\"prod\">" |
| 215 "<daystart elapsed_seconds=\"56754\"/><app appid=\"") + |
| 216 test_application_id_ + |
| 217 "\" status=\"ok\">" |
| 218 "<updatecheck status=\"noupdate\"/><ping status=\"ok\"/>" |
| 219 "</app></response>"; |
| 220 fetcher->SetResponseString(response); |
| 221 fetcher->delegate()->OnURLFetchComplete(fetcher); |
| 222 |
| 223 EXPECT_EQ(0, service.number_of_tries_); |
| 224 EXPECT_FALSE(service.current_ping_time_.is_null()); |
| 225 EXPECT_EQ(service.current_ping_time_, service.next_tries_time_); |
| 226 EXPECT_GT(service.last_sent_time_, now); |
| 227 EXPECT_FALSE(NeedUpdate()); |
| 228 } |
| 229 |
| 230 TEST_F(OmahaServiceTest, SendInstallEventSuccess) { |
| 231 base::Time now = base::Time::Now(); |
| 232 OmahaService service(false); |
| 233 service.set_upgrade_recommended_callback( |
| 234 base::Bind(&OmahaServiceTest::OnNeedUpdate, base::Unretained(this))); |
| 235 CleanService(&service, ""); |
| 236 net::TestURLFetcherFactory factory_; |
| 237 |
| 238 service.SendPing(); |
| 239 EXPECT_EQ(1, service.number_of_tries_); |
| 240 EXPECT_TRUE(service.current_ping_time_.is_null()); |
| 241 EXPECT_GE(service.next_tries_time_, now + base::TimeDelta::FromMinutes(54)); |
| 242 EXPECT_LE(service.next_tries_time_, now + base::TimeDelta::FromHours(7)); |
| 243 |
| 244 net::TestURLFetcher* fetcher = factory_.GetFetcherByID(0); |
| 245 DCHECK(fetcher); |
| 246 DCHECK(fetcher->delegate()); |
| 247 fetcher->set_status(net::URLRequestStatus()); |
| 248 fetcher->set_response_code(200); |
| 249 std::string response = |
| 250 std::string( |
| 251 "<?xml version=\"1.0\"?><response protocol=\"3.0\" server=\"prod\">" |
| 252 "<daystart elapsed_seconds=\"56754\"/><app appid=\"") + |
| 253 test_application_id_ + |
| 254 "\" status=\"ok\">" |
| 255 "<event status=\"ok\"/>" |
| 256 "</app></response>"; |
| 257 fetcher->SetResponseString(response); |
| 258 fetcher->delegate()->OnURLFetchComplete(fetcher); |
| 259 |
| 260 EXPECT_FALSE(service.current_ping_time_.is_null()); |
| 261 EXPECT_GT(service.last_sent_time_, now); |
| 262 EXPECT_FALSE(NeedUpdate()); |
| 263 } |
| 264 |
| 265 TEST_F(OmahaServiceTest, SendPingReceiveUpdate) { |
| 266 base::Time now = base::Time::Now(); |
| 267 OmahaService service(false); |
| 268 service.set_upgrade_recommended_callback( |
| 269 base::Bind(&OmahaServiceTest::OnNeedUpdate, base::Unretained(this))); |
| 270 CleanService(&service, version_info::GetVersionNumber()); |
| 271 net::TestURLFetcherFactory factory_; |
| 272 |
| 273 service.SendPing(); |
| 274 EXPECT_EQ(1, service.number_of_tries_); |
| 275 EXPECT_TRUE(service.current_ping_time_.is_null()); |
| 276 EXPECT_GE(service.next_tries_time_, now + base::TimeDelta::FromMinutes(54)); |
| 277 EXPECT_LE(service.next_tries_time_, now + base::TimeDelta::FromHours(7)); |
| 278 |
| 279 net::TestURLFetcher* fetcher = factory_.GetFetcherByID(0); |
| 280 DCHECK(fetcher); |
| 281 DCHECK(fetcher->delegate()); |
| 282 fetcher->set_status(net::URLRequestStatus()); |
| 283 fetcher->set_response_code(200); |
| 284 std::string response = |
| 285 std::string( |
| 286 "<?xml version=\"1.0\"?><response protocol=\"3.0\" server=\"prod\">" |
| 287 "<daystart elapsed_seconds=\"56754\"/><app appid=\"") + |
| 288 test_application_id_ + |
| 289 "\" status=\"ok\">" |
| 290 "<updatecheck status=\"ok\"><urls>" |
| 291 "<url codebase=\"http://www.goo.fr/foo/\"/></urls>" |
| 292 "<manifest version=\"0.0.1075.1441\">" |
| 293 "<packages>" |
| 294 "<package hash=\"0\" name=\"Chrome\" required=\"true\" size=\"0\"/>" |
| 295 "</packages>" |
| 296 "<actions>" |
| 297 "<action event=\"update\" run=\"Chrome\"/>" |
| 298 "<action event=\"postinstall\" osminversion=\"6.0\"/>" |
| 299 "</actions>" |
| 300 "</manifest>" |
| 301 "</updatecheck><ping status=\"ok\"/>" |
| 302 "</app></response>"; |
| 303 fetcher->SetResponseString(response); |
| 304 fetcher->delegate()->OnURLFetchComplete(fetcher); |
| 305 |
| 306 EXPECT_EQ(0, service.number_of_tries_); |
| 307 EXPECT_FALSE(service.current_ping_time_.is_null()); |
| 308 EXPECT_EQ(service.current_ping_time_, service.next_tries_time_); |
| 309 EXPECT_GT(service.last_sent_time_, now); |
| 310 EXPECT_TRUE(NeedUpdate()); |
| 311 } |
| 312 |
| 313 TEST_F(OmahaServiceTest, SendPingFailure) { |
| 314 base::Time now = base::Time::Now(); |
| 315 OmahaService service(false); |
| 316 service.set_upgrade_recommended_callback( |
| 317 base::Bind(&OmahaServiceTest::OnNeedUpdate, base::Unretained(this))); |
| 318 CleanService(&service, version_info::GetVersionNumber()); |
| 319 net::TestURLFetcherFactory factory_; |
| 320 |
| 321 // Tries with a non 200 result. |
| 322 service.SendPing(); |
| 323 EXPECT_EQ(1, service.number_of_tries_); |
| 324 EXPECT_TRUE(service.current_ping_time_.is_null()); |
| 325 EXPECT_GE(service.next_tries_time_, now + base::TimeDelta::FromMinutes(54)); |
| 326 EXPECT_LE(service.next_tries_time_, now + base::TimeDelta::FromHours(7)); |
| 327 base::Time next_tries_time = service.next_tries_time_; |
| 328 |
| 329 net::TestURLFetcher* fetcher = factory_.GetFetcherByID(0); |
| 330 DCHECK(fetcher); |
| 331 DCHECK(fetcher->delegate()); |
| 332 fetcher->set_status(net::URLRequestStatus()); |
| 333 fetcher->set_response_code(400); |
| 334 fetcher->SetResponseString(""); |
| 335 fetcher->delegate()->OnURLFetchComplete(fetcher); |
| 336 |
| 337 EXPECT_EQ(1, service.number_of_tries_); |
| 338 EXPECT_TRUE(service.current_ping_time_.is_null()); |
| 339 EXPECT_EQ(next_tries_time, service.next_tries_time_); |
| 340 EXPECT_LT(service.last_sent_time_, now); |
| 341 EXPECT_FALSE(NeedUpdate()); |
| 342 |
| 343 // Tries with an incorrect xml message. |
| 344 service.SendPing(); |
| 345 EXPECT_EQ(2, service.number_of_tries_); |
| 346 EXPECT_TRUE(service.current_ping_time_.is_null()); |
| 347 EXPECT_GE(service.next_tries_time_, now + base::TimeDelta::FromMinutes(54)); |
| 348 EXPECT_LE(service.next_tries_time_, now + base::TimeDelta::FromHours(7)); |
| 349 next_tries_time = service.next_tries_time_; |
| 350 |
| 351 fetcher = factory_.GetFetcherByID(0); |
| 352 DCHECK(fetcher); |
| 353 DCHECK(fetcher->delegate()); |
| 354 fetcher->set_status(net::URLRequestStatus()); |
| 355 fetcher->set_response_code(200); |
| 356 fetcher->SetResponseString("Incorrect Message"); |
| 357 fetcher->delegate()->OnURLFetchComplete(fetcher); |
| 358 |
| 359 EXPECT_EQ(2, service.number_of_tries_); |
| 360 EXPECT_TRUE(service.current_ping_time_.is_null()); |
| 361 EXPECT_EQ(next_tries_time, service.next_tries_time_); |
| 362 EXPECT_LT(service.last_sent_time_, now); |
| 363 EXPECT_FALSE(NeedUpdate()); |
| 364 } |
| 365 |
| 366 TEST_F(OmahaServiceTest, PersistStatesTest) { |
| 367 std::string version_string = version_info::GetVersionNumber(); |
| 368 base::Time now = base::Time::Now(); |
| 369 OmahaService service(false); |
| 370 service.set_upgrade_recommended_callback( |
| 371 base::Bind(&OmahaServiceTest::OnNeedUpdate, base::Unretained(this))); |
| 372 service.number_of_tries_ = 5; |
| 373 service.last_sent_time_ = now - base::TimeDelta::FromSeconds(1); |
| 374 service.next_tries_time_ = now + base::TimeDelta::FromSeconds(2); |
| 375 service.current_ping_time_ = now + base::TimeDelta::FromSeconds(3); |
| 376 service.last_sent_version_ = base::Version(version_string); |
| 377 service.PersistStates(); |
| 378 |
| 379 OmahaService service2(false); |
| 380 EXPECT_EQ(service.number_of_tries_, 5); |
| 381 EXPECT_EQ(service2.last_sent_time_, now - base::TimeDelta::FromSeconds(1)); |
| 382 EXPECT_EQ(service2.next_tries_time_, now + base::TimeDelta::FromSeconds(2)); |
| 383 EXPECT_EQ(service2.current_ping_time_, now + base::TimeDelta::FromSeconds(3)); |
| 384 EXPECT_EQ(service.last_sent_version_.GetString(), version_string); |
| 385 } |
| 386 |
| 387 TEST_F(OmahaServiceTest, BackoffTest) { |
| 388 for (int i = 1; i < 100; ++i) { |
| 389 // Testing multiple times for a given number of retries, as the method has |
| 390 // a random part. |
| 391 for (int j = 0; j < 2; ++j) { |
| 392 EXPECT_GE(OmahaService::GetBackOff(i).InSeconds(), 3600 - 360); |
| 393 EXPECT_LE(OmahaService::GetBackOff(i).InSeconds(), 6 * 3600); |
| 394 } |
| 395 } |
| 396 } |
| 397 |
| 398 // Tests that an active ping is scheduled immediately after a successful install |
| 399 // event send. |
| 400 TEST_F(OmahaServiceTest, ActivePingAfterInstallEventTest) { |
| 401 base::Time now = base::Time::Now(); |
| 402 OmahaService service(false); |
| 403 service.set_upgrade_recommended_callback( |
| 404 base::Bind(&OmahaServiceTest::OnNeedUpdate, base::Unretained(this))); |
| 405 CleanService(&service, ""); |
| 406 net::TestURLFetcherFactory factory_; |
| 407 |
| 408 service.SendPing(); |
| 409 EXPECT_EQ(1, service.number_of_tries_); |
| 410 EXPECT_TRUE(service.current_ping_time_.is_null()); |
| 411 EXPECT_GE(service.next_tries_time_, now + base::TimeDelta::FromMinutes(54)); |
| 412 EXPECT_LE(service.next_tries_time_, now + base::TimeDelta::FromHours(7)); |
| 413 |
| 414 net::TestURLFetcher* fetcher = factory_.GetFetcherByID(0); |
| 415 DCHECK(fetcher); |
| 416 DCHECK(fetcher->delegate()); |
| 417 fetcher->set_status(net::URLRequestStatus()); |
| 418 fetcher->set_response_code(200); |
| 419 std::string response = |
| 420 std::string( |
| 421 "<?xml version=\"1.0\"?><response protocol=\"3.0\" server=\"prod\">" |
| 422 "<daystart elapsed_seconds=\"0\"/><app appid=\"") + |
| 423 test_application_id_ + |
| 424 "\" status=\"ok\">" |
| 425 "<event status=\"ok\"/>" |
| 426 "</app></response>"; |
| 427 fetcher->SetResponseString(response); |
| 428 fetcher->delegate()->OnURLFetchComplete(fetcher); |
| 429 |
| 430 EXPECT_EQ(1, service.number_of_tries_); |
| 431 EXPECT_LT(service.current_ping_time_ - now, base::TimeDelta::FromMinutes(1)); |
| 432 EXPECT_GT(service.next_tries_time_, service.current_ping_time_); |
| 433 EXPECT_FALSE(NeedUpdate()); |
| 434 } |
| 435 |
| 436 // Tests that active pings are not sent in rapid succession. |
| 437 TEST_F(OmahaServiceTest, NonSpammingTest) { |
| 438 base::Time now = base::Time::Now(); |
| 439 OmahaService service(false); |
| 440 service.set_upgrade_recommended_callback( |
| 441 base::Bind(&OmahaServiceTest::OnNeedUpdate, base::Unretained(this))); |
| 442 CleanService(&service, version_info::GetVersionNumber()); |
| 443 net::TestURLFetcherFactory factory_; |
| 444 |
| 445 service.SendPing(); |
| 446 EXPECT_EQ(1, service.number_of_tries_); |
| 447 EXPECT_TRUE(service.current_ping_time_.is_null()); |
| 448 EXPECT_GE(service.next_tries_time_, now + base::TimeDelta::FromMinutes(54)); |
| 449 EXPECT_LE(service.next_tries_time_, now + base::TimeDelta::FromHours(7)); |
| 450 |
| 451 net::TestURLFetcher* fetcher = factory_.GetFetcherByID(0); |
| 452 DCHECK(fetcher); |
| 453 DCHECK(fetcher->delegate()); |
| 454 fetcher->set_status(net::URLRequestStatus()); |
| 455 fetcher->set_response_code(200); |
| 456 std::string response = |
| 457 std::string( |
| 458 "<?xml version=\"1.0\"?><response protocol=\"3.0\" server=\"prod\">" |
| 459 "<daystart elapsed_seconds=\"0\"/><app appid=\"") + |
| 460 test_application_id_ + |
| 461 "\" status=\"ok\">" |
| 462 "<updatecheck status=\"noupdate\"/><ping status=\"ok\"/>" |
| 463 "</app></response>"; |
| 464 fetcher->SetResponseString(response); |
| 465 fetcher->delegate()->OnURLFetchComplete(fetcher); |
| 466 |
| 467 EXPECT_EQ(0, service.number_of_tries_); |
| 468 EXPECT_FALSE(service.current_ping_time_.is_null()); |
| 469 EXPECT_GE(service.next_tries_time_ - now, base::TimeDelta::FromHours(2)); |
| 470 EXPECT_GT(service.last_sent_time_, now); |
| 471 EXPECT_FALSE(NeedUpdate()); |
| 472 } |
| 473 |
| 474 TEST_F(OmahaServiceTest, InstallRetryTest) { |
| 475 OmahaService service(false); |
| 476 service.set_upgrade_recommended_callback( |
| 477 base::Bind(&OmahaServiceTest::OnNeedUpdate, base::Unretained(this))); |
| 478 CleanService(&service, ""); |
| 479 net::TestURLFetcherFactory factory_; |
| 480 |
| 481 EXPECT_FALSE(service.IsNextPingInstallRetry()); |
| 482 std::string id1 = service.GetNextPingRequestId(OmahaService::INSTALL_EVENT); |
| 483 EXPECT_TRUE(service.IsNextPingInstallRetry()); |
| 484 ASSERT_EQ(id1, service.GetNextPingRequestId(OmahaService::INSTALL_EVENT)); |
| 485 |
| 486 service.SendPing(); |
| 487 net::TestURLFetcher* fetcher = factory_.GetFetcherByID(0); |
| 488 DCHECK(fetcher); |
| 489 DCHECK(fetcher->delegate()); |
| 490 fetcher->set_status(net::URLRequestStatus()); |
| 491 fetcher->set_response_code(200); |
| 492 std::string response = |
| 493 std::string( |
| 494 "<?xml version=\"1.0\"?><response protocol=\"3.0\" server=\"prod\">" |
| 495 "<daystart elapsed_seconds=\"56754\"/><app appid=\"") + |
| 496 test_application_id_ + |
| 497 "\" status=\"ok\">" |
| 498 "<updatecheck status=\"noupdate\"/><ping status=\"ok\"/>" |
| 499 "</app></response>"; |
| 500 fetcher->SetResponseString(response); |
| 501 fetcher->delegate()->OnURLFetchComplete(fetcher); |
| 502 |
| 503 EXPECT_FALSE(service.IsNextPingInstallRetry()); |
| 504 id1 = service.GetNextPingRequestId(OmahaService::USAGE_PING); |
| 505 ASSERT_NE(id1, service.GetNextPingRequestId(OmahaService::USAGE_PING)); |
| 506 } |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 2568003005:
[ios] Adds code for Omaha and the upgrade center. (Closed)
