def test_config_both_old_and_new_config_are_set(repo, version_config,
setuptools_git_versioning):
create_file(
repo,
"setup.py",
textwrap.dedent("""
from coverage.control import Coverage
coverage = Coverage()
coverage.start()
try:
import setuptools
setuptools.setup(
name="mypkg",
setuptools_git_versioning={setuptools_git_versioning},
version_config={version_config},
setup_requires=[
"setuptools>=41",
"wheel",
"setuptools-git-versioning",
]
)
finally:
coverage.stop()
coverage.save()
""").format(version_config=version_config,
setuptools_git_versioning=setuptools_git_versioning),
)
with pytest.raises(subprocess.CalledProcessError):
get_version(repo)
def test_tag_sort_by_tag_date(repo, create_config, message):
sort_by = "taggerdate"
create_config(repo, {"sort_by": sort_by})
commits = {}
tags_to_commit = [
"1.1.10",
"1.1.0",
"1.1.1",
]
for i, tag in enumerate(tags_to_commit):
create_file(repo, commit=False)
dt = datetime.now() - timedelta(days=len(tags_to_commit) - i)
create_commit(repo, "Some commit", dt=dt)
commits[tag] = get_sha(repo)
tags_to_create = [
"1.1.0",
"1.1.1",
"1.1.10",
]
for tag in tags_to_create:
create_tag(repo, tag, message=message, commit=commits[tag])
time.sleep(1)
if message:
# the result is not stable because latest tag (by creation time)
# has nothing in common with commit creation time
assert "1.1.10" in get_version(repo)
else:
assert get_version(repo).startswith("1.1")
def test_tag_sort_by_commit_date(repo, create_config, message):
sort_by = "committerdate"
create_config(repo, {"sort_by": sort_by})
commits = {}
tags_to_commit = [
"1.1.10",
"1.1.0",
"1.1.1",
]
for i, tag in enumerate(tags_to_commit):
create_file(repo, commit=False)
dt = datetime.now() - timedelta(days=len(tags_to_commit) - i)
create_commit(repo, "Some commit", dt=dt)
commits[tag] = get_sha(repo)
time.sleep(1)
tags_to_create = [
"1.1.0",
"1.1.1",
"1.1.10",
]
for tag in tags_to_create:
create_tag(repo, tag, message=message, commit=commits[tag])
if not message:
assert get_version(repo) == "1.1.1"
else:
assert get_version(repo).startswith("1.1")
def test_version_callback_missing(repo, create_version_py, create_config):
version_callback = "version:wtf"
if create_version_py:
create_file(repo, "version.py", "", commit=False)
create_config(repo, {"version_callback": version_callback})
with pytest.raises(subprocess.CalledProcessError):
get_version(repo)
def test_tag_formatter_regexp_wrong_format(repo, create_config):
create_config(
repo,
{
"tag_formatter": "(",
},
)
create_tag(repo, "1.0.0")
with pytest.raises(subprocess.CalledProcessError):
get_version(repo)
def test_tag_formatter_regexp_no_capture_group(repo, create_config, regexp):
create_config(
repo,
{
"tag_formatter": regexp,
},
)
create_tag(repo, "1.0.0")
with pytest.raises(subprocess.CalledProcessError):
get_version(repo)
def test_tag_formatter_regexp_not_match(repo, create_config):
create_config(
repo,
{
"tag_formatter": r".*?(?P<tag>[\d.]+).*",
},
)
create_tag(repo, "unknown")
with pytest.raises(subprocess.CalledProcessError):
get_version(repo)
def test_version_callback(repo, version_callback, create_config):
create_file(repo, "version.py", VERSION_PY.format(version="1.0.0"), commit=False)
create_config(repo, {"version_callback": version_callback})
assert get_version(repo) == "1.0.0"
create_file(repo)
assert get_version(repo) == "1.0.0"
create_file(repo)
assert get_version(repo) == "1.0.0"
def test_branch_formatter_regexp_no_capture_group(repo, template_config,
create_config, regexp):
template_config(
repo,
create_config,
config={
"branch_formatter": regexp,
},
)
with pytest.raises(subprocess.CalledProcessError):
get_version(repo)
def test_branch_formatter_regexp_wrong_format(repo, template_config,
create_config):
template_config(
repo,
create_config,
config={
"branch_formatter": "(",
},
)
with pytest.raises(subprocess.CalledProcessError):
get_version(repo)
def test_branch_formatter_regexp_not_match(repo, template_config,
create_config):
checkout_branch(repo, "unknown")
template_config(
repo,
create_config,
template="{tag}{branch}{ccount}",
config={
"branch_formatter": r".*?(?P<branch>[\d]+).*",
},
)
with pytest.raises(subprocess.CalledProcessError):
get_version(repo)
def test_tag_linear_history(repo, create_config):
create_tag(repo, "1.0.0")
checkout_branch(repo, "dev")
create_config(repo)
sha = get_sha(repo)
assert get_version(repo) == "1.0.0.post1+git.{sha}".format(sha=sha)
def test_config_setup_py_is_used_then_pyproject_toml_is_empty(repo):
create_pyproject_toml(repo, NotImplemented, add=False, commit=False)
create_setup_py(repo, {"starting_version": "2.3.4"},
add=False,
commit=False)
assert get_version(repo) == "2.3.4"
def test_tag_sort_by_version(repo, create_config, message):
sort_by = "version:refname"
create_config(repo, {"sort_by": sort_by})
commits = {}
tags_to_commit = [
"1.1.0",
"1.1.10",
"1.1.1",
]
for i, tag in enumerate(tags_to_commit):
create_file(repo, commit=False)
dt = datetime.now() - timedelta(days=len(tags_to_commit) - i)
create_commit(repo, "Some commit", dt=dt)
commits[tag] = get_sha(repo)
tags_to_create = [
"1.1.0",
"1.1.10",
"1.1.1",
]
for tag in tags_to_create:
create_tag(repo, tag, message=message, commit=commits[tag])
# the result is not stable because latest tag (by name)
# has nothing in common with commit creation time
# so it could mess everything up: https://github.com/dolfinus/setuptools-git-versioning/issues/22
# that's why this value is not default
assert "1.1.10" in get_version(repo)
def test_tag_no_tag(repo, create_config, starting_version, version):
if starting_version:
create_config(repo, {"starting_version": starting_version})
else:
create_config(repo)
assert get_version(repo) == version
def test_branch_formatter_external(repo, template_config, create_config,
branch, suffix):
checkout_branch(repo, branch)
create_file(
repo,
"util.py",
textwrap.dedent("""
import re
def branch_formatter(branch):
return re.sub("[^\\d]+", "", branch)
"""),
)
template_config(
repo,
create_config,
template="{tag}{branch}{ccount}",
config={
"branch_formatter": "util:branch_formatter",
},
)
assert get_version(repo) == "1.2.3{suffix}0".format(suffix=suffix)
def test_tag_formatter_no_tag(repo, create_config):
create_config(
repo,
{
"tag_formatter": "(",
},
)
assert get_version(repo) == "0.0.1"
def test_tag_formatter_regexp(repo, create_config, tag, version):
create_config(
repo,
{
"tag_formatter": r".*?(?P<tag>[\d.]+).*",
},
)
create_tag(repo, tag)
assert get_version(repo) == version
def test_config_not_used(repo):
create_file(
repo,
"setup.py",
textwrap.dedent("""
from coverage.control import Coverage
coverage = Coverage()
coverage.start()
try:
import setuptools
setuptools.setup(
name="mypkg",
)
finally:
coverage.stop()
coverage.save()
"""),
)
assert get_version_setup_py(repo) == "0.0.0"
cfg = {
"build-system": {
"requires": [
"setuptools>=41",
"wheel",
"coverage",
],
"build-backend": "setuptools.build_meta",
}
}
create_file(
repo,
"pyproject.toml",
toml.dumps(cfg),
)
assert get_version(repo, isolated=False) == "0.0.0"
assert get_version(repo, isolated=True) == "0.0.0"
def test_tag(repo, create_config, template, subst):
if template:
create_config(repo, {"template": template})
else:
create_config(repo)
create_tag(repo, "1.0.0")
full_sha = get_full_sha(repo)
sha = get_sha(repo)
assert get_version(repo) == subst.format(sha=sha, full_sha=full_sha)
def test_version_callback_not_a_repo(repo_dir, create_config):
version = "1.0.0"
create_file(repo_dir, "version.py", VERSION_PY.format(version=version), add=False, commit=False)
create_config(
repo_dir,
{"version_callback": "version:get_version"},
add=False,
commit=False,
)
assert get_version(repo_dir) == version
def test_tag_formatter_external_not_callable(repo, create_config):
create_file(
repo,
"util.py",
textwrap.dedent(r"""
import re
tag_formatter = re.compile(r"[^\d.]+")
"""),
)
create_config(
repo,
{
"tag_formatter": "util:tag_formatter",
},
)
create_tag(repo, "1.0.0")
with pytest.raises(subprocess.CalledProcessError):
get_version(repo)
def test_version_file_drop_leading_v(repo, create_config, version, real_version):
create_config(
repo,
{
"version_file": "VERSION.txt",
"dev_template": "{tag}",
"count_commits_from_version_file": True,
},
)
create_file(repo, "VERSION.txt", version)
assert get_version(repo) == real_version
def test_tag_dirty(repo, create_config, add, template, subst):
if template:
create_config(repo, {"dirty_template": template})
else:
create_config(repo)
create_tag(repo, "1.0.0")
create_file(repo, add=add, commit=False)
full_sha = get_full_sha(repo)
sha = get_sha(repo)
assert get_version(repo) == subst.format(sha=sha, full_sha=full_sha)
def test_tag_sort_by_create_date(repo, create_config, message, sort_by):
if sort_by:
create_config(repo, {"sort_by": sort_by})
else:
create_config(repo)
commits = {}
tags_to_commit = [
"1.1.0",
"1.1.10",
"1.1.1",
]
for i, tag in enumerate(tags_to_commit):
create_file(repo, commit=False)
dt = datetime.now() - timedelta(days=len(tags_to_commit) - i)
create_commit(repo, "Some commit", dt=dt)
commits[tag] = get_sha(repo)
time.sleep(1)
tags_to_create = [
"1.1.10",
"1.1.1",
"1.1.0",
]
for tag in tags_to_create:
create_tag(repo, tag, message=message, commit=commits[tag])
time.sleep(1)
if message:
# the result is not stable because latest tag (by creation time)
# has nothing in common with commit creation time
# so it is not recommended to create annotated tags in the past
assert "1.1.0" in get_version(repo)
else:
# but at least creatordate field is present in both tag types
# https://stackoverflow.com/questions/67206124
# so this is a default value
assert get_version(repo) == "1.1.1"
def test_version_file(repo, create_config, template):
config = {
"version_file": "VERSION.txt",
}
if template:
# template is ignored
config["dev_template"] = template
create_config(repo, config)
create_file(repo, "VERSION.txt", "1.0.0")
assert get_version(repo) == "1.0.0"
create_file(repo)
assert get_version(repo) == "1.0.0"
create_file(repo, add=True, commit=False)
assert get_version(repo) == "1.0.0"
create_commit(repo, "add file")
create_file(repo, add=False)
assert get_version(repo) == "1.0.0"
def test_version_file_count_commits(repo, create_config, template, subst):
config = {
"version_file": "VERSION.txt",
"count_commits_from_version_file": True,
}
if template:
# template is not ignored
config["dev_template"] = template
create_config(repo, config)
create_file(repo, "VERSION.txt", "1.0.0")
full_sha = get_full_sha(repo)
sha = get_sha(repo)
assert get_version(repo) == subst.format(sha=sha, full_sha=full_sha, ccount=0)
create_file(repo)
full_sha = get_full_sha(repo)
sha = get_sha(repo)
assert get_version(repo) == subst.format(sha=sha, full_sha=full_sha, ccount=1)
def test_version_file_missing(repo, create_config, create_version, starting_version, version):
config = {
"version_file": "VERSION.txt",
"count_commits_from_version_file": True,
}
if starting_version:
config["starting_version"] = starting_version
if create_version:
create_file(repo, "VERSION.txt", "")
create_config(repo, config)
assert get_version(repo) == version
def test_branch_formatter_external_not_callable(repo, template_config,
create_config):
create_file(
repo,
"util.py",
textwrap.dedent("""
import re
branch_formatter = re.compile("[^\\d]+")
"""),
)
template_config(
repo,
create_config,
config={
"branch_formatter": "util:branch_formatter",
},
)
with pytest.raises(subprocess.CalledProcessError):
get_version(repo)
def test_tag_non_linear_history(repo, create_config):
checkout_branch(repo, "dev")
create_file(repo, commit=False)
create_config(repo)
checkout_branch(repo, "master", new=False)
create_file(repo, commit=False)
create_config(repo)
create_tag(repo, "1.0.0")
checkout_branch(repo, "dev", new=False)
create_file(repo)
assert get_version(repo) == "0.0.1"
