chrome/installer/util/product_state_unittest.cc

   1 // Copyright (c) 2011 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 "base/strings/utf_string_conversions.h"
   8 #include "base/test/test_reg_util_win.h"
   9 #include "base/version.h"
  10 #include "base/win/registry.h"
  11 #include "chrome/installer/util/browser_distribution.h"
  12 #include "chrome/installer/util/google_update_constants.h"
  13 #include "chrome/installer/util/installation_state.h"
  14 #include "chrome/installer/util/product_unittest.h"
  15 #include "chrome/installer/util/util_constants.h"
  16 #include "testing/gtest/include/gtest/gtest.h"
  17
  18 using base::win::RegKey;
  19 using installer::ProductState;
  20 using registry_util::RegistryOverrideManager;
  21
  22 class ProductStateTest : public testing::Test {
  23  protected:
  24   static void SetUpTestCase();
  25   static void TearDownTestCase();
  26
  27   virtual void SetUp();
  28   virtual void TearDown();
  29
  30   void ApplyUninstallCommand(const wchar_t* exe_path, const wchar_t* args);
  31   void MinimallyInstallProduct(const wchar_t* version);
  32
  33   static BrowserDistribution* dist_;
  34   bool system_install_;
  35   HKEY overridden_;
  36   registry_util::RegistryOverrideManager registry_override_manager_;
  37   RegKey clients_;
  38   RegKey client_state_;
  39 };
  40
  41 BrowserDistribution* ProductStateTest::dist_;
  42
  43 // static
  44 void ProductStateTest::SetUpTestCase() {
  45   testing::Test::SetUpTestCase();
  46
  47   // We'll use Chrome as our test subject.
  48   dist_ = BrowserDistribution::GetSpecificDistribution(
  49       BrowserDistribution::CHROME_BROWSER);
  50 }
  51
  52 // static
  53 void ProductStateTest::TearDownTestCase() {
  54   dist_ = NULL;
  55
  56   testing::Test::TearDownTestCase();
  57 }
  58
  59 void ProductStateTest::SetUp() {
  60   testing::Test::SetUp();
  61
  62   // Create/open the keys for the product we'll test.
  63   system_install_ = true;
  64   overridden_ = (system_install_ ? HKEY_LOCAL_MACHINE : HKEY_CURRENT_USER);
  65
  66   // Override for test purposes.  We don't use ScopedRegistryKeyOverride
  67   // directly because it doesn't suit itself to our use here.
  68   RegKey temp_key;
  69
  70   registry_override_manager_.OverrideRegistry(overridden_);
  71
  72   EXPECT_EQ(ERROR_SUCCESS,
  73             clients_.Create(overridden_, dist_->GetVersionKey().c_str(),
  74                             KEY_ALL_ACCESS));
  75   EXPECT_EQ(ERROR_SUCCESS,
  76             client_state_.Create(overridden_, dist_->GetStateKey().c_str(),
  77                                  KEY_ALL_ACCESS));
  78 }
  79
  80 void ProductStateTest::TearDown() {
  81   // Done with the keys.
  82   client_state_.Close();
  83   clients_.Close();
  84   overridden_ = NULL;
  85   system_install_ = false;
  86
  87   testing::Test::TearDown();
  88 }
  89
  90 void ProductStateTest::MinimallyInstallProduct(const wchar_t* version) {
  91   EXPECT_EQ(ERROR_SUCCESS,
  92             clients_.WriteValue(google_update::kRegVersionField, version));
  93 }
  94
  95 void ProductStateTest::ApplyUninstallCommand(const wchar_t* exe_path,
  96                                              const wchar_t* args) {
  97   if (exe_path == NULL) {
  98     LONG result = client_state_.DeleteValue(installer::kUninstallStringField);
  99     EXPECT_TRUE(result == ERROR_SUCCESS || result == ERROR_FILE_NOT_FOUND);
 100   } else {
 101     EXPECT_EQ(ERROR_SUCCESS,
 102               client_state_.WriteValue(installer::kUninstallStringField,
 103                                        exe_path));
 104   }
 105
 106   if (args == NULL) {
 107     LONG result =
 108         client_state_.DeleteValue(installer::kUninstallArgumentsField);
 109     EXPECT_TRUE(result == ERROR_SUCCESS || result == ERROR_FILE_NOT_FOUND);
 110   } else {
 111     EXPECT_EQ(ERROR_SUCCESS,
 112               client_state_.WriteValue(installer::kUninstallArgumentsField,
 113                                        args));
 114   }
 115 }
 116
 117 TEST_F(ProductStateTest, InitializeInstalled) {
 118   // Not installed.
 119   {
 120     ProductState state;
 121     LONG result = clients_.DeleteValue(google_update::kRegVersionField);
 122     EXPECT_TRUE(result == ERROR_SUCCESS || result == ERROR_FILE_NOT_FOUND);
 123     EXPECT_FALSE(state.Initialize(system_install_, dist_));
 124   }
 125
 126   // Empty version.
 127   {
 128     ProductState state;
 129     LONG result = clients_.WriteValue(google_update::kRegVersionField, L"");
 130     EXPECT_TRUE(result == ERROR_SUCCESS || result == ERROR_FILE_NOT_FOUND);
 131     EXPECT_FALSE(state.Initialize(system_install_, dist_));
 132   }
 133
 134   // Bogus version.
 135   {
 136     ProductState state;
 137     LONG result = clients_.WriteValue(google_update::kRegVersionField,
 138                                       L"goofy");
 139     EXPECT_TRUE(result == ERROR_SUCCESS || result == ERROR_FILE_NOT_FOUND);
 140     EXPECT_FALSE(state.Initialize(system_install_, dist_));
 141   }
 142
 143   // Valid "pv" value.
 144   {
 145     ProductState state;
 146     LONG result = clients_.WriteValue(google_update::kRegVersionField,
 147                                       L"10.0.47.0");
 148     EXPECT_TRUE(result == ERROR_SUCCESS || result == ERROR_FILE_NOT_FOUND);
 149     EXPECT_TRUE(state.Initialize(system_install_, dist_));
 150     EXPECT_EQ("10.0.47.0", state.version().GetString());
 151   }
 152 }
 153
 154 // Test extraction of the "opv" value from the Clients key.
 155 TEST_F(ProductStateTest, InitializeOldVersion) {
 156   MinimallyInstallProduct(L"10.0.1.1");
 157
 158   // No "opv" value.
 159   {
 160     ProductState state;
 161     LONG result = clients_.DeleteValue(google_update::kRegOldVersionField);
 162     EXPECT_TRUE(result == ERROR_SUCCESS || result == ERROR_FILE_NOT_FOUND);
 163     EXPECT_TRUE(state.Initialize(system_install_, dist_));
 164     EXPECT_TRUE(state.old_version() == NULL);
 165   }
 166
 167   // Empty "opv" value.
 168   {
 169     ProductState state;
 170     LONG result = clients_.WriteValue(google_update::kRegOldVersionField, L"");
 171     EXPECT_TRUE(result == ERROR_SUCCESS || result == ERROR_FILE_NOT_FOUND);
 172     EXPECT_TRUE(state.Initialize(system_install_, dist_));
 173     EXPECT_TRUE(state.old_version() == NULL);
 174   }
 175
 176   // Bogus "opv" value.
 177   {
 178     ProductState state;
 179     LONG result = clients_.WriteValue(google_update::kRegOldVersionField,
 180                                       L"coming home");
 181     EXPECT_TRUE(result == ERROR_SUCCESS || result == ERROR_FILE_NOT_FOUND);
 182     EXPECT_TRUE(state.Initialize(system_install_, dist_));
 183     EXPECT_TRUE(state.old_version() == NULL);
 184   }
 185
 186   // Valid "opv" value.
 187   {
 188     ProductState state;
 189     LONG result = clients_.WriteValue(google_update::kRegOldVersionField,
 190                                       L"10.0.47.0");
 191     EXPECT_TRUE(result == ERROR_SUCCESS || result == ERROR_FILE_NOT_FOUND);
 192     EXPECT_TRUE(state.Initialize(system_install_, dist_));
 193     EXPECT_TRUE(state.old_version() != NULL);
 194     EXPECT_EQ("10.0.47.0", state.old_version()->GetString());
 195   }
 196 }
 197
 198 // Test extraction of the "cmd" value from the Clients key.
 199 TEST_F(ProductStateTest, InitializeRenameCmd) {
 200   MinimallyInstallProduct(L"10.0.1.1");
 201
 202   // No "cmd" value.
 203   {
 204     ProductState state;
 205     LONG result = clients_.DeleteValue(google_update::kRegRenameCmdField);
 206     EXPECT_TRUE(result == ERROR_SUCCESS || result == ERROR_FILE_NOT_FOUND);
 207     EXPECT_TRUE(state.Initialize(system_install_, dist_));
 208     EXPECT_TRUE(state.rename_cmd().empty());
 209   }
 210
 211   // Empty "cmd" value.
 212   {
 213     ProductState state;
 214     LONG result = clients_.WriteValue(google_update::kRegRenameCmdField, L"");
 215     EXPECT_TRUE(result == ERROR_SUCCESS || result == ERROR_FILE_NOT_FOUND);
 216     EXPECT_TRUE(state.Initialize(system_install_, dist_));
 217     EXPECT_TRUE(state.rename_cmd().empty());
 218   }
 219
 220   // Valid "cmd" value.
 221   {
 222     ProductState state;
 223     LONG result = clients_.WriteValue(google_update::kRegRenameCmdField,
 224                                       L"spam.exe --spamalot");
 225     EXPECT_TRUE(result == ERROR_SUCCESS || result == ERROR_FILE_NOT_FOUND);
 226     EXPECT_TRUE(state.Initialize(system_install_, dist_));
 227     EXPECT_EQ(L"spam.exe --spamalot", state.rename_cmd());
 228   }
 229 }
 230
 231 // Test extraction of the "ap" value from the ClientState key.
 232 TEST_F(ProductStateTest, InitializeChannelInfo) {
 233   MinimallyInstallProduct(L"10.0.1.1");
 234
 235   // No "ap" value.
 236   {
 237     ProductState state;
 238     LONG result = client_state_.DeleteValue(google_update::kRegApField);
 239     EXPECT_TRUE(result == ERROR_SUCCESS || result == ERROR_FILE_NOT_FOUND);
 240     EXPECT_TRUE(state.Initialize(system_install_, dist_));
 241     EXPECT_TRUE(state.channel().value().empty());
 242   }
 243
 244   // Empty "ap" value.
 245   {
 246     ProductState state;
 247     LONG result = client_state_.WriteValue(google_update::kRegApField, L"");
 248     EXPECT_TRUE(result == ERROR_SUCCESS || result == ERROR_FILE_NOT_FOUND);
 249     EXPECT_TRUE(state.Initialize(system_install_, dist_));
 250     EXPECT_TRUE(state.channel().value().empty());
 251   }
 252
 253   // Valid "ap" value.
 254   {
 255     ProductState state;
 256     LONG result = client_state_.WriteValue(google_update::kRegApField, L"spam");
 257     EXPECT_TRUE(result == ERROR_SUCCESS || result == ERROR_FILE_NOT_FOUND);
 258     EXPECT_TRUE(state.Initialize(system_install_, dist_));
 259     EXPECT_EQ(L"spam", state.channel().value());
 260   }
 261 }
 262
 263 // Test extraction of the uninstall command and arguments from the ClientState
 264 // key.
 265 TEST_F(ProductStateTest, InitializeUninstallCommand) {
 266   MinimallyInstallProduct(L"10.0.1.1");
 267
 268   // No uninstall command.
 269   {
 270     ProductState state;
 271     ApplyUninstallCommand(NULL, NULL);
 272     EXPECT_TRUE(state.Initialize(system_install_, dist_));
 273     EXPECT_TRUE(state.GetSetupPath().empty());
 274     EXPECT_TRUE(state.uninstall_command().GetCommandLineString().empty());
 275     EXPECT_TRUE(state.uninstall_command().GetSwitches().empty());
 276   }
 277
 278   // Empty values.
 279   {
 280     ProductState state;
 281     ApplyUninstallCommand(L"", L"");
 282     EXPECT_TRUE(state.Initialize(system_install_, dist_));
 283     EXPECT_TRUE(state.GetSetupPath().empty());
 284     EXPECT_TRUE(state.uninstall_command().GetCommandLineString().empty());
 285     EXPECT_TRUE(state.uninstall_command().GetSwitches().empty());
 286   }
 287
 288   // Uninstall command without exe.
 289   {
 290     ProductState state;
 291     ApplyUninstallCommand(NULL, L"--uninstall");
 292     EXPECT_TRUE(state.Initialize(system_install_, dist_));
 293     EXPECT_TRUE(state.GetSetupPath().empty());
 294     EXPECT_EQ(L" --uninstall",
 295               state.uninstall_command().GetCommandLineString());
 296     EXPECT_EQ(1U, state.uninstall_command().GetSwitches().size());
 297   }
 298
 299   // Uninstall command without args.
 300   {
 301     ProductState state;
 302     ApplyUninstallCommand(L"setup.exe", NULL);
 303     EXPECT_TRUE(state.Initialize(system_install_, dist_));
 304     EXPECT_EQ(L"setup.exe", state.GetSetupPath().value());
 305     EXPECT_EQ(L"setup.exe", state.uninstall_command().GetCommandLineString());
 306     EXPECT_TRUE(state.uninstall_command().GetSwitches().empty());
 307   }
 308
 309   // Uninstall command with exe that requires quoting.
 310   {
 311     ProductState state;
 312     ApplyUninstallCommand(L"set up.exe", NULL);
 313     EXPECT_TRUE(state.Initialize(system_install_, dist_));
 314     EXPECT_EQ(L"set up.exe", state.GetSetupPath().value());
 315     EXPECT_EQ(L"\"set up.exe\"",
 316               state.uninstall_command().GetCommandLineString());
 317     EXPECT_TRUE(state.uninstall_command().GetSwitches().empty());
 318   }
 319
 320   // Uninstall command with both exe and args.
 321   {
 322     ProductState state;
 323     ApplyUninstallCommand(L"setup.exe", L"--uninstall");
 324     EXPECT_TRUE(state.Initialize(system_install_, dist_));
 325     EXPECT_EQ(L"setup.exe", state.GetSetupPath().value());
 326     EXPECT_EQ(L"setup.exe --uninstall",
 327               state.uninstall_command().GetCommandLineString());
 328     EXPECT_EQ(1U, state.uninstall_command().GetSwitches().size());
 329   }
 330 }
 331
 332 // Test extraction of the msi marker from the ClientState key.
 333 TEST_F(ProductStateTest, InitializeMsi) {
 334   MinimallyInstallProduct(L"10.0.1.1");
 335
 336   // No msi marker.
 337   {
 338     ProductState state;
 339     LONG result = client_state_.DeleteValue(google_update::kRegMSIField);
 340     EXPECT_TRUE(result == ERROR_SUCCESS || result == ERROR_FILE_NOT_FOUND);
 341     EXPECT_TRUE(state.Initialize(system_install_, dist_));
 342     EXPECT_FALSE(state.is_msi());
 343   }
 344
 345   // Msi marker set to zero.
 346   {
 347     ProductState state;
 348     EXPECT_EQ(ERROR_SUCCESS,
 349               client_state_.WriteValue(google_update::kRegMSIField,
 350                                        static_cast<DWORD>(0)));
 351     EXPECT_TRUE(state.Initialize(system_install_, dist_));
 352     EXPECT_FALSE(state.is_msi());
 353   }
 354
 355   // Msi marker set to one.
 356   {
 357     ProductState state;
 358     EXPECT_EQ(ERROR_SUCCESS,
 359               client_state_.WriteValue(google_update::kRegMSIField,
 360                                        static_cast<DWORD>(1)));
 361     EXPECT_TRUE(state.Initialize(system_install_, dist_));
 362     EXPECT_TRUE(state.is_msi());
 363   }
 364
 365   // Msi marker set to a bogus DWORD.
 366   {
 367     ProductState state;
 368     EXPECT_EQ(ERROR_SUCCESS,
 369               client_state_.WriteValue(google_update::kRegMSIField,
 370                                        static_cast<DWORD>(47)));
 371     EXPECT_TRUE(state.Initialize(system_install_, dist_));
 372     EXPECT_TRUE(state.is_msi());
 373   }
 374
 375   // Msi marker set to a bogus string.
 376   {
 377     ProductState state;
 378     EXPECT_EQ(ERROR_SUCCESS,
 379               client_state_.WriteValue(google_update::kRegMSIField,
 380                                        L"bogus!"));
 381     EXPECT_TRUE(state.Initialize(system_install_, dist_));
 382     EXPECT_FALSE(state.is_msi());
 383   }
 384 }
 385
 386 // Test detection of multi-install.
 387 TEST_F(ProductStateTest, InitializeMultiInstall) {
 388   MinimallyInstallProduct(L"10.0.1.1");
 389
 390   // No uninstall command means single install.
 391   {
 392     ProductState state;
 393     ApplyUninstallCommand(NULL, NULL);
 394     EXPECT_TRUE(state.Initialize(system_install_, dist_));
 395     EXPECT_FALSE(state.is_multi_install());
 396   }
 397
 398   // Uninstall command without --multi-install is single install.
 399   {
 400     ProductState state;
 401     ApplyUninstallCommand(L"setup.exe", L"--uninstall");
 402     EXPECT_TRUE(state.Initialize(system_install_, dist_));
 403     EXPECT_FALSE(state.is_multi_install());
 404   }
 405
 406   // Uninstall command with --multi-install is multi install.
 407   {
 408     ProductState state;
 409     ApplyUninstallCommand(L"setup.exe",
 410                           L"--uninstall --chrome --multi-install");
 411     EXPECT_TRUE(state.Initialize(system_install_, dist_));
 412     EXPECT_TRUE(state.is_multi_install());
 413   }
 414 }