def GetFlake(luci_project, original_step_name, original_test_name, master_name,
builder_name, build_number):
"""Returns an existing Flake or creates one as needed.
Args:
luci_project (str): The project being analyzed, e.g. 'chromium'.
original_step_name (str): The original step name which may contain hardware
information and 'with(out) patch' etc. suffixes.
original_test_name (str): The original test name.
master_name (str): Master name of the build of the step.
builder_name (str): Builder name of the build of the step.
build_number (int): Build number of the build of the step.
"""
normalized_step_name = Flake.LegacyNormalizeStepName(
original_step_name, master_name, builder_name, build_number)
normalized_test_name = Flake.NormalizeTestName(original_test_name,
original_step_name)
flake = Flake.Get(luci_project, normalized_step_name, normalized_test_name)
if not flake: # pragma: no branch
label = Flake.GetTestLabelName(original_test_name, original_step_name)
flake = Flake.Create(luci_project, normalized_step_name,
normalized_test_name, label)
flake.put()
return flake
def testNormalizeTestName(self):
self.assertEqual('suite.test', Flake.NormalizeTestName('suite.test'))
self.assertEqual('suite.test',
Flake.NormalizeTestName('a/suite.test/0', ))
self.assertEqual('suite.test', Flake.NormalizeTestName('suite.test/1'))
self.assertEqual('suite.test', Flake.NormalizeTestName('suite.test/*'))
self.assertEqual('suite.test',
Flake.NormalizeTestName('*/suite.test/*'))
self.assertEqual('suite.test',
Flake.NormalizeTestName('suite.PRE_PRE_test'))
self.assertEqual('suite.test',
Flake.NormalizeTestName('a/suite.PRE_PRE_test/0'))
self.assertEqual('a/b/c/d.html',
Flake.NormalizeTestName('a/b/c/d.html'))
self.assertEqual('a/b/c/d.html',
Flake.NormalizeTestName('a/b/c/d.html?1000-2000'))
self.assertEqual('a/b/c/d.html',
Flake.NormalizeTestName('a/b/c/d.html?*'))
def _GetIssueGenerator(self, new_issue=True):
luci_project = 'chromium'
normalized_step_name = 'step'
flake0 = Flake.Create(luci_project, normalized_step_name, 'suite.test0',
'suite.test0')
flake0.tags = ['component::Blink']
flake0.put()
flake1 = Flake.Create(luci_project, normalized_step_name, 'suite.test1',
'suite.test1')
flake1.tags = ['component::Blink/Infra']
flake1.put()
flake2 = Flake.Create(luci_project, normalized_step_name, 'suite.test2',
'suite.test2')
flake2.put()
flake3 = Flake.Create(luci_project, 'other_step', 'other_test',
'other_test')
flake3.put()
issue_generator_new = issue_generator.FlakeDetectionGroupIssueGenerator(
flakes=[flake0, flake1, flake2],
num_occurrences=5,
canonical_step_name=normalized_step_name)
flake_issue = FlakeIssue.Create(luci_project, 12345)
flake_issue.put()
issue_generator_old = issue_generator.FlakeDetectionGroupIssueGenerator(
flakes=[flake1, flake2, flake3],
num_occurrences=5,
flake_issue=flake_issue,
flakes_with_same_occurrences=False)
return issue_generator_new if new_issue else issue_generator_old
def testNormalizeTestNameWithStepName(self):
self.assertEqual('suite.test',
Flake.NormalizeTestName('a/suite.test/1'))
self.assertEqual('a.html', Flake.NormalizeTestName('a/b.html'))
self.assertEqual(
'a/b.html',
Flake.NormalizeTestName('a/b.html', 'webkit_layout_tests'))
def testUpdateTestLocationAndTagsRecentlyUpdated(self, _):
flake = Flake(
normalized_test_name='suite.test',
tags=['gerrit_project::chromium/src'],
)
flake.last_test_location_based_tag_update_time = datetime(2019, 6, 1)
self.assertFalse(
detect_flake_occurrences._UpdateTestLocationAndTags(flake, [], {}, {}))
def testAnalysisIsNeededForCrashedAnalysisWithForce(self):
master_name = 'm'
builder_name = 'b 1'
build_number = 123
step_name = 's'
test_name = 't'
flake = Flake.Create('chromium', step_name, test_name, 'l')
_CreateAndSaveMasterFlakeAnalysis(
master_name,
builder_name,
build_number,
step_name,
test_name,
status=analysis_status.ERROR)
mocked_now = datetime(2017, 05, 01, 10, 10, 10)
self.MockUTCNow(mocked_now)
test = TestInfo(master_name, builder_name, build_number, step_name,
test_name)
need_analysis, analysis = initialize_flake_pipeline._NeedANewAnalysis(
test,
test,
flake.key,
None,
user_email='*****@*****.**',
allow_new_analysis=True,
force=True)
self.assertTrue(need_analysis)
self.assertIsNotNone(analysis)
self.assertFalse(analysis.triggering_user_email_obscured)
self.assertEqual(mocked_now, analysis.request_time)
self.assertEqual(analysis.version_number, 2)
def testDetectCQHiddenFlakesShouldSkip(self, mock_query, *_):
flake = Flake.Create(
luci_project='luci_project',
normalized_step_name='s',
normalized_test_name='t',
test_label_name='t')
flake.put()
existing_occurrence = FlakeOccurrence.Create(
flake_type=FlakeType.CQ_HIDDEN_FLAKE,
build_id=123,
step_ui_name='s',
test_name='t',
luci_project='luci_project',
luci_bucket='luci_bucket',
luci_builder='luci_builder',
legacy_master_name='legacy_master_name',
legacy_build_number=123,
time_happened=datetime(2018, 12, 19, 23),
gerrit_cl_id=654321,
parent_flake_key=flake.key,
tags=[])
existing_occurrence.time_detected = datetime(2018, 12, 19, 23, 30)
existing_occurrence.put()
mock_query.side_effect = [(False, []), (True, [])]
detect_flake_occurrences.QueryAndStoreHiddenFlakes()
self.assertIsNone(detect_flake_occurrences._GetLastCQHiddenFlakeQueryTime())
detect_flake_occurrences.QueryAndStoreHiddenFlakes()
self.assertEqual(
datetime(2018, 12, 20),
detect_flake_occurrences._GetLastCQHiddenFlakeQueryTime())
detect_flake_occurrences.QueryAndStoreHiddenFlakes()
def testDetectCQHiddenFlakesShouldRun(self, _):
flake = Flake.Create(
luci_project='luci_project',
normalized_step_name='s',
normalized_test_name='t',
test_label_name='t')
flake.put()
existing_occurrence = FlakeOccurrence.Create(
flake_type=FlakeType.CQ_HIDDEN_FLAKE,
build_id=123,
step_ui_name='s',
test_name='t',
luci_project='luci_project',
luci_bucket='luci_bucket',
luci_builder='luci_builder',
legacy_master_name='legacy_master_name',
legacy_build_number=123,
time_happened=datetime(2018, 12, 19, 20),
gerrit_cl_id=654321,
parent_flake_key=flake.key,
tags=[])
existing_occurrence.time_detected = datetime(2018, 12, 19, 20)
existing_occurrence.put()
self.assertEqual(('2018-12-19 19:40:00 UTC', '2018-12-19 22:00:00 UTC'),
detect_flake_occurrences._GetCQHiddenFlakeQueryStartTime())
def _GetFlakeQueryResults(luci_project, cursor, direction, page_size):
"""Gets queried results of flakes.
Args:
luci_project (str): Luci project of the flakes.
cursor (None or str): The cursor provides a cursor in the current query
results, allowing you to retrieve the next set based on the offset.
direction (str): Either previous or next.
page_size (int): Number of entities to show per page.
Returns:
A tuple of (flakes, prev_cursor, cursor).
flakes (list): List of flakes to be displayed at the current page.
prev_cursor (str): The urlsafe encoding of the cursor, which is at the
top position of entities of the current page.
cursor (str): The urlsafe encoding of the cursor, which is at the
bottom position of entities of the current page.
"""
flake_query = Flake.query(
ndb.AND(Flake.luci_project == luci_project, Flake.archived == False)) # pylint: disable=singleton-comparison
# Orders flakes by flake_score_last_week.
flake_query = flake_query.filter(Flake.flake_score_last_week > 0)
first_sort_property = Flake.flake_score_last_week
return dashboard_util.GetPagedResults(
flake_query,
order_properties=[
(first_sort_property, dashboard_util.DESC),
(Flake.last_occurred_time, dashboard_util.DESC),
(Flake.normalized_step_name, dashboard_util.ASC),
(Flake.test_label_name, dashboard_util.ASC),
],
cursor=cursor,
direction=direction,
page_size=page_size)
def testCIFlakes(self, _):
luci_project = 'chromium'
normalized_step_name = 'normalized_step_name'
flake4 = Flake.Create(luci_project=luci_project,
normalized_step_name=normalized_step_name,
normalized_test_name='normalized_test_name_4',
test_label_name='test_label4')
flake4.last_occurred_time = datetime(2018, 9, 1)
flake4.put()
flake4_key = flake4.key
step_ui_name = 'step'
luci_bucket = 'try'
luci_builder = 'luci builder'
legacy_master_name = 'buildbot master'
for i in xrange(98761, 98765):
occurrence = FlakeOccurrence.Create(
flake_type=FlakeType.CQ_HIDDEN_FLAKE,
build_id=i,
step_ui_name=step_ui_name,
test_name='t4',
luci_project=luci_project,
luci_bucket=luci_bucket,
luci_builder=luci_builder,
legacy_master_name=legacy_master_name,
legacy_build_number=i,
time_happened=datetime(2018, 8, 31),
gerrit_cl_id=i,
parent_flake_key=flake4_key)
occurrence.put()
occurrence10 = FlakeOccurrence.Create(
flake_type=FlakeType.CI_FAILED_STEP,
build_id=76543,
step_ui_name=step_ui_name,
test_name='t4',
luci_project=luci_project,
luci_bucket=luci_bucket,
luci_builder=luci_builder,
legacy_master_name=legacy_master_name,
legacy_build_number=76543,
time_happened=datetime(2018, 8, 31),
gerrit_cl_id=-1,
parent_flake_key=flake4_key)
occurrence10.put()
UpdateFlakeCounts()
flake4 = flake4_key.get()
self.assertEqual([
FlakeCountsByType(flake_type=FlakeType.CQ_HIDDEN_FLAKE,
impacted_cl_count=4,
occurrence_count=4),
FlakeCountsByType(flake_type=FlakeType.CI_FAILED_STEP,
impacted_cl_count=-1,
occurrence_count=1)
], flake4.flake_counts_last_week)
self.assertEqual(14, flake4.flake_score_last_week)
def testUpdateTestLocationAndTagsNoComponent(self, *_):
flake = Flake(
normalized_test_name='suite.test',
tags=['gerrit_project::chromium/src'],
)
occurrences = [
FlakeOccurrence(step_ui_name='browser_tests'),
]
component_mapping = {
'base/feature/': 'root>a>b',
'base/feature/url': 'root>a>b>c',
}
watchlist = {
'feature': 'base/feature',
'url': r'base/feature/url_test\.cc',
'other': 'a/b/c',
}
expected_tags = sorted([
'gerrit_project::chromium/src',
'directory::unknown/',
'source::unknown/path.cc',
'component::Unknown',
'parent_component::Unknown',
])
for tag in flake.tags:
name = tag.split(TAG_DELIMITER)[0]
self.assertTrue(name in detect_flake_occurrences.SUPPORTED_TAGS)
self.assertTrue(
detect_flake_occurrences._UpdateTestLocationAndTags(
flake, occurrences, component_mapping, watchlist))
self.assertEqual(expected_tags, flake.tags)
def testCreate(self):
luci_project = 'chromium'
normalized_step_name = 'normalized_step'
normalized_test_name = 'normalized_test'
test_label_name = 'test_label'
flake = Flake.Create(luci_project=luci_project,
normalized_step_name=normalized_step_name,
normalized_test_name=normalized_test_name,
test_label_name=test_label_name)
flake.put()
fetched_flakes = Flake.query().fetch()
self.assertEqual(1, len(fetched_flakes))
self.assertEqual(flake, fetched_flakes[0])
def testGetFlakeIssueNoIssueKey(self):
flake = Flake.Create(luci_project='chromium',
normalized_step_name='step',
normalized_test_name='suite.test',
test_label_name='*/suite.test/*')
flake.put()
self.assertIsNone(flake.GetIssue())
def testCreate(self):
luci_project = 'chromium'
step_ui_name = 'step'
test_name = 'test'
normalized_step_name = 'normalized_step_name'
normalized_test_name = 'normalized_test_name'
test_label_name = 'test_label'
flake = Flake.Create(luci_project=luci_project,
normalized_step_name=normalized_step_name,
normalized_test_name=normalized_test_name,
test_label_name=test_label_name)
flake.put()
build_id = 123
luci_bucket = 'try'
luci_builder = 'luci builder'
legacy_master_name = 'buildbot master'
legacy_build_number = 999
time_happened = datetime.datetime(2018, 1, 1)
gerrit_cl_id = 98765
cq_false_rejection_occurrence = FlakeOccurrence.Create(
FlakeType.CQ_FALSE_REJECTION,
build_id=build_id,
step_ui_name=step_ui_name,
test_name=test_name,
luci_project=luci_project,
luci_bucket=luci_bucket,
luci_builder=luci_builder,
legacy_master_name=legacy_master_name,
legacy_build_number=legacy_build_number,
time_happened=time_happened,
gerrit_cl_id=gerrit_cl_id,
parent_flake_key=flake.key)
cq_false_rejection_occurrence.put()
retry_with_patch_occurrence = FlakeOccurrence.Create(
FlakeType.RETRY_WITH_PATCH,
build_id=build_id,
step_ui_name=step_ui_name,
test_name=test_name,
luci_project=luci_project,
luci_bucket=luci_bucket,
luci_builder=luci_builder,
legacy_master_name=legacy_master_name,
legacy_build_number=legacy_build_number,
time_happened=time_happened,
gerrit_cl_id=gerrit_cl_id,
parent_flake_key=flake.key)
retry_with_patch_occurrence.put()
fetched_flake_occurrences = FlakeOccurrence.query().fetch()
self.assertEqual(2, len(fetched_flake_occurrences))
self.assertIn(cq_false_rejection_occurrence, fetched_flake_occurrences)
self.assertIn(retry_with_patch_occurrence, fetched_flake_occurrences)
self.assertIsNotNone(fetched_flake_occurrences[0].time_detected)
self.assertIsNotNone(fetched_flake_occurrences[1].time_detected)
def testGetTestLabelName(self):
self.assertEqual(
'suite.test', Flake.GetTestLabelName('suite.test',
'base_unittests'))
self.assertEqual(
'suite.test/*',
Flake.GetTestLabelName('suite.test/1', 'base_unittests'))
self.assertEqual(
'*/suite.test/*',
Flake.GetTestLabelName('a/suite.test/0', 'base_unittests'))
self.assertEqual(
'suite.*test',
Flake.GetTestLabelName('suite.PRE_PRE_test', 'base_unittests'))
self.assertEqual(
'*/suite.*test/*',
Flake.GetTestLabelName('a/suite.PRE_PRE_test/0', 'base_unittests'))
self.assertEqual(
'a/b.html',
Flake.NormalizeTestName('a/b.html', 'webkit_layout_tests'))
self.assertEqual(
'a/b.html?*',
Flake.GetTestLabelName('a/b.html?1000-2000',
'webkit_layout_tests'))
def testNormalizeStepName(self, mocked_get_isolate_target_name,
mocked_get_canonical_step_name):
self.assertEqual(
'isolate_target_name',
Flake.NormalizeStepName(
step_name='step_name (with patch) on Android',
master_name='m',
builder_name='b',
build_number=200))
def testRemoveDisabledFlakes(self):
flake_1 = Flake.Create('a', 'b', '1', 'test_label')
flake_2 = Flake.Create('a', 'b', '2', 'test_label')
flake_3 = Flake.Create('a', 'b', '3', 'test_label')
luci_test_1 = LuciTest(
key=LuciTest.CreateKey('a', 'b', 1),
disabled_test_variants={('config',)},
)
luci_test_1.put()
luci_test_2 = LuciTest(
key=LuciTest.CreateKey('a', 'b', 2),
disabled_test_variants=set(),
)
luci_test_2.put()
self.assertEqual([flake_2, flake_3],
flake_detection_utils.RemoveDisabledFlakes(
[flake_1, flake_2, flake_3]))
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 testGetId(self):
luci_project = 'chromium'
normalized_step_name = 'normalized_step'
normalized_test_name = 'normalized_test'
self.assertEqual(
'chromium@normalized_step@normalized_test',
Flake.GetId(luci_project=luci_project,
normalized_step_name=normalized_step_name,
normalized_test_name=normalized_test_name))
def _CreateLocalTests(row, local_tests, component_mapping, watchlists):
"""Creates a LuciTest key-test variant pair for a row fetched from BigQuery.
Args:
row: A row of query results.
local_tests (dict): LuciTest entities in local memory in the format
{LuciTest.key: {'disabled_test_variants : set(), issue_keys: set()},
mutated by this function.
component_mapping (dict): Mapping from directories to crbug components.
watchlists (dict): Mapping from directories to watchlists.
"""
build_id = row['build_id']
builder_name = row['builder_name']
step_name = row['step_name']
test_name = row['test_name']
bugs = row['bugs']
if int(build_id) == 1:
# To filter out tests results with invalid build_id.
# TODO (crbug.com/999215): Remove this check after test-results is fixed.
logging.info(
'Failed to define test variant for build_id: %s, row is %r',
build_id, row)
return
normalized_step_name = Flake.NormalizeStepName(build_id, step_name)
normalized_test_name = Flake.NormalizeTestName(test_name, step_name)
test_key = LuciTest.CreateKey(_DEFAULT_LUCI_PROJECT, normalized_step_name,
normalized_test_name)
if not local_tests.get(test_key):
local_tests[test_key] = {
'disabled_test_variants': set(),
'issue_keys': set(),
'tags': set()
}
local_tests[test_key]['tags'].update(
_GetNewTestTags(local_tests[test_key]['tags'], step_name, test_name,
normalized_step_name, normalized_test_name, build_id,
component_mapping, watchlists))
disabled_variant = _CreateDisabledVariant(build_id, builder_name,
step_name)
local_tests[test_key]['disabled_test_variants'].add(disabled_variant)
local_tests[test_key]['issue_keys'].update(_CreateIssueKeys(bugs))
def _ArchiveFlakesForClosedIssue(flake_issue):
"""Archives flakes with closed issue.
Flakes with closed issue should be archived since they are fixed or not
actionable.
"""
flakes = Flake.query(Flake.flake_issue_key == flake_issue.key).fetch()
for flake in flakes:
flake.archived = True
ndb.put_multi(flakes)
def testStoreDetectedCIFlakesNoBuild(self, *_):
master_name = 'm'
builder_name = 'b'
build_number = 123
flaky_tests = {'s': ['t1', 't2']}
detect_flake_occurrences.StoreDetectedCIFlakes(master_name, builder_name,
build_number, flaky_tests)
flake = Flake.Get('chromium', 'normalized_step_name', 't1')
self.assertIsNone(flake)
def testNormalizeStepName(self, cases, mock_isolate, mock_canonical):
mock_isolate.return_value = cases['isolate_return_value']
mock_canonical.return_value = cases['canonical_return_value']
step_name = Flake.NormalizeStepName(123, 'step_name (with patch)')
self.assertEqual(cases['expected_step_name'], step_name)
self.assertEqual(cases['isolate_fn_call_count'],
mock_isolate.call_count)
self.assertEqual(cases['canonical_fn_call_count'],
mock_canonical.call_count)
def testGet(self):
luci_project = 'chromium'
normalized_step_name = 'normalized_step'
normalized_test_name = 'normalized_test'
test_label_name = 'test_label'
flake = Flake.Create(luci_project=luci_project,
normalized_step_name=normalized_step_name,
normalized_test_name=normalized_test_name,
test_label_name=test_label_name)
flake.put()
retrieved_flake = Flake.Get(luci_project, normalized_step_name,
normalized_test_name)
self.assertIsNotNone(retrieved_flake)
self.assertEqual(normalized_test_name,
retrieved_flake.normalized_test_name)
self.assertEqual(normalized_step_name,
retrieved_flake.normalized_step_name)
def _CreateFlakeFromRow(row):
"""Creates a Flake entity from a row fetched from BigQuery."""
luci_project = row['luci_project']
luci_builder = row['luci_builder']
legacy_master_name = row['legacy_master_name']
legacy_build_number = row['legacy_build_number']
step_ui_name = row['step_ui_name']
test_name = row['test_name']
normalized_step_name = Flake.NormalizeStepName(
step_name=step_ui_name,
master_name=legacy_master_name,
builder_name=luci_builder,
build_number=legacy_build_number)
normalized_test_name = Flake.NormalizeTestName(test_name, step_ui_name)
test_label_name = Flake.GetTestLabelName(test_name, step_ui_name)
return Flake.Create(luci_project=luci_project,
normalized_step_name=normalized_step_name,
normalized_test_name=normalized_test_name,
test_label_name=test_label_name)
def testGetIssueNoIssue(self):
luci_project = 'chromium'
normalized_step_name = 'normalized_step'
normalized_test_name = 'a/b.html'
test_label_name = 'test_label'
flake = Flake.Create(luci_project=luci_project,
normalized_step_name=normalized_step_name,
normalized_test_name=normalized_test_name,
test_label_name=test_label_name)
self.assertIsNone(flake.GetIssue())
def testGetTestSuiteName(self):
luci_project = 'chromium'
normalized_step_name = 'normalized_step'
normalized_test_name = 'a/b.html'
test_label_name = 'test_label'
flake = Flake.Create(luci_project=luci_project,
normalized_step_name=normalized_step_name,
normalized_test_name=normalized_test_name,
test_label_name=test_label_name)
flake.tags.append('suite::a')
flake.put()
self.assertEqual('a', flake.GetTestSuiteName())
def testRerunAnalysisWithAnalyzeFlakePipeline(
self, mocked_analysis, mocked_pipeline, mocked_need_analysis,
mocked_build_info, mock_dimensions, *_):
buildbucket_id = 'id'
mock_dimensions.return_value = ['os:Mac', 'cpu:x86']
start_commit_position = 1000
start_build_info = BuildInfo('m', 'b 1', 123)
start_build_info.commit_position = start_commit_position
start_build_info.chromium_revision = 'r1000'
start_build_info.buildbucket_id = buildbucket_id
mocked_build_info.return_value = start_build_info
mocked_analysis.pipeline_status_path.return_value = 'status'
mocked_analysis.key.urlsafe.return_value = 'urlsafe_key'
mocked_need_analysis.return_value = (True, mocked_analysis)
test = TestInfo('m', 'b 1', 123, 's', 't')
manually_triggered = False
flake = Flake.Create('chromium', 's', 't', 'l')
analysis = initialize_flake_pipeline.ScheduleAnalysisIfNeeded(
test,
test,
flake.key,
bug_id=None,
allow_new_analysis=True,
manually_triggered=manually_triggered,
force=True,
queue_name=constants.DEFAULT_QUEUE)
self.assertIsNotNone(analysis)
self.assertEqual(buildbucket_id, analysis.build_id)
self.assertEqual(buildbucket_id, analysis.original_build_id)
analyze_flake_input = AnalyzeFlakeInput(
analysis_urlsafe_key='urlsafe_key',
analyze_commit_position_parameters=NextCommitPositionOutput(
culprit_commit_id=None,
next_commit_id=CommitID(
commit_position=start_commit_position,
revision=start_build_info.chromium_revision)),
commit_position_range=IntRange(lower=None, upper=start_commit_position),
dimensions=ListOfBasestring.FromSerializable(
['os:Mac', 'cpu:x86', 'pool:luci.chromium.findit']),
manually_triggered=manually_triggered,
rerun=True,
retries=0,
step_metadata=StepMetadata.FromSerializable({}))
mocked_pipeline.assert_has_calls([
mock.call(analyze_flake_input),
mock.call().start(queue_name=constants.DEFAULT_QUEUE)
])
def _CreateFlake(flake_data, with_component=True):
"""
Args:
with_component (bool): Sets flake.component if True, otherwise sets tags.
"""
luci_project = 'chromium'
normalized_step_name = 'normalized_step_name'
flake_issue = _GetOrCreateFlakeIssue(flake_data['bug_id'])
flake = Flake.Create(normalized_test_name=flake_data['test'],
luci_project=luci_project,
normalized_step_name=normalized_step_name,
test_label_name='test_label')
if with_component:
flake.component = flake_data['component']
else:
flake.tags = ['component::{}'.format(flake_data['component'])]
flake.flake_issue_key = flake_issue.key
flake.flake_counts_last_week = []
for flake_type, counts in flake_data['counts'].iteritems():
flake.flake_counts_last_week.append(
FlakeCountsByType(flake_type=flake_type,
occurrence_count=counts[0],
impacted_cl_count=counts[1]))
flake.last_occurred_time = datetime.strptime(
flake_data['last_occurred_time'], '%Y-W%W-%w')
flake.put()
for occurrence_data in flake_data['occurrences']:
time_happened = datetime.strptime('2018-%d-4' % occurrence_data[2],
'%Y-%W-%w')
hour = occurrence_data[3]
time_happened += timedelta(hours=hour)
occurrence = FlakeOccurrence.Create(
flake_type=occurrence_data[0],
build_id=123 + hour,
step_ui_name='step',
test_name=flake.normalized_test_name,
luci_project='chromium',
luci_bucket='try',
luci_builder='builder',
legacy_master_name='master',
legacy_build_number=42,
time_happened=time_happened,
gerrit_cl_id=occurrence_data[1],
parent_flake_key=flake.key)
occurrence.put()
def testGetFlakeIssue(self):
flake_issue = FlakeIssue.Create(monorail_project='chromium',
issue_id=12345)
flake_issue.put()
flake_issue_key = flake_issue.key
flake = Flake.Create(luci_project='chromium',
normalized_step_name='step',
normalized_test_name='suite.test',
test_label_name='*/suite.test/*')
flake.flake_issue_key = flake_issue_key
flake.put()
self.assertEqual(flake_issue_key,
flake.GetIssue(up_to_date=True, key_only=True))
