def test_advanced(output_test_path, render_output, rendered_template, helper, client):
form = AdvancedForm()
pack = helper.template_pack
helper.layout = Layout(
Row(
Column(
'simple',
css_class='six'
),
Column(
'opt_in',
css_class='six'
),
),
Row(
Column(
'longtext'
),
),
Row(
Column(
ButtonHolder(Submit('submit', 'Submit')),
),
css_class="large"
),
)
rendered = rendered_template(form, helper=helper)
attempted = render_output(os.path.join(output_test_path, pack,
"test_advanced.html"))
#write_output(output_test_path, pack, "test_advanced.html", rendered)
assert parse_html(attempted) == parse_html(rendered)
def test_count(self):
from django.test.html import parse_html
# equal html contains each other one time
dom1 = parse_html('<p>foo')
dom2 = parse_html('<p>foo</p>')
self.assertEqual(dom1.count(dom2), 1)
self.assertEqual(dom2.count(dom1), 1)
dom2 = parse_html('<p>foo</p><p>bar</p>')
self.assertEqual(dom2.count(dom1), 1)
dom2 = parse_html('<p>foo foo</p><p>foo</p>')
self.assertEqual(dom2.count('foo'), 3)
dom2 = parse_html('<p class="bar">foo</p>')
self.assertEqual(dom2.count('bar'), 0)
self.assertEqual(dom2.count('class'), 0)
self.assertEqual(dom2.count('p'), 0)
self.assertEqual(dom2.count('o'), 2)
dom2 = parse_html('<p>foo</p><p>foo</p>')
self.assertEqual(dom2.count(dom1), 2)
dom2 = parse_html('<div><p>foo<input type=""></p><p>foo</p></div>')
self.assertEqual(dom2.count(dom1), 1)
dom2 = parse_html('<div><div><p>foo</p></div></div>')
self.assertEqual(dom2.count(dom1), 1)
dom2 = parse_html('<p>foo<p>foo</p></p>')
self.assertEqual(dom2.count(dom1), 1)
dom2 = parse_html('<p>foo<p>bar</p></p>')
self.assertEqual(dom2.count(dom1), 0)
def test_parsing_errors(self):
with self.assertRaises(AssertionError):
self.assertHTMLEqual('<p>', '')
with self.assertRaises(AssertionError):
self.assertHTMLEqual('', '<p>')
with self.assertRaises(HTMLParseError):
parse_html('</p>')
def test_count(self):
# equal html contains each other one time
dom1 = parse_html("<p>foo")
dom2 = parse_html("<p>foo</p>")
self.assertEqual(dom1.count(dom2), 1)
self.assertEqual(dom2.count(dom1), 1)
dom2 = parse_html("<p>foo</p><p>bar</p>")
self.assertEqual(dom2.count(dom1), 1)
dom2 = parse_html("<p>foo foo</p><p>foo</p>")
self.assertEqual(dom2.count("foo"), 3)
dom2 = parse_html('<p class="bar">foo</p>')
self.assertEqual(dom2.count("bar"), 0)
self.assertEqual(dom2.count("class"), 0)
self.assertEqual(dom2.count("p"), 0)
self.assertEqual(dom2.count("o"), 2)
dom2 = parse_html("<p>foo</p><p>foo</p>")
self.assertEqual(dom2.count(dom1), 2)
dom2 = parse_html('<div><p>foo<input type=""></p><p>foo</p></div>')
self.assertEqual(dom2.count(dom1), 1)
dom2 = parse_html("<div><div><p>foo</p></div></div>")
self.assertEqual(dom2.count(dom1), 1)
dom2 = parse_html("<p>foo<p>foo</p></p>")
self.assertEqual(dom2.count(dom1), 1)
dom2 = parse_html("<p>foo<p>bar</p></p>")
self.assertEqual(dom2.count(dom1), 0)
def test_parsing_errors(self):
with self.assertRaises(AssertionError):
self.assertHTMLEqual("<p>", "")
with self.assertRaises(AssertionError):
self.assertHTMLEqual("", "<p>")
with self.assertRaises(HTMLParseError):
parse_html("</p>")
def test_parsing_errors(self):
from django.test.html import HTMLParseError, parse_html
with self.assertRaises(AssertionError):
self.assertHTMLEqual('<p>', '')
with self.assertRaises(AssertionError):
self.assertHTMLEqual('', '<p>')
with self.assertRaises(HTMLParseError):
parse_html('</p>')
def test_layout(output_test_path, render_output, rendered_template, helper, client):
form = BasicInputFormLayoutIncluded(helper=helper)
pack = helper.template_pack
rendered = rendered_template(form)
attempted = render_output(os.path.join(output_test_path, pack,
"test_layout.html"))
#write_output(output_test_path, pack, "test_layout.html", rendered)
assert parse_html(attempted) == parse_html(rendered)
def test_parsing_errors(self):
with self.assertRaises(AssertionError):
self.assertHTMLEqual('<p>', '')
with self.assertRaises(AssertionError):
self.assertHTMLEqual('', '<p>')
error_msg = (
"First argument is not valid HTML:\n"
"('Unexpected end tag `div` (Line 1, Column 6)', (1, 6))"
)
with self.assertRaisesMessage(AssertionError, error_msg):
self.assertHTMLEqual('< div></ div>', '<div></div>')
with self.assertRaises(HTMLParseError):
parse_html('</p>')
def test_self_closing_tags(self):
self_closing_tags = ("br", "hr", "input", "img", "meta", "spacer", "link", "frame", "base", "col")
for tag in self_closing_tags:
dom = parse_html("<p>Hello <%s> world</p>" % tag)
self.assertEqual(len(dom.children), 3)
self.assertEqual(dom[0], "Hello")
self.assertEqual(dom[1].name, tag)
self.assertEqual(dom[2], "world")
dom = parse_html("<p>Hello <%s /> world</p>" % tag)
self.assertEqual(len(dom.children), 3)
self.assertEqual(dom[0], "Hello")
self.assertEqual(dom[1].name, tag)
self.assertEqual(dom[2], "world")
def test_parse_html_in_script(self):
parse_html('<script>var a = "<p" + ">";</script>')
parse_html('''
<script>
var js_sha_link='<p>***</p>';
</script>
''')
# script content will be parsed to text
dom = parse_html('''
<script><p>foo</p> '</scr'+'ipt>' <span>bar</span></script>
''')
self.assertEqual(len(dom.children), 1)
self.assertEqual(dom.children[0], "<p>foo</p> '</scr'+'ipt>' <span>bar</span>")
def test_self_closing_tags(self):
self_closing_tags = ('br', 'hr', 'input', 'img', 'meta', 'spacer',
'link', 'frame', 'base', 'col')
for tag in self_closing_tags:
dom = parse_html('<p>Hello <%s> world</p>' % tag)
self.assertEqual(len(dom.children), 3)
self.assertEqual(dom[0], 'Hello')
self.assertEqual(dom[1].name, tag)
self.assertEqual(dom[2], 'world')
dom = parse_html('<p>Hello <%s /> world</p>' % tag)
self.assertEqual(len(dom.children), 3)
self.assertEqual(dom[0], 'Hello')
self.assertEqual(dom[1].name, tag)
self.assertEqual(dom[2], 'world')
def test_fakefield(output_test_path, render_output, rendered_template,
helper, client):
form = BasicInputForm()
pack = helper.template_pack
helper.layout = Layout(
FakeField('simple')
)
rendered = rendered_template(form, helper=helper)
attempted = render_output(os.path.join(output_test_path, pack,
"test_fakefield.html"))
#write_output(output_test_path, pack, "test_fakefield.html", rendered)
assert parse_html(attempted) == parse_html(rendered)
def assert_and_parse_html(self, html, user_msg, msg):
try:
dom = parse_html(html)
except HTMLParseError as e:
standardMsg = '%s\n%s' % (msg, e.msg)
self.fail(self._formatMessage(user_msg, standardMsg))
return dom
def assert_and_parse_html(html, user_msg, msg):
try:
dom = parse_html(html)
except HTMLParseError as e:
standard_msg = '%s\n%s\n%s' % (user_msg, msg, e.msg)
raise AssertionError(standard_msg)
return dom
def test_inlinefield(output_test_path, render_output, rendered_template,
helper, client):
form = BasicInputForm()
pack = helper.template_pack
helper.layout = Layout(
InlineField('simple', label_column='large-7', input_column='large-5',
label_class='foobar')
)
rendered = rendered_template(form, helper=helper)
attempted = render_output(os.path.join(output_test_path, pack,
"test_inlinefield.html"))
#write_output(output_test_path, pack, "test_inlinefield.html", rendered)
assert parse_html(attempted) == parse_html(rendered)
def test_self_closing_tags(self):
from django.test.html import parse_html
self_closing_tags = ('br', 'hr', 'input', 'img', 'meta', 'spacer',
'link', 'frame', 'base', 'col')
for tag in self_closing_tags:
dom = parse_html('<p>Hello <%s> world</p>' % tag)
self.assertEqual(len(dom.children), 3)
self.assertEqual(dom[0], 'Hello')
self.assertEqual(dom[1].name, tag)
self.assertEqual(dom[2], 'world')
dom = parse_html('<p>Hello <%s /> world</p>' % tag)
self.assertEqual(len(dom.children), 3)
self.assertEqual(dom[0], 'Hello')
self.assertEqual(dom[1].name, tag)
self.assertEqual(dom[2], 'world')
def test_prepended_appended_text(self, settings):
test_form = SampleForm()
test_form.helper = FormHelper()
test_form.helper.layout = Layout(
PrependedAppendedText('email', '@', 'gmail.com'),
AppendedText('password1', '#'),
PrependedText('password2', '$'),
)
html = render_crispy_form(test_form)
dom = parse_html(html)
# Check form parameters
if settings.CRISPY_TEMPLATE_PACK == 'bootstrap':
assert dom.count(parse_html('<span class="add-on">@</span>')) == 1
assert dom.count(parse_html('<span class="add-on">gmail.com</span>')) == 1
assert dom.count(parse_html('<span class="add-on">#</span>')) == 1
assert dom.count(parse_html('<span class="add-on">$</span>')) == 1
if settings.CRISPY_TEMPLATE_PACK == 'bootstrap3':
assert html.count('<span class="input-group-addon">@</span>') == 1
assert html.count(
'<span class="input-group-addon">gmail.com</span>') == 1
assert html.count('<span class="input-group-addon">#</span>') == 1
assert html.count('<span class="input-group-addon">$</span>') == 1
test_form.helper.layout = Layout(
PrependedAppendedText('email', '@', 'gmail.com',
css_class='input-lg'), )
html = render_crispy_form(test_form)
assert 'class="input-lg' in html
assert contains_partial(html, '<span class="input-group-addon input-lg"/>')
if settings.CRISPY_TEMPLATE_PACK == 'bootstrap4':
assert html.count('<span class="input-group-text">@</span>') == 1
assert html.count(
'<span class="input-group-text">gmail.com</span>') == 1
assert html.count('<span class="input-group-text">#</span>') == 1
assert html.count('<span class="input-group-text">$</span>') == 1
test_form.helper.layout = Layout(
PrependedAppendedText('email', '@', 'gmail.com',
css_class='form-control-lg'), )
html = render_crispy_form(test_form)
assert 'class="form-control-lg' in html
assert contains_partial(html, '<span class="input-group-text"/>')
def test_prepended_appended_text(self, settings):
test_form = SampleForm()
test_form.helper = FormHelper()
test_form.helper.layout = Layout(
PrependedAppendedText('email', '@', 'gmail.com'),
AppendedText('password1', '#'),
PrependedText('password2', '$'),
)
html = render_crispy_form(test_form)
dom = parse_html(html)
# Check form parameters
if settings.CRISPY_TEMPLATE_PACK == 'bootstrap':
assert dom.count(parse_html('<span class="add-on">@</span>')) == 1
assert dom.count(parse_html('<span class="add-on">gmail.com</span>')) == 1
assert dom.count(parse_html('<span class="add-on">#</span>')) == 1
assert dom.count(parse_html('<span class="add-on">$</span>')) == 1
if settings.CRISPY_TEMPLATE_PACK == 'bootstrap3':
assert html.count('<span class="input-group-addon">@</span>') == 1
assert html.count(
'<span class="input-group-addon">gmail.com</span>') == 1
assert html.count('<span class="input-group-addon">#</span>') == 1
assert html.count('<span class="input-group-addon">$</span>') == 1
test_form.helper.layout = Layout(
PrependedAppendedText('email', '@', 'gmail.com',
css_class='input-lg'), )
html = render_crispy_form(test_form)
assert 'class="input-lg' in html
assert contains_partial(html, '<span class="input-group-addon input-lg"/>')
if settings.CRISPY_TEMPLATE_PACK == 'bootstrap4':
assert html.count('<span class="input-group-text">@</span>') == 1
assert html.count(
'<span class="input-group-text">gmail.com</span>') == 1
assert html.count('<span class="input-group-text">#</span>') == 1
assert html.count('<span class="input-group-text">$</span>') == 1
test_form.helper.layout = Layout(
PrependedAppendedText('email', '@', 'gmail.com',
css_class='form-control-lg'), )
html = render_crispy_form(test_form)
assert 'class="form-control-lg' in html
assert contains_partial(html, '<span class="input-group-text"/>')
def test_inlinefield(output_test_path, render_output, rendered_template,
helper, client):
form = BasicInputForm()
pack = helper.template_pack
helper.layout = Layout(
InlineField('simple',
label_column='large-7',
input_column='large-5',
label_class='foobar'))
rendered = rendered_template(form, helper=helper)
attempted = render_output(
os.path.join(output_test_path, pack, "test_inlinefield.html"))
#write_output(output_test_path, pack, "test_inlinefield.html", rendered)
assert parse_html(attempted) == parse_html(rendered)
def _assert_and_parse_html(self, html, user_msg, msg):
"""
convert a html snippet into a DOM tree.
raise error if snippet is no valid html.
"""
try:
return parse_html(html)
except HTMLParseError, e:
self.fail("html code is not valid: %s - code: %r" % (e, html))
def _assert_and_parse_html_response(self, response):
"""
convert html response content into a DOM tree.
raise browser traceback, if content is no valid html.
"""
try:
return parse_html(response.content)
except HTMLParseError, e:
self.raise_browser_traceback(response, "Response's content is no valid html: %s" % e)
def test_inlineswitchfield(output_test_path, render_output, rendered_template,
helper, client):
form = BoolInputForm()
pack = helper.template_pack
helper.layout = Layout(
InlineSwitchField('opt_in', label_column='large-8',
input_column='large-4', label_class='foobar',
switch_class="inline")
)
rendered = rendered_template(form, helper=helper)
attempted = render_output(os.path.join(output_test_path, pack,
"test_inlineswitchfield.html"))
#write_output(output_test_path, pack, "test_inlineswitchfield.html", rendered)
assert parse_html(attempted) == parse_html(rendered)
def _assert_and_parse_html(self, html, user_msg, msg):
"""
convert a html snippet into a DOM tree.
raise error if snippet is no valid html.
"""
try:
return parse_html(html)
except HTMLParseError, e:
self.fail("html code is not valid: %s - code: %r" % (e, html))
def test_inlineswitchfield(output_test_path, render_output, rendered_template,
helper, client):
form = BoolInputForm()
pack = helper.template_pack
helper.layout = Layout(
InlineSwitchField('opt_in', label_column='large-8',
input_column='large-4', label_class='foobar',
switch_class='inline')
)
rendered = rendered_template(form, helper=helper)
attempted = render_output(os.path.join(output_test_path, pack,
'test_inlineswitchfield.html'))
#write_output(output_test_path, pack, "test_inlineswitchfield.html", rendered)
assert parse_html(attempted) == parse_html(rendered)
def contains_partial(haystack, needle):
"""Search for a html element with at least the corresponding elements
(other elements may be present in the matched element from the haystack)
"""
if not isinstance(haystack, Element):
haystack = parse_html(haystack)
if not isinstance(needle, Element):
needle = parse_html(needle)
if (
needle.name == haystack.name and
set(needle.attributes).issubset(haystack.attributes)
):
return True
return any(
contains_partial(child, needle) for child in haystack.children
if isinstance(child, Element)
)
def test_tab(output_test_path, render_output, rendered_template, helper,
client):
form = AdvancedForm()
pack = helper.template_pack
helper.layout = Layout(
TabHolder(TabItem('My tab 1', 'simple'),
TabItem('My tab 2', 'opt_in'),
TabItem('My tab 3', 'longtext'),
css_id="meep-meep"))
rendered = rendered_template(form, helper=helper)
attempted = render_output(
os.path.join(output_test_path, pack, "test_tab.html"))
#write_output(output_test_path, pack, "test_tab.html", rendered)
assert parse_html(attempted) == parse_html(rendered)
def assert_multi_email(
self,
subject=None,
html_snippets=None,
text_snippets=None,
snippet_context=None,
):
"""
Make assertions about a multipart/alternatives email.
Assert that there is only one email in the testing outbox, that it's
subject is ``subject``, and that all the snippets in ``html_snippets``
and ``text_snippets`` (both lists) are found in the HTML and text
portions of the email body, respectively.
If ``snippet_context`` is set, it is used as the context for a % string
interpolation on each snippet.
"""
assert len(mail.outbox) == 1
email = mail.outbox[0]
if subject is not None:
assert email.subject == subject
snippet_context = snippet_context or {}
snippet_context['base'] = settings.PORTFOLIYO_BASE_URL
assert len(email.alternatives) == 1
assert email.alternatives[0][1] == 'text/html'
parsed_html_body = html.parse_html(email.alternatives[0][0])
for html_bit in html_snippets or []:
if snippet_context:
html_bit = html_bit % snippet_context
parsed_bit = html.parse_html(html_bit)
assert parsed_html_body.count(
parsed_bit), "%s not in %s" % (parsed_bit, parsed_html_body)
body = email.body.replace('\n\n', '\n')
for text_bit in text_snippets or []:
if snippet_context:
text_bit = text_bit % snippet_context
assert text_bit in body, "%s not in %s" % (text_bit, body)
def test_buttongroup(output_test_path, render_output, rendered_template,
helper, client):
form = BasicInputForm()
pack = helper.template_pack
helper.layout = Layout(
'simple',
ButtonGroup(
Submit('Save', 'Save'),
Button('Cancel', 'Cancel'),
))
rendered = rendered_template(form, helper=helper)
attempted = render_output(
os.path.join(output_test_path, pack, "test_buttongroup.html"))
#write_output(output_test_path, pack, "test_buttongroup.html", rendered)
assert parse_html(attempted) == parse_html(rendered)
def parsed_inputs(html):
"Returns a dictionary mapping name --> node of inputs found in the HTML."
node = parse_html(html)
inputs = {}
for field in [c for c in node.children if c.name == 'input']:
name = dict(field.attributes)['name']
current = inputs.get(name, [])
current.append(field)
inputs[name] = current
return inputs
def contains_partial(haystack, needle, ignore_needle_children=False):
"""Search for a html element with at least the corresponding elements
(other elements may be present in the matched element from the haystack)
"""
if not isinstance(haystack, Element):
haystack = parse_html(haystack)
if not isinstance(needle, Element):
needle = parse_html(needle)
if len(needle.children) > 0 and not ignore_needle_children:
raise NotImplementedError("contains_partial does not check needle's children:%s" % str(needle.children))
if needle.name == haystack.name and set(needle.attributes).issubset(haystack.attributes):
return True
return any(
contains_partial(child, needle, ignore_needle_children=ignore_needle_children)
for child in haystack.children
if isinstance(child, Element)
)
def assert_multi_email(self,
subject=None,
html_snippets=None,
text_snippets=None,
snippet_context=None,
):
"""
Make assertions about a multipart/alternatives email.
Assert that there is only one email in the testing outbox, that it's
subject is ``subject``, and that all the snippets in ``html_snippets``
and ``text_snippets`` (both lists) are found in the HTML and text
portions of the email body, respectively.
If ``snippet_context`` is set, it is used as the context for a % string
interpolation on each snippet.
"""
assert len(mail.outbox) == 1
email = mail.outbox[0]
if subject is not None:
assert email.subject == subject
snippet_context = snippet_context or {}
snippet_context['base'] = settings.PORTFOLIYO_BASE_URL
assert len(email.alternatives) == 1
assert email.alternatives[0][1] == 'text/html'
parsed_html_body = html.parse_html(email.alternatives[0][0])
for html_bit in html_snippets or []:
if snippet_context:
html_bit = html_bit % snippet_context
parsed_bit = html.parse_html(html_bit)
assert parsed_html_body.count(parsed_bit), "%s not in %s" % (
parsed_bit, parsed_html_body)
body = email.body.replace('\n\n', '\n')
for text_bit in text_snippets or []:
if snippet_context:
text_bit = text_bit % snippet_context
assert text_bit in body, "%s not in %s" % (text_bit, body)
def parse_content(response, html=False):
"""
Décode et retourne le contenu de la réponse, en le transformant en
objet de structure Python si `html` vaut `True`.
"""
if (hasattr(response, "render") and callable(response.render)
and not response.is_rendered):
response.render()
content = response.content.decode(response.charset)
return parse_html(content) if html else content
def test_accordion(output_test_path, render_output, rendered_template, helper,
client):
form = AdvancedForm()
pack = helper.template_pack
# Define 'css_id' to avoid test fails with automatic generated random ID
helper.layout = Layout(
AccordionHolder(AccordionItem('Group 1', 'simple'),
AccordionItem('Group 2', 'opt_in'),
AccordionItem('Group 3', 'longtext'),
css_id="meep-meep"))
rendered = rendered_template(form, helper=helper)
attempted = render_output(
os.path.join(output_test_path, pack, "test_accordion.html"))
#write_output(output_test_path, pack, "test_accordion.html", rendered)
assert parse_html(attempted) == parse_html(rendered)
def _assert_and_parse_html_response(self, response):
"""
convert html response content into a DOM tree.
raise browser traceback, if content is no valid html.
"""
try:
return parse_html(response.content)
except HTMLParseError, e:
self.raise_browser_traceback(
response, "Response's content is no valid html: %s" % e)
def count_text_in_content(response, text, html=False):
"""
Retourne le nombre d'occurrence de `text` dans le contenu de la réponse,
en les analysant en tant que HTML si `html` vaut `True`.
Cette méthode se base sur `django.test.SimpleTestCase.assertContains()`,
et pourrait être remplacée après l'intégration de pytest-django#709.
"""
content = parse_content(response, html=html)
text = parse_html(text) if html else str(text)
return content.count(text)
def test_label_class_and_field_class():
form = SampleForm()
form.helper = FormHelper()
form.helper.label_class = 'col-lg-2'
form.helper.field_class = 'col-lg-8'
html = render_crispy_form(form)
dom = parse_html(html)
snippet = parse_html('<div class="form-group"> <div class="controls col-lg-offset-2 col-lg-8"> <div id="div_id_is_company" class="checkbox"> <label for="id_is_company" class=""> <input class="checkboxinput" id="id_is_company" name="is_company" type="checkbox" />company')
assert dom.count(snippet)
assert html.count('col-lg-8') == 7
form.helper.label_class = 'col-sm-3 col-md-4'
form.helper.field_class = 'col-sm-8 col-md-6'
html = render_crispy_form(form)
dom = parse_html(html)
snippet = parse_html('<div class="form-group"> <div class="controls col-sm-offset-3 col-md-offset-4 col-sm-8 col-md-6"> <div id="div_id_is_company" class="checkbox"> <label for="id_is_company" class=""> <input class="checkboxinput" id="id_is_company" name="is_company" type="checkbox" />company' )
assert dom.count(snippet)
assert html.count('col-sm-8') == 7
def test_buttongroup(output_test_path, render_output, rendered_template,
helper, client):
form = BasicInputForm()
pack = helper.template_pack
helper.layout = Layout(
'simple',
ButtonGroup(
Submit('Save', 'Save'),
Button('Cancel', 'Cancel'),
)
)
rendered = rendered_template(form, helper=helper)
attempted = render_output(os.path.join(output_test_path, pack,
"test_buttongroup.html"))
#write_output(output_test_path, pack, "test_buttongroup.html", rendered)
assert parse_html(attempted) == parse_html(rendered)
def test_label_class_and_field_class():
form = SampleForm()
form.helper = FormHelper()
form.helper.label_class = 'col-lg-2'
form.helper.field_class = 'col-lg-8'
html = render_crispy_form(form)
dom = parse_html(html)
snippet = parse_html('<div class="form-group"> <div class="controls col-lg-offset-2 col-lg-8"> <div id="div_id_is_company" class="checkbox"> <label for="id_is_company" class=""> <input class="checkboxinput" id="id_is_company" name="is_company" type="checkbox" />company')
assert dom.count(snippet)
assert html.count('col-lg-8') == 7
form.helper.label_class = 'col-sm-3 col-md-4'
form.helper.field_class = 'col-sm-8 col-md-6'
html = render_crispy_form(form)
dom = parse_html(html)
snippet = parse_html('<div class="form-group"> <div class="controls col-sm-offset-3 col-md-offset-4 col-sm-8 col-md-6"> <div id="div_id_is_company" class="checkbox"> <label for="id_is_company" class=""> <input class="checkboxinput" id="id_is_company" name="is_company" type="checkbox" />company' )
assert dom.count(snippet)
assert html.count('col-sm-8') == 7
def grab_field_data(self, response):
"""
Pull the appropriate field data from the context to pass to the next wizard step
"""
previous_fields = parse_html(response.context['previous_fields'])
fields = {'wizard_step': response.context['step0']}
for input_field in previous_fields:
input_attrs = dict(input_field.attributes)
fields[input_attrs["name"]] = input_attrs["value"]
return fields
def grab_field_data(self, response):
"""
Pull the appropriate field data from the context to pass to the next wizard step
"""
previous_fields = parse_html(response.context['previous_fields'])
fields = {'wizard_step': response.context['step0']}
for input_field in previous_fields:
input_attrs = dict(input_field.attributes)
fields[input_attrs["name"]] = input_attrs["value"]
return fields
def test_tab(output_test_path, render_output, rendered_template, helper,
client):
form = AdvancedForm()
pack = helper.template_pack
helper.layout = Layout(
TabHolder(
TabItem('My tab 1', 'simple'),
TabItem('My tab 2', 'opt_in'),
TabItem('My tab 3', 'longtext'),
css_id="meep-meep"
)
)
rendered = rendered_template(form, helper=helper)
attempted = render_output(os.path.join(output_test_path, pack,
"test_tab.html"))
#write_output(output_test_path, pack, "test_tab.html", rendered)
assert parse_html(attempted) == parse_html(rendered)
def test_accordion(output_test_path, render_output, rendered_template, helper,
client):
form = AdvancedForm()
pack = helper.template_pack
# Define 'css_id' to avoid test fails with automatic generated random ID
helper.layout = Layout(
AccordionHolder(
AccordionItem('Group 1', 'simple'),
AccordionItem('Group 2', 'opt_in'),
AccordionItem('Group 3', 'longtext'),
css_id="meep-meep"
)
)
rendered = rendered_template(form, helper=helper)
attempted = render_output(os.path.join(output_test_path, pack,
"test_accordion.html"))
#write_output(output_test_path, pack, "test_accordion.html", rendered)
assert parse_html(attempted) == parse_html(rendered)
def test_advanced(output_test_path, render_output, rendered_template, helper,
client):
form = AdvancedForm()
pack = helper.template_pack
helper.layout = Layout(
Row(
Column('simple', css_class='six'),
Column('opt_in', css_class='six'),
),
Row(Column('longtext'), ),
Row(Column(ButtonHolder(Submit('submit', 'Submit')), ),
css_class="large"),
)
rendered = rendered_template(form, helper=helper)
attempted = render_output(
os.path.join(output_test_path, pack, "test_advanced.html"))
#write_output(output_test_path, pack, "test_advanced.html", rendered)
assert parse_html(attempted) == parse_html(rendered)
def test_process__sample__links_are_updated(wiki, page, asset):
raw = f"""
<p><a href="/app">example</a></p>
<p><a href="other">other</a></p>
<p><a href="wiki:sibling">sibling</a></p>
<p><img src="asset:{asset.name}"></p>
"""
expected = f"""
<p>
<a href="/app">example</a>
</p>
<p>
<a
href="/wiki/slug/parent/other/"
data-edit="/wiki/slug/parent/other/_edit/"
data-missing="True"
class="powerwiki__wiki"
>other</a>
</p>
<p>
<a
href="/wiki/slug/sibling/"
data-edit="/wiki/slug/sibling/_edit/"
data-missing="True"
class="powerwiki__wiki"
>sibling</a>
</p>
<p>
<img
src="{asset.file.url}"
data-edit="/wiki/slug/_asset/{asset.name}/_edit/"
class="powerwiki__asset"
>
</p>
"""
processed = process(raw, wiki=wiki, page=page, user=AnonymousUser())
assert parse_html(processed) == parse_html(expected)
def assertHTMLInContent(self, html_tag, resp):
find_html = parse_html(html_tag)
if find_html.children:
raise ValueError("Can only look for single tags")
tag_name = find_html.name
find_attrs = dict(find_html.attributes)
html = parse_html(encoding.smart_text(resp.content))
queue = deque()
queue.extend(html.children)
while queue:
node = queue.popleft()
if isinstance(node, Element):
if node.name == tag_name and _is_dict_subset(find_attrs, dict(node.attributes)):
return
if node.children:
queue.extend(node.children)
raise AssertionError("Element <{html_tag}> not found in {html}".format(
html_tag=html_tag,
html=html,
))
def assertHTMLInContent(self, html_tag, resp):
find_html = parse_html(html_tag)
if find_html.children:
raise ValueError("Can only look for single tags")
tag_name = find_html.name
find_attrs = dict(find_html.attributes)
html = parse_html(encoding.smart_text(resp.content))
queue = deque()
queue.extend(html.children)
while queue:
node = queue.popleft()
if isinstance(node, Element):
if node.name == tag_name and _is_dict_subset(find_attrs, dict(node.attributes)):
return
if node.children:
queue.extend(node.children)
raise AssertionError("Element <{html_tag}> not found in {html}".format(
html_tag=html_tag,
html=html,
))
def mail_sent_contains_html(self):
"""
Test that an email contains the HTML (assert HTML in) in the multiline as
one of its MIME alternatives.
The HTML is normalised by passing through Django's
:func:`django.test.html.parse_html`.
Example:
.. code-block:: gherkin
And I have sent an email with the following HTML alternative:
\"\"\"
<p><strong>Name:</strong> Sir Panda</p>
<p><strong>Phone:</strong> 0400000000</p>
<p><strong>Email:</strong> [email protected]</p>
\"\"\"
"""
for email in mail.outbox:
try:
html = next(content for content, mime in email.alternatives
if mime == 'text/html')
dom1 = parse_html(html)
dom2 = parse_html(self.multiline)
assert_in(dom1, dom2)
except AssertionError as exc:
print("Email did not match", exc)
# we intentionally eat the exception
continue
return True
raise AssertionError("No email contained the HTML")
def mail_sent_contains_html(self):
"""
Test that an email contains the HTML (assert HTML in) in the multiline as
one of its MIME alternatives.
The HTML is normalised by passing through Django's
:func:`django.test.html.parse_html`.
Example:
.. code-block:: gherkin
And I have sent an email with the following HTML alternative:
\"\"\"
<p><strong>Name:</strong> Sir Panda</p>
<p><strong>Phone:</strong> 0400000000</p>
<p><strong>Email:</strong> [email protected]</p>
\"\"\"
"""
for email in mail.outbox:
try:
html = next(content for content, mime in email.alternatives
if mime == 'text/html')
dom1 = parse_html(html)
dom2 = parse_html(self.multiline)
assert_in(dom1, dom2)
except AssertionError as exc:
print("Email did not match", exc)
# we intentionally eat the exception
continue
return True
raise AssertionError("No email contained the HTML")
def test_error_summary():
"""Verify an error summary is displayed correctly."""
template = """
{% load crispy_forms_tags %}
{% if form.helper.form_show_errors and form.errors %}
{% include 'gds/layout/error_summary.html' %}
{% endif %}
<div class="govuk-body">
{% crispy form %}
</div>
"""
form = TextInputForm(data={"name": ""})
form.add_error(None, "Non-field error")
page = render_template(template, form=form)
assert parse_html(page) == parse_contents(RESULT_DIR, "error_summary.html")
def html_element(content):
"""
Shortand to use Django HTML parsing on given content.
This is more useful for comparaison on HTML parts.
Arguments:
content (TemplateResponse or string): HTML content to parse.
Returns:
django.test.html.Element: A Python object structure able to perform
comparaison on a semantical way. See ``django.test.html.parse_html`` for
more details.
"""
return parse_html(decode_response_or_string(content))
def test_html_parser(self):
element = parse_html('<div><p>Hello</p></div>')
self.assertEqual(len(element.children), 1)
self.assertEqual(element.children[0].name, 'p')
self.assertEqual(element.children[0].children[0], 'Hello')
parse_html('<p>')
parse_html('<p attr>')
dom = parse_html('<p>foo')
self.assertEqual(len(dom.children), 1)
self.assertEqual(dom.name, 'p')
self.assertEqual(dom[0], 'foo')
def test_html_parser(self):
element = parse_html("<div><p>Hello</p></div>")
self.assertEqual(len(element.children), 1)
self.assertEqual(element.children[0].name, "p")
self.assertEqual(element.children[0].children[0], "Hello")
parse_html("<p>")
parse_html("<p attr>")
dom = parse_html("<p>foo")
self.assertEqual(len(dom.children), 1)
self.assertEqual(dom.name, "p")
self.assertEqual(dom[0], "foo")
def test_html_parser(self):
element = parse_html('<div><p>Hello</p></div>')
self.assertEqual(len(element.children), 1)
self.assertEqual(element.children[0].name, 'p')
self.assertEqual(element.children[0].children[0], 'Hello')
parse_html('<p>')
parse_html('<p attr>')
dom = parse_html('<p>foo')
self.assertEqual(len(dom.children), 1)
self.assertEqual(dom.name, 'p')
self.assertEqual(dom[0], 'foo')
def test_change_workbasket_status_options(upload, client, superadmin, workbasket):
detail_url = reverse("admin:workbaskets_workbasket_change", args=[workbasket.id])
client.force_login(superadmin)
response = client.get(detail_url, follow=True)
select = re.search(
r'<select name="transition".*select>',
response.content.decode(),
re.DOTALL,
)
if not select:
pytest.fail("Workbasket transition select field not found")
options = parse_html(select[0]).children
option_values = [
attr[1] for opt in options for attr in opt.attributes if attr[0] == "value"
]
assert option_values == [""] + [
t.name for t in workbasket.get_available_status_transitions()
]
def arrange(self, element):
"""Arrange an HTML node for comparison.
This method uses Django's ``parse_html`` testing utility to build
an HTML node for asserting purposes. Usage::
def test_div_foo(client, parser):
body = parser.parse(client.get('/foo/'))
expected = parser.arrange('<body><div>foo</div></body>')
assert parser.arrage(body) == expected
:param element: An HTML element. This can be either an lxml element,
or a string containing valid HTML. If an lxml element is passed
in, ``lxml.etree.tostring`` is used to convert the element to
string.
"""
lxml_etree = pytest.importorskip('lxml.etree')
if isinstance(element, lxml_etree.ElementBase):
element = lxml_etree.tostring(element)
if not isinstance(element, str):
element = element.decode('utf-8')
return parse_html(element)
def test_html_contain(self):
# equal html contains each other
dom1 = parse_html('<p>foo')
dom2 = parse_html('<p>foo</p>')
self.assertIn(dom1, dom2)
self.assertIn(dom2, dom1)
dom2 = parse_html('<div><p>foo</p></div>')
self.assertIn(dom1, dom2)
self.assertNotIn(dom2, dom1)
self.assertNotIn('<p>foo</p>', dom2)
self.assertIn('foo', dom2)
# when a root element is used ...
dom1 = parse_html('<p>foo</p><p>bar</p>')
dom2 = parse_html('<p>foo</p><p>bar</p>')
self.assertIn(dom1, dom2)
dom1 = parse_html('<p>foo</p>')
self.assertIn(dom1, dom2)
dom1 = parse_html('<p>bar</p>')
self.assertIn(dom1, dom2)
dom1 = parse_html('<div><p>foo</p><p>bar</p></div>')
self.assertIn(dom2, dom1)
def test_html_contain(self):
# equal html contains each other
dom1 = parse_html('<p>foo')
dom2 = parse_html('<p>foo</p>')
self.assertTrue(dom1 in dom2)
self.assertTrue(dom2 in dom1)
dom2 = parse_html('<div><p>foo</p></div>')
self.assertTrue(dom1 in dom2)
self.assertTrue(dom2 not in dom1)
self.assertFalse('<p>foo</p>' in dom2)
self.assertTrue('foo' in dom2)
# when a root element is used ...
dom1 = parse_html('<p>foo</p><p>bar</p>')
dom2 = parse_html('<p>foo</p><p>bar</p>')
self.assertTrue(dom1 in dom2)
dom1 = parse_html('<p>foo</p>')
self.assertTrue(dom1 in dom2)
dom1 = parse_html('<p>bar</p>')
self.assertTrue(dom1 in dom2)
def test_count(self):
# equal html contains each other one time
dom1 = parse_html('<p>foo')
dom2 = parse_html('<p>foo</p>')
self.assertEqual(dom1.count(dom2), 1)
self.assertEqual(dom2.count(dom1), 1)
dom2 = parse_html('<p>foo</p><p>bar</p>')
self.assertEqual(dom2.count(dom1), 1)
dom2 = parse_html('<p>foo foo</p><p>foo</p>')
self.assertEqual(dom2.count('foo'), 3)
dom2 = parse_html('<p class="bar">foo</p>')
self.assertEqual(dom2.count('bar'), 0)
self.assertEqual(dom2.count('class'), 0)
self.assertEqual(dom2.count('p'), 0)
self.assertEqual(dom2.count('o'), 2)
dom2 = parse_html('<p>foo</p><p>foo</p>')
self.assertEqual(dom2.count(dom1), 2)
dom2 = parse_html('<div><p>foo<input type=""></p><p>foo</p></div>')
self.assertEqual(dom2.count(dom1), 1)
dom2 = parse_html('<div><div><p>foo</p></div></div>')
self.assertEqual(dom2.count(dom1), 1)
dom2 = parse_html('<p>foo<p>foo</p></p>')
self.assertEqual(dom2.count(dom1), 1)
dom2 = parse_html('<p>foo<p>bar</p></p>')
self.assertEqual(dom2.count(dom1), 0)
# html with a root element contains the same html with no root element
dom1 = parse_html('<p>foo</p><p>bar</p>')
dom2 = parse_html('<div><p>foo</p><p>bar</p></div>')
self.assertEqual(dom2.count(dom1), 1)
def test_review_request_box_template_hooks(self):
"""Testing ReviewRequestDetailView template hooks for the review
request box
"""
class ContentTemplateHook(TemplateHook):
def initialize(self, name, content):
super(ContentTemplateHook, self).initialize(name)
self.content = content
def render_to_string(self, request, context):
return self.content
class TestExtension(Extension):
registration = RegisteredExtension.objects.create(
class_name='test-extension',
name='test-extension',
enabled=True,
installed=True)
extension = TestExtension(get_extension_manager())
review_request = self.create_review_request(publish=True)
hooks = []
for name in ('before-review-request-summary',
'review-request-summary-pre',
'review-request-summary-post',
'after-review-request-summary-post',
'before-review-request-fields',
'after-review-request-fields',
'before-review-request-extra-panes',
'review-request-extra-panes-pre',
'review-request-extra-panes-post',
'after-review-request-extra-panes'):
hooks.append(ContentTemplateHook(extension, name,
'[%s here]' % name))
# Turn off some parts of the page, to simplify the resulting HTML
# and shorten render/parse times.
self.spy_on(get_review_request_fieldsets,
call_fake=lambda *args, **kwargs: [])
response = self.client.get(
local_site_reverse('review-request-detail',
args=[review_request.display_id]))
self.assertEqual(response.status_code, 200)
parsed_html = six.text_type(
parse_html(response.content.decode('utf-8')))
self.assertIn(
'<div class="review-request-body">\n'
'[before-review-request-summary here]',
parsed_html)
self.assertIn(
'<div class="review-request-section review-request-summary">\n'
'[review-request-summary-pre here]',
parsed_html)
self.assertIn(
'</time>\n</p>[review-request-summary-post here]\n</div>',
parsed_html)
self.assertIn(
'[before-review-request-fields here]'
'<table class="review-request-section"'
' id="review-request-details">',
parsed_html)
self.assertIn(
'</div>'
'[after-review-request-fields here] '
'[before-review-request-extra-panes here]'
'<div id="review-request-extra">\n'
'[review-request-extra-panes-pre here]',
parsed_html)
self.assertIn(
'</div>[review-request-extra-panes-post here]\n'
'</div>[after-review-request-extra-panes here]\n'
'</div>',
parsed_html)
