[Predator] renamed "Result" to "Suspect"

appengine/findit/crash/test/changelist_classifier_test.py

 # Copyright 2016 The Chromium Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 from collections import defaultdict
 import copy
 
 from common.dependency import Dependency
 from common.dependency import DependencyRoll
 from common import chrome_dependency_fetcher
 from crash import changelist_classifier
 from crash.crash_report import CrashReport
-from crash.results import AnalysisInfo
-from crash.results import StackInfo
-from crash.results import MatchResult
+from crash.suspect import AnalysisInfo
+from crash.suspect import StackInfo
+from crash.suspect import Suspect
 from crash.stacktrace import CallStack
 from crash.stacktrace import StackFrame
 from crash.stacktrace import Stacktrace
 from crash.test.crash_test_suite import CrashTestSuite
 from libs.gitiles.blame import Blame
 from libs.gitiles.blame import Region
 from libs.gitiles.change_log import ChangeLog
 from libs.gitiles.gitiles_repository import GitilesRepository
 
 DUMMY_CHANGELOG1 = ChangeLog.FromDict({
@@ skipping 67 matching lines @@
     'code_review_url': 'https://codereview.chromium.org/3281',
     'committer_name': 'example@chromium.org',
     'revision': '3',
     'reverted_revision': None
 })
 
 # TODO(wrengr): re crrev.com/2414523002: we need to have a specified
 # revision_range (even if the versions therein are None), because
 # ChangelistClassifier.__call__ will take it apart in order to call
 # GetDEPSRollsDict; if it can't then it will immediately return the
-# empty list of results, breaking many of the tests here. Of course,
+# empty list of suspects, breaking many of the tests here. Of course,
 # taking revision_range apart isn't actually required for the tests,
 # since we mock GetDEPSRollsDict. So, really what we ought to do in the
 # long run is redesign things so that GetDEPSRollsDict takes the
 # CrashReport directly and pulls out the revision_range and platform
 # itself; that way ChangelistClassifier.__call__ needn't worry about it,
 # allowing us to clean up the tests here.
 # TODO(wrengr): this empty stacktrace causes the unittests to emit
 # logging warnings about the fact that we can't get the crash_stack. Would
 # be nice to avoid that.
 DUMMY_REPORT = CrashReport(None, None, None, Stacktrace(), (None, None))
@@ skipping 18 matching lines @@
 
     passed_in_regression_deps_rolls = []
     def _MockGetChangeLogsForFilesGroupedByDeps(regression_deps_rolls, *_):
       passed_in_regression_deps_rolls.append(regression_deps_rolls)
       return {}, None
 
     self.mock(changelist_classifier, 'GetChangeLogsForFilesGroupedByDeps',
               _MockGetChangeLogsForFilesGroupedByDeps)
     self.mock(changelist_classifier, 'GetStackInfosForFilesGroupedByDeps',
               lambda *_: {})
-    self.mock(changelist_classifier, 'FindMatchResults', lambda *_: None)
+    self.mock(changelist_classifier, 'FindSuspects', lambda *_: None)
 
     self.changelist_classifier(CrashReport(crashed_version = '5',
                                signature = 'sig',
                                platform = 'canary',
                                stacktrace = Stacktrace([CallStack(0)]),
                                regression_range = ['4', '5']))
     expected_regression_deps_rolls = copy.deepcopy(dep_rolls)
 
     # Regression of a dep added/deleted (old_revision/new_revision is None) can
     # not be known for sure and this case rarely happens, so just filter them
@@ skipping 96 matching lines @@
     for dep, file_to_stack_infos in dep_file_to_stack_infos.iteritems():
       self.assertTrue(dep in expected_dep_file_to_stack_infos)
       expected_file_to_stack_infos = expected_dep_file_to_stack_infos[dep]
 
       for file_path, stack_infos in file_to_stack_infos.iteritems():
         self.assertTrue(file_path in expected_file_to_stack_infos)
         expected_stack_infos = expected_file_to_stack_infos[file_path]
 
         self._VerifyTwoStackInfosEqual(stack_infos, expected_stack_infos)
 
-  def testFindMatchResults(self):
+  def testFindSuspects(self):
     dep_file_to_changelogs = {
         'src/': {
             'a.cc': [
                 DUMMY_CHANGELOG1,
             ]
         }
     }
 
     dep_file_to_stack_infos = {
         'src/': {
@@ skipping 15 matching lines @@
         Region(1, 5, '6', 'a', 'a@chromium.org', 'Thu Mar 31 21:24:43 2016'))
     dummy_blame.AddRegion(
         Region(6, 10, '1', 'b', 'b@chromium.org', 'Thu Jun 19 12:11:40 2015'))
 
     self.mock(GitilesRepository, 'GetBlame', lambda *_: dummy_blame)
 
     stack_deps = {
         'src/': Dependency('src/', 'https://url_src', 'rev1', 'DEPS'),
     }
 
-    expected_match_results = [{
+    expected_suspects = [{
         'url': 'https://repo.test/+/1',
         'review_url': 'https://codereview.chromium.org/3281',
         'revision': '1',
         'project_path': 'src/',
         'author': 'r@chromium.org',
         'time': 'Thu Mar 31 21:24:43 2016',
         'reasons': None,
         'confidence': None,
         'changed_files': None
     }]
 
-    match_results = changelist_classifier.FindMatchResults(
+    suspects = changelist_classifier.FindSuspects(
         dep_file_to_changelogs, dep_file_to_stack_infos, stack_deps,
         GitilesRepository(self.GetMockHttpClient()))
-    self.assertListEqual([result.ToDict() for result in match_results],
-                         expected_match_results)
+    self.assertListEqual([suspect.ToDict() for suspect in suspects],
+                         expected_suspects)
 
   # TODO(http://crbug.com/659346): why do these mocks give coverage
   # failures? That's almost surely hiding a bug in the tests themselves.
   def testFindItForCrashNoRegressionRange(self): # pragma: no cover
     self.mock(chrome_dependency_fetcher.ChromeDependencyFetcher,
         'GetDependencyRollsDict', lambda *_: {})
     self.mock(chrome_dependency_fetcher.ChromeDependencyFetcher,
         'GetDependency', lambda *_: {})
     # N.B., for this one test we really do want regression_range=None.
     report = DUMMY_REPORT._replace(regression_range=None)
     self.assertListEqual(self.changelist_classifier(report), [])
 
   def testFindItForCrashNoMatchFound(self):
-    self.mock(changelist_classifier, 'FindMatchResults', lambda *_: [])
+    self.mock(changelist_classifier, 'FindSuspects', lambda *_: [])
     self.mock(chrome_dependency_fetcher.ChromeDependencyFetcher,
         'GetDependencyRollsDict',
         lambda *_: {'src/': DependencyRoll('src/', 'https://repo', '1', '2')})
     self.mock(chrome_dependency_fetcher.ChromeDependencyFetcher,
         'GetDependency', lambda *_: {})
     self.assertListEqual(self.changelist_classifier(DUMMY_REPORT), [])
 
   def testFindItForCrash(self):
 
-    def _MockFindMatchResults(*_):
-      match_result1 = MatchResult(DUMMY_CHANGELOG1, 'src/', confidence=0.)
+    def _MockFindSuspects(*_):
+      suspect1 = Suspect(DUMMY_CHANGELOG1, 'src/', confidence=0.)
       frame1 = StackFrame(0, 'src/', 'func', 'a.cc', 'src/a.cc', [1])
       frame2 = StackFrame(1, 'src/', 'func', 'a.cc', 'src/a.cc', [7])
-      match_result1.file_to_stack_infos = {
+      suspect1.file_to_stack_infos = {
           'a.cc': [StackInfo(frame1, 0), StackInfo(frame2, 0)]
       }
-      match_result1.file_to_analysis_info = {
+      suspect1.file_to_analysis_info = {
           'a.cc': AnalysisInfo(min_distance=0, min_distance_frame=frame1)
       }
 
-      match_result2 = MatchResult(DUMMY_CHANGELOG3, 'src/', confidence=0.)
+      suspect2 = Suspect(DUMMY_CHANGELOG3, 'src/', confidence=0.)
       frame3 = StackFrame(5, 'src/', 'func', 'f.cc', 'src/f.cc', [1])
-      match_result2.file_to_stack_infos = {
+      suspect2.file_to_stack_infos = {
           'f.cc': [StackInfo(frame3, 0)]
       }
-      match_result2.file_to_analysis_info = {
+      suspect2.file_to_analysis_info = {
           'a.cc': AnalysisInfo(min_distance=20, min_distance_frame=frame3)
       }
 
-      return [match_result1, match_result2]
+      return [suspect1, suspect2]
 
-    self.mock(changelist_classifier, 'FindMatchResults', _MockFindMatchResults)
+    self.mock(changelist_classifier, 'FindSuspects', _MockFindSuspects)
     self.mock(chrome_dependency_fetcher.ChromeDependencyFetcher,
         'GetDependencyRollsDict',
         lambda *_: {'src/': DependencyRoll('src/', 'https://repo', '1', '2')})
     self.mock(chrome_dependency_fetcher.ChromeDependencyFetcher,
         'GetDependency', lambda *_: {})
-    results = self.changelist_classifier(DUMMY_REPORT)
-    expected_match_results = [
+    suspects = self.changelist_classifier(DUMMY_REPORT)
+    expected_suspects = [
         {
             'reasons': [('TopFrameIndex', 1.0, 'Top frame is #0'),
                         ('MinDistance', 1, 'Minimum distance is 0')],
             'changed_files': [{'info': 'Minimum distance (LOC) 0, frame #0',
                                'blame_url': None, 'file': 'a.cc'}],
             'time': 'Thu Mar 31 21:24:43 2016',
             'author': 'r@chromium.org',
             'url': 'https://repo.test/+/1',
             'project_path': 'src/',
             'review_url': 'https://codereview.chromium.org/3281',
             'confidence': 1.0, 'revision': '1'
         },
     ]
-    self.assertListEqual([result.ToDict() for result in results],
-                         expected_match_results)
+    self.assertListEqual([suspect.ToDict() for suspect in suspects],
+                         expected_suspects)
 
   def testFinditForCrashFilterZeroConfidentResults(self):
-    def _MockFindMatchResults(*_):
-      match_result1 = MatchResult(DUMMY_CHANGELOG1, 'src/', confidence=0.)
+    def _MockFindSuspects(*_):
+      suspect1 = Suspect(DUMMY_CHANGELOG1, 'src/', confidence=0.)
       frame1 = StackFrame(0, 'src/', 'func', 'a.cc', 'src/a.cc', [1])
       frame2 = StackFrame(1, 'src/', 'func', 'a.cc', 'src/a.cc', [7])
-      match_result1.file_to_stack_infos = {
+      suspect1.file_to_stack_infos = {
           'a.cc': [StackInfo(frame1, 0), StackInfo(frame2, 0)]
       }
-      match_result1.file_to_analysis_info = {
+      suspect1.file_to_analysis_info = {
           'a.cc': AnalysisInfo(min_distance=1, min_distance_frame=frame1)
       }
 
-      match_result2 = MatchResult(DUMMY_CHANGELOG3, 'src/', confidence=0.)
+      suspect2 = Suspect(DUMMY_CHANGELOG3, 'src/', confidence=0.)
       frame3 = StackFrame(15, 'src/', 'func', 'f.cc', 'src/f.cc', [1])
-      match_result2.file_to_stack_infos = {
+      suspect2.file_to_stack_infos = {
           'f.cc': [StackInfo(frame3, 0)]
       }
-      match_result2.file_to_analysis_info = {
+      suspect2.file_to_analysis_info = {
           'f.cc': AnalysisInfo(min_distance=20, min_distance_frame=frame3)
       }
 
-      match_result3 = MatchResult(DUMMY_CHANGELOG3, 'src/', confidence=0.)
+      suspect3 = Suspect(DUMMY_CHANGELOG3, 'src/', confidence=0.)
       frame4 = StackFrame(3, 'src/', 'func', 'ff.cc', 'src/ff.cc', [1])
-      match_result3.file_to_stack_infos = {
+      suspect3.file_to_stack_infos = {
           'f.cc': [StackInfo(frame4, 0)]
       }
-      match_result3.file_to_analysis_info = {
+      suspect3.file_to_analysis_info = {
           'f.cc': AnalysisInfo(min_distance=60, min_distance_frame=frame4)
       }
 
-      return [match_result1, match_result2, match_result3]
+      return [suspect1, suspect2, suspect3]
 
-    self.mock(changelist_classifier, 'FindMatchResults', _MockFindMatchResults)
+    self.mock(changelist_classifier, 'FindSuspects', _MockFindSuspects)
     self.mock(chrome_dependency_fetcher.ChromeDependencyFetcher,
         'GetDependencyRollsDict',
         lambda *_: {'src/': DependencyRoll('src/', 'https://repo', '1', '2')})
     self.mock(chrome_dependency_fetcher.ChromeDependencyFetcher,
         'GetDependency', lambda *_: {})
 
-    results = self.changelist_classifier(DUMMY_REPORT)
-    expected_match_results = [
+    suspects = self.changelist_classifier(DUMMY_REPORT)
+    expected_suspects = [
         {
             'author': 'r@chromium.org',
             'changed_files': [
                 {
                     'blame_url': None,
                     'file': 'a.cc',
                     'info': 'Minimum distance (LOC) 1, frame #0'
                 }
             ],
             'confidence': 0.8,
             'project_path': 'src/',
             'reasons': [
                 ('TopFrameIndex', 1.0, 'Top frame is #0'),
                 ('MinDistance', 0.8, 'Minimum distance is 1')
             ],
             'review_url': 'https://codereview.chromium.org/3281',
             'revision': '1',
             'time': 'Thu Mar 31 21:24:43 2016',
             'url': 'https://repo.test/+/1'
         }
     ]
-    self.assertListEqual([result.ToDict() for result in results],
-                         expected_match_results)
+    self.assertListEqual([suspect.ToDict() for suspect in suspects],
+                         expected_suspects)
 
-  def testFinditForCrashAllMatchResultsWithZeroConfidences(self):
-    """Test that we filter out results with too-large frame indices.
+  def testFinditForCrashAllSuspectsWithZeroConfidences(self):
+    """Test that we filter out suspects with too-large frame indices.
 
-    In the mock results below we return frames with indices
+    In the mock suspects below we return frames with indices
     15, 20, 21 which are all larger than the ``max_top_n`` of
     ``TopFrameIndexScorer``. Therefore we should get a score of zero
     for that feature, which causes the total score to be zero, and so
-    we should not return these results.
+    we should not return these suspects.
     """
-    def _MockFindMatchResults(*_):
-      match_result1 = MatchResult(DUMMY_CHANGELOG1, 'src/', confidence=0.)
+    def _MockFindSuspects(*_):
+      suspect1 = Suspect(DUMMY_CHANGELOG1, 'src/', confidence=0.)
       frame1 = StackFrame(20, 'src/', '', 'func', 'a.cc', [1])
       frame2 = StackFrame(21, 'src/', '', 'func', 'a.cc', [7])
-      match_result1.file_to_stack_infos = {
+      suspect1.file_to_stack_infos = {
           'a.cc': [StackInfo(frame1, 0), StackInfo(frame2, 0)]
       }
-      match_result1.file_to_analysis_info = {
+      suspect1.file_to_analysis_info = {
           'a.cc': AnalysisInfo(min_distance=1, min_distance_frame=frame1)
       }
 
-      match_result2 = MatchResult(DUMMY_CHANGELOG3, 'src/', confidence=0.)
+      suspect2 = Suspect(DUMMY_CHANGELOG3, 'src/', confidence=0.)
       frame3 = StackFrame(15, 'src/', '', 'func', 'f.cc', [1])
-      match_result2.file_to_stack_infos = {
+      suspect2.file_to_stack_infos = {
           'f.cc': [StackInfo(frame3, 0)]
       }
-      match_result2.min_distance = 20
-      match_result2.file_to_analysis_info = {
+      suspect2.min_distance = 20
+      suspect2.file_to_analysis_info = {
           'f.cc': AnalysisInfo(min_distance=20, min_distance_frame=frame3)
       }
 
-      return [match_result1, match_result2]
+      return [suspect1, suspect2]
 
-    self.mock(changelist_classifier, 'FindMatchResults', _MockFindMatchResults)
+    self.mock(changelist_classifier, 'FindSuspects', _MockFindSuspects)
     self.mock(chrome_dependency_fetcher.ChromeDependencyFetcher,
         'GetDependencyRollsDict',
         lambda *_: {'src/': DependencyRoll('src/', 'https://repo', '1', '2')})
     self.mock(chrome_dependency_fetcher.ChromeDependencyFetcher,
         'GetDependency', lambda *_: {})
 
     self.assertListEqual(self.changelist_classifier(DUMMY_REPORT), [])