[Findit] Factoring the gitiles (etc) stuff out into its own directory

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.
 
 from common import chrome_dependency_fetcher
-from common import git_repository
 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_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.culprit import NullCulprit
 from crash.findit_for_chromecrash import FinditForChromeCrash
 from crash.findit_for_chromecrash import FinditForFracas
 from crash.findit import Findit
 from crash.project_classifier import ProjectClassifier
 from crash.results import MatchResult
 from crash.stacktrace import CallStack
 from crash.stacktrace import Stacktrace
 from crash.test.crash_pipeline_test import DummyCrashData
 from crash.test.crash_testcase import CrashTestCase
 from crash.type_enums import CrashClient
+from lib.gitiles import gitiles_repository
 from model import analysis_status
 from model.crash.crash_analysis import CrashAnalysis
 from model.crash.fracas_crash_analysis import FracasCrashAnalysis
 
 # In production we'd use CrashWrapperPipeline. And that'd work fine here,
 # since we never actually call the method that uses it. But just to be
 # absolutely sure we don't go over the wire due to some mocking failure,
 # we'll use this dummy class instead. (In fact, since it's never used,
 # we don't even need to give a real class; |None| works just fine.)
 MOCK_PIPELINE_CLS = None
@@ skipping 32 matching lines @@
     return {}
 
 def _FinditForFracas():
   """A helper to pass in the standard pipeline class."""
   return FinditForFracas(MOCK_REPOSITORY, MOCK_PIPELINE_CLS)
 
 
 class FinditForChromeCrashTest(CrashTestCase):
 
   chrome_dep_fetcher = chrome_dependency_fetcher.ChromeDependencyFetcher(
-      git_repository.GitRepository(http_client=HttpClientAppengine()))
+      gitiles_repository.GitilesRepository(http_client=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, *_: NullCulprit())
 
     # 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(
-        git_repository.GitRepository(http_client=HttpClientAppengine()))
+        gitiles_repository.GitilesRepository(http_client=HttpClientAppengine()))
     result, tags = findit_client.FindCulprit(analysis).ToDicts()
     # TODO(wrengr): just test for the NullCulprit directly; instead of
     # going through |ToDicts|.
     expected_result, expected_tags = NullCulprit().ToDicts()
     self.assertDictEqual(result, expected_result)
     self.assertDictEqual(tags, expected_tags)
 
 
 class FinditForFracasTest(CrashTestCase):
 
@@ skipping 197 matching lines @@
     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_tag, tag)