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.
5 import command_executor
6 from command_executor import Command
7 from webelement import WebElement
10 class ChromeDriverException(Exception):
12 class NoSuchElement(ChromeDriverException):
14 class NoSuchFrame(ChromeDriverException):
16 class UnknownCommand(ChromeDriverException):
18 class StaleElementReference(ChromeDriverException):
20 class UnknownError(ChromeDriverException):
22 class JavaScriptError(ChromeDriverException):
24 class XPathLookupError(ChromeDriverException):
26 class NoSuchWindow(ChromeDriverException):
28 class InvalidCookieDomain(ChromeDriverException):
30 class ScriptTimeout(ChromeDriverException):
32 class InvalidSelector(ChromeDriverException):
34 class SessionNotCreatedException(ChromeDriverException):
36 class NoSuchSession(ChromeDriverException):
39 def _ExceptionForResponse(response):
40 exception_class_map = {
45 10: StaleElementReference,
50 24: InvalidCookieDomain,
53 33: SessionNotCreatedException
55 status = response['status']
56 msg = response['value']['message']
57 return exception_class_map.get(status, ChromeDriverException)(msg)
60 class ChromeDriver(object):
61 """Starts and controls a single Chrome instance on this machine."""
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 performance_log_level=None, mobile_emulation=None,
69 experimental_options=None, download_dir=None):
70 self._executor = command_executor.CommandExecutor(server_url)
74 if experimental_options:
75 assert isinstance(experimental_options, dict)
76 options = experimental_options.copy()
79 options['androidPackage'] = android_package
81 options['androidActivity'] = android_activity
83 options['androidProcess'] = android_process
84 if android_use_running_app:
85 options['androidUseRunningApp'] = android_use_running_app
87 options['binary'] = chrome_binary
90 assert type(chrome_switches) is list
91 options['args'] = chrome_switches
94 assert type(mobile_emulation) is dict
95 options['mobileEmulation'] = mobile_emulation
98 assert type(chrome_extensions) is list
99 options['extensions'] = chrome_extensions
102 assert type(chrome_log_path) is str
103 options['logPath'] = chrome_log_path
106 assert type(debugger_address) is str
107 options['debuggerAddress'] = debugger_address
110 log_levels = ['ALL', 'DEBUG', 'INFO', 'WARNING', 'SEVERE', 'OFF']
111 if browser_log_level:
112 assert browser_log_level in log_levels
113 logging_prefs['browser'] = browser_log_level
114 if performance_log_level:
115 assert performance_log_level in log_levels
116 logging_prefs['performance'] = performance_log_level
120 if 'prefs' not in options:
121 options['prefs'] = {}
122 if 'download' not in options['prefs']:
123 options['prefs']['download'] = {}
124 options['prefs']['download']['default_directory'] = download_dir
127 'desiredCapabilities': {
128 'chromeOptions': options,
129 'loggingPrefs': logging_prefs
133 response = self._ExecuteCommand(Command.NEW_SESSION, params)
134 self._session_id = response['sessionId']
135 self.capabilities = self._UnwrapValue(response['value'])
137 def _WrapValue(self, value):
138 """Wrap value from client side for chromedriver side."""
139 if isinstance(value, dict):
141 for key, val in value.items():
142 converted[key] = self._WrapValue(val)
144 elif isinstance(value, WebElement):
145 return {'ELEMENT': value._id}
146 elif isinstance(value, list):
147 return list(self._WrapValue(item) for item in value)
151 def _UnwrapValue(self, value):
152 """Unwrap value from chromedriver side for client side."""
153 if isinstance(value, dict):
154 if (len(value) == 1 and 'ELEMENT' in value
155 and isinstance(value['ELEMENT'], basestring)):
156 return WebElement(self, value['ELEMENT'])
159 for key, val in value.items():
160 unwraped[key] = self._UnwrapValue(val)
162 elif isinstance(value, list):
163 return list(self._UnwrapValue(item) for item in value)
167 def _ExecuteCommand(self, command, params={}):
168 params = self._WrapValue(params)
169 response = self._executor.Execute(command, params)
170 if response['status'] != 0:
171 raise _ExceptionForResponse(response)
174 def ExecuteCommand(self, command, params={}):
175 params['sessionId'] = self._session_id
176 response = self._ExecuteCommand(command, params)
177 return self._UnwrapValue(response['value'])
179 def GetWindowHandles(self):
180 return self.ExecuteCommand(Command.GET_WINDOW_HANDLES)
182 def SwitchToWindow(self, handle_or_name):
183 self.ExecuteCommand(Command.SWITCH_TO_WINDOW, {'name': handle_or_name})
185 def GetCurrentWindowHandle(self):
186 return self.ExecuteCommand(Command.GET_CURRENT_WINDOW_HANDLE)
188 def CloseWindow(self):
189 self.ExecuteCommand(Command.CLOSE)
192 self.ExecuteCommand(Command.GET, {'url': url})
194 def LaunchApp(self, app_id):
195 self.ExecuteCommand(Command.LAUNCH_APP, {'id': app_id})
197 def ExecuteScript(self, script, *args):
198 converted_args = list(args)
199 return self.ExecuteCommand(
200 Command.EXECUTE_SCRIPT, {'script': script, 'args': converted_args})
202 def ExecuteAsyncScript(self, script, *args):
203 converted_args = list(args)
204 return self.ExecuteCommand(
205 Command.EXECUTE_ASYNC_SCRIPT,
206 {'script': script, 'args': converted_args})
208 def SwitchToFrame(self, id_or_name):
209 self.ExecuteCommand(Command.SWITCH_TO_FRAME, {'id': id_or_name})
211 def SwitchToFrameByIndex(self, index):
212 self.SwitchToFrame(index)
214 def SwitchToMainFrame(self):
215 self.SwitchToFrame(None)
217 def SwitchToParentFrame(self):
218 self.ExecuteCommand(Command.SWITCH_TO_PARENT_FRAME)
221 return self.ExecuteCommand(Command.GET_TITLE)
223 def GetPageSource(self):
224 return self.ExecuteCommand(Command.GET_PAGE_SOURCE)
226 def FindElement(self, strategy, target):
227 return self.ExecuteCommand(
228 Command.FIND_ELEMENT, {'using': strategy, 'value': target})
230 def FindElements(self, strategy, target):
231 return self.ExecuteCommand(
232 Command.FIND_ELEMENTS, {'using': strategy, 'value': target})
234 def SetTimeout(self, type, timeout):
235 return self.ExecuteCommand(
236 Command.SET_TIMEOUT, {'type' : type, 'ms': timeout})
238 def GetCurrentUrl(self):
239 return self.ExecuteCommand(Command.GET_CURRENT_URL)
242 return self.ExecuteCommand(Command.GO_BACK)
245 return self.ExecuteCommand(Command.GO_FORWARD)
248 return self.ExecuteCommand(Command.REFRESH)
250 def MouseMoveTo(self, element=None, x_offset=None, y_offset=None):
252 if element is not None:
253 params['element'] = element._id
254 if x_offset is not None:
255 params['xoffset'] = x_offset
256 if y_offset is not None:
257 params['yoffset'] = y_offset
258 self.ExecuteCommand(Command.MOUSE_MOVE_TO, params)
260 def MouseClick(self, button=0):
261 self.ExecuteCommand(Command.MOUSE_CLICK, {'button': button})
263 def MouseButtonDown(self, button=0):
264 self.ExecuteCommand(Command.MOUSE_BUTTON_DOWN, {'button': button})
266 def MouseButtonUp(self, button=0):
267 self.ExecuteCommand(Command.MOUSE_BUTTON_UP, {'button': button})
269 def MouseDoubleClick(self, button=0):
270 self.ExecuteCommand(Command.MOUSE_DOUBLE_CLICK, {'button': button})
272 def TouchDown(self, x, y):
273 self.ExecuteCommand(Command.TOUCH_DOWN, {'x': x, 'y': y})
275 def TouchUp(self, x, y):
276 self.ExecuteCommand(Command.TOUCH_UP, {'x': x, 'y': y})
278 def TouchMove(self, x, y):
279 self.ExecuteCommand(Command.TOUCH_MOVE, {'x': x, 'y': y})
281 def TouchFlick(self, element, xoffset, yoffset, speed):
283 'element': element._id,
288 self.ExecuteCommand(Command.TOUCH_FLICK, params)
290 def GetCookies(self):
291 return self.ExecuteCommand(Command.GET_COOKIES)
293 def AddCookie(self, cookie):
294 self.ExecuteCommand(Command.ADD_COOKIE, {'cookie': cookie})
296 def DeleteCookie(self, name):
297 self.ExecuteCommand(Command.DELETE_COOKIE, {'name': name})
299 def DeleteAllCookies(self):
300 self.ExecuteCommand(Command.DELETE_ALL_COOKIES)
302 def IsAlertOpen(self):
303 return self.ExecuteCommand(Command.GET_ALERT)
305 def GetAlertMessage(self):
306 return self.ExecuteCommand(Command.GET_ALERT_TEXT)
308 def HandleAlert(self, accept, prompt_text=''):
310 self.ExecuteCommand(Command.SET_ALERT_VALUE, {'text': prompt_text})
312 cmd = Command.ACCEPT_ALERT
314 cmd = Command.DISMISS_ALERT
315 self.ExecuteCommand(cmd)
318 return self.ExecuteCommand(Command.IS_LOADING)
320 def GetWindowPosition(self):
321 position = self.ExecuteCommand(Command.GET_WINDOW_POSITION,
322 {'windowHandle': 'current'})
323 return [position['x'], position['y']]
325 def SetWindowPosition(self, x, y):
326 self.ExecuteCommand(Command.SET_WINDOW_POSITION,
327 {'windowHandle': 'current', 'x': x, 'y': y})
329 def GetWindowSize(self):
330 size = self.ExecuteCommand(Command.GET_WINDOW_SIZE,
331 {'windowHandle': 'current'})
332 return [size['width'], size['height']]
334 def SetWindowSize(self, width, height):
336 Command.SET_WINDOW_SIZE,
337 {'windowHandle': 'current', 'width': width, 'height': height})
339 def MaximizeWindow(self):
340 self.ExecuteCommand(Command.MAXIMIZE_WINDOW, {'windowHandle': 'current'})
343 """Quits the browser and ends the session."""
344 self.ExecuteCommand(Command.QUIT)
346 def GetLog(self, type):
347 return self.ExecuteCommand(Command.GET_LOG, {'type': type})
349 def GetAvailableLogTypes(self):
350 return self.ExecuteCommand(Command.GET_AVAILABLE_LOG_TYPES)
352 def IsAutoReporting(self):
353 return self.ExecuteCommand(Command.IS_AUTO_REPORTING)
355 def SetAutoReporting(self, enabled):
356 self.ExecuteCommand(Command.SET_AUTO_REPORTING, {'enabled': enabled})