Current File : //lib/python3/dist-packages/twisted/python/test/test_versions.py
# Copyright (c) Twisted Matrix Laboratories.
# See LICENSE for details.
"""
Tests for L{twisted.python.versions}.
"""
import operator
from incremental import _inf
from twisted.python.versions import IncomparableVersions, Version, getVersionString
from twisted.trial.unittest import SynchronousTestCase as TestCase
class VersionsTests(TestCase):
def test_versionComparison(self) -> None:
"""
Versions can be compared for equality and order.
"""
va = Version("dummy", 1, 0, 0)
vb = Version("dummy", 0, 1, 0)
self.assertTrue(va > vb)
self.assertTrue(vb < va)
self.assertTrue(va >= vb)
self.assertTrue(vb <= va)
self.assertTrue(va != vb)
self.assertTrue(vb == Version("dummy", 0, 1, 0))
self.assertTrue(vb == vb)
def test_versionComparisonCaseInsensitive(self) -> None:
"""
Version packages are compared case insensitively.
"""
va = Version("twisted", 1, 0, 0)
vb = Version("Twisted", 0, 1, 0)
self.assertTrue(va > vb)
self.assertTrue(vb < va)
self.assertTrue(va >= vb)
self.assertTrue(vb <= va)
self.assertTrue(va != vb)
self.assertTrue(vb == Version("twisted", 0, 1, 0))
self.assertTrue(vb == Version("TWISted", 0, 1, 0))
self.assertTrue(vb == vb)
def test_comparingPrereleasesWithReleases(self) -> None:
"""
Prereleases are always less than versions without prereleases.
"""
va = Version("whatever", 1, 0, 0, prerelease=1)
vb = Version("whatever", 1, 0, 0)
self.assertTrue(va < vb)
self.assertFalse(va > vb)
self.assertNotEqual(vb, va)
def test_comparingPrereleases(self) -> None:
"""
The value specified as the prerelease is used in version comparisons.
"""
va = Version("whatever", 1, 0, 0, prerelease=1)
vb = Version("whatever", 1, 0, 0, prerelease=2)
self.assertTrue(va < vb)
self.assertTrue(vb > va)
self.assertTrue(va <= vb)
self.assertTrue(vb >= va)
self.assertTrue(va != vb)
self.assertTrue(vb == Version("whatever", 1, 0, 0, prerelease=2))
self.assertTrue(va == va)
def test_infComparison(self) -> None:
"""
L{_inf} is equal to L{_inf}.
This is a regression test.
"""
self.assertEqual(_inf, _inf)
def test_disallowBuggyComparisons(self) -> None:
"""
The package names of the Version objects need to be the same,
"""
self.assertRaises(
IncomparableVersions,
operator.eq,
Version("dummy", 1, 0, 0),
Version("dumym", 1, 0, 0),
)
def test_notImplementedComparisons(self) -> None:
"""
Comparing a L{Version} to some other object type results in
C{NotImplemented}.
"""
va = Version("dummy", 1, 0, 0)
vb = ("dummy", 1, 0, 0) # a tuple is not a Version object
result = va.__cmp__(vb) # type:ignore[arg-type]
self.assertEqual(result, NotImplemented)
def test_repr(self) -> None:
"""
Calling C{repr} on a version returns a human-readable string
representation of the version.
"""
self.assertEqual(repr(Version("dummy", 1, 2, 3)), "Version('dummy', 1, 2, 3)")
def test_reprWithPrerelease(self) -> None:
"""
Calling C{repr} on a version with a prerelease returns a human-readable
string representation of the version including the prerelease.
"""
self.assertEqual(
repr(Version("dummy", 1, 2, 3, prerelease=4)),
"Version('dummy', 1, 2, 3, release_candidate=4)",
)
def test_str(self) -> None:
"""
Calling C{str} on a version returns a human-readable string
representation of the version.
"""
self.assertEqual(str(Version("dummy", 1, 2, 3)), "[dummy, version 1.2.3]")
def _test_strWithPrerelease(self) -> None:
"""
Calling C{str} on a version with a prerelease includes the prerelease.
"""
self.assertEqual(
str(Version("dummy", 1, 0, 0, prerelease=1)), "[dummy, version 1.0.0.rc1]"
)
def testShort(self) -> None:
self.assertEqual(Version("dummy", 1, 2, 3).short(), "1.2.3")
def test_getVersionString(self) -> None:
"""
L{getVersionString} returns a string with the package name and the
short version number.
"""
self.assertEqual("Twisted 8.0.0", getVersionString(Version("Twisted", 8, 0, 0)))
def _test_getVersionStringWithPrerelease(self) -> None:
"""
L{getVersionString} includes the prerelease, if any.
"""
self.assertEqual(
getVersionString(Version("whatever", 8, 0, 0, prerelease=1)),
"whatever 8.0.0.rc1",
)
def test_base(self) -> None:
"""
The L{base} method returns a very simple representation of the version.
"""
self.assertEqual(Version("foo", 1, 0, 0).base(), "1.0.0")
def _test_baseWithPrerelease(self) -> None:
"""
The base version includes 'preX' for versions with prereleases.
"""
self.assertEqual(Version("foo", 1, 0, 0, prerelease=8).base(), "1.0.0.rc8")
Mini Shell