d633541ecc
Gerrit wants each commit message to include a unique identifier string in a special footer line, so provides a commit-msg hook to randomly generate and insert one. Traditionally, this file is served directly from each Gerrit server and users retrieve it via SCP or HTTPS to install a local copy in their clone of every repository. Retrieving this file over the network has historically presented a number of challenges: modern OpenSSH has deprecated the SCP protocol while the mina-sshd library Gerrit uses hasn't implemented compatible SFTP support, authentication failures can shadow some clearer error handling later in git-review's workflow leading to confusing error messages, and then there are the security concerns with needing to trust the Gerrit server to supply a script which will end up running locally on the developer's machine. In order to address these problems, making git-review more robust and secure, we embed a copy of the Gerrit upstream project's commit-msg hook in the client itself and write that to disk by default rather than pulling a remote copy. This approach does mean that the user will end up with a frozen version of the script contemporary with the git-review release they've installed (but its function is simple and the implementation has changed very infrequently). It may also break workflows for sites which rely on users retrieving a customized commit-msg hook. For those reasons, a command-line option is provided to restore the prior behavior. Change-Id: Ia26abc781a281817115cb1cafcd5e7b78b383e39
669 lines
28 KiB
Python
669 lines
28 KiB
Python
# -*- coding: utf-8 -*-
|
|
|
|
# Copyright (c) 2013 Mirantis Inc.
|
|
#
|
|
# Licensed under the Apache License, Version 2.0 (the "License");
|
|
# you may not use this file except in compliance with the License.
|
|
# You may obtain a copy of the License at
|
|
#
|
|
# http://www.apache.org/licenses/LICENSE-2.0
|
|
#
|
|
# Unless required by applicable law or agreed to in writing, software
|
|
# distributed under the License is distributed on an "AS IS" BASIS,
|
|
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
|
|
# implied.
|
|
# See the License for the specific language governing permissions and
|
|
# limitations under the License.
|
|
|
|
import json
|
|
import os
|
|
import shutil
|
|
import tempfile
|
|
import testtools
|
|
|
|
from git_review import tests
|
|
from git_review.tests import utils
|
|
|
|
|
|
class ConfigTestCase(tests.BaseGitReviewTestCase):
|
|
"""Class for config tests."""
|
|
|
|
def test_get_config_from_cli(self):
|
|
self.reset_remote()
|
|
self._run_git('remote', 'rm', 'origin')
|
|
self._create_gitreview_file(defaultremote='remote-file')
|
|
self._run_git('config', 'gitreview.remote', 'remote-gitconfig')
|
|
self._run_git_review('-s', '-r', 'remote-cli')
|
|
|
|
remote = self._run_git('remote').strip()
|
|
self.assertEqual('remote-cli', remote)
|
|
|
|
def test_get_config_from_gitconfig(self):
|
|
self.reset_remote()
|
|
self._run_git('remote', 'rm', 'origin')
|
|
self._create_gitreview_file(defaultremote='remote-file')
|
|
self._run_git('config', 'gitreview.remote', 'remote-gitconfig')
|
|
self._run_git_review('-s')
|
|
|
|
remote = self._run_git('remote').strip()
|
|
self.assertEqual('remote-gitconfig', remote)
|
|
|
|
def test_get_config_from_file(self):
|
|
self.reset_remote()
|
|
self._run_git('remote', 'rm', 'origin')
|
|
self._create_gitreview_file(defaultremote='remote-file')
|
|
self._run_git_review('-s')
|
|
|
|
remote = self._run_git('remote').strip()
|
|
self.assertEqual('remote-file', remote)
|
|
|
|
|
|
class GitReviewTestCase(tests.BaseGitReviewTestCase):
|
|
"""Class for the git-review tests."""
|
|
|
|
def test_cloned_repo(self):
|
|
"""Test git-review on the just cloned repository."""
|
|
self._simple_change('test file modified', 'test commit message')
|
|
self.assertNotIn('Change-Id:', self._run_git('log', '-1'))
|
|
gr = self._run_git_review()
|
|
self.assertIn('remote: SUCCESS', gr)
|
|
self.assertIn('test commit message [NEW]', gr)
|
|
self.assertIn('Change-Id:', self._run_git('log', '-1'))
|
|
|
|
def test_git_review_s(self):
|
|
"""Test git-review -s."""
|
|
self.reset_remote()
|
|
self._run_git_review('-s')
|
|
self._simple_change('test file modified', 'test commit message')
|
|
self.assertIn('Change-Id:', self._run_git('log', '-1'))
|
|
|
|
def test_git_review_s_in_detached_head(self):
|
|
"""Test git-review -s in detached HEAD state."""
|
|
self.reset_remote()
|
|
master_sha1 = self._run_git('rev-parse', 'master')
|
|
self._run_git('checkout', master_sha1)
|
|
self._run_git_review('-s')
|
|
self._simple_change('test file modified', 'test commit message')
|
|
self.assertIn('Change-Id:', self._run_git('log', '-1'))
|
|
|
|
def test_git_review_s_with_outdated_repo(self):
|
|
"""Test git-review -s with a outdated repo."""
|
|
self._simple_change('test file to outdate', 'test commit message 1')
|
|
self._run_git('push', 'origin', 'master')
|
|
self._run_git('reset', '--hard', 'HEAD^')
|
|
|
|
# Review setup with an outdated repo
|
|
self.reset_remote()
|
|
self._run_git_review('-s')
|
|
self._simple_change('test file modified', 'test commit message 2')
|
|
self.assertIn('Change-Id:', self._run_git('log', '-1'))
|
|
|
|
def test_git_review_s_from_subdirectory(self):
|
|
"""Test git-review -s from subdirectory."""
|
|
self.reset_remote()
|
|
utils.run_cmd('mkdir', 'subdirectory', chdir=self.test_dir)
|
|
self._run_git_review(
|
|
'-s', chdir=os.path.join(self.test_dir, 'subdirectory'))
|
|
|
|
def test_install_embedded_hook(self):
|
|
"""Test whether git-review -s correctly creates the commit-msg hook
|
|
from the embedded copy with appropriate permissions and content.
|
|
"""
|
|
hooks_subdir = ".git/hooks"
|
|
hook_file = os.path.join(self.test_dir, hooks_subdir, 'commit-msg')
|
|
self.reset_remote()
|
|
|
|
self._run_git_review('-s')
|
|
self.assertTrue(os.path.exists(hook_file))
|
|
self.assertTrue(os.access(hook_file, os.W_OK))
|
|
self.assertTrue(os.access(hook_file, os.X_OK))
|
|
with open(hook_file) as f:
|
|
content = f.read()
|
|
self.assertTrue(content.startswith('#!/'))
|
|
# This line should not appear in the embedded version
|
|
self.assertNotIn('# From Gerrit Code Review', content)
|
|
|
|
def test_install_remote_hook(self):
|
|
"""Test whether git-review -s correctly creates the commit-msg hook
|
|
from the Gerrit server with appropriate permissions and content.
|
|
"""
|
|
hooks_subdir = ".git/hooks"
|
|
hook_file = os.path.join(self.test_dir, hooks_subdir, 'commit-msg')
|
|
self.reset_remote()
|
|
|
|
self._run_git_review('-s', '--remote-hook')
|
|
self.assertTrue(os.path.exists(hook_file))
|
|
self.assertTrue(os.access(hook_file, os.W_OK))
|
|
self.assertTrue(os.access(hook_file, os.X_OK))
|
|
with open(hook_file) as f:
|
|
content = f.read()
|
|
self.assertTrue(content.startswith('#!/'))
|
|
# This line is injected by the Gerrit server in its version
|
|
self.assertIn('# From Gerrit Code Review', content)
|
|
|
|
def test_git_review_s_without_core_hooks_path_option(self):
|
|
"""Test whether git-review -s correctly creates the commit-msg hook,
|
|
with the Git core.hooksPath option unset.
|
|
"""
|
|
hooks_subdir = ".git/hooks"
|
|
self.reset_remote()
|
|
|
|
# There really isn't a good way to ensure that
|
|
# "core.hooksPath" option is presently unset. "git config
|
|
# --unset" is not idempotent; if you try to unset a config
|
|
# option that isn't defined it fails with an exit code of
|
|
# 5. Running "git config core.hooksPath" to retrieve the value
|
|
# returns 1 if unset, but we can't use self.assertRaises here
|
|
# either because run_cmd raises a generic Exception and that's
|
|
# too broad. So instead, we don't check core.hooksPath at all
|
|
# here, and instead rely on the next two tests to unset the
|
|
# option after they've set it.
|
|
self._run_git_review('-s')
|
|
self.assertTrue(os.path.exists(os.path.join(self.test_dir,
|
|
hooks_subdir,
|
|
'commit-msg')))
|
|
|
|
def test_git_review_s_with_core_hooks_path_option_relative(self):
|
|
"""Test whether git-review -s correctly creates the commit-msg hook,
|
|
with the Git core.hooksPath option set to a relative path.
|
|
"""
|
|
hooks_subdir = "foo"
|
|
self.reset_remote()
|
|
self._run_git("config", "core.hooksPath", hooks_subdir)
|
|
self._run_git_review('-s')
|
|
self.assertTrue(os.path.exists(os.path.join(self.test_dir,
|
|
hooks_subdir,
|
|
'commit-msg')))
|
|
self._run_git("config", "--unset", "core.hooksPath")
|
|
|
|
def test_git_review_s_with_core_hooks_path_option_absolute(self):
|
|
"""Test whether git-review -s correctly creates the commit-msg hook,
|
|
with the Git core.hooksPath option set to an absolute path.
|
|
"""
|
|
self.reset_remote()
|
|
with tempfile.TemporaryDirectory() as hooks_dir:
|
|
self._run_git("config", "core.hooksPath", hooks_dir)
|
|
self._run_git_review('-s')
|
|
self.assertTrue(os.path.exists(os.path.join(hooks_dir,
|
|
'commit-msg')))
|
|
self._run_git("config", "--unset", "core.hooksPath")
|
|
|
|
def test_git_review_d(self):
|
|
"""Test git-review -d."""
|
|
self._run_git_review('-s')
|
|
|
|
# create new review to be downloaded
|
|
self._simple_change('test file modified', 'test commit message')
|
|
self._run_git_review()
|
|
change_id = self._run_git('log', '-1').split()[-1]
|
|
|
|
shutil.rmtree(self.test_dir)
|
|
|
|
# download clean Git repository and fresh change from Gerrit to it
|
|
self._run_git('clone', self.project_uri)
|
|
self.configure_gerrit_remote()
|
|
self._run_git_review('-d', change_id)
|
|
self.assertIn('test commit message', self._run_git('log', '-1'))
|
|
|
|
# test backport branch
|
|
self._run_git('checkout', '-b', 'mybackport',
|
|
self._remote + '/' + 'testbranch')
|
|
self._simple_change('test file modified in branch',
|
|
'test branch commit message\n\nChange-Id: %s' %
|
|
change_id)
|
|
self._run_git_review('testbranch')
|
|
self._run_git('checkout', 'master')
|
|
self._run_git_review('-d', change_id, 'testbranch')
|
|
self.assertIn('test branch commit message',
|
|
self._run_git('log', '-1'))
|
|
|
|
# second download should also work correctly
|
|
self._run_git('checkout', 'master')
|
|
self._run_git_review('-d', change_id)
|
|
self.assertIn('test commit message', self._run_git('show', 'HEAD'))
|
|
self.assertNotIn('test commit message',
|
|
self._run_git('show', 'HEAD^1'))
|
|
|
|
# and branch is tracking
|
|
head = self._run_git('symbolic-ref', '-q', 'HEAD')
|
|
self.assertIn(
|
|
'refs/remotes/%s/master' % self._remote,
|
|
self._run_git("for-each-ref", "--format='%(upstream)'", head))
|
|
|
|
# add some more changes & upload
|
|
self._simple_amend('test 2nd rev',
|
|
self._dir('test', '2nd_rev_file.txt'))
|
|
self._run_git_review('-v')
|
|
self._simple_amend('test 3rd rev',
|
|
self._dir('test', '3rd_rev_file.txt'))
|
|
self._run_git_review('-v')
|
|
|
|
# get rev 2; assert rev2 file is there, but not rev3
|
|
self._run_git_review('-d', '%s,%s' % (change_id, 2))
|
|
self.assertIn('2nd_rev_file.txt',
|
|
self._run_git('show', 'HEAD'))
|
|
self.assertNotIn('3rd_rev_file.txt',
|
|
self._run_git('show', 'HEAD'))
|
|
|
|
def test_multiple_changes(self):
|
|
"""Test git-review asks about multiple changes.
|
|
|
|
Should register user's wish to send two change requests by interactive
|
|
'yes' message and by the -y option.
|
|
"""
|
|
self._run_git_review('-s')
|
|
|
|
# 'yes' message
|
|
self._simple_change('test file modified 1st time',
|
|
'test commit message 1')
|
|
self._simple_change('test file modified 2nd time',
|
|
'test commit message 2')
|
|
|
|
review_res = self._run_git_review(confirm=True)
|
|
self.assertIn("Type 'yes' to confirm", review_res)
|
|
self.assertIn("new: 2", review_res)
|
|
|
|
# abandon changes sent to the Gerrit
|
|
head = self._run_git('rev-parse', 'HEAD')
|
|
head_1 = self._run_git('rev-parse', 'HEAD^1')
|
|
self._run_gerrit_cli('review', '--abandon', head)
|
|
self._run_gerrit_cli('review', '--abandon', head_1)
|
|
|
|
# -y option
|
|
self._simple_change('test file modified 3rd time',
|
|
'test commit message 3')
|
|
self._simple_change('test file modified 4th time',
|
|
'test commit message 4')
|
|
review_res = self._run_git_review('-y')
|
|
self.assertIn("new: 2", review_res)
|
|
self.assertIn("remote: SUCCESS", review_res)
|
|
self.assertIn("test commit message 3 [NEW]", review_res)
|
|
self.assertIn("test commit message 4 [NEW]", review_res)
|
|
|
|
def test_git_review_re(self):
|
|
"""Test git-review adding reviewers to changes."""
|
|
self._run_git_review('-s')
|
|
|
|
# Create users to add as reviewers
|
|
self._run_gerrit_cli('create-account', '--email',
|
|
'reviewer1@example.com', 'reviewer1')
|
|
self._run_gerrit_cli('create-account', '--email',
|
|
'reviewer2@example.com', 'reviewer2')
|
|
|
|
self._simple_change('test file', 'test commit message')
|
|
|
|
review_res = self._run_git_review('--reviewers', 'reviewer1',
|
|
'reviewer2')
|
|
self.assertIn("new: 1", review_res)
|
|
|
|
# verify both reviewers are on patch set
|
|
head = self._run_git('rev-parse', 'HEAD')
|
|
change = self._run_gerrit_cli('query', '--format=JSON',
|
|
'--all-reviewers', head)
|
|
# The first result should be the one we want
|
|
change = json.loads(change.split('\n')[0])
|
|
|
|
self.assertEqual(2, len(change['allReviewers']))
|
|
|
|
reviewers = set()
|
|
for reviewer in change['allReviewers']:
|
|
reviewers.add(reviewer['username'])
|
|
|
|
self.assertEqual(set(['reviewer1', 'reviewer2']), reviewers)
|
|
|
|
def test_rebase_unstaged_changes_msg(self):
|
|
"""Test message displayed when unstaged changes are present."""
|
|
self._run_git_review('-s')
|
|
self._run_git('checkout', '-b', 'test_branch')
|
|
self._unstaged_change(change_text='simple message')
|
|
exc = self.assertRaises(Exception, self._run_git_review)
|
|
self.assertIn("You have unstaged changes. Please", exc.args[0])
|
|
|
|
def test_rebase_uncommitted_changes_msg(self):
|
|
"""Test message displayed when staged changes are present."""
|
|
self._run_git_review('-s')
|
|
self._run_git('checkout', '-b', 'test_branch')
|
|
self._uncommitted_change(change_text='simple message')
|
|
exc = self.assertRaises(Exception, self._run_git_review)
|
|
self.assertIn("You have uncommitted changes. Please", exc.args[0])
|
|
|
|
def test_ignore_unstaged_submodule_changes(self):
|
|
"""Test message displayed when unstaged changes are present."""
|
|
self._run_git_review('-s')
|
|
self._run_git('checkout', '-b', 'test_branch')
|
|
self._run_git_sub('init')
|
|
self._unstaged_change_sub(change_text='simple message')
|
|
self._run_git_review()
|
|
|
|
def test_ignore_uncommitted_submodule_changes(self):
|
|
"""Test message displayed when staged changes are present."""
|
|
self._run_git_review('-s')
|
|
self._run_git('checkout', '-b', 'test_branch')
|
|
self._run_git_sub('init')
|
|
self._uncommitted_change_sub(change_text='simple message')
|
|
self._run_git_review()
|
|
|
|
def test_rebase_no_remote_branch_msg(self):
|
|
"""Test message displayed where no remote branch exists."""
|
|
self._run_git_review('-s')
|
|
self._run_git('checkout', '-b', 'new_branch')
|
|
self._simple_change('simple message',
|
|
'need to avoid noop message')
|
|
exc = self.assertRaises(Exception, self._run_git_review, 'new_branch')
|
|
self.assertIn("The branch 'new_branch' does not exist on the given "
|
|
"remote '%s'" % self._remote, exc.args[0])
|
|
|
|
def test_need_rebase_no_upload(self):
|
|
"""Test change needing a rebase does not upload."""
|
|
self._run_git_review('-s')
|
|
head_1 = self._run_git('rev-parse', 'HEAD^1')
|
|
|
|
self._run_git('checkout', '-b', 'test_branch', head_1)
|
|
|
|
self._simple_change('some other message',
|
|
'create conflict with master')
|
|
|
|
exc = self.assertRaises(Exception, self._run_git_review)
|
|
rebased = ("Errors running git rebase --rebase-merges "
|
|
"-i remotes/%s/master" % self._remote in exc.args[0] or
|
|
"Errors running git rebase --preserve-merges "
|
|
"-i remotes/%s/master" % self._remote in exc.args[0])
|
|
self.assertTrue(rebased)
|
|
self.assertIn("It is likely that your change has a merge conflict.",
|
|
exc.args[0])
|
|
|
|
def test_upload_without_rebase(self):
|
|
"""Test change not needing a rebase can upload without rebasing."""
|
|
self._run_git_review('-s')
|
|
head_1 = self._run_git('rev-parse', 'HEAD^1')
|
|
|
|
self._run_git('checkout', '-b', 'test_branch', head_1)
|
|
|
|
self._simple_change('some new message',
|
|
'just another file (no conflict)',
|
|
self._dir('test', 'new_test_file.txt'))
|
|
|
|
review_res = self._run_git_review('-v')
|
|
rebased = ("Running: git rebase --rebase-merges "
|
|
"-i remotes/%s/master" % self._remote in review_res or
|
|
"Running: git rebase --preserve-merges "
|
|
"-i remotes/%s/master" % self._remote in review_res)
|
|
self.assertTrue(rebased)
|
|
self.assertEqual(self._run_git('rev-parse', 'HEAD^1'), head_1)
|
|
|
|
def test_uploads_with_nondefault_rebase(self):
|
|
"""Test changes rebase against correct branches."""
|
|
# prepare maintenance branch that is behind master
|
|
self._create_gitreview_file(track='true',
|
|
defaultremote='origin')
|
|
self._run_git('add', '.gitreview')
|
|
self._run_git('commit', '-m', 'track=true.')
|
|
self._simple_change('diverge master from maint',
|
|
'no conflict',
|
|
self._dir('test', 'test_file_to_diverge.txt'))
|
|
self._run_git('push', 'origin', 'master')
|
|
self._run_git('push', 'origin', 'master', 'master:other')
|
|
self._run_git_review('-s')
|
|
head_1 = self._run_git('rev-parse', 'HEAD^1')
|
|
self._run_gerrit_cli('create-branch',
|
|
'test/test_project',
|
|
'maint', head_1)
|
|
self._run_git('fetch')
|
|
|
|
br_out = self._run_git('checkout',
|
|
'-b', 'test_branch', 'origin/maint')
|
|
expected_track = (".*\nBranch '?test_branch'? set up to track remote "
|
|
"branch '?maint'? from '?origin'?.")
|
|
track_matcher = testtools.matchers.MatchesRegex(expected_track)
|
|
self.assertThat(br_out, track_matcher)
|
|
branches = self._run_git('branch', '-a')
|
|
expected_branch = '* test_branch'
|
|
observed = branches.split('\n')
|
|
self.assertIn(expected_branch, observed)
|
|
|
|
self._simple_change('some new message',
|
|
'just another file (no conflict)',
|
|
self._dir('test', 'new_tracked_test_file.txt'))
|
|
change_id = self._run_git('log', '-1').split()[-1]
|
|
|
|
review_res = self._run_git_review('-v')
|
|
# no rebase needed; if it breaks it would try to rebase to master
|
|
self.assertNotIn("Running: git rebase --rebase-merges "
|
|
"-i remotes/origin/master", review_res)
|
|
self.assertNotIn("Running: git rebase --preserve-merges "
|
|
"-i remotes/origin/master", review_res)
|
|
# Don't need to query gerrit for the branch as the second half
|
|
# of this test will work only if the branch was correctly
|
|
# stored in gerrit
|
|
|
|
# delete branch locally
|
|
self._run_git('checkout', 'master')
|
|
self._run_git('branch', '-D', 'test_branch')
|
|
|
|
# download, amend, submit
|
|
self._run_git_review('-d', change_id)
|
|
self._simple_amend('just another file (no conflict)',
|
|
self._dir('test', 'new_tracked_test_file_2.txt'))
|
|
new_change_id = self._run_git('log', '-1').split()[-1]
|
|
self.assertEqual(change_id, new_change_id)
|
|
review_res = self._run_git_review('-v')
|
|
# caused the right thing to happen
|
|
rebased = ("Running: git rebase --rebase-merges "
|
|
"-i remotes/origin/maint" in review_res or
|
|
"Running: git rebase --preserve-merges "
|
|
"-i remotes/origin/maint" in review_res)
|
|
self.assertTrue(rebased)
|
|
|
|
# track different branch than expected in changeset
|
|
branch = self._run_git('rev-parse', '--abbrev-ref', 'HEAD')
|
|
self._run_git('branch',
|
|
'--set-upstream-to',
|
|
'remotes/origin/other',
|
|
branch)
|
|
self.assertRaises(
|
|
Exception, # cmd.BranchTrackingMismatch inside
|
|
self._run_git_review, '-d', change_id)
|
|
|
|
def test_no_rebase_check(self):
|
|
"""Test -R causes a change to be uploaded without rebase checking."""
|
|
self._run_git_review('-s')
|
|
head_1 = self._run_git('rev-parse', 'HEAD^1')
|
|
|
|
self._run_git('checkout', '-b', 'test_branch', head_1)
|
|
self._simple_change('some new message', 'just another file',
|
|
self._dir('test', 'new_test_file.txt'))
|
|
|
|
review_res = self._run_git_review('-v', '-R')
|
|
self.assertNotIn('rebase', review_res)
|
|
self.assertEqual(self._run_git('rev-parse', 'HEAD^1'), head_1)
|
|
|
|
def test_rebase_anyway(self):
|
|
"""Test -F causes a change to be rebased regardless."""
|
|
self._run_git_review('-s')
|
|
head = self._run_git('rev-parse', 'HEAD')
|
|
head_1 = self._run_git('rev-parse', 'HEAD^1')
|
|
|
|
self._run_git('checkout', '-b', 'test_branch', head_1)
|
|
self._simple_change('some new message', 'just another file',
|
|
self._dir('test', 'new_test_file.txt'))
|
|
review_res = self._run_git_review('-v', '-F')
|
|
self.assertIn('rebase', review_res)
|
|
self.assertEqual(self._run_git('rev-parse', 'HEAD^1'), head)
|
|
|
|
def _assert_branch_would_be(self, branch, extra_args=None):
|
|
extra_args = extra_args or []
|
|
output = self._run_git_review('-n', *extra_args)
|
|
# last non-empty line should be:
|
|
# git push gerrit HEAD:refs/publish/master
|
|
last_line = output.strip().split('\n')[-1]
|
|
branch_was = last_line.rsplit(' ', 1)[-1].split('/', 2)[-1]
|
|
self.assertEqual(branch, branch_was)
|
|
|
|
def test_detached_head(self):
|
|
"""Test on a detached state: we shouldn't have '(detached' as topic."""
|
|
self._run_git_review('-s')
|
|
curr_branch = self._run_git('rev-parse', '--abbrev-ref', 'HEAD')
|
|
# Note: git checkout --detach has been introduced in git 1.7.5 (2011)
|
|
self._run_git('checkout', curr_branch + '^0')
|
|
self._simple_change('some new message', 'just another file',
|
|
self._dir('test', 'new_test_file.txt'))
|
|
# switch to French, 'git branch' should return '(détaché du HEAD)'
|
|
lang_env = os.getenv('LANG', 'C')
|
|
os.environ.update(LANG='fr_FR.UTF-8')
|
|
try:
|
|
self._assert_branch_would_be(curr_branch)
|
|
finally:
|
|
os.environ.update(LANG=lang_env)
|
|
|
|
def test_no_topic(self):
|
|
"""Test on change with no topic.
|
|
|
|
This will be checked out as 'review/{owner}/{ID}'. We don't want to set
|
|
the topic to '{ID}'.
|
|
"""
|
|
self._run_git_review('-s')
|
|
curr_branch = self._run_git('rev-parse', '--abbrev-ref', 'HEAD')
|
|
self._run_git('checkout', '-b', 'review/johndoe/123456')
|
|
self._simple_change('test file modified', 'derp derp derp')
|
|
self._assert_branch_would_be(curr_branch)
|
|
|
|
def test_git_review_t(self):
|
|
self._run_git_review('-s')
|
|
self._simple_change('test file modified', 'commit message for bug 654')
|
|
self._assert_branch_would_be('master%topic=zat',
|
|
extra_args=['-t', 'zat'])
|
|
|
|
# -t takes precedence over notopic
|
|
self._run_git('config', 'gitreview.notopic', 'true')
|
|
self._assert_branch_would_be('master%topic=zat',
|
|
extra_args=['-t', 'zat'])
|
|
|
|
def test_git_review_T(self):
|
|
self._run_git_review('-s')
|
|
self._run_git('checkout', '-b', 'bug/456')
|
|
self._simple_change('test file modified', 'commit message for bug 456')
|
|
self._assert_branch_would_be('master%topic=bug/456')
|
|
self._assert_branch_would_be('master', extra_args=['-T'])
|
|
|
|
self._run_git('config', 'gitreview.notopic', 'true')
|
|
self._assert_branch_would_be('master')
|
|
self._run_git('config', 'gitreview.notopic', 'false')
|
|
self._assert_branch_would_be('master%topic=bug/456')
|
|
|
|
# -T takes precedence over notopic=false
|
|
self._assert_branch_would_be('master', extra_args=['-T'])
|
|
|
|
def test_git_review_T_t(self):
|
|
self.assertRaises(Exception, self._run_git_review, '-T', '-t', 'taz')
|
|
|
|
def test_git_review_l(self):
|
|
self._run_git_review('-s')
|
|
|
|
# Populate "project" repo
|
|
self._simple_change('project: test1', 'project: change1, merged')
|
|
self._simple_change('project: test2', 'project: change2, open')
|
|
self._simple_change('project: test3', 'project: change3, abandoned')
|
|
self._run_git_review('-y')
|
|
head = self._run_git('rev-parse', 'HEAD')
|
|
head_2 = self._run_git('rev-parse', 'HEAD^^')
|
|
self._run_gerrit_cli('review', head_2, '--code-review=+2', '--submit')
|
|
self._run_gerrit_cli('review', head, '--abandon')
|
|
|
|
# Populate "project2" repo
|
|
self._run_gerrit_cli('create-project', 'test/test_project2',
|
|
'--empty-commit')
|
|
project2_uri = self.project_uri.replace('test/test_project',
|
|
'test/test_project2')
|
|
self._run_git('fetch', project2_uri, 'HEAD')
|
|
self._run_git('checkout', 'FETCH_HEAD')
|
|
# We have to rewrite the .gitreview file after this checkout.
|
|
self._create_gitreview_file()
|
|
self._simple_change('project2: test1', 'project2: change1, open')
|
|
self._run_git('push', project2_uri, 'HEAD:refs/for/master')
|
|
|
|
# Only project1 open changes
|
|
result = self._run_git_review('-l')
|
|
self.assertNotIn('project: change1, merged', result)
|
|
self.assertIn('project: change2, open', result)
|
|
self.assertNotIn('project: change3, abandoned', result)
|
|
self.assertNotIn('project2:', result)
|
|
|
|
def _test_git_review_F(self, rebase):
|
|
self._run_git_review('-s')
|
|
|
|
# Populate repo
|
|
self._simple_change('create file', 'test commit message')
|
|
change1 = self._run_git('rev-parse', 'HEAD')
|
|
self._run_git_review()
|
|
self._run_gerrit_cli('review', change1, '--code-review=+2', '--submit')
|
|
self._run_git('reset', '--hard', 'HEAD^')
|
|
|
|
# Review with force_rebase
|
|
self._run_git('config', 'gitreview.rebase', rebase)
|
|
self._simple_change('create file2', 'test commit message 2',
|
|
self._dir('test', 'test_file2.txt'))
|
|
self._run_git_review('-F')
|
|
head_1 = self._run_git('rev-parse', 'HEAD^')
|
|
self.assertEqual(change1, head_1)
|
|
|
|
def test_git_review_F(self):
|
|
self._test_git_review_F('1')
|
|
|
|
def test_git_review_F_norebase(self):
|
|
self._test_git_review_F('0')
|
|
|
|
def test_git_review_F_R(self):
|
|
self.assertRaises(Exception, self._run_git_review, '-F', '-R')
|
|
|
|
def test_git_review_no_thin(self):
|
|
"""Test git-review --no-thin."""
|
|
self._run_git_review('-s')
|
|
|
|
# Push with --no-thin set. We can't really introspect the packs
|
|
# that were sent so we infer success as the command not failing.
|
|
self._simple_change('test file modified', 'test commit message')
|
|
self._run_git_review('--no-thin')
|
|
|
|
def test_config_instead_of_honored(self):
|
|
self.set_remote('test_project_url')
|
|
|
|
self.assertRaises(Exception, self._run_git_review, '-l')
|
|
|
|
self._run_git('config', '--add', 'url.%s.insteadof' % self.project_uri,
|
|
'test_project_url')
|
|
self._run_git_review('-l')
|
|
|
|
def test_config_pushinsteadof_honored(self):
|
|
self.set_remote('test_project_url')
|
|
|
|
self.assertRaises(Exception, self._run_git_review, '-l')
|
|
|
|
self._run_git('config', '--add',
|
|
'url.%s.pushinsteadof' % self.project_uri,
|
|
'test_project_url')
|
|
self._run_git_review('-l')
|
|
|
|
|
|
class PushUrlTestCase(GitReviewTestCase):
|
|
"""Class for the git-review tests using origin push-url."""
|
|
|
|
_remote = 'origin'
|
|
|
|
def set_remote(self, uri):
|
|
self._run_git('remote', 'set-url', '--push', self._remote, uri)
|
|
|
|
def reset_remote(self):
|
|
self._run_git('config', '--unset', 'remote.%s.pushurl' % self._remote)
|
|
|
|
def configure_gerrit_remote(self):
|
|
self.set_remote(self.project_uri)
|
|
self._run_git('config', 'gitreview.usepushurl', '1')
|
|
|
|
def test_config_pushinsteadof_honored(self):
|
|
self.skipTest("pushinsteadof doesn't rewrite pushurls")
|
|
|
|
|
|
class HttpGitReviewTestCase(tests.HttpMixin, GitReviewTestCase):
|
|
"""Class for the git-review tests over HTTP(S)."""
|
|
pass
|