src/chrome/test/chromedriver/client/chromedriver.py

   1 # Copyright 2013 The Chromium Authors. All rights reserved.
   2 # Use of this source code is governed by a BSD-style license that can be
   3 # found in the LICENSE file.
   4
   5 import command_executor
   6 from command_executor import Command
   7 from webelement import WebElement
   8
   9
  10 class ChromeDriverException(Exception):
  11   pass
  12 class NoSuchElement(ChromeDriverException):
  13   pass
  14 class NoSuchFrame(ChromeDriverException):
  15   pass
  16 class UnknownCommand(ChromeDriverException):
  17   pass
  18 class StaleElementReference(ChromeDriverException):
  19   pass
  20 class UnknownError(ChromeDriverException):
  21   pass
  22 class JavaScriptError(ChromeDriverException):
  23   pass
  24 class XPathLookupError(ChromeDriverException):
  25   pass
  26 class NoSuchWindow(ChromeDriverException):
  27   pass
  28 class InvalidCookieDomain(ChromeDriverException):
  29   pass
  30 class ScriptTimeout(ChromeDriverException):
  31   pass
  32 class InvalidSelector(ChromeDriverException):
  33   pass
  34 class SessionNotCreatedException(ChromeDriverException):
  35   pass
  36 class NoSuchSession(ChromeDriverException):
  37   pass
  38
  39 def _ExceptionForResponse(response):
  40   exception_class_map = {
  41     6: NoSuchSession,
  42     7: NoSuchElement,
  43     8: NoSuchFrame,
  44     9: UnknownCommand,
  45     10: StaleElementReference,
  46     13: UnknownError,
  47     17: JavaScriptError,
  48     19: XPathLookupError,
  49     23: NoSuchWindow,
  50     24: InvalidCookieDomain,
  51     28: ScriptTimeout,
  52     32: InvalidSelector,
  53     33: SessionNotCreatedException
  54   }
  55   status = response['status']
  56   msg = response['value']['message']
  57   return exception_class_map.get(status, ChromeDriverException)(msg)
  58
  59
  60 class ChromeDriver(object):
  61   """Starts and controls a single Chrome instance on this machine."""
  62
  63   def __init__(self, server_url, chrome_binary=None, android_package=None,
  64                android_activity=None, android_process=None,
  65                android_use_running_app=None, chrome_switches=None,
  66                chrome_extensions=None, chrome_log_path=None,
  67                debugger_address=None, browser_log_level=None,
  68                experimental_options=None):
  69     self._executor = command_executor.CommandExecutor(server_url)
  70
  71     options = {}
  72
  73     if experimental_options:
  74       assert isinstance(experimental_options, dict)
  75       options = experimental_options.copy()
  76
  77     if android_package:
  78       options['androidPackage'] = android_package
  79       if android_activity:
  80         options['androidActivity'] = android_activity
  81       if android_process:
  82         options['androidProcess'] = android_process
  83       if android_use_running_app:
  84         options['androidUseRunningApp'] = android_use_running_app
  85     elif chrome_binary:
  86       options['binary'] = chrome_binary
  87
  88     if chrome_switches:
  89       assert type(chrome_switches) is list
  90       options['args'] = chrome_switches
  91
  92     if chrome_extensions:
  93       assert type(chrome_extensions) is list
  94       options['extensions'] = chrome_extensions
  95
  96     if chrome_log_path:
  97       assert type(chrome_log_path) is str
  98       options['logPath'] = chrome_log_path
  99
 100     if debugger_address:
 101       assert type(debugger_address) is str
 102       options['debuggerAddress'] = debugger_address
 103
 104     logging_prefs = {}
 105     log_levels = ['ALL', 'DEBUG', 'INFO', 'WARNING', 'SEVERE', 'OFF']
 106     if browser_log_level:
 107       assert browser_log_level in log_levels
 108       logging_prefs['browser'] = browser_log_level
 109
 110     params = {
 111       'desiredCapabilities': {
 112         'chromeOptions': options,
 113         'loggingPrefs': logging_prefs
 114       }
 115     }
 116
 117     response = self._ExecuteCommand(Command.NEW_SESSION, params)
 118     self._session_id = response['sessionId']
 119     self.capabilities = self._UnwrapValue(response['value'])
 120
 121   def _WrapValue(self, value):
 122     """Wrap value from client side for chromedriver side."""
 123     if isinstance(value, dict):
 124       converted = {}
 125       for key, val in value.items():
 126         converted[key] = self._WrapValue(val)
 127       return converted
 128     elif isinstance(value, WebElement):
 129       return {'ELEMENT': value._id}
 130     elif isinstance(value, list):
 131       return list(self._WrapValue(item) for item in value)
 132     else:
 133       return value
 134
 135   def _UnwrapValue(self, value):
 136     """Unwrap value from chromedriver side for client side."""
 137     if isinstance(value, dict):
 138       if (len(value) == 1 and 'ELEMENT' in value
 139           and isinstance(value['ELEMENT'], basestring)):
 140         return WebElement(self, value['ELEMENT'])
 141       else:
 142         unwraped = {}
 143         for key, val in value.items():
 144           unwraped[key] = self._UnwrapValue(val)
 145         return unwraped
 146     elif isinstance(value, list):
 147       return list(self._UnwrapValue(item) for item in value)
 148     else:
 149       return value
 150
 151   def _ExecuteCommand(self, command, params={}):
 152     params = self._WrapValue(params)
 153     response = self._executor.Execute(command, params)
 154     if response['status'] != 0:
 155       raise _ExceptionForResponse(response)
 156     return response
 157
 158   def ExecuteCommand(self, command, params={}):
 159     params['sessionId'] = self._session_id
 160     response = self._ExecuteCommand(command, params)
 161     return self._UnwrapValue(response['value'])
 162
 163   def GetWindowHandles(self):
 164     return self.ExecuteCommand(Command.GET_WINDOW_HANDLES)
 165
 166   def SwitchToWindow(self, handle_or_name):
 167     self.ExecuteCommand(Command.SWITCH_TO_WINDOW, {'name': handle_or_name})
 168
 169   def GetCurrentWindowHandle(self):
 170     return self.ExecuteCommand(Command.GET_CURRENT_WINDOW_HANDLE)
 171
 172   def CloseWindow(self):
 173     self.ExecuteCommand(Command.CLOSE)
 174
 175   def Load(self, url):
 176     self.ExecuteCommand(Command.GET, {'url': url})
 177
 178   def ExecuteScript(self, script, *args):
 179     converted_args = list(args)
 180     return self.ExecuteCommand(
 181         Command.EXECUTE_SCRIPT, {'script': script, 'args': converted_args})
 182
 183   def ExecuteAsyncScript(self, script, *args):
 184     converted_args = list(args)
 185     return self.ExecuteCommand(
 186         Command.EXECUTE_ASYNC_SCRIPT,
 187         {'script': script, 'args': converted_args})
 188
 189   def SwitchToFrame(self, id_or_name):
 190     self.ExecuteCommand(Command.SWITCH_TO_FRAME, {'id': id_or_name})
 191
 192   def SwitchToFrameByIndex(self, index):
 193     self.SwitchToFrame(index)
 194
 195   def SwitchToMainFrame(self):
 196     self.SwitchToFrame(None)
 197
 198   def GetTitle(self):
 199     return self.ExecuteCommand(Command.GET_TITLE)
 200
 201   def GetPageSource(self):
 202     return self.ExecuteCommand(Command.GET_PAGE_SOURCE)
 203
 204   def FindElement(self, strategy, target):
 205     return self.ExecuteCommand(
 206         Command.FIND_ELEMENT, {'using': strategy, 'value': target})
 207
 208   def FindElements(self, strategy, target):
 209     return self.ExecuteCommand(
 210         Command.FIND_ELEMENTS, {'using': strategy, 'value': target})
 211
 212   def SetTimeout(self, type, timeout):
 213     return self.ExecuteCommand(
 214         Command.SET_TIMEOUT, {'type' : type, 'ms': timeout})
 215
 216   def GetCurrentUrl(self):
 217     return self.ExecuteCommand(Command.GET_CURRENT_URL)
 218
 219   def GoBack(self):
 220     return self.ExecuteCommand(Command.GO_BACK)
 221
 222   def GoForward(self):
 223     return self.ExecuteCommand(Command.GO_FORWARD)
 224
 225   def Refresh(self):
 226     return self.ExecuteCommand(Command.REFRESH)
 227
 228   def MouseMoveTo(self, element=None, x_offset=None, y_offset=None):
 229     params = {}
 230     if element is not None:
 231       params['element'] = element._id
 232     if x_offset is not None:
 233       params['xoffset'] = x_offset
 234     if y_offset is not None:
 235       params['yoffset'] = y_offset
 236     self.ExecuteCommand(Command.MOUSE_MOVE_TO, params)
 237
 238   def MouseClick(self, button=0):
 239     self.ExecuteCommand(Command.MOUSE_CLICK, {'button': button})
 240
 241   def MouseButtonDown(self, button=0):
 242     self.ExecuteCommand(Command.MOUSE_BUTTON_DOWN, {'button': button})
 243
 244   def MouseButtonUp(self, button=0):
 245     self.ExecuteCommand(Command.MOUSE_BUTTON_UP, {'button': button})
 246
 247   def MouseDoubleClick(self, button=0):
 248     self.ExecuteCommand(Command.MOUSE_DOUBLE_CLICK, {'button': button})
 249
 250   def TouchDown(self, x, y):
 251     self.ExecuteCommand(Command.TOUCH_DOWN, {'x': x, 'y': y})
 252
 253   def TouchUp(self, x, y):
 254     self.ExecuteCommand(Command.TOUCH_UP, {'x': x, 'y': y})
 255
 256   def TouchMove(self, x, y):
 257     self.ExecuteCommand(Command.TOUCH_MOVE, {'x': x, 'y': y})
 258
 259   def TouchFlick(self, element, xoffset, yoffset, speed):
 260     params = {
 261         'element': element._id,
 262         'xoffset': xoffset,
 263         'yoffset': yoffset,
 264         'speed': speed
 265     }
 266     self.ExecuteCommand(Command.TOUCH_FLICK, params)
 267
 268   def GetCookies(self):
 269     return self.ExecuteCommand(Command.GET_COOKIES)
 270
 271   def AddCookie(self, cookie):
 272     self.ExecuteCommand(Command.ADD_COOKIE, {'cookie': cookie})
 273
 274   def DeleteCookie(self, name):
 275     self.ExecuteCommand(Command.DELETE_COOKIE, {'name': name})
 276
 277   def DeleteAllCookies(self):
 278     self.ExecuteCommand(Command.DELETE_ALL_COOKIES)
 279
 280   def IsAlertOpen(self):
 281     return self.ExecuteCommand(Command.GET_ALERT)
 282
 283   def GetAlertMessage(self):
 284     return self.ExecuteCommand(Command.GET_ALERT_TEXT)
 285
 286   def HandleAlert(self, accept, prompt_text=''):
 287     if prompt_text:
 288       self.ExecuteCommand(Command.SET_ALERT_VALUE, {'text': prompt_text})
 289     if accept:
 290       cmd = Command.ACCEPT_ALERT
 291     else:
 292       cmd = Command.DISMISS_ALERT
 293     self.ExecuteCommand(cmd)
 294
 295   def IsLoading(self):
 296     return self.ExecuteCommand(Command.IS_LOADING)
 297
 298   def GetWindowPosition(self):
 299     position = self.ExecuteCommand(Command.GET_WINDOW_POSITION,
 300                                    {'windowHandle': 'current'})
 301     return [position['x'], position['y']]
 302
 303   def SetWindowPosition(self, x, y):
 304     self.ExecuteCommand(Command.SET_WINDOW_POSITION,
 305                         {'windowHandle': 'current', 'x': x, 'y': y})
 306
 307   def GetWindowSize(self):
 308     size = self.ExecuteCommand(Command.GET_WINDOW_SIZE,
 309                                {'windowHandle': 'current'})
 310     return [size['width'], size['height']]
 311
 312   def SetWindowSize(self, width, height):
 313     self.ExecuteCommand(
 314         Command.SET_WINDOW_SIZE,
 315         {'windowHandle': 'current', 'width': width, 'height': height})
 316
 317   def MaximizeWindow(self):
 318     self.ExecuteCommand(Command.MAXIMIZE_WINDOW, {'windowHandle': 'current'})
 319
 320   def Quit(self):
 321     """Quits the browser and ends the session."""
 322     self.ExecuteCommand(Command.QUIT)
 323
 324   def GetLog(self, type):
 325     return self.ExecuteCommand(Command.GET_LOG, {'type': type})
 326
 327   def GetAvailableLogTypes(self):
 328     return self.ExecuteCommand(Command.GET_AVAILABLE_LOG_TYPES)
 329
 330   def IsAutoReporting(self):
 331     return self.ExecuteCommand(Command.IS_AUTO_REPORTING)
 332
 333   def SetAutoReporting(self, enabled):
 334     self.ExecuteCommand(Command.SET_AUTO_REPORTING, {'enabled': enabled})