#!/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()