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_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_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_substitution_env(repo, dev_template, pipeline_id, suffix):
create_setup_py(repo, {"dev_template": dev_template})
create_tag(repo, "1.2.3")
create_file(repo)
env = {"ANOTHER_ENV": "3.4.5"}
if pipeline_id is not None:
env["PIPELINE_ID"] = pipeline_id
assert get_version_setup_py(repo, env=env) == "1.2.3.post{suffix}".format(suffix=suffix)
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_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_dev(repo, create_config, template, subst):
if template:
create_config(repo, {"dev_template": template})
else:
create_config(repo)
create_tag(repo, "1.0.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)
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_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_config_pyproject_toml_is_used_then_setup_py_does_not_exist(repo):
create_pyproject_toml(repo, {"starting_version": "2.3.4"},
add=False,
commit=False)
create_file(
repo,
"setup.cfg",
textwrap.dedent("""
[metadata]
name = mypkg
"""),
)
assert get_version(repo) == "2.3.4"
def test_version_callback_has_more_priority_than_version_file(repo, create_config):
create_file(repo, "VERSION.txt", "1.2.3")
version = "1.0.0"
create_file(repo, "version.py", VERSION_PY.format(version=version), commit=False)
create_config(
repo,
{
"version_file": "VERSION.txt",
"version_callback": "version:get_version",
},
)
assert get_version(repo) == version
def test_version_file_tag_is_preferred(repo, create_config):
create_tag(repo, "1.2.3")
create_file(repo, "VERSION.txt", "1.0.0")
create_config(
repo,
{
"version_file": "VERSION.txt",
"count_commits_from_version_file": True,
},
)
sha = get_sha(repo)
assert get_version(repo) == "1.2.3.post2+git.{sha}".format(sha=sha)
def test_tag_formatter_ignored_if_version_file_set(repo, create_config,
count_commits):
create_config(
repo,
{
"version_file": "VERSION.txt",
"count_commits_from_version_file": count_commits,
"dev_template": "{tag}",
"tag_formatter": "(",
},
)
create_file(repo, "VERSION.txt", "1.0.0")
assert get_version(repo) == "1.0.0"
def repo_dir(tmpdir):
repo_dir = str(tmpdir.mkdir(rand_str()))
# collect coverage data
with open(os.path.join(root, ".coveragerc")) as f:
create_file(repo_dir, ".coveragerc", f.read(), add=False, commit=False)
os.mkdir(os.path.join(repo_dir, "reports"))
yield repo_dir
if os.environ.get("CI", "false").lower() in ["1", "true"]:
# move collect coverage data to reports directory
for root_path, _dirs, files in os.walk(
os.path.join(repo_dir, "reports")):
for file in files:
shutil.move(os.path.join(root_path, file),
os.path.join(root, "reports", file))
def test_version_callback_template_substitutions_are_ignored(
repo,
template,
version_callback,
create_config,
):
version = "1.0.0"
create_file(
repo,
"version.py",
VERSION_PY.format(version=version),
commit=False,
)
create_config(repo, {"version_callback": version_callback, "dev_template": template})
assert get_version(repo) == version
def test_version_file_not_a_repo(repo_dir, create_config, count_commits):
create_file(
repo_dir,
"VERSION.txt",
"1.0.0",
add=False,
commit=False,
)
create_config(
repo_dir,
{
"version_file": "VERSION.txt",
"count_commits_from_version_file": count_commits,
},
add=False,
commit=False,
)
assert get_version(repo_dir) == "1.0.0"
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_formatter_external(repo, create_config, tag, version):
create_file(
repo,
"util.py",
textwrap.dedent(r"""
import re
def tag_formatter(tag):
return re.sub(r"[^\d.]+", "", tag)
"""),
)
create_config(
repo,
{
"tag_formatter": "util:tag_formatter",
},
)
create_tag(repo, tag)
assert get_version(repo) == version
def test_branch_formatter_ignored_if_version_callback_set(
repo, create_config, version_callback):
create_file(
repo,
"version.py",
textwrap.dedent("""
def get_version():
return "1.0.0"
__version__ = "1.0.0"
"""),
)
create_config(
repo,
{
"version_callback": version_callback,
"branch_formatter": "(",
},
)
assert get_version(repo) == "1.0.0"
def repo(repo_dir):
execute(repo_dir, "git init -b master")
execute(repo_dir, "git config --local user.email '*****@*****.**'")
execute(repo_dir, "git config --local user.name 'Tests runner'")
execute(repo_dir, "git add .coveragerc")
create_file(
repo_dir,
".gitignore",
textwrap.dedent("""
.eggs
*.egg
*.egg-info/
build
dist
*.py[oc]
reports/
"""),
)
create_file(repo_dir, "__init__.py", "")
return repo_dir
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_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_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_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_version_callback_setup_py_direct_import(repo, setup_py):
create_file(repo, "version.py", VERSION_PY.format(version="1.0.0"), commit=False)
create_file(
repo,
"setup.py",
setup_py,
)
assert get_version_setup_py(repo) == "1.0.0"
create_file(repo)
assert get_version_setup_py(repo) == "1.0.0"
create_file(repo)
assert get_version_setup_py(repo) == "1.0.0"
def test_tag_formatter_external_missing(repo, create_config, create_util):
if create_util:
create_file(
repo,
"util.py",
textwrap.dedent(r"""
import re
def tag_formatter(tag):
return re.sub(r"[^\d.]+", "", tag)
"""),
)
create_config(
repo,
{
"tag_formatter": "util:wtf",
},
)
create_tag(repo, "1.0.0")
with pytest.raises(subprocess.CalledProcessError):
get_version(repo)
def test_branch_formatter_external_missing(repo, template_config,
create_config, create_util):
if create_util:
create_file(
repo,
"util.py",
textwrap.dedent("""
import re
def branch_formatter(branch):
return re.sub("[^\\d]+", "", branch)
"""),
)
template_config(
repo,
create_config,
config={
"branch_formatter": "util:wtf",
},
)
with pytest.raises(subprocess.CalledProcessError):
get_version(repo)
