| #!/usr/bin/env python |
| # Copyright (c) 2011 The Chromium Authors. All rights reserved. |
| # Use of this source code is governed by a BSD-style license that can be |
| # found in the LICENSE file. |
| |
| """ |
| This module is a simple qa tool that installs extensions and tests whether the |
| browser crashes while visiting a list of urls. |
| |
| Usage: python extensions.py -v |
| |
| Note: This assumes that there is a directory of extensions called |
| 'extensions-tool' and that there is a file of newline-separated urls to visit |
| called 'urls.txt' in the data directory. |
| """ |
| |
| import glob |
| import logging |
| import os |
| import sys |
| |
| import pyauto_functional # must be imported before pyauto |
| import pyauto |
| |
| |
| class ExtensionsPage(object): |
| """Access options in extensions page (chrome://extensions-frame).""" |
| |
| _URL = 'chrome://extensions-frame' |
| |
| def __init__(self, driver): |
| self._driver = driver |
| self._driver.get(ExtensionsPage._URL) |
| |
| def CheckExtensionVisible(self, ext_id): |
| """Returns True if |ext_id| exists on page.""" |
| return len(self._driver.find_elements_by_id(ext_id)) == 1 |
| |
| def SetEnabled(self, ext_id, enabled): |
| """Clicks on 'Enabled' checkbox for specified extension. |
| |
| Args: |
| ext_id: Extension ID to be enabled or disabled. |
| enabled: Boolean indicating whether |ext_id| is to be enabled or disabled. |
| """ |
| checkbox = self._driver.find_element_by_xpath( |
| '//*[@id="%s"]//*[@class="enable-controls"]//*[@type="checkbox"]' % |
| ext_id) |
| if checkbox != enabled: |
| checkbox.click() |
| # Reload page to ensure that the UI is recreated. |
| self._driver.get(ExtensionsPage._URL) |
| |
| def SetAllowInIncognito(self, ext_id, allowed): |
| """Clicks on 'Allow in incognito' checkbox for specified extension. |
| |
| Args: |
| ext_id: Extension ID to be enabled or disabled. |
| allowed: Boolean indicating whether |ext_id| is to be allowed or |
| disallowed in incognito. |
| """ |
| checkbox = self._driver.find_element_by_xpath( |
| '//*[@id="%s"]//*[@class="incognito-control"]//*[@type="checkbox"]' % |
| ext_id) |
| if checkbox.is_selected() != allowed: |
| checkbox.click() |
| # Reload page to ensure that the UI is recreated. |
| self._driver.get(ExtensionsPage._URL) |
| |
| def SetAllowAccessFileURLs(self, ext_id, allowed): |
| """Clicks on 'Allow access to file URLs' checkbox for specified extension. |
| |
| Args: |
| ext_id: Extension ID to be enabled or disabled. |
| allowed: Boolean indicating whether |ext_id| is to be allowed access to |
| file URLs. |
| """ |
| checkbox = self._driver.find_element_by_xpath( |
| '//*[@id="%s"]//*[@class="file-access-control"]//*[@type="checkbox"]' % |
| ext_id) |
| if checkbox.is_selected() != allowed: |
| checkbox.click() |
| |
| |
| class ExtensionsTest(pyauto.PyUITest): |
| """Test of extensions.""" |
| |
| def Debug(self): |
| """Test method for experimentation. |
| |
| This method is not run automatically. |
| """ |
| while True: |
| raw_input('Interact with the browser and hit <enter> to dump history.') |
| print '*' * 20 |
| self.pprint(self.GetExtensionsInfo()) |
| |
| def _GetInstalledExtensionIds(self): |
| return [extension['id'] for extension in self.GetExtensionsInfo()] |
| |
| def _ReturnCrashingExtensions(self, extensions, group_size, top_urls): |
| """Returns the group of extensions that crashes (if any). |
| |
| Install the given extensions in groups of group_size and return the |
| group of extensions that crashes (if any). |
| |
| Args: |
| extensions: A list of extensions to install. |
| group_size: The number of extensions to install at one time. |
| top_urls: The list of top urls to visit. |
| |
| Returns: |
| The extensions in the crashing group or None if there is no crash. |
| """ |
| curr_extension = 0 |
| num_extensions = len(extensions) |
| self.RestartBrowser() |
| orig_extension_ids = self._GetInstalledExtensionIds() |
| |
| while curr_extension < num_extensions: |
| logging.debug('New group of %d extensions.', group_size) |
| group_end = curr_extension + group_size |
| for extension in extensions[curr_extension:group_end]: |
| logging.debug('Installing extension: %s', extension) |
| self.InstallExtension(extension) |
| |
| for url in top_urls: |
| self.NavigateToURL(url) |
| |
| def _LogAndReturnCrashing(): |
| crashing_extensions = extensions[curr_extension:group_end] |
| logging.debug('Crashing extensions: %s', crashing_extensions) |
| return crashing_extensions |
| |
| # If the browser has crashed, return the extensions in the failing group. |
| try: |
| num_browser_windows = self.GetBrowserWindowCount() |
| except: |
| return _LogAndReturnCrashing() |
| else: |
| if not num_browser_windows: |
| return _LogAndReturnCrashing() |
| else: |
| # Uninstall all extensions that aren't installed by default. |
| new_extension_ids = [id for id in self._GetInstalledExtensionIds() |
| if id not in orig_extension_ids] |
| for extension_id in new_extension_ids: |
| self.UninstallExtensionById(extension_id) |
| |
| curr_extension = group_end |
| |
| # None of the extensions crashed. |
| return None |
| |
| def _GetExtensionInfoById(self, extensions, id): |
| for x in extensions: |
| if x['id'] == id: |
| return x |
| return None |
| |
| def ExtensionCrashes(self): |
| """Add top extensions; confirm browser stays up when visiting top urls.""" |
| # TODO: provide a way in pyauto to pass args to a test - take these as args |
| extensions_dir = os.path.join(self.DataDir(), 'extensions-tool') |
| urls_file = os.path.join(self.DataDir(), 'urls.txt') |
| |
| error_msg = 'The dir "%s" must exist' % os.path.abspath(extensions_dir) |
| assert os.path.exists(extensions_dir), error_msg |
| error_msg = 'The file "%s" must exist' % os.path.abspath(urls_file) |
| assert os.path.exists(urls_file), error_msg |
| |
| num_urls_to_visit = 100 |
| extensions_group_size = 20 |
| |
| top_urls = [l.rstrip() for l in |
| open(urls_file).readlines()[:num_urls_to_visit]] |
| |
| failed_extensions = glob.glob(os.path.join(extensions_dir, '*.crx')) |
| group_size = extensions_group_size |
| |
| while (group_size and failed_extensions): |
| failed_extensions = self._ReturnCrashingExtensions( |
| failed_extensions, group_size, top_urls) |
| group_size = group_size // 2 |
| |
| self.assertFalse(failed_extensions, |
| 'Extension(s) in failing group: %s' % failed_extensions) |
| |
| def _InstallExtensionCheckDefaults(self, crx_file): |
| """Installs extension at extensions/|crx_file| and checks default status. |
| |
| Checks that the installed extension is enabled and not allowed in incognito. |
| |
| Args: |
| crx_file: Relative path from self.DataDir()/extensions to .crx extension |
| to be installed. |
| |
| Returns: |
| The extension ID. |
| """ |
| crx_file_path = os.path.abspath( |
| os.path.join(self.DataDir(), 'extensions', crx_file)) |
| ext_id = self.InstallExtension(crx_file_path) |
| extension = self._GetExtensionInfoById(self.GetExtensionsInfo(), ext_id) |
| self.assertTrue(extension['is_enabled'], |
| msg='Extension was not enabled on installation') |
| self.assertFalse(extension['allowed_in_incognito'], |
| msg='Extension was allowed in incognito on installation.') |
| |
| return ext_id |
| |
| def _ExtensionValue(self, ext_id, key): |
| """Returns the value of |key| for |ext_id|. |
| |
| Args: |
| ext_id: The extension ID. |
| key: The key for which the extensions info value is required. |
| |
| Returns: |
| The value of extensions info |key| for |ext_id|. |
| """ |
| return self._GetExtensionInfoById(self.GetExtensionsInfo(), ext_id)[key] |
| |
| def _FileAccess(self, ext_id): |
| """Returns the value of newAllowFileAccess for |ext_id|. |
| |
| Args: |
| ext_id: The extension ID. |
| |
| Returns: |
| The value of extensions settings newAllowFileAccess for |ext_id|. |
| """ |
| extension_settings = self.GetPrefsInfo().Prefs()['extensions']['settings'] |
| return extension_settings[ext_id]['newAllowFileAccess'] |
| |
| def testGetExtensionPermissions(self): |
| """Ensures we can retrieve the host/api permissions for an extension. |
| |
| This test assumes that the 'Bookmark Manager' extension exists in a fresh |
| profile. |
| """ |
| extensions_info = self.GetExtensionsInfo() |
| bm_exts = [x for x in extensions_info if x['name'] == 'Bookmark Manager'] |
| self.assertTrue(bm_exts, |
| msg='Could not find info for the Bookmark Manager ' |
| 'extension.') |
| ext = bm_exts[0] |
| |
| permissions_host = ext['host_permissions'] |
| self.assertTrue(len(permissions_host) == 2 and |
| 'chrome://favicon/*' in permissions_host and |
| 'chrome://resources/*' in permissions_host, |
| msg='Unexpected host permissions information.') |
| |
| permissions_api = ext['api_permissions'] |
| print permissions_api |
| self.assertTrue(len(permissions_api) == 5 and |
| 'bookmarks' in permissions_api and |
| 'bookmarkManagerPrivate' in permissions_api and |
| 'metricsPrivate' in permissions_api and |
| 'systemPrivate' in permissions_api and |
| 'tabs' in permissions_api, |
| msg='Unexpected API permissions information.') |
| |
| def testDisableEnableExtension(self): |
| """Tests that an extension can be disabled and enabled with the UI.""" |
| ext_id = self._InstallExtensionCheckDefaults('good.crx') |
| |
| # Disable extension. |
| driver = self.NewWebDriver() |
| ext_page = ExtensionsPage(driver) |
| self.WaitUntil(ext_page.CheckExtensionVisible, args=[ext_id]) |
| ext_page.SetEnabled(ext_id, False) |
| self.WaitUntil(self._ExtensionValue, args=[ext_id, 'is_enabled'], |
| expect_retval=False) |
| self.assertFalse(self._ExtensionValue(ext_id, 'is_enabled'), |
| msg='Extension did not get disabled.') |
| |
| # Enable extension. |
| self.WaitUntil(ext_page.CheckExtensionVisible, args=[ext_id]) |
| ext_page.SetEnabled(ext_id, True) |
| self.WaitUntil(self._ExtensionValue, args=[ext_id, 'is_enabled'], |
| expect_retval=True) |
| self.assertTrue(self._ExtensionValue(ext_id, 'is_enabled'), |
| msg='Extension did not get enabled.') |
| |
| def testAllowIncognitoExtension(self): |
| """Tests allowing and disallowing an extension in incognito mode.""" |
| ext_id = self._InstallExtensionCheckDefaults('good.crx') |
| |
| # Allow in incognito. |
| driver = self.NewWebDriver() |
| ext_page = ExtensionsPage(driver) |
| self.WaitUntil(ext_page.CheckExtensionVisible, args=[ext_id]) |
| ext_page.SetAllowInIncognito(ext_id, True) |
| |
| # Check extension now allowed in incognito. |
| self.WaitUntil(self._ExtensionValue, args=[ext_id, 'allowed_in_incognito'], |
| expect_retval=True) |
| self.assertTrue(self._ExtensionValue(ext_id, 'allowed_in_incognito'), |
| msg='Extension did not get allowed in incognito.') |
| |
| # Disallow in incognito. |
| self.WaitUntil(ext_page.CheckExtensionVisible, args=[ext_id]) |
| ext_page.SetAllowInIncognito(ext_id, False) |
| |
| # Check extension now disallowed in incognito. |
| self.WaitUntil(self._ExtensionValue, args=[ext_id, 'allowed_in_incognito'], |
| expect_retval=False) |
| self.assertFalse(self._ExtensionValue(ext_id, 'allowed_in_incognito'), |
| msg='Extension did not get disallowed in incognito.') |
| |
| def testAllowAccessFileURLs(self): |
| """Tests disallowing and allowing and extension access to file URLs.""" |
| ext_id = self._InstallExtensionCheckDefaults(os.path.join('permissions', |
| 'files')) |
| |
| # Check extension allowed access to file URLs by default. |
| extension_settings = self.GetPrefsInfo().Prefs()['extensions']['settings'] |
| self.assertTrue(extension_settings[ext_id]['newAllowFileAccess'], |
| msg='Extension was not allowed access to file URLs on ' |
| 'installation') |
| |
| # Disallow access to file URLs. |
| driver = self.NewWebDriver() |
| ext_page = ExtensionsPage(driver) |
| self.WaitUntil(ext_page.CheckExtensionVisible, args=[ext_id]) |
| ext_page.SetAllowAccessFileURLs(ext_id, False) |
| |
| # Check that extension does not have access to file URLs. |
| self.WaitUntil(self._FileAccess, args=[ext_id], expect_retval=False) |
| self.assertFalse(self._FileAccess(ext_id), |
| msg='Extension did not have access to file URLs denied.') |
| |
| # Allow access to file URLs. |
| self.WaitUntil(ext_page.CheckExtensionVisible, args=[ext_id]) |
| ext_page.SetAllowAccessFileURLs(ext_id, True) |
| |
| # Check that extension now has access to file URLs. |
| self.WaitUntil(self._FileAccess, args=[ext_id], expect_retval=True) |
| self.assertTrue(self._FileAccess(ext_id), |
| msg='Extension did not have access to file URLs granted.') |
| |
| |
| if __name__ == '__main__': |
| pyauto_functional.Main() |
