import os import shutil from drivers.alr import run_alr, init_local_crate, alr_with, alr_publish from drivers.helpers import init_git_repo, on_windows, commit_all # from drivers.asserts import assert_eq, assert_match from subprocess import run # We create a repository with two nested crates that will act as the upstream # remote repository: start_dir = os.getcwd() os.mkdir("monoproject.upstream") os.chdir("monoproject.upstream") init_local_crate("crate1", enter=False) os.chdir(start_dir) commit1 = init_git_repo("monoproject.upstream") # We clone the project to obtain our local copy assert run(["git", "clone", "monoproject.upstream", "monoproject"]).returncode == 0 # We enter the crate nested inside and publish. # We are now at monoproject/mycrate. os.chdir("monoproject") os.chdir("crate1") alr_publish("crate1", "0.0.0", index_path=os.path.join(start_dir, "my_index")) # We create a second crate at another commit os.chdir(os.path.join(start_dir, "monoproject.upstream")) init_local_crate("crate2", enter=False) os.chdir(start_dir)
from subprocess import run import os def verify_manifest(): target = os.path.join("alire", "releases", "xxx-0.1.0-dev.toml") assert os.path.isfile(target), \ "Index manifest not found at expected location" # Clean up for next test rmtree(os.path.join("alire", "releases")) # Prepare our "remote" repo init_local_crate("xxx", enter=False) head_commit = init_git_repo("xxx") # Clone to a "local" repo and set minimal config assert run(["git", "clone", "xxx", "xxx_local"]).returncode == 0 os.chdir("xxx_local") assert run(["git", "config", "user.email", "*****@*****.**"]).returncode == 0 assert run(["git", "config", "user.name", "Alire Testsuite"]).returncode == 0 # Tests with different default arguments that must all succeed run_alr("--force", "publish") verify_manifest() run_alr("--force", "publish", ".") verify_manifest() run_alr("--force", "publish", ".", "master")
from drivers.alr import run_alr, alr_pin, init_local_crate from drivers.asserts import assert_eq, assert_match from drivers.helpers import init_git_repo, dir_separator import re import os # We are going to setup xxx --> yyy --> zzz, where xxx and zzz live at the # same level, and yyy is at ./nest/yyy. Both yyy and zzz will be git # repositories, so we refer to them by their absolute path (as if they were # remote URLs) # zzz crate/repo init_local_crate(name="zzz", enter=False) path_zzz = os.path.join(os.getcwd(), "zzz") init_git_repo(path_zzz) # yyy crate/repo os.mkdir("nest") os.chdir("nest") init_local_crate(name="yyy") alr_pin("zzz", url=path_zzz) os.chdir("..") path_yyy = os.path.join(os.getcwd(), "yyy") init_git_repo(path_yyy) # xxx crate os.chdir("..") init_local_crate() alr_pin("yyy", url=path_yyy)
run_alr("clean", "--cache") assert not os.path.isdir(pin_path) # Verify automatic redownload when needed run_alr("build") # Prepare for next test run_alr("with", "--del", "upstream") # Remove dependency p = run_alr("pin") assert_eq(f"There are no pins\n", p.out) # Ensure pin is gone shutil.rmtree("alire") # Total cleanup outside of alr # Initialize a git repo that will act as the "online" remote init_local_crate(name="upstream", binary=False) head = init_git_repo(".") os.chdir("..") os.rename("upstream", "upstream.git") # so it is recognized as git repo # Initialize a client crate that will use the remote init_local_crate() # This leaves us inside the new crate # Add using with directly run_alr("with", "--use", "../upstream.git", "--commit", head) verify(head) # Add using with, without head commit run_alr("with", "--use", "../upstream.git") verify() # Pin afterwards, with commit
from drivers.alr import run_alr, alr_pin, alr_unpin, init_local_crate from drivers.asserts import assert_eq, assert_match from drivers.helpers import git_branch, git_head, init_git_repo from e3.os.fs import touch from re import escape import re import os import shutil import subprocess # "remote" is going to be the remote crate init_local_crate(name="remote", enter=False) url = os.path.join(os.getcwd(), "remote") head1 = init_git_repo("remote") os.chdir("remote") default_branch = git_branch() # Create a second branch and commit for testing subprocess.run(["git", "checkout", "-b", "devel"]).check_returncode() touch("telltale") subprocess.run(["git", "add", "telltale"]).check_returncode() subprocess.run(["git", "commit", "-m", "branching"]).check_returncode() os.chdir("..") # Now pin to the branch, and verify the telltale file exists in the checkout init_local_crate() alr_pin("remote", url=url, branch="devel") p = run_alr("pin") assert_match("remote file:alire/cache/pins/remote " +
from drivers.asserts import assert_eq, assert_match from subprocess import run crate = "pinner" # We create a repository with the nested crate that will act as the upstream # remote repository: start_dir = os.getcwd() init_local_crate(crate) # And add the pin directly in the remote alr_pin("unobtanium", path="/") # We can now create the upstream repo os.chdir("..") commit = init_git_repo(crate) os.rename(crate, f"{crate}.upstream") # We clone the project to obtain our local copy assert run(["git", "clone", f"{crate}.upstream", crate]).returncode == 0 # We enter the clone os.chdir(crate) # Verify the pin is there assert_match(".*\[\[pins\]\].*", content_of(alr_manifest())) # We publish with the pin in the manifest p = alr_publish(crate, "0.0.0", index_path=os.path.join(start_dir, "my_index"),
""" Tests tarball publishing from a git repository """ from drivers.alr import init_local_crate, run_alr from drivers.helpers import init_git_repo from shutil import copyfile from subprocess import run import os # Prepare our "remote" repo init_local_crate("xxx", enter=True) # Initialize a repo right here init_git_repo(".") # Clone it to simulate it's our local copy os.chdir("..") os.rename("xxx", "xxx_upstream") run(["git", "clone", "xxx_upstream", "xxx"]).check_returncode() os.chdir("xxx") # Publish it. We need to give input to alr, so we directly call it. We use the # generated location as the "online" location, and this works because we are # forcing. ".tgz" is used, as bzip2 is not supported by `git archive`. p = run( ["alr", "-q", "-f", "-n", "publish", "--skip-build", "--tar"], input=f"file:{os.getcwd()}/alire/archives/xxx-0.1.0-dev.tgz\n".encode()) p.check_returncode()
from drivers.asserts import assert_eq, assert_match from drivers.helpers import git_blast, git_head, init_git_repo from e3.os.fs import touch from re import escape import re import os import shutil import subprocess # "remote" is going to be the remote crate. Two other crates will depend on it # with different branches/commits etc init_local_crate(name="zzz", enter=False) url = os.path.join(os.getcwd(), "zzz") head1 = init_git_repo("zzz") os.chdir("zzz") # Create a second branch and commit for testing subprocess.run(["git", "checkout", "-b", "devel"]).check_returncode() touch("x") subprocess.run(["git", "add", "x"]).check_returncode() subprocess.run(["git", "commit", "-m", "branching"]).check_returncode() head2 = git_head() os.chdir("..") # In this function we will test that two crates with the same remote works, # for several combinations def should_work(commit="", branch=""): os.mkdir("nest")
# Local pinnable crate init_local_crate("yyy", enter=False) yyy_path = "../yyy" # Local pinnable raw project os.mkdir("zzz") zzz_path = "../zzz" # Simple pin, no restrictions check_equivalent("yyy", path=yyy_path) check_equivalent("zzz", path=zzz_path) # Prepare repository head = init_git_repo("yyy") branch = git_branch("yyy") os.rename("yyy", "yyy.git") # to be recognizable as a git url url = "../yyy.git" # Simple git remote, explicit crate check_equivalent(crate="yyy", url=url) # Explicit commit check_equivalent(crate="yyy", url=url, commit=head) # Explicit branch check_equivalent(crate="yyy", url=url, branch=branch) print('SUCCESS')