[Predator] renamed "Result" to "Suspect"

appengine/findit/crash/test/findit_for_chromecrash_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.
 
 import mock
 
 from common import chrome_dependency_fetcher
 from common.dependency import DependencyRoll
 from common.http_client_appengine import HttpClientAppengine
 from crash import chromecrash_parser
 from crash import detect_regression_range
 from crash import findit
 from crash import findit_for_chromecrash
 from crash.changelist_classifier import ChangelistClassifier
 from crash.chromecrash_parser import ChromeCrashParser
 from crash.component_classifier import ComponentClassifier
 from crash.crash_report import CrashReport
 from crash.culprit import Culprit
 from crash.findit_for_chromecrash import FinditForChromeCrash
 from crash.findit_for_chromecrash import FinditForFracas
 from crash.project_classifier import ProjectClassifier
-from crash.results import MatchResult
+from crash.suspect import Suspect
 from crash.stacktrace import CallStack
 from crash.stacktrace import Stacktrace
 from crash.test.crash_pipeline_test import DummyCrashData
 from crash.test.predator_testcase import PredatorTestCase
 from crash.type_enums import CrashClient
 from libs.gitiles import gitiles_repository
 from model import analysis_status
 from model.crash.crash_analysis import CrashAnalysis
 from model.crash.fracas_crash_analysis import FracasCrashAnalysis
 
@@ skipping 161 matching lines @@
     self.mock(ChromeCrashParser, 'Parse', lambda *_: Stacktrace([CallStack(0)]))
     self.mock(chrome_dependency_fetcher.ChromeDependencyFetcher,
         'GetDependencyRollsDict',
         lambda *_: {
             'src/': DependencyRoll('src/', 'https://repo', '1', '2'),
             'src/add': DependencyRoll('src/add', 'https://repo1', None, '2'),
             'src/delete': DependencyRoll('src/delete', 'https://repo2', '2',
                 None)
     })
 
-    dummy_match_result = MatchResult(self.GetDummyChangeLog(), 'src/')
+    dummy_suspect = Suspect(self.GetDummyChangeLog(), 'src/')
     self.mock(ChangelistClassifier, '__call__',
         lambda _self, report:
-            [dummy_match_result] if report.regression_range else [])
+            [dummy_suspect] if report.regression_range else [])
 
     self.mock(ComponentClassifier, 'Classify', lambda *_: [])
     self.mock(ProjectClassifier, 'Classify', lambda *_: '')
 
     # TODO(wrengr): for both these tests, we should compare Culprit
     # objects directly rather than calling ToDicts and comparing the
     # dictionaries.
-    self._testFindCulpritForChromeCrashSucceeds(dummy_match_result)
+    self._testFindCulpritForChromeCrashSucceeds(dummy_suspect)
     self._testFindCulpritForChromeCrashFails()
 
-  def _testFindCulpritForChromeCrashSucceeds(self, dummy_match_result):
+  def _testFindCulpritForChromeCrashSucceeds(self, dummy_suspect):
     analysis = CrashAnalysis()
     analysis.signature = 'signature'
     analysis.platform = 'win'
     analysis.stack_trace = 'frame1\nframe2'
     analysis.crashed_version = '50.0.1234.0'
     dummy_regression_range = ['50.0.1233.0', '50.0.1234.0']
     analysis.regression_range = dummy_regression_range
     culprit = _FinditForChromeCrash().FindCulprit(analysis)
     self.assertIsNotNone(culprit, 'FindCulprit failed unexpectedly')
-    results, tag = culprit.ToDicts()
+    suspects, tag = culprit.ToDicts()
 
-    expected_results = {
+    expected_suspects = {
           'found': True,
-          'suspected_cls': [dummy_match_result.ToDict()],
+          'suspected_cls': [dummy_suspect.ToDict()],
           'regression_range': dummy_regression_range
     }
     expected_tag = {
           'found_suspects': True,
           'found_project': False,
           'found_components': False,
           'has_regression_range': True,
           'solution': 'core_algorithm',
     }
 
-    self.assertDictEqual(expected_results, results)
+    self.assertDictEqual(expected_suspects, suspects)
     self.assertDictEqual(expected_tag, tag)
 
   def _testFindCulpritForChromeCrashFails(self):
     analysis = CrashAnalysis()
     analysis.signature = 'signature'
     analysis.platform = 'win'
     analysis.stack_trace = 'frame1\nframe2'
     analysis.crashed_version = '50.0.1234.0'
-    results, tag = _FinditForChromeCrash().FindCulprit(analysis).ToDicts()
+    suspects, tag = _FinditForChromeCrash().FindCulprit(analysis).ToDicts()
 
-    expected_results = {'found': False}
+    expected_suspects = {'found': False}
     expected_tag = {
           'found_suspects': False,
           'found_project': False,
           'found_components': False,
           'has_regression_range': False,
           'solution': 'core_algorithm',
     }
 
-    self.assertDictEqual(expected_results, results)
+    self.assertDictEqual(expected_suspects, suspects)
     self.assertDictEqual(expected_tag, tag)
 
   @mock.patch('google.appengine.ext.ndb.Key.urlsafe')
   @mock.patch('common.appengine_util.GetDefaultVersionHostname')
   def testProcessResultForPublishing(self, mocked_get_default_host,
                                      mocked_urlsafe):
     mocked_host = 'http://host'
     mocked_get_default_host.return_value = mocked_host
     urlsafe_key = 'abcde'
     mocked_urlsafe.return_value = urlsafe_key
 
     crash_identifiers = {'signature': 'sig'}
     analysis = FracasCrashAnalysis.Create(crash_identifiers)
     analysis.result = {'other': 'data'}
     findit_object = FinditForFracas(None)
-    expected_processed_result = {
+    expected_processed_suspect = {
         'client_id': findit_object.client_id,
         'crash_identifiers': {'signature': 'sig'},
         'result': {
             'feedback_url': (
                 findit_for_chromecrash._FRACAS_FEEDBACK_URL_TEMPLATE % (
                     mocked_host, urlsafe_key)),
             'other': 'data'
         }
     }
 
     self.assertDictEqual(findit_object.GetPublishableResult(crash_identifiers,
                                                             analysis),
-                         expected_processed_result)
+                         expected_processed_suspect)