def test_using_non_numeric_string_as_major_minor_patch_throws():
with pytest.raises(ValueError):
Version("a")
with pytest.raises(ValueError):
Version(1, "a")
with pytest.raises(ValueError):
Version(1, 2, "a")
def test_should_compare_version_info_objects():
v1 = Version(major=0, minor=10, patch=4)
v2 = Version(major=0, minor=10, patch=4, prerelease="beta.1", build=None)
# use `not` to enforce using comparision operators
assert v1 != v2
assert v1 > v2
assert v1 >= v2
assert not (v1 < v2)
assert not (v1 <= v2)
assert not (v1 == v2)
v3 = Version(major=0, minor=10, patch=4)
assert not (v1 != v3)
assert not (v1 > v3)
assert v1 >= v3
assert not (v1 < v3)
assert v1 <= v3
assert v1 == v3
v4 = Version(major=0, minor=10, patch=5)
assert v1 != v4
assert not (v1 > v4)
assert not (v1 >= v4)
assert v1 < v4
assert v1 <= v4
assert not (v1 == v4)
def test_not_equal(self):
for v in EQUALITY_COMPS:
version1 = Version(v[0])
version2 = Version(v[1])
if v[2] == '!=':
self.assertTrue(version1 != version2, "{} should be equal to {}.".format(version1, version2))
else:
self.assertFalse(version1 != version2, "{} should NOT be equal to {}.".format(version1, version2))
def test_should_be_able_to_use_strings_as_major_minor_patch():
v = Version("1", "2", "3")
assert isinstance(v.major, int)
assert isinstance(v.minor, int)
assert isinstance(v.patch, int)
assert v.prerelease is None
assert v.build is None
assert Version("1", "2", "3") == Version(1, 2, 3)
def test_should_compare_prerelease_and_build_with_numbers():
assert Version(major=1, minor=9, patch=1, prerelease=1, build=1) < Version(
major=1, minor=9, patch=1, prerelease=2, build=1
)
assert Version(1, 9, 1, 1, 1) < Version(1, 9, 1, 2, 1)
assert Version("2") < Version(10)
assert Version("2") < Version("10")
def test_should_compare_version_dictionaries():
v1 = Version(major=0, minor=10, patch=4)
v2 = dict(major=0, minor=10, patch=4, prerelease="beta.1", build=None)
assert v1 != v2
assert v1 > v2
assert v1 >= v2
assert not (v1 < v2)
assert not (v1 <= v2)
assert not (v1 == v2)
v3 = dict(major=0, minor=10, patch=4)
assert not (v1 != v3)
assert not (v1 > v3)
assert v1 >= v3
assert not (v1 < v3)
assert v1 <= v3
assert v1 == v3
v4 = dict(major=0, minor=10, patch=5)
assert v1 != v4
assert not (v1 > v4)
assert not (v1 >= v4)
assert v1 < v4
assert v1 <= v4
assert not (v1 == v4)
def coerce(version: str) -> Tuple[Version, Optional[str]]:
"""
Convert an incomplete version string into a semver-compatible Version
object
* Tries to detect a "basic" version string (``major.minor.patch``).
* If not enough components can be found, missing components are
set to zero to obtain a valid semver version.
:param str version: the version string to convert
:return: a tuple with a :class:`Version` instance (or ``None``
if it's not a version) and the rest of the string which doesn't
belong to a basic version.
:rtype: tuple(:class:`Version` | None, str)
"""
match = BASEVERSION.search(version)
if not match:
return (None, version)
ver = {
key: 0 if value is None else value for key, value in match.groupdict().items()
}
ver = Version(**ver)
rest = match.string[match.end() :] # noqa:E203
return ver, rest
def test_should_compare_version_string(s):
v0 = Version(major=0, minor=4, patch=5, prerelease="pre.2", build="build.4")
v1 = Version(major=3, minor=4, patch=5, prerelease="pre.2", build="build.4")
assert v0 < s
assert v0 <= s
assert v0 != s
assert not v0 == s
assert v1 > s
assert v1 >= s
# Symmetric
assert s > v0
assert s >= v0
assert s < v1
assert s <= v1
assert s != v0
assert not s == v0
def test_should_compare_version_list(lst):
v0 = Version(major=0, minor=4, patch=5, prerelease="pre.2", build="build.4")
v1 = Version(major=3, minor=4, patch=5, prerelease="pre.2", build="build.4")
assert v0 < lst
assert v0 <= lst
assert v0 != lst
assert not v0 == lst
assert v1 > lst
assert v1 >= lst
# Symmetric
assert lst > v0
assert lst >= v0
assert lst < v1
assert lst <= v1
assert lst != v0
assert not lst == v0
def test_should_compare_version_tuples(t):
v0 = Version(major=0, minor=4, patch=5, prerelease="pre.2", build="build.4")
v1 = Version(major=3, minor=4, patch=5, prerelease="pre.2", build="build.4")
assert v0 < t
assert v0 <= t
assert v0 != t
assert not v0 == t
assert v1 > t
assert v1 >= t
# Symmetric
assert t > v0
assert t >= v0
assert t < v1
assert t <= v1
assert t != v0
assert not t == v0
def test_should_not_allow_to_compare_version_with_int():
v1 = Version(major=3, minor=4, patch=5, prerelease="pre.2", build="build.4")
with pytest.raises(TypeError):
v1 > 1
with pytest.raises(TypeError):
1 > v1
with pytest.raises(TypeError):
semver.compare(1)
def test():
"""Global test on all types
"""
v = Version('test.txt', 'actual.txt', 'expected.txt')
expectedFile = Path(v.expectedFile)
if expectedFile.is_file():
with open(v.expectedFile, "r") as ins:
x = 0
for line in ins:
assert line.split()[0] == v.solutionList[x]
x += 1
def test_pessimistic(self):
for requirement, version_list in SATISFIES.items():
for v in version_list:
self.assertTrue(Version(v).satisfies(requirement), "{} should satify {} requirement.".format(v, requirement))
def test_parse_constraint_multi(input):
assert parse_constraint(input) == VersionRange(Version(2, 0, 0),
Version(3, 0, 0),
include_min=False,
include_max=True)
def test_parse_constraint_multi_wilcard(input):
assert parse_constraint(input) == VersionUnion(
VersionRange(Version(2, 7, 0), Version(3, 0, 0), True, False),
VersionRange(Version(3, 2, 0), None, True, False),
)
def test_greater_than(self):
self.assertTrue(Version('1.2.4') > Version('1.2.3'))
self.assertTrue(Version('3.10.7+20141005') > Version('2.0.12+i386'))
self.assertFalse(Version('2.3.4') > Version('3.2.1'))
self.assertFalse(Version('2.10.7+20141005') > Version('3.0.12+i386'))
from semver import Version
from semver import VersionRange
from semver import VersionUnion
from semver import parse_constraint
@pytest.mark.parametrize(
"input,constraint",
[
("*", VersionRange()),
("*.*", VersionRange()),
("v*.*", VersionRange()),
("*.x.*", VersionRange()),
("x.X.x.*", VersionRange()),
# ('!=1.0.0', Constraint('!=', '1.0.0.0')),
(">1.0.0", VersionRange(min=Version(1, 0, 0))),
("<1.2.3", VersionRange(max=Version(1, 2, 3))),
("<=1.2.3", VersionRange(max=Version(1, 2, 3), include_max=True)),
(">=1.2.3", VersionRange(min=Version(1, 2, 3), include_min=True)),
("=1.2.3", Version(1, 2, 3)),
("1.2.3", Version(1, 2, 3)),
("=1.0", Version(1, 0, 0)),
("1.2.3b5", Version(1, 2, 3, pre="b5")),
(">= 1.2.3", VersionRange(min=Version(1, 2, 3), include_min=True)),
(">dev", VersionRange(min=Version(0, 0, pre="dev"))), # Issue 206
],
)
def test_parse_constraint(input, constraint):
assert parse_constraint(input) == constraint
def test_versioninfo_compare_should_raise_when_passed_invalid_value():
with pytest.raises(TypeError):
Version(1, 2, 3).compare(4)
import pytest
from semver import EmptyConstraint
from semver import Version
from semver import VersionRange
from semver.exceptions import ParseVersionError
@pytest.mark.parametrize(
"input,version",
[
("1.0.0", Version(1, 0, 0)),
("1", Version(1, 0, 0)),
("1.0", Version(1, 0, 0)),
("1b1", Version(1, 0, 0, pre="beta1")),
("1.0b1", Version(1, 0, 0, pre="beta1")),
("1.0.0b1", Version(1, 0, 0, pre="beta1")),
("1.0.0-b1", Version(1, 0, 0, pre="beta1")),
("1.0.0-beta.1", Version(1, 0, 0, pre="beta1")),
("1.0.0+1", Version(1, 0, 0, build="1")),
("1.0.0-1", Version(1, 0, 0, build="1")),
("1.0.0.0", Version(1, 0, 0)),
("1.0.0-post", Version(1, 0, 0)),
("1.0.0-post1", Version(1, 0, 0, build="1")),
("0.6c", Version(0, 6, 0, pre="rc0")),
("0.6pre", Version(0, 6, 0, pre="rc0")),
],
)
def test_parse_valid(input, version):
parsed = Version.parse(input)
def test_greater_than_or_equals(self):
self.assertTrue(Version('1.2.3') >= Version('1.2.3'))
self.assertTrue(Version('3.10.7+20141005') >= Version('2.0.12+i386'))
self.assertFalse(Version('1.2.3') >= Version('11.2.3'))
self.assertFalse(Version('2.10.7+20141005') > Version('3.0.12+i386'))
def test_should_be_able_to_use_integers_as_prerelease_build():
v = Version(1, 2, 3, 4, 5)
assert isinstance(v.prerelease, str)
assert isinstance(v.build, str)
assert Version(1, 2, 3, 4, 5) == Version(1, 2, 3, "4", "5")
def test_less_than(self):
self.assertTrue(Version('1.2.3') < Version('1.2.4'))
self.assertTrue(Version('2.0.12+i386') < Version('3.10.7+20141005'))
self.assertFalse(Version('3.2.1') < Version('2.2.4'))
self.assertFalse(Version('3.0.12+i386') < Version('1.10.7+20141005'))
def test_should_not_allow_negative_numbers(ver):
with pytest.raises(ValueError, match=".* is negative. .*"):
Version(**ver)
assert format_version(3, 4, 5, prerelease="rc.1") == "3.4.5-rc.1"
assert format_version(3, 4, 5, build="build.4") == "3.4.5+build.4"
assert format_version(3, 4, 5, "rc.1", "build.4") == "3.4.5-rc.1+build.4"
def test_parse_method_for_version_info():
s_version = "1.2.3-alpha.1.2+build.11.e0f985a"
v = Version.parse(s_version)
assert str(v) == s_version
@pytest.mark.parametrize(
"version, expected",
[
(
Version(major=1, minor=2, patch=3, prerelease=None, build=None),
"Version(major=1, minor=2, patch=3, prerelease=None, build=None)",
),
(
Version(major=1, minor=2, patch=3, prerelease="r.1", build=None),
"Version(major=1, minor=2, patch=3, prerelease='r.1', build=None)",
),
(
Version(major=1, minor=2, patch=3, prerelease="dev.1", build=None),
"Version(major=1, minor=2, patch=3, prerelease='dev.1', build=None)",
),
(
Version(major=1, minor=2, patch=3, prerelease="dev.1", build="b.1"),
"Version(major=1, minor=2, patch=3, prerelease='dev.1', build='b.1')",
),
(
def test_should_compare_prerelease_with_numbers_and_letters():
v1 = Version(major=1, minor=9, patch=1, prerelease="1unms", build=None)
v2 = Version(major=1, minor=9, patch=1, prerelease=None, build="1asd")
assert v1 < v2
assert compare("1.9.1-1unms", "1.9.1+1") == -1
def test_should_not_allow_to_compare_invalid_versionstring(s):
v = Version(major=3, minor=4, patch=5, prerelease="pre.2", build="build.4")
with pytest.raises(ValueError):
v < s
with pytest.raises(ValueError):
s > v
