| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright 2007-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 <atlpath.h> | |
| 17 #include <atlstr.h> | |
| 18 #include "base/scoped_ptr.h" | |
| 19 #include "omaha/base/app_util.h" | |
| 20 #include "omaha/base/error.h" | |
| 21 #include "omaha/base/file.h" | |
| 22 #include "omaha/base/path.h" | |
| 23 #include "omaha/base/process.h" | |
| 24 #include "omaha/base/reg_key.h" | |
| 25 #include "omaha/base/scoped_ptr_address.h" | |
| 26 #include "omaha/base/shell.h" | |
| 27 #include "omaha/base/system.h" | |
| 28 #include "omaha/base/timer.h" | |
| 29 #include "omaha/base/utils.h" | |
| 30 #include "omaha/base/vistautil.h" | |
| 31 #include "omaha/common/app_registry_utils.h" | |
| 32 #include "omaha/common/const_goopdate.h" | |
| 33 #include "omaha/common/install_manifest.h" | |
| 34 #include "omaha/goopdate/app_manager.h" | |
| 35 #include "omaha/goopdate/installer_wrapper.h" | |
| 36 #include "omaha/goopdate/model.h" | |
| 37 #include "omaha/goopdate/resource_manager.h" | |
| 38 #include "omaha/testing/unit_test.h" | |
| 39 | |
| 40 namespace omaha { | |
| 41 | |
| 42 namespace { | |
| 43 | |
| 44 const TCHAR kAppId[] = _T("{B18BC01B-E0BD-4BF0-A33E-1133055E5FDE}"); | |
| 45 const GUID kAppGuid = {0xB18BC01B, 0xE0BD, 0x4BF0, | |
| 46 {0xA3, 0x3E, 0x11, 0x33, 0x05, 0x5E, 0x5F, 0xDE}}; | |
| 47 | |
| 48 const TCHAR kFullAppClientsKeyPath[] = | |
| 49 _T("HKCU\\Software\\") SHORT_COMPANY_NAME _T("\\") | |
| 50 PRODUCT_NAME _T("\\Clients\\{B18BC01B-E0BD-4BF0-A33E-1133055E5FDE}"); | |
| 51 const TCHAR kFullAppClientStateKeyPath[] = | |
| 52 _T("HKCU\\Software\\") SHORT_COMPANY_NAME _T("\\") | |
| 53 PRODUCT_NAME _T("\\ClientState\\{B18BC01B-E0BD-4BF0-A33E-1133055E5FDE}"); | |
| 54 const TCHAR kFullFooAppClientKeyPath[] = | |
| 55 _T("HKLM\\Software\\") SHORT_COMPANY_NAME _T("\\") | |
| 56 PRODUCT_NAME _T("\\Clients\\{D6B08267-B440-4C85-9F79-E195E80D9937}"); | |
| 57 const TCHAR kFullFooAppClientStateKeyPath[] = | |
| 58 _T("HKLM\\Software\\") SHORT_COMPANY_NAME _T("\\") | |
| 59 PRODUCT_NAME _T("\\ClientState\\{D6B08267-B440-4C85-9F79-E195E80D9937}"); | |
| 60 | |
| 61 const TCHAR kSetupFooV1RelativeLocation[] = | |
| 62 _T("unittest_support\\test_foo_v1.0.101.0.msi"); | |
| 63 const TCHAR kFooGuid[] = _T("{D6B08267-B440-4C85-9F79-E195E80D9937}"); | |
| 64 const TCHAR kFooInstallerBarPropertyArg[] = _T("PROPBAR=7"); | |
| 65 const TCHAR kFooInstallerBarValueName[] = _T("propbar"); | |
| 66 | |
| 67 // Values related to using cmd.exe as an "installer". | |
| 68 const TCHAR kCmdExecutable[] = _T("cmd.exe"); | |
| 69 const TCHAR kExecuteCommandAndTerminateSwitch[] = _T("/c %s"); | |
| 70 const TCHAR kExecuteTwoCommandsFormat[] = _T("\"%s & %s\""); | |
| 71 | |
| 72 const TCHAR kMsiLogFormat[] = _T("%s.log"); | |
| 73 | |
| 74 const TCHAR kMsiUninstallArguments[] = _T("/quiet /uninstall \"%s\""); | |
| 75 const TCHAR kMsiCommand[] = _T("msiexec"); | |
| 76 | |
| 77 const DWORD kInitialErrorValue = 5; | |
| 78 const TCHAR kMeaninglessErrorString[] = _T("This is an error string."); | |
| 79 | |
| 80 // Some error strings are slightly different on Vista than XP because spaces | |
| 81 // were removed. Therefore, the comparison must ignore that space. | |
| 82 | |
| 83 // The US English error string for ERROR_INSTALL_PACKAGE_OPEN_FAILED. | |
| 84 const TCHAR kMsiPackageOpenFailedStringPartA[] = | |
| 85 _T("This installation package could not be opened. "); | |
| 86 const TCHAR kMsiPackageOpenFailedStringPartB[] = | |
| 87 _T("Verify that the package exists and that you can access it, ") | |
| 88 _T("or contact the application vendor to verify that this is a ") | |
| 89 _T("valid Windows Installer package. "); | |
| 90 | |
| 91 // The US English error string for ERROR_INSTALL_ALREADY_RUNNING. | |
| 92 const TCHAR kMsiBusyStringPartA[] = | |
| 93 _T("Another installation is already in progress. "); | |
| 94 const TCHAR kMsiBusyStringPartB[] = | |
| 95 _T("Complete that installation before proceeding with this install. "); | |
| 96 | |
| 97 const TCHAR* const kError1603Text = | |
| 98 _T("The installer encountered error 1603: Fatal error during ") | |
| 99 _T("installation. "); | |
| 100 | |
| 101 const TCHAR kError1618MessagePrefix[] = | |
| 102 _T("The installer encountered error 1618: "); | |
| 103 const int kError1618MessagePrefixLength = | |
| 104 arraysize(kError1618MessagePrefix) - 1; | |
| 105 | |
| 106 const TCHAR* const kError0x800B010FText = | |
| 107 _T("The installer encountered error 0x800b010f: ") | |
| 108 _T("The certificate's CN name does not match the passed value. "); | |
| 109 | |
| 110 const TCHAR* const kLaunchCmdLine = | |
| 111 _T("\"C:\\Local\\Google\\Chrome\\Application\\chrome.exe\" -home"); | |
| 112 | |
| 113 const TCHAR* const kLanguageEnglish = _T("en"); | |
| 114 | |
| 115 const int kMsiAlreadyRunningRetryDelayBaseMs = 5000; | |
| 116 const int kNumMsiTriesDefault = 4; // Up to 35 seconds. | |
| 117 const int kNumMsiTriesOnBuildSystem = 7; // Up to 6.25 minutes. | |
| 118 | |
| 119 int GetNumMsiTries() { | |
| 120 return IsBuildSystem() ? kNumMsiTriesOnBuildSystem : kNumMsiTriesDefault; | |
| 121 } | |
| 122 | |
| 123 } // namespace | |
| 124 | |
| 125 extern const TCHAR kRegExecutable[] = _T("reg.exe"); | |
| 126 extern const TCHAR kSetInstallerResultTypeMsiErrorRegCmdArgs[] = | |
| 127 _T("add HKCU\\Software\\") SHORT_COMPANY_NAME _T("\\") PRODUCT_NAME | |
| 128 _T("\\UnitTest\\HKCU\\Software\\") SHORT_COMPANY_NAME _T("\\") | |
| 129 PRODUCT_NAME _T("\\ClientState\\{B18BC01B-E0BD-4BF0-A33E-1133055E5FDE} ") | |
| 130 _T("/v InstallerResult /t REG_DWORD /d 2"); | |
| 131 extern const TCHAR kMsiInstallerBusyExitCodeCmd[] = _T("exit 1618"); | |
| 132 | |
| 133 extern const TCHAR kError1619MessagePrefix[] = | |
| 134 _T("The installer encountered error 1619: "); | |
| 135 extern const int kError1619MessagePrefixLength = | |
| 136 arraysize(kError1619MessagePrefix) - 1; | |
| 137 | |
| 138 void VerifyStringIsMsiPackageOpenFailedString(const CString& str) { | |
| 139 EXPECT_STREQ(kMsiPackageOpenFailedStringPartA, | |
| 140 str.Left(arraysize(kMsiPackageOpenFailedStringPartA) - 1)); | |
| 141 EXPECT_STREQ(kMsiPackageOpenFailedStringPartB, | |
| 142 str.Right(arraysize(kMsiPackageOpenFailedStringPartB) - 1)); | |
| 143 } | |
| 144 | |
| 145 void VerifyStringIsMsiBusyString(const CString& str) { | |
| 146 EXPECT_STREQ(kMsiBusyStringPartA, | |
| 147 str.Left(arraysize(kMsiBusyStringPartA) - 1)); | |
| 148 EXPECT_STREQ(kMsiBusyStringPartB, | |
| 149 str.Right(arraysize(kMsiBusyStringPartB) - 1)); | |
| 150 } | |
| 151 | |
| 152 // Unit tests may run while other updaters are running on the build system. | |
| 153 // Give the tests lots of time to run to avoid false negatives. | |
| 154 void AdjustMsiTries(InstallerWrapper* installer_wrapper) { | |
| 155 ASSERT1(installer_wrapper); | |
| 156 installer_wrapper->set_num_tries_when_msi_busy(GetNumMsiTries()); | |
| 157 } | |
| 158 | |
| 159 // Waits for the uninstall to complete to avoid race conditions with other tests | |
| 160 // that install the same MSI. It appears msiexec causes an an asynchronous | |
| 161 // request that may be processed out of order. | |
| 162 // Retries when ERROR_INSTALL_ALREADY_RUNNING is encountered. | |
| 163 void UninstallTestMsi(const CString& installer_path) { | |
| 164 CString uninstall_arguments; | |
| 165 uninstall_arguments.Format(kMsiUninstallArguments, installer_path); | |
| 166 | |
| 167 const int max_tries = GetNumMsiTries(); | |
| 168 int retry_delay = kMsiAlreadyRunningRetryDelayBaseMs; | |
| 169 int num_tries(0); | |
| 170 uint32 exit_code = ERROR_INSTALL_ALREADY_RUNNING; | |
| 171 for (num_tries = 0; | |
| 172 exit_code == ERROR_INSTALL_ALREADY_RUNNING && num_tries < max_tries; | |
| 173 ++num_tries) { | |
| 174 if (0 < num_tries) { | |
| 175 // Retrying - wait between attempts. | |
| 176 ::Sleep(retry_delay); | |
| 177 retry_delay *= 2; // Double the retry delay next time. | |
| 178 } | |
| 179 | |
| 180 Process p(kMsiCommand, NULL); | |
| 181 EXPECT_HRESULT_SUCCEEDED(p.Start(uninstall_arguments, NULL)); | |
| 182 EXPECT_TRUE(p.WaitUntilDead(10000)); | |
| 183 | |
| 184 EXPECT_TRUE(p.GetExitCode(&exit_code)); | |
| 185 } | |
| 186 | |
| 187 EXPECT_EQ(0, exit_code); | |
| 188 } | |
| 189 | |
| 190 class InstallerWrapperTest : public testing::Test { | |
| 191 protected: | |
| 192 explicit InstallerWrapperTest(bool is_machine) | |
| 193 : is_machine_(is_machine), | |
| 194 hive_override_key_name_(kRegistryHiveOverrideRoot) { | |
| 195 } | |
| 196 | |
| 197 static void SetUpTestCase() { | |
| 198 CString system_path; | |
| 199 EXPECT_SUCCEEDED(Shell::GetSpecialFolder(CSIDL_SYSTEM, | |
| 200 false, | |
| 201 &system_path)); | |
| 202 EXPECT_FALSE(system_path.IsEmpty()); | |
| 203 cmd_exe_path_.Combine(system_path, kCmdExecutable); | |
| 204 EXPECT_TRUE(File::Exists(cmd_exe_path_)); | |
| 205 | |
| 206 CPath reg_path; | |
| 207 reg_path.Combine(system_path, kRegExecutable); | |
| 208 set_installer_result_type_msi_error_cmd_.Format( | |
| 209 _T("%s %s"), | |
| 210 reg_path, kSetInstallerResultTypeMsiErrorRegCmdArgs); | |
| 211 } | |
| 212 | |
| 213 virtual void SetUp() { | |
| 214 RegKey::DeleteKey(hive_override_key_name_, true); | |
| 215 OverrideRegistryHivesWithExecutionPermissions(hive_override_key_name_); | |
| 216 | |
| 217 EXPECT_SUCCEEDED(AppManager::CreateInstance(is_machine_)); | |
| 218 | |
| 219 im_.reset(new InstallerWrapper(is_machine_)); | |
| 220 EXPECT_SUCCEEDED(im_->Initialize()); | |
| 221 | |
| 222 EXPECT_SUCCEEDED(ResourceManager::Create( | |
| 223 is_machine_, app_util::GetCurrentModuleDirectory(), _T("en"))); | |
| 224 } | |
| 225 | |
| 226 virtual void TearDown() { | |
| 227 AppManager::DeleteInstance(); | |
| 228 | |
| 229 RestoreRegistryHives(); | |
| 230 ASSERT_SUCCEEDED(RegKey::DeleteKey(hive_override_key_name_, true)); | |
| 231 ResourceManager::Delete(); | |
| 232 } | |
| 233 | |
| 234 void SetupInstallerResultRegistry(const CString& app_guid, | |
| 235 bool set_installer_result, | |
| 236 DWORD installer_result, | |
| 237 bool set_installer_error, | |
| 238 DWORD installer_error, | |
| 239 bool set_installer_extra_code1, | |
| 240 DWORD installer_extra_code1, | |
| 241 bool set_installer_result_uistring, | |
| 242 const CString& installer_result_uistring, | |
| 243 bool set_installer_launch_cmd_line, | |
| 244 const CString& installer_launch_cmd_line) { | |
| 245 CString app_client_state_key = | |
| 246 app_registry_utils::GetAppClientStateKey(is_machine_, app_guid); | |
| 247 RegKey::CreateKey(app_client_state_key); | |
| 248 if (set_installer_result) { | |
| 249 RegKey::SetValue(app_client_state_key, | |
| 250 kRegValueInstallerResult, | |
| 251 installer_result); | |
| 252 } | |
| 253 | |
| 254 if (set_installer_error) { | |
| 255 RegKey::SetValue(app_client_state_key, | |
| 256 kRegValueInstallerError, | |
| 257 installer_error); | |
| 258 } | |
| 259 | |
| 260 if (set_installer_extra_code1) { | |
| 261 RegKey::SetValue(app_client_state_key, | |
| 262 kRegValueInstallerExtraCode1, | |
| 263 installer_extra_code1); | |
| 264 } | |
| 265 | |
| 266 if (set_installer_result_uistring) { | |
| 267 RegKey::SetValue(app_client_state_key, | |
| 268 kRegValueInstallerResultUIString, | |
| 269 installer_result_uistring); | |
| 270 } | |
| 271 | |
| 272 if (set_installer_launch_cmd_line) { | |
| 273 RegKey::SetValue(app_client_state_key, | |
| 274 kRegValueInstallerSuccessLaunchCmdLine, | |
| 275 installer_launch_cmd_line); | |
| 276 } | |
| 277 } | |
| 278 | |
| 279 void VerifyLastRegistryValues(const CString& app_guid, | |
| 280 bool expect_installer_result, | |
| 281 DWORD expected_installer_result, | |
| 282 bool expect_installer_error, | |
| 283 DWORD expected_installer_error, | |
| 284 bool expect_installer_extra_code1, | |
| 285 DWORD expected_installer_extra_code1, | |
| 286 bool expect_installer_result_uistring, | |
| 287 const CString& expected_result_uistring, | |
| 288 bool expect_installer_launch_cmd_line, | |
| 289 const CString& expected_launch_cmd_line) { | |
| 290 ASSERT_TRUE(expect_installer_result || !expected_installer_result); | |
| 291 ASSERT_TRUE(expect_installer_error || !expected_installer_error); | |
| 292 ASSERT_TRUE(expect_installer_extra_code1 || | |
| 293 !expected_installer_extra_code1); | |
| 294 ASSERT_TRUE(expect_installer_result_uistring || | |
| 295 expected_result_uistring.IsEmpty()); | |
| 296 ASSERT_TRUE(expect_installer_launch_cmd_line || | |
| 297 expected_launch_cmd_line.IsEmpty()); | |
| 298 | |
| 299 CString app_client_state_key = | |
| 300 app_registry_utils::GetAppClientStateKey(is_machine_, app_guid); | |
| 301 EXPECT_FALSE(RegKey::HasValue(app_client_state_key, | |
| 302 kRegValueInstallerResult)); | |
| 303 EXPECT_FALSE(RegKey::HasValue(app_client_state_key, | |
| 304 kRegValueInstallerError)); | |
| 305 EXPECT_FALSE(RegKey::HasValue(app_client_state_key, | |
| 306 kRegValueInstallerExtraCode1)); | |
| 307 EXPECT_FALSE(RegKey::HasValue(app_client_state_key, | |
| 308 kRegValueInstallerResultUIString)); | |
| 309 | |
| 310 if (expect_installer_result) { | |
| 311 EXPECT_TRUE(RegKey::HasValue(app_client_state_key, | |
| 312 kRegValueLastInstallerResult)); | |
| 313 DWORD last_installer_result = 0; | |
| 314 EXPECT_SUCCEEDED(RegKey::GetValue(app_client_state_key, | |
| 315 kRegValueLastInstallerResult, | |
| 316 &last_installer_result)); | |
| 317 EXPECT_EQ(expected_installer_result, last_installer_result); | |
| 318 } else { | |
| 319 EXPECT_FALSE(RegKey::HasValue(app_client_state_key, | |
| 320 kRegValueLastInstallerResult)); | |
| 321 } | |
| 322 | |
| 323 if (expect_installer_error) { | |
| 324 EXPECT_TRUE(RegKey::HasValue(app_client_state_key, | |
| 325 kRegValueLastInstallerError)); | |
| 326 DWORD last_installer_error = 0; | |
| 327 EXPECT_SUCCEEDED(RegKey::GetValue(app_client_state_key, | |
| 328 kRegValueLastInstallerError, | |
| 329 &last_installer_error)); | |
| 330 EXPECT_EQ(expected_installer_error, last_installer_error); | |
| 331 } else { | |
| 332 EXPECT_FALSE(RegKey::HasValue(app_client_state_key, | |
| 333 kRegValueLastInstallerError)); | |
| 334 } | |
| 335 | |
| 336 if (expect_installer_extra_code1) { | |
| 337 EXPECT_TRUE(RegKey::HasValue(app_client_state_key, | |
| 338 kRegValueLastInstallerExtraCode1)); | |
| 339 DWORD last_installer_extracode1 = 0; | |
| 340 EXPECT_SUCCEEDED(RegKey::GetValue(app_client_state_key, | |
| 341 kRegValueLastInstallerExtraCode1, | |
| 342 &last_installer_extracode1)); | |
| 343 EXPECT_EQ(expected_installer_extra_code1, last_installer_extracode1); | |
| 344 } else { | |
| 345 EXPECT_FALSE(RegKey::HasValue(app_client_state_key, | |
| 346 kRegValueLastInstallerExtraCode1)); | |
| 347 } | |
| 348 | |
| 349 if (expect_installer_result_uistring) { | |
| 350 EXPECT_TRUE(RegKey::HasValue(app_client_state_key, | |
| 351 kRegValueLastInstallerResultUIString)); | |
| 352 CString last_installer_result_uistring; | |
| 353 EXPECT_SUCCEEDED(RegKey::GetValue(app_client_state_key, | |
| 354 kRegValueLastInstallerResultUIString, | |
| 355 &last_installer_result_uistring)); | |
| 356 EXPECT_STREQ(expected_result_uistring, | |
| 357 last_installer_result_uistring); | |
| 358 } else { | |
| 359 EXPECT_FALSE(RegKey::HasValue(app_client_state_key, | |
| 360 kRegValueLastInstallerResultUIString)); | |
| 361 } | |
| 362 | |
| 363 if (expect_installer_launch_cmd_line) { | |
| 364 EXPECT_TRUE(RegKey::HasValue(app_client_state_key, | |
| 365 kRegValueLastInstallerSuccessLaunchCmdLine)); | |
| 366 CString last_installer_launch_cmd_line; | |
| 367 EXPECT_SUCCEEDED( | |
| 368 RegKey::GetValue(app_client_state_key, | |
| 369 kRegValueLastInstallerSuccessLaunchCmdLine, | |
| 370 &last_installer_launch_cmd_line)); | |
| 371 EXPECT_STREQ(expected_launch_cmd_line, | |
| 372 last_installer_launch_cmd_line); | |
| 373 } else { | |
| 374 EXPECT_FALSE(RegKey::HasValue( | |
| 375 app_client_state_key, | |
| 376 kRegValueLastInstallerSuccessLaunchCmdLine)); | |
| 377 } | |
| 378 } | |
| 379 | |
| 380 void VerifyNoLastRegistryValues(const CString& app_guid) { | |
| 381 VerifyLastRegistryValues(app_guid, | |
| 382 false, 0, | |
| 383 false, 0, | |
| 384 false, 0, | |
| 385 false, _T(""), | |
| 386 false, _T("")); | |
| 387 } | |
| 388 | |
| 389 void CallGetInstallerResultHelper(const GUID& app_guid, | |
| 390 int installer_type, | |
| 391 uint32 exit_code, | |
| 392 InstallerResultInfo* result_info) { | |
| 393 ASSERT1(result_info); | |
| 394 | |
| 395 im_->GetInstallerResultHelper( | |
| 396 app_guid, | |
| 397 static_cast<InstallerWrapper::InstallerType>(installer_type), | |
| 398 exit_code, | |
| 399 kLanguageEnglish, | |
| 400 result_info); | |
| 401 } | |
| 402 | |
| 403 static const int kResultSuccess = AppManager::INSTALLER_RESULT_SUCCESS; | |
| 404 static const int kResultFailedCustomError = | |
| 405 AppManager::INSTALLER_RESULT_FAILED_CUSTOM_ERROR; | |
| 406 static const int kResultFailedMsiError = | |
| 407 AppManager::INSTALLER_RESULT_FAILED_MSI_ERROR; | |
| 408 static const int kResultFailedSystemError = | |
| 409 AppManager::INSTALLER_RESULT_FAILED_SYSTEM_ERROR; | |
| 410 static const int kResultExitCode = AppManager::INSTALLER_RESULT_EXIT_CODE; | |
| 411 | |
| 412 static const int kMsiInstaller = InstallerWrapper::MSI_INSTALLER; | |
| 413 static const int kOtherInstaller = InstallerWrapper::CUSTOM_INSTALLER; | |
| 414 | |
| 415 bool is_machine_; | |
| 416 CString hive_override_key_name_; | |
| 417 scoped_ptr<InstallerWrapper> im_; | |
| 418 | |
| 419 // Used as an argument to various functions. | |
| 420 InstallerResultInfo result_info_; | |
| 421 | |
| 422 static CPath cmd_exe_path_; | |
| 423 static CString set_installer_result_type_msi_error_cmd_; | |
| 424 }; | |
| 425 | |
| 426 CPath InstallerWrapperTest::cmd_exe_path_; | |
| 427 CString InstallerWrapperTest::set_installer_result_type_msi_error_cmd_; | |
| 428 | |
| 429 class InstallerWrapperMachineTest : public InstallerWrapperTest { | |
| 430 protected: | |
| 431 InstallerWrapperMachineTest() | |
| 432 : InstallerWrapperTest(true) { | |
| 433 } | |
| 434 }; | |
| 435 | |
| 436 class InstallerWrapperUserTest : public InstallerWrapperTest { | |
| 437 protected: | |
| 438 InstallerWrapperUserTest() | |
| 439 : InstallerWrapperTest(false) { | |
| 440 } | |
| 441 }; | |
| 442 | |
| 443 class InstallerWrapperUserGetInstallerResultHelperTest | |
| 444 : public InstallerWrapperUserTest { | |
| 445 protected: | |
| 446 InstallerWrapperUserGetInstallerResultHelperTest() | |
| 447 : InstallerWrapperUserTest() { | |
| 448 result_info_.text = kMeaninglessErrorString; | |
| 449 } | |
| 450 | |
| 451 virtual void SetUp() { | |
| 452 InstallerWrapperUserTest::SetUp(); | |
| 453 AppManager::Instance()->GetRegistryStableStateLock().Lock(); | |
| 454 } | |
| 455 | |
| 456 virtual void TearDown() { | |
| 457 AppManager::Instance()->GetRegistryStableStateLock().Unlock(); | |
| 458 InstallerWrapperUserTest::TearDown(); | |
| 459 } | |
| 460 | |
| 461 // Shorter names used to make test calls fit on one line. | |
| 462 static const int kMsi = kMsiInstaller; | |
| 463 static const int kOther = kOtherInstaller; | |
| 464 }; | |
| 465 | |
| 466 // | |
| 467 // Helper method tests | |
| 468 // | |
| 469 TEST(InstallerWrapperTest, GetMessageForSystemErrorCode) { | |
| 470 VerifyStringIsMsiPackageOpenFailedString( | |
| 471 GetMessageForSystemErrorCode(ERROR_INSTALL_PACKAGE_OPEN_FAILED)); | |
| 472 } | |
| 473 | |
| 474 // CheckApplicationRegistration does not read the registry. This is verified by | |
| 475 // not setting any registry values before calling it. | |
| 476 | |
| 477 TEST_F(InstallerWrapperUserTest, | |
| 478 CheckApplicationRegistration_EmptyRegisteredVersion) { | |
| 479 EXPECT_EQ(GOOPDATEINSTALL_E_INSTALLER_DID_NOT_WRITE_CLIENTS_KEY, | |
| 480 im_->CheckApplicationRegistration( | |
| 481 kAppGuid, _T(""), _T(""), _T(""), false)); | |
| 482 EXPECT_EQ(GOOPDATEINSTALL_E_INSTALLER_DID_NOT_WRITE_CLIENTS_KEY, | |
| 483 im_->CheckApplicationRegistration( | |
| 484 kAppGuid, _T(""), _T(""), _T(""), true)); | |
| 485 EXPECT_EQ(GOOPDATEINSTALL_E_INSTALLER_DID_NOT_WRITE_CLIENTS_KEY, | |
| 486 im_->CheckApplicationRegistration( | |
| 487 kAppGuid, _T(""), _T("1.2.3.4"), _T(""), false)); | |
| 488 EXPECT_EQ(GOOPDATEINSTALL_E_INSTALLER_DID_NOT_WRITE_CLIENTS_KEY, | |
| 489 im_->CheckApplicationRegistration( | |
| 490 kAppGuid, _T(""), _T("1.2.3.4"), _T(""), true)); | |
| 491 EXPECT_EQ(GOOPDATEINSTALL_E_INSTALLER_DID_NOT_WRITE_CLIENTS_KEY, | |
| 492 im_->CheckApplicationRegistration( | |
| 493 kAppGuid, _T(""), _T("1.2.3.4"), _T("1.2.3.3"), false)); | |
| 494 EXPECT_EQ(GOOPDATEINSTALL_E_INSTALLER_DID_NOT_WRITE_CLIENTS_KEY, | |
| 495 im_->CheckApplicationRegistration( | |
| 496 kAppGuid, _T(""), _T("1.2.3.4"), _T("1.2.3.3"), true)); | |
| 497 } | |
| 498 | |
| 499 TEST_F(InstallerWrapperUserTest, | |
| 500 CheckApplicationRegistration_NoExpectedOrPreviousVersion) { | |
| 501 EXPECT_SUCCEEDED(im_->CheckApplicationRegistration( | |
| 502 kAppGuid, _T("0.9.6.4"), _T(""), _T(""), false)); | |
| 503 EXPECT_SUCCEEDED(im_->CheckApplicationRegistration( | |
| 504 kAppGuid, _T("0.9.6.4"), _T(""), _T(""), true)); | |
| 505 } | |
| 506 | |
| 507 TEST_F(InstallerWrapperUserTest, | |
| 508 CheckApplicationRegistration_ExpectedMatch_NoPreviousVersion) { | |
| 509 EXPECT_SUCCEEDED(im_->CheckApplicationRegistration( | |
| 510 kAppGuid, _T("0.9.6.4"), _T("0.9.6.4"), _T(""), false)); | |
| 511 EXPECT_SUCCEEDED(im_->CheckApplicationRegistration( | |
| 512 kAppGuid, _T("0.9.6.4"), _T("0.9.6.4"), _T(""), true)); | |
| 513 } | |
| 514 | |
| 515 TEST_F(InstallerWrapperUserTest, | |
| 516 CheckApplicationRegistration_NoExpectedVersion_PreviousVersionOlder) { | |
| 517 EXPECT_SUCCEEDED(im_->CheckApplicationRegistration( | |
| 518 kAppGuid, _T("0.9.6.4"), _T(""), _T("0.9.6.3"), false)); | |
| 519 EXPECT_SUCCEEDED(im_->CheckApplicationRegistration( | |
| 520 kAppGuid, _T("0.9.6.4"), _T(""), _T("0.9.6.3"), true)); | |
| 521 } | |
| 522 | |
| 523 TEST_F(InstallerWrapperUserTest, | |
| 524 CheckApplicationRegistration_ExpectedMatch_PreviousVersionSame_UnchangedA
llowed) { // NOLINT | |
| 525 EXPECT_SUCCEEDED( | |
| 526 im_->CheckApplicationRegistration( | |
| 527 kAppGuid, _T("0.9.6.4"), _T(""), _T("0.9.6.4"), false)); | |
| 528 EXPECT_SUCCEEDED( | |
| 529 im_->CheckApplicationRegistration( | |
| 530 kAppGuid, _T("0.9.6.4"), _T("0.9.6.4"), _T("0.9.6.4"), false)); | |
| 531 } | |
| 532 | |
| 533 TEST_F(InstallerWrapperUserTest, | |
| 534 CheckApplicationRegistration_ExpectedMatch_PreviousVersionSame_UnchangedN
otAllowed) { // NOLINT | |
| 535 EXPECT_EQ(GOOPDATEINSTALL_E_INSTALLER_DID_NOT_CHANGE_VERSION, | |
| 536 im_->CheckApplicationRegistration( | |
| 537 kAppGuid, _T("0.9.6.4"), _T(""), _T("0.9.6.4"), true)); | |
| 538 | |
| 539 ExpectAsserts expect_asserts; // expected_version is expected to be greater. | |
| 540 EXPECT_EQ(GOOPDATEINSTALL_E_INSTALLER_DID_NOT_CHANGE_VERSION, | |
| 541 im_->CheckApplicationRegistration( | |
| 542 kAppGuid, _T("0.9.6.4"), _T("0.9.6.4"), _T("0.9.6.4"), true)); | |
| 543 } | |
| 544 | |
| 545 TEST_F(InstallerWrapperUserTest, | |
| 546 CheckApplicationRegistration_ExpectedMatch_PreviousVersionOlder) { | |
| 547 EXPECT_SUCCEEDED( | |
| 548 im_->CheckApplicationRegistration( | |
| 549 kAppGuid, _T("0.9.6.4"), _T("0.9.6.4"), _T("0.9.6.3"), false)); | |
| 550 EXPECT_SUCCEEDED( | |
| 551 im_->CheckApplicationRegistration( | |
| 552 kAppGuid, _T("0.9.6.4"), _T("0.9.6.4"), _T("0.9.6.3"), true)); | |
| 553 } | |
| 554 | |
| 555 TEST_F(InstallerWrapperUserTest, | |
| 556 CheckApplicationRegistration_ExpectedMatch_PreviousVersionNewer) { | |
| 557 EXPECT_SUCCEEDED( | |
| 558 im_->CheckApplicationRegistration( | |
| 559 kAppGuid, _T("0.9.6.4"), _T("0.9.6.4"), _T("0.9.6.5"), false)); | |
| 560 EXPECT_SUCCEEDED( | |
| 561 im_->CheckApplicationRegistration( | |
| 562 kAppGuid, _T("0.9.6.4"), _T("0.9.6.4"), _T("0.9.6.5"), true)); | |
| 563 } | |
| 564 | |
| 565 // This is the over-install when a newer version is present case. This might | |
| 566 // happen if a dev track version is installed and a stable track version is | |
| 567 // installed. For installs, this is okay. | |
| 568 TEST_F(InstallerWrapperUserTest, | |
| 569 CheckApplicationRegistration_ExpectedMatch_RegisteredNewer_NoPreviousVers
ion_NewInstall) { // NOLINT | |
| 570 EXPECT_SUCCEEDED( | |
| 571 im_->CheckApplicationRegistration( | |
| 572 kAppGuid, _T("0.9.6.4"), _T("0.9.6.3"), _T(""), false)); | |
| 573 } | |
| 574 | |
| 575 TEST_F(InstallerWrapperUserTest, | |
| 576 CheckApplicationRegistration_ExpectedMismatch_RegisteredNewer_NoPreviousV
ersion_Update) { // NOLINT | |
| 577 EXPECT_EQ(GOOPDATEINSTALL_E_INSTALLER_VERSION_MISMATCH, | |
| 578 im_->CheckApplicationRegistration( | |
| 579 kAppGuid, _T("0.9.6.4"), _T("0.9.6.3"), _T(""), true)); | |
| 580 } | |
| 581 | |
| 582 // This is the over-install when a newer version is present case. This might | |
| 583 // happen if a dev track version is installed and a stable track version is | |
| 584 // installed. For installs, this is okay. | |
| 585 TEST_F(InstallerWrapperUserTest, | |
| 586 CheckApplicationRegistration_ExpectedMismatch_RegisteredNewer_PreviousVer
sionSame) { // NOLINT | |
| 587 EXPECT_SUCCEEDED( | |
| 588 im_->CheckApplicationRegistration( | |
| 589 kAppGuid, _T("0.9.6.4"), _T("0.9.6.3"), _T("0.9.6.4"), false)); | |
| 590 ExpectAsserts expect_asserts; // expected_version is expected to be greater. | |
| 591 EXPECT_EQ(GOOPDATEINSTALL_E_INSTALLER_DID_NOT_CHANGE_VERSION, | |
| 592 im_->CheckApplicationRegistration( | |
| 593 kAppGuid, _T("0.9.6.4"), _T("0.9.6.3"), _T("0.9.6.4"), true)); | |
| 594 } | |
| 595 | |
| 596 TEST_F(InstallerWrapperUserTest, | |
| 597 CheckApplicationRegistration_ExpectedMismatch_RegisteredNewer_PreviousVer
sionDifferent) { // NOLINT | |
| 598 EXPECT_SUCCEEDED( | |
| 599 im_->CheckApplicationRegistration( | |
| 600 kAppGuid, _T("0.9.6.4"), _T("0.9.6.3"), _T("0.9.6.3"), false)); | |
| 601 EXPECT_EQ(GOOPDATEINSTALL_E_INSTALLER_VERSION_MISMATCH, | |
| 602 im_->CheckApplicationRegistration( | |
| 603 kAppGuid, _T("0.9.6.4"), _T("0.9.6.3"), _T("0.9.6.3"), true)); | |
| 604 } | |
| 605 | |
| 606 TEST_F(InstallerWrapperUserTest, | |
| 607 CheckApplicationRegistration_ExpectedMismatch_RegisteredOlder_NoPreviousV
ersion) { // NOLINT | |
| 608 EXPECT_EQ(GOOPDATEINSTALL_E_INSTALLER_VERSION_MISMATCH, | |
| 609 im_->CheckApplicationRegistration( | |
| 610 kAppGuid, _T("0.9.6.2"), _T("0.9.6.3"), _T(""), false)); | |
| 611 EXPECT_EQ(GOOPDATEINSTALL_E_INSTALLER_VERSION_MISMATCH, | |
| 612 im_->CheckApplicationRegistration( | |
| 613 kAppGuid, _T("0.9.6.2"), _T("0.9.6.3"), _T(""), true)); | |
| 614 } | |
| 615 | |
| 616 TEST_F(InstallerWrapperUserTest, | |
| 617 CheckApplicationRegistration_ExpectedMismatch_RegisteredOlder_PreviousVer
sionSame) { // NOLINT | |
| 618 EXPECT_EQ(GOOPDATEINSTALL_E_INSTALLER_VERSION_MISMATCH, | |
| 619 im_->CheckApplicationRegistration( | |
| 620 kAppGuid, _T("0.9.6.2"), _T("0.9.6.3"), _T("0.9.6.2"), false)); | |
| 621 EXPECT_EQ(GOOPDATEINSTALL_E_INSTALLER_VERSION_MISMATCH, | |
| 622 im_->CheckApplicationRegistration( | |
| 623 kAppGuid, _T("0.9.6.2"), _T("0.9.6.3"), _T("0.9.6.2"), true)); | |
| 624 } | |
| 625 | |
| 626 TEST_F(InstallerWrapperUserTest, | |
| 627 CheckApplicationRegistration_ExpectedMismatch_RegisteredOlder_PreviousVer
sionDifferent) { // NOLINT | |
| 628 EXPECT_EQ(GOOPDATEINSTALL_E_INSTALLER_VERSION_MISMATCH, | |
| 629 im_->CheckApplicationRegistration( | |
| 630 kAppGuid, _T("0.9.6.2"), _T("0.9.6.3"), _T("0.9.6.1"), false)); | |
| 631 EXPECT_EQ(GOOPDATEINSTALL_E_INSTALLER_VERSION_MISMATCH, | |
| 632 im_->CheckApplicationRegistration( | |
| 633 kAppGuid, _T("0.9.6.2"), _T("0.9.6.3"), _T("0.9.6.1"), true)); | |
| 634 } | |
| 635 | |
| 636 TEST_F(InstallerWrapperUserTest, | |
| 637 CheckApplicationRegistration_ExpectedMismatch_RegisteredNewer_PreviousVer
sionSame_UnrecognizedVersions) { // NOLINT | |
| 638 EXPECT_EQ(GOOPDATEINSTALL_E_INSTALLER_VERSION_MISMATCH, | |
| 639 im_->CheckApplicationRegistration( | |
| 640 kAppGuid, _T("0.9.6.4.0"), _T("0.9.6.3"), _T("0.9.6.4.0"), | |
| 641 false)); | |
| 642 EXPECT_EQ(GOOPDATEINSTALL_E_INSTALLER_VERSION_MISMATCH, | |
| 643 im_->CheckApplicationRegistration( | |
| 644 kAppGuid, _T("0.9.6.4.0"), _T("0.9.6.3"), _T("0.9.6.4.0"), | |
| 645 true)); | |
| 646 | |
| 647 EXPECT_EQ(GOOPDATEINSTALL_E_INSTALLER_VERSION_MISMATCH, | |
| 648 im_->CheckApplicationRegistration( | |
| 649 kAppGuid, _T("0.9.6.4"), _T("0.9.6.3.0"), _T("0.9.6.4"), | |
| 650 false)); | |
| 651 EXPECT_EQ(GOOPDATEINSTALL_E_INSTALLER_VERSION_MISMATCH, | |
| 652 im_->CheckApplicationRegistration( | |
| 653 kAppGuid, _T("0.9.6.4"), _T("0.9.6.3.0"), _T("0.9.6.4"), | |
| 654 true)); | |
| 655 | |
| 656 EXPECT_EQ(GOOPDATEINSTALL_E_INSTALLER_VERSION_MISMATCH, | |
| 657 im_->CheckApplicationRegistration( | |
| 658 kAppGuid, _T("0.9.6.4.0"), _T("0.9.6.3.0"), _T("0.9.6.4.0"), | |
| 659 false)); | |
| 660 EXPECT_EQ(GOOPDATEINSTALL_E_INSTALLER_VERSION_MISMATCH, | |
| 661 im_->CheckApplicationRegistration( | |
| 662 kAppGuid, _T("0.9.6.4.0"), _T("0.9.6.3.0"), _T("0.9.6.4.0"), | |
| 663 true)); | |
| 664 | |
| 665 EXPECT_EQ(GOOPDATEINSTALL_E_INSTALLER_VERSION_MISMATCH, | |
| 666 im_->CheckApplicationRegistration( | |
| 667 kAppGuid, _T("0.9.6"), _T("0.9.5"), _T("0.9.6"), false)); | |
| 668 EXPECT_EQ(GOOPDATEINSTALL_E_INSTALLER_VERSION_MISMATCH, | |
| 669 im_->CheckApplicationRegistration( | |
| 670 kAppGuid, _T("0.9.6"), _T("0.9.5"), _T("0.9.6"), true)); | |
| 671 } | |
| 672 | |
| 673 // | |
| 674 // Negative Tests | |
| 675 // | |
| 676 | |
| 677 TEST_F(InstallerWrapperUserTest, InstallApp_InstallerWithoutFilenameExtension) { | |
| 678 EXPECT_EQ(GOOPDATEINSTALL_E_FILENAME_INVALID, | |
| 679 im_->InstallApp(NULL, | |
| 680 kAppGuid, | |
| 681 _T("c:\\temp\\foo"), | |
| 682 _T(""), // Arguments. | |
| 683 _T(""), // Installer data. | |
| 684 kLanguageEnglish, | |
| 685 &result_info_)); | |
| 686 | |
| 687 EXPECT_EQ(INSTALLER_RESULT_UNKNOWN, result_info_.type); | |
| 688 EXPECT_EQ(S_OK, result_info_.code); | |
| 689 EXPECT_TRUE(result_info_.text.IsEmpty()); | |
| 690 EXPECT_TRUE(result_info_.post_install_launch_command_line.IsEmpty()); | |
| 691 EXPECT_TRUE(result_info_.post_install_url.IsEmpty()); | |
| 692 EXPECT_EQ(POST_INSTALL_ACTION_DEFAULT, result_info_.post_install_action); | |
| 693 } | |
| 694 | |
| 695 TEST_F(InstallerWrapperUserTest, | |
| 696 InstallApp_UnsupportedInstallerFilenameExtension) { | |
| 697 EXPECT_EQ(GOOPDATEINSTALL_E_FILENAME_INVALID, | |
| 698 im_->InstallApp(NULL, | |
| 699 kAppGuid, | |
| 700 _T("c:\\temp\\foo.bar"), | |
| 701 _T(""), // Arguments. | |
| 702 _T(""), // Installer data. | |
| 703 kLanguageEnglish, | |
| 704 &result_info_)); | |
| 705 | |
| 706 EXPECT_EQ(INSTALLER_RESULT_UNKNOWN, result_info_.type); | |
| 707 EXPECT_EQ(S_OK, result_info_.code); | |
| 708 EXPECT_TRUE(result_info_.text.IsEmpty()); | |
| 709 EXPECT_TRUE(result_info_.post_install_launch_command_line.IsEmpty()); | |
| 710 EXPECT_TRUE(result_info_.post_install_url.IsEmpty()); | |
| 711 EXPECT_EQ(POST_INSTALL_ACTION_DEFAULT, result_info_.post_install_action); | |
| 712 } | |
| 713 | |
| 714 TEST_F(InstallerWrapperUserTest, InstallApp_InstallerEmtpyFilename) { | |
| 715 EXPECT_EQ(GOOPDATEINSTALL_E_FILENAME_INVALID, | |
| 716 im_->InstallApp(NULL, | |
| 717 kAppGuid, | |
| 718 _T(""), | |
| 719 _T(""), // Arguments. | |
| 720 _T(""), // Installer data. | |
| 721 kLanguageEnglish, | |
| 722 &result_info_)); | |
| 723 | |
| 724 EXPECT_EQ(INSTALLER_RESULT_UNKNOWN, result_info_.type); | |
| 725 EXPECT_EQ(S_OK, result_info_.code); | |
| 726 EXPECT_TRUE(result_info_.text.IsEmpty()); | |
| 727 EXPECT_TRUE(result_info_.post_install_launch_command_line.IsEmpty()); | |
| 728 EXPECT_TRUE(result_info_.post_install_url.IsEmpty()); | |
| 729 EXPECT_EQ(POST_INSTALL_ACTION_DEFAULT, result_info_.post_install_action); | |
| 730 } | |
| 731 | |
| 732 TEST_F(InstallerWrapperUserTest, InstallApp_ExeFileDoesNotExist) { | |
| 733 __mutexScope(AppManager::Instance()->GetRegistryStableStateLock()); | |
| 734 EXPECT_EQ(GOOPDATEINSTALL_E_INSTALLER_FAILED_START, | |
| 735 im_->InstallApp(NULL, | |
| 736 kAppGuid, | |
| 737 _T("c:\\temp\\foo.exe"), | |
| 738 _T(""), // Arguments. | |
| 739 _T(""), // Installer data. | |
| 740 kLanguageEnglish, | |
| 741 &result_info_)); | |
| 742 | |
| 743 EXPECT_EQ(INSTALLER_RESULT_UNKNOWN, result_info_.type); | |
| 744 EXPECT_EQ(S_OK, result_info_.code); | |
| 745 EXPECT_TRUE(result_info_.text.IsEmpty()); | |
| 746 EXPECT_TRUE(result_info_.post_install_launch_command_line.IsEmpty()); | |
| 747 EXPECT_TRUE(result_info_.post_install_url.IsEmpty()); | |
| 748 EXPECT_EQ(POST_INSTALL_ACTION_DEFAULT, result_info_.post_install_action); | |
| 749 | |
| 750 EXPECT_FALSE(RegKey::HasKey(kFullAppClientsKeyPath)); | |
| 751 EXPECT_FALSE(RegKey::HasKey(kFullAppClientStateKeyPath)); | |
| 752 } | |
| 753 | |
| 754 // | |
| 755 // EXE Installer Tests | |
| 756 // | |
| 757 | |
| 758 // This test uses cmd.exe as an installer that leaves the payload | |
| 759 // kPayloadFileName. | |
| 760 TEST_F(InstallerWrapperUserTest, InstallApp_ExeInstallerWithArgumentsSucceeds) { | |
| 761 const TCHAR kPayloadFileName[] = _T("exe_payload.txt"); | |
| 762 const TCHAR kCommandToExecute[] = _T("echo \"hi\" > %s"); | |
| 763 | |
| 764 CString full_command_to_execute; | |
| 765 full_command_to_execute.Format(kCommandToExecute, kPayloadFileName); | |
| 766 CString arguments; | |
| 767 arguments.Format(kExecuteCommandAndTerminateSwitch, full_command_to_execute); | |
| 768 | |
| 769 EXPECT_SUCCEEDED(File::Remove(kPayloadFileName)); | |
| 770 EXPECT_FALSE(File::Exists(kPayloadFileName)); | |
| 771 | |
| 772 // Create the Clients key since this isn't an actual installer. | |
| 773 EXPECT_SUCCEEDED(RegKey::CreateKey(kFullAppClientsKeyPath)); | |
| 774 EXPECT_TRUE(RegKey::HasKey(kFullAppClientsKeyPath)); | |
| 775 EXPECT_SUCCEEDED(RegKey::SetValue(kFullAppClientsKeyPath, | |
| 776 kRegValueProductVersion, | |
| 777 _T("0.10.69.5"))); | |
| 778 | |
| 779 __mutexScope(AppManager::Instance()->GetRegistryStableStateLock()); | |
| 780 EXPECT_SUCCEEDED(im_->InstallApp(NULL, | |
| 781 kAppGuid, | |
| 782 cmd_exe_path_, | |
| 783 arguments, | |
| 784 _T(""), // Installer data. | |
| 785 kLanguageEnglish, | |
| 786 &result_info_)); | |
| 787 | |
| 788 EXPECT_EQ(INSTALLER_RESULT_SUCCESS, result_info_.type); | |
| 789 EXPECT_EQ(S_OK, result_info_.code); | |
| 790 EXPECT_TRUE(result_info_.text.IsEmpty()); | |
| 791 EXPECT_TRUE(result_info_.post_install_launch_command_line.IsEmpty()); | |
| 792 EXPECT_TRUE(result_info_.post_install_url.IsEmpty()); | |
| 793 EXPECT_EQ(POST_INSTALL_ACTION_DEFAULT, result_info_.post_install_action); | |
| 794 | |
| 795 // EXPECT_SUCCEEDED( | |
| 796 // im_->CheckApplicationRegistration(kAppGuid, _T("0.9.70.1"), false)); | |
| 797 | |
| 798 EXPECT_TRUE(File::Exists(kPayloadFileName)); | |
| 799 EXPECT_SUCCEEDED(File::Remove(kPayloadFileName)); | |
| 800 } | |
| 801 | |
| 802 TEST_F(InstallerWrapperUserTest, | |
| 803 InstallApp_ExeInstallerReturnsNonZeroExitCode) { | |
| 804 const TCHAR kCommandToExecute[] = _T("exit 1"); | |
| 805 | |
| 806 CString arguments; | |
| 807 arguments.Format(kExecuteCommandAndTerminateSwitch, kCommandToExecute); | |
| 808 | |
| 809 // Create the Clients key since this isn't an actual installer. | |
| 810 ASSERT_SUCCEEDED(RegKey::CreateKey(kFullAppClientsKeyPath)); | |
| 811 ASSERT_TRUE(RegKey::HasKey(kFullAppClientsKeyPath)); | |
| 812 ASSERT_SUCCEEDED(RegKey::SetValue(kFullAppClientsKeyPath, | |
| 813 kRegValueProductVersion, | |
| 814 _T("0.10.69.5"))); | |
| 815 | |
| 816 __mutexScope(AppManager::Instance()->GetRegistryStableStateLock()); | |
| 817 EXPECT_EQ(GOOPDATEINSTALL_E_INSTALLER_FAILED, | |
| 818 im_->InstallApp(NULL, | |
| 819 kAppGuid, | |
| 820 cmd_exe_path_, | |
| 821 arguments, | |
| 822 _T(""), // Installer data. | |
| 823 kLanguageEnglish, | |
| 824 &result_info_)); | |
| 825 | |
| 826 EXPECT_EQ(INSTALLER_RESULT_ERROR_OTHER, result_info_.type); | |
| 827 EXPECT_EQ(1, result_info_.code); | |
| 828 EXPECT_STREQ(_T("The installer encountered error 1."), result_info_.text); | |
| 829 EXPECT_TRUE(result_info_.post_install_launch_command_line.IsEmpty()); | |
| 830 EXPECT_TRUE(result_info_.post_install_url.IsEmpty()); | |
| 831 EXPECT_EQ(POST_INSTALL_ACTION_DEFAULT, result_info_.post_install_action); | |
| 832 } | |
| 833 | |
| 834 /* TODO(omaha): Figure out a way to perform this test. | |
| 835 ClearInstallerResultApiValues clears the result values it sets. | |
| 836 TODO(omaha): Add another test that reports an error in using registry API. | |
| 837 // Also tests that the launch cmd is set. | |
| 838 TEST_F(InstallerWrapperUserTest, | |
| 839 InstallApp_ExeInstallerReturnsNonZeroExitCode_InstallerResultSuccess) { | |
| 840 const TCHAR kCommandToExecute[] = _T("exit 1"); | |
| 841 | |
| 842 CString arguments; | |
| 843 arguments.Format(kExecuteCommandAndTerminateSwitch, kCommandToExecute); | |
| 844 | |
| 845 // Create the Clients key since this isn't an actual installer. | |
| 846 ASSERT_SUCCEEDED(RegKey::CreateKey(kFullAppClientsKeyPath)); | |
| 847 ASSERT_TRUE(RegKey::HasKey(kFullAppClientsKeyPath)); | |
| 848 ASSERT_SUCCEEDED(RegKey::SetValue(kFullAppClientsKeyPath, | |
| 849 kRegValueProductVersion, | |
| 850 _T("0.10.69.5"))); | |
| 851 SetupInstallerResultRegistry(kAppId, | |
| 852 true, kResultSuccess, | |
| 853 false, 0, | |
| 854 false, _T(""), | |
| 855 true, kLaunchCmdLine); | |
| 856 | |
| 857 __mutexScope(AppManager::Instance()->GetRegistryStableStateLock()); | |
| 858 EXPECT_SUCCEEDED(im_->InstallApp(kAppGuid, | |
| 859 cmd_exe_path_, | |
| 860 arguments, | |
| 861 _T(""), // Installer data. | |
| 862 &result_info_)); | |
| 863 | |
| 864 EXPECT_EQ(INSTALLER_RESULT_SUCCESS, result_info_.type); | |
| 865 EXPECT_EQ(1, result_info_.code); | |
| 866 EXPECT_TRUE(result_info_.text.IsEmpty()); | |
| 867 EXPECT_STREQ(kLaunchCmdLine, result_info_.post_install_launch_command_line); | |
| 868 EXPECT_TRUE(result_info_.post_install_url.IsEmpty()); | |
| 869 EXPECT_EQ(POST_INSTALL_ACTION_LAUNCH_COMMAND, | |
| 870 result_info_.post_install_action); | |
| 871 | |
| 872 EXPECT_SUCCEEDED( | |
| 873 im_->CheckApplicationRegistration(kAppGuid, _T("0.9.70.1"), false)); | |
| 874 | |
| 875 VerifyLastRegistryValues(kAppId, | |
| 876 true, kResultSuccess, | |
| 877 false, 0, | |
| 878 false, _T(""), | |
| 879 true, kLaunchCmdLine); | |
| 880 } | |
| 881 */ | |
| 882 | |
| 883 TEST_F(InstallerWrapperMachineTest, InstallApp_MsiInstallerSucceeds) { | |
| 884 if (!vista_util::IsUserAdmin()) { | |
| 885 std::wcout << _T("\tTest did not run because the user is not an admin.") | |
| 886 << std::endl; | |
| 887 return; | |
| 888 } | |
| 889 // We can't fake the registry keys because we are interacting with a real | |
| 890 // installer. | |
| 891 RestoreRegistryHives(); | |
| 892 | |
| 893 AdjustMsiTries(im_.get()); | |
| 894 | |
| 895 CString installer_full_path( | |
| 896 ConcatenatePath(app_util::GetCurrentModuleDirectory(), | |
| 897 kSetupFooV1RelativeLocation)); | |
| 898 ASSERT_TRUE(File::Exists(installer_full_path)); | |
| 899 | |
| 900 CString installer_log_full_path; | |
| 901 installer_log_full_path.Format(kMsiLogFormat, installer_full_path); | |
| 902 | |
| 903 ASSERT_SUCCEEDED(File::Remove(installer_log_full_path)); | |
| 904 ASSERT_FALSE(File::Exists(installer_log_full_path)); | |
| 905 | |
| 906 RegKey::DeleteKey(kFullFooAppClientKeyPath); | |
| 907 ASSERT_FALSE(RegKey::HasKey(kFullFooAppClientKeyPath)); | |
| 908 RegKey::DeleteKey(kFullFooAppClientStateKeyPath); | |
| 909 ASSERT_FALSE(RegKey::HasKey(kFullFooAppClientStateKeyPath)); | |
| 910 | |
| 911 __mutexScope(AppManager::Instance()->GetRegistryStableStateLock()); | |
| 912 EXPECT_SUCCEEDED(im_->InstallApp(NULL, | |
| 913 StringToGuid(kFooGuid), | |
| 914 installer_full_path, | |
| 915 _T(""), // Arguments. | |
| 916 _T(""), // Installer data. | |
| 917 kLanguageEnglish, | |
| 918 &result_info_)); | |
| 919 | |
| 920 EXPECT_EQ(INSTALLER_RESULT_SUCCESS, result_info_.type); | |
| 921 EXPECT_EQ(S_OK, result_info_.code); | |
| 922 EXPECT_TRUE(result_info_.text.IsEmpty()); | |
| 923 EXPECT_TRUE(result_info_.post_install_launch_command_line.IsEmpty()); | |
| 924 EXPECT_TRUE(result_info_.post_install_url.IsEmpty()); | |
| 925 EXPECT_EQ(POST_INSTALL_ACTION_DEFAULT, result_info_.post_install_action); | |
| 926 | |
| 927 EXPECT_TRUE(File::Exists(installer_log_full_path)); | |
| 928 | |
| 929 EXPECT_TRUE(RegKey::HasKey(kFullFooAppClientKeyPath)); | |
| 930 EXPECT_FALSE(RegKey::HasKey(kFullFooAppClientStateKeyPath)); | |
| 931 // Verify the installer did not write a value that is to be written only in | |
| 932 // the presence of an MSI property that was not specified. | |
| 933 EXPECT_FALSE(RegKey::HasValue(kFullFooAppClientKeyPath, | |
| 934 kFooInstallerBarValueName)); | |
| 935 // EXPECT_SUCCEEDED(im_->CheckApplicationRegistration( | |
| 936 // StringToGuid(kFooGuid), _T("0.9.70.1"), false)); | |
| 937 | |
| 938 UninstallTestMsi(installer_full_path); | |
| 939 | |
| 940 EXPECT_FALSE(RegKey::HasKey(kFullFooAppClientKeyPath)); | |
| 941 EXPECT_SUCCEEDED(RegKey::DeleteKey(kFullFooAppClientKeyPath)); | |
| 942 } | |
| 943 | |
| 944 TEST_F(InstallerWrapperMachineTest, | |
| 945 InstallApp_MsiInstallerWithArgumentSucceeds) { | |
| 946 if (!vista_util::IsUserAdmin()) { | |
| 947 std::wcout << _T("\tTest did not run because the user is not an admin.") | |
| 948 << std::endl; | |
| 949 return; | |
| 950 } | |
| 951 | |
| 952 // We can't fake the registry keys because we are interacting with a real | |
| 953 // installer. | |
| 954 RestoreRegistryHives(); | |
| 955 | |
| 956 AdjustMsiTries(im_.get()); | |
| 957 | |
| 958 CString installer_full_path( | |
| 959 ConcatenatePath(app_util::GetCurrentModuleDirectory(), | |
| 960 kSetupFooV1RelativeLocation)); | |
| 961 ASSERT_TRUE(File::Exists(installer_full_path)); | |
| 962 | |
| 963 CString installer_log_full_path; | |
| 964 installer_log_full_path.Format(kMsiLogFormat, installer_full_path); | |
| 965 | |
| 966 ASSERT_SUCCEEDED(File::Remove(installer_log_full_path)); | |
| 967 ASSERT_FALSE(File::Exists(installer_log_full_path)); | |
| 968 | |
| 969 RegKey::DeleteKey(kFullFooAppClientKeyPath); | |
| 970 ASSERT_FALSE(RegKey::HasKey(kFullFooAppClientKeyPath)); | |
| 971 RegKey::DeleteKey(kFullFooAppClientStateKeyPath); | |
| 972 ASSERT_FALSE(RegKey::HasKey(kFullFooAppClientStateKeyPath)); | |
| 973 | |
| 974 __mutexScope(AppManager::Instance()->GetRegistryStableStateLock()); | |
| 975 EXPECT_SUCCEEDED(im_->InstallApp(NULL, | |
| 976 StringToGuid(kFooGuid), | |
| 977 installer_full_path, | |
| 978 kFooInstallerBarPropertyArg, | |
| 979 _T(""), // Installer data. | |
| 980 kLanguageEnglish, | |
| 981 &result_info_)); | |
| 982 | |
| 983 EXPECT_EQ(INSTALLER_RESULT_SUCCESS, result_info_.type); | |
| 984 EXPECT_EQ(S_OK, result_info_.code); | |
| 985 EXPECT_TRUE(result_info_.text.IsEmpty()); | |
| 986 EXPECT_TRUE(result_info_.post_install_launch_command_line.IsEmpty()); | |
| 987 EXPECT_TRUE(result_info_.post_install_url.IsEmpty()); | |
| 988 EXPECT_EQ(POST_INSTALL_ACTION_DEFAULT, result_info_.post_install_action); | |
| 989 | |
| 990 EXPECT_TRUE(File::Exists(installer_log_full_path)); | |
| 991 | |
| 992 EXPECT_TRUE(RegKey::HasKey(kFullFooAppClientKeyPath)); | |
| 993 EXPECT_FALSE(RegKey::HasKey(kFullFooAppClientStateKeyPath)); | |
| 994 EXPECT_TRUE(RegKey::HasValue(kFullFooAppClientKeyPath, | |
| 995 kFooInstallerBarValueName)); | |
| 996 DWORD barprop_value = 0; | |
| 997 EXPECT_SUCCEEDED(RegKey::GetValue(kFullFooAppClientKeyPath, | |
| 998 kFooInstallerBarValueName, | |
| 999 &barprop_value)); | |
| 1000 EXPECT_EQ(7, barprop_value); | |
| 1001 | |
| 1002 // EXPECT_SUCCEEDED(im_->CheckApplicationRegistration( | |
| 1003 // StringToGuid(kFooGuid), _T("0.9.70.1"), false)); | |
| 1004 | |
| 1005 UninstallTestMsi(installer_full_path); | |
| 1006 | |
| 1007 EXPECT_FALSE(RegKey::HasKey(kFullFooAppClientKeyPath)); | |
| 1008 EXPECT_SUCCEEDED(RegKey::DeleteKey(kFullFooAppClientKeyPath)); | |
| 1009 } | |
| 1010 | |
| 1011 // The use of kGoogleUpdateAppId is the key to this test. | |
| 1012 // Note that the version is not changed - this is the normal self-update case. | |
| 1013 TEST_F(InstallerWrapperUserTest, InstallApp_UpdateOmahaSucceeds) { | |
| 1014 CString arguments; | |
| 1015 arguments.Format(kExecuteCommandAndTerminateSwitch, _T("")); | |
| 1016 | |
| 1017 const CString kExistingVersion(_T("0.9.69.5")); | |
| 1018 | |
| 1019 // Because we don't actually run the Omaha installer, we need to make sure | |
| 1020 // its Clients key and pv value exist to avoid an error. | |
| 1021 ASSERT_SUCCEEDED(RegKey::CreateKey(USER_REG_CLIENTS_GOOPDATE)); | |
| 1022 ASSERT_TRUE(RegKey::HasKey(USER_REG_CLIENTS_GOOPDATE)); | |
| 1023 ASSERT_SUCCEEDED(RegKey::SetValue(USER_REG_CLIENTS_GOOPDATE, | |
| 1024 kRegValueProductVersion, | |
| 1025 kExistingVersion)); | |
| 1026 | |
| 1027 __mutexScope(AppManager::Instance()->GetRegistryStableStateLock()); | |
| 1028 EXPECT_SUCCEEDED(im_->InstallApp(NULL, | |
| 1029 kGoopdateGuid, | |
| 1030 cmd_exe_path_, | |
| 1031 arguments, | |
| 1032 _T(""), // Installer data. | |
| 1033 kLanguageEnglish, | |
| 1034 &result_info_)); | |
| 1035 | |
| 1036 EXPECT_EQ(INSTALLER_RESULT_SUCCESS, result_info_.type); | |
| 1037 EXPECT_EQ(S_OK, result_info_.code); | |
| 1038 EXPECT_TRUE(result_info_.text.IsEmpty()); | |
| 1039 EXPECT_TRUE(result_info_.post_install_launch_command_line.IsEmpty()); | |
| 1040 EXPECT_TRUE(result_info_.post_install_url.IsEmpty()); | |
| 1041 EXPECT_EQ(POST_INSTALL_ACTION_DEFAULT, result_info_.post_install_action); | |
| 1042 | |
| 1043 EXPECT_TRUE(RegKey::HasKey(USER_REG_CLIENTS_GOOPDATE)); | |
| 1044 CString version; | |
| 1045 EXPECT_SUCCEEDED(RegKey::GetValue(USER_REG_CLIENTS_GOOPDATE, | |
| 1046 kRegValueProductVersion, | |
| 1047 &version)); | |
| 1048 EXPECT_STREQ(kExistingVersion, version); | |
| 1049 | |
| 1050 // Do not call CheckApplicationRegistration for Omaha. | |
| 1051 } | |
| 1052 | |
| 1053 // The main purpose of this test is to ensure that self-updates don't fail if | |
| 1054 // Omaha's Clients key doesn't exist for some reason. | |
| 1055 TEST_F(InstallerWrapperUserTest, | |
| 1056 InstallApp_UpdateOmahaSucceedsWhenClientsKeyAbsent) { | |
| 1057 CString arguments; | |
| 1058 arguments.Format(kExecuteCommandAndTerminateSwitch, _T("")); | |
| 1059 | |
| 1060 const CString kExistingVersion(_T("0.9.69.5")); | |
| 1061 | |
| 1062 __mutexScope(AppManager::Instance()->GetRegistryStableStateLock()); | |
| 1063 EXPECT_SUCCEEDED(im_->InstallApp(NULL, | |
| 1064 kGoopdateGuid, | |
| 1065 cmd_exe_path_, | |
| 1066 arguments, | |
| 1067 _T(""), // Installer data. | |
| 1068 kLanguageEnglish, | |
| 1069 &result_info_)); | |
| 1070 | |
| 1071 EXPECT_EQ(INSTALLER_RESULT_SUCCESS, result_info_.type); | |
| 1072 EXPECT_EQ(S_OK, result_info_.code); | |
| 1073 EXPECT_TRUE(result_info_.text.IsEmpty()); | |
| 1074 EXPECT_TRUE(result_info_.post_install_launch_command_line.IsEmpty()); | |
| 1075 EXPECT_TRUE(result_info_.post_install_url.IsEmpty()); | |
| 1076 EXPECT_EQ(POST_INSTALL_ACTION_DEFAULT, result_info_.post_install_action); | |
| 1077 | |
| 1078 EXPECT_FALSE(RegKey::HasKey(USER_REG_CLIENTS_GOOPDATE)); | |
| 1079 | |
| 1080 // Do not call CheckApplicationRegistration for Omaha. | |
| 1081 } | |
| 1082 | |
| 1083 TEST_F(InstallerWrapperUserTest, InstallApp_InstallerDoesNotWriteClientsKey) { | |
| 1084 CString arguments; | |
| 1085 arguments.Format(kExecuteCommandAndTerminateSwitch, _T("")); | |
| 1086 | |
| 1087 __mutexScope(AppManager::Instance()->GetRegistryStableStateLock()); | |
| 1088 EXPECT_SUCCEEDED(im_->InstallApp(NULL, | |
| 1089 kAppGuid, | |
| 1090 cmd_exe_path_, | |
| 1091 arguments, | |
| 1092 _T(""), // Installer data. | |
| 1093 kLanguageEnglish, | |
| 1094 &result_info_)); | |
| 1095 | |
| 1096 EXPECT_FALSE(RegKey::HasKey(kFullAppClientsKeyPath)); | |
| 1097 EXPECT_FALSE(RegKey::HasKey(kFullAppClientStateKeyPath)); | |
| 1098 | |
| 1099 EXPECT_EQ(INSTALLER_RESULT_SUCCESS, result_info_.type); | |
| 1100 EXPECT_EQ(S_OK, result_info_.code); | |
| 1101 EXPECT_TRUE(result_info_.text.IsEmpty()); | |
| 1102 EXPECT_TRUE(result_info_.post_install_launch_command_line.IsEmpty()); | |
| 1103 EXPECT_TRUE(result_info_.post_install_url.IsEmpty()); | |
| 1104 EXPECT_EQ(POST_INSTALL_ACTION_DEFAULT, result_info_.post_install_action); | |
| 1105 | |
| 1106 // EXPECT_EQ(GOOPDATEINSTALL_E_INSTALLER_DID_NOT_WRITE_CLIENTS_KEY, | |
| 1107 // im_->CheckApplicationRegistration(kAppGuid, _T(""), true)); | |
| 1108 } | |
| 1109 | |
| 1110 TEST_F(InstallerWrapperUserTest, | |
| 1111 InstallApp_InstallerFailureMsiFileDoesNotExist) { | |
| 1112 CPath msi_path(app_util::GetTempDir()); | |
| 1113 msi_path.Append(_T("foo.msi")); | |
| 1114 const CString log_path = msi_path + _T(".log"); | |
| 1115 | |
| 1116 AdjustMsiTries(im_.get()); | |
| 1117 | |
| 1118 ASSERT_SUCCEEDED(File::Remove(log_path)); | |
| 1119 ASSERT_FALSE(File::Exists(log_path)); | |
| 1120 | |
| 1121 __mutexScope(AppManager::Instance()->GetRegistryStableStateLock()); | |
| 1122 EXPECT_EQ(GOOPDATEINSTALL_E_INSTALLER_FAILED, | |
| 1123 im_->InstallApp(NULL, | |
| 1124 kAppGuid, | |
| 1125 msi_path, | |
| 1126 _T(""), // Arguments. | |
| 1127 _T(""), // Installer data. | |
| 1128 kLanguageEnglish, | |
| 1129 &result_info_)); | |
| 1130 | |
| 1131 EXPECT_EQ(INSTALLER_RESULT_ERROR_MSI, result_info_.type); | |
| 1132 EXPECT_EQ(ERROR_INSTALL_PACKAGE_OPEN_FAILED, result_info_.code); | |
| 1133 EXPECT_STREQ(kError1619MessagePrefix, | |
| 1134 result_info_.text.Left(kError1619MessagePrefixLength)); | |
| 1135 VerifyStringIsMsiPackageOpenFailedString( | |
| 1136 result_info_.text.Mid(kError1619MessagePrefixLength)); | |
| 1137 EXPECT_TRUE(result_info_.post_install_launch_command_line.IsEmpty()); | |
| 1138 EXPECT_TRUE(result_info_.post_install_url.IsEmpty()); | |
| 1139 EXPECT_EQ(POST_INSTALL_ACTION_DEFAULT, result_info_.post_install_action); | |
| 1140 | |
| 1141 // msiexec creates an empty log file. | |
| 1142 EXPECT_TRUE(File::Exists(log_path)); | |
| 1143 EXPECT_SUCCEEDED(File::Remove(log_path)); | |
| 1144 | |
| 1145 EXPECT_FALSE(RegKey::HasKey(kFullAppClientsKeyPath)); | |
| 1146 EXPECT_FALSE(RegKey::HasKey(kFullAppClientStateKeyPath)); | |
| 1147 } | |
| 1148 | |
| 1149 // Simulates the MSI busy error by having an exe installer return the error | |
| 1150 // as its exit code and specifying MSI error using Installer Result API. | |
| 1151 // Assumes reg.exe is in the path. | |
| 1152 TEST_F(InstallerWrapperUserTest, InstallApp_MsiIsBusy_NoRetries) { | |
| 1153 CString commands; | |
| 1154 commands.Format(kExecuteTwoCommandsFormat, | |
| 1155 set_installer_result_type_msi_error_cmd_, | |
| 1156 kMsiInstallerBusyExitCodeCmd); | |
| 1157 | |
| 1158 CString arguments; | |
| 1159 arguments.Format(kExecuteCommandAndTerminateSwitch, commands); | |
| 1160 | |
| 1161 LowResTimer install_timer(true); | |
| 1162 | |
| 1163 __mutexScope(AppManager::Instance()->GetRegistryStableStateLock()); | |
| 1164 EXPECT_EQ(GOOPDATEINSTALL_E_MSI_INSTALL_ALREADY_RUNNING, | |
| 1165 im_->InstallApp(NULL, | |
| 1166 kAppGuid, | |
| 1167 cmd_exe_path_, | |
| 1168 arguments, | |
| 1169 _T(""), // Installer data. | |
| 1170 kLanguageEnglish, | |
| 1171 &result_info_)); | |
| 1172 | |
| 1173 EXPECT_GT(2, install_timer.GetSeconds()); // Check Omaha did not retry. | |
| 1174 | |
| 1175 EXPECT_EQ(INSTALLER_RESULT_ERROR_MSI, result_info_.type); | |
| 1176 EXPECT_EQ(ERROR_INSTALL_ALREADY_RUNNING, result_info_.code); | |
| 1177 EXPECT_STREQ(kError1618MessagePrefix, | |
| 1178 result_info_.text.Left(kError1618MessagePrefixLength)); | |
| 1179 VerifyStringIsMsiBusyString( | |
| 1180 result_info_.text.Mid(kError1618MessagePrefixLength)); | |
| 1181 EXPECT_TRUE(result_info_.post_install_launch_command_line.IsEmpty()); | |
| 1182 EXPECT_TRUE(result_info_.post_install_url.IsEmpty()); | |
| 1183 EXPECT_EQ(POST_INSTALL_ACTION_DEFAULT, result_info_.post_install_action); | |
| 1184 } | |
| 1185 | |
| 1186 // This test takes at least 5 seconds, so it is not run all the time. | |
| 1187 TEST_F(InstallerWrapperUserTest, InstallApp_MsiIsBusy_TwoTries) { | |
| 1188 if (!ShouldRunLargeTest()) { | |
| 1189 return; | |
| 1190 } | |
| 1191 | |
| 1192 CString commands; | |
| 1193 commands.Format(kExecuteTwoCommandsFormat, | |
| 1194 set_installer_result_type_msi_error_cmd_, | |
| 1195 kMsiInstallerBusyExitCodeCmd); | |
| 1196 | |
| 1197 CString arguments; | |
| 1198 arguments.Format(kExecuteCommandAndTerminateSwitch, commands); | |
| 1199 | |
| 1200 im_->set_num_tries_when_msi_busy(2); | |
| 1201 | |
| 1202 LowResTimer install_timer(true); | |
| 1203 | |
| 1204 __mutexScope(AppManager::Instance()->GetRegistryStableStateLock()); | |
| 1205 EXPECT_EQ(GOOPDATEINSTALL_E_MSI_INSTALL_ALREADY_RUNNING, | |
| 1206 im_->InstallApp(NULL, | |
| 1207 kAppGuid, | |
| 1208 cmd_exe_path_, | |
| 1209 arguments, | |
| 1210 _T(""), // Installer data. | |
| 1211 kLanguageEnglish, | |
| 1212 &result_info_)); | |
| 1213 | |
| 1214 EXPECT_LE(5, install_timer.GetSeconds()); // Check Omaha did retry. | |
| 1215 EXPECT_GT(10, install_timer.GetSeconds()); | |
| 1216 | |
| 1217 EXPECT_EQ(INSTALLER_RESULT_ERROR_MSI, result_info_.type); | |
| 1218 EXPECT_EQ(ERROR_INSTALL_ALREADY_RUNNING, result_info_.code); | |
| 1219 EXPECT_STREQ(kError1618MessagePrefix, | |
| 1220 result_info_.text.Left(kError1618MessagePrefixLength)); | |
| 1221 VerifyStringIsMsiBusyString( | |
| 1222 result_info_.text.Mid(kError1618MessagePrefixLength)); | |
| 1223 EXPECT_TRUE(result_info_.post_install_launch_command_line.IsEmpty()); | |
| 1224 EXPECT_TRUE(result_info_.post_install_url.IsEmpty()); | |
| 1225 EXPECT_EQ(POST_INSTALL_ACTION_DEFAULT, result_info_.post_install_action); | |
| 1226 } | |
| 1227 | |
| 1228 // This test uses cmd.exe as an installer that leaves the payload files. | |
| 1229 TEST_F(InstallerWrapperUserTest, InstallApp_InstallMultipleApps) { | |
| 1230 const TCHAR kPayloadFileName1[] = _T("exe_payload1.txt"); | |
| 1231 const TCHAR kPayloadFileName2[] = _T("exe_payload2.txt"); | |
| 1232 const TCHAR kCommandToExecute[] = _T("echo \"hi\" > %s"); | |
| 1233 | |
| 1234 CString full_command_to_execute; | |
| 1235 full_command_to_execute.Format(kCommandToExecute, kPayloadFileName1); | |
| 1236 CString arguments1; | |
| 1237 arguments1.Format(kExecuteCommandAndTerminateSwitch, full_command_to_execute); | |
| 1238 | |
| 1239 full_command_to_execute.Format(kCommandToExecute, kPayloadFileName2); | |
| 1240 CString arguments2; | |
| 1241 arguments2.Format(kExecuteCommandAndTerminateSwitch, full_command_to_execute); | |
| 1242 | |
| 1243 EXPECT_SUCCEEDED(File::Remove(kPayloadFileName1)); | |
| 1244 EXPECT_FALSE(File::Exists(kPayloadFileName1)); | |
| 1245 EXPECT_SUCCEEDED(File::Remove(kPayloadFileName2)); | |
| 1246 EXPECT_FALSE(File::Exists(kPayloadFileName2)); | |
| 1247 | |
| 1248 // Create the Clients key since this isn't an actual installer. | |
| 1249 EXPECT_SUCCEEDED(RegKey::CreateKey(kFullAppClientsKeyPath)); | |
| 1250 EXPECT_TRUE(RegKey::HasKey(kFullAppClientsKeyPath)); | |
| 1251 EXPECT_SUCCEEDED(RegKey::SetValue(kFullAppClientsKeyPath, | |
| 1252 kRegValueProductVersion, | |
| 1253 _T("0.10.69.5"))); | |
| 1254 | |
| 1255 __mutexScope(AppManager::Instance()->GetRegistryStableStateLock()); | |
| 1256 | |
| 1257 EXPECT_SUCCEEDED(im_->InstallApp(NULL, | |
| 1258 kAppGuid, | |
| 1259 cmd_exe_path_, | |
| 1260 arguments1, | |
| 1261 _T(""), // Installer data. | |
| 1262 kLanguageEnglish, | |
| 1263 &result_info_)); | |
| 1264 | |
| 1265 EXPECT_EQ(INSTALLER_RESULT_SUCCESS, result_info_.type); | |
| 1266 EXPECT_EQ(S_OK, result_info_.code); | |
| 1267 EXPECT_TRUE(result_info_.text.IsEmpty()); | |
| 1268 EXPECT_TRUE(result_info_.post_install_launch_command_line.IsEmpty()); | |
| 1269 EXPECT_TRUE(result_info_.post_install_url.IsEmpty()); | |
| 1270 EXPECT_EQ(POST_INSTALL_ACTION_DEFAULT, result_info_.post_install_action); | |
| 1271 | |
| 1272 // EXPECT_SUCCEEDED( | |
| 1273 // im_->CheckApplicationRegistration(kAppGuid, _T("0.9.70.1"), false)); | |
| 1274 | |
| 1275 EXPECT_TRUE(File::Exists(kPayloadFileName1)); | |
| 1276 EXPECT_SUCCEEDED(File::Remove(kPayloadFileName1)); | |
| 1277 | |
| 1278 // Run the second installer. | |
| 1279 | |
| 1280 result_info_.type = INSTALLER_RESULT_UNKNOWN; | |
| 1281 result_info_.code = kInitialErrorValue; | |
| 1282 | |
| 1283 EXPECT_SUCCEEDED(im_->InstallApp(NULL, | |
| 1284 kAppGuid, | |
| 1285 cmd_exe_path_, | |
| 1286 arguments2, | |
| 1287 _T(""), // Installer data. | |
| 1288 kLanguageEnglish, | |
| 1289 &result_info_)); | |
| 1290 | |
| 1291 EXPECT_EQ(INSTALLER_RESULT_SUCCESS, result_info_.type); | |
| 1292 EXPECT_EQ(S_OK, result_info_.code); | |
| 1293 EXPECT_TRUE(result_info_.text.IsEmpty()); | |
| 1294 EXPECT_TRUE(result_info_.post_install_launch_command_line.IsEmpty()); | |
| 1295 EXPECT_TRUE(result_info_.post_install_url.IsEmpty()); | |
| 1296 EXPECT_EQ(POST_INSTALL_ACTION_DEFAULT, result_info_.post_install_action); | |
| 1297 | |
| 1298 // EXPECT_SUCCEEDED( | |
| 1299 // im_->CheckApplicationRegistration(kAppGuid, _T("0.9.70.1"), false)); | |
| 1300 | |
| 1301 EXPECT_TRUE(File::Exists(kPayloadFileName2)); | |
| 1302 EXPECT_SUCCEEDED(File::Remove(kPayloadFileName2)); | |
| 1303 } | |
| 1304 | |
| 1305 // | |
| 1306 // GetInstallerResultHelper tests | |
| 1307 // | |
| 1308 | |
| 1309 TEST_F(InstallerWrapperUserGetInstallerResultHelperTest, | |
| 1310 GetInstallerResultHelper_NoRegistry_MSI_ZeroExitCode) { | |
| 1311 CallGetInstallerResultHelper(kAppGuid, kMsi, 0, &result_info_); | |
| 1312 | |
| 1313 EXPECT_EQ(INSTALLER_RESULT_SUCCESS, result_info_.type); | |
| 1314 EXPECT_EQ(0, result_info_.code); | |
| 1315 EXPECT_TRUE(result_info_.text.IsEmpty()); | |
| 1316 EXPECT_TRUE(result_info_.post_install_launch_command_line.IsEmpty()); | |
| 1317 EXPECT_TRUE(result_info_.post_install_url.IsEmpty()); | |
| 1318 EXPECT_EQ(POST_INSTALL_ACTION_DEFAULT, result_info_.post_install_action); | |
| 1319 | |
| 1320 VerifyNoLastRegistryValues(kAppId); | |
| 1321 } | |
| 1322 | |
| 1323 TEST_F(InstallerWrapperUserGetInstallerResultHelperTest, | |
| 1324 GetInstallerResultHelper_NoRegistry_MSI_NonZeroExitCode) { | |
| 1325 CallGetInstallerResultHelper(kAppGuid, kMsi, 1603, &result_info_); | |
| 1326 | |
| 1327 EXPECT_EQ(INSTALLER_RESULT_ERROR_MSI, result_info_.type); | |
| 1328 EXPECT_EQ(1603, result_info_.code); | |
| 1329 EXPECT_STREQ(kError1603Text, result_info_.text); | |
| 1330 EXPECT_TRUE(result_info_.post_install_launch_command_line.IsEmpty()); | |
| 1331 EXPECT_TRUE(result_info_.post_install_url.IsEmpty()); | |
| 1332 EXPECT_EQ(POST_INSTALL_ACTION_DEFAULT, result_info_.post_install_action); | |
| 1333 | |
| 1334 VerifyNoLastRegistryValues(kAppId); | |
| 1335 } | |
| 1336 | |
| 1337 TEST_F(InstallerWrapperUserGetInstallerResultHelperTest, | |
| 1338 GetInstallerResultHelper_NoRegistry_EXE_ZeroExitCode) { | |
| 1339 CallGetInstallerResultHelper(kAppGuid, kOther, 0, &result_info_); | |
| 1340 | |
| 1341 EXPECT_EQ(INSTALLER_RESULT_SUCCESS, result_info_.type); | |
| 1342 EXPECT_EQ(0, result_info_.code); | |
| 1343 EXPECT_TRUE(result_info_.text.IsEmpty()); | |
| 1344 EXPECT_TRUE(result_info_.post_install_launch_command_line.IsEmpty()); | |
| 1345 EXPECT_TRUE(result_info_.post_install_url.IsEmpty()); | |
| 1346 EXPECT_EQ(POST_INSTALL_ACTION_DEFAULT, result_info_.post_install_action); | |
| 1347 | |
| 1348 VerifyNoLastRegistryValues(kAppId); | |
| 1349 } | |
| 1350 | |
| 1351 TEST_F(InstallerWrapperUserGetInstallerResultHelperTest, | |
| 1352 GetInstallerResultHelper_NoRegistry_EXE_NonZeroExitCode_SmallNumber) { | |
| 1353 CallGetInstallerResultHelper(kAppGuid, kOther, 8, &result_info_); | |
| 1354 | |
| 1355 EXPECT_EQ(INSTALLER_RESULT_ERROR_OTHER, result_info_.type); | |
| 1356 EXPECT_EQ(8, result_info_.code); | |
| 1357 EXPECT_STREQ(_T("The installer encountered error 8."), result_info_.text); | |
| 1358 EXPECT_TRUE(result_info_.post_install_launch_command_line.IsEmpty()); | |
| 1359 EXPECT_TRUE(result_info_.post_install_url.IsEmpty()); | |
| 1360 EXPECT_EQ(POST_INSTALL_ACTION_DEFAULT, result_info_.post_install_action); | |
| 1361 | |
| 1362 VerifyNoLastRegistryValues(kAppId); | |
| 1363 } | |
| 1364 | |
| 1365 TEST_F(InstallerWrapperUserGetInstallerResultHelperTest, | |
| 1366 GetInstallerResultHelper_NoRegistry_EXE_NonZeroExitCode_HRESULTFailure) { | |
| 1367 CallGetInstallerResultHelper(kAppGuid, kOther, 0x80004005, &result_info_); | |
| 1368 | |
| 1369 EXPECT_EQ(INSTALLER_RESULT_ERROR_OTHER, result_info_.type); | |
| 1370 EXPECT_EQ(0x80004005, result_info_.code); | |
| 1371 EXPECT_STREQ(_T("The installer encountered error 0x80004005."), | |
| 1372 result_info_.text); | |
| 1373 EXPECT_TRUE(result_info_.post_install_launch_command_line.IsEmpty()); | |
| 1374 EXPECT_TRUE(result_info_.post_install_url.IsEmpty()); | |
| 1375 EXPECT_EQ(POST_INSTALL_ACTION_DEFAULT, result_info_.post_install_action); | |
| 1376 | |
| 1377 VerifyNoLastRegistryValues(kAppId); | |
| 1378 } | |
| 1379 | |
| 1380 TEST_F(InstallerWrapperUserGetInstallerResultHelperTest, | |
| 1381 GetInstallerResultHelper_ExitCode_MSI) { | |
| 1382 SetupInstallerResultRegistry(kAppId, | |
| 1383 true, kResultExitCode, | |
| 1384 false, 0, | |
| 1385 false, 0, | |
| 1386 false, _T(""), | |
| 1387 false, _T("")); | |
| 1388 | |
| 1389 CallGetInstallerResultHelper(kAppGuid, kMsi, 1603, &result_info_); | |
| 1390 | |
| 1391 EXPECT_EQ(INSTALLER_RESULT_ERROR_MSI, result_info_.type); | |
| 1392 EXPECT_EQ(1603, result_info_.code); | |
| 1393 EXPECT_STREQ(kError1603Text, result_info_.text); | |
| 1394 EXPECT_TRUE(result_info_.post_install_launch_command_line.IsEmpty()); | |
| 1395 EXPECT_TRUE(result_info_.post_install_url.IsEmpty()); | |
| 1396 EXPECT_EQ(POST_INSTALL_ACTION_DEFAULT, result_info_.post_install_action); | |
| 1397 | |
| 1398 VerifyLastRegistryValues(kAppId, | |
| 1399 true, kResultExitCode, | |
| 1400 false, 0, | |
| 1401 false, 0, | |
| 1402 false, _T(""), | |
| 1403 false, _T("")); | |
| 1404 } | |
| 1405 | |
| 1406 TEST_F(InstallerWrapperUserGetInstallerResultHelperTest, | |
| 1407 GetInstallerResultHelper_NoRegistry_MSI_RebootRequired) { | |
| 1408 CallGetInstallerResultHelper(kAppGuid, kMsi, ERROR_SUCCESS_REBOOT_REQUIRED, | |
| 1409 &result_info_); | |
| 1410 | |
| 1411 EXPECT_EQ(INSTALLER_RESULT_SUCCESS, result_info_.type); | |
| 1412 EXPECT_EQ(0, result_info_.code); | |
| 1413 EXPECT_TRUE(result_info_.text.IsEmpty()); | |
| 1414 EXPECT_TRUE(result_info_.post_install_launch_command_line.IsEmpty()); | |
| 1415 EXPECT_TRUE(result_info_.post_install_url.IsEmpty()); | |
| 1416 EXPECT_EQ(POST_INSTALL_ACTION_REBOOT, result_info_.post_install_action); | |
| 1417 | |
| 1418 VerifyNoLastRegistryValues(kAppId); | |
| 1419 } | |
| 1420 | |
| 1421 TEST_F(InstallerWrapperUserGetInstallerResultHelperTest, | |
| 1422 GetInstallerResultHelper_SystemError_EXE_RebootRequired) { | |
| 1423 SetupInstallerResultRegistry(kAppId, | |
| 1424 true, kResultFailedSystemError, | |
| 1425 true, ERROR_SUCCESS_REBOOT_REQUIRED, | |
| 1426 false, 0, | |
| 1427 false, _T(""), | |
| 1428 true, kLaunchCmdLine); | |
| 1429 | |
| 1430 CallGetInstallerResultHelper(kAppGuid, kOther, 1, &result_info_); | |
| 1431 | |
| 1432 EXPECT_EQ(INSTALLER_RESULT_SUCCESS, result_info_.type); | |
| 1433 EXPECT_EQ(0, result_info_.code); | |
| 1434 EXPECT_TRUE(result_info_.text.IsEmpty()); | |
| 1435 EXPECT_EQ(POST_INSTALL_ACTION_REBOOT, result_info_.post_install_action); | |
| 1436 | |
| 1437 VerifyLastRegistryValues(kAppId, | |
| 1438 true, kResultFailedSystemError, | |
| 1439 true, ERROR_SUCCESS_REBOOT_REQUIRED, | |
| 1440 false, 0, | |
| 1441 false, _T(""), | |
| 1442 true, kLaunchCmdLine); | |
| 1443 } | |
| 1444 | |
| 1445 TEST_F(InstallerWrapperUserGetInstallerResultHelperTest, | |
| 1446 GetInstallerResultHelper_CustomError_ShouldNotReboot) { | |
| 1447 SetupInstallerResultRegistry(kAppId, | |
| 1448 true, kResultFailedCustomError, | |
| 1449 true, ERROR_SUCCESS_REBOOT_REQUIRED, | |
| 1450 false, 0, | |
| 1451 false, _T(""), | |
| 1452 false, _T("")); | |
| 1453 | |
| 1454 CallGetInstallerResultHelper(kAppGuid, kMsi, 0, &result_info_); | |
| 1455 | |
| 1456 EXPECT_EQ(INSTALLER_RESULT_ERROR_OTHER, result_info_.type); | |
| 1457 EXPECT_EQ(ERROR_SUCCESS_REBOOT_REQUIRED, result_info_.code); | |
| 1458 EXPECT_STREQ(_T("The installer encountered error 3010."), result_info_.text); | |
| 1459 EXPECT_TRUE(result_info_.post_install_launch_command_line.IsEmpty()); | |
| 1460 EXPECT_TRUE(result_info_.post_install_url.IsEmpty()); | |
| 1461 EXPECT_EQ(POST_INSTALL_ACTION_DEFAULT, result_info_.post_install_action); | |
| 1462 } | |
| 1463 | |
| 1464 TEST_F(InstallerWrapperUserGetInstallerResultHelperTest, | |
| 1465 GetInstallerResultHelper_Success_NoErrorCode) { | |
| 1466 SetupInstallerResultRegistry(kAppId, | |
| 1467 true, kResultSuccess, | |
| 1468 false, 0, | |
| 1469 false, 0, | |
| 1470 false, _T(""), | |
| 1471 false, _T("")); | |
| 1472 | |
| 1473 CallGetInstallerResultHelper(kAppGuid, kOther, 99, &result_info_); | |
| 1474 | |
| 1475 EXPECT_EQ(INSTALLER_RESULT_SUCCESS, result_info_.type); | |
| 1476 EXPECT_EQ(99, result_info_.code); | |
| 1477 EXPECT_TRUE(result_info_.text.IsEmpty()); | |
| 1478 EXPECT_TRUE(result_info_.post_install_launch_command_line.IsEmpty()); | |
| 1479 EXPECT_TRUE(result_info_.post_install_url.IsEmpty()); | |
| 1480 EXPECT_EQ(POST_INSTALL_ACTION_DEFAULT, result_info_.post_install_action); | |
| 1481 | |
| 1482 VerifyLastRegistryValues(kAppId, | |
| 1483 true, kResultSuccess, | |
| 1484 false, 0, | |
| 1485 false, 0, | |
| 1486 false, _T(""), | |
| 1487 false, _T("")); | |
| 1488 } | |
| 1489 | |
| 1490 TEST_F(InstallerWrapperUserGetInstallerResultHelperTest, | |
| 1491 GetInstallerResultHelper_Success_AllValues) { | |
| 1492 SetupInstallerResultRegistry(kAppId, | |
| 1493 true, kResultSuccess, | |
| 1494 true, 555, | |
| 1495 false, 0, | |
| 1496 true, _T("an ignored error"), | |
| 1497 true, kLaunchCmdLine); | |
| 1498 | |
| 1499 CallGetInstallerResultHelper(kAppGuid, kOther, 99, &result_info_); | |
| 1500 | |
| 1501 EXPECT_EQ(INSTALLER_RESULT_SUCCESS, result_info_.type); | |
| 1502 EXPECT_EQ(555, result_info_.code) << | |
| 1503 _T("InstallerError overwrites exit code."); | |
| 1504 EXPECT_FALSE(result_info_.text.IsEmpty()) << | |
| 1505 _T("UIString is ignored for Success."); | |
| 1506 EXPECT_STREQ(kLaunchCmdLine, result_info_.post_install_launch_command_line); | |
| 1507 EXPECT_TRUE(result_info_.post_install_url.IsEmpty()); | |
| 1508 EXPECT_EQ(POST_INSTALL_ACTION_LAUNCH_COMMAND, | |
| 1509 result_info_.post_install_action); | |
| 1510 | |
| 1511 VerifyLastRegistryValues(kAppId, | |
| 1512 true, kResultSuccess, | |
| 1513 true, 555, | |
| 1514 false, 0, | |
| 1515 true, _T("an ignored error"), | |
| 1516 true, kLaunchCmdLine); | |
| 1517 } | |
| 1518 | |
| 1519 TEST_F(InstallerWrapperUserGetInstallerResultHelperTest, | |
| 1520 GetInstallerResultHelper_LaunchCmdOnly_MSI_ZeroExitCode) { | |
| 1521 SetupInstallerResultRegistry(kAppId, | |
| 1522 false, 0, | |
| 1523 false, 0, | |
| 1524 false, 0, | |
| 1525 false, _T(""), | |
| 1526 true, kLaunchCmdLine); | |
| 1527 | |
| 1528 CallGetInstallerResultHelper(kAppGuid, kMsi, 0, &result_info_); | |
| 1529 | |
| 1530 EXPECT_EQ(INSTALLER_RESULT_SUCCESS, result_info_.type); | |
| 1531 EXPECT_EQ(0, result_info_.code); | |
| 1532 EXPECT_TRUE(result_info_.text.IsEmpty()); | |
| 1533 EXPECT_STREQ(kLaunchCmdLine, result_info_.post_install_launch_command_line); | |
| 1534 EXPECT_TRUE(result_info_.post_install_url.IsEmpty()); | |
| 1535 EXPECT_EQ(POST_INSTALL_ACTION_LAUNCH_COMMAND, | |
| 1536 result_info_.post_install_action); | |
| 1537 | |
| 1538 VerifyLastRegistryValues(kAppId, | |
| 1539 false, 0, | |
| 1540 false, 0, | |
| 1541 false, 0, | |
| 1542 false, _T(""), | |
| 1543 true, kLaunchCmdLine); | |
| 1544 } | |
| 1545 | |
| 1546 // Exit code is used when no error code is present. It's interpreted as a system | |
| 1547 // error even though the installer is not an MSI. | |
| 1548 TEST_F(InstallerWrapperUserGetInstallerResultHelperTest, | |
| 1549 GetInstallerResultHelper_Failed_NoErrorCodeOrUiString) { | |
| 1550 SetupInstallerResultRegistry(kAppId, | |
| 1551 true, kResultFailedCustomError, | |
| 1552 false, 0, | |
| 1553 false, 0, | |
| 1554 false, _T(""), | |
| 1555 false, _T("")); | |
| 1556 | |
| 1557 CallGetInstallerResultHelper(kAppGuid, kOther, 8, &result_info_); | |
| 1558 | |
| 1559 EXPECT_EQ(INSTALLER_RESULT_ERROR_OTHER, result_info_.type); | |
| 1560 EXPECT_EQ(8, result_info_.code); | |
| 1561 EXPECT_STREQ(_T("The installer encountered error 8."), result_info_.text); | |
| 1562 EXPECT_TRUE(result_info_.post_install_launch_command_line.IsEmpty()); | |
| 1563 EXPECT_TRUE(result_info_.post_install_url.IsEmpty()); | |
| 1564 EXPECT_EQ(POST_INSTALL_ACTION_DEFAULT, result_info_.post_install_action); | |
| 1565 | |
| 1566 VerifyLastRegistryValues(kAppId, | |
| 1567 true, kResultFailedCustomError, | |
| 1568 false, 0, | |
| 1569 false, 0, | |
| 1570 false, _T(""), | |
| 1571 false, _T("")); | |
| 1572 } | |
| 1573 | |
| 1574 TEST_F(InstallerWrapperUserGetInstallerResultHelperTest, | |
| 1575 GetInstallerResultHelper_Failed_WithErrorCode) { | |
| 1576 SetupInstallerResultRegistry(kAppId, | |
| 1577 true, kResultFailedCustomError, | |
| 1578 true, 8, | |
| 1579 false, 0, | |
| 1580 false, _T(""), | |
| 1581 false, _T("")); | |
| 1582 | |
| 1583 CallGetInstallerResultHelper(kAppGuid, kOther, 1618, &result_info_); | |
| 1584 | |
| 1585 EXPECT_EQ(INSTALLER_RESULT_ERROR_OTHER, result_info_.type); | |
| 1586 EXPECT_EQ(8, result_info_.code); | |
| 1587 EXPECT_STREQ(_T("The installer encountered error 8."), result_info_.text); | |
| 1588 EXPECT_TRUE(result_info_.post_install_launch_command_line.IsEmpty()); | |
| 1589 EXPECT_TRUE(result_info_.post_install_url.IsEmpty()); | |
| 1590 EXPECT_EQ(POST_INSTALL_ACTION_DEFAULT, result_info_.post_install_action); | |
| 1591 | |
| 1592 VerifyLastRegistryValues(kAppId, | |
| 1593 true, kResultFailedCustomError, | |
| 1594 true, 8, | |
| 1595 false, 0, | |
| 1596 false, _T(""), | |
| 1597 false, _T("")); | |
| 1598 } | |
| 1599 | |
| 1600 // This test shows that command line is read and | |
| 1601 // POST_INSTALL_ACTION_LAUNCH_COMMAND is set. | |
| 1602 TEST_F(InstallerWrapperUserGetInstallerResultHelperTest, | |
| 1603 GetInstallerResultHelper_Failed_AllValues) { | |
| 1604 const DWORD kInstallerErrorValue = 8; | |
| 1605 const TCHAR* const kUiString = _T("a message from the installer"); | |
| 1606 | |
| 1607 SetupInstallerResultRegistry(kAppId, | |
| 1608 true, kResultFailedCustomError, | |
| 1609 true, kInstallerErrorValue, | |
| 1610 false, 0, | |
| 1611 true, kUiString, | |
| 1612 true, kLaunchCmdLine); | |
| 1613 | |
| 1614 CallGetInstallerResultHelper(kAppGuid, kOther, 1618, &result_info_); | |
| 1615 | |
| 1616 EXPECT_EQ(INSTALLER_RESULT_ERROR_OTHER, result_info_.type); | |
| 1617 EXPECT_EQ(kInstallerErrorValue, result_info_.code); | |
| 1618 EXPECT_STREQ(kUiString, result_info_.text); | |
| 1619 EXPECT_STREQ(kLaunchCmdLine, result_info_.post_install_launch_command_line); | |
| 1620 EXPECT_TRUE(result_info_.post_install_url.IsEmpty()); | |
| 1621 EXPECT_EQ(POST_INSTALL_ACTION_LAUNCH_COMMAND, | |
| 1622 result_info_.post_install_action); | |
| 1623 | |
| 1624 VerifyLastRegistryValues(kAppId, | |
| 1625 true, kResultFailedCustomError, | |
| 1626 true, kInstallerErrorValue, | |
| 1627 false, 0, | |
| 1628 true, kUiString, | |
| 1629 true, kLaunchCmdLine); | |
| 1630 } | |
| 1631 | |
| 1632 // Exit code is used and interpreted as MSI error when no error code present. | |
| 1633 TEST_F(InstallerWrapperUserGetInstallerResultHelperTest, | |
| 1634 GetInstallerResultHelper_FailedMsiError_NoErrorCode) { | |
| 1635 SetupInstallerResultRegistry(kAppId, | |
| 1636 true, kResultFailedMsiError, | |
| 1637 false, 0, | |
| 1638 false, 0, | |
| 1639 false, _T(""), | |
| 1640 false, _T("")); | |
| 1641 | |
| 1642 CallGetInstallerResultHelper(kAppGuid, kOther, 1603, &result_info_); | |
| 1643 | |
| 1644 EXPECT_EQ(INSTALLER_RESULT_ERROR_MSI, result_info_.type); | |
| 1645 EXPECT_EQ(1603, result_info_.code); | |
| 1646 EXPECT_STREQ(kError1603Text, result_info_.text); | |
| 1647 EXPECT_TRUE(result_info_.post_install_launch_command_line.IsEmpty()); | |
| 1648 EXPECT_TRUE(result_info_.post_install_url.IsEmpty()); | |
| 1649 EXPECT_EQ(POST_INSTALL_ACTION_DEFAULT, result_info_.post_install_action); | |
| 1650 | |
| 1651 VerifyLastRegistryValues(kAppId, | |
| 1652 true, kResultFailedMsiError, | |
| 1653 false, 0, | |
| 1654 false, 0, | |
| 1655 false, _T(""), | |
| 1656 false, _T("")); | |
| 1657 } | |
| 1658 | |
| 1659 TEST_F(InstallerWrapperUserGetInstallerResultHelperTest, | |
| 1660 GetInstallerResultHelper_FailedMsiError_WithErrorCode) { | |
| 1661 const DWORD kInstallerErrorValue = 1603; | |
| 1662 | |
| 1663 SetupInstallerResultRegistry(kAppId, | |
| 1664 true, kResultFailedMsiError, | |
| 1665 true, kInstallerErrorValue, | |
| 1666 false, 0, | |
| 1667 false, _T(""), | |
| 1668 false, _T("")); | |
| 1669 | |
| 1670 CallGetInstallerResultHelper(kAppGuid, kOther, 1618, &result_info_); | |
| 1671 | |
| 1672 EXPECT_EQ(INSTALLER_RESULT_ERROR_MSI, result_info_.type); | |
| 1673 EXPECT_EQ(kInstallerErrorValue, result_info_.code); | |
| 1674 EXPECT_STREQ(kError1603Text, result_info_.text); | |
| 1675 EXPECT_TRUE(result_info_.post_install_launch_command_line.IsEmpty()); | |
| 1676 EXPECT_TRUE(result_info_.post_install_url.IsEmpty()); | |
| 1677 EXPECT_EQ(POST_INSTALL_ACTION_DEFAULT, result_info_.post_install_action); | |
| 1678 | |
| 1679 VerifyLastRegistryValues(kAppId, | |
| 1680 true, kResultFailedMsiError, | |
| 1681 true, kInstallerErrorValue, | |
| 1682 false, 0, | |
| 1683 false, _T(""), | |
| 1684 false, _T("")); | |
| 1685 } | |
| 1686 | |
| 1687 // This test shows that command line is read and | |
| 1688 // POST_INSTALL_ACTION_LAUNCH_COMMAND is set. | |
| 1689 TEST_F(InstallerWrapperUserGetInstallerResultHelperTest, | |
| 1690 GetInstallerResultHelper_FailedMsiError_AllValues) { | |
| 1691 const DWORD kInstallerErrorValue = 1603; | |
| 1692 | |
| 1693 SetupInstallerResultRegistry(kAppId, | |
| 1694 true, kResultFailedMsiError, | |
| 1695 true, kInstallerErrorValue, | |
| 1696 false, 0, | |
| 1697 true, _T("an ignored error"), | |
| 1698 true, kLaunchCmdLine); | |
| 1699 | |
| 1700 CallGetInstallerResultHelper(kAppGuid, kOther, 1618, &result_info_); | |
| 1701 | |
| 1702 EXPECT_EQ(INSTALLER_RESULT_ERROR_MSI, result_info_.type); | |
| 1703 EXPECT_EQ(kInstallerErrorValue, result_info_.code); | |
| 1704 EXPECT_STREQ(kError1603Text, result_info_.text) << _T("UIString is ignored."); | |
| 1705 EXPECT_STREQ(kLaunchCmdLine, result_info_.post_install_launch_command_line); | |
| 1706 EXPECT_TRUE(result_info_.post_install_url.IsEmpty()); | |
| 1707 EXPECT_EQ(POST_INSTALL_ACTION_LAUNCH_COMMAND, | |
| 1708 result_info_.post_install_action); | |
| 1709 | |
| 1710 VerifyLastRegistryValues(kAppId, | |
| 1711 true, kResultFailedMsiError, | |
| 1712 true, kInstallerErrorValue, | |
| 1713 false, 0, | |
| 1714 true, _T("an ignored error"), | |
| 1715 true, kLaunchCmdLine); | |
| 1716 } | |
| 1717 | |
| 1718 // Exit code is used and interpreted as system error when no error code present. | |
| 1719 TEST_F(InstallerWrapperUserGetInstallerResultHelperTest, | |
| 1720 GetInstallerResultHelper_FailedSystemError_NoErrorCode) { | |
| 1721 SetupInstallerResultRegistry(kAppId, | |
| 1722 true, kResultFailedSystemError, | |
| 1723 false, 0, | |
| 1724 false, 0, | |
| 1725 false, _T(""), | |
| 1726 false, _T("")); | |
| 1727 | |
| 1728 CallGetInstallerResultHelper(kAppGuid, kOther, 1603, &result_info_); | |
| 1729 | |
| 1730 EXPECT_EQ(INSTALLER_RESULT_ERROR_SYSTEM, result_info_.type); | |
| 1731 EXPECT_EQ(1603, result_info_.code); | |
| 1732 EXPECT_STREQ(kError1603Text, result_info_.text); | |
| 1733 EXPECT_TRUE(result_info_.post_install_launch_command_line.IsEmpty()); | |
| 1734 EXPECT_TRUE(result_info_.post_install_url.IsEmpty()); | |
| 1735 EXPECT_EQ(POST_INSTALL_ACTION_DEFAULT, result_info_.post_install_action); | |
| 1736 | |
| 1737 VerifyLastRegistryValues(kAppId, | |
| 1738 true, kResultFailedSystemError, | |
| 1739 false, 0, | |
| 1740 false, 0, | |
| 1741 false, _T(""), | |
| 1742 false, _T("")); | |
| 1743 } | |
| 1744 | |
| 1745 TEST_F(InstallerWrapperUserGetInstallerResultHelperTest, | |
| 1746 GetInstallerResultHelper_FailedSystemError_WithErrorCode) { | |
| 1747 const DWORD kInstallerErrorValue = 1603; | |
| 1748 | |
| 1749 SetupInstallerResultRegistry(kAppId, | |
| 1750 true, kResultFailedSystemError, | |
| 1751 true, kInstallerErrorValue, | |
| 1752 false, 0, | |
| 1753 false, _T(""), | |
| 1754 false, _T("")); | |
| 1755 | |
| 1756 CallGetInstallerResultHelper(kAppGuid, kOther, 1618, &result_info_); | |
| 1757 | |
| 1758 EXPECT_EQ(INSTALLER_RESULT_ERROR_SYSTEM, result_info_.type); | |
| 1759 EXPECT_EQ(kInstallerErrorValue, result_info_.code); | |
| 1760 EXPECT_STREQ(kError1603Text, result_info_.text); | |
| 1761 EXPECT_TRUE(result_info_.post_install_launch_command_line.IsEmpty()); | |
| 1762 EXPECT_TRUE(result_info_.post_install_url.IsEmpty()); | |
| 1763 EXPECT_EQ(POST_INSTALL_ACTION_DEFAULT, result_info_.post_install_action); | |
| 1764 | |
| 1765 VerifyLastRegistryValues(kAppId, | |
| 1766 true, kResultFailedSystemError, | |
| 1767 true, kInstallerErrorValue, | |
| 1768 false, 0, | |
| 1769 false, _T(""), | |
| 1770 false, _T("")); | |
| 1771 } | |
| 1772 | |
| 1773 // INSTALLER_RESULT_FAILED_SYSTEM_ERROR supports values beyond the basic | |
| 1774 // "System Error Codes" and their HRESULT equivalents. | |
| 1775 TEST_F(InstallerWrapperUserGetInstallerResultHelperTest, | |
| 1776 GetInstallerResultHelper_FailedSystemError_WithHRESULTSystemError) { | |
| 1777 const DWORD kInstallerErrorValue = 0x800B010F; | |
| 1778 | |
| 1779 SetupInstallerResultRegistry(kAppId, | |
| 1780 true, kResultFailedSystemError, | |
| 1781 true, kInstallerErrorValue, | |
| 1782 false, 0, | |
| 1783 false, _T(""), | |
| 1784 false, _T("")); | |
| 1785 | |
| 1786 CallGetInstallerResultHelper(kAppGuid, kOther, 1618, &result_info_); | |
| 1787 | |
| 1788 EXPECT_EQ(INSTALLER_RESULT_ERROR_SYSTEM, result_info_.type); | |
| 1789 EXPECT_EQ(kInstallerErrorValue, result_info_.code); | |
| 1790 EXPECT_STREQ(kError0x800B010FText, result_info_.text); | |
| 1791 EXPECT_TRUE(result_info_.post_install_launch_command_line.IsEmpty()); | |
| 1792 EXPECT_TRUE(result_info_.post_install_url.IsEmpty()); | |
| 1793 EXPECT_EQ(POST_INSTALL_ACTION_DEFAULT, result_info_.post_install_action); | |
| 1794 | |
| 1795 VerifyLastRegistryValues(kAppId, | |
| 1796 true, kResultFailedSystemError, | |
| 1797 true, kInstallerErrorValue, | |
| 1798 false, 0, | |
| 1799 false, _T(""), | |
| 1800 false, _T("")); | |
| 1801 } | |
| 1802 | |
| 1803 TEST_F(InstallerWrapperUserGetInstallerResultHelperTest, | |
| 1804 GetInstallerResultHelper_FailedSystemError_WithUnrecognizedError) { | |
| 1805 const DWORD kInstallerErrorValue = 0x80040200; | |
| 1806 | |
| 1807 SetupInstallerResultRegistry(kAppId, | |
| 1808 true, kResultFailedSystemError, | |
| 1809 true, kInstallerErrorValue, | |
| 1810 false, 0, | |
| 1811 false, _T(""), | |
| 1812 false, _T("")); | |
| 1813 | |
| 1814 CallGetInstallerResultHelper(kAppGuid, kOther, 1618, &result_info_); | |
| 1815 | |
| 1816 EXPECT_EQ(INSTALLER_RESULT_ERROR_SYSTEM, result_info_.type); | |
| 1817 EXPECT_EQ(kInstallerErrorValue, result_info_.code); | |
| 1818 EXPECT_STREQ(_T("The installer encountered error 0x80040200."), | |
| 1819 result_info_.text); | |
| 1820 EXPECT_TRUE(result_info_.post_install_launch_command_line.IsEmpty()); | |
| 1821 EXPECT_TRUE(result_info_.post_install_url.IsEmpty()); | |
| 1822 EXPECT_EQ(POST_INSTALL_ACTION_DEFAULT, result_info_.post_install_action); | |
| 1823 | |
| 1824 VerifyLastRegistryValues(kAppId, | |
| 1825 true, kResultFailedSystemError, | |
| 1826 true, kInstallerErrorValue, | |
| 1827 false, 0, | |
| 1828 false, _T(""), | |
| 1829 false, _T("")); | |
| 1830 } | |
| 1831 | |
| 1832 // This test shows that command line is read and | |
| 1833 // POST_INSTALL_ACTION_LAUNCH_COMMAND is set. | |
| 1834 TEST_F(InstallerWrapperUserGetInstallerResultHelperTest, | |
| 1835 GetInstallerResultHelper_FailedSystemError_AllValues) { | |
| 1836 const DWORD kInstallerErrorValue = 1603; | |
| 1837 | |
| 1838 SetupInstallerResultRegistry(kAppId, | |
| 1839 true, kResultFailedSystemError, | |
| 1840 true, kInstallerErrorValue, | |
| 1841 false, 0, | |
| 1842 true, _T("an ignored error"), | |
| 1843 true, kLaunchCmdLine); | |
| 1844 | |
| 1845 CallGetInstallerResultHelper(kAppGuid, kOther, 1618, &result_info_); | |
| 1846 | |
| 1847 EXPECT_EQ(INSTALLER_RESULT_ERROR_SYSTEM, result_info_.type); | |
| 1848 EXPECT_EQ(kInstallerErrorValue, result_info_.code); | |
| 1849 EXPECT_STREQ(kError1603Text, result_info_.text) << _T("UIString is ignored."); | |
| 1850 EXPECT_STREQ(kLaunchCmdLine, result_info_.post_install_launch_command_line); | |
| 1851 EXPECT_TRUE(result_info_.post_install_url.IsEmpty()); | |
| 1852 EXPECT_EQ(POST_INSTALL_ACTION_LAUNCH_COMMAND, | |
| 1853 result_info_.post_install_action); | |
| 1854 | |
| 1855 VerifyLastRegistryValues(kAppId, | |
| 1856 true, kResultFailedSystemError, | |
| 1857 true, kInstallerErrorValue, | |
| 1858 false, 0, | |
| 1859 true, _T("an ignored error"), | |
| 1860 true, kLaunchCmdLine); | |
| 1861 } | |
| 1862 | |
| 1863 TEST_F(InstallerWrapperUserGetInstallerResultHelperTest, | |
| 1864 GetInstallerResultHelper_ExtraCode1) { | |
| 1865 const DWORD kInstallerErrorValue = 10; | |
| 1866 const DWORD kInstallerExtraCode1 = 0xabcd; | |
| 1867 | |
| 1868 SetupInstallerResultRegistry(kAppId, | |
| 1869 true, kResultFailedCustomError, | |
| 1870 true, kInstallerErrorValue, | |
| 1871 true, kInstallerExtraCode1, | |
| 1872 false, _T(""), | |
| 1873 false, _T("")); | |
| 1874 | |
| 1875 CallGetInstallerResultHelper(kAppGuid, | |
| 1876 kOther, | |
| 1877 kInstallerErrorValue, | |
| 1878 &result_info_); | |
| 1879 | |
| 1880 EXPECT_EQ(INSTALLER_RESULT_ERROR_OTHER, result_info_.type); | |
| 1881 EXPECT_EQ(kInstallerErrorValue, result_info_.code); | |
| 1882 EXPECT_EQ(kInstallerExtraCode1, result_info_.extra_code1); | |
| 1883 | |
| 1884 VerifyLastRegistryValues(kAppId, | |
| 1885 true, kResultFailedCustomError, | |
| 1886 true, kInstallerErrorValue, | |
| 1887 true, kInstallerExtraCode1, | |
| 1888 false, _T(""), | |
| 1889 false, _T("")); | |
| 1890 } | |
| 1891 | |
| 1892 // TODO(omaha): Add a machine test. | |
| 1893 | |
| 1894 } // 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