[Predator] Pass config as argument to findit.

appengine/findit/handlers/crash/test/crash_handler_test.py

 # Copyright 2015 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 base64
 import copy
 import json
 import logging
 
 from google.appengine.api import app_identity
 from google.appengine.ext import ndb
 import webapp2
 from webtest.app import AppError
 
 from common import chrome_dependency_fetcher
 from crash import crash_pipeline
 from crash.findit import Findit
 from crash.findit_for_chromecrash import FinditForFracas
 from crash.test.predator_testcase import PredatorTestCase
 from crash.type_enums import CrashClient
 from handlers.crash import crash_handler
 from libs.gitiles import gitiles_repository
 from model import analysis_status
+from model.crash.crash_config import CrashConfig
 from model.crash.fracas_crash_analysis import FracasCrashAnalysis
 
 
 MOCK_GET_REPOSITORY = lambda _: None # pragma: no cover
 
 
 class MockCulprit(object):
   """Construct a fake culprit where ``ToDicts`` returns whatever we please."""
 
   def __init__(self, mock_result, mock_tags):
     self._result = mock_result
     self._tags = mock_tags
 
   def ToDicts(self): # pragma: no cover
     return self._result, self._tags
 
 
 class CrashHandlerTest(PredatorTestCase):
   app_module = webapp2.WSGIApplication([
       ('/_ah/push-handlers/crash/fracas', crash_handler.CrashHandler),
   ], debug=True)
 
   def testScheduleNewAnalysisWithFailingPolicy(self):
-    class _MockFindit(Findit): # pylint: disable=W0223
-      def __init__(self):
-        super(_MockFindit, self).__init__(MOCK_GET_REPOSITORY)
-
-      def CheckPolicy(self, crash_data):
-        """This is the same as inherited, but just to be explicit."""
-        return None
-
-      def _NeedsNewAnalysis(self, _crash_data):
-        raise AssertionError('testScheduleNewAnalysisWithFailingPolicy: '
-            "called _MockFindit._NeedsNewAnalysis, when it shouldn't.")
-
-    self.mock(crash_pipeline, 'FinditForClientID', lambda *_: _MockFindit())
+    mock_findit = self.GetMockFindit()
+    self.mock(mock_findit, 'CheckPolicy', lambda *_: None)
+    self.mock(crash_pipeline, 'FinditForClientID', lambda *_: mock_findit)
     self.assertFalse(crash_handler.ScheduleNewAnalysis(self.GetDummyCrashData(
         client_id = 'MOCK_CLIENT')))
 
   def testScheduleNewAnalysisWithPlatformRename(self):
     original_crash_data = self.GetDummyCrashData(
         client_id = 'MOCK_CLIENT',
         version = None,
         platform = 'unix',
         crash_identifiers = {})
     renamed_crash_data = copy.deepcopy(original_crash_data)
     renamed_crash_data['platform'] = 'linux'
 
-    testcase = self
-    class _MockFindit(Findit): # pylint: disable=W0223
-      def __init__(self):
-        super(_MockFindit, self).__init__(MOCK_GET_REPOSITORY)
-
-      @property
-      def config(self):
-        """Make PlatformRename work as expected."""
-        return {'platform_rename': {'unix': 'linux'}}
-
-      def CheckPolicy(self, crash_data):
-        """Call PlatformRename, and return successfully.
-
-        N.B., if we did not override this method, then our overridden
-        ``_NeedsNewAnalysis`` would never be called either."""
-        # TODO(wrengr): should we clone ``crash_data`` rather than mutating it?
-        crash_data['platform'] = self.RenamePlatform(crash_data['platform'])
-        return crash_data
-
-      def _NeedsNewAnalysis(self, new_crash_data):
-        logging.debug('Called _MockFindit._NeedsNewAnalysis, as desired')
-        testcase.assertDictEqual(new_crash_data, renamed_crash_data)
-        return False
-
     self.mock(crash_pipeline, 'FinditForClientID',
-        lambda _client_id, repository: _MockFindit())
+        lambda *_: self.GetMockFindit(client_id='fracas'))
     self.assertFalse(crash_handler.ScheduleNewAnalysis(original_crash_data))
 
   def testScheduleNewAnalysisSkipsUnsupportedChannel(self):
     self.assertFalse(crash_handler.ScheduleNewAnalysis(self.GetDummyCrashData(
         client_id = CrashClient.FRACAS,
         version = None,
         signature = None,
         crash_identifiers = {},
         channel = 'unsupported_channel')))
 
   def testScheduleNewAnalysisSkipsUnsupportedPlatform(self):
     self.assertFalse(crash_handler.ScheduleNewAnalysis(self.GetDummyCrashData(
         client_id = CrashClient.FRACAS,
         version = None,
         signature = None,
         platform = 'unsupported_platform',
         crash_identifiers = {})))
 
   def testScheduleNewAnalysisSkipsBlackListSignature(self):
     self.assertFalse(crash_handler.ScheduleNewAnalysis(self.GetDummyCrashData(
         client_id = CrashClient.FRACAS,
         version = None,
         signature = 'Blacklist marker signature',
         crash_identifiers = {})))
 
   def testScheduleNewAnalysisSkipsIfAlreadyCompleted(self):
-    findit_client = FinditForFracas(MOCK_GET_REPOSITORY)
+    findit_client = FinditForFracas(MOCK_GET_REPOSITORY, CrashConfig.Get())
     crash_data = self.GetDummyCrashData(client_id = findit_client.client_id)
     crash_identifiers = crash_data['crash_identifiers']
     analysis = findit_client.CreateAnalysis(crash_identifiers)
     analysis.status = analysis_status.COMPLETED
     analysis.put()
     self.assertFalse(crash_handler.ScheduleNewAnalysis(crash_data))
 
   def testAnalysisScheduled(self):
     # We need to mock out the method on Findit itself (rather than using a
     # subclass), since this method only gets called on objects we
@@ skipping 202 matching lines @@
         'has_regression_range': True,
         'solution': 'core',
         'unsupported_tag': '',
     }
 
     analysis = self._TestRunningAnalysisForResult(
         analysis_result, analysis_tags)
     self.assertTrue(analysis.has_regression_range)
     self.assertTrue(analysis.found_suspects)
     self.assertEqual('core', analysis.solution)