| OLD | NEW |
|---|
| (Empty) |
| 1 #!/usr/bin/env python | |
| 2 # Copyright (c) 2012 The Chromium Authors. All rights reserved. | |
| 3 # Use of this source code is governed by a BSD-style license that can be | |
| 4 # found in the LICENSE file. | |
| 5 | |
| 6 import pyauto_functional # Must be imported first | |
| 7 import pyauto | |
| 8 import test_utils | |
| 9 | |
| 10 import json | |
| 11 import logging | |
| 12 import os | |
| 13 | |
| 14 | |
| 15 class BaseProtectorTest(pyauto.PyUITest): | |
| 16 """Base class for Protector test cases.""" | |
| 17 | |
| 18 _DEFAULT_SEARCH_ID_KEY = 'Default Search Provider ID' | |
| 19 | |
| 20 # Possible values for session.restore_on_startup pref: | |
| 21 _SESSION_STARTUP_HOMEPAGE = 0 # For migration testing only. | |
| 22 _SESSION_STARTUP_LAST = 1 | |
| 23 _SESSION_STARTUP_URLS = 4 | |
| 24 _SESSION_STARTUP_NTP = 5 | |
| 25 | |
| 26 def setUp(self): | |
| 27 pyauto.PyUITest.setUp(self) | |
| 28 # Get the profile path of the first profile. | |
| 29 profiles = self.GetMultiProfileInfo() | |
| 30 self.assertTrue(profiles['profiles']) | |
| 31 self._profile_path = profiles['profiles'][0]['path'] | |
| 32 self.assertTrue(self._profile_path) | |
| 33 # Set to the keyword of the new default search engine after a successful | |
| 34 # _GetDefaultSearchEngine call. | |
| 35 self._new_default_search_keyword = None | |
| 36 | |
| 37 def _IsEnabled(self): | |
| 38 """Whether protector should be enabled for the test suite.""" | |
| 39 return True | |
| 40 | |
| 41 def ExtraChromeFlags(self): | |
| 42 """Adds required Protector-related flags. | |
| 43 | |
| 44 Returns: | |
| 45 A list of extra flags to pass to Chrome when it is launched. | |
| 46 """ | |
| 47 return super(BaseProtectorTest, self).ExtraChromeFlags() + [ | |
| 48 '--protector' if self._IsEnabled() else '--no-protector' | |
| 49 ] | |
| 50 | |
| 51 def _GetDefaultSearchEngine(self): | |
| 52 """Returns the default search engine, if any; None otherwise. | |
| 53 | |
| 54 Returns: | |
| 55 Dictionary describing the default search engine. See GetSearchEngineInfo | |
| 56 for an example. | |
| 57 """ | |
| 58 for search_engine in self.GetSearchEngineInfo(): | |
| 59 if search_engine['is_default']: | |
| 60 return search_engine | |
| 61 return None | |
| 62 | |
| 63 def _OpenDatabase(self, db_name): | |
| 64 """Opens a given SQLite database in the default profile. | |
| 65 | |
| 66 Args: | |
| 67 db_name: name of database file (relative to the profile directory). | |
| 68 | |
| 69 Returns: | |
| 70 An sqlite3.Connection instance. | |
| 71 | |
| 72 Raises: | |
| 73 ImportError if sqlite3 module is not found. | |
| 74 """ | |
| 75 db_path = os.path.join(self._profile_path, db_name) | |
| 76 logging.info('Opening DB: %s' % db_path) | |
| 77 import sqlite3 | |
| 78 db_conn = sqlite3.connect(db_path) | |
| 79 db_conn.isolation_level = None | |
| 80 self.assertTrue(db_conn) | |
| 81 return db_conn | |
| 82 | |
| 83 def _FetchSingleValue(self, conn, query, parameters=None): | |
| 84 """Executes an SQL query that should select a single row with a single | |
| 85 column and returns its value. | |
| 86 | |
| 87 Args: | |
| 88 conn: sqlite3.Connection instance. | |
| 89 query: SQL query (may contain placeholders). | |
| 90 parameters: parameters to substitute for query. | |
| 91 | |
| 92 Returns: | |
| 93 Value of the column fetched. | |
| 94 """ | |
| 95 cursor = conn.cursor() | |
| 96 cursor.execute(query, parameters) | |
| 97 row = cursor.fetchone() | |
| 98 self.assertTrue(row) | |
| 99 self.assertEqual(1, len(row)) | |
| 100 return row[0] | |
| 101 | |
| 102 def _UpdateSingleRow(self, conn, query, parameters=None): | |
| 103 """Executes an SQL query that should update a single row. | |
| 104 | |
| 105 Args: | |
| 106 conn: sqlite3.Connection instance. | |
| 107 query: SQL query (may contain placeholders). | |
| 108 parameters: parameters to substitute for query. | |
| 109 """ | |
| 110 cursor = conn.cursor() | |
| 111 cursor.execute(query, parameters) | |
| 112 self.assertEqual(1, cursor.rowcount) | |
| 113 | |
| 114 def _ChangeDefaultSearchEngine(self): | |
| 115 """Replaces the default search engine in Web Data database with another one. | |
| 116 | |
| 117 Keywords of the new default search engine is saved to | |
| 118 self._new_default_search_keyword. | |
| 119 """ | |
| 120 web_database = self._OpenDatabase('Web Data') | |
| 121 default_id = int(self._FetchSingleValue( | |
| 122 web_database, | |
| 123 'SELECT value FROM meta WHERE key = ?', | |
| 124 (self._DEFAULT_SEARCH_ID_KEY,))) | |
| 125 self.assertTrue(default_id) | |
| 126 new_default_id = int(self._FetchSingleValue( | |
| 127 web_database, | |
| 128 'SELECT id FROM keywords WHERE id != ? LIMIT 1', | |
| 129 (default_id,))) | |
| 130 self.assertTrue(new_default_id) | |
| 131 self.assertNotEqual(default_id, new_default_id) | |
| 132 self._UpdateSingleRow(web_database, | |
| 133 'UPDATE meta SET value = ? WHERE key = ?', | |
| 134 (new_default_id, self._DEFAULT_SEARCH_ID_KEY)) | |
| 135 self._new_default_search_keyword = self._FetchSingleValue( | |
| 136 web_database, | |
| 137 'SELECT keyword FROM keywords WHERE id = ?', | |
| 138 (new_default_id,)) | |
| 139 logging.info('Update default search ID: %d -> %d (%s)' % | |
| 140 (default_id, new_default_id, self._new_default_search_keyword)) | |
| 141 web_database.close() | |
| 142 | |
| 143 def _LoadPreferences(self): | |
| 144 """Reads the contents of Preferences file. | |
| 145 | |
| 146 Returns: dict() with user preferences as returned by PrefsInfo.Prefs(). | |
| 147 """ | |
| 148 prefs_path = os.path.join(self._profile_path, 'Preferences') | |
| 149 logging.info('Opening prefs: %s' % prefs_path) | |
| 150 with open(prefs_path) as f: | |
| 151 return json.load(f) | |
| 152 | |
| 153 def _WritePreferences(self, prefs): | |
| 154 """Writes new contents to the Preferences file. | |
| 155 | |
| 156 Args: | |
| 157 prefs: dict() with new user preferences as returned by PrefsInfo.Prefs(). | |
| 158 """ | |
| 159 with open(os.path.join(self._profile_path, 'Preferences'), 'w') as f: | |
| 160 json.dump(prefs, f) | |
| 161 | |
| 162 def _InvalidatePreferencesBackup(self): | |
| 163 """Makes the Preferences backup invalid by clearing the signature.""" | |
| 164 prefs = self._LoadPreferences() | |
| 165 prefs['backup']['_signature'] = 'INVALID' | |
| 166 self._WritePreferences(prefs) | |
| 167 | |
| 168 def _ChangeSessionStartupPrefs(self, startup_type=None, startup_urls=None, | |
| 169 homepage=None, delete_migrated_pref=False): | |
| 170 """Changes the session startup type and the list of URLs to load on startup. | |
| 171 | |
| 172 Args: | |
| 173 startup_type: int with one of _SESSION_STARTUP_* values. If startup_type | |
| 174 is None, then it deletes the preference. | |
| 175 startup_urls: list(str) with a list of URLs; if None, is left unchanged. | |
| 176 homepage: unless None, the new value for homepage. | |
| 177 delete_migrated_pref: Whether we should delete the preference which says | |
| 178 we've already migrated the startup_type preference. | |
| 179 """ | |
| 180 prefs = self._LoadPreferences() | |
| 181 if startup_type is None: | |
| 182 del prefs['session']['restore_on_startup'] | |
| 183 else: | |
| 184 prefs['session']['restore_on_startup'] = startup_type | |
| 185 | |
| 186 if startup_urls is not None: | |
| 187 prefs['session']['urls_to_restore_on_startup'] = startup_urls | |
| 188 if homepage is not None: | |
| 189 prefs['homepage'] = homepage | |
| 190 prefs['homepage_is_newtabpage'] = False | |
| 191 if delete_migrated_pref: | |
| 192 del prefs['session']['restore_on_startup_migrated'] | |
| 193 self._WritePreferences(prefs) | |
| 194 | |
| 195 def _ChangePinnedTabsPrefs(self, pinned_tabs): | |
| 196 """Changes the list of pinned tabs. | |
| 197 | |
| 198 Args: | |
| 199 pinned_tabs: list(str) with a list of pinned tabs URLs. | |
| 200 """ | |
| 201 prefs = self._LoadPreferences() | |
| 202 prefs['pinned_tabs'] = [] | |
| 203 for tab in pinned_tabs: | |
| 204 prefs['pinned_tabs'].append({'url': tab}) | |
| 205 self._WritePreferences(prefs) | |
| 206 | |
| 207 def _ChangeHomepage(self, homepage, homepage_is_ntp, show_homepage_button): | |
| 208 """Changes homepage settings. | |
| 209 | |
| 210 Args: | |
| 211 homepage: new homepage URL (str), | |
| 212 homepage_is_ntp: whether homepage is NTP. | |
| 213 show_homepage_button: whether homepage button is visible. | |
| 214 """ | |
| 215 prefs = self._LoadPreferences() | |
| 216 prefs['homepage'] = homepage | |
| 217 prefs['homepage_is_newtabpage'] = homepage_is_ntp | |
| 218 prefs['browser']['show_home_button'] = show_homepage_button | |
| 219 self._WritePreferences(prefs) | |
| 220 | |
| 221 def _AssertTabsOpen(self, urls, pinned=None): | |
| 222 """Asserts that exactly one window with the specified URLs is open. | |
| 223 | |
| 224 Args: | |
| 225 urls: list of URLs of expected open tabs. | |
| 226 pinned: if given, list of boolean values whether the corresponding tab is | |
| 227 expected to be pinned or not. | |
| 228 """ | |
| 229 info = self.GetBrowserInfo() | |
| 230 self.assertEqual(1, len(info['windows'])) # one window | |
| 231 self.assertEqual(urls, [tab['url'] for tab in info['windows'][0]['tabs']]) | |
| 232 if pinned: | |
| 233 self.assertEqual(pinned, | |
| 234 [tab['pinned'] for tab in info['windows'][0]['tabs']]) | |
| 235 | |
| 236 def testNoChangeOnCleanProfile(self): | |
| 237 """Test that no change is reported on a clean profile.""" | |
| 238 self.assertFalse(self.GetProtectorState()['showing_change']) | |
| 239 | |
| 240 | |
| 241 class ProtectorSearchEngineTest(BaseProtectorTest): | |
| 242 """Test suite for search engine change detection with Protector enabled.""" | |
| 243 | |
| 244 def testDetectSearchEngineChangeAndApply(self): | |
| 245 """Test for detecting and applying a default search engine change.""" | |
| 246 # Get current search engine. | |
| 247 old_default_search = self._GetDefaultSearchEngine() | |
| 248 self.assertTrue(old_default_search) | |
| 249 # Close browser, change the search engine and start it again. | |
| 250 self.RestartBrowser(clear_profile=False, | |
| 251 pre_launch_hook=self._ChangeDefaultSearchEngine) | |
| 252 # The change must be detected by Protector. | |
| 253 self.assertTrue(self.GetProtectorState()['showing_change']) | |
| 254 default_search = self._GetDefaultSearchEngine() | |
| 255 # Protector must restore the old search engine. | |
| 256 self.assertEqual(old_default_search, default_search) | |
| 257 self.ApplyProtectorChange() | |
| 258 # Now the search engine must have changed to the new one. | |
| 259 default_search = self._GetDefaultSearchEngine() | |
| 260 self.assertNotEqual(old_default_search, default_search) | |
| 261 self.assertEqual(self._new_default_search_keyword, | |
| 262 default_search['keyword']) | |
| 263 # No longer showing the change. | |
| 264 self.assertFalse(self.GetProtectorState()['showing_change']) | |
| 265 | |
| 266 def testDetectSearchEngineChangeAndDiscard(self): | |
| 267 """Test for detecting and discarding a default search engine change.""" | |
| 268 # Get current search engine. | |
| 269 old_default_search = self._GetDefaultSearchEngine() | |
| 270 self.assertTrue(old_default_search) | |
| 271 # Close browser, change the search engine and start it again. | |
| 272 self.RestartBrowser(clear_profile=False, | |
| 273 pre_launch_hook=self._ChangeDefaultSearchEngine) | |
| 274 # The change must be detected by Protector. | |
| 275 self.assertTrue(self.GetProtectorState()['showing_change']) | |
| 276 default_search = self._GetDefaultSearchEngine() | |
| 277 # Protector must restore the old search engine. | |
| 278 self.assertEqual(old_default_search, default_search) | |
| 279 self.DiscardProtectorChange() | |
| 280 # Old search engine remains active. | |
| 281 default_search = self._GetDefaultSearchEngine() | |
| 282 self.assertEqual(old_default_search, default_search) | |
| 283 # No longer showing the change. | |
| 284 self.assertFalse(self.GetProtectorState()['showing_change']) | |
| 285 | |
| 286 def testSearchEngineChangeDismissedOnEdit(self): | |
| 287 """Test that default search engine change is dismissed when default search | |
| 288 engine is changed by user. | |
| 289 """ | |
| 290 # Get current search engine. | |
| 291 old_default_search = self._GetDefaultSearchEngine() | |
| 292 self.assertTrue(old_default_search) | |
| 293 # Close browser, change the search engine and start it again. | |
| 294 self.RestartBrowser(clear_profile=False, | |
| 295 pre_launch_hook=self._ChangeDefaultSearchEngine) | |
| 296 # The change must be detected by Protector. | |
| 297 self.assertTrue(self.GetProtectorState()['showing_change']) | |
| 298 # Change default search engine. | |
| 299 self.MakeSearchEngineDefault(self._new_default_search_keyword) | |
| 300 # Change is successful. | |
| 301 default_search = self._GetDefaultSearchEngine() | |
| 302 self.assertEqual(self._new_default_search_keyword, | |
| 303 default_search['keyword']) | |
| 304 # No longer showing the change. | |
| 305 self.assertFalse(self.GetProtectorState()['showing_change']) | |
| 306 search_urls = [engine['url'] for engine in self.GetSearchEngineInfo()] | |
| 307 # Verify there are no duplicate search engines: | |
| 308 self.assertEqual(len(search_urls), len(set(search_urls))) | |
| 309 | |
| 310 def testSearchEngineChangeWithMultipleWindows(self): | |
| 311 """Test that default search engine change is detected in multiple | |
| 312 browser windows. | |
| 313 """ | |
| 314 # Get current search engine. | |
| 315 old_default_search = self._GetDefaultSearchEngine() | |
| 316 self.assertTrue(old_default_search) | |
| 317 # Close browser, change the search engine and start it again. | |
| 318 self.RestartBrowser(clear_profile=False, | |
| 319 pre_launch_hook=self._ChangeDefaultSearchEngine) | |
| 320 # The change must be detected by Protector in first window | |
| 321 self.OpenNewBrowserWindow(True) | |
| 322 self.assertTrue(self.GetProtectorState(window_index=0)['showing_change']) | |
| 323 # Open another Browser Window | |
| 324 self.OpenNewBrowserWindow(True) | |
| 325 # The change must be detected by Protector in second window | |
| 326 self.assertTrue(self.GetProtectorState(window_index=1)['showing_change']) | |
| 327 | |
| 328 def testSearchEngineChangeDiscardedOnRelaunchingBrowser(self): | |
| 329 """Verify that relaunching the browser while Protector is showing a change | |
| 330 discards it. | |
| 331 """ | |
| 332 # Get current search engine. | |
| 333 old_default_search = self._GetDefaultSearchEngine() | |
| 334 self.assertTrue(old_default_search) | |
| 335 # Close browser, change the search engine and start it again. | |
| 336 self.RestartBrowser(clear_profile=False, | |
| 337 pre_launch_hook=self._ChangeDefaultSearchEngine) | |
| 338 # The change must be detected by Protector. | |
| 339 self.assertTrue(self.GetProtectorState()['showing_change']) | |
| 340 default_search = self._GetDefaultSearchEngine() | |
| 341 self.assertEqual(old_default_search, default_search) | |
| 342 # After relaunching the browser, old search engine still must be active. | |
| 343 self.RestartBrowser(clear_profile=False) | |
| 344 default_search = self._GetDefaultSearchEngine() | |
| 345 self.assertEqual(old_default_search, default_search) | |
| 346 # No longer showing the change. | |
| 347 self.assertFalse(self.GetProtectorState()['showing_change']) | |
| 348 | |
| 349 # TODO(ivankr): more hijacking cases (remove the current default search engine, | |
| 350 # add new search engines to the list, invalidate backup, etc). | |
| 351 | |
| 352 | |
| 353 class ProtectorPreferencesTest(BaseProtectorTest): | |
| 354 """Generic test suite for Preferences protection.""" | |
| 355 | |
| 356 def testPreferencesBackupInvalid(self): | |
| 357 """Test for detecting invalid Preferences backup.""" | |
| 358 # Set startup prefs to open specific URLs. | |
| 359 self.SetPrefs(pyauto.kRestoreOnStartup, self._SESSION_STARTUP_URLS) | |
| 360 self.SetPrefs(pyauto.kURLsToRestoreOnStartup, ['http://www.google.com/']) | |
| 361 self.RestartBrowser( | |
| 362 clear_profile=False, | |
| 363 pre_launch_hook=self._InvalidatePreferencesBackup) | |
| 364 # The change must be detected by Protector. | |
| 365 self.assertTrue(self.GetProtectorState()['showing_change']) | |
| 366 # Startup settings are reset to default (NTP). | |
| 367 self.assertEqual(self._SESSION_STARTUP_NTP, | |
| 368 self.GetPrefsInfo().Prefs(pyauto.kRestoreOnStartup)) | |
| 369 # Verify that previous startup URL has not been opened. | |
| 370 self._AssertTabsOpen(['chrome://newtab/']) | |
| 371 # Click "Edit Settings...". | |
| 372 self.DiscardProtectorChange() | |
| 373 # Verify that a new tab with settings is opened. | |
| 374 info = self.GetBrowserInfo() | |
| 375 self._AssertTabsOpen(['chrome://newtab/', 'chrome://chrome/settings/']) | |
| 376 # No longer showing the change. | |
| 377 self.assertFalse(self.GetProtectorState()['showing_change']) | |
| 378 self.RestartBrowser(clear_profile=False) | |
| 379 # Not showing the change after a restart | |
| 380 self.assertFalse(self.GetProtectorState()['showing_change']) | |
| 381 | |
| 382 def testPreferencesBackupInvalidRestoreLastSession(self): | |
| 383 """Test that session restore setting is not reset if backup is invalid.""" | |
| 384 # Set startup prefs to restore the last session. | |
| 385 self.SetPrefs(pyauto.kRestoreOnStartup, self._SESSION_STARTUP_LAST) | |
| 386 previous_urls = ['chrome://version/', 'http://news.google.com/'] | |
| 387 self.NavigateToURL(previous_urls[0]) | |
| 388 for url in previous_urls[1:]: | |
| 389 self.AppendTab(pyauto.GURL(url)) | |
| 390 self.RestartBrowser( | |
| 391 clear_profile=False, | |
| 392 pre_launch_hook=self._InvalidatePreferencesBackup) | |
| 393 # The change must be detected by Protector. | |
| 394 self.assertTrue(self.GetProtectorState()['showing_change']) | |
| 395 # Startup settings are left unchanged. | |
| 396 self.assertEqual(self._SESSION_STARTUP_LAST, | |
| 397 self.GetPrefsInfo().Prefs(pyauto.kRestoreOnStartup)) | |
| 398 # Session has been restored. | |
| 399 self._AssertTabsOpen(previous_urls) | |
| 400 | |
| 401 def testPreferencesBackupInvalidChangeDismissedOnEdit(self): | |
| 402 """Test that editing protected prefs dismisses the invalid backup bubble.""" | |
| 403 self.RestartBrowser( | |
| 404 clear_profile=False, | |
| 405 pre_launch_hook=self._InvalidatePreferencesBackup) | |
| 406 # The change must be detected by Protector. | |
| 407 self.assertTrue(self.GetProtectorState()['showing_change']) | |
| 408 # Change some protected setting manually. | |
| 409 self.SetPrefs(pyauto.kHomePage, 'http://example.com/') | |
| 410 # No longer showing the change. | |
| 411 self.assertFalse(self.GetProtectorState()['showing_change']) | |
| 412 | |
| 413 | |
| 414 class ProtectorSessionStartupTest(BaseProtectorTest): | |
| 415 """Test suite for session startup changes detection with Protector enabled. | |
| 416 """ | |
| 417 def testDetectSessionStartupChangeAndApply(self): | |
| 418 """Test for detecting and applying a session startup pref change.""" | |
| 419 # Set startup prefs to restoring last open tabs. | |
| 420 self.SetPrefs(pyauto.kRestoreOnStartup, self._SESSION_STARTUP_LAST) | |
| 421 previous_urls = ['chrome://version/', 'http://news.google.com/'] | |
| 422 self.NavigateToURL(previous_urls[0]) | |
| 423 for url in previous_urls[1:]: | |
| 424 self.AppendTab(pyauto.GURL(url)) | |
| 425 # Restart browser with startup prefs set to open google.com. | |
| 426 self.RestartBrowser( | |
| 427 clear_profile=False, | |
| 428 pre_launch_hook=lambda: self._ChangeSessionStartupPrefs( | |
| 429 self._SESSION_STARTUP_URLS, | |
| 430 startup_urls=['http://www.google.com'])) | |
| 431 # The change must be detected by Protector. | |
| 432 self.assertTrue(self.GetProtectorState()['showing_change']) | |
| 433 # Protector must restore old preference values. | |
| 434 self.assertEqual(self._SESSION_STARTUP_LAST, | |
| 435 self.GetPrefsInfo().Prefs(pyauto.kRestoreOnStartup)) | |
| 436 # Verify that open tabs are consistent with restored prefs. | |
| 437 self._AssertTabsOpen(previous_urls) | |
| 438 self.ApplyProtectorChange() | |
| 439 # Now the new preference values are active. | |
| 440 self.assertEqual(self._SESSION_STARTUP_URLS, | |
| 441 self.GetPrefsInfo().Prefs(pyauto.kRestoreOnStartup)) | |
| 442 # No longer showing the change. | |
| 443 self.assertFalse(self.GetProtectorState()['showing_change']) | |
| 444 | |
| 445 def testDetectSessionStartupChangeAndDiscard(self): | |
| 446 """Test for detecting and discarding a session startup pref change.""" | |
| 447 # Set startup prefs to restoring last open tabs. | |
| 448 self.SetPrefs(pyauto.kRestoreOnStartup, self._SESSION_STARTUP_LAST) | |
| 449 # Restart browser with startup prefs set to open google.com. | |
| 450 self.RestartBrowser( | |
| 451 clear_profile=False, | |
| 452 pre_launch_hook=lambda: self._ChangeSessionStartupPrefs( | |
| 453 self._SESSION_STARTUP_URLS, | |
| 454 startup_urls=['http://www.google.com'])) | |
| 455 # The change must be detected by Protector. | |
| 456 self.assertTrue(self.GetProtectorState()['showing_change']) | |
| 457 # Old preference values restored. | |
| 458 self.assertEqual(self._SESSION_STARTUP_LAST, | |
| 459 self.GetPrefsInfo().Prefs(pyauto.kRestoreOnStartup)) | |
| 460 self.DiscardProtectorChange() | |
| 461 # Old preference values are still active. | |
| 462 self.assertEqual(self._SESSION_STARTUP_LAST, | |
| 463 self.GetPrefsInfo().Prefs(pyauto.kRestoreOnStartup)) | |
| 464 # No longer showing the change. | |
| 465 self.assertFalse(self.GetProtectorState()['showing_change']) | |
| 466 | |
| 467 def testSessionStartupChangeDismissedOnEdit(self): | |
| 468 """Test for that editing startup prefs manually dismissed the change.""" | |
| 469 # Set startup prefs to restoring last open tabs. | |
| 470 self.SetPrefs(pyauto.kRestoreOnStartup, self._SESSION_STARTUP_LAST) | |
| 471 # Restart browser with startup prefs set to open google.com. | |
| 472 self.RestartBrowser( | |
| 473 clear_profile=False, | |
| 474 pre_launch_hook=lambda: self._ChangeSessionStartupPrefs( | |
| 475 self._SESSION_STARTUP_URLS, | |
| 476 startup_urls=['http://www.google.com'])) | |
| 477 # The change must be detected by Protector. | |
| 478 self.assertTrue(self.GetProtectorState()['showing_change']) | |
| 479 # Change the setting manually. | |
| 480 self.SetPrefs(pyauto.kRestoreOnStartup, self._SESSION_STARTUP_NTP) | |
| 481 # No longer showing the change. | |
| 482 self.assertFalse(self.GetProtectorState()['showing_change']) | |
| 483 | |
| 484 def testSessionStartupPrefMigrationFromHomepage(self): | |
| 485 """Test migration from old session.restore_on_startup values (homepage).""" | |
| 486 # Set startup prefs to restoring last open tabs. | |
| 487 self.SetPrefs(pyauto.kRestoreOnStartup, self._SESSION_STARTUP_LAST) | |
| 488 self.SetPrefs(pyauto.kURLsToRestoreOnStartup, []) | |
| 489 new_homepage = 'http://www.google.com/' | |
| 490 # Restart browser with startup prefs set to open homepage (google.com). | |
| 491 self.RestartBrowser( | |
| 492 clear_profile=False, | |
| 493 pre_launch_hook=lambda: self._ChangeSessionStartupPrefs( | |
| 494 self._SESSION_STARTUP_HOMEPAGE, | |
| 495 homepage=new_homepage, | |
| 496 delete_migrated_pref=True)) | |
| 497 # The change must be detected by Protector. | |
| 498 self.assertTrue(self.GetProtectorState()['showing_change']) | |
| 499 # Protector must restore old preference values. | |
| 500 self.assertEqual(self._SESSION_STARTUP_LAST, | |
| 501 self.GetPrefsInfo().Prefs(pyauto.kRestoreOnStartup)) | |
| 502 self.assertEqual([], | |
| 503 self.GetPrefsInfo().Prefs(pyauto.kURLsToRestoreOnStartup)) | |
| 504 self.ApplyProtectorChange() | |
| 505 # Now the new preference values are active. | |
| 506 self.assertEqual(self._SESSION_STARTUP_URLS, | |
| 507 self.GetPrefsInfo().Prefs(pyauto.kRestoreOnStartup)) | |
| 508 # Homepage migrated to the list of startup URLs. | |
| 509 self.assertEqual([new_homepage], | |
| 510 self.GetPrefsInfo().Prefs(pyauto.kURLsToRestoreOnStartup)) | |
| 511 # No longer showing the change. | |
| 512 self.assertFalse(self.GetProtectorState()['showing_change']) | |
| 513 | |
| 514 def testSessionStartupPrefMigrationFromBlank(self): | |
| 515 """Test migration from session.restore_on_startup being blank, as it would | |
| 516 be for a user who had m18 or lower, and never changed that preference. | |
| 517 """ | |
| 518 # Set startup prefs to restoring last open tabs. | |
| 519 self.SetPrefs(pyauto.kRestoreOnStartup, self._SESSION_STARTUP_LAST) | |
| 520 self.SetPrefs(pyauto.kURLsToRestoreOnStartup, []) | |
| 521 # Set the homepage. | |
| 522 new_homepage = 'http://www.google.com/' | |
| 523 self.SetPrefs(pyauto.kHomePageIsNewTabPage, False) | |
| 524 self.SetPrefs(pyauto.kHomePage, new_homepage) | |
| 525 # Restart browser, clearing the 'restore on startup' pref, to simulate a | |
| 526 # user coming from m18 and having left it on the default value. | |
| 527 self.RestartBrowser( | |
| 528 clear_profile=False, | |
| 529 pre_launch_hook=lambda: self._ChangeSessionStartupPrefs( | |
| 530 startup_type=None, | |
| 531 delete_migrated_pref=True)) | |
| 532 # The change must be detected by Protector. | |
| 533 self.assertTrue(self.GetProtectorState()['showing_change']) | |
| 534 # Protector must restore old preference values. | |
| 535 self.assertEqual(self._SESSION_STARTUP_LAST, | |
| 536 self.GetPrefsInfo().Prefs(pyauto.kRestoreOnStartup)) | |
| 537 self.assertEqual([], | |
| 538 self.GetPrefsInfo().Prefs(pyauto.kURLsToRestoreOnStartup)) | |
| 539 self.ApplyProtectorChange() | |
| 540 # Now the new preference values are active. | |
| 541 self.assertEqual(self._SESSION_STARTUP_URLS, | |
| 542 self.GetPrefsInfo().Prefs(pyauto.kRestoreOnStartup)) | |
| 543 # Homepage migrated to the list of startup URLs. | |
| 544 self.assertEqual([new_homepage], | |
| 545 self.GetPrefsInfo().Prefs(pyauto.kURLsToRestoreOnStartup)) | |
| 546 # No longer showing the change. | |
| 547 self.assertFalse(self.GetProtectorState()['showing_change']) | |
| 548 | |
| 549 def testSessionStartupPrefNoMigrationOnHomepageChange(self): | |
| 550 """Test that when the user modifies their homepage in m19+, we don't do the | |
| 551 preference migration. | |
| 552 """ | |
| 553 # Initially, the default value is selected for kRestoreOnStartup. | |
| 554 self.assertEqual(self._SESSION_STARTUP_NTP, | |
| 555 self.GetPrefsInfo().Prefs(pyauto.kRestoreOnStartup)) | |
| 556 # Set the homepage, but leave kRestoreOnStartup unchanged. | |
| 557 new_homepage = 'http://www.google.com/' | |
| 558 self.SetPrefs(pyauto.kHomePageIsNewTabPage, False) | |
| 559 self.SetPrefs(pyauto.kHomePage, new_homepage) | |
| 560 # Restart browser. | |
| 561 self.RestartBrowser(clear_profile=False) | |
| 562 # Now the new preference values are active. | |
| 563 self.assertEqual(self._SESSION_STARTUP_NTP, | |
| 564 self.GetPrefsInfo().Prefs(pyauto.kRestoreOnStartup)) | |
| 565 # kURLsToRestoreOnStartup pref is unchanged. | |
| 566 self.assertEqual([], | |
| 567 self.GetPrefsInfo().Prefs(pyauto.kURLsToRestoreOnStartup)) | |
| 568 # No longer showing the change. | |
| 569 self.assertFalse(self.GetProtectorState()['showing_change']) | |
| 570 | |
| 571 def testDetectPinnedTabsChangeAndApply(self): | |
| 572 """Test for detecting and applying a change to pinned tabs.""" | |
| 573 pinned_urls = ['chrome://version/', 'chrome://credits/'] | |
| 574 self.RestartBrowser( | |
| 575 clear_profile=False, | |
| 576 pre_launch_hook=lambda: self._ChangePinnedTabsPrefs(pinned_urls)) | |
| 577 # The change must be detected by Protector. | |
| 578 self.assertTrue(self.GetProtectorState()['showing_change']) | |
| 579 # Protector must restore old preference values. | |
| 580 self.assertEqual([], | |
| 581 self.GetPrefsInfo().Prefs(pyauto.kPinnedTabs)) | |
| 582 # No pinned tabs are open, only NTP. | |
| 583 info = self.GetBrowserInfo() | |
| 584 self._AssertTabsOpen(['chrome://newtab/']) | |
| 585 self.ApplyProtectorChange() | |
| 586 # No longer showing the change. | |
| 587 self.assertFalse(self.GetProtectorState()['showing_change']) | |
| 588 # Pinned tabs should have been opened now in the correct order. | |
| 589 self._AssertTabsOpen(pinned_urls + ['chrome://newtab/'], | |
| 590 pinned=[True, True, False]) | |
| 591 self.RestartBrowser(clear_profile=False) | |
| 592 # Not showing the change after a restart | |
| 593 self.assertFalse(self.GetProtectorState()['showing_change']) | |
| 594 # Same pinned tabs are open. | |
| 595 self._AssertTabsOpen(pinned_urls + ['chrome://newtab/'], | |
| 596 pinned=[True, True, False]) | |
| 597 | |
| 598 def testDetectPinnedTabsChangeAndDiscard(self): | |
| 599 """Test for detecting and discarding a change to pinned tabs.""" | |
| 600 pinned_url = 'chrome://version/' | |
| 601 self.RestartBrowser( | |
| 602 clear_profile=False, | |
| 603 pre_launch_hook=lambda: self._ChangePinnedTabsPrefs([pinned_url])) | |
| 604 # The change must be detected by Protector. | |
| 605 self.assertTrue(self.GetProtectorState()['showing_change']) | |
| 606 # Protector must restore old preference values. | |
| 607 self.assertEqual([], | |
| 608 self.GetPrefsInfo().Prefs(pyauto.kPinnedTabs)) | |
| 609 # No pinned tabs are open, only NTP. | |
| 610 info = self.GetBrowserInfo() | |
| 611 self._AssertTabsOpen(['chrome://newtab/']) | |
| 612 self.DiscardProtectorChange() | |
| 613 # No longer showing the change. | |
| 614 self.assertFalse(self.GetProtectorState()['showing_change']) | |
| 615 # Pinned tabs are not opened after another restart. | |
| 616 self.RestartBrowser(clear_profile=False) | |
| 617 self._AssertTabsOpen(['chrome://newtab/']) | |
| 618 # Not showing the change after a restart. | |
| 619 self.assertFalse(self.GetProtectorState()['showing_change']) | |
| 620 | |
| 621 | |
| 622 class ProtectorHomepageTest(BaseProtectorTest): | |
| 623 """Test suite for homepage changes with Protector enabled.""" | |
| 624 | |
| 625 def testDetectHomepageChangeAndApply(self): | |
| 626 """Test that homepage change is detected and can be applied.""" | |
| 627 previous_homepage = 'http://example.com/' | |
| 628 new_homepage = 'http://example.info/' | |
| 629 self.SetPrefs(pyauto.kHomePage, previous_homepage) | |
| 630 self.SetPrefs(pyauto.kHomePageIsNewTabPage, False) | |
| 631 self.SetPrefs(pyauto.kShowHomeButton, False) | |
| 632 self.RestartBrowser( | |
| 633 clear_profile=False, | |
| 634 pre_launch_hook=lambda: self._ChangeHomepage(new_homepage, False, True)) | |
| 635 # The change must be detected by Protector. | |
| 636 self.assertTrue(self.GetProtectorState()['showing_change']) | |
| 637 # Protector must restore old preference values. | |
| 638 self.assertEquals(previous_homepage, | |
| 639 self.GetPrefsInfo().Prefs(pyauto.kHomePage)) | |
| 640 self.assertEquals(False, self.GetPrefsInfo().Prefs(pyauto.kShowHomeButton)) | |
| 641 self.ApplyProtectorChange() | |
| 642 # Now new values are active. | |
| 643 self.assertEquals(new_homepage, self.GetPrefsInfo().Prefs(pyauto.kHomePage)) | |
| 644 self.assertEquals(True, self.GetPrefsInfo().Prefs(pyauto.kShowHomeButton)) | |
| 645 # No longer showing the change | |
| 646 self.assertFalse(self.GetProtectorState()['showing_change']) | |
| 647 | |
| 648 def testDetectHomepageChangeAndDiscard(self): | |
| 649 """Test that homepage change is detected and can be discarded.""" | |
| 650 previous_homepage = 'http://example.com/' | |
| 651 new_homepage = 'http://example.info/' | |
| 652 self.SetPrefs(pyauto.kHomePage, previous_homepage) | |
| 653 self.SetPrefs(pyauto.kHomePageIsNewTabPage, False) | |
| 654 self.SetPrefs(pyauto.kShowHomeButton, False) | |
| 655 self.RestartBrowser( | |
| 656 clear_profile=False, | |
| 657 pre_launch_hook=lambda: self._ChangeHomepage(new_homepage, False, True)) | |
| 658 # The change must be detected by Protector. | |
| 659 self.assertTrue(self.GetProtectorState()['showing_change']) | |
| 660 # Protector must restore old preference values. | |
| 661 self.assertEquals(previous_homepage, | |
| 662 self.GetPrefsInfo().Prefs(pyauto.kHomePage)) | |
| 663 self.assertEquals(False, self.GetPrefsInfo().Prefs(pyauto.kShowHomeButton)) | |
| 664 self.DiscardProtectorChange() | |
| 665 # Nothing changed | |
| 666 self.assertEquals(previous_homepage, | |
| 667 self.GetPrefsInfo().Prefs(pyauto.kHomePage)) | |
| 668 self.assertEquals(False, self.GetPrefsInfo().Prefs(pyauto.kShowHomeButton)) | |
| 669 # No longer showing the change | |
| 670 self.assertFalse(self.GetProtectorState()['showing_change']) | |
| 671 | |
| 672 | |
| 673 class ProtectorDisabledTest(BaseProtectorTest): | |
| 674 """Test suite for Protector in disabled state.""" | |
| 675 | |
| 676 def _IsEnabled(self): | |
| 677 """Overriden from BaseProtectorTest to disable Protector.""" | |
| 678 return False | |
| 679 | |
| 680 def testNoSearchEngineChangeReported(self): | |
| 681 """Test that the default search engine change is neither reported to user | |
| 682 nor reverted. | |
| 683 """ | |
| 684 # Get current search engine. | |
| 685 old_default_search = self._GetDefaultSearchEngine() | |
| 686 self.assertTrue(old_default_search) | |
| 687 # Close browser, change the search engine and start it again. | |
| 688 self.RestartBrowser(clear_profile=False, | |
| 689 pre_launch_hook=self._ChangeDefaultSearchEngine) | |
| 690 # The change must not be reported by Protector. | |
| 691 self.assertFalse(self.GetProtectorState()['showing_change']) | |
| 692 default_search = self._GetDefaultSearchEngine() | |
| 693 # The new search engine must be active. | |
| 694 self.assertEqual(self._new_default_search_keyword, | |
| 695 default_search['keyword']) | |
| 696 | |
| 697 def testNoPreferencesBackupInvalidReported(self): | |
| 698 """Test that invalid Preferences backup is not reported.""" | |
| 699 self.SetPrefs(pyauto.kRestoreOnStartup, self._SESSION_STARTUP_URLS) | |
| 700 new_url = 'chrome://version/' | |
| 701 self.SetPrefs(pyauto.kURLsToRestoreOnStartup, [new_url]) | |
| 702 self.RestartBrowser( | |
| 703 clear_profile=False, | |
| 704 pre_launch_hook=self._InvalidatePreferencesBackup) | |
| 705 # The change must not be reported by Protector. | |
| 706 self.assertFalse(self.GetProtectorState()['showing_change']) | |
| 707 # New preference values must be active. | |
| 708 self.assertEqual(self._SESSION_STARTUP_URLS, | |
| 709 self.GetPrefsInfo().Prefs(pyauto.kRestoreOnStartup)) | |
| 710 # Verify that open tabs are consistent with new prefs. | |
| 711 self._AssertTabsOpen([new_url]) | |
| 712 | |
| 713 def testNoSessionStartupChangeReported(self): | |
| 714 """Test that the session startup change is neither reported nor reverted.""" | |
| 715 # Set startup prefs to restoring last open tabs. | |
| 716 self.SetPrefs(pyauto.kRestoreOnStartup, self._SESSION_STARTUP_LAST) | |
| 717 new_url = 'chrome://version/' | |
| 718 self.NavigateToURL('http://www.google.com/') | |
| 719 # Restart browser with startup prefs set to open google.com. | |
| 720 self.RestartBrowser( | |
| 721 clear_profile=False, | |
| 722 pre_launch_hook=lambda: self._ChangeSessionStartupPrefs( | |
| 723 self._SESSION_STARTUP_URLS, | |
| 724 startup_urls=[new_url])) | |
| 725 # The change must not be reported by Protector. | |
| 726 self.assertFalse(self.GetProtectorState()['showing_change']) | |
| 727 # New preference values must be active. | |
| 728 self.assertEqual(self._SESSION_STARTUP_URLS, | |
| 729 self.GetPrefsInfo().Prefs(pyauto.kRestoreOnStartup)) | |
| 730 # Verify that open tabs are consistent with new prefs. | |
| 731 self._AssertTabsOpen([new_url]) | |
| 732 | |
| 733 def testNoHomepageChangeReported(self): | |
| 734 """Test that homepage change is neither reported nor reverted.""" | |
| 735 new_homepage = 'http://example.info/' | |
| 736 self.SetPrefs(pyauto.kHomePage, 'http://example.com/') | |
| 737 self.SetPrefs(pyauto.kHomePageIsNewTabPage, False) | |
| 738 self.SetPrefs(pyauto.kShowHomeButton, False) | |
| 739 self.RestartBrowser( | |
| 740 clear_profile=False, | |
| 741 pre_launch_hook=lambda: self._ChangeHomepage(new_homepage, False, True)) | |
| 742 # Not showing the change. | |
| 743 self.assertFalse(self.GetProtectorState()['showing_change']) | |
| 744 # New values must be active. | |
| 745 self.assertEquals(new_homepage, self.GetPrefsInfo().Prefs(pyauto.kHomePage)) | |
| 746 self.assertEquals(True, self.GetPrefsInfo().Prefs(pyauto.kShowHomeButton)) | |
| 747 | |
| 748 | |
| 749 if __name__ == '__main__': | |
| 750 pyauto_functional.Main() | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 11493003:
Remove the protector service. (Closed)
Base URL: svn://svn.chromium.org/chrome/trunk/src