def ReviveOrCreateTryJobEntity(master_name, builder_name, build_number,
force_try_job):
"""Checks try job entity to further determine if need a new try job.
* If there is an entity for a running or completed try job, no need for new
job.
* If there is an entity for a failed try job, revive the entity and start a
new job.
* If there is no entity, create one.
Returns:
A bool to indicate if a try job entity is revived or created.
The try job entities' key.
"""
try_job_entity_revived_or_created = True
try_job = WfTryJob.Get(master_name, builder_name, build_number)
if try_job:
if try_job.failed or force_try_job:
try_job.status = analysis_status.PENDING
try_job.put()
else:
try_job_entity_revived_or_created = False
else:
try_job = WfTryJob.Create(master_name, builder_name, build_number)
try_job.put()
return try_job_entity_revived_or_created, try_job.key.urlsafe()
def testProperties(self):
master_name = 'm'
builder_name = 'b'
try_job = WfTryJob.Create(master_name, builder_name, 123)
self.assertEqual(master_name, try_job.master_name)
self.assertEqual(builder_name, try_job.builder_name)
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 testGetTryJobResultForCompileOnlyReturnUrlIfStarts(self):
try_job = WfTryJob.Create(self.master_name, self.builder_name,
self.build_number)
try_job.status = analysis_status.RUNNING
try_job.compile_results = [{
'result':
None,
'url': ('http://build.chromium.org/p/tryserver.chromium.linux/'
'builders/linux_chromium_variable/builds/121')
}]
try_job.put()
result = handlers_util._GetTryJobResultForCompile(
{'compile': 'm/b/121'})
expected_result = {
'compile': {
'try_jobs': [{
'try_job_key':
'm/b/121',
'status':
analysis_status.RUNNING,
'try_job_build_number':
121,
'try_job_url':
('http://build.chromium.org/p/tryserver.chromium.'
'linux/builders/linux_chromium_variable/builds/121')
}]
}
}
self.assertEqual(expected_result, result)
def testNotNeedANewWaterfallTryJobIfNoNewFailure(self, mock_fn):
master_name = 'm'
builder_name = 'b'
build_number = 223
failure_info = {
'failed_steps': {
'a': {
'current_failure': 223,
'first_failure': 222,
'last_pass': 221,
'tests': {
'a.t2': {
'current_failure': 223,
'first_failure': 222,
'last_pass': 221
}
}
}
},
'failure_type': failure_type.TEST
}
analysis = WfAnalysis.Create(master_name, builder_name, build_number)
analysis.failure_result_map = {'a': {'a.t2': 'm/b/222'}}
analysis.put()
mock_fn.return_value = False
expected_try_job_key = WfTryJob.Create(master_name, builder_name,
build_number).key
need_try_job, try_job_key = try_job_util.NeedANewWaterfallTryJob(
master_name, builder_name, build_number, failure_info, None, None)
self.assertFalse(need_try_job)
self.assertEqual(expected_try_job_key, try_job_key)
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 testGetTryJobResultForCompileNonBuildbot(self):
try_job = WfTryJob.Create(self.master_name, self.builder_name,
self.build_number)
try_job.status = analysis_status.RUNNING
try_job.compile_results = [{
'result': None,
'url': 'https://luci-milo.appspot.com/swarming/task/3639e',
'try_job_id': '12341234'
}]
try_job.put()
result = handlers_util._GetTryJobResultForCompile(
{'compile': 'm/b/121'})
expected_result = {
'compile': {
'try_jobs': [{
'try_job_key':
'm/b/121',
'status':
analysis_status.RUNNING,
'try_job_build_number':
'12341234',
'try_job_url':
'https://luci-milo.appspot.com/swarming/task/3639e',
}]
}
}
self.assertEqual(expected_result, result)
def testNotNeedANewWaterfallTryJobForOtherType(self, mock_fn):
master_name = 'm'
builder_name = 'b'
build_number = 223
failure_info = {
'master_name': master_name,
'builder_name': builder_name,
'build_number': build_number,
'failed_steps': {},
'builds': {
'222': {
'blame_list': ['222-1'],
'chromium_revision': '222-1'
},
'223': {
'blame_list': ['223-1', '223-2', '223-3'],
'chromium_revision': '223-3'
}
},
'failure_type': failure_type.UNKNOWN
}
mock_fn.return_value = False
expected_try_job_key = WfTryJob.Create(master_name, builder_name,
build_number).key
need_try_job, try_job_key = try_job_util.NeedANewWaterfallTryJob(
master_name, builder_name, build_number, failure_info, None, None)
self.assertFalse(need_try_job)
self.assertEqual(expected_try_job_key, try_job_key)
def testGetCulpritInfoForTryJobResultForTestTryJobNoResult(self):
try_job_key = 'm/b/119'
culprits_info = {
'step1 on platform': {
'try_jobs': [{
'ref_name': 'step1',
'try_job_key': try_job_key,
'tests': ['test2', 'test3']
}]
}
}
WfTryJob.Create('m', 'b', '119').put()
handlers_util._GetCulpritInfoForTryJobResultForTest(
try_job_key, culprits_info)
expected_culprits_info = {
'step1 on platform': {
'try_jobs': [{
'ref_name': 'step1',
'try_job_key': try_job_key,
'tests': ['test2', 'test3'],
'status': analysis_status.PENDING
}]
}
}
self.assertEqual(expected_culprits_info, culprits_info)
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 testGetWaterfallTryJobs(self):
try_job_completed = WfTryJobData.Create(3)
try_job_completed.try_job_key = WfTryJob.Create('m', 'b', 3).key
try_job_completed.try_job_type = 'compile'
try_job_completed.start_time = datetime(2016, 5, 4, 0, 0, 1)
try_job_completed.request_time = datetime(2016, 5, 4, 0, 0, 0)
try_job_completed.created_time = datetime(2016, 5, 4, 0, 0, 0)
try_job_completed.end_time = datetime(2016, 5, 4, 0, 0, 2)
try_job_completed.try_job_url = 'url3'
try_job_completed.culprits = {'compile': {'12345': 'failed'}}
try_job_completed.last_buildbucket_response = {'status': 'COMPLETED'}
try_job_completed.put()
expected_try_job_completed_display_data = {
'master_name': 'm',
'builder_name': 'b',
'build_number': 3,
'try_job_type': 'compile',
'request_time': '2016-05-04 00:00:00 UTC',
'try_job_url': 'url3',
'culprit_found': True,
'last_buildbucket_response': '{"status": "COMPLETED"}'
}
response = self.test_app.get(
('/try-job-dashboard?format=json&start_date=2016-05-03&'
'category=waterfall'))
response_data = response.json_body
successfully_completed_try_jobs = response_data.get(
'successfully_completed_try_jobs')
self.assertEqual(response.status_int, 200)
self.validateTryJobDisplayData(
[expected_try_job_completed_display_data],
successfully_completed_try_jobs)
def testGetStatusAndCulpritFromTryJobTryJobFailed(self):
try_job = WfTryJob.Create('m', 'b', 123)
try_job.status = analysis_status.ERROR
try_job.put()
status, culprit = findit_api.FindItApi(
)._GetStatusAndCulpritFromTryJob(try_job, None, None, None, None)
self.assertEqual(status, findit_api._TryJobStatus.FINISHED)
self.assertIsNone(culprit)
def testCompileTryJob(self, mock_module):
master_name = 'm'
builder_name = 'b'
build_number = 1
try_job_type = failure_type.COMPILE
failure_info = {
'failure_type': try_job_type,
'builds': {
'0': {
'blame_list': ['r0', 'r1'],
'chromium_revision': 'r1'
},
'1': {
'blame_list': ['r2'],
'chromium_revision': 'r2'
}
},
'failed_steps': {
'compile': {
'first_failure': 1,
'last_pass': 0
}
}
}
good_revision = 'r1'
bad_revision = 'r2'
try_job = WfTryJob.Create('m', 'b', 1)
try_job.put()
mock_module.NeedANewWaterfallTryJob.return_value = True, try_job.key
mock_module.GetFailedTargetsFromSignals.return_value = {}
self.MockPipeline(
start_try_job_on_demand_pipeline.ScheduleCompileTryJobPipeline,
'try_job_id',
expected_args=[
master_name, builder_name, build_number, good_revision,
bad_revision, try_job_type, {}, []
],
expected_kwargs={})
self.MockPipeline(
start_try_job_on_demand_pipeline.MonitorTryJobPipeline,
'try_job_result',
expected_args=[try_job.key.urlsafe(), try_job_type, 'try_job_id'],
expected_kwargs={})
self.MockPipeline(
start_try_job_on_demand_pipeline.IdentifyTryJobCulpritPipeline,
'final_result',
expected_args=[
master_name, builder_name, build_number, ['r2'], try_job_type,
'try_job_id', 'try_job_result'
],
expected_kwargs={})
pipeline = StartTryJobOnDemandPipeline()
result = pipeline.run('m', 'b', 1, failure_info, {}, {}, True, False)
self.assertNotEqual(list(result), [])
def testGetTryJobResultWhenTryJobCompleted(self):
analysis = WfAnalysis.Create(self.master_name, self.builder_name,
self.build_number)
analysis.failure_result_map = {'compile': 'm/b/121'}
analysis.put()
try_job = WfTryJob.Create(self.master_name, self.builder_name,
self.build_number)
try_job.status = analysis_status.COMPLETED
try_job.compile_results = [{
'report': {
'result': {
'rev1': 'passed',
'rev2': 'failed'
}
},
'try_job_id':
'm/b/121',
'url': ('http://build.chromium.org/p/tryserver.chromium.'
'linux/builders/linux_chromium_variable/builds/121'),
'culprit': {
'compile': {
'revision': 'rev2',
'commit_position': '2',
'review_url': 'url_2'
}
}
}]
try_job.put()
result = handlers_util.GetAllTryJobResults(self.master_name,
self.builder_name,
self.build_number)
expected_result = {
'compile': {
'try_jobs': [{
'try_job_key':
'm/b/121',
'status':
analysis_status.COMPLETED,
'try_job_build_number':
121,
'try_job_url':
('http://build.chromium.org/p/tryserver.chromium.'
'linux/builders/linux_chromium_variable/builds/121'),
'culprit': {
'revision': 'rev2',
'commit_position': '2',
'review_url': 'url_2'
}
}]
}
}
self.assertEqual(expected_result, result)
def testUpdateTryJobMetadataForBuildError(self):
error_data = {'reason': 'BUILD_NOT_FOUND', 'message': 'message'}
error = buildbucket_client.BuildbucketError(error_data)
try_job_data = WfTryJobData.Create('1')
try_job_data.try_job_key = WfTryJob.Create('m', 'b', 123).key
monitor_try_job_pipeline._UpdateTryJobMetadata(try_job_data,
failure_type.COMPILE,
None, error, False)
self.assertEqual(try_job_data.error, error_data)
def testSuccessfullyScheduleNewTryJobForCompileWithSuspectedRevisions(
self, mock_module):
master_name = 'm'
builder_name = 'b'
build_number = 223
good_revision = 'rev1'
bad_revision = 'rev2'
build_id = '1'
url = 'url'
build = WfBuild.Create(master_name, builder_name, build_number)
build.data = {
'properties': {
'parent_mastername': 'pm',
'parent_buildername': 'pb'
}
}
build.put()
response = {
'build': {
'id': build_id,
'url': url,
'status': 'SCHEDULED',
}
}
results = [(None,
buildbucket_client.BuildbucketBuild(response['build']))]
mock_module.TriggerTryJobs.return_value = results
WfTryJob.Create(master_name, builder_name, build_number).put()
try_job_pipeline = ScheduleCompileTryJobPipeline()
try_job_id = try_job_pipeline.run(master_name, builder_name,
build_number, good_revision,
bad_revision, failure_type.COMPILE,
None, ['r5'], None, None)
try_job = WfTryJob.Get(master_name, builder_name, build_number)
try_job_data = WfTryJobData.Get(build_id)
expected_try_job_id = '1'
self.assertEqual(expected_try_job_id, try_job_id)
self.assertEqual(expected_try_job_id,
try_job.compile_results[-1]['try_job_id'])
self.assertTrue(expected_try_job_id in try_job.try_job_ids)
self.assertIsNotNone(try_job_data)
self.assertEqual(try_job_data.master_name, master_name)
self.assertEqual(try_job_data.builder_name, builder_name)
self.assertEqual(try_job_data.build_number, build_number)
self.assertEqual(
try_job_data.try_job_type,
failure_type.GetDescriptionForFailureType(failure_type.COMPILE))
self.assertFalse(try_job_data.has_compile_targets)
self.assertTrue(try_job_data.has_heuristic_results)
def testProperties(self):
master_name = 'm'
builder_name = 'b'
build_number = 123
try_job_id = 'try_job_id'
try_job = WfTryJob.Create(master_name, builder_name, build_number)
try_job_data = WfTryJobData.Create(try_job_id)
try_job_data.try_job_key = try_job.key
self.assertEqual(master_name, try_job_data.master_name)
self.assertEqual(builder_name, try_job_data.builder_name)
self.assertEqual(build_number, try_job_data.build_number)
def testGet(self):
master_name = 'm'
builder_name = 'b'
build_number = 123
try_job_id = 'try_job_id'
try_job_before = WfTryJob.Create(master_name, builder_name,
build_number)
try_job_before.try_job_ids = [try_job_id]
try_job_before.put()
try_job_after = WfTryJob.Get(master_name, builder_name, build_number)
self.assertEqual([try_job_id], try_job_after.try_job_ids)
def testReturnNoneIfNoTryJobId(self):
master_name = 'm'
builder_name = 'b'
build_number = 1
pipeline = MonitorTryJobPipeline()
pipeline.start_test()
try_job = WfTryJob.Create(master_name, builder_name, build_number)
pipeline.run(try_job.key.urlsafe(), failure_type.TEST, None)
# Reload from ID to get all internal properties in sync.
pipeline = MonitorTryJobPipeline.from_id(pipeline.pipeline_id)
pipeline.finalized()
test_result = pipeline.outputs.default.value
self.assertIsNone(test_result)
def testUpdateTryJobMetadata(self):
try_job_id = '1'
url = 'url'
build_data = {
'id': try_job_id,
'url': url,
'status': 'COMPLETED',
'completed_ts': '1454367574000000',
'created_ts': '1454367570000000',
}
report = {
'result': {
'rev1': 'passed',
'rev2': 'failed'
},
'metadata': {
'regression_range_size': 2
}
}
build = buildbucket_client.BuildbucketBuild(build_data)
expected_error_dict = {
'message':
'Try job monitoring was abandoned.',
'reason':
('Timeout after %s hours' %
waterfall_config.GetTryJobSettings().get('job_timeout_hours'))
}
try_job_data = WfTryJobData.Create(try_job_id)
try_job_data.try_job_key = WfTryJob.Create('m', 'b', 123).key
monitor_try_job_pipeline._UpdateTryJobMetadata(try_job_data,
failure_type.COMPILE,
build, None, False,
report)
try_job_data = WfTryJobData.Get(try_job_id)
self.assertIsNone(try_job_data.error)
self.assertEqual(try_job_data.regression_range_size, 2)
self.assertEqual(try_job_data.number_of_commits_analyzed, 2)
self.assertEqual(try_job_data.end_time,
datetime(2016, 2, 1, 22, 59, 34))
self.assertEqual(try_job_data.request_time,
datetime(2016, 2, 1, 22, 59, 30))
self.assertEqual(try_job_data.try_job_url, url)
monitor_try_job_pipeline._UpdateTryJobMetadata(try_job_data,
failure_type.COMPILE,
build, None, True)
self.assertEqual(try_job_data.error, expected_error_dict)
self.assertEqual(try_job_data.error_code, try_job_error.TIMEOUT)
def _CreateEntities(
self, master_name, builder_name, build_number, try_job_id,
try_job_status=None, compile_results=None, test_results=None):
try_job = WfTryJob.Create(master_name, builder_name, build_number)
if try_job_status:
try_job.status = try_job_status
if compile_results:
try_job.compile_results = compile_results
if test_results:
try_job.test_results = test_results
try_job.put()
try_job_data = WfTryJobData.Create(try_job_id)
try_job_data.try_job_key = try_job.key
try_job_data.put()
def testUpdateTryJobResultAnalyzing(self):
master_name = 'm'
builder_name = 'b'
build_number = 1
try_job_id = '3'
try_job = WfTryJob.Create(master_name, builder_name, build_number)
try_job.put()
pipeline = MonitorTryJobPipeline()
pipeline._UpdateTryJobResult(
try_job.key.urlsafe(), failure_type.TEST, try_job_id, 'url',
buildbucket_client.BuildbucketBuild.STARTED)
try_job = WfTryJob.Get(master_name, builder_name, build_number)
self.assertEqual(analysis_status.RUNNING, try_job.status)
def _ReviveOrCreateTryJobEntity(master_name, builder_name, build_number,
force_try_job):
try_job_entity_revived_or_created = True
try_job = WfTryJob.Get(master_name, builder_name, build_number)
if try_job:
if try_job.failed or force_try_job:
try_job.status = analysis_status.PENDING
try_job.put()
else:
try_job_entity_revived_or_created = False
else:
try_job = WfTryJob.Create(master_name, builder_name, build_number)
try_job.put()
return try_job_entity_revived_or_created, try_job.key
def testForceTryJob(self):
master_name = 'm'
builder_name = 'b'
build_number = 223
failure_info = {
'failed_steps': {
'a': {
'current_failure': 223,
'first_failure': 223,
'last_pass': 222,
'tests': {
'a.t2': {
'current_failure': 223,
'first_failure': 223,
'last_pass': 222
}
}
}
},
'builds': {
'222': {
'blame_list': ['222-1'],
'chromium_revision': '222-1'
},
'223': {
'blame_list': ['223-1', '223-2', '223-3'],
'chromium_revision': '223-3'
}
},
'failure_type': failure_type.TEST
}
try_job = WfTryJob.Create(master_name, builder_name, build_number)
try_job.compile_results = [['rev', 'failed']]
try_job.status = analysis_status.COMPLETED
try_job.put()
analysis = WfAnalysis.Create(master_name, builder_name, build_number)
analysis.failure_result_map = {'a': {'a.t2': 'm/b/223'}}
analysis.put()
need_try_job, try_job_key = try_job_util.NeedANewWaterfallTryJob(
master_name, builder_name, build_number, failure_info, None, None,
True)
self.assertTrue(need_try_job)
self.assertEqual(try_job_key, try_job.key)
def testGetBuildbotLink(self):
try_job_completed = WfTryJobData.Create(3)
try_job_completed.try_job_key = WfTryJob.Create('m', 'b', 3).key
try_job_completed.try_job_type = 'compile'
try_job_completed.start_time = datetime(2016, 5, 4, 0, 0, 1)
try_job_completed.request_time = datetime(2016, 5, 4, 0, 0, 0)
try_job_completed.created_time = datetime(2016, 5, 4, 0, 0, 0)
try_job_completed.end_time = datetime(2016, 5, 4, 0, 0, 2)
try_job_completed.try_job_url = 'url3'
try_job_completed.culprits = {'compile': {'12345': 'failed'}}
try_job_completed.last_buildbucket_response = {'status': 'COMPLETED'}
try_job_completed.put()
response = self.test_app.get(
('/try-job-dashboard?start_date=2016-05-03&category=waterfall'))
self.assertEqual(response.status_int, 200)
self.assertIn('buildbot link', response.body)
def testNotNeedANewWaterfallTryJobIfNotFirstTimeFailure(self, mock_fn):
master_name = 'm'
builder_name = 'b'
build_number = 223
WfAnalysis.Create(master_name, builder_name, build_number).put()
failure_info = {
'master_name': master_name,
'builder_name': builder_name,
'build_number': build_number,
'failed_steps': {
'compile': {
'current_failure': 223,
'first_failure': 221,
'last_pass': 220
}
},
'builds': {
'220': {
'blame_list': ['220-1', '220-2'],
'chromium_revision': '220-2'
},
'221': {
'blame_list': ['221-1', '221-2'],
'chromium_revision': '221-2'
},
'222': {
'blame_list': ['222-1'],
'chromium_revision': '222-1'
},
'223': {
'blame_list': ['223-1', '223-2', '223-3'],
'chromium_revision': '223-3'
}
},
'failure_type': failure_type.COMPILE
}
WfAnalysis.Create(master_name, builder_name, build_number).put()
mock_fn.return_value = False
expected_key = WfTryJob.Create(master_name, builder_name,
build_number).key
need_try_job, try_job_key = try_job_util.NeedANewWaterfallTryJob(
master_name, builder_name, build_number, failure_info, None, None)
self.assertFalse(need_try_job)
self.assertEqual(expected_key, try_job_key)
def testGetTryJobResultForCompileOnlyReturnStatusNoResult(self):
WfTryJob.Create(self.master_name, self.builder_name,
self.build_number).put()
result = handlers_util._GetTryJobResultForCompile(
{'compile': 'm/b/121'})
expected_result = {
'compile': {
'try_jobs': [{
'try_job_key': 'm/b/121',
'status': analysis_status.PENDING
}]
}
}
self.assertEqual(expected_result, result)
def testPrepareTryJobDataForCompileFailure(self):
analysis = WfAnalysis.Create('m', 'b', 123)
analysis.result = {
'failures': [
{
'step_name': 'compile',
'first_failure': 122,
'last_pass': 121,
'suspected_cls': [],
},
{
'step_name': 'steps',
},
]
}
analysis.failure_result_map = {
'compile': 'm/b/122',
}
try_job = WfTryJob.Create('m', 'b', 122)
try_job.status = analysis_status.COMPLETED
try_job.compile_results = [{
'url': 'build/url',
'culprit': {
'compile': {
'revision': 'rev',
}
}
}]
try_job.put()
expected_try_job_data = {
'status': 'completed',
'url': 'build/url',
'completed': True,
'failed': False,
'culprit': {
'revision': 'rev',
}
}
try_job_data = (
build_failure._PrepareTryJobDataForCompileFailure(analysis))
self.assertEqual(expected_try_job_data, try_job_data)
def testSuccessfullyScheduleNewTryJobForTest(self, mock_module):
master_name = 'm'
builder_name = 'b'
build_number = 223
good_revision = 'rev1'
bad_revision = 'rev2'
targeted_tests = ['a on platform', ['a', ['test1', 'test2']]]
build_id = '1'
build = WfBuild.Create(master_name, builder_name, build_number)
build.data = {'properties': {'parent_mastername': 'pm',
'parent_buildername': 'pb'}}
build.put()
response = {
'build': {
'id': build_id,
'url': 'url',
'status': 'SCHEDULED',
}
}
results = [(None, buildbucket_client.BuildbucketBuild(response['build']))]
mock_module.TriggerTryJobs.return_value = results
WfTryJob.Create(master_name, builder_name, build_number).put()
try_job_pipeline = ScheduleTestTryJobPipeline()
try_job_id = try_job_pipeline.run(
master_name, builder_name, build_number, good_revision, bad_revision,
failure_type.TEST, None, None, None, targeted_tests)
try_job = WfTryJob.Get(master_name, builder_name, build_number)
self.assertEqual(try_job_id, build_id)
self.assertEqual(try_job.test_results[-1]['try_job_id'], build_id)
try_job_data = WfTryJobData.Get(try_job_id)
self.assertIsNotNone(try_job_data)
self.assertEqual(try_job_data.master_name, master_name)
self.assertEqual(try_job_data.builder_name, builder_name)
self.assertEqual(try_job_data.build_number, build_number)
self.assertEqual(
try_job_data.try_job_type,
failure_type.GetDescriptionForFailureType(failure_type.TEST))
self.assertFalse(try_job_data.has_compile_targets)
self.assertFalse(try_job_data.has_heuristic_results)
def testGetCulpritInfoForTryJobResultForTestTryJobRunning(self):
try_job_key = 'm/b/119'
culprits_info = {
'step1 on platform': {
'try_jobs': [{
'ref_name': 'step1',
'try_job_key': try_job_key,
'tests': ['test2', 'test3']
}]
}
}
try_job = WfTryJob.Create('m', 'b', '119')
try_job.status = analysis_status.RUNNING
try_job.test_results = [{
'url': ('http://build.chromium.org/p/tryserver.chromium.'
'linux/builders/linux_chromium_variable/builds/121'),
'try_job_id':
'121'
}]
try_job.put()
handlers_util._GetCulpritInfoForTryJobResultForTest(
try_job_key, culprits_info)
expected_culprits_info = {
'step1 on platform': {
'try_jobs': [{
'ref_name':
'step1',
'try_job_key':
try_job_key,
'tests': ['test2', 'test3'],
'status':
analysis_status.RUNNING,
'try_job_url':
('http://build.chromium.org/p/tryserver.chromium.'
'linux/builders/linux_chromium_variable/builds/121'),
'try_job_build_number':
121
}]
}
}
self.assertEqual(expected_culprits_info, culprits_info)