Write installer results in all relevant registry keys so that we're sure that Google Update will ...

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"
 #include "base/file_util.h"
 #include "base/memory/scoped_temp_dir.h"
 #include "base/path_service.h"
 #include "base/process_util.h"
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
 #include "base/version.h"
 #include "base/win/registry.h"
 #include "base/win/scoped_handle.h"
 #include "chrome/installer/util/google_update_constants.h"
 #include "chrome/installer/util/helper.h"
 #include "chrome/installer/util/installation_state.h"
 #include "chrome/installer/util/installer_state.h"
 #include "chrome/installer/util/master_preferences.h"
 #include "chrome/installer/util/product_unittest.h"
 #include "chrome/installer/util/work_item.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
+#include "installer_util_strings.h"  // NOLINT
+
+using base::win::RegKey;
+using installer::InstallationState;
+using installer::InstallerState;
+using installer::MasterPreferences;
+
 class InstallerStateTest : public TestWithTempDirAndDeleteTempOverrideKeys {
  protected:
 };
 
 // An installer state on which we can tweak the target path.
-class MockInstallerState : public installer::InstallerState {
+class MockInstallerState : public InstallerState {
  public:
   MockInstallerState() : InstallerState() { }
   void set_target_path(const FilePath& target_path) {
     target_path_ = target_path;
   }
 };
 
 // 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 FilePath& target_dir,
                             MockInstallerState* installer_state) {
   CommandLine cmd_line = CommandLine::FromString(L"setup.exe");
-  installer::MasterPreferences prefs(cmd_line);
-  installer::InstallationState machine_state;
+  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);
   EXPECT_TRUE(installer_state->FindProduct(BrowserDistribution::CHROME_FRAME)
       == NULL);
 }
 
 wchar_t text_content_1[] = L"delete me";
@@ skipping 158 matching lines @@
 
 // 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;
   CommandLine cmd_line = CommandLine::FromString(
       std::wstring(L"setup.exe") +
       (multi_install ? L" --multi-install --chrome" : L"") +
       (system_level ? L" --system-level" : L""));
-  installer::MasterPreferences prefs(cmd_line);
-  installer::InstallationState machine_state;
+  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";
 
@@ skipping 61 matching lines @@
   EXPECT_FALSE(file_util::PathExists(old_version_dir));
 }
 
 TEST_F(InstallerStateTest, WithProduct) {
   const bool multi_install = false;
   const bool system_level = true;
   CommandLine cmd_line = CommandLine::FromString(
       std::wstring(L"setup.exe") +
       (multi_install ? L" --multi-install --chrome" : L"") +
       (system_level ? L" --system-level" : L""));
-  installer::MasterPreferences prefs(cmd_line);
-  installer::InstallationState machine_state;
+  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(1U, installer_state.products().size());
   EXPECT_EQ(system_level, installer_state.system_install());
 
   const char kCurrentVersion[] = "1.2.3.4";
   scoped_ptr<Version> current_version(
       Version::GetVersionFromString(kCurrentVersion));
 
   HKEY root = system_level ? HKEY_LOCAL_MACHINE : HKEY_CURRENT_USER;
   EXPECT_EQ(root, installer_state.root_key());
   {
     TempRegKeyOverride override(root, L"root_pit");
     BrowserDistribution* dist = BrowserDistribution::GetSpecificDistribution(
         BrowserDistribution::CHROME_BROWSER);
-    base::win::RegKey chrome_key(root, dist->GetVersionKey().c_str(),
-                                 KEY_ALL_ACCESS);
+    RegKey chrome_key(root, dist->GetVersionKey().c_str(), KEY_ALL_ACCESS);
     EXPECT_TRUE(chrome_key.Valid());
     if (chrome_key.Valid()) {
       chrome_key.WriteValue(google_update::kRegVersionField,
                             UTF8ToWide(current_version->GetString()).c_str());
       machine_state.Initialize();
       // TODO(tommi): Also test for when there exists a new_chrome.exe.
       scoped_ptr<Version> found_version(installer_state.GetCurrentVersion(
           machine_state));
       EXPECT_TRUE(found_version.get() != NULL);
       if (found_version.get()) {
         EXPECT_TRUE(current_version->Equals(*found_version));
       }
     }
   }
 }
+
+TEST_F(InstallerStateTest, InstallerResult) {
+  const bool system_level = true;
+  bool multi_install = false;
+  HKEY root = system_level ? HKEY_LOCAL_MACHINE : HKEY_CURRENT_USER;
+
+  RegKey key;
+  std::wstring launch_cmd = L"hey diddle diddle";
+  std::wstring value;
+  DWORD dw_value;
+
+  // check results for a fresh install of single Chrome
+  {
+    TempRegKeyOverride override(root, L"root_inst_res");
+    CommandLine cmd_line = CommandLine::FromString(L"setup.exe --system-level");
+    const MasterPreferences prefs(cmd_line);
+    InstallationState machine_state;
+    machine_state.Initialize();
+    InstallerState state;
+    state.Initialize(cmd_line, prefs, machine_state);
+    state.WriteInstallerResult(installer::FIRST_INSTALL_SUCCESS,
+                               IDS_INSTALL_OS_ERROR_BASE, &launch_cmd);
+    BrowserDistribution* distribution =
+        BrowserDistribution::GetSpecificDistribution(
+            BrowserDistribution::CHROME_BROWSER);
+    EXPECT_EQ(ERROR_SUCCESS,
+        key.Open(root, distribution->GetStateKey().c_str(), KEY_READ));
+    EXPECT_EQ(ERROR_SUCCESS,
+        key.ReadValueDW(installer::kInstallerResult, &dw_value));
+    EXPECT_EQ(static_cast<DWORD>(0), dw_value);
+    EXPECT_EQ(ERROR_SUCCESS,
+        key.ReadValueDW(installer::kInstallerError, &dw_value));
+    EXPECT_EQ(static_cast<DWORD>(installer::FIRST_INSTALL_SUCCESS), dw_value);
+    EXPECT_EQ(ERROR_SUCCESS,
+        key.ReadValue(installer::kInstallerResultUIString, &value));
+    EXPECT_FALSE(value.empty());
+    EXPECT_EQ(ERROR_SUCCESS,
+        key.ReadValue(installer::kInstallerSuccessLaunchCmdLine, &value));
+    EXPECT_EQ(launch_cmd, value);
+  }
+  TempRegKeyOverride::DeleteAllTempKeys();
+
+  // check results for a fresh install of multi Chrome
+  {
+    TempRegKeyOverride override(root, L"root_inst_res");
+    CommandLine cmd_line = CommandLine::FromString(
+        L"setup.exe --system-level --multi-install --chrome");
+    const MasterPreferences prefs(cmd_line);
+    InstallationState machine_state;
+    machine_state.Initialize();
+    InstallerState state;
+    state.Initialize(cmd_line, prefs, machine_state);
+    state.WriteInstallerResult(installer::FIRST_INSTALL_SUCCESS, 0,
+                               &launch_cmd);
+    BrowserDistribution* distribution =
+        BrowserDistribution::GetSpecificDistribution(
+            BrowserDistribution::CHROME_BROWSER);
+    BrowserDistribution* binaries =
+        BrowserDistribution::GetSpecificDistribution(
+            BrowserDistribution::CHROME_BINARIES);
+    EXPECT_EQ(ERROR_SUCCESS,
+        key.Open(root, distribution->GetStateKey().c_str(), KEY_READ));
+    EXPECT_EQ(ERROR_SUCCESS,
+        key.ReadValue(installer::kInstallerSuccessLaunchCmdLine, &value));
+    EXPECT_EQ(launch_cmd, value);
+    EXPECT_EQ(ERROR_SUCCESS,
+        key.Open(root, binaries->GetStateKey().c_str(), KEY_READ));
+    EXPECT_EQ(ERROR_SUCCESS,
+        key.ReadValue(installer::kInstallerSuccessLaunchCmdLine, &value));
+    EXPECT_EQ(launch_cmd, value);
+    key.Close();
+  }
+  TempRegKeyOverride::DeleteAllTempKeys();
+}