def testReturnNoneIfNoTryJob(self):
master_name = 'm'
builder_name = 'b'
build_number = 8
WfTryJob.Create(master_name, builder_name, build_number).put()
self.MockGeneratorPipeline(
pipeline_class=RevertAndNotifyTestCulpritPipeline,
expected_input=CulpritActionParameters(
build_key=BuildKey(master_name=master_name,
builder_name=builder_name,
build_number=build_number),
culprits=DictOfBasestring(),
heuristic_cls=ListOfBasestring(),
failure_to_culprit_map=None),
mocked_output=False)
parameters = IdentifyTestTryJobCulpritParameters(build_key=BuildKey(
master_name=master_name,
builder_name=builder_name,
build_number=build_number),
result=None)
pipeline = IdentifyTestTryJobCulpritPipeline(parameters)
pipeline.start()
self.execute_queued_tasks()
try_job = WfTryJob.Get(master_name, builder_name, build_number)
self.assertEqual(try_job.test_results, [])
self.assertEqual(try_job.status, analysis_status.COMPLETED)
def testAnalyzeCompileFailurePipelineStartTryJob(self, mocked_pipeline,
mock_log, mock_mon):
master_name = 'm'
builder_name = 'b'
build_number = 124
failure_info = {
'failed_steps': {
'compile': {
'last_pass': 122,
'current_failure': 123,
'first_failure': 123
}
}
}
self._SetupAnalysis(
master_name,
builder_name,
build_number,
status=analysis_status.RUNNING,
signals={},
failure_info=failure_info)
pipeline_input = AnalyzeCompileFailureInput(
build_key=BuildKey(
master_name=master_name,
builder_name=builder_name,
build_number=build_number),
current_failure_info=CompileFailureInfo.FromSerializable({}),
build_completed=False,
force=False)
root_pipeline = AnalyzeCompileFailurePipeline(pipeline_input)
root_pipeline.OnAbort(pipeline_input)
heuristic_result = CompileHeuristicAnalysisOutput.FromSerializable({
'failure_info': failure_info,
'signals': {},
'heuristic_result': None
})
start_try_job_params = StartCompileTryJobInput(
build_key=BuildKey(
master_name=master_name,
builder_name=builder_name,
build_number=build_number),
heuristic_result=heuristic_result,
build_completed=False,
force=False)
mocked_pipeline.assert_called_once_with(start_try_job_params)
mocked_pipeline.assert_has_calls(
[mock.call().start(queue_name=constants.WATERFALL_ANALYSIS_QUEUE)])
mock_log.assert_called_once_with(
'A try job pipeline for build %s, %s, %s starts after heuristic '
'analysis was aborted. Check pipeline at: %s.', master_name,
builder_name, build_number, root_pipeline.pipeline_status_path)
mock_mon.assert_called_once_with(master_name, builder_name,
analysis_status.ERROR,
analysis_approach_type.HEURISTIC)
def testIdentifyCulpritForCompileTryJobSuccess(self, mock_fn):
master_name = 'm'
builder_name = 'b'
build_number = 1
try_job_id = '1'
compile_result = {
'report': {
'result': {
'rev1': 'passed',
'rev2': 'failed'
},
'culprit': 'rev2'
},
'try_job_id': try_job_id,
}
repo_name = 'chromium'
revision = 'rev2'
culprit = WfSuspectedCL.Create(repo_name, revision, 100)
culprit.put()
culprits_result = {
'rev2': {
'revision': revision,
'commit_position': 2,
'url': 'url_2',
'repo_name': repo_name
}
}
mock_fn.return_value = culprits_result, ListOfBasestring()
culprits = DictOfBasestring()
culprits['rev2'] = culprit.key.urlsafe()
self.MockGeneratorPipeline(pipeline_class=revert_pipeline.
RevertAndNotifyCompileCulpritPipeline,
expected_input=CulpritActionParameters(
build_key=BuildKey(
master_name=master_name,
builder_name=builder_name,
build_number=build_number),
culprits=culprits,
heuristic_cls=ListOfBasestring(),
failure_to_culprit_map=None),
mocked_output=False)
pipeline_input = IdentifyCompileTryJobCulpritParameters(
build_key=BuildKey(master_name=master_name,
builder_name=builder_name,
build_number=build_number),
result=CompileTryJobResult.FromSerializable(compile_result))
pipeline = culprit_pipeline.IdentifyCompileTryJobCulpritPipeline(
pipeline_input)
pipeline.start()
self.execute_queued_tasks()
def testIdentifyCulpritForTestTryJobSuccess(self, mock_fn, mock_fn2):
master_name = 'm'
builder_name = 'b'
build_number = 1
repo_name = 'chromium'
revision = 'rev2'
culprit = WfSuspectedCL.Create(repo_name, revision, 100)
culprit.put()
culprits_result = {
'rev1': {
'revision': 'rev1',
'repo_name': 'chromium',
'commit_position': 1,
'url': 'url_1'
},
'rev2': {
'revision': revision,
'commit_position': 2,
'url': 'url_2',
'repo_name': repo_name
}
}
culprit_map = {'step': {'test1': 'rev1', 'test2': 'rev2'}}
mock_fn.return_value = culprits_result, ListOfBasestring.FromSerializable(
[]), FailureToCulpritMap.FromSerializable(culprit_map)
culprits = DictOfBasestring()
culprits['rev2'] = culprit.key.urlsafe()
mock_fn2.return_value = culprits
self.MockGeneratorPipeline(
pipeline_class=RevertAndNotifyTestCulpritPipeline,
expected_input=CulpritActionParameters(
build_key=BuildKey(master_name=master_name,
builder_name=builder_name,
build_number=build_number),
culprits=culprits,
heuristic_cls=ListOfBasestring(),
failure_to_culprit_map=FailureToCulpritMap.FromSerializable(
culprit_map)),
mocked_output=False)
parameters = IdentifyTestTryJobCulpritParameters(
build_key=BuildKey(master_name=master_name,
builder_name=builder_name,
build_number=build_number),
result=TestTryJobResult.FromSerializable({}))
pipeline = IdentifyTestTryJobCulpritPipeline(parameters)
pipeline.start()
self.execute_queued_tasks()
mock_fn.assert_called_once_with(parameters)
def testBuildFailurePipelineFlow(self):
master_name = 'm'
builder_name = 'b'
build_number = 124
current_failure_info = {}
self._SetupAnalysis(master_name, builder_name, build_number)
heuristic_params = CompileHeuristicAnalysisParameters.FromSerializable({
'failure_info': current_failure_info,
'build_completed': False
})
heuristic_output = CompileHeuristicAnalysisOutput.FromSerializable({
'failure_info': None,
'signals': None,
'heuristic_result': {}
})
self.MockSynchronousPipeline(
analyze_compile_failure_pipeline.HeuristicAnalysisForCompilePipeline,
heuristic_params, heuristic_output)
start_try_job_params = StartCompileTryJobInput(
build_key=BuildKey(
master_name=master_name,
builder_name=builder_name,
build_number=build_number),
heuristic_result=heuristic_output,
build_completed=False,
force=False)
self.MockGeneratorPipeline(
analyze_compile_failure_pipeline.StartCompileTryJobPipeline,
start_try_job_params, False)
report_event_input = report_event_pipeline.ReportEventInput(
analysis_urlsafe_key=WfAnalysis.Get(master_name, builder_name,
build_number).key.urlsafe())
self.MockGeneratorPipeline(
report_event_pipeline.ReportAnalysisEventPipeline, report_event_input,
None)
pipeline_input = AnalyzeCompileFailureInput(
build_key=BuildKey(
master_name=master_name,
builder_name=builder_name,
build_number=build_number),
current_failure_info=CompileFailureInfo.FromSerializable(
current_failure_info),
build_completed=False,
force=False)
root_pipeline = AnalyzeCompileFailurePipeline(pipeline_input)
root_pipeline.start(queue_name=constants.DEFAULT_QUEUE)
self.execute_queued_tasks()
analysis = WfAnalysis.Get(master_name, builder_name, build_number)
self.assertEqual(analysis_status.RUNNING, analysis.status)
def testAnalyzeTestFailurePipelineStartTryJob(self, mocked_pipeline, mock_fn):
master_name = 'm'
builder_name = 'b'
build_number = 124
failure_info = {
'failed_steps': {
'test': {
'last_pass': 122,
'current_failure': 123,
'first_failure': 123
}
}
}
self._SetupAnalysis(
master_name,
builder_name,
build_number,
status=analysis_status.RUNNING,
signals={},
failure_info=failure_info)
pipeline_input = AnalyzeTestFailureInput(
build_key=BuildKey(
master_name=master_name,
builder_name=builder_name,
build_number=build_number),
current_failure_info=None,
build_completed=True,
force=False)
root_pipeline = AnalyzeTestFailurePipeline(pipeline_input)
root_pipeline.OnAbort(pipeline_input)
heuristic_result = {'failure_info': failure_info, 'heuristic_result': None}
expected_pipeline_input = StartTestTryJobInputs(
build_key=BuildKey(
master_name=master_name,
builder_name=builder_name,
build_number=build_number),
build_completed=True,
force=False,
heuristic_result=TestHeuristicAnalysisOutput.FromSerializable(
heuristic_result),
consistent_failures=CollectSwarmingTaskResultsOutputs.FromSerializable(
{}))
mocked_pipeline.assert_called_once_with(expected_pipeline_input)
mocked_pipeline.assert_has_calls(
[mock.call().start(queue_name=constants.WATERFALL_ANALYSIS_QUEUE)])
mock_fn.assert_called_once_with(master_name, builder_name,
analysis_status.ERROR,
analysis_approach_type.HEURISTIC)
def testOnSwarmingTaskTimeout(self, mock_mon, _):
master_name = 'm'
builder_name = 'b'
build_number = 16
step_name = 's'
swarming_task = WfSwarmingTask.Create(master_name, builder_name,
build_number, step_name)
swarming_task.put()
parameters = RunSwarmingTaskParameters(build_key=BuildKey(
master_name=master_name,
builder_name=builder_name,
build_number=build_number),
step_name=step_name,
tests=['tests'])
test_swarming.OnSwarmingTaskTimeout(parameters, 'task_id')
swarming_task = WfSwarmingTask.Get(master_name, builder_name,
build_number, step_name)
self.assertEqual(analysis_status.ERROR, swarming_task.status)
self.assertEqual(
{
'code': swarming_task_error.RUNNER_TIMEOUT,
'message': 'Runner to run swarming task timed out'
}, swarming_task.error)
mock_mon.assert_called_once_with(master_name, builder_name,
build_number, step_name,
analysis_status.ERROR,
analysis_approach_type.SWARMING)
def testTriggerSwarmingTask(self, mock_ref, mock_create, mock_trigger, _):
runner_id = 'runner_id'
master_name = 'm'
builder_name = 'b'
build_number = 6
step_name = 's'
tests = ['test']
WfSwarmingTask.Create(master_name, builder_name, build_number,
step_name).put()
parameters = RunSwarmingTaskParameters(build_key=BuildKey(
master_name=master_name,
builder_name=builder_name,
build_number=build_number),
step_name=step_name,
tests=tests)
new_request = SwarmingTaskRequest.FromSerializable(
_SAMPLE_REQUEST_JSON)
mock_create.return_value = new_request
task_id = test_swarming.TriggerSwarmingTask(parameters, runner_id)
self.assertEqual('new_task_id', task_id)
mock_ref.assert_called_once_with(master_name, builder_name,
build_number, step_name, None)
mock_create.assert_called_once_with('runner_id', 'task_id',
'ref_request', master_name,
builder_name, step_name, tests, 10)
mock_trigger.assert_called_once_with('chromium-swarm.appspot.com',
new_request, None)
def testNoCompileTryJobBecauseNoGoodRevision(self, mock_pipeline,
mock_parameter, mock_fn):
mock_parameter.return_value = RunCompileTryJobParameters(
good_revision=None)
try_job = WfTryJob.Create('m', 'b', 1)
try_job.put()
mock_fn.return_value = (True, try_job.key.urlsafe())
failure_info = {'failure_type': failure_type.COMPILE}
heuristic_result = {
'failure_info': failure_info,
'signals': {},
'heuristic_result': {}
}
start_try_job_params = StartCompileTryJobInput(
build_key=BuildKey(master_name='m',
builder_name='b',
build_number=1),
heuristic_result=CompileHeuristicAnalysisOutput.FromSerializable(
heuristic_result),
build_completed=True,
force=False)
pipeline = StartCompileTryJobPipeline(start_try_job_params)
result = pipeline.RunImpl(start_try_job_params)
self.assertEqual(list(result), [])
self.assertFalse(mock_pipeline.called)
def testAnalyzeCompileFailurePipelineNotAbortedIfWithoutError(self, mock_mon):
master_name = 'm'
builder_name = 'b'
build_number = 124
self._SetupAnalysis(
master_name,
builder_name,
build_number,
status=analysis_status.COMPLETED)
pipeline_input = AnalyzeCompileFailureInput(
build_key=BuildKey(
master_name=master_name,
builder_name=builder_name,
build_number=build_number),
current_failure_info=CompileFailureInfo.FromSerializable({}),
build_completed=False,
force=True)
root_pipeline = AnalyzeCompileFailurePipeline(pipeline_input)
root_pipeline.OnAbort(pipeline_input)
analysis = WfAnalysis.Get(master_name, builder_name, build_number)
self.assertIsNotNone(analysis)
self.assertNotEqual(analysis_status.ERROR, analysis.status)
self.assertFalse(mock_mon.called)
def testAnalyzeCompileFailurePipelineAbortedIfWithError(self, mock_mon):
master_name = 'm'
builder_name = 'b'
build_number = 124
self._SetupAnalysis(
master_name, builder_name, build_number, status=analysis_status.RUNNING)
pipeline_input = AnalyzeCompileFailureInput(
build_key=BuildKey(
master_name=master_name,
builder_name=builder_name,
build_number=build_number),
current_failure_info=CompileFailureInfo.FromSerializable({}),
build_completed=False,
force=True)
root_pipeline = AnalyzeCompileFailurePipeline(pipeline_input)
root_pipeline.OnAbort(pipeline_input)
analysis = WfAnalysis.Get(master_name, builder_name, build_number)
self.assertIsNotNone(analysis)
self.assertEqual(analysis_status.ERROR, analysis.status)
self.assertIsNone(analysis.result_status)
self.assertTrue(analysis.aborted)
mock_mon.assert_called_once_with(master_name, builder_name,
analysis_status.ERROR,
analysis_approach_type.HEURISTIC)
def _ContinueTryJobPipeline(self, pipeline_input, failure_info):
master_name, builder_name, build_number = (
pipeline_input.build_key.GetParts())
heuristic_result = {
'failure_info': failure_info,
'heuristic_result': None
}
start_waterfall_try_job_inputs = StartTestTryJobInputs(
build_key=BuildKey(master_name=master_name,
builder_name=builder_name,
build_number=build_number),
build_completed=pipeline_input.build_completed,
force=pipeline_input.force,
heuristic_result=TestHeuristicAnalysisOutput.FromSerializable(
heuristic_result),
consistent_failures=CollectSwarmingTaskResultsOutputs.
FromSerializable({}))
try_job_pipeline = StartTestTryJobPipeline(
start_waterfall_try_job_inputs)
try_job_pipeline.target = appengine_util.GetTargetNameForModule(
constants.WATERFALL_BACKEND)
try_job_pipeline.start(queue_name=constants.WATERFALL_ANALYSIS_QUEUE)
logging.info(
'A try job pipeline for build %s, %s, %s starts after heuristic '
'analysis was aborted. Check pipeline at: %s.', master_name,
builder_name, build_number, self.pipeline_status_path)
def testTriggerFlakeAnalysesPipeline(self, mock_monitoring, *_):
master_name = 'm'
builder_name = 'b'
build_number = 2
step_name = 'a_tests'
test_name = 'Unittest1.Subtest1'
analysis = WfAnalysis.Create(master_name, builder_name, build_number)
analysis.flaky_tests = {step_name: [test_name, 'Unittest1.Subtest2']}
analysis.put()
build_key = BuildKey(master_name=master_name,
builder_name=builder_name,
build_number=build_number)
with mock.patch.object(
flake_analysis_service,
'ScheduleAnalysisForFlake') as mocked_ScheduleAnalysisForFlake:
pipeline = TriggerFlakeAnalysesPipeline(build_key)
pipeline.RunImpl(build_key)
self.assertTrue(mocked_ScheduleAnalysisForFlake.called)
mock_monitoring.assert_has_calls([
mock.call('a_tests', 'a_tests', 'analyzed', 1),
mock.call('a_tests', 'a_tests', 'throttled', 1)
])
def testSendNotificationLatestBuildPassed(self, mocked_pipeline, _):
master_name = 'm'
builder_name = 'b'
build_number = 124
cl_key = 'mockurlsafekey'
culprits = DictOfBasestring()
culprits['r1'] = cl_key
heuristic_cls = ListOfBasestring()
heuristic_cls.append(cl_key)
failure_to_culprit_map = FailureToCulpritMap.FromSerializable(
{'step1': {
't1': 'r1'
}})
pipeline = RevertAndNotifyTestCulpritPipeline(
CulpritActionParameters(
build_key=BuildKey(master_name=master_name,
builder_name=builder_name,
build_number=build_number),
culprits=culprits,
heuristic_cls=heuristic_cls,
failure_to_culprit_map=failure_to_culprit_map))
pipeline.start(queue_name=constants.DEFAULT_QUEUE)
self.execute_queued_tasks()
self.assertFalse(mocked_pipeline.called)
def testGetCulpritsShouldTakeActions(self, _):
master_name = 'm'
builder_name = 'b'
build_number = 124
culprits = DictOfBasestring()
culprits['r1'] = 'mockurlsafekey'
culprits['r2'] = 'mockurlsafekey2'
failure_to_culprit_map = FailureToCulpritMap.FromSerializable({
'step1': {
'test1': 'r1',
'test2': 'r2'
},
'step2': {
'test1': 'r2'
}
})
parameters = CulpritActionParameters(
build_key=BuildKey(master_name=master_name,
builder_name=builder_name,
build_number=build_number),
culprits=culprits,
heuristic_cls=ListOfBasestring(),
failure_to_culprit_map=failure_to_culprit_map)
self.assertEqual(
set(['r1']),
test_culprit_action.GetCulpritsShouldTakeActions(parameters))
def setUp(self):
super(CollectSwarmingTaskResultsPipelineTest, self).setUp()
self.pipeline_input = CollectSwarmingTaskResultsInputs(
build_key=BuildKey(master_name='m',
builder_name='b',
build_number=41),
build_completed=True)
def _CreateRunTestTryJobParameters(self):
master_name = 'm'
builder_name = 'b'
build_number = 1
try_job_id = '1'
job = WfTryJob.Create(master_name, builder_name, build_number)
try_job_data = WfTryJobData.Create(try_job_id)
try_job_data.try_job_key = job.key
try_job_data.try_job_url = (
'https://build.chromium.org/p/m/builders/b/builds/1234')
try_job_data.put()
job.test_results = [{
'report': None,
'url': 'https://build.chromium.org/p/m/builders/b/builds/1234',
'try_job_id': '1',
}]
job.status = analysis_status.RUNNING
job.put()
return RunTestTryJobParameters(build_key=BuildKey(
master_name=master_name,
builder_name=builder_name,
build_number=build_number),
good_revision='rev1',
bad_revision='rev2',
suspected_revisions=['r5'],
cache_name=None,
dimensions=[],
targeted_tests={},
urlsafe_try_job_key=job.key.urlsafe())
def testSendNotificationForTestCulpritNoRevert(self, *_):
master_name = 'm'
builder_name = 'b'
build_number = 124
cl_key = 'mockurlsafekey'
culprits = DictOfBasestring()
culprits['r1'] = cl_key
heuristic_cls = ListOfBasestring()
heuristic_cls.append(cl_key)
failure_to_culprit_map = FailureToCulpritMap.FromSerializable(
{'step1': {
't1': 'r1'
}})
input_object = SendNotificationForCulpritParameters(
cl_key=cl_key,
force_notify=True,
revert_status=services_constants.SKIPPED,
failure_type=failure_type.TEST)
self.MockSynchronousPipeline(SendNotificationForCulpritPipeline,
input_object, True)
pipeline = RevertAndNotifyTestCulpritPipeline(
CulpritActionParameters(
build_key=BuildKey(master_name=master_name,
builder_name=builder_name,
build_number=build_number),
culprits=culprits,
heuristic_cls=heuristic_cls,
failure_to_culprit_map=failure_to_culprit_map))
pipeline.start(queue_name=constants.DEFAULT_QUEUE)
self.execute_queued_tasks()
def testGetFirstTimeTestFailuresToRunSwarmingTasks(self, mock_fn, _):
master_name = 'm'
builder_name = 'b'
build_number = 13
step_name = 'step'
failure_info_json = {
'failure_type': failure_type.TEST,
'failed_steps': {
step_name: {}
}
}
failure_info = TestFailureInfo.FromSerializable(failure_info_json)
heuristic_result = TestHeuristicAnalysisOutput(
failure_info=failure_info,
heuristic_result=TestHeuristicResult.FromSerializable({}))
params = RunSwarmingTasksInput(build_key=BuildKey(
master_name=master_name,
builder_name=builder_name,
build_number=build_number),
heuristic_result=heuristic_result,
force=False)
self.assertEqual(
{'step': ['test']},
test_swarming.GetFirstTimeTestFailuresToRunSwarmingTasks(params))
mock_fn.assert_called_once_with(master_name, builder_name,
build_number, failure_info, False)
def testCollectSwarmingTaskResultsError(self, mock_monitoring, *_):
master_name = 'm'
builder_name = 'b'
build_number = 15
params = CollectSwarmingTaskResultsInputs(build_key=BuildKey(
master_name=master_name,
builder_name=builder_name,
build_number=build_number),
build_completed=True)
steps = ['step1', 'step2']
task1 = WfSwarmingTask.Create(master_name, builder_name, build_number,
'step1')
task1.status = analysis_status.ERROR
task1.put()
task2 = WfSwarmingTask.Create(master_name, builder_name, build_number,
'step2')
task2.status = analysis_status.COMPLETED
task2.tests_statuses = {
'TestSuite1.test1': {
'total_run': 2,
'SUCCESS': 2
},
'TestSuite1.test2': {
'total_run': 4,
'SUCCESS': 2,
'FAILURE': 2
},
'TestSuite1.test3': {
'total_run': 6,
'FAILURE': 6
},
'TestSuite1.test4': {
'total_run': 6,
'SKIPPED': 6
},
'TestSuite1.test5': {
'total_run': 6,
'UNKNOWN': 6
}
}
task2.put()
expected_result_json = {
'consistent_failures': {
'step2': ['TestSuite1.test3', 'TestSuite1.test4']
}
}
self.assertEqual(
CollectSwarmingTaskResultsOutputs.FromSerializable(
expected_result_json),
test_swarming.GetConsistentFailuresWhenAllTasksComplete(
params, steps))
mock_monitoring.assert_called_once_with('step2', 'step2', 'skip', 1)
def testOnAbort(self, mock_mon):
heuristic_result = {'failure_info': {}, 'heuristic_result': {}}
params = StartTestTryJobInputs(
build_key=BuildKey(master_name='m',
builder_name='b',
build_number=1),
build_completed=True,
force=False,
heuristic_result=TestHeuristicAnalysisOutput.FromSerializable(
heuristic_result),
consistent_failures=None)
pipeline = StartTestTryJobPipeline(params)
pipeline.OnAbort(params)
self.assertFalse(mock_mon.called)
def testGetStepsToCollectSwarmingTaskResultsBuildNotComplete(
self, mock_fn):
master_name = 'm'
builder_name = 'b'
build_number = 14
params = CollectSwarmingTaskResultsInputs(build_key=BuildKey(
master_name=master_name,
builder_name=builder_name,
build_number=build_number),
build_completed=False)
self.assertEqual(
[], test_swarming.GetStepsToCollectSwarmingTaskResults(params))
self.assertFalse(mock_fn.called)
def testShouldTakeActionsOnCulprit(self, _):
master_name = 'm'
builder_name = 'b'
build_number = 124
culprits = DictOfBasestring()
culprits['r1'] = 'mockurlsafekey'
parameters = CulpritActionParameters(build_key=BuildKey(
master_name=master_name,
builder_name=builder_name,
build_number=build_number),
culprits=culprits,
heuristic_cls=ListOfBasestring())
self.assertTrue(
compile_culprit_action.ShouldTakeActionsOnCulprit(parameters))
def testSendNotificationToConfirmRevert(self, *_):
master_name = 'm'
builder_name = 'b'
build_number = 124
build_key = 'm/b/124'
cl_key = 'mockurlsafekey'
culprits = DictOfBasestring()
culprits['r1'] = cl_key
heuristic_cls = ListOfBasestring()
heuristic_cls.append(cl_key)
self.MockSynchronousPipeline(
CreateRevertCLPipeline,
CreateRevertCLParameters(cl_key=cl_key,
build_key=build_key,
failure_type=failure_type.COMPILE),
services_constants.CREATED_BY_FINDIT)
self.MockSynchronousPipeline(
SubmitRevertCLPipeline,
SubmitRevertCLParameters(
cl_key=cl_key,
revert_status=services_constants.CREATED_BY_FINDIT,
failure_type=failure_type.COMPILE),
services_constants.COMMITTED)
self.MockSynchronousPipeline(
SendNotificationToIrcPipeline,
SendNotificationToIrcParameters(
cl_key=cl_key,
revert_status=services_constants.CREATED_BY_FINDIT,
commit_status=services_constants.COMMITTED,
failure_type=failure_type.COMPILE), True)
self.MockSynchronousPipeline(
SendNotificationForCulpritPipeline,
SendNotificationForCulpritParameters(
cl_key=cl_key,
force_notify=True,
revert_status=services_constants.CREATED_BY_FINDIT,
failure_type=failure_type.COMPILE), True)
pipeline = wrapper_pipeline.RevertAndNotifyCompileCulpritPipeline(
CulpritActionParameters(build_key=BuildKey(
master_name=master_name,
builder_name=builder_name,
build_number=build_number),
culprits=culprits,
heuristic_cls=heuristic_cls,
failure_to_culprit_map=None))
pipeline.start(queue_name=constants.DEFAULT_QUEUE)
self.execute_queued_tasks()
def testGetStepsToCollectSwarmingTaskResults(self, mock_fn):
master_name = 'm'
builder_name = 'b'
build_number = 13
params = CollectSwarmingTaskResultsInputs(build_key=BuildKey(
master_name=master_name,
builder_name=builder_name,
build_number=build_number),
build_completed=True)
self.assertEqual(
['step'],
test_swarming.GetStepsToCollectSwarmingTaskResults(params))
mock_fn.assert_called_once_with(master_name, builder_name,
build_number)
def testGetFirstTimeTestFailuresToRunSwarmingTasksBailOut(self, mock_fn):
master_name = 'm'
builder_name = 'b'
build_number = 14
params = RunSwarmingTasksInput(
build_key=BuildKey(master_name=master_name,
builder_name=builder_name,
build_number=build_number),
heuristic_result=TestHeuristicAnalysisOutput.FromSerializable({}),
force=False)
self.assertEqual(
{},
test_swarming.GetFirstTimeTestFailuresToRunSwarmingTasks(params))
self.assertFalse(mock_fn.called)
def testOnSwarmingTaskStateChangedError(self, *_):
master_name = 'm'
builder_name = 'b'
build_number = 10
step_name = 's'
WfSwarmingTask.Create(master_name, builder_name, build_number,
step_name).put()
parameters = RunSwarmingTaskParameters(build_key=BuildKey(
master_name=master_name,
builder_name=builder_name,
build_number=build_number),
step_name=step_name,
tests=['test'])
self.assertFalse(
test_swarming.OnSwarmingTaskStateChanged(parameters, 'task_id'))
def testNotScheduleTryJobIfBuildNotCompleted(self):
heuristic_result = {
'failure_info': {},
'signals': {},
'heuristic_result': {}
}
start_try_job_params = StartCompileTryJobInput(
build_key=BuildKey(master_name='m',
builder_name='b',
build_number=1),
heuristic_result=CompileHeuristicAnalysisOutput.FromSerializable(
heuristic_result),
build_completed=False,
force=False)
pipeline = StartCompileTryJobPipeline(start_try_job_params)
result = pipeline.RunImpl(start_try_job_params)
self.assertEqual(list(result), [])
def RunImpl(self, pipeline_input):
master_name, builder_name, build_number = (
pipeline_input.build_key.GetParts())
build_failure_analysis.ResetAnalysisForANewAnalysis(
master_name,
builder_name,
build_number,
build_completed=pipeline_input.build_completed,
pipeline_status_path=self.pipeline_status_path,
current_version=appengine_util.GetCurrentVersion())
# TODO(crbug/869684): Use a gauge metric to track intermittent statuses.
# The yield statements below return PipelineFutures, which allow subsequent
# pipelines to refer to previous output values.
# https://github.com/GoogleCloudPlatform/appengine-pipelines/wiki/Python
# Heuristic Approach.
heuristic_params = CompileHeuristicAnalysisParameters(
failure_info=pipeline_input.current_failure_info,
build_completed=pipeline_input.build_completed)
heuristic_result = yield HeuristicAnalysisForCompilePipeline(
heuristic_params)
# Try job approach.
# Checks if first time failures happen and starts a try job if yes.
with pipelines.pipeline.InOrder():
start_compile_try_job_input = self.CreateInputObjectInstance(
StartCompileTryJobInput,
build_key=BuildKey(master_name=master_name,
builder_name=builder_name,
build_number=build_number),
heuristic_result=heuristic_result,
build_completed=pipeline_input.build_completed,
force=pipeline_input.force)
yield StartCompileTryJobPipeline(start_compile_try_job_input)
# Report event to BQ.
report_event_input = self.CreateInputObjectInstance(
report_event_pipeline.ReportEventInput,
analysis_urlsafe_key=WfAnalysis.Get(
master_name, builder_name, build_number).key.urlsafe())
if not pipeline_input.force:
yield report_event_pipeline.ReportAnalysisEventPipeline(
report_event_input)
def testUpdateAbortedAnalysisNoTryJob(self):
master_name = 'm'
builder_name = 'b'
build_number = 124
parameter = AnalyzeCompileFailureInput(
build_key=BuildKey(master_name=master_name,
builder_name=builder_name,
build_number=build_number),
current_failure_info=CompileFailureInfo.FromSerializable({}),
build_completed=False,
force=True)
WfAnalysis.Create(master_name, builder_name, build_number).put()
analysis, run_try_job, heuristic_aborted = (
build_failure_analysis.UpdateAbortedAnalysis(parameter))
self.assertEqual(analysis_status.ERROR, analysis.status)
self.assertTrue(analysis.aborted)
self.assertFalse(run_try_job)
self.assertTrue(heuristic_aborted)
