def test_sync_branch_devel(qisrc_action, git_server, test_git):
# This tests the case where everything goes smoothly
git_server.create_repo("foo.git")
qisrc_action("init", git_server.manifest_url)
git_server.push_file("foo.git", "foo.txt", "a super change")
git_server.push_file("foo.git", "bar.txt", "a super bugfix")
git_worktree = TestGitWorkTree()
foo = git_worktree.get_git_project("foo")
test_git = TestGit(foo.path)
test_git.call("checkout", "-b", "devel")
test_git.commit_file("developing.txt", "like a boss")
git_server.push_file("foo.git", "foobar.txt", "some other change")
git_server.push_file("foo.git", "bigchange.txt", "some huge change")
qisrc_action("sync", "--rebase-devel")
test_git.call("checkout", "master")
# Check that master is fast-forwarded
bigchange_txt = os.path.join(foo.path, "bigchange.txt")
assert os.path.exists(bigchange_txt)
# Check rebase is done smoothly
test_git.call("checkout", "devel")
test_git.call("rebase", "master")
assert os.path.exists(bigchange_txt)
developing_txt = os.path.join(foo.path, "developing.txt")
assert os.path.exists(developing_txt)
def test_when_ahead(git_server, qisrc_action):
git_server.create_repo("foo")
git_server.switch_manifest_branch("devel")
git_server.change_branch("foo", "devel")
qisrc_action("init", git_server.manifest_url, "--branch", "devel")
git_worktree = TestGitWorkTree()
foo_proj = git_worktree.get_git_project("foo")
git = TestGit(foo_proj.path)
git.commit_file("devel.txt", "devel")
git.push()
qisrc_action("rebase", "--all")
def test_publish_drafts(qisrc_action, git_server):
foo_repo = git_server.create_repo("foo.git", review=True)
qisrc_action("init", git_server.manifest_url)
git_worktree = TestGitWorkTree()
foo_proj = git_worktree.get_git_project("foo")
foo_git = TestGit(foo_proj.path)
foo_git.commit_file("a.txt", "a")
qisrc_action("push", "--project", "foo", "--draft")
_, sha1 = foo_git.call("log", "-1", "--pretty=%H", raises=False)
(_, remote) = foo_git.call("ls-remote", "gerrit", "refs/drafts/master", raises=False)
assert remote == "%s\trefs/drafts/master" % sha1
def test_when_ahead(git_server, qisrc_action):
git_server.create_repo("foo")
git_server.switch_manifest_branch("devel")
git_server.change_branch("foo", "devel")
qisrc_action("init", git_server.manifest_url, "--branch", "devel")
git_worktree = TestGitWorkTree()
foo_proj = git_worktree.get_git_project("foo")
git = TestGit(foo_proj.path)
git.commit_file("devel.txt", "devel")
git.push()
qisrc_action("rebase", "--all")
def test_publish_changes(qisrc_action, git_server):
foo_repo = git_server.create_repo("foo.git", review=True)
qisrc_action("init", git_server.manifest_url)
git_worktree = TestGitWorkTree()
foo_proj = git_worktree.get_git_project("foo")
foo_git = TestGit(foo_proj.path)
foo_git.commit_file("a.txt", "a")
qisrc_action("push", "foo")
_, sha1 = foo_git.call("log", "-1", "--pretty=%H", raises=False)
(_, remote) = foo_git.call("ls-remote", "gerrit", "refs/for/master", raises=False)
assert remote == "%s\trefs/for/master" % sha1
def test_not_under_code_review(qisrc_action, git_server):
foo_repo = git_server.create_repo("foo.git")
qisrc_action("init", git_server.manifest_url)
git_worktree = TestGitWorkTree()
foo_proj = git_worktree.get_git_project("foo")
foo_git = TestGit(foo_proj.path)
foo_git.commit_file("a.txt", "a")
qisrc_action("push", "foo")
_, sha1 = foo_git.call("log", "-1", "--pretty=%H", raises=False)
(_, remote) = foo_git.call("ls-remote", "origin", "master", raises=False)
assert remote == "%s\trefs/heads/master" % sha1
def test_not_under_code_review(qisrc_action, git_server):
foo_repo = git_server.create_repo("foo.git")
qisrc_action("init", git_server.manifest_url)
git_worktree = TestGitWorkTree()
foo_proj = git_worktree.get_git_project("foo")
foo_git = TestGit(foo_proj.path)
foo_git.commit_file("a.txt", "a")
qisrc_action("push", "foo")
_, sha1 = foo_git.call("log", "-1", "--pretty=%H", raises=False)
(_, remote) = foo_git.call("ls-remote", "origin", "master", raises=False)
assert remote == "%s\trefs/heads/master" % sha1
def test_copy_git_src(tmpdir):
src = tmpdir.mkdir("src")
dest = tmpdir.mkdir("dest")
foo_src = src.mkdir("foo")
foo_git = TestGit(foo_src.strpath)
foo_git.initialize()
foo_git.commit_file("a.txt", "a\n")
foo_git.commit_file("b.txt", "a\n")
foo_src.ensure("c.txt", file=True)
qisys.sh.copy_git_src(foo_src.strpath, dest.strpath)
assert dest.join("a.txt").check(file=True)
assert not dest.join("c.txt").check(file=True)
def test_copy_git_src(tmpdir):
src = tmpdir.mkdir("src")
dest = tmpdir.mkdir("dest")
foo_src = src.mkdir("foo")
foo_git = TestGit(foo_src.strpath)
foo_git.initialize()
foo_git.commit_file("a.txt", "a\n")
foo_git.commit_file("b.txt", "a\n")
foo_src.ensure("c.txt", file=True)
qisys.sh.copy_git_src(foo_src.strpath, dest.strpath)
assert dest.join("a.txt").check(file=True)
assert not dest.join("c.txt").check(file=True)
def test_pushing_custom_ref(qisrc_action, git_server):
foo_repo = git_server.create_repo("foo.git", review=True)
qisrc_action("init", git_server.manifest_url)
git_worktree = TestGitWorkTree()
foo_proj = git_worktree.get_git_project("foo")
foo_git = TestGit(foo_proj.path)
foo_git.checkout("-b", "perso")
foo_git.commit_file("a.txt", "a")
_, sha1 = foo_git.call("log", "-1", "--pretty=%H", raises=False)
foo_git.commit_file("b.txt", "b")
qisrc_action("push", "--project", "foo", "HEAD~1:master")
(_, remote) = foo_git.call("ls-remote", "gerrit", "refs/for/master", raises=False)
assert remote == "%s\trefs/for/master" % sha1
def test_using_carbon_copy(qisrc_action, git_server):
foo_repo = git_server.create_repo("foo.git", review=True)
qisrc_action("init", git_server.manifest_url)
git_worktree = TestGitWorkTree()
foo_proj = git_worktree.get_git_project("foo")
foo_git = TestGit(foo_proj.path)
# Need to fetch gerrit remote at least once for gerrit/master to exist
foo_git.fetch("--all")
foo_git.commit_file("a.txt", "a")
with mock.patch.object(qisys.command, "call") as mocked_call:
qisrc_action("push", "--project", "foo", "--cc", "jdoe")
set_reviewers_args = mocked_call.call_args_list[2][0][0][7]
assert "jdoe" in set_reviewers_args
def test_fixed_ref(qisrc_action, git_server):
git_server.create_repo("foo.git")
git_server.push_tag("foo.git", "v0.1")
git_server.set_fixed_ref("foo.git", "v0.1")
qisrc_action("init", git_server.manifest_url)
git_worktree = TestGitWorkTree()
foo_proj = git_worktree.get_git_project("foo")
git = TestGit(foo_proj.path)
git.commit_file("a.txt", "a", "test")
qisrc_action("reset")
_, actual = git.call("rev-parse", "HEAD", raises=False)
_, expected = git.call("rev-parse", "v0.1", raises=False)
assert actual == expected
def test_using_carbon_copy(qisrc_action, git_server):
foo_repo = git_server.create_repo("foo.git", review=True)
qisrc_action("init", git_server.manifest_url)
git_worktree = TestGitWorkTree()
foo_proj = git_worktree.get_git_project("foo")
foo_git = TestGit(foo_proj.path)
# Need to fetch gerrit remote at least once for gerrit/master to exist
foo_git.fetch("--all")
foo_git.commit_file("a.txt", "a")
with mock.patch.object(qisys.command, "call") as mocked_call:
qisrc_action("push", "foo", "--cc", "jdoe")
set_reviewers_args = mocked_call.call_args_list[2][0][0][7]
assert "jdoe" in set_reviewers_args
def test_fixed_ref(qisrc_action, git_server):
""" Test Fixed Ref """
git_server.create_repo("foo.git")
git_server.push_tag("foo.git", "v0.1")
git_server.set_fixed_ref("foo.git", "v0.1")
qisrc_action("init", git_server.manifest_url)
git_worktree = TestGitWorkTree()
foo_proj = git_worktree.get_git_project("foo")
git = TestGit(foo_proj.path)
git.commit_file("a.txt", "a", "test")
qisrc_action("reset")
_, actual = git.call("rev-parse", "HEAD", raises=False)
_, expected = git.call("rev-parse", "v0.1", raises=False)
assert actual == expected
def test_happy_rebase(git_server, qisrc_action):
git_server.create_repo("foo")
git_server.switch_manifest_branch("devel")
git_server.change_branch("foo", "devel")
qisrc_action("init", git_server.manifest_url, "--branch", "devel")
git_server.push_file("foo", "master.txt", "master")
git_worktree = TestGitWorkTree()
foo_proj = git_worktree.get_git_project("foo")
git = TestGit(foo_proj.path)
git.commit_file("devel.txt", "devel")
git.push()
git.fetch()
qisrc_action("rebase", "--branch", "master", "--all")
rc, out = git.log("--pretty=oneline", raises=False)
assert len(out.splitlines()) == 3
def test_happy_rebase(git_server, qisrc_action):
git_server.create_repo("foo")
git_server.switch_manifest_branch("devel")
git_server.change_branch("foo", "devel")
qisrc_action("init", git_server.manifest_url, "--branch", "devel")
git_server.push_file("foo", "master.txt", "master")
git_worktree = TestGitWorkTree()
foo_proj = git_worktree.get_git_project("foo")
git = TestGit(foo_proj.path)
git.commit_file("devel.txt", "devel")
git.push()
git.fetch()
qisrc_action("rebase", "--branch", "master", "--all")
rc, out = git.log("--pretty=oneline", raises=False)
assert len(out.splitlines()) == 3
def test_when_moved(git_server, qisrc_action, record_messages): # pylint: disable=unused-argument
git_server.create_repo("foo")
git_server.switch_manifest_branch("devel")
git_server.change_branch("foo", "devel")
git_server.move_repo("foo", "lib/foo")
qisrc_action("init", git_server.manifest_url, "--branch", "devel")
git_server.push_file("foo", "master.txt", "master")
git_worktree = TestGitWorkTree()
foo_proj = git_worktree.get_git_project("lib/foo")
git = TestGit(foo_proj.path)
git.commit_file("devel.txt", "devel")
git.push()
qisrc_action("rebase", "--branch", "master", "--all")
rc, out = git.log("--pretty=oneline", raises=False)
assert len(out.splitlines()) == 3
def test_not_under_code_review_ask_user(qisrc_action, git_server, interact):
""" Test Not Under Code Review Ask User """
_foo_repo = git_server.create_repo("foo.git")
qisrc_action("init", git_server.manifest_url)
git_worktree = TestGitWorkTree()
foo_proj = git_worktree.get_git_project("foo")
foo_git = TestGit(foo_proj.path)
foo_git.commit_file("a.txt", "a")
interact.answers = [False, True]
qisrc_action("push", "--project", "foo")
_, sha1 = foo_git.call("log", "-1", "--pretty=%H", raises=False)
(_, remote) = foo_git.call("ls-remote", "origin", "master", raises=False)
assert remote != "%s\trefs/heads/master" % sha1
qisrc_action("push", "--project", "foo")
(_, remote) = foo_git.call("ls-remote", "origin", "master", raises=False)
assert remote == "%s\trefs/heads/master" % sha1
def test_when_moved(git_server, qisrc_action, record_messages):
""" Test When Moved """
git_server.create_repo("foo")
git_server.switch_manifest_branch("devel")
git_server.change_branch("foo", "devel")
git_server.move_repo("foo", "lib/foo")
qisrc_action("init", git_server.manifest_url, "--branch", "devel")
git_server.push_file("foo", "master.txt", "master")
git_worktree = TestGitWorkTree()
foo_proj = git_worktree.get_git_project("lib/foo")
git = TestGit(foo_proj.path)
git.commit_file("devel.txt", "devel")
git.push()
qisrc_action("rebase", "--branch", "master", "--all")
_rc, out = git.log("--pretty=oneline", raises=False)
assert len(out.splitlines()) == 3
def test_not_under_code_review_ask_user(qisrc_action, git_server, interact):
""" Test Not Under Code Review Ask User """
_foo_repo = git_server.create_repo("foo.git")
qisrc_action("init", git_server.manifest_url)
git_worktree = TestGitWorkTree()
foo_proj = git_worktree.get_git_project("foo")
foo_git = TestGit(foo_proj.path)
foo_git.commit_file("a.txt", "a")
interact.answers = [False, True]
qisrc_action("push", "--project", "foo")
_, sha1 = foo_git.call("log", "-1", "--pretty=%H", raises=False)
(_, remote) = foo_git.call("ls-remote", "origin", "master", raises=False)
assert remote != "%s\trefs/heads/master" % sha1
qisrc_action("push", "--project", "foo")
(_, remote) = foo_git.call("ls-remote", "origin", "master", raises=False)
assert remote == "%s\trefs/heads/master" % sha1
def test_sync_branch_devel_no_ff(qisrc_action, git_server, test_git):
""" Test Sync Branc Devel No Fast Forward """
# Case where master can't be fast-forwarded, does nothing except warning
git_server.create_repo("foo.git")
qisrc_action("init", git_server.manifest_url)
git_server.push_file("foo.git", "foo.txt", "a super change")
git_worktree = TestGitWorkTree()
foo1 = git_worktree.get_git_project("foo")
test_git = TestGit(foo1.path)
test_git.commit_file("foo.git", "div.txt", "diverging from master")
master_sha1 = test_git.get_ref_sha1("refs/heads/master")
test_git.call("checkout", "-b", "devel")
test_git.commit_file("developing.txt", "like a boss")
git_server.push_file("foo.git", "foobar.txt", "some other change")
qisrc_action("sync", "--rebase-devel")
# Master HEAD is untouched
assert test_git.get_ref_sha1("refs/heads/master") == master_sha1
def test_sync_branch_devel_no_ff(qisrc_action, git_server, test_git):
""" Test Sync Branc Devel No Fast Forward """
# Case where master can't be fast-forwarded, does nothing except warning
git_server.create_repo("foo.git")
qisrc_action("init", git_server.manifest_url)
git_server.push_file("foo.git", "foo.txt", "a super change")
git_worktree = TestGitWorkTree()
foo1 = git_worktree.get_git_project("foo")
test_git = TestGit(foo1.path)
test_git.commit_file("foo.git", "div.txt", "diverging from master")
master_sha1 = test_git.get_ref_sha1("refs/heads/master")
test_git.call("checkout", "-b", "devel")
test_git.commit_file("developing.txt", "like a boss")
git_server.push_file("foo.git", "foobar.txt", "some other change")
qisrc_action("sync", "--rebase-devel")
# Master HEAD is untouched
assert test_git.get_ref_sha1("refs/heads/master") == master_sha1
def test_alert_maintainers(qisrc_action, git_server):
foo_repo = git_server.create_repo("foo.git", review=True)
qiproject_xml = """\
<project version="3">
<maintainer email="*****@*****.**">John Doe</maintainer>
</project>"""
git_server.push_file("foo.git", "qiproject.xml", qiproject_xml)
qisrc_action("init", git_server.manifest_url)
git_worktree = TestGitWorkTree()
foo_proj = git_worktree.get_git_project("foo")
foo_git = TestGit(foo_proj.path)
# Need to fetch gerrit remote at least once for gerrit/master to exist
foo_git.fetch("--all")
foo_git.commit_file("a.txt", "a")
with mock.patch.object(qisys.command, "call") as mocked_call:
qisrc_action("push", "foo")
set_reviewers_args = mocked_call.call_args_list[3][0][0][7]
assert "*****@*****.**" in set_reviewers_args
def test_rebase_conflict(git_server, qisrc_action):
git_server.create_repo("foo")
git_server.switch_manifest_branch("devel")
git_server.change_branch("foo", "devel")
qisrc_action("init", git_server.manifest_url, "--branch", "devel")
git_server.push_file("foo", "foo.txt", "master")
git_worktree = TestGitWorkTree()
foo_proj = git_worktree.get_git_project("foo")
git = TestGit(foo_proj.path)
git.commit_file("foo.txt", "devel")
git.push()
_, before = git.call("show", raises=False)
git.fetch()
# pylint: disable-msg=E1101
with pytest.raises(Exception):
qisrc_action("rebase", "--branch", "master", "--all")
_, after = git.call("show", raises=False)
assert after == before
def test_push_after_rebase(git_server, git_worktree, qisrc_action, interact):
git_server.create_repo("foo")
git_server.switch_manifest_branch("devel")
git_server.change_branch("foo", "devel")
git_server.push_file("foo", "master.txt", "devel")
qisrc_action("init", git_server.manifest_url, "--branch", "devel")
git_server.push_file("foo", "master.txt", "master")
git_worktree = TestGitWorkTree()
foo_proj = git_worktree.get_git_project("foo")
git = TestGit(foo_proj.path)
git.commit_file("devel.txt", "devel")
git.fetch()
git.push("origin", "devel")
interact.answers = [True]
qisrc_action("rebase", "--branch", "master", "--push", "--force", "--all")
local_sha1 = git.get_ref_sha1("refs/heads/devel")
remote_sha1 = git.get_ref_sha1("refs/remotes/origin/devel")
assert local_sha1 == remote_sha1
def test_sync_branch_devel_unclean(qisrc_action, git_server, test_git):
""" Test Sync Branch Devel UnClean """
# Case where the worktree isn't clean
git_server.create_repo("foo.git")
qisrc_action("init", git_server.manifest_url)
git_server.push_file("foo.git", "foo.txt", "a super change")
git_server.push_file("foo.git", "bar.txt", "a super bugfix")
git_worktree = TestGitWorkTree()
foo1 = git_worktree.get_git_project("foo")
test_git = TestGit(foo1.path)
test_git.call("checkout", "-b", "devel")
test_git.commit_file("developing.txt", "like a boss")
git_server.push_file("foo.git", "foobar.txt", "some other change")
wip_txt = os.path.join(foo1.path, "wip.txt")
open(wip_txt, 'w').close()
qisys.script.run_action("qisrc.actions.sync", ["--rebase-devel"])
# Master has been fast-forwarded and I haven't lost my WIP
assert os.path.exists(wip_txt)
def test_push_after_rebase(git_server, git_worktree, qisrc_action, interact): # pylint: disable=unused-argument
git_server.create_repo("foo")
git_server.switch_manifest_branch("devel")
git_server.change_branch("foo", "devel")
git_server.push_file("foo", "master.txt", "devel")
qisrc_action("init", git_server.manifest_url, "--branch", "devel")
git_server.push_file("foo", "master.txt", "master")
git_worktree = TestGitWorkTree()
foo_proj = git_worktree.get_git_project("foo")
git = TestGit(foo_proj.path)
git.commit_file("devel.txt", "devel")
git.fetch()
git.push("origin", "devel")
interact.answers = [True]
qisrc_action("rebase", "--branch", "master", "--push", "--force", "--all")
local_sha1 = git.get_ref_sha1("refs/heads/devel")
remote_sha1 = git.get_ref_sha1("refs/remotes/origin/devel")
assert local_sha1 == remote_sha1
def test_sync_reset(qisrc_action, git_server):
git_server.create_repo("bar")
git_server.create_repo("baz")
qisrc_action("init", git_server.manifest_url)
git_worktree = TestGitWorkTree()
bar_proj = git_worktree.get_git_project("bar")
baz_proj = git_worktree.get_git_project("baz")
bar_git = TestGit(bar_proj.path)
baz_git = TestGit(baz_proj.path)
bar_git.checkout("-B", "devel")
baz_git.commit_file("unrelated.txt", "unrelated\n")
git_server.push_file("bar", "bar.txt", "this is bar\n")
qisrc_action("sync", "--reset")
assert bar_git.get_current_branch() == "master"
assert bar_git.read_file("bar.txt") == "this is bar\n"
# pylint: disable-msg=E1101
with pytest.raises(Exception):
baz_git.read_file("unrelated.txt")
def test_sync_reset(qisrc_action, git_server):
""" Test Sync Reset """
git_server.create_repo("bar")
git_server.create_repo("baz")
qisrc_action("init", git_server.manifest_url)
git_worktree = TestGitWorkTree()
bar_proj = git_worktree.get_git_project("bar")
baz_proj = git_worktree.get_git_project("baz")
bar_git = TestGit(bar_proj.path)
baz_git = TestGit(baz_proj.path)
bar_git.checkout("-B", "devel")
baz_git.commit_file("unrelated.txt", "unrelated\n")
git_server.push_file("bar", "bar.txt", "this is bar\n")
qisrc_action("sync", "--reset")
assert bar_git.get_current_branch() == "master"
assert bar_git.read_file("bar.txt") == "this is bar\n"
with pytest.raises(Exception):
baz_git.read_file("unrelated.txt")
def test_sync_branch_devel_unclean(qisrc_action, git_server, test_git):
""" Test Sync Branch Devel UnClean """
# Case where the worktree isn't clean
git_server.create_repo("foo.git")
qisrc_action("init", git_server.manifest_url)
git_server.push_file("foo.git", "foo.txt", "a super change")
git_server.push_file("foo.git", "bar.txt", "a super bugfix")
git_worktree = TestGitWorkTree()
foo1 = git_worktree.get_git_project("foo")
test_git = TestGit(foo1.path)
test_git.call("checkout", "-b", "devel")
test_git.commit_file("developing.txt", "like a boss")
git_server.push_file("foo.git", "foobar.txt", "some other change")
wip_txt = os.path.join(foo1.path, "wip.txt")
open(wip_txt, 'w').close()
qisys.script.run_action("qisrc.actions.sync", ["--rebase-devel"])
# Master has been fast-forwarded and I haven't lost my WIP
assert os.path.exists(wip_txt)
def test_orphaned_project(qisrc_action, git_server, record_messages):
foo_repo = git_server.create_repo("foo.git", review=True)
qiproject_xml = """\
<project version="3">
<maintainer>ORPHANED</maintainer>
</project>"""
git_server.push_file("foo.git", "qiproject.xml", qiproject_xml)
qisrc_action("init", git_server.manifest_url)
git_worktree = TestGitWorkTree()
foo_proj = git_worktree.get_git_project("foo")
foo_git = TestGit(foo_proj.path)
# Need to fetch gerrit remote at least once for gerrit/master to exist
foo_git.fetch("--all")
foo_git.commit_file("a.txt", "a")
record_messages.reset()
qisrc_action("push", "--project", "foo")
assert record_messages.find("Project is orphaned")
def test_alert_maintainers(qisrc_action, git_server):
foo_repo = git_server.create_repo("foo.git", review=True)
qiproject_xml = """\
<project format="3">
<maintainer email="*****@*****.**">John Doe</maintainer>
</project>"""
git_server.push_file("foo.git", "qiproject.xml", qiproject_xml)
qisrc_action("init", git_server.manifest_url)
git_worktree = TestGitWorkTree()
foo_proj = git_worktree.get_git_project("foo")
foo_git = TestGit(foo_proj.path)
# Need to fetch gerrit remote at least once for gerrit/master to exist
foo_git.fetch("--all")
foo_git.commit_file("a.txt", "a")
with mock.patch.object(qisys.command, "call") as mocked_call:
qisrc_action("push", "--project", "foo")
set_reviewers_args = mocked_call.call_args_list[-1][0][0][-1] # Last argument of last command
assert "jdoe" in set_reviewers_args
assert not "@company.com" in set_reviewers_args
