git cl: refactor branch setting get/set.

tests/git_cl_test.py

 #!/usr/bin/env python
 # Copyright (c) 2012 The Chromium Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 """Unit tests for git_cl.py."""
 
 import os
 import StringIO
 import stat
 import sys
 import unittest
 import urlparse
 
 sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
 
 from testing_support.auto_stub import TestCase
 
 import git_cl
 import git_common
 import git_footers
 import subprocess2
 
+def callError(code=1, cmd='', cwd='', stdout='', stderr=''):
+  return subprocess2.CalledProcessError(code, cmd, cwd, stdout, stderr)
+
+
+CERR1 = callError(1)
+
+
 class ChangelistMock(object):
   # A class variable so we can access it when we don't have access to the
   # instance that's being set.
   desc = ""
   def __init__(self, **kwargs):
     pass
   def GetIssue(self):
     return 1
   def GetDescription(self):
     return ChangelistMock.desc
   def UpdateDescription(self, desc):
     ChangelistMock.desc = desc
 
+
 class PresubmitMock(object):
   def __init__(self, *args, **kwargs):
     self.reviewers = []
   @staticmethod
   def should_continue():
     return True
 
 
 class RietveldMock(object):
   def __init__(self, *args, **kwargs):
@@ skipping 179 matching lines @@
 
 
 class TestGitCl(TestCase):
   def setUp(self):
     super(TestGitCl, self).setUp()
     self.calls = []
     self._calls_done = []
     self.mock(subprocess2, 'call', self._mocked_call)
     self.mock(subprocess2, 'check_call', self._mocked_call)
     self.mock(subprocess2, 'check_output', self._mocked_call)
-    self.mock(subprocess2, 'communicate', self._mocked_call)
+    self.mock(subprocess2, 'communicate',
+              lambda *a, **kw: ([self._mocked_call(*a, **kw), ''], 0))
     self.mock(git_cl.gclient_utils, 'CheckCallAndFilter', self._mocked_call)
     self.mock(git_common, 'is_dirty_git_tree', lambda x: False)
     self.mock(git_common, 'get_or_create_merge_base',
               lambda *a: (
                   self._mocked_call(['get_or_create_merge_base']+list(a))))
     self.mock(git_cl, 'BranchExists', lambda _: True)
     self.mock(git_cl, 'FindCodereviewSettingsFile', lambda: '')
     self.mock(git_cl, 'ask_for_data', self._mocked_call)
     self.mock(git_cl.presubmit_support, 'DoPresubmitChecks', PresubmitMock)
     self.mock(git_cl.rietveld, 'Rietveld', RietveldMock)
@@ skipping 15 matching lines @@
       if not self.has_failed():
         self.assertEquals([], self.calls)
     finally:
       super(TestGitCl, self).tearDown()
 
   def _mocked_call(self, *args, **_kwargs):
     self.assertTrue(
         self.calls,
         '@%d  Expected: <Missing>   Actual: %r' % (len(self._calls_done), args))
     top = self.calls.pop(0)
-    if len(top) > 2 and top[2]:
-      raise top[2]
     expected_args, result = top
+    if isinstance(result, Exception):
+      exc = result
+      result = None
+    else:
+      exc = None
 
     # Also logs otherwise it could get caught in a try/finally and be hard to
     # diagnose.
     if expected_args != args:
       N = 5
       prior_calls  = '\n  '.join(
           '@%d: %r' % (len(self._calls_done) - N + i, c[0])
           for i, c in enumerate(self._calls_done[-N:]))
       following_calls = '\n  '.join(
           '@%d: %r' % (len(self._calls_done) + i + 1, c[0])
           for i, c in enumerate(self.calls[:N]))
       extended_msg = (
           'A few prior calls:\n  %s\n\n'
           'This (expected):\n  @%d: %r\n'
           'This (actual):\n  @%d: %r\n\n'
           'A few following expected calls:\n  %s' %
           (prior_calls, len(self._calls_done), expected_args,
            len(self._calls_done), args, following_calls))
       git_cl.logging.error(extended_msg)
 
       self.fail('@%d\n'
                 '  Expected: %r\n'
                 '  Actual:   %r' % (
           len(self._calls_done), expected_args, args))
 
     self._calls_done.append(top)
-    return result
+    if exc is None:
+      return result
+    raise exc
 
   @classmethod
   def _is_gerrit_calls(cls, gerrit=False):
     return [((['git', 'config', 'rietveld.autoupdate'],), ''),
             ((['git', 'config', 'gerrit.host'],), 'True' if gerrit else '')]
 
   @classmethod
   def _upload_calls(cls, similarity, find_copies, private):
     return (cls._git_base_calls(similarity, find_copies) +
             cls._git_upload_calls(private))
 
   @classmethod
   def _upload_no_rev_calls(cls, similarity, find_copies):
     return (cls._git_base_calls(similarity, find_copies) +
             cls._git_upload_no_rev_calls())
 
   @classmethod
   def _git_base_calls(cls, similarity, find_copies):
     if similarity is None:
       similarity = '50'
-      similarity_call = ((['git', 'config', '--int', '--get',
-                         'branch.master.git-cl-similarity'],), '')
+      similarity_call = ((['git', 'config', '--int',
+                         'branch.master.git-cl-similarity'],), CERR1)
     else:
       similarity_call = ((['git', 'config', '--int',
-                         'branch.master.git-cl-similarity', similarity],), '')
+                           'branch.master.git-cl-similarity', similarity],), '')
 
     if find_copies is None:
       find_copies = True
-      find_copies_call = ((['git', 'config', '--int', '--get',
-                          'branch.master.git-find-copies'],), '')
+      find_copies_call = ((['git', 'config', '--bool',
+                          'branch.master.git-find-copies'],), CERR1)
     else:
-      val = str(int(find_copies))
-      find_copies_call = ((['git', 'config', '--int',
+      val = str(find_copies).lower()
+      find_copies_call = ((['git', 'config', '--bool',
                           'branch.master.git-find-copies', val],), '')
 
     if find_copies:
       stat_call = ((['git', 'diff', '--no-ext-diff', '--stat',
                    '--find-copies-harder', '-l100000', '-C'+similarity,
                    'fake_ancestor_sha', 'HEAD'],), '+dat')
     else:
       stat_call = ((['git', 'diff', '--no-ext-diff', '--stat',
                    '-M'+similarity, 'fake_ancestor_sha', 'HEAD'],), '+dat')
 
     return [
       ((['git', 'symbolic-ref', 'HEAD'],), 'master'),
       similarity_call,
       ((['git', 'symbolic-ref', 'HEAD'],), 'master'),
       find_copies_call,
     ] + cls._is_gerrit_calls() + [
       ((['git', 'symbolic-ref', 'HEAD'],), 'master'),
-      ((['git', 'config', 'branch.master.rietveldissue'],), ''),
-      ((['git', 'config', 'branch.master.gerritissue'],), ''),
+      ((['git', 'config', '--int', 'branch.master.rietveldissue'],), CERR1),
+      ((['git', 'config', '--int', 'branch.master.gerritissue'],), CERR1),
       ((['git', 'config', 'rietveld.server'],),
        'codereview.example.com'),
       ((['git', 'config', 'branch.master.merge'],), 'master'),
       ((['git', 'config', 'branch.master.remote'],), 'origin'),
       ((['get_or_create_merge_base', 'master', 'master'],),
        'fake_ancestor_sha'),
     ] + cls._git_sanity_checks('fake_ancestor_sha', 'master') + [
       ((['git', 'rev-parse', '--show-cdup'],), ''),
       ((['git', 'rev-parse', 'HEAD'],), '12345'),
       ((['git', 'diff', '--name-status', '--no-renames', '-r',
          'fake_ancestor_sha...', '.'],),
         'M\t.gitignore\n'),
-      ((['git', 'config', 'branch.master.rietveldpatchset'],),
-       ''),
+      ((['git', 'config', '--int', 'branch.master.rietveldpatchset'],), CERR1),
       ((['git', 'log', '--pretty=format:%s%n%n%b',
          'fake_ancestor_sha...'],),
        'foo'),
       ((['git', 'config', 'user.email'],), 'me@example.com'),
       stat_call,
       ((['git', 'log', '--pretty=format:%s\n\n%b',
          'fake_ancestor_sha..HEAD'],),
        'desc\n'),
       ((['git', 'config', 'rietveld.bug-prefix'],), ''),
     ]
@@ skipping 18 matching lines @@
         ((['git', 'config', 'core.editor'],), ''),
     ] + cc_call + private_call + [
         ((['git', 'config', 'branch.master.base-url'],), ''),
         ((['git', 'config', 'rietveld.pending-ref-prefix'],), ''),
         ((['git',
            'config', '--local', '--get-regexp', '^svn-remote\\.'],),
          (('', None), 0)),
         ((['git', 'rev-parse', '--show-cdup'],), ''),
         ((['git', 'svn', 'info'],), ''),
         ((['git', 'config', 'rietveld.project'],), ''),
-        ((['git',
-           'config', 'branch.master.rietveldissue', '1'],), ''),
+        ((['git', 'config', '--int', 'branch.master.rietveldissue', '1'],), ''),
         ((['git', 'config', 'branch.master.rietveldserver',
            'https://codereview.example.com'],), ''),
         ((['git',
-           'config', 'branch.master.rietveldpatchset', '2'],), ''),
+           'config', '--int', 'branch.master.rietveldpatchset', '2'],), ''),
     ] + cls._git_post_upload_calls()
 
   @classmethod
   def _git_post_upload_calls(cls):
     return [
         ((['git', 'rev-parse', 'HEAD'],), 'hash'),
         ((['git', 'symbolic-ref', 'HEAD'],), 'hash'),
         ((['git',
            'config', 'branch.hash.last-upload-hash', 'hash'],), ''),
         ((['git', 'config', 'rietveld.run-post-upload-hook'],), ''),
     ]
 
   @staticmethod
   def _git_sanity_checks(diff_base, working_branch, get_remote_branch=True):
     fake_ancestor = 'fake_ancestor'
     fake_cl = 'fake_cl_for_patch'
     return [
       ((['git',
          'rev-parse', '--verify', diff_base],), fake_ancestor),
       ((['git',
          'merge-base', fake_ancestor, 'HEAD'],), fake_ancestor),
       ((['git',
          'rev-list', '^' + fake_ancestor, 'HEAD'],), fake_cl),
       # Mock a config miss (error code 1)
       ((['git',
-         'config', 'gitcl.remotebranch'],), (('', None), 1)),
+         'config', 'gitcl.remotebranch'],), CERR1),
     ] + ([
       # Call to GetRemoteBranch()
       ((['git',
          'config', 'branch.%s.merge' % working_branch],),
        'refs/heads/master'),
       ((['git',
          'config', 'branch.%s.remote' % working_branch],), 'origin'),
     ] if get_remote_branch else []) + [
       ((['git', 'rev-list', '^' + fake_ancestor,
          'refs/remotes/origin/master'],), ''),
     ]
 
   @classmethod
   def _dcommit_calls_1(cls):
     return [
       ((['git', 'config', 'rietveld.autoupdate'],),
        ''),
       ((['git', 'config', 'rietveld.pending-ref-prefix'],),
        ''),
       ((['git',
          'config', '--local', '--get-regexp', '^svn-remote\\.'],),
        ((('svn-remote.svn.url svn://svn.chromium.org/chrome\n'
           'svn-remote.svn.fetch trunk/src:refs/remotes/origin/master'),
          None),
         0)),
       ((['git', 'symbolic-ref', 'HEAD'],), 'refs/heads/working'),
-      ((['git', 'config', '--int', '--get',
-        'branch.working.git-cl-similarity'],), ''),
+      ((['git', 'config', '--int',
+        'branch.working.git-cl-similarity'],), CERR1),
       ((['git', 'symbolic-ref', 'HEAD'],), 'refs/heads/working'),
-      ((['git', 'config', '--int', '--get',
-        'branch.working.git-find-copies'],), ''),
+      ((['git', 'config', '--bool',
+        'branch.working.git-find-copies'],), CERR1),
       ((['git', 'symbolic-ref', 'HEAD'],), 'refs/heads/working'),
       ((['git',
-         'config', 'branch.working.rietveldissue'],), '12345'),
+         'config', '--int', 'branch.working.rietveldissue'],), '12345'),
       ((['git',
          'config', 'rietveld.server'],), 'codereview.example.com'),
       ((['git',
          'config', 'branch.working.merge'],), 'refs/heads/master'),
       ((['git', 'config', 'branch.working.remote'],), 'origin'),
       ((['git', 'config', 'branch.working.merge'],),
        'refs/heads/master'),
       ((['git', 'config', 'branch.working.remote'],), 'origin'),
       ((['git', 'rev-list', '--merges',
          '--grep=^SVN changes up to revision [0-9]*$',
@@ skipping 16 matching lines @@
   def _dcommit_calls_normal(cls):
     return [
       ((['git', 'rev-parse', '--show-cdup'],), ''),
       ((['git', 'rev-parse', 'HEAD'],),
           '00ff397798ea57439712ed7e04ab96e13969ef40'),
       ((['git',
          'diff', '--name-status', '--no-renames', '-r', 'fake_ancestor_sha...',
          '.'],),
         'M\tPRESUBMIT.py'),
       ((['git',
-         'config', 'branch.working.rietveldpatchset'],), '31137'),
+         'config', '--int', 'branch.working.rietveldpatchset'],), '31137'),
       ((['git', 'config', 'branch.working.rietveldserver'],),
          'codereview.example.com'),
       ((['git', 'config', 'user.email'],), 'author@example.com'),
       ((['git', 'config', 'rietveld.tree-status-url'],), ''),
   ]
 
   @classmethod
   def _dcommit_calls_bypassed(cls):
     return [
       ((['git', 'config', 'branch.working.rietveldserver'],),
          'codereview.example.com'),
   ]
 
   @classmethod
   def _dcommit_calls_3(cls):
     return [
       ((['git',
          'diff', '--no-ext-diff', '--stat', '--find-copies-harder',
          '-l100000', '-C50', 'fake_ancestor_sha',
          'refs/heads/working'],),
        (' PRESUBMIT.py |    2 +-\n'
         ' 1 files changed, 1 insertions(+), 1 deletions(-)\n')),
       ((['git', 'show-ref', '--quiet', '--verify',
-         'refs/heads/git-cl-commit'],),
-       (('', None), 0)),
+         'refs/heads/git-cl-commit'],), ''),
       ((['git', 'branch', '-D', 'git-cl-commit'],), ''),
       ((['git', 'show-ref', '--quiet', '--verify',
-         'refs/heads/git-cl-cherry-pick'],), ''),
+         'refs/heads/git-cl-cherry-pick'],), CERR1),
       ((['git', 'rev-parse', '--show-cdup'],), '\n'),
       ((['git', 'checkout', '-q', '-b', 'git-cl-commit'],), ''),
       ((['git', 'reset', '--soft', 'fake_ancestor_sha'],), ''),
       ((['git', 'commit', '-m',
          'Issue: 12345\n\nR=john@chromium.org\n\n'
          'Review URL: https://codereview.example.com/12345 .'],),
        ''),
       ((['git', 'config', 'rietveld.force-https-commit-url'],), ''),
       ((['git',
          'svn', 'dcommit', '-C50', '--no-rebase', '--rmdir'],),
@@ skipping 184 matching lines @@
         self._dcommit_calls_3())
     git_cl.main(['dcommit', '--bypass-hooks'])
 
 
   @classmethod
   def _gerrit_ensure_auth_calls(cls, issue=None, skip_auth_check=False):
     cmd = ['git', 'config', '--bool', 'gerrit.skip-ensure-authenticated']
     if skip_auth_check:
       return [((cmd, ), 'true')]
 
-    calls = [((cmd, ), '', subprocess2.CalledProcessError(1, '', '', '', ''))]
+    calls = [((cmd, ), CERR1)]
     if issue:
       calls.extend([
           ((['git', 'config', 'branch.master.gerritserver'],), ''),
       ])
     calls.extend([
         ((['git', 'config', 'branch.master.merge'],), 'refs/heads/master'),
         ((['git', 'config', 'branch.master.remote'],), 'origin'),
         ((['git', 'config', 'remote.origin.url'],),
          'https://chromium.googlesource.com/my/repo'),
         ((['git', 'config', 'remote.origin.url'],),
          'https://chromium.googlesource.com/my/repo'),
     ])
     return calls
 
   @classmethod
   def _gerrit_base_calls(cls, issue=None):
     return [
         ((['git', 'symbolic-ref', 'HEAD'],), 'master'),
-        ((['git', 'config', '--int', '--get',
-          'branch.master.git-cl-similarity'],), ''),
+        ((['git', 'config', '--int', 'branch.master.git-cl-similarity'],),
+         CERR1),
         ((['git', 'symbolic-ref', 'HEAD'],), 'master'),
-        ((['git', 'config', '--int', '--get',
-          'branch.master.git-find-copies'],), ''),
+        ((['git', 'config', '--bool', 'branch.master.git-find-copies'],),
+         CERR1),
       ] + cls._is_gerrit_calls(True) + [
         ((['git', 'symbolic-ref', 'HEAD'],), 'master'),
-        ((['git', 'config', 'branch.master.rietveldissue'],), ''),
-        ((['git', 'config', 'branch.master.gerritissue'],),
-          '' if issue is None else str(issue)),
+        ((['git', 'config', '--int', 'branch.master.rietveldissue'],), CERR1),
+        ((['git', 'config', '--int', 'branch.master.gerritissue'],),
+          CERR1 if issue is None else str(issue)),
         ((['git', 'config', 'branch.master.merge'],), 'refs/heads/master'),
         ((['git', 'config', 'branch.master.remote'],), 'origin'),
         ((['get_or_create_merge_base', 'master',
            'refs/remotes/origin/master'],),
          'fake_ancestor_sha'),
         # Calls to verify branch point is ancestor
       ] + (cls._gerrit_ensure_auth_calls(issue=issue) +
            cls._git_sanity_checks('fake_ancestor_sha', 'master',
                                   get_remote_branch=False)) + [
         ((['git', 'rev-parse', '--show-cdup'],), ''),
         ((['git', 'rev-parse', 'HEAD'],), '12345'),
 
         ((['git',
            'diff', '--name-status', '--no-renames', '-r',
            'fake_ancestor_sha...', '.'],),
          'M\t.gitignore\n'),
-        ((['git', 'config', 'branch.master.gerritpatchset'],), ''),
+        ((['git', 'config', '--int', 'branch.master.gerritpatchset'],), CERR1),
       ] + ([] if issue else [
         ((['git',
            'log', '--pretty=format:%s%n%n%b', 'fake_ancestor_sha...'],),
          'foo'),
       ]) + [
         ((['git', 'config', 'user.email'],), 'me@example.com'),
         ((['git',
            'diff', '--no-ext-diff', '--stat', '--find-copies-harder',
            '-l100000', '-C50', 'fake_ancestor_sha', 'HEAD'],),
          '+dat'),
@@ skipping 98 matching lines @@
          'remote: Processing changes: new: 1, done\n'
          'remote:\n'
          'remote: New Changes:\n'
          'remote:   https://chromium-review.googlesource.com/123456 XXX.\n'
          'remote:\n'
          'To https://chromium.googlesource.com/yyy/zzz\n'
          ' * [new branch]      hhhh -> refs/for/refs/heads/master\n')),
         ]
     if squash:
       calls += [
-          ((['git', 'config', 'branch.master.gerritissue', '123456'],), ''),
+          ((['git', 'config', '--int', 'branch.master.gerritissue', '123456'],),
+           ''),
           ((['git', 'config', 'branch.master.gerritserver',
-          'https://chromium-review.googlesource.com'],), ''),
+             'https://chromium-review.googlesource.com'],), ''),
           ((['git', 'config', 'branch.master.gerritsquashhash',
              'abcdef0123456789'],), ''),
       ]
     calls += cls._git_post_upload_calls()
     return calls
 
   def _run_gerrit_upload_test(
       self,
       upload_args,
       description,
@@ skipping 340 matching lines @@
               })
     self.mock(git_cl.Changelist, 'GetDescription',
               lambda *args: 'Description')
     self.mock(git_cl, 'IsGitVersionAtLeast', lambda *args: True)
 
     self.calls = self.calls or []
     if not force_codereview:
       # These calls detect codereview to use.
       self.calls += [
         ((['git', 'symbolic-ref', 'HEAD'],), 'master'),
-        ((['git', 'config', 'branch.master.rietveldissue'],), ''),
-        ((['git', 'config', 'branch.master.gerritissue'],), ''),
-        ((['git', 'config', 'rietveld.autoupdate'],), ''),
+        ((['git', 'config', '--int', 'branch.master.rietveldissue'],), CERR1),
+        ((['git', 'config', '--int', 'branch.master.gerritissue'],), CERR1),
+        ((['git', 'config', 'rietveld.autoupdate'],), CERR1),
       ]
 
     if is_gerrit:
       if not force_codereview:
         self.calls += [
           ((['git', 'config', 'gerrit.host'],), 'true'),
         ]
     else:
       self.calls += [
-        ((['git', 'config', 'gerrit.host'],), ''),
+        ((['git', 'config', 'gerrit.host'],), CERR1),
         ((['git', 'config', 'rietveld.server'],), 'codereview.example.com'),
         ((['git', 'rev-parse', '--show-cdup'],), ''),
         ((['sed', '-e', 's|^--- a/|--- |; s|^+++ b/|+++ |'],), ''),
       ]
 
   def _common_patch_successful(self):
     self._patch_common()
     self.calls += [
       ((['git', 'apply', '--index', '-p0', '--3way'],), ''),
       ((['git', 'commit', '-m',
          'Description\n\n' +
          'patch from issue 123456 at patchset 60001 ' +
          '(http://crrev.com/123456#ps60001)'],), ''),
-      ((['git', 'config', 'branch.master.rietveldissue', '123456'],), ''),
-      ((['git', 'config', 'branch.master.rietveldserver'],), ''),
+      ((['git', 'config', '--int', 'branch.master.rietveldissue', '123456'],),
+       ''),
+      ((['git', 'config', 'branch.master.rietveldserver'],), CERR1),
       ((['git', 'config', 'branch.master.rietveldserver',
          'https://codereview.example.com'],), ''),
-      ((['git', 'config', 'branch.master.rietveldpatchset', '60001'],), ''),
+      ((['git', 'config', '--int', 'branch.master.rietveldpatchset', '60001'],),
+       ''),
     ]
 
   def test_patch_successful(self):
     self._common_patch_successful()
     self.assertEqual(git_cl.main(['patch', '123456']), 0)
 
   def test_patch_successful_new_branch(self):
     self.calls = [ ((['git', 'new-branch', 'master'],), ''), ]
     self._common_patch_successful()
     self.assertEqual(git_cl.main(['patch', '-b', 'master', '123456']), 0)
 
   def test_patch_conflict(self):
     self._patch_common()
     self.calls += [
-      ((['git', 'apply', '--index', '-p0', '--3way'],), '',
-       subprocess2.CalledProcessError(1, '', '', '', '')),
+      ((['git', 'apply', '--index', '-p0', '--3way'],), CERR1),
     ]
     self.assertNotEqual(git_cl.main(['patch', '123456']), 0)
 
   def test_gerrit_patch_successful(self):
     self._patch_common(is_gerrit=True)
     self.calls += [
       ((['git', 'fetch', 'https://chromium.googlesource.com/my/repo',
          'refs/changes/56/123456/7'],), ''),
       ((['git', 'cherry-pick', 'FETCH_HEAD'],), ''),
-      ((['git', 'config', 'branch.master.gerritissue', '123456'],), ''),
+      ((['git', 'config', '--int', 'branch.master.gerritissue', '123456'],),
+       ''),
       ((['git', 'config', 'branch.master.gerritserver'],), ''),
       ((['git', 'config', 'branch.master.merge'],), 'master'),
       ((['git', 'config', 'branch.master.remote'],), 'origin'),
       ((['git', 'config', 'remote.origin.url'],),
        'https://chromium.googlesource.com/my/repo'),
       ((['git', 'config', 'branch.master.gerritserver',
         'https://chromium-review.googlesource.com'],), ''),
-      ((['git', 'config', 'branch.master.gerritpatchset', '7'],), ''),
+      ((['git', 'config', '--int', 'branch.master.gerritpatchset', '7'],), ''),
     ]
     self.assertEqual(git_cl.main(['patch', '123456']), 0)
 
   def test_patch_force_codereview(self):
     self._patch_common(is_gerrit=True, force_codereview=True)
     self.calls += [
       ((['git', 'fetch', 'https://chromium.googlesource.com/my/repo',
          'refs/changes/56/123456/7'],), ''),
       ((['git', 'cherry-pick', 'FETCH_HEAD'],), ''),
       ((['git', 'symbolic-ref', 'HEAD'],), 'master'),
-      ((['git', 'config', 'branch.master.gerritissue', '123456'],), ''),
+      ((['git', 'config', '--int', 'branch.master.gerritissue', '123456'],),
+       ''),
       ((['git', 'config', 'branch.master.gerritserver'],), ''),
       ((['git', 'config', 'branch.master.merge'],), 'master'),
       ((['git', 'config', 'branch.master.remote'],), 'origin'),
       ((['git', 'config', 'remote.origin.url'],),
        'https://chromium.googlesource.com/my/repo'),
       ((['git', 'config', 'branch.master.gerritserver',
         'https://chromium-review.googlesource.com'],), ''),
-      ((['git', 'config', 'branch.master.gerritpatchset', '7'],), ''),
+      ((['git', 'config', '--int', 'branch.master.gerritpatchset', '7'],), ''),
     ]
     self.assertEqual(git_cl.main(['patch', '--gerrit', '123456']), 0)
 
   def test_gerrit_patch_url_successful(self):
     self._patch_common(is_gerrit=True)
     self.calls += [
       ((['git', 'fetch', 'https://chromium.googlesource.com/my/repo',
          'refs/changes/56/123456/1'],), ''),
       ((['git', 'cherry-pick', 'FETCH_HEAD'],), ''),
-      ((['git', 'config', 'branch.master.gerritissue', '123456'],), ''),
+      ((['git', 'config', '--int', 'branch.master.gerritissue', '123456'],),
+       ''),
       ((['git', 'config', 'branch.master.gerritserver',
         'https://chromium-review.googlesource.com'],), ''),
-      ((['git', 'config', 'branch.master.gerritpatchset', '1'],), ''),
+      ((['git', 'config', '--int', 'branch.master.gerritpatchset', '1'],), ''),
     ]
     self.assertEqual(git_cl.main(
       ['patch', 'https://chromium-review.googlesource.com/#/c/123456/1']), 0)
 
   def test_gerrit_patch_conflict(self):
     self._patch_common(is_gerrit=True)
     self.mock(git_cl, 'DieWithError',
               lambda msg: self._mocked_call(['DieWithError', msg]))
     class SystemExitMock(Exception):
       pass
     self.calls += [
       ((['git', 'fetch', 'https://chromium.googlesource.com/my/repo',
          'refs/changes/56/123456/1'],), ''),
-      ((['git', 'cherry-pick', 'FETCH_HEAD'],),
-        '', subprocess2.CalledProcessError(1, '', '', '', '')),
-      ((['DieWithError', 'git cherry-pick FETCH_HEAD" failed.\n'],),
-        '', SystemExitMock()),
+      ((['git', 'cherry-pick', 'FETCH_HEAD'],), CERR1),
+      ((['DieWithError', 'Command "git cherry-pick FETCH_HEAD" failed.\n'],),
+       SystemExitMock()),
     ]
     with self.assertRaises(SystemExitMock):
       git_cl.main(['patch',
                    'https://chromium-review.googlesource.com/#/c/123456/1'])
 
   def _checkout_calls(self):
     return [
         ((['git', 'config', '--local', '--get-regexp',
            'branch\\..*\\.rietveldissue'], ),
            ('branch.retrying.rietveldissue 1111111111\n'
@@ skipping 20 matching lines @@
     """Tests git cl checkout <issue>."""
     self.mock(git_cl.sys, 'stdout', StringIO.StringIO())
     self.calls = self._checkout_calls()
     self.assertEqual(1, git_cl.main(['checkout', '99999']))
 
   def test_checkout_no_branch_issues(self):
     """Tests git cl checkout <issue>."""
     self.mock(git_cl.sys, 'stdout', StringIO.StringIO())
     self.calls = [
         ((['git', 'config', '--local', '--get-regexp',
-           'branch\\..*\\.rietveldissue'], ), '',
-         subprocess2.CalledProcessError(1, '', '', '', '')),
+           'branch\\..*\\.rietveldissue'], ), CERR1),
         ((['git', 'config', '--local', '--get-regexp',
-           'branch\\..*\\.gerritissue'], ), '',
-         subprocess2.CalledProcessError(1, '', '', '', '')),
-
+           'branch\\..*\\.gerritissue'], ), CERR1),
     ]
     self.assertEqual(1, git_cl.main(['checkout', '99999']))
 
   def _test_gerrit_ensure_authenticated_common(self, auth,
                                                skip_auth_check=False):
     self.mock(git_cl.gerrit_util, 'CookiesAuthenticator',
               CookiesAuthenticatorMockFactory(hosts_with_creds=auth))
     self.mock(git_cl, 'DieWithError',
               lambda msg: self._mocked_call(['DieWithError', msg]))
     self.mock(git_cl, 'ask_for_data',
@@ skipping 39 matching lines @@
   def test_gerrit_ensure_authenticated_skipped(self):
     cl = self._test_gerrit_ensure_authenticated_common(
         auth={}, skip_auth_check=True)
     self.assertIsNone(cl.EnsureAuthenticated(force=False))
 
   def test_cmd_set_commit_rietveld(self):
     self.mock(git_cl._RietveldChangelistImpl, 'SetFlags',
               lambda _, v: self._mocked_call(['SetFlags', v]))
     self.calls = [
         ((['git', 'symbolic-ref', 'HEAD'],), 'feature'),
-        ((['git', 'config', 'branch.feature.rietveldissue'],), '123'),
+        ((['git', 'config', '--int', 'branch.feature.rietveldissue'],), '123'),
         ((['git', 'config', 'rietveld.autoupdate'],), ''),
         ((['git', 'config', 'rietveld.server'],), ''),
         ((['git', 'config', 'rietveld.server'],), ''),
         ((['git', 'config', 'branch.feature.rietveldserver'],),
          'https://codereview.chromium.org'),
         ((['SetFlags', {'commit': '1', 'cq_dry_run': '0'}], ), ''),
     ]
     self.assertEqual(0, git_cl.main(['set-commit']))
 
   def _cmd_set_commit_gerrit_common(self, vote):
     self.mock(git_cl.gerrit_util, 'SetReview',
               lambda h, i, labels: self._mocked_call(
                   ['SetReview', h, i, labels]))
     self.calls = [
         ((['git', 'symbolic-ref', 'HEAD'],), 'feature'),
-        ((['git', 'config', 'branch.feature.rietveldissue'],), ''),
-        ((['git', 'config', 'branch.feature.gerritissue'],), '123'),
+        ((['git', 'config', '--int', 'branch.feature.rietveldissue'],), CERR1),
+        ((['git', 'config', '--int', 'branch.feature.gerritissue'],), '123'),
         ((['git', 'config', 'branch.feature.gerritserver'],),
          'https://chromium-review.googlesource.com'),
         ((['SetReview', 'chromium-review.googlesource.com', 123,
            {'Commit-Queue': vote}],), ''),
     ]
 
   def test_cmd_set_commit_gerrit_clear(self):
     self._cmd_set_commit_gerrit_common(0)
     self.assertEqual(0, git_cl.main(['set-commit', '-c']))
 
@@ skipping 134 matching lines @@
 
     self.mock(git_cl.sys, 'stdout', StringIO.StringIO())
     self.mock(git_cl.Changelist, 'GetDescription',
               lambda *args: current_desc)
     self.mock(git_cl._GerritChangelistImpl, 'UpdateDescriptionRemote',
               UpdateDescriptionRemote)
     self.mock(git_cl.gclient_utils, 'RunEditor', RunEditor)
 
     self.calls = [
         ((['git', 'symbolic-ref', 'HEAD'],), 'feature'),
-        ((['git', 'config', 'branch.feature.gerritissue'],), '123'),
-        ((['git', 'config', 'rietveld.autoupdate'],), ''),
-        ((['git', 'config', 'rietveld.bug-prefix'],), ''),
+        ((['git', 'config', '--int', 'branch.feature.gerritissue'],), '123'),
+        ((['git', 'config', 'rietveld.autoupdate'],), CERR1),
+        ((['git', 'config', 'rietveld.bug-prefix'],), CERR1),
         ((['git', 'config', 'core.editor'],), 'vi'),
     ]
     self.assertEqual(0, git_cl.main(['description', '--gerrit']))
 
   def test_description_set_stdin(self):
     out = StringIO.StringIO()
     self.mock(git_cl.sys, 'stdout', out)
 
     self.mock(git_cl, 'Changelist', ChangelistMock)
     self.mock(git_cl.sys, 'stdin', StringIO.StringIO('hi \r\n\t there\n\nman'))
 
     self.assertEqual(0, git_cl.main(['description', '-n', '-']))
     self.assertEqual('hi\n\t there\n\nman', ChangelistMock.desc)
 
   def test_archive(self):
     self.mock(git_cl.sys, 'stdout', StringIO.StringIO())
 
     self.calls = \
         [((['git', 'for-each-ref', '--format=%(refname)', 'refs/heads'],),
           'refs/heads/master\nrefs/heads/foo\nrefs/heads/bar'),
-         ((['git', 'config', 'branch.master.rietveldissue'],), '1'),
-         ((['git', 'config', 'rietveld.autoupdate'],), ''),
-         ((['git', 'config', 'rietveld.server'],), ''),
-         ((['git', 'config', 'rietveld.server'],), ''),
-         ((['git', 'config', 'branch.foo.rietveldissue'],), '456'),
-         ((['git', 'config', 'rietveld.server'],), ''),
-         ((['git', 'config', 'rietveld.server'],), ''),
-         ((['git', 'config', 'branch.bar.rietveldissue'],), ''),
-         ((['git', 'config', 'branch.bar.gerritissue'],), '789'),
+         ((['git', 'config', '--int', 'branch.master.rietveldissue'],), '1'),
+         ((['git', 'config', 'rietveld.autoupdate'],), CERR1),
+         ((['git', 'config', 'rietveld.server'],), 'codereview.example.com'),
+         ((['git', 'config', '--int', 'branch.foo.rietveldissue'],), '456'),
+         ((['git', 'config', '--int', 'branch.bar.rietveldissue'],), CERR1),
+         ((['git', 'config', '--int', 'branch.bar.gerritissue'],), '789'),
          ((['git', 'symbolic-ref', 'HEAD'],), 'master'),
          ((['git', 'tag', 'git-cl-archived-456-foo', 'foo'],), ''),
          ((['git', 'branch', '-D', 'foo'],), '')]
 
     class MockChangelist():
       def __init__(self, branch, issue):
         self.branch = branch
         self.issue = issue
       def GetBranch(self):
         return self.branch
       def GetIssue(self):
         return self.issue
 
     self.mock(git_cl, 'get_cl_statuses',
               lambda branches, fine_grained, max_processes:
               [(MockChangelist('master', 1), 'open'),
                (MockChangelist('foo', 456), 'closed'),
                (MockChangelist('bar', 789), 'open')])
 
     self.assertEqual(0, git_cl.main(['archive', '-f']))
 
   def test_archive_current_branch_fails(self):
     self.mock(git_cl.sys, 'stdout', StringIO.StringIO())
     self.calls = \
         [((['git', 'for-each-ref', '--format=%(refname)', 'refs/heads'],),
           'refs/heads/master'),
-         ((['git', 'config', 'branch.master.rietveldissue'],), '1'),
-         ((['git', 'config', 'rietveld.autoupdate'],), ''),
-         ((['git', 'config', 'rietveld.server'],), ''),
-         ((['git', 'config', 'rietveld.server'],), ''),
+         ((['git', 'config', '--int', 'branch.master.rietveldissue'],), '1'),
+         ((['git', 'config', 'rietveld.autoupdate'],), CERR1),
+         ((['git', 'config', 'rietveld.server'],), 'codereview.example.com'),
          ((['git', 'symbolic-ref', 'HEAD'],), 'master')]
 
     class MockChangelist():
       def __init__(self, branch, issue):
         self.branch = branch
         self.issue = issue
       def GetBranch(self):
         return self.branch
       def GetIssue(self):
         return self.issue
 
     self.mock(git_cl, 'get_cl_statuses',
               lambda branches, fine_grained, max_processes:
               [(MockChangelist('master', 1), 'closed')])
 
     self.assertEqual(1, git_cl.main(['archive', '-f']))
 
   def test_cmd_issue_erase_existing(self):
     out = StringIO.StringIO()
     self.mock(git_cl.sys, 'stdout', out)
     self.calls = [
         ((['git', 'symbolic-ref', 'HEAD'],), 'feature'),
-        ((['git', 'config', 'branch.feature.rietveldissue'],), ''),
-        ((['git', 'config', 'branch.feature.gerritissue'],), '123'),
+        ((['git', 'config', '--int', 'branch.feature.rietveldissue'],), CERR1),
+        ((['git', 'config', '--int', 'branch.feature.gerritissue'],), '123'),
+        # Let this command raise exception (retcode=1) - it should be ignored.
+        ((['git', 'config', '--unset', 'branch.feature.last-upload-hash'],),
+         CERR1),
         ((['git', 'config', '--unset', 'branch.feature.gerritissue'],), ''),
         ((['git', 'config', '--unset', 'branch.feature.gerritpatchset'],), ''),
-        # Let this command raise exception (retcode=1) - it should be ignored.
-        ((['git', 'config', '--unset', 'branch.feature.last-upload-hash'],),
-         '', subprocess2.CalledProcessError(1, '', '', '', '')),
         ((['git', 'config', '--unset', 'branch.feature.gerritserver'],), ''),
         ((['git', 'config', '--unset', 'branch.feature.gerritsquashhash'],),
          ''),
     ]
     self.assertEqual(0, git_cl.main(['issue', '0']))
 
   def test_git_cl_try_default(self):
     self.mock(git_cl.Changelist, 'GetChange',
               lambda _, *a: (
                 self._mocked_call(['GetChange']+list(a))))
     self.mock(git_cl.presubmit_support, 'DoGetTryMasters',
               lambda *_, **__: (
                 self._mocked_call(['DoGetTryMasters'])))
     self.mock(git_cl.presubmit_support, 'DoGetTrySlaves',
               lambda *_, **__: (
                 self._mocked_call(['DoGetTrySlaves'])))
     self.mock(git_cl._RietveldChangelistImpl, 'SetCQState',
               lambda _, s: self._mocked_call(['SetCQState', s]))
     self.calls = [
         ((['git', 'symbolic-ref', 'HEAD'],), 'feature'),
-        ((['git', 'config', 'branch.feature.rietveldissue'],), '123'),
+        ((['git', 'config', '--int', 'branch.feature.rietveldissue'],), '123'),
         ((['git', 'config', 'rietveld.autoupdate'],), ''),
         ((['git', 'config', 'rietveld.server'],),
          'https://codereview.chromium.org'),
         ((['git', 'config', 'branch.feature.rietveldserver'],), ''),
         ((['git', 'config', 'branch.feature.merge'],), 'feature'),
         ((['git', 'config', 'branch.feature.remote'],), 'origin'),
         ((['get_or_create_merge_base', 'feature', 'feature'],),
          'fake_ancestor_sha'),
         ((['GetChange', 'fake_ancestor_sha', None], ),
          git_cl.presubmit_support.GitChange(
@@ skipping 52 matching lines @@
         ((['rm_file_or_tree', '/abs/git_repo_root/.git/hooks/commit-msg'],),
          ''),
     ]
     cl._codereview_impl._GerritCommitMsgHookCheck(offer_removal=True)
 
 
 if __name__ == '__main__':
   git_cl.logging.basicConfig(
       level=git_cl.logging.DEBUG if '-v' in sys.argv else git_cl.logging.ERROR)
   unittest.main()