#!/usr/bin/env vpython3
# Copyright 2021 The Chromium Authors
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.
"""Tests for find_bad_builds."""
from __future__ import division
from __future__ import print_function
import contextlib
import datetime
import json
import argparse
import unittest
import git_utils
import find_bad_builds
import mock
class Pool:
"""Simple object used to mock out multiprocessing.Pool."""
def map(self, fn, lst):
return map(fn, lst)
@mock.patch('find_bad_builds._get_pool')
class FindBadBuildsIntegrationTest(unittest.TestCase):
"""Integration tests for find_bad_builds.
This only tests that the script works from an end to end perspective. It mocks
all the interactions with git and buildbucket in the script. That
functionality is fairly simple, and doesn't need to be tested.
"""
def _gen_build(self,
bid,
rev,
running_time,
builder='linux-rel',
bucket='try',
project='chromium'):
"""Generates a buildbucket dict representing a single build."""
return {
'id': str(bid),
'revision': rev,
'running_time': running_time,
'builder': {
'builder': builder,
'bucket': bucket,
'project': project
},
}
@contextlib.contextmanager
def _setup_git(self, commits, first_commit_date=None, time_gap=1):
"""Sets up git mocks.
Args:
commits: An ordered list of commit hashes. The first commit is assumed to
be the most recent.
first_commit_date: When the first commit starts. Datetime object.
time_gap: How long between git commits (minutes).
Returns:
Nothing. Yields to the caller, to allow the patches to be used during the
test.
"""
if not first_commit_date:
first_commit_date = datetime.datetime(2020, 1, 1, 0, 0, 0)
with mock.patch('git_utils.get_revisions_between') as rev_btwn:
def find_btwn(commit1, commit2):
# technically inefficient, but probably fine.
first = commits.index(commit1)
last = commits.index(commit2)
# Only want commits in between these two
return commits[first + 1:last]
rev_btwn.side_effect = find_btwn
with mock.patch('git_utils.get_commit_date') as rev_date:
def calc_date(rev):
ind = commits.index(rev)
return first_commit_date + datetime.timedelta(minutes=ind * time_gap)
rev_date.side_effect = calc_date
yield
@contextlib.contextmanager
def _setup_buildbucket(self, builds):
"""Sets up buildbucket mocks.
Args:
builds: A list of buildbucket builds (dict).
Yields:
The mock object for '_find_builds'. Callers can modify its side_effect to
verify attributes of the predicate passed to buildbucket.
"""
with mock.patch('find_bad_builds._find_builds') as find_builds:
find_builds.return_value = [json.dumps(b) for b in builds]
with mock.patch('find_bad_builds._fetch_build_revision') as fetch_rev:
def find_rev(bid):
for b in builds:
if b['id'] == bid:
return b['revision']
self.fail('build %s is missing a revision' % bid)
return None
fetch_rev.side_effect = find_rev
with mock.patch('find_bad_builds._get_build_running_time') as b_runtime:
b_runtime.side_effect = lambda build: datetime.timedelta(minutes=int(
build['running_time']))
# Yield find_builds so callers can assert on the predicate being
# passed to find_builds.
yield find_builds
def _run(self, args):
"""Runs the script. Returns the exit code and printed lines."""
lines = []
return find_bad_builds.main(args, lines.append), set(lines)
def test_simple(self, get_pool):
get_pool.return_value = Pool()
with self._setup_git(['1,', '2', '3', '4', '5']):
with self._setup_buildbucket([
self._gen_build(11, '1', 5),
self._gen_build(22, '2', 4),
self._gen_build(33, '3', 3),
self._gen_build(44, '4', 2),
self._gen_build(55, '5', 1),
]) as find_builds:
rval = find_builds.return_value
def se(predicate):
self.assertEqual(
predicate['createTime']['startTime'],
# commit '2' commit time.
'2020-01-01T00:01:00+00:00')
self.assertEqual(
predicate['createTime']['endTime'],
# commit '4' commit time, plus git replication lag.
'2020-01-01T00:23:00+00:00')
return rval
find_builds.side_effect = se
self.assertEqual(
self._run(['4', '2', '100']),
(
# Only builds with revision '2' and '3' should be cancelled. '4'
# has the good commit, so it's fine to run.
0,
set(['22', '33'])))
def test_print_builds(self, get_pool):
get_pool.return_value = Pool()
with self._setup_git(['1,', '2', '3', '4', '5']):
with self._setup_buildbucket([
self._gen_build(11, '1', 29),
self._gen_build(22, '2', 28),
self._gen_build(33, '3', 27),
self._gen_build(44, '4', 26),
self._gen_build(55, '5', 25),
]):
retcode, lines = self._run(['4', '2', '100', '-s'])
self.assertEqual(retcode, 0)
# Sort to get rid of header, then remove.
lines = sorted(lines)
self.assertTrue(lines[-1].startswith('Build '))
self.assertTrue(lines[0].startswith('------'))
self.assertEqual(
set(lines[1:-1]),
set([
'11 | False | 29 ',
'22 | True | 28 ',
'33 | True | 27 ',
'44 | False | 26 ',
'55 | False | 25 ',
]))
def test_build_time_filter(self, get_pool):
get_pool.return_value = Pool()
with self._setup_git(['1,', '2', '3', '4', '5']):
with self._setup_buildbucket([
self._gen_build(11, '1', 31),
self._gen_build(22, '2', 29),
self._gen_build(33, '3', 27),
self._gen_build(34, '3', 26),
self._gen_build(44, '4', 25),
self._gen_build(55, '5', 23),
]):
self.assertEqual(self._run(['4', '2', '28']), (0, set(['34', '33'])))
def test_builder_filter(self, get_pool):
get_pool.return_value = Pool()
with self._setup_git(['1,', '2', '3', '4', '5']):
with self._setup_buildbucket([
self._gen_build(11, '1', 4),
self._gen_build(21, '2', 5, builder='linux-rel'),
self._gen_build(22, '2', 5, builder='mac-rel'),
self._gen_build(23, '2', 5, builder='win-rel'),
self._gen_build(33, '3', 3),
self._gen_build(44, '4', 2),
self._gen_build(55, '5', 1),
]):
self.assertEqual(
self._run(['4', '2', '100', '-b', 'linux-rel', '-b', 'mac-rel']),
(0, set(['21', '22', '33'])))
def test_git_replication(self, get_pool):
get_pool.return_value = Pool()
with self._setup_git(['1,', '2', '3', '4', '5']):
with self._setup_buildbucket([
self._gen_build(11, '1', 6),
self._gen_build(22, '2', 5),
self._gen_build(33, '3', 4),
self._gen_build(44, '4', 3),
self._gen_build(55, '5', 2),
# Sometimes git has replication lag, which means that builds can get
# old git data. In this case, a build which ran after '5', which was
# committed after '4', gets '4' as the HEAD revision. This can happen
# in prod.
self._gen_build(66, '3', 1),
]):
self.assertEqual(self._run(['4', '2', '100']),
(0, set(['22', '33', '66'])))
if __name__ == '__main__':
unittest.main()
Codebase Browser
chromium