| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright 2010 Google Inc. | |
| 2 // | |
| 3 // Licensed under the Apache License, Version 2.0 (the "License"); | |
| 4 // you may not use this file except in compliance with the License. | |
| 5 // You may obtain a copy of the License at | |
| 6 // | |
| 7 // http://www.apache.org/licenses/LICENSE-2.0 | |
| 8 // | |
| 9 // Unless required by applicable law or agreed to in writing, software | |
| 10 // distributed under the License is distributed on an "AS IS" BASIS, | |
| 11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. | |
| 12 // See the License for the specific language governing permissions and | |
| 13 // limitations under the License. | |
| 14 // ======================================================================== | |
| 15 | |
| 16 #include <atlbase.h> | |
| 17 #include <atlcom.h> | |
| 18 #include "omaha/base/error.h" | |
| 19 #include "omaha/common/const_goopdate.h" | |
| 20 #include "omaha/common/const_group_policy.h" | |
| 21 #include "omaha/common/update_request.h" | |
| 22 #include "omaha/common/update_response.h" | |
| 23 #include "omaha/goopdate/app_state_checking_for_update.h" | |
| 24 #include "omaha/goopdate/app_state_update_available.h" | |
| 25 #include "omaha/goopdate/app_state_waiting_to_check_for_update.h" | |
| 26 #include "omaha/goopdate/app_unittest_base.h" | |
| 27 #include "omaha/testing/unit_test.h" | |
| 28 | |
| 29 using ::testing::_; | |
| 30 | |
| 31 namespace omaha { | |
| 32 | |
| 33 namespace { | |
| 34 | |
| 35 #define APP_ID1 _T("{D9F05AEA-BEDA-4f91-B216-BE45DAE330CB}"); | |
| 36 const TCHAR* const kAppId1 = APP_ID1 | |
| 37 const TCHAR* const kInstallPolicyApp1 = _T("Install") APP_ID1; | |
| 38 const TCHAR* const kUpdatePolicyApp1 = _T("Update") APP_ID1; | |
| 39 const TCHAR* const kAppId1ClientsKeyPathUser = | |
| 40 _T("HKCU\\Software\\") SHORT_COMPANY_NAME _T("\\") | |
| 41 PRODUCT_NAME _T("\\Clients\\") APP_ID1; | |
| 42 const TCHAR* const kGuid1ClientStateKeyPathUser = | |
| 43 _T("HKCU\\Software\\") SHORT_COMPANY_NAME _T("\\") | |
| 44 PRODUCT_NAME _T("\\ClientState\\") APP_ID1; | |
| 45 | |
| 46 #define APP_ID2 _T("{EF3CACD4-89EB-46b7-B9BF-B16B15F08584}"); | |
| 47 const TCHAR* const kInstallPolicyApp2 = _T("Install") APP_ID2; | |
| 48 const TCHAR* const kUpdatePolicyApp2 = _T("Update") APP_ID2; | |
| 49 | |
| 50 void SetPolicy(const CString& policy, DWORD value) { | |
| 51 EXPECT_SUCCEEDED(RegKey::SetValue(kRegKeyGoopdateGroupPolicy, | |
| 52 policy, | |
| 53 value)); | |
| 54 } | |
| 55 | |
| 56 } // namespace | |
| 57 | |
| 58 class AppTest : public AppTestBaseWithRegistryOverride { | |
| 59 protected: | |
| 60 explicit AppTest(bool use_strict_mock) | |
| 61 : AppTestBaseWithRegistryOverride(false, // Always as user for now. | |
| 62 use_strict_mock), | |
| 63 app_(NULL) {} | |
| 64 | |
| 65 virtual void SetUp() { | |
| 66 AppTestBaseWithRegistryOverride::SetUp(); | |
| 67 | |
| 68 update_response_.reset(xml::UpdateResponse::Create()); | |
| 69 } | |
| 70 | |
| 71 void AddAppResponse(const CString& status) { | |
| 72 xml::response::App app; | |
| 73 app.status = kResponseStatusOkValue; | |
| 74 app.appid = kAppId1; | |
| 75 app.update_check.status = status; | |
| 76 | |
| 77 xml::response::Response response; | |
| 78 response.apps.push_back(app); | |
| 79 | |
| 80 SetResponseForUnitTest(update_response_.get(), response); | |
| 81 } | |
| 82 | |
| 83 App* app_; | |
| 84 scoped_ptr<xml::UpdateResponse> update_response_; | |
| 85 | |
| 86 private: | |
| 87 DISALLOW_COPY_AND_ASSIGN(AppTest); | |
| 88 }; | |
| 89 | |
| 90 class AppInstallTest : public AppTest { | |
| 91 protected: | |
| 92 AppInstallTest() : AppTest(true) {} | |
| 93 | |
| 94 virtual void SetUp() { | |
| 95 AppTest::SetUp(); | |
| 96 EXPECT_SUCCEEDED( | |
| 97 app_bundle_->createApp(CComBSTR(kAppId1), &app_)); | |
| 98 ASSERT_TRUE(app_); | |
| 99 } | |
| 100 }; | |
| 101 | |
| 102 class AppManualUpdateTest : public AppTest { | |
| 103 protected: | |
| 104 AppManualUpdateTest() : AppTest(true) {} | |
| 105 explicit AppManualUpdateTest(bool use_strict_mock) | |
| 106 : AppTest(use_strict_mock) {} | |
| 107 | |
| 108 // Calling checkForUpdate() should leave AppBundle::is_auto_update as false. | |
| 109 virtual void SetUp() { | |
| 110 AppTest::SetUp(); | |
| 111 EXPECT_SUCCEEDED(RegKey::SetValue(kAppId1ClientsKeyPathUser, | |
| 112 kRegValueProductVersion, | |
| 113 _T("1.2.3.4"))); | |
| 114 EXPECT_SUCCEEDED(RegKey::SetValue(kAppId1ClientsKeyPathUser, | |
| 115 kRegValueAppName, | |
| 116 _T("Unit Test App"))); | |
| 117 EXPECT_SUCCEEDED(app_bundle_->createInstalledApp( | |
| 118 CComBSTR(kAppId1), &app_)); | |
| 119 ASSERT_TRUE(app_); | |
| 120 | |
| 121 EXPECT_CALL(*mock_worker_, CheckForUpdateAsync(_)).Times(1); | |
| 122 EXPECT_SUCCEEDED(app_bundle_->checkForUpdate()); | |
| 123 EXPECT_FALSE(app_bundle_->is_auto_update()); | |
| 124 } | |
| 125 }; | |
| 126 | |
| 127 class AppAutoUpdateTest : public AppManualUpdateTest { | |
| 128 protected: | |
| 129 AppAutoUpdateTest() : AppManualUpdateTest(false) {} | |
| 130 | |
| 131 // Calling UpdateAllAppsAsync() sets AppBundle::is_auto_update. | |
| 132 virtual void SetUp() { | |
| 133 AppTest::SetUp(); | |
| 134 EXPECT_SUCCEEDED(RegKey::SetValue(kAppId1ClientsKeyPathUser, | |
| 135 kRegValueProductVersion, | |
| 136 _T("1.2.3.4"))); | |
| 137 EXPECT_SUCCEEDED(RegKey::SetValue(kGuid1ClientStateKeyPathUser, | |
| 138 kRegValueProductVersion, | |
| 139 _T("1.2.3.4"))); | |
| 140 EXPECT_SUCCEEDED(RegKey::SetValue(kAppId1ClientsKeyPathUser, | |
| 141 kRegValueAppName, | |
| 142 _T("Unit Test App"))); | |
| 143 | |
| 144 EXPECT_CALL(*mock_worker_, UpdateAllAppsAsync(_)).Times(1); | |
| 145 EXPECT_SUCCEEDED(app_bundle_->updateAllApps()); | |
| 146 EXPECT_TRUE(app_bundle_->is_auto_update()); | |
| 147 | |
| 148 app_= app_bundle_->GetApp(0); | |
| 149 ASSERT_TRUE(app_); | |
| 150 } | |
| 151 }; | |
| 152 | |
| 153 // | |
| 154 // CheckGroupPolicy Tests. | |
| 155 // | |
| 156 | |
| 157 TEST_F(AppInstallTest, CheckGroupPolicy_NoPolicy) { | |
| 158 EXPECT_SUCCEEDED(app_->CheckGroupPolicy()); | |
| 159 } | |
| 160 | |
| 161 TEST_F(AppManualUpdateTest, CheckGroupPolicy_NoPolicy) { | |
| 162 EXPECT_SUCCEEDED(app_->CheckGroupPolicy()); | |
| 163 } | |
| 164 | |
| 165 TEST_F(AppAutoUpdateTest, CheckGroupPolicy_NoPolicy) { | |
| 166 EXPECT_SUCCEEDED(app_->CheckGroupPolicy()); | |
| 167 } | |
| 168 | |
| 169 TEST_F(AppInstallTest, CheckGroupPolicy_InstallDisabled) { | |
| 170 SetPolicy(kInstallPolicyApp1, kPolicyDisabled); | |
| 171 EXPECT_EQ(GOOPDATE_E_APP_INSTALL_DISABLED_BY_POLICY, | |
| 172 app_->CheckGroupPolicy()); | |
| 173 } | |
| 174 | |
| 175 TEST_F(AppManualUpdateTest, CheckGroupPolicy_InstallDisabled) { | |
| 176 SetPolicy(kInstallPolicyApp1, kPolicyDisabled); | |
| 177 EXPECT_SUCCEEDED(app_->CheckGroupPolicy()); | |
| 178 } | |
| 179 | |
| 180 TEST_F(AppAutoUpdateTest, CheckGroupPolicy_InstallDisabled) { | |
| 181 SetPolicy(kInstallPolicyApp1, kPolicyDisabled); | |
| 182 EXPECT_SUCCEEDED(app_->CheckGroupPolicy()); | |
| 183 } | |
| 184 | |
| 185 TEST_F(AppInstallTest, CheckGroupPolicy_AllUpdatesDisabled) { | |
| 186 SetPolicy(kUpdatePolicyApp1, kPolicyDisabled); | |
| 187 EXPECT_SUCCEEDED(app_->CheckGroupPolicy()); | |
| 188 } | |
| 189 | |
| 190 TEST_F(AppManualUpdateTest, CheckGroupPolicy_AllUpdatesDisabled) { | |
| 191 SetPolicy(kUpdatePolicyApp1, kPolicyDisabled); | |
| 192 EXPECT_EQ(GOOPDATE_E_APP_UPDATE_DISABLED_BY_POLICY, app_->CheckGroupPolicy()); | |
| 193 } | |
| 194 | |
| 195 TEST_F(AppAutoUpdateTest, CheckGroupPolicy_AllUpdatesDisabled) { | |
| 196 SetPolicy(kUpdatePolicyApp1, kPolicyDisabled); | |
| 197 EXPECT_EQ(GOOPDATE_E_APP_UPDATE_DISABLED_BY_POLICY, app_->CheckGroupPolicy()); | |
| 198 } | |
| 199 | |
| 200 TEST_F(AppInstallTest, CheckGroupPolicy_AutoUpdatesDisabled) { | |
| 201 SetPolicy(kUpdatePolicyApp1, kPolicyManualUpdatesOnly); | |
| 202 EXPECT_SUCCEEDED(app_->CheckGroupPolicy()); | |
| 203 } | |
| 204 | |
| 205 TEST_F(AppManualUpdateTest, CheckGroupPolicy_AutoUpdatesDisabled) { | |
| 206 SetPolicy(kUpdatePolicyApp1, kPolicyManualUpdatesOnly); | |
| 207 EXPECT_SUCCEEDED(app_->CheckGroupPolicy()); | |
| 208 } | |
| 209 | |
| 210 TEST_F(AppAutoUpdateTest, CheckGroupPolicy_AutoUpdatesDisabled) { | |
| 211 SetPolicy(kUpdatePolicyApp1, kPolicyManualUpdatesOnly); | |
| 212 EXPECT_EQ(GOOPDATE_E_APP_UPDATE_DISABLED_BY_POLICY, app_->CheckGroupPolicy()); | |
| 213 } | |
| 214 | |
| 215 // | |
| 216 // PostUpdateCheck Tests. | |
| 217 // | |
| 218 | |
| 219 TEST_F(AppInstallTest, PostUpdateCheck_NoUpdate) { | |
| 220 SetAppStateForUnitTest(app_, new fsm::AppStateCheckingForUpdate); | |
| 221 AddAppResponse(kResponseStatusNoUpdate); | |
| 222 | |
| 223 app_->PostUpdateCheck(S_OK, update_response_.get()); | |
| 224 EXPECT_EQ(STATE_ERROR, app_->state()); | |
| 225 EXPECT_EQ(GOOPDATE_E_NO_UPDATE_RESPONSE, app_->error_code()); | |
| 226 } | |
| 227 | |
| 228 TEST_F(AppInstallTest, PostUpdateCheck_UpdateAvailable) { | |
| 229 SetAppStateForUnitTest(app_, new fsm::AppStateCheckingForUpdate); | |
| 230 AddAppResponse(kResponseStatusOkValue); | |
| 231 | |
| 232 app_->PostUpdateCheck(S_OK, update_response_.get()); | |
| 233 EXPECT_EQ(STATE_UPDATE_AVAILABLE, app_->state()); | |
| 234 EXPECT_EQ(S_OK, app_->error_code()); | |
| 235 } | |
| 236 | |
| 237 // Policy is not checked by this function. | |
| 238 TEST_F(AppInstallTest, PostUpdateCheck_UpdateAvailable_InstallDisabled) { | |
| 239 SetPolicy(kInstallPolicyApp1, kPolicyDisabled); | |
| 240 SetAppStateForUnitTest(app_, new fsm::AppStateCheckingForUpdate); | |
| 241 AddAppResponse(kResponseStatusOkValue); | |
| 242 | |
| 243 app_->PostUpdateCheck(S_OK, update_response_.get()); | |
| 244 EXPECT_EQ(STATE_UPDATE_AVAILABLE, app_->state()); | |
| 245 EXPECT_EQ(S_OK, app_->error_code()); | |
| 246 } | |
| 247 | |
| 248 TEST_F(AppManualUpdateTest, PostUpdateCheck_NoUpdate) { | |
| 249 SetAppStateForUnitTest(app_, new fsm::AppStateCheckingForUpdate); | |
| 250 AddAppResponse(kResponseStatusNoUpdate); | |
| 251 | |
| 252 app_->PostUpdateCheck(S_OK, update_response_.get()); | |
| 253 EXPECT_EQ(STATE_NO_UPDATE, app_->state()); | |
| 254 EXPECT_EQ(0, app_->error_code()); | |
| 255 } | |
| 256 | |
| 257 TEST_F(AppManualUpdateTest, PostUpdateCheck_UpdateAvailable) { | |
| 258 SetAppStateForUnitTest(app_, new fsm::AppStateCheckingForUpdate); | |
| 259 AddAppResponse(kResponseStatusOkValue); | |
| 260 | |
| 261 app_->PostUpdateCheck(S_OK, update_response_.get()); | |
| 262 EXPECT_EQ(STATE_UPDATE_AVAILABLE, app_->state()); | |
| 263 EXPECT_EQ(S_OK, app_->error_code()); | |
| 264 } | |
| 265 | |
| 266 // Policy is not checked by this function. | |
| 267 TEST_F(AppManualUpdateTest, | |
| 268 PostUpdateCheck_UpdateAvailable_AllUpdatesDisabled) { | |
| 269 SetPolicy(kUpdatePolicyApp1, kPolicyDisabled); | |
| 270 SetAppStateForUnitTest(app_, new fsm::AppStateCheckingForUpdate); | |
| 271 AddAppResponse(kResponseStatusOkValue); | |
| 272 | |
| 273 app_->PostUpdateCheck(S_OK, update_response_.get()); | |
| 274 EXPECT_EQ(STATE_UPDATE_AVAILABLE, app_->state()); | |
| 275 EXPECT_EQ(S_OK, app_->error_code()); | |
| 276 } | |
| 277 | |
| 278 TEST_F(AppAutoUpdateTest, PostUpdateCheck_NoUpdate) { | |
| 279 SetAppStateForUnitTest(app_, new fsm::AppStateCheckingForUpdate); | |
| 280 AddAppResponse(kResponseStatusNoUpdate); | |
| 281 | |
| 282 app_->PostUpdateCheck(S_OK, update_response_.get()); | |
| 283 EXPECT_EQ(STATE_NO_UPDATE, app_->state()); | |
| 284 EXPECT_EQ(0, app_->error_code()); | |
| 285 } | |
| 286 | |
| 287 TEST_F(AppAutoUpdateTest, PostUpdateCheck_UpdateAvailable) { | |
| 288 SetAppStateForUnitTest(app_, new fsm::AppStateCheckingForUpdate); | |
| 289 AddAppResponse(kResponseStatusOkValue); | |
| 290 | |
| 291 app_->PostUpdateCheck(S_OK, update_response_.get()); | |
| 292 EXPECT_EQ(STATE_UPDATE_AVAILABLE, app_->state()); | |
| 293 EXPECT_EQ(S_OK, app_->error_code()); | |
| 294 } | |
| 295 | |
| 296 // Policy is not checked by this function. | |
| 297 TEST_F(AppAutoUpdateTest, PostUpdateCheck_UpdateAvailable_AllUpdatesDisabled) { | |
| 298 SetPolicy(kUpdatePolicyApp1, kPolicyDisabled); | |
| 299 SetAppStateForUnitTest(app_, new fsm::AppStateCheckingForUpdate); | |
| 300 AddAppResponse(kResponseStatusOkValue); | |
| 301 | |
| 302 app_->PostUpdateCheck(S_OK, update_response_.get()); | |
| 303 EXPECT_EQ(STATE_UPDATE_AVAILABLE, app_->state()); | |
| 304 EXPECT_EQ(S_OK, app_->error_code()); | |
| 305 } | |
| 306 | |
| 307 // | |
| 308 // QueueDownload Tests. | |
| 309 // | |
| 310 | |
| 311 TEST_F(AppInstallTest, QueueDownload_NoPolicy) { | |
| 312 SetAppStateForUnitTest(app_, new fsm::AppStateUpdateAvailable); | |
| 313 | |
| 314 app_->QueueDownload(); | |
| 315 EXPECT_EQ(STATE_WAITING_TO_DOWNLOAD, app_->state()); | |
| 316 EXPECT_EQ(S_OK, app_->error_code()); | |
| 317 } | |
| 318 | |
| 319 TEST_F(AppInstallTest, QueueDownload_InstallDisabled) { | |
| 320 SetPolicy(kInstallPolicyApp1, kPolicyDisabled); | |
| 321 SetAppStateForUnitTest(app_, new fsm::AppStateUpdateAvailable); | |
| 322 | |
| 323 app_->QueueDownload(); | |
| 324 EXPECT_EQ(STATE_ERROR, app_->state()); | |
| 325 EXPECT_EQ(GOOPDATE_E_APP_INSTALL_DISABLED_BY_POLICY, app_->error_code()); | |
| 326 } | |
| 327 | |
| 328 TEST_F(AppInstallTest, | |
| 329 QueueDownload_InstallDisabledForDifferentApp) { | |
| 330 SetPolicy(kInstallPolicyApp2, kPolicyDisabled); | |
| 331 SetAppStateForUnitTest(app_, new fsm::AppStateUpdateAvailable); | |
| 332 | |
| 333 app_->QueueDownload(); | |
| 334 EXPECT_EQ(STATE_WAITING_TO_DOWNLOAD, app_->state()); | |
| 335 EXPECT_EQ(S_OK, app_->error_code()); | |
| 336 } | |
| 337 | |
| 338 TEST_F(AppInstallTest, QueueDownload_AllUpdatesDisabled) { | |
| 339 SetPolicy(kUpdatePolicyApp1, kPolicyDisabled); | |
| 340 SetAppStateForUnitTest(app_, new fsm::AppStateUpdateAvailable); | |
| 341 | |
| 342 app_->QueueDownload(); | |
| 343 EXPECT_EQ(STATE_WAITING_TO_DOWNLOAD, app_->state()); | |
| 344 EXPECT_EQ(S_OK, app_->error_code()); | |
| 345 } | |
| 346 | |
| 347 TEST_F(AppManualUpdateTest, QueueDownload_NoPolicy) { | |
| 348 SetAppStateForUnitTest(app_, new fsm::AppStateUpdateAvailable); | |
| 349 | |
| 350 app_->QueueDownload(); | |
| 351 EXPECT_EQ(STATE_WAITING_TO_DOWNLOAD, app_->state()); | |
| 352 EXPECT_EQ(S_OK, app_->error_code()); | |
| 353 } | |
| 354 | |
| 355 TEST_F(AppManualUpdateTest, QueueDownload_AllUpdatesDisabled) { | |
| 356 SetPolicy(kUpdatePolicyApp1, kPolicyDisabled); | |
| 357 SetAppStateForUnitTest(app_, new fsm::AppStateUpdateAvailable); | |
| 358 | |
| 359 app_->QueueDownload(); | |
| 360 EXPECT_EQ(STATE_ERROR, app_->state()); | |
| 361 EXPECT_EQ(GOOPDATE_E_APP_UPDATE_DISABLED_BY_POLICY, app_->error_code()); | |
| 362 } | |
| 363 | |
| 364 TEST_F(AppManualUpdateTest, | |
| 365 QueueDownload_AllUpdatesDisabledForDifferentApp) { | |
| 366 SetPolicy(kUpdatePolicyApp2, kPolicyDisabled); | |
| 367 SetAppStateForUnitTest(app_, new fsm::AppStateUpdateAvailable); | |
| 368 | |
| 369 app_->QueueDownload(); | |
| 370 EXPECT_EQ(STATE_WAITING_TO_DOWNLOAD, app_->state()); | |
| 371 EXPECT_EQ(S_OK, app_->error_code()); | |
| 372 } | |
| 373 | |
| 374 TEST_F(AppManualUpdateTest, QueueDownload_AutoUpdatesDisabled) { | |
| 375 SetPolicy(kUpdatePolicyApp1, kPolicyManualUpdatesOnly); | |
| 376 SetAppStateForUnitTest(app_, new fsm::AppStateUpdateAvailable); | |
| 377 | |
| 378 app_->QueueDownload(); | |
| 379 EXPECT_EQ(STATE_WAITING_TO_DOWNLOAD, app_->state()); | |
| 380 EXPECT_EQ(S_OK, app_->error_code()); | |
| 381 } | |
| 382 | |
| 383 TEST_F(AppManualUpdateTest, QueueDownload_InstallDisabled) { | |
| 384 SetPolicy(kInstallPolicyApp1, kPolicyDisabled); | |
| 385 SetAppStateForUnitTest(app_, new fsm::AppStateUpdateAvailable); | |
| 386 | |
| 387 app_->QueueDownload(); | |
| 388 EXPECT_EQ(STATE_WAITING_TO_DOWNLOAD, app_->state()); | |
| 389 EXPECT_EQ(S_OK, app_->error_code()); | |
| 390 } | |
| 391 | |
| 392 TEST_F(AppAutoUpdateTest, QueueDownload_AllUpdatesDisabled_NoPolicy) { | |
| 393 SetAppStateForUnitTest(app_, new fsm::AppStateUpdateAvailable); | |
| 394 | |
| 395 app_->QueueDownload(); | |
| 396 EXPECT_EQ(STATE_WAITING_TO_DOWNLOAD, app_->state()); | |
| 397 EXPECT_EQ(S_OK, app_->error_code()); | |
| 398 } | |
| 399 | |
| 400 TEST_F(AppAutoUpdateTest, QueueDownload_AllUpdatesDisabled) { | |
| 401 SetPolicy(kUpdatePolicyApp1, kPolicyDisabled); | |
| 402 SetAppStateForUnitTest(app_, new fsm::AppStateUpdateAvailable); | |
| 403 | |
| 404 app_->QueueDownload(); | |
| 405 EXPECT_EQ(STATE_ERROR, app_->state()); | |
| 406 EXPECT_EQ(GOOPDATE_E_APP_UPDATE_DISABLED_BY_POLICY, app_->error_code()); | |
| 407 } | |
| 408 | |
| 409 TEST_F(AppAutoUpdateTest, QueueDownload_AllUpdatesDisabledForDifferentApp) { | |
| 410 SetPolicy(kUpdatePolicyApp2, kPolicyDisabled); | |
| 411 SetAppStateForUnitTest(app_, new fsm::AppStateUpdateAvailable); | |
| 412 | |
| 413 app_->QueueDownload(); | |
| 414 EXPECT_EQ(STATE_WAITING_TO_DOWNLOAD, app_->state()); | |
| 415 EXPECT_EQ(S_OK, app_->error_code()); | |
| 416 } | |
| 417 | |
| 418 TEST_F(AppAutoUpdateTest, QueueDownload_AutoUpdatesDisabled) { | |
| 419 SetPolicy(kUpdatePolicyApp1, kPolicyManualUpdatesOnly); | |
| 420 SetAppStateForUnitTest(app_, new fsm::AppStateUpdateAvailable); | |
| 421 | |
| 422 app_->QueueDownload(); | |
| 423 EXPECT_EQ(STATE_ERROR, app_->state()); | |
| 424 EXPECT_EQ(GOOPDATE_E_APP_UPDATE_DISABLED_BY_POLICY, app_->error_code()); | |
| 425 } | |
| 426 | |
| 427 TEST_F(AppAutoUpdateTest, QueueDownload_InstallDisabled) { | |
| 428 SetPolicy(kInstallPolicyApp1, kPolicyDisabled); | |
| 429 SetAppStateForUnitTest(app_, new fsm::AppStateUpdateAvailable); | |
| 430 | |
| 431 app_->QueueDownload(); | |
| 432 EXPECT_EQ(STATE_WAITING_TO_DOWNLOAD, app_->state()); | |
| 433 EXPECT_EQ(S_OK, app_->error_code()); | |
| 434 } | |
| 435 | |
| 436 // | |
| 437 // PreUpdateCheck Tests. | |
| 438 // | |
| 439 | |
| 440 TEST_F(AppInstallTest, PreUpdateCheck_EulaAccepted) { | |
| 441 SetAppStateForUnitTest(app_, new fsm::AppStateWaitingToCheckForUpdate); | |
| 442 EXPECT_SUCCEEDED(app_->put_isEulaAccepted(VARIANT_TRUE)); | |
| 443 | |
| 444 scoped_ptr<xml::UpdateRequest> update_request; | |
| 445 update_request.reset(xml::UpdateRequest::Create(is_machine_, | |
| 446 _T("unittest_sessionid"), | |
| 447 _T("unittest_instsource"), | |
| 448 CString())); | |
| 449 EXPECT_TRUE(update_request->IsEmpty()); | |
| 450 | |
| 451 app_->PreUpdateCheck(update_request.get()); | |
| 452 EXPECT_EQ(STATE_CHECKING_FOR_UPDATE, app_->state()); | |
| 453 EXPECT_EQ(S_OK, app_->error_code()); | |
| 454 EXPECT_FALSE(update_request->IsEmpty()); | |
| 455 } | |
| 456 | |
| 457 TEST_F(AppAutoUpdateTest, PreUpdateCheck_EulaAccepted) { | |
| 458 SetAppStateForUnitTest(app_, new fsm::AppStateWaitingToCheckForUpdate); | |
| 459 EXPECT_SUCCEEDED(app_->put_isEulaAccepted(VARIANT_TRUE)); | |
| 460 | |
| 461 scoped_ptr<xml::UpdateRequest> update_request; | |
| 462 update_request.reset(xml::UpdateRequest::Create(is_machine_, | |
| 463 _T("unittest_sessionid"), | |
| 464 _T("unittest_instsource"), | |
| 465 CString())); | |
| 466 EXPECT_TRUE(update_request->IsEmpty()); | |
| 467 | |
| 468 app_->PreUpdateCheck(update_request.get()); | |
| 469 EXPECT_EQ(STATE_CHECKING_FOR_UPDATE, app_->state()); | |
| 470 EXPECT_EQ(S_OK, app_->error_code()); | |
| 471 EXPECT_FALSE(update_request->IsEmpty()); | |
| 472 } | |
| 473 | |
| 474 TEST_F(AppInstallTest, PreUpdateCheck_EulaNotAccepted_Online) { | |
| 475 SetAppStateForUnitTest(app_, new fsm::AppStateWaitingToCheckForUpdate); | |
| 476 EXPECT_SUCCEEDED(app_->put_isEulaAccepted(VARIANT_FALSE)); | |
| 477 | |
| 478 scoped_ptr<xml::UpdateRequest> update_request; | |
| 479 update_request.reset(xml::UpdateRequest::Create(is_machine_, | |
| 480 _T("unittest_sessionid"), | |
| 481 _T("unittest_instsource"), | |
| 482 CString())); | |
| 483 | |
| 484 ExpectAsserts expect_asserts; // Asserts because not is_update. | |
| 485 | |
| 486 app_->PreUpdateCheck(update_request.get()); | |
| 487 EXPECT_EQ(STATE_ERROR, app_->state()); | |
| 488 EXPECT_EQ(GOOPDATE_E_APP_UPDATE_DISABLED_EULA_NOT_ACCEPTED, | |
| 489 app_->error_code()); | |
| 490 EXPECT_TRUE(update_request->IsEmpty()) << _T("Should not add request."); | |
| 491 } | |
| 492 | |
| 493 TEST_F(AppInstallTest, PreUpdateCheck_EulaNotAccepted_Offline) { | |
| 494 SetAppStateForUnitTest(app_, new fsm::AppStateWaitingToCheckForUpdate); | |
| 495 EXPECT_SUCCEEDED(app_->put_isEulaAccepted(VARIANT_FALSE)); | |
| 496 EXPECT_SUCCEEDED(app_bundle_->put_offlineDirectory(CComBSTR(_T("foo")))); | |
| 497 | |
| 498 scoped_ptr<xml::UpdateRequest> update_request; | |
| 499 update_request.reset(xml::UpdateRequest::Create(is_machine_, | |
| 500 _T("unittest_sessionid"), | |
| 501 _T("unittest_instsource"), | |
| 502 CString())); | |
| 503 | |
| 504 app_->PreUpdateCheck(update_request.get()); | |
| 505 EXPECT_EQ(STATE_CHECKING_FOR_UPDATE, app_->state()); | |
| 506 EXPECT_EQ(S_OK, app_->error_code()); | |
| 507 EXPECT_TRUE(update_request->IsEmpty()) << _T("Should not add request."); | |
| 508 } | |
| 509 | |
| 510 TEST_F(AppAutoUpdateTest, PreUpdateCheck_EulaNotAccepted) { | |
| 511 SetAppStateForUnitTest(app_, new fsm::AppStateWaitingToCheckForUpdate); | |
| 512 EXPECT_SUCCEEDED(app_->put_isEulaAccepted(VARIANT_FALSE)); | |
| 513 | |
| 514 scoped_ptr<xml::UpdateRequest> update_request; | |
| 515 update_request.reset(xml::UpdateRequest::Create(is_machine_, | |
| 516 _T("unittest_sessionid"), | |
| 517 _T("unittest_instsource"), | |
| 518 CString())); | |
| 519 | |
| 520 app_->PreUpdateCheck(update_request.get()); | |
| 521 EXPECT_EQ(STATE_ERROR, app_->state()); | |
| 522 EXPECT_EQ(GOOPDATE_E_APP_UPDATE_DISABLED_EULA_NOT_ACCEPTED, | |
| 523 app_->error_code()); | |
| 524 EXPECT_TRUE(update_request->IsEmpty()) << _T("Should not add request."); | |
| 525 } | |
| 526 | |
| 527 } // namespace omaha | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 624713003:
Keep only base/extractor.[cc|h]. (Closed)
Base URL: https://chromium.googlesource.com/external/omaha.git@master