Skip tests with pygments version mismatch.

If pygments is installed and the version doesn't match the expected version.
then any relevant tests will fail. To avoid failing tests due to different
output by pygments, those tests will be skipped. The pygments tox env
sets the `PYGMENTS_VERSION environment variable, so that env will always
run those tests against the expected version.

2 files changed, 282 insertions, 261 deletions

diff --git a/tests/test_syntax/extensions/test_code_hilite.py b/tests/test_syntax/extensions/test_code_hilite.py
index 3e36ae5..709aa96 100644
--- a/tests/test_syntax/extensions/test_code_hilite.py
+++ b/tests/test_syntax/extensions/test_code_hilite.py
@@ -21,6 +21,7 @@ License: BSD (see LICENSE.md for details).
 
 from markdown.test_tools import TestCase
 from markdown.extensions.codehilite import CodeHiliteExtension, CodeHilite
+import os
 
 try:
     import pygments  # noqa
@@ -28,10 +29,19 @@ try:
 except ImportError:
     has_pygments = False
 
+# The version required by the tests is the version specified and installed in the 'pygments' tox env.
+# In any environment where the PYGMENTS_VERSION environment variabe is either not defined or doesn't
+# match the version of Pygments installed, all tests which rely in pygments will be skipped.
+required_pygments_version = os.environ.get('PYGMENTS_VERSION', '')
+
 
 class TestCodeHiliteClass(TestCase):
     """ Test the markdown.extensions.codehilite.CodeHilite class. """
 
+    def setUp(self):
+        if has_pygments and pygments.__version__ != required_pygments_version:
+            self.skipTest(f'Pygments=={required_pygments_version} is required')
+
     maxDiff = None
 
     def assertOutputEquals(self, source, expected, **options):
@@ -340,6 +350,10 @@ class TestCodeHiliteClass(TestCase):
 class TestCodeHiliteExtension(TestCase):
     """ Test codehilite extension. """
 
+    def setUp(self):
+        if has_pygments and pygments.__version__ != required_pygments_version:
+            self.skipTest(f'Pygments=={required_pygments_version} is required')
+
     maxDiff = None
 
     def testBasicCodeHilite(self):
diff --git a/tests/test_syntax/extensions/test_fenced_code.py b/tests/test_syntax/extensions/test_fenced_code.py
index a78c18c..ac6ce17 100644
--- a/tests/test_syntax/extensions/test_fenced_code.py
+++ b/tests/test_syntax/extensions/test_fenced_code.py
@@ -23,19 +23,19 @@ from markdown.test_tools import TestCase
 import markdown
 import os
 
+try:
+    import pygments  # noqa
+    has_pygments = True
+except ImportError:
+    has_pygments = False
 
-class TestFencedCode(TestCase):
+# The version required by the tests is the version specified and installed in the 'pygments' tox env.
+# In any environment where the PYGMENTS_VERSION environment variabe is either not defined or doesn't
+# match the version of Pygments installed, all tests which rely in pygments will be skipped.
+required_pygments_version = os.environ.get('PYGMENTS_VERSION', '')
 
-    def setUp(self):
-        # Only set self.has_pygments to True if pygments is installed and the version matches
-        # the version expected by the tests. The version expected by the tests is the version
-        # specified and installed in the 'pygments' tox env. Outside of the tox env, an environment
-        # variable named PYGMENTS_VERSION will need to be defined to force the tests to use pygments.
-        try:
-            import pygments  # noqa
-            self.has_pygments = pygments.__version__ == os.environ.get('PYGMENTS_VERSION', '')
-        except ImportError:
-            self.has_pygments = False
+
+class TestFencedCode(TestCase):
 
     def testBasicFence(self):
         self.assertMarkdownRenders(
@@ -134,8 +134,255 @@ class TestFencedCode(TestCase):
             extensions=['fenced_code']
         )
 
+    def test_fenced_code_in_raw_html(self):
+        self.assertMarkdownRenders(
+            self.dedent(
+                """
+                <details>
+                ```
+                Begone placeholders!
+                ```
+                </details>
+                """
+            ),
+            self.dedent(
+                """
+                <details>
+
+                <pre><code>Begone placeholders!
+                </code></pre>
+
+                </details>
+                """
+            ),
+            extensions=['fenced_code']
+        )
+
+    def testFencedLanguageInAttr(self):
+        self.assertMarkdownRenders(
+            self.dedent(
+                '''
+                ``` {.python}
+                # Some python code
+                ```
+                '''
+            ),
+            self.dedent(
+                '''
+                <pre><code class="language-python"># Some python code
+                </code></pre>
+                '''
+            ),
+            extensions=['fenced_code']
+        )
+
+    def testFencedMultipleClassesInAttr(self):
+        self.assertMarkdownRenders(
+            self.dedent(
+                '''
+                ``` {.python .foo .bar}
+                # Some python code
+                ```
+                '''
+            ),
+            self.dedent(
+                '''
+                <pre class="foo bar"><code class="language-python"># Some python code
+                </code></pre>
+                '''
+            ),
+            extensions=['fenced_code']
+        )
+
+    def testFencedIdInAttr(self):
+        self.assertMarkdownRenders(
+            self.dedent(
+                '''
+                ``` { #foo }
+                # Some python code
+                ```
+                '''
+            ),
+            self.dedent(
+                '''
+                <pre id="foo"><code># Some python code
+                </code></pre>
+                '''
+            ),
+            extensions=['fenced_code']
+        )
+
+    def testFencedIdAndLangInAttr(self):
+        self.assertMarkdownRenders(
+            self.dedent(
+                '''
+                ``` { .python #foo }
+                # Some python code
+                ```
+                '''
+            ),
+            self.dedent(
+                '''
+                <pre id="foo"><code class="language-python"># Some python code
+                </code></pre>
+                '''
+            ),
+            extensions=['fenced_code']
+        )
+
+    def testFencedIdAndLangAndClassInAttr(self):
+        self.assertMarkdownRenders(
+            self.dedent(
+                '''
+                ``` { .python #foo .bar }
+                # Some python code
+                ```
+                '''
+            ),
+            self.dedent(
+                '''
+                <pre id="foo" class="bar"><code class="language-python"># Some python code
+                </code></pre>
+                '''
+            ),
+            extensions=['fenced_code']
+        )
+
+    def testFencedLanguageIdAndPygmentsDisabledInAttrNoCodehilite(self):
+        self.assertMarkdownRenders(
+            self.dedent(
+                '''
+                ``` { .python #foo use_pygments=False }
+                # Some python code
+                ```
+                '''
+            ),
+            self.dedent(
+                '''
+                <pre id="foo"><code class="language-python"># Some python code
+                </code></pre>
+                '''
+            ),
+            extensions=['fenced_code']
+        )
+
+    def testFencedLanguageIdAndPygmentsEnabledInAttrNoCodehilite(self):
+        self.assertMarkdownRenders(
+            self.dedent(
+                '''
+                ``` { .python #foo use_pygments=True }
+                # Some python code
+                ```
+                '''
+            ),
+            self.dedent(
+                '''
+                <pre id="foo"><code class="language-python"># Some python code
+                </code></pre>
+                '''
+            ),
+            extensions=['fenced_code']
+        )
+
+    def testFencedLanguageNoCodehiliteWithAttrList(self):
+        self.assertMarkdownRenders(
+            self.dedent(
+                '''
+                ``` { .python foo=bar }
+                # Some python code
+                ```
+                '''
+            ),
+            self.dedent(
+                '''
+                <pre><code class="language-python" foo="bar"># Some python code
+                </code></pre>
+                '''
+            ),
+            extensions=['fenced_code', 'attr_list']
+        )
+
+    def testFencedLanguagePygmentsDisabledInAttrNoCodehiliteWithAttrList(self):
+        self.assertMarkdownRenders(
+            self.dedent(
+                '''
+                ``` { .python foo=bar use_pygments=False }
+                # Some python code
+                ```
+                '''
+            ),
+            self.dedent(
+                '''
+                <pre><code class="language-python" foo="bar"># Some python code
+                </code></pre>
+                '''
+            ),
+            extensions=['fenced_code', 'attr_list']
+        )
+
+    def testFencedLanguagePygmentsEnabledInAttrNoCodehiliteWithAttrList(self):
+        self.assertMarkdownRenders(
+            self.dedent(
+                '''
+                ``` { .python foo=bar use_pygments=True }
+                # Some python code
+                ```
+                '''
+            ),
+            self.dedent(
+                '''
+                <pre><code class="language-python"># Some python code
+                </code></pre>
+                '''
+            ),
+            extensions=['fenced_code', 'attr_list']
+        )
+
+    def testFencedLanguageNoPrefix(self):
+        self.assertMarkdownRenders(
+            self.dedent(
+                '''
+                ``` python
+                # Some python code
+                ```
+                '''
+            ),
+            self.dedent(
+                '''
+                <pre><code class="python"># Some python code
+                </code></pre>
+                '''
+            ),
+            extensions=[markdown.extensions.fenced_code.FencedCodeExtension(lang_prefix='')]
+        )
+
+    def testFencedLanguageAltPrefix(self):
+        self.assertMarkdownRenders(
+            self.dedent(
+                '''
+                ``` python
+                # Some python code
+                ```
+                '''
+            ),
+            self.dedent(
+                '''
+                <pre><code class="lang-python"># Some python code
+                </code></pre>
+                '''
+            ),
+            extensions=[markdown.extensions.fenced_code.FencedCodeExtension(lang_prefix='lang-')]
+        )
+
+
+class TestFencedCodeWithCodehilite(TestCase):
+
+    def setUp(self):
+        if has_pygments and pygments.__version__ != required_pygments_version:
+            self.skipTest(f'Pygments=={required_pygments_version} is required')
+
     def testFencedCodeWithHighlightLines(self):
-        if self.has_pygments:
+        if has_pygments:
             expected = self.dedent(
                 '''
                 <div class="codehilite"><pre><span></span><code><span class="hll">line 1
@@ -171,7 +418,7 @@ class TestFencedCode(TestCase):
         )
 
     def testFencedLanguageAndHighlightLines(self):
-        if self.has_pygments:
+        if has_pygments:
             expected = (
                 '<div class="codehilite"><pre><span></span><code>'
                 '<span class="hll"><span class="n">line</span> <span class="mi">1</span>\n'
@@ -227,7 +474,7 @@ class TestFencedCode(TestCase):
         )
 
     def testFencedLanguageDoubleEscape(self):
-        if self.has_pygments:
+        if has_pygments:
             expected = (
                 '<div class="codehilite"><pre><span></span><code>'
                 '<span class="p">&lt;</span><span class="nt">span</span>'
@@ -258,7 +505,7 @@ class TestFencedCode(TestCase):
         )
 
     def testFencedAmps(self):
-        if self.has_pygments:
+        if has_pygments:
             expected = self.dedent(
                 '''
                 <div class="codehilite"><pre><span></span><code>&amp;
@@ -293,122 +540,8 @@ class TestFencedCode(TestCase):
             ]
         )
 
-    def test_fenced_code_in_raw_html(self):
-        self.assertMarkdownRenders(
-            self.dedent(
-                """
-                <details>
-                ```
-                Begone placeholders!
-                ```
-                </details>
-                """
-            ),
-            self.dedent(
-                """
-                <details>
-
-                <pre><code>Begone placeholders!
-                </code></pre>
-
-                </details>
-                """
-            ),
-            extensions=['fenced_code']
-        )
-
-    def testFencedLanguageInAttr(self):
-        self.assertMarkdownRenders(
-            self.dedent(
-                '''
-                ``` {.python}
-                # Some python code
-                ```
-                '''
-            ),
-            self.dedent(
-                '''
-                <pre><code class="language-python"># Some python code
-                </code></pre>
-                '''
-            ),
-            extensions=['fenced_code']
-        )
-
-    def testFencedMultipleClassesInAttr(self):
-        self.assertMarkdownRenders(
-            self.dedent(
-                '''
-                ``` {.python .foo .bar}
-                # Some python code
-                ```
-                '''
-            ),
-            self.dedent(
-                '''
-                <pre class="foo bar"><code class="language-python"># Some python code
-                </code></pre>
-                '''
-            ),
-            extensions=['fenced_code']
-        )
-
-    def testFencedIdInAttr(self):
-        self.assertMarkdownRenders(
-            self.dedent(
-                '''
-                ``` { #foo }
-                # Some python code
-                ```
-                '''
-            ),
-            self.dedent(
-                '''
-                <pre id="foo"><code># Some python code
-                </code></pre>
-                '''
-            ),
-            extensions=['fenced_code']
-        )
-
-    def testFencedIdAndLangInAttr(self):
-        self.assertMarkdownRenders(
-            self.dedent(
-                '''
-                ``` { .python #foo }
-                # Some python code
-                ```
-                '''
-            ),
-            self.dedent(
-                '''
-                <pre id="foo"><code class="language-python"># Some python code
-                </code></pre>
-                '''
-            ),
-            extensions=['fenced_code']
-        )
-
-    def testFencedIdAndLangAndClassInAttr(self):
-        self.assertMarkdownRenders(
-            self.dedent(
-                '''
-                ``` { .python #foo .bar }
-                # Some python code
-                ```
-                '''
-            ),
-            self.dedent(
-                '''
-                <pre id="foo" class="bar"><code class="language-python"># Some python code
-                </code></pre>
-                '''
-            ),
-            extensions=['fenced_code']
-        )
-
     def testFencedCodeWithHighlightLinesInAttr(self):
-        if self.has_pygments:
+        if has_pygments:
             expected = self.dedent(
                 '''
                 <div class="codehilite"><pre><span></span><code><span class="hll">line 1
@@ -444,7 +577,7 @@ class TestFencedCode(TestCase):
         )
 
     def testFencedLanguageAndHighlightLinesInAttr(self):
-        if self.has_pygments:
+        if has_pygments:
             expected = (
                 '<div class="codehilite"><pre><span></span><code>'
                 '<span class="hll"><span class="n">line</span> <span class="mi">1</span>\n'
@@ -517,44 +650,8 @@ class TestFencedCode(TestCase):
             extensions=['codehilite', 'fenced_code']
         )
 
-    def testFencedLanguageIdAndPygmentsDisabledInAttrNoCodehilite(self):
-        self.assertMarkdownRenders(
-            self.dedent(
-                '''
-                ``` { .python #foo use_pygments=False }
-                # Some python code
-                ```
-                '''
-            ),
-            self.dedent(
-                '''
-                <pre id="foo"><code class="language-python"># Some python code
-                </code></pre>
-                '''
-            ),
-            extensions=['fenced_code']
-        )
-
-    def testFencedLanguageIdAndPygmentsEnabledInAttrNoCodehilite(self):
-        self.assertMarkdownRenders(
-            self.dedent(
-                '''
-                ``` { .python #foo use_pygments=True }
-                # Some python code
-                ```
-                '''
-            ),
-            self.dedent(
-                '''
-                <pre id="foo"><code class="language-python"># Some python code
-                </code></pre>
-                '''
-            ),
-            extensions=['fenced_code']
-        )
-
     def testFencedLanguageAttrCssclass(self):
-        if self.has_pygments:
+        if has_pygments:
             expected = self.dedent(
                 '''
                 <div class="pygments"><pre><span></span><code><span class="c1"># Some python code</span>
@@ -579,7 +676,7 @@ class TestFencedCode(TestCase):
         )
 
     def testFencedLanguageAttrLinenums(self):
-        if self.has_pygments:
+        if has_pygments:
             expected = (
                 '<table class="codehilitetable"><tr>'
                 '<td class="linenos"><div class="linenodiv"><pre>1</pre></div></td>'
@@ -606,7 +703,7 @@ class TestFencedCode(TestCase):
         )
 
     def testFencedLanguageAttrGuesslang(self):
-        if self.has_pygments:
+        if has_pygments:
             expected = self.dedent(
                 '''
                 <div class="codehilite"><pre><span></span><code># Some python code
@@ -631,7 +728,7 @@ class TestFencedCode(TestCase):
         )
 
     def testFencedLanguageAttrNoclasses(self):
-        if self.has_pygments:
+        if has_pygments:
             expected = (
                 '<div class="codehilite" style="background: #f8f8f8">'
                 '<pre style="line-height: 125%; margin: 0;"><span></span><code>'
@@ -654,93 +751,3 @@ class TestFencedCode(TestCase):
             expected,
             extensions=['codehilite', 'fenced_code']
         )
-
-    def testFencedLanguageNoCodehiliteWithAttrList(self):
-        self.assertMarkdownRenders(
-            self.dedent(
-                '''
-                ``` { .python foo=bar }
-                # Some python code
-                ```
-                '''
-            ),
-            self.dedent(
-                '''
-                <pre><code class="language-python" foo="bar"># Some python code
-                </code></pre>
-                '''
-            ),
-            extensions=['fenced_code', 'attr_list']
-        )
-
-    def testFencedLanguagePygmentsDisabledInAttrNoCodehiliteWithAttrList(self):
-        self.assertMarkdownRenders(
-            self.dedent(
-                '''
-                ``` { .python foo=bar use_pygments=False }
-                # Some python code
-                ```
-                '''
-            ),
-            self.dedent(
-                '''
-                <pre><code class="language-python" foo="bar"># Some python code
-                </code></pre>
-                '''
-            ),
-            extensions=['fenced_code', 'attr_list']
-        )
-
-    def testFencedLanguagePygmentsEnabledInAttrNoCodehiliteWithAttrList(self):
-        self.assertMarkdownRenders(
-            self.dedent(
-                '''
-                ``` { .python foo=bar use_pygments=True }
-                # Some python code
-                ```
-                '''
-            ),
-            self.dedent(
-                '''
-                <pre><code class="language-python"># Some python code
-                </code></pre>
-                '''
-            ),
-            extensions=['fenced_code', 'attr_list']
-        )
-
-    def testFencedLanguageNoPrefix(self):
-        self.assertMarkdownRenders(
-            self.dedent(
-                '''
-                ``` python
-                # Some python code
-                ```
-                '''
-            ),
-            self.dedent(
-                '''
-                <pre><code class="python"># Some python code
-                </code></pre>
-                '''
-            ),
-            extensions=[markdown.extensions.fenced_code.FencedCodeExtension(lang_prefix='')]
-        )
-
-    def testFencedLanguageAltPrefix(self):
-        self.assertMarkdownRenders(
-            self.dedent(
-                '''
-                ``` python
-                # Some python code
-                ```
-                '''
-            ),
-            self.dedent(
-                '''
-                <pre><code class="lang-python"># Some python code
-                </code></pre>
-                '''
-            ),
-            extensions=[markdown.extensions.fenced_code.FencedCodeExtension(lang_prefix='lang-')]
-        )