1
2 """
3 Copyright 2006 ThoughtWorks, Inc.
4
5 Licensed under the Apache License, Version 2.0 (the "License");
6 you may not use this file except in compliance with the License.
7 You may obtain a copy of the License at
8
9 http://www.apache.org/licenses/LICENSE-2.0
10
11 Unless required by applicable law or agreed to in writing, software
12 distributed under the License is distributed on an "AS IS" BASIS,
13 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 See the License for the specific language governing permissions and
15 limitations under the License.
16 """
17 __docformat__ = "restructuredtext en"
18
19
20
21 import httplib
22 import urllib
23 import re
24
26 """
27 Defines an object that runs Selenium commands.
28
29 Element Locators
30 ~~~~~~~~~~~~~~~~
31
32 Element Locators tell Selenium which HTML element a command refers to.
33 The format of a locator is:
34
35 \ *locatorType*\ **=**\ \ *argument*
36
37
38 We support the following strategies for locating elements:
39
40
41 * \ **identifier**\ =\ *id*:
42 Select the element with the specified @id attribute. If no match is
43 found, select the first element whose @name attribute is \ *id*.
44 (This is normally the default; see below.)
45 * \ **id**\ =\ *id*:
46 Select the element with the specified @id attribute.
47 * \ **name**\ =\ *name*:
48 Select the first element with the specified @name attribute.
49
50 * username
51 * name=username
52
53
54 The name may optionally be followed by one or more \ *element-filters*, separated from the name by whitespace. If the \ *filterType* is not specified, \ **value**\ is assumed.
55
56 * name=flavour value=chocolate
57
58
59 * \ **dom**\ =\ *javascriptExpression*:
60
61 Find an element by evaluating the specified string. This allows you to traverse the HTML Document Object
62 Model using JavaScript. Note that you must not return a value in this string; simply make it the last expression in the block.
63
64 * dom=document.forms['myForm'].myDropdown
65 * dom=document.images[56]
66 * dom=function foo() { return document.links[1]; }; foo();
67
68
69 * \ **xpath**\ =\ *xpathExpression*:
70 Locate an element using an XPath expression.
71
72 * xpath=//img[@alt='The image alt text']
73 * xpath=//table[@id='table1']//tr[4]/td[2]
74 * xpath=//a[contains(@href,'#id1')]
75 * xpath=//a[contains(@href,'#id1')]/@class
76 * xpath=(//table[@class='stylee'])//th[text()='theHeaderText']/../td
77 * xpath=//input[@name='name2' and @value='yes']
78 * xpath=//\*[text()="right"]
79
80
81 * \ **link**\ =\ *textPattern*:
82 Select the link (anchor) element which contains text matching the
83 specified \ *pattern*.
84
85 * link=The link text
86
87
88 * \ **css**\ =\ *cssSelectorSyntax*:
89 Select the element using css selectors. Please refer to CSS2 selectors, CSS3 selectors for more information. You can also check the TestCssLocators test in the selenium test suite for an example of usage, which is included in the downloaded selenium core package.
90
91 * css=a[href="#id3"]
92 * css=span#firstChild + span
93
94
95 Currently the css selector locator supports all css1, css2 and css3 selectors except namespace in css3, some pseudo classes(:nth-of-type, :nth-last-of-type, :first-of-type, :last-of-type, :only-of-type, :visited, :hover, :active, :focus, :indeterminate) and pseudo elements(::first-line, ::first-letter, ::selection, ::before, ::after).
96
97 * \ **ui**\ =\ *uiSpecifierString*:
98 Locate an element by resolving the UI specifier string to another locator, and evaluating it. See the Selenium UI-Element Reference for more details.
99
100 * ui=loginPages::loginButton()
101 * ui=settingsPages::toggle(label=Hide Email)
102 * ui=forumPages::postBody(index=2)//a[2]
103
104
105
106
107
108 Without an explicit locator prefix, Selenium uses the following default
109 strategies:
110
111
112 * \ **dom**\ , for locators starting with "document."
113 * \ **xpath**\ , for locators starting with "//"
114 * \ **identifier**\ , otherwise
115
116 Element Filters
117 ~~~~~~~~~~~~~~~
118
119 Element filters can be used with a locator to refine a list of candidate elements. They are currently used only in the 'name' element-locator.
120
121 Filters look much like locators, ie.
122
123 \ *filterType*\ **=**\ \ *argument*
124
125 Supported element-filters are:
126
127 \ **value=**\ \ *valuePattern*
128
129
130 Matches elements based on their values. This is particularly useful for refining a list of similarly-named toggle-buttons.
131
132 \ **index=**\ \ *index*
133
134
135 Selects a single element based on its position in the list (offset from zero).
136
137 String-match Patterns
138 ~~~~~~~~~~~~~~~~~~~~~
139
140 Various Pattern syntaxes are available for matching string values:
141
142
143 * \ **glob:**\ \ *pattern*:
144 Match a string against a "glob" (aka "wildmat") pattern. "Glob" is a
145 kind of limited regular-expression syntax typically used in command-line
146 shells. In a glob pattern, "\*" represents any sequence of characters, and "?"
147 represents any single character. Glob patterns match against the entire
148 string.
149 * \ **regexp:**\ \ *regexp*:
150 Match a string using a regular-expression. The full power of JavaScript
151 regular-expressions is available.
152 * \ **regexpi:**\ \ *regexpi*:
153 Match a string using a case-insensitive regular-expression.
154 * \ **exact:**\ \ *string*:
155
156 Match a string exactly, verbatim, without any of that fancy wildcard
157 stuff.
158
159
160
161 If no pattern prefix is specified, Selenium assumes that it's a "glob"
162 pattern.
163
164
165
166 For commands that return multiple values (such as verifySelectOptions),
167 the string being matched is a comma-separated list of the return values,
168 where both commas and backslashes in the values are backslash-escaped.
169 When providing a pattern, the optional matching syntax (i.e. glob,
170 regexp, etc.) is specified once, as usual, at the beginning of the
171 pattern.
172
173
174 """
175
176
177 - def __init__(self, host, port, browserStartCommand, browserURL):
178 self.host = host
179 self.port = port
180 self.browserStartCommand = browserStartCommand
181 self.browserURL = browserURL
182 self.sessionId = None
183 self.extensionJs = ""
184
185 - def setExtensionJs(self, extensionJs):
186 self.extensionJs = extensionJs
187
189 result = self.get_string("getNewBrowserSession", [self.browserStartCommand, self.browserURL, self.extensionJs])
190 try:
191 self.sessionId = result
192 except ValueError:
193 raise Exception, result
194
196 self.do_command("testComplete", [])
197 self.sessionId = None
198
200 conn = httplib.HTTPConnection(self.host, self.port)
201 body = u'cmd=' + urllib.quote_plus(unicode(verb).encode('utf-8'))
202 for i in range(len(args)):
203 body += '&' + unicode(i+1) + '=' + urllib.quote_plus(unicode(args[i]).encode('utf-8'))
204 if (None != self.sessionId):
205 body += "&sessionId=" + unicode(self.sessionId)
206 headers = {"Content-Type": "application/x-www-form-urlencoded; charset=utf-8"}
207 conn.request("POST", "/selenium-server/driver/", body, headers)
208
209 response = conn.getresponse()
210
211 data = unicode(response.read(), "UTF-8")
212 result = response.reason
213
214 if (not data.startswith('OK')):
215 raise Exception, data
216 return data
217
219 result = self.do_command(verb, args)
220 return result[3:]
221
223 csv = self.get_string(verb, args)
224 token = ""
225 tokens = []
226 escape = False
227 for i in range(len(csv)):
228 letter = csv[i]
229 if (escape):
230 token = token + letter
231 escape = False
232 continue
233 if (letter == '\\'):
234 escape = True
235 elif (letter == ','):
236 tokens.append(token)
237 token = ""
238 else:
239 token = token + letter
240 tokens.append(token)
241 return tokens
242
246
250
252 boolstr = self.get_string(verb, args)
253 if ("true" == boolstr):
254 return True
255 if ("false" == boolstr):
256 return False
257 raise ValueError, "result is neither 'true' nor 'false': " + boolstr
258
260 boolarr = self.get_string_array(verb, args)
261 for i in range(len(boolarr)):
262 if ("true" == boolstr):
263 boolarr[i] = True
264 continue
265 if ("false" == boolstr):
266 boolarr[i] = False
267 continue
268 raise ValueError, "result is neither 'true' nor 'false': " + boolarr[i]
269 return boolarr
270
271
272
273
274
275
276 - def click(self,locator):
277 """
278 Clicks on a link, button, checkbox or radio button. If the click action
279 causes a new page to load (like a link usually does), call
280 waitForPageToLoad.
281
282 'locator' is an element locator
283 """
284 self.do_command("click", [locator,])
285
286
288 """
289 Double clicks on a link, button, checkbox or radio button. If the double click action
290 causes a new page to load (like a link usually does), call
291 waitForPageToLoad.
292
293 'locator' is an element locator
294 """
295 self.do_command("doubleClick", [locator,])
296
297
299 """
300 Simulates opening the context menu for the specified element (as might happen if the user "right-clicked" on the element).
301
302 'locator' is an element locator
303 """
304 self.do_command("contextMenu", [locator,])
305
306
307 - def click_at(self,locator,coordString):
308 """
309 Clicks on a link, button, checkbox or radio button. If the click action
310 causes a new page to load (like a link usually does), call
311 waitForPageToLoad.
312
313 'locator' is an element locator
314 'coordString' is specifies the x,y position (i.e. - 10,20) of the mouse event relative to the element returned by the locator.
315 """
316 self.do_command("clickAt", [locator,coordString,])
317
318
320 """
321 Doubleclicks on a link, button, checkbox or radio button. If the action
322 causes a new page to load (like a link usually does), call
323 waitForPageToLoad.
324
325 'locator' is an element locator
326 'coordString' is specifies the x,y position (i.e. - 10,20) of the mouse event relative to the element returned by the locator.
327 """
328 self.do_command("doubleClickAt", [locator,coordString,])
329
330
332 """
333 Simulates opening the context menu for the specified element (as might happen if the user "right-clicked" on the element).
334
335 'locator' is an element locator
336 'coordString' is specifies the x,y position (i.e. - 10,20) of the mouse event relative to the element returned by the locator.
337 """
338 self.do_command("contextMenuAt", [locator,coordString,])
339
340
342 """
343 Explicitly simulate an event, to trigger the corresponding "on\ *event*"
344 handler.
345
346 'locator' is an element locator
347 'eventName' is the event name, e.g. "focus" or "blur"
348 """
349 self.do_command("fireEvent", [locator,eventName,])
350
351
352 - def focus(self,locator):
353 """
354 Move the focus to the specified element; for example, if the element is an input field, move the cursor to that field.
355
356 'locator' is an element locator
357 """
358 self.do_command("focus", [locator,])
359
360
362 """
363 Simulates a user pressing and releasing a key.
364
365 'locator' is an element locator
366 'keySequence' is Either be a string("\" followed by the numeric keycode of the key to be pressed, normally the ASCII value of that key), or a single character. For example: "w", "\119".
367 """
368 self.do_command("keyPress", [locator,keySequence,])
369
370
372 """
373 Press the shift key and hold it down until doShiftUp() is called or a new page is loaded.
374
375 """
376 self.do_command("shiftKeyDown", [])
377
378
380 """
381 Release the shift key.
382
383 """
384 self.do_command("shiftKeyUp", [])
385
386
393
394
401
402
404 """
405 Press the alt key and hold it down until doAltUp() is called or a new page is loaded.
406
407 """
408 self.do_command("altKeyDown", [])
409
410
412 """
413 Release the alt key.
414
415 """
416 self.do_command("altKeyUp", [])
417
418
420 """
421 Press the control key and hold it down until doControlUp() is called or a new page is loaded.
422
423 """
424 self.do_command("controlKeyDown", [])
425
426
428 """
429 Release the control key.
430
431 """
432 self.do_command("controlKeyUp", [])
433
434
435 - def key_down(self,locator,keySequence):
436 """
437 Simulates a user pressing a key (without releasing it yet).
438
439 'locator' is an element locator
440 'keySequence' is Either be a string("\" followed by the numeric keycode of the key to be pressed, normally the ASCII value of that key), or a single character. For example: "w", "\119".
441 """
442 self.do_command("keyDown", [locator,keySequence,])
443
444
445 - def key_up(self,locator,keySequence):
446 """
447 Simulates a user releasing a key.
448
449 'locator' is an element locator
450 'keySequence' is Either be a string("\" followed by the numeric keycode of the key to be pressed, normally the ASCII value of that key), or a single character. For example: "w", "\119".
451 """
452 self.do_command("keyUp", [locator,keySequence,])
453
454
456 """
457 Simulates a user hovering a mouse over the specified element.
458
459 'locator' is an element locator
460 """
461 self.do_command("mouseOver", [locator,])
462
463
465 """
466 Simulates a user moving the mouse pointer away from the specified element.
467
468 'locator' is an element locator
469 """
470 self.do_command("mouseOut", [locator,])
471
472
474 """
475 Simulates a user pressing the left mouse button (without releasing it yet) on
476 the specified element.
477
478 'locator' is an element locator
479 """
480 self.do_command("mouseDown", [locator,])
481
482
484 """
485 Simulates a user pressing the right mouse button (without releasing it yet) on
486 the specified element.
487
488 'locator' is an element locator
489 """
490 self.do_command("mouseDownRight", [locator,])
491
492
494 """
495 Simulates a user pressing the left mouse button (without releasing it yet) at
496 the specified location.
497
498 'locator' is an element locator
499 'coordString' is specifies the x,y position (i.e. - 10,20) of the mouse event relative to the element returned by the locator.
500 """
501 self.do_command("mouseDownAt", [locator,coordString,])
502
503
505 """
506 Simulates a user pressing the right mouse button (without releasing it yet) at
507 the specified location.
508
509 'locator' is an element locator
510 'coordString' is specifies the x,y position (i.e. - 10,20) of the mouse event relative to the element returned by the locator.
511 """
512 self.do_command("mouseDownRightAt", [locator,coordString,])
513
514
516 """
517 Simulates the event that occurs when the user releases the mouse button (i.e., stops
518 holding the button down) on the specified element.
519
520 'locator' is an element locator
521 """
522 self.do_command("mouseUp", [locator,])
523
524
526 """
527 Simulates the event that occurs when the user releases the right mouse button (i.e., stops
528 holding the button down) on the specified element.
529
530 'locator' is an element locator
531 """
532 self.do_command("mouseUpRight", [locator,])
533
534
536 """
537 Simulates the event that occurs when the user releases the mouse button (i.e., stops
538 holding the button down) at the specified location.
539
540 'locator' is an element locator
541 'coordString' is specifies the x,y position (i.e. - 10,20) of the mouse event relative to the element returned by the locator.
542 """
543 self.do_command("mouseUpAt", [locator,coordString,])
544
545
547 """
548 Simulates the event that occurs when the user releases the right mouse button (i.e., stops
549 holding the button down) at the specified location.
550
551 'locator' is an element locator
552 'coordString' is specifies the x,y position (i.e. - 10,20) of the mouse event relative to the element returned by the locator.
553 """
554 self.do_command("mouseUpRightAt", [locator,coordString,])
555
556
558 """
559 Simulates a user pressing the mouse button (without releasing it yet) on
560 the specified element.
561
562 'locator' is an element locator
563 """
564 self.do_command("mouseMove", [locator,])
565
566
568 """
569 Simulates a user pressing the mouse button (without releasing it yet) on
570 the specified element.
571
572 'locator' is an element locator
573 'coordString' is specifies the x,y position (i.e. - 10,20) of the mouse event relative to the element returned by the locator.
574 """
575 self.do_command("mouseMoveAt", [locator,coordString,])
576
577
578 - def type(self,locator,value):
579 """
580 Sets the value of an input field, as though you typed it in.
581
582
583 Can also be used to set the value of combo boxes, check boxes, etc. In these cases,
584 value should be the value of the option selected, not the visible text.
585
586
587 'locator' is an element locator
588 'value' is the value to type
589 """
590 self.do_command("type", [locator,value,])
591
592
594 """
595 Simulates keystroke events on the specified element, as though you typed the value key-by-key.
596
597
598 This is a convenience method for calling keyDown, keyUp, keyPress for every character in the specified string;
599 this is useful for dynamic UI widgets (like auto-completing combo boxes) that require explicit key events.
600
601 Unlike the simple "type" command, which forces the specified value into the page directly, this command
602 may or may not have any visible effect, even in cases where typing keys would normally have a visible effect.
603 For example, if you use "typeKeys" on a form element, you may or may not see the results of what you typed in
604 the field.
605
606 In some cases, you may need to use the simple "type" command to set the value of the field and then the "typeKeys" command to
607 send the keystroke events corresponding to what you just typed.
608
609
610 'locator' is an element locator
611 'value' is the value to type
612 """
613 self.do_command("typeKeys", [locator,value,])
614
615
617 """
618 Set execution speed (i.e., set the millisecond length of a delay which will follow each selenium operation). By default, there is no such delay, i.e.,
619 the delay is 0 milliseconds.
620
621 'value' is the number of milliseconds to pause after operation
622 """
623 self.do_command("setSpeed", [value,])
624
625
627 """
628 Get execution speed (i.e., get the millisecond length of the delay following each selenium operation). By default, there is no such delay, i.e.,
629 the delay is 0 milliseconds.
630
631 See also setSpeed.
632
633 """
634 return self.get_string("getSpeed", [])
635
636
637 - def check(self,locator):
638 """
639 Check a toggle-button (checkbox/radio)
640
641 'locator' is an element locator
642 """
643 self.do_command("check", [locator,])
644
645
647 """
648 Uncheck a toggle-button (checkbox/radio)
649
650 'locator' is an element locator
651 """
652 self.do_command("uncheck", [locator,])
653
654
655 - def select(self,selectLocator,optionLocator):
656 """
657 Select an option from a drop-down using an option locator.
658
659
660
661 Option locators provide different ways of specifying options of an HTML
662 Select element (e.g. for selecting a specific option, or for asserting
663 that the selected option satisfies a specification). There are several
664 forms of Select Option Locator.
665
666
667 * \ **label**\ =\ *labelPattern*:
668 matches options based on their labels, i.e. the visible text. (This
669 is the default.)
670
671 * label=regexp:^[Oo]ther
672
673
674 * \ **value**\ =\ *valuePattern*:
675 matches options based on their values.
676
677 * value=other
678
679
680 * \ **id**\ =\ *id*:
681
682 matches options based on their ids.
683
684 * id=option1
685
686
687 * \ **index**\ =\ *index*:
688 matches an option based on its index (offset from zero).
689
690 * index=2
691
692
693
694
695
696 If no option locator prefix is provided, the default behaviour is to match on \ **label**\ .
697
698
699
700 'selectLocator' is an element locator identifying a drop-down menu
701 'optionLocator' is an option locator (a label by default)
702 """
703 self.do_command("select", [selectLocator,optionLocator,])
704
705
707 """
708 Add a selection to the set of selected options in a multi-select element using an option locator.
709
710 @see #doSelect for details of option locators
711
712 'locator' is an element locator identifying a multi-select box
713 'optionLocator' is an option locator (a label by default)
714 """
715 self.do_command("addSelection", [locator,optionLocator,])
716
717
719 """
720 Remove a selection from the set of selected options in a multi-select element using an option locator.
721
722 @see #doSelect for details of option locators
723
724 'locator' is an element locator identifying a multi-select box
725 'optionLocator' is an option locator (a label by default)
726 """
727 self.do_command("removeSelection", [locator,optionLocator,])
728
729
731 """
732 Unselects all of the selected options in a multi-select element.
733
734 'locator' is an element locator identifying a multi-select box
735 """
736 self.do_command("removeAllSelections", [locator,])
737
738
739 - def submit(self,formLocator):
740 """
741 Submit the specified form. This is particularly useful for forms without
742 submit buttons, e.g. single-input "Search" forms.
743
744 'formLocator' is an element locator for the form you want to submit
745 """
746 self.do_command("submit", [formLocator,])
747
748
749 - def open(self,url):
750 """
751 Opens an URL in the test frame. This accepts both relative and absolute
752 URLs.
753
754 The "open" command waits for the page to load before proceeding,
755 ie. the "AndWait" suffix is implicit.
756
757 \ *Note*: The URL must be on the same domain as the runner HTML
758 due to security restrictions in the browser (Same Origin Policy). If you
759 need to open an URL on another domain, use the Selenium Server to start a
760 new browser session on that domain.
761
762 'url' is the URL to open; may be relative or absolute
763 """
764 self.do_command("open", [url,])
765
766
768 """
769 Opens a popup window (if a window with that ID isn't already open).
770 After opening the window, you'll need to select it using the selectWindow
771 command.
772
773
774 This command can also be a useful workaround for bug SEL-339. In some cases, Selenium will be unable to intercept a call to window.open (if the call occurs during or before the "onLoad" event, for example).
775 In those cases, you can force Selenium to notice the open window's name by using the Selenium openWindow command, using
776 an empty (blank) url, like this: openWindow("", "myFunnyWindow").
777
778
779 'url' is the URL to open, which can be blank
780 'windowID' is the JavaScript window ID of the window to select
781 """
782 self.do_command("openWindow", [url,windowID,])
783
784
786 """
787 Selects a popup window using a window locator; once a popup window has been selected, all
788 commands go to that window. To select the main window again, use null
789 as the target.
790
791
792
793
794 Window locators provide different ways of specifying the window object:
795 by title, by internal JavaScript "name," or by JavaScript variable.
796
797
798 * \ **title**\ =\ *My Special Window*:
799 Finds the window using the text that appears in the title bar. Be careful;
800 two windows can share the same title. If that happens, this locator will
801 just pick one.
802
803 * \ **name**\ =\ *myWindow*:
804 Finds the window using its internal JavaScript "name" property. This is the second
805 parameter "windowName" passed to the JavaScript method window.open(url, windowName, windowFeatures, replaceFlag)
806 (which Selenium intercepts).
807
808 * \ **var**\ =\ *variableName*:
809 Some pop-up windows are unnamed (anonymous), but are associated with a JavaScript variable name in the current
810 application window, e.g. "window.foo = window.open(url);". In those cases, you can open the window using
811 "var=foo".
812
813
814
815
816 If no window locator prefix is provided, we'll try to guess what you mean like this:
817
818 1.) if windowID is null, (or the string "null") then it is assumed the user is referring to the original window instantiated by the browser).
819
820 2.) if the value of the "windowID" parameter is a JavaScript variable name in the current application window, then it is assumed
821 that this variable contains the return value from a call to the JavaScript window.open() method.
822
823 3.) Otherwise, selenium looks in a hash it maintains that maps string names to window "names".
824
825 4.) If \ *that* fails, we'll try looping over all of the known windows to try to find the appropriate "title".
826 Since "title" is not necessarily unique, this may have unexpected behavior.
827
828 If you're having trouble figuring out the name of a window that you want to manipulate, look at the Selenium log messages
829 which identify the names of windows created via window.open (and therefore intercepted by Selenium). You will see messages
830 like the following for each window as it is opened:
831
832 ``debug: window.open call intercepted; window ID (which you can use with selectWindow()) is "myNewWindow"``
833
834 In some cases, Selenium will be unable to intercept a call to window.open (if the call occurs during or before the "onLoad" event, for example).
835 (This is bug SEL-339.) In those cases, you can force Selenium to notice the open window's name by using the Selenium openWindow command, using
836 an empty (blank) url, like this: openWindow("", "myFunnyWindow").
837
838
839 'windowID' is the JavaScript window ID of the window to select
840 """
841 self.do_command("selectWindow", [windowID,])
842
843
845 """
846 Selects a frame within the current window. (You may invoke this command
847 multiple times to select nested frames.) To select the parent frame, use
848 "relative=parent" as a locator; to select the top frame, use "relative=top".
849 You can also select a frame by its 0-based index number; select the first frame with
850 "index=0", or the third frame with "index=2".
851
852
853 You may also use a DOM expression to identify the frame you want directly,
854 like this: ``dom=frames["main"].frames["subframe"]``
855
856
857 'locator' is an element locator identifying a frame or iframe
858 """
859 self.do_command("selectFrame", [locator,])
860
861
863 """
864 Determine whether current/locator identify the frame containing this running code.
865
866
867 This is useful in proxy injection mode, where this code runs in every
868 browser frame and window, and sometimes the selenium server needs to identify
869 the "current" frame. In this case, when the test calls selectFrame, this
870 routine is called for each frame to figure out which one has been selected.
871 The selected frame will return true, while all others will return false.
872
873
874 'currentFrameString' is starting frame
875 'target' is new frame (which might be relative to the current one)
876 """
877 return self.get_boolean("getWhetherThisFrameMatchFrameExpression", [currentFrameString,target,])
878
879
881 """
882 Determine whether currentWindowString plus target identify the window containing this running code.
883
884
885 This is useful in proxy injection mode, where this code runs in every
886 browser frame and window, and sometimes the selenium server needs to identify
887 the "current" window. In this case, when the test calls selectWindow, this
888 routine is called for each window to figure out which one has been selected.
889 The selected window will return true, while all others will return false.
890
891
892 'currentWindowString' is starting window
893 'target' is new window (which might be relative to the current one, e.g., "_parent")
894 """
895 return self.get_boolean("getWhetherThisWindowMatchWindowExpression", [currentWindowString,target,])
896
897
899 """
900 Waits for a popup window to appear and load up.
901
902 'windowID' is the JavaScript window "name" of the window that will appear (not the text of the title bar)
903 'timeout' is a timeout in milliseconds, after which the action will return with an error
904 """
905 self.do_command("waitForPopUp", [windowID,timeout,])
906
907
909 """
910
911
912 By default, Selenium's overridden window.confirm() function will
913 return true, as if the user had manually clicked OK; after running
914 this command, the next call to confirm() will return false, as if
915 the user had clicked Cancel. Selenium will then resume using the
916 default behavior for future confirmations, automatically returning
917 true (OK) unless/until you explicitly call this command for each
918 confirmation.
919
920
921
922 Take note - every time a confirmation comes up, you must
923 consume it with a corresponding getConfirmation, or else
924 the next selenium operation will fail.
925
926
927
928 """
929 self.do_command("chooseCancelOnNextConfirmation", [])
930
931
933 """
934
935
936 Undo the effect of calling chooseCancelOnNextConfirmation. Note
937 that Selenium's overridden window.confirm() function will normally automatically
938 return true, as if the user had manually clicked OK, so you shouldn't
939 need to use this command unless for some reason you need to change
940 your mind prior to the next confirmation. After any confirmation, Selenium will resume using the
941 default behavior for future confirmations, automatically returning
942 true (OK) unless/until you explicitly call chooseCancelOnNextConfirmation for each
943 confirmation.
944
945
946
947 Take note - every time a confirmation comes up, you must
948 consume it with a corresponding getConfirmation, or else
949 the next selenium operation will fail.
950
951
952
953 """
954 self.do_command("chooseOkOnNextConfirmation", [])
955
956
958 """
959 Instructs Selenium to return the specified answer string in response to
960 the next JavaScript prompt [window.prompt()].
961
962 'answer' is the answer to give in response to the prompt pop-up
963 """
964 self.do_command("answerOnNextPrompt", [answer,])
965
966
968 """
969 Simulates the user clicking the "back" button on their browser.
970
971 """
972 self.do_command("goBack", [])
973
974
976 """
977 Simulates the user clicking the "Refresh" button on their browser.
978
979 """
980 self.do_command("refresh", [])
981
982
984 """
985 Simulates the user clicking the "close" button in the titlebar of a popup
986 window or tab.
987
988 """
989 self.do_command("close", [])
990
991
993 """
994 Has an alert occurred?
995
996
997
998 This function never throws an exception
999
1000
1001
1002 """
1003 return self.get_boolean("isAlertPresent", [])
1004
1005
1007 """
1008 Has a prompt occurred?
1009
1010
1011
1012 This function never throws an exception
1013
1014
1015
1016 """
1017 return self.get_boolean("isPromptPresent", [])
1018
1019
1021 """
1022 Has confirm() been called?
1023
1024
1025
1026 This function never throws an exception
1027
1028
1029
1030 """
1031 return self.get_boolean("isConfirmationPresent", [])
1032
1033
1035 """
1036 Retrieves the message of a JavaScript alert generated during the previous action, or fail if there were no alerts.
1037
1038
1039 Getting an alert has the same effect as manually clicking OK. If an
1040 alert is generated but you do not consume it with getAlert, the next Selenium action
1041 will fail.
1042
1043 Under Selenium, JavaScript alerts will NOT pop up a visible alert
1044 dialog.
1045
1046 Selenium does NOT support JavaScript alerts that are generated in a
1047 page's onload() event handler. In this case a visible dialog WILL be
1048 generated and Selenium will hang until someone manually clicks OK.
1049
1050
1051 """
1052 return self.get_string("getAlert", [])
1053
1054
1056 """
1057 Retrieves the message of a JavaScript confirmation dialog generated during
1058 the previous action.
1059
1060
1061
1062 By default, the confirm function will return true, having the same effect
1063 as manually clicking OK. This can be changed by prior execution of the
1064 chooseCancelOnNextConfirmation command.
1065
1066
1067
1068 If an confirmation is generated but you do not consume it with getConfirmation,
1069 the next Selenium action will fail.
1070
1071
1072
1073 NOTE: under Selenium, JavaScript confirmations will NOT pop up a visible
1074 dialog.
1075
1076
1077
1078 NOTE: Selenium does NOT support JavaScript confirmations that are
1079 generated in a page's onload() event handler. In this case a visible
1080 dialog WILL be generated and Selenium will hang until you manually click
1081 OK.
1082
1083
1084
1085 """
1086 return self.get_string("getConfirmation", [])
1087
1088
1090 """
1091 Retrieves the message of a JavaScript question prompt dialog generated during
1092 the previous action.
1093
1094
1095 Successful handling of the prompt requires prior execution of the
1096 answerOnNextPrompt command. If a prompt is generated but you
1097 do not get/verify it, the next Selenium action will fail.
1098
1099 NOTE: under Selenium, JavaScript prompts will NOT pop up a visible
1100 dialog.
1101
1102 NOTE: Selenium does NOT support JavaScript prompts that are generated in a
1103 page's onload() event handler. In this case a visible dialog WILL be
1104 generated and Selenium will hang until someone manually clicks OK.
1105
1106
1107 """
1108 return self.get_string("getPrompt", [])
1109
1110
1112 """
1113 Gets the absolute URL of the current page.
1114
1115 """
1116 return self.get_string("getLocation", [])
1117
1118
1120 """
1121 Gets the title of the current page.
1122
1123 """
1124 return self.get_string("getTitle", [])
1125
1126
1127 - def get_body_text(self):
1128 """
1129 Gets the entire text of the page.
1130
1131 """
1132 return self.get_string("getBodyText", [])
1133
1134
1136 """
1137 Gets the (whitespace-trimmed) value of an input field (or anything else with a value parameter).
1138 For checkbox/radio elements, the value will be "on" or "off" depending on
1139 whether the element is checked or not.
1140
1141 'locator' is an element locator
1142 """
1143 return self.get_string("getValue", [locator,])
1144
1145
1146 - def get_text(self,locator):
1147 """
1148 Gets the text of an element. This works for any element that contains
1149 text. This command uses either the textContent (Mozilla-like browsers) or
1150 the innerText (IE-like browsers) of the element, which is the rendered
1151 text shown to the user.
1152
1153 'locator' is an element locator
1154 """
1155 return self.get_string("getText", [locator,])
1156
1157
1159 """
1160 Briefly changes the backgroundColor of the specified element yellow. Useful for debugging.
1161
1162 'locator' is an element locator
1163 """
1164 self.do_command("highlight", [locator,])
1165
1166
1168 """
1169 Gets the result of evaluating the specified JavaScript snippet. The snippet may
1170 have multiple lines, but only the result of the last line will be returned.
1171
1172
1173 Note that, by default, the snippet will run in the context of the "selenium"
1174 object itself, so ``this`` will refer to the Selenium object. Use ``window`` to
1175 refer to the window of your application, e.g. ``window.document.getElementById('foo')``
1176
1177 If you need to use
1178 a locator to refer to a single element in your application page, you can
1179 use ``this.browserbot.findElement("id=foo")`` where "id=foo" is your locator.
1180
1181
1182 'script' is the JavaScript snippet to run
1183 """
1184 return self.get_string("getEval", [script,])
1185
1186
1188 """
1189 Gets whether a toggle-button (checkbox/radio) is checked. Fails if the specified element doesn't exist or isn't a toggle-button.
1190
1191 'locator' is an element locator pointing to a checkbox or radio button
1192 """
1193 return self.get_boolean("isChecked", [locator,])
1194
1195
1197 """
1198 Gets the text from a cell of a table. The cellAddress syntax
1199 tableLocator.row.column, where row and column start at 0.
1200
1201 'tableCellAddress' is a cell address, e.g. "foo.1.4"
1202 """
1203 return self.get_string("getTable", [tableCellAddress,])
1204
1205
1207 """
1208 Gets all option labels (visible text) for selected options in the specified select or multi-select element.
1209
1210 'selectLocator' is an element locator identifying a drop-down menu
1211 """
1212 return self.get_string_array("getSelectedLabels", [selectLocator,])
1213
1214
1216 """
1217 Gets option label (visible text) for selected option in the specified select element.
1218
1219 'selectLocator' is an element locator identifying a drop-down menu
1220 """
1221 return self.get_string("getSelectedLabel", [selectLocator,])
1222
1223
1225 """
1226 Gets all option values (value attributes) for selected options in the specified select or multi-select element.
1227
1228 'selectLocator' is an element locator identifying a drop-down menu
1229 """
1230 return self.get_string_array("getSelectedValues", [selectLocator,])
1231
1232
1234 """
1235 Gets option value (value attribute) for selected option in the specified select element.
1236
1237 'selectLocator' is an element locator identifying a drop-down menu
1238 """
1239 return self.get_string("getSelectedValue", [selectLocator,])
1240
1241
1243 """
1244 Gets all option indexes (option number, starting at 0) for selected options in the specified select or multi-select element.
1245
1246 'selectLocator' is an element locator identifying a drop-down menu
1247 """
1248 return self.get_string_array("getSelectedIndexes", [selectLocator,])
1249
1250
1252 """
1253 Gets option index (option number, starting at 0) for selected option in the specified select element.
1254
1255 'selectLocator' is an element locator identifying a drop-down menu
1256 """
1257 return self.get_string("getSelectedIndex", [selectLocator,])
1258
1259
1261 """
1262 Gets all option element IDs for selected options in the specified select or multi-select element.
1263
1264 'selectLocator' is an element locator identifying a drop-down menu
1265 """
1266 return self.get_string_array("getSelectedIds", [selectLocator,])
1267
1268
1270 """
1271 Gets option element ID for selected option in the specified select element.
1272
1273 'selectLocator' is an element locator identifying a drop-down menu
1274 """
1275 return self.get_string("getSelectedId", [selectLocator,])
1276
1277
1279 """
1280 Determines whether some option in a drop-down menu is selected.
1281
1282 'selectLocator' is an element locator identifying a drop-down menu
1283 """
1284 return self.get_boolean("isSomethingSelected", [selectLocator,])
1285
1286
1288 """
1289 Gets all option labels in the specified select drop-down.
1290
1291 'selectLocator' is an element locator identifying a drop-down menu
1292 """
1293 return self.get_string_array("getSelectOptions", [selectLocator,])
1294
1295
1297 """
1298 Gets the value of an element attribute. The value of the attribute may
1299 differ across browsers (this is the case for the "style" attribute, for
1300 example).
1301
1302 'attributeLocator' is an element locator followed by an @ sign and then the name of the attribute, e.g. "foo@bar"
1303 """
1304 return self.get_string("getAttribute", [attributeLocator,])
1305
1306
1307 - def is_text_present(self,pattern):
1308 """
1309 Verifies that the specified text pattern appears somewhere on the rendered page shown to the user.
1310
1311 'pattern' is a pattern to match with the text of the page
1312 """
1313 return self.get_boolean("isTextPresent", [pattern,])
1314
1315
1317 """
1318 Verifies that the specified element is somewhere on the page.
1319
1320 'locator' is an element locator
1321 """
1322 return self.get_boolean("isElementPresent", [locator,])
1323
1324
1326 """
1327 Determines if the specified element is visible. An
1328 element can be rendered invisible by setting the CSS "visibility"
1329 property to "hidden", or the "display" property to "none", either for the
1330 element itself or one if its ancestors. This method will fail if
1331 the element is not present.
1332
1333 'locator' is an element locator
1334 """
1335 return self.get_boolean("isVisible", [locator,])
1336
1337
1339 """
1340 Determines whether the specified input element is editable, ie hasn't been disabled.
1341 This method will fail if the specified element isn't an input element.
1342
1343 'locator' is an element locator
1344 """
1345 return self.get_boolean("isEditable", [locator,])
1346
1347
1358
1359
1361 """
1362 Returns the IDs of all links on the page.
1363
1364
1365 If a given link has no ID, it will appear as "" in this array.
1366
1367
1368 """
1369 return self.get_string_array("getAllLinks", [])
1370
1371
1373 """
1374 Returns the IDs of all input fields on the page.
1375
1376
1377 If a given field has no ID, it will appear as "" in this array.
1378
1379
1380 """
1381 return self.get_string_array("getAllFields", [])
1382
1383
1385 """
1386 Returns every instance of some attribute from all known windows.
1387
1388 'attributeName' is name of an attribute on the windows
1389 """
1390 return self.get_string_array("getAttributeFromAllWindows", [attributeName,])
1391
1392
1393 - def dragdrop(self,locator,movementsString):
1394 """
1395 deprecated - use dragAndDrop instead
1396
1397 'locator' is an element locator
1398 'movementsString' is offset in pixels from the current location to which the element should be moved, e.g., "+70,-300"
1399 """
1400 self.do_command("dragdrop", [locator,movementsString,])
1401
1402
1404 """
1405 Configure the number of pixels between "mousemove" events during dragAndDrop commands (default=10).
1406
1407 Setting this value to 0 means that we'll send a "mousemove" event to every single pixel
1408 in between the start location and the end location; that can be very slow, and may
1409 cause some browsers to force the JavaScript to timeout.
1410
1411 If the mouse speed is greater than the distance between the two dragged objects, we'll
1412 just send one "mousemove" at the start location and then one final one at the end location.
1413
1414
1415 'pixels' is the number of pixels between "mousemove" events
1416 """
1417 self.do_command("setMouseSpeed", [pixels,])
1418
1419
1421 """
1422 Returns the number of pixels between "mousemove" events during dragAndDrop commands (default=10).
1423
1424 """
1425 return self.get_number("getMouseSpeed", [])
1426
1427
1429 """
1430 Drags an element a certain distance and then drops it
1431
1432 'locator' is an element locator
1433 'movementsString' is offset in pixels from the current location to which the element should be moved, e.g., "+70,-300"
1434 """
1435 self.do_command("dragAndDrop", [locator,movementsString,])
1436
1437
1439 """
1440 Drags an element and drops it on another element
1441
1442 'locatorOfObjectToBeDragged' is an element to be dragged
1443 'locatorOfDragDestinationObject' is an element whose location (i.e., whose center-most pixel) will be the point where locatorOfObjectToBeDragged is dropped
1444 """
1445 self.do_command("dragAndDropToObject", [locatorOfObjectToBeDragged,locatorOfDragDestinationObject,])
1446
1447
1449 """
1450 Gives focus to the currently selected window
1451
1452 """
1453 self.do_command("windowFocus", [])
1454
1455
1457 """
1458 Resize currently selected window to take up the entire screen
1459
1460 """
1461 self.do_command("windowMaximize", [])
1462
1463
1465 """
1466 Returns the IDs of all windows that the browser knows about.
1467
1468 """
1469 return self.get_string_array("getAllWindowIds", [])
1470
1471
1473 """
1474 Returns the names of all windows that the browser knows about.
1475
1476 """
1477 return self.get_string_array("getAllWindowNames", [])
1478
1479
1481 """
1482 Returns the titles of all windows that the browser knows about.
1483
1484 """
1485 return self.get_string_array("getAllWindowTitles", [])
1486
1487
1489 """
1490 Returns the entire HTML source between the opening and
1491 closing "html" tags.
1492
1493 """
1494 return self.get_string("getHtmlSource", [])
1495
1496
1498 """
1499 Moves the text cursor to the specified position in the given input element or textarea.
1500 This method will fail if the specified element isn't an input element or textarea.
1501
1502 'locator' is an element locator pointing to an input element or textarea
1503 'position' is the numerical position of the cursor in the field; position should be 0 to move the position to the beginning of the field. You can also set the cursor to -1 to move it to the end of the field.
1504 """
1505 self.do_command("setCursorPosition", [locator,position,])
1506
1507
1509 """
1510 Get the relative index of an element to its parent (starting from 0). The comment node and empty text node
1511 will be ignored.
1512
1513 'locator' is an element locator pointing to an element
1514 """
1515 return self.get_number("getElementIndex", [locator,])
1516
1517
1519 """
1520 Check if these two elements have same parent and are ordered siblings in the DOM. Two same elements will
1521 not be considered ordered.
1522
1523 'locator1' is an element locator pointing to the first element
1524 'locator2' is an element locator pointing to the second element
1525 """
1526 return self.get_boolean("isOrdered", [locator1,locator2,])
1527
1528
1530 """
1531 Retrieves the horizontal position of an element
1532
1533 'locator' is an element locator pointing to an element OR an element itself
1534 """
1535 return self.get_number("getElementPositionLeft", [locator,])
1536
1537
1539 """
1540 Retrieves the vertical position of an element
1541
1542 'locator' is an element locator pointing to an element OR an element itself
1543 """
1544 return self.get_number("getElementPositionTop", [locator,])
1545
1546
1548 """
1549 Retrieves the width of an element
1550
1551 'locator' is an element locator pointing to an element
1552 """
1553 return self.get_number("getElementWidth", [locator,])
1554
1555
1557 """
1558 Retrieves the height of an element
1559
1560 'locator' is an element locator pointing to an element
1561 """
1562 return self.get_number("getElementHeight", [locator,])
1563
1564
1566 """
1567 Retrieves the text cursor position in the given input element or textarea; beware, this may not work perfectly on all browsers.
1568
1569
1570 Specifically, if the cursor/selection has been cleared by JavaScript, this command will tend to
1571 return the position of the last location of the cursor, even though the cursor is now gone from the page. This is filed as SEL-243.
1572
1573 This method will fail if the specified element isn't an input element or textarea, or there is no cursor in the element.
1574
1575 'locator' is an element locator pointing to an input element or textarea
1576 """
1577 return self.get_number("getCursorPosition", [locator,])
1578
1579
1581 """
1582 Returns the specified expression.
1583
1584
1585 This is useful because of JavaScript preprocessing.
1586 It is used to generate commands like assertExpression and waitForExpression.
1587
1588
1589 'expression' is the value to return
1590 """
1591 return self.get_string("getExpression", [expression,])
1592
1593
1595 """
1596 Returns the number of nodes that match the specified xpath, eg. "//table" would give
1597 the number of tables.
1598
1599 'xpath' is the xpath expression to evaluate. do NOT wrap this expression in a 'count()' function; we will do that for you.
1600 """
1601 return self.get_number("getXpathCount", [xpath,])
1602
1603
1605 """
1606 Temporarily sets the "id" attribute of the specified element, so you can locate it in the future
1607 using its ID rather than a slow/complicated XPath. This ID will disappear once the page is
1608 reloaded.
1609
1610 'locator' is an element locator pointing to an element
1611 'identifier' is a string to be used as the ID of the specified element
1612 """
1613 self.do_command("assignId", [locator,identifier,])
1614
1615
1617 """
1618 Specifies whether Selenium should use the native in-browser implementation
1619 of XPath (if any native version is available); if you pass "false" to
1620 this function, we will always use our pure-JavaScript xpath library.
1621 Using the pure-JS xpath library can improve the consistency of xpath
1622 element locators between different browser vendors, but the pure-JS
1623 version is much slower than the native implementations.
1624
1625 'allow' is boolean, true means we'll prefer to use native XPath; false means we'll only use JS XPath
1626 """
1627 self.do_command("allowNativeXpath", [allow,])
1628
1629
1631 """
1632 Specifies whether Selenium will ignore xpath attributes that have no
1633 value, i.e. are the empty string, when using the non-native xpath
1634 evaluation engine. You'd want to do this for performance reasons in IE.
1635 However, this could break certain xpaths, for example an xpath that looks
1636 for an attribute whose value is NOT the empty string.
1637
1638 The hope is that such xpaths are relatively rare, but the user should
1639 have the option of using them. Note that this only influences xpath
1640 evaluation when using the ajaxslt engine (i.e. not "javascript-xpath").
1641
1642 'ignore' is boolean, true means we'll ignore attributes without value at the expense of xpath "correctness"; false means we'll sacrifice speed for correctness.
1643 """
1644 self.do_command("ignoreAttributesWithoutValue", [ignore,])
1645
1646
1648 """
1649 Runs the specified JavaScript snippet repeatedly until it evaluates to "true".
1650 The snippet may have multiple lines, but only the result of the last line
1651 will be considered.
1652
1653
1654 Note that, by default, the snippet will be run in the runner's test window, not in the window
1655 of your application. To get the window of your application, you can use
1656 the JavaScript snippet ``selenium.browserbot.getCurrentWindow()``, and then
1657 run your JavaScript in there
1658
1659
1660 'script' is the JavaScript snippet to run
1661 'timeout' is a timeout in milliseconds, after which this command will return with an error
1662 """
1663 self.do_command("waitForCondition", [script,timeout,])
1664
1665
1667 """
1668 Specifies the amount of time that Selenium will wait for actions to complete.
1669
1670
1671 Actions that require waiting include "open" and the "waitFor\*" actions.
1672
1673 The default timeout is 30 seconds.
1674
1675 'timeout' is a timeout in milliseconds, after which the action will return with an error
1676 """
1677 self.do_command("setTimeout", [timeout,])
1678
1679
1680 - def wait_for_page_to_load(self,timeout):
1681 """
1682 Waits for a new page to load.
1683
1684
1685 You can use this command instead of the "AndWait" suffixes, "clickAndWait", "selectAndWait", "typeAndWait" etc.
1686 (which are only available in the JS API).
1687
1688 Selenium constantly keeps track of new pages loading, and sets a "newPageLoaded"
1689 flag when it first notices a page load. Running any other Selenium command after
1690 turns the flag to false. Hence, if you want to wait for a page to load, you must
1691 wait immediately after a Selenium command that caused a page-load.
1692
1693
1694 'timeout' is a timeout in milliseconds, after which this command will return with an error
1695 """
1696 self.do_command("waitForPageToLoad", [timeout,])
1697
1698
1700 """
1701 Waits for a new frame to load.
1702
1703
1704 Selenium constantly keeps track of new pages and frames loading,
1705 and sets a "newPageLoaded" flag when it first notices a page load.
1706
1707
1708 See waitForPageToLoad for more information.
1709
1710 'frameAddress' is FrameAddress from the server side
1711 'timeout' is a timeout in milliseconds, after which this command will return with an error
1712 """
1713 self.do_command("waitForFrameToLoad", [frameAddress,timeout,])
1714
1715
1717 """
1718 Return all cookies of the current page under test.
1719
1720 """
1721 return self.get_string("getCookie", [])
1722
1723
1725 """
1726 Returns the value of the cookie with the specified name, or throws an error if the cookie is not present.
1727
1728 'name' is the name of the cookie
1729 """
1730 return self.get_string("getCookieByName", [name,])
1731
1732
1734 """
1735 Returns true if a cookie with the specified name is present, or false otherwise.
1736
1737 'name' is the name of the cookie
1738 """
1739 return self.get_boolean("isCookiePresent", [name,])
1740
1741
1743 """
1744 Create a new cookie whose path and domain are same with those of current page
1745 under test, unless you specified a path for this cookie explicitly.
1746
1747 'nameValuePair' is name and value of the cookie in a format "name=value"
1748 'optionsString' is options for the cookie. Currently supported options include 'path', 'max_age' and 'domain'. the optionsString's format is "path=/path/, max_age=60, domain=.foo.com". The order of options are irrelevant, the unit of the value of 'max_age' is second. Note that specifying a domain that isn't a subset of the current domain will usually fail.
1749 """
1750 self.do_command("createCookie", [nameValuePair,optionsString,])
1751
1752
1754 """
1755 Delete a named cookie with specified path and domain. Be careful; to delete a cookie, you
1756 need to delete it using the exact same path and domain that were used to create the cookie.
1757 If the path is wrong, or the domain is wrong, the cookie simply won't be deleted. Also
1758 note that specifying a domain that isn't a subset of the current domain will usually fail.
1759
1760 Since there's no way to discover at runtime the original path and domain of a given cookie,
1761 we've added an option called 'recurse' to try all sub-domains of the current domain with
1762 all paths that are a subset of the current path. Beware; this option can be slow. In
1763 big-O notation, it operates in O(n\*m) time, where n is the number of dots in the domain
1764 name and m is the number of slashes in the path.
1765
1766 'name' is the name of the cookie to be deleted
1767 'optionsString' is options for the cookie. Currently supported options include 'path', 'domain' and 'recurse.' The optionsString's format is "path=/path/, domain=.foo.com, recurse=true". The order of options are irrelevant. Note that specifying a domain that isn't a subset of the current domain will usually fail.
1768 """
1769 self.do_command("deleteCookie", [name,optionsString,])
1770
1771
1773 """
1774 Calls deleteCookie with recurse=true on all cookies visible to the current page.
1775 As noted on the documentation for deleteCookie, recurse=true can be much slower
1776 than simply deleting the cookies using a known domain/path.
1777
1778 """
1779 self.do_command("deleteAllVisibleCookies", [])
1780
1781
1783 """
1784 Sets the threshold for browser-side logging messages; log messages beneath this threshold will be discarded.
1785 Valid logLevel strings are: "debug", "info", "warn", "error" or "off".
1786 To see the browser logs, you need to
1787 either show the log window in GUI mode, or enable browser-side logging in Selenium RC.
1788
1789 'logLevel' is one of the following: "debug", "info", "warn", "error" or "off"
1790 """
1791 self.do_command("setBrowserLogLevel", [logLevel,])
1792
1793
1795 """
1796 Creates a new "script" tag in the body of the current test window, and
1797 adds the specified text into the body of the command. Scripts run in
1798 this way can often be debugged more easily than scripts executed using
1799 Selenium's "getEval" command. Beware that JS exceptions thrown in these script
1800 tags aren't managed by Selenium, so you should probably wrap your script
1801 in try/catch blocks if there is any chance that the script will throw
1802 an exception.
1803
1804 'script' is the JavaScript snippet to run
1805 """
1806 self.do_command("runScript", [script,])
1807
1808
1810 """
1811 Defines a new function for Selenium to locate elements on the page.
1812 For example,
1813 if you define the strategy "foo", and someone runs click("foo=blah"), we'll
1814 run your function, passing you the string "blah", and click on the element
1815 that your function
1816 returns, or throw an "Element not found" error if your function returns null.
1817
1818 We'll pass three arguments to your function:
1819
1820 * locator: the string the user passed in
1821 * inWindow: the currently selected window
1822 * inDocument: the currently selected document
1823
1824
1825 The function must return null if the element can't be found.
1826
1827 'strategyName' is the name of the strategy to define; this should use only letters [a-zA-Z] with no spaces or other punctuation.
1828 'functionDefinition' is a string defining the body of a function in JavaScript. For example: ``return inDocument.getElementById(locator);``
1829 """
1830 self.do_command("addLocationStrategy", [strategyName,functionDefinition,])
1831
1832
1833 - def capture_entire_page_screenshot(self,filename,kwargs):
1834 """
1835 Saves the entire contents of the current window canvas to a PNG file.
1836 Contrast this with the captureScreenshot command, which captures the
1837 contents of the OS viewport (i.e. whatever is currently being displayed
1838 on the monitor), and is implemented in the RC only. Currently this only
1839 works in Firefox when running in chrome mode, and in IE non-HTA using
1840 the EXPERIMENTAL "Snapsie" utility. The Firefox implementation is mostly
1841 borrowed from the Screengrab! Firefox extension. Please see
1842 http://www.screengrab.org and http://snapsie.sourceforge.net/ for
1843 details.
1844
1845 'filename' is the path to the file to persist the screenshot as. No filename extension will be appended by default. Directories will not be created if they do not exist, and an exception will be thrown, possibly by native code.
1846 'kwargs' is a kwargs string that modifies the way the screenshot is captured. Example: "background=#CCFFDD" . Currently valid options:
1847 * background
1848 the background CSS for the HTML document. This may be useful to set for capturing screenshots of less-than-ideal layouts, for example where absolute positioning causes the calculation of the canvas dimension to fail and a black background is exposed (possibly obscuring black text).
1849
1850
1851 """
1852 self.do_command("captureEntirePageScreenshot", [filename,kwargs,])
1853
1854
1855 - def rollup(self,rollupName,kwargs):
1856 """
1857 Executes a command rollup, which is a series of commands with a unique
1858 name, and optionally arguments that control the generation of the set of
1859 commands. If any one of the rolled-up commands fails, the rollup is
1860 considered to have failed. Rollups may also contain nested rollups.
1861
1862 'rollupName' is the name of the rollup command
1863 'kwargs' is keyword arguments string that influences how the rollup expands into commands
1864 """
1865 self.do_command("rollup", [rollupName,kwargs,])
1866
1867
1869 """
1870 Loads script content into a new script tag in the Selenium document. This
1871 differs from the runScript command in that runScript adds the script tag
1872 to the document of the AUT, not the Selenium document. The following
1873 entities in the script content are replaced by the characters they
1874 represent:
1875
1876 <
1877 >
1878 &
1879
1880 The corresponding remove command is removeScript.
1881
1882 'scriptContent' is the Javascript content of the script to add
1883 'scriptTagId' is (optional) the id of the new script tag. If specified, and an element with this id already exists, this operation will fail.
1884 """
1885 self.do_command("addScript", [scriptContent,scriptTagId,])
1886
1887
1889 """
1890 Removes a script tag from the Selenium document identified by the given
1891 id. Does nothing if the referenced tag doesn't exist.
1892
1893 'scriptTagId' is the id of the script element to remove.
1894 """
1895 self.do_command("removeScript", [scriptTagId,])
1896
1897
1899 """
1900 Allows choice of one of the available libraries.
1901
1902 'libraryName' is name of the desired library Only the following three can be chosen: ajaxslt - Google's library javascript - Cybozu Labs' faster library default - The default library. Currently the default library is ajaxslt. If libraryName isn't one of these three, then no change will be made.
1903 """
1904 self.do_command("useXpathLibrary", [libraryName,])
1905
1906
1907 - def set_context(self,context):
1908 """
1909 Writes a message to the status bar and adds a note to the browser-side
1910 log.
1911
1912 'context' is the message to be sent to the browser
1913 """
1914 self.do_command("setContext", [context,])
1915
1916
1918 """
1919 Sets a file input (upload) field to the file listed in fileLocator
1920
1921 'fieldLocator' is an element locator
1922 'fileLocator' is a URL pointing to the specified file. Before the file can be set in the input field (fieldLocator), Selenium RC may need to transfer the file to the local machine before attaching the file in a web page form. This is common in selenium grid configurations where the RC server driving the browser is not the same machine that started the test. Supported Browsers: Firefox ("\*chrome") only.
1923 """
1924 self.do_command("attachFile", [fieldLocator,fileLocator,])
1925
1926
1928 """
1929 Captures a PNG screenshot to the specified file.
1930
1931 'filename' is the absolute path to the file to be written, e.g. "c:\blah\screenshot.png"
1932 """
1933 self.do_command("captureScreenshot", [filename,])
1934
1935
1937 """
1938 Capture a PNG screenshot. It then returns the file as a base 64 encoded string.
1939
1940 """
1941 return self.get_string("captureScreenshotToString", [])
1942
1943
1945 """
1946 Downloads a screenshot of the browser current window canvas to a
1947 based 64 encoded PNG file. The \ *entire* windows canvas is captured,
1948 including parts rendered outside of the current view port.
1949
1950 Currently this only works in Mozilla and when running in chrome mode.
1951
1952 'kwargs' is A kwargs string that modifies the way the screenshot is captured. Example: "background=#CCFFDD". This may be useful to set for capturing screenshots of less-than-ideal layouts, for example where absolute positioning causes the calculation of the canvas dimension to fail and a black background is exposed (possibly obscuring black text).
1953 """
1954 return self.get_string("captureEntirePageScreenshotToString", [kwargs,])
1955
1956
1958 """
1959 Kills the running Selenium Server and all browser sessions. After you run this command, you will no longer be able to send
1960 commands to the server; you can't remotely start the server once it has been stopped. Normally
1961 you should prefer to run the "stop" command, which terminates the current browser session, rather than
1962 shutting down the entire server.
1963
1964 """
1965 self.do_command("shutDownSeleniumServer", [])
1966
1967
1969 """
1970 Retrieve the last messages logged on a specific remote control. Useful for error reports, especially
1971 when running multiple remote controls in a distributed environment. The maximum number of log messages
1972 that can be retrieve is configured on remote control startup.
1973
1974 """
1975 return self.get_string("retrieveLastRemoteControlLogs", [])
1976
1977
1979 """
1980 Simulates a user pressing a key (without releasing it yet) by sending a native operating system keystroke.
1981 This function uses the java.awt.Robot class to send a keystroke; this more accurately simulates typing
1982 a key on the keyboard. It does not honor settings from the shiftKeyDown, controlKeyDown, altKeyDown and
1983 metaKeyDown commands, and does not target any particular HTML element. To send a keystroke to a particular
1984 element, focus on the element first before running this command.
1985
1986 'keycode' is an integer keycode number corresponding to a java.awt.event.KeyEvent; note that Java keycodes are NOT the same thing as JavaScript keycodes!
1987 """
1988 self.do_command("keyDownNative", [keycode,])
1989
1990
1992 """
1993 Simulates a user releasing a key by sending a native operating system keystroke.
1994 This function uses the java.awt.Robot class to send a keystroke; this more accurately simulates typing
1995 a key on the keyboard. It does not honor settings from the shiftKeyDown, controlKeyDown, altKeyDown and
1996 metaKeyDown commands, and does not target any particular HTML element. To send a keystroke to a particular
1997 element, focus on the element first before running this command.
1998
1999 'keycode' is an integer keycode number corresponding to a java.awt.event.KeyEvent; note that Java keycodes are NOT the same thing as JavaScript keycodes!
2000 """
2001 self.do_command("keyUpNative", [keycode,])
2002
2003
2005 """
2006 Simulates a user pressing and releasing a key by sending a native operating system keystroke.
2007 This function uses the java.awt.Robot class to send a keystroke; this more accurately simulates typing
2008 a key on the keyboard. It does not honor settings from the shiftKeyDown, controlKeyDown, altKeyDown and
2009 metaKeyDown commands, and does not target any particular HTML element. To send a keystroke to a particular
2010 element, focus on the element first before running this command.
2011
2012 'keycode' is an integer keycode number corresponding to a java.awt.event.KeyEvent; note that Java keycodes are NOT the same thing as JavaScript keycodes!
2013 """
2014 self.do_command("keyPressNative", [keycode,])
2015