gcapi_reactivation_test.cc revision 7d4cd473f85ac64c3747c96c277f9e506a0d2246
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 <string> 6 7#include "base/basictypes.h" 8#include "base/guid.h" 9#include "base/strings/string_number_conversions.h" 10#include "base/strings/stringprintf.h" 11#include "base/strings/utf_string_conversions.h" 12#include "base/test/test_reg_util_win.h" 13#include "base/time.h" 14#include "base/win/registry.h" 15#include "chrome/installer/gcapi/gcapi.h" 16#include "chrome/installer/gcapi/gcapi_omaha_experiment.h" 17#include "chrome/installer/gcapi/gcapi_reactivation.h" 18#include "chrome/installer/util/google_update_constants.h" 19#include "testing/gtest/include/gtest/gtest.h" 20 21using base::Time; 22using base::TimeDelta; 23using base::win::RegKey; 24 25namespace { 26 27const wchar_t kExperimentLabels[] = L"experiment_labels"; 28 29const wchar_t* kExperimentAppGuids[] = { 30 L"{4DC8B4CA-1BDA-483e-B5FA-D3C12E15B62D}", 31 L"{8A69D345-D564-463C-AFF1-A69D9E530F96}", 32}; 33 34} 35 36class GCAPIReactivationTest : public ::testing::Test { 37 protected: 38 void SetUp() { 39 // Override keys - this is undone during destruction. 40 std::wstring hkcu_override = base::StringPrintf( 41 L"hkcu_override\\%ls", ASCIIToWide(base::GenerateGUID())); 42 override_manager_.OverrideRegistry(HKEY_CURRENT_USER, hkcu_override); 43 std::wstring hklm_override = base::StringPrintf( 44 L"hklm_override\\%ls", ASCIIToWide(base::GenerateGUID())); 45 override_manager_.OverrideRegistry(HKEY_LOCAL_MACHINE, hklm_override); 46 } 47 48 bool SetChromeInstallMarker(HKEY hive) { 49 // Create the client state keys in the right places. 50 std::wstring reg_path(google_update::kRegPathClients); 51 reg_path += L"\\"; 52 reg_path += google_update::kChromeUpgradeCode; 53 RegKey client_state(hive, 54 reg_path.c_str(), 55 KEY_CREATE_SUB_KEY | KEY_SET_VALUE); 56 return (client_state.Valid() && 57 client_state.WriteValue( 58 google_update::kRegVersionField, L"1.2.3.4") == ERROR_SUCCESS); 59 } 60 61 bool SetLastRunTime(HKEY hive, int64 last_run_time) { 62 return SetLastRunTimeString(hive, base::Int64ToString16(last_run_time)); 63 } 64 65 bool SetLastRunTimeString(HKEY hive, const string16& last_run_time_string) { 66 const wchar_t* base_path = 67 (hive == HKEY_LOCAL_MACHINE) ? 68 google_update::kRegPathClientStateMedium : 69 google_update::kRegPathClientState; 70 std::wstring path(base_path); 71 path += L"\\"; 72 path += google_update::kChromeUpgradeCode; 73 74 RegKey client_state(hive, path.c_str(), KEY_SET_VALUE); 75 return (client_state.Valid() && 76 client_state.WriteValue( 77 google_update::kRegLastRunTimeField, 78 last_run_time_string.c_str()) == ERROR_SUCCESS); 79 } 80 81 bool HasExperimentLabels(HKEY hive) { 82 int label_count = 0; 83 for (int i = 0; i < arraysize(kExperimentAppGuids); ++i) { 84 string16 client_state_path(google_update::kRegPathClientState); 85 client_state_path += L"\\"; 86 client_state_path += kExperimentAppGuids[i]; 87 88 RegKey client_state_key(hive, 89 client_state_path.c_str(), 90 KEY_QUERY_VALUE); 91 if (client_state_key.Valid() && 92 client_state_key.HasValue(kExperimentLabels)) { 93 label_count++; 94 } 95 } 96 return label_count == arraysize(kExperimentAppGuids); 97 } 98 99 std::wstring GetReactivationString(HKEY hive) { 100 const wchar_t* base_path = 101 (hive == HKEY_LOCAL_MACHINE) ? 102 google_update::kRegPathClientStateMedium : 103 google_update::kRegPathClientState; 104 std::wstring path(base_path); 105 path += L"\\"; 106 path += google_update::kChromeUpgradeCode; 107 108 RegKey client_state(hive, path.c_str(), KEY_QUERY_VALUE); 109 if (client_state.Valid()) { 110 std::wstring actual_brand; 111 if (client_state.ReadValue(google_update::kRegRLZReactivationBrandField, 112 &actual_brand) == ERROR_SUCCESS) { 113 return actual_brand; 114 } 115 } 116 117 return L"ERROR"; 118 } 119 120 private: 121 registry_util::RegistryOverrideManager override_manager_; 122}; 123 124TEST_F(GCAPIReactivationTest, CheckSetReactivationBrandCode) { 125 EXPECT_TRUE(SetReactivationBrandCode(L"GAGA", GCAPI_INVOKED_STANDARD_SHELL)); 126 EXPECT_EQ(L"GAGA", GetReactivationString(HKEY_CURRENT_USER)); 127 128 EXPECT_TRUE(HasBeenReactivated()); 129 130} 131 132TEST_F(GCAPIReactivationTest, CanOfferReactivation_Basic) { 133 DWORD error; 134 135 // We're not installed yet. Make sure CanOfferReactivation fails. 136 EXPECT_FALSE(CanOfferReactivation(L"GAGA", 137 GCAPI_INVOKED_STANDARD_SHELL, 138 &error)); 139 EXPECT_EQ(REACTIVATE_ERROR_NOTINSTALLED, error); 140 141 // Now pretend to be installed. CanOfferReactivation should pass. 142 EXPECT_TRUE(SetChromeInstallMarker(HKEY_CURRENT_USER)); 143 EXPECT_TRUE(CanOfferReactivation(L"GAGA", 144 GCAPI_INVOKED_STANDARD_SHELL, 145 &error)); 146 147 // Now set a recent last_run value. CanOfferReactivation should fail again. 148 Time hkcu_last_run = Time::NowFromSystemTime() - TimeDelta::FromDays(20); 149 EXPECT_TRUE(SetLastRunTime(HKEY_CURRENT_USER, 150 hkcu_last_run.ToInternalValue())); 151 EXPECT_FALSE(CanOfferReactivation(L"GAGA", 152 GCAPI_INVOKED_STANDARD_SHELL, 153 &error)); 154 EXPECT_EQ(REACTIVATE_ERROR_NOTDORMANT, error); 155 156 // Now set a last_run value that exceeds the threshold. 157 hkcu_last_run = Time::NowFromSystemTime() - 158 TimeDelta::FromDays(kReactivationMinDaysDormant); 159 EXPECT_TRUE(SetLastRunTime(HKEY_CURRENT_USER, 160 hkcu_last_run.ToInternalValue())); 161 EXPECT_TRUE(CanOfferReactivation(L"GAGA", 162 GCAPI_INVOKED_STANDARD_SHELL, 163 &error)); 164 165 // Test some invalid inputs 166 EXPECT_FALSE(CanOfferReactivation(NULL, 167 GCAPI_INVOKED_STANDARD_SHELL, 168 &error)); 169 EXPECT_EQ(REACTIVATE_ERROR_INVALID_INPUT, error); 170 171 // One more valid one 172 EXPECT_TRUE(CanOfferReactivation(L"GAGA", 173 GCAPI_INVOKED_STANDARD_SHELL, 174 &error)); 175 176 // Check that the previous brands check works: 177 EXPECT_TRUE(SetReactivationBrandCode(L"GOOGOO", 178 GCAPI_INVOKED_STANDARD_SHELL)); 179 EXPECT_FALSE(CanOfferReactivation(L"GAGA", 180 GCAPI_INVOKED_STANDARD_SHELL, 181 &error)); 182 EXPECT_EQ(REACTIVATE_ERROR_ALREADY_REACTIVATED, error); 183} 184 185TEST_F(GCAPIReactivationTest, Reactivation_Flow) { 186 DWORD error; 187 188 // Set us up as a candidate for reactivation. 189 EXPECT_TRUE(SetChromeInstallMarker(HKEY_CURRENT_USER)); 190 191 Time hkcu_last_run = Time::NowFromSystemTime() - 192 TimeDelta::FromDays(kReactivationMinDaysDormant); 193 EXPECT_TRUE(SetLastRunTime(HKEY_CURRENT_USER, 194 hkcu_last_run.ToInternalValue())); 195 196 EXPECT_TRUE(ReactivateChrome(L"GAGA", 197 GCAPI_INVOKED_STANDARD_SHELL, 198 &error)); 199 EXPECT_EQ(L"GAGA", GetReactivationString(HKEY_CURRENT_USER)); 200 201 // Make sure we can't reactivate again: 202 EXPECT_FALSE(ReactivateChrome(L"GAGA", 203 GCAPI_INVOKED_STANDARD_SHELL, 204 &error)); 205 EXPECT_EQ(REACTIVATE_ERROR_ALREADY_REACTIVATED, error); 206 207 // Should not be able to reactivate under other brands: 208 EXPECT_FALSE(ReactivateChrome(L"MAMA", 209 GCAPI_INVOKED_STANDARD_SHELL, 210 &error)); 211 EXPECT_EQ(L"GAGA", GetReactivationString(HKEY_CURRENT_USER)); 212 213 // Validate that previous_brands are rejected: 214 EXPECT_FALSE(ReactivateChrome(L"PFFT", 215 GCAPI_INVOKED_STANDARD_SHELL, 216 &error)); 217 EXPECT_EQ(REACTIVATE_ERROR_ALREADY_REACTIVATED, error); 218 EXPECT_EQ(L"GAGA", GetReactivationString(HKEY_CURRENT_USER)); 219} 220 221TEST_F(GCAPIReactivationTest, ExperimentLabelCheck) { 222 DWORD error; 223 224 // Set us up as a candidate for reactivation. 225 EXPECT_TRUE(SetChromeInstallMarker(HKEY_CURRENT_USER)); 226 227 Time hkcu_last_run = Time::NowFromSystemTime() - 228 TimeDelta::FromDays(kReactivationMinDaysDormant); 229 EXPECT_TRUE(SetLastRunTime(HKEY_CURRENT_USER, 230 hkcu_last_run.ToInternalValue())); 231 232 EXPECT_TRUE(ReactivateChrome(L"GAGA", 233 GCAPI_INVOKED_STANDARD_SHELL, 234 &error)); 235 EXPECT_EQ(L"GAGA", GetReactivationString(HKEY_CURRENT_USER)); 236 237 EXPECT_TRUE(HasExperimentLabels(HKEY_CURRENT_USER)); 238} 239