from __future__ import annotations
import pickle
import re
import typing
import warnings
import weakref
from typing import TYPE_CHECKING, Any, cast
import pytest
from lxml import etree
from packaging.version import Version
from parsel import Selector, SelectorList
from parsel.selector import (
_NOT_SET,
LXML_SUPPORTS_HUGE_TREE,
CannotRemoveElementWithoutParent,
CannotRemoveElementWithoutRoot,
)
if TYPE_CHECKING:
from collections.abc import Mapping
from lxml.html import HtmlElement
class TestSelector:
sscls = Selector
def assertIsSelector(self, value: Any) -> None:
assert type(value) is type(self.sscls(text=""))
def assertIsSelectorList(self, value: Any) -> None:
assert type(value) is type(self.sscls.selectorlist_cls())
def test_pickle_selector(self) -> None:
sel = self.sscls(text="some text
")
with pytest.raises(TypeError):
pickle.dumps(sel, protocol=2)
def test_pickle_selector_list(self) -> None:
sel = self.sscls(
text=""
)
sel_list = sel.css("li")
empty_sel_list = sel.css("p")
self.assertIsSelectorList(sel_list)
self.assertIsSelectorList(empty_sel_list)
with pytest.raises(TypeError):
pickle.dumps(sel_list, protocol=2)
with pytest.raises(TypeError):
pickle.dumps(empty_sel_list, protocol=2)
def test_simple_selection(self) -> None:
"""Simple selector tests"""
body = "
"
sel = self.sscls(text=body)
xl = sel.xpath("//input")
assert len(xl) == 2
for x in xl:
self.assertIsSelector(x)
assert sel.xpath("//input").extract() == [
x.extract() for x in sel.xpath("//input")
]
assert [x.extract() for x in sel.xpath("//input[@name='a']/@name")] == ["a"]
assert [
x.extract()
for x in sel.xpath(
"number(concat(//input[@name='a']/@value, //input[@name='b']/@value))"
)
] == ["12.0"]
assert sel.xpath("concat('xpath', 'rules')").extract() == ["xpathrules"]
assert [
x.extract()
for x in sel.xpath(
"concat(//input[@name='a']/@value, //input[@name='b']/@value)"
)
] == ["12"]
def test_simple_selection_with_variables(self) -> None:
"""Using XPath variables"""
body = "
"
sel = self.sscls(text=body)
assert [
x.extract() for x in sel.xpath("//input[@value=$number]/@name", number=1)
] == ["a"]
assert [
x.extract() for x in sel.xpath("//input[@name=$letter]/@value", letter="b")
] == ["2"]
assert sel.xpath(
"count(//input[@value=$number or @name=$letter])", number=2, letter="a"
).extract() == ["2.0"]
# you can also pass booleans
assert sel.xpath(
"boolean(count(//input)=$cnt)=$test", cnt=2, test=True
).extract() == ["1"]
assert sel.xpath(
"boolean(count(//input)=$cnt)=$test", cnt=4, test=True
).extract() == ["0"]
assert sel.xpath(
"boolean(count(//input)=$cnt)=$test", cnt=4, test=False
).extract() == ["1"]
# for named nodes, you need to use "name()=node_name"
assert sel.xpath(
"boolean(count(//*[name()=$tag])=$cnt)=$test", tag="input", cnt=2, test=True
).extract() == ["1"]
def test_simple_selection_with_variables_escape_friendly(self) -> None:
"""Using XPath variables with quotes that would need escaping with string formatting"""
body = """I'm mixing single and
"""
sel = self.sscls(text=body)
t = 'I say "Yeah!"'
# naive string formatting with give something like:
# ValueError: XPath error: Invalid predicate in //input[@value="I say "Yeah!""]/@name
with pytest.raises(ValueError, match="Invalid predicate in"):
sel.xpath(f'//input[@value="{t}"]/@name')
# with XPath variables, escaping is done for you
assert [
x.extract() for x in sel.xpath("//input[@value=$text]/@name", text=t)
] == ["a"]
lt = """I'm mixing single and "double quotes" and I don't care :)"""
# the following gives you something like
# ValueError: XPath error: Invalid predicate in //p[normalize-space()='I'm mixing single and "double quotes" and I don't care :)']//@name
with pytest.raises(ValueError, match="Invalid predicate in"):
sel.xpath(f"//p[normalize-space()='{lt}']//@name")
assert [
x.extract() for x in sel.xpath("//p[normalize-space()=$lng]//@name", lng=lt)
] == ["a"]
def test_accessing_attributes(self) -> None:
body = """
"""
sel = self.sscls(text=body)
assert sel.attrib == {"lang": "en", "version": "1.0"}
assert sel.css("ul")[0].attrib == {"id": "some-list", "class": "list-cls"}
# for a SelectorList, bring the attributes of first-element only
assert sel.css("ul").attrib == {"id": "some-list", "class": "list-cls"}
assert sel.css("li").attrib == {"class": "item-cls", "id": "list-item-1"}
assert sel.css("body").attrib == {}
assert sel.css("non-existing-element").attrib == {}
assert [e.attrib for e in sel.css("li")] == [
{"class": "item-cls", "id": "list-item-1"},
{"class": "item-cls active", "id": "list-item-2"},
{"class": "item-cls", "id": "list-item-3"},
]
def test_representation_slice(self) -> None:
body = f"
"
sel = self.sscls(text=body)
representation = f""
assert [repr(it) for it in sel.xpath("//input/@name")] == [representation]
def test_representation_unicode_query(self) -> None:
body = f"
"
representation = ""
sel = self.sscls(text=body)
assert [repr(it) for it in sel.xpath('//input[@value="©"]/@value')] == [
representation
]
def test_check_text_argument_type(self) -> None:
with pytest.raises(TypeError, match="text argument should be of type"):
self.sscls(b" ") # type: ignore[arg-type]
def test_extract_first(self) -> None:
"""Test if extract_first() returns first element"""
body = ''
sel = self.sscls(text=body)
assert (
sel.xpath("//ul/li/text()").extract_first()
== sel.xpath("//ul/li/text()").extract()[0]
)
assert (
sel.xpath('//ul/li[@id="1"]/text()').extract_first()
== sel.xpath('//ul/li[@id="1"]/text()').extract()[0]
)
assert (
sel.xpath("//ul/li[2]/text()").extract_first()
== sel.xpath("//ul/li/text()").extract()[1]
)
assert sel.xpath('/ul/li[@id="doesnt-exist"]/text()').extract_first() is None
def test_extract_first_default(self) -> None:
"""Test if extract_first() returns default value when no results found"""
body = ''
sel = self.sscls(text=body)
assert sel.xpath("//div/text()").extract_first(default="missing") == "missing"
def test_selector_get_alias(self) -> None:
"""Test if get() returns extracted value on a Selector"""
body = ''
sel = self.sscls(text=body)
assert sel.xpath("//ul/li[position()>1]")[0].get() == '2 '
assert sel.xpath("//ul/li[position()>1]/text()")[0].get() == "2"
def test_selector_getall_alias(self) -> None:
"""Test if get() returns extracted value on a Selector"""
body = ''
sel = self.sscls(text=body)
assert sel.xpath("//ul/li[position()>1]")[0].getall() == ['2 ']
assert sel.xpath("//ul/li[position()>1]/text()")[0].getall() == ["2"]
def test_selectorlist_get_alias(self) -> None:
"""Test if get() returns first element for a selection call"""
body = ''
sel = self.sscls(text=body)
assert sel.xpath("//ul/li").get() == '1 '
assert sel.xpath("//ul/li/text()").get() == "1"
def test_re_first(self) -> None:
"""Test if re_first() returns first matched element"""
body = ''
sel = self.sscls(text=body)
assert (
sel.xpath("//ul/li/text()").re_first(r"\d")
== sel.xpath("//ul/li/text()").re(r"\d")[0]
)
assert (
sel.xpath('//ul/li[@id="1"]/text()').re_first(r"\d")
== sel.xpath('//ul/li[@id="1"]/text()').re(r"\d")[0]
)
assert (
sel.xpath("//ul/li[2]/text()").re_first(r"\d")
== sel.xpath("//ul/li/text()").re(r"\d")[1]
)
assert sel.xpath("/ul/li/text()").re_first(r"\w+") is None
assert sel.xpath('/ul/li[@id="doesnt-exist"]/text()').re_first(r"\d") is None
assert sel.re_first(r'id="(\d+)') == "1"
assert sel.re_first(r"foo") is None
assert sel.re_first(r"foo", default="bar") == "bar"
def test_extract_first_re_default(self) -> None:
"""Test if re_first() returns default value when no results found"""
body = ''
sel = self.sscls(text=body)
assert (
sel.xpath("//div/text()").re_first(r"\w+", default="missing") == "missing"
)
assert (
sel.xpath("/ul/li/text()").re_first(r"\w+", default="missing") == "missing"
)
def test_select_unicode_query(self) -> None:
body = "
"
sel = self.sscls(text=body)
assert sel.xpath('//input[@name="©"]/@value').extract() == ["1"]
def test_list_elements_type(self) -> None:
"""Test Selector returning the same type in selection methods"""
text = "test
"
assert type(self.sscls(text=text).xpath("//p")[0]) is type(
self.sscls(text=text)
)
assert type(self.sscls(text=text).css("p")[0]) is type(self.sscls(text=text))
def test_boolean_result(self) -> None:
body = "
"
xs = self.sscls(text=body)
assert xs.xpath("//input[@name='a']/@name='a'").extract() == ["1"]
assert xs.xpath("//input[@name='a']/@name='n'").extract() == ["0"]
def test_differences_parsing_xml_vs_html(self) -> None:
"""Test that XML and HTML Selector's behave differently"""
# some text which is parsed differently by XML and HTML flavors
text = 'Hello
Hello
Hello
false true '
hs = self.sscls(text=text, type="html")
falsish = hs.xpath("//a/@href")[0]
assert falsish.extract() == ""
assert not falsish
trueish = hs.xpath("//a/@href")[1]
assert trueish.extract() == "nonempty"
assert trueish
def test_slicing(self) -> None:
text = ""
hs = self.sscls(text=text, type="html")
self.assertIsSelector(hs.css("p")[2])
self.assertIsSelectorList(hs.css("p")[2:3])
self.assertIsSelectorList(hs.css("p")[:2])
assert hs.css("p")[2:3].extract() == ["3
"]
assert hs.css("p")[1:3].extract() == ["2
", "3
"]
def test_nested_selectors(self) -> None:
"""Nested selector tests"""
body = """
"""
x = self.sscls(text=body)
divtwo = x.xpath('//div[@class="two"]')
assert divtwo.xpath("//li").extract() == [
"one ",
"two ",
"four ",
"five ",
"six ",
]
assert divtwo.xpath("./ul/li").extract() == [
"four ",
"five ",
"six ",
]
assert divtwo.xpath(".//li").extract() == [
"four ",
"five ",
"six ",
]
assert divtwo.xpath("./li").extract() == []
def test_selectorlist_getall_alias(self) -> None:
"""Nested selector tests using getall()"""
body = """
"""
x = self.sscls(text=body)
divtwo = x.xpath('//div[@class="two"]')
assert divtwo.xpath("//li").getall() == [
"one ",
"two ",
"four ",
"five ",
"six ",
]
assert divtwo.xpath("./ul/li").getall() == [
"four ",
"five ",
"six ",
]
assert divtwo.xpath(".//li").getall() == [
"four ",
"five ",
"six ",
]
assert divtwo.xpath("./li").getall() == []
def test_mixed_nested_selectors(self) -> None:
body = """
notme
"""
sel = self.sscls(text=body)
assert sel.xpath('//div[@id="1"]').css("span::text").extract() == ["me"]
assert sel.css("#1").xpath("./span/text()").extract() == ["me"]
def test_dont_strip(self) -> None:
sel = self.sscls(text='')
assert sel.xpath("//text()").extract() == ["fff: ", "zzz"]
def test_namespaces_simple(self) -> None:
body = """
take this
found
"""
x = self.sscls(text=body, type="xml")
x.register_namespace("somens", "http://scrapy.org")
assert x.xpath("//somens:a/text()").extract() == ["take this"]
def test_namespaces_adhoc(self) -> None:
body = """
take this
found
"""
x = self.sscls(text=body, type="xml")
assert x.xpath(
"//somens:a/text()", namespaces={"somens": "http://scrapy.org"}
).extract() == ["take this"]
def test_namespaces_adhoc_variables(self) -> None:
body = """
take this
found
"""
x = self.sscls(text=body, type="xml")
assert x.xpath(
"//somens:a/following-sibling::a[@id=$identifier]/text()",
namespaces={"somens": "http://scrapy.org"},
identifier="bar",
).extract() == ["found"]
def test_namespaces_multiple(self) -> None:
body = """
hello
value iron 90 Dried Rose
"""
x = self.sscls(text=body, type="xml")
x.register_namespace(
"xmlns",
"http://webservices.amazon.com/AWSECommerceService/2005-10-05",
)
x.register_namespace("p", "http://www.scrapy.org/product")
x.register_namespace("b", "http://somens.com")
assert len(x.xpath("//xmlns:TestTag")) == 1
assert x.xpath("//b:Operation/text()").extract()[0] == "hello"
assert x.xpath("//xmlns:TestTag/@b:att").extract()[0] == "value"
assert x.xpath("//p:SecondTestTag/xmlns:price/text()").extract()[0] == "90"
assert (
x.xpath("//p:SecondTestTag").xpath("./xmlns:price/text()")[0].extract()
== "90"
)
assert x.xpath("//p:SecondTestTag/xmlns:material/text()").extract()[0] == "iron"
def test_namespaces_multiple_adhoc(self) -> None:
body = """
hello
value iron 90 Dried Rose
"""
x = self.sscls(text=body, type="xml")
x.register_namespace(
"xmlns",
"http://webservices.amazon.com/AWSECommerceService/2005-10-05",
)
assert len(x.xpath("//xmlns:TestTag")) == 1
# "b" namespace is not declared yet
with pytest.raises(ValueError, match="Undefined namespace prefix"):
x.xpath("//xmlns:TestTag/@b:att")
# "b" namespace being passed ad-hoc
assert (
x.xpath(
"//b:Operation/text()", namespaces={"b": "http://somens.com"}
).extract()[0]
== "hello"
)
# "b" namespace declaration is not cached
with pytest.raises(ValueError, match="Undefined namespace prefix"):
x.xpath("//xmlns:TestTag/@b:att")
# "xmlns" is still defined
assert (
x.xpath(
"//xmlns:TestTag/@b:att", namespaces={"b": "http://somens.com"}
).extract()[0]
== "value"
)
# chained selectors still have knowledge of register_namespace() operations
assert (
x.xpath(
"//p:SecondTestTag", namespaces={"p": "http://www.scrapy.org/product"}
)
.xpath("./xmlns:price/text()")[0]
.extract()
== "90"
)
# but chained selector don't know about parent ad-hoc declarations
with pytest.raises(ValueError, match="Undefined namespace prefix"):
x.xpath(
"//p:SecondTestTag",
namespaces={"p": "http://www.scrapy.org/product"},
).xpath("p:name/text()")
# ad-hoc declarations need repeats when chaining
assert (
x.xpath(
"//p:SecondTestTag", namespaces={"p": "http://www.scrapy.org/product"}
)
.xpath("p:name/text()", namespaces={"p": "http://www.scrapy.org/product"})
.extract_first()
== "Dried Rose"
)
# declaring several ad-hoc namespaces
assert (
x.xpath(
"string(//b:Operation/following-sibling::xmlns:TestTag/following-sibling::*//p:name)",
namespaces={
"b": "http://somens.com",
"p": "http://www.scrapy.org/product",
},
).extract_first()
== "Dried Rose"
)
# "p" prefix is not cached from previous calls
with pytest.raises(ValueError, match="Undefined namespace prefix"):
x.xpath("//p:SecondTestTag/xmlns:price/text()")
x.register_namespace("p", "http://www.scrapy.org/product")
assert x.xpath("//p:SecondTestTag/xmlns:material/text()").extract()[0] == "iron"
def test_make_links_absolute(self) -> None:
text = 'link to file '
sel = Selector(text=text, base_url="http://example.com")
typing.cast("HtmlElement", sel.root).make_links_absolute()
assert sel.xpath("//a/@href").extract_first() == "http://example.com/file.html"
def test_re(self) -> None:
body = """Name: Mary
Name: John
Age: 10
Name: Paul
Age: 20
Age: 20
foo)") == ["foo"]
assert x.re("(?Pbaz)") == []
# A purposely constructed test for an edge case
x = self.sscls(text="baz")
assert x.re("(?Pfoo)|(?Pbaz)") == []
def test_re_replace_entities(self) -> None:
body = """"""
x = self.sscls(text=body)
name_re = re.compile('{"foo":(.*)}')
# by default, only & and < are preserved ;
# other entities are converted
expected = '"bar & "baz""'
assert x.xpath("//script/text()").re(name_re) == [expected]
assert x.xpath("//script").re(name_re) == [expected]
assert x.xpath("//script/text()")[0].re(name_re) == [expected]
assert x.xpath("//script")[0].re(name_re) == [expected]
# check that re_first() works the same way for single value output
assert x.xpath("//script").re_first(name_re) == expected
assert x.xpath("//script")[0].re_first(name_re) == expected
# switching off replace_entities will preserve " also
expected = '"bar & "baz""'
assert x.xpath("//script/text()").re(name_re, replace_entities=False) == [
expected
]
assert x.xpath("//script")[0].re(name_re, replace_entities=False) == [expected]
assert (
x.xpath("//script/text()").re_first(name_re, replace_entities=False)
== expected
)
assert (
x.xpath("//script")[0].re_first(name_re, replace_entities=False) == expected
)
def test_re_intl(self) -> None:
body = "Evento: cumplea\xf1os
"
x = self.sscls(text=body)
assert x.xpath("//div").re(r"Evento: (\w+)") == ["cumpleaños"]
def test_selector_over_text(self) -> None:
hs = self.sscls(text="lala ")
assert hs.extract() == "lala "
xs = self.sscls(text="lala ", type="xml")
assert xs.extract() == "lala "
assert xs.xpath(".").extract() == ["lala "]
def test_invalid_xpath(self) -> None:
"""Test invalid xpath raises ValueError with the invalid xpath"""
x = self.sscls(text="")
xpath = "//test[@foo='bar]"
with pytest.raises(ValueError, match=re.escape(xpath)):
x.xpath(xpath)
def test_invalid_xpath_unicode(self) -> None:
"""Test *Unicode* invalid xpath raises ValueError with the invalid xpath"""
x = self.sscls(text="")
xpath = "//test[@foo='\\u0431ar]"
with pytest.raises(ValueError, match=re.escape(xpath)):
x.xpath(xpath)
def test_http_header_encoding_precedence(self) -> None:
# '\xa3' = pound symbol in unicode
# '\xc2\xa3' = pound symbol in utf-8
# '\xa3' = pound symbol in latin-1 (iso-8859-1)
text = """
\xa3 """
x = self.sscls(text=text)
assert x.xpath("//span[@id='blank']/text()").extract() == ["£"]
def test_empty_bodies_shouldnt_raise_errors(self) -> None:
self.sscls(text="").xpath("//text()").extract()
def test_bodies_with_comments_only(self) -> None:
sel = self.sscls(text="", base_url="http://example.com")
assert sel.root.base == "http://example.com"
def test_null_bytes_shouldnt_raise_errors(self) -> None:
text = "pre\x00post "
self.sscls(text).xpath("//text()").extract()
def test_replacement_char_from_badly_encoded_body(self) -> None:
# \xe9 alone isn't valid utf8 sequence
text = "an Jos\\ufffd de
"
assert self.sscls(text).xpath("//text()").extract() == ["an Jos\\ufffd de"]
def test_select_on_unevaluable_nodes(self) -> None:
r = self.sscls(text='some text ')
# Text node
x1 = r.xpath("//text()")
assert x1.extract() == ["some text"]
assert x1.xpath(".//b").extract() == []
# Tag attribute
x1 = r.xpath("//span/@class")
assert x1.extract() == ["big"]
assert x1.xpath(".//text()").extract() == []
def test_select_on_text_nodes(self) -> None:
r = self.sscls(text="Options: opt1
Other opt2
")
x1 = r.xpath(
"//div/descendant::text()[preceding-sibling::b[contains(text(), 'Options')]]"
)
assert x1.extract() == ["opt1"]
x1 = r.xpath(
"//div/descendant::text()/preceding-sibling::b[contains(text(), 'Options')]"
)
assert x1.extract() == ["Options: "]
@pytest.mark.skip("Text nodes lost parent node reference in lxml")
def test_nested_select_on_text_nodes(self) -> None:
# FIXME: does not work with lxml backend [upstream]
r = self.sscls(text="Options: opt1
Other opt2
")
x1 = r.xpath("//div/descendant::text()")
x2 = x1.xpath("./preceding-sibling::b[contains(text(), 'Options')]")
assert x2.extract() == ["Options: "]
def test_weakref_slots(self) -> None:
"""Check that classes are using slots and are weak-referenceable"""
x = self.sscls(text="")
weakref.ref(x)
assert not hasattr(x, "__dict__"), (
f"{x.__class__.__name__} does not use __slots__"
)
def test_remove_namespaces(self) -> None:
xml = """
"""
sel = self.sscls(text=xml, type="xml")
assert len(sel.xpath("//link")) == 0
assert len(sel.xpath("./namespace::*")) == 3
sel.remove_namespaces()
assert len(sel.xpath("//link")) == 3
assert len(sel.xpath("./namespace::*")) == 1
def test_remove_namespaces_embedded(self) -> None:
xml = """
"""
sel = self.sscls(text=xml, type="xml")
assert len(sel.xpath("//link")) == 0
assert len(sel.xpath("//stop")) == 0
assert len(sel.xpath("./namespace::*")) == 2
assert (
len(sel.xpath("//f:link", namespaces={"f": "http://www.w3.org/2005/Atom"}))
== 2
)
assert (
len(sel.xpath("//s:stop", namespaces={"s": "http://www.w3.org/2000/svg"}))
== 2
)
sel.remove_namespaces()
assert len(sel.xpath("//link")) == 2
assert len(sel.xpath("//stop")) == 2
assert len(sel.xpath("./namespace::*")) == 1
def test_remove_attributes_namespaces(self) -> None:
xml = """
"""
sel = self.sscls(text=xml, type="xml")
assert len(sel.xpath("//link/@type")) == 0
sel.remove_namespaces()
assert len(sel.xpath("//link/@type")) == 3
def test_smart_strings(self) -> None:
"""Lxml smart strings return values"""
class SmartStringsSelector(Selector):
_lxml_smart_strings = True
body = """
"""
# .getparent() is available for text nodes and attributes
# only when smart_strings are on
x = self.sscls(text=body)
li_text = x.xpath("//li/text()")
assert not any(hasattr(e.root, "getparent") for e in li_text)
div_class = x.xpath("//div/@class")
assert not any(hasattr(e.root, "getparent") for e in div_class)
smart_x = SmartStringsSelector(text=body)
smart_li_text = smart_x.xpath("//li/text()")
assert all(hasattr(e.root, "getparent") for e in smart_li_text)
smart_div_class = smart_x.xpath("//div/@class")
assert all(hasattr(e.root, "getparent") for e in smart_div_class)
def test_xml_entity_expansion(self) -> None:
malicious_xml = (
''
" ]>&xxe; '
)
sel = self.sscls(text=malicious_xml, type="xml")
assert sel.extract() == "&xxe; "
def test_configure_base_url(self) -> None:
sel = self.sscls(text="nothing", base_url="http://example.com")
assert sel.root.base == "http://example.com"
def test_extending_selector(self) -> None:
class MySelectorList(SelectorList["MySelector"]):
pass
class MySelector(Selector):
selectorlist_cls = MySelectorList # type: ignore[assignment]
def extra_method(self) -> str:
return "extra" + cast("str", self.get())
sel = MySelector(text="foo
")
assert isinstance(sel.xpath("//div"), MySelectorList)
assert isinstance(sel.xpath("//div")[0], MySelector)
assert isinstance(sel.css("div"), MySelectorList)
assert isinstance(sel.css("div")[0], MySelector)
content: str = sel.css("div")[0].extra_method()
assert content == "extrafoo
"
def test_replacement_null_char_from_body(self) -> None:
text = "\x00Grainy
"
assert self.sscls(text).extract() == "Grainy
"
def test_remove_selector_list(self) -> None:
sel = self.sscls(
text=""
)
sel_list = sel.css("li")
sel_list.drop()
self.assertIsSelectorList(sel.css("li"))
assert sel.css("li") == []
def test_remove_selector(self) -> None:
sel = self.sscls(
text=""
)
sel_list = sel.css("li")
sel_list[0].drop()
self.assertIsSelectorList(sel.css("li"))
assert sel.css("li::text").getall() == ["2", "3"]
def test_remove_pseudo_element_selector_list(self) -> None:
sel = self.sscls(
text=""
)
sel_list = sel.css("li::text")
assert sel_list.getall() == ["1", "2", "3"]
with pytest.raises(CannotRemoveElementWithoutRoot):
sel_list.drop()
self.assertIsSelectorList(sel.css("li"))
assert sel.css("li::text").getall() == ["1", "2", "3"]
def test_remove_pseudo_element_selector(self) -> None:
sel = self.sscls(
text=""
)
sel_list = sel.css("li::text")
assert sel_list.getall() == ["1", "2", "3"]
with pytest.raises(CannotRemoveElementWithoutRoot):
sel_list[0].drop()
self.assertIsSelectorList(sel.css("li"))
assert sel.css("li::text").getall() == ["1", "2", "3"]
def test_remove_root_element_selector(self) -> None:
sel = self.sscls(
text=""
)
sel_list = sel.css("li::text")
assert sel_list.getall() == ["1", "2", "3"]
with pytest.raises(CannotRemoveElementWithoutParent):
sel.drop()
with pytest.raises(CannotRemoveElementWithoutParent):
sel.css("html").drop()
self.assertIsSelectorList(sel.css("li"))
assert sel.css("li::text").getall() == ["1", "2", "3"]
sel.css("body").drop()
assert sel.get() == ""
def test_deep_nesting(self) -> None:
lxml_version = Version(etree.__version__)
lxml_huge_tree_version = Version("4.2")
content = """
