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 |