docutils/test/test__init__.py

   1 #! /usr/bin/env python3
   2 # $Id$
   3 # Authors: Günter Milde <milde@users.sf.net>,
   4 #          David Goodger <goodger@python.org>
   5 # Copyright: This module has been placed in the public domain.
   6
   7 """
   8 Test module for the docutils' __init__.py.
   9 """
  10
  11 from pathlib import Path
  12 import sys
  13 import unittest
  14
  15 if __name__ == '__main__':
  16     # prepend the "docutils root" to the Python library path
  17     # so we import the local `docutils` package.
  18     sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
  19
  20 import docutils
  21 import docutils.utils
  22 from docutils import VersionInfo
  23
  24
  25 class ApplicationErrorTests(unittest.TestCase):
  26
  27     def test_message(self):
  28         err = docutils.ApplicationError('the message')
  29         self.assertEqual('the message', str(err))
  30
  31     def test_non_ASCII_message(self):
  32         err = docutils.ApplicationError('\u0169')
  33         self.assertEqual('\u0169', str(err))
  34
  35
  36 class VersionInfoTests(unittest.TestCase):
  37
  38     def test_VersionInfo(self):
  39         # arguments may use keywords
  40         self.assertEqual(VersionInfo(0, 1, 2, 'beta', 3, False),
  41                          VersionInfo(major=0, minor=1, micro=2,
  42                                      releaselevel='beta', serial=3,
  43                                      release=False))
  44         # check defaults:
  45         self.assertEqual(VersionInfo(),
  46                          VersionInfo(0, 0, 0, releaselevel='final',
  47                                      serial=0, release=True))
  48
  49     def test_VersionInfo_value_check(self):
  50         # releaselevel must be one of ('alpha', 'beta', 'candidate', 'final')
  51         with self.assertRaises(ValueError):
  52             VersionInfo(0, 1, 0, 'gamma')
  53         # releaselevel 'final' must not be used with development versions
  54         with self.assertRaises(ValueError):
  55             VersionInfo(0, 1, releaselevel='final', release=False)
  56         # "serial" must be 0 for final releases'
  57         with self.assertRaises(ValueError):
  58             VersionInfo(0, 1, releaselevel='final', serial=1)
  59
  60     def test__version_info__(self):
  61         """Ensure that the current __version_info__ is valid."""
  62         releaselevels = ('alpha', 'beta', 'candidate', 'final')
  63
  64         self.assertEqual(len(docutils.__version_info__), 6)
  65         self.assertEqual(type(docutils.__version_info__.major), int)
  66         self.assertEqual(type(docutils.__version_info__.minor), int)
  67         self.assertEqual(type(docutils.__version_info__.micro), int)
  68         self.assertTrue(
  69             docutils.__version_info__.releaselevel in releaselevels)
  70         self.assertEqual(type(docutils.__version_info__.serial), int)
  71         self.assertEqual(type(docutils.__version_info__.release), bool)
  72
  73     def test__version__(self):
  74         """Test that __version__ is equivalent to __version_info__."""
  75         self.assertEqual(
  76             docutils.utils.version_identifier(docutils.__version_info__),
  77             docutils.__version__, f'{docutils.__version_info__} differs')
  78
  79     def test_version_info_comparing(self):
  80         """Test comparing of __version_info__ instances."""
  81
  82         # Example development cycle:
  83         devcycle = ('0.1a.dev 0.1a 0.1a1.dev '
  84                     '0.1b.dev 0.1b 0.1b1.dev '
  85                     '0.1rc1.dev 0.1rc1 0.1rc2.dev '
  86                     '0.1 0.1.1b.dev 0.1.1b 0.1.1 '
  87                     '0.2b.dev 0.2b 0.2')
  88         # corresponding version_info values:
  89         versioninfos = [VersionInfo(0, 1, 0, 'alpha', 0, False),
  90                         VersionInfo(0, 1, 0, 'alpha', 0, True),
  91                         VersionInfo(0, 1, 0, 'alpha', 1, False),
  92                         VersionInfo(0, 1, 0, 'beta', 0, False),
  93                         VersionInfo(0, 1, 0, 'beta', 0, True),
  94                         VersionInfo(0, 1, 0, 'beta', 1, False),
  95                         VersionInfo(0, 1, 0, 'candidate', 1, False),
  96                         VersionInfo(0, 1, 0, 'candidate', 1, True),
  97                         VersionInfo(0, 1, 0, 'candidate', 2, False),
  98                         VersionInfo(0, 1, 0, 'final', 0, True),
  99                         VersionInfo(0, 1, 1, 'beta', 0, False),
 100                         VersionInfo(0, 1, 1, 'beta', 0, True),
 101                         VersionInfo(0, 1, 1, 'final', 0, True),
 102                         VersionInfo(0, 2, 0, 'beta', 0, False),
 103                         VersionInfo(0, 2, 0, 'beta', 0, True),
 104                         VersionInfo(0, 2, 0, 'final', 0, True),
 105                         ]
 106         # transform to version strings
 107         versions = [docutils.utils.version_identifier(vinfo)
 108                     for vinfo in versioninfos]
 109
 110         # ensure version infos corresponding to the dev cycle are ascending
 111         self.assertEqual(versions, devcycle.split())
 112         self.assertEqual(versioninfos, sorted(versioninfos))
 113
 114     def test_version_info_tuple_comparing(self):
 115         """Test comparing of __version_info__ instances to tuples."""
 116
 117         # {<version string>: <version info>}
 118         v01b = VersionInfo(0, 1, 0, 'beta', 0, True)
 119         v01 = VersionInfo(0, 1, 0, 'final', 0, True)
 120         v02b_dev = VersionInfo(0, 2, 0, 'beta', 0, False)
 121
 122         # compare to ordinary tuples:
 123         self.assertTrue(v01b < (0, 2))
 124         self.assertTrue((0, 2) > v01b)
 125         self.assertTrue(v01b < (0, 1))
 126         self.assertTrue((0, 1) > v01b)
 127         self.assertTrue(v01 <= (0, 1))
 128         self.assertTrue(v01 >= (0, 1))
 129         self.assertTrue((0, 1) <= v01)
 130         self.assertTrue((0, 1) >= v01)
 131         self.assertTrue(v02b_dev > (0, 1))
 132         self.assertTrue((0, 1) < v02b_dev)
 133         # Test for equality requires complete tuple, because __eg__() is
 134         # not called when comparing a namedtuple subclass to a tuple:
 135         self.assertTrue((0, 1, 0, 'final', 0, True) == v01)
 136         # self.assertTrue((0, 1) == v01) # fails
 137         # self.assertTrue(v01 == (0, 1)) # fails
 138
 139
 140 if __name__ == '__main__':
 141     unittest.main()