import datetime as dt import os import re from contextlib import contextmanager from pathlib import Path from typing import Callable, Iterator, Optional try: import importlib.metadata as ilm except ImportError: import importlib_metadata as ilm # type: ignore import pytest from dunamai import ( bump_version, check_version, get_version, Version, serialize_pep440, serialize_pvp, serialize_semver, Pattern, Style, Vcs, _run_cmd, VERSION_SOURCE_PATTERN, ) @contextmanager def chdir(where: Path) -> Iterator[None]: start = Path.cwd() os.chdir(str(where)) try: yield finally: os.chdir(str(start)) def make_run_callback(where: Path) -> Callable: def inner(command, expected_code: int = 0): _, out = _run_cmd(command, where=where, codes=[expected_code]) return out return inner def make_from_callback(function: Callable, mock_commit: Optional[str] = "abc") -> Callable: def inner(*args, **kwargs): version = function(*args, **kwargs) if version.commit and mock_commit: version.commit = mock_commit return version return inner from_any_vcs = make_from_callback(Version.from_any_vcs) from_any_vcs_unmocked = make_from_callback(Version.from_any_vcs, mock_commit=None) from_explicit_vcs = make_from_callback(Version.from_vcs) def test__pattern__regex() -> None: assert Pattern.Default.regex() == VERSION_SOURCE_PATTERN assert Pattern.DefaultUnprefixed.regex() == VERSION_SOURCE_PATTERN.replace("^v", "^v?", 1) assert Pattern.Default.regex("foo-") == VERSION_SOURCE_PATTERN.replace("^", "^foo-", 1) def test__pattern__parse() -> None: assert Pattern.parse(r"(?P\d+)") == r"(?P\d+)" assert Pattern.parse(r"(?P\d+)", "foo-") == r"(?P\d+)" assert Pattern.parse(r"^(?P\d+)", "foo-") == r"^foo-(?P\d+)" assert Pattern.parse("default") == Pattern.Default.regex() assert Pattern.parse("default-unprefixed") == Pattern.DefaultUnprefixed.regex() assert Pattern.parse("default", "foo-") == Pattern.Default.regex("foo-") with pytest.raises(ValueError): Pattern.parse(r"foo") def test__version__init() -> None: v = Version("1", stage=("a", 2), distance=3, commit="abc", dirty=True, tagged_metadata="def", epoch=4) assert v.base == "1" assert v.stage == "a" assert v.revision == 2 assert v.distance == 3 assert v.commit == "abc" assert v.dirty assert v.tagged_metadata == "def" assert v.epoch == 4 def test__version__str() -> None: v = Version("1", stage=("a", 2), distance=3, commit="abc", dirty=True) assert str(v) == v.serialize() def test__version__repr() -> None: v = Version( "1", stage=("a", 2), distance=3, commit="abc", dirty=True, tagged_metadata="tagged", epoch=4, branch="master", timestamp=dt.datetime(2000, 1, 2, 3, 4, 5).replace(tzinfo=dt.timezone.utc), ) assert repr(v) == ( "Version(base='1', stage='a', revision=2, distance=3, commit='abc'," " dirty=True, tagged_metadata='tagged', epoch=4, branch='master'," " timestamp=datetime.datetime(2000, 1, 2, 3, 4, 5, tzinfo=datetime.timezone.utc))" ) def test__version__ordering() -> None: assert Version("0.1.0", distance=2) == Version("0.1.0", distance=2) assert Version("0.2.0") > Version("0.1.0") assert Version("0.1.0", distance=2) > Version("0.1.0", distance=1) with pytest.raises(TypeError): Version("0.1.0") == "0.1.0" with pytest.raises(TypeError): Version("0.1.0") < "0.2.0" assert Version("0.1.0", commit="a") != Version("0.1.0", commit="b") assert Version("0.1.0", dirty=True) == Version("0.1.0", dirty=True) assert Version("0.1.0", dirty=False) != Version("0.1.0", dirty=True) assert Version("0.1.0") != Version("0.1.0", dirty=True) assert Version("0.1.0") != Version("0.1.0", dirty=False) assert Version("0.2.0") < Version("0.2.1") assert Version("1.1.0") < Version("1.2.0") assert Version("1.0.0", stage=("rc", 1)) < Version("1.0.0") assert Version("1.0.0", stage=("a", 1)) < Version("1.0.0", stage=("b", 1)) assert Version("1.0.0") < Version("1.0.0", stage=("post", 1)) assert Version("1.0.0", epoch=1) < Version("1.0.0", epoch=2) assert Version("1.0.0", stage=("bar", 1)) < Version("1.0.0", stage=("foo", 1)) def test__version__serialize__pep440() -> None: assert Version("0.1.0").serialize() == "0.1.0" assert Version("1", stage=("a", 2), distance=3, commit="abc", dirty=True).serialize() == "1a2.post3.dev0+abc" assert ( Version("1", stage=("a", 2), distance=3, commit="abc", dirty=True).serialize(dirty=True) == "1a2.post3.dev0+abc.dirty" ) assert ( Version("1", stage=("a", 2), distance=3, commit="abc", dirty=True).serialize(metadata=False) == "1a2.post3.dev0" ) assert ( Version("1", stage=("a", 2), distance=3, commit="abc", dirty=True).serialize(metadata=False, dirty=True) == "1a2.post3.dev0" ) assert Version("1", stage=("a", 0), distance=3, commit="abc", dirty=False).serialize() == "1a0.post3.dev0+abc" assert Version("1", stage=("a", 2), distance=0, commit="abc", dirty=False).serialize() == "1a2" assert Version("1", stage=("a", 2), distance=3, commit="000", dirty=False).serialize() == "1a2.post3.dev0+000" assert ( Version("1", stage=("a", 0), distance=3, commit="abc", dirty=False).serialize(commit_prefix="x") == "1a0.post3.dev0+xabc" ) assert Version("1", stage=("a", None)).serialize() == "1a0" assert Version("1", stage=("b", 2)).serialize() == "1b2" assert Version("1", stage=("rc", 2)).serialize() == "1rc2" assert Version("0.1.0").serialize(bump=True) == "0.1.0" assert Version("0.1.0", distance=3).serialize(bump=True) == "0.1.1.dev3" assert Version("1", distance=3).serialize(bump=True) == "2.dev3" assert Version("0.1.0", stage=("a", None), distance=3).serialize(bump=True) == "0.1.0a2.dev3" assert Version("0.1.0", stage=("b", 2), distance=3).serialize(bump=True) == "0.1.0b3.dev3" assert Version("0.1.0", epoch=2).serialize() == "2!0.1.0" assert Version("0.1.0", stage=("post", 1)).serialize() == "0.1.0.post1" assert Version("0.1.0", stage=("post", 1), distance=3).serialize() == "0.1.0.post1.dev3" assert Version("0.1.0", stage=("post", 1), distance=3).serialize(bump=True) == "0.1.0.post2.dev3" assert Version("0.1.0", stage=("dev", 1)).serialize() == "0.1.0.dev1" assert Version("0.1.0", stage=("dev", 1), distance=3).serialize() == "0.1.0.dev4" assert Version("0.1.0", stage=("dev", 1), distance=3).serialize(bump=True) == "0.1.0.dev5" def test__version__serialize__semver() -> None: style = Style.SemVer assert Version("0.1.0").serialize(style=style) == "0.1.0" assert ( Version("0.1.0", stage=("alpha", 2), distance=3, commit="abc", dirty=True).serialize(style=style) == "0.1.0-alpha.2.post.3+abc" ) assert ( Version("0.1.0", stage=("alpha", 2), distance=3, commit="abc", dirty=True).serialize(dirty=True, style=style) == "0.1.0-alpha.2.post.3+abc.dirty" ) assert ( Version("0.1.0", stage=("alpha", 2), distance=3, commit="abc", dirty=True).serialize( metadata=False, style=style ) == "0.1.0-alpha.2.post.3" ) assert ( Version("0.1.0", stage=("alpha", 2), distance=3, commit="abc", dirty=True).serialize( metadata=False, dirty=True, style=style ) == "0.1.0-alpha.2.post.3" ) assert ( Version("0.1.0", stage=("alpha", 0), distance=3, commit="abc", dirty=False).serialize(style=style) == "0.1.0-alpha.0.post.3+abc" ) assert ( Version("0.1.0", stage=("alpha", 2), distance=0, commit="abc", dirty=False).serialize(style=style) == "0.1.0-alpha.2" ) assert ( Version("0.1.0", stage=("alpha", 2), distance=3, commit="000", dirty=False).serialize(style=style) == "0.1.0-alpha.2.post.3+000" ) assert Version("0.1.0", stage=("alpha", None)).serialize(style=style) == "0.1.0-alpha" assert Version("0.1.0", stage=("beta", 2)).serialize(style=style) == "0.1.0-beta.2" assert Version("0.1.0", stage=("rc", 2)).serialize(style=style) == "0.1.0-rc.2" assert Version("0.1.0").serialize(style=style, bump=True) == "0.1.0" assert Version("0.1.0", distance=3).serialize(style=style, bump=True) == "0.1.1-pre.3" assert ( Version("0.1.0", stage=("alpha", None), distance=3).serialize(style=style, bump=True) == "0.1.0-alpha.2.pre.3" ) assert Version("0.1.0", stage=("beta", 2), distance=4).serialize(style=style, bump=True) == "0.1.0-beta.3.pre.4" assert Version("0.1.0", epoch=2).serialize(style=style) == "0.1.0" def test__version__serialize__pvp() -> None: style = Style.Pvp assert Version("0.1.0").serialize(style=style) == "0.1.0" assert ( Version("0.1.0", stage=("alpha", 2), distance=3, commit="abc", dirty=True).serialize(style=style) == "0.1.0-alpha-2-post-3-abc" ) assert ( Version("0.1.0", stage=("alpha", 2), distance=3, commit="abc", dirty=True).serialize(dirty=True, style=style) == "0.1.0-alpha-2-post-3-abc-dirty" ) assert ( Version("0.1.0", stage=("alpha", 2), distance=3, commit="abc", dirty=True).serialize( metadata=False, style=style ) == "0.1.0-alpha-2-post-3" ) assert ( Version("0.1.0", stage=("alpha", 2), distance=3, commit="abc", dirty=True).serialize( metadata=False, dirty=True, style=style ) == "0.1.0-alpha-2-post-3" ) assert ( Version("0.1.0", stage=("alpha", 0), distance=3, commit="abc", dirty=False).serialize(style=style) == "0.1.0-alpha-0-post-3-abc" ) assert ( Version("0.1.0", stage=("alpha", 2), distance=0, commit="abc", dirty=False).serialize(style=style) == "0.1.0-alpha-2" ) assert ( Version("0.1.0", stage=("alpha", 2), distance=3, commit="000", dirty=False).serialize(style=style) == "0.1.0-alpha-2-post-3-000" ) assert Version("0.1.0", stage=("alpha", None)).serialize(style=style) == "0.1.0-alpha" assert Version("0.1.0", stage=("beta", 2)).serialize(style=style) == "0.1.0-beta-2" assert Version("0.1.0", stage=("rc", 2)).serialize(style=style) == "0.1.0-rc-2" assert Version("0.1.0").serialize(style=style, bump=True) == "0.1.0" assert Version("0.1.0", distance=3).serialize(style=style, bump=True) == "0.1.1-pre-3" assert ( Version("0.1.0", stage=("alpha", None), distance=3).serialize(style=style, bump=True) == "0.1.0-alpha-2-pre-3" ) assert Version("0.1.0", stage=("beta", 2), distance=4).serialize(style=style, bump=True) == "0.1.0-beta-3-pre-4" assert Version("0.1.0", epoch=2).serialize(style=style) == "0.1.0" def test__version__serialize__pep440_metadata() -> None: assert Version("0.1.0").serialize() == "0.1.0" assert Version("0.1.0").serialize(metadata=True) == "0.1.0" assert Version("0.1.0").serialize(metadata=False) == "0.1.0" assert Version("0.1.0", stage=("a", 1), commit="abc").serialize() == "0.1.0a1" assert Version("0.1.0", stage=("a", 1), commit="abc").serialize(metadata=True) == "0.1.0a1+abc" assert Version("0.1.0", stage=("a", 1), commit="abc").serialize(metadata=False) == "0.1.0a1" assert Version("0.1.0", distance=1, commit="abc").serialize() == "0.1.0.post1.dev0+abc" assert Version("0.1.0", distance=1, commit="abc").serialize(metadata=True) == "0.1.0.post1.dev0+abc" assert Version("0.1.0", distance=1, commit="abc").serialize(metadata=False) == "0.1.0.post1.dev0" assert ( Version("0.1.0", distance=1, commit="abc", tagged_metadata="def").serialize(tagged_metadata=True) == "0.1.0.post1.dev0+def.abc" ) def test__version__serialize__semver_with_metadata() -> None: style = Style.SemVer assert Version("0.1.0").serialize(style=style) == "0.1.0" assert Version("0.1.0").serialize(metadata=True, style=style) == "0.1.0" assert Version("0.1.0").serialize(metadata=False, style=style) == "0.1.0" assert Version("0.1.0", stage=("a", 1), commit="abc").serialize(style=style) == "0.1.0-a.1" assert Version("0.1.0", stage=("a", 1), commit="abc").serialize(metadata=True, style=style) == "0.1.0-a.1+abc" assert Version("0.1.0", stage=("a", 1), commit="abc").serialize(metadata=False, style=style) == "0.1.0-a.1" assert Version("0.1.0", distance=1, commit="abc").serialize(style=style) == "0.1.0-post.1+abc" assert Version("0.1.0", distance=1, commit="abc").serialize(metadata=True, style=style) == "0.1.0-post.1+abc" assert Version("0.1.0", distance=1, commit="abc").serialize(metadata=False, style=style) == "0.1.0-post.1" assert ( Version("0.1.0", distance=1, commit="abc", tagged_metadata="def").serialize(style=style, tagged_metadata=True) == "0.1.0-post.1+def.abc" ) def test__version__serialize__pvp_with_metadata() -> None: style = Style.Pvp assert Version("0.1.0").serialize(style=style) == "0.1.0" assert Version("0.1.0").serialize(metadata=True, style=style) == "0.1.0" assert Version("0.1.0").serialize(metadata=False, style=style) == "0.1.0" assert Version("0.1.0", stage=("a", 1), commit="abc").serialize(style=style) == "0.1.0-a-1" assert Version("0.1.0", stage=("a", 1), commit="abc").serialize(metadata=True, style=style) == "0.1.0-a-1-abc" assert Version("0.1.0", stage=("a", 1), commit="abc").serialize(metadata=False, style=style) == "0.1.0-a-1" assert Version("0.1.0", distance=1, commit="abc").serialize(style=style) == "0.1.0-post-1-abc" assert Version("0.1.0", distance=1, commit="abc").serialize(metadata=True, style=style) == "0.1.0-post-1-abc" assert Version("0.1.0", distance=1, commit="abc").serialize(metadata=False, style=style) == "0.1.0-post-1" assert ( Version("0.1.0", distance=1, commit="abc", tagged_metadata="def").serialize(style=style, tagged_metadata=True) == "0.1.0-post-1-def-abc" ) def test__version__serialize__pep440_with_dirty() -> None: assert Version("0.1.0", dirty=True).serialize() == "0.1.0" assert Version("0.1.0", dirty=True).serialize(dirty=True) == "0.1.0+dirty" assert Version("0.1.0", dirty=False).serialize() == "0.1.0" assert Version("0.1.0", dirty=False).serialize(dirty=True) == "0.1.0" assert Version("0.1.0", dirty=True).serialize(metadata=True) == "0.1.0" assert Version("0.1.0", dirty=True).serialize(metadata=True, dirty=True) == "0.1.0+dirty" assert Version("0.1.0", dirty=True).serialize(metadata=False) == "0.1.0" assert Version("0.1.0", dirty=True).serialize(metadata=False, dirty=True) == "0.1.0" def test__version__serialize__semver_with_dirty() -> None: style = Style.SemVer assert Version("0.1.0", dirty=True).serialize(style=style) == "0.1.0" assert Version("0.1.0", dirty=True).serialize(dirty=True, style=style) == "0.1.0+dirty" assert Version("0.1.0", dirty=False).serialize(style=style) == "0.1.0" assert Version("0.1.0", dirty=False).serialize(dirty=True, style=style) == "0.1.0" assert Version("0.1.0", dirty=True).serialize(metadata=True, style=style) == "0.1.0" assert Version("0.1.0", dirty=True).serialize(metadata=True, dirty=True, style=style) == "0.1.0+dirty" assert Version("0.1.0", dirty=True).serialize(metadata=False, style=style) == "0.1.0" assert Version("0.1.0", dirty=True).serialize(metadata=False, dirty=True, style=style) == "0.1.0" def test__version__serialize__pvp_with_dirty() -> None: style = Style.Pvp assert Version("0.1.0", dirty=True).serialize(style=style) == "0.1.0" assert Version("0.1.0", dirty=True).serialize(dirty=True, style=style) == "0.1.0-dirty" assert Version("0.1.0", dirty=False).serialize(style=style) == "0.1.0" assert Version("0.1.0", dirty=False).serialize(dirty=True, style=style) == "0.1.0" assert Version("0.1.0", dirty=True).serialize(metadata=True, style=style) == "0.1.0" assert Version("0.1.0", dirty=True).serialize(metadata=True, dirty=True, style=style) == "0.1.0-dirty" assert Version("0.1.0", dirty=True).serialize(metadata=False, style=style) == "0.1.0" assert Version("0.1.0", dirty=True).serialize(metadata=False, dirty=True, style=style) == "0.1.0" def test__version__serialize__format_as_str() -> None: format = "{base},{stage},{revision},{distance},{commit},{dirty},{branch},{branch_escaped},{timestamp},{major},{minor},{patch}" assert Version("0.1.0").serialize(format=format) == "0.1.0,,,0,,clean,,,,0,1,0" assert ( Version( "1", stage=("a", 2), distance=3, commit="abc", dirty=True, branch="a/b", timestamp=dt.datetime(2001, 2, 3, 4, 5, 6, tzinfo=dt.timezone.utc), ).serialize(format=format) == "1,a,2,3,abc,dirty,a/b,ab,20010203040506,1,0,0" ) with pytest.raises(ValueError): Version("0.1.0").serialize(format="v{base}", style=Style.Pep440) assert Version("1", commit="abc").serialize(format="{commit}", commit_prefix="x") == "xabc" assert Version("1", branch="a/b").serialize(format="{branch_escaped}", escape_with=".") == "a.b" def test__version__serialize__format_as_callable() -> None: def format(v: Version) -> str: return "{},{},{}".format(v.base, v.stage, v.revision) assert Version("0.1.0").serialize(format=format) == "0.1.0,None,None" assert Version("1", stage=("a", 2)).serialize(format=format) == "1,a,2" with pytest.raises(ValueError): Version("0.1.0").serialize(format=lambda v: "v{}".format(v.base), style=Style.Pep440) def immutable(v: Version) -> str: v.distance += 100 return v.serialize() version = Version("0.1.0") version.serialize(format=immutable) assert version.distance == 0 def test__version__bump() -> None: assert Version("1.2.3").bump().serialize() == "1.2.4" assert Version("1.2.3").bump(-2).serialize() == "1.3.0" assert Version("1.2.3").bump(0).serialize() == "2.0.0" assert Version("1.2.3", stage=("a", None)).bump().serialize() == "1.2.3a2" assert Version("1.2.3", stage=("a", 4)).bump().serialize() == "1.2.3a5" assert Version("1.2.3", distance=0).bump(smart=False).serialize() == "1.2.4" assert Version("1.2.3", distance=0).bump(smart=True).serialize() == "1.2.3" assert Version("1.2.3", distance=0).serialize(bump=True) == "1.2.3" assert Version("1.2.3", distance=5).bump(smart=False).serialize() == "1.2.4.post5.dev0" assert Version("1.2.3", distance=5).bump(smart=True).serialize() == "1.2.4.dev5" assert Version("1.2.3", distance=5).serialize(bump=True) == "1.2.4.dev5" def test__version__parse(): assert Version.parse("1.2.3") == Version("1.2.3") assert Version.parse("1.2.3a") == Version("1.2.3", stage=("a", None)) assert Version.parse("1.2.3a3") == Version("1.2.3", stage=("a", 3)) assert Version.parse("1.2.3+7") == Version("1.2.3", distance=7) assert Version.parse("1.2.3+d7") == Version("1.2.3", distance=7) assert Version.parse("1.2.3+b6a9020") == Version("1.2.3", commit="b6a9020") assert Version.parse("1.2.3+gb6a9020") == Version("1.2.3", commit="b6a9020") assert Version.parse("1.2.3+dirty") == Version("1.2.3", dirty=True) assert Version.parse("1.2.3+clean") == Version("1.2.3", dirty=False) assert Version.parse("1.2.3a3+7.b6a9020.dirty") == Version( "1.2.3", stage=("a", 3), distance=7, commit="b6a9020", dirty=True ) assert Version.parse("1.2.3a3+7.b6a9020.dirty.linux") == Version( "1.2.3", stage=("a", 3), distance=7, commit="b6a9020", dirty=True, tagged_metadata="linux" ) assert Version.parse("2!1.2.3") == Version("1.2.3", epoch=2) assert Version.parse("2!1.2.3a3+d7.gb6a9020.dirty.linux") == Version( "1.2.3", stage=("a", 3), distance=7, commit="b6a9020", dirty=True, tagged_metadata="linux", epoch=2, ) assert Version.parse("foo") == Version("foo") assert Version.parse("1.2.3.dev5") == Version("1.2.3", distance=5) assert Version.parse("1.2.3.post4") == Version("1.2.3", stage=("post", 4)) assert Version.parse("1.2.3.post4+d6") == Version("1.2.3", stage=("post", 4), distance=6) assert Version.parse("1.2.3.post4.dev5") == Version("1.2.3", distance=4) assert Version.parse("1.2.3.post4.dev5+d6") == Version("1.2.3", distance=10) assert Version.parse("1.2.3.post4.dev5.blah6") == Version("1.2.3.post4.dev5.blah6") def test__get_version__from_name() -> None: assert get_version("dunamai") == Version(ilm.version("dunamai")) def test__get_version__first_choice() -> None: assert get_version("dunamai", first_choice=lambda: Version("1")) == Version("1") def test__get_version__third_choice() -> None: assert get_version("dunamai_nonexistent_test", third_choice=lambda: Version("3")) == Version("3") def test__get_version__fallback() -> None: assert get_version("dunamai_nonexistent_test") == Version("0.0.0") def test__get_version__from_name__ignore() -> None: assert get_version( "dunamai", ignore=[Version(ilm.version("dunamai"))], fallback=Version("2"), ) == Version("2") def test__get_version__first_choice__ignore() -> None: assert get_version( "dunamai_nonexistent_test", first_choice=lambda: Version("1"), ignore=[Version("1")], fallback=Version("2"), ) == Version("2") def test__get_version__first_choice__ignore_with_distance() -> None: assert get_version( "dunamai_nonexistent_test", first_choice=lambda: Version("1", distance=2), ignore=[Version("1")], fallback=Version("2"), ) == Version("2") assert get_version( "dunamai_nonexistent_test", first_choice=lambda: Version("1"), ignore=[Version("1", distance=2)], fallback=Version("2"), ) != Version("2") def test__get_version__first_choice__ignore__with_commit() -> None: assert get_version( "dunamai_nonexistent_test", first_choice=lambda: Version("1", commit="aaaa"), ignore=[Version("1")], fallback=Version("2"), ) == Version("2") def test__get_version__first_choice__ignore__without_commit() -> None: assert get_version( "dunamai_nonexistent_test", first_choice=lambda: Version("1"), ignore=[Version("1", commit="aaaa")], fallback=Version("2"), ) == Version("1") def test__get_version__third_choice__ignore() -> None: assert get_version( "dunamai_nonexistent_test", third_choice=lambda: Version("3"), ignore=[Version("3")], fallback=Version("2"), ) == Version("2") def test__version__from_any_vcs(tmp_path) -> None: with chdir(tmp_path): with pytest.raises(RuntimeError): Version.from_any_vcs() with pytest.raises(RuntimeError): Version.from_vcs(Vcs.Any) def test__check_version__pep440() -> None: check_version("0.1.0") check_version("0.01.0") check_version("2!0.1.0") check_version("23!0.1.0") check_version("0.1.0a1") check_version("0.1.0b1") check_version("0.1.0rc1") with pytest.raises(ValueError): check_version("0.1.0x1") check_version("0.1.0.post0") check_version("0.1.0.dev0") check_version("0.1.0.post0.dev0") with pytest.raises(ValueError): check_version("0.1.0.other0") check_version("0.1.0+abc.dirty") check_version("0.1.0+abc..dirty") with pytest.raises(ValueError): check_version("0.1.0+abc_dirty") with pytest.raises(ValueError): check_version("0.1.0+.abc") with pytest.raises(ValueError): check_version("0.1.0+abc.") check_version("2!0.1.0a1.post0.dev0+abc.dirty") def test__check_version__semver() -> None: style = Style.SemVer check_version("0.1.0", style=style) check_version("0.1.0-alpha.1", style=style) check_version("0.1.0+abc", style=style) check_version("0.1.0+a.b.c", style=style) check_version("0.1.0-alpha.1.beta.2+abc.dirty", style=style) with pytest.raises(ValueError): check_version("1", style=style) with pytest.raises(ValueError): check_version("0.1", style=style) with pytest.raises(ValueError): check_version("0.0.0.1", style=style) # "-" is a valid identifier. Version("0.1.0--").serialize(style=style) Version("0.1.0--.-").serialize(style=style) with pytest.raises(ValueError): check_version("0.1.0+abc_dirty", style=style) # No leading zeroes in numeric segments: with pytest.raises(ValueError): Version("00.0.0").serialize(style=style) with pytest.raises(ValueError): Version("0.01.0").serialize(style=style) with pytest.raises(ValueError): Version("0.1.0-alpha.02").serialize(style=style) # But leading zeroes are fine for non-numeric parts: Version("0.1.0-alpha.02a").serialize(style=style) # Identifiers can't be empty: with pytest.raises(ValueError): Version("0.1.0-.").serialize(style=style) with pytest.raises(ValueError): Version("0.1.0-a.").serialize(style=style) with pytest.raises(ValueError): Version("0.1.0-.a").serialize(style=style) def test__check_version__pvp() -> None: style = Style.Pvp check_version("1", style=style) check_version("0.1", style=style) check_version("0.0.1", style=style) check_version("0.0.0.1", style=style) check_version("0.1.0-alpha-1", style=style) with pytest.raises(ValueError): check_version("0.1.0-a.1", style=style) with pytest.raises(ValueError): check_version("0.1.0-abc_dirty", style=style) def test__default_version_pattern() -> None: def check_re( tag: str, base: Optional[str] = None, stage: Optional[str] = None, revision: Optional[str] = None, tagged_metadata: Optional[str] = None, epoch: Optional[str] = None, ) -> None: result = re.search(VERSION_SOURCE_PATTERN, tag) if result is None: if any(x is not None for x in [base, stage, revision]): raise ValueError("Pattern did not match, {tag}".format(tag=tag)) else: assert result.group("base") == base assert result.group("stage") == stage assert result.group("revision") == revision assert result.group("tagged_metadata") == tagged_metadata assert result.group("epoch") == epoch check_re("v0.1.0", "0.1.0") check_re("av0.1.0") check_re("v0.1.0a", "0.1.0", "a") check_re("v0.1.0a1", "0.1.0", "a", "1") check_re("v0.1.0a1b", None) check_re("v0.1.0-1.a", None) check_re("v0.1.0-alpha.123", "0.1.0", "alpha", "123") check_re("v0.1.0-1.alpha", None) check_re("v0.1.0-alpha.1.post.4", None) check_re("v0.1.0rc.4", "0.1.0", "rc", "4") check_re("v0.1.0-beta", "0.1.0", "beta") check_re("v0.1.0a2", "0.1.0", "a", "2") check_re("v0.1.0-a-2", "0.1.0", "a", "2") check_re("v0.1.0.a.2", "0.1.0", "a", "2") check_re("v0.1.0_a_2", "0.1.0", "a", "2") check_re("v0.1.0rc.4+specifier", "0.1.0", "rc", "4", tagged_metadata="specifier") check_re("v1", "1") check_re("v1b2", "1", "b", "2") check_re("v1!2", "2", epoch="1") def test__serialize_pep440(): assert serialize_pep440("1.2.3") == "1.2.3" assert serialize_pep440("1.2.3", epoch=0) == "0!1.2.3" assert serialize_pep440("1.2.3", stage="a") == "1.2.3a0" assert serialize_pep440("1.2.3", stage="a", revision=4) == "1.2.3a4" assert serialize_pep440("1.2.3", post=4) == "1.2.3.post4" assert serialize_pep440("1.2.3", dev=4) == "1.2.3.dev4" assert serialize_pep440("1.2.3", metadata=[]) == "1.2.3" assert serialize_pep440("1.2.3", metadata=["foo"]) == "1.2.3+foo" assert serialize_pep440("1.2.3", metadata=["foo", "bar"]) == "1.2.3+foo.bar" assert serialize_pep440("1.2.3", metadata=[4]) == "1.2.3+4" assert ( serialize_pep440("1.2.3", epoch=0, stage="a", revision=4, post=5, dev=6, metadata=["foo", "bar"]) == "0!1.2.3a4.post5.dev6+foo.bar" ) assert serialize_pep440("1.2.3", stage="alpha", revision=4) == "1.2.3a4" assert serialize_pep440("1.2.3", stage="ALphA", revision=4) == "1.2.3a4" assert serialize_pep440("1.2.3", stage="beta", revision=4) == "1.2.3b4" assert serialize_pep440("1.2.3", stage="c", revision=4) == "1.2.3rc4" assert serialize_pep440("1.2.3", stage="pre", revision=4) == "1.2.3rc4" assert serialize_pep440("1.2.3", stage="preview", revision=4) == "1.2.3rc4" with pytest.raises(ValueError): serialize_pep440("foo") def test__serialize_semver(): assert serialize_semver("1.2.3") == "1.2.3" assert serialize_semver("1.2.3", pre=["alpha"]) == "1.2.3-alpha" assert serialize_semver("1.2.3", pre=["alpha", 4]) == "1.2.3-alpha.4" assert serialize_semver("1.2.3", metadata=["foo"]) == "1.2.3+foo" assert serialize_semver("1.2.3", metadata=["foo", "bar"]) == "1.2.3+foo.bar" assert serialize_semver("1.2.3", metadata=[4]) == "1.2.3+4" assert serialize_semver("1.2.3", pre=["alpha", 4], metadata=["foo", "bar"]) == "1.2.3-alpha.4+foo.bar" with pytest.raises(ValueError): serialize_semver("foo") def test__serialize_pvp(): assert serialize_pvp("1") == "1" assert serialize_pvp("1.2") == "1.2" assert serialize_pvp("1.2.3") == "1.2.3" assert serialize_pvp("1.2.3.4") == "1.2.3.4" assert serialize_pvp("1.2.3", metadata=["foo"]) == "1.2.3-foo" assert serialize_pvp("1.2.3", metadata=["foo", "bar"]) == "1.2.3-foo-bar" assert serialize_pvp("1.2.3", metadata=[4]) == "1.2.3-4" with pytest.raises(ValueError): serialize_pvp("foo") def test__bump_version(): # default bump=1 assert bump_version("1.2.3") == "1.2.4" assert bump_version("1.2.3", 0) == "2.0.0" assert bump_version("1.2.3", 1) == "1.3.0" assert bump_version("1.2.3", 2) == "1.2.4" assert bump_version("1.2.3", -1) == "1.2.4" assert bump_version("1.2.3", -2) == "1.3.0" assert bump_version("1.2.3", -3) == "2.0.0" # expicit bump increment assert bump_version("1.2.3", increment=3) == "1.2.6" assert bump_version("1.2.3", 0, increment=3) == "4.0.0" assert bump_version("1.2.3", 1, increment=3) == "1.5.0" assert bump_version("1.2.3", 2, increment=3) == "1.2.6" assert bump_version("1.2.3", -1, increment=3) == "1.2.6" assert bump_version("1.2.3", -2, increment=3) == "1.5.0" assert bump_version("1.2.3", -3, increment=3) == "4.0.0" # check if incorrect index raises issues with pytest.raises(IndexError): bump_version("1.2.3", 3) with pytest.raises(IndexError): bump_version("1.2.3", -4) with pytest.raises(ValueError): bump_version("foo", 0)