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_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 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 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 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_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)