[Predator] Pass config as argument to findit.

appengine/findit/crash/test/findit_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 copy
 import logging
 
 from google.appengine.api import app_identity
 
 from crash.findit import Findit
 from crash.type_enums import CrashClient
 from crash.test.predator_testcase import PredatorTestCase
+from model.crash.crash_config import CrashConfig
 from model.crash.fracas_crash_analysis import FracasCrashAnalysis
 
-
 MOCK_GET_REPOSITORY = lambda _: None # pragma: no cover
 
 
 class UnsupportedClient(Findit): # pylint: disable=W0223
   # TODO(http://crbug.com/659346): this isn't being called for some reason.
   @property
   def client_id(self): # pragma: no cover
     return self._client_id
 
   @property
-  def config(self): # pragma: no cover
+  def client_config(self): # pragma: no cover
     """Don't return None, so that PlatformRename doesn't crash."""
     return {}
 
-  def __init__(self, client_id=None):
-    super(UnsupportedClient, self).__init__(MOCK_GET_REPOSITORY)
+  def __init__(self, client_id=None, config=None):
     if client_id is None:
       client_id = 'unsupported_client'
     self._client_id = client_id
+    super(UnsupportedClient, self).__init__(MOCK_GET_REPOSITORY, config)
 
 
 class MockFindit(Findit):  # pylint: disable = W
   """Overwrite abstract method of Findit for testing."""
 
-  def __init__(self):
-    super(MockFindit, self).__init__(MOCK_GET_REPOSITORY)
+  def __init__(self, config=None):
+    super(MockFindit, self).__init__(MOCK_GET_REPOSITORY, config)
 
   @classmethod
   def _ClientID(cls):
     return CrashClient.FRACAS
 
   def ProcessResultForPublishing(self, result, key):
     return result
 
 
 class FinditTest(PredatorTestCase):
 
   def setUp(self):
     super(FinditTest, self).setUp()
-    self.findit = MockFindit()
+    self.findit = MockFindit(CrashConfig.Get())
 
   def testPlatformRename(self):
     self.assertEqual(
         self.findit.RenamePlatform('linux'), 'unix')
 
   def testCheckPolicyUnsupportedClient(self):
-    self.assertIsNone(UnsupportedClient().CheckPolicy(self.GetDummyCrashData(
-        platform = 'canary',
-        signature = 'sig',
-    )))
+    self.assertIsNone(UnsupportedClient(config=CrashConfig.Get()).CheckPolicy(
+        self.GetDummyCrashData(
+            platform = 'canary',
+            signature = 'sig',
+        )))
 
   def testCreateAnalysisForUnsupportedClientId(self):
-    self.assertIsNone(UnsupportedClient('unsupported_id').CreateAnalysis(
-        {'signature': 'sig'}))
+    unsupported_client = UnsupportedClient('unsupported_id',
+                                           config=CrashConfig.Get())
+    self.assertIsNone(unsupported_client.CreateAnalysis({'signature': 'sig'}))
 
   def testGetAnalysisForUnsuportedClient(self):
     crash_identifiers = {'signature': 'sig'}
     # TODO(wrengr): it'd be less fragile to call FinditForFracas.CreateAnalysis
     # instead. But then we'd need to make UnsupportedClient inherit that
     # implementation, rather than inheriting the one from the Findit
     # base class.
     analysis = FracasCrashAnalysis.Create(crash_identifiers)
     analysis.put()
+    unsupported_client = UnsupportedClient('Unsupported_client',
+                                           config=CrashConfig.Get())
     self.assertIsNone(
-        UnsupportedClient('Unsupported_client').GetAnalysis(crash_identifiers),
+        unsupported_client.GetAnalysis(crash_identifiers),
         'Unsupported client unexpectedly got analysis %s via identifiers %s'
         % (analysis, crash_identifiers))
 
   def testGetPublishableResultFoundTrue(self):
     analysis_result = {
         'found': True,
         'suspected_cls': [
             {'confidence': 0.21434,
              'reasons': ['reason1', 'reason2'],
              'other': 'data'}
@@ skipping 30 matching lines @@
         'client_id': self.findit.client_id,
         'result': copy.deepcopy(analysis_result),
     }
 
     analysis = FracasCrashAnalysis.Create(crash_identifiers)
     analysis.result = analysis_result
 
     self.assertDictEqual(self.findit.GetPublishableResult(crash_identifiers,
                                                           analysis),
                          expected_processed_result)