def header(name, should_be):
"""
>> header <name> <value>
Check to make sure the header <name> for the last page is as given.
"""
headers = browser.get_headers()
if not headers.has_key(name):
raise TwillAssertionError("missing header %s" % name)
if headers[name] != should_be:
raise TwillAssertionError("header %s is %s != %s" % (name, headers[name], should_be))
def find(what, flags=''):
"""
>> find <regexp> [<flags>]
Succeed if the regular expression is on the page. Sets the local
variable __match__ to the matching text.
Flags is a string consisting of the following characters:
* i: ignorecase
* m: multiline
* s: dotall
For explanations of these, please see the Python re module
documentation.
"""
regexp = re.compile(what, _parseFindFlags(flags))
page = browser.get_html()
m = regexp.search(page)
if not m:
raise TwillAssertionError("no match to '%s'" % (what, ))
if m.groups():
match_str = m.group(1)
else:
match_str = m.group(0)
_, local_dict = get_twill_glocals()
local_dict['__match__'] = match_str
def url(should_be):
"""
>> url <regexp>
Check to make sure that the current URL matches the regexp. The local
variable __match__ is set to the matching part of the URL.
"""
regexp = re.compile(should_be)
current_url = browser.get_url()
m = None
if current_url is not None:
m = regexp.search(current_url)
else:
current_url = ''
if not m:
raise TwillAssertionError("""\
current url is '%s';
does not match '%s'
""" % (
current_url,
should_be,
))
if m.groups():
match_str = m.group(1)
else:
match_str = m.group(0)
global_dict, local_dict = get_twill_glocals()
local_dict['__match__'] = match_str
return match_str
def code(should_be):
"""
>> code <int>
Check to make sure the response code for the last page is as given.
"""
if browser.get_code() != int(should_be):
raise TwillAssertionError("code is %s != %s" % (browser.get_code(),
should_be))
def notfind(what, flags=''):
"""
>> notfind <regexp> [<flags>]
Fail if the regular expression is on the page.
"""
regexp = re.compile(what, _parseFindFlags(flags))
page = browser.get_html()
if regexp.search(page):
raise TwillAssertionError("match to '%s'" % (what, ))
def tidy_ok():
"""
>> tidy_ok
Assert that 'tidy' produces no warnings or errors when run on the current
page.
If 'tidy' cannot be run, will fail silently (unless 'tidy_should_exist'
option is true; see 'config' command).
"""
page = browser.get_html()
if page is None:
raise TwillAssertionError("not viewing HTML!")
(clean_page, errors) = run_tidy(page)
if clean_page is None: # tidy doesn't exist...
if _options.get('tidy_should_exist'):
raise TwillAssertionError("cannot run 'tidy'")
elif errors:
raise TwillAssertionError("tidy errors:\n====\n%s\n====\n" % (errors,))
def formvalue(formname, fieldname, value):
"""
>> formvalue <formname> <field> <value>
Set value of a form field.
There are some ambiguities in the way formvalue deals with lists:
'formvalue' will *add* the given value to a list of multiple selection,
for lists that allow it.
Forms are matched against 'formname' as follows:
1. regexp match to actual form name;
2. if 'formname' is an integer, it's tried as an index.
Form controls are matched against 'fieldname' as follows:
1. unique exact match to control name;
2. unique regexp match to control name;
3. if fieldname is an integer, it's tried as an index;
4. unique & exact match to submit-button values.
Formvalue ignores read-only fields completely; if they're readonly,
nothing is done, unless the config options ('config' command) are
changed.
'formvalue' is available as 'fv' as well.
"""
form = browser.get_form(formname)
if form is None:
raise TwillAssertionError("no matching forms!")
control = browser.get_form_field(form, fieldname)
browser.clicked(form, control)
if isinstance(control, html.CheckboxGroup):
pass
elif 'readonly' in control.attrib.keys() and \
_options['readonly_controls_writeable']:
print>>OUT, 'forcing read-only form field to writeable'
del control.attrib['readonly']
elif 'readonly' in control.attrib.keys() or \
(hasattr(control, 'type') and control.type == 'file'):
print>>OUT, 'form field is read-only or ignorable; nothing done.'
return
if hasattr(control, 'type') and control.type == 'file':
raise TwillException(
'form field is for file upload; use "formfile" instead'
)
set_form_control_value(control, value)
def _parseFindFlags(flags):
KNOWN_FLAGS = {
'i': re.IGNORECASE,
'm': re.MULTILINE,
's': re.DOTALL,
}
finalFlags = 0
for char in flags:
try:
finalFlags |= KNOWN_FLAGS[char]
except IndexError:
raise TwillAssertionError("unknown 'find' flag %r" % char)
return finalFlags
def follow(what):
"""
>> follow <regexp>
Find the first matching link on the page & visit it.
"""
regexp = re.compile(what)
link = browser.find_link(regexp)
if link != '':
browser.follow_link(link)
return browser.get_url()
raise TwillAssertionError("no links match to '%s'" % (what,))
def title(what):
"""
>> title <regexp>
Succeed if the regular expression is in the page title.
"""
regexp = re.compile(what)
title = browser.get_title()
print >> OUT, "title is '%s'." % (title, )
m = regexp.search(title)
if not m:
raise TwillAssertionError("title does not contain '%s'" % (what, ))
if m.groups():
match_str = m.group(1)
else:
match_str = m.group(0)
global_dict, local_dict = get_twill_glocals()
local_dict['__match__'] = match_str
return match_str