1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. 2 // Use of this source code is governed by a BSD-style license that can be 3 // found in the LICENSE file. 4 5 #include <windows.h> 6 7 #include <fstream> 8 9 #include "base/base_paths.h" 10 #include "base/command_line.h" 11 #include "base/files/file_enumerator.h" 12 #include "base/files/file_path.h" 13 #include "base/files/file_util.h" 14 #include "base/files/scoped_temp_dir.h" 15 #include "base/path_service.h" 16 #include "base/strings/string_util.h" 17 #include "base/strings/utf_string_conversions.h" 18 #include "base/test/scoped_path_override.h" 19 #include "base/test/test_reg_util_win.h" 20 #include "base/version.h" 21 #include "base/win/registry.h" 22 #include "base/win/scoped_handle.h" 23 #include "chrome/common/chrome_constants.h" 24 #include "chrome/installer/test/alternate_version_generator.h" 25 #include "chrome/installer/util/fake_installation_state.h" 26 #include "chrome/installer/util/fake_product_state.h" 27 #include "chrome/installer/util/google_update_constants.h" 28 #include "chrome/installer/util/helper.h" 29 #include "chrome/installer/util/installation_state.h" 30 #include "chrome/installer/util/installer_state.h" 31 #include "chrome/installer/util/master_preferences.h" 32 #include "chrome/installer/util/product_unittest.h" 33 #include "chrome/installer/util/util_constants.h" 34 #include "chrome/installer/util/work_item.h" 35 #include "testing/gtest/include/gtest/gtest.h" 36 37 #include "installer_util_strings.h" // NOLINT 38 39 using base::win::RegKey; 40 using installer::InstallationState; 41 using installer::InstallerState; 42 using installer::MasterPreferences; 43 using registry_util::RegistryOverrideManager; 44 45 class InstallerStateTest : public TestWithTempDirAndDeleteTempOverrideKeys { 46 protected: 47 }; 48 49 // An installer state on which we can access otherwise protected members. 50 class MockInstallerState : public InstallerState { 51 public: 52 MockInstallerState() : InstallerState() { } 53 void set_target_path(const base::FilePath& target_path) { 54 target_path_ = target_path; 55 } 56 static bool IsFileInUse(const base::FilePath& file) { 57 return InstallerState::IsFileInUse(file); 58 } 59 const Version& critical_update_version() const { 60 return critical_update_version_; 61 } 62 void GetExistingExeVersions(std::set<std::string>* existing_version_strings) { 63 return InstallerState::GetExistingExeVersions(existing_version_strings); 64 } 65 }; 66 67 // Simple function to dump some text into a new file. 68 void CreateTextFile(const std::wstring& filename, 69 const std::wstring& contents) { 70 std::ofstream file; 71 file.open(filename.c_str()); 72 ASSERT_TRUE(file.is_open()); 73 file << contents; 74 file.close(); 75 } 76 77 void BuildSingleChromeState(const base::FilePath& target_dir, 78 MockInstallerState* installer_state) { 79 CommandLine cmd_line = CommandLine::FromString(L"setup.exe"); 80 MasterPreferences prefs(cmd_line); 81 InstallationState machine_state; 82 machine_state.Initialize(); 83 installer_state->Initialize(cmd_line, prefs, machine_state); 84 installer_state->set_target_path(target_dir); 85 EXPECT_TRUE(installer_state->FindProduct(BrowserDistribution::CHROME_BROWSER) 86 != NULL); 87 } 88 89 wchar_t text_content_1[] = L"delete me"; 90 wchar_t text_content_2[] = L"delete me as well"; 91 92 // Delete version directories. Everything lower than the given version 93 // should be deleted. 94 TEST_F(InstallerStateTest, Delete) { 95 // TODO(grt): move common stuff into the test fixture. 96 // Create a Chrome dir 97 base::FilePath chrome_dir(test_dir_.path()); 98 chrome_dir = chrome_dir.AppendASCII("chrome"); 99 base::CreateDirectory(chrome_dir); 100 ASSERT_TRUE(base::PathExists(chrome_dir)); 101 102 base::FilePath chrome_dir_1(chrome_dir); 103 chrome_dir_1 = chrome_dir_1.AppendASCII("1.0.1.0"); 104 base::CreateDirectory(chrome_dir_1); 105 ASSERT_TRUE(base::PathExists(chrome_dir_1)); 106 107 base::FilePath chrome_dir_2(chrome_dir); 108 chrome_dir_2 = chrome_dir_2.AppendASCII("1.0.2.0"); 109 base::CreateDirectory(chrome_dir_2); 110 ASSERT_TRUE(base::PathExists(chrome_dir_2)); 111 112 base::FilePath chrome_dir_3(chrome_dir); 113 chrome_dir_3 = chrome_dir_3.AppendASCII("1.0.3.0"); 114 base::CreateDirectory(chrome_dir_3); 115 ASSERT_TRUE(base::PathExists(chrome_dir_3)); 116 117 base::FilePath chrome_dir_4(chrome_dir); 118 chrome_dir_4 = chrome_dir_4.AppendASCII("1.0.4.0"); 119 base::CreateDirectory(chrome_dir_4); 120 ASSERT_TRUE(base::PathExists(chrome_dir_4)); 121 122 base::FilePath chrome_dll_1(chrome_dir_1); 123 chrome_dll_1 = chrome_dll_1.AppendASCII("chrome.dll"); 124 CreateTextFile(chrome_dll_1.value(), text_content_1); 125 ASSERT_TRUE(base::PathExists(chrome_dll_1)); 126 127 base::FilePath chrome_dll_2(chrome_dir_2); 128 chrome_dll_2 = chrome_dll_2.AppendASCII("chrome.dll"); 129 CreateTextFile(chrome_dll_2.value(), text_content_1); 130 ASSERT_TRUE(base::PathExists(chrome_dll_2)); 131 132 base::FilePath chrome_dll_3(chrome_dir_3); 133 chrome_dll_3 = chrome_dll_3.AppendASCII("chrome.dll"); 134 CreateTextFile(chrome_dll_3.value(), text_content_1); 135 ASSERT_TRUE(base::PathExists(chrome_dll_3)); 136 137 base::FilePath chrome_dll_4(chrome_dir_4); 138 chrome_dll_4 = chrome_dll_4.AppendASCII("chrome.dll"); 139 CreateTextFile(chrome_dll_4.value(), text_content_1); 140 ASSERT_TRUE(base::PathExists(chrome_dll_4)); 141 142 MockInstallerState installer_state; 143 BuildSingleChromeState(chrome_dir, &installer_state); 144 Version latest_version("1.0.4.0"); 145 { 146 base::ScopedTempDir temp_dir; 147 ASSERT_TRUE(temp_dir.CreateUniqueTempDir()); 148 installer_state.RemoveOldVersionDirectories(latest_version, NULL, 149 temp_dir.path()); 150 } 151 152 // old versions should be gone 153 EXPECT_FALSE(base::PathExists(chrome_dir_1)); 154 EXPECT_FALSE(base::PathExists(chrome_dir_2)); 155 EXPECT_FALSE(base::PathExists(chrome_dir_3)); 156 // the latest version should stay 157 EXPECT_TRUE(base::PathExists(chrome_dll_4)); 158 } 159 160 // Delete older version directories, keeping the one in used intact. 161 TEST_F(InstallerStateTest, DeleteInUsed) { 162 // Create a Chrome dir 163 base::FilePath chrome_dir(test_dir_.path()); 164 chrome_dir = chrome_dir.AppendASCII("chrome"); 165 base::CreateDirectory(chrome_dir); 166 ASSERT_TRUE(base::PathExists(chrome_dir)); 167 168 base::FilePath chrome_dir_1(chrome_dir); 169 chrome_dir_1 = chrome_dir_1.AppendASCII("1.0.1.0"); 170 base::CreateDirectory(chrome_dir_1); 171 ASSERT_TRUE(base::PathExists(chrome_dir_1)); 172 173 base::FilePath chrome_dir_2(chrome_dir); 174 chrome_dir_2 = chrome_dir_2.AppendASCII("1.0.2.0"); 175 base::CreateDirectory(chrome_dir_2); 176 ASSERT_TRUE(base::PathExists(chrome_dir_2)); 177 178 base::FilePath chrome_dir_3(chrome_dir); 179 chrome_dir_3 = chrome_dir_3.AppendASCII("1.0.3.0"); 180 base::CreateDirectory(chrome_dir_3); 181 ASSERT_TRUE(base::PathExists(chrome_dir_3)); 182 183 base::FilePath chrome_dir_4(chrome_dir); 184 chrome_dir_4 = chrome_dir_4.AppendASCII("1.0.4.0"); 185 base::CreateDirectory(chrome_dir_4); 186 ASSERT_TRUE(base::PathExists(chrome_dir_4)); 187 188 base::FilePath chrome_dll_1(chrome_dir_1); 189 chrome_dll_1 = chrome_dll_1.AppendASCII("chrome.dll"); 190 CreateTextFile(chrome_dll_1.value(), text_content_1); 191 ASSERT_TRUE(base::PathExists(chrome_dll_1)); 192 193 base::FilePath chrome_dll_2(chrome_dir_2); 194 chrome_dll_2 = chrome_dll_2.AppendASCII("chrome.dll"); 195 CreateTextFile(chrome_dll_2.value(), text_content_1); 196 ASSERT_TRUE(base::PathExists(chrome_dll_2)); 197 198 // Open the file to make it in use. 199 std::ofstream file; 200 file.open(chrome_dll_2.value().c_str()); 201 202 base::FilePath chrome_othera_2(chrome_dir_2); 203 chrome_othera_2 = chrome_othera_2.AppendASCII("othera.dll"); 204 CreateTextFile(chrome_othera_2.value(), text_content_2); 205 ASSERT_TRUE(base::PathExists(chrome_othera_2)); 206 207 base::FilePath chrome_otherb_2(chrome_dir_2); 208 chrome_otherb_2 = chrome_otherb_2.AppendASCII("otherb.dll"); 209 CreateTextFile(chrome_otherb_2.value(), text_content_2); 210 ASSERT_TRUE(base::PathExists(chrome_otherb_2)); 211 212 base::FilePath chrome_dll_3(chrome_dir_3); 213 chrome_dll_3 = chrome_dll_3.AppendASCII("chrome.dll"); 214 CreateTextFile(chrome_dll_3.value(), text_content_1); 215 ASSERT_TRUE(base::PathExists(chrome_dll_3)); 216 217 base::FilePath chrome_dll_4(chrome_dir_4); 218 chrome_dll_4 = chrome_dll_4.AppendASCII("chrome.dll"); 219 CreateTextFile(chrome_dll_4.value(), text_content_1); 220 ASSERT_TRUE(base::PathExists(chrome_dll_4)); 221 222 MockInstallerState installer_state; 223 BuildSingleChromeState(chrome_dir, &installer_state); 224 Version latest_version("1.0.4.0"); 225 Version existing_version("1.0.1.0"); 226 { 227 base::ScopedTempDir temp_dir; 228 ASSERT_TRUE(temp_dir.CreateUniqueTempDir()); 229 installer_state.RemoveOldVersionDirectories(latest_version, 230 &existing_version, 231 temp_dir.path()); 232 } 233 234 // the version defined as the existing version should stay 235 EXPECT_TRUE(base::PathExists(chrome_dir_1)); 236 // old versions not in used should be gone 237 EXPECT_FALSE(base::PathExists(chrome_dir_3)); 238 // every thing under in used version should stay 239 EXPECT_TRUE(base::PathExists(chrome_dir_2)); 240 EXPECT_TRUE(base::PathExists(chrome_dll_2)); 241 EXPECT_TRUE(base::PathExists(chrome_othera_2)); 242 EXPECT_TRUE(base::PathExists(chrome_otherb_2)); 243 // the latest version should stay 244 EXPECT_TRUE(base::PathExists(chrome_dll_4)); 245 } 246 247 // Tests a few basic things of the Package class. Makes sure that the path 248 // operations are correct 249 TEST_F(InstallerStateTest, Basic) { 250 const bool multi_install = false; 251 const bool system_level = true; 252 CommandLine cmd_line = CommandLine::FromString( 253 std::wstring(L"setup.exe") + 254 (multi_install ? L" --multi-install --chrome" : L"") + 255 (system_level ? L" --system-level" : L"")); 256 MasterPreferences prefs(cmd_line); 257 InstallationState machine_state; 258 machine_state.Initialize(); 259 MockInstallerState installer_state; 260 installer_state.Initialize(cmd_line, prefs, machine_state); 261 installer_state.set_target_path(test_dir_.path()); 262 EXPECT_EQ(test_dir_.path().value(), installer_state.target_path().value()); 263 EXPECT_EQ(1U, installer_state.products().size()); 264 265 const char kOldVersion[] = "1.2.3.4"; 266 const char kNewVersion[] = "2.3.4.5"; 267 268 Version new_version(kNewVersion); 269 Version old_version(kOldVersion); 270 ASSERT_TRUE(new_version.IsValid()); 271 ASSERT_TRUE(old_version.IsValid()); 272 273 base::FilePath installer_dir( 274 installer_state.GetInstallerDirectory(new_version)); 275 EXPECT_FALSE(installer_dir.empty()); 276 277 base::FilePath new_version_dir(installer_state.target_path().Append( 278 base::UTF8ToWide(new_version.GetString()))); 279 base::FilePath old_version_dir(installer_state.target_path().Append( 280 base::UTF8ToWide(old_version.GetString()))); 281 282 EXPECT_FALSE(base::PathExists(new_version_dir)); 283 EXPECT_FALSE(base::PathExists(old_version_dir)); 284 285 EXPECT_FALSE(base::PathExists(installer_dir)); 286 base::CreateDirectory(installer_dir); 287 EXPECT_TRUE(base::PathExists(new_version_dir)); 288 289 base::CreateDirectory(old_version_dir); 290 EXPECT_TRUE(base::PathExists(old_version_dir)); 291 292 // Create a fake chrome.dll key file in the old version directory. This 293 // should prevent the old version directory from getting deleted. 294 base::FilePath old_chrome_dll(old_version_dir.Append(installer::kChromeDll)); 295 EXPECT_FALSE(base::PathExists(old_chrome_dll)); 296 297 // Hold on to the file exclusively to prevent the directory from 298 // being deleted. 299 base::win::ScopedHandle file( 300 ::CreateFile(old_chrome_dll.value().c_str(), GENERIC_READ, 301 0, NULL, OPEN_ALWAYS, 0, NULL)); 302 EXPECT_TRUE(file.IsValid()); 303 EXPECT_TRUE(base::PathExists(old_chrome_dll)); 304 305 base::ScopedTempDir temp_dir; 306 ASSERT_TRUE(temp_dir.CreateUniqueTempDir()); 307 308 // Don't explicitly tell the directory cleanup logic not to delete the 309 // old version, rely on the key files to keep it around. 310 installer_state.RemoveOldVersionDirectories(new_version, 311 NULL, 312 temp_dir.path()); 313 314 // The old directory should still exist. 315 EXPECT_TRUE(base::PathExists(old_version_dir)); 316 EXPECT_TRUE(base::PathExists(new_version_dir)); 317 318 // Now close the file handle to make it possible to delete our key file. 319 file.Close(); 320 321 installer_state.RemoveOldVersionDirectories(new_version, 322 NULL, 323 temp_dir.path()); 324 // The new directory should still exist. 325 EXPECT_TRUE(base::PathExists(new_version_dir)); 326 327 // Now, the old directory and key file should be gone. 328 EXPECT_FALSE(base::PathExists(old_chrome_dll)); 329 EXPECT_FALSE(base::PathExists(old_version_dir)); 330 } 331 332 TEST_F(InstallerStateTest, WithProduct) { 333 const bool multi_install = false; 334 const bool system_level = true; 335 CommandLine cmd_line = CommandLine::FromString( 336 std::wstring(L"setup.exe") + 337 (multi_install ? L" --multi-install --chrome" : L"") + 338 (system_level ? L" --system-level" : L"")); 339 MasterPreferences prefs(cmd_line); 340 InstallationState machine_state; 341 machine_state.Initialize(); 342 MockInstallerState installer_state; 343 installer_state.Initialize(cmd_line, prefs, machine_state); 344 installer_state.set_target_path(test_dir_.path()); 345 EXPECT_EQ(1U, installer_state.products().size()); 346 EXPECT_EQ(system_level, installer_state.system_install()); 347 348 const char kCurrentVersion[] = "1.2.3.4"; 349 Version current_version(kCurrentVersion); 350 351 HKEY root = system_level ? HKEY_LOCAL_MACHINE : HKEY_CURRENT_USER; 352 EXPECT_EQ(root, installer_state.root_key()); 353 354 { 355 RegistryOverrideManager override_manager; 356 override_manager.OverrideRegistry(root); 357 BrowserDistribution* dist = BrowserDistribution::GetSpecificDistribution( 358 BrowserDistribution::CHROME_BROWSER); 359 RegKey chrome_key(root, dist->GetVersionKey().c_str(), KEY_ALL_ACCESS); 360 EXPECT_TRUE(chrome_key.Valid()); 361 if (chrome_key.Valid()) { 362 chrome_key.WriteValue(google_update::kRegVersionField, 363 base::UTF8ToWide( 364 current_version.GetString()).c_str()); 365 machine_state.Initialize(); 366 // TODO(tommi): Also test for when there exists a new_chrome.exe. 367 Version found_version(*installer_state.GetCurrentVersion(machine_state)); 368 EXPECT_TRUE(found_version.IsValid()); 369 if (found_version.IsValid()) 370 EXPECT_TRUE(current_version.Equals(found_version)); 371 } 372 } 373 } 374 375 TEST_F(InstallerStateTest, InstallerResult) { 376 const bool system_level = true; 377 bool multi_install = false; 378 HKEY root = system_level ? HKEY_LOCAL_MACHINE : HKEY_CURRENT_USER; 379 380 RegKey key; 381 std::wstring launch_cmd = L"hey diddle diddle"; 382 std::wstring value; 383 DWORD dw_value; 384 385 // check results for a fresh install of single Chrome 386 { 387 RegistryOverrideManager override_manager; 388 override_manager.OverrideRegistry(root); 389 CommandLine cmd_line = CommandLine::FromString(L"setup.exe --system-level"); 390 const MasterPreferences prefs(cmd_line); 391 InstallationState machine_state; 392 machine_state.Initialize(); 393 InstallerState state; 394 state.Initialize(cmd_line, prefs, machine_state); 395 state.WriteInstallerResult(installer::FIRST_INSTALL_SUCCESS, 396 IDS_INSTALL_OS_ERROR_BASE, &launch_cmd); 397 BrowserDistribution* distribution = 398 BrowserDistribution::GetSpecificDistribution( 399 BrowserDistribution::CHROME_BROWSER); 400 EXPECT_EQ(ERROR_SUCCESS, 401 key.Open(root, distribution->GetStateKey().c_str(), KEY_READ)); 402 EXPECT_EQ(ERROR_SUCCESS, 403 key.ReadValueDW(installer::kInstallerResult, &dw_value)); 404 EXPECT_EQ(static_cast<DWORD>(0), dw_value); 405 EXPECT_EQ(ERROR_SUCCESS, 406 key.ReadValueDW(installer::kInstallerError, &dw_value)); 407 EXPECT_EQ(static_cast<DWORD>(installer::FIRST_INSTALL_SUCCESS), dw_value); 408 EXPECT_EQ(ERROR_SUCCESS, 409 key.ReadValue(installer::kInstallerResultUIString, &value)); 410 EXPECT_FALSE(value.empty()); 411 EXPECT_EQ(ERROR_SUCCESS, 412 key.ReadValue(installer::kInstallerSuccessLaunchCmdLine, &value)); 413 EXPECT_EQ(launch_cmd, value); 414 } 415 416 // check results for a fresh install of multi Chrome 417 { 418 RegistryOverrideManager override_manager; 419 override_manager.OverrideRegistry(root); 420 CommandLine cmd_line = CommandLine::FromString( 421 L"setup.exe --system-level --multi-install --chrome"); 422 const MasterPreferences prefs(cmd_line); 423 InstallationState machine_state; 424 machine_state.Initialize(); 425 InstallerState state; 426 state.Initialize(cmd_line, prefs, machine_state); 427 state.WriteInstallerResult(installer::FIRST_INSTALL_SUCCESS, 0, 428 &launch_cmd); 429 BrowserDistribution* distribution = 430 BrowserDistribution::GetSpecificDistribution( 431 BrowserDistribution::CHROME_BROWSER); 432 BrowserDistribution* binaries = 433 BrowserDistribution::GetSpecificDistribution( 434 BrowserDistribution::CHROME_BINARIES); 435 EXPECT_EQ(ERROR_SUCCESS, 436 key.Open(root, distribution->GetStateKey().c_str(), KEY_READ)); 437 EXPECT_EQ(ERROR_SUCCESS, 438 key.ReadValue(installer::kInstallerSuccessLaunchCmdLine, &value)); 439 EXPECT_EQ(launch_cmd, value); 440 EXPECT_EQ(ERROR_SUCCESS, 441 key.Open(root, binaries->GetStateKey().c_str(), KEY_READ)); 442 EXPECT_EQ(ERROR_SUCCESS, 443 key.ReadValue(installer::kInstallerSuccessLaunchCmdLine, &value)); 444 EXPECT_EQ(launch_cmd, value); 445 key.Close(); 446 } 447 } 448 449 // Test GetCurrentVersion when migrating single Chrome to multi 450 TEST_F(InstallerStateTest, GetCurrentVersionMigrateChrome) { 451 using installer::FakeInstallationState; 452 453 const bool system_install = false; 454 FakeInstallationState machine_state; 455 456 // Pretend that this version of single-install Chrome is already installed. 457 machine_state.AddChrome(system_install, false, 458 new Version(chrome::kChromeVersion)); 459 460 // Now we're invoked to install multi Chrome. 461 CommandLine cmd_line( 462 CommandLine::FromString(L"setup.exe --multi-install --chrome")); 463 MasterPreferences prefs(cmd_line); 464 InstallerState installer_state; 465 installer_state.Initialize(cmd_line, prefs, machine_state); 466 467 // Is the Chrome version picked up? 468 scoped_ptr<Version> version(installer_state.GetCurrentVersion(machine_state)); 469 EXPECT_TRUE(version.get() != NULL); 470 } 471 472 TEST_F(InstallerStateTest, IsFileInUse) { 473 base::ScopedTempDir temp_dir; 474 ASSERT_TRUE(temp_dir.CreateUniqueTempDir()); 475 476 base::FilePath temp_file; 477 ASSERT_TRUE(base::CreateTemporaryFileInDir(temp_dir.path(), &temp_file)); 478 479 EXPECT_FALSE(MockInstallerState::IsFileInUse(temp_file)); 480 481 { 482 // Open a handle to the file with the same access mode and sharing options 483 // as the loader. 484 base::win::ScopedHandle temp_handle( 485 CreateFile(temp_file.value().c_str(), 486 SYNCHRONIZE | FILE_EXECUTE, 487 FILE_SHARE_DELETE | FILE_SHARE_READ, 488 NULL, OPEN_EXISTING, 0, 0)); 489 ASSERT_TRUE(temp_handle.IsValid()); 490 491 // The file should now be in use. 492 EXPECT_TRUE(MockInstallerState::IsFileInUse(temp_file)); 493 } 494 495 // And once the handle is gone, it should no longer be in use. 496 EXPECT_FALSE(MockInstallerState::IsFileInUse(temp_file)); 497 } 498 499 TEST_F(InstallerStateTest, RemoveOldVersionDirs) { 500 MockInstallerState installer_state; 501 installer_state.set_target_path(test_dir_.path()); 502 EXPECT_EQ(test_dir_.path().value(), installer_state.target_path().value()); 503 504 const char kOldVersion[] = "2.0.0.0"; 505 const char kNewVersion[] = "3.0.0.0"; 506 const char kOldChromeExeVersion[] = "2.1.0.0"; 507 const char kChromeExeVersion[] = "2.1.1.1"; 508 const char kNewChromeExeVersion[] = "3.0.0.0"; 509 510 Version new_version(kNewVersion); 511 Version old_version(kOldVersion); 512 Version old_chrome_exe_version(kOldChromeExeVersion); 513 Version chrome_exe_version(kChromeExeVersion); 514 Version new_chrome_exe_version(kNewChromeExeVersion); 515 516 ASSERT_TRUE(new_version.IsValid()); 517 ASSERT_TRUE(old_version.IsValid()); 518 ASSERT_TRUE(old_chrome_exe_version.IsValid()); 519 ASSERT_TRUE(chrome_exe_version.IsValid()); 520 ASSERT_TRUE(new_chrome_exe_version.IsValid()); 521 522 // Set up a bunch of version dir paths. 523 base::FilePath version_dirs[] = { 524 installer_state.target_path().Append(L"1.2.3.4"), 525 installer_state.target_path().Append(L"1.2.3.5"), 526 installer_state.target_path().Append(L"1.2.3.6"), 527 installer_state.target_path().Append(base::ASCIIToWide(kOldVersion)), 528 installer_state.target_path().Append( 529 base::ASCIIToWide(kOldChromeExeVersion)), 530 installer_state.target_path().Append(L"2.1.1.0"), 531 installer_state.target_path().Append(base::ASCIIToWide(kChromeExeVersion)), 532 installer_state.target_path().Append(base::ASCIIToWide(kNewVersion)), 533 installer_state.target_path().Append(L"3.9.1.1"), 534 }; 535 536 // Create the version directories. 537 for (int i = 0; i < arraysize(version_dirs); i++) { 538 base::CreateDirectory(version_dirs[i]); 539 EXPECT_TRUE(base::PathExists(version_dirs[i])); 540 } 541 542 // Create exes with the appropriate version resource. 543 // Use the current test exe as a baseline. 544 base::FilePath exe_path; 545 ASSERT_TRUE(PathService::Get(base::FILE_EXE, &exe_path)); 546 547 struct target_info { 548 base::FilePath target_file; 549 const Version& target_version; 550 } targets[] = { 551 { installer_state.target_path().Append(installer::kChromeOldExe), 552 old_chrome_exe_version }, 553 { installer_state.target_path().Append(installer::kChromeExe), 554 chrome_exe_version }, 555 { installer_state.target_path().Append(installer::kChromeNewExe), 556 new_chrome_exe_version }, 557 }; 558 for (int i = 0; i < arraysize(targets); ++i) { 559 ASSERT_TRUE(upgrade_test::GenerateSpecificPEFileVersion( 560 exe_path, targets[i].target_file, targets[i].target_version)); 561 } 562 563 // Call GetExistingExeVersions, validate that picks up the 564 // exe resources. 565 std::set<std::string> expected_exe_versions; 566 expected_exe_versions.insert(kOldChromeExeVersion); 567 expected_exe_versions.insert(kChromeExeVersion); 568 expected_exe_versions.insert(kNewChromeExeVersion); 569 570 std::set<std::string> actual_exe_versions; 571 installer_state.GetExistingExeVersions(&actual_exe_versions); 572 EXPECT_EQ(expected_exe_versions, actual_exe_versions); 573 574 // Call RemoveOldVersionDirectories 575 installer_state.RemoveOldVersionDirectories(new_version, 576 &old_version, 577 installer_state.target_path()); 578 579 // What we expect to have left. 580 std::set<std::string> expected_remaining_dirs; 581 expected_remaining_dirs.insert(kOldVersion); 582 expected_remaining_dirs.insert(kNewVersion); 583 expected_remaining_dirs.insert(kOldChromeExeVersion); 584 expected_remaining_dirs.insert(kChromeExeVersion); 585 expected_remaining_dirs.insert(kNewChromeExeVersion); 586 587 // Enumerate dirs in target_path(), ensure only desired remain. 588 base::FileEnumerator version_enum(installer_state.target_path(), false, 589 base::FileEnumerator::DIRECTORIES); 590 for (base::FilePath next_version = version_enum.Next(); !next_version.empty(); 591 next_version = version_enum.Next()) { 592 base::FilePath dir_name(next_version.BaseName()); 593 Version version(base::UTF16ToASCII(dir_name.value())); 594 if (version.IsValid()) { 595 EXPECT_TRUE(expected_remaining_dirs.erase(version.GetString())) 596 << "Unexpected version dir found: " << version.GetString(); 597 } 598 } 599 600 std::set<std::string>::const_iterator iter( 601 expected_remaining_dirs.begin()); 602 for (; iter != expected_remaining_dirs.end(); ++iter) 603 ADD_FAILURE() << "Expected to find version dir for " << *iter; 604 } 605 606 TEST_F(InstallerStateTest, InitializeTwice) { 607 // Override these paths so that they can be found after the registry override 608 // manager is in place. 609 base::FilePath temp; 610 PathService::Get(base::DIR_PROGRAM_FILES, &temp); 611 base::ScopedPathOverride program_files_override(base::DIR_PROGRAM_FILES, 612 temp); 613 PathService::Get(base::DIR_PROGRAM_FILESX86, &temp); 614 base::ScopedPathOverride program_filesx86_override(base::DIR_PROGRAM_FILESX86, 615 temp); 616 PathService::Get(base::DIR_LOCAL_APP_DATA, &temp); 617 base::ScopedPathOverride local_app_data_override(base::DIR_LOCAL_APP_DATA, 618 temp); 619 registry_util::RegistryOverrideManager override_manager; 620 override_manager.OverrideRegistry(HKEY_CURRENT_USER); 621 override_manager.OverrideRegistry(HKEY_LOCAL_MACHINE); 622 623 InstallationState machine_state; 624 machine_state.Initialize(); 625 626 InstallerState installer_state; 627 628 // Initialize the instance to install multi Chrome. 629 { 630 CommandLine cmd_line( 631 CommandLine::FromString(L"setup.exe --multi-install --chrome")); 632 MasterPreferences prefs(cmd_line); 633 installer_state.Initialize(cmd_line, prefs, machine_state); 634 } 635 // Confirm the expected state. 636 EXPECT_EQ(InstallerState::USER_LEVEL, installer_state.level()); 637 EXPECT_EQ(InstallerState::MULTI_PACKAGE, installer_state.package_type()); 638 EXPECT_EQ(InstallerState::MULTI_INSTALL, installer_state.operation()); 639 EXPECT_TRUE(wcsstr(installer_state.target_path().value().c_str(), 640 BrowserDistribution::GetSpecificDistribution( 641 BrowserDistribution::CHROME_BINARIES)-> 642 GetInstallSubDir().c_str())); 643 EXPECT_FALSE(installer_state.verbose_logging()); 644 EXPECT_EQ(installer_state.state_key(), 645 BrowserDistribution::GetSpecificDistribution( 646 BrowserDistribution::CHROME_BROWSER)->GetStateKey()); 647 EXPECT_EQ(installer_state.state_type(), BrowserDistribution::CHROME_BROWSER); 648 EXPECT_TRUE(installer_state.multi_package_binaries_distribution()); 649 EXPECT_TRUE(installer_state.FindProduct(BrowserDistribution::CHROME_BROWSER)); 650 651 // Now initialize it to install system-level single Chrome. 652 { 653 CommandLine cmd_line( 654 CommandLine::FromString(L"setup.exe --system-level --verbose-logging")); 655 MasterPreferences prefs(cmd_line); 656 installer_state.Initialize(cmd_line, prefs, machine_state); 657 } 658 659 // Confirm that the old state is gone. 660 EXPECT_EQ(InstallerState::SYSTEM_LEVEL, installer_state.level()); 661 EXPECT_EQ(InstallerState::SINGLE_PACKAGE, installer_state.package_type()); 662 EXPECT_EQ(InstallerState::SINGLE_INSTALL_OR_UPDATE, 663 installer_state.operation()); 664 EXPECT_TRUE(wcsstr(installer_state.target_path().value().c_str(), 665 BrowserDistribution::GetSpecificDistribution( 666 BrowserDistribution::CHROME_BROWSER)-> 667 GetInstallSubDir().c_str())); 668 EXPECT_TRUE(installer_state.verbose_logging()); 669 EXPECT_EQ(installer_state.state_key(), 670 BrowserDistribution::GetSpecificDistribution( 671 BrowserDistribution::CHROME_BROWSER)->GetStateKey()); 672 EXPECT_EQ(installer_state.state_type(), BrowserDistribution::CHROME_BROWSER); 673 EXPECT_TRUE(installer_state.FindProduct(BrowserDistribution::CHROME_BROWSER)); 674 } 675 676 // A fixture for testing InstallerState::DetermineCriticalVersion. Individual 677 // tests must invoke Initialize() with a critical version. 678 class InstallerStateCriticalVersionTest : public ::testing::Test { 679 protected: 680 InstallerStateCriticalVersionTest() : cmd_line_(CommandLine::NO_PROGRAM) {} 681 682 // Creates a set of versions for use by all test runs. 683 static void SetUpTestCase() { 684 low_version_ = new Version("15.0.874.106"); 685 opv_version_ = new Version("15.0.874.255"); 686 middle_version_ = new Version("16.0.912.32"); 687 pv_version_ = new Version("16.0.912.255"); 688 high_version_ = new Version("17.0.932.0"); 689 } 690 691 // Cleans up versions used by all test runs. 692 static void TearDownTestCase() { 693 delete low_version_; 694 delete opv_version_; 695 delete middle_version_; 696 delete pv_version_; 697 delete high_version_; 698 } 699 700 // Initializes the InstallerState to use for a test run. The returned 701 // instance's critical update version is set to |version|. |version| may be 702 // NULL, in which case the critical update version is unset. 703 MockInstallerState& Initialize(const Version* version) { 704 cmd_line_ = version == NULL ? 705 CommandLine::FromString(L"setup.exe") : 706 CommandLine::FromString( 707 L"setup.exe --critical-update-version=" + 708 base::ASCIIToWide(version->GetString())); 709 prefs_.reset(new MasterPreferences(cmd_line_)); 710 machine_state_.Initialize(); 711 installer_state_.Initialize(cmd_line_, *prefs_, machine_state_); 712 return installer_state_; 713 } 714 715 static Version* low_version_; 716 static Version* opv_version_; 717 static Version* middle_version_; 718 static Version* pv_version_; 719 static Version* high_version_; 720 721 CommandLine cmd_line_; 722 scoped_ptr<MasterPreferences> prefs_; 723 InstallationState machine_state_; 724 MockInstallerState installer_state_; 725 }; 726 727 Version* InstallerStateCriticalVersionTest::low_version_ = NULL; 728 Version* InstallerStateCriticalVersionTest::opv_version_ = NULL; 729 Version* InstallerStateCriticalVersionTest::middle_version_ = NULL; 730 Version* InstallerStateCriticalVersionTest::pv_version_ = NULL; 731 Version* InstallerStateCriticalVersionTest::high_version_ = NULL; 732 733 // Test the case where the critical version is less than the currently-running 734 // Chrome. The critical version is ignored since it doesn't apply. 735 TEST_F(InstallerStateCriticalVersionTest, CriticalBeforeOpv) { 736 MockInstallerState& installer_state(Initialize(low_version_)); 737 738 EXPECT_TRUE(installer_state.critical_update_version().Equals(*low_version_)); 739 // Unable to determine the installed version, so assume critical update. 740 EXPECT_TRUE( 741 installer_state.DetermineCriticalVersion(NULL, *pv_version_).IsValid()); 742 // Installed version is past the critical update. 743 EXPECT_FALSE( 744 installer_state.DetermineCriticalVersion(opv_version_, *pv_version_) 745 .IsValid()); 746 // Installed version is past the critical update. 747 EXPECT_FALSE( 748 installer_state.DetermineCriticalVersion(pv_version_, *pv_version_) 749 .IsValid()); 750 } 751 752 // Test the case where the critical version is equal to the currently-running 753 // Chrome. The critical version is ignored since it doesn't apply. 754 TEST_F(InstallerStateCriticalVersionTest, CriticalEqualsOpv) { 755 MockInstallerState& installer_state(Initialize(opv_version_)); 756 757 EXPECT_TRUE(installer_state.critical_update_version().Equals(*opv_version_)); 758 // Unable to determine the installed version, so assume critical update. 759 EXPECT_TRUE( 760 installer_state.DetermineCriticalVersion(NULL, *pv_version_).IsValid()); 761 // Installed version equals the critical update. 762 EXPECT_FALSE( 763 installer_state.DetermineCriticalVersion(opv_version_, *pv_version_) 764 .IsValid()); 765 // Installed version equals the critical update. 766 EXPECT_FALSE( 767 installer_state.DetermineCriticalVersion(pv_version_, *pv_version_) 768 .IsValid()); 769 } 770 771 // Test the case where the critical version is between the currently-running 772 // Chrome and the to-be-installed Chrome. 773 TEST_F(InstallerStateCriticalVersionTest, CriticalBetweenOpvAndPv) { 774 MockInstallerState& installer_state(Initialize(middle_version_)); 775 776 EXPECT_TRUE(installer_state.critical_update_version().Equals( 777 *middle_version_)); 778 // Unable to determine the installed version, so assume critical update. 779 EXPECT_TRUE( 780 installer_state.DetermineCriticalVersion(NULL, *pv_version_).IsValid()); 781 // Installed version before the critical update. 782 EXPECT_TRUE( 783 installer_state.DetermineCriticalVersion(opv_version_, *pv_version_) 784 .IsValid()); 785 // Installed version is past the critical update. 786 EXPECT_FALSE( 787 installer_state.DetermineCriticalVersion(pv_version_, *pv_version_) 788 .IsValid()); 789 } 790 791 // Test the case where the critical version is the same as the to-be-installed 792 // Chrome. 793 TEST_F(InstallerStateCriticalVersionTest, CriticalEqualsPv) { 794 MockInstallerState& installer_state(Initialize(pv_version_)); 795 796 EXPECT_TRUE(installer_state.critical_update_version().Equals( 797 *pv_version_)); 798 // Unable to determine the installed version, so assume critical update. 799 EXPECT_TRUE( 800 installer_state.DetermineCriticalVersion(NULL, *pv_version_).IsValid()); 801 // Installed version before the critical update. 802 EXPECT_TRUE( 803 installer_state.DetermineCriticalVersion(opv_version_, *pv_version_) 804 .IsValid()); 805 // Installed version equals the critical update. 806 EXPECT_FALSE( 807 installer_state.DetermineCriticalVersion(pv_version_, *pv_version_) 808 .IsValid()); 809 } 810 811 // Test the case where the critical version is greater than the to-be-installed 812 // Chrome. 813 TEST_F(InstallerStateCriticalVersionTest, CriticalAfterPv) { 814 MockInstallerState& installer_state(Initialize(high_version_)); 815 816 EXPECT_TRUE(installer_state.critical_update_version().Equals( 817 *high_version_)); 818 // Critical update newer than the new version. 819 EXPECT_FALSE( 820 installer_state.DetermineCriticalVersion(NULL, *pv_version_).IsValid()); 821 EXPECT_FALSE( 822 installer_state.DetermineCriticalVersion(opv_version_, *pv_version_) 823 .IsValid()); 824 EXPECT_FALSE( 825 installer_state.DetermineCriticalVersion(pv_version_, *pv_version_) 826 .IsValid()); 827 } 828
