Add support for --critical-update-version to installer.

chrome/installer/util/installer_state_unittest.cc

 // Copyright (c) 2011 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 <windows.h>
 
 #include <fstream>
 
 #include "base/base_paths.h"
 #include "base/command_line.h"
@@ skipping 24 matching lines @@
 using base::win::RegKey;
 using installer::InstallationState;
 using installer::InstallerState;
 using installer::MasterPreferences;
 using registry_util::RegistryOverrideManager;
 
 class InstallerStateTest : public TestWithTempDirAndDeleteTempOverrideKeys {
  protected:
 };
 
-// An installer state on which we can tweak the target path.
+// An installer state on which we can access otherwise protected members.
 class MockInstallerState : public InstallerState {
  public:
   MockInstallerState() : InstallerState() { }
   void set_target_path(const FilePath& target_path) {
     target_path_ = target_path;
   }
   static bool IsFileInUse(const FilePath& file) {
     return InstallerState::IsFileInUse(file);
   }
+  const Version& critical_update_version() const {
+    return critical_update_version_;
+  }
 };
 
 // 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();
@@ skipping 419 matching lines @@
                    NULL, OPEN_EXISTING, 0, 0));
     ASSERT_TRUE(temp_handle != NULL);
 
     // 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));
 }
+
+// A fixture for testing InstallerState::DetermineCriticalVersion.  Individual
+// tests must invoke Initialize() with a critical version.
+class InstallerStateCriticalVersionTest : public ::testing::Test {
+ protected:
+  InstallerStateCriticalVersionTest() : cmd_line_(CommandLine::NO_PROGRAM) {}
+
+  // Creates a set of versions for use by all test runs.
+  static void SetUpTestCase() {
+    low_version_    = new Version("15.0.874.106");
+    opv_version_    = new Version("15.0.874.255");
+    middle_version_ = new Version("16.0.912.32");
+    pv_version_     = new Version("16.0.912.255");
+    high_version_   = new Version("17.0.932.0");
+  }
+
+  // Cleans up versions used by all test runs.
+  static void TearDownTestCase() {
+    delete low_version_;
+    delete opv_version_;
+    delete middle_version_;
+    delete pv_version_;
+    delete high_version_;
+  }
+
+  // Initializes the InstallerState to use for a test run.  The returned
+  // instance's critical update version is set to |version|.  |version| may be
+  // NULL, in which case the critical update version is unset.
+  MockInstallerState& Initialize(const Version* version) {
+    cmd_line_ = version == NULL ?
+        CommandLine::FromString(L"setup.exe") :
+        CommandLine::FromString(
+            L"setup.exe --critical-update-version=" +
+            ASCIIToWide(version->GetString()));
+    prefs_.reset(new MasterPreferences(cmd_line_));
+    machine_state_.Initialize();
+    installer_state_.Initialize(cmd_line_, *prefs_, machine_state_);
+    return installer_state_;
+  }
+
+  static Version* low_version_;
+  static Version* opv_version_;
+  static Version* middle_version_;
+  static Version* pv_version_;
+  static Version* high_version_;
+
+  CommandLine cmd_line_;
+  scoped_ptr<MasterPreferences> prefs_;
+  InstallationState machine_state_;
+  MockInstallerState installer_state_;
+};
+
+Version* InstallerStateCriticalVersionTest::low_version_;
+Version* InstallerStateCriticalVersionTest::opv_version_;
+Version* InstallerStateCriticalVersionTest::middle_version_;
+Version* InstallerStateCriticalVersionTest::pv_version_;
+Version* InstallerStateCriticalVersionTest::high_version_;

[Finnur, 2011/11/11 10:31:01]

= NULL; ?

[grt (UTC plus 2), 2011/11/11 11:40:08]

C++ zero-initializes these during static initialization.  NULLs added to make it
obvious.

+
+// Test the case where the critical version is less than the currently-running
+// Chrome.  The critical version is ignored since it doesn't apply.
+TEST_F(InstallerStateCriticalVersionTest, CriticalBeforeOpv) {
+  MockInstallerState& installer_state(Initialize(low_version_));
+
+  EXPECT_TRUE(installer_state.critical_update_version().Equals(*low_version_));
+  // Unable to determine the installed version, so assume critical update.
+  EXPECT_TRUE(
+      installer_state.DetermineCriticalVersion(NULL, *pv_version_).IsValid());
+  // Installed version is past the critical update.
+  EXPECT_FALSE(
+      installer_state.DetermineCriticalVersion(opv_version_, *pv_version_)
+          .IsValid());
+  // Installed version is past the critical update.
+  EXPECT_FALSE(
+      installer_state.DetermineCriticalVersion(pv_version_, *pv_version_)
+          .IsValid());
+}
+
+// Test the case where the critical version is equal to the currently-running
+// Chrome.  The critical version is ignored since it doesn't apply.
+TEST_F(InstallerStateCriticalVersionTest, CriticalEqualsOpv) {
+  MockInstallerState& installer_state(Initialize(opv_version_));
+
+  EXPECT_TRUE(installer_state.critical_update_version().Equals(*opv_version_));
+  // Unable to determine the installed version, so assume critical update.
+  EXPECT_TRUE(
+      installer_state.DetermineCriticalVersion(NULL, *pv_version_).IsValid());
+  // Installed version equals the critical update.
+  EXPECT_FALSE(
+      installer_state.DetermineCriticalVersion(opv_version_, *pv_version_)
+          .IsValid());
+  // Installed version equals the critical update.
+  EXPECT_FALSE(
+      installer_state.DetermineCriticalVersion(pv_version_, *pv_version_)
+          .IsValid());
+}
+
+// Test the case where the critical version is between the currently-running
+// Chrome and the to-be-installed Chrome.
+TEST_F(InstallerStateCriticalVersionTest, CriticalBetweenOpvAndPv) {
+  MockInstallerState& installer_state(Initialize(middle_version_));
+
+  EXPECT_TRUE(installer_state.critical_update_version().Equals(
+      *middle_version_));
+  // Unable to determine the installed version, so assume critical update.
+  EXPECT_TRUE(
+      installer_state.DetermineCriticalVersion(NULL, *pv_version_).IsValid());
+  // Installed version before the critical update.
+  EXPECT_TRUE(
+      installer_state.DetermineCriticalVersion(opv_version_, *pv_version_)
+          .IsValid());
+  // Installed version is past the critical update.
+  EXPECT_FALSE(
+      installer_state.DetermineCriticalVersion(pv_version_, *pv_version_)
+          .IsValid());
+}
+
+// Test the case where the critical version is the same as the to-be-installed
+// Chrome.
+TEST_F(InstallerStateCriticalVersionTest, CriticalEqualsPv) {
+  MockInstallerState& installer_state(Initialize(pv_version_));
+
+  EXPECT_TRUE(installer_state.critical_update_version().Equals(
+      *pv_version_));
+  // Unable to determine the installed version, so assume critical update.
+  EXPECT_TRUE(
+      installer_state.DetermineCriticalVersion(NULL, *pv_version_).IsValid());
+  // Installed version before the critical update.
+  EXPECT_TRUE(
+      installer_state.DetermineCriticalVersion(opv_version_, *pv_version_)
+          .IsValid());
+  // Installed version equals the critical update.
+  EXPECT_FALSE(
+      installer_state.DetermineCriticalVersion(pv_version_, *pv_version_)
+          .IsValid());
+}
+
+// Test the case where the critical version is greater than the to-be-installed
+// Chrome.
+TEST_F(InstallerStateCriticalVersionTest, CriticalAfterPv) {
+  MockInstallerState& installer_state(Initialize(high_version_));
+
+  EXPECT_TRUE(installer_state.critical_update_version().Equals(
+      *high_version_));
+  // 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());
+}