[ros-vcstools] 29/31: Imported Upstream version 0.1.38
Jochen Sprickerhof
jspricke-guest at moszumanska.debian.org
Sun Oct 18 14:23:23 UTC 2015
This is an automated email from the git hooks/post-receive script.
jspricke-guest pushed a commit to branch master
in repository ros-vcstools.
commit d54aa30a19d4d538efad3e54f15866526edc0ed3
Author: Jochen Sprickerhof <git at jochen.sprickerhof.de>
Date: Tue Oct 13 12:11:38 2015 +0200
Imported Upstream version 0.1.38
---
.travis.yml | 2 +-
doc/changelog.rst | 7 ++
src/vcstools/__version__.py | 2 +-
src/vcstools/git.py | 122 +++++++++++++++++++-------------
src/vcstools/vcs_abstraction.py | 3 +
src/vcstools/vcs_base.py | 14 +++-
test/test_git.py | 152 +++++++++++++++++++++-------------------
test/test_svn.py | 2 +
8 files changed, 182 insertions(+), 122 deletions(-)
diff --git a/.travis.yml b/.travis.yml
index 9863346..d9c5c7b 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -42,7 +42,7 @@ install:
- python setup.py build
# cannot build mercurial and bzr using py3k, but cannot use python2 in python2.6 case
- export PY2K=`python -c 'import sys; print("python2" if (sys.version_info[0] == 3) else "python")'`
- - pip install coverage
+ - pip install 'coverage<4'
- pip install cython
- pip install pep8
- pip install "pyyaml<=$PYYAML" > pyaml-warnings.log 2>&1 || (cat pyaml-warnings.log && false)
diff --git a/doc/changelog.rst b/doc/changelog.rst
index 15bcd23..ab79686 100644
--- a/doc/changelog.rst
+++ b/doc/changelog.rst
@@ -4,6 +4,13 @@ Changelog
0.1
===
+0.1.38
+------
+
+- Fixed test failures due to SVN 1.9.
+- Added the ``get_default_remote_version_label()`` API method to support changes in ``wstool``.
+- Renamed some internal functions to have a leading ``_`` to indicate that they are private.
+
0.1.37
------
diff --git a/src/vcstools/__version__.py b/src/vcstools/__version__.py
index 2d1c1e1..b0b983b 100644
--- a/src/vcstools/__version__.py
+++ b/src/vcstools/__version__.py
@@ -1 +1 @@
-version = '0.1.37'
+version = '0.1.38'
diff --git a/src/vcstools/git.py b/src/vcstools/git.py
index 8d456c8..1dd91d7 100644
--- a/src/vcstools/git.py
+++ b/src/vcstools/git.py
@@ -37,9 +37,11 @@ refnames in git can be branchnames, hashes, partial hashes, tags. On
checkout, git will disambiguate by checking them in that order, taking
the first that applies
-This class aims to provide git for linear centralized workflows. This
-means we assume that the only relevant remote is the one named
-"origin", and we assume that commits once on origin remain on origin.
+This class aims to provide git for linear centralized workflows. This
+means in case of ambiguity, we assume that the only relevant remote
+is the one named "origin", and we assume that commits once on origin
+remain on origin.
+
A challenge with git is that it has strong reasonable conventions, but
is very allowing for breaking them. E.g. it is possible to name
@@ -149,14 +151,22 @@ class GitClient(VcsClientBase):
def get_url(self):
"""
- :returns: GIT URL of the directory path (output of git info command), or None if it cannot be determined
+ :returns: git URL of the directory path (output of git info command), or None if it cannot be determined
"""
if self.detect_presence():
- cmd = "git config --get remote.origin.url"
+ cmd = "git config --get remote.%s.url" % self._get_default_remote()
_, output, _ = run_shell_command(cmd, shell=True, cwd=self._path)
return output.rstrip()
return None
+ def _get_default_remote(self):
+ """
+ in order to support users who name their default origin
+ something else than origin, read remote name.
+ """
+ # TODO: maybe pick other remote depending on context
+ return 'origin'
+
@staticmethod
def static_detect_presence(path):
# There is a proposed implementation of detect_presence which might be
@@ -204,7 +214,7 @@ class GitClient(VcsClientBase):
except GitError:
return False
- def update_submodules(self, verbose=False, timeout=None):
+ def _update_submodules(self, verbose=False, timeout=None):
# update and or init submodules too
if LooseVersion(self.gitversion) > LooseVersion('1.7'):
@@ -257,13 +267,13 @@ class GitClient(VcsClientBase):
:param update_submodules: if false, does not attempt to update submodules
'''
# are we on any branch?
- current_branch = self.get_branch()
+ current_branch = self._get_branch()
branch_parent = None
if current_branch:
# local branch might be named differently from remote by user, we respect that
same_branch = (refname == current_branch)
if not same_branch:
- (branch_parent, remote) = self.get_branch_parent(current_branch=current_branch)
+ (branch_parent, remote) = self._get_branch_parent(current_branch=current_branch)
if not refname:
# ! changing refname to cause fast-forward
refname = branch_parent
@@ -278,16 +288,17 @@ class GitClient(VcsClientBase):
if not refname:
# we are neither tracking, nor did we get any refname to update to
- return (not update_submodules) or self.update_submodules(verbose=verbose,
- timeout=timeout)
+ return (not update_submodules) or self._update_submodules(verbose=verbose,
+ timeout=timeout)
+ default_remote = self._get_default_remote()
if same_branch:
if fast_foward:
if not branch_parent and current_branch:
- (branch_parent, remote) = self.get_branch_parent(current_branch=current_branch)
- if remote != 'origin':
+ (branch_parent, remote) = self._get_branch_parent(current_branch=current_branch)
+ if remote != default_remote:
# if remote is not origin, must not fast-forward (because based on origin)
- sys.stderr.write("vcstools only handles branches tracking remote 'origin'," +
+ sys.stderr.write("vcstools only handles branches tracking default remote," +
" branch '%s' tracks remote '%s'\n" % (current_branch, remote))
branch_parent = None
# already on correct branch, fast-forward if there is a parent
@@ -299,12 +310,12 @@ class GitClient(VcsClientBase):
else:
# refname can be a different branch or something else than a branch
- refname_is_local_branch = self.is_local_branch(refname)
+ refname_is_local_branch = self._is_local_branch(refname)
if refname_is_local_branch:
# might also be remote branch, but we treat it as local
refname_is_remote_branch = False
else:
- refname_is_remote_branch = self.is_remote_branch(refname, fetch=False)
+ refname_is_remote_branch = self._is_remote_branch(refname, fetch=False)
refname_is_branch = refname_is_remote_branch or refname_is_local_branch
current_version = None
@@ -312,16 +323,16 @@ class GitClient(VcsClientBase):
if not refname_is_branch:
current_version = self.get_version()
if current_version == refname:
- return (not update_submodules) or self.update_submodules(verbose=verbose,
- timeout=timeout)
+ return (not update_submodules) or self._update_submodules(verbose=verbose,
+ timeout=timeout)
if current_branch is None:
if not current_version:
current_version = self.get_version()
# prevent commit from becoming dangling
- if self.is_commit_in_orphaned_subtree(current_version, fetch=False):
+ if self._is_commit_in_orphaned_subtree(current_version, fetch=False):
# commit becomes dangling unless we move to one of its descendants
- if not self.rev_list_contains(refname, current_version, fetch=False):
+ if not self._rev_list_contains(refname, current_version, fetch=False):
# TODO: should raise error instead of printing message
sys.stderr.write("vcstools refusing to move away from dangling commit, to protect your work.\n")
return False
@@ -331,10 +342,10 @@ class GitClient(VcsClientBase):
if refname_is_local_branch:
# if we just switched to a local tracking branch (not created one), we should also fast forward
- (new_branch_parent, remote) = self.get_branch_parent(current_branch=refname)
- if remote != 'origin':
+ (new_branch_parent, remote) = self._get_branch_parent(current_branch=refname)
+ if remote != default_remote:
# if remote is not origin, must not fast-forward (because based on origin)
- sys.stderr.write("vcstools only handles branches tracking remote 'origin'," +
+ sys.stderr.write("vcstools only handles branches tracking default remote," +
" branch '%s' tracks remote '%s'\n" % (current_branch, remote))
new_branch_parent = None
if new_branch_parent is not None:
@@ -343,30 +354,42 @@ class GitClient(VcsClientBase):
fetch=False,
verbose=verbose):
return False
- return (not update_submodules) or self.update_submodules(verbose=verbose, timeout=timeout)
+ return (not update_submodules) or self._update_submodules(verbose=verbose, timeout=timeout)
def get_current_version_label(self):
"""
For git we change the label to clarify when a different remote
is configured.
"""
- branch = self.get_branch()
+ branch = self._get_branch()
if branch is None:
return '<detached>'
result = branch
- (remote_branch, remote) = self.get_branch_parent()
+ (remote_branch, remote) = self._get_branch_parent()
if remote_branch is not None:
+ default_remote = self._get_default_remote()
# if not following 'origin/branch', display 'branch < tracked ref'
- if (remote_branch != branch or remote != 'origin'):
+ if (remote_branch != branch or remote != default_remote):
result += ' < '
- if remote != 'origin':
+ if remote != default_remote:
result += remote + '/'
result += remote_branch
return result
+ def get_default_remote_version_label(self):
+ if self.detect_presence():
+ _, output, _ = run_shell_command('git remote show %s' % self._get_default_remote(),
+ shell=True,
+ cwd=self._path)
+ for line in output.splitlines():
+ elems = line.split()
+ if elems[0:2] == ['HEAD', 'branch:']:
+ return elems[2]
+ return None
+
def get_remote_version(self, fetch=False):
# try tracked branch on origin (returns None if on other remote)
- (parent_branch, remote) = self.get_branch_parent(fetch=fetch)
+ (parent_branch, remote) = self._get_branch_parent(fetch=fetch)
if parent_branch is not None:
return self.get_version(spec=remote+'/'+parent_branch)
@@ -491,7 +514,7 @@ class GitClient(VcsClientBase):
response = response_processed
return response
- def is_remote_branch(self, branch_name, remote_name=None, fetch=True):
+ def _is_remote_branch(self, branch_name, remote_name=None, fetch=True):
"""
checks list of remote branches for match. Set fetch to False if you just fetched already.
@@ -499,7 +522,7 @@ class GitClient(VcsClientBase):
:raises: GitError when git fetch fails
"""
if remote_name is None:
- remote_name = "origin" # default remote name is origin
+ remote_name = self._get_default_remote()
if self.path_exists():
if fetch:
@@ -515,7 +538,7 @@ class GitClient(VcsClientBase):
return True
return False
- def is_local_branch(self, branch_name):
+ def _is_local_branch(self, branch_name):
if self.path_exists():
_, output, _ = run_shell_command('git branch',
shell=True,
@@ -530,7 +553,7 @@ class GitClient(VcsClientBase):
return True
return False
- def get_branch(self):
+ def _get_branch(self):
if self.path_exists():
_, output, _ = run_shell_command('git branch',
shell=True,
@@ -541,7 +564,7 @@ class GitClient(VcsClientBase):
return elems[1]
return None
- def get_branch_parent(self, fetch=False, current_branch=None):
+ def _get_branch_parent(self, fetch=False, current_branch=None):
"""
:param fetch: if true, performs git fetch first
:param current_branch: if not None, this is used as current branch (else extra shell call)
@@ -551,7 +574,7 @@ class GitClient(VcsClientBase):
if not self.path_exists():
return (None, None)
# get name of configured merge ref.
- branchname = current_branch or self.get_branch()
+ branchname = current_branch or self._get_branch()
if branchname is None:
return (None, None)
@@ -571,7 +594,7 @@ class GitClient(VcsClientBase):
# get name of configured remote
cmd = 'git config --get "branch.%s.remote"' % branchname
_, output2, _ = run_shell_command(cmd, shell=True, cwd=self._path)
- remote = output2 or 'origin'
+ remote = output2 or self._get_default_remote()
branch_reference = lines[0]
# branch_reference is either refname, or /refs/heads/refname, or
@@ -591,9 +614,11 @@ class GitClient(VcsClientBase):
candidate = candidate[len('remotes/'):]
result = None
- if self.is_remote_branch(candidate, remote_name=remote, fetch=fetch):
+ if self._is_remote_branch(candidate, remote_name=remote, fetch=fetch):
result = candidate
- elif branch_reference != candidate and self.is_remote_branch(branch_reference, remote_name=remote, fetch=False):
+ elif branch_reference != candidate and self._is_remote_branch(branch_reference,
+ remote_name=remote,
+ fetch=False):
result = branch_reference
if result is not None:
@@ -620,7 +645,7 @@ class GitClient(VcsClientBase):
return True
return False
- def rev_list_contains(self, refname, version, fetch=True):
+ def _rev_list_contains(self, refname, version, fetch=True):
"""
calls git rev-list with refname and returns True if version
can be found in rev-list result
@@ -653,7 +678,7 @@ class GitClient(VcsClientBase):
return True
return False
- def is_commit_in_orphaned_subtree(self, version, mask_self=False, fetch=True):
+ def _is_commit_in_orphaned_subtree(self, version, mask_self=False, fetch=True):
"""
checks git log --all (the list of all commits reached by
references, meaning branches or tags) for version. If it shows
@@ -761,19 +786,20 @@ class GitClient(VcsClientBase):
"""
assert branch_parent is not None
current_version = self.get_version()
- parent_version = self.get_version("remotes/origin/%s" % branch_parent)
+ default_remote = self._get_default_remote()
+ parent_version = self.get_version("remotes/%s/%s" % (default_remote, branch_parent))
if current_version == parent_version:
return True
# check if we are true ancestor of tracked branch
- if not self.rev_list_contains(parent_version,
- current_version,
- fetch=fetch):
+ if not self._rev_list_contains(parent_version,
+ current_version,
+ fetch=fetch):
# if not rev_list_contains this version, we are on same
# commit (checked before), have advanced, or have diverged.
# Now check whether tracked branch is a true ancestor of us
- if self.rev_list_contains(current_version,
- parent_version,
- fetch=False):
+ if self._rev_list_contains(current_version,
+ parent_version,
+ fetch=False):
return True
print("Cannot fast-forward, local repository and remote '%s' have diverged." % branch_parent)
return False
@@ -784,7 +810,7 @@ class GitClient(VcsClientBase):
if LooseVersion(self.gitversion) >= LooseVersion('1.7.1'):
# --keep allows o rebase even with local changes, as long as
# local changes are not in files that change between versions
- cmd = "git reset --keep remotes/origin/%s" % branch_parent
+ cmd = "git reset --keep remotes/%s/%s" % (default_remote, branch_parent)
value, _, _ = run_shell_command(cmd,
shell=True,
cwd=self._path,
@@ -798,7 +824,7 @@ class GitClient(VcsClientBase):
verboseflag = '-v'
# prior to version 1.7.1, git does not know --keep
# Do not merge, rebase does nothing when there are local changes
- cmd = "git rebase %s remotes/origin/%s" % (verboseflag, branch_parent)
+ cmd = "git rebase %s remotes/%s/%s" % (verboseflag, default_remote, branch_parent)
value, _, _ = run_shell_command(cmd,
shell=True,
cwd=self._path,
diff --git a/src/vcstools/vcs_abstraction.py b/src/vcstools/vcs_abstraction.py
index af51799..ecb1bbc 100644
--- a/src/vcstools/vcs_abstraction.py
+++ b/src/vcstools/vcs_abstraction.py
@@ -107,6 +107,9 @@ class VcsClient(object):
def get_remote_version(self, fetch=False):
return self.vcs.get_remote_version(fetch)
+ def get_default_remote_version_label(self):
+ return self.vcs.get_default_remote_version_label()
+
def checkout(self, url, version='', verbose=False, shallow=False):
return self.vcs.checkout(url,
version,
diff --git a/src/vcstools/vcs_base.py b/src/vcstools/vcs_base.py
index 901406b..7b67429 100644
--- a/src/vcstools/vcs_base.py
+++ b/src/vcstools/vcs_base.py
@@ -108,7 +108,7 @@ class VcsClientBase(object):
def get_url(self):
"""
- :returns: The source control url for the path
+ :returns: The source control url for the path or None if not set
:rtype: str
"""
raise NotImplementedError(
@@ -155,6 +155,18 @@ class VcsClientBase(object):
raise NotImplementedError("Base class get_remote_version method must be overridden for client type %s " %
self._vcs_type_name)
+ def get_default_remote_version_label(self):
+ """
+ Find a label for the default branch on remote, meaning
+ the one that would be checked out on a clean checkout.
+
+ :returns: a label or None (if not applicable)
+ :rtype: str
+ """
+ raise NotImplementedError("Base class get_default_remote_version_label" +
+ "method must be overridden for client type %s " %
+ self._vcs_type_name)
+
def checkout(self, url, version=None, verbose=False, shallow=False, timeout=None):
"""
Attempts to create a local repository given a remote
diff --git a/test/test_git.py b/test/test_git.py
index 4da4f84..e22c503 100644
--- a/test/test_git.py
+++ b/test/test_git.py
@@ -101,6 +101,16 @@ class GitClientTestSetups(unittest.TestCase):
if os.path.exists(self.local_path):
shutil.rmtree(self.local_path)
+class GitSwitchDefaultBranchTest(GitClientTestSetups):
+ def test_get_default_remote_version_label(self):
+ url = self.remote_path
+ client = GitClient(self.local_path)
+ self.assertTrue(client.checkout(url))
+ self.assertEqual(client.get_default_remote_version_label(), 'master')
+ subprocess.check_call("git symbolic-ref HEAD refs/heads/test_branch", shell=True, cwd=self.remote_path)
+ self.assertEqual(client.get_default_remote_version_label(), 'test_branch')
+
+
class GitClientTest(GitClientTestSetups):
@@ -117,10 +127,10 @@ class GitClientTest(GitClientTestSetups):
self.assertEqual(client.get_version(self.readonly_version_init[0:6]), self.readonly_version_init)
self.assertEqual(client.get_version("test_tag"), self.readonly_version_init)
# private functions
- self.assertFalse(client.is_local_branch("test_branch"))
- self.assertTrue(client.is_remote_branch("test_branch"))
+ self.assertFalse(client._is_local_branch("test_branch"))
+ self.assertTrue(client._is_remote_branch("test_branch"))
self.assertTrue(client.is_tag("test_tag"))
- self.assertFalse(client.is_remote_branch("test_tag"))
+ self.assertFalse(client._is_remote_branch("test_tag"))
self.assertFalse(client.is_tag("test_branch"))
def test_get_url_nonexistant(self):
@@ -143,8 +153,8 @@ class GitClientTest(GitClientTestSetups):
self.assertTrue(client.detect_presence())
self.assertEqual(client.get_path(), self.local_path)
self.assertEqual(client.get_url(), url)
- self.assertEqual(client.get_branch(), "master")
- self.assertEqual(client.get_branch_parent(), ("master", "origin"))
+ self.assertEqual(client._get_branch(), "master")
+ self.assertEqual(client._get_branch_parent(), ("master", "origin"))
#self.assertEqual(client.get_version(), '-r*')
def test_checkout_dir_exists(self):
@@ -175,7 +185,7 @@ class GitClientTest(GitClientTestSetups):
return True
client._do_fetch = types.MethodType(ifetch, client)
client._do_fast_forward = types.MethodType(iff, client)
- client.update_submodules = types.MethodType(isubm, client)
+ client._update_submodules = types.MethodType(isubm, client)
url = self.remote_path
self.assertFalse(client.path_exists())
self.assertFalse(client.detect_presence())
@@ -215,7 +225,7 @@ class GitClientTest(GitClientTestSetups):
return True
client._do_fetch = types.MethodType(ifetch, client)
client._do_fast_forward = types.MethodType(iff, client)
- client.update_submodules = types.MethodType(isubm, client)
+ client._update_submodules = types.MethodType(isubm, client)
url = self.remote_path
self.assertFalse(client.path_exists())
self.assertFalse(client.detect_presence())
@@ -234,8 +244,8 @@ class GitClientTest(GitClientTestSetups):
self.assertTrue(client.detect_presence())
self.assertEqual(client.get_path(), self.local_path)
self.assertEqual(client.get_url(), url)
- self.assertEqual(client.get_branch(), "master")
- self.assertEqual(client.get_branch_parent(), ("master", "origin"))
+ self.assertEqual(client._get_branch(), "master")
+ self.assertEqual(client._get_branch_parent(), ("master", "origin"))
po = subprocess.Popen("git log --pretty=format:%H", shell=True, cwd=self.local_path, stdout=subprocess.PIPE)
log = po.stdout.read().decode('UTF-8').strip().splitlines()
if LooseVersion(client.gitversion) >= LooseVersion('1.8.2'):
@@ -274,10 +284,10 @@ class GitClientTest(GitClientTestSetups):
self.assertTrue(client.detect_presence())
self.assertEqual(client.get_path(), self.local_path)
self.assertEqual(client.get_url(), url)
- self.assertEqual(client.get_branch_parent(), (branch, "origin"))
+ self.assertEqual(client._get_branch_parent(), (branch, "origin"))
self.assertTrue(client.update(branch))
- self.assertEqual(client.get_branch_parent(), (branch, "origin"))
+ self.assertEqual(client._get_branch_parent(), (branch, "origin"))
def test_checkout_specific_branch_and_update(self):
# subdir = "checkout_specific_version_test"
@@ -289,27 +299,27 @@ class GitClientTest(GitClientTestSetups):
self.assertTrue(client.checkout(url, branch))
self.assertTrue(client.path_exists())
self.assertTrue(client.detect_presence())
- self.assertTrue(client.is_local_branch(branch))
+ self.assertTrue(client._is_local_branch(branch))
self.assertEqual(client.get_path(), self.local_path)
self.assertEqual(client.get_url(), url)
self.assertEqual(client.get_version(), self.readonly_version_init)
- self.assertEqual(client.get_branch(), branch)
- self.assertEqual(client.get_branch_parent(), (branch, "origin"))
+ self.assertEqual(client._get_branch(), branch)
+ self.assertEqual(client._get_branch_parent(), (branch, "origin"))
self.assertTrue(client.update()) # no arg
- self.assertEqual(client.get_branch(), branch)
+ self.assertEqual(client._get_branch(), branch)
self.assertEqual(client.get_version(), self.readonly_version_init)
- self.assertEqual(client.get_branch_parent(), (branch, "origin"))
+ self.assertEqual(client._get_branch_parent(), (branch, "origin"))
self.assertTrue(client.update(branch)) # same branch arg
- self.assertEqual(client.get_branch(), branch)
+ self.assertEqual(client._get_branch(), branch)
self.assertEqual(client.get_version(), self.readonly_version_init)
- self.assertEqual(client.get_branch_parent(), (branch, "origin"))
+ self.assertEqual(client._get_branch_parent(), (branch, "origin"))
new_branch = 'master'
self.assertTrue(client.update(new_branch))
- self.assertEqual(client.get_branch(), new_branch)
- self.assertEqual(client.get_branch_parent(), (new_branch, "origin"))
+ self.assertEqual(client._get_branch(), new_branch)
+ self.assertEqual(client._get_branch_parent(), (new_branch, "origin"))
def test_checkout_local_only_branch_and_update(self):
# prevent regression on wstool#25: no rebase after switching branch
@@ -321,15 +331,15 @@ class GitClientTest(GitClientTestSetups):
self.assertTrue(client.checkout(url, branch))
self.assertTrue(client.path_exists())
self.assertTrue(client.detect_presence())
- self.assertTrue(client.is_local_branch(branch))
+ self.assertTrue(client._is_local_branch(branch))
subprocess.check_call("git reset --hard HEAD~1", shell=True, cwd=self.local_path)
subprocess.check_call("git checkout -b new_local_branch", shell=True, cwd=self.local_path)
self.assertTrue(client.update(branch)) # same branch arg
- self.assertEqual(client.get_branch(), branch)
+ self.assertEqual(client._get_branch(), branch)
self.assertEqual(client.get_version(), self.readonly_version)
- self.assertEqual(client.get_branch_parent(), (branch, "origin"))
+ self.assertEqual(client._get_branch_parent(), (branch, "origin"))
def test_checkout_specific_tag_and_update(self):
@@ -343,14 +353,14 @@ class GitClientTest(GitClientTestSetups):
self.assertTrue(client.detect_presence())
self.assertEqual(client.get_path(), self.local_path)
self.assertEqual(client.get_url(), url)
- self.assertEqual(client.get_branch_parent(), (None, None))
+ self.assertEqual(client._get_branch_parent(), (None, None))
tag = "test_tag"
self.assertTrue(client.update(tag))
- self.assertEqual(client.get_branch_parent(), (None, None))
+ self.assertEqual(client._get_branch_parent(), (None, None))
new_branch = 'master'
self.assertTrue(client.update(new_branch))
- self.assertEqual(client.get_branch_parent(), (new_branch, "origin"))
+ self.assertEqual(client._get_branch_parent(), (new_branch, "origin"))
tag = "test_tag"
self.assertTrue(client.update(tag))
@@ -380,7 +390,7 @@ class GitClientTest(GitClientTestSetups):
# replace "refs/head/master" with just "master"
subprocess.check_call("git config --replace-all branch.master.merge master", shell=True, cwd=self.local_path)
- self.assertTrue(client.get_branch_parent() is not (None, None))
+ self.assertTrue(client._get_branch_parent() is not (None, None))
def test_get_version_not_exist(self):
client = GitClient(path=self.local_path)
@@ -390,18 +400,18 @@ class GitClientTest(GitClientTestSetups):
def test_get_branch_parent(self):
client = GitClient(path=self.local_path)
client.checkout(url=self.remote_path, version='master')
- self.assertEqual(client.get_branch_parent(), ("master", "origin"))
+ self.assertEqual(client._get_branch_parent(), ("master", "origin"))
# with other remote than origin
for cmd in ['git remote add remote2 %s' % self.remote_path,
'git config --replace-all branch.master.remote remote2']:
subprocess.check_call(cmd, shell=True, cwd=self.local_path)
- self.assertEqual(client.get_branch_parent(), (None, None))
- self.assertEqual(client.get_branch_parent(fetch=True), ('master', "remote2"))
+ self.assertEqual(client._get_branch_parent(), (None, None))
+ self.assertEqual(client._get_branch_parent(fetch=True), ('master', "remote2"))
# with not actual remote branch
cmd = 'git config --replace-all branch.master.merge dummy_branch'
subprocess.check_call(cmd, shell=True, cwd=self.local_path)
- self.assertEqual(client.get_branch_parent(), (None, None))
+ self.assertEqual(client._get_branch_parent(), (None, None))
# return remote back to original config
for cmd in [
'git config --replace-all branch.master.remote origin',
@@ -410,7 +420,7 @@ class GitClientTest(GitClientTestSetups):
# with detached local status
client.update(version='test_tag')
- self.assertEqual(client.get_branch_parent(), (None, None))
+ self.assertEqual(client._get_branch_parent(), (None, None))
# back to master branch
client.update(version='master')
@@ -488,7 +498,7 @@ class GitClientUpdateTest(GitClientTestSetups):
url = self.remote_path
client = GitClient(self.local_path)
self.assertTrue(client.checkout(url, "master"))
- self.assertEqual(client.get_branch(), "master")
+ self.assertEqual(client._get_branch(), "master")
self.assertTrue(client.update())
p = subprocess.Popen("git tag", shell=True, cwd=self.local_path, stdout=subprocess.PIPE)
output = p.communicate()[0].decode('utf-8')
@@ -530,7 +540,7 @@ class GitClientRemoteVersionFetchTest(GitClientTestSetups):
url = self.remote_path
client = GitClient(self.local_path)
self.assertTrue(client.checkout(url, "master"))
- self.assertEqual(client.get_branch(), "master")
+ self.assertEqual(client._get_branch(), "master")
self.assertEqual(client.get_remote_version(fetch=False), self.readonly_version)
self.assertEqual(client.get_remote_version(fetch=True), self.readonly_version)
@@ -639,30 +649,30 @@ class GitClientDanglingCommitsTest(GitClientTestSetups):
def test_is_commit_in_orphaned_subtree(self):
client = GitClient(self.local_path)
- self.assertTrue(client.is_commit_in_orphaned_subtree(self.dangling_version))
- self.assertFalse(client.is_commit_in_orphaned_subtree(self.no_br_tag_version))
- self.assertFalse(client.is_commit_in_orphaned_subtree(self.diverged_branch_version))
+ self.assertTrue(client._is_commit_in_orphaned_subtree(self.dangling_version))
+ self.assertFalse(client._is_commit_in_orphaned_subtree(self.no_br_tag_version))
+ self.assertFalse(client._is_commit_in_orphaned_subtree(self.diverged_branch_version))
def test_protect_dangling(self):
client = GitClient(self.local_path)
# url = self.remote_path
- self.assertEqual(client.get_branch(), "master")
+ self.assertEqual(client._get_branch(), "master")
tag = "no_br_tag"
self.assertTrue(client.update(tag))
- self.assertEqual(client.get_branch(), None)
- self.assertEqual(client.get_branch_parent(), (None, None))
+ self.assertEqual(client._get_branch(), None)
+ self.assertEqual(client._get_branch_parent(), (None, None))
tag = "test_tag"
self.assertTrue(client.update(tag))
- self.assertEqual(client.get_branch(), None)
- self.assertEqual(client.get_branch_parent(), (None, None))
+ self.assertEqual(client._get_branch(), None)
+ self.assertEqual(client._get_branch_parent(), (None, None))
# to dangling commit
sha = self.dangling_version
self.assertTrue(client.update(sha))
- self.assertEqual(client.get_branch(), None)
+ self.assertEqual(client._get_branch(), None)
self.assertEqual(client.get_version(), self.dangling_version)
- self.assertEqual(client.get_branch_parent(), (None, None))
+ self.assertEqual(client._get_branch_parent(), (None, None))
# now HEAD protects the dangling commit, should not be allowed to move off.
new_branch = 'master'
@@ -671,75 +681,75 @@ class GitClientDanglingCommitsTest(GitClientTestSetups):
def test_detached_to_branch(self):
client = GitClient(self.local_path)
# url = self.remote_path
- self.assertEqual(client.get_branch(), "master")
+ self.assertEqual(client._get_branch(), "master")
tag = "no_br_tag"
self.assertTrue(client.update(tag))
- self.assertEqual(client.get_branch(), None)
- self.assertEqual(client.get_branch_parent(), (None, None))
+ self.assertEqual(client._get_branch(), None)
+ self.assertEqual(client._get_branch_parent(), (None, None))
tag = "test_tag"
self.assertTrue(client.update(tag))
- self.assertEqual(client.get_branch(), None)
+ self.assertEqual(client._get_branch(), None)
self.assertEqual(client.get_version(), self.readonly_version_init)
- self.assertEqual(client.get_branch_parent(), (None, None))
+ self.assertEqual(client._get_branch_parent(), (None, None))
#update should not change anything
self.assertTrue(client.update()) # no arg
- self.assertEqual(client.get_branch(), None)
+ self.assertEqual(client._get_branch(), None)
self.assertEqual(client.get_version(), self.readonly_version_init)
- self.assertEqual(client.get_branch_parent(), (None, None))
+ self.assertEqual(client._get_branch_parent(), (None, None))
new_branch = 'master'
self.assertTrue(client.update(new_branch))
- self.assertEqual(client.get_branch(), new_branch)
+ self.assertEqual(client._get_branch(), new_branch)
self.assertEqual(client.get_version(), self.readonly_version)
- self.assertEqual(client.get_branch_parent(), (new_branch, "origin"))
+ self.assertEqual(client._get_branch_parent(), (new_branch, "origin"))
def test_checkout_untracked_branch_and_update(self):
# difference to tracked branches is that branch parent is None, and we may hop outside lineage
client = GitClient(self.local_path)
url = self.remote_path
branch = "localbranch"
- self.assertEqual(client.get_branch(), "master")
+ self.assertEqual(client._get_branch(), "master")
self.assertTrue(client.path_exists())
self.assertTrue(client.detect_presence())
- self.assertTrue(client.is_local_branch(branch))
+ self.assertTrue(client._is_local_branch(branch))
self.assertEqual(client.get_path(), self.local_path)
self.assertEqual(client.get_url(), url)
self.assertTrue(client.update(branch))
self.assertEqual(client.get_version(), self.untracked_version)
- self.assertEqual(client.get_branch(), branch)
- self.assertEqual(client.get_branch_parent(), (None, None))
+ self.assertEqual(client._get_branch(), branch)
+ self.assertEqual(client._get_branch_parent(), (None, None))
self.assertTrue(client.update()) # no arg
- self.assertEqual(client.get_branch(), branch)
+ self.assertEqual(client._get_branch(), branch)
self.assertEqual(client.get_version(), self.untracked_version)
- self.assertEqual(client.get_branch_parent(), (None, None))
+ self.assertEqual(client._get_branch_parent(), (None, None))
self.assertTrue(client.update(branch)) # same branch arg
- self.assertEqual(client.get_branch(), branch)
+ self.assertEqual(client._get_branch(), branch)
self.assertEqual(client.get_version(), self.untracked_version)
- self.assertEqual(client.get_branch_parent(), (None, None))
+ self.assertEqual(client._get_branch_parent(), (None, None))
# to master
new_branch = 'master'
self.assertTrue(client.update(new_branch))
- self.assertEqual(client.get_branch(), new_branch)
+ self.assertEqual(client._get_branch(), new_branch)
self.assertEqual(client.get_version(), self.readonly_version)
- self.assertEqual(client.get_branch_parent(), (new_branch, "origin"))
+ self.assertEqual(client._get_branch_parent(), (new_branch, "origin"))
# and back
self.assertTrue(client.update(branch)) # same branch arg
- self.assertEqual(client.get_branch(), branch)
+ self.assertEqual(client._get_branch(), branch)
self.assertEqual(client.get_version(), self.untracked_version)
- self.assertEqual(client.get_branch_parent(), (None, None))
+ self.assertEqual(client._get_branch_parent(), (None, None))
# to dangling commit
sha = self.dangling_version
self.assertTrue(client.update(sha))
- self.assertEqual(client.get_branch(), None)
+ self.assertEqual(client._get_branch(), None)
self.assertEqual(client.get_version(), self.dangling_version)
- self.assertEqual(client.get_branch_parent(), (None, None))
+ self.assertEqual(client._get_branch_parent(), (None, None))
#should not work to protect commits from becoming dangled
# to commit outside lineage
@@ -754,12 +764,12 @@ class GitClientDanglingCommitsTest(GitClientTestSetups):
except VcsError:
pass
try:
- client.rev_list_contains('foo"; echo bar"', "foo", fetch=False)
+ client._rev_list_contains('foo"; echo bar"', "foo", fetch=False)
self.fail("expected Exception")
except VcsError:
pass
try:
- client.rev_list_contains('foo', 'foo"; echo bar"', fetch=False)
+ client._rev_list_contains('foo', 'foo"; echo bar"', fetch=False)
self.fail("expected Exception")
except VcsError:
pass
@@ -789,7 +799,7 @@ class GitClientOverflowTest(GitClientTestSetups):
def test_orphaned_overflow(self):
client = GitClient(self.local_path)
# this failed when passing all ref ids to git log
- self.assertFalse(client.is_commit_in_orphaned_subtree(self.last_version))
+ self.assertFalse(client._is_commit_in_orphaned_subtree(self.last_version))
class GitDiffStatClientTest(GitClientTestSetups):
@@ -927,7 +937,7 @@ class GitTimeoutTest(unittest.TestCase):
url = 'ssh://test@127.0.0.1:{0}/test'.format(self.mute_port)
client = GitClient(self.local_path)
start = time.time()
-
+
self.assertFalse(client.checkout(url, timeout=2.0))
stop = time.time()
self.assertTrue(stop - start > 1.9)
diff --git a/test/test_svn.py b/test/test_svn.py
index 0c661d8..7035d55 100644
--- a/test/test_svn.py
+++ b/test/test_svn.py
@@ -371,6 +371,8 @@ class SvnDiffStatClientTest(SvnClientTestSetups):
# new svn versions use different labels for added
# files (working copy) vs (revision x)
fixedline = re.sub('\(revision [0-9]+\)', '(working copy)', line)
+ # svn 1.9 added (nonexistent)
+ fixedline = re.sub('\(nonexistent\)', '(working copy)', fixedline)
newblock.append(fixedline)
return "\n".join(newblock)
--
Alioth's /usr/local/bin/git-commit-notice on /srv/git.debian.org/git/debian-science/packages/ros/ros-vcstools.git
More information about the debian-science-commits
mailing list