1# Copyright (c) Twisted Matrix Laboratories. 2# See LICENSE for details. 3 4""" 5Tests for L{twisted.python.versions}. 6""" 7 8 9import operator 10 11from incremental import _inf 12 13from twisted.python.versions import IncomparableVersions, Version, getVersionString 14from twisted.trial.unittest import SynchronousTestCase as TestCase 15 16 17class VersionsTests(TestCase): 18 def test_versionComparison(self): 19 """ 20 Versions can be compared for equality and order. 21 """ 22 va = Version("dummy", 1, 0, 0) 23 vb = Version("dummy", 0, 1, 0) 24 self.assertTrue(va > vb) 25 self.assertTrue(vb < va) 26 self.assertTrue(va >= vb) 27 self.assertTrue(vb <= va) 28 self.assertTrue(va != vb) 29 self.assertTrue(vb == Version("dummy", 0, 1, 0)) 30 self.assertTrue(vb == vb) 31 32 def test_versionComparisonCaseInsensitive(self): 33 """ 34 Version packages are compared case insensitively. 35 """ 36 va = Version("twisted", 1, 0, 0) 37 vb = Version("Twisted", 0, 1, 0) 38 self.assertTrue(va > vb) 39 self.assertTrue(vb < va) 40 self.assertTrue(va >= vb) 41 self.assertTrue(vb <= va) 42 self.assertTrue(va != vb) 43 self.assertTrue(vb == Version("twisted", 0, 1, 0)) 44 self.assertTrue(vb == Version("TWISted", 0, 1, 0)) 45 self.assertTrue(vb == vb) 46 47 def test_comparingPrereleasesWithReleases(self): 48 """ 49 Prereleases are always less than versions without prereleases. 50 """ 51 va = Version("whatever", 1, 0, 0, prerelease=1) 52 vb = Version("whatever", 1, 0, 0) 53 self.assertTrue(va < vb) 54 self.assertFalse(va > vb) 55 self.assertNotEqual(vb, va) 56 57 def test_comparingPrereleases(self): 58 """ 59 The value specified as the prerelease is used in version comparisons. 60 """ 61 va = Version("whatever", 1, 0, 0, prerelease=1) 62 vb = Version("whatever", 1, 0, 0, prerelease=2) 63 self.assertTrue(va < vb) 64 self.assertTrue(vb > va) 65 self.assertTrue(va <= vb) 66 self.assertTrue(vb >= va) 67 self.assertTrue(va != vb) 68 self.assertTrue(vb == Version("whatever", 1, 0, 0, prerelease=2)) 69 self.assertTrue(va == va) 70 71 def test_infComparison(self): 72 """ 73 L{_inf} is equal to L{_inf}. 74 75 This is a regression test. 76 """ 77 self.assertEqual(_inf, _inf) 78 79 def test_disallowBuggyComparisons(self): 80 """ 81 The package names of the Version objects need to be the same, 82 """ 83 self.assertRaises( 84 IncomparableVersions, 85 operator.eq, 86 Version("dummy", 1, 0, 0), 87 Version("dumym", 1, 0, 0), 88 ) 89 90 def test_notImplementedComparisons(self): 91 """ 92 Comparing a L{Version} to some other object type results in 93 C{NotImplemented}. 94 """ 95 va = Version("dummy", 1, 0, 0) 96 vb = ("dummy", 1, 0, 0) # a tuple is not a Version object 97 self.assertEqual(va.__cmp__(vb), NotImplemented) # type: ignore[operator] 98 99 def test_repr(self): 100 """ 101 Calling C{repr} on a version returns a human-readable string 102 representation of the version. 103 """ 104 self.assertEqual(repr(Version("dummy", 1, 2, 3)), "Version('dummy', 1, 2, 3)") 105 106 def test_reprWithPrerelease(self): 107 """ 108 Calling C{repr} on a version with a prerelease returns a human-readable 109 string representation of the version including the prerelease. 110 """ 111 self.assertEqual( 112 repr(Version("dummy", 1, 2, 3, prerelease=4)), 113 "Version('dummy', 1, 2, 3, release_candidate=4)", 114 ) 115 116 def test_str(self): 117 """ 118 Calling C{str} on a version returns a human-readable string 119 representation of the version. 120 """ 121 self.assertEqual(str(Version("dummy", 1, 2, 3)), "[dummy, version 1.2.3]") 122 123 def test_strWithPrerelease(self): 124 """ 125 Calling C{str} on a version with a prerelease includes the prerelease. 126 """ 127 self.assertEqual( 128 str(Version("dummy", 1, 0, 0, prerelease=1)), "[dummy, version 1.0.0.rc1]" 129 ) 130 131 def testShort(self): 132 self.assertEqual(Version("dummy", 1, 2, 3).short(), "1.2.3") 133 134 def test_getVersionString(self): 135 """ 136 L{getVersionString} returns a string with the package name and the 137 short version number. 138 """ 139 self.assertEqual("Twisted 8.0.0", getVersionString(Version("Twisted", 8, 0, 0))) 140 141 def test_getVersionStringWithPrerelease(self): 142 """ 143 L{getVersionString} includes the prerelease, if any. 144 """ 145 self.assertEqual( 146 getVersionString(Version("whatever", 8, 0, 0, prerelease=1)), 147 "whatever 8.0.0.rc1", 148 ) 149 150 def test_base(self): 151 """ 152 The L{base} method returns a very simple representation of the version. 153 """ 154 self.assertEqual(Version("foo", 1, 0, 0).base(), "1.0.0") 155 156 def test_baseWithPrerelease(self): 157 """ 158 The base version includes 'preX' for versions with prereleases. 159 """ 160 self.assertEqual(Version("foo", 1, 0, 0, prerelease=8).base(), "1.0.0.rc8") 161