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))