def testRevertCLSucceed(self, mock_fn, mock_revert, *_):
        repo_name = 'chromium'
        revision = 'rev1'
        commit_position = 123
        build_key = 'm/b/123'

        cl_info = ClInfo(self.review_server_host, self.review_change_id)
        cl_info.commits.append(
            Commit('20001', 'rev1', ['rev0'], datetime(2017, 2, 1, 0, 0, 0)))
        cl_info.owner_email = '*****@*****.**'
        mock_fn.return_value = cl_info
        mock_revert.return_value = '54321'

        culprit = WfSuspectedCL.Create(repo_name, revision, commit_position)
        culprit.builds = {
            build_key: {
                'status': None,
                'failures': {
                    'step': ['test1']
                }
            }
        }
        culprit.put()

        pipeline_input = CreateRevertCLParameters(
            cl_key=culprit.key.urlsafe(),
            build_key=build_key,
            failure_type=failure_type.COMPILE)
        pipeline = CreateRevertCLPipeline(pipeline_input)
        revert_status = pipeline.run(pipeline_input)

        self.assertEquals(revert_status, constants.CREATED_BY_FINDIT)

        culprit = WfSuspectedCL.Get(repo_name, revision)
        self.assertEqual(culprit.revert_status, status.COMPLETED)
        self.assertIsNotNone(culprit.revert_cl)

        reason = textwrap.dedent("""
        Findit (https://goo.gl/kROfz5) identified CL at revision %s as the
        culprit for failures in the build cycles as shown on:
        https://analysis.chromium.org/waterfall/culprit?key=%s\n
        Sample Failed Build: %s\n
        Sample Failed Step: %s""") % (commit_position, culprit.key.urlsafe(),
                                      buildbot.CreateBuildUrl('m', 'b',
                                                              '123'), 'step')
        mock_revert.assert_called_with(reason,
                                       self.review_change_id,
                                       '20001',
                                       bug_id=None)
    def testRevertSkipped(self, _):
        repo_name = 'chromium'
        revision = 'rev1'
        build_key = 'm/b/123'

        culprit = WfSuspectedCL.Create(repo_name, revision, 123)
        culprit.revert_status = status.SKIPPED
        culprit.put()

        pipeline_input = CreateRevertCLParameters(
            cl_key=culprit.key.urlsafe(),
            build_key=build_key,
            failure_type=failure_type.COMPILE)
        pipeline = CreateRevertCLPipeline(pipeline_input)
        revert_status = pipeline.run(pipeline_input)

        self.assertEqual(constants.SKIPPED, revert_status)
    def testLogUnexpectedAbortingPipelineIdNotMatch(self):
        repo_name = 'chromium'
        revision = 'rev1'
        build_key = 'm/b/123'

        culprit = WfSuspectedCL.Create(repo_name, revision, 123)
        culprit.revert_pipeline_id = 'pipeline_id'
        culprit.put()

        pipeline_input = CreateRevertCLParameters(
            cl_key=culprit.key.urlsafe(),
            build_key=build_key,
            failure_type=failure_type.COMPILE)
        pipeline = CreateRevertCLPipeline(pipeline_input)
        pipeline.start()
        pipeline.OnAbort(pipeline_input)
        culprit = WfSuspectedCL.Get(repo_name, revision)
        self.assertEqual(culprit.revert_pipeline_id, 'pipeline_id')
    def testLogUnexpectedAbortingNoChange(self):
        repo_name = 'chromium'
        revision = 'rev1'
        build_key = 'm/b/123'
        culprit = WfSuspectedCL.Create(repo_name, revision, 123)
        culprit.put()

        pipeline_input = CreateRevertCLParameters(
            cl_key=culprit.key.urlsafe(),
            build_key=build_key,
            failure_type=failure_type.COMPILE)
        CreateRevertCLPipeline(pipeline_input).OnAbort(pipeline_input)
        culprit = WfSuspectedCL.Get(repo_name, revision)
        self.assertIsNone(culprit.revert_status)
Ejemplo n.º 5
0
    def RunImpl(self, pipeline_input):

        culprits_should_take_actions = (
            test_culprit_action.GetCulpritsShouldTakeActions(pipeline_input))
        if not culprits_should_take_actions:
            return

        master_name, builder_name, build_number = (
            pipeline_input.build_key.GetParts())
        build_key = BaseBuildModel.CreateBuildKey(master_name, builder_name,
                                                  build_number)
        culprits = pipeline_input.culprits
        build_failure_type = failure_type.TEST

        for culprit_revision in culprits_should_take_actions:
            culprit_key = culprits.get(culprit_revision)
            assert culprit_key, (
                'Failed to get culprit_key for culprit {} when analyzing failures'
                ' at build {}/{}/{}'.format(culprit_revision, master_name,
                                            builder_name, build_number))

            revert_status = constants.SKIPPED
            if test_culprit_action.CanAutoCreateRevert(
                    culprit_key, pipeline_input):  # pragma: no branch.
                revert_status = yield CreateRevertCLPipeline(
                    CreateRevertCLParameters(cl_key=culprit_key,
                                             build_key=build_key,
                                             failure_type=build_failure_type))

                if test_culprit_action.CanAutoCommitRevertByFindit():
                    submit_revert_pipeline_input = self.CreateInputObjectInstance(
                        SubmitRevertCLParameters,
                        cl_key=culprit_key,
                        revert_status=revert_status,
                        failure_type=build_failure_type)
                    yield SubmitRevertCLPipeline(submit_revert_pipeline_input)

            # Checks if any of the culprits was also found by heuristic analysis,
            # if so send notification right away.
            send_notification_to_culprit_input = self.CreateInputObjectInstance(
                SendNotificationForCulpritParameters,
                cl_key=culprit_key,
                force_notify=culprit_action.ShouldForceNotify(
                    culprit_key, pipeline_input),
                revert_status=revert_status,
                failure_type=build_failure_type)
            yield SendNotificationForCulpritPipeline(
                send_notification_to_culprit_input)
    def RunImpl(self, pipeline_input):
        if not compile_culprit_action.ShouldTakeActionsOnCulprit(
                pipeline_input):
            return

        master_name, builder_name, build_number = (
            pipeline_input.build_key.GetParts())
        culprits = pipeline_input.culprits
        culprit = culprits.values()[0]
        force_notify = culprit_action.ShouldForceNotify(
            culprit, pipeline_input)
        build_key = BaseBuildModel.CreateBuildKey(master_name, builder_name,
                                                  build_number)

        build_failure_type = failure_type.COMPILE
        revert_status = constants.SKIPPED
        commit_status = constants.SKIPPED
        if compile_culprit_action.CanAutoCreateRevert():
            revert_status = yield CreateRevertCLPipeline(
                CreateRevertCLParameters(cl_key=culprit,
                                         build_key=build_key,
                                         failure_type=build_failure_type))

            if compile_culprit_action.CanAutoCommitRevertByFindit():
                submit_revert_pipeline_input = self.CreateInputObjectInstance(
                    SubmitRevertCLParameters,
                    cl_key=culprit,
                    revert_status=revert_status,
                    failure_type=build_failure_type)
                commit_status = yield SubmitRevertCLPipeline(
                    submit_revert_pipeline_input)

            send_notification_to_irc_input = self.CreateInputObjectInstance(
                SendNotificationToIrcParameters,
                cl_key=culprit,
                revert_status=revert_status,
                commit_status=commit_status,
                failure_type=build_failure_type)
            yield SendNotificationToIrcPipeline(send_notification_to_irc_input)

        send_notification_to_culprit_input = self.CreateInputObjectInstance(
            SendNotificationForCulpritParameters,
            cl_key=culprit,
            force_notify=force_notify,
            revert_status=revert_status,
            failure_type=build_failure_type)
        yield SendNotificationForCulpritPipeline(
            send_notification_to_culprit_input)