Remove pyauto tests.

chrome/test/functional/extensions.py

Index: chrome/test/functional/extensions.py
===================================================================
--- chrome/test/functional/extensions.py	(revision 261231)
+++ chrome/test/functional/extensions.py	(working copy)
@@ -1,346 +0,0 @@
-#!/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()