Extract version comparisons as pytest parameters.

pkg_resources/tests/test_resources.py

@@ -4,6 +4,7 @@ import os
 import sys
 import string
 import platform
+import itertools
 
 from pkg_resources.extern.six.moves import map
 
@@ -17,6 +18,14 @@ from pkg_resources import (
     WorkingSet)
 
 
+# from Python 3.6 docs.
+def pairwise(iterable):
+    "s -> (s0,s1), (s1,s2), (s2, s3), ..."
+    a, b = itertools.tee(iterable)
+    next(b, None)
+    return zip(a, b)
+
+
 class Metadata(pkg_resources.EmptyProvider):
     """Mock object to return metadata as if from an on-disk distribution"""
 
@@ -650,95 +659,53 @@ class TestParsing:
         req, = parse_requirements('foo>=1.0, <3')
         req, = parse_requirements('foo >= 1.0, < 3')
 
-    def testVersionEquality(self):
-        def c(s1, s2):
-            p1, p2 = parse_version(s1), parse_version(s2)
-            assert p1 == p2, (s1, s2, p1, p2)
-
-        c('1.2-rc1', '1.2rc1')
-        c('0.4', '0.4.0')
-        c('0.4.0.0', '0.4.0')
-        c('0.4.0-0', '0.4-0')
-        c('0post1', '0.0post1')
-        c('0pre1', '0.0c1')
-        c('0.0.0preview1', '0c1')
-        c('0.0c1', '0-rc1')
-        c('1.2a1', '1.2.a.1')
-        c('1.2.a', '1.2a')
-
-    def testVersionOrdering(self):
-        def c(s1, s2):
-            p1, p2 = parse_version(s1), parse_version(s2)
-            assert p1 < p2, (s1, s2, p1, p2)
-
-        c('2.1', '2.1.1')
-        c('2a1', '2b0')
-        c('2a1', '2.1')
-        c('2.3a1', '2.3')
-        c('2.1-1', '2.1-2')
-        c('2.1-1', '2.1.1')
-        c('2.1', '2.1post4')
-        c('2.1a0-20040501', '2.1')
-        c('1.1', '02.1')
-        c('3.2', '3.2.post0')
-        c('3.2post1', '3.2post2')
-        c('0.4', '4.0')
-        c('0.0.4', '0.4.0')
-        c('0post1', '0.4post1')
-        c('2.1.0-rc1', '2.1.0')
-        c('2.1dev', '2.1a0')
-
-        torture = """
+    @pytest.mark.parametrize(
+        ['lower', 'upper'],
+        [
+            ('1.2-rc1', '1.2rc1'),
+            ('0.4', '0.4.0'),
+            ('0.4.0.0', '0.4.0'),
+            ('0.4.0-0', '0.4-0'),
+            ('0post1', '0.0post1'),
+            ('0pre1', '0.0c1'),
+            ('0.0.0preview1', '0c1'),
+            ('0.0c1', '0-rc1'),
+            ('1.2a1', '1.2.a.1'),
+            ('1.2.a', '1.2a'),
+        ],
+    )
+    def testVersionEquality(self, lower, upper):
+        assert parse_version(lower) == parse_version(upper)
+
+    torture = """
         0.80.1-3 0.80.1-2 0.80.1-1 0.79.9999+0.80.0pre4-1
         0.79.9999+0.80.0pre2-3 0.79.9999+0.80.0pre2-2
         0.77.2-1 0.77.1-1 0.77.0-1
-        """.split()
-
-        for p, v1 in enumerate(torture):
-            for v2 in torture[p + 1:]:
-                c(v2, v1)
-
-    def testVersionBuildout(self):
-        """
-        Buildout has a function in it's bootstrap.py that inspected the return
-        value of parse_version. The new parse_version returns a Version class
-        which needs to support this behavior, at least for now.
-        """
-
-        def buildout(parsed_version):
-            _final_parts = '*final-', '*final'
-
-            def _final_version(parsed_version):
-                for part in parsed_version:
-                    if (part[:1] == '*') and (part not in _final_parts):
-                        return False
-                return True
-
-            return _final_version(parsed_version)
-
-        assert buildout(parse_version("1.0"))
-        assert not buildout(parse_version("1.0a1"))
-
-    def testVersionIndexable(self):
         """
-        Some projects were doing things like parse_version("v")[0], so we'll
-        support indexing the same as we support iterating.
-        """
-        assert parse_version("1.0")[0] == "00000001"
 
-    def testVersionTupleSort(self):
-        """
-        Some projects expected to be able to sort tuples against the return
-        value of parse_version. So again we'll add a warning enabled shim to
-        make this possible.
-        """
-        assert parse_version("1.0") < tuple(parse_version("2.0"))
-        assert parse_version("1.0") <= tuple(parse_version("2.0"))
-        assert parse_version("1.0") == tuple(parse_version("1.0"))
-        assert parse_version("3.0") > tuple(parse_version("2.0"))
-        assert parse_version("3.0") >= tuple(parse_version("2.0"))
-        assert parse_version("3.0") != tuple(parse_version("2.0"))
-        assert not (parse_version("3.0") != tuple(parse_version("3.0")))
+    @pytest.mark.parametrize(
+        ['lower', 'upper'],
+        [
+            ('2.1', '2.1.1'),
+            ('2a1', '2b0'),
+            ('2a1', '2.1'),
+            ('2.3a1', '2.3'),
+            ('2.1-1', '2.1-2'),
+            ('2.1-1', '2.1.1'),
+            ('2.1', '2.1post4'),
+            ('2.1a0-20040501', '2.1'),
+            ('1.1', '02.1'),
+            ('3.2', '3.2.post0'),
+            ('3.2post1', '3.2post2'),
+            ('0.4', '4.0'),
+            ('0.0.4', '0.4.0'),
+            ('0post1', '0.4post1'),
+            ('2.1.0-rc1', '2.1.0'),
+            ('2.1dev', '2.1a0'),
+        ] + list(pairwise(reversed(torture.split()))),
+    )
+    def testVersionOrdering(self, lower, upper):
+        assert parse_version(lower) < parse_version(upper)
 
     def testVersionHashable(self):
         """