def test_default_do_not_track_tags(cli, tmpdir, datafiles):
project = str(datafiles)
project_config = load_yaml(os.path.join(project, "project.conf"))
project_config["ref-storage"] = "inline"
generate_project(project, config=project_config)
repofiles = os.path.join(str(tmpdir), "repofiles")
os.makedirs(repofiles, exist_ok=True)
file0 = os.path.join(repofiles, "file0")
with open(file0, "w", encoding="utf-8") as f:
f.write("test\n")
repo = create_repo("git", str(tmpdir))
repo.create(repofiles)
repo.add_tag("tag")
config = repo.source_config()
config["track"] = repo.latest_commit()
# Write out our test target
element = {
"kind": "import",
"sources": [config],
}
generate_element(project, "target.bst", element)
element_path = os.path.join(project, "target.bst")
result = cli.run(project=project, args=["source", "track", "target.bst"])
result.assert_success()
element = load_yaml(element_path)
source = element.get_sequence("sources").mapping_at(0)
assert "tags" not in source
def test_custom_transform_source(cli, datafiles):
project = str(datafiles)
# Set the project_dir alias in project.conf to the path to the tested project
project_config_path = os.path.join(project, "project.conf")
project_config = load_yaml(project_config_path)
aliases = project_config.get_mapping("aliases")
aliases["project_dir"] = "file://{}".format(project)
generate_project(project, project_config)
# Ensure we can track
result = cli.run(project=project, args=["source", "track", "target.bst"])
result.assert_success()
# Ensure we can fetch
result = cli.run(project=project, args=["source", "fetch", "target.bst"])
result.assert_success()
# Ensure we get correct output from foo_transform
cli.run(project=project, args=["build", "target.bst"])
destpath = os.path.join(cli.directory, "checkout")
result = cli.run(
project=project,
args=["artifact", "checkout", "target.bst", "--directory", destpath])
result.assert_success()
# Assert that files from both sources exist, and that they have
# the same content
assert os.path.exists(os.path.join(destpath, "file"))
assert os.path.exists(os.path.join(destpath, "filetransform"))
with open(os.path.join(destpath, "file")) as file1:
with open(os.path.join(destpath, "filetransform")) as file2:
assert file1.read() == file2.read()
def test_track_fetch(cli, tmpdir, datafiles, ref_format, tag, extra_commit):
project = str(datafiles)
# Create the repo from 'repofiles' subdir
repo = create_repo("git", str(tmpdir))
repo.create(os.path.join(project, "repofiles"))
if tag:
repo.add_tag("tag")
if extra_commit:
repo.add_commit()
# Write out our test target
element = {"kind": "import", "sources": [repo.source_config()]}
element["sources"][0]["ref-format"] = ref_format
generate_element(project, "target.bst", element)
element_path = os.path.join(project, "target.bst")
# Track it
result = cli.run(project=project, args=["source", "track", "target.bst"])
result.assert_success()
element = load_yaml(element_path)
new_ref = element.get_sequence("sources").mapping_at(0).get_str("ref")
if ref_format == "git-describe" and tag:
# Check and strip prefix
prefix = "tag-{}-g".format(0 if not extra_commit else 1)
assert new_ref.startswith(prefix)
new_ref = new_ref[len(prefix):]
# 40 chars for SHA-1
assert len(new_ref) == 40
# Fetch it
result = cli.run(project=project, args=["source", "fetch", "target.bst"])
result.assert_success()
def test_git_describe_head_is_tagged(cli, tmpdir, datafiles, ref_storage,
tag_type):
project = str(datafiles)
project_config = load_yaml(os.path.join(project, "project.conf"))
project_config["ref-storage"] = ref_storage
generate_project(project, config=project_config)
repofiles = os.path.join(str(tmpdir), "repofiles")
os.makedirs(repofiles, exist_ok=True)
file0 = os.path.join(repofiles, "file0")
with open(file0, "w", encoding="utf-8") as f:
f.write("test\n")
repo = create_repo("git", str(tmpdir))
def tag(name):
if tag_type == "annotated":
repo.add_annotated_tag(name, name)
else:
repo.add_tag(name)
repo.create(repofiles)
tag("uselesstag")
file1 = os.path.join(str(tmpdir), "file1")
with open(file1, "w", encoding="utf-8") as f:
f.write("test\n")
repo.add_file(file1)
file2 = os.path.join(str(tmpdir), "file2")
with open(file2, "w", encoding="utf-8") as f:
f.write("test\n")
repo.branch("branch2")
repo.add_file(file2)
repo.checkout("master")
file3 = os.path.join(str(tmpdir), "file3")
with open(file3, "w", encoding="utf-8") as f:
f.write("test\n")
repo.add_file(file3)
tagged_ref = repo.merge("branch2")
tag("tag")
config = repo.source_config()
config["track"] = repo.latest_commit()
config["track-tags"] = True
# Write out our test target
element = {
"kind": "import",
"sources": [config],
}
generate_element(project, "target.bst", element)
element_path = os.path.join(project, "target.bst")
if ref_storage == "inline":
result = cli.run(project=project,
args=["source", "track", "target.bst"])
result.assert_success()
else:
result = cli.run(
project=project,
args=["source", "track", "target.bst", "--deps", "all"])
result.assert_success()
if ref_storage == "inline":
element = load_yaml(element_path)
source = element.get_sequence("sources").mapping_at(0)
tags = source.get_sequence("tags")
assert len(tags) == 1
tag = source.get_sequence("tags").mapping_at(0)
assert "tag" in tag
assert "commit" in tag
assert "annotated" in tag
assert tag.get_bool("annotated") == (tag_type == "annotated")
tag_name = tag.get_str("tag")
commit = tag.get_str("commit")
assert (tag_name, commit) == ("tag", repo.rev_parse("tag^{commit}"))
checkout = os.path.join(str(tmpdir), "checkout")
result = cli.run(project=project, args=["build", "target.bst"])
result.assert_success()
result = cli.run(
project=project,
args=["artifact", "checkout", "target.bst", "--directory", checkout])
result.assert_success()
if tag_type == "annotated":
options = []
else:
options = ["--tags"]
describe = subprocess.check_output(["git", "describe", *options],
cwd=checkout,
universal_newlines=True)
assert describe.startswith("tag")
tags = subprocess.check_output(["git", "tag"],
cwd=checkout,
universal_newlines=True)
tags = set(tags.splitlines())
assert tags == set(["tag"])
rev_list = subprocess.check_output(["git", "rev-list", "--all"],
cwd=checkout,
universal_newlines=True)
assert set(rev_list.splitlines()) == set([tagged_ref])
with pytest.raises(subprocess.CalledProcessError):
subprocess.run(
["git", "log", repo.rev_parse("uselesstag")],
cwd=checkout,
check=True)
def test_overwrite_rogue_tag_multiple_remotes(cli, tmpdir, datafiles):
"""When using multiple remotes in cache (i.e. when using aliases), we
need to make sure we override tags. This is not allowed to fetch
tags that were present from different origins
"""
project = str(datafiles)
repofiles = os.path.join(str(tmpdir), "repofiles")
os.makedirs(repofiles, exist_ok=True)
file0 = os.path.join(repofiles, "file0")
with open(file0, "w", encoding="utf-8") as f:
f.write("test\n")
repo = create_repo("git", str(tmpdir))
top_commit = repo.create(repofiles)
repodir, reponame = os.path.split(repo.repo)
project_config = load_yaml(os.path.join(project, "project.conf"))
project_config["aliases"] = Node.from_dict({"repo": "http://example.com/"})
project_config["mirrors"] = [{
"name": "middle-earth",
"aliases": {
"repo": ["file://{}/".format(repodir)]
}
}]
generate_project(project, config=project_config)
repo.add_annotated_tag("tag", "tag")
file1 = os.path.join(repofiles, "file1")
with open(file1, "w", encoding="utf-8") as f:
f.write("test\n")
ref = repo.add_file(file1)
config = repo.source_config(ref=ref)
del config["track"]
config["url"] = "repo:{}".format(reponame)
# Write out our test target
element = {
"kind": "import",
"sources": [config],
}
generate_element(project, "target.bst", element)
result = cli.run(project=project, args=["build", "target.bst"])
result.assert_success()
repo.checkout(top_commit)
file2 = os.path.join(repofiles, "file2")
with open(file2, "w", encoding="utf-8") as f:
f.write("test\n")
new_ref = repo.add_file(file2)
repo.delete_tag("tag")
repo.add_annotated_tag("tag", "tag")
repo.checkout("master")
otherpath = os.path.join(str(tmpdir), "other_path")
shutil.copytree(repo.repo, os.path.join(otherpath, "repo"))
create_repo("git", otherpath)
repodir, reponame = os.path.split(repo.repo)
generate_project(project, config=project_config)
config = repo.source_config(ref=new_ref)
del config["track"]
config["url"] = "repo:{}".format(reponame)
element = {
"kind": "import",
"sources": [config],
}
generate_element(project, "target.bst", element)
result = cli.run(project=project, args=["build", "target.bst"])
result.assert_success()
def test_git_describe_relevant_history(cli, tmpdir, datafiles):
project = str(datafiles)
project_config = load_yaml(os.path.join(project, "project.conf"))
project_config["ref-storage"] = "project.refs"
generate_project(project, config=project_config)
repofiles = os.path.join(str(tmpdir), "repofiles")
os.makedirs(repofiles, exist_ok=True)
file0 = os.path.join(repofiles, "file0")
with open(file0, "w", encoding="utf-8") as f:
f.write("test\n")
repo = create_repo("git", str(tmpdir))
repo.create(repofiles)
file1 = os.path.join(str(tmpdir), "file1")
with open(file1, "w", encoding="utf-8") as f:
f.write("test\n")
repo.add_file(file1)
repo.branch("branch")
repo.checkout("master")
file2 = os.path.join(str(tmpdir), "file2")
with open(file2, "w", encoding="utf-8") as f:
f.write("test\n")
repo.add_file(file2)
file3 = os.path.join(str(tmpdir), "file3")
with open(file3, "w", encoding="utf-8") as f:
f.write("test\n")
branch_boundary = repo.add_file(file3)
repo.checkout("branch")
file4 = os.path.join(str(tmpdir), "file4")
with open(file4, "w", encoding="utf-8") as f:
f.write("test\n")
tagged_ref = repo.add_file(file4)
repo.add_annotated_tag("tag1", "tag1")
head = repo.merge("master")
config = repo.source_config()
config["track"] = head
config["track-tags"] = True
# Write out our test target
element = {
"kind": "import",
"sources": [config],
}
generate_element(project, "target.bst", element)
result = cli.run(project=project,
args=["source", "track", "target.bst", "--deps", "all"])
result.assert_success()
checkout = os.path.join(str(tmpdir), "checkout")
result = cli.run(project=project, args=["build", "target.bst"])
result.assert_success()
result = cli.run(
project=project,
args=["artifact", "checkout", "target.bst", "--directory", checkout])
result.assert_success()
describe = subprocess.check_output(["git", "describe"],
cwd=checkout,
universal_newlines=True)
assert describe.startswith("tag1-2-")
rev_list = subprocess.check_output(["git", "rev-list", "--all"],
cwd=checkout,
universal_newlines=True)
assert set(rev_list.splitlines()) == set(
[head, tagged_ref, branch_boundary])