#!/usr/bin/env vpython3
# coding=utf-8
# 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 codecs
import datetime
import json
import logging
import multiprocessing
import optparse
import os
import io
import shutil
import sys
import tempfile
import unittest
from unittest import mock
sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
import scm_mock
import metrics
import metrics_utils
# We have to disable monitoring before importing git_cl.
metrics_utils.COLLECT_METRICS = False
import clang_format
import contextlib
import gclient_utils
import gerrit_util
import git_cl
import git_common
import git_footers
import git_new_branch
import owners_client
import scm
import subprocess2
# TODO: Should fix these warnings.
# pylint: disable=line-too-long
def callError(code=1, cmd='', cwd='', stdout=b'', stderr=b''):
return subprocess2.CalledProcessError(code, cmd, cwd, stdout, stderr)
CERR1 = callError(1)
def getAccountDetailsMock(host, account_id='self', *, authenticator=None):
if account_id == 'self':
return {
'_account_id': 123456,
'avatars': [],
'email': 'getAccountDetailsMock@example.com',
'name': 'GetAccountDetails(self)',
'status': 'OOO',
}
return None
class TemporaryFileMock(object):
def __init__(self):
self.suffix = 0
@contextlib.contextmanager
def __call__(self):
self.suffix += 1
yield '/tmp/fake-temp' + str(self.suffix)
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, gerrit_change=None, use_python3=False, **kwargs):
self._gerrit_change = gerrit_change
self._use_python3 = use_python3
def GetIssue(self):
return 1
def FetchDescription(self):
return ChangelistMock.desc
def UpdateDescription(self, desc, force=False):
ChangelistMock.desc = desc
def GetGerritChange(self, patchset=None, **kwargs):
del patchset
return self._gerrit_change
def GetRemoteBranch(self):
return ('origin', 'refs/remotes/origin/main')
class WatchlistsMock(object):
def __init__(self, _):
pass
@staticmethod
def GetWatchersForPaths(_):
return ['joe@example.com']
class CodereviewSettingsFileMock(object):
def __init__(self):
pass
# pylint: disable=no-self-use
def read(self):
return ('CODE_REVIEW_SERVER: gerrit.chromium.org\n' +
'GERRIT_HOST: True\n')
class AuthenticatorMock(object):
def __init__(self, *_args):
pass
def has_cached_credentials(self):
return True
def authorize(self, http):
return http
def CookiesAuthenticatorMockFactory(hosts_with_creds=None, same_auth=False):
"""Use to mock Gerrit/Git credentials from ~/.gitcookies.
Usage:
>>> self.mock(git_cl.gerrit_util, "CookiesAuthenticator",
CookiesAuthenticatorMockFactory({'host': ('user', 'pass')})
OR
>>> self.mock(git_cl.gerrit_util, "CookiesAuthenticator",
CookiesAuthenticatorMockFactory(
same_auth=('user', 'pass'))
"""
class CookiesAuthenticatorMock(git_cl.gerrit_util.CookiesAuthenticator):
def __init__(self): # pylint: disable=super-init-not-called
# Intentionally not calling super() because it reads actual cookie
# files.
pass
@classmethod
def get_gitcookies_path(cls):
return os.path.join('~', '.gitcookies')
def _get_auth_for_host(self, host):
if same_auth:
return same_auth
return (hosts_with_creds or {}).get(host)
return CookiesAuthenticatorMock
class MockChangelistWithBranchAndIssue():
def __init__(self, branch, issue):
self.branch = branch
self.issue = issue
def GetBranch(self):
return self.branch
def GetIssue(self):
return self.issue
class SystemExitMock(Exception):
pass
class ParserErrorMock(Exception):
pass
class TestGitClBasic(unittest.TestCase):
def setUp(self):
mock.patch('sys.exit', side_effect=SystemExitMock).start()
mock.patch('sys.stdout', io.StringIO()).start()
mock.patch('sys.stderr', io.StringIO()).start()
self.addCleanup(mock.patch.stopall)
def test_die_with_error(self):
with self.assertRaises(SystemExitMock):
git_cl.DieWithError('foo', git_cl.ChangeDescription('lorem ipsum'))
self.assertEqual(sys.stderr.getvalue(), 'foo\n')
self.assertTrue('saving CL description' in sys.stdout.getvalue())
self.assertTrue('Content of CL description' in sys.stdout.getvalue())
self.assertTrue('lorem ipsum' in sys.stdout.getvalue())
sys.exit.assert_called_once_with(1)
def test_die_with_error_no_desc(self):
with self.assertRaises(SystemExitMock):
git_cl.DieWithError('foo')
self.assertEqual(sys.stderr.getvalue(), 'foo\n')
self.assertEqual(sys.stdout.getvalue(), '')
sys.exit.assert_called_once_with(1)
def test_fetch_description(self):
cl = git_cl.Changelist(issue=1, codereview_host='host')
cl.description = 'x'
self.assertEqual(cl.FetchDescription(), 'x')
@mock.patch('git_cl.Changelist.EnsureAuthenticated')
@mock.patch('git_cl.Changelist.GetStatus', lambda cl: cl.status)
def test_get_cl_statuses(self, *_mocks):
statuses = [
'closed', 'commit', 'dry-run', 'lgtm', 'reply', 'unsent', 'waiting'
]
changes = []
for status in statuses:
cl = git_cl.Changelist()
cl.status = status
changes.append(cl)
actual = set(git_cl.get_cl_statuses(changes, True))
self.assertEqual(set(zip(changes, statuses)), actual)
def test_upload_to_non_default_branch_no_retry(self):
m = mock.patch('git_cl.Changelist._CMDUploadChange',
side_effect=[git_cl.GitPushError(), None]).start()
mock.patch('git_cl.Changelist.GetRemoteBranch',
return_value=('foo', 'bar')).start()
mock.patch('git_cl.Changelist.GetGerritProject',
return_value='foo').start()
mock.patch('git_cl.gerrit_util.GetProjectHead',
return_value='refs/heads/main').start()
cl = git_cl.Changelist()
options = optparse.Values()
options.target_branch = 'refs/heads/bar'
with self.assertRaises(SystemExitMock):
cl.CMDUploadChange(options, [], 'foo',
git_cl.ChangeDescription('bar'))
# ensure upload is called once
self.assertEqual(len(m.mock_calls), 1)
sys.exit.assert_called_once_with(1)
# option not set as retry didn't happen
self.assertFalse(hasattr(options, 'force'))
self.assertFalse(hasattr(options, 'edit_description'))
def test_upload_to_meta_config_branch_no_retry(self):
m = mock.patch('git_cl.Changelist._CMDUploadChange',
side_effect=[git_cl.GitPushError(), None]).start()
mock.patch('git_cl.Changelist.GetRemoteBranch',
return_value=('foo', 'bar')).start()
mock.patch('git_cl.Changelist.GetGerritProject',
return_value='foo').start()
mock.patch('git_cl.gerrit_util.GetProjectHead',
return_value='refs/heads/main').start()
cl = git_cl.Changelist()
options = optparse.Values()
options.target_branch = 'refs/meta/config'
with self.assertRaises(SystemExitMock):
cl.CMDUploadChange(options, [], 'foo',
git_cl.ChangeDescription('bar'))
# ensure upload is called once
self.assertEqual(len(m.mock_calls), 1)
sys.exit.assert_called_once_with(1)
# option not set as retry didn't happen
self.assertFalse(hasattr(options, 'force'))
self.assertFalse(hasattr(options, 'edit_description'))
def test_upload_to_old_default_still_active(self):
m = mock.patch('git_cl.Changelist._CMDUploadChange',
side_effect=[git_cl.GitPushError(), None]).start()
mock.patch('git_cl.Changelist.GetRemoteBranch',
return_value=('foo', git_cl.DEFAULT_OLD_BRANCH)).start()
mock.patch('git_cl.Changelist.GetGerritProject',
return_value='foo').start()
mock.patch('git_cl.gerrit_util.GetProjectHead',
return_value='refs/heads/main').start()
cl = git_cl.Changelist()
options = optparse.Values()
options.target_branch = 'refs/heads/main'
with self.assertRaises(SystemExitMock):
cl.CMDUploadChange(options, [], 'foo',
git_cl.ChangeDescription('bar'))
# ensure upload is called once
self.assertEqual(len(m.mock_calls), 1)
sys.exit.assert_called_once_with(1)
# option not set as retry didn't happen
self.assertFalse(hasattr(options, 'force'))
self.assertFalse(hasattr(options, 'edit_description'))
def test_upload_with_message_file_no_editor(self):
m = mock.patch('git_cl.ChangeDescription.prompt',
return_value=None).start()
mock.patch('git_cl.Changelist.GetRemoteBranch',
return_value=('foo', git_cl.DEFAULT_NEW_BRANCH)).start()
mock.patch('git_cl.GetTargetRef',
return_value='refs/heads/main').start()
mock.patch('git_cl.Changelist._GerritCommitMsgHookCheck',
lambda offer_removal: None).start()
mock.patch('git_cl.Changelist.GetIssue', return_value=None).start()
mock.patch('git_cl.Changelist.GetBranch',
side_effect=SystemExitMock).start()
mock.patch('git_cl.GenerateGerritChangeId', return_value=None).start()
mock.patch('git_cl.RunGit').start()
cl = git_cl.Changelist()
options = optparse.Values()
options.target_branch = 'refs/heads/main'
options.squash = True
options.edit_description = False
options.force = False
options.preserve_tryjobs = False
options.message_file = "message.txt"
options.commit_description = None
with self.assertRaises(SystemExitMock):
cl.CMDUploadChange(options, [], 'foo',
git_cl.ChangeDescription('bar'))
self.assertEqual(len(m.mock_calls), 0)
options.message_file = None
with self.assertRaises(SystemExitMock):
cl.CMDUploadChange(options, [], 'foo',
git_cl.ChangeDescription('bar'))
self.assertEqual(len(m.mock_calls), 1)
def test_get_cl_statuses_no_changes(self):
self.assertEqual([], list(git_cl.get_cl_statuses([], True)))
@mock.patch('git_cl.Changelist.EnsureAuthenticated')
@mock.patch('multiprocessing.pool.ThreadPool')
def test_get_cl_statuses_timeout(self, *_mocks):
changes = [git_cl.Changelist() for _ in range(2)]
pool = multiprocessing.pool.ThreadPool()
it = pool.imap_unordered.return_value.__iter__ = mock.Mock()
it.return_value.next.side_effect = [
(changes[0], 'lgtm'),
multiprocessing.TimeoutError,
]
actual = list(git_cl.get_cl_statuses(changes, True))
self.assertEqual([(changes[0], 'lgtm'), (changes[1], 'error')], actual)
@mock.patch('git_cl.Changelist.GetIssueURL')
def test_get_cl_statuses_not_finegrained(self, _mock):
changes = [git_cl.Changelist() for _ in range(2)]
urls = ['some-url', None]
git_cl.Changelist.GetIssueURL.side_effect = urls
actual = set(git_cl.get_cl_statuses(changes, False))
self.assertEqual(set([(changes[0], 'waiting'), (changes[1], 'error')]),
actual)
def test_get_issue_url(self):
cl = git_cl.Changelist(issue=123)
cl._gerrit_server = 'https://example.com'
self.assertEqual(cl.GetIssueURL(), 'https://example.com/123')
self.assertEqual(cl.GetIssueURL(short=True), 'https://example.com/123')
cl = git_cl.Changelist(issue=123)
cl._gerrit_server = 'https://chromium-review.googlesource.com'
self.assertEqual(cl.GetIssueURL(),
'https://chromium-review.googlesource.com/123')
self.assertEqual(cl.GetIssueURL(short=True), 'https://crrev.com/c/123')
def test_set_preserve_tryjobs(self):
d = git_cl.ChangeDescription('Simple.')
d.set_preserve_tryjobs()
self.assertEqual(d.description.splitlines(), [
'Simple.',
'',
'Cq-Do-Not-Cancel-Tryjobs: true',
])
before = d.description
d.set_preserve_tryjobs()
self.assertEqual(before, d.description)
d = git_cl.ChangeDescription('\n'.join([
'One is enough',
'',
'Cq-Do-Not-Cancel-Tryjobs: dups not encouraged, but don\'t hurt',
'Change-Id: Ideadbeef',
]))
d.set_preserve_tryjobs()
self.assertEqual(d.description.splitlines(), [
'One is enough',
'',
'Cq-Do-Not-Cancel-Tryjobs: dups not encouraged, but don\'t hurt',
'Change-Id: Ideadbeef',
'Cq-Do-Not-Cancel-Tryjobs: true',
])
def test_get_bug_line_values(self):
f = lambda p, bugs: list(git_cl._get_bug_line_values(p, bugs))
self.assertEqual(f('', ''), [])
self.assertEqual(f('', '123,v8:456'), ['123', 'v8:456'])
# Prefix that ends with colon.
self.assertEqual(f('v8:', '456'), ['v8:456'])
self.assertEqual(f('v8:', 'chromium:123,456'),
['v8:456', 'chromium:123'])
# Prefix that ends without colon.
self.assertEqual(f('v8', '456'), ['v8:456'])
self.assertEqual(f('v8', 'chromium:123,456'),
['v8:456', 'chromium:123'])
# Not nice, but not worth carying.
self.assertEqual(f('v8:', 'chromium:123,456,v8:123'),
['v8:456', 'chromium:123', 'v8:123'])
self.assertEqual(f('v8', 'chromium:123,456,v8:123'),
['v8:456', 'chromium:123', 'v8:123'])
@mock.patch('gerrit_util.GetAccountDetails')
def test_valid_accounts(self, mockGetAccountDetails):
mock_per_account = {
'u1': None, # 404, doesn't exist.
'u2': {
'_account_id': 123124,
'avatars': [],
'email': 'u2@example.com',
'name': 'User Number 2',
'status': 'OOO',
},
'u3': git_cl.gerrit_util.GerritError(500,
'retries didn\'t help :('),
}
def GetAccountDetailsMock(_, account):
# Poor-man's mock library's side_effect.
v = mock_per_account.pop(account)
if isinstance(v, Exception):
raise v
return v
mockGetAccountDetails.side_effect = GetAccountDetailsMock
actual = git_cl.gerrit_util.ValidAccounts('host', ['u1', 'u2', 'u3'],
max_threads=1)
self.assertEqual(
actual, {
'u2': {
'_account_id': 123124,
'avatars': [],
'email': 'u2@example.com',
'name': 'User Number 2',
'status': 'OOO',
},
})
class TestParseIssueURL(unittest.TestCase):
def _test(self, arg, issue=None, patchset=None, hostname=None, fail=False):
parsed = git_cl.ParseIssueNumberArgument(arg)
self.assertIsNotNone(parsed)
if fail:
self.assertFalse(parsed.valid)
return
self.assertTrue(parsed.valid)
self.assertEqual(parsed.issue, issue)
self.assertEqual(parsed.patchset, patchset)
self.assertEqual(parsed.hostname, hostname)
def test_basic(self):
self._test('123', 123)
self._test('', fail=True)
self._test('abc', fail=True)
self._test('123/1', fail=True)
self._test('123a', fail=True)
self._test('ssh://chrome-review.source.com/#/c/123/4/', fail=True)
self._test('ssh://chrome-review.source.com/c/123/1/', fail=True)
def test_gerrit_url(self):
self._test('https://codereview.source.com/123', 123, None,
'codereview.source.com')
self._test('http://chrome-review.source.com/c/123', 123, None,
'chrome-review.source.com')
self._test('https://chrome-review.source.com/c/123/', 123, None,
'chrome-review.source.com')
self._test('https://chrome-review.source.com/c/123/4', 123, 4,
'chrome-review.source.com')
self._test('https://chrome-review.source.com/#/c/123/4', 123, 4,
'chrome-review.source.com')
self._test('https://chrome-review.source.com/c/123/4', 123, 4,
'chrome-review.source.com')
self._test('https://chrome-review.source.com/123', 123, None,
'chrome-review.source.com')
self._test('https://chrome-review.source.com/123/4', 123, 4,
'chrome-review.source.com')
self._test('https://chrome-review.source.com/bad/123/4', fail=True)
self._test('https://chrome-review.source.com/c/123/1/whatisthis',
fail=True)
self._test('https://chrome-review.source.com/c/abc/', fail=True)
def test_short_urls(self):
self._test('https://crrev.com/c/2151934', 2151934, None,
'chromium-review.googlesource.com')
def test_missing_scheme(self):
self._test('codereview.source.com/123', 123, None,
'codereview.source.com')
self._test('crrev.com/c/2151934', 2151934, None,
'chromium-review.googlesource.com')
class GitCookiesCheckerTest(unittest.TestCase):
def setUp(self):
super(GitCookiesCheckerTest, self).setUp()
self.c = git_cl._GitCookiesChecker()
self.c._all_hosts = []
mock.patch('sys.stdout', io.StringIO()).start()
self.addCleanup(mock.patch.stopall)
def mock_hosts_creds(self, subhost_identity_pairs):
def ensure_googlesource(h):
if not h.endswith(git_cl._GOOGLESOURCE):
assert not h.endswith('.')
return h + '.' + git_cl._GOOGLESOURCE
return h
self.c._all_hosts = [(ensure_googlesource(h), i, '.gitcookies')
for h, i in subhost_identity_pairs]
def test_identity_parsing(self):
self.assertEqual(self.c._parse_identity('ldap.google.com'),
('ldap', 'google.com'))
self.assertEqual(self.c._parse_identity('git-ldap.example.com'),
('ldap', 'example.com'))
# Specical case because we know there are no subdomains in chromium.org.
self.assertEqual(self.c._parse_identity('git-note.period.chromium.org'),
('note.period', 'chromium.org'))
# Pathological: ".period." can be either username OR domain, more likely
# domain.
self.assertEqual(self.c._parse_identity('git-note.period.example.com'),
('note', 'period.example.com'))
def test_analysis_nothing(self):
self.c._all_hosts = []
self.assertFalse(self.c.has_generic_host())
self.assertEqual(set(), self.c.get_conflicting_hosts())
self.assertEqual(set(), self.c.get_duplicated_hosts())
self.assertEqual(set(), self.c.get_partially_configured_hosts())
def test_analysis(self):
self.mock_hosts_creds([
('.googlesource.com', 'git-example.chromium.org'),
('chromium', 'git-example.google.com'),
('chromium-review', 'git-example.google.com'),
('chrome-internal', 'git-example.chromium.org'),
('chrome-internal-review', 'git-example.chromium.org'),
('conflict', 'git-example.google.com'),
('conflict-review', 'git-example.chromium.org'),
('dup', 'git-example.google.com'),
('dup', 'git-example.google.com'),
('dup-review', 'git-example.google.com'),
('partial', 'git-example.google.com'),
('gpartial-review', 'git-example.google.com'),
])
self.assertTrue(self.c.has_generic_host())
self.assertEqual(set(['conflict.googlesource.com']),
self.c.get_conflicting_hosts())
self.assertEqual(set(['dup.googlesource.com']),
self.c.get_duplicated_hosts())
self.assertEqual(
set([
'partial.googlesource.com', 'gpartial-review.googlesource.com'
]), self.c.get_partially_configured_hosts())
def test_report_no_problems(self):
self.test_analysis_nothing()
self.assertFalse(self.c.find_and_report_problems())
self.assertEqual(sys.stdout.getvalue(), '')
@mock.patch('git_cl.gerrit_util.CookiesAuthenticator.get_gitcookies_path',
return_value=os.path.join('~', '.gitcookies'))
def test_report(self, *_mocks):
self.test_analysis()
self.assertTrue(self.c.find_and_report_problems())
with open(
os.path.join(os.path.dirname(__file__),
'git_cl_creds_check_report.txt')) as f:
expected = f.read() % {
'sep': os.sep,
}
def by_line(text):
return [l.rstrip() for l in text.rstrip().splitlines()]
self.maxDiff = 10000 # pylint: disable=attribute-defined-outside-init
self.assertEqual(by_line(sys.stdout.getvalue().strip()),
by_line(expected))
class TestGitCl(unittest.TestCase):
def setUp(self):
super(TestGitCl, self).setUp()
self.calls = []
self._calls_done = []
oldEnv = dict(os.environ)
def _resetEnv():
os.environ = oldEnv
self.addCleanup(_resetEnv)
self.failed = False
mock.patch('sys.stdout', io.StringIO()).start()
mock.patch('git_cl.time_time',
lambda: self._mocked_call('time.time')).start()
mock.patch('git_cl.metrics.collector.add_repeated',
lambda *a: self._mocked_call('add_repeated', *a)).start()
mock.patch('subprocess2.call', self._mocked_call).start()
mock.patch('subprocess2.check_call', self._mocked_call).start()
mock.patch('subprocess2.check_output', self._mocked_call).start()
mock.patch('subprocess2.communicate', lambda *a, **_k:
([self._mocked_call(*a), ''], 0)).start()
mock.patch('git_cl.gclient_utils.CheckCallAndFilter',
self._mocked_call).start()
mock.patch('git_common.is_dirty_git_tree', lambda x: False).start()
mock.patch('git_cl.FindCodereviewSettingsFile', return_value='').start()
mock.patch(
'git_cl.SaveDescriptionBackup',
lambda _: self._mocked_call('SaveDescriptionBackup')).start()
mock.patch('git_cl.write_json',
lambda *a: self._mocked_call('write_json', *a)).start()
mock.patch('git_cl.Changelist.RunHook',
return_value={
'more_cc': ['test-more-cc@chromium.org']
}).start()
mock.patch('git_cl.watchlists.Watchlists', WatchlistsMock).start()
mock.patch('git_cl.auth.Authenticator', AuthenticatorMock).start()
mock.patch('gerrit_util.GetChangeDetail').start()
mock.patch(
'git_cl.gerrit_util.GetChangeComments',
lambda *a: self._mocked_call('GetChangeComments', *a)).start()
mock.patch(
'git_cl.gerrit_util.GetChangeRobotComments',
lambda *a: self._mocked_call('GetChangeRobotComments', *a)).start()
mock.patch('git_cl.gerrit_util.AddReviewers',
lambda *a: self._mocked_call('AddReviewers', *a)).start()
mock.patch('git_cl.gerrit_util.SetReview',
lambda h, i, msg=None, labels=None, notify=None, ready=None:
(self._mocked_call('SetReview', h, i, msg, labels, notify,
ready))).start()
mock.patch('git_cl.gerrit_util.LuciContextAuthenticator.is_applicable',
return_value=False).start()
mock.patch('git_cl.gerrit_util.GceAuthenticator.is_applicable',
return_value=False).start()
mock.patch('git_cl.gerrit_util.ValidAccounts',
lambda *a: self._mocked_call('ValidAccounts', *a)).start()
mock.patch('sys.exit', side_effect=SystemExitMock).start()
mock.patch('git_cl.Settings.GetRoot', return_value='').start()
scm_mock.GIT(self)
mock.patch('scm.GIT.ResolveCommit', return_value='hash').start()
mock.patch('scm.GIT.IsValidRevision', return_value=True).start()
mock.patch('scm.GIT.FetchUpstreamTuple',
return_value=('origin', 'refs/heads/main')).start()
mock.patch('scm.GIT.CaptureStatus',
return_value=[('M', 'foo.txt')]).start()
# It's important to reset settings to not have inter-tests interference.
git_cl.settings = git_cl.Settings()
self.addCleanup(mock.patch.stopall)
gerrit_util._Authenticator._resolved = None
def tearDown(self):
try:
if not self.failed:
self.assertEqual([], self.calls)
except AssertionError:
calls = ''.join(' %s\n' % str(call) for call in self.calls[:5])
if len(self.calls) > 5:
calls += ' ...\n'
self.fail(
'\n'
'There are un-consumed calls after this test has finished:\n' +
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)
expected_args, result = top
# 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))
self.failed = True
self.fail(
'@%d\n'
' Expected: %r\n'
' Actual: %r\n'
'\n'
'%s' %
(len(self._calls_done), expected_args, args, extended_msg))
self._calls_done.append(top)
if isinstance(result, Exception):
raise result
# stdout from git commands is supposed to be a bytestream. Convert it
# here instead of converting all test output in this file to bytes.
if args[0][0] == 'git' and not isinstance(result, bytes):
result = result.encode('utf-8')
return result
@mock.patch('sys.stdin', io.StringIO('blah\nye\n'))
@mock.patch('sys.stdout', io.StringIO())
def test_ask_for_explicit_yes_true(self):
self.assertTrue(git_cl.ask_for_explicit_yes('prompt'))
self.assertEqual('prompt [Yes/No]: Please, type yes or no: ',
sys.stdout.getvalue())
def test_LoadCodereviewSettingsFromFile_gerrit(self):
codereview_file = io.StringIO('GERRIT_HOST: true')
self.calls = [
]
self.assertIsNone(
git_cl.LoadCodereviewSettingsFromFile(codereview_file))
@classmethod
def _gerrit_base_calls(cls,
issue=None,
fetched_description=None,
fetched_status=None,
other_cl_owner=None,
custom_cl_base=None,
short_hostname='chromium',
change_id=None,
default_branch='main',
reset_issue=False):
calls = [
(
(['os.path.isfile', '.gitmodules'], ),
'True',
),
]
if custom_cl_base:
ancestor_revision = custom_cl_base
else:
# Determine ancestor_revision to be merge base.
ancestor_revision = 'origin/' + default_branch
if issue:
# TODO: if tests don't provide a `change_id` the default used here
# will cause the TRACES_README_FORMAT mock (which uses the test
# provided `change_id` to fail.
gerrit_util.GetChangeDetail.return_value = {
'owner': {
'email': (other_cl_owner or 'owner@example.com')
},
'change_id': (change_id or '123456789'),
'current_revision': 'sha1_of_current_revision',
'revisions': {
'sha1_of_current_revision': {
'commit': {
'message': fetched_description
},
}
},
'status': fetched_status or 'NEW',
}
if fetched_status == 'ABANDONED':
return calls
if fetched_status == 'MERGED':
calls.append(((
'ask_for_data',
'Change https://chromium-review.googlesource.com/%s has been '
'submitted, new uploads are not allowed. Would you like to start '
'a new change (Y/n)?' % issue),
'y' if reset_issue else 'n'))
if not reset_issue:
return calls
# Part of SetIssue call.
calls.append(((['git', 'log', '-1', '--format=%B'], ), ''))
if other_cl_owner:
calls += [
(('ask_for_data',
'Press Enter to upload, or Ctrl+C to abort'), ''),
]
calls += [
((['git', 'rev-list', '--count'] +
([f'{custom_cl_base}..HEAD']
if custom_cl_base else [f'{ancestor_revision}..HEAD']), ), '3'),
]
calls += [
((['git', 'diff', '--no-ext-diff', '--stat', '-l100000', '-C50'] +
([custom_cl_base]
if custom_cl_base else [ancestor_revision, 'HEAD']), ), '+dat'),
]
return calls
def _gerrit_upload_calls(self,
description,
reviewers,
squash,
squash_mode='default',
title=None,
notify=False,
post_amend_description=None,
issue=None,
cc=None,
custom_cl_base=None,
short_hostname='chromium',
labels=None,
change_id=None,
final_description=None,
gitcookies_exists=True,
force=False,
edit_description=None,
default_branch='main',
ref_to_push='abcdef0123456789',
external_parent=None,
push_opts=None):
if post_amend_description is None:
post_amend_description = description
cc = cc or []
calls = []
if squash_mode in ('override_squash', 'override_nosquash'):
scm.GIT.SetConfig(
'', 'gerrit.override-squash-uploads',
'true' if squash_mode == 'override_squash' else 'false')
if not git_footers.get_footer_change_id(description) and not squash:
calls += [
(('DownloadGerritHook', False), ''),
]
if squash:
if not issue and not force:
calls += [
((['RunEditor'], ), description),
]
# user wants to edit description
if edit_description:
calls += [
((['RunEditor'], ), edit_description),
]
if external_parent:
parent = external_parent
else:
if custom_cl_base is None:
parent = 'origin/' + default_branch
git_common.get_or_create_merge_base.return_value = parent
else:
calls += [
(([
'git', 'merge-base', '--is-ancestor',
custom_cl_base,
'refs/remotes/origin/' + default_branch
], ), callError(1)), # Means not ancenstor.
(('ask_for_data',
'Do you take responsibility for cleaning up potential mess '
'resulting from proceeding with upload? Press Enter to upload, '
'or Ctrl+C to abort'), ''),
]
parent = custom_cl_base
calls += [
(
(['git', 'rev-parse',
'HEAD:'], ), # `HEAD:` means HEAD's tree hash.
'0123456789abcdef'),
((['FileWrite', '/tmp/fake-temp1', description], ), None),
(([
'git', 'commit-tree', '0123456789abcdef', '-p', parent,
'-F', '/tmp/fake-temp1'
], ), ref_to_push),
]
else:
ref_to_push = 'HEAD'
parent = 'origin/refs/heads/' + default_branch
calls += [
(('SaveDescriptionBackup', ), None),
((['git', 'rev-list',
parent + '..' + ref_to_push], ), '1hashPerLine\n'),
]
metrics_arguments = []
ref_suffix_list = []
if notify:
ref_suffix_list.append('ready,notify=ALL')
metrics_arguments += ['ready', 'notify=ALL']
elif not issue and squash:
ref_suffix_list.append('wip')
metrics_arguments.append('wip')
# If issue is given, then description is fetched from Gerrit instead.
if not title and squash_mode != "override_nosquash":
if issue is None:
if squash:
title = 'Initial upload'
else:
calls += [
((['git', 'show', '-s', '--format=%s', 'HEAD',
'--'], ), ''),
(('ask_for_data', 'Title for patchset []: '), 'User input'),
]
title = 'User input'
if title:
ref_suffix_list.append('m=' +
gerrit_util.PercentEncodeForGitRef(title))
metrics_arguments.append('m')
for k, v in sorted((labels or {}).items()):
ref_suffix_list.append('l=%s+%d' % (k, v))
metrics_arguments.append('l=%s+%d' % (k, v))
if short_hostname == 'chromium':
# All reviewers and ccs get into ref_suffix.
for r in sorted(reviewers):
ref_suffix_list.append('r=%s' % r)
metrics_arguments.append('r')
if issue is None:
cc += ['test-more-cc@chromium.org', 'joe@example.com']
for c in sorted(cc):
ref_suffix_list.append('cc=%s' % c)
metrics_arguments.append('cc')
reviewers, cc = [], []
else:
# TODO(crbug/877717): remove this case.
calls += [(('ValidAccounts',
'%s-review.googlesource.com' % short_hostname,
sorted(reviewers) +
['joe@example.com', 'test-more-cc@chromium.org'] + cc),
{
e: {
'email': e
}
for e in (reviewers + ['joe@example.com'] + cc)
})]
for r in sorted(reviewers):
if r != 'bad-account-or-email':
ref_suffix_list.append('r=%s' % r)
metrics_arguments.append('r')
reviewers.remove(r)
if issue is None:
cc += ['joe@example.com']
for c in sorted(cc):
ref_suffix_list.append('cc=%s' % c)
metrics_arguments.append('cc')
if c in cc:
cc.remove(c)
ref_suffix = ''
if ref_suffix_list:
ref_suffix = '%' + ','.join(ref_suffix_list)
calls += [
(
('time.time', ),
1000,
),
(
([
'git', 'push',
'https://%s.googlesource.com/my/repo' % short_hostname,
ref_to_push + ':refs/for/refs/heads/' + default_branch +
ref_suffix
] + (push_opts if push_opts else []), ),
(('remote:\n'
'remote: Processing changes: (\\)\n'
'remote: Processing changes: (|)\n'
'remote: Processing changes: (/)\n'
'remote: Processing changes: (-)\n'
'remote: Processing changes: new: 1 (/)\n'
'remote: Processing changes: new: 1, done\n'
'remote:\n'
'remote: New Changes:\n'
'remote: '
'https://%s-review.googlesource.com/#/c/my/repo/+/123456'
' XXX\n'
'remote:\n'
'To https://%s.googlesource.com/my/repo\n'
' * [new branch] hhhh -> refs/for/refs/heads/%s\n') %
(short_hostname, short_hostname, default_branch)),
),
(
('time.time', ),
2000,
),
(
('add_repeated', 'sub_commands', {
'execution_time': 1000,
'command': 'git push',
'exit_code': 0,
'arguments': sorted(metrics_arguments),
}),
None,
),
]
final_description = final_description or post_amend_description.strip()
trace_name = os.path.join('TRACES_DIR', '20170316T200041.000000')
# Trace-related calls
calls += [
# Write a description with context for the current trace.
(
([
'FileWrite', trace_name + '-README',
'%(date)s\n'
'%(short_hostname)s-review.googlesource.com\n'
'%(change_id)s\n'
'%(title)s\n'
'%(description)s\n'
'1000\n'
'0\n'
'%(trace_name)s' % {
'date': '2017-03-16T20:00:41.000000',
'short_hostname': short_hostname,
'change_id': change_id,
'description': final_description,
'title': title or '<untitled>',
'trace_name': trace_name,
}
], ),
None,
),
# Read traces and shorten git hashes.
(
(['os.path.isfile',
os.path.join('TEMP_DIR', 'trace-packet')], ),
True,
),
(
(['FileRead',
os.path.join('TEMP_DIR', 'trace-packet')], ),
('git-hash: 0123456789012345678901234567890123456789\n'
'git-hash: abcdeabcdeabcdeabcdeabcdeabcdeabcdeabcde\n'),
),
(
([
'FileWrite',
os.path.join('TEMP_DIR', 'trace-packet'),
'git-hash: 012345\n'
'git-hash: abcdea\n'
], ),
None,
),
# Make zip file for the git traces.
(
(['make_archive', trace_name + '-traces', 'zip', 'TEMP_DIR'], ),
None,
),
# Collect git config and gitcookies.
#
# We accept ANY for the git-config file because it's just reflecting
# our mocked git config in scm.GIT anyway.
(
([
'FileWrite',
os.path.join('TEMP_DIR', 'git-config'), mock.ANY,
], ),
None,
),
(
(['os.path.isfile',
os.path.join('~', '.gitcookies')], ),
gitcookies_exists,
),
]
if gitcookies_exists:
calls += [
(
(['FileRead', os.path.join('~', '.gitcookies')], ),
'gitcookies 1/SECRET',
),
(
([
'FileWrite',
os.path.join(
'TEMP_DIR',
'CookiesAuthenticatorMock.debug_summary_state'),
'gitcookies REDACTED'
], ),
None,
),
]
else:
calls += [
(
([
'FileWrite',
os.path.join(
'TEMP_DIR',
'CookiesAuthenticatorMock.debug_summary_state'), ''
], ),
None,
),
]
calls += [
# Make zip file for the git config and gitcookies.
(
(['make_archive', trace_name + '-git-info', 'zip',
'TEMP_DIR'], ),
None,
),
]
# TODO(crbug/877717): this should never be used.
if squash and short_hostname != 'chromium':
calls += [
(('AddReviewers', 'chromium-review.googlesource.com',
'my%2Frepo~123456', sorted(reviewers),
cc + ['test-more-cc@chromium.org'], notify), ''),
]
return calls
def _run_gerrit_upload_test(self,
upload_args,
description,
reviewers=None,
squash=True,
squash_mode=None,
title=None,
notify=False,
post_amend_description=None,
issue=None,
patchset=None,
cc=None,
fetched_status=None,
other_cl_owner=None,
custom_cl_base=None,
short_hostname='chromium',
labels=None,
change_id=None,
final_description=None,
gitcookies_exists=True,
force=False,
log_description=None,
edit_description=None,
fetched_description=None,
default_branch='main',
ref_to_push='abcdef0123456789',
external_parent=None,
push_opts=None,
reset_issue=False):
"""Generic gerrit upload test framework."""
if squash_mode is None:
if '--no-squash' in upload_args:
squash_mode = 'nosquash'
elif '--squash' in upload_args:
squash_mode = 'squash'
else:
squash_mode = 'default'
reviewers = reviewers or []
cc = cc or []
mock.patch(
'git_cl.gerrit_util.CookiesAuthenticator',
CookiesAuthenticatorMockFactory(same_auth=('git-owner.example.com',
'pass'))).start()
mock.patch('git_cl.Changelist._GerritCommitMsgHookCheck',
lambda offer_removal: None).start()
mock.patch('git_cl.Changelist.GetMostRecentPatchset',
lambda _, update: patchset).start()
mock.patch('git_cl.gclient_utils.RunEditor',
lambda *_, **__: self._mocked_call(['RunEditor'])).start()
mock.patch('git_cl.DownloadGerritHook', lambda force: self._mocked_call(
'DownloadGerritHook', force)).start()
mock.patch('git_cl.gclient_utils.FileRead',
lambda path: self._mocked_call(['FileRead', path])).start()
mock.patch(
'git_cl.gclient_utils.FileWrite', lambda path, contents: self.
_mocked_call(['FileWrite', path, contents])).start()
mock.patch(
'git_cl.datetime_now',
lambda: datetime.datetime(2017, 3, 16, 20, 0, 41, 0)).start()
mock.patch('git_cl.tempfile.mkdtemp', lambda: 'TEMP_DIR').start()
mock.patch('git_cl.TRACES_DIR', 'TRACES_DIR').start()
mock.patch(
'git_cl.TRACES_README_FORMAT', '%(now)s\n'
'%(gerrit_host)s\n'
'%(change_id)s\n'
'%(title)s\n'
'%(description)s\n'
'%(execution_time)s\n'
'%(exit_code)s\n'
'%(trace_name)s').start()
mock.patch(
'git_cl.shutil.make_archive', lambda *args: self._mocked_call(
['make_archive'] + list(args))).start()
mock.patch(
'os.path.isfile',
lambda path: self._mocked_call(['os.path.isfile', path])).start()
mock.patch('git_cl._create_description_from_log',
return_value=log_description or description).start()
mock.patch('git_cl.Changelist._AddChangeIdToCommitMessage',
return_value=post_amend_description or description).start()
mock.patch('git_cl.GenerateGerritChangeId',
return_value=change_id).start()
mock.patch('git_common.get_or_create_merge_base',
return_value='origin/' + default_branch).start()
mock.patch('gerrit_util.GetAccountDetails',
getAccountDetailsMock).start()
mock.patch(
'gclient_utils.AskForData',
lambda prompt: self._mocked_call('ask_for_data', prompt)).start()
scm.GIT.SetConfig('', 'gerrit.host', 'true')
scm.GIT.SetConfig('', 'branch.main.gerritissue',
(str(issue) if issue else None))
scm.GIT.SetConfig('', 'remote.origin.url',
f'https://{short_hostname}.googlesource.com/my/repo')
scm.GIT.SetConfig('', 'user.email', 'owner@example.com')
if squash_mode == "override_nosquash":
if issue:
mock.patch('gerrit_util.GetChange',
return_value={
'_number': issue
}).start()
else:
mock.patch('gerrit_util.GetChange', return_value={}).start()
self.calls = self._gerrit_base_calls(
issue=issue,
fetched_description=fetched_description or description,
fetched_status=fetched_status,
other_cl_owner=other_cl_owner,
custom_cl_base=custom_cl_base,
short_hostname=short_hostname,
change_id=change_id,
default_branch=default_branch,
reset_issue=reset_issue)
if fetched_status == 'ABANDONED' or (fetched_status == 'MERGED'
and not reset_issue):
pass # readability
else:
if fetched_status == 'MERGED' and reset_issue:
fetched_status = 'NEW'
issue = None
mock.patch('gclient_utils.temporary_file',
TemporaryFileMock()).start()
mock.patch('os.remove', return_value=True).start()
self.calls += self._gerrit_upload_calls(
description,
reviewers,
squash,
squash_mode=squash_mode,
title=title,
notify=notify,
post_amend_description=post_amend_description,
issue=issue,
cc=cc,
custom_cl_base=custom_cl_base,
short_hostname=short_hostname,
labels=labels,
change_id=change_id,
final_description=final_description,
gitcookies_exists=gitcookies_exists,
force=force,
edit_description=edit_description,
default_branch=default_branch,
ref_to_push=ref_to_push,
external_parent=external_parent,
push_opts=push_opts)
# Uncomment when debugging.
# print('\n'.join(map(lambda x: '%2i: %s' % x, enumerate(self.calls))))
git_cl.main(['upload'] + upload_args)
if squash:
self.assertIssueAndPatchset(patchset=str((patchset or 0) + 1))
self.assertEqual(
ref_to_push,
scm.GIT.GetBranchConfig('', 'main',
git_cl.GERRIT_SQUASH_HASH_CONFIG_KEY))
@mock.patch('git_cl.Changelist.GetGerritHost',
return_value='chromium-review.googlesource.com')
@mock.patch('git_cl.Changelist.GetRemoteBranch',
return_value=('origin', 'refs/remotes/origin/main'))
@mock.patch('git_cl.Changelist.PostUploadUpdates')
@mock.patch('git_cl.Changelist._RunGitPushWithTraces')
@mock.patch('git_cl._UploadAllPrecheck')
@mock.patch('git_cl.Changelist.PrepareCherryPickSquashedCommit')
def test_upload_all_squashed_cherry_pick(self, mockCherryPickCommit,
mockUploadAllPrecheck,
mockRunGitPush,
mockPostUploadUpdates, *_mocks):
# Set up
cls = [
git_cl.Changelist(branchref='refs/heads/current-branch',
issue='12345'),
git_cl.Changelist(branchref='refs/heads/upstream-branch')
]
mockUploadAllPrecheck.return_value = (cls, True)
upstream_gerrit_commit = 'upstream-commit'
scm.GIT.SetConfig('', 'branch.upstream-branch.gerritsquashhash',
upstream_gerrit_commit)
reviewers = []
ccs = []
commit_to_push = 'commit-to-push'
new_last_upload = 'new-last-upload'
change_desc = git_cl.ChangeDescription(
'stonks/nChange-Id:ec15e81197380')
prev_patchset = 2
new_upload = git_cl._NewUpload(reviewers, ccs, commit_to_push,
new_last_upload, upstream_gerrit_commit,
change_desc, prev_patchset)
mockCherryPickCommit.return_value = new_upload
options = optparse.Values()
options.send_mail = options.private = False
options.squash = True
options.title = None
options.message = 'honk stonk'
options.topic = 'circus'
options.enable_auto_submit = False
options.enable_owners_override = False
options.set_bot_commit = False
options.cq_dry_run = False
options.use_commit_queue = False
options.hashtags = ['cow']
options.target_branch = None
options.push_options = ['uploadvalidator~skip']
orig_args = []
mockRunGitPush.return_value = (
'remote: https://chromium-review.'
'googlesource.com/c/chromium/circus/clown/+/1234 stonks')
# Call
git_cl.UploadAllSquashed(options, orig_args)
# Asserts
mockCherryPickCommit.assert_called_once_with(options,
upstream_gerrit_commit)
expected_refspec = ('commit-to-push:refs/for/refs/heads/main%'
'm=honk_stonk,topic=circus,hashtag=cow')
expected_refspec_opts = ['m=honk_stonk', 'topic=circus', 'hashtag=cow']
mockRunGitPush.assert_called_once_with(expected_refspec,
expected_refspec_opts, mock.ANY,
options.push_options)
mockPostUploadUpdates.assert_called_once_with(options, new_upload,
'1234')
@mock.patch('git_cl.Changelist.GetGerritHost',
return_value='chromium-review.googlesource.com')
@mock.patch('git_cl.Changelist.GetRemoteBranch',
return_value=('origin', 'refs/remotes/origin/main'))
@mock.patch(
'git_cl.Changelist.GetCommonAncestorWithUpstream',
side_effect=['current-upstream-ancestor', 'next-upstream-ancestor'])
@mock.patch('git_cl.Changelist.PostUploadUpdates')
@mock.patch('git_cl.Changelist._RunGitPushWithTraces')
@mock.patch('git_cl._UploadAllPrecheck')
@mock.patch('git_cl.Changelist.PrepareSquashedCommit')
def test_upload_all_squashed(self, mockSquashedCommit,
mockUploadAllPrecheck, mockRunGitPush,
mockPostUploadUpdates, *_mocks):
# Set up
cls = [
git_cl.Changelist(branchref='refs/heads/current-branch',
issue='12345'),
git_cl.Changelist(branchref='refs/heads/upstream-branch')
]
mockUploadAllPrecheck.return_value = (cls, False)
reviewers = []
ccs = []
current_commit_to_push = 'commit-to-push'
current_new_last_upload = 'new-last-upload'
change_desc = git_cl.ChangeDescription(
'stonks/nChange-Id:ec15e81197380')
prev_patchset = 2
new_upload_current = git_cl._NewUpload(reviewers, ccs,
current_commit_to_push,
current_new_last_upload,
'next-upstream-ancestor',
change_desc, prev_patchset)
upstream_desc = git_cl.ChangeDescription('kwak')
upstream_parent = 'origin-commit'
upstream_new_last_upload = 'upstrea-last-upload'
upstream_commit_to_push = 'upstream_push_commit'
new_upload_upstream = git_cl._NewUpload(reviewers, ccs,
upstream_commit_to_push,
upstream_new_last_upload,
upstream_parent, upstream_desc,
prev_patchset)
mockSquashedCommit.side_effect = [
new_upload_upstream, new_upload_current
]
options = optparse.Values()
options.send_mail = options.private = False
options.squash = True
options.title = None
options.message = 'honk stonk'
options.topic = 'circus'
options.enable_auto_submit = False
options.enable_owners_override = False
options.set_bot_commit = False
options.cq_dry_run = False
options.use_commit_queue = False
options.hashtags = ['cow']
options.target_branch = None
options.push_options = ['uploadvalidator~skip']
orig_args = []
mockRunGitPush.return_value = (
'remote: https://chromium-review.'
'googlesource.com/c/chromium/circus/clown/+/1233 kwak'
'\n'
'remote: https://chromium-review.'
'googlesource.com/c/chromium/circus/clown/+/1234 stonks')
# Call
git_cl.UploadAllSquashed(options, orig_args)
# Asserts
self.maxDiff = None
self.assertEqual(mockSquashedCommit.mock_calls, [
mock.call(options,
'current-upstream-ancestor',
'current-upstream-ancestor',
end_commit='next-upstream-ancestor'),
mock.call(options,
upstream_commit_to_push,
'next-upstream-ancestor',
end_commit=None)
])
expected_refspec = ('commit-to-push:refs/for/refs/heads/main%'
'topic=circus,hashtag=cow')
expected_refspec_opts = ['topic=circus', 'hashtag=cow']
mockRunGitPush.assert_called_once_with(expected_refspec,
expected_refspec_opts, mock.ANY,
options.push_options)
self.assertEqual(mockPostUploadUpdates.mock_calls, [
mock.call(options, new_upload_upstream, '1233'),
mock.call(options, new_upload_current, '1234')
])
@mock.patch('git_cl.Changelist.GetGerritHost',
return_value='chromium-review.googlesource.com')
@mock.patch('git_cl.Changelist.GetRemoteBranch',
return_value=('origin', 'refs/remotes/origin/main'))
@mock.patch('git_cl.Changelist.GetCommonAncestorWithUpstream',
return_value='current-upstream-ancestor')
@mock.patch('git_cl.Changelist._UpdateWithExternalChanges')
@mock.patch('git_cl.Changelist.PostUploadUpdates')
@mock.patch('git_cl.Changelist._RunGitPushWithTraces')
@mock.patch('git_cl._UploadAllPrecheck')
@mock.patch('git_cl.Changelist.PrepareSquashedCommit')
def test_upload_all_squashed_external_changes(self, mockSquashedCommit,
mockUploadAllPrecheck,
mockRunGitPush,
mockPostUploadUpdates,
mockExternalChanges, *_mocks):
options = optparse.Values()
options.send_mail = options.private = False
options.squash = True
options.title = None
options.topic = 'circus'
options.message = 'honk stonk'
options.enable_auto_submit = False
options.enable_owners_override = False
options.set_bot_commit = False
options.cq_dry_run = False
options.use_commit_queue = False
options.hashtags = ['cow']
options.target_branch = None
options.push_options = ['uploadvalidator~skip']
orig_args = []
cls = [
git_cl.Changelist(branchref='refs/heads/current-branch',
issue='12345')
]
mockUploadAllPrecheck.return_value = (cls, False)
reviewers = []
ccs = []
# Test case: user wants to pull in external changes.
mockExternalChanges.reset_mock()
mockExternalChanges.return_value = None
current_commit_to_push = 'commit-to-push'
current_new_last_upload = 'new-last-upload'
change_desc = git_cl.ChangeDescription(
'stonks/nChange-Id:ec15e81197380')
prev_patchset = 2
new_upload_current = git_cl._NewUpload(reviewers, ccs,
current_commit_to_push,
current_new_last_upload,
'next-upstream-ancestor',
change_desc, prev_patchset)
mockSquashedCommit.return_value = new_upload_current
mockRunGitPush.return_value = (
'remote: https://chromium-review.'
'googlesource.com/c/chromium/circus/clown/+/1233 kwak')
# Test case: user wants to pull in external changes.
mockExternalChanges.reset_mock()
mockExternalChanges.return_value = 'external-commit'
# Call
git_cl.UploadAllSquashed(options, orig_args)
# Asserts
self.assertEqual(mockSquashedCommit.mock_calls, [
mock.call(
options, 'external-commit', 'external-commit', end_commit=None)
])
expected_refspec = ('commit-to-push:refs/for/refs/heads/main%'
'm=honk_stonk,topic=circus,hashtag=cow')
expected_refspec_opts = ['m=honk_stonk', 'topic=circus', 'hashtag=cow']
mockRunGitPush.assert_called_once_with(expected_refspec,
expected_refspec_opts, mock.ANY,
options.push_options)
self.assertEqual(mockPostUploadUpdates.mock_calls,
[mock.call(options, new_upload_current, '1233')])
# Test case: user does not want external changes or there are none.
mockSquashedCommit.reset_mock()
mockExternalChanges.return_value = None
# Call
git_cl.UploadAllSquashed(options, orig_args)
# Asserts
self.assertEqual(mockSquashedCommit.mock_calls, [
mock.call(options,
'current-upstream-ancestor',
'current-upstream-ancestor',
end_commit=None)
])
@mock.patch('git_cl.Changelist._GerritCommitMsgHookCheck',
lambda offer_removal: None)
@mock.patch('git_cl.RunGit')
@mock.patch('git_cl.RunGitSilent')
@mock.patch('git_cl.Changelist._GitGetBranchConfigValue')
@mock.patch('git_cl.Changelist.FetchUpstreamTuple')
@mock.patch('git_cl.Changelist.GetCommonAncestorWithUpstream')
@mock.patch('scm.GIT.GetBranchRef')
@mock.patch('git_cl.Changelist.GetRemoteBranch')
@mock.patch('scm.GIT.IsAncestor')
@mock.patch('gclient_utils.AskForData')
def test_upload_all_precheck_long_chain(
self, mockAskForData, mockIsAncestor, mockGetRemoteBranch,
mockGetBranchRef, mockGetCommonAncestorWithUpstream,
mockFetchUpstreamTuple, mockGitGetBranchConfigValue,
mockRunGitSilent, mockRunGit, *_mocks):
mockGetRemoteBranch.return_value = ('origin',
'refs/remotes/origin/main')
branches = [
'current', 'upstream3', 'blank3', 'blank2', 'upstream2', 'blank1',
'upstream1', 'origin/main'
]
mockGetBranchRef.side_effect = (
['refs/heads/current'] + # detached HEAD check
['refs/heads/%s' % b for b in branches])
mockGetCommonAncestorWithUpstream.side_effect = [
'commit3.5',
'commit3.5',
'commit3.5',
'commit2.5',
'commit1.5',
'commit1.5',
'commit0.5',
]
mockFetchUpstreamTuple.side_effect = [('.', 'refs/heads/upstream3'),
('.', 'refs/heads/blank3'),
('.', 'refs/heads/blank2'),
('.', 'refs/heads/upstream2'),
('.', 'refs/heads/blank1'),
('.', 'refs/heads/upstream1'),
('origin',
'refs/heads/origin/main')]
# end commits
mockRunGit.side_effect = [
'commit4', 'commit3.5', 'commit3.5', 'commit2', 'commit1.5',
'commit1', 'commit0.5'
]
mockRunGitSilent.side_effect = ['80', '81', '0', '0', '82', '0', '83']
# Get gerrit squash hash. We only check this for branches that have a
# diff. Set to None to trigger `must_upload_upstream`.
mockGitGetBranchConfigValue.return_value = None
options = optparse.Values()
options.force = False
options.cherry_pick_stacked = False
orig_args = ['--preserve-tryjobs', '--chicken']
# Case 2: upstream3 has never been uploaded.
# (so no LAST_UPLOAD_HASH_CONIFG_KEY)
# Case 4: upstream2's last_upload is behind upstream3's base_commit
key = f'branch.upstream2.{git_cl.LAST_UPLOAD_HASH_CONFIG_KEY}'
scm.GIT.SetConfig('', key, 'commit2.3')
mockIsAncestor.side_effect = [True]
# Case 3: upstream1's last_upload matches upstream2's base_commit
key = f'branch.upstream1.{git_cl.LAST_UPLOAD_HASH_CONFIG_KEY}'
scm.GIT.SetConfig('', key, 'commit1.5')
cls, cherry_pick = git_cl._UploadAllPrecheck(options, orig_args)
self.assertFalse(cherry_pick)
mockAskForData.assert_called_once_with(
"\noptions ['--preserve-tryjobs', '--chicken'] will be used for all "
"uploads.\nAt least one parent branch in `current, upstream3, "
"upstream2` has never been uploaded and must be uploaded before/with "
"`upstream3`.\nPress Enter to confirm, or Ctrl+C to abort")
self.assertEqual(len(cls), 3)
@mock.patch('git_cl.Changelist._GerritCommitMsgHookCheck',
lambda offer_removal: None)
@mock.patch('git_cl.RunGit')
@mock.patch('git_cl.RunGitSilent')
@mock.patch('git_cl.Changelist._GitGetBranchConfigValue')
@mock.patch('git_cl.Changelist.FetchUpstreamTuple')
@mock.patch('git_cl.Changelist.GetCommonAncestorWithUpstream')
@mock.patch('scm.GIT.GetBranchRef')
@mock.patch('git_cl.Changelist.GetRemoteBranch')
@mock.patch('scm.GIT.IsAncestor')
@mock.patch('gclient_utils.AskForData')
def test_upload_all_precheck_options_must_upload(
self, mockAskForData, mockIsAncestor, mockGetRemoteBranch,
mockGetBranchRef, mockGetCommonAncestorWithUpstream,
mockFetchUpstreamTuple, mockGitGetBranchConfigValue,
mockRunGitSilent, mockRunGit, *_mocks):
mockGetRemoteBranch.return_value = ('origin',
'refs/remotes/origin/main')
branches = ['current', 'upstream3', 'main']
mockGetBranchRef.side_effect = (
['refs/heads/current'] + # detached HEAD check
['refs/heads/%s' % b for b in branches])
mockGetCommonAncestorWithUpstream.side_effect = [
'commit3.5', 'commit0.5'
]
mockFetchUpstreamTuple.side_effect = [('.', 'refs/heads/upstream3'),
('origin', 'refs/heads/main')]
mockIsAncestor.return_value = True
# end commits
mockRunGit.return_value = 'any-commit'
mockRunGitSilent.return_value = '42'
# Get gerrit squash hash. We only check this for branches that have a
# diff.
mockGitGetBranchConfigValue.return_value = None
# Test case: User wants to cherry pick, but all branches must be
# uploaded.
options = optparse.Values()
options.force = True
options.cherry_pick_stacked = True
orig_args = []
with self.assertRaises(SystemExitMock):
git_cl._UploadAllPrecheck(options, orig_args)
# Test case: User does not require cherry picking
options.cherry_pick_stacked = False
# reset side_effects
mockGetBranchRef.side_effect = (
['refs/heads/current'] + # detached HEAD check
['refs/heads/%s' % b for b in branches])
mockGetCommonAncestorWithUpstream.side_effect = [
'commit3.5', 'commit0.5'
]
mockFetchUpstreamTuple.side_effect = [('.', 'refs/heads/upstream3'),
('origin', 'refs/heads/main')]
cls, cherry_pick = git_cl._UploadAllPrecheck(options, orig_args)
self.assertFalse(cherry_pick)
self.assertEqual(len(cls), 2)
mockAskForData.assert_not_called()
# Test case: User does not require cherry picking and not in force mode.
options.force = False
# reset side_effects
mockGetBranchRef.side_effect = (
['refs/heads/current'] + # detached HEAD check
['refs/heads/%s' % b for b in branches])
mockGetCommonAncestorWithUpstream.side_effect = [
'commit3.5', 'commit0.5'
]
mockFetchUpstreamTuple.side_effect = [('.', 'refs/heads/upstream3'),
('origin', 'refs/heads/main')]
cls, cherry_pick = git_cl._UploadAllPrecheck(options, orig_args)
self.assertFalse(cherry_pick)
self.assertEqual(len(cls), 2)
mockAskForData.assert_called_once()
@mock.patch('git_cl.Changelist._GerritCommitMsgHookCheck',
lambda offer_removal: None)
@mock.patch('git_cl.RunGit')
@mock.patch('git_cl.RunGitSilent')
@mock.patch('git_cl.Changelist._GitGetBranchConfigValue')
@mock.patch('git_cl.Changelist.FetchUpstreamTuple')
@mock.patch('git_cl.Changelist.GetCommonAncestorWithUpstream')
@mock.patch('scm.GIT.GetBranchRef')
@mock.patch('scm.GIT.IsAncestor')
@mock.patch('gclient_utils.AskForData')
def test_upload_all_precheck_must_rebase(
self, mockAskForData, mockIsAncestor, mockGetBranchRef,
mockGetCommonAncestorWithUpstream, mockFetchUpstreamTuple,
mockGitGetBranchConfigValue, mockRunGitSilent, mockRunGit, *_mocks):
branches = ['current', 'upstream3']
mockGetBranchRef.side_effect = ['refs/heads/%s' % b for b in branches]
mockGetCommonAncestorWithUpstream.return_value = 'commit3.5'
mockFetchUpstreamTuple.return_value = ('.', 'refs/heads/upstream3')
# end commits
mockRunGit.return_value = 'commit4'
mockRunGitSilent.return_value = '42'
# Get gerrit squash hash. We only check this for branches that have a
# diff. Set to None to trigger `must_upload_upstream`.
mockGitGetBranchConfigValue.return_value = None
# Case 5: current's base_commit is behind upstream3's last_upload.
key = f'branch.upstream3.{git_cl.LAST_UPLOAD_HASH_CONFIG_KEY}'
scm.GIT.SetConfig('', key, 'commit3.7')
mockIsAncestor.side_effect = [False, True]
with self.assertRaises(SystemExitMock):
options = optparse.Values()
options.force = False
options.cherry_pick_stacked = False
git_cl._UploadAllPrecheck(options, [])
@mock.patch('git_cl.Changelist._GerritCommitMsgHookCheck',
lambda offer_removal: None)
@mock.patch('git_cl.RunGit')
@mock.patch('git_cl.RunGitSilent')
@mock.patch('git_cl.Changelist._GitGetBranchConfigValue')
@mock.patch('git_cl.Changelist.FetchUpstreamTuple')
@mock.patch('git_cl.Changelist.GetCommonAncestorWithUpstream')
@mock.patch('scm.GIT.GetBranchRef')
@mock.patch('git_cl.Changelist.GetRemoteBranch')
@mock.patch('scm.GIT.IsAncestor')
@mock.patch('gclient_utils.AskForData')
def test_upload_all_precheck_hit_main(
self, mockAskForData, mockIsAncestor, mockGetRemoteBranch,
mockGetBranchRef, mockGetCommonAncestorWithUpstream,
mockFetchUpstreamTuple, mockGitGetBranchConfigValue,
mockRunGitSilent, mockRunGit, *_mocks):
options = optparse.Values()
options.force = False
options.cherry_pick_stacked = False
orig_args = ['--preserve-tryjobs', '--chicken']
mockGetRemoteBranch.return_value = ('origin',
'refs/remotes/origin/main')
branches = ['current', 'upstream3', 'main']
mockGetBranchRef.side_effect = (
['refs/heads/current'] + # detached HEAD check
['refs/heads/%s' % b for b in branches])
mockGetCommonAncestorWithUpstream.side_effect = [
'commit3.5', 'commit0.5'
]
mockFetchUpstreamTuple.side_effect = [('.', 'refs/heads/upstream3'),
('origin', 'refs/heads/main')]
mockIsAncestor.return_value = True
# Give upstream3 a last upload hash
key = f'branch.upstream3.{git_cl.LAST_UPLOAD_HASH_CONFIG_KEY}'
scm.GIT.SetConfig('', key, 'commit3.4')
# end commits
mockRunGit.return_value = 'commit4'
mockRunGitSilent.return_value = '42'
# Get gerrit squash hash. We only check this for branches that have a
# diff.
mockGitGetBranchConfigValue.return_value = 'just needs to exist'
# Test case: user cherry picks with options
options.cherry_pick_stacked = True
# Reset side_effects
mockGetBranchRef.side_effect = (
['refs/heads/current'] + # detached HEAD check
['refs/heads/%s' % b for b in branches])
mockGetCommonAncestorWithUpstream.side_effect = [
'commit3.5', 'commit0.5'
]
mockFetchUpstreamTuple.side_effect = [('.', 'refs/heads/upstream3'),
('origin', 'refs/heads/main')]
cls, cherry_pick = git_cl._UploadAllPrecheck(options, orig_args)
self.assertTrue(cherry_pick)
self.assertEqual(len(cls), 2)
mockAskForData.assert_not_called()
# Test case: user uses force, no cherry-pick.
options.cherry_pick_stacked = False
options.force = True
# Reset side_effects
mockGetBranchRef.side_effect = (
['refs/heads/current'] + # detached HEAD check
['refs/heads/%s' % b for b in branches])
mockGetCommonAncestorWithUpstream.side_effect = [
'commit3.5', 'commit0.5'
]
mockFetchUpstreamTuple.side_effect = [('.', 'refs/heads/upstream3'),
('origin', 'refs/heads/main')]
cls, cherry_pick = git_cl._UploadAllPrecheck(options, orig_args)
self.assertFalse(cherry_pick)
self.assertEqual(len(cls), 2)
mockAskForData.assert_not_called()
# Test case: user wants to cherry pick after being asked.
mockAskForData.return_value = 'n'
options.cherry_pick_stacked = False
options.force = False
# Reset side_effects
mockGetBranchRef.side_effect = (
['refs/heads/current'] + # detached HEAD check
['refs/heads/%s' % b for b in branches])
mockGetCommonAncestorWithUpstream.side_effect = [
'commit3.5', 'commit0.5'
]
mockFetchUpstreamTuple.side_effect = [('.', 'refs/heads/upstream3'),
('origin', 'refs/heads/main')]
cls, cherry_pick = git_cl._UploadAllPrecheck(options, orig_args)
self.assertTrue(cherry_pick)
self.assertEqual(len(cls), 2)
mockAskForData.assert_called_once_with(
"\noptions ['--preserve-tryjobs', '--chicken'] will be used for all "
"uploads.\n"
"Press enter to update branches current, upstream3.\n"
"Or type `n` to upload only `current` cherry-picked on upstream3's "
"last upload:")
@mock.patch('git_cl.Changelist._GerritCommitMsgHookCheck',
lambda offer_removal: None)
@mock.patch('git_cl.RunGit')
@mock.patch('git_cl.RunGitSilent')
@mock.patch('git_cl.Changelist._GitGetBranchConfigValue')
@mock.patch('git_cl.Changelist.FetchUpstreamTuple')
@mock.patch('git_cl.Changelist.GetCommonAncestorWithUpstream')
@mock.patch('scm.GIT.GetBranchRef')
@mock.patch('git_cl.Changelist.GetRemoteBranch')
@mock.patch('scm.GIT.IsAncestor')
@mock.patch('gclient_utils.AskForData')
def test_upload_all_precheck_one_change(
self, mockAskForData, mockIsAncestor, mockGetRemoteBranch,
mockGetBranchRef, mockGetCommonAncestorWithUpstream,
mockFetchUpstreamTuple, mockGitGetBranchConfigValue,
mockRunGitSilent, mockRunGit, *_mocks):
options = optparse.Values()
options.force = False
options.cherry_pick_stacked = False
orig_args = ['--preserve-tryjobs', '--chicken']
mockGetRemoteBranch.return_value = ('origin',
'refs/remotes/origin/main')
mockGetBranchRef.side_effect = [
'refs/heads/current', # detached HEAD check
'refs/heads/current', # call within while loop
'refs/heads/main',
'refs/heads/main'
]
mockGetCommonAncestorWithUpstream.return_value = 'commit3.5'
mockFetchUpstreamTuple.return_value = ('', 'refs/heads/main')
mockIsAncestor.return_value = True
# end commits
mockRunGit.return_value = 'commit4'
mockRunGitSilent.return_value = '42'
# Get gerrit squash hash. We only check this for branches that have a
# diff. Set to None to trigger `must_upload_upstream`.
mockGitGetBranchConfigValue.return_value = 'does not matter'
# Case 1: We hit the main branch
cls, cherry_pick = git_cl._UploadAllPrecheck(options, orig_args)
self.assertFalse(cherry_pick)
self.assertEqual(len(cls), 1)
mockAskForData.assert_not_called()
# No diff for current change
mockRunGitSilent.return_value = '0'
with self.assertRaises(SystemExitMock):
git_cl._UploadAllPrecheck(options, orig_args)
@mock.patch('scm.GIT.GetBranchRef', return_value=None)
def test_upload_all_precheck_detached_HEAD(self, mockGetBranchRef):
with self.assertRaises(SystemExitMock):
git_cl._UploadAllPrecheck(optparse.Values(), [])
@mock.patch('git_cl.RunGit')
@mock.patch('git_cl.CMDupload')
@mock.patch('sys.stdin', io.StringIO('\n'))
@mock.patch('sys.stdout', io.StringIO())
def test_upload_branch_deps(self, *_mocks):
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
'test3 test2', # test2 -> test3
'test3.1 test2', # test2 -> test3.1
'test4 test3', # test3 -> test4
'test5 test4', # test4 -> test5
'test6 test0', # test0 -> test6
'test7', # test7
]
return '\n'.join(branch_deps)
git_cl.RunGit.side_effect = mock_run_git
git_cl.CMDupload.return_value = 0
class MockChangelist():
def __init__(self):
pass
def GetBranch(self):
return 'test1'
def GetIssue(self):
return '123'
def GetPatchset(self):
return '1001'
def IsGerrit(self):
return False
ret = git_cl.upload_branch_deps(MockChangelist(), [])
# CMDupload should have been called 5 times because of 5 dependent
# branches.
self.assertEqual(5, len(git_cl.CMDupload.mock_calls))
self.assertEqual(0, ret)
def test_gerrit_change_id(self):
self.calls = [
((['git', 'write-tree'], ), 'hashtree'),
((['git', 'rev-parse', 'HEAD~0'], ), 'branch-parent'),
((['git', 'var',
'GIT_AUTHOR_IDENT'], ), 'A B <a@b.org> 1456848326 +0100'),
((['git', 'var',
'GIT_COMMITTER_IDENT'], ), 'C D <c@d.org> 1456858326 +0100'),
((['git', 'hash-object', '-t', 'commit',
'--stdin'], ), 'hashchange'),
]
change_id = git_cl.GenerateGerritChangeId('line1\nline2\n')
self.assertEqual(change_id, 'Ihashchange')
@mock.patch('gerrit_util.IsCodeOwnersEnabledOnHost')
@mock.patch('git_cl.Settings.GetBugPrefix')
@mock.patch('git_cl.Changelist.FetchDescription')
@mock.patch('git_cl.Changelist.GetBranch')
@mock.patch('git_cl.Changelist.GetCommonAncestorWithUpstream')
@mock.patch('git_cl.Changelist.GetGerritHost')
@mock.patch('git_cl.Changelist.GetGerritProject')
@mock.patch('git_cl.Changelist.GetRemoteBranch')
@mock.patch('owners_client.OwnersClient.BatchListOwners')
def getDescriptionForUploadTest(self,
mockBatchListOwners=None,
mockGetRemoteBranch=None,
mockGetGerritProject=None,
mockGetGerritHost=None,
mockGetCommonAncestorWithUpstream=None,
mockGetBranch=None,
mockFetchDescription=None,
mockGetBugPrefix=None,
mockIsCodeOwnersEnabledOnHost=None,
initial_description='desc',
commit_description=None,
bug=None,
fixed=None,
branch='branch',
reviewers=None,
add_owners_to=None,
expected_description='desc'):
reviewers = reviewers or []
owners_by_path = {
'a': ['a@example.com'],
'b': ['b@example.com'],
'c': ['c@example.com'],
}
mockIsCodeOwnersEnabledOnHost.return_value = True
mockGetBranch.return_value = branch
mockGetBugPrefix.return_value = 'prefix'
mockGetCommonAncestorWithUpstream.return_value = 'upstream'
mockGetRemoteBranch.return_value = ('origin',
'refs/remotes/origin/main')
mockFetchDescription.return_value = 'desc'
mockBatchListOwners.side_effect = lambda ps: {
p: owners_by_path.get(p)
for p in ps
}
cl = git_cl.Changelist(issue=1234)
actual = cl._GetDescriptionForUpload(options=mock.Mock(
bug=bug,
fixed=fixed,
reviewers=reviewers,
add_owners_to=add_owners_to,
message=initial_description,
commit_description=commit_description),
git_diff_args=None,
files=list(owners_by_path))
self.assertEqual(expected_description, actual.description)
def testGetDescriptionForUpload(self):
self.getDescriptionForUploadTest()
def testGetDescriptionForUpload_Bug(self):
self.getDescriptionForUploadTest(bug='1234',
expected_description='\n'.join([
'desc',
'',
'Bug: prefix:1234',
]))
def testGetDescriptionForUpload_Fixed(self):
self.getDescriptionForUploadTest(fixed='1234',
expected_description='\n'.join([
'desc',
'',
'Fixed: prefix:1234',
]))
@mock.patch('git_cl.Changelist.GetIssue')
def testGetDescriptionForUpload_BugFromBranch(self, mockGetIssue):
mockGetIssue.return_value = None
self.getDescriptionForUploadTest(branch='bug-1234',
expected_description='\n'.join([
'desc',
'',
'Bug: prefix:1234',
]))
@mock.patch('git_cl.Changelist.GetIssue')
def testGetDescriptionForUpload_FixedFromBranch(self, mockGetIssue):
mockGetIssue.return_value = None
self.getDescriptionForUploadTest(branch='fix-1234',
expected_description='\n'.join([
'desc',
'',
'Fixed: prefix:1234',
]))
def testGetDescriptionForUpload_SkipBugFromBranchIfAlreadyUploaded(self):
self.getDescriptionForUploadTest(
branch='bug-1234',
expected_description='desc',
)
def testGetDescriptionForUpload_AddOwnersToR(self):
self.getDescriptionForUploadTest(
reviewers=['a@example.com'],
add_owners_to='R',
expected_description='\n'.join([
'desc',
'',
'R=a@example.com, b@example.com, c@example.com',
]))
def testGetDescriptionForUpload_AddOwnersToNoOwnersNeeded(self):
self.getDescriptionForUploadTest(
reviewers=['a@example.com', 'c@example.com'],
expected_description='\n'.join([
'desc',
'',
'R=a@example.com, c@example.com',
]))
def testGetDescriptionForUpload_Reviewers(self):
self.getDescriptionForUploadTest(
reviewers=['a@example.com', 'b@example.com'],
expected_description='\n'.join([
'desc',
'',
'R=a@example.com, b@example.com',
]))
def testGetDescriptionForUpload_NewDesc(self):
self.getDescriptionForUploadTest(
commit_description='this is a new desc',
expected_description='this is a new desc')
@mock.patch('sys.stdin', io.StringIO('this is a new desc'))
def testGetDescriptionForUpload_NewDescFromStdin(self):
self.getDescriptionForUploadTest(
commit_description='-', expected_description='this is a new desc')
def test_description_append_footer(self):
for init_desc, footer_line, expected_desc in [
# Use unique desc first lines for easy test failure
# identification.
('foo', 'R=one', 'foo\n\nR=one'),
('foo\n\nR=one', 'BUG=', 'foo\n\nR=one\nBUG='),
('foo\n\nR=one', 'Change-Id: Ixx',
'foo\n\nR=one\n\nChange-Id: Ixx'),
('foo\n\nChange-Id: Ixx', 'R=one',
'foo\n\nR=one\n\nChange-Id: Ixx'),
('foo\n\nR=one\n\nChange-Id: Ixx', 'Foo-Bar: baz',
'foo\n\nR=one\n\nChange-Id: Ixx\nFoo-Bar: baz'),
('foo\n\nChange-Id: Ixx', 'Foo-Bak: baz',
'foo\n\nChange-Id: Ixx\nFoo-Bak: baz'),
('foo', 'Change-Id: Ixx', 'foo\n\nChange-Id: Ixx'),
]:
desc = git_cl.ChangeDescription(init_desc)
desc.append_footer(footer_line)
self.assertEqual(desc.description, expected_desc)
def test_update_reviewers(self):
data = [
('foo', [], 'foo'),
('foo\nR=xx', [], 'foo\nR=xx'),
('foo', ['a@c'], 'foo\n\nR=a@c'),
('foo\nR=xx', ['a@c'], 'foo\n\nR=a@c, xx'),
('foo\nBUG=', ['a@c'], 'foo\nBUG=\nR=a@c'),
('foo\nR=xx\nR=bar', ['a@c'], 'foo\n\nR=a@c, bar, xx'),
('foo', ['a@c', 'b@c'], 'foo\n\nR=a@c, b@c'),
('foo\nBar\n\nR=\nBUG=', ['c@c'], 'foo\nBar\n\nR=c@c\nBUG='),
('foo\nBar\n\nR=\nBUG=\nR=', ['c@c'], 'foo\nBar\n\nR=c@c\nBUG='),
# Same as the line before, but full of whitespaces.
(
'foo\nBar\n\n R = \n BUG = \n R = ',
['c@c'],
'foo\nBar\n\nR=c@c\n BUG =',
),
# Whitespaces aren't interpreted as new lines.
('foo BUG=allo R=joe ', ['c@c'], 'foo BUG=allo R=joe\n\nR=c@c'),
]
expected = [i[-1] for i in data]
actual = []
for orig, reviewers, _expected in data:
obj = git_cl.ChangeDescription(orig)
obj.update_reviewers(reviewers)
actual.append(obj.description)
self.assertEqual(expected, actual)
def test_get_hash_tags(self):
cases = [
('', []),
('a', []),
('[a]', ['a']),
('[aa]', ['aa']),
('[a ]', ['a']),
('[a- ]', ['a']),
('[a- b]', ['a-b']),
('[a--b]', ['a-b']),
('[a', []),
('[a]x', ['a']),
('[aa]x', ['aa']),
('[a b]', ['a-b']),
('[a b]', ['a-b']),
('[a__b]', ['a-b']),
('[a] x', ['a']),
('[a][b]', ['a', 'b']),
('[a] [b]', ['a', 'b']),
('[a][b]x', ['a', 'b']),
('[a][b] x', ['a', 'b']),
('[a]\n[b]', ['a']),
('[a\nb]', []),
('[a][', ['a']),
('Revert "[a] feature"', ['a']),
('Reland "[a] feature"', ['a']),
('Revert: [a] feature', ['a']),
('Reland: [a] feature', ['a']),
('Revert "Reland: [a] feature"', ['a']),
('Foo: feature', ['foo']),
('Foo Bar: feature', ['foo-bar']),
('Change Foo::Bar', []),
('Foo: Change Foo::Bar', ['foo']),
('Revert "Foo bar: feature"', ['foo-bar']),
('Reland "Foo bar: feature"', ['foo-bar']),
]
for desc, expected in cases:
change_desc = git_cl.ChangeDescription(desc)
actual = change_desc.get_hash_tags()
self.assertEqual(
actual, expected,
'GetHashTags(%r) == %r, expected %r' % (desc, actual, expected))
self.assertEqual(None, git_cl.GetTargetRef('origin', None, 'main'))
self.assertEqual(
None, git_cl.GetTargetRef(None, 'refs/remotes/origin/main', 'main'))
# Check default target refs for branches.
self.assertEqual(
'refs/heads/main',
git_cl.GetTargetRef('origin', 'refs/remotes/origin/main', None))
self.assertEqual(
'refs/heads/main',
git_cl.GetTargetRef('origin', 'refs/remotes/origin/lkgr', None))
self.assertEqual(
'refs/heads/main',
git_cl.GetTargetRef('origin', 'refs/remotes/origin/lkcr', None))
self.assertEqual(
'refs/branch-heads/123',
git_cl.GetTargetRef('origin', 'refs/remotes/branch-heads/123',
None))
self.assertEqual(
'refs/diff/test',
git_cl.GetTargetRef('origin', 'refs/remotes/origin/refs/diff/test',
None))
self.assertEqual(
'refs/heads/chrome/m42',
git_cl.GetTargetRef('origin', 'refs/remotes/origin/chrome/m42',
None))
# Check target refs for user-specified target branch.
for branch in ('branch-heads/123', 'remotes/branch-heads/123',
'refs/remotes/branch-heads/123'):
self.assertEqual(
'refs/branch-heads/123',
git_cl.GetTargetRef('origin', 'refs/remotes/origin/main',
branch))
for branch in ('origin/main', 'remotes/origin/main',
'refs/remotes/origin/main'):
self.assertEqual(
'refs/heads/main',
git_cl.GetTargetRef('origin', 'refs/remotes/branch-heads/123',
branch))
for branch in ('main', 'heads/main', 'refs/heads/main'):
self.assertEqual(
'refs/heads/main',
git_cl.GetTargetRef('origin', 'refs/remotes/branch-heads/123',
branch))
@mock.patch('git_common.is_dirty_git_tree', return_value=True)
def test_patch_when_dirty(self, *_mocks):
# Patch when local tree is dirty.
self.assertNotEqual(git_cl.main(['patch', '123456']), 0)
def assertIssueAndPatchset(self,
branch='main',
issue='123456',
patchset='7',
git_short_host='chromium'):
self.assertEqual(issue,
scm.GIT.GetBranchConfig('', branch, 'gerritissue'))
self.assertEqual(patchset,
scm.GIT.GetBranchConfig('', branch, 'gerritpatchset'))
self.assertEqual('https://%s-review.googlesource.com' % git_short_host,
scm.GIT.GetBranchConfig('', branch, 'gerritserver'))
def _patch_common(self, git_short_host='chromium'):
mock.patch('scm.GIT.ResolveCommit', return_value='deadbeef').start()
scm.GIT.SetConfig('', 'remote.origin.url',
f'https://{git_short_host}.googlesource.com/my/repo')
gerrit_util.GetChangeDetail.return_value = {
'current_revision': '7777777777',
'revisions': {
'1111111111': {
'_number': 1,
'fetch': {
'http': {
'url': 'https://%s.googlesource.com/my/repo' %
git_short_host,
'ref': 'refs/changes/56/123456/1',
}
},
},
'7777777777': {
'_number': 7,
'fetch': {
'http': {
'url': 'https://%s.googlesource.com/my/repo' %
git_short_host,
'ref': 'refs/changes/56/123456/7',
}
},
},
},
}
@unittest.skipIf(gclient_utils.IsEnvCog(),
'not supported in non-git environment')
def test_patch_gerrit_default(self):
self._patch_common()
self.calls += [
(([
'git', 'fetch', 'https://chromium.googlesource.com/my/repo',
'refs/changes/56/123456/7'
], ), ''),
((['git', 'cherry-pick', 'FETCH_HEAD'], ), ''),
]
self.assertEqual(git_cl.main(['patch', '123456']), 0)
self.assertIssueAndPatchset()
@unittest.skipIf(gclient_utils.IsEnvCog(),
'not supported in non-git environment')
def test_patch_gerrit_new_branch(self):
self._patch_common()
self.calls += [
(([
'git', 'fetch', 'https://chromium.googlesource.com/my/repo',
'refs/changes/56/123456/7'
], ), ''),
((['git', 'cherry-pick', 'FETCH_HEAD'], ), ''),
]
self.assertEqual(git_cl.main(['patch', '-b', 'feature', '123456']), 0)
self.assertIssueAndPatchset(branch='feature')
@unittest.skipIf(gclient_utils.IsEnvCog(),
'not supported in non-git environment')
def test_patch_gerrit_force(self):
self._patch_common('host')
self.calls += [
(([
'git', 'fetch', 'https://host.googlesource.com/my/repo',
'refs/changes/56/123456/7'
], ), ''),
((['git', 'reset', '--hard', 'FETCH_HEAD'], ), ''),
]
self.assertEqual(git_cl.main(['patch', '123456', '--force']), 0)
self.assertIssueAndPatchset(git_short_host='host')
@unittest.skipIf(gclient_utils.IsEnvCog(),
'not supported in non-git environment')
def test_patch_gerrit_guess_by_url(self):
self._patch_common('else')
self.calls += [
(([
'git', 'fetch', 'https://else.googlesource.com/my/repo',
'refs/changes/56/123456/1'
], ), ''),
((['git', 'cherry-pick', 'FETCH_HEAD'], ), ''),
]
self.assertEqual(
git_cl.main(
['patch', 'https://else-review.googlesource.com/#/c/123456/1']),
0)
self.assertIssueAndPatchset(patchset='1', git_short_host='else')
@unittest.skipIf(gclient_utils.IsEnvCog(),
'not supported in non-git environment')
def test_patch_gerrit_guess_by_url_with_repo(self):
self._patch_common('else')
self.calls += [
(([
'git', 'fetch', 'https://else.googlesource.com/my/repo',
'refs/changes/56/123456/1'
], ), ''),
((['git', 'cherry-pick', 'FETCH_HEAD'], ), ''),
]
self.assertEqual(
git_cl.main([
'patch',
'https://else-review.googlesource.com/c/my/repo/+/123456/1'
]), 0)
self.assertIssueAndPatchset(patchset='1', git_short_host='else')
@unittest.skipIf(gclient_utils.IsEnvCog(),
'not supported in non-git environment')
@mock.patch('sys.stderr', io.StringIO())
def test_patch_gerrit_conflict(self):
self._patch_common()
self.calls += [
(([
'git', 'fetch', 'https://chromium.googlesource.com/my/repo',
'refs/changes/56/123456/7'
], ), ''),
((['git', 'cherry-pick', 'FETCH_HEAD'], ), CERR1),
]
with self.assertRaises(SystemExitMock):
git_cl.main(['patch', '123456'])
self.assertEqual('Command "git cherry-pick FETCH_HEAD" failed.\n\n',
sys.stderr.getvalue())
@unittest.skipIf(gclient_utils.IsEnvCog(),
'not supported in non-git environment')
@mock.patch('gerrit_util.GetChangeDetail',
side_effect=gerrit_util.GerritError(404, ''))
@mock.patch('sys.stderr', io.StringIO())
def test_patch_gerrit_not_exists(self, *_mocks):
scm.GIT.SetConfig('', 'remote.origin.url',
'https://chromium.googlesource.com/my/repo')
with self.assertRaises(SystemExitMock):
self.assertEqual(1, git_cl.main(['patch', '123456']))
self.assertEqual(
'change 123456 at https://chromium-review.googlesource.com does not '
'exist or you have no access to it\n', sys.stderr.getvalue())
def _checkout_config(self):
scm.GIT.SetConfig('', 'branch.ger-branch.gerritissue', '123456')
scm.GIT.SetConfig('', 'branch.gbranch654.gerritissue', '654321')
@unittest.skipIf(gclient_utils.IsEnvCog(),
'not supported in non-git environment')
def test_checkout_gerrit(self):
"""Tests git cl checkout <issue>."""
self._checkout_config()
self.calls += [((['git', 'checkout', 'ger-branch'], ), '')]
self.assertEqual(0, git_cl.main(['checkout', '123456']))
def test_checkout_not_found(self):
"""Tests git cl checkout <issue>."""
self._checkout_config()
self.assertEqual(1, git_cl.main(['checkout', '99999']))
def test_checkout_no_branch_issues(self):
"""Tests git cl checkout <issue>."""
self.assertEqual(1, git_cl.main(['checkout', '99999']))
def _test_gerrit_ensure_authenticated_common(self, auth):
mock.patch(
'gclient_utils.AskForData',
lambda prompt: self._mocked_call('ask_for_data', prompt)).start()
mock.patch(
'git_cl.gerrit_util.CookiesAuthenticator',
CookiesAuthenticatorMockFactory(hosts_with_creds=auth)).start()
mock.patch('git_auth.AutoConfigure', return_value=None).start()
scm.GIT.SetConfig('', 'remote.origin.url',
'https://chromium.googlesource.com/my/repo')
cl = git_cl.Changelist()
cl.branch = 'main'
cl.branchref = 'refs/heads/main'
return cl
def test_gerrit_ensure_authenticated_ok(self):
cl = self._test_gerrit_ensure_authenticated_common(
auth={
'chromium.googlesource.com': ('git-same.example.com', 'secret'),
'chromium-review.googlesource.com': ('git-same.example.com',
'secret'),
})
self.assertIsNone(cl.EnsureAuthenticated(force=False))
def test_gerrit_ensure_authenticated_skipped(self):
scm.GIT.SetConfig('', 'gerrit.skip-ensure-authenticated', 'true')
cl = self._test_gerrit_ensure_authenticated_common(auth={})
self.assertIsNone(cl.EnsureAuthenticated(force=False))
def test_gerrit_ensure_authenticated_sso(self):
scm.GIT.SetConfig('', 'remote.origin.url', 'sso://repo')
mock.patch(
'git_cl.gerrit_util.CookiesAuthenticator',
CookiesAuthenticatorMockFactory(hosts_with_creds={})).start()
cl = git_cl.Changelist()
cl.branch = 'main'
cl.branchref = 'refs/heads/main'
cl.lookedup_issue = True
self.assertIsNone(cl.EnsureAuthenticated(force=False))
def test_gerrit_ensure_authenticated_bearer_token(self):
cl = self._test_gerrit_ensure_authenticated_common(
auth={
'chromium.googlesource.com': ('', 'secret'),
'chromium-review.googlesource.com': ('', 'secret'),
})
self.assertIsNone(cl.EnsureAuthenticated(force=False))
conn = gerrit_util.HttpConn(
req_uri='???',
req_method='GET',
req_host='chromium.googlesource.com',
req_headers={},
req_body=None,
)
gerrit_util.CookiesAuthenticator().authenticate(conn)
self.assertTrue('Bearer' in conn.req_headers['Authorization'])
def test_gerrit_ensure_authenticated_non_https_sso(self):
scm.GIT.SetConfig('', 'remote.origin.url', 'custom-scheme://repo')
self.calls = [
(('logging.warning',
'Ignoring branch %(branch)s with non-https remote '
'%(remote)s', {
'branch': 'main',
'remote': 'custom-scheme://repo'
}), None),
]
mock.patch(
'git_cl.gerrit_util.CookiesAuthenticator',
CookiesAuthenticatorMockFactory(hosts_with_creds={})).start()
mock.patch('logging.warning',
lambda *a: self._mocked_call('logging.warning', *a)).start()
cl = git_cl.Changelist()
cl.branch = 'main'
cl.branchref = 'refs/heads/main'
cl.lookedup_issue = True
self.assertIsNone(cl.EnsureAuthenticated(force=False))
def test_gerrit_ensure_authenticated_non_url(self):
scm.GIT.SetConfig('', 'remote.origin.url',
'git@somehost.example:foo/bar.git')
self.calls = [
(('logging.error',
'Remote "%(remote)s" for branch "%(branch)s" points to "%(url)s", '
'but it doesn\'t exist.', {
'remote': 'origin',
'branch': 'main',
'url': 'git@somehost.example:foo/bar.git'
}), None),
]
mock.patch(
'git_cl.gerrit_util.CookiesAuthenticator',
CookiesAuthenticatorMockFactory(hosts_with_creds={})).start()
mock.patch('logging.error',
lambda *a: self._mocked_call('logging.error', *a)).start()
cl = git_cl.Changelist()
cl.branch = 'main'
cl.branchref = 'refs/heads/main'
cl.lookedup_issue = True
self.assertIsNone(cl.EnsureAuthenticated(force=False))
def _cmd_set_commit_gerrit_common(self, vote, notify=None):
scm.GIT.SetConfig('', 'branch.main.gerritissue', '123')
scm.GIT.SetConfig('', 'branch.main.gerritserver',
'https://chromium-review.googlesource.com')
scm.GIT.SetConfig('', 'remote.origin.url',
'https://chromium.googlesource.com/infra/infra')
self.calls = [
(('SetReview', 'chromium-review.googlesource.com',
'infra%2Finfra~123', None, {
'Commit-Queue': vote
}, notify, None), ''),
]
@unittest.skipIf(gclient_utils.IsEnvCog(),
'not supported in non-git environment')
def test_cmd_set_commit_gerrit_clear(self):
self._cmd_set_commit_gerrit_common(0)
self.assertEqual(0, git_cl.main(['set-commit', '-c']))
@unittest.skipIf(gclient_utils.IsEnvCog(),
'not supported in non-git environment')
def test_cmd_set_commit_gerrit_dry(self):
self._cmd_set_commit_gerrit_common(1, notify=False)
self.assertEqual(0, git_cl.main(['set-commit', '-d']))
@unittest.skipIf(gclient_utils.IsEnvCog(),
'not supported in non-git environment')
def test_cmd_set_commit_gerrit(self):
self._cmd_set_commit_gerrit_common(2)
self.assertEqual(0, git_cl.main(['set-commit']))
@unittest.skipIf(gclient_utils.IsEnvCog(),
'not supported in non-git environment')
def test_description_display(self):
mock.patch('git_cl.Changelist', ChangelistMock).start()
ChangelistMock.desc = 'foo\n'
self.assertEqual(0, git_cl.main(['description', '-d']))
self.assertEqual('foo\n', sys.stdout.getvalue())
@unittest.skipIf(gclient_utils.IsEnvCog(),
'not supported in non-git environment')
@mock.patch('sys.stderr', io.StringIO())
def test_StatusFieldOverrideIssueMissingArgs(self):
try:
self.assertEqual(git_cl.main(['status', '--issue', '1']), 0)
except SystemExitMock:
self.assertIn('--field must be given when --issue is set.',
sys.stderr.getvalue())
@unittest.skipIf(gclient_utils.IsEnvCog(),
'not supported in non-git environment')
def test_StatusFieldOverrideIssue(self):
def assertIssue(cl_self, *_args):
self.assertEqual(cl_self.issue, 1)
return 'foobar'
mock.patch('git_cl.Changelist.FetchDescription', assertIssue).start()
self.assertEqual(
git_cl.main(['status', '--issue', '1', '--field', 'desc']), 0)
self.assertEqual(sys.stdout.getvalue(), 'foobar\n')
@unittest.skipIf(gclient_utils.IsEnvCog(),
'not supported in non-git environment')
def test_SetCloseOverrideIssue(self):
def assertIssue(cl_self, *_args):
self.assertEqual(cl_self.issue, 1)
return 'foobar'
mock.patch('git_cl.Changelist.FetchDescription', assertIssue).start()
mock.patch('git_cl.Changelist.CloseIssue', lambda *_: None).start()
self.assertEqual(git_cl.main(['set-close', '--issue', '1']), 0)
@unittest.skipIf(gclient_utils.IsEnvCog(),
'not supported in non-git environment')
def test_description(self):
scm.GIT.SetConfig('', 'remote.origin.url',
'https://chromium.googlesource.com/my/repo')
gerrit_util.GetChangeDetail.return_value = {
'current_revision': 'sha1',
'revisions': {
'sha1': {
'commit': {
'message': 'foobar'
},
}
},
}
self.assertEqual(
0,
git_cl.main([
'description',
'https://chromium-review.googlesource.com/c/my/repo/+/123123',
'-d'
]))
self.assertEqual('foobar\n', sys.stdout.getvalue())
@unittest.skipIf(gclient_utils.IsEnvCog(),
'not supported in non-git environment')
def test_description_set_raw(self):
mock.patch('git_cl.Changelist', ChangelistMock).start()
mock.patch('git_cl.sys.stdin', io.StringIO('hihi')).start()
self.assertEqual(0, git_cl.main(['description', '-n', 'hihi']))
self.assertEqual('hihi', ChangelistMock.desc)
@unittest.skipIf(gclient_utils.IsEnvCog(),
'not supported in non-git environment')
def test_description_appends_bug_line(self):
current_desc = 'Some.\n\nChange-Id: xxx'
def RunEditor(desc, _, **kwargs):
self.assertEqual(
'# Enter a description of the change.\n'
'# This will be displayed on the codereview site.\n'
'# The first line will also be used as the subject of the review.\n'
'#--------------------This line is 72 characters long'
'--------------------\n'
'Some.\n\nChange-Id: xxx\nBug: ', desc)
# Simulate user changing something.
return 'Some.\n\nChange-Id: xxx\nBug: 123'
def UpdateDescription(_, desc, force=False):
self.assertEqual(desc, 'Some.\n\nChange-Id: xxx\nBug: 123')
mock.patch('git_cl.Changelist.FetchDescription',
lambda *args: current_desc).start()
mock.patch('git_cl.Changelist.UpdateDescription',
UpdateDescription).start()
mock.patch('git_cl.gclient_utils.RunEditor', RunEditor).start()
scm.GIT.SetConfig('', 'branch.main.gerritissue', '123')
self.assertEqual(0, git_cl.main(['description']))
@unittest.skipIf(gclient_utils.IsEnvCog(),
'not supported in non-git environment')
def test_description_does_not_append_bug_line_if_fixed_is_present(self):
current_desc = 'Some.\n\nFixed: 123\nChange-Id: xxx'
def RunEditor(desc, _, **kwargs):
self.assertEqual(
'# Enter a description of the change.\n'
'# This will be displayed on the codereview site.\n'
'# The first line will also be used as the subject of the review.\n'
'#--------------------This line is 72 characters long'
'--------------------\n'
'Some.\n\nFixed: 123\nChange-Id: xxx', desc)
return desc
mock.patch('git_cl.Changelist.FetchDescription',
lambda *args: current_desc).start()
mock.patch('git_cl.gclient_utils.RunEditor', RunEditor).start()
scm.GIT.SetConfig('', 'branch.main.gerritissue', '123')
self.assertEqual(0, git_cl.main(['description']))
@unittest.skipIf(gclient_utils.IsEnvCog(),
'not supported in non-git environment')
def test_description_set_stdin(self):
mock.patch('git_cl.Changelist', ChangelistMock).start()
mock.patch('git_cl.sys.stdin',
io.StringIO('hi \r\n\t there\n\nman')).start()
self.assertEqual(0, git_cl.main(['description', '-n', '-']))
self.assertEqual('hi\n\t there\n\nman', ChangelistMock.desc)
@unittest.skipIf(gclient_utils.IsEnvCog(),
'not supported in non-git environment')
def test_archive(self):
self.calls = [
((['git', 'for-each-ref', '--format=%(refname)', 'refs/heads'], ),
'refs/heads/main\nrefs/heads/foo\nrefs/heads/bar'),
((['git', 'for-each-ref', '--format=%(refname)',
'refs/tags'], ), ''),
((['git', 'tag', 'git-cl-archived-456-foo', 'foo'], ), ''),
((['git', 'branch', '-D', 'foo'], ), '')
]
mock.patch(
'git_cl.get_cl_statuses',
lambda branches, fine_grained, max_processes: [
(MockChangelistWithBranchAndIssue('main', 1), 'open'),
(MockChangelistWithBranchAndIssue('foo', 456), 'closed'),
(MockChangelistWithBranchAndIssue('bar', 789), 'open')
]).start()
self.assertEqual(0, git_cl.main(['archive', '-f']))
@unittest.skipIf(gclient_utils.IsEnvCog(),
'not supported in non-git environment')
def test_archive_tag_collision(self):
self.calls = [
((['git', 'for-each-ref', '--format=%(refname)', 'refs/heads'], ),
'refs/heads/main\nrefs/heads/foo\nrefs/heads/bar'),
((['git', 'for-each-ref', '--format=%(refname)',
'refs/tags'], ), 'refs/tags/git-cl-archived-456-foo'),
((['git', 'tag', 'git-cl-archived-456-foo-2', 'foo'], ), ''),
((['git', 'branch', '-D', 'foo'], ), '')
]
mock.patch(
'git_cl.get_cl_statuses',
lambda branches, fine_grained, max_processes: [
(MockChangelistWithBranchAndIssue('main', 1), 'open'),
(MockChangelistWithBranchAndIssue('foo', 456), 'closed'),
(MockChangelistWithBranchAndIssue('bar', 789), 'open')
]).start()
self.assertEqual(0, git_cl.main(['archive', '-f']))
@unittest.skipIf(gclient_utils.IsEnvCog(),
'not supported in non-git environment')
def test_archive_current_branch_fails(self):
self.calls = [
((['git', 'for-each-ref', '--format=%(refname)',
'refs/heads'], ), 'refs/heads/main'),
((['git', 'for-each-ref', '--format=%(refname)',
'refs/tags'], ), ''),
]
mock.patch(
'git_cl.get_cl_statuses',
lambda branches, fine_grained, max_processes: [
(MockChangelistWithBranchAndIssue('main', 1), 'closed')
]).start()
self.assertEqual(1, git_cl.main(['archive', '-f']))
@unittest.skipIf(gclient_utils.IsEnvCog(),
'not supported in non-git environment')
def test_archive_dry_run(self):
self.calls = [
((['git', 'for-each-ref', '--format=%(refname)', 'refs/heads'], ),
'refs/heads/main\nrefs/heads/foo\nrefs/heads/bar'),
((['git', 'for-each-ref', '--format=%(refname)',
'refs/tags'], ), ''),
]
mock.patch(
'git_cl.get_cl_statuses',
lambda branches, fine_grained, max_processes: [
(MockChangelistWithBranchAndIssue('main', 1), 'open'),
(MockChangelistWithBranchAndIssue('foo', 456), 'closed'),
(MockChangelistWithBranchAndIssue('bar', 789), 'open')
]).start()
self.assertEqual(0, git_cl.main(['archive', '-f', '--dry-run']))
@unittest.skipIf(gclient_utils.IsEnvCog(),
'not supported in non-git environment')
def test_archive_no_tags(self):
self.calls = [
((['git', 'for-each-ref', '--format=%(refname)', 'refs/heads'], ),
'refs/heads/main\nrefs/heads/foo\nrefs/heads/bar'),
((['git', 'for-each-ref', '--format=%(refname)',
'refs/tags'], ), ''), ((['git', 'branch', '-D', 'foo'], ), '')
]
mock.patch(
'git_cl.get_cl_statuses',
lambda branches, fine_grained, max_processes: [
(MockChangelistWithBranchAndIssue('main', 1), 'open'),
(MockChangelistWithBranchAndIssue('foo', 456), 'closed'),
(MockChangelistWithBranchAndIssue('bar', 789), 'open')
]).start()
self.assertEqual(0, git_cl.main(['archive', '-f', '--notags']))
@unittest.skipIf(gclient_utils.IsEnvCog(),
'not supported in non-git environment')
def test_archive_tag_cleanup_on_branch_deletion_error(self):
self.calls = [
((['git', 'for-each-ref', '--format=%(refname)', 'refs/heads'], ),
'refs/heads/main\nrefs/heads/foo\nrefs/heads/bar'),
((['git', 'for-each-ref', '--format=%(refname)',
'refs/tags'], ), ''),
((['git', 'tag', 'git-cl-archived-456-foo',
'foo'], ), 'refs/tags/git-cl-archived-456-foo'),
((['git', 'branch', '-D', 'foo'], ), CERR1),
((['git', 'tag', '-d', 'git-cl-archived-456-foo'], ),
'refs/tags/git-cl-archived-456-foo'),
]
mock.patch(
'git_cl.get_cl_statuses',
lambda branches, fine_grained, max_processes: [
(MockChangelistWithBranchAndIssue('main', 1), 'open'),
(MockChangelistWithBranchAndIssue('foo', 456), 'closed'),
(MockChangelistWithBranchAndIssue('bar', 789), 'open')
]).start()
self.assertEqual(0, git_cl.main(['archive', '-f']))
@unittest.skipIf(gclient_utils.IsEnvCog(),
'not supported in non-git environment')
def test_archive_with_format(self):
self.calls = [
((['git', 'for-each-ref', '--format=%(refname)', 'refs/heads'], ),
'refs/heads/main\nrefs/heads/foo\nrefs/heads/bar'),
((['git', 'for-each-ref', '--format=%(refname)',
'refs/tags'], ), ''),
((['git', 'tag', 'archived/12-foo', 'foo'], ), ''),
((['git', 'branch', '-D', 'foo'], ), ''),
]
mock.patch(
'git_cl.get_cl_statuses',
lambda branches, fine_grained, max_processes: [
(MockChangelistWithBranchAndIssue('foo', 12), 'closed')
]).start()
self.assertEqual(
0, git_cl.main(['archive', '-f', '-p',
'archived/{issue}-{branch}']))
@unittest.skipIf(gclient_utils.IsEnvCog(),
'not supported in non-git environment')
def test_squash_closed(self):
self.calls = [
((['git', 'for-each-ref', '--format=%(refname)', 'refs/heads'], ),
'refs/heads/main\nrefs/heads/foo\nrefs/heads/bar'),
((['git', 'checkout', 'foo'], ), ''),
((['git', 'checkout', 'main'], ), ''),
]
mock.patch(
'git_cl.get_cl_statuses',
lambda branches, fine_grained, max_processes: [
(MockChangelistWithBranchAndIssue('main', 1), 'open'),
(MockChangelistWithBranchAndIssue('foo', 456), 'closed'),
(MockChangelistWithBranchAndIssue('bar', 789), 'open')
]).start()
mock.patch('git_common.current_branch', return_value='main').start()
mock.patch('git_squash_branch.main', return_value=0).start()
self.assertEqual(0, git_cl.main(['squash-closed', '-f']))
@unittest.skipIf(gclient_utils.IsEnvCog(),
'not supported in non-git environment')
def test_squash_closed_dry_run(self):
self.calls = [
((['git', 'for-each-ref', '--format=%(refname)', 'refs/heads'], ),
'refs/heads/main\nrefs/heads/foo\nrefs/heads/bar'),
]
mock.patch(
'git_cl.get_cl_statuses',
lambda branches, fine_grained, max_processes: [
(MockChangelistWithBranchAndIssue('main', 1), 'open'),
(MockChangelistWithBranchAndIssue('foo', 456), 'closed'),
(MockChangelistWithBranchAndIssue('bar', 789), 'open')
]).start()
self.assertEqual(0, git_cl.main(['squash-closed', '-d']))
@unittest.skipIf(gclient_utils.IsEnvCog(),
'not supported in non-git environment')
def test_squash_closed_current_branch_fails(self):
self.calls = [
((['git', 'for-each-ref', '--format=%(refname)', 'refs/heads'], ),
'refs/heads/main\nrefs/heads/foo\nrefs/heads/bar'),
]
mock.patch(
'git_cl.get_cl_statuses',
lambda branches, fine_grained, max_processes: [
(MockChangelistWithBranchAndIssue('main', 1), 'closed'),
]).start()
self.assertEqual(1, git_cl.main(['squash-closed', '-f']))
@unittest.skipIf(gclient_utils.IsEnvCog(),
'not supported in non-git environment')
def test_squash_closed_reset_on_failure(self):
self.calls = [
((['git', 'for-each-ref', '--format=%(refname)', 'refs/heads'], ),
'refs/heads/main\nrefs/heads/foo\nrefs/heads/bar'),
((['git', 'checkout', 'foo'], ), ''),
((['git', 'checkout', 'main'], ), ''),
]
mock.patch(
'git_cl.get_cl_statuses',
lambda branches, fine_grained, max_processes: [
(MockChangelistWithBranchAndIssue('main', 1), 'open'),
(MockChangelistWithBranchAndIssue('foo', 456), 'closed'),
(MockChangelistWithBranchAndIssue('bar', 789), 'open')
]).start()
mock.patch('git_common.current_branch', return_value='main').start()
mock.patch('git_squash_branch.main', return_value=1).start()
self.assertEqual(1, git_cl.main(['squash-closed', '-f']))
@unittest.skipIf(gclient_utils.IsEnvCog(),
'not supported in non-git environment')
def test_squash_closed_clean_exit_no_closed_branches(self):
self.calls = [
((['git', 'for-each-ref', '--format=%(refname)', 'refs/heads'], ),
'refs/heads/main\nrefs/heads/foo\nrefs/heads/bar'),
]
mock.patch(
'git_cl.get_cl_statuses',
lambda branches, fine_grained, max_processes: [
(MockChangelistWithBranchAndIssue('main', 1), 'open'),
(MockChangelistWithBranchAndIssue('foo', 456), 'open'),
(MockChangelistWithBranchAndIssue('bar', 789), 'open')
]).start()
mock.patch('git_common.current_branch', return_value='main').start()
mock.patch('git_squash_branch.main', return_value=0).start()
self.assertEqual(0, git_cl.main(['squash-closed', '-f']))
@unittest.skipIf(gclient_utils.IsEnvCog(),
'not supported in non-git environment')
def test_squash_closed_abort_on_dirty_tree(self):
mock.patch('git_common.is_dirty_git_tree', return_value=True).start()
self.assertEqual(1, git_cl.main(['squash-closed', '-f']))
@unittest.skipIf(gclient_utils.IsEnvCog(),
'not supported in non-git environment')
def test_cmd_issue_erase_existing(self):
scm.GIT.SetConfig('', 'branch.main.gerritissue', '123')
scm.GIT.SetConfig('', 'branch.main.gerritserver',
'https://chromium-review.googlesource.com')
self.calls = [
((['git', 'log', '-1', '--format=%B'], ), 'This is a description'),
]
self.assertEqual(0, git_cl.main(['issue', '0']))
self.assertIsNone(scm.GIT.GetConfig('root', 'branch.main.gerritissue'))
self.assertIsNone(scm.GIT.GetConfig('root', 'branch.main.gerritserver'))
@unittest.skipIf(gclient_utils.IsEnvCog(),
'not supported in non-git environment')
def test_cmd_issue_erase_existing_with_change_id(self):
scm.GIT.SetConfig('', 'branch.main.gerritissue', '123')
scm.GIT.SetConfig('', 'branch.main.gerritserver',
'https://chromium-review.googlesource.com')
mock.patch(
'git_cl.Changelist.FetchDescription',
lambda _: 'This is a description\n\nChange-Id: Ideadbeef').start()
self.calls = [
((['git', 'log', '-1', '--format=%B'], ),
'This is a description\n\nChange-Id: Ideadbeef'),
((['git', 'commit', '--amend', '-m',
'This is a description\n'], ), ''),
]
self.assertEqual(0, git_cl.main(['issue', '0']))
self.assertIsNone(scm.GIT.GetConfig('root', 'branch.main.gerritissue'))
self.assertIsNone(scm.GIT.GetConfig('root', 'branch.main.gerritserver'))
@unittest.skipIf(gclient_utils.IsEnvCog(),
'not supported in non-git environment')
def test_cmd_issue_json(self):
scm.GIT.SetConfig('', 'branch.main.gerritissue', '123')
scm.GIT.SetConfig('', 'branch.main.gerritserver',
'https://chromium-review.googlesource.com')
scm.GIT.SetConfig('', 'remote.origin.url',
'https://chromium.googlesource.com/chromium/src')
self.calls = [(
(
'write_json',
'output.json',
{
'issue': 123,
'issue_url': 'https://chromium-review.googlesource.com/123',
'gerrit_host': 'chromium-review.googlesource.com',
'gerrit_project': 'chromium/src',
},
),
'',
)]
self.assertEqual(0, git_cl.main(['issue', '--json', 'output.json']))
def _common_GerritCommitMsgHookCheck(self):
mock.patch('git_cl.os.path.abspath',
lambda path: self._mocked_call(['abspath', path])).start()
mock.patch('git_cl.os.path.exists',
lambda path: self._mocked_call(['exists', path])).start()
mock.patch('git_cl.gclient_utils.FileRead',
lambda path: self._mocked_call(['FileRead', path])).start()
mock.patch(
'git_cl.gclient_utils.rm_file_or_tree',
lambda path: self._mocked_call(['rm_file_or_tree', path])).start()
mock.patch(
'gclient_utils.AskForData',
lambda prompt: self._mocked_call('ask_for_data', prompt)).start()
return git_cl.Changelist(issue=123)
def test_GerritCommitMsgHookCheck_custom_hook(self):
cl = self._common_GerritCommitMsgHookCheck()
self.calls += [
((['exists', os.path.join('.git', 'hooks', 'commit-msg')], ), True),
((['FileRead',
os.path.join('.git', 'hooks',
'commit-msg')], ), '#!/bin/sh\necho "custom hook"')
]
cl._GerritCommitMsgHookCheck(offer_removal=True)
def test_GerritCommitMsgHookCheck_not_exists(self):
cl = self._common_GerritCommitMsgHookCheck()
self.calls += [
((['exists', os.path.join('.git', 'hooks',
'commit-msg')], ), False),
]
cl._GerritCommitMsgHookCheck(offer_removal=True)
def test_GerritCommitMsgHookCheck(self):
cl = self._common_GerritCommitMsgHookCheck()
self.calls += [
((['exists', os.path.join('.git', 'hooks', 'commit-msg')], ), True),
((['FileRead',
os.path.join('.git', 'hooks', 'commit-msg')], ),
'...\n# From Gerrit Code Review\n...\nadd_ChangeId()\n'),
(('ask_for_data', 'Do you want to remove it now? [Yes/No]: '),
'Yes'),
((['rm_file_or_tree',
os.path.join('.git', 'hooks', 'commit-msg')], ), ''),
]
cl._GerritCommitMsgHookCheck(offer_removal=True)
def test_GerritCmdLand(self):
scm.GIT.SetConfig('', 'branch.main.gerritsquashhash', 'deadbeaf')
scm.GIT.SetConfig('', 'branch.main.gerritserver',
'chromium-review.googlesource.com')
self.calls += [
((['git', 'diff', 'deadbeaf'], ), ''), # No diff.
]
cl = git_cl.Changelist(issue=123)
cl._GetChangeDetail = lambda *args, **kwargs: {
'labels': {},
'current_revision': 'deadbeaf',
}
cl._GetChangeCommit = lambda: {
'commit':
'deadbeef',
'web_links': [{
'name': 'gitiles',
'url': 'https://git.googlesource.com/test/+/deadbeef'
}],
}
cl.SubmitIssue = lambda: None
self.assertEqual(
0,
cl.CMDLand(force=True,
bypass_hooks=True,
verbose=True,
parallel=False,
resultdb=False,
realm=None))
self.assertIn(
'Issue chromium-review.googlesource.com/123 has been submitted',
sys.stdout.getvalue())
self.assertIn('Landed as: https://git.googlesource.com/test/+/deadbeef',
sys.stdout.getvalue())
def _mock_gerrit_changes_for_detail_cache(self):
mock.patch('git_cl.Changelist.GetGerritHost', lambda _: 'host').start()
def test_gerrit_change_detail_cache_simple(self):
self._mock_gerrit_changes_for_detail_cache()
gerrit_util.GetChangeDetail.side_effect = ['a', 'b']
cl1 = git_cl.Changelist(issue=1)
cl1._cached_remote_url = (
True, 'https://chromium.googlesource.com/a/my/repo.git/')
cl2 = git_cl.Changelist(issue=2)
cl2._cached_remote_url = (True,
'https://chromium.googlesource.com/ab/repo')
self.assertEqual(cl1._GetChangeDetail(), 'a') # Miss.
self.assertEqual(cl1._GetChangeDetail(), 'a')
self.assertEqual(cl2._GetChangeDetail(), 'b') # Miss.
def test_gerrit_change_detail_cache_options(self):
self._mock_gerrit_changes_for_detail_cache()
gerrit_util.GetChangeDetail.side_effect = ['cab', 'ad']
cl = git_cl.Changelist(issue=1)
cl._cached_remote_url = (True,
'https://chromium.googlesource.com/repo/')
self.assertEqual(cl._GetChangeDetail(options=['C', 'A', 'B']), 'cab')
self.assertEqual(cl._GetChangeDetail(options=['A', 'B', 'C']), 'cab')
self.assertEqual(cl._GetChangeDetail(options=['B', 'A']), 'cab')
self.assertEqual(cl._GetChangeDetail(options=['C']), 'cab')
self.assertEqual(cl._GetChangeDetail(options=['A']), 'cab')
self.assertEqual(cl._GetChangeDetail(), 'cab')
self.assertEqual(cl._GetChangeDetail(options=['A', 'D']), 'ad')
self.assertEqual(cl._GetChangeDetail(options=['A']), 'cab')
self.assertEqual(cl._GetChangeDetail(options=['D']), 'ad')
self.assertEqual(cl._GetChangeDetail(), 'cab')
def test_gerrit_description_caching(self):
gerrit_util.GetChangeDetail.return_value = {
'current_revision': 'rev1',
'revisions': {
'rev1': {
'commit': {
'message': 'desc1'
}
},
},
}
self._mock_gerrit_changes_for_detail_cache()
cl = git_cl.Changelist(issue=1)
cl._cached_remote_url = (
True, 'https://chromium.googlesource.com/a/my/repo.git/')
self.assertEqual(cl.FetchDescription(), 'desc1')
self.assertEqual(cl.FetchDescription(), 'desc1') # cache hit.
def test_print_current_creds(self):
class CookiesAuthenticatorMock(object):
def __init__(self):
self.gitcookies = {
'host.googlesource.com': ('user', 'pass'),
'host-review.googlesource.com': ('user', 'pass'),
}
mock.patch('git_cl.gerrit_util.CookiesAuthenticator',
CookiesAuthenticatorMock).start()
git_cl._GitCookiesChecker().print_current_creds()
self.assertEqual(list(sys.stdout.getvalue().splitlines()), [
'Your .gitcookies have credentials for these hosts:',
' Host\tUser\t Which file',
'============================\t====\t===========',
'host-review.googlesource.com\tuser\t.gitcookies',
' host.googlesource.com\tuser\t.gitcookies',
])
sys.stdout.seek(0)
sys.stdout.truncate(0)
git_cl._GitCookiesChecker().print_current_creds()
self.assertEqual(list(sys.stdout.getvalue().splitlines()), [
'Your .gitcookies have credentials for these hosts:',
' Host\tUser\t Which file',
'============================\t====\t===========',
'host-review.googlesource.com\tuser\t.gitcookies',
' host.googlesource.com\tuser\t.gitcookies',
])
def _common_creds_check_mocks(self):
def exists_mock(path):
dirname = os.path.dirname(path)
if dirname == os.path.expanduser('~'):
dirname = '~'
base = os.path.basename(path)
if base == '.gitcookies':
return self._mocked_call('os.path.exists',
os.path.join(dirname, base))
# git cl also checks for existence other files not relevant to this
# test.
return None
mock.patch(
'gclient_utils.AskForData',
lambda prompt: self._mocked_call('ask_for_data', prompt)).start()
mock.patch('os.path.exists', exists_mock).start()
@unittest.skipIf(gclient_utils.IsEnvCog(),
'not supported in non-git environment')
def test_git_cl_comment_add_gerrit(self):
git_new_branch.create_new_branch(None) # hits mock from scm_mock.GIT.
scm.GIT.SetConfig('', 'remote.origin.url',
'https://chromium.googlesource.com/infra/infra')
self.calls = [
(('SetReview', 'chromium-review.googlesource.com',
'infra%2Finfra~10', 'msg', None, None, None), None),
]
self.assertEqual(0, git_cl.main(['comment', '-i', '10', '-a', 'msg']))
@unittest.skipIf(gclient_utils.IsEnvCog(),
'not supported in non-git environment')
@mock.patch('git_cl.Changelist.GetBranch', return_value='foo')
def test_git_cl_comments_fetch_gerrit(self, *_mocks):
scm.GIT.SetConfig('', 'remote.origin.url',
'https://chromium.googlesource.com/infra/infra')
gerrit_util.GetChangeDetail.return_value = {
'owner': {
'email': 'owner@example.com'
},
'current_revision':
'ba5eba11',
'revisions': {
'deadbeaf': {
'_number': 1,
},
'ba5eba11': {
'_number': 2,
},
},
'messages': [
{
u'_revision_number': 1,
u'author': {
u'_account_id': 1111084,
u'email': u'could-be-anything@example.com',
u'name': u'LUCI CQ'
},
u'date': u'2017-03-15 20:08:45.000000000',
u'id': u'f5a6c25ecbd3b3b54a43ae418ed97eff046dc50b',
u'message':
u'Patch Set 1:\n\nDry run: CQ is trying the patch...',
u'tag': u'autogenerated:cv:dry-run'
},
{
u'_revision_number': 2,
u'author': {
u'_account_id': 11151243,
u'email': u'owner@example.com',
u'name': u'owner'
},
u'date': u'2017-03-16 20:00:41.000000000',
u'id': u'f5a6c25ecbd3b3b54a43ae418ed97eff046d1234',
u'message': u'PTAL',
},
{
u'_revision_number': 2,
u'author': {
u'_account_id': 148512,
u'email': u'reviewer@example.com',
u'name': u'reviewer'
},
u'date': u'2017-03-17 05:19:37.500000000',
u'id': u'f5a6c25ecbd3b3b54a43ae418ed97eff046d4568',
u'message': u'Patch Set 2: Code-Review+1',
},
{
u'_revision_number': 2,
u'author': {
u'_account_id': 42,
u'name': u'reviewer'
},
u'date': u'2017-03-17 05:19:37.900000000',
u'id': u'f5a6c25ecbd3b3b54a43ae418ed97eff046d0000',
u'message': u'A bot with no email set',
},
]
}
self.calls = [
(('GetChangeComments', 'chromium-review.googlesource.com',
'infra%2Finfra~1'), {
'/COMMIT_MSG': [
{
'author': {
'email': u'reviewer@example.com'
},
'updated': u'2017-03-17 05:19:37.500000000',
'patch_set': 2,
'side': 'REVISION',
'message': 'Please include a bug link',
},
],
'codereview.settings': [
{
'author': {
'email': u'owner@example.com'
},
'updated': u'2017-03-16 20:00:41.000000000',
'patch_set': 2,
'side': 'PARENT',
'line': 42,
'message': 'I removed this because it is bad',
},
]
}),
(('GetChangeRobotComments', 'chromium-review.googlesource.com',
'infra%2Finfra~1'), {}),
] * 2 + [(('write_json', 'output.json', [{
u'date':
u'2017-03-16 20:00:41.000000',
u'message': (u'PTAL\n' + u'\n' + u'codereview.settings\n' +
u' Base, Line 42: https://crrev.com/c/1/2/'
u'codereview.settings#b42\n' +
u' I removed this because it is bad\n'),
u'autogenerated':
False,
u'approval':
False,
u'disapproval':
False,
u'sender':
u'owner@example.com'
}, {
u'date':
u'2017-03-17 05:19:37.500000',
u'message':
(u'Patch Set 2: Code-Review+1\n' + u'\n' + u'/COMMIT_MSG\n' +
u' PS2, File comment: https://crrev.com/c/1/2//COMMIT_MSG#\n' +
u' Please include a bug link\n'),
u'autogenerated':
False,
u'approval':
False,
u'disapproval':
False,
u'sender':
u'reviewer@example.com'
}]), '')]
expected_comments_summary = [
git_cl._CommentSummary(
message=(u'PTAL\n' + u'\n' + u'codereview.settings\n' +
u' Base, Line 42: https://crrev.com/c/1/2/' +
u'codereview.settings#b42\n' +
u' I removed this because it is bad\n'),
date=datetime.datetime(2017, 3, 16, 20, 0, 41, 0),
autogenerated=False,
disapproval=False,
approval=False,
sender=u'owner@example.com'),
git_cl._CommentSummary(message=(
u'Patch Set 2: Code-Review+1\n' + u'\n' + u'/COMMIT_MSG\n' +
u' PS2, File comment: https://crrev.com/c/1/2//COMMIT_MSG#\n' +
u' Please include a bug link\n'),
date=datetime.datetime(
2017, 3, 17, 5, 19, 37, 500000),
autogenerated=False,
disapproval=False,
approval=False,
sender=u'reviewer@example.com'),
]
cl = git_cl.Changelist(issue=1, branchref='refs/heads/foo')
self.assertEqual(cl.GetCommentsSummary(), expected_comments_summary)
self.assertEqual(
0, git_cl.main(['comments', '-i', '1', '-j', 'output.json']))
@unittest.skipIf(gclient_utils.IsEnvCog(),
'not supported in non-git environment')
def test_git_cl_comments_robot_comments(self):
# git cl comments also fetches robot comments (which are considered a
# type of autogenerated comment), and unlike other types of comments,
# only robot comments from the latest patchset are shown.
scm.GIT.SetConfig('', 'remote.origin.url',
'https://x.googlesource.com/infra/infra')
gerrit_util.GetChangeDetail.return_value = {
'owner': {
'email': 'owner@example.com'
},
'current_revision':
'ba5eba11',
'revisions': {
'deadbeaf': {
'_number': 1,
},
'ba5eba11': {
'_number': 2,
},
},
'messages': [
{
u'_revision_number': 1,
u'author': {
u'_account_id': 1111084,
u'email': u'commit-bot@chromium.org',
u'name': u'Commit Bot'
},
u'date': u'2017-03-15 20:08:45.000000000',
u'id': u'f5a6c25ecbd3b3b54a43ae418ed97eff046dc50b',
u'message':
u'Patch Set 1:\n\nDry run: CQ is trying the patch...',
u'tag': u'autogenerated:cq:dry-run'
},
{
u'_revision_number': 1,
u'author': {
u'_account_id': 123,
u'email': u'tricium@serviceaccount.com',
u'name': u'Tricium'
},
u'date': u'2017-03-16 20:00:41.000000000',
u'id': u'f5a6c25ecbd3b3b54a43ae418ed97eff046d1234',
u'message': u'(1 comment)',
u'tag': u'autogenerated:tricium',
},
{
u'_revision_number': 1,
u'author': {
u'_account_id': 123,
u'email': u'tricium@serviceaccount.com',
u'name': u'Tricium'
},
u'date': u'2017-03-16 20:00:41.000000000',
u'id': u'f5a6c25ecbd3b3b54a43ae418ed97eff046d1234',
u'message': u'(1 comment)',
u'tag': u'autogenerated:tricium',
},
{
u'_revision_number': 2,
u'author': {
u'_account_id': 123,
u'email': u'tricium@serviceaccount.com',
u'name': u'reviewer'
},
u'date': u'2017-03-17 05:30:37.000000000',
u'tag': u'autogenerated:tricium',
u'id': u'f5a6c25ecbd3b3b54a43ae418ed97eff046d4568',
u'message': u'(1 comment)',
},
]
}
self.calls = [
(('GetChangeComments', 'x-review.googlesource.com',
'infra%2Finfra~1'), {}),
(('GetChangeRobotComments', 'x-review.googlesource.com',
'infra%2Finfra~1'), {
'codereview.settings': [
{
u'author': {
u'email': u'tricium@serviceaccount.com'
},
u'updated': u'2017-03-17 05:30:37.000000000',
u'robot_run_id': u'5565031076855808',
u'robot_id': u'Linter/Category',
u'tag': u'autogenerated:tricium',
u'patch_set': 2,
u'side': u'REVISION',
u'message': u'Linter warning message text',
u'line': 32,
},
],
}),
]
expected_comments_summary = [
git_cl._CommentSummary(
date=datetime.datetime(2017, 3, 17, 5, 30, 37),
message=(
u'(1 comment)\n\ncodereview.settings\n'
u' PS2, Line 32: https://x-review.googlesource.com/c/1/2/'
u'codereview.settings#32\n'
u' Linter warning message text\n'),
sender=u'tricium@serviceaccount.com',
autogenerated=True,
approval=False,
disapproval=False)
]
cl = git_cl.Changelist(issue=1, branchref='refs/heads/foo')
self.assertEqual(cl.GetCommentsSummary(), expected_comments_summary)
def test_get_remote_url_with_mirror(self):
original_os_path_isdir = os.path.isdir
def selective_os_path_isdir_mock(path):
if path == '/cache/this-dir-exists':
return self._mocked_call('os.path.isdir', path)
return original_os_path_isdir(path)
mock.patch('os.path.isdir', selective_os_path_isdir_mock).start()
url = 'https://chromium.googlesource.com/my/repo'
scm.GIT.SetConfig('', 'remote.origin.url', '/cache/this-dir-exists')
scm.GIT.SetConfig('/cache/this-dir-exists', 'remote.origin.url', url)
self.calls = [
(('os.path.isdir', '/cache/this-dir-exists'), True),
]
cl = git_cl.Changelist(issue=1)
self.assertEqual(cl.GetRemoteUrl(), url)
self.assertEqual(cl.GetRemoteUrl(), url) # Must be cached.
def test_get_remote_url_non_existing_mirror(self):
original_os_path_isdir = os.path.isdir
def selective_os_path_isdir_mock(path):
if path == '/cache/this-dir-doesnt-exist':
return self._mocked_call('os.path.isdir', path)
return original_os_path_isdir(path)
mock.patch('os.path.isdir', selective_os_path_isdir_mock).start()
mock.patch('logging.error',
lambda *a: self._mocked_call('logging.error', *a)).start()
scm.GIT.SetConfig('', 'remote.origin.url',
'/cache/this-dir-doesnt-exist')
self.calls = [
(('os.path.isdir', '/cache/this-dir-doesnt-exist'), False),
(('logging.error',
'Remote "%(remote)s" for branch "%(branch)s" points to "%(url)s", '
'but it doesn\'t exist.', {
'remote': 'origin',
'branch': 'main',
'url': '/cache/this-dir-doesnt-exist'
}), None),
]
cl = git_cl.Changelist(issue=1)
self.assertIsNone(cl.GetRemoteUrl())
def test_get_remote_url_misconfigured_mirror(self):
original_os_path_isdir = os.path.isdir
def selective_os_path_isdir_mock(path):
if path == '/cache/this-dir-exists':
return self._mocked_call('os.path.isdir', path)
return original_os_path_isdir(path)
mock.patch('os.path.isdir', selective_os_path_isdir_mock).start()
mock.patch('logging.error',
lambda *a: self._mocked_call('logging.error', *a)).start()
scm.GIT.SetConfig('', 'remote.origin.url', '/cache/this-dir-exists')
self.calls = [
(('os.path.isdir', '/cache/this-dir-exists'), True),
(('logging.error',
'Remote "%(remote)s" for branch "%(branch)s" points to '
'"%(cache_path)s", but it is misconfigured.\n'
'"%(cache_path)s" must be a git repo and must have a remote named '
'"%(remote)s" pointing to the git host.', {
'remote': 'origin',
'cache_path': '/cache/this-dir-exists',
'branch': 'main'
}), None),
]
cl = git_cl.Changelist(issue=1)
self.assertIsNone(cl.GetRemoteUrl())
def test_gerrit_change_identifier_with_project(self):
scm.GIT.SetConfig('', 'remote.origin.url',
'https://chromium.googlesource.com/a/my/repo.git/')
cl = git_cl.Changelist(issue=123456)
self.assertEqual(cl._GerritChangeIdentifier(), 'my%2Frepo~123456')
def test_gerrit_change_identifier_without_project(self):
mock.patch('logging.error',
lambda *a: self._mocked_call('logging.error', *a)).start()
self.calls = [
(('logging.error',
'Remote "%(remote)s" for branch "%(branch)s" points to "%(url)s", '
'but it doesn\'t exist.', {
'remote': 'origin',
'branch': 'main',
'url': ''
}), None),
]
cl = git_cl.Changelist(issue=123456)
self.assertEqual(cl._GerritChangeIdentifier(), '123456')
class ChangelistTest(unittest.TestCase):
LAST_COMMIT_SUBJECT = 'Fixes goat teleporter destination to be Australia'
def _mock_run_git(commands):
if commands == ['show', '-s', '--format=%s', 'HEAD', '--']:
return ChangelistTest.LAST_COMMIT_SUBJECT
def setUp(self):
super(ChangelistTest, self).setUp()
mock.patch('gclient_utils.FileRead').start()
mock.patch('gclient_utils.FileWrite').start()
mock.patch('gclient_utils.temporary_file', TemporaryFileMock()).start()
mock.patch(
'git_cl.Changelist.GetCodereviewServer',
return_value='https://chromium-review.googlesource.com').start()
mock.patch('git_cl.Changelist.GetAuthor', return_value='author').start()
mock.patch('git_cl.Changelist.GetIssue', return_value=123456).start()
mock.patch('git_cl.Changelist.GetPatchset', return_value=7).start()
mock.patch('git_cl.Changelist.GetRemoteBranch',
return_value=('origin', 'refs/remotes/origin/main')).start()
mock.patch('git_cl.PRESUBMIT_SUPPORT', 'PRESUBMIT_SUPPORT').start()
mock.patch('git_cl.Settings.GetRoot', return_value='root').start()
mock.patch('git_cl.Settings.GetIsGerrit', return_value=True).start()
mock.patch('git_cl.time_time').start()
mock.patch('metrics.collector').start()
mock.patch('subprocess2.Popen').start()
mock.patch('git_cl.Changelist.GetGerritProject',
return_value='project').start()
mock.patch('sys.exit', side_effect=SystemExitMock).start()
scm_mock.GIT(self)
self.addCleanup(mock.patch.stopall)
self.temp_count = 0
gerrit_util._Authenticator._resolved = None
def testRunHook(self):
expected_results = {
'more_cc': ['cc@example.com', 'more@example.com'],
'errors': [],
'notifications': [],
'warnings': [],
}
gclient_utils.FileRead.return_value = json.dumps(expected_results)
git_cl.time_time.side_effect = [100, 200, 300, 400]
mockProcess = mock.Mock()
mockProcess.wait.return_value = 0
subprocess2.Popen.return_value = mockProcess
cl = git_cl.Changelist()
results = cl.RunHook(committing=True,
may_prompt=True,
verbose=2,
parallel=True,
upstream='upstream',
description='description',
all_files=True,
resultdb=False)
self.assertEqual(expected_results, results)
subprocess2.Popen.assert_any_call([
'vpython3',
'PRESUBMIT_SUPPORT',
'--root',
'root',
'--upstream',
'upstream',
'--verbose',
'--verbose',
'--gerrit_url',
'https://chromium-review.googlesource.com',
'--gerrit_project',
'project',
'--gerrit_branch',
'refs/heads/main',
'--author',
'author',
'--issue',
'123456',
'--patchset',
'7',
'--commit',
'--may_prompt',
'--parallel',
'--all_files',
'--no_diffs',
'--json_output',
'/tmp/fake-temp2',
'--description_file',
'/tmp/fake-temp1',
])
gclient_utils.FileWrite.assert_any_call('/tmp/fake-temp1',
'description')
metrics.collector.add_repeated('sub_commands', {
'command': 'presubmit',
'execution_time': 100,
'exit_code': 0,
})
def testRunHook_FewerOptions(self):
expected_results = {
'more_cc': ['cc@example.com', 'more@example.com'],
'errors': [],
'notifications': [],
'warnings': [],
}
gclient_utils.FileRead.return_value = json.dumps(expected_results)
git_cl.time_time.side_effect = [100, 200, 300, 400]
mockProcess = mock.Mock()
mockProcess.wait.return_value = 0
subprocess2.Popen.return_value = mockProcess
git_cl.Changelist.GetAuthor.return_value = None
git_cl.Changelist.GetIssue.return_value = None
git_cl.Changelist.GetPatchset.return_value = None
cl = git_cl.Changelist()
results = cl.RunHook(committing=False,
may_prompt=False,
verbose=0,
parallel=False,
upstream='upstream',
description='description',
all_files=False,
resultdb=False)
self.assertEqual(expected_results, results)
subprocess2.Popen.assert_any_call([
'vpython3',
'PRESUBMIT_SUPPORT',
'--root',
'root',
'--upstream',
'upstream',
'--gerrit_url',
'https://chromium-review.googlesource.com',
'--gerrit_project',
'project',
'--gerrit_branch',
'refs/heads/main',
'--upload',
'--json_output',
'/tmp/fake-temp2',
'--description_file',
'/tmp/fake-temp1',
])
gclient_utils.FileWrite.assert_any_call('/tmp/fake-temp1',
'description')
metrics.collector.add_repeated('sub_commands', {
'command': 'presubmit',
'execution_time': 100,
'exit_code': 0,
})
def testRunHook_FewerOptionsResultDB(self):
expected_results = {
'more_cc': ['cc@example.com', 'more@example.com'],
'errors': [],
'notifications': [],
'warnings': [],
}
gclient_utils.FileRead.return_value = json.dumps(expected_results)
git_cl.time_time.side_effect = [100, 200, 300, 400]
mockProcess = mock.Mock()
mockProcess.wait.return_value = 0
subprocess2.Popen.return_value = mockProcess
git_cl.Changelist.GetAuthor.return_value = None
git_cl.Changelist.GetIssue.return_value = None
git_cl.Changelist.GetPatchset.return_value = None
cl = git_cl.Changelist()
results = cl.RunHook(committing=False,
may_prompt=False,
verbose=0,
parallel=False,
upstream='upstream',
description='description',
all_files=False,
resultdb=True,
realm='chromium:public')
self.assertEqual(expected_results, results)
subprocess2.Popen.assert_any_call([
'rdb',
'stream',
'-new',
'-realm',
'chromium:public',
'--',
'vpython3',
'PRESUBMIT_SUPPORT',
'--root',
'root',
'--upstream',
'upstream',
'--gerrit_url',
'https://chromium-review.googlesource.com',
'--gerrit_project',
'project',
'--gerrit_branch',
'refs/heads/main',
'--upload',
'--json_output',
'/tmp/fake-temp2',
'--description_file',
'/tmp/fake-temp1',
])
def testRunHook_NoGerrit(self):
mock.patch('git_cl.Settings.GetIsGerrit', return_value=False).start()
expected_results = {
'more_cc': ['cc@example.com', 'more@example.com'],
'errors': [],
'notifications': [],
'warnings': [],
}
gclient_utils.FileRead.return_value = json.dumps(expected_results)
git_cl.time_time.side_effect = [100, 200, 300, 400]
mockProcess = mock.Mock()
mockProcess.wait.return_value = 0
subprocess2.Popen.return_value = mockProcess
git_cl.Changelist.GetAuthor.return_value = None
git_cl.Changelist.GetIssue.return_value = None
git_cl.Changelist.GetPatchset.return_value = None
cl = git_cl.Changelist()
results = cl.RunHook(committing=False,
may_prompt=False,
verbose=0,
parallel=False,
upstream='upstream',
description='description',
all_files=False,
resultdb=False)
self.assertEqual(expected_results, results)
subprocess2.Popen.assert_any_call([
'vpython3',
'PRESUBMIT_SUPPORT',
'--root',
'root',
'--upstream',
'upstream',
'--upload',
'--json_output',
'/tmp/fake-temp2',
'--description_file',
'/tmp/fake-temp1',
])
gclient_utils.FileWrite.assert_any_call('/tmp/fake-temp1',
'description')
metrics.collector.add_repeated('sub_commands', {
'command': 'presubmit',
'execution_time': 100,
'exit_code': 0,
})
@mock.patch('sys.exit', side_effect=SystemExitMock)
def testRunHook_Failure(self, _mock):
git_cl.time_time.side_effect = [100, 200]
mockProcess = mock.Mock()
mockProcess.wait.return_value = 2
subprocess2.Popen.return_value = mockProcess
cl = git_cl.Changelist()
with self.assertRaises(SystemExitMock):
cl.RunHook(committing=True,
may_prompt=True,
verbose=2,
parallel=True,
upstream='upstream',
description='description',
all_files=True,
resultdb=False)
sys.exit.assert_called_once_with(2)
def testRunPostUploadHook(self):
cl = git_cl.Changelist()
cl.RunPostUploadHook(2, 'upstream', 'description')
subprocess2.Popen.assert_called_with([
'vpython3',
'PRESUBMIT_SUPPORT',
'--root',
'root',
'--upstream',
'upstream',
'--verbose',
'--verbose',
'--gerrit_url',
'https://chromium-review.googlesource.com',
'--gerrit_project',
'project',
'--gerrit_branch',
'refs/heads/main',
'--author',
'author',
'--issue',
'123456',
'--patchset',
'7',
'--post_upload',
'--description_file',
'/tmp/fake-temp1',
])
gclient_utils.FileWrite.assert_called_once_with('/tmp/fake-temp1',
'description')
def testRunPostUploadHookPy3Only(self):
cl = git_cl.Changelist()
cl.RunPostUploadHook(2, 'upstream', 'description')
subprocess2.Popen.assert_called_once_with([
'vpython3',
'PRESUBMIT_SUPPORT',
'--root',
'root',
'--upstream',
'upstream',
'--verbose',
'--verbose',
'--gerrit_url',
'https://chromium-review.googlesource.com',
'--gerrit_project',
'project',
'--gerrit_branch',
'refs/heads/main',
'--author',
'author',
'--issue',
'123456',
'--patchset',
'7',
'--post_upload',
'--description_file',
'/tmp/fake-temp1',
])
gclient_utils.FileWrite.assert_called_once_with('/tmp/fake-temp1',
'description')
@mock.patch('git_cl.RunGit', _mock_run_git)
def testDefaultTitleEmptyMessage(self):
cl = git_cl.Changelist()
cl.issue = 100
options = optparse.Values({
'squash': True,
'title': None,
'message': None,
'force': None,
'skip_title': None
})
mock.patch('gclient_utils.AskForData', lambda _: user_title).start()
for user_title in ['', 'y', 'Y']:
self.assertEqual(cl._GetTitleForUpload(options),
self.LAST_COMMIT_SUBJECT)
for user_title in ['not empty', 'yes', 'YES']:
self.assertEqual(cl._GetTitleForUpload(options), user_title)
@mock.patch('git_cl.Changelist.GetMostRecentPatchset', return_value=2)
@mock.patch('git_cl.RunGit')
@mock.patch('git_cl.Changelist._PrepareChange')
def testPrepareSquashedCommit(self, mockPrepareChange, mockRunGit, *_mocks):
change_desc = git_cl.ChangeDescription('BOO!')
reviewers = []
ccs = []
mockPrepareChange.return_value = (reviewers, ccs, change_desc)
parent_hash = 'upstream-gerrit-hash'
parent_orig_hash = 'upstream-last-upload-hash'
parent_hash_root = 'root-commit'
hash_to_push = 'new-squash-hash'
hash_to_push_root = 'new-squash-hash-root'
branchref = 'refs/heads/current-branch'
end_hash = 'end-hash'
tree_hash = 'tree-hash'
def mock_run_git(commands):
if {'commit-tree', tree_hash, '-p', parent_hash,
'-F'}.issubset(set(commands)):
return hash_to_push
if {'commit-tree', tree_hash, '-p', parent_hash_root,
'-F'}.issubset(set(commands)):
return hash_to_push_root
if commands == ['rev-parse', branchref]:
return end_hash
if commands == ['rev-parse', end_hash + ':']:
return tree_hash
mockRunGit.side_effect = mock_run_git
cl = git_cl.Changelist(branchref=branchref)
options = optparse.Values()
new_upload = cl.PrepareSquashedCommit(options, parent_hash,
parent_orig_hash)
self.assertEqual(new_upload.reviewers, reviewers)
self.assertEqual(new_upload.ccs, ccs)
self.assertEqual(new_upload.commit_to_push, hash_to_push)
self.assertEqual(new_upload.new_last_uploaded_commit, end_hash)
self.assertEqual(new_upload.change_desc, change_desc)
mockPrepareChange.assert_called_with(options, parent_orig_hash,
end_hash)
@mock.patch('git_cl.Settings.GetRoot', return_value='')
@mock.patch('git_cl.Changelist.GetMostRecentPatchset', return_value=2)
@mock.patch('git_cl.RunGitWithCode')
@mock.patch('git_cl.RunGit')
@mock.patch('git_cl.Changelist._PrepareChange')
@mock.patch('git_cl.Changelist.GetCommonAncestorWithUpstream')
def testPrepareCherryPickSquashedCommit(self,
mockGetCommonAncestorWithUpstream,
mockPrepareChange, mockRunGit,
mockRunGitWithCode, *_mocks):
cherry_pick_base_hash = '1a2bcherrypickbase'
mockGetCommonAncestorWithUpstream.return_value = cherry_pick_base_hash
change_desc = git_cl.ChangeDescription('BOO!')
ccs = ['cc@review.cl']
reviewers = ['reviewer@review.cl']
mockPrepareChange.return_value = (reviewers, ccs, change_desc)
branchref = 'refs/heads/current-branch'
cl = git_cl.Changelist(branchref=branchref)
options = optparse.Values()
upstream_gerrit_hash = 'upstream-gerrit-hash'
latest_tree_hash = 'tree-hash'
hash_to_cp = 'squashed-hash'
hash_to_push = 'hash-to-push'
hash_to_save_as_last_upload = 'last-upload'
def mock_run_git(commands):
if commands == ['rev-parse', branchref]:
return hash_to_save_as_last_upload
if commands == ['rev-parse', branchref + ':']:
return latest_tree_hash
if {
'commit-tree', latest_tree_hash, '-p',
cherry_pick_base_hash, '-F'
}.issubset(set(commands)):
return hash_to_cp
if commands == ['rev-parse', 'HEAD']:
return hash_to_push
mockRunGit.side_effect = mock_run_git
def mock_run_git_with_code(commands):
if commands == ['cherry-pick', hash_to_cp]:
return 0, ''
mockRunGitWithCode.side_effect = mock_run_git_with_code
new_upload = cl.PrepareCherryPickSquashedCommit(options,
upstream_gerrit_hash)
self.assertEqual(new_upload.reviewers, reviewers)
self.assertEqual(new_upload.ccs, ccs)
self.assertEqual(new_upload.commit_to_push, hash_to_push)
self.assertEqual(new_upload.new_last_uploaded_commit,
hash_to_save_as_last_upload)
self.assertEqual(new_upload.change_desc, change_desc)
# Test failed cherry-pick
def mock_run_git_with_code(commands):
if commands == ['cherry-pick', hash_to_cp]:
return 1, ''
mockRunGitWithCode.side_effect = mock_run_git_with_code
with self.assertRaises(SystemExitMock):
cl.PrepareCherryPickSquashedCommit(options, cherry_pick_base_hash)
@mock.patch('git_cl.Settings.GetDefaultCCList', return_value=[])
@mock.patch('git_cl.Changelist.GetAffectedFiles', return_value=[])
@mock.patch('git_cl.GenerateGerritChangeId', return_value='1a2b3c')
@mock.patch('git_cl.Changelist.GetIssue', return_value=None)
@mock.patch('git_cl.ChangeDescription.prompt')
@mock.patch('git_cl.Changelist.RunHook')
@mock.patch('git_cl.Changelist._GetDescriptionForUpload')
@mock.patch('git_cl.Changelist.EnsureCanUploadPatchset')
def testPrepareChange_new(self, mockEnsureCanUploadPatchset,
mockGetDescriptionForupload, mockRunHook,
mockPrompt, *_mocks):
options = optparse.Values()
options.force = False
options.bypass_hooks = False
options.verbose = False
options.parallel = False
options.preserve_tryjobs = False
options.private = False
options.no_autocc = False
options.message_file = None
options.commit_description = None
options.cc = ['chicken@bok.farm']
parent = '420parent'
latest_tree = '420latest_tree'
mockRunHook.return_value = {'more_cc': ['cow@moo.farm']}
desc = 'AH!\nCC=cow2@moo.farm\nR=horse@apple.farm'
mockGetDescriptionForupload.return_value = git_cl.ChangeDescription(
desc)
cl = git_cl.Changelist()
reviewers, ccs, change_desc = cl._PrepareChange(options, parent,
latest_tree)
self.assertEqual(reviewers, ['horse@apple.farm'])
self.assertEqual(ccs,
['cow@moo.farm', 'chicken@bok.farm', 'cow2@moo.farm'])
self.assertEqual(change_desc._description_lines, [
'AH!', 'CC=cow2@moo.farm', 'R=horse@apple.farm', '',
'Change-Id: 1a2b3c'
])
mockPrompt.assert_called_once()
mockEnsureCanUploadPatchset.assert_called_once()
mockRunHook.assert_called_once_with(committing=False,
may_prompt=True,
verbose=False,
parallel=False,
upstream='420parent',
description=desc,
all_files=False,
end_commit='420latest_tree')
@mock.patch('git_cl.Changelist.GetAffectedFiles', return_value=[])
@mock.patch('git_cl.Changelist.GetIssue', return_value='123')
@mock.patch('git_cl.ChangeDescription.prompt')
@mock.patch('gerrit_util.GetChangeDetail')
@mock.patch('git_cl.Changelist.RunHook')
@mock.patch('git_cl.Changelist._GetDescriptionForUpload')
@mock.patch('git_cl.Changelist.EnsureCanUploadPatchset')
def testPrepareChange_existing(self, mockEnsureCanUploadPatchset,
mockGetDescriptionForupload, mockRunHook,
mockGetChangeDetail, mockPrompt, *_mocks):
cl = git_cl.Changelist()
options = optparse.Values()
options.force = False
options.bypass_hooks = False
options.verbose = False
options.parallel = False
options.edit_description = False
options.preserve_tryjobs = False
options.private = False
options.no_autocc = False
options.cc = ['chicken@bok.farm']
parent = '420parent'
latest_tree = '420latest_tree'
mockRunHook.return_value = {'more_cc': ['cow@moo.farm']}
desc = 'AH!\nCC=cow2@moo.farm\nR=horse@apple.farm'
mockGetDescriptionForupload.return_value = git_cl.ChangeDescription(
desc)
# Existing change
gerrit_util.GetChangeDetail.return_value = {
'change_id': ('123456789'),
'current_revision': 'sha1_of_current_revision',
}
reviewers, ccs, change_desc = cl._PrepareChange(options, parent,
latest_tree)
self.assertEqual(reviewers, ['horse@apple.farm'])
self.assertEqual(ccs, ['chicken@bok.farm', 'cow2@moo.farm'])
self.assertEqual(change_desc._description_lines, [
'AH!', 'CC=cow2@moo.farm', 'R=horse@apple.farm', '',
'Change-Id: 123456789'
])
mockRunHook.assert_called_once_with(committing=False,
may_prompt=True,
verbose=False,
parallel=False,
upstream=parent,
description=desc,
all_files=False,
end_commit=latest_tree)
mockEnsureCanUploadPatchset.assert_called_once()
# Test preserve_tryjob
options.preserve_tryjobs = True
# Test edit_description
options.edit_description = True
# Test private
options.private = True
options.no_autocc = True
reviewers, ccs, change_desc = cl._PrepareChange(options, parent,
latest_tree)
self.assertEqual(ccs, ['chicken@bok.farm', 'cow2@moo.farm'])
mockPrompt.assert_called_once()
self.assertEqual(change_desc._description_lines, [
'AH!', 'CC=cow2@moo.farm', 'R=horse@apple.farm', '',
'Change-Id: 123456789', 'Cq-Do-Not-Cancel-Tryjobs: true'
])
@mock.patch('git_cl.Changelist.GetGerritHost', return_value='chromium')
@mock.patch('git_cl.Settings.GetRunPostUploadHook', return_value=True)
@mock.patch('git_cl.Changelist.SetPatchset')
@mock.patch('git_cl.Changelist.RunPostUploadHook')
@mock.patch('git_cl.gerrit_util.AddReviewers')
def testPostUploadUpdates(self, mockAddReviewers, mockRunPostHook,
mockSetPatchset, *_mocks):
cl = git_cl.Changelist(branchref='refs/heads/current-branch')
options = optparse.Values()
options.verbose = True
options.no_python2_post_upload_hooks = True
options.send_mail = False
reviewers = ['monkey@vp.circus']
ccs = ['cow@rds.corp']
change_desc = git_cl.ChangeDescription('[stonks] honk honk')
new_upload = git_cl._NewUpload(reviewers, ccs, 'pushed-commit',
'last-uploaded-commit', 'parent-commit',
change_desc, 2)
cl.PostUploadUpdates(options, new_upload, '12345')
mockSetPatchset.assert_called_once_with(3)
self.assertEqual(
scm.GIT.GetConfig('root', 'branch.current-branch.gerritsquashhash'),
new_upload.commit_to_push)
self.assertEqual(
scm.GIT.GetConfig('root', 'branch.current-branch.last-upload-hash'),
new_upload.new_last_uploaded_commit)
mockAddReviewers.assert_called_once_with('chromium',
'project~123456',
reviewers=reviewers,
ccs=ccs,
notify=False)
mockRunPostHook.assert_called_once_with(True, 'parent-commit',
change_desc.description)
class CMDTestCaseBase(unittest.TestCase):
_STATUSES = [
'STATUS_UNSPECIFIED',
'SCHEDULED',
'STARTED',
'SUCCESS',
'FAILURE',
'INFRA_FAILURE',
'CANCELED',
]
_CHANGE_DETAIL = {
'project': 'depot_tools',
'status': 'OPEN',
'owner': {
'email': 'owner@e.mail'
},
'current_revision': 'beeeeeef',
'revisions': {
'deadbeaf': {
'_number': 6,
'kind': 'REWORK',
},
'beeeeeef': {
'_number': 7,
'kind': 'NO_CODE_CHANGE',
'fetch': {
'http': {
'url': 'https://chromium.googlesource.com/depot_tools',
'ref': 'refs/changes/56/123456/7'
}
},
},
},
}
_DEFAULT_RESPONSE = {
'builds': [{
'id': str(100 + idx),
'builder': {
'project': 'chromium',
'bucket': 'try',
'builder': 'bot_' + status.lower(),
},
'createTime': '2019-10-09T08:00:0%d.854286Z' % (idx % 10),
'tags': [],
'status': status,
} for idx, status in enumerate(_STATUSES)]
}
def setUp(self):
super(CMDTestCaseBase, self).setUp()
mock.patch('git_cl.sys.stdout', io.StringIO()).start()
mock.patch('git_cl.uuid.uuid4', return_value='uuid4').start()
mock.patch('git_cl.Changelist.GetIssue', return_value=123456).start()
mock.patch(
'git_cl.Changelist.GetCodereviewServer',
return_value='https://chromium-review.googlesource.com').start()
mock.patch('git_cl.Changelist.GetGerritHost',
return_value='chromium-review.googlesource.com').start()
mock.patch('git_cl.Changelist.GetMostRecentPatchset',
return_value=7).start()
mock.patch('git_cl.Changelist.GetMostRecentDryRunPatchset',
return_value=6).start()
mock.patch('git_cl.Changelist.GetRemoteUrl',
return_value='https://chromium.googlesource.com/depot_tools'
).start()
mock.patch('auth.Authenticator',
return_value=AuthenticatorMock()).start()
mock.patch('gerrit_util.GetChangeDetail',
return_value=self._CHANGE_DETAIL).start()
mock.patch('git_cl._call_buildbucket',
return_value=self._DEFAULT_RESPONSE).start()
mock.patch('git_common.is_dirty_git_tree', return_value=False).start()
self.addCleanup(mock.patch.stopall)
@unittest.skipIf(gclient_utils.IsEnvCog(),
'not supported in non-git environment')
class CMDPresubmitTestCase(CMDTestCaseBase):
_RUN_HOOK_RETURN = {
'errors': [],
'more_cc': [],
'notifications': [],
'warnings': []
}
def setUp(self):
super(CMDPresubmitTestCase, self).setUp()
mock.patch('git_cl.Changelist.GetCommonAncestorWithUpstream',
return_value='upstream').start()
mock.patch('git_cl.Changelist.FetchDescription',
return_value='fetch description').start()
mock.patch('git_cl._create_description_from_log',
return_value='get description').start()
mock.patch('git_cl.Changelist.RunHook',
return_value=self._RUN_HOOK_RETURN).start()
def testDefaultCase(self):
self.assertEqual(0, git_cl.main(['presubmit']))
git_cl.Changelist.RunHook.assert_called_once_with(
committing=True,
may_prompt=False,
verbose=0,
parallel=None,
upstream='upstream',
description='fetch description',
all_files=None,
files=None,
resultdb=None,
realm=None)
def testNoIssue(self):
git_cl.Changelist.GetIssue.return_value = None
self.assertEqual(0, git_cl.main(['presubmit']))
git_cl.Changelist.RunHook.assert_called_once_with(
committing=True,
may_prompt=False,
verbose=0,
parallel=None,
upstream='upstream',
description='get description',
all_files=None,
files=None,
resultdb=None,
realm=None)
def testCustomBranch(self):
self.assertEqual(0, git_cl.main(['presubmit', 'custom_branch']))
git_cl.Changelist.RunHook.assert_called_once_with(
committing=True,
may_prompt=False,
verbose=0,
parallel=None,
upstream='custom_branch',
description='fetch description',
all_files=None,
files=None,
resultdb=None,
realm=None)
def testOptions(self):
self.assertEqual(
0,
git_cl.main([
'presubmit', '-v', '-v', '--all', '--parallel', '-u',
'--resultdb', '--realm', 'chromium:public'
]))
git_cl.Changelist.RunHook.assert_called_once_with(
committing=False,
may_prompt=False,
verbose=2,
parallel=True,
upstream='upstream',
description='fetch description',
all_files=True,
files=None,
resultdb=True,
realm='chromium:public')
@mock.patch('git_cl.write_json')
def testJson(self, mock_write_json):
self.assertEqual(0, git_cl.main(['presubmit', '--json', 'file.json']))
mock_write_json.assert_called_once_with('file.json',
self._RUN_HOOK_RETURN)
class CMDTryResultsTestCase(CMDTestCaseBase):
_DEFAULT_REQUEST = {
'predicate': {
"gerritChanges": [{
"project": "depot_tools",
"host": "chromium-review.googlesource.com",
"patchset": 6,
"change": 123456,
}],
},
'fields': ('builds.*.id,builds.*.builder,builds.*.status' +
',builds.*.createTime,builds.*.tags'),
}
_TRIVIAL_REQUEST = {
'predicate': {
"gerritChanges": [{
"project": "depot_tools",
"host": "chromium-review.googlesource.com",
"patchset": 7,
"change": 123456,
}],
},
'fields': ('builds.*.id,builds.*.builder,builds.*.status' +
',builds.*.createTime,builds.*.tags'),
}
@unittest.skipIf(gclient_utils.IsEnvCog(),
'not supported in non-git environment')
def testNoJobs(self):
git_cl._call_buildbucket.return_value = {}
self.assertEqual(0, git_cl.main(['try-results']))
self.assertEqual('No tryjobs scheduled.\n', sys.stdout.getvalue())
git_cl._call_buildbucket.assert_called_once_with(
mock.ANY, 'cr-buildbucket.appspot.com', 'SearchBuilds',
self._DEFAULT_REQUEST)
@unittest.skipIf(gclient_utils.IsEnvCog(),
'not supported in non-git environment')
def testTrivialCommits(self):
self.assertEqual(0, git_cl.main(['try-results']))
git_cl._call_buildbucket.assert_called_with(
mock.ANY, 'cr-buildbucket.appspot.com', 'SearchBuilds',
self._DEFAULT_REQUEST)
git_cl._call_buildbucket.return_value = {}
self.assertEqual(0, git_cl.main(['try-results', '--patchset', '7']))
git_cl._call_buildbucket.assert_called_with(
mock.ANY, 'cr-buildbucket.appspot.com', 'SearchBuilds',
self._TRIVIAL_REQUEST)
self.assertEqual([
'Successes:',
' bot_success https://ci.chromium.org/b/103',
'Infra Failures:',
' bot_infra_failure https://ci.chromium.org/b/105',
'Failures:',
' bot_failure https://ci.chromium.org/b/104',
'Canceled:',
' bot_canceled ',
'Started:',
' bot_started https://ci.chromium.org/b/102',
'Scheduled:',
' bot_scheduled id=101',
'Other:',
' bot_status_unspecified id=100',
'Total: 7 tryjobs',
'No tryjobs scheduled.',
],
sys.stdout.getvalue().splitlines())
@unittest.skipIf(gclient_utils.IsEnvCog(),
'not supported in non-git environment')
def testPrintToStdout(self):
self.assertEqual(0, git_cl.main(['try-results']))
self.assertEqual([
'Successes:',
' bot_success https://ci.chromium.org/b/103',
'Infra Failures:',
' bot_infra_failure https://ci.chromium.org/b/105',
'Failures:',
' bot_failure https://ci.chromium.org/b/104',
'Canceled:',
' bot_canceled ',
'Started:',
' bot_started https://ci.chromium.org/b/102',
'Scheduled:',
' bot_scheduled id=101',
'Other:',
' bot_status_unspecified id=100',
'Total: 7 tryjobs',
],
sys.stdout.getvalue().splitlines())
git_cl._call_buildbucket.assert_called_once_with(
mock.ANY, 'cr-buildbucket.appspot.com', 'SearchBuilds',
self._DEFAULT_REQUEST)
@unittest.skipIf(gclient_utils.IsEnvCog(),
'not supported in non-git environment')
def testPrintToStdoutWithMasters(self):
self.assertEqual(0, git_cl.main(['try-results', '--print-master']))
self.assertEqual([
'Successes:',
' try bot_success https://ci.chromium.org/b/103',
'Infra Failures:',
' try bot_infra_failure https://ci.chromium.org/b/105',
'Failures:',
' try bot_failure https://ci.chromium.org/b/104',
'Canceled:',
' try bot_canceled ',
'Started:',
' try bot_started https://ci.chromium.org/b/102',
'Scheduled:',
' try bot_scheduled id=101',
'Other:',
' try bot_status_unspecified id=100',
'Total: 7 tryjobs',
],
sys.stdout.getvalue().splitlines())
git_cl._call_buildbucket.assert_called_once_with(
mock.ANY, 'cr-buildbucket.appspot.com', 'SearchBuilds',
self._DEFAULT_REQUEST)
@unittest.skipIf(gclient_utils.IsEnvCog(),
'not supported in non-git environment')
@mock.patch('git_cl.write_json')
def testWriteToJson(self, mockJsonDump):
self.assertEqual(0, git_cl.main(['try-results', '--json', 'file.json']))
git_cl._call_buildbucket.assert_called_once_with(
mock.ANY, 'cr-buildbucket.appspot.com', 'SearchBuilds',
self._DEFAULT_REQUEST)
mockJsonDump.assert_called_once_with('file.json',
self._DEFAULT_RESPONSE['builds'])
def test_filter_failed_for_one_simple(self):
self.assertEqual([], git_cl._filter_failed_for_retry([]))
self.assertEqual([
('chromium', 'try', 'bot_failure'),
('chromium', 'try', 'bot_infra_failure'),
], git_cl._filter_failed_for_retry(self._DEFAULT_RESPONSE['builds']))
def test_filter_failed_for_retry_many_builds(self):
def _build(name, created_sec, status, experimental=False):
assert 0 <= created_sec < 100, created_sec
b = {
'id': 112112,
'builder': {
'project': 'chromium',
'bucket': 'try',
'builder': name,
},
'createTime': '2019-10-09T08:00:%02d.854286Z' % created_sec,
'status': status,
'tags': [],
}
if experimental:
b['tags'].append({'key': 'cq_experimental', 'value': 'true'})
return b
builds = [
_build('flaky-last-green', 1, 'FAILURE'),
_build('flaky-last-green', 2, 'SUCCESS'),
_build('flaky', 1, 'SUCCESS'),
_build('flaky', 2, 'FAILURE'),
_build('running', 1, 'FAILED'),
_build('running', 2, 'SCHEDULED'),
_build('yep-still-running', 1, 'STARTED'),
_build('yep-still-running', 2, 'FAILURE'),
_build('cq-experimental', 1, 'SUCCESS', experimental=True),
_build('cq-experimental', 2, 'FAILURE', experimental=True),
# Simulate experimental in CQ builder, which developer decided
# to retry manually which resulted in 2nd build non-experimental.
_build('sometimes-experimental', 1, 'FAILURE', experimental=True),
_build('sometimes-experimental', 2, 'FAILURE', experimental=False),
]
builds.sort(key=lambda b: b['status']) # ~deterministic shuffle.
self.assertEqual([
('chromium', 'try', 'flaky'),
('chromium', 'try', 'sometimes-experimental'),
], git_cl._filter_failed_for_retry(builds))
class CMDTryTestCase(CMDTestCaseBase):
@unittest.skipIf(gclient_utils.IsEnvCog(),
'not supported in non-git environment')
@mock.patch('git_cl.Changelist.SetCQState')
def testSetCQDryRunByDefault(self, mockSetCQState):
mockSetCQState.return_value = 0
self.assertEqual(0, git_cl.main(['try']))
git_cl.Changelist.SetCQState.assert_called_with(git_cl._CQState.DRY_RUN)
self.assertEqual(
sys.stdout.getvalue(), 'Scheduling CQ dry run on: '
'https://chromium-review.googlesource.com/123456\n')
@unittest.skipIf(gclient_utils.IsEnvCog(),
'not supported in non-git environment')
@mock.patch('git_cl._call_buildbucket')
def testScheduleOnBuildbucket(self, mockCallBuildbucket):
mockCallBuildbucket.return_value = {}
self.assertEqual(
0,
git_cl.main([
'try', '-B', 'luci.chromium.try', '-b', 'win', '-p', 'key=val',
'-p', 'json=[{"a":1}, null]'
]))
self.assertIn('Scheduling jobs on:\n'
' chromium/try: win', git_cl.sys.stdout.getvalue())
expected_request = {
"requests": [{
"scheduleBuild": {
"requestId":
"uuid4",
"builder": {
"project": "chromium",
"builder": "win",
"bucket": "try",
},
"gerritChanges": [{
"project": "depot_tools",
"host": "chromium-review.googlesource.com",
"patchset": 7,
"change": 123456,
}],
"properties": {
"category": "git_cl_try",
"json": [{
"a": 1
}, None],
"key": "val",
},
"tags": [
{
"value": "win",
"key": "builder"
},
{
"value": "git_cl_try",
"key": "user_agent"
},
],
},
}],
}
mockCallBuildbucket.assert_called_with(mock.ANY,
'cr-buildbucket.appspot.com',
'Batch', expected_request)
@unittest.skipIf(gclient_utils.IsEnvCog(),
'not supported in non-git environment')
@mock.patch('git_cl._call_buildbucket')
def testScheduleOnBuildbucketWithRevision(self, mockCallBuildbucket):
mockCallBuildbucket.return_value = {}
mock.patch('git_cl.Changelist.GetRemoteBranch',
return_value=('origin', 'refs/remotes/origin/main')).start()
self.assertEqual(
0,
git_cl.main([
'try', '-B', 'luci.chromium.try', '-b', 'win', '-b', 'linux',
'-p', 'key=val', '-p', 'json=[{"a":1}, null]', '-r',
'beeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeef'
]))
self.assertIn(
'Scheduling jobs on:\n'
' chromium/try: linux\n'
' chromium/try: win', git_cl.sys.stdout.getvalue())
expected_request = {
"requests": [{
"scheduleBuild": {
"requestId":
"uuid4",
"builder": {
"project": "chromium",
"builder": "linux",
"bucket": "try",
},
"gerritChanges": [{
"project": "depot_tools",
"host": "chromium-review.googlesource.com",
"patchset": 7,
"change": 123456,
}],
"properties": {
"category": "git_cl_try",
"json": [{
"a": 1
}, None],
"key": "val",
},
"tags": [
{
"value": "linux",
"key": "builder"
},
{
"value": "git_cl_try",
"key": "user_agent"
},
],
"gitilesCommit": {
"host": "chromium.googlesource.com",
"project": "depot_tools",
"id": "beeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeef",
"ref": "refs/heads/main",
}
},
}, {
"scheduleBuild": {
"requestId":
"uuid4",
"builder": {
"project": "chromium",
"builder": "win",
"bucket": "try",
},
"gerritChanges": [{
"project": "depot_tools",
"host": "chromium-review.googlesource.com",
"patchset": 7,
"change": 123456,
}],
"properties": {
"category": "git_cl_try",
"json": [{
"a": 1
}, None],
"key": "val",
},
"tags": [
{
"value": "win",
"key": "builder"
},
{
"value": "git_cl_try",
"key": "user_agent"
},
],
"gitilesCommit": {
"host": "chromium.googlesource.com",
"project": "depot_tools",
"id": "beeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeef",
"ref": "refs/heads/main",
}
},
}],
}
mockCallBuildbucket.assert_called_with(mock.ANY,
'cr-buildbucket.appspot.com',
'Batch', expected_request)
@unittest.skipIf(gclient_utils.IsEnvCog(),
'not supported in non-git environment')
@mock.patch('sys.stderr', io.StringIO())
def testScheduleOnBuildbucket_WrongBucket(self):
with self.assertRaises(SystemExit):
git_cl.main([
'try', '-B', 'not-a-bucket', '-b', 'win', '-p', 'key=val', '-p',
'json=[{"a":1}, null]'
])
self.assertIn('Invalid bucket: not-a-bucket.', sys.stderr.getvalue())
@unittest.skipIf(gclient_utils.IsEnvCog(),
'not supported in non-git environment')
@mock.patch('git_cl._call_buildbucket')
@mock.patch('git_cl._fetch_tryjobs')
def testScheduleOnBuildbucketRetryFailed(self, mockFetchTryJobs,
mockCallBuildbucket):
git_cl._fetch_tryjobs.side_effect = lambda *_, **kw: {
7: [],
6: [{
'id': 112112,
'builder': {
'project': 'chromium',
'bucket': 'try',
'builder': 'linux',
},
'createTime': '2019-10-09T08:00:01.854286Z',
'tags': [],
'status': 'FAILURE',
}],
}[kw['patchset']]
mockCallBuildbucket.return_value = {}
self.assertEqual(0, git_cl.main(['try', '--retry-failed']))
self.assertIn('Scheduling jobs on:\n'
' chromium/try: linux', git_cl.sys.stdout.getvalue())
expected_request = {
"requests": [{
"scheduleBuild": {
"requestId":
"uuid4",
"builder": {
"project": "chromium",
"bucket": "try",
"builder": "linux",
},
"gerritChanges": [{
"project": "depot_tools",
"host": "chromium-review.googlesource.com",
"patchset": 7,
"change": 123456,
}],
"properties": {
"category": "git_cl_try",
},
"tags": [
{
"value": "linux",
"key": "builder"
},
{
"value": "git_cl_try",
"key": "user_agent"
},
{
"value": "1",
"key": "retry_failed"
},
],
},
}],
}
mockCallBuildbucket.assert_called_with(mock.ANY,
'cr-buildbucket.appspot.com',
'Batch', expected_request)
def test_parse_bucket(self):
test_cases = [
{
'bucket': 'chromium/try',
'result': ('chromium', 'try'),
},
{
'bucket': 'luci.chromium.try',
'result': ('chromium', 'try'),
'has_warning': True,
},
{
'bucket': 'skia.primary',
'result': ('skia', 'skia.primary'),
'has_warning': True,
},
{
'bucket': 'not-a-bucket',
'result': (None, None),
},
]
for test_case in test_cases:
git_cl.sys.stdout.truncate(0)
self.assertEqual(test_case['result'],
git_cl._parse_bucket(test_case['bucket']))
if test_case.get('has_warning'):
expected_warning = 'WARNING Please use %s/%s to specify the bucket' % (
test_case['result'])
self.assertIn(expected_warning, git_cl.sys.stdout.getvalue())
class CMDUploadTestCase(CMDTestCaseBase):
def setUp(self):
super(CMDUploadTestCase, self).setUp()
mock.patch('git_cl._fetch_tryjobs').start()
mock.patch('git_cl._trigger_tryjobs', return_value={}).start()
mock.patch('git_cl.Changelist.CMDUpload', return_value=0).start()
mock.patch('git_cl.Settings.GetRoot', return_value='').start()
mock.patch('git_cl.Settings.GetSquashGerritUploads',
return_value=True).start()
self.addCleanup(mock.patch.stopall)
class MakeRequestsHelperTestCase(unittest.TestCase):
def exampleGerritChange(self):
return {
'host': 'chromium-review.googlesource.com',
'project': 'depot_tools',
'change': 1,
'patchset': 2,
}
def testMakeRequestsHelperNoOptions(self):
# Basic test for the helper function _make_tryjob_schedule_requests;
# it shouldn't throw AttributeError even when options doesn't have any
# of the expected values; it will use default option values.
changelist = ChangelistMock(gerrit_change=self.exampleGerritChange())
jobs = [('chromium', 'try', 'my-builder')]
options = optparse.Values()
requests = git_cl._make_tryjob_schedule_requests(changelist,
jobs,
options,
patchset=None)
# requestId is non-deterministic. Just assert that it's there and has
# a particular length.
self.assertEqual(len(requests[0]['scheduleBuild'].pop('requestId')), 36)
self.assertEqual(requests, [{
'scheduleBuild': {
'builder': {
'bucket': 'try',
'builder': 'my-builder',
'project': 'chromium'
},
'gerritChanges': [self.exampleGerritChange()],
'properties': {
'category': 'git_cl_try'
},
'tags': [{
'key': 'builder',
'value': 'my-builder'
}, {
'key': 'user_agent',
'value': 'git_cl_try'
}]
}
}])
def testMakeRequestsHelperPresubmitSetsDryRunProperty(self):
changelist = ChangelistMock(gerrit_change=self.exampleGerritChange())
jobs = [('chromium', 'try', 'presubmit')]
options = optparse.Values()
requests = git_cl._make_tryjob_schedule_requests(changelist,
jobs,
options,
patchset=None)
self.assertEqual(requests[0]['scheduleBuild']['properties'], {
'category': 'git_cl_try',
'dry_run': 'true'
})
def testMakeRequestsHelperRevisionSet(self):
# Gitiles commit is specified when revision is in options.
changelist = ChangelistMock(gerrit_change=self.exampleGerritChange())
jobs = [('chromium', 'try', 'my-builder')]
options = optparse.Values({'revision': 'ba5eba11'})
requests = git_cl._make_tryjob_schedule_requests(changelist,
jobs,
options,
patchset=None)
self.assertEqual(
requests[0]['scheduleBuild']['gitilesCommit'], {
'host': 'chromium.googlesource.com',
'id': 'ba5eba11',
'project': 'depot_tools',
'ref': 'refs/heads/main',
})
def testMakeRequestsHelperRetryFailedSet(self):
# An extra tag is added when retry_failed is in options.
changelist = ChangelistMock(gerrit_change=self.exampleGerritChange())
jobs = [('chromium', 'try', 'my-builder')]
options = optparse.Values({'retry_failed': 'true'})
requests = git_cl._make_tryjob_schedule_requests(changelist,
jobs,
options,
patchset=None)
self.assertEqual(requests[0]['scheduleBuild']['tags'],
[{
'key': 'builder',
'value': 'my-builder'
}, {
'key': 'user_agent',
'value': 'git_cl_try'
}, {
'key': 'retry_failed',
'value': '1'
}])
def testMakeRequestsHelperCategorySet(self):
# The category property can be overridden with options.
changelist = ChangelistMock(gerrit_change=self.exampleGerritChange())
jobs = [('chromium', 'try', 'my-builder')]
options = optparse.Values({'category': 'my-special-category'})
requests = git_cl._make_tryjob_schedule_requests(changelist,
jobs,
options,
patchset=None)
self.assertEqual(requests[0]['scheduleBuild']['properties'],
{'category': 'my-special-category'})
class CMDFormatTestCase(unittest.TestCase):
def setUp(self):
super(CMDFormatTestCase, self).setUp()
mock.patch('git_cl.RunCommand').start()
mock.patch('clang_format.FindClangFormatToolInChromiumTree').start()
mock.patch('clang_format.FindClangFormatScriptInChromiumTree').start()
mock.patch('git_cl.settings').start()
self._top_dir = tempfile.mkdtemp()
self.addCleanup(mock.patch.stopall)
def tearDown(self):
shutil.rmtree(self._top_dir)
super(CMDFormatTestCase, self).tearDown()
def _make_temp_file(self, fname, contents):
gclient_utils.FileWrite(os.path.join(self._top_dir, fname),
('\n'.join(contents)))
def _make_yapfignore(self, contents):
self._make_temp_file('.yapfignore', contents)
def _check_yapf_filtering(self, files, expected):
self.assertEqual(
expected,
git_cl._FilterYapfIgnoredFiles(
files, git_cl._GetYapfIgnorePatterns(self._top_dir)))
def _run_command_mock(self, return_value):
def f(*args, **kwargs):
if 'stdin' in kwargs:
self.assertIsInstance(kwargs['stdin'], bytes)
return return_value
return f
def testClangFormatDiffFull(self):
self._make_temp_file('test.cc', ['// test'])
git_cl.settings.GetFormatFullByDefault.return_value = False
diff_file = [os.path.join(self._top_dir, 'test.cc')]
mock_opts = mock.Mock(full=True, dry_run=True, diff=False)
# Diff
git_cl.RunCommand.side_effect = self._run_command_mock(' // test')
return_value = git_cl._RunClangFormatDiff(mock_opts, diff_file,
self._top_dir, 'HEAD')
self.assertEqual(2, return_value)
# No diff
git_cl.RunCommand.side_effect = self._run_command_mock('// test')
return_value = git_cl._RunClangFormatDiff(mock_opts, diff_file,
self._top_dir, 'HEAD')
self.assertEqual(0, return_value)
def testClangFormatDiff(self):
git_cl.settings.GetFormatFullByDefault.return_value = False
# A valid file is required, so use this test.
clang_format.FindClangFormatToolInChromiumTree.return_value = __file__
mock_opts = mock.Mock(full=False, dry_run=True, diff=False)
# Diff
git_cl.RunCommand.side_effect = self._run_command_mock('error')
return_value = git_cl._RunClangFormatDiff(mock_opts, ['.'],
self._top_dir, 'HEAD')
self.assertEqual(2, return_value)
# No diff
git_cl.RunCommand.side_effect = self._run_command_mock('')
return_value = git_cl._RunClangFormatDiff(mock_opts, ['.'],
self._top_dir, 'HEAD')
self.assertEqual(0, return_value)
def testYapfignoreExplicit(self):
self._make_yapfignore(['foo/bar.py', 'foo/bar/baz.py'])
files = [
'bar.py',
'foo/bar.py',
'foo/baz.py',
'foo/bar/baz.py',
'foo/bar/foobar.py',
]
expected = [
'bar.py',
'foo/baz.py',
'foo/bar/foobar.py',
]
self._check_yapf_filtering(files, expected)
def testYapfignoreSingleWildcards(self):
self._make_yapfignore(['*bar.py', 'foo*', 'baz*.py'])
files = [
'bar.py', # Matched by *bar.py.
'bar.txt',
'foobar.py', # Matched by *bar.py, foo*.
'foobar.txt', # Matched by foo*.
'bazbar.py', # Matched by *bar.py, baz*.py.
'bazbar.txt',
'foo/baz.txt', # Matched by foo*.
'bar/bar.py', # Matched by *bar.py.
'baz/foo.py', # Matched by baz*.py, foo*.
'baz/foo.txt',
]
expected = [
'bar.txt',
'bazbar.txt',
'baz/foo.txt',
]
self._check_yapf_filtering(files, expected)
def testYapfignoreMultiplewildcards(self):
self._make_yapfignore(['*bar*', '*foo*baz.txt'])
files = [
'bar.py', # Matched by *bar*.
'bar.txt', # Matched by *bar*.
'abar.py', # Matched by *bar*.
'foobaz.txt', # Matched by *foo*baz.txt.
'foobaz.py',
'afoobaz.txt', # Matched by *foo*baz.txt.
]
expected = [
'foobaz.py',
]
self._check_yapf_filtering(files, expected)
def testYapfignoreComments(self):
self._make_yapfignore(['test.py', '#test2.py'])
files = [
'test.py',
'test2.py',
]
expected = [
'test2.py',
]
self._check_yapf_filtering(files, expected)
def testYapfHandleUtf8(self):
self._make_yapfignore(['test.py', 'test_🌐.py'])
files = [
'test.py',
'test_🌐.py',
'test2.py',
]
expected = [
'test2.py',
]
self._check_yapf_filtering(files, expected)
def testYapfignoreBlankLines(self):
self._make_yapfignore(['test.py', '', '', 'test2.py'])
files = [
'test.py',
'test2.py',
'test3.py',
]
expected = [
'test3.py',
]
self._check_yapf_filtering(files, expected)
def testYapfignoreWhitespace(self):
self._make_yapfignore([' test.py '])
files = [
'test.py',
'test2.py',
]
expected = [
'test2.py',
]
self._check_yapf_filtering(files, expected)
def testYapfignoreNoFiles(self):
self._make_yapfignore(['test.py'])
self._check_yapf_filtering([], [])
def testYapfignoreMissingYapfignore(self):
files = [
'test.py',
]
expected = [
'test.py',
]
self._check_yapf_filtering(files, expected)
@mock.patch('gclient_paths.GetPrimarySolutionPath')
def testRunMetricsXMLFormatSkipIfPresubmit(self, find_top_dir):
"""Verifies that it skips the formatting if opts.presubmit is True."""
find_top_dir.return_value = self._top_dir
mock_opts = mock.Mock(full=True,
dry_run=True,
diff=False,
presubmit=True)
files = [
os.path.join(self._top_dir, 'tools', 'metrics', 'ukm', 'ukm.xml'),
]
return_value = git_cl._RunMetricsXMLFormat(mock_opts, files,
self._top_dir, 'HEAD')
git_cl.RunCommand.assert_not_called()
self.assertEqual(0, return_value)
@mock.patch('gclient_paths.GetPrimarySolutionPath')
def testRunMetricsFormatWithUkm(self, find_top_dir):
"""Checks if the command line arguments do not contain the input path.
"""
find_top_dir.return_value = self._top_dir
mock_opts = mock.Mock(full=True,
dry_run=False,
diff=False,
presubmit=False)
files = [
os.path.join(self._top_dir, 'tools', 'metrics', 'ukm', 'ukm.xml'),
]
git_cl._RunMetricsXMLFormat(mock_opts, files, self._top_dir, 'HEAD')
git_cl.RunCommand.assert_called_with([
mock.ANY,
os.path.join(self._top_dir, 'tools', 'metrics', 'ukm',
'pretty_print.py'),
'--non-interactive',
],
cwd=self._top_dir)
@mock.patch('gclient_paths.GetPrimarySolutionPath')
def testRunMetricsFormatWithHistograms(self, find_top_dir):
"""Checks if the command line arguments contain the input file paths."""
find_top_dir.return_value = self._top_dir
mock_opts = mock.Mock(full=True,
dry_run=False,
diff=False,
presubmit=False)
files = [
os.path.join(self._top_dir, 'tools', 'metrics', 'histograms',
'enums.xml'),
os.path.join(self._top_dir, 'tools', 'metrics', 'histograms',
'test_data', 'enums.xml'),
]
git_cl._RunMetricsXMLFormat(mock_opts, files, self._top_dir, 'HEAD')
pretty_print_path = os.path.join(self._top_dir, 'tools', 'metrics',
'histograms', 'pretty_print.py')
git_cl.RunCommand.assert_has_calls([
mock.call(
[mock.ANY, pretty_print_path, '--non-interactive', files[0]],
cwd=self._top_dir),
mock.call(
[mock.ANY, pretty_print_path, '--non-interactive', files[1]],
cwd=self._top_dir),
])
@mock.patch('subprocess2.call')
def testLUCICfgFormatWorks(self, mock_call):
"""Checks if lucicfg is given then input file path."""
mock_opts = mock.Mock(dry_run=False)
files = ['test/main.star']
mock_call.return_value = 0
ret = git_cl._RunLUCICfgFormat(mock_opts, files, self._top_dir, 'HEAD')
mock_call.assert_called_with([
mock.ANY,
'fmt',
'test/main.star',
])
self.assertEqual(ret, 0)
@mock.patch('subprocess2.call')
def testLUCICfgFormatWithDryRun(self, mock_call):
"""Tests the command with --dry-run."""
mock_opts = mock.Mock(dry_run=True)
files = ['test/main.star']
git_cl._RunLUCICfgFormat(mock_opts, files, self._top_dir, 'HEAD')
mock_call.assert_called_with([
mock.ANY,
'fmt',
'--dry-run',
'test/main.star',
])
@mock.patch('subprocess2.call')
def testLUCICfgFormatWithDryRunReturnCode(self, mock_call):
"""Tests that it returns 2 for non-zero exit codes."""
mock_opts = mock.Mock(dry_run=True)
files = ['test/main.star']
run = git_cl._RunLUCICfgFormat
mock_call.return_value = 0
self.assertEqual(run(mock_opts, files, self._top_dir, 'HEAD'), 0)
mock_call.return_value = 1
self.assertEqual(run(mock_opts, files, self._top_dir, 'HEAD'), 2)
mock_call.return_value = 2
self.assertEqual(run(mock_opts, files, self._top_dir, 'HEAD'), 2)
mock_call.return_value = 255
self.assertEqual(run(mock_opts, files, self._top_dir, 'HEAD'), 2)
@unittest.skipIf(gclient_utils.IsEnvCog(),
'not supported in non-git environment')
class CMDStatusTestCase(CMDTestCaseBase):
# Return branch names a,..,f with comitterdates in increasing order, i.e.
# 'f' is the most-recently changed branch.
def _mock_run_git(commands):
if commands == [
'for-each-ref', '--format=%(refname) %(committerdate:unix)',
'refs/heads'
]:
branches_and_committerdates = [
'refs/heads/a 1',
'refs/heads/b 2',
'refs/heads/c 3',
'refs/heads/d 4',
'refs/heads/e 5',
'refs/heads/f 6',
]
return '\n'.join(branches_and_committerdates)
# Mock the status in such a way that the issue number gives us an
# indication of the commit date (simplifies manual debugging).
def _mock_get_cl_statuses(branches, fine_grained, max_processes):
for c in branches:
c.issue = (100 + int(c.GetCommitDate()))
yield (c, 'open')
@mock.patch('git_cl.Changelist.EnsureAuthenticated')
@mock.patch('git_cl.Changelist.FetchDescription', lambda cl, pretty: 'x')
@mock.patch('git_cl.Changelist.GetIssue', lambda cl: cl.issue)
@mock.patch('git_cl.RunGit', _mock_run_git)
@mock.patch('git_cl.get_cl_statuses', _mock_get_cl_statuses)
@mock.patch('git_cl.Settings.GetRoot', return_value='')
@mock.patch('git_cl.Settings.IsStatusCommitOrderByDate', return_value=False)
@mock.patch('scm.GIT.GetBranch', return_value='a')
def testStatus(self, *_mocks):
self.assertEqual(0, git_cl.main(['status', '--no-branch-color']))
self.maxDiff = None
self.assertEqual(
sys.stdout.getvalue(), 'Branches associated with reviews:\n'
' * a : https://crrev.com/c/101 (open)\n'
' b : https://crrev.com/c/102 (open)\n'
' c : https://crrev.com/c/103 (open)\n'
' d : https://crrev.com/c/104 (open)\n'
' e : https://crrev.com/c/105 (open)\n'
' f : https://crrev.com/c/106 (open)\n\n'
'Current branch: a\n'
'Issue number: 101 (https://chromium-review.googlesource.com/101)\n'
'Issue description:\n'
'x\n')
@mock.patch('git_cl.Changelist.EnsureAuthenticated')
@mock.patch('git_cl.Changelist.FetchDescription', lambda cl, pretty: 'x')
@mock.patch('git_cl.Changelist.GetIssue', lambda cl: cl.issue)
@mock.patch('git_cl.RunGit', _mock_run_git)
@mock.patch('git_cl.get_cl_statuses', _mock_get_cl_statuses)
@mock.patch('git_cl.Settings.GetRoot', return_value='')
@mock.patch('git_cl.Settings.IsStatusCommitOrderByDate', return_value=False)
@mock.patch('scm.GIT.GetBranch', return_value='a')
def testStatusByDate(self, *_mocks):
self.assertEqual(
0, git_cl.main(['status', '--no-branch-color', '--date-order']))
self.maxDiff = None
self.assertEqual(
sys.stdout.getvalue(), 'Branches associated with reviews:\n'
' f : https://crrev.com/c/106 (open)\n'
' e : https://crrev.com/c/105 (open)\n'
' d : https://crrev.com/c/104 (open)\n'
' c : https://crrev.com/c/103 (open)\n'
' b : https://crrev.com/c/102 (open)\n'
' * a : https://crrev.com/c/101 (open)\n\n'
'Current branch: a\n'
'Issue number: 101 (https://chromium-review.googlesource.com/101)\n'
'Issue description:\n'
'x\n')
@mock.patch('git_cl.Changelist.EnsureAuthenticated')
@mock.patch('git_cl.Changelist.FetchDescription', lambda cl, pretty: 'x')
@mock.patch('git_cl.Changelist.GetIssue', lambda cl: cl.issue)
@mock.patch('git_cl.RunGit', _mock_run_git)
@mock.patch('git_cl.get_cl_statuses', _mock_get_cl_statuses)
@mock.patch('git_cl.Settings.GetRoot', return_value='')
@mock.patch('git_cl.Settings.IsStatusCommitOrderByDate', return_value=True)
@mock.patch('scm.GIT.GetBranch', return_value='a')
def testStatusByDate(self, *_mocks):
self.assertEqual(0, git_cl.main(['status', '--no-branch-color']))
self.maxDiff = None
self.assertEqual(
sys.stdout.getvalue(), 'Branches associated with reviews:\n'
' f : https://crrev.com/c/106 (open)\n'
' e : https://crrev.com/c/105 (open)\n'
' d : https://crrev.com/c/104 (open)\n'
' c : https://crrev.com/c/103 (open)\n'
' b : https://crrev.com/c/102 (open)\n'
' * a : https://crrev.com/c/101 (open)\n\n'
'Current branch: a\n'
'Issue number: 101 (https://chromium-review.googlesource.com/101)\n'
'Issue description:\n'
'x\n')
@unittest.skipIf(gclient_utils.IsEnvCog(),
'not supported in non-git environment')
class CMDOwnersTestCase(CMDTestCaseBase):
def setUp(self):
super(CMDOwnersTestCase, self).setUp()
self.owners_by_path = {
'foo': ['a@example.com'],
'bar': ['b@example.com', 'c@example.com'],
}
mock.patch('git_cl.Settings.GetRoot', return_value='root').start()
mock.patch('git_cl.Changelist.GetAuthor', return_value='author').start()
mock.patch('git_cl.Changelist.GetAffectedFiles',
return_value=list(self.owners_by_path)).start()
mock.patch('git_cl.Changelist.GetCommonAncestorWithUpstream',
return_value='upstream').start()
mock.patch('git_cl.Changelist.GetGerritHost',
return_value='host').start()
mock.patch('git_cl.Changelist.GetGerritProject',
return_value='project').start()
mock.patch('git_cl.Changelist.GetRemoteBranch',
return_value=('origin', 'refs/remotes/origin/main')).start()
mock.patch('owners_client.OwnersClient.BatchListOwners',
return_value=self.owners_by_path).start()
mock.patch('gerrit_util.IsCodeOwnersEnabledOnHost',
return_value=True).start()
self.addCleanup(mock.patch.stopall)
def testShowAllNoArgs(self):
self.assertEqual(0, git_cl.main(['owners', '--show-all']))
self.assertEqual('No files specified for --show-all. Nothing to do.\n',
git_cl.sys.stdout.getvalue())
def testShowAll(self):
self.assertEqual(
0, git_cl.main(['owners', '--show-all', 'foo', 'bar', 'baz']))
owners_client.OwnersClient.BatchListOwners.assert_called_once_with(
['foo', 'bar', 'baz'])
self.assertEqual(
'\n'.join([
'Owners for foo:',
' - a@example.com',
'Owners for bar:',
' - b@example.com',
' - c@example.com',
'Owners for baz:',
' - No owners found',
'',
]), sys.stdout.getvalue())
def testBatch(self):
self.assertEqual(0, git_cl.main(['owners', '--batch']))
self.assertIn('a@example.com', sys.stdout.getvalue())
self.assertIn('b@example.com', sys.stdout.getvalue())
class CMDLintTestCase(CMDTestCaseBase):
bad_indent = '\n'.join([
'// Copyright 1999 <a@example.com>',
'namespace foo {',
' class a;',
'}',
'',
])
filesInCL = ['foo', 'bar']
def setUp(self):
super(CMDLintTestCase, self).setUp()
mock.patch('git_cl.sys.stderr', io.StringIO()).start()
mock.patch('codecs.open', mock.mock_open()).start()
mock.patch('os.path.isfile', return_value=True).start()
def testLintSingleFile(self, *_mock):
codecs.open().read.return_value = self.bad_indent
self.assertEqual(1, git_cl.main(['lint', 'pdf.h']))
self.assertIn('pdf.h:3: (cpplint) Do not indent within a namespace',
git_cl.sys.stderr.getvalue())
def testLintMultiFiles(self, *_mock):
codecs.open().read.return_value = self.bad_indent
self.assertEqual(1, git_cl.main(['lint', 'pdf.h', 'pdf.cc']))
self.assertIn('pdf.h:3: (cpplint) Do not indent within a namespace',
git_cl.sys.stderr.getvalue())
self.assertIn('pdf.cc:3: (cpplint) Do not indent within a namespace',
git_cl.sys.stderr.getvalue())
@unittest.skipIf(gclient_utils.IsEnvCog(),
'not supported in non-git environment')
@mock.patch('git_cl.Changelist.GetAffectedFiles',
return_value=['chg-1.h', 'chg-2.cc'])
@mock.patch('git_cl.Changelist.GetCommonAncestorWithUpstream',
return_value='upstream')
@mock.patch('git_cl.Settings.GetRoot', return_value='.')
@mock.patch('git_cl.FindCodereviewSettingsFile', return_value=None)
def testLintChangelist(self, *_mock):
codecs.open().read.return_value = self.bad_indent
self.assertEqual(1, git_cl.main(['lint']))
self.assertIn('chg-1.h:3: (cpplint) Do not indent within a namespace',
git_cl.sys.stderr.getvalue())
self.assertIn('chg-2.cc:3: (cpplint) Do not indent within a namespace',
git_cl.sys.stderr.getvalue())
class CMDCherryPickTestCase(CMDTestCaseBase):
def setUp(self):
super(CMDTestCaseBase, self).setUp()
def testCreateCommitMessage(self):
orig_message = """Foo the bar
This change foo's the bar.
Bug: 123456
Change-Id: I25699146b24c7ad8776f17775f489b9d41499595
"""
expected_message = """Cherry pick "Foo the bar"
Original change's description:
> Foo the bar
>
> This change foo's the bar.
>
> Bug: 123456
> Change-Id: I25699146b24c7ad8776f17775f489b9d41499595
Change-Id: I25699146b24c7ad8776f17775f489b9d41499595
"""
self.assertEqual(git_cl._create_commit_message(orig_message),
expected_message)
def testCreateCommitMessageWithBug(self):
bug = "987654"
orig_message = """Foo the bar
This change foo's the bar.
Bug: 123456
Change-Id: I25699146b24c7ad8776f17775f489b9d41499595
"""
expected_message = f"""Cherry pick "Foo the bar"
Original change's description:
> Foo the bar
>
> This change foo's the bar.
>
> Bug: 123456
> Change-Id: I25699146b24c7ad8776f17775f489b9d41499595
Bug: {bug}
Change-Id: I25699146b24c7ad8776f17775f489b9d41499595
"""
self.assertEqual(git_cl._create_commit_message(orig_message, bug),
expected_message)
@unittest.skipIf(gclient_utils.IsEnvCog(),
'not supported in non-git environment')
class CMDSplitTestCase(CMDTestCaseBase):
def setUp(self):
super(CMDTestCaseBase, self).setUp()
self.mock_get_root = mock.patch('git_cl.Settings.GetRoot',
return_value='root').start()
self.mock_split_cl = mock.patch("split_cl.SplitCl",
return_value=0).start()
self.mock_parser_error = mock.patch(
"git_cl.OptionParser.error", side_effect=ParserErrorMock).start()
def testDescriptionFlagRequired(self):
# --description-file is mandatory...
self.assertRaises(ParserErrorMock, git_cl.main, ['split'])
self.assertEqual(self.mock_split_cl.call_count, 0)
self.assertEqual(git_cl.main(['split', '--description=SomeFile.txt']),
0)
self.assertEqual(self.mock_split_cl.call_count, 1)
# ...unless we're doing a dry run
self.mock_split_cl.reset_mock()
self.assertEqual(git_cl.main(['split', '-n']), 0)
self.assertEqual(self.mock_split_cl.call_count, 1)
def testReviewerParsing(self):
"""Make sure we correctly parse various combinations of --reviewers"""
# Helper function to pull out the reviewers arg and compare it
def testOneSetOfFlags(flags, expected):
self.assertEqual(git_cl.main(['split', '-n'] + flags), 0)
self.mock_split_cl.assert_called_once()
# It's unfortunate that there's no better way to get the argument
# than to hardcode its number, unless we switch to using keyword
# arguments everywhere or pass the options in directly.
reviewers_arg = self.mock_split_cl.call_args.args[6]
self.assertEqual(reviewers_arg, expected)
self.mock_split_cl.reset_mock()
# If no --reviewers flag is passed, we should get None
testOneSetOfFlags([], None)
# If --reviewers flag is passed, we should get a list of args
testOneSetOfFlags(['--reviewers', 'a@b.com'], ['a@b.com'])
testOneSetOfFlags(['--reviewers', 'a@b.com', '--reviewers', 'c@d.com'],
['a@b.com', 'c@d.com'])
# If --no-reviewers flag is passed, we should always get an empty list
testOneSetOfFlags(['--no-reviewers'], [])
testOneSetOfFlags(['--reviewers', 'a@b.com', '--no-reviewers'], [])
def testTargetRangeParsing(self):
# Helper function to pull out the target_range arg and compare it
def testOneSetOfFlags(flags, expected):
self.assertEqual(git_cl.main(['split', '-n'] + flags), 0)
self.mock_split_cl.assert_called_once()
# It's unfortunate that there's no better way to get the argument
# than to hardcode its number, unless we switch to using keyword
# arguments everywhere or pass the options in directly.
target_range = self.mock_split_cl.call_args.args[11]
self.assertEqual(target_range, expected)
self.mock_split_cl.reset_mock()
def ensureFailure(flags):
self.assertRaises(ParserErrorMock, git_cl.main,
(['split', '-n'] + flags))
testOneSetOfFlags([], None)
testOneSetOfFlags(["--target-range", "3", "5"], (3, 5))
testOneSetOfFlags(["--target-range", "3", "3"], (3, 3))
# Can't have second arg larger than first
ensureFailure(["--target-range", "5", "3"])
# Need exactly two args
ensureFailure(["--target-range"])
ensureFailure(["--target-range", "5"])
# Only accepts int args
ensureFailure(["--target-range", "5", "six"])
if __name__ == '__main__':
logging.basicConfig(
level=logging.DEBUG if '-v' in sys.argv else logging.ERROR)
unittest.main()