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