Delete old files after an update.

chrome/installer/util/installer_state_unittest.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "chrome/installer/util/installer_state.h"
 
 #include <windows.h>
 #include <stddef.h>
 
 #include <fstream>
 
 #include "base/base_paths.h"
 #include "base/command_line.h"
-#include "base/files/file_enumerator.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/macros.h"
 #include "base/path_service.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/test/scoped_path_override.h"
 #include "base/test/test_reg_util_win.h"
 #include "base/version.h"
@@ skipping 38 matching lines @@
   MockInstallerState() : InstallerState() { }
   void set_target_path(const base::FilePath& target_path) {
     target_path_ = target_path;
   }
   static bool IsFileInUse(const base::FilePath& file) {
     return InstallerState::IsFileInUse(file);
   }
   const Version& critical_update_version() const {
     return critical_update_version_;
   }
-  void GetExistingExeVersions(std::set<std::string>* existing_version_strings) {
-    return InstallerState::GetExistingExeVersions(existing_version_strings);
-  }
 };
 
 // Simple function to dump some text into a new file.
 void CreateTextFile(const std::wstring& filename,
                     const std::wstring& contents) {
   std::ofstream file;
   file.open(filename.c_str());
   ASSERT_TRUE(file.is_open());
   file << contents;
   file.close();
 }
 
 void BuildSingleChromeState(const base::FilePath& target_dir,
                             MockInstallerState* installer_state) {
   base::CommandLine cmd_line = base::CommandLine::FromString(L"setup.exe");
   MasterPreferences prefs(cmd_line);
   InstallationState machine_state;
   machine_state.Initialize();
   installer_state->Initialize(cmd_line, prefs, machine_state);
   installer_state->set_target_path(target_dir);
   EXPECT_TRUE(installer_state->FindProduct(BrowserDistribution::CHROME_BROWSER)
       != NULL);
 }
 
-wchar_t text_content_1[] = L"delete me";
-wchar_t text_content_2[] = L"delete me as well";
-
-// Delete version directories. Everything lower than the given version
-// should be deleted.
-TEST_F(InstallerStateTest, Delete) {
-  // TODO(grt): move common stuff into the test fixture.
-  // Create a Chrome dir
-  base::FilePath chrome_dir(test_dir_.path());
-  chrome_dir = chrome_dir.AppendASCII("chrome");
-  base::CreateDirectory(chrome_dir);
-  ASSERT_TRUE(base::PathExists(chrome_dir));
-
-  base::FilePath chrome_dir_1(chrome_dir);
-  chrome_dir_1 = chrome_dir_1.AppendASCII("1.0.1.0");
-  base::CreateDirectory(chrome_dir_1);
-  ASSERT_TRUE(base::PathExists(chrome_dir_1));
-
-  base::FilePath chrome_dir_2(chrome_dir);
-  chrome_dir_2 = chrome_dir_2.AppendASCII("1.0.2.0");
-  base::CreateDirectory(chrome_dir_2);
-  ASSERT_TRUE(base::PathExists(chrome_dir_2));
-
-  base::FilePath chrome_dir_3(chrome_dir);
-  chrome_dir_3 = chrome_dir_3.AppendASCII("1.0.3.0");
-  base::CreateDirectory(chrome_dir_3);
-  ASSERT_TRUE(base::PathExists(chrome_dir_3));
-
-  base::FilePath chrome_dir_4(chrome_dir);
-  chrome_dir_4 = chrome_dir_4.AppendASCII("1.0.4.0");
-  base::CreateDirectory(chrome_dir_4);
-  ASSERT_TRUE(base::PathExists(chrome_dir_4));
-
-  base::FilePath chrome_dll_1(chrome_dir_1);
-  chrome_dll_1 = chrome_dll_1.AppendASCII("chrome.dll");
-  CreateTextFile(chrome_dll_1.value(), text_content_1);
-  ASSERT_TRUE(base::PathExists(chrome_dll_1));
-
-  base::FilePath chrome_dll_2(chrome_dir_2);
-  chrome_dll_2 = chrome_dll_2.AppendASCII("chrome.dll");
-  CreateTextFile(chrome_dll_2.value(), text_content_1);
-  ASSERT_TRUE(base::PathExists(chrome_dll_2));
-
-  base::FilePath chrome_dll_3(chrome_dir_3);
-  chrome_dll_3 = chrome_dll_3.AppendASCII("chrome.dll");
-  CreateTextFile(chrome_dll_3.value(), text_content_1);
-  ASSERT_TRUE(base::PathExists(chrome_dll_3));
-
-  base::FilePath chrome_dll_4(chrome_dir_4);
-  chrome_dll_4 = chrome_dll_4.AppendASCII("chrome.dll");
-  CreateTextFile(chrome_dll_4.value(), text_content_1);
-  ASSERT_TRUE(base::PathExists(chrome_dll_4));
-
-  MockInstallerState installer_state;
-  BuildSingleChromeState(chrome_dir, &installer_state);
-  Version latest_version("1.0.4.0");
-  {
-    base::ScopedTempDir temp_dir;
-    ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
-    installer_state.RemoveOldVersionDirectories(latest_version, NULL,
-                                                temp_dir.path());
-  }
-
-  // old versions should be gone
-  EXPECT_FALSE(base::PathExists(chrome_dir_1));
-  EXPECT_FALSE(base::PathExists(chrome_dir_2));
-  EXPECT_FALSE(base::PathExists(chrome_dir_3));
-  // the latest version should stay
-  EXPECT_TRUE(base::PathExists(chrome_dll_4));
-}
-
-// Delete older version directories, keeping the one in used intact.
-TEST_F(InstallerStateTest, DeleteInUsed) {
-  // Create a Chrome dir
-  base::FilePath chrome_dir(test_dir_.path());
-  chrome_dir = chrome_dir.AppendASCII("chrome");
-  base::CreateDirectory(chrome_dir);
-  ASSERT_TRUE(base::PathExists(chrome_dir));
-
-  base::FilePath chrome_dir_1(chrome_dir);
-  chrome_dir_1 = chrome_dir_1.AppendASCII("1.0.1.0");
-  base::CreateDirectory(chrome_dir_1);
-  ASSERT_TRUE(base::PathExists(chrome_dir_1));
-
-  base::FilePath chrome_dir_2(chrome_dir);
-  chrome_dir_2 = chrome_dir_2.AppendASCII("1.0.2.0");
-  base::CreateDirectory(chrome_dir_2);
-  ASSERT_TRUE(base::PathExists(chrome_dir_2));
-
-  base::FilePath chrome_dir_3(chrome_dir);
-  chrome_dir_3 = chrome_dir_3.AppendASCII("1.0.3.0");
-  base::CreateDirectory(chrome_dir_3);
-  ASSERT_TRUE(base::PathExists(chrome_dir_3));
-
-  base::FilePath chrome_dir_4(chrome_dir);
-  chrome_dir_4 = chrome_dir_4.AppendASCII("1.0.4.0");
-  base::CreateDirectory(chrome_dir_4);
-  ASSERT_TRUE(base::PathExists(chrome_dir_4));
-
-  base::FilePath chrome_dll_1(chrome_dir_1);
-  chrome_dll_1 = chrome_dll_1.AppendASCII("chrome.dll");
-  CreateTextFile(chrome_dll_1.value(), text_content_1);
-  ASSERT_TRUE(base::PathExists(chrome_dll_1));
-
-  base::FilePath chrome_dll_2(chrome_dir_2);
-  chrome_dll_2 = chrome_dll_2.AppendASCII("chrome.dll");
-  CreateTextFile(chrome_dll_2.value(), text_content_1);
-  ASSERT_TRUE(base::PathExists(chrome_dll_2));
-
-  // Open the file to make it in use.
-  std::ofstream file;
-  file.open(chrome_dll_2.value().c_str());
-
-  base::FilePath chrome_othera_2(chrome_dir_2);
-  chrome_othera_2 = chrome_othera_2.AppendASCII("othera.dll");
-  CreateTextFile(chrome_othera_2.value(), text_content_2);
-  ASSERT_TRUE(base::PathExists(chrome_othera_2));
-
-  base::FilePath chrome_otherb_2(chrome_dir_2);
-  chrome_otherb_2 = chrome_otherb_2.AppendASCII("otherb.dll");
-  CreateTextFile(chrome_otherb_2.value(), text_content_2);
-  ASSERT_TRUE(base::PathExists(chrome_otherb_2));
-
-  base::FilePath chrome_dll_3(chrome_dir_3);
-  chrome_dll_3 = chrome_dll_3.AppendASCII("chrome.dll");
-  CreateTextFile(chrome_dll_3.value(), text_content_1);
-  ASSERT_TRUE(base::PathExists(chrome_dll_3));
-
-  base::FilePath chrome_dll_4(chrome_dir_4);
-  chrome_dll_4 = chrome_dll_4.AppendASCII("chrome.dll");
-  CreateTextFile(chrome_dll_4.value(), text_content_1);
-  ASSERT_TRUE(base::PathExists(chrome_dll_4));
-
-  MockInstallerState installer_state;
-  BuildSingleChromeState(chrome_dir, &installer_state);
-  Version latest_version("1.0.4.0");
-  Version existing_version("1.0.1.0");
-  {
-    base::ScopedTempDir temp_dir;
-    ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
-    installer_state.RemoveOldVersionDirectories(latest_version,
-                                                &existing_version,
-                                                temp_dir.path());
-  }
-
-  // the version defined as the existing version should stay
-  EXPECT_TRUE(base::PathExists(chrome_dir_1));
-  // old versions not in used should be gone
-  EXPECT_FALSE(base::PathExists(chrome_dir_3));
-  // every thing under in used version should stay
-  EXPECT_TRUE(base::PathExists(chrome_dir_2));
-  EXPECT_TRUE(base::PathExists(chrome_dll_2));
-  EXPECT_TRUE(base::PathExists(chrome_othera_2));
-  EXPECT_TRUE(base::PathExists(chrome_otherb_2));
-  // the latest version should stay
-  EXPECT_TRUE(base::PathExists(chrome_dll_4));
-}
-
-// Tests a few basic things of the Package class.  Makes sure that the path
-// operations are correct
-TEST_F(InstallerStateTest, Basic) {
-  const bool multi_install = false;
-  const bool system_level = true;
-  base::CommandLine cmd_line = base::CommandLine::FromString(
-      std::wstring(L"setup.exe") +
-      (multi_install ? L" --multi-install --chrome" : L"") +
-      (system_level ? L" --system-level" : L""));
-  MasterPreferences prefs(cmd_line);
-  InstallationState machine_state;
-  machine_state.Initialize();
-  MockInstallerState installer_state;
-  installer_state.Initialize(cmd_line, prefs, machine_state);
-  installer_state.set_target_path(test_dir_.path());
-  EXPECT_EQ(test_dir_.path().value(), installer_state.target_path().value());
-  EXPECT_EQ(1U, installer_state.products().size());
-
-  const char kOldVersion[] = "1.2.3.4";
-  const char kNewVersion[] = "2.3.4.5";
-
-  Version new_version(kNewVersion);
-  Version old_version(kOldVersion);
-  ASSERT_TRUE(new_version.IsValid());
-  ASSERT_TRUE(old_version.IsValid());
-
-  base::FilePath installer_dir(
-      installer_state.GetInstallerDirectory(new_version));
-  EXPECT_FALSE(installer_dir.empty());
-
-  base::FilePath new_version_dir(installer_state.target_path().Append(
-      base::UTF8ToWide(new_version.GetString())));
-  base::FilePath old_version_dir(installer_state.target_path().Append(
-      base::UTF8ToWide(old_version.GetString())));
-
-  EXPECT_FALSE(base::PathExists(new_version_dir));
-  EXPECT_FALSE(base::PathExists(old_version_dir));
-
-  EXPECT_FALSE(base::PathExists(installer_dir));
-  base::CreateDirectory(installer_dir);
-  EXPECT_TRUE(base::PathExists(new_version_dir));
-
-  base::CreateDirectory(old_version_dir);
-  EXPECT_TRUE(base::PathExists(old_version_dir));
-
-  // Create a fake chrome.dll key file in the old version directory.  This
-  // should prevent the old version directory from getting deleted.
-  base::FilePath old_chrome_dll(old_version_dir.Append(installer::kChromeDll));
-  EXPECT_FALSE(base::PathExists(old_chrome_dll));
-
-  // Hold on to the file exclusively to prevent the directory from
-  // being deleted.
-  base::win::ScopedHandle file(
-    ::CreateFile(old_chrome_dll.value().c_str(), GENERIC_READ,
-                 0, NULL, OPEN_ALWAYS, 0, NULL));
-  EXPECT_TRUE(file.IsValid());
-  EXPECT_TRUE(base::PathExists(old_chrome_dll));
-
-  base::ScopedTempDir temp_dir;
-  ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
-
-  // Don't explicitly tell the directory cleanup logic not to delete the
-  // old version, rely on the key files to keep it around.
-  installer_state.RemoveOldVersionDirectories(new_version,
-                                              NULL,
-                                              temp_dir.path());
-
-  // The old directory should still exist.
-  EXPECT_TRUE(base::PathExists(old_version_dir));
-  EXPECT_TRUE(base::PathExists(new_version_dir));
-
-  // Now close the file handle to make it possible to delete our key file.
-  file.Close();
-
-  installer_state.RemoveOldVersionDirectories(new_version,
-                                              NULL,
-                                              temp_dir.path());
-  // The new directory should still exist.
-  EXPECT_TRUE(base::PathExists(new_version_dir));
-
-  // Now, the old directory and key file should be gone.
-  EXPECT_FALSE(base::PathExists(old_chrome_dll));
-  EXPECT_FALSE(base::PathExists(old_version_dir));
-}
-
 TEST_F(InstallerStateTest, WithProduct) {
   const bool multi_install = false;
   const bool system_level = true;
   base::CommandLine cmd_line = base::CommandLine::FromString(
       std::wstring(L"setup.exe") +
       (multi_install ? L" --multi-install --chrome" : L"") +
       (system_level ? L" --system-level" : L""));
   MasterPreferences prefs(cmd_line);
   InstallationState machine_state;
   machine_state.Initialize();
@@ skipping 147 matching lines @@
     ASSERT_TRUE(temp_handle.IsValid());
 
     // The file should now be in use.
     EXPECT_TRUE(MockInstallerState::IsFileInUse(temp_file));
   }
 
   // And once the handle is gone, it should no longer be in use.
   EXPECT_FALSE(MockInstallerState::IsFileInUse(temp_file));
 }
 
-TEST_F(InstallerStateTest, RemoveOldVersionDirs) {
-  MockInstallerState installer_state;
-  installer_state.set_target_path(test_dir_.path());
-  EXPECT_EQ(test_dir_.path().value(), installer_state.target_path().value());
-
-  const char kOldVersion[] = "2.0.0.0";
-  const char kNewVersion[] = "3.0.0.0";
-  const char kOldChromeExeVersion[] = "2.1.0.0";
-  const char kChromeExeVersion[] = "2.1.1.1";
-  const char kNewChromeExeVersion[] = "3.0.0.0";
-
-  Version new_version(kNewVersion);
-  Version old_version(kOldVersion);
-  Version old_chrome_exe_version(kOldChromeExeVersion);
-  Version chrome_exe_version(kChromeExeVersion);
-  Version new_chrome_exe_version(kNewChromeExeVersion);
-
-  ASSERT_TRUE(new_version.IsValid());
-  ASSERT_TRUE(old_version.IsValid());
-  ASSERT_TRUE(old_chrome_exe_version.IsValid());
-  ASSERT_TRUE(chrome_exe_version.IsValid());
-  ASSERT_TRUE(new_chrome_exe_version.IsValid());
-
-  // Set up a bunch of version dir paths.
-  base::FilePath version_dirs[] = {
-    installer_state.target_path().Append(L"1.2.3.4"),
-    installer_state.target_path().Append(L"1.2.3.5"),
-    installer_state.target_path().Append(L"1.2.3.6"),
-    installer_state.target_path().AppendASCII(kOldVersion),
-    installer_state.target_path().AppendASCII(kOldChromeExeVersion),
-    installer_state.target_path().Append(L"2.1.1.0"),
-    installer_state.target_path().AppendASCII(kChromeExeVersion),
-    installer_state.target_path().AppendASCII(kNewVersion),
-    installer_state.target_path().Append(L"3.9.1.1"),
-  };
-
-  // Create the version directories.
-  for (size_t i = 0; i < arraysize(version_dirs); i++) {
-    base::CreateDirectory(version_dirs[i]);
-    EXPECT_TRUE(base::PathExists(version_dirs[i]));
-  }
-
-  // Create exes with the appropriate version resource.
-  // Use the current test exe as a baseline.
-  base::FilePath exe_path;
-  ASSERT_TRUE(PathService::Get(base::FILE_EXE, &exe_path));
-
-  struct target_info {
-    base::FilePath target_file;
-    const Version& target_version;
-  } targets[] = {
-    { installer_state.target_path().Append(installer::kChromeOldExe),
-      old_chrome_exe_version },
-    { installer_state.target_path().Append(installer::kChromeExe),
-      chrome_exe_version },
-    { installer_state.target_path().Append(installer::kChromeNewExe),
-      new_chrome_exe_version },
-  };
-  for (size_t i = 0; i < arraysize(targets); ++i) {
-    ASSERT_TRUE(upgrade_test::GenerateSpecificPEFileVersion(
-        exe_path, targets[i].target_file, targets[i].target_version));
-  }
-
-  // Call GetExistingExeVersions, validate that picks up the
-  // exe resources.
-  std::set<std::string> expected_exe_versions;
-  expected_exe_versions.insert(kOldChromeExeVersion);
-  expected_exe_versions.insert(kChromeExeVersion);
-  expected_exe_versions.insert(kNewChromeExeVersion);
-
-  std::set<std::string> actual_exe_versions;
-  installer_state.GetExistingExeVersions(&actual_exe_versions);
-  EXPECT_EQ(expected_exe_versions, actual_exe_versions);
-
-  // Call RemoveOldVersionDirectories
-  installer_state.RemoveOldVersionDirectories(new_version,
-                                              &old_version,
-                                              installer_state.target_path());
-
-  // What we expect to have left.
-  std::set<std::string> expected_remaining_dirs;
-  expected_remaining_dirs.insert(kOldVersion);
-  expected_remaining_dirs.insert(kNewVersion);
-  expected_remaining_dirs.insert(kOldChromeExeVersion);
-  expected_remaining_dirs.insert(kChromeExeVersion);
-  expected_remaining_dirs.insert(kNewChromeExeVersion);
-
-  // Enumerate dirs in target_path(), ensure only desired remain.
-  base::FileEnumerator version_enum(installer_state.target_path(), false,
-                                    base::FileEnumerator::DIRECTORIES);
-  for (base::FilePath next_version = version_enum.Next(); !next_version.empty();
-       next_version = version_enum.Next()) {
-    base::FilePath dir_name(next_version.BaseName());
-    Version version(base::UTF16ToASCII(dir_name.value()));
-    if (version.IsValid()) {
-      EXPECT_TRUE(expected_remaining_dirs.erase(version.GetString()))
-          << "Unexpected version dir found: " << version.GetString();
-    }
-  }
-
-  std::set<std::string>::const_iterator iter(
-      expected_remaining_dirs.begin());
-  for (; iter != expected_remaining_dirs.end(); ++iter)
-    ADD_FAILURE() << "Expected to find version dir for " << *iter;
-}
-
 TEST_F(InstallerStateTest, InitializeTwice) {
   // Override these paths so that they can be found after the registry override
   // manager is in place.
   base::FilePath temp;
   PathService::Get(base::DIR_PROGRAM_FILES, &temp);
   base::ScopedPathOverride program_files_override(base::DIR_PROGRAM_FILES,
                                                   temp);
   PathService::Get(base::DIR_PROGRAM_FILESX86, &temp);
   base::ScopedPathOverride program_filesx86_override(base::DIR_PROGRAM_FILESX86,
                                                      temp);
@@ skipping 199 matching lines @@
   // Critical update newer than the new version.
   EXPECT_FALSE(
       installer_state.DetermineCriticalVersion(NULL, *pv_version_).IsValid());
   EXPECT_FALSE(
       installer_state.DetermineCriticalVersion(opv_version_, *pv_version_)
           .IsValid());
   EXPECT_FALSE(
       installer_state.DetermineCriticalVersion(pv_version_, *pv_version_)
           .IsValid());
 }