Removing the mutation in the factories for getting dep repositories

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
@@ skipping 12 matching lines @@
 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
 
-MOCK_REPOSITORY = None
+MOCK_GET_REPOSITORY = lambda _: None # pragma: no cover
 
 class _FinditForChromeCrash(FinditForChromeCrash):  # pylint: disable = W
-  # We allow overriding the default MOCK_REPOSITORY because one unittest
+  # We allow overriding the default ``get_repository`` because one unittest
   # needs to.
-  def __init__(self, repository=MOCK_REPOSITORY):
-    super(_FinditForChromeCrash, self).__init__(repository)
+  def __init__(self, get_repository=MOCK_GET_REPOSITORY):
+    super(_FinditForChromeCrash, self).__init__(get_repository)
 
   @classmethod
   def _ClientID(cls): # pragma: no cover
     """Avoid throwing a NotImplementedError.
 
     Since this method is called from ``FinditForChromeCrash.__init__``
     in order to construct the Azalea object, we need to not throw
     exceptions since we want to be able to test the FinditForChromeCrash
     class itself.
     """
     return ''
 
   @property
   def config(self):
     """Avoid returning None.
 
     The default ``Findit.config`` will return None if the client
     id is not found in the CrashConfig. This in turn will cause
     ``FinditForChromeCrash.__init__`` to crash, since NoneType doesn't
     have a ``get`` method. In general it's fine for things to crash, since
     noone should make instances of Findit subclasses which don't define
     ``_clientID``; but for this test suite, we want to permit instances
     of FinditForChromeCrash, so that we can test that class directly.
     """
     return {}
 
 
 def _FinditForFracas():
   """A helper to pass in the standard pipeline class."""
-  return FinditForFracas(MOCK_REPOSITORY)
+  return FinditForFracas(MOCK_GET_REPOSITORY)
+
+
+def _GitilesRepositoryFactory(repo_url): # pragma: no cover
+  return gitiles_repository.GitilesRepository(
+      HttpClientAppengine(), repo_url)
 
 
 class FinditForChromeCrashTest(PredatorTestCase):
 
-  chrome_dep_fetcher = chrome_dependency_fetcher.ChromeDependencyFetcher(
-      gitiles_repository.GitilesRepository(HttpClientAppengine()))
-
   # TODO(wrengr): what was the purpose of this test? As written it's
   # just testing that mocking works. I'm guessing it was to check that
   # we fail when the analysis is for the wrong client_id; but if so,
   # then we shouldn't need to mock FindCulprit...
   def testFindCulprit(self):
     self.mock(FinditForChromeCrash, 'FindCulprit', lambda self, *_: None)
 
     # TODO(wrengr): would be less fragile to call
     # FinditForFracas.CreateAnalysis instead; though if I'm right about
     # the original purpose of this test, then this is one of the few
     # places where calling FracasCrashAnalysis directly would actually
     # make sense.
     analysis = FracasCrashAnalysis.Create({'signature': 'sig'})
     # TODO(wrengr): shouldn't FracasCrashAnalysis.Create already have set
     # the client_id?
     analysis.client_id = CrashClient.FRACAS
 
-    findit_client = _FinditForChromeCrash(
-        gitiles_repository.GitilesRepository(HttpClientAppengine()))
+    findit_client = _FinditForChromeCrash(_GitilesRepositoryFactory)
     self.assertIsNone(findit_client.FindCulprit(analysis))
 
 
 class FinditForFracasTest(PredatorTestCase):
 
   def testPlatformRename(self):
     self.assertEqual(_FinditForFracas().RenamePlatform('linux'), 'unix')
 
   def testCheckPolicyUnsupportedPlatform(self):
     self.assertIsNone(_FinditForFracas().CheckPolicy(DummyCrashData(
@@ skipping 164 matching lines @@
   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)
+    findit_object = FinditForFracas(MOCK_GET_REPOSITORY)
     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_suspect)