Merge pull request #34 from mshroyer/rst-refactor-tests

Refactor tests for RST support

Author: rlaboiss

pelican/plugins/graphviz/test_graphviz.py

@@ -1,6 +1,7 @@
 """Unit testing suite for the Graphviz plugin."""
 
 # Copyright (C) 2015, 2021, 2023, 2025  Rafael Laboissière <[email protected]>
+# Copyright (C) 2025  Mark Shroyer <[email protected]>
 #
 # This program is free software: you can redistribute it and/or modify it
 # under the terms of the GNU General Affero Public License as published by
@@ -21,231 +22,209 @@
 from tempfile import mkdtemp
 import unittest
 
+from bs4 import BeautifulSoup, Tag
+
 from pelican import Pelican
 from pelican.settings import read_settings
 
 from . import graphviz
 
 TEST_FILE_STEM = "test"
 TEST_DIR_PREFIX = "pelicantests."
-GRAPHVIZ_RE = (
-    r'<{0} class="{1}"><img alt="{2}" '
-    r'src="data:image/svg\+xml;base64,[0-9a-zA-Z+=]+"></{0}>'
-)
-
-GRAPHVIZ_RE_XML = r'<svg width="\d+pt" height="\d+pt"'
+DIMENSION_ATTR_RE = re.compile(r"\d+pt")
 
 
 class TestGraphviz(unittest.TestCase):
     """Class for testing the URL output of the Graphviz plugin."""
 
     def setUp(
         self,
-        block_start="..graphviz",
-        image_class="graphviz",
-        html_element="div",
-        alt_text="GRAPH",
-        compress=True,
-        options=None,
-        expected_html_element=None,
-        expected_image_class=None,
-        expected_alt_text=None,
-        digraph_id="G",
+        config=None,
+        settings=None,
+        expected=None,
     ):
         """Set up the test environment."""
         # Set the paths for the input (content) and output (html) files
         self.output_path = mkdtemp(prefix=TEST_DIR_PREFIX)
         self.content_path = mkdtemp(prefix=TEST_DIR_PREFIX)
 
-        # Configuration setting for the Pelican process
-        settings = {
+        # Input configuration
+        self.config = {
+            "md_block_start": "..graphviz",
+            "options": None,
+            "digraph_id": "G",
+        }
+        if config is not None:
+            self.config.update(config)
+
+        # Settings for the Pelican process
+        self.settings = {
             "PATH": self.content_path,
             "OUTPUT_PATH": self.output_path,
             "PLUGINS": [graphviz],
             "CACHE_CONTENT": False,
-            "GRAPHVIZ_HTML_ELEMENT": html_element,
-            "GRAPHVIZ_BLOCK_START": block_start,
-            "GRAPHVIZ_IMAGE_CLASS": image_class,
-            "GRAPHVIZ_ALT_TEXT": alt_text,
-            "GRAPHVIZ_COMPRESS": compress,
         }
+        if settings is not None:
+            self.settings.update(settings)
+
+        # Properties of the expected output
+        self.expected = {
+            "compressed": True,
+            "html_element": "div",
+            "image_class": "graphviz",
+            "alt_text": "G",
+        }
+        if expected is not None:
+            self.expected.update(expected)
 
-        # Store the image_class and the html_element in self, since they will
-        # be needed in the test_output method defined below
-        self.image_class = image_class
-        self.html_element = html_element
-        self.alt_text = alt_text
-
-        # Get default expected values
-        if not expected_image_class:
-            self.expected_image_class = self.image_class
-        else:
-            self.expected_image_class = expected_image_class
-        if not expected_html_element:
-            self.expected_html_element = self.html_element
-        else:
-            self.expected_html_element = expected_html_element
-        if not expected_alt_text:
-            self.expected_alt_text = digraph_id if digraph_id else alt_text
-        else:
-            self.expected_alt_text = expected_alt_text
+    def test_md(self):
+        options_string = ""
+        if self.config["options"]:
+            kvs = ",".join(f'{k}="{v}"' for k, v in self.config["options"].items())
+            options_string = f"[{kvs}]"
 
         # Create the article file
         with open(os.path.join(self.content_path, f"{TEST_FILE_STEM}.md"), "w") as fid:
             # Write header
             fid.write(f"Title: {TEST_FILE_STEM}\nDate: 1970-01-01\n")
             # Write Graphviz block
-            fid.write(
-                f"""
-{block_start}{f" [{options}] " if options else " "}dot
-digraph {digraph_id if digraph_id else ""} {{
+            fid.write(f"""
+{self.config["md_block_start"]} {options_string} dot
+digraph{f" {self.config['digraph_id']}" if self.config["digraph_id"] else ""} {{
   graph [rankdir = LR];
   Hello -> World
 }}
-"""
-            )
+""")
 
-        # Run the Pelican instance
-        self.settings = read_settings(override=settings)
-        pelican = Pelican(settings=self.settings)
-        pelican.run()
+        self.run_pelican()
+        self.assert_expected_output()
 
-    def tearDown(self):
-        """Tidy up the test environment."""
-        rmtree(self.output_path)
-        rmtree(self.content_path)
+    def run_pelican(self):
+        settings = read_settings(override=self.settings)
+        pelican = Pelican(settings=settings)
+        pelican.run()
 
-    def test_output(self):
+    def assert_expected_output(self):
         """Test for default values of the configuration variables."""
         # Open the output HTML file
         with open(os.path.join(self.output_path, f"{TEST_FILE_STEM}.html")) as fid:
+            # Keep content as a string so we can see full content in output
+            # from failed asserts.
             content = fid.read()
-            found = False
-            # Iterate over the lines and look for the HTML element corresponding
-            # to the generated Graphviz figure
-            for line in content.splitlines():
-                if self.settings["GRAPHVIZ_COMPRESS"]:
-                    if re.search(
-                        GRAPHVIZ_RE.format(
-                            self.expected_html_element,
-                            self.expected_image_class,
-                            self.expected_alt_text,
-                        ),
-                        line,
-                    ):
-                        found = True
-                        break
-                elif re.search(GRAPHVIZ_RE_XML, line):
-                    found = True
-                    break
-            assert found, content
+            soup = BeautifulSoup(content, "html.parser")
+            if self.expected["compressed"]:
+                elt = soup.find(
+                    self.expected["html_element"], class_=self.expected["image_class"]
+                )
+                assert isinstance(elt, Tag), content
+
+                img = elt.find("img", attrs={"alt": self.expected["alt_text"]})
+                assert img is not None, content
+            else:
+                svg = soup.find("svg")
+                assert isinstance(svg, Tag), content
+
+                for attr in ["width", "height"]:
+                    assert attr in svg.attrs
+                    assert DIMENSION_ATTR_RE.fullmatch(str(svg.attrs[attr]))
+
+    def tearDown(self):
+        """Tidy up the test environment."""
+        rmtree(self.output_path)
+        rmtree(self.content_path)
 
 
 class TestGraphvizHtmlElement(TestGraphviz):
     """Class for exercising the configuration variable GRAPHVIZ_HTML_ELEMENT."""
 
     def setUp(self):
         """Initialize the configuration."""
-        TestGraphviz.setUp(self, html_element="span")
-
-    def test_output(self):
-        """Test for GRAPHVIZ_HTML_ELEMENT setting."""
-        TestGraphviz.test_output(self)
+        value = "span"
+        super().setUp(
+            settings={"GRAPHVIZ_HTML_ELEMENT": value},
+            expected={"html_element": value},
+        )
 
 
 class TestGraphvizBlockStart(TestGraphviz):
     """Class for exercising the configuration variable GRAPHVIZ_BLOCK_START."""
 
     def setUp(self):
         """Initialize the configuration."""
-        TestGraphviz.setUp(self, block_start="==foobar")
-
-    def test_output(self):
-        """Test for GRAPHVIZ_BLOCK_START setting."""
-        TestGraphviz.test_output(self)
+        value = "==foobar"
+        super().setUp(
+            config={"md_block_start": value},
+            settings={"GRAPHVIZ_BLOCK_START": value},
+        )
 
 
 class TestGraphvizImageClass(TestGraphviz):
     """Class for exercising configuration variable GRAPHVIZ_IMAGE_CLASS."""
 
     def setUp(self):
         """Initialize the configuration."""
-        TestGraphviz.setUp(self, image_class="foo")
-
-    def test_output(self):
-        """Test for GRAPHVIZ_IMAGE_CLASS setting."""
-        TestGraphviz.test_output(self)
+        value = "foo"
+        super().setUp(
+            settings={"GRAPHVIZ_IMAGE_CLASS": value}, expected={"image_class": value}
+        )
 
 
 class TestGraphvizImageNoCompress(TestGraphviz):
     """Class for exercising configuration variable GRAPHVIZ_COMPRESS."""
 
     def setUp(self):
         """Initialize the configuration."""
-        TestGraphviz.setUp(self, compress=False)
-
-    def test_output(self):
-        """Test for GRAPHVIZ_COMPRESS setting."""
-        TestGraphviz.test_output(self)
+        value = False
+        super().setUp(
+            settings={"GRAPHVIZ_COMPRESS": value}, expected={"compressed": value}
+        )
 
 
 class TestGraphvizLocallyOverrideConfiguration(TestGraphviz):
     """Class for exercising the override of a configuration variable."""
 
     def setUp(self):
         """Initialize the configuration."""
-        TestGraphviz.setUp(
-            self,
-            html_element="div",
-            options="html-element=span",
-            expected_html_element="span",
+        value = "span"
+        super().setUp(
+            config={"options": {"html-element": value}},
+            expected={"html_element": value},
         )
 
-    def test_output(self):
-        """Test for overrind the configuration."""
-        TestGraphviz.test_output(self)
-
 
 class TestGraphvizAltText(TestGraphviz):
     """Class for exercising configuration variable GRAPHVIZ_ALT_TEXT."""
 
     def setUp(self):
         """Initialize the configuration."""
-        TestGraphviz.setUp(self, alt_text="foo")
-
-    def test_output(self):
-        """Test for GRAPHVIZ_IMAGE_CLASS setting."""
-        TestGraphviz.test_output(self)
+        value = "G"
+        super().setUp(
+            config={"digraph_id": value},
+            settings={"GRAPHVIZ_ALT_TEXT": "foo"},
+            expected={"alt_text": value},
+        )
 
 
 class TestGraphvizAltTextWithoutID(TestGraphviz):
     """Class for testing the case where the Graphviz element has no id."""
 
     def setUp(self):
         """Initialize the configuration."""
-        TestGraphviz.setUp(
-            self,
-            digraph_id=None,
-            alt_text="foo",
+        value = "foo"
+        super().setUp(
+            config={"digraph_id": None},
+            settings={"GRAPHVIZ_ALT_TEXT": value},
+            expected={"alt_text": value},
         )
 
-    def test_output(self):
-        """Test for GRAPHVIZ_IMAGE_CLASS setting."""
-        TestGraphviz.test_output(self)
-
 
 class TestGraphvizAltTextViaOption(TestGraphviz):
     """Class for testing the alternative text given via the alt-text option."""
 
     def setUp(self):
         """Initialize the configuration."""
         text = "A wonderful graph"
-        TestGraphviz.setUp(
-            self,
-            options=f'alt-text="{text}"',
-            expected_alt_text=text,
+        super().setUp(
+            config={"options": {"alt-text": text}},
+            expected={"alt_text": text},
         )
-
-    def test_output(self):
-        """Test for GRAPHVIZ_IMAGE_CLASS setting."""
-        TestGraphviz.test_output(self)

pyproject.toml

@@ -45,6 +45,7 @@ lint = [
     "ruff>=0.9.1,<1.0.0",
 ]
 test = [
+    "beautifulsoup4>=4.13",
     "invoke>=2.2",
     "markdown>=3.4",
     "pytest>=7.0",