src/chrome/test/functional/prefs_ui.py

   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 time
   7
   8 import pyauto_functional  # Must be imported before pyauto
   9 import pyauto
  10 import test_utils
  11
  12 from webdriver_pages import settings
  13 from webdriver_pages.settings import Behaviors, ContentTypes
  14 from webdriver_pages.settings import RestoreOnStartupType
  15
  16
  17 class PrefsUITest(pyauto.PyUITest):
  18   """TestCase for Preferences UI."""
  19
  20   INFOBAR_TYPE = 'rph_infobar'
  21
  22   def setUp(self):
  23     pyauto.PyUITest.setUp(self)
  24     self._driver = self.NewWebDriver()
  25
  26   def Debug(self):
  27     """Test method for experimentation.
  28
  29     This method will not run automatically.
  30     """
  31     driver = self.NewWebDriver()
  32     page = settings.ContentSettingsPage.FromNavigation(driver)
  33     import pdb
  34     pdb.set_trace()
  35
  36   def _GetGeolocationContentSettingsBehavior(self):
  37     """Get the Content Settings behavior for Geolocation.
  38
  39     Returns:
  40       The exceptions behavior for the specified content type.
  41       The content type is the available content setting available.
  42     """
  43     behavior_key = self.GetPrefsInfo().Prefs(
  44         pyauto.kGeolocationDefaultContentSetting)
  45     behaviors_dict = {1: 'ALLOW', 2: 'BLOCK', 3: 'ASK'}
  46     self.assertTrue(
  47         behavior_key in behaviors_dict,
  48         msg=('Invalid default behavior key "%s" for "geolocation" content' %
  49              behavior_key))
  50     return behaviors_dict[behavior_key]
  51
  52   def _VerifyContentExceptionUI(self, content_type, hostname_pattern, behavior,
  53                                 incognito=False):
  54     """Find hostname pattern and behavior within UI on content exceptions page.
  55
  56     Args:
  57       content_type: The string content settings type to manage.
  58       hostname_pattern: The URL or pattern associated with the behavior.
  59       behavior: The exception to allow or block the hostname.
  60       incognito: Incognito list displayed on exceptions settings page.
  61                  Default to False.
  62     """
  63     page = settings.ManageExceptionsPage.FromNavigation(
  64         self._driver, content_type)
  65     self.assertTrue(page.GetExceptions(incognito).has_key(hostname_pattern),
  66                      msg=('No displayed host name matches pattern "%s"'
  67                           % hostname_pattern))
  68     self.assertEqual(behavior, page.GetExceptions(incognito)[hostname_pattern],
  69                      msg=('Displayed behavior "%s" does not match behavior "%s"'
  70                           % (page.GetExceptions(incognito)[hostname_pattern],
  71                              behavior)))
  72
  73   def testLocationSettingOptionsUI(self):
  74     """Verify the location options setting UI.
  75
  76     Set the options through the UI using webdriver and verify the settings in
  77     pyAuto.
  78     """
  79     page = settings.ContentSettingsPage.FromNavigation(self._driver)
  80     page.SetContentTypeOption(ContentTypes.GEOLOCATION, Behaviors.ALLOW)
  81     self.assertEqual(
  82         1, self.GetPrefsInfo().Prefs(pyauto.kGeolocationDefaultContentSetting))
  83     page.SetContentTypeOption(ContentTypes.GEOLOCATION, Behaviors.BLOCK)
  84     self.assertEqual(
  85         2, self.GetPrefsInfo().Prefs(pyauto.kGeolocationDefaultContentSetting))
  86     page.SetContentTypeOption(ContentTypes.GEOLOCATION, Behaviors.ASK)
  87     self.assertEqual(
  88         3, self.GetPrefsInfo().Prefs(pyauto.kGeolocationDefaultContentSetting))
  89
  90   def testBehaviorValueCorrectlyDisplayed(self):
  91     """Verify the set behavior value is correctly displayed."""
  92     # Block all sites.
  93     self.SetPrefs(pyauto.kGeolocationDefaultContentSetting, 2)
  94     self.assertEqual(
  95         self._GetGeolocationContentSettingsBehavior(), Behaviors.BLOCK.upper(),
  96         msg='The behavior was incorrectly set.')
  97     # Allow all sites.
  98     self.SetPrefs(pyauto.kGeolocationDefaultContentSetting, 1)
  99     self.assertEqual(
 100         self._GetGeolocationContentSettingsBehavior(), Behaviors.ALLOW.upper(),
 101         msg='The behavior was incorrectly set.')
 102     # Ask for permission when site wants to track.
 103     self.SetPrefs(pyauto.kGeolocationDefaultContentSetting, 3)
 104     self.assertEqual(
 105         self._GetGeolocationContentSettingsBehavior(), Behaviors.ASK.upper(),
 106         msg='The behavior was incorrectly set.')
 107
 108   def testExceptionsEntryCorrectlyDisplayed(self):
 109     """Verify the exceptions line entry is correctly displayed in the UI."""
 110     geo_exception = (
 111         {'http://maps.google.com:80,http://maps.google.com:80':
 112             {'geolocation': 2}})
 113     self.SetPrefs(pyauto.kContentSettingsPatternPairs, geo_exception)
 114     self._VerifyContentExceptionUI(
 115         ContentTypes.GEOLOCATION, 'http://maps.google.com:80',
 116         Behaviors.BLOCK)
 117     geo_exception = (
 118         {'http://maps.google.com:80,http://maps.google.com:80':
 119             {'geolocation': 1}})
 120     self.SetPrefs(pyauto.kContentSettingsPatternPairs, geo_exception)
 121     self._VerifyContentExceptionUI(
 122         ContentTypes.GEOLOCATION, 'http://maps.google.com:80',
 123         Behaviors.ALLOW)
 124     geo_exception = (
 125         {'http://maps.google.com:80,http://maps.google.com:80':
 126             {'geolocation': 3}})
 127     self.SetPrefs(pyauto.kContentSettingsPatternPairs, geo_exception)
 128     self._VerifyContentExceptionUI(
 129         ContentTypes.GEOLOCATION, 'http://maps.google.com:80', Behaviors.ASK)
 130
 131   def testAddNewExceptionUI(self):
 132     """Verify new exception added for hostname pattern and behavior in UI."""
 133     content_type = ContentTypes.PLUGINS
 134     page = settings.ManageExceptionsPage.FromNavigation(
 135         self._driver, content_type)
 136
 137     pattern, behavior = ('bing.com', Behaviors.BLOCK)
 138     page.AddNewException(pattern, behavior)
 139     self.assertEqual(page.GetExceptions()[pattern], Behaviors.BLOCK,
 140                      msg='The behavior "%s" was not added for pattern "%s"'
 141                      % (behavior, pattern))
 142
 143   def testChangeExceptionBehaviorUI(self):
 144     """Verify behavior for hostname pattern is changed in the UI."""
 145     content_type = ContentTypes.PLUGINS
 146     page = settings.ManageExceptionsPage.FromNavigation(
 147         self._driver, content_type)
 148
 149     pattern, behavior = ('bing.com', Behaviors.BLOCK)
 150     page.AddNewException(pattern, behavior)
 151     new_behavior = Behaviors.ALLOW
 152     page.SetBehaviorForPattern(pattern, new_behavior)
 153     self.assertEqual(page.GetExceptions()[pattern], Behaviors.ALLOW,
 154                      msg='The behavior for "%s" did not change: "%s"'
 155                      % (pattern, behavior))
 156
 157   def testDeleteExceptionUI(self):
 158     """Verify exception deleted for hostname pattern and behavior in the UI."""
 159     content_type = ContentTypes.PLUGINS
 160     page = settings.ManageExceptionsPage.FromNavigation(
 161         self._driver, content_type)
 162
 163     pattern, behavior = ('bing.com', Behaviors.BLOCK)
 164     page.AddNewException(pattern, behavior)
 165     self.assertEqual(page.GetExceptions()[pattern], Behaviors.BLOCK,
 166                      msg='The behavior "%s" was not added for pattern "%s"'
 167                      % (behavior, pattern))
 168     page.DeleteException(pattern)
 169     self.assertEqual(page.GetExceptions().get(pattern, KeyError), KeyError,
 170                      msg='Pattern "%s" was not deleted' % pattern)
 171
 172   def testNoInitialLineEntryInUI(self):
 173     """Verify no initial line entry is displayed in UI."""
 174     # Ask for permission when site wants to track.
 175     self.SetPrefs(pyauto.kGeolocationDefaultContentSetting, 3)
 176     self.assertEqual(
 177         3, self.GetPrefsInfo().Prefs(pyauto.kGeolocationDefaultContentSetting))
 178     page = settings.ManageExceptionsPage.FromNavigation(
 179         self._driver, ContentTypes.GEOLOCATION)
 180     self.assertEqual(0, len(page.GetExceptions()))
 181
 182   def testCorrectCookiesSessionInUI(self):
 183     """Verify exceptions for cookies in UI list entry."""
 184     # Block cookies for for a session for google.com.
 185     self.SetPrefs(pyauto.kContentSettingsPatternPairs,
 186                   {'http://google.com:80': {'cookies': 2}})
 187     self._VerifyContentExceptionUI(
 188         ContentTypes.COOKIES, 'http://google.com:80', Behaviors.BLOCK)
 189
 190   def testInitialLineEntryInIncognitoUI(self):
 191     """Verify initial line entry is displayed in Incognito UI."""
 192     self.RunCommand(pyauto.IDC_NEW_INCOGNITO_WINDOW)  # Display incognito list.
 193     page = settings.ManageExceptionsPage.FromNavigation(
 194         self._driver, ContentTypes.PLUGINS)
 195     self.assertEqual(1, len(page.GetExceptions(incognito=True)))
 196
 197   def testIncognitoExceptionsEntryCorrectlyDisplayed(self):
 198     """Verify exceptions entry is correctly displayed in the incognito UI."""
 199     self.RunCommand(pyauto.IDC_NEW_INCOGNITO_WINDOW)  # Display incognito list.
 200     page = settings.ManageExceptionsPage.FromNavigation(
 201         self._driver, ContentTypes.PLUGINS)
 202     pattern, behavior = ('http://maps.google.com:80', Behaviors.BLOCK)
 203     page.AddNewException(pattern, behavior, incognito=True)
 204     self._VerifyContentExceptionUI(
 205         ContentTypes.PLUGINS, 'http://maps.google.com:80',
 206         Behaviors.BLOCK, incognito=True)
 207
 208   def testSetCookieAndDeleteInContentSettings(self):
 209     """Verify a cookie can be deleted in the Content Settings UI."""
 210     # Create a cookie.
 211     cookie_dict = {
 212         'name': 'test_cookie',
 213         'value': 'test_value',
 214         'expiry': time.time() + 30,
 215     }
 216     site = '127.0.0.1'
 217     self.NavigateToURL(self.GetHttpURLForDataPath('google', 'google.html'))
 218     self._driver.add_cookie(cookie_dict)
 219     page = settings.CookiesAndSiteDataSettings.FromNavigation(self._driver)
 220     page.DeleteSiteData(site)
 221     self.assertTrue(site not in page.GetSiteNameList(),
 222                     'Site "%s" was not deleted.'  % site)
 223
 224   def testRemoveMailProtocolHandler(self):
 225     """Verify the mail protocol handler is added and removed successfully."""
 226     url = self.GetHttpURLForDataPath('settings', 'protocol_handler.html')
 227     self.NavigateToURL(url)
 228     # Returns a dictionary with the mail handler that was asked for
 229     # registration.
 230     asked_handler_dict = self._driver.execute_script(
 231         'return registerMailClient()')
 232     self.PerformActionOnInfobar(
 233         'accept', infobar_index=test_utils.WaitForInfobarTypeAndGetIndex(
 234             self, self.INFOBAR_TYPE))
 235     self._driver.find_element_by_id('test_mail_protocol').click()
 236
 237     protocol_handlers_list = (
 238         self.GetPrefsInfo().Prefs(pyauto.kRegisteredProtocolHandlers))
 239     registered_mail_handler = {}
 240     for handler_dict in protocol_handlers_list:
 241       if (handler_dict['protocol'] == 'mailto' and
 242           handler_dict['url'] == asked_handler_dict['url'] and
 243           handler_dict['title'] == asked_handler_dict['title'] and
 244           handler_dict.get('default')):
 245         registered_mail_handler = handler_dict
 246         break
 247       # Verify the mail handler is registered as asked.
 248       self.assertNotEqual(
 249       registered_mail_handler, {},
 250       msg='Mail protocol handler was not registered correctly.')
 251       # Verify the registered mail handler works as expected.
 252       self.assertTrue(
 253           self._driver.execute_script(
 254               'return doesQueryConformsToProtocol("%s", "%s")'
 255               % (asked_handler_dict['query_key'],
 256                  asked_handler_dict['query_value'])),
 257               msg='Mail protocol did not register correctly.')
 258
 259     self._driver.get('chrome://settings-frame/handlers')
 260     # There are 3 DIVs in a handler entry. The last one acts as a remove button.
 261     # The remove button is also equivalent to setting the site to NONE.
 262     self._driver.find_element_by_id('handlers-list').\
 263         find_element_by_xpath('.//div[@role="listitem"]').\
 264         find_element_by_xpath('.//div[@class="handlers-site-column"]').\
 265         find_element_by_xpath('.//option[@value="-1"]').click()
 266
 267     self._driver.get(url)
 268     self._driver.find_element_by_id('test_mail_protocol').click()
 269     self.assertEqual(url, self._driver.current_url,
 270                      msg='Mail protocol still registered.')
 271
 272 class BasicSettingsUITest(pyauto.PyUITest):
 273   """Testcases for uber page basic settings UI."""
 274
 275   def setUp(self):
 276     pyauto.PyUITest.setUp(self)
 277     self._driver = self.NewWebDriver()
 278
 279   def Debug(self):
 280     """chrome://plugins test debug method.
 281
 282     This method will not run automatically.
 283     """
 284     driver = self.NewWebDriver()
 285     page = settings.BasicSettingsPage.FromNavigation(driver)
 286     import pdb
 287     pdb.set_trace()
 288
 289   def testOnStartupSettings(self):
 290     """Verify user can set startup options."""
 291     page = settings.BasicSettingsPage.FromNavigation(self._driver)
 292     page.SetOnStartupOptions(RestoreOnStartupType.NEW_TAB_PAGE)
 293     self.assertEqual(RestoreOnStartupType.NEW_TAB_PAGE,
 294         self.GetPrefsInfo().Prefs(pyauto.kRestoreOnStartup))
 295     page.SetOnStartupOptions(RestoreOnStartupType.RESTORE_SESSION)
 296     self.assertEqual(RestoreOnStartupType.RESTORE_SESSION,
 297         self.GetPrefsInfo().Prefs(pyauto.kRestoreOnStartup))
 298     page.SetOnStartupOptions(RestoreOnStartupType.RESTORE_URLS)
 299     self.assertEqual(RestoreOnStartupType.RESTORE_URLS,
 300         self.GetPrefsInfo().Prefs(pyauto.kRestoreOnStartup))
 301
 302   def testSetStartupPages(self):
 303     """Verify user can add urls for startup pages."""
 304     page = settings.BasicSettingsPage.FromNavigation(self._driver)
 305     for url in ['www.google.com', 'http://www.amazon.com', 'ebay.com']:
 306       page.AddStartupPage(url)
 307     self.assertEqual(RestoreOnStartupType.RESTORE_URLS,
 308         self.GetPrefsInfo().Prefs(pyauto.kRestoreOnStartup))
 309     startup_urls = self.GetPrefsInfo().Prefs(pyauto.kURLsToRestoreOnStartup)
 310     self.assertEqual(startup_urls[0], 'http://www.google.com/')
 311     self.assertEqual(startup_urls[1], 'http://www.amazon.com/')
 312     self.assertEqual(startup_urls[2], 'http://ebay.com/')
 313
 314   def testUseCurrentPagesForStartup(self):
 315     """Verify user can start up browser using current pages."""
 316     page = settings.BasicSettingsPage.FromNavigation(self._driver)
 317     self.OpenNewBrowserWindow(True)
 318     url1 = self.GetHttpURLForDataPath('title2.html')
 319     url2 = self.GetHttpURLForDataPath('title3.html')
 320     self.NavigateToURL(url1, 1, 0)
 321     self.AppendTab(pyauto.GURL(url2), 1)
 322     title_list = ['Title Of Awesomeness',
 323                   'Title Of More Awesomeness']
 324     page.UseCurrentPageForStartup(title_list)
 325     page.VerifyStartupURLs(title_list)
 326     self.assertEqual(RestoreOnStartupType.RESTORE_URLS,
 327         self.GetPrefsInfo().Prefs(pyauto.kRestoreOnStartup))
 328     startup_urls = self.GetPrefsInfo().Prefs(pyauto.kURLsToRestoreOnStartup)
 329     self.assertEqual(len(startup_urls), 3)
 330     self.assertEqual(startup_urls[1], url1)
 331     self.assertEqual(startup_urls[2], url2)
 332
 333   def testCancelStartupURLSetting(self):
 334     """Verify canceled start up URLs settings are not saved."""
 335     page = settings.BasicSettingsPage.FromNavigation(self._driver)
 336     for url in ['www.google.com', 'http://www.amazon.com']:
 337       page.CancelStartupURLSetting(url)
 338     startup_urls = self.GetPrefsInfo().Prefs(pyauto.kURLsToRestoreOnStartup)
 339     self.assertEqual(len(startup_urls), 0)
 340
 341
 342 if __name__ == '__main__':
 343   pyauto_functional.Main()