Bump beautifulsoup4 from 4.11.1 to 4.11.2 (#1987)

* Bump beautifulsoup4 from 4.11.1 to 4.11.2 Bumps [beautifulsoup4](https://www.crummy.com/software/BeautifulSoup/bs4/) from 4.11.1 to 4.11.2. --- updated-dependencies: - dependency-name: beautifulsoup4 dependency-type: direct:production update-type: version-update:semver-patch ... Signed-off-by: dependabot[bot] <support@github.com> * Update beautifulsoup4==4.11.2 --------- Signed-off-by: dependabot[bot] <support@github.com> Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com> Co-authored-by: JonnyWong16 <9099342+JonnyWong16@users.noreply.github.com> [skip ci]
2025-08-20 21:33:18 -07:00 · 2023-03-02 20:56:24 -08:00 · 2023-03-02 20:56:24 -08:00 · 8e42757b2d
commit 8e42757b2d
parent ded93ef2f5
23 changed files with 449 additions and 537 deletions
--- a/lib/bs4/tests/init.py
+++ b/lib/bs4/tests/init.py
@ -29,6 +29,29 @@ from bs4.builder import (
 )
 default_builder = HTMLParserTreeBuilder

+# Some tests depend on specific third-party libraries. We use
+# @pytest.mark.skipIf on the following conditionals to skip them
+# if the libraries are not installed.
+try:
+    from soupsieve import SelectorSyntaxError
+    SOUP_SIEVE_PRESENT = True
+except ImportError:
+    SOUP_SIEVE_PRESENT = False
+
+try:
+    import html5lib
+    HTML5LIB_PRESENT = True
+except ImportError:
+    HTML5LIB_PRESENT = False
+
+try:
+    import lxml.etree
+    LXML_PRESENT = True
+    LXML_VERSION = lxml.etree.LXML_VERSION
+except ImportError:
+    LXML_PRESENT = False
+    LXML_VERSION = (0,)
+
 BAD_DOCUMENT = """A bare string
 <!DOCTYPE xsl:stylesheet SYSTEM "htmlent.dtd">
 <!DOCTYPE xsl:stylesheet PUBLIC "htmlent.dtd">
@ -258,10 +281,10 @@ class TreeBuilderSmokeTest(object):

    @pytest.mark.parametrize(
        "multi_valued_attributes",
-        [None, dict(b=['class']), {'*': ['notclass']}]
+        [None, {}, dict(b=['class']), {'*': ['notclass']}]
    )
    def test_attribute_not_multi_valued(self, multi_valued_attributes):
-        markup = '<a class="a b c">'
+        markup = '<html xmlns="http://www.w3.org/1999/xhtml"><a class="a b c"></html>'
        soup = self.soup(markup, multi_valued_attributes=multi_valued_attributes)
        assert soup.a['class'] == 'a b c'

@ -820,26 +843,27 @@ Hello, world!
        soup = self.soup(text)
        assert soup.p.encode("utf-8") == expected

-    def test_real_iso_latin_document(self):
+    def test_real_iso_8859_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 = '<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>'
+        # Here it is in Unicode. Note that it claims to be in ISO-8859-1.
+        unicode_html = '<html><head><meta content="text/html; charset=ISO-8859-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.
+        # That's because we're going to encode it into ISO-8859-1,
+        # and use that to test.
        iso_latin_html = unicode_html.encode("iso-8859-1")

-        # Parse the ISO-Latin-1 HTML.
+        # Parse the ISO-8859-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")
+        # UTF-8 instead of ISO-8859-1.
+        expected = unicode_html.replace("ISO-8859-1", "utf-8")

        # And, of course, it would be in UTF-8, not Unicode.
        expected = expected.encode("utf-8")
@ -1177,15 +1201,3 @@ class HTML5TreeBuilderSmokeTest(HTMLTreeBuilderSmokeTest):
        assert isinstance(soup.contents[0], Comment)
        assert soup.contents[0] == '?xml version="1.0" encoding="utf-8"?'
        assert "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
--- a/lib/bs4/tests/test_builder_registry.py
+++ b/lib/bs4/tests/test_builder_registry.py
@ -10,22 +10,23 @@ from bs4.builder import (
    TreeBuilderRegistry,
 )

-try:
-    from bs4.builder import HTML5TreeBuilder
-    HTML5LIB_PRESENT = True
-except ImportError:
-    HTML5LIB_PRESENT = False
+from . import (
+    HTML5LIB_PRESENT,
+    LXML_PRESENT,
+)

-try:
+if HTML5LIB_PRESENT:
+    from bs4.builder import HTML5TreeBuilder
+
+if LXML_PRESENT:
    from bs4.builder import (
        LXMLTreeBuilderForXML,
        LXMLTreeBuilder,
        )
-    LXML_PRESENT = True
-except ImportError:
-    LXML_PRESENT = False


+# TODO: Split out the lxml and html5lib tests into their own classes
+# and gate with pytest.mark.skipIf.
 class TestBuiltInRegistry(object):
    """Test the built-in registry with the default builders registered."""

--- a/lib/bs4/tests/test_dammit.py
+++ b/lib/bs4/tests/test_dammit.py
@ -17,26 +17,24 @@ class TestUnicodeDammit(object):
        dammit = UnicodeDammit(markup)
        assert dammit.unicode_markup == markup

-    def test_smart_quotes_to_unicode(self):
+    @pytest.mark.parametrize(
+        "smart_quotes_to,expect_converted",
+        [(None, "\u2018\u2019\u201c\u201d"),
+         ("xml", "&#x2018;&#x2019;&#x201C;&#x201D;"),
+         ("html", "&lsquo;&rsquo;&ldquo;&rdquo;"),
+         ("ascii", "''" + '""'),
+        ]
+    )
+    def test_smart_quotes_to(self, smart_quotes_to, expect_converted):
+        """Verify the functionality of the smart_quotes_to argument
+        to the UnicodeDammit constructor."""
        markup = b"<foo>\x91\x92\x93\x94</foo>"
-        dammit = UnicodeDammit(markup)
-        assert dammit.unicode_markup == "<foo>\u2018\u2019\u201c\u201d</foo>"
-
-    def test_smart_quotes_to_xml_entities(self):
-        markup = b"<foo>\x91\x92\x93\x94</foo>"
-        dammit = UnicodeDammit(markup, smart_quotes_to="xml")
-        assert dammit.unicode_markup == "<foo>&#x2018;&#x2019;&#x201C;&#x201D;</foo>"
-
-    def test_smart_quotes_to_html_entities(self):
-        markup = b"<foo>\x91\x92\x93\x94</foo>"
-        dammit = UnicodeDammit(markup, smart_quotes_to="html")
-        assert dammit.unicode_markup == "<foo>&lsquo;&rsquo;&ldquo;&rdquo;</foo>"
-
-    def test_smart_quotes_to_ascii(self):
-        markup = b"<foo>\x91\x92\x93\x94</foo>"
-        dammit = UnicodeDammit(markup, smart_quotes_to="ascii")
-        assert dammit.unicode_markup == """<foo>''""</foo>"""
-
+        converted = UnicodeDammit(
+            markup, known_definite_encodings=["windows-1252"],
+            smart_quotes_to=smart_quotes_to
+        ).unicode_markup
+        assert converted == "<foo>{}</foo>".format(expect_converted)
+        
    def test_detect_utf8(self):
        utf8 = b"Sacr\xc3\xa9 bleu! \xe2\x98\x83"
        dammit = UnicodeDammit(utf8)
@ -275,23 +273,24 @@ class TestEntitySubstitution(object):
    def setup_method(self):
        self.sub = EntitySubstitution

-    def test_simple_html_substitution(self):
-        # Unicode characters corresponding to named HTML entites
-        # are substituted, and no others.
-        s = "foo\u2200\N{SNOWMAN}\u00f5bar"
-        assert self.sub.substitute_html(s) == "foo&forall;\N{SNOWMAN}&otilde;bar"

-    def test_smart_quote_substitution(self):
-        # MS smart quotes are a common source of frustration, so we
-        # give them a special test.
-        quotes = b"\x91\x92foo\x93\x94"
-        dammit = UnicodeDammit(quotes)
-        assert self.sub.substitute_html(dammit.markup) == "&lsquo;&rsquo;foo&ldquo;&rdquo;"
+    @pytest.mark.parametrize(
+        "original,substituted",
+        [
+            # Basic case. Unicode characters corresponding to named
+            # HTML entites are substituted; others are not.
+            ("foo\u2200\N{SNOWMAN}\u00f5bar",
+             "foo&forall;\N{SNOWMAN}&otilde;bar"),

+            # MS smart quotes are a common source of frustration, so we
+            # give them a special test.
+            ('‘’foo“”', "&lsquo;&rsquo;foo&ldquo;&rdquo;"),           
+        ]
+    )
+    def test_substitute_html(self, original, substituted):
+        assert self.sub.substitute_html(original) == substituted
+        
    def test_html5_entity(self):
-        # Some HTML5 entities correspond to single- or multi-character
-        # Unicode sequences.
-
        for entity, u in (
            # A few spot checks of our ability to recognize
            # special character sequences and convert them
--- a/lib/bs4/tests/test_html5lib.py
+++ b/lib/bs4/tests/test_html5lib.py
@ -1,27 +1,26 @@
 """Tests to ensure that the html5lib tree builder generates good trees."""

+import pytest
 import warnings

-try:
-    from bs4.builder import HTML5TreeBuilder
-    HTML5LIB_PRESENT = True
-except ImportError as e:
-    HTML5LIB_PRESENT = False
+from bs4 import BeautifulSoup
 from bs4.element import SoupStrainer
 from . import (
+    HTML5LIB_PRESENT,
    HTML5TreeBuilderSmokeTest,
    SoupTest,
-    skipIf,
 )

-@skipIf(
+@pytest.mark.skipif(
    not HTML5LIB_PRESENT,
-    "html5lib seems not to be present, not testing its tree builder.")
+    reason="html5lib seems not to be present, not testing its tree builder."
+)
 class TestHTML5LibBuilder(SoupTest, HTML5TreeBuilderSmokeTest):
    """See ``HTML5TreeBuilderSmokeTest``."""

    @property
    def default_builder(self):
+        from bs4.builder import HTML5TreeBuilder
        return HTML5TreeBuilder

    def test_soupstrainer(self):
@ -29,10 +28,12 @@ class TestHTML5LibBuilder(SoupTest, HTML5TreeBuilderSmokeTest):
        strainer = SoupStrainer("b")
        markup = "<p>A <b>bold</b> statement.</p>"
        with warnings.catch_warnings(record=True) as w:
-            soup = self.soup(markup, parse_only=strainer)
+            soup = BeautifulSoup(markup, "html5lib", parse_only=strainer)
        assert soup.decode() == self.document_for(markup)

-        assert "the html5lib tree builder doesn't support parse_only" in str(w[0].message)
+        [warning] = w
+        assert warning.filename == __file__
+        assert "the html5lib tree builder doesn't support parse_only" in str(warning.message)

    def test_correctly_nested_tables(self):
        """html5lib inserts <tbody> tags where other parsers don't."""
--- a/lib/bs4/tests/test_htmlparser.py
+++ b/lib/bs4/tests/test_htmlparser.py
@ -122,15 +122,3 @@ class TestHTMLParserTreeBuilder(SoupTest, HTMLTreeBuilderSmokeTest):
            with_element = div.encode(formatter="html")
            expect = b"<div>%s</div>" % output_element
            assert with_element == expect
-
-class TestHTMLParserSubclass(SoupTest):
-    def test_error(self):
-        """Verify that our HTMLParser subclass implements error() in a way
-        that doesn't cause a crash.
-        """
-        parser = BeautifulSoupHTMLParser()
-        with warnings.catch_warnings(record=True) as warns:
-            parser.error("don't crash")
-        [warning] = warns
-        assert "don't crash" == str(warning.message)
-
--- a/lib/bs4/tests/test_lxml.py
+++ b/lib/bs4/tests/test_lxml.py
@ -1,16 +1,10 @@
 """Tests to ensure that the lxml tree builder generates good trees."""

 import pickle
+import pytest
 import re
 import warnings
-
-try:
-    import lxml.etree
-    LXML_PRESENT = True
-    LXML_VERSION = lxml.etree.LXML_VERSION
-except ImportError as e:
-    LXML_PRESENT = False
-    LXML_VERSION = (0,)
+from . import LXML_PRESENT, LXML_VERSION

 if LXML_PRESENT:
    from bs4.builder import LXMLTreeBuilder, LXMLTreeBuilderForXML
@ -23,13 +17,14 @@ from bs4.element import Comment, Doctype, SoupStrainer
 from . import (
    HTMLTreeBuilderSmokeTest,
    XMLTreeBuilderSmokeTest,
+    SOUP_SIEVE_PRESENT,
    SoupTest,
-    skipIf,
 )

-@skipIf(
+@pytest.mark.skipif(
    not LXML_PRESENT,
-    "lxml seems not to be present, not testing its tree builder.")
+    reason="lxml seems not to be present, not testing its tree builder."
+)
 class TestLXMLTreeBuilder(SoupTest, HTMLTreeBuilderSmokeTest):
    """See ``HTMLTreeBuilderSmokeTest``."""

@ -54,9 +49,10 @@ class TestLXMLTreeBuilder(SoupTest, HTMLTreeBuilderSmokeTest):
    # In lxml < 2.3.5, an empty doctype causes a segfault. Skip this
    # test if an old version of lxml is installed.

-    @skipIf(
+    @pytest.mark.skipif(
        not LXML_PRESENT or LXML_VERSION < (2,3,5,0),
-        "Skipping doctype test for old version of lxml to avoid segfault.")
+        reason="Skipping doctype test for old version of lxml to avoid segfault."
+    )
    def test_empty_doctype(self):
        soup = self.soup("<!DOCTYPE>")
        doctype = soup.contents[0]
@ -68,7 +64,9 @@ class TestLXMLTreeBuilder(SoupTest, HTMLTreeBuilderSmokeTest):
        with warnings.catch_warnings(record=True) as w:
            soup = BeautifulStoneSoup("<b />")
        assert "<b/>" == str(soup.b)
-        assert "BeautifulStoneSoup class is deprecated" in str(w[0].message)
+        [warning] = w
+        assert warning.filename == __file__
+        assert "BeautifulStoneSoup class is deprecated" in str(warning.message)

    def test_tracking_line_numbers(self):
        # The lxml TreeBuilder cannot keep track of line numbers from
@ -85,9 +83,10 @@ class TestLXMLTreeBuilder(SoupTest, HTMLTreeBuilderSmokeTest):
        assert "sourceline" == soup.p.sourceline.name
        assert "sourcepos" == soup.p.sourcepos.name
        
-@skipIf(
+@pytest.mark.skipif(
    not LXML_PRESENT,
-    "lxml seems not to be present, not testing its XML tree builder.")
+    reason="lxml seems not to be present, not testing its XML tree builder."
+)
 class TestLXMLXMLTreeBuilder(SoupTest, XMLTreeBuilderSmokeTest):
    """See ``HTMLTreeBuilderSmokeTest``."""

@ -148,6 +147,9 @@ class TestLXMLXMLTreeBuilder(SoupTest, XMLTreeBuilderSmokeTest):
        }


+    @pytest.mark.skipif(
+        not SOUP_SIEVE_PRESENT, reason="Soup Sieve not installed"
+    )
    def test_namespace_interaction_with_select_and_find(self):
        # Demonstrate how namespaces interact with select* and
        # find* methods.
--- a/lib/bs4/tests/test_pageelement.py
+++ b/lib/bs4/tests/test_pageelement.py
@ -3,15 +3,18 @@ import copy
 import pickle
 import pytest

-from soupsieve import SelectorSyntaxError
-
 from bs4 import BeautifulSoup
 from bs4.element import (
    Comment,
    SoupStrainer,
 )
-from . import SoupTest
+from . import (
+    SoupTest,
+    SOUP_SIEVE_PRESENT,
+)

+if SOUP_SIEVE_PRESENT:
+    from soupsieve import SelectorSyntaxError

 class TestEncoding(SoupTest):
    """Test the ability to encode objects into strings."""
@ -213,6 +216,7 @@ class TestFormatters(SoupTest):
        assert soup.contents[0].name == 'pre'


+@pytest.mark.skipif(not SOUP_SIEVE_PRESENT, reason="Soup Sieve not installed")
 class TestCSSSelectors(SoupTest):
    """Test basic CSS selector functionality.

@ -694,6 +698,7 @@ class TestPersistence(SoupTest):
        assert tag.can_be_empty_element == copied.can_be_empty_element
        assert tag.cdata_list_attributes == copied.cdata_list_attributes
        assert tag.preserve_whitespace_tags == copied.preserve_whitespace_tags
+        assert tag.interesting_string_types == copied.interesting_string_types
        
    def test_unicode_pickle(self):
        # A tree containing Unicode characters can be pickled.
--- a/lib/bs4/tests/test_soup.py
+++ b/lib/bs4/tests/test_soup.py
@ -30,19 +30,11 @@ from bs4.element import (

 from . import (
    default_builder,
+    LXML_PRESENT,
    SoupTest,
-    skipIf,
 )
 import warnings
-
-try:
-    from bs4.builder import LXMLTreeBuilder, LXMLTreeBuilderForXML
-    LXML_PRESENT = True
-except ImportError as e:
-    LXML_PRESENT = False
    
-PYTHON_3_PRE_3_2 = (sys.version_info[0] == 3 and sys.version_info < (3,2))
-
 class TestConstructor(SoupTest):

    def test_short_unicode_input(self):
@ -139,7 +131,7 @@ class TestConstructor(SoupTest):
        assert " an id " == a['id']
        assert ["a", "class"] == a['class']

-        # TreeBuilder takes an argument called 'mutli_valued_attributes'  which lets
+        # TreeBuilder takes an argument called 'multi_valued_attributes'  which lets
        # you customize or disable this. As always, you can customize the TreeBuilder
        # by passing in a keyword argument to the BeautifulSoup constructor.
        soup = self.soup(markup, builder=default_builder, multi_valued_attributes=None)
@ -219,10 +211,17 @@ class TestConstructor(SoupTest):


 class TestWarnings(SoupTest):
+    # Note that some of the tests in this class create BeautifulSoup
+    # objects directly rather than using self.soup(). That's
+    # because SoupTest.soup is defined in a different file,
+    # which will throw off the assertion in _assert_warning
+    # that the code that triggered the warning is in the same
+    # file as the test.

    def _assert_warning(self, warnings, cls):
        for w in warnings:
            if isinstance(w.message, cls):
+                assert w.filename == __file__
                return w
        raise Exception("%s warning not found in %r" % (cls, warnings))
    
@ -243,13 +242,17 @@ class TestWarnings(SoupTest):

    def test_no_warning_if_explicit_parser_specified(self):
        with warnings.catch_warnings(record=True) as w:
-            soup = BeautifulSoup("<a><b></b></a>", "html.parser")
+            soup = self.soup("<a><b></b></a>")
        assert [] == w

    def test_parseOnlyThese_renamed_to_parse_only(self):
        with warnings.catch_warnings(record=True) as w:
-            soup = self.soup("<a><b></b></a>", parseOnlyThese=SoupStrainer("b"))
-        msg = str(w[0].message)
+            soup = BeautifulSoup(
+                "<a><b></b></a>", "html.parser",
+                parseOnlyThese=SoupStrainer("b"),
+            )
+        warning = self._assert_warning(w, DeprecationWarning)
+        msg = str(warning.message)
        assert "parseOnlyThese" in msg
        assert "parse_only" in msg
        assert b"<b></b>" == soup.encode()
@ -257,8 +260,11 @@ class TestWarnings(SoupTest):
    def test_fromEncoding_renamed_to_from_encoding(self):
        with warnings.catch_warnings(record=True) as w:
            utf8 = b"\xc3\xa9"
-            soup = self.soup(utf8, fromEncoding="utf8")
-        msg = str(w[0].message)
+            soup = BeautifulSoup(
+                utf8, "html.parser", fromEncoding="utf8"
+            )
+        warning = self._assert_warning(w, DeprecationWarning)
+        msg = str(warning.message)
        assert "fromEncoding" in msg
        assert "from_encoding" in msg
        assert "utf8" == soup.original_encoding
@ -276,7 +282,7 @@ class TestWarnings(SoupTest):
        # A warning is issued if the "markup" looks like the name of
        # an HTML or text file, or a full path to a file on disk.
        with warnings.catch_warnings(record=True) as w:
-            soup = self.soup("markup" + extension)
+            soup = BeautifulSoup("markup" + extension, "html.parser")
            warning = self._assert_warning(w, MarkupResemblesLocatorWarning)
            assert "looks more like a filename" in str(warning.message)

@ -291,11 +297,11 @@ class TestWarnings(SoupTest):
        with warnings.catch_warnings(record=True) as w:
            soup = self.soup("markup" + extension)
        assert [] == w
-        
+
    def test_url_warning_with_bytes_url(self):
        url = b"http://www.crummybytes.com/"
        with warnings.catch_warnings(record=True) as warning_list:
-            soup = self.soup(url)
+            soup = BeautifulSoup(url, "html.parser")
        warning = self._assert_warning(
            warning_list, MarkupResemblesLocatorWarning
        )
@ -307,7 +313,7 @@ class TestWarnings(SoupTest):
        with warnings.catch_warnings(record=True) as warning_list:
            # note - this url must differ from the bytes one otherwise
            # python's warnings system swallows the second warning
-            soup = self.soup(url)
+            soup = BeautifulSoup(url, "html.parser")
        warning = self._assert_warning(
            warning_list, MarkupResemblesLocatorWarning
        )
@ -347,18 +353,22 @@ class TestNewTag(SoupTest):
        assert "foo" == new_tag.name
        assert dict(bar="baz", name="a name") == new_tag.attrs
        assert None == new_tag.parent
-        
+
+    @pytest.mark.skipif(
+        not LXML_PRESENT,
+        reason="lxml not installed, cannot parse XML document"
+    )
+    def test_xml_tag_inherits_self_closing_rules_from_builder(self):
+        xml_soup = BeautifulSoup("", "xml")
+        xml_br = xml_soup.new_tag("br")
+        xml_p = xml_soup.new_tag("p")
+
+        # Both the <br> and <p> tag are empty-element, just because
+        # they have no contents.
+        assert b"<br/>" == xml_br.encode()
+        assert b"<p/>" == xml_p.encode()
+
    def test_tag_inherits_self_closing_rules_from_builder(self):
-        if LXML_PRESENT:
-            xml_soup = BeautifulSoup("", "lxml-xml")
-            xml_br = xml_soup.new_tag("br")
-            xml_p = xml_soup.new_tag("p")
-
-            # Both the <br> and <p> tag are empty-element, just because
-            # they have no contents.
-            assert b"<br/>" == xml_br.encode()
-            assert b"<p/>" == xml_p.encode()
-
        html_soup = BeautifulSoup("", "html.parser")
        html_br = html_soup.new_tag("br")
        html_p = html_soup.new_tag("p")
@ -450,13 +460,3 @@ class TestEncodingConversion(SoupTest):
        # The internal data structures can be encoded as UTF-8.
        soup_from_unicode = self.soup(self.unicode_data)
        assert soup_from_unicode.encode('utf-8') == self.utf8_data
-
-    @skipIf(
-        PYTHON_3_PRE_3_2,
-        "Bad HTMLParser detected; skipping test of non-ASCII characters in attribute name.")
-    def test_attribute_name_containing_unicode_characters(self):
-        markup = '<div><a \N{SNOWMAN}="snowman"></a></div>'
-        assert self.soup(markup).div.encode("utf8") == markup.encode("utf8")
-
-
-
--- a/lib/bs4/tests/test_tree.py
+++ b/lib/bs4/tests/test_tree.py
@ -33,7 +33,6 @@ from bs4.element import (
 )
 from . import (
    SoupTest,
-    skipIf,
 )

 class TestFind(SoupTest):
@ -910,12 +909,16 @@ class TestTreeModification(SoupTest):
        soup.a.extend(l)
        assert "<a><g></g><f></f><e></e><d></d><c></c><b></b></a>" == soup.decode()

-    def test_extend_with_another_tags_contents(self):
+    @pytest.mark.parametrize(
+        "get_tags", [lambda tag: tag, lambda tag: tag.contents]
+    )
+    def test_extend_with_another_tags_contents(self, get_tags):
        data = '<body><div id="d1"><a>1</a><a>2</a><a>3</a><a>4</a></div><div id="d2"></div></body>'
        soup = self.soup(data)
        d1 = soup.find('div', id='d1')
        d2 = soup.find('div', id='d2')
-        d2.extend(d1)
+        tags = get_tags(d1)
+        d2.extend(tags)
        assert '<div id="d1"></div>' == d1.decode()
        assert '<div id="d2"><a>1</a><a>2</a><a>3</a><a>4</a></div>' == d2.decode()
        
@ -1272,19 +1275,30 @@ class TestTreeModification(SoupTest):

 class TestDeprecatedArguments(SoupTest):

-    def test_find_type_method_string(self):
+    @pytest.mark.parametrize(
+        "method_name", [
+            "find", "find_all", "find_parent", "find_parents",
+            "find_next", "find_all_next", "find_previous",
+            "find_all_previous", "find_next_sibling", "find_next_siblings",
+            "find_previous_sibling", "find_previous_siblings",
+        ]
+    )
+    def test_find_type_method_string(self, method_name):
        soup = self.soup("<a>some</a><b>markup</b>")
+        method = getattr(soup.b, method_name)
        with warnings.catch_warnings(record=True) as w:
-            [result] = soup.find_all(text='markup')
-            assert result == 'markup'
-            assert result.parent.name == 'b'
-            msg = str(w[0].message)
+            method(text='markup')
+            [warning] = w
+            assert warning.filename == __file__
+            msg = str(warning.message)
            assert msg == "The 'text' argument to find()-type methods is deprecated. Use 'string' instead."

    def test_soupstrainer_constructor_string(self):
        with warnings.catch_warnings(record=True) as w:
            strainer = SoupStrainer(text="text")
            assert strainer.text == 'text'
-            msg = str(w[0].message)
+            [warning] = w
+            msg = str(warning.message)
+            assert warning.filename == __file__
            assert msg == "The 'text' argument to the SoupStrainer constructor is deprecated. Use 'string' instead."