Allow to skip EnsureAuthenticated for Gerrit.

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
@@ skipping 509 matching lines @@
 
   def _run_reviewer_test(
       self,
       upload_args,
       expected_description,
       returned_description,
       final_description,
       reviewers,
       private=False):
     """Generic reviewer test framework."""
+    self.mock(git_cl.sys, 'stdout', StringIO.StringIO())
     try:
       similarity = upload_args[upload_args.index('--similarity')+1]
     except ValueError:
       similarity = None
 
     if '--find-copies' in upload_args:
       find_copies = True
     elif '--no-find-copies' in upload_args:
       find_copies = False
     else:
@@ skipping 113 matching lines @@
       self.fail()
     except SystemExit:
       self.assertEqual(
           'Using 50% similarity for rename/copy detection. Override with '
           '--similarity.\n',
           stdout.getvalue())
       self.assertEqual(
           'Must specify reviewers to send email.\n', stderr.getvalue())
 
   def test_dcommit(self):
+    self.mock(git_cl.sys, 'stdout', StringIO.StringIO())
     self.calls = (
         self._dcommit_calls_1() +
         self._git_sanity_checks('fake_ancestor_sha', 'working') +
         self._dcommit_calls_normal() +
         self._dcommit_calls_3())
     git_cl.main(['dcommit'])
 
   def test_dcommit_bypass_hooks(self):
+    self.mock(git_cl.sys, 'stdout', StringIO.StringIO())
     self.calls = (
         self._dcommit_calls_1() +
         self._dcommit_calls_bypassed() +
         self._dcommit_calls_3())
     git_cl.main(['dcommit', '--bypass-hooks'])
 
 
   @classmethod
-  def _gerrit_ensure_auth_calls(cls, issue=None):
-    calls = []
+  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, '', '', '', ''))]
     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'],),
@@ skipping 151 matching lines @@
       upload_args,
       description,
       reviewers=None,
       squash=False,
       expected_upstream_ref='origin/refs/heads/master',
       ref_suffix='',
       post_amend_description=None,
       issue=None):
     """Generic gerrit upload test framework."""
     reviewers = reviewers or []
+    self.mock(git_cl.sys, 'stdout', StringIO.StringIO())
     self.mock(git_cl.gerrit_util, "CookiesAuthenticator",
               CookiesAuthenticatorMockFactory(same_cookie='same_cred'))
     self.calls = self._gerrit_base_calls(issue=issue)
     self.calls += self._gerrit_upload_calls(
         description, reviewers, squash,
         expected_upstream_ref=expected_upstream_ref,
         ref_suffix=ref_suffix,
         post_amend_description=post_amend_description,
         issue=issue)
     # Uncomment when debugging.
@@ skipping 57 matching lines @@
               lambda *args: {'change_id': '123456789'})
     self._run_gerrit_upload_test(
         ['--squash'],
         description,
         [],
         squash=True,
         expected_upstream_ref='origin/master',
         issue=123456)
 
   def test_upload_branch_deps(self):
+    self.mock(git_cl.sys, 'stdout', StringIO.StringIO())
     def mock_run_git(*args, **_kwargs):
       if args[0] == ['for-each-ref',
                        '--format=%(refname:short) %(upstream:short)',
                        'refs/heads']:
         # Create a local branch dependency tree that looks like this:
         # test1 -> test2 -> test3   -> test4 -> test5
         #                -> test3.1
         # test6 -> test0
         branch_deps = [
             'test2 test1',    # test1 -> test2
@@ skipping 148 matching lines @@
       ((['git', 'config', 'rietveld.server'],), 'codereview.example.com'),
     ]
     self.assertNotEqual(git_cl.main(['patch', '123456']), 0)
 
   def test_diff_when_dirty(self):
     # Do 'git cl diff' when local tree is dirty
     self.mock(git_common, 'is_dirty_git_tree', lambda x: True)
     self.assertNotEqual(git_cl.main(['diff']), 0)
 
   def _patch_common(self, is_gerrit=False, force_codereview=False):
+    self.mock(git_cl.sys, 'stdout', StringIO.StringIO())
     self.mock(git_cl._RietveldChangelistImpl, 'GetMostRecentPatchset',
               lambda x: '60001')
     self.mock(git_cl._RietveldChangelistImpl, 'GetPatchSetDiff',
               lambda *args: None)
     self.mock(git_cl._GerritChangelistImpl, '_GetChangeDetail',
               lambda *args: {
                 'current_revision': '7777777777',
                 'revisions': {
                   '1111111111': {
                     '_number': 1,
@@ skipping 151 matching lines @@
     self.assertEqual(0, git_cl.main(['checkout', '123456']))
 
   def test_checkout_rietveld(self):
     """Tests git cl checkout <issue>."""
     self.calls = self._checkout_calls()
     self.calls += [((['git', 'checkout', 'some-fix'], ), '')]
     self.assertEqual(0, git_cl.main(['checkout', '2222222222']))
 
   def test_checkout_not_found(self):
     """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, '', '', '', '')),
         ((['git', 'config', '--local', '--get-regexp',
            'branch\\..*\\.gerritissue'], ), '',
          subprocess2.CalledProcessError(1, '', '', '', '')),
 
     ]
     self.assertEqual(1, git_cl.main(['checkout', '99999']))
 
-  def _test_gerrit_ensure_authenticated_common(self, auth):
+  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',
               lambda msg: self._mocked_call(['ask_for_data', msg]))
-    self.calls = [
-        ((['git', 'symbolic-ref', 'HEAD'],), 'master')
-    ] + self._gerrit_ensure_auth_calls()
+    self.calls = self._gerrit_ensure_auth_calls(skip_auth_check=skip_auth_check)
     cl = git_cl.Changelist(codereview='gerrit')
+    cl.branch = 'master'
+    cl.branchref = 'refs/heads/master'
     cl.lookedup_issue = True
     return cl
 
   def test_gerrit_ensure_authenticated_missing(self):
     cl = self._test_gerrit_ensure_authenticated_common(auth={
       'chromium.googlesource.com': 'git is ok, but gerrit one is missing',
     })
     self.calls.append(
         ((['DieWithError',
            'Credentials for the following hosts are required:\n'
            '  chromium-review.googlesource.com\n'
            'These are read from ~/.gitcookies (or legacy ~/.netrc)\n'
            'You can (re)generate your credentails by visiting '
            'https://chromium-review.googlesource.com/new-password'],), ''),)
     self.assertIsNone(cl.EnsureAuthenticated(force=False))
 
   def test_gerrit_ensure_authenticated_conflict(self):
+    self.mock(git_cl.sys, 'stdout', StringIO.StringIO())
     cl = self._test_gerrit_ensure_authenticated_common(auth={
       'chromium.googlesource.com': 'one',
       'chromium-review.googlesource.com': 'other',
     })
     self.calls.append(
         ((['ask_for_data', 'If you know what you are doing, '
                                                                                                  'press Enter to continue, Ctrl+C to abort.'],), ''))
     self.assertIsNone(cl.EnsureAuthenticated(force=False))
 
   def test_gerrit_ensure_authenticated_ok(self):
     cl = self._test_gerrit_ensure_authenticated_common(auth={
       'chromium.googlesource.com': 'same',
       'chromium-review.googlesource.com': 'same',
     })
     self.assertIsNone(cl.EnsureAuthenticated(force=False))
 
+  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, 'SetFlag',
               lambda _, f, v: self._mocked_call(['SetFlag', f, v]))
     self.calls = [
         ((['git', 'symbolic-ref', 'HEAD'],), 'feature'),
         ((['git', 'config', 'branch.feature.rietveldissue'],), '123'),
         ((['git', 'config', 'rietveld.autoupdate'],), ''),
         ((['git', 'config', 'rietveld.server'],), ''),
         ((['git', 'config', 'rietveld.server'],), ''),
         ((['git', 'config', 'branch.feature.rietveldserver'],),
@@ skipping 18 matching lines @@
     # TODO(tandrii): consider testing just set-commit and set-commit --clear,
     # but without copy-pasting tons of expectations, as modifying them later is
     # super tedious.
     self.assertEqual(0, git_cl.main(['set-commit', '-d']))
 
 
 if __name__ == '__main__':
   git_cl.logging.basicConfig(
       level=git_cl.logging.DEBUG if '-v' in sys.argv else git_cl.logging.ERROR)
   unittest.main()