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

appengine/findit/lib/gitiles/test/gitiles_repository_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
 from datetime import datetime
 import json
 import re
 
 from testing_utils import testing
 
-from common import git_repository
+from lib.gitiles import gitiles_repository
+from lib.gitiles.change_log import ChangeLog

[stgao, 2016/10/28 18:21:00]

order of import

[wrengr, 2016/10/28 19:24:49]

Done.

+# TODO(wrengr): we shouldn't have anything in the gitiles directory
+# depend on stuff in the common directory.
 from common import retry_http_client
-from common.change_log import ChangeLog
 
 
 COMMIT_MESSAGE = ('Add popover for snapshot canvas log.\n\n'
                   'Review URL: https://codereview.chromium.org/320423004\n\n'
                   'Review URL: https://codereview.chromium.org/328113005\n\n'
                   'Cr-Commit-Position: refs/heads/master@{#175976}')
 
 COMMIT_LOG = """)]}'
 {
   "commit": "bcfd5a12eea05588aee98b7cf7e032d8cb5b58bb",
@@ skipping 255 matching lines @@
   def _Put(self, *_):  # pragma: no cover
     pass
 
 
 class GitRepositoryTest(testing.AppengineTestCase):
 
   def setUp(self):
     super(GitRepositoryTest, self).setUp()
     self.http_client_for_git = HttpClientForGit()
     self.repo_url = 'https://repo.test'
-    self.git_repo = git_repository.GitRepository(self.repo_url,
+    self.git_repo = gitiles_repository.GitilesRepository(self.repo_url,
                                                  self.http_client_for_git)
 
   def testGitRepositoryPropertySetters(self):
     http_client_for_git = HttpClientForGit()
-    git_repo = git_repository.GitRepository(http_client=http_client_for_git)
+    git_repo = gitiles_repository.GitilesRepository(
+        http_client=http_client_for_git)
     git_repo.repo_url = 'https://repo'
     self.assertEqual(git_repo.repo_url, 'https://repo')
 
     self.assertEqual(git_repo. http_client, http_client_for_git)
 
   def testExtractCommitPositionAndCodeReviewUrl(self):
     testcases = [
         {
             'message':
                 'balabala...\n'
@@ skipping 39 matching lines @@
     ]
 
     for testcase in testcases:
       (commit_position,
        code_review_url) = self.git_repo.ExtractCommitPositionAndCodeReviewUrl(
            testcase['message'])
       self.assertEqual(commit_position, testcase['commit_position'])
       self.assertEqual(code_review_url, testcase['code_review_url'])
 
   def testEndingSlashInRepoUrl(self):
-    git_repo1 = git_repository.GitRepository(self.repo_url,
-                                             self.http_client_for_git)
+    git_repo1 = gitiles_repository.GitilesRepository(
+        self.repo_url, self.http_client_for_git)
     self.assertEqual(self.repo_url, git_repo1.repo_url)
 
-    git_repo2 = git_repository.GitRepository('%s/' % self.repo_url,
-                                             self.http_client_for_git)
+    git_repo2 = gitiles_repository.GitilesRepository(
+        '%s/' % self.repo_url, self.http_client_for_git)
     self.assertEqual(self.repo_url, git_repo2.repo_url)
 
   def testMalformattedJsonReponse(self):
     self.http_client_for_git.SetResponseForUrl(
         '%s/+/%s?format=json' % (self.repo_url, 'aaa'), 'abcde{"a": 1}')
     self.assertRaisesRegexp(
         Exception, re.escape('Response does not begin with )]}\'\n'),
         self.git_repo.GetChangeLog, 'aaa')
 
   def testGetChangeLog(self):
@@ skipping 111 matching lines @@
     self.assertIsNone(reverted_revision)
 
   def testGetCommitsBetweenRevisions(self):
     def _MockSendRequestForJsonResponse(*_):
       return {
           'log': [
               {'commit': '3'},
               {'commit': '2'},
               {'commit': '1'}]
       }
-    self.mock(git_repository.GitRepository, '_SendRequestForJsonResponse',
-              _MockSendRequestForJsonResponse)
+    self.mock(gitiles_repository.GitilesRepository,
+        '_SendRequestForJsonResponse', _MockSendRequestForJsonResponse)
     expected_commits = ['3', '2', '1']
     actual_commits = self.git_repo.GetCommitsBetweenRevisions('0', '3')
     self.assertEqual(expected_commits, actual_commits)
 
   def testGetCommitsBetweenRevisionsWithEmptyData(self):
     def _MockSendRequestForJsonResponse(*_):
       return None
-    self.mock(git_repository.GitRepository, '_SendRequestForJsonResponse',
-              _MockSendRequestForJsonResponse)
+    self.mock(gitiles_repository.GitilesRepository,
+        '_SendRequestForJsonResponse', _MockSendRequestForJsonResponse)
     expected_commits = []
     actual_commits = self.git_repo.GetCommitsBetweenRevisions('0', '3')
     self.assertEqual(expected_commits, actual_commits)
 
   def testGetCommitsBetweenRevisionsWithIncompleteData(self):
     def _MockSendRequestForJsonResponse(*_):
       return {
           'log': [
               {'commit': '1'},
               {'something_else': '2'}
           ]
       }
-    self.mock(git_repository.GitRepository, '_SendRequestForJsonResponse',
-              _MockSendRequestForJsonResponse)
+    self.mock(gitiles_repository.GitilesRepository,
+        '_SendRequestForJsonResponse', _MockSendRequestForJsonResponse)
     expected_commits = ['1']
     actual_commits = self.git_repo.GetCommitsBetweenRevisions('0', '3')
     self.assertEqual(expected_commits, actual_commits)
 
   def testGetCommitsBetweenRevisionsWithPaging(self):
     def _MockSendRequestForJsonResponse(*args, **_):
       url = args[1]
       if '0..3' in url:
         return {
             'log': [
                 {'commit': '3'},
                 {'commit': '2'}
             ],
             'next': '1'
         }
       else:
         return {
             'log': [
                 {'commit': '1'}
             ]
         }
 
-    self.mock(git_repository.GitRepository, '_SendRequestForJsonResponse',
-              _MockSendRequestForJsonResponse)
+    self.mock(gitiles_repository.GitilesRepository,
+        '_SendRequestForJsonResponse', _MockSendRequestForJsonResponse)
     expected_commits = ['3', '2', '1']
     actual_commits = self.git_repo.GetCommitsBetweenRevisions('0', '3', n=2)
     self.assertEqual(expected_commits, actual_commits)
 
   def testGetChangeLogs(self):
     def _MockSendRequestForJsonResponse(*_, **kargs):
       self.assertTrue(bool(kargs))
       return {'log': [json.loads(COMMIT_LOG[5:])]}
 
-    self.mock(git_repository.GitRepository, '_SendRequestForJsonResponse',
-              _MockSendRequestForJsonResponse)
+    self.mock(gitiles_repository.GitilesRepository,
+        '_SendRequestForJsonResponse', _MockSendRequestForJsonResponse)
 
     changelogs = self.git_repo.GetChangeLogs('0', '2')
 
     self.assertEqual(len(changelogs), 1)
     self.assertEqual(changelogs[0].ToDict(), EXPECTED_CHANGE_LOG_JSON)
 
   def testGetChangeLogsNextPage(self):
     log1 = json.loads(COMMIT_LOG[5:])
     log1['commit'] = 'first_commit'
     log2 = log1.copy()
     log2['commit'] = 'next_page_commit'
 
     def _MockSendRequestForJsonResponse(_, url, **kargs):
       self.assertTrue(bool(kargs))
       if 'next' in url:
         return {'log': [log2]}
 
       return {'log': [log1], 'next': 'next_page_commit'}
 
-    self.mock(git_repository.GitRepository, '_SendRequestForJsonResponse',
-              _MockSendRequestForJsonResponse)
+    self.mock(gitiles_repository.GitilesRepository,
+        '_SendRequestForJsonResponse', _MockSendRequestForJsonResponse)
 
     changelogs = self.git_repo.GetChangeLogs('0', '2')
 
     self.assertEqual(len(changelogs), 2)
 
   def testGetWrappedGitRepositoryClass(self):
-    repo = git_repository.GitRepository('http://repo_url', HttpClientForGit())
+    repo = gitiles_repository.GitilesRepository(
+        'http://repo_url', HttpClientForGit())
 
     self.assertEqual(repo.repo_url, 'http://repo_url')
     self.assertTrue(isinstance(repo.http_client, HttpClientForGit))