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

appengine/findit/common/test/chrome_dependency_fetcher_test.py

 # Copyright 2014 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 collections
 
 from testing_utils import testing
 
 from common import chrome_dependency_fetcher
 from common import deps_parser
-from common import git_repository
-from common import repository
 from common import retry_http_client
 from common import http_client_appengine
 from common.dependency import Dependency, DependencyRoll
+from lib.gitiles.git_repository import GitRepository
+from lib.gitiles import gitiles_repository
 
 
-class DummyGitRepository(repository.Repository):
+class MockGitilesRepository(GitRepository):
+  """A class for mocking GitilesRepository.
+
+  N.B., in order to use this class for mocking, every module we want to
+  test with a mock GitilesRepository must not import that class directly.
+  Instead they must import the gitiles_repository module and rely on
+  dynamic dispatch to resolve the GitilesRepository attribute. Otherwise
+  those modules will hold direct links to the real GitilesRepository
+  class, and so won't dispatch into this mock class for our unit tests."""
+
   RESPONSES = {}
 
   def __init__(self, *_):
     pass
 
   def GetSource(self, path, revision):
     return self.RESPONSES.get(path, {}).get(revision, None)
 
 
 class ChromiumDEPSTest(testing.AppengineTestCase):
   DEPS_GIT = '.DEPS.git'
   DEPS = 'DEPS'
   deps_downloader = chrome_dependency_fetcher.DEPSDownloader(
-      DummyGitRepository())
+      MockGitilesRepository())
   chrome_dep_fetcher = chrome_dependency_fetcher.ChromeDependencyFetcher(
-      DummyGitRepository())
+      MockGitilesRepository())
 
   def testUseDEPS_GIT(self):
     revision = 'abc'
     expected_content = '.DEPS.git content'
 
-    DummyGitRepository.RESPONSES = {
+    MockGitilesRepository.RESPONSES = {
         self.DEPS_GIT: {
             revision: expected_content
         },
         self.DEPS: {
             revision: 'DEPS test'
         },
     }
 
     content = self.deps_downloader.Load(
         chrome_dependency_fetcher._CHROMIUM_REPO_MASTER, revision, 'DEPS')
     self.assertEqual(expected_content, content)
 
   def testNotUseDEPS_GIT(self):
     revision = 'abc'
     expected_content = 'DEPS test'
 
-    DummyGitRepository.RESPONSES = {
+    MockGitilesRepository.RESPONSES = {
         self.DEPS_GIT: {
             revision: '.DEPS.git content'
         },
         self.DEPS: {
             revision: expected_content
         },
     }
 
-    self.mock(git_repository, 'GitRepository', DummyGitRepository)
+    self.mock(gitiles_repository, 'GitilesRepository', MockGitilesRepository)
 
     content = self.deps_downloader.Load(
         'https://src.git', revision, 'DEPS')
     self.assertEqual(expected_content, content)
 
   def testUseFallbackDEPS(self):
     revision = 'abc'
     expected_content = 'DEPS test'
 
-    DummyGitRepository.RESPONSES = {
+    MockGitilesRepository.RESPONSES = {
         self.DEPS: {
             revision: expected_content
         },
     }
 
-    self.mock(git_repository, 'GitRepository', DummyGitRepository)
+    self.mock(gitiles_repository, 'GitilesRepository', MockGitilesRepository)
 
     content = self.deps_downloader.Load(
         'https://src.git', revision, 'NONEXISTENT_DEPS')
     self.assertEqual(expected_content, content)
 
   def testUseSlaveDEPS(self):
     revision = 'abc'
     expected_content = 'slave DEPS content'
 
-    DummyGitRepository.RESPONSES = {
+    MockGitilesRepository.RESPONSES = {
         self.DEPS_GIT: {
             revision: '.DEPS.git content'
         },
         'slave.DEPS': {
             revision: expected_content
         },
     }
 
-    self.mock(git_repository, 'GitRepository', DummyGitRepository)
+    self.mock(gitiles_repository, 'GitilesRepository', MockGitilesRepository)
 
     content = self.deps_downloader.Load(
         'https://src.git', revision, 'slave.DEPS')
     self.assertEqual(expected_content, content)
 
   def testFailedToPullDEPSFile(self):
-    DummyGitRepository.RESPONSES = {}
+    MockGitilesRepository.RESPONSES = {}
 
     self.assertRaisesRegexp(Exception, 'Failed to pull DEPS file.',
                             self.deps_downloader.Load,
                             'https://src.git', 'abc', 'DEPS')
 
   def testDEPSDownloaderForChromeVersion(self):
 
     def _MockGet(*_):
       return 200, base64.b64encode('Dummy DEPS content')
 
     self.mock(http_client_appengine.HttpClientAppengine, '_Get', _MockGet)
 
     deps_downloader = chrome_dependency_fetcher.DEPSDownloader(
-        git_repository.GitRepository(
+        gitiles_repository.GitilesRepository(
             http_client=http_client_appengine.HttpClientAppengine()))
     content = deps_downloader.Load(
         'http://chrome-internal', '50.0.1234.0', 'DEPS')
     self.assertEqual(content, 'Dummy DEPS content')
 
     self.assertRaisesRegexp(
         Exception,
         'Failed to pull DEPS file from http://chrome, at revision 50.0.1234.1.',
         self.deps_downloader.Load,
         'http://chrome', '50.0.1234.1', 'DEPS')
@@ skipping 49 matching lines @@
     def DummyUpdateDependencyTree(root_dep, target_os_list, _):
       self.assertEqual(src_path, root_dep.path)
       self.assertEqual(src_repo_url, root_dep.repo_url)
       self.assertEqual([os_platform], target_os_list)
 
       expected_dependency_dict[root_dep.path] = root_dep
       child1_dep.SetParent(root_dep)
       child2_dep.SetParent(root_dep)
       grand_child1.SetParent(child1_dep)
 
-    self.mock(git_repository, 'GitRepository', DummyGitRepository)
+    self.mock(gitiles_repository, 'GitilesRepository', MockGitilesRepository)
     self.mock(deps_parser, 'UpdateDependencyTree', DummyUpdateDependencyTree)
 
     dependency_dict = self.chrome_dep_fetcher.GetDependency(
         '50.0.1234.0', os_platform)
     self.assertEqual(expected_dependency_dict, dependency_dict)
 
   def testGetDependencyRolls(self):
     def MockGetDependency(revision, os_platform, _=False):
       self.assertEqual('unix', os_platform)
       if revision == 'rev2':
@@ skipping 74 matching lines @@
             'src/',
             'https://chromium.googlesource.com/chromium/src.git', '4', '5'),
     }
     self.assertEqual(self.chrome_dep_fetcher.GetDependencyRollsDict(
         '4', '5', 'all'), expected_deps_rolls_dict)
 
   def testIsChromeVersion(self):
     self.assertTrue(chrome_dependency_fetcher.IsChromeVersion('50.0.1234.1'))
     self.assertFalse(chrome_dependency_fetcher.IsChromeVersion('a.b.c.e'))
     self.assertFalse(chrome_dependency_fetcher.IsChromeVersion('5.021.2.0.123'))