def test_ignores_env(tmpdir, monkeypatch): repo1 = tmpdir.mkdir("repo1") repo2 = tmpdir.mkdir("repo2") git1 = TestGit(repo1.strpath) git2 = TestGit(repo2.strpath) git1.initialize() git2.initialize() untracked = repo1.join("untracked") untracked.ensure(file=True) monkeypatch.setenv("GIT_DIR", repo1.join(".git").strpath) monkeypatch.setenv("GIT_WORK_TREE", repo1.strpath) git2.call("clean", "--force") assert untracked.check(file=1)
def test_switching_from_fixed_ref_to_branch_local_changes( qisrc_action, git_server, record_messages): """ Test Swithcing From Fixed Ref To Branch Local Changes """ git_server.create_repo("foo.git") git_server.push_file("foo.git", "a.txt", "a") git_server.push_tag("foo.git", "v0.1") git_server.push_file("foo.git", "b.txt", "b") git_server.push_tag("foo.git", "v0.2") git_server.push_file("foo.git", "c.txt", "c") 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.write_file("a.txt", "unstaged changes") git_server.set_branch("foo.git", "master") record_messages.reset() rc = qisrc_action("sync", retcode=True) # ERROR message must be displayed to warn user assert rc != 0 assert record_messages.find("unstaged changes") _, sha1 = git.call("rev-parse", "HEAD", raises=False) expected = git.get_ref_sha1("refs/tags/v0.1") # git repo unchanged assert sha1 == expected git.call("reset", "--hard") qisrc_action("sync", retcode=True) # if modification is revert sync must be successful assert git.get_current_branch() == "master"
def test_safe_checkout(cd_to_tmpdir, git_server): git_server.create_repo("foo.git") git = TestGit() git.clone(git_server.srv.join("foo.git").strpath) ok, mess = git.safe_checkout("devel", "origin") assert git.get_current_branch() == "devel" assert ok
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_qisrc_checkout_with_branch_to_ref(qisrc_action, git_server): """ Test QiSrc Checkout With Branch to Ref """ manifest_url = git_server.manifest_url git_server.create_repo("foo.git") git_server.create_repo("bar.git") git_server.push_file("foo.git", "a.txt", "a") git_server.push_tag("foo.git", "v0.1") git_server.push_file("foo.git", "b.txt", "b") git_server.push_tag("bar.git", "v0.2") git_server.push_file("bar.git", "c.txt", "b") qisrc_action("init", manifest_url) git_server.switch_manifest_branch("devel") git_server.set_fixed_ref("foo.git", "v0.1") git_server.set_fixed_ref("bar.git", "v0.2") git_worktree = TestGitWorkTree() foo_proj = git_worktree.get_git_project("foo") git = TestGit(foo_proj.path) assert git.get_current_branch() == "master" qisrc_action("checkout", "devel") _, sha1 = git.call("rev-parse", "HEAD", raises=False) expected = git.get_ref_sha1("refs/tags/v0.1") assert sha1 == expected bar_proj = git_worktree.get_git_project("bar") bar_git = qisrc.git.Git(bar_proj.path) _, sha1 = bar_git.call("rev-parse", "HEAD", raises=False) expected = bar_git.get_ref_sha1("refs/tags/v0.2") assert sha1 == expected
def test_get_repo_root(tmpdir): root = tmpdir.ensure("CrazyCase", dir=True) git = TestGit(root.strpath) git.initialize() subdir = root.ensure("some" , "subdir", dir=True) actual = qisrc.git.get_repo_root(subdir.strpath) expected = qisys.sh.to_native_path(root.strpath) assert actual == expected
def test_retcode_when_skipping(qisrc_action, git_server): git_server.create_repo("bar") qisrc_action("init", git_server.manifest_url) git_worktree = TestGitWorkTree() bar_proj = git_worktree.get_git_project("bar") git = TestGit(bar_proj.path) git.checkout("-b", "devel") rc = qisrc_action("sync", retcode=True) assert rc != 0
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_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_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_skip_when_not_on_correct_branch(git_server, qisrc_action, record_messages): 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.checkout("-B", "perso") qisrc_action("rebase", "--branch", "master", "--all") assert record_messages.find("skipped")
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_reset_undo_local_changes(qisrc_action, git_server): git_server.create_repo("foo") manifest_url = git_server.manifest_url qisrc_action("init", manifest_url) git_worktree = TestGitWorkTree() foo_proj = git_worktree.get_git_project("foo") foo_git = TestGit(foo_proj.path) orig_gitinore = foo_git.read_file(".gitignore") foo_git.root.join(".gitignore").write("new line\n") qisrc_action("reset", "--force") assert foo_git.read_file(".gitignore") == orig_gitinore
def test_changelog(cd_to_tmpdir): git = TestGit() git.initialize() message_1 = "mess1" git.commit_file("foo.txt", "foo\n", message=message_1) message_2 = "mess2" git.commit_file("foo.txt", "bar\n", message=message_2) commits = git.get_log("HEAD~2", "HEAD") assert len(commits) == 2 assert commits[0]["message"] == message_1 assert commits[1]["message"] == message_2
def test_checkout_creates_at_correct_place(qisrc_action, git_server): manifest_url = git_server.manifest_url git_server.create_repo("foo.git") git_server.switch_manifest_branch("devel") git_server.change_branch("foo.git", "devel") git_server.push_file("foo.git", "foo.txt", "this is foo") qisrc_action("init", manifest_url, "--branch", "devel") qisrc_action("checkout", "master") git_worktree = TestGitWorkTree() foo_proj = git_worktree.get_git_project("foo") git = TestGit(foo_proj.path) git.read_file("foo.txt")
def test_sync_dash_g(qisrc_action, git_server): git_server.create_group("mygroup", ["a", "b"]) git_server.create_repo("other") git_server.push_file("other", "other.txt", "change 1") qisrc_action("init", git_server.manifest_url) git_server.push_file("other", "other.txt", "change 2") qisrc_action("sync", "--group", "mygroup") git_worktree = TestGitWorkTree() other_proj = git_worktree.get_git_project("other") other_git = TestGit(other_proj.path) assert other_git.read_file("other.txt") == "change 1"
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_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_changing_branch_of_repo_under_code_review(qisrc_action, git_server, record_messages): git_server.create_repo("foo.git", review=True) qisrc_action("init", git_server.manifest_url) git_server.change_branch("foo.git", "devel") git_worktree = TestGitWorkTree() foo_proj = git_worktree.get_git_project("foo") git = TestGit(foo_proj.path) git.checkout("-b", "devel") record_messages.reset() qisrc_action("sync") assert record_messages.find("default branch changed") assert not record_messages.find("now using code review")
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_incorrect_branch_still_fetches(qisrc_action, git_server): git_server.create_repo("foo.git") qisrc_action("init", git_server.manifest_url) qisrc_action("sync") git_worktree = TestGitWorkTree() foo = git_worktree.get_git_project("foo") test_git = TestGit(foo.path) test_git.checkout("-b", "wip") git_server.push_file("foo.git", "foo.txt", "some change") previous_sha1 = test_git.get_ref_sha1("refs/remotes/origin/master") foo.sync() new_sha1 = test_git.get_ref_sha1("refs/remotes/origin/master") assert previous_sha1 != new_sha1
def test_fixed_ref_local_changes(qisrc_action, git_server, record_messages): git_server.create_repo("foo.git") git_server.push_file("foo.git", "a.txt", "a") qisrc_action("init", git_server.manifest_url) git_worktree = TestGitWorkTree() foo_proj = git_worktree.get_git_project("foo") git = TestGit(foo_proj.path) git.write_file("a.txt", "unstaged changes") git_server.push_tag("foo.git", "v.01") record_messages.reset() rc = qisrc_action("sync", retcode=True) assert rc != 0 assert record_messages.find("unstaged changes")
def test_keeps_staged_changes(qisrc_action, git_server): git_server.create_repo("foo.git") qisrc_action("init", git_server.manifest_url) qisrc_action("sync") git_worktree = TestGitWorkTree() foo = git_worktree.get_git_project("foo") test_git = TestGit(foo.path) staged_file = os.path.join(foo.path, "staged") with open(staged_file, "w") as f: f.write("I'm going to stage stuff") test_git.add(staged_file) foo.sync() assert os.path.exists(staged_file)
def test_tags(qisrc_action, git_server): """ Test Tags """ git_server.create_repo("foo.git") git_server.push_file("foo.git", "a.txt", "a") git_server.push_tag("foo.git", "v0.1") git_server.push_file("foo.git", "b.txt", "b") 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) _, sha1 = git.call("rev-parse", "HEAD", raises=False) expected = git.get_ref_sha1("refs/tags/v0.1") assert sha1 == expected
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_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_push_tags(git_server, tmpdir): foo_repo = git_server.create_repo("foo.git") foo_url = foo_repo.clone_url git_server.push_file("foo.git", "a.txt", "a") git_server.push_tag("foo.git", "v0.1") git_server.push_file("foo.git", "b.txt", "b") foo = tmpdir.mkdir("foo") foo_git = TestGit(foo.strpath) foo_git.clone(foo_url) assert foo_git.read_file("b.txt") == "b" foo_git.reset("--hard", "v0.1") #pylint:disable-msg=E1101 with pytest.raises(Exception): foo_git.read_file("b.txt") assert foo_git.read_file("a.txt") == "a"
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