| # Copyright 2017 The Chromium OS Authors. All rights reserved. |
| # Use of this source code is governed by a BSD-style license that can be |
| # found in the LICENSE file. |
| |
| """Tests for innocent_cls_precq.py""" |
| |
| from __future__ import absolute_import |
| from __future__ import division |
| from __future__ import print_function |
| |
| import datetime |
| |
| from chromite.lib import build_requests |
| from chromite.lib import clactions |
| from chromite.lib import constants |
| from chromite.lib import cros_test_lib |
| from chromite.lib import fake_cidb |
| from google.cloud import datastore # pylint: disable=E0611,import-error |
| |
| from exonerator import innocent_cls_cq |
| from exonerator import innocent_cls_cq_test |
| from exonerator import innocent_cls_precq |
| from exonerator import innocent_cls_precq_flake |
| from testing_utils import fake_datastore |
| |
| |
| # Make the tests a bit less verbose by making some aliases: |
| ChangeWithBuild = innocent_cls_cq.ChangeWithBuild |
| GerritPatchTuple = clactions.GerritPatchTuple |
| DateTime = innocent_cls_cq_test.DateTime |
| FakeDatastoreClient = fake_datastore.FakeDatastoreClient |
| |
| |
| # pylint: disable=protected-access |
| class TestInnocentCLsPreCQ(cros_test_lib.MockTestCase): |
| """Tests the innocent_cls module with a fake MySQL server.""" |
| |
| default_build_values = { |
| 'builder_name': 'my builder', |
| 'buildbot_generation': constants.BUILDBOT_GENERATION, |
| 'waterfall': 'chromiumos', |
| 'build_config': 'a build config', |
| 'bot_hostname': 'bot hostname', |
| } |
| |
| def setUp(self): |
| """Sets up a fake datastore and some fake cidb data.""" |
| self.build_ids = [] |
| self.build_requests = [] |
| self.db = fake_cidb.FakeCIDBConnection() |
| # datastore state is global. This resets its state between tests. |
| # TODO(phobbs) make the datastore state a fixture object with a .Client() |
| # method. |
| FakeDatastoreClient.reset_store() |
| self.ds = FakeDatastoreClient() |
| self._SetupPreCQs() |
| self.PatchObject(datastore, 'Client', lambda: self.ds) |
| |
| def _SetupPreCQs(self, |
| status=constants.BUILDER_STATUS_FAILED, |
| cl_number=1234): |
| """Creates rows in cidb for a finalized BAD_CL annotation.""" |
| self.build_ids.append( |
| self.db.InsertBuild( |
| 'test_build', 2, 'test_build', 'hostname', status=status)) |
| action_picked_up = clactions.CLAction.FromGerritPatchAndAction( |
| GerritPatchTuple(cl_number, 1, True), |
| constants.CL_ACTION_PICKED_UP) |
| pre_cq_status = ( |
| constants.CL_ACTION_PRE_CQ_FAILED |
| if status == constants.BUILDER_STATUS_FAILED |
| # 'verified' is inserted when a CL passes a given pre-cq builder |
| else constants.CL_ACTION_VERIFIED) |
| action_failed = clactions.CLAction.FromGerritPatchAndAction( |
| GerritPatchTuple(cl_number, 1, True), |
| pre_cq_status) |
| |
| self.db.InsertCLActions( |
| self.build_ids[-1], [action_picked_up, action_failed]) |
| |
| def _InsertSanityBuild(self, status): |
| self.build_ids.append( |
| self.db.InsertBuild( |
| 'test_build', 1, 'test_build', 'hostname', status=status)) |
| now = datetime.datetime.now() + datetime.timedelta(seconds=1) |
| self.build_requests.append( |
| build_requests.BuildRequest( |
| id=len(self.build_requests), |
| build_id=self.build_ids[-1], |
| request_build_config='test_build', |
| request_build_args='', |
| request_buildbucket_id='0', |
| request_reason='sanity-pre-cq', |
| timestamp=now)) |
| self.db.InsertBuildRequests([self.build_requests[-1]]) |
| |
| def test_NewInnocentCLs(self): |
| """An innocent CLs will get yielded.""" |
| self._InsertSanityBuild(constants.BUILDER_STATUS_FAILED) |
| new_cls = list(innocent_cls_precq.NewInnocentCLs(self.db, True)) |
| assert new_cls == [ |
| [ChangeWithBuild(GerritPatchTuple(1234, 1, internal=True), |
| self.build_ids[0]),] |
| ] |
| |
| def test_NewInnocentCLsWithNewerPreCQFailure(self): |
| """If the CL was picked up after the failure, we don't exonerate.""" |
| self._InsertSanityBuild(constants.BUILDER_STATUS_FAILED) |
| new_build_id = self.db.InsertBuild( |
| 'test_build', 1, 'test_build', 'hostname', |
| status=constants.BUILDER_STATUS_PASSED) |
| new_action = clactions.CLAction.FromGerritPatchAndAction( |
| GerritPatchTuple(1234, 1, True), |
| constants.CL_ACTION_PICKED_UP) |
| |
| self.db.InsertCLActions(new_build_id, [new_action]) |
| |
| new_cls = list(innocent_cls_precq.NewInnocentCLs(self.db, True)) |
| assert len(new_cls) == 0 |
| |
| def test_NewInnocentCLsAlreadyForgiven(self): |
| """If we already forgave the build, we don't forgive it again.""" |
| self._InsertSanityBuild(constants.BUILDER_STATUS_FAILED) |
| key = self.ds.key( |
| innocent_cls_precq.PRECQ_PROCESSED_KEY, self.build_ids[0]) |
| last_run = datastore.Entity(key=key) |
| last_run['1234'] = True |
| self.ds.put(last_run) |
| |
| new_cls = list(innocent_cls_precq.NewInnocentCLs(self.db, True)) |
| assert new_cls == [] |
| |
| def test_NewInnocentCLsCheckpointing(self): |
| """Test that checkpointing works. |
| |
| We shouldn't get the same CLs back after requesting NewInnocentCLs more |
| than once. |
| """ |
| self._InsertSanityBuild(constants.BUILDER_STATUS_FAILED) |
| first_pass = list(innocent_cls_precq.NewInnocentCLs(self.db, True)) |
| second_pass = list(innocent_cls_precq.NewInnocentCLs(self.db, True)) |
| third_pass = list(innocent_cls_precq.NewInnocentCLs(self.db, True)) |
| |
| assert first_pass == [ |
| [ChangeWithBuild( |
| GerritPatchTuple(1234, 1, internal=True), |
| self.build_ids[0]),] |
| ] |
| assert second_pass == [] |
| assert third_pass == [] |
| |
| def test_PassedSanityBuild(self): |
| """If the sanity build passed, don't exonerate any CLs.""" |
| self._InsertSanityBuild(constants.BUILDER_STATUS_PASSED) |
| got = list(innocent_cls_precq.NewInnocentCLs(self.db, True)) |
| assert got == [] |
| |
| def test_AlreadyExonerated(self): |
| """Don't re-exonerate a CL.""" |
| self._InsertSanityBuild(constants.BUILDER_STATUS_PASSED) |
| action_exonerated = clactions.CLAction.FromGerritPatchAndAction( |
| GerritPatchTuple(1234, 1, True), |
| constants.CL_ACTION_EXONERATED) |
| self.db.InsertCLActions(self.build_ids[0], [action_exonerated]) |
| |
| got = list(innocent_cls_precq.NewInnocentCLs(self.db, True)) |
| assert got == [] |
| |
| def test_NoSanity(self): |
| """Test that no CLs are yielded when there isn't a sanity failure.""" |
| got = list(innocent_cls_precq.NewInnocentCLs(self.db, True)) |
| assert got == [] |
| |
| def test_PreCQNaturalSanity(self): |
| """Test a "natural" sanity build. |
| |
| A natural sanity failure is when a pre-CQ config fails and passes for the |
| same patchset. |
| """ |
| # TODO(phobbs) this doesn't do any real testing of the MySQL queries, which |
| # are pretty complicated. Add an integration test which subclasses |
| # cidb_integration_test. |
| self._SetupPreCQs(status=constants.BUILDER_STATUS_PASSED) |
| self._SetupPreCQs(cl_number=9999) |
| self.PatchObject( |
| innocent_cls_precq_flake, |
| '_AffectedPreCQBuilds', |
| _FakeAffectedPreCQBuilds) |
| new_cls = list(innocent_cls_precq.NewInnocentCLs(self.db, True)) |
| assert new_cls == [ |
| [ChangeWithBuild( |
| GerritPatchTuple(9999, 1, internal=True), |
| self.build_ids[-1]),] |
| ] |
| |
| |
| def _FakeAffectedPreCQBuilds(conn, config): |
| """Finds the CLs with outstanding failures of |config|. |
| |
| Args: |
| conn: A FakeCIDBConnection instance. |
| config: A build config. |
| |
| Yields: |
| Tuples of (GerritPatchTuple, build_id) which are the patchsets whose |
| latest run of |config| was a failure. |
| """ |
| actions_by_cl = _ActionsByCL(conn) |
| builds_by_id = _BuildsById(conn) |
| def _BuildForAction(action): |
| """Returns the buildTable row associated with given the claction.""" |
| return builds_by_id[action['build_id']] |
| |
| cls_with_outstanding_failures = [] |
| for cl, actions in actions_by_cl.iteritems(): |
| actions_for_config = [ |
| a for a in actions |
| if _BuildForAction(a)['build_config'] == config |
| ] |
| if not actions_for_config: |
| continue |
| latest_build = max( |
| (_BuildForAction(action) for action in actions), |
| key=lambda build: build['start_time']) |
| |
| actions_for_latest_build = [ |
| action for action in actions |
| if action['build_id'] == latest_build['id'] |
| ] |
| # for each patchset with actions relevant to |config|, |
| # if the patchset's last action for |config| was a failure, include it. |
| if any(a['action'] == constants.CL_ACTION_PRE_CQ_FAILED |
| for a in actions_for_latest_build): |
| cls_with_outstanding_failures.append(( |
| GerritPatchTuple(*cl), latest_build['id'])) |
| |
| return cls_with_outstanding_failures |
| |
| |
| def _BuildsById(conn): |
| """Returns a mapping of build ids to buildTable rows.""" |
| builds_by_id = {} |
| for build in conn.buildTable: |
| builds_by_id[build['id']] = build |
| return builds_by_id |
| |
| |
| def _ActionsByCL(conn): |
| """Returns groups of CLActions rows grouped by CL patchset.""" |
| actions_by_cl = {} |
| for action in conn.clActionTable: |
| k = (action['change_number'], |
| action['patch_number'], |
| action['change_source'] == 'internal') |
| actions_by_cl.setdefault(k, []).append(action) |
| return actions_by_cl |
