mirror of
https://github.com/moparisthebest/SickRage
synced 2024-11-11 03:45:01 -05:00
593 lines
24 KiB
Python
593 lines
24 KiB
Python
|
"""Helper classes for tests."""
|
||
|
|
|
||
|
|
import copy
|
||
|
|
import functools
|
||
|
|
import unittest
|
||
|
|
from unittest import TestCase
|
||
|
|
from bs4 import BeautifulSoup
|
||
|
|
from bs4.element import (
|
||
|
|
CharsetMetaAttributeValue,
|
||
|
|
Comment,
|
||
|
|
ContentMetaAttributeValue,
|
||
|
|
Doctype,
|
||
|
|
SoupStrainer,
|
||
|
|
)
|
||
|
|
|
||
|
|
from bs4.builder import HTMLParserTreeBuilder
|
||
|
|
default_builder = HTMLParserTreeBuilder
|
||
|
|
|
||
|
|
|
||
|
|
class SoupTest(unittest.TestCase):
|
||
|
|
|
||
|
|
@property
|
||
|
|
def default_builder(self):
|
||
|
|
return default_builder()
|
||
|
|
|
||
|
|
def soup(self, markup, **kwargs):
|
||
|
|
"""Build a Beautiful Soup object from markup."""
|
||
|
|
builder = kwargs.pop('builder', self.default_builder)
|
||
|
|
return BeautifulSoup(markup, builder=builder, **kwargs)
|
||
|
|
|
||
|
|
def document_for(self, markup):
|
||
|
|
"""Turn an HTML fragment into a document.
|
||
|
|
|
||
|
|
The details depend on the builder.
|
||
|
|
"""
|
||
|
|
return self.default_builder.test_fragment_to_document(markup)
|
||
|
|
|
||
|
|
def assertSoupEquals(self, to_parse, compare_parsed_to=None):
|
||
|
|
builder = self.default_builder
|
||
|
|
obj = BeautifulSoup(to_parse, builder=builder)
|
||
|
|
if compare_parsed_to is None:
|
||
|
|
compare_parsed_to = to_parse
|
||
|
|
|
||
|
|
self.assertEqual(obj.decode(), self.document_for(compare_parsed_to))
|
||
|
|
|
||
|
|
|
||
|
|
class HTMLTreeBuilderSmokeTest(object):
|
||
|
|
|
||
|
|
"""A basic test of a treebuilder's competence.
|
||
|
|
|
||
|
|
Any HTML treebuilder, present or future, should be able to pass
|
||
|
|
these tests. With invalid markup, there's room for interpretation,
|
||
|
|
and different parsers can handle it differently. But with the
|
||
|
|
markup in these tests, there's not much room for interpretation.
|
||
|
|
"""
|
||
|
|
|
||
|
|
def assertDoctypeHandled(self, doctype_fragment):
|
||
|
|
"""Assert that a given doctype string is handled correctly."""
|
||
|
|
doctype_str, soup = self._document_with_doctype(doctype_fragment)
|
||
|
|
|
||
|
|
# Make sure a Doctype object was created.
|
||
|
|
doctype = soup.contents[0]
|
||
|
|
self.assertEqual(doctype.__class__, Doctype)
|
||
|
|
self.assertEqual(doctype, doctype_fragment)
|
||
|
|
self.assertEqual(str(soup)[:len(doctype_str)], doctype_str)
|
||
|
|
|
||
|
|
# Make sure that the doctype was correctly associated with the
|
||
|
|
# parse tree and that the rest of the document parsed.
|
||
|
|
self.assertEqual(soup.p.contents[0], 'foo')
|
||
|
|
|
||
|
|
def _document_with_doctype(self, doctype_fragment):
|
||
|
|
"""Generate and parse a document with the given doctype."""
|
||
|
|
doctype = '<!DOCTYPE %s>' % doctype_fragment
|
||
|
|
markup = doctype + '\n<p>foo</p>'
|
||
|
|
soup = self.soup(markup)
|
||
|
|
return doctype, soup
|
||
|
|
|
||
|
|
def test_normal_doctypes(self):
|
||
|
|
"""Make sure normal, everyday HTML doctypes are handled correctly."""
|
||
|
|
self.assertDoctypeHandled("html")
|
||
|
|
self.assertDoctypeHandled(
|
||
|
|
'html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"')
|
||
|
|
|
||
|
|
def test_empty_doctype(self):
|
||
|
|
soup = self.soup("<!DOCTYPE>")
|
||
|
|
doctype = soup.contents[0]
|
||
|
|
self.assertEqual("", doctype.strip())
|
||
|
|
|
||
|
|
def test_public_doctype_with_url(self):
|
||
|
|
doctype = 'html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"'
|
||
|
|
self.assertDoctypeHandled(doctype)
|
||
|
|
|
||
|
|
def test_system_doctype(self):
|
||
|
|
self.assertDoctypeHandled('foo SYSTEM "http://www.example.com/"')
|
||
|
|
|
||
|
|
def test_namespaced_system_doctype(self):
|
||
|
|
# We can handle a namespaced doctype with a system ID.
|
||
|
|
self.assertDoctypeHandled('xsl:stylesheet SYSTEM "htmlent.dtd"')
|
||
|
|
|
||
|
|
def test_namespaced_public_doctype(self):
|
||
|
|
# Test a namespaced doctype with a public id.
|
||
|
|
self.assertDoctypeHandled('xsl:stylesheet PUBLIC "htmlent.dtd"')
|
||
|
|
|
||
|
|
def test_real_xhtml_document(self):
|
||
|
|
"""A real XHTML document should come out more or less the same as it went in."""
|
||
|
|
markup = b"""<?xml version="1.0" encoding="utf-8"?>
|
||
|
|
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN">
|
||
|
|
<html xmlns="http://www.w3.org/1999/xhtml">
|
||
|
|
<head><title>Hello.</title></head>
|
||
|
|
<body>Goodbye.</body>
|
||
|
|
</html>"""
|
||
|
|
soup = self.soup(markup)
|
||
|
|
self.assertEqual(
|
||
|
|
soup.encode("utf-8").replace(b"\n", b""),
|
||
|
|
markup.replace(b"\n", b""))
|
||
|
|
|
||
|
|
def test_deepcopy(self):
|
||
|
|
"""Make sure you can copy the tree builder.
|
||
|
|
|
||
|
|
This is important because the builder is part of a
|
||
|
|
BeautifulSoup object, and we want to be able to copy that.
|
||
|
|
"""
|
||
|
|
copy.deepcopy(self.default_builder)
|
||
|
|
|
||
|
|
def test_p_tag_is_never_empty_element(self):
|
||
|
|
"""A <p> tag is never designated as an empty-element tag.
|
||
|
|
|
||
|
|
Even if the markup shows it as an empty-element tag, it
|
||
|
|
shouldn't be presented that way.
|
||
|
|
"""
|
||
|
|
soup = self.soup("<p/>")
|
||
|
|
self.assertFalse(soup.p.is_empty_element)
|
||
|
|
self.assertEqual(str(soup.p), "<p></p>")
|
||
|
|
|
||
|
|
def test_unclosed_tags_get_closed(self):
|
||
|
|
"""A tag that's not closed by the end of the document should be closed.
|
||
|
|
|
||
|
|
This applies to all tags except empty-element tags.
|
||
|
|
"""
|
||
|
|
self.assertSoupEquals("<p>", "<p></p>")
|
||
|
|
self.assertSoupEquals("<b>", "<b></b>")
|
||
|
|
|
||
|
|
self.assertSoupEquals("<br>", "<br/>")
|
||
|
|
|
||
|
|
def test_br_is_always_empty_element_tag(self):
|
||
|
|
"""A <br> tag is designated as an empty-element tag.
|
||
|
|
|
||
|
|
Some parsers treat <br></br> as one <br/> tag, some parsers as
|
||
|
|
two tags, but it should always be an empty-element tag.
|
||
|
|
"""
|
||
|
|
soup = self.soup("<br></br>")
|
||
|
|
self.assertTrue(soup.br.is_empty_element)
|
||
|
|
self.assertEqual(str(soup.br), "<br/>")
|
||
|
|
|
||
|
|
def test_nested_formatting_elements(self):
|
||
|
|
self.assertSoupEquals("<em><em></em></em>")
|
||
|
|
|
||
|
|
def test_comment(self):
|
||
|
|
# Comments are represented as Comment objects.
|
||
|
|
markup = "<p>foo<!--foobar-->baz</p>"
|
||
|
|
self.assertSoupEquals(markup)
|
||
|
|
|
||
|
|
soup = self.soup(markup)
|
||
|
|
comment = soup.find(text="foobar")
|
||
|
|
self.assertEqual(comment.__class__, Comment)
|
||
|
|
|
||
|
|
# The comment is properly integrated into the tree.
|
||
|
|
foo = soup.find(text="foo")
|
||
|
|
self.assertEqual(comment, foo.next_element)
|
||
|
|
baz = soup.find(text="baz")
|
||
|
|
self.assertEqual(comment, baz.previous_element)
|
||
|
|
|
||
|
|
def test_preserved_whitespace_in_pre_and_textarea(self):
|
||
|
|
"""Whitespace must be preserved in <pre> and <textarea> tags."""
|
||
|
|
self.assertSoupEquals("<pre> </pre>")
|
||
|
|
self.assertSoupEquals("<textarea> woo </textarea>")
|
||
|
|
|
||
|
|
def test_nested_inline_elements(self):
|
||
|
|
"""Inline elements can be nested indefinitely."""
|
||
|
|
b_tag = "<b>Inside a B tag</b>"
|
||
|
|
self.assertSoupEquals(b_tag)
|
||
|
|
|
||
|
|
nested_b_tag = "<p>A <i>nested <b>tag</b></i></p>"
|
||
|
|
self.assertSoupEquals(nested_b_tag)
|
||
|
|
|
||
|
|
double_nested_b_tag = "<p>A <a>doubly <i>nested <b>tag</b></i></a></p>"
|
||
|
|
self.assertSoupEquals(nested_b_tag)
|
||
|
|
|
||
|
|
def test_nested_block_level_elements(self):
|
||
|
|
"""Block elements can be nested."""
|
||
|
|
soup = self.soup('<blockquote><p><b>Foo</b></p></blockquote>')
|
||
|
|
blockquote = soup.blockquote
|
||
|
|
self.assertEqual(blockquote.p.b.string, 'Foo')
|
||
|
|
self.assertEqual(blockquote.b.string, 'Foo')
|
||
|
|
|
||
|
|
def test_correctly_nested_tables(self):
|
||
|
|
"""One table can go inside another one."""
|
||
|
|
markup = ('<table id="1">'
|
||
|
|
'<tr>'
|
||
|
|
"<td>Here's another table:"
|
||
|
|
'<table id="2">'
|
||
|
|
'<tr><td>foo</td></tr>'
|
||
|
|
'</table></td>')
|
||
|
|
|
||
|
|
self.assertSoupEquals(
|
||
|
|
markup,
|
||
|
|
'<table id="1"><tr><td>Here\'s another table:'
|
||
|
|
'<table id="2"><tr><td>foo</td></tr></table>'
|
||
|
|
'</td></tr></table>')
|
||
|
|
|
||
|
|
self.assertSoupEquals(
|
||
|
|
"<table><thead><tr><td>Foo</td></tr></thead>"
|
||
|
|
"<tbody><tr><td>Bar</td></tr></tbody>"
|
||
|
|
"<tfoot><tr><td>Baz</td></tr></tfoot></table>")
|
||
|
|
|
||
|
|
def test_deeply_nested_multivalued_attribute(self):
|
||
|
|
# html5lib can set the attributes of the same tag many times
|
||
|
|
# as it rearranges the tree. This has caused problems with
|
||
|
|
# multivalued attributes.
|
||
|
|
markup = '<table><div><div class="css"></div></div></table>'
|
||
|
|
soup = self.soup(markup)
|
||
|
|
self.assertEqual(["css"], soup.div.div['class'])
|
||
|
|
|
||
|
|
def test_angle_brackets_in_attribute_values_are_escaped(self):
|
||
|
|
self.assertSoupEquals('<a b="<a>"></a>', '<a b="<a>"></a>')
|
||
|
|
|
||
|
|
def test_entities_in_attributes_converted_to_unicode(self):
|
||
|
|
expect = u'<p id="pi\N{LATIN SMALL LETTER N WITH TILDE}ata"></p>'
|
||
|
|
self.assertSoupEquals('<p id="piñata"></p>', expect)
|
||
|
|
self.assertSoupEquals('<p id="piñata"></p>', expect)
|
||
|
|
self.assertSoupEquals('<p id="piñata"></p>', expect)
|
||
|
|
self.assertSoupEquals('<p id="piñata"></p>', expect)
|
||
|
|
|
||
|
|
def test_entities_in_text_converted_to_unicode(self):
|
||
|
|
expect = u'<p>pi\N{LATIN SMALL LETTER N WITH TILDE}ata</p>'
|
||
|
|
self.assertSoupEquals("<p>piñata</p>", expect)
|
||
|
|
self.assertSoupEquals("<p>piñata</p>", expect)
|
||
|
|
self.assertSoupEquals("<p>piñata</p>", expect)
|
||
|
|
self.assertSoupEquals("<p>piñata</p>", expect)
|
||
|
|
|
||
|
|
def test_quot_entity_converted_to_quotation_mark(self):
|
||
|
|
self.assertSoupEquals("<p>I said "good day!"</p>",
|
||
|
|
'<p>I said "good day!"</p>')
|
||
|
|
|
||
|
|
def test_out_of_range_entity(self):
|
||
|
|
expect = u"\N{REPLACEMENT CHARACTER}"
|
||
|
|
self.assertSoupEquals("�", expect)
|
||
|
|
self.assertSoupEquals("�", expect)
|
||
|
|
self.assertSoupEquals("�", expect)
|
||
|
|
|
||
|
|
def test_multipart_strings(self):
|
||
|
|
"Mostly to prevent a recurrence of a bug in the html5lib treebuilder."
|
||
|
|
soup = self.soup("<html><h2>\nfoo</h2><p></p></html>")
|
||
|
|
self.assertEqual("p", soup.h2.string.next_element.name)
|
||
|
|
self.assertEqual("p", soup.p.name)
|
||
|
|
|
||
|
|
def test_basic_namespaces(self):
|
||
|
|
"""Parsers don't need to *understand* namespaces, but at the
|
||
|
|
very least they should not choke on namespaces or lose
|
||
|
|
data."""
|
||
|
|
|
||
|
|
markup = b'<html xmlns="http://www.w3.org/1999/xhtml" xmlns:mathml="http://www.w3.org/1998/Math/MathML" xmlns:svg="http://www.w3.org/2000/svg"><head></head><body><mathml:msqrt>4</mathml:msqrt><b svg:fill="red"></b></body></html>'
|
||
|
|
soup = self.soup(markup)
|
||
|
|
self.assertEqual(markup, soup.encode())
|
||
|
|
html = soup.html
|
||
|
|
self.assertEqual('http://www.w3.org/1999/xhtml', soup.html['xmlns'])
|
||
|
|
self.assertEqual(
|
||
|
|
'http://www.w3.org/1998/Math/MathML', soup.html['xmlns:mathml'])
|
||
|
|
self.assertEqual(
|
||
|
|
'http://www.w3.org/2000/svg', soup.html['xmlns:svg'])
|
||
|
|
|
||
|
|
def test_multivalued_attribute_value_becomes_list(self):
|
||
|
|
markup = b'<a class="foo bar">'
|
||
|
|
soup = self.soup(markup)
|
||
|
|
self.assertEqual(['foo', 'bar'], soup.a['class'])
|
||
|
|
|
||
|
|
#
|
||
|
|
# Generally speaking, tests below this point are more tests of
|
||
|
|
# Beautiful Soup than tests of the tree builders. But parsers are
|
||
|
|
# weird, so we run these tests separately for every tree builder
|
||
|
|
# to detect any differences between them.
|
||
|
|
#
|
||
|
|
|
||
|
|
def test_can_parse_unicode_document(self):
|
||
|
|
# A seemingly innocuous document... but it's in Unicode! And
|
||
|
|
# it contains characters that can't be represented in the
|
||
|
|
# encoding found in the declaration! The horror!
|
||
|
|
markup = u'<html><head><meta encoding="euc-jp"></head><body>Sacr\N{LATIN SMALL LETTER E WITH ACUTE} bleu!</body>'
|
||
|
|
soup = self.soup(markup)
|
||
|
|
self.assertEqual(u'Sacr\xe9 bleu!', soup.body.string)
|
||
|
|
|
||
|
|
def test_soupstrainer(self):
|
||
|
|
"""Parsers should be able to work with SoupStrainers."""
|
||
|
|
strainer = SoupStrainer("b")
|
||
|
|
soup = self.soup("A <b>bold</b> <meta/> <i>statement</i>",
|
||
|
|
parse_only=strainer)
|
||
|
|
self.assertEqual(soup.decode(), "<b>bold</b>")
|
||
|
|
|
||
|
|
def test_single_quote_attribute_values_become_double_quotes(self):
|
||
|
|
self.assertSoupEquals("<foo attr='bar'></foo>",
|
||
|
|
'<foo attr="bar"></foo>')
|
||
|
|
|
||
|
|
def test_attribute_values_with_nested_quotes_are_left_alone(self):
|
||
|
|
text = """<foo attr='bar "brawls" happen'>a</foo>"""
|
||
|
|
self.assertSoupEquals(text)
|
||
|
|
|
||
|
|
def test_attribute_values_with_double_nested_quotes_get_quoted(self):
|
||
|
|
text = """<foo attr='bar "brawls" happen'>a</foo>"""
|
||
|
|
soup = self.soup(text)
|
||
|
|
soup.foo['attr'] = 'Brawls happen at "Bob\'s Bar"'
|
||
|
|
self.assertSoupEquals(
|
||
|
|
soup.foo.decode(),
|
||
|
|
"""<foo attr="Brawls happen at "Bob\'s Bar"">a</foo>""")
|
||
|
|
|
||
|
|
def test_ampersand_in_attribute_value_gets_escaped(self):
|
||
|
|
self.assertSoupEquals('<this is="really messed up & stuff"></this>',
|
||
|
|
'<this is="really messed up & stuff"></this>')
|
||
|
|
|
||
|
|
self.assertSoupEquals(
|
||
|
|
'<a href="http://example.org?a=1&b=2;3">foo</a>',
|
||
|
|
'<a href="http://example.org?a=1&b=2;3">foo</a>')
|
||
|
|
|
||
|
|
def test_escaped_ampersand_in_attribute_value_is_left_alone(self):
|
||
|
|
self.assertSoupEquals('<a href="http://example.org?a=1&b=2;3"></a>')
|
||
|
|
|
||
|
|
def test_entities_in_strings_converted_during_parsing(self):
|
||
|
|
# Both XML and HTML entities are converted to Unicode characters
|
||
|
|
# during parsing.
|
||
|
|
text = "<p><<sacré bleu!>></p>"
|
||
|
|
expected = u"<p><<sacr\N{LATIN SMALL LETTER E WITH ACUTE} bleu!>></p>"
|
||
|
|
self.assertSoupEquals(text, expected)
|
||
|
|
|
||
|
|
def test_smart_quotes_converted_on_the_way_in(self):
|
||
|
|
# Microsoft smart quotes are converted to Unicode characters during
|
||
|
|
# parsing.
|
||
|
|
quote = b"<p>\x91Foo\x92</p>"
|
||
|
|
soup = self.soup(quote)
|
||
|
|
self.assertEqual(
|
||
|
|
soup.p.string,
|
||
|
|
u"\N{LEFT SINGLE QUOTATION MARK}Foo\N{RIGHT SINGLE QUOTATION MARK}")
|
||
|
|
|
||
|
|
def test_non_breaking_spaces_converted_on_the_way_in(self):
|
||
|
|
soup = self.soup("<a> </a>")
|
||
|
|
self.assertEqual(soup.a.string, u"\N{NO-BREAK SPACE}" * 2)
|
||
|
|
|
||
|
|
def test_entities_converted_on_the_way_out(self):
|
||
|
|
text = "<p><<sacré bleu!>></p>"
|
||
|
|
expected = u"<p><<sacr\N{LATIN SMALL LETTER E WITH ACUTE} bleu!>></p>".encode("utf-8")
|
||
|
|
soup = self.soup(text)
|
||
|
|
self.assertEqual(soup.p.encode("utf-8"), expected)
|
||
|
|
|
||
|
|
def test_real_iso_latin_document(self):
|
||
|
|
# Smoke test of interrelated functionality, using an
|
||
|
|
# easy-to-understand document.
|
||
|
|
|
||
|
|
# Here it is in Unicode. Note that it claims to be in ISO-Latin-1.
|
||
|
|
unicode_html = u'<html><head><meta content="text/html; charset=ISO-Latin-1" http-equiv="Content-type"/></head><body><p>Sacr\N{LATIN SMALL LETTER E WITH ACUTE} bleu!</p></body></html>'
|
||
|
|
|
||
|
|
# That's because we're going to encode it into ISO-Latin-1, and use
|
||
|
|
# that to test.
|
||
|
|
iso_latin_html = unicode_html.encode("iso-8859-1")
|
||
|
|
|
||
|
|
# Parse the ISO-Latin-1 HTML.
|
||
|
|
soup = self.soup(iso_latin_html)
|
||
|
|
# Encode it to UTF-8.
|
||
|
|
result = soup.encode("utf-8")
|
||
|
|
|
||
|
|
# What do we expect the result to look like? Well, it would
|
||
|
|
# look like unicode_html, except that the META tag would say
|
||
|
|
# UTF-8 instead of ISO-Latin-1.
|
||
|
|
expected = unicode_html.replace("ISO-Latin-1", "utf-8")
|
||
|
|
|
||
|
|
# And, of course, it would be in UTF-8, not Unicode.
|
||
|
|
expected = expected.encode("utf-8")
|
||
|
|
|
||
|
|
# Ta-da!
|
||
|
|
self.assertEqual(result, expected)
|
||
|
|
|
||
|
|
def test_real_shift_jis_document(self):
|
||
|
|
# Smoke test to make sure the parser can handle a document in
|
||
|
|
# Shift-JIS encoding, without choking.
|
||
|
|
shift_jis_html = (
|
||
|
|
b'<html><head></head><body><pre>'
|
||
|
|
b'\x82\xb1\x82\xea\x82\xcdShift-JIS\x82\xc5\x83R\x81[\x83f'
|
||
|
|
b'\x83B\x83\x93\x83O\x82\xb3\x82\xea\x82\xbd\x93\xfa\x96{\x8c'
|
||
|
|
b'\xea\x82\xcc\x83t\x83@\x83C\x83\x8b\x82\xc5\x82\xb7\x81B'
|
||
|
|
b'</pre></body></html>')
|
||
|
|
unicode_html = shift_jis_html.decode("shift-jis")
|
||
|
|
soup = self.soup(unicode_html)
|
||
|
|
|
||
|
|
# Make sure the parse tree is correctly encoded to various
|
||
|
|
# encodings.
|
||
|
|
self.assertEqual(soup.encode("utf-8"), unicode_html.encode("utf-8"))
|
||
|
|
self.assertEqual(soup.encode("euc_jp"), unicode_html.encode("euc_jp"))
|
||
|
|
|
||
|
|
def test_real_hebrew_document(self):
|
||
|
|
# A real-world test to make sure we can convert ISO-8859-9 (a
|
||
|
|
# Hebrew encoding) to UTF-8.
|
||
|
|
hebrew_document = b'<html><head><title>Hebrew (ISO 8859-8) in Visual Directionality</title></head><body><h1>Hebrew (ISO 8859-8) in Visual Directionality</h1>\xed\xe5\xec\xf9</body></html>'
|
||
|
|
soup = self.soup(
|
||
|
|
hebrew_document, from_encoding="iso8859-8")
|
||
|
|
self.assertEqual(soup.original_encoding, 'iso8859-8')
|
||
|
|
self.assertEqual(
|
||
|
|
soup.encode('utf-8'),
|
||
|
|
hebrew_document.decode("iso8859-8").encode("utf-8"))
|
||
|
|
|
||
|
|
def test_meta_tag_reflects_current_encoding(self):
|
||
|
|
# Here's the <meta> tag saying that a document is
|
||
|
|
# encoded in Shift-JIS.
|
||
|
|
meta_tag = ('<meta content="text/html; charset=x-sjis" '
|
||
|
|
'http-equiv="Content-type"/>')
|
||
|
|
|
||
|
|
# Here's a document incorporating that meta tag.
|
||
|
|
shift_jis_html = (
|
||
|
|
'<html><head>\n%s\n'
|
||
|
|
'<meta http-equiv="Content-language" content="ja"/>'
|
||
|
|
'</head><body>Shift-JIS markup goes here.') % meta_tag
|
||
|
|
soup = self.soup(shift_jis_html)
|
||
|
|
|
||
|
|
# Parse the document, and the charset is seemingly unaffected.
|
||
|
|
parsed_meta = soup.find('meta', {'http-equiv': 'Content-type'})
|
||
|
|
content = parsed_meta['content']
|
||
|
|
self.assertEqual('text/html; charset=x-sjis', content)
|
||
|
|
|
||
|
|
# But that value is actually a ContentMetaAttributeValue object.
|
||
|
|
self.assertTrue(isinstance(content, ContentMetaAttributeValue))
|
||
|
|
|
||
|
|
# And it will take on a value that reflects its current
|
||
|
|
# encoding.
|
||
|
|
self.assertEqual('text/html; charset=utf8', content.encode("utf8"))
|
||
|
|
|
||
|
|
# For the rest of the story, see TestSubstitutions in
|
||
|
|
# test_tree.py.
|
||
|
|
|
||
|
|
def test_html5_style_meta_tag_reflects_current_encoding(self):
|
||
|
|
# Here's the <meta> tag saying that a document is
|
||
|
|
# encoded in Shift-JIS.
|
||
|
|
meta_tag = ('<meta id="encoding" charset="x-sjis" />')
|
||
|
|
|
||
|
|
# Here's a document incorporating that meta tag.
|
||
|
|
shift_jis_html = (
|
||
|
|
'<html><head>\n%s\n'
|
||
|
|
'<meta http-equiv="Content-language" content="ja"/>'
|
||
|
|
'</head><body>Shift-JIS markup goes here.') % meta_tag
|
||
|
|
soup = self.soup(shift_jis_html)
|
||
|
|
|
||
|
|
# Parse the document, and the charset is seemingly unaffected.
|
||
|
|
parsed_meta = soup.find('meta', id="encoding")
|
||
|
|
charset = parsed_meta['charset']
|
||
|
|
self.assertEqual('x-sjis', charset)
|
||
|
|
|
||
|
|
# But that value is actually a CharsetMetaAttributeValue object.
|
||
|
|
self.assertTrue(isinstance(charset, CharsetMetaAttributeValue))
|
||
|
|
|
||
|
|
# And it will take on a value that reflects its current
|
||
|
|
# encoding.
|
||
|
|
self.assertEqual('utf8', charset.encode("utf8"))
|
||
|
|
|
||
|
|
def test_tag_with_no_attributes_can_have_attributes_added(self):
|
||
|
|
data = self.soup("<a>text</a>")
|
||
|
|
data.a['foo'] = 'bar'
|
||
|
|
self.assertEqual('<a foo="bar">text</a>', data.a.decode())
|
||
|
|
|
||
|
|
class XMLTreeBuilderSmokeTest(object):
|
||
|
|
|
||
|
|
def test_docstring_generated(self):
|
||
|
|
soup = self.soup("<root/>")
|
||
|
|
self.assertEqual(
|
||
|
|
soup.encode(), b'<?xml version="1.0" encoding="utf-8"?>\n<root/>')
|
||
|
|
|
||
|
|
def test_real_xhtml_document(self):
|
||
|
|
"""A real XHTML document should come out *exactly* the same as it went in."""
|
||
|
|
markup = b"""<?xml version="1.0" encoding="utf-8"?>
|
||
|
|
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN">
|
||
|
|
<html xmlns="http://www.w3.org/1999/xhtml">
|
||
|
|
<head><title>Hello.</title></head>
|
||
|
|
<body>Goodbye.</body>
|
||
|
|
</html>"""
|
||
|
|
soup = self.soup(markup)
|
||
|
|
self.assertEqual(
|
||
|
|
soup.encode("utf-8"), markup)
|
||
|
|
|
||
|
|
def test_formatter_processes_script_tag_for_xml_documents(self):
|
||
|
|
doc = """
|
||
|
|
<script type="text/javascript">
|
||
|
|
</script>
|
||
|
|
"""
|
||
|
|
soup = BeautifulSoup(doc, "xml")
|
||
|
|
# lxml would have stripped this while parsing, but we can add
|
||
|
|
# it later.
|
||
|
|
soup.script.string = 'console.log("< < hey > > ");'
|
||
|
|
encoded = soup.encode()
|
||
|
|
self.assertTrue(b"< < hey > >" in encoded)
|
||
|
|
|
||
|
|
def test_can_parse_unicode_document(self):
|
||
|
|
markup = u'<?xml version="1.0" encoding="euc-jp"><root>Sacr\N{LATIN SMALL LETTER E WITH ACUTE} bleu!</root>'
|
||
|
|
soup = self.soup(markup)
|
||
|
|
self.assertEqual(u'Sacr\xe9 bleu!', soup.root.string)
|
||
|
|
|
||
|
|
def test_popping_namespaced_tag(self):
|
||
|
|
markup = '<rss xmlns:dc="foo"><dc:creator>b</dc:creator><dc:date>2012-07-02T20:33:42Z</dc:date><dc:rights>c</dc:rights><image>d</image></rss>'
|
||
|
|
soup = self.soup(markup)
|
||
|
|
self.assertEqual(
|
||
|
|
unicode(soup.rss), markup)
|
||
|
|
|
||
|
|
def test_docstring_includes_correct_encoding(self):
|
||
|
|
soup = self.soup("<root/>")
|
||
|
|
self.assertEqual(
|
||
|
|
soup.encode("latin1"),
|
||
|
|
b'<?xml version="1.0" encoding="latin1"?>\n<root/>')
|
||
|
|
|
||
|
|
def test_large_xml_document(self):
|
||
|
|
"""A large XML document should come out the same as it went in."""
|
||
|
|
markup = (b'<?xml version="1.0" encoding="utf-8"?>\n<root>'
|
||
|
|
+ b'0' * (2**12)
|
||
|
|
+ b'</root>')
|
||
|
|
soup = self.soup(markup)
|
||
|
|
self.assertEqual(soup.encode("utf-8"), markup)
|
||
|
|
|
||
|
|
|
||
|
|
def test_tags_are_empty_element_if_and_only_if_they_are_empty(self):
|
||
|
|
self.assertSoupEquals("<p>", "<p/>")
|
||
|
|
self.assertSoupEquals("<p>foo</p>")
|
||
|
|
|
||
|
|
def test_namespaces_are_preserved(self):
|
||
|
|
markup = '<root xmlns:a="http://example.com/" xmlns:b="http://example.net/"><a:foo>This tag is in the a namespace</a:foo><b:foo>This tag is in the b namespace</b:foo></root>'
|
||
|
|
soup = self.soup(markup)
|
||
|
|
root = soup.root
|
||
|
|
self.assertEqual("http://example.com/", root['xmlns:a'])
|
||
|
|
self.assertEqual("http://example.net/", root['xmlns:b'])
|
||
|
|
|
||
|
|
def test_closing_namespaced_tag(self):
|
||
|
|
markup = '<p xmlns:dc="http://purl.org/dc/elements/1.1/"><dc:date>20010504</dc:date></p>'
|
||
|
|
soup = self.soup(markup)
|
||
|
|
self.assertEqual(unicode(soup.p), markup)
|
||
|
|
|
||
|
|
def test_namespaced_attributes(self):
|
||
|
|
markup = '<foo xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"><bar xsi:schemaLocation="http://www.example.com"/></foo>'
|
||
|
|
soup = self.soup(markup)
|
||
|
|
self.assertEqual(unicode(soup.foo), markup)
|
||
|
|
|
||
|
|
def test_namespaced_attributes_xml_namespace(self):
|
||
|
|
markup = '<foo xml:lang="fr">bar</foo>'
|
||
|
|
soup = self.soup(markup)
|
||
|
|
self.assertEqual(unicode(soup.foo), markup)
|
||
|
|
|
||
|
|
class HTML5TreeBuilderSmokeTest(HTMLTreeBuilderSmokeTest):
|
||
|
|
"""Smoke test for a tree builder that supports HTML5."""
|
||
|
|
|
||
|
|
def test_real_xhtml_document(self):
|
||
|
|
# Since XHTML is not HTML5, HTML5 parsers are not tested to handle
|
||
|
|
# XHTML documents in any particular way.
|
||
|
|
pass
|
||
|
|
|
||
|
|
def test_html_tags_have_namespace(self):
|
||
|
|
markup = "<a>"
|
||
|
|
soup = self.soup(markup)
|
||
|
|
self.assertEqual("http://www.w3.org/1999/xhtml", soup.a.namespace)
|
||
|
|
|
||
|
|
def test_svg_tags_have_namespace(self):
|
||
|
|
markup = '<svg><circle/></svg>'
|
||
|
|
soup = self.soup(markup)
|
||
|
|
namespace = "http://www.w3.org/2000/svg"
|
||
|
|
self.assertEqual(namespace, soup.svg.namespace)
|
||
|
|
self.assertEqual(namespace, soup.circle.namespace)
|
||
|
|
|
||
|
|
|
||
|
|
def test_mathml_tags_have_namespace(self):
|
||
|
|
markup = '<math><msqrt>5</msqrt></math>'
|
||
|
|
soup = self.soup(markup)
|
||
|
|
namespace = 'http://www.w3.org/1998/Math/MathML'
|
||
|
|
self.assertEqual(namespace, soup.math.namespace)
|
||
|
|
self.assertEqual(namespace, soup.msqrt.namespace)
|
||
|
|
|
||
|
|
def test_xml_declaration_becomes_comment(self):
|
||
|
|
markup = '<?xml version="1.0" encoding="utf-8"?><html></html>'
|
||
|
|
soup = self.soup(markup)
|
||
|
|
self.assertTrue(isinstance(soup.contents[0], Comment))
|
||
|
|
self.assertEqual(soup.contents[0], '?xml version="1.0" encoding="utf-8"?')
|
||
|
|
self.assertEqual("html", soup.contents[0].next_element.name)
|
||
|
|
|
||
|
|
def skipIf(condition, reason):
|
||
|
|
def nothing(test, *args, **kwargs):
|
||
|
|
return None
|
||
|
|
|
||
|
|
def decorator(test_item):
|
||
|
|
if condition:
|
||
|
|
return nothing
|
||
|
|
else:
|
||
|
|
return test_item
|
||
|
|
|
||
|
|
return decorator
|