Merge lp:~cjwatson/soupmatchers/python3 into lp:soupmatchers

[Colin Watson]

Port to beautifulsoup4 and Python 3.

Since the interface exposed by this package is mostly about searching in existing text, just continuing to use native strings everywhere seems to work fine; we just need the usual porting stuff, a BeautifulSoup upgrade, and some care around testtools.Content (whose second argument is an iterator over bytes objects).

[James Westby (james-w)]

review: Approve

=== modified file 'README'
--- README	2010-07-12 16:43:33 +0000
+++ README	2017-10-20 22:33:14 +0000
@@ -20,25 +20,25 @@
 BeautifulSoup
 -------------
 
-  >>> import BeautifulSoup
-  >>> root = BeautifulSoup.BeautifulSoup(html)
+  >>> import bs4
+  >>> root = bs4.BeautifulSoup(html, "html.parser")
 
 It is an HTML parsing library that includes
 a way to search the document for matching tags. If you had a parsed
 representation of your document you could find the above part by doing
 
   >>> import re
-  >>> anchor_tags = root.findAll(
+  >>> anchor_tags = root.find_all(
   ...    "a", attrs={"href": "https://launchpad.net/testtools",
   ...        "class": "awesome"})
-  >>> print anchor_tags
-  [<a href="https://launchpad.net/testtools" class="awesome">testtools <b>rocks</b></a>]
+  >>> print(anchor_tags)
+  [<a class="awesome" href="https://launchpad.net/testtools">testtools <b>rocks</b></a>]
 
-which would return you a list with (lets assume) a single entry, the
-BeautifulSoup.Tag for the <a>. You can locate the nested tag with:
+which would return you a list with (let's assume) a single entry, the
+bs4.Tag for the <a>. You can locate the nested tag with:
 
   >>> anchor_tag = anchor_tags[0]
-  >>> anchor_tag.findAll("b")
+  >>> anchor_tag.find_all("b")
   [<b>rocks</b>]
 
 which will again return a single item list.
@@ -65,10 +65,10 @@
 has a certain css class, and mentions testtools in the anchor text.
 
   >>> import soupmatchers
-  >>> print soupmatchers.Tag(
+  >>> print(soupmatchers.Tag(
   ...     "link to testtols", "a",
   ...     attrs={"href": "https://launchpad.net/testtools",
-  ...         "class": "awesome"})
+  ...         "class": "awesome"}))
   Tag("link to testtols",
   <a class='awesome' href='https://launchpad.net/testtools' ...>...</a>)
 
@@ -81,29 +81,29 @@
 Further though, soupmatchers allows you to specify text that the
 tag must contain to match.
 
-  >>> print soupmatchers.Tag(
-  ...     "link to testtols", "a",
+  >>> print(soupmatchers.Tag(
+  ...     "link to testtools", "a",
   ...     attrs={"href": "https://launchpad.net/testtools",
-  ...            "class": "awesome"}, text=re.compile(r"testtools"))
-  Tag("link to testtols",
+  ...            "class": "awesome"}, text=re.compile(r"testtools")))
+  Tag("link to testtools",
   <a class='awesome' href='https://launchpad.net/testtools'
   ...>re.compile('testtools') ...</a>)
 
 Now lets define a create a matcher that will match the bold tag from above.
 
-  >>> print soupmatchers.Tag("bold rocks", "b", text="rocks")
+  >>> print(soupmatchers.Tag("bold rocks", "b", text="rocks"))
   Tag("bold rocks", <b ...>rocks ...</b>)
 
 Obviously this would allow the bold tag to be outside of the anchor tag, but
 no fear, we can create a matcher that will check that one is inside the
 other, simply use the Within matcher to combine the two.
 
-  >>> print soupmatchers.Within(
+  >>> print(soupmatchers.Within(
   ...     soupmatchers.Tag(
   ...         "link to testtools", "a",
   ...         attrs={"href": "https://launchpad.net/testtools",
   ...                "class": "awesome"}, text=re.compile(r"testtools")),
-  ...     soupmatchers.Tag("bold rocks", "b", text="rocks"))
+  ...     soupmatchers.Tag("bold rocks", "b", text="rocks")))
   Tag("bold rocks", <b ...>rocks ...</b>) within Tag("link to testtools",
   <a class='awesome' href='https://launchpad.net/testtools'
   ...>re.compile('testtools') ...</a>)
@@ -115,7 +115,8 @@
 mean you have to go to the trouble of parsing every time you want to use
 them. To simplify that you can use
 
-  >>> print soupmatchers.HTMLContains(soupmatchers.Tag("some image", "image"))
+  >>> print(soupmatchers.HTMLContains(
+  ...     soupmatchers.Tag("some image", "image")))
   HTML contains [Tag("some image", <image ...>...</image>)]
 
 to create a matcher that will parse the string before checking the tag
@@ -135,7 +136,7 @@
   >>> import testtools
   >>> matcher = testtools.matchers.Equals(1)
   >>> match = matcher.match(1)
-  >>> print match
+  >>> print(match)
   None
 
 the returned match will be None if the matcher matches the content that
@@ -159,10 +160,10 @@
 attribute of the passed object against an expected value, and also check
 the content attribute against any matcher you wish to specify.
 
-  >>> print soupmatchers.ResponseHas(
+  >>> print(soupmatchers.ResponseHas(
   ...     status_code=404,
   ...     content_matches=soupmatchers.HTMLContains(soupmatchers.Tag(
-  ...         "an anchor", "a")))
+  ...         "an anchor", "a"))))
   ResponseHas(status_code=404, content_matches=HTML contains
   [Tag("an anchor", <a ...>...</a>)])
 
@@ -171,8 +172,8 @@
 As working with HTML is very common, there's an easier way to write the
 above.
 
-  >>> print soupmatchers.HTMLResponseHas(
-  ...     status_code=404, html_matches=soupmatchers.Tag("an anchor", "a"))
+  >>> print(soupmatchers.HTMLResponseHas(
+  ...     status_code=404, html_matches=soupmatchers.Tag("an anchor", "a")))
   HTMLResponseHas(status_code=404, content_matches=HTML contains
   [Tag("an anchor", <a ...>...</a>)])
 
@@ -201,12 +202,12 @@
   ...     html_matches=combined_matcher)
   >>> #self.assertThat(response, response_matcher)
   >>> match = response_matcher.match(ExpectedResponse())
-  >>> print match
+  >>> print(match)
   None
   >>> match = response_matcher.match(UnexpectedResponse())
-  >>> print repr(match) #doctest: +ELLIPSIS
+  >>> print(repr(match)) #doctest: +ELLIPSIS
   <soupmatchers.TagMismatch object at ...>
-  >>> print match.describe()
+  >>> print(match.describe())
   Matched 0 times
   Here is some information that may be useful:
     0 matches for "bold rocks" in the document.
@@ -218,7 +219,7 @@
 Checking the number of times a pattern is matched
 -------------------------------------------------
 
-Remember how findAll returned a list, and we just assumed that it only found
+Remember how find_all returned a list, and we just assumed that it only found
 one tag in the example? Well, the matchers allow you to not just assume that,
 they allow you to assert that. That means that you can assert that
 a particular tag only occurs once by passing
@@ -232,10 +233,10 @@
   >>> html_matcher = soupmatchers.HTMLContains(tag_matcher)
   >>> content = '<a href="https://launchpad.net/testtools"></a>'
   >>> match = html_matcher.match(content)
-  >>> print match
+  >>> print(match)
   None
   >>> match = html_matcher.match(content * 2)
-  >>> print match.describe()
+  >>> print(match.describe())
   Matched 2 times
   The matches were:
     <a href="https://launchpad.net/testtools"></a>
@@ -251,7 +252,7 @@
   >>> html_matcher = soupmatchers.HTMLContains(tag_matcher)
   >>> content = '<a href="https://launchpad.net/testtools"></a>'
   >>> match = html_matcher.match(content)
-  >>> print match.describe()
+  >>> print(match.describe())
   Matched 1 time
   The match was:
     <a href="https://launchpad.net/testtools"></a>
@@ -275,9 +276,9 @@
 
   >>> matcher = soupmatchers.HTMLContains(soupmatchers.Tag("bold", "b"))
   >>> mismatch = matcher.match("<image></image>")
-  >>> print mismatch.get_details().keys()
+  >>> print(list(mismatch.get_details().keys()))
   ['html']
-  >>> print ''.join(list(mismatch.get_details()["html"].iter_bytes()))
+  >>> print(''.join(list(mismatch.get_details()["html"].iter_text())))
   <image></image>
 
 If you use assertThat then it will automatically call addDetails with this
@@ -294,7 +295,7 @@
   >>> matcher = soupmatchers.HTMLContains(soupmatchers.Tag(
   ...        "no bold", "b", count=0))
   >>> mismatch = matcher.match("<b>rocks</b>")
-  >>> print mismatch.describe()
+  >>> print(mismatch.describe())
   Matched 1 time
   The match was:
       <b>rocks</b>
@@ -309,7 +310,7 @@
   ...               "class": "awesome"}))
   >>> mismatch = matcher.match(
   ...    "<a href='https://launchpad.net/testtools'></a>")
-  >>> print mismatch.describe()
+  >>> print(mismatch.describe())
   Matched 0 times
   Here is some information that may be useful:
      1 matches for "testtools link" when attribute class="awesome" is not a
@@ -319,7 +320,7 @@
   ...    soupmatchers.Tag("bold rocks", "b", text="rocks"))
   >>> mismatch = matcher.match(
   ...    "<b>is awesome</b>")
-  >>> print mismatch.describe()
+  >>> print(mismatch.describe())
   Matched 0 times
   Here is some information that may be useful:
     1 matches for "bold rocks" when text="rocks" is not a requirement.
@@ -342,11 +343,11 @@
   >>> body_matcher = soupmatchers.Tag("the body", "body")
   >>> matcher = soupmatchers.HTMLContains(
   ...     soupmatchers.Within(body_matcher, child_matcher))
-  >>> print matcher
+  >>> print(matcher)
   HTML contains [Tag("bold rocks", <b ...>rocks ...</b>)
   within Tag("the body", <body ...>...</body>)]
   >>> mismatch = matcher.match("<b>rocks</b><body></body>")
-  >>> print mismatch.describe()
+  >>> print(mismatch.describe())
   Matched 0 times
   Here is some information that may be useful:
     1 matches for "bold rocks" in the document.

=== modified file 'setup.py'
--- setup.py	2012-02-08 00:44:34 +0000
+++ setup.py	2017-10-20 22:33:14 +0000
@@ -17,5 +17,15 @@
         to your TestCase hierarchy because it makes use of testtools
         Matchers.'''),
     setup_requires=['setuptools'],
-    install_requires=['testtools>0.9.3', 'BeautifulSoup'],
+    install_requires=['testtools>0.9.3', 'beautifulsoup4'],
+    classifiers=[
+        "Development Status :: 5 - Production/Stable",
+        "Intended Audience :: Developers",
+        "License :: OSI Approved :: Eclipse Public License 1.0 (EPL-1.0)",
+        "Programming Language :: Python",
+        "Programming Language :: Python :: 2",
+        "Programming Language :: Python :: 3",
+        "Topic :: Text Processing :: Markup :: HTML",
+        "Topic :: Software Development :: Testing",
+        ],
     )

=== modified file 'soupmatchers/__init__.py'
--- soupmatchers/__init__.py	2012-02-08 00:43:44 +0000
+++ soupmatchers/__init__.py	2017-10-20 22:33:14 +0000
@@ -23,7 +23,7 @@
 See the README for more information.
 """
 
-import BeautifulSoup
+import bs4
 
 from testtools import matchers
 from testtools.content import Content
@@ -47,7 +47,7 @@
         if self.html is not None:
             return {
                 "html": Content(ContentType("text", "html"),
-                        lambda: self.html)
+                        lambda: [self.html.encode("UTF-8")])
             }
         return {}
 
@@ -125,7 +125,7 @@
 
     def match(self, content):
         if len(self.matchers) > 0:
-            parsed_content = BeautifulSoup.BeautifulSoup(content)
+            parsed_content = bs4.BeautifulSoup(content, "html.parser")
             for matcher in self.matchers:
                 match = matcher.match(parsed_content)
                 if match is not None:
@@ -171,7 +171,8 @@
     def get_details(self):
         details = {
             "html": Content(
-                ContentType("text", "html"), lambda: [str(self.content)])
+                ContentType("text", "html"),
+                lambda: [str(self.content).encode("UTF-8")])
         }
         return details
 
@@ -185,6 +186,10 @@
                 or self.content != other.content
                 or self.matches != other.matches)
 
+    def __repr__(self):
+        return  "<soupmatchers.TagMismatch object at %x attributes=%r>" % (
+            id(self), self.__dict__)
+
 
 class DocumentPart(matchers.Matcher):
 
@@ -266,8 +271,8 @@
         is a key in the dict, or True, which matches any tag name.
 
         It is also possible to pass a callable as a tag name. The callable
-        should take a BeautifulSoup.Tag object as the argument and
-        return a boolean, with True indicating that the tag should match.
+        should take a bs4.Tag object as the argument and return a boolean,
+        with True indicating that the tag should match.
 
         attrs is a dict that defines what attributes the tag should have.
         The keys are the names of attributes and the values define the
@@ -324,12 +329,12 @@
     def _check_text(self, candidates, text):
         if len(candidates) > 0 and text is not _not_passed:
             for candidate in candidates[:]:
-                texts = candidate.findAll(text=text)
+                texts = candidate.find_all(text=text)
                 if len(texts) < 1:
                     candidates.remove(candidate)
 
     def _get_matches(self, html, attrs, text):
-        candidates = list(html.findAll(self.tag_type, attrs=attrs))
+        candidates = list(html.find_all(self.tag_type, attrs=attrs))
         self._check_text(candidates, text)
         return candidates
 

=== modified file 'soupmatchers/tests/__init__.py'
--- soupmatchers/tests/__init__.py	2012-02-08 00:36:21 +0000
+++ soupmatchers/tests/__init__.py	2017-10-20 22:33:14 +0000
@@ -1,19 +1,22 @@
+from __future__ import print_function
+
+
 def load_tests(loader, standard_tests, pattern):
     import doctest
     import os
     import sys
-    import unittest
-    suite = unittest.TestSuite()
-    loader = unittest.TestLoader()
-    suite.addTest(loader.loadTestsFromName(__name__))
+
+    this_dir = os.path.dirname(__file__)
+    standard_tests.addTests(
+        loader.discover(start_dir=this_dir, pattern=pattern))
     source_readme_path = os.path.join(
-        os.path.dirname(os.path.dirname(os.path.dirname(__file__))), "README")
+        os.path.dirname(os.path.dirname(this_dir)), "README")
     if os.path.exists(source_readme_path):
-        suite.addTest(
-            doctest.DocFileTest(os.path.relpath(
-                    source_readme_path, os.path.dirname(__file__)),
-                optionflags=doctest.NORMALIZE_WHITESPACE))
+        standard_tests.addTest(
+            doctest.DocFileTest(os.path.relpath(source_readme_path, this_dir),
+                optionflags=doctest.NORMALIZE_WHITESPACE,
+                globs={'print_function': print_function}))
     else:
         sys.stderr.write("Warning: not testing README as it can't be found")
-    return suite
+    return standard_tests
 

=== modified file 'soupmatchers/tests/test_matchers.py'
--- soupmatchers/tests/test_matchers.py	2012-02-08 00:43:44 +0000
+++ soupmatchers/tests/test_matchers.py	2017-10-20 22:33:14 +0000
@@ -2,7 +2,7 @@
 
 import re
 
-import BeautifulSoup
+import bs4
 
 from testtools import (
     matchers as testtools_matchers,
@@ -53,7 +53,8 @@
         html = "<image></image>"
         mismatch = matchers.StatusCodeMismatch(200, 404, html=html)
         self.assertEqual(
-            {"html": Content(ContentType("text", "html"), lambda: html)},
+            {"html": Content(
+                ContentType("text", "html"), lambda: [html.encode("UTF-8")])},
             mismatch.get_details())
 
     def get_equal_mismatches(self):
@@ -129,7 +130,9 @@
         response = TestResponse(status_code=404, content=content)
         match = matchers.ResponseHas(status_code=200).match(response)
         self.assertEquals(
-            {"html": Content(ContentType("text", "html"), lambda: content)},
+            {"html": Content(
+                ContentType("text", "html"),
+                lambda: [content.encode("UTF-8")])},
             match.get_details())
 
     def test_response_has_content_matches(self):
@@ -195,7 +198,7 @@
         html_matcher = matchers.HTMLContains(anchor_matcher)
         content = "<image></image>"
         match = html_matcher.match(content)
-        parsed_content = BeautifulSoup.BeautifulSoup(content)
+        parsed_content = bs4.BeautifulSoup(content, "html.parser")
         self.assertEquals(
             matchers.TagMismatch(anchor_matcher, parsed_content, []), match)
 
@@ -203,7 +206,7 @@
         html_matcher = matchers.HTMLContains(anchor_matcher, image_matcher)
         content = "<image></image>"
         match = html_matcher.match(content)
-        parsed_content = BeautifulSoup.BeautifulSoup(content)
+        parsed_content = bs4.BeautifulSoup(content, "html.parser")
         self.assertEquals(
             matchers.TagMismatch(anchor_matcher, parsed_content, []), match)
 
@@ -211,7 +214,7 @@
         html_matcher = matchers.HTMLContains(anchor_matcher, image_matcher)
         content = "<b></b>"
         match = html_matcher.match(content)
-        parsed_content = BeautifulSoup.BeautifulSoup(content)
+        parsed_content = bs4.BeautifulSoup(content, "html.parser")
         self.assertEquals(
             matchers.TagMismatch(anchor_matcher, parsed_content, []), match)
 
@@ -229,13 +232,13 @@
 
     def test_describe_zero(self):
         content = "<image></image>"
-        parsed_content = BeautifulSoup.BeautifulSoup(content)
+        parsed_content = bs4.BeautifulSoup(content, "html.parser")
         mismatch = matchers.TagMismatch(anchor_matcher, parsed_content, [])
         self.assertEqual("Matched 0 times", mismatch.describe())
 
     def test_describe_one(self):
         content = "<image></image>"
-        parsed_content = BeautifulSoup.BeautifulSoup(content)
+        parsed_content = bs4.BeautifulSoup(content, "html.parser")
         mismatch = matchers.TagMismatch(
             anchor_matcher, parsed_content, ["<a></a>"])
         self.assertEqual(
@@ -244,7 +247,7 @@
 
     def test_describe_two(self):
         content = "<image></image>"
-        parsed_content = BeautifulSoup.BeautifulSoup(content)
+        parsed_content = bs4.BeautifulSoup(content, "html.parser")
         mismatch = matchers.TagMismatch(
             anchor_matcher, parsed_content, ["<a></a>", "<b></b>"])
         self.assertEqual(
@@ -253,15 +256,17 @@
 
     def test_get_details(self):
         content = "<image></image>"
-        parsed_content = BeautifulSoup.BeautifulSoup(content)
+        parsed_content = bs4.BeautifulSoup(content, "html.parser")
         mismatch = matchers.TagMismatch(anchor_matcher, parsed_content, [])
         self.assertEqual(
-            {"html": Content(ContentType("text", "html"),
-                    lambda: str(parsed_content))}, mismatch.get_details())
+            {"html": Content(
+                ContentType("text", "html"),
+                lambda: [str(parsed_content).encode("UTF-8")])},
+            mismatch.get_details())
 
     def test_eq_equal(self):
         content = "<image></image>"
-        parsed_content = BeautifulSoup.BeautifulSoup(content)
+        parsed_content = bs4.BeautifulSoup(content, "html.parser")
         matches = ["<a></a>"]
         mismatch1 = matchers.TagMismatch(
             anchor_matcher, parsed_content, matches)
@@ -271,7 +276,7 @@
 
     def test_eq_different_tag(self):
         content = "<image></image>"
-        parsed_content = BeautifulSoup.BeautifulSoup(content)
+        parsed_content = bs4.BeautifulSoup(content, "html.parser")
         matches = ["<a></a>"]
         mismatch1 = matchers.TagMismatch(
             anchor_matcher, parsed_content, matches)
@@ -281,9 +286,9 @@
 
     def test_eq_different_content(self):
         content1 = "<image></image>"
-        parsed_content1 = BeautifulSoup.BeautifulSoup(content1)
+        parsed_content1 = bs4.BeautifulSoup(content1, "html.parser")
         content2 = "<div></div>"
-        parsed_content2 = BeautifulSoup.BeautifulSoup(content2)
+        parsed_content2 = bs4.BeautifulSoup(content2, "html.parser")
         matches = ["<a></a>"]
         mismatch1 = matchers.TagMismatch(
             anchor_matcher, parsed_content1, matches)
@@ -293,7 +298,7 @@
 
     def test_eq_different_matches(self):
         content = "<image></image>"
-        parsed_content = BeautifulSoup.BeautifulSoup(content)
+        parsed_content = bs4.BeautifulSoup(content, "html.parser")
         matches1 = ["<a></a>"]
         matches2 = ["<b></b>"]
         mismatch1 = matchers.TagMismatch(
@@ -344,7 +349,7 @@
             str(tag_matcher))
 
     def get_match(self, matcher, content):
-        parsed_content = BeautifulSoup.BeautifulSoup(content)
+        parsed_content = bs4.BeautifulSoup(content, "html.parser")
         return matcher.match(parsed_content), parsed_content
 
     def test_matches_one_instance(self):
@@ -524,14 +529,14 @@
 
     def test_get_extra_info_no_close_matches(self):
         content = "<image></image>"
-        parsed_content = BeautifulSoup.BeautifulSoup(content)
+        parsed_content = bs4.BeautifulSoup(content, "html.parser")
         extra_info = anchor_matcher.get_extra_info([parsed_content], "")
         self.assertEqual([], extra_info)
 
     def test_get_extra_info_vary_attributes(self):
         tag_matcher = matchers.Tag("foo link", "a", attrs={"href": "foo"})
         content = "<a></a>"
-        parsed_content = BeautifulSoup.BeautifulSoup(content)
+        parsed_content = bs4.BeautifulSoup(content, "html.parser")
         close_matches = tag_matcher.get_extra_info([parsed_content], "")
         self.assertEqual(
             ['1 matches for "foo link" when attribute href="foo" '
@@ -541,7 +546,7 @@
         tag_matcher = matchers.Tag(
             "foo bar link", "a", attrs={"href": "foo", "class": "bar"})
         content = "<a href='foo'></a><a class='bar'></a>"
-        parsed_content = BeautifulSoup.BeautifulSoup(content)
+        parsed_content = bs4.BeautifulSoup(content, "html.parser")
         extra_info = tag_matcher.get_extra_info([parsed_content], "")
         self.assertEqual(
             ['1 matches for "foo bar link" when attribute class="bar" '
@@ -553,7 +558,7 @@
     def test_get_extra_info_vary_text(self):
         tag_matcher = matchers.Tag("bold rocks", "b", text="rocks")
         content = "<b>is awesome</b>"
-        parsed_content = BeautifulSoup.BeautifulSoup(content)
+        parsed_content = bs4.BeautifulSoup(content, "html.parser")
         extra_info = tag_matcher.get_extra_info([parsed_content], "")
         self.assertEqual(
             ['1 matches for \"bold rocks\" when text="rocks" is not a '
@@ -563,16 +568,16 @@
         tag_matcher = matchers.Tag(
             "no bold rocks", "b", text="rocks", count=0)
         content = "<b>is awesome</b>"
-        parsed_content = BeautifulSoup.BeautifulSoup(content)
+        parsed_content = bs4.BeautifulSoup(content, "html.parser")
         extra_info = tag_matcher.get_extra_info([parsed_content], "")
         self.assertEqual([], extra_info)
 
     def test_get_extra_info_multiple_roots(self):
         tag_matcher = matchers.Tag("bold rocks", "b", text="rocks")
         content1 = "<b>is awesome</b>"
-        parsed_content1 = BeautifulSoup.BeautifulSoup(content1)
+        parsed_content1 = bs4.BeautifulSoup(content1, "html.parser")
         content2 = "<b>is awesome</b>"
-        parsed_content2 = BeautifulSoup.BeautifulSoup(content2)
+        parsed_content2 = bs4.BeautifulSoup(content2, "html.parser")
         extra_info = tag_matcher.get_extra_info(
             [parsed_content1, parsed_content2], "")
         self.assertEqual(
@@ -582,7 +587,7 @@
     def test_get_extra_info_identifier_suffix(self):
         tag_matcher = matchers.Tag("bold rocks", "b", text="rocks")
         content = "<b>is awesome</b>"
-        parsed_content = BeautifulSoup.BeautifulSoup(content)
+        parsed_content = bs4.BeautifulSoup(content, "html.parser")
         extra_info = tag_matcher.get_extra_info([parsed_content],
                 " within foo")
         self.assertEqual(
@@ -644,7 +649,7 @@
     def test_match_outer_not_matched(self):
         within_matcher = matchers.Within(anchor_matcher, image_matcher)
         content = "<image></image>"
-        parsed_content = BeautifulSoup.BeautifulSoup(content)
+        parsed_content = bs4.BeautifulSoup(content, "html.parser")
         mismatch = within_matcher.match(parsed_content)
         self.assertEqual(
             matchers.TagMismatch(within_matcher, parsed_content, []),
@@ -653,7 +658,7 @@
     def test_match_mismatch(self):
         within_matcher = matchers.Within(anchor_matcher, image_matcher)
         content = "<a></a><image></image>"
-        parsed_content = BeautifulSoup.BeautifulSoup(content)
+        parsed_content = bs4.BeautifulSoup(content, "html.parser")
         mismatch = within_matcher.match(parsed_content)
         self.assertEqual(
             matchers.TagMismatch(within_matcher, parsed_content, []),
@@ -662,7 +667,7 @@
     def test_match_match_in_one(self):
         within_matcher = matchers.Within(anchor_matcher, image_matcher)
         content = "<a><image></image></a>"
-        parsed_content = BeautifulSoup.BeautifulSoup(content)
+        parsed_content = bs4.BeautifulSoup(content, "html.parser")
         mismatch = within_matcher.match(parsed_content)
         self.assertEqual(None, mismatch)
 
@@ -676,7 +681,7 @@
         content = '<div><div></div></div>'
         child_matcher = matchers.Tag("div", 'div')
         tag_matcher = matchers.Within(child_matcher, child_matcher)
-        parsed_content = BeautifulSoup.BeautifulSoup(content)
+        parsed_content = bs4.BeautifulSoup(content, "html.parser")
         match = tag_matcher.match(parsed_content)
         self.assertEqual(None, match)
 
@@ -690,7 +695,7 @@
         content = '<div><span></span></div>'
         child_matcher = matchers.Tag("div", 'div')
         tag_matcher = matchers.Within(child_matcher, child_matcher)
-        parsed_content = BeautifulSoup.BeautifulSoup(content)
+        parsed_content = bs4.BeautifulSoup(content, "html.parser")
         match = tag_matcher.match(parsed_content)
         self.assertEqual(
             matchers.TagMismatch(tag_matcher, parsed_content, []),
@@ -699,7 +704,7 @@
     def test_get_extra_info_both_missing(self):
         content = ''
         tag_matcher = matchers.Within(anchor_matcher, image_matcher)
-        parsed_content = BeautifulSoup.BeautifulSoup(content)
+        parsed_content = bs4.BeautifulSoup(content, "html.parser")
         extra_info = tag_matcher.get_extra_info([parsed_content], "")
         self.assertEqual(
             ['0 matches for "%s" in the document.'
@@ -711,7 +716,7 @@
     def test_get_extra_info_inner_missing(self):
         content = '<a></a>'
         tag_matcher = matchers.Within(anchor_matcher, image_matcher)
-        parsed_content = BeautifulSoup.BeautifulSoup(content)
+        parsed_content = bs4.BeautifulSoup(content, "html.parser")
         extra_info = tag_matcher.get_extra_info([parsed_content], "")
         self.assertEqual(
             ['0 matches for "%s" in the document.'
@@ -723,7 +728,7 @@
     def test_get_extra_info_neither_missing(self):
         content = '<a></a><image></image>'
         tag_matcher = matchers.Within(anchor_matcher, image_matcher)
-        parsed_content = BeautifulSoup.BeautifulSoup(content)
+        parsed_content = bs4.BeautifulSoup(content, "html.parser")
         extra_info = tag_matcher.get_extra_info([parsed_content], "")
         self.assertEqual(
             ['1 matches for "%s" in the document.'
@@ -736,7 +741,7 @@
         content = '<a><b>is awesome</b></a>'
         bold_matcher = matchers.Tag("bold rocks", "b", text="rocks")
         tag_matcher = matchers.Within(anchor_matcher, bold_matcher)
-        parsed_content = BeautifulSoup.BeautifulSoup(content)
+        parsed_content = bs4.BeautifulSoup(content, "html.parser")
         extra_info = tag_matcher.get_extra_info([parsed_content], "")
         self.assertEqual(
             ['0 matches for "bold rocks" in the document.',
@@ -749,7 +754,7 @@
     def test_get_extra_info_multiple_parts(self):
         content = '<a></a><image></image>'
         tag_matcher = matchers.Within(anchor_matcher, image_matcher)
-        parsed_content = BeautifulSoup.BeautifulSoup(content)
+        parsed_content = bs4.BeautifulSoup(content, "html.parser")
         extra_info = tag_matcher.get_extra_info(
             [parsed_content, parsed_content], "")
         self.assertEqual(
@@ -762,7 +767,7 @@
     def test_get_extra_info_with_suffix(self):
         content = '<a></a><image></image>'
         tag_matcher = matchers.Within(anchor_matcher, image_matcher)
-        parsed_content = BeautifulSoup.BeautifulSoup(content)
+        parsed_content = bs4.BeautifulSoup(content, "html.parser")
         extra_info = tag_matcher.get_extra_info([parsed_content],
                 " within foo")
         self.assertEqual(
@@ -775,7 +780,7 @@
     def test_get_matches(self):
         within_matcher = matchers.Within(anchor_matcher, image_matcher)
         content = "<a><image></image></a>"
-        parsed_content = BeautifulSoup.BeautifulSoup(content)
+        parsed_content = bs4.BeautifulSoup(content, "html.parser")
         matches = within_matcher.get_matches(parsed_content)
         self.assertEqual([content], [str(a) for a in matches])
 
@@ -910,7 +915,7 @@
     def test_get_matches_outer_missing(self):
         select_matcher = self.get_select_matcher_with_single_choice()
         content = '<option value="choice1">Choice 1</option>'
-        parsed_content = BeautifulSoup.BeautifulSoup(content)
+        parsed_content = bs4.BeautifulSoup(content, "html.parser")
         matches = select_matcher.get_matches(parsed_content)
         self.assertEqual([], matches)
 
@@ -919,7 +924,7 @@
             choices={"choice1": "Choice 1", "choice2": "Choice 2"})
         content = ('<select name="foo"><option value="choice1">'
                 'Choice 1</option></select>')
-        parsed_content = BeautifulSoup.BeautifulSoup(content)
+        parsed_content = bs4.BeautifulSoup(content, "html.parser")
         matches = select_matcher.get_matches(parsed_content)
         self.assertEqual([], matches)
 
@@ -929,7 +934,7 @@
         content = ('<select name="foo"><option value="choice1">'
                 'Choice 1</option><option value="choice2">'
                 'Choice 2</option></select>')
-        parsed_content = BeautifulSoup.BeautifulSoup(content)
+        parsed_content = bs4.BeautifulSoup(content, "html.parser")
         matches = select_matcher.get_matches(parsed_content)
         self.assertEqual([content], [str(a) for a in matches])
 
@@ -941,14 +946,14 @@
                 'Choice 2</option></select>')
         unmatched_content = ('<select name="foo"><option value="choice1">'
                 'Choice 1</option></select>')
-        parsed_content = BeautifulSoup.BeautifulSoup(
-                content+unmatched_content)
+        parsed_content = bs4.BeautifulSoup(
+                content+unmatched_content, "html.parser")
         matches = select_matcher.get_matches(parsed_content)
         self.assertEqual([content], [str(a) for a in matches])
 
     def test_match_twice(self):
         select_matcher = self.get_select_matcher_with_single_choice()
         content = '<select><option value="choice1">Choice 1</option></select>'
-        parsed_content = BeautifulSoup.BeautifulSoup(content*2)
+        parsed_content = bs4.BeautifulSoup(content*2, "html.parser")
         matches = select_matcher.get_matches(parsed_content)
         self.assertEqual([content]*2, [str(a) for a in matches])