def testAddBuildStep(self):
t1 = datetime(2016, 10, 1, 0, 0, 0)
t2 = datetime(2016, 10, 2, 0, 0, 0)
t3 = datetime(2016, 10, 2, 1, 0, 0)
t4 = datetime(2016, 10, 2, 0, 30, 0)
request = FlakeAnalysisRequest.Create('flaky_test', False, 123)
self.assertTrue(request.AddBuildStep('m', 'b1', 1, 's', t1))
self.assertTrue(request.AddBuildStep('m', 'b2', 10, 's', t2))
self.assertFalse(request.AddBuildStep('m', 'b2', 11, 's', t3))
self.assertTrue(request.AddBuildStep('m', 'b2', 9, 's', t4))
self.assertEqual(2, len(request.build_steps), request.build_steps)
self.assertEqual(BuildStep.Create('m', 'b1', 1, 's', t1),
request.build_steps[0])
self.assertEqual(BuildStep.Create('m', 'b2', 9, 's', t4),
request.build_steps[1])
def setUp(self):
super(StepMapperTest, self).setUp()
self.http_client = FinditHttpClient()
self.master_name = 'tryserver.m'
self.wf_master_name = 'm'
self.builder_name = 'b'
self.build_number = 123
self.step_name = 'browser_tests on platform'
self.build_step = BuildStep.Create(self.master_name, self.builder_name,
self.build_number, self.step_name, None)
self.build_step.put()
self.wf_build_step = BuildStep.Create(self.wf_master_name,
self.builder_name, self.build_number,
self.step_name, None)
self.wf_build_step.put()
def testNeedNewAnalysisWithTooOldPreviousAnalysis(self):
existing_request = FlakeAnalysisRequest.Create('flake', False, None)
step1 = BuildStep.Create('m', 'b1', 11, 's', datetime(2016, 10, 01))
step1.swarmed = True
step1.supported = True
step1.scheduled = True
step2 = BuildStep.Create('m', 'b2', 12, 's', datetime(2016, 10, 01))
step2.swarmed = True
step2.supported = True
step2.scheduled = True
existing_request.supported = True
existing_request.swarmed = True
existing_request.user_emails = ['*****@*****.**']
existing_request.build_steps = [step1, step2]
existing_request.Save()
request = FlakeAnalysisRequest.Create('flake', False, 123)
step3 = BuildStep.Create('m', 'b2', 80, 's', datetime(2016, 10, 20))
step3.swarmed = True
step3.supported = True
request.build_steps = [step3]
request.user_emails = ['*****@*****.**']
version, step = flake_analysis_service._CheckForNewAnalysis(request)
self.assertEqual(1, version)
self.assertIsNotNone(step)
self.assertEqual(80, step.build_number)
request = FlakeAnalysisRequest.GetVersion(key='flake')
self.assertEqual(['*****@*****.**', '*****@*****.**'],
request.user_emails)
def testBuildStapHasMatchingWaterfallStep(self):
build_step = BuildStep.Create('m', 'b', 0, 's', datetime.utcnow())
self.assertFalse(build_step.has_matching_waterfall_step)
build_step.wf_master_name = 'm'
build_step.wf_builder_name = 'b'
build_step.wf_build_number = 0
build_step.wf_step_name = 's'
self.assertTrue(build_step.has_matching_waterfall_step)
def testUnauthorizedAccess(self):
request = FlakeAnalysisRequest.Create('flake', False, 123)
step = BuildStep.Create('m', 'b2', 80, 's', datetime(2016, 10, 20))
request.build_steps = [step]
self.assertIsNone(
flake_analysis_service.ScheduleAnalysisForFlake(
request, '*****@*****.**', False, triggering_sources.FINDIT_UI))
def testAuthorizedAccessAndNewAnalysisNeededButNotTriggered(
self, mock_mon, _):
step = BuildStep.Create('m', 'b', 80, 's', datetime(2016, 10, 20))
step.step_metadata = {
'isolate_target_name': 'wf_s',
'canonical_step_name': 'wf_s'
}
flake = Flake.Create('chromium', 's', 't', 'l')
request = FlakeAnalysisRequest.Create('flake', False, 123)
request.flake_key = flake.key
request.build_steps = [step]
user_email = '*****@*****.**'
triggering_source = triggering_sources.FINDIT_UI
def CheckForNewAnalysis(*_):
step.wf_master_name = 'wf_m'
step.wf_builder_name = 'wf_b'
step.wf_build_number = 100
step.wf_step_name = 'wf_s'
return 1, step
normalized_test = TestInfo('wf_m', 'wf_b', 100, 'wf_s', 'flake')
original_test = TestInfo('m', 'b', 80, 's', 'flake')
with mock.patch.object(
flake_analysis_service,
'_CheckForNewAnalysis',
side_effect=CheckForNewAnalysis) as (
mocked_CheckForNewAnalysis), mock.patch.object(
flake_analysis_service.initialize_flake_pipeline,
'ScheduleAnalysisIfNeeded',
return_value=None) as (
mocked_ScheduleAnalysisIfNeeded), mock.patch.object(
flake_analysis_service.FlakeAnalysisRequest,
'GetVersion',
return_value=None) as mocked_GetVersion:
self.assertFalse(
flake_analysis_service.ScheduleAnalysisForFlake(
request, user_email, True, triggering_sources.FINDIT_UI))
mocked_CheckForNewAnalysis.assert_called_once_with(request, False)
mocked_ScheduleAnalysisIfNeeded.assert_called_once_with(
normalized_test,
original_test,
flake.key,
bug_id=123,
allow_new_analysis=True,
manually_triggered=False,
user_email=user_email,
triggering_source=triggering_source,
queue_name=constants.WATERFALL_ANALYSIS_QUEUE,
force=False)
self.assertFalse(mocked_GetVersion.called)
mock_mon.assert_called_once_with(
source='waterfall',
operation='error',
trigger='auto',
canonical_step_name='wf_s',
isolate_target_name='wf_s')
def testBailoutForAndroidAndFuchsia(self, *_):
step1 = BuildStep.Create('m', 'Win10 Tests x64 (dbg)', 80, 's',
datetime(2016, 10, 20))
step2 = BuildStep.Create('m', 'Fuchsia t', 80, 's', datetime(2016, 10, 20))
request = FlakeAnalysisRequest.Create('flake', False, 123)
request.build_steps = [step1, step2]
def FindMatchingWaterfallStep(step, _):
step.wf_master_name = step.master_name
step.wf_builder_name = step.builder_name
step.wf_build_number = 100
step.wf_step_name = 'step'
with mock.patch.object(
flake_analysis_service.step_mapper,
'FindMatchingWaterfallStep',
side_effect=FindMatchingWaterfallStep):
self.assertIsNone(
flake_analysis_service.ScheduleAnalysisForFlake(
request, '*****@*****.**', True,
triggering_sources.FINDIT_API))
def testAuthorizedAccessButNoNewAnalysisNeeded(self, mock_mon, *_):
request = FlakeAnalysisRequest.Create('flake', False, 123)
step = BuildStep.Create('m', 'b2', 80, 's', datetime(2016, 10, 20))
request.build_steps = [step]
self.assertFalse(
flake_analysis_service.ScheduleAnalysisForFlake(
request, '*****@*****.**', True, triggering_sources.FINDIT_UI))
mock_mon.assert_called_once_with(
source='waterfall',
operation='skip',
trigger='auto',
canonical_step_name='unknown',
isolate_target_name='unknown')
def testGetNormalizedConfigurationNames(self):
master_name = 'm'
builder_name = 'b'
build_number = 123
step_name = 's'
test_name = 't'
reported_time = datetime(2016, 11, 16)
request = FlakeAnalysisRequest.Create(test_name, False, 123)
build_step = BuildStep.Create(master_name, builder_name, build_number,
step_name, reported_time)
build_step.wf_master_name = master_name
build_step.wf_builder_name = builder_name
build_step.wf_build_number = build_number
build_step.wf_step_name = step_name
request.build_steps.append(build_step)
self.assertEqual((None, None),
request._GetNormalizedConfigurationNames('m2', 'b2'))
self.assertEqual(
(master_name, builder_name),
request._GetNormalizedConfigurationNames(master_name,
builder_name))