marcocosta10000
723ca1506b
Adds `_fetch_page_content()`, which downloads a URL with a browser-like User-Agent and uses BeautifulSoup with the lxml parser to strip scripts, navigation, and other non-content markup, returning up to 3000 characters of readable text. The response validator now also compares generated replies against this scraped text, flagging named entities and claims that do not appear in the retrieved page content. Dependencies: adds beautifulsoup4==4.12.3 and pins lxml==5.3.0 for parser compatibility.
145 lines
5.0 KiB
Python
145 lines
5.0 KiB
Python
import pytest
|
|
|
|
from bs4.element import (
|
|
CData,
|
|
Comment,
|
|
Declaration,
|
|
Doctype,
|
|
NavigableString,
|
|
RubyParenthesisString,
|
|
RubyTextString,
|
|
Script,
|
|
Stylesheet,
|
|
TemplateString,
|
|
)
|
|
|
|
from . import SoupTest
|
|
|
|
class TestNavigableString(SoupTest):
|
|
|
|
def test_text_acquisition_methods(self):
|
|
# These methods are intended for use against Tag, but they
|
|
# work on NavigableString as well,
|
|
|
|
s = NavigableString("fee ")
|
|
cdata = CData("fie ")
|
|
comment = Comment("foe ")
|
|
|
|
assert "fee " == s.get_text()
|
|
assert "fee" == s.get_text(strip=True)
|
|
assert ["fee "] == list(s.strings)
|
|
assert ["fee"] == list(s.stripped_strings)
|
|
assert ["fee "] == list(s._all_strings())
|
|
|
|
assert "fie " == cdata.get_text()
|
|
assert "fie" == cdata.get_text(strip=True)
|
|
assert ["fie "] == list(cdata.strings)
|
|
assert ["fie"] == list(cdata.stripped_strings)
|
|
assert ["fie "] == list(cdata._all_strings())
|
|
|
|
# Since a Comment isn't normally considered 'text',
|
|
# these methods generally do nothing.
|
|
assert "" == comment.get_text()
|
|
assert [] == list(comment.strings)
|
|
assert [] == list(comment.stripped_strings)
|
|
assert [] == list(comment._all_strings())
|
|
|
|
# Unless you specifically say that comments are okay.
|
|
assert "foe" == comment.get_text(strip=True, types=Comment)
|
|
assert "foe " == comment.get_text(types=(Comment, NavigableString))
|
|
|
|
def test_string_has_immutable_name_property(self):
|
|
# string.name is defined as None and can't be modified
|
|
string = self.soup("s").string
|
|
assert None == string.name
|
|
with pytest.raises(AttributeError):
|
|
string.name = 'foo'
|
|
|
|
class TestNavigableStringSubclasses(SoupTest):
|
|
|
|
def test_cdata(self):
|
|
# None of the current builders turn CDATA sections into CData
|
|
# objects, but you can create them manually.
|
|
soup = self.soup("")
|
|
cdata = CData("foo")
|
|
soup.insert(1, cdata)
|
|
assert str(soup) == "<![CDATA[foo]]>"
|
|
assert soup.find(string="foo") == "foo"
|
|
assert soup.contents[0] == "foo"
|
|
|
|
def test_cdata_is_never_formatted(self):
|
|
"""Text inside a CData object is passed into the formatter.
|
|
|
|
But the return value is ignored.
|
|
"""
|
|
|
|
self.count = 0
|
|
def increment(*args):
|
|
self.count += 1
|
|
return "BITTER FAILURE"
|
|
|
|
soup = self.soup("")
|
|
cdata = CData("<><><>")
|
|
soup.insert(1, cdata)
|
|
assert b"<![CDATA[<><><>]]>" == soup.encode(formatter=increment)
|
|
assert 1 == self.count
|
|
|
|
def test_doctype_ends_in_newline(self):
|
|
# Unlike other NavigableString subclasses, a DOCTYPE always ends
|
|
# in a newline.
|
|
doctype = Doctype("foo")
|
|
soup = self.soup("")
|
|
soup.insert(1, doctype)
|
|
assert soup.encode() == b"<!DOCTYPE foo>\n"
|
|
|
|
def test_declaration(self):
|
|
d = Declaration("foo")
|
|
assert "<?foo?>" == d.output_ready()
|
|
|
|
def test_default_string_containers(self):
|
|
# In some cases, we use different NavigableString subclasses for
|
|
# the same text in different tags.
|
|
soup = self.soup(
|
|
"<div>text</div><script>text</script><style>text</style>"
|
|
)
|
|
assert [NavigableString, Script, Stylesheet] == [
|
|
x.__class__ for x in soup.find_all(string=True)
|
|
]
|
|
|
|
# The TemplateString is a little unusual because it's generally found
|
|
# _inside_ children of a <template> element, not a direct child of the
|
|
# <template> element.
|
|
soup = self.soup(
|
|
"<template>Some text<p>In a tag</p></template>Some text outside"
|
|
)
|
|
assert all(
|
|
isinstance(x, TemplateString)
|
|
for x in soup.template._all_strings(types=None)
|
|
)
|
|
|
|
# Once the <template> tag closed, we went back to using
|
|
# NavigableString.
|
|
outside = soup.template.next_sibling
|
|
assert isinstance(outside, NavigableString)
|
|
assert not isinstance(outside, TemplateString)
|
|
|
|
# The TemplateString is also unusual because it can contain
|
|
# NavigableString subclasses of _other_ types, such as
|
|
# Comment.
|
|
markup = b"<template>Some text<p>In a tag</p><!--with a comment--></template>"
|
|
soup = self.soup(markup)
|
|
assert markup == soup.template.encode("utf8")
|
|
|
|
def test_ruby_strings(self):
|
|
markup = "<ruby>漢 <rp>(</rp><rt>kan</rt><rp>)</rp> 字 <rp>(</rp><rt>ji</rt><rp>)</rp></ruby>"
|
|
soup = self.soup(markup)
|
|
assert isinstance(soup.rp.string, RubyParenthesisString)
|
|
assert isinstance(soup.rt.string, RubyTextString)
|
|
|
|
# Just as a demo, here's what this means for get_text usage.
|
|
assert "漢字" == soup.get_text(strip=True)
|
|
assert "漢(kan)字(ji)" == soup.get_text(
|
|
strip=True,
|
|
types=(NavigableString, RubyTextString, RubyParenthesisString)
|
|
)
|