def process_pull_request(user, repo, number, lintrc):
"""
Starts processing a pull request and running the various
lint tools against it.
"""
log.info('Starting to process lint for %s/%s/%s', user, repo, number)
log.debug("lintrc contents '%s'", lintrc)
review_config = ReviewConfig(lintrc)
if len(review_config.linters()) == 0:
log.info('No configured linters, skipping processing.')
return
gh = github.get_client(config, user, repo)
try:
log.info('Loading pull request data from github.')
pull_request = gh.pull_requests.get(number)
head_repo = pull_request.head['repo']['git_url']
pr_head = pull_request.head['sha']
# Clone/Update repository
target_path = git.get_repo_path(user, repo, number, config)
git.clone_or_update(head_repo, target_path, pr_head)
processor = Processor(gh, number, pr_head, target_path, config)
processor.load_changes()
processor.run_tools(review_config)
processor.publish()
log.info('Completed lint processing for %s/%s/%s' %
(user, repo, number))
except BaseException, e:
log.exception(e)
def process_pull_request(user, repo, number, lintrc):
"""
Starts processing a pull request and running the various
lint tools against it.
"""
log.info('Starting to process lint for %s/%s/%s', user, repo, number)
log.debug("lintrc contents '%s'", lintrc)
review_config = ReviewConfig(lintrc)
if len(review_config.linters()) == 0:
log.info('No configured linters, skipping processing.')
return
gh = github.get_client(config, user, repo)
try:
log.info('Loading pull request data from github.')
pull_request = gh.pull_requests.get(number)
head_repo = pull_request.head['repo']['clone_url']
private_repo = pull_request.head['repo']['private']
pr_head = pull_request.head['sha']
# Clone/Update repository
target_path = git.get_repo_path(user, repo, number, config)
git.clone_or_update(config, head_repo, target_path, pr_head,
private_repo)
processor = Processor(gh, number, pr_head, target_path, config)
processor.load_changes()
processor.run_tools(review_config)
processor.publish()
log.info('Completed lint processing for %s/%s/%s' % (
user, repo, number))
except BaseException, e:
log.exception(e)
def process_pull_request(self, user, repo_name, number, lintrc):
"""
Starts processing a pull request and running the various
lint tools against it.
"""
log.info('Starting to process lint for %s/%s/%s', user, repo_name, number)
log.debug("lintrc contents '%s'", lintrc)
review_config = build_review_config(lintrc, deepcopy(config))
if len(review_config.linters()) == 0:
log.info('No configured linters, skipping processing.')
return
try:
log.info(
'Loading pull request data from github. user=%s '
'repo=%s number=%s', user, repo_name, number)
repo = GithubRepository(config, user, repo_name)
pull_request = repo.pull_request(number)
clone_url = pull_request.clone_url
pr_head = pull_request.head
target_branch = pull_request.target_branch
if target_branch in review_config.ignore_branches():
log.info('Pull request into ignored branch %s, skipping review.',
target_branch)
return
repo.create_status(pr_head, 'pending', 'Lintreview processing')
# Clone/Update repository
target_path = git.get_repo_path(user, repo_name, number, config)
git.clone_or_update(config, clone_url, target_path, pr_head)
processor = Processor(repo, pull_request, target_path, review_config)
processor.load_changes()
processor.run_tools()
processor.publish()
log.info('Completed lint processing for %s/%s/%s' %
(user, repo_name, number))
except Exception as e:
log.exception(e)
except TimeoutError as e:
log.exception(e)
raise self.retry(
countdown=5, # Pause for 5 seconds to clear things out
max_retries=2, # only give it one more shot
)
finally:
try:
git.destroy(target_path)
log.info('Cleaned up pull request %s/%s/%s', user, repo_name,
number)
except Exception as e:
log.exception(e)
def process_pull_request(self, user, repo_name, number, lintrc):
"""
Starts processing a pull request and running the various
lint tools against it.
"""
log.info('Starting to process lint for %s/%s/%s', user, repo_name, number)
log.debug("lintrc contents '%s'", lintrc)
review_config = build_review_config(lintrc, deepcopy(config))
if len(review_config.linters()) == 0:
log.info('No configured linters, skipping processing.')
return
try:
log.info('Loading pull request data from github. user=%s '
'repo=%s number=%s', user, repo_name, number)
repo = GithubRepository(config, user, repo_name)
pull_request = repo.pull_request(number)
clone_url = pull_request.clone_url
pr_head = pull_request.head
target_branch = pull_request.target_branch
if target_branch in review_config.ignore_branches():
log.info('Pull request into ignored branch %s, skipping review.',
target_branch)
return
repo.create_status(pr_head, 'pending', 'Lintreview processing')
# Clone/Update repository
target_path = git.get_repo_path(user, repo_name, number, config)
git.clone_or_update(config, clone_url, target_path, pr_head)
processor = Processor(repo, pull_request, target_path, review_config)
processor.load_changes()
processor.run_tools()
processor.publish()
log.info('Completed lint processing for %s/%s/%s' % (
user, repo_name, number))
except Exception as e:
log.exception(e)
except TimeoutError as e:
log.exception(e)
raise self.retry(
countdown=5, # Pause for 5 seconds to clear things out
max_retries=2, # only give it one more shot
)
finally:
try:
git.destroy(target_path)
log.info('Cleaned up pull request %s/%s/%s',
user, repo_name, number)
except Exception as e:
log.exception(e)
def test_publish(self):
subject = Processor(None, 1, '123abc', './tests')
subject._problems = Mock()
subject._review = Mock()
subject.publish()
self.assertTrue(subject._problems.limit_to_changes.called,
'Problems should be filtered.')
self.assertTrue(subject._review.publish.called,
'Review should be published.')
def test_publish(self):
subject = Processor(None, 1, '123abc', './tests')
subject._problems = Mock()
subject._review = Mock()
subject.publish()
self.assertTrue(
subject._problems.limit_to_changes.called,
'Problems should be filtered.')
self.assertTrue(
subject._review.publish.called,
'Review should be published.')
def test_publish(self):
subject = Processor(None, 1, '123abc', './tests',
{'SUMMARY_THRESHOLD': 50})
subject._problems = Mock()
subject._review = Mock()
subject.publish()
self.assertTrue(subject._problems.limit_to_changes.called,
'Problems should be filtered.')
self.assertTrue(subject._review.publish.called,
'Review should be published.')
subject._review.publish.assert_called_with(subject._problems, '123abc',
50)
def process_pull_request(user, repo_name, number, lintrc):
"""
Starts processing a pull request and running the various
lint tools against it.
"""
log.info('Starting to process lint for %s/%s/%s', user, repo_name, number)
log.debug("lintrc contents '%s'", lintrc)
review_config = build_review_config(lintrc, config)
if len(review_config.linters()) == 0:
log.info('No configured linters, skipping processing.')
return
try:
log.info('Loading pull request data from github. user=%s '
'repo=%s number=%s', user, repo_name, number)
repo = GithubRepository(config, user, repo_name)
pull_request = repo.pull_request(number)
clone_url = pull_request.clone_url
pr_head = pull_request.head
target_branch = pull_request.target_branch
if target_branch in review_config.ignore_branches():
log.info('Pull request into ignored branch %s, skipping review.',
target_branch)
return
status = config.get('PULLREQUEST_STATUS', True)
if status:
repo.create_status(pr_head, 'pending', 'Lintreview processing...')
# Clone/Update repository
target_path = git.get_repo_path(user, repo_name, number, config)
git.clone_or_update(config, clone_url, target_path, pr_head)
processor = Processor(repo, pull_request,
target_path, config)
processor.load_changes()
processor.run_tools(review_config)
processor.publish()
log.info('Completed lint processing for %s/%s/%s' % (
user, repo, number))
git.destroy(target_path)
log.info('Cleaned up pull request %s/%s/%s', user, repo, number)
except BaseException as e:
log.exception(e)
def test_publish(self):
subject = Processor(None, 1, '123abc', './tests', {'SUMMARY_THRESHOLD': 50})
subject._problems = Mock()
subject._review = Mock()
subject.publish()
self.assertTrue(
subject._problems.limit_to_changes.called,
'Problems should be filtered.')
self.assertTrue(
subject._review.publish.called,
'Review should be published.')
subject._review.publish.assert_called_with(
subject._problems, '123abc', 50)
def process_pull_request(user, repo_name, number, lintrc):
"""
Starts processing a pull request and running the various
lint tools against it.
"""
log.info('Starting to process lint for %s/%s/%s', user, repo_name, number)
log.debug("lintrc contents '%s'", lintrc)
review_config = build_review_config(lintrc, config)
if len(review_config.linters()) == 0:
log.info('No configured linters, skipping processing.')
return
try:
log.info('Loading pull request data from github. user=%s '
'repo=%s number=%s', user, repo_name, number)
repo = GithubRepository(config, user, repo_name)
pull_request = repo.pull_request(number)
head_repo = pull_request.clone_url
private_repo = pull_request.is_private
pr_head = pull_request.head
target_branch = pull_request.target_branch
if target_branch in review_config.ignore_branches():
log.info('Pull request into ignored branch %s, skipping processing.' %
target_branch)
return
status = config.get('PULLREQUEST_STATUS', True)
if status:
repo.create_status(pr_head, 'pending', 'Lintreview processing...')
# Clone/Update repository
target_path = git.get_repo_path(user, repo_name, number, config)
git.clone_or_update(config, head_repo, target_path, pr_head,
private_repo)
processor = Processor(repo, pull_request,
target_path, config)
processor.load_changes()
processor.run_tools(review_config)
processor.publish()
log.info('Completed lint processing for %s/%s/%s' % (
user, repo, number))
except BaseException, e:
log.exception(e)
def test_publish(self):
pull = self.get_pull_request()
repo = Mock()
subject = Processor(repo, pull, './tests', app_config)
subject.problems = Mock()
subject._review = Mock()
subject.publish()
eq_(True, subject.problems.limit_to_changes.called,
'Problems should be filtered.')
eq_(True, subject._review.publish.called,
'Review should be published.')
subject._review.publish.assert_called_with(subject.problems, pull.head,
50)
def test_publish(self):
gh = self.get_mock_client(load_fixture('commits.json'))
subject = Processor(gh, 1, '123abc', './tests',
{'SUMMARY_THRESHOLD': 50})
subject._problems = Mock()
subject._review = Mock()
subject.publish()
self.assertTrue(subject._problems.limit_to_changes.called,
'Problems should be filtered.')
self.assertTrue(subject._review.publish.called,
'Review should be published.')
subject._review.publish.assert_called_with(subject._problems, '123abc',
50)
def test_publish_checkrun(self):
pull = self.get_pull_request()
repo = Mock()
config = build_review_config(fixer_ini, app_config)
subject = Processor(repo, pull, './tests', config)
subject.problems = Mock()
subject._review = Mock()
subject.publish(check_run_id=9)
eq_(True, subject.problems.limit_to_changes.called,
'Problems should be filtered.')
eq_(True, subject._review.publish_checkrun.called,
'Review should be published.')
subject._review.publish_checkrun.assert_called_with(
subject.problems, 9)
def test_publish(self):
gh = self.get_mock_client(load_fixture('commits.json'))
subject = Processor(gh, 1, '123abc', './tests', {'SUMMARY_THRESHOLD': 50})
subject._problems = Mock()
subject._review = Mock()
subject.publish()
self.assertTrue(
subject._problems.limit_to_changes.called,
'Problems should be filtered.')
self.assertTrue(
subject._review.publish.called,
'Review should be published.')
subject._review.publish.assert_called_with(
subject._problems, '123abc', 50)
def process_pull_request(user, repo, number, lintrc):
"""
Starts processing a pull request and running the various
lint tools against it.
"""
log.info('Starting to process lint for %s/%s/%s', user, repo, number)
log.debug("lintrc contents '%s'", lintrc)
review_config = build_review_config(lintrc, config)
if len(review_config.linters()) == 0:
log.info('No configured linters, skipping processing.')
return
try:
log.info(
'Loading pull request data from github. user=%s '
'repo=%s number=%s', user, repo, number)
gh = github.get_repository(config, user, repo)
pull_request = gh.pull_request(number)
pr_dict = pull_request.as_dict()
head_repo = pr_dict['head']['repo']['clone_url']
private_repo = pr_dict['head']['repo']['private']
pr_head = pr_dict['head']['sha']
target_branch = pr_dict['base']['ref']
if target_branch in review_config.ignore_branches():
log.info(
'Pull request into ignored branch %s, skipping processing.' %
target_branch)
return
# Clone/Update repository
target_path = git.get_repo_path(user, repo, number, config)
git.clone_or_update(config, head_repo, target_path, pr_head,
private_repo)
processor = Processor(gh, number, pr_head, target_path, config)
processor.load_changes()
processor.run_tools(review_config)
processor.publish()
log.info('Completed lint processing for %s/%s/%s' %
(user, repo, number))
except BaseException as e:
log.exception(e)
def test_publish(self):
pull = self.get_pull_request()
repo = Mock()
config = build_review_config(fixer_ini, app_config)
subject = Processor(repo, pull, './tests', config)
subject.problems = Mock()
subject._review = Mock()
subject.publish()
self.assertTrue(subject.problems.limit_to_changes.called,
'Problems should be filtered.')
self.assertTrue(subject._review.publish_review.called,
'Review should be published.')
subject._review.publish_review.assert_called_with(
subject.problems,
pull.head)
def process_pull_request(user, repo, number, lintrc):
"""
Starts processing a pull request and running the various
lint tools against it.
"""
log.info('Starting to process lint for %s/%s/%s', user, repo, number)
log.debug("lintrc contents '%s'", lintrc)
lintrc_defaults = get_lintrc_defaults(config)
review_config = ReviewConfig(lintrc, lintrc_defaults)
if len(review_config.linters()) == 0:
log.info('No configured linters, skipping processing.')
return
try:
log.info('Loading pull request data from github. user=%s '
'repo=%s number=%s', user, repo, number)
gh = github.get_repository(config, user, repo)
pull_request = gh.pull_request(number)
pr_dict = pull_request.as_dict()
head_repo = pr_dict['head']['repo']['clone_url']
private_repo = pr_dict['head']['repo']['private']
pr_head = pr_dict['head']['sha']
target_branch = pr_dict['base']['ref']
if target_branch in review_config.ignore_branches():
log.info('Pull request into ignored branch %s, skipping processing.' %
target_branch)
return
# Clone/Update repository
target_path = git.get_repo_path(user, repo, number, config)
git.clone_or_update(config, head_repo, target_path, pr_head,
private_repo)
processor = Processor(gh, number, pr_head,
target_path, config)
processor.load_changes()
processor.run_tools(review_config)
processor.publish()
log.info('Completed lint processing for %s/%s/%s' % (
user, repo, number))
except BaseException, e:
log.exception(e)