VersionInfo fixes

* Raise ValueError for invalid values.

* Provide default values.

* Fix comparison to ordinary tuples.
  (Test for equality still fails, because __eg__() is not called
   when comparing a namedtuple subclass to a tuple!)

git-svn-id: http://svn.code.sf.net/p/docutils/code/trunk@8468 929543f6-e4f2-0310-98a6-ba3bd3dd1d04

1 files changed, 88 insertions, 18 deletions

diff --git a/docutils/test/test__init__.py b/docutils/test/test__init__.py
index c66f97a02..e78d167b8 100644
--- a/docutils/test/test__init__.py
+++ b/docutils/test/test__init__.py
@@ -14,6 +14,7 @@ import sys
 import DocutilsTestSupport              # must be imported before docutils
 import docutils
 import docutils.utils
+from docutils import VersionInfo
 
 
 if sys.version_info >= (3, 0):
@@ -33,32 +34,41 @@ class ApplicationErrorTests(unittest.TestCase):
 
 class VersionInfoTests(unittest.TestCase):
 
+    def test_VersionInfo(self):
+        # arguments may use keywords
+        self.assertEqual(VersionInfo(0, 1, 2, 'beta', 3, False),
+                         VersionInfo(major=0, minor=1, micro=2,
+                                     releaselevel='beta', serial=3, 
+                                     release=False))
+        # check defaults:
+        self.assertEqual(VersionInfo(),
+                         VersionInfo(0, 0, 0, releaselevel='final',
+                                     serial=0, release=True))
+        
+    def test_VersionInfo_value_check(self):
+        # releaselevel must be one of ('alpha', 'beta', 'candidate', 'final')
+        with self.assertRaises(ValueError):
+            VersionInfo(0, 1, 0, 'gamma')
+        # releaselevel 'final' must not be used with development versions
+        with self.assertRaises(ValueError):
+            VersionInfo(0, 1, releaselevel='final', release=False)
+        # "serial" must be 0 for final releases'
+        with self.assertRaises(ValueError):
+            VersionInfo(0, 1, releaselevel='final', serial=1)
+
     def test__version_info__(self):
+        """Ensure that the current __version_info__ is valid."""
+        releaselevels = ('alpha', 'beta', 'candidate', 'final')
+
         self.assertEqual(len(docutils.__version_info__), 6)
         self.assertEqual(type(docutils.__version_info__.major), int)
         self.assertEqual(type(docutils.__version_info__.minor), int)
         self.assertEqual(type(docutils.__version_info__.micro), int)
-        self.assertEqual(type(docutils.__version_info__.releaselevel), str)
-        self.assertEqual(type(docutils.__version_info__.serial), int)
-        self.assertEqual(type(docutils.__version_info__.release), bool)
-
-        releaselevels = ('alpha', 'beta', 'candidate', 'final')
         self.assertTrue(
             docutils.__version_info__.releaselevel in releaselevels)
+        self.assertEqual(type(docutils.__version_info__.serial), int)
+        self.assertEqual(type(docutils.__version_info__.release), bool)
 
-        if (docutils.__version_info__.releaselevel == 'final'):
-            # releaselevel 'final' must not be used with development versions
-            # (leads to wrong version ordering of the related __version__):
-            #
-            #   Within a numeric release (1.0, 2.7.3), the following suffixes
-            #   are permitted and MUST be ordered as shown:
-            #
-            #      .devN, aN, bN, rcN, <no suffix>, .postN
-            #
-            # https://www.python.org/dev/peps/pep-0440/#summary-of-permitted-suffixes-and-relative-ordering
-            self.assertTrue(docutils.__version_info__.release)
-            # pre-release serial number must be 0 for final releases:
-            self.assertEqual(docutils.__version_info__.serial, 0)
 
     def test__version__(self):
         """Test that __version__ is equivalent to __version_info__."""
@@ -66,6 +76,66 @@ class VersionInfoTests(unittest.TestCase):
             docutils.utils.version_identifier(docutils.__version_info__),
             docutils.__version__)
 
+    def test_version_info_comparing(self):
+        """Test comparing of __version_info__ instances."""
+
+        # Example development cycle:
+        devcycle = ('0.1a.dev 0.1a 0.1a1.dev '
+                    '0.1b.dev 0.1b 0.1b1.dev '
+                    '0.1rc1.dev 0.1rc1 0.1rc2.dev '
+                    '0.1 0.1.1b.dev 0.1.1b 0.1.1 '
+                    '0.2b.dev 0.2b 0.2')
+        # corresponding version_info values:
+        versioninfos = [VersionInfo(0, 1, 0, 'alpha', 0, False),
+                        VersionInfo(0, 1, 0, 'alpha', 0, True),
+                        VersionInfo(0, 1, 0, 'alpha', 1, False),
+                        VersionInfo(0, 1, 0, 'beta', 0, False),
+                        VersionInfo(0, 1, 0, 'beta', 0, True),
+                        VersionInfo(0, 1, 0, 'beta', 1, False),
+                        VersionInfo(0, 1, 0, 'candidate', 1, False),
+                        VersionInfo(0, 1, 0, 'candidate', 1, True),
+                        VersionInfo(0, 1, 0, 'candidate', 2, False),
+                        VersionInfo(0, 1, 0, 'final', 0, True),
+                        VersionInfo(0, 1, 1, 'beta', 0, False),
+                        VersionInfo(0, 1, 1, 'beta', 0, True),
+                        VersionInfo(0, 1, 1, 'final', 0, True),
+                        VersionInfo(0, 2, 0, 'beta', 0, False),
+                        VersionInfo(0, 2, 0, 'beta', 0, True),
+                        VersionInfo(0, 2, 0, 'final', 0, True),
+                       ]
+        # transform to version strings
+        versions = [docutils.utils.version_identifier(vinfo)
+                    for vinfo in versioninfos]
+
+        # ensure version infos corresponding to the dev cycle are ascending
+        self.assertEqual(versions, devcycle.split())
+        self.assertEqual(versioninfos, sorted(versioninfos))
+
+    def test_version_info_tuple_comparing(self):
+        """Test comparing of __version_info__ instances to tuples."""
+
+        # {<version string>: <version info>}
+        v01b =      VersionInfo(0, 1, 0, 'beta', 0, True)
+        v01 =       VersionInfo(0, 1, 0, 'final', 0, True)
+        v02b_dev =  VersionInfo(0, 2, 0, 'beta', 0, False)
+
+        # compare to ordinary tuples:
+        self.assertTrue(v01b < (0, 2))
+        self.assertTrue((0, 2) > v01b)
+        self.assertTrue(v01b < (0, 1))
+        self.assertTrue((0, 1) > v01b)
+        self.assertTrue(v01 <= (0, 1))
+        self.assertTrue(v01 >= (0, 1))
+        self.assertTrue((0, 1) <= v01)
+        self.assertTrue((0, 1) >= v01)
+        self.assertTrue(v02b_dev > (0, 1))
+        self.assertTrue((0, 1) < v02b_dev)
+        # Test for equality requires complete tuple, because __eg__() is
+        # not called when comparing a namedtuple subclass to a tuple:
+        self.assertTrue((0, 1, 0, 'final', 0, True) == v01)
+        # self.assertTrue((0, 1) == v01) # fails
+        # self.assertTrue(v01 == (0, 1)) # fails
+
 
 if __name__ == '__main__':
     unittest.main()