Group SCM-specific functions in classes to simplify generalization of the interface.

tests/presubmit_unittest.py

 #!/usr/bin/python
 # Copyright (c) 2006-2009 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.
 
 """Unit tests for presubmit_support.py and presubmit_canned_checks.py."""
 
 import StringIO
 
-# Local imports
 import presubmit_support as presubmit
-import presubmit_canned_checks
+# Shortcut.
+from presubmit_support import presubmit_canned_checks
 from super_mox import mox, SuperMoxTestBase
 
 
 class PresubmitTestsBase(SuperMoxTestBase):
   """Setups and tear downs the mocks but doesn't test anything as-is."""
   presubmit_text = """
 def CheckChangeOnUpload(input_api, output_api):
   if not input_api.change.NOSUCHKEY:
     return [output_api.PresubmitError("!!")]
   elif not input_api.change.REALLYNOSUCHKEY:
@@ skipping 17 matching lines @@
     self.fake_root_dir = self.RootDir()
     # Special mocks.
     def MockAbsPath(f):
       return f
     def MockChdir(f):
       return None
     # SuperMoxTestBase already mock these but simplify our life.
     presubmit.os.path.abspath = MockAbsPath
     presubmit.os.getcwd = self.RootDir
     presubmit.os.chdir = MockChdir
-    self.mox.StubOutWithMock(presubmit.gclient_scm, 'CaptureSVNInfo')
-    self.mox.StubOutWithMock(presubmit.gcl, 'GetSVNFileProperty')
+    self.mox.StubOutWithMock(presubmit.scm.SVN, 'CaptureInfo')
+    self.mox.StubOutWithMock(presubmit.scm.SVN, 'GetFileProperty')
+    # TODO(maruel): Err, small duplication of code here.
     self.mox.StubOutWithMock(presubmit.gcl, 'ReadFile')
+    self.mox.StubOutWithMock(presubmit.gclient_utils, 'FileRead')
 
 
 class PresubmitUnittest(PresubmitTestsBase):
   """General presubmit_support.py tests (excluding InputApi and OutputApi)."""
   def testMembersChanged(self):
     self.mox.ReplayAll()
     members = [
       'AffectedFile', 'Change', 'DoGetTrySlaves', 'DoPresubmitChecks',
       'GetTrySlavesExecuter', 'GitAffectedFile', 'GitChange',
       'InputApi', 'ListRelevantPresubmitFiles', 'Main',
       'NotImplementedException', 'OutputApi', 'ParseFiles',
       'PresubmitExecuter', 'PromptYesNo', 'ScanSubDirs',
       'SvnAffectedFile', 'SvnChange', 'cPickle', 'cStringIO',
-      'exceptions', 'fnmatch', 'gcl', 'gclient_scm', 'glob',
+      'exceptions', 'fnmatch', 'gcl', 'gclient_utils', 'glob',
       'logging', 'marshal', 'normpath', 'optparse', 'os', 'pickle',
-      'presubmit_canned_checks', 'random', 're', 'subprocess', 'sys',
+      'presubmit_canned_checks', 'random', 're', 'scm', 'subprocess', 'sys',
       'tempfile', 'time', 'traceback', 'types', 'unittest', 'urllib2',
       'warnings',
     ]
     # If this test fails, you should add the relevant test.
     self.compareMembers(presubmit, members)
 
   def testListRelevantPresubmitFiles(self):
     join = presubmit.os.path.join
     files = [
       'blat.cc',
@@ skipping 54 matching lines @@
     isdir = presubmit.os.path.join(self.fake_root_dir, 'isdir')
     presubmit.os.path.exists(blat).AndReturn(True)
     presubmit.os.path.isdir(blat).AndReturn(False)
     presubmit.os.path.exists(binary).AndReturn(True)
     presubmit.os.path.isdir(binary).AndReturn(False)
     presubmit.os.path.exists(isdir).AndReturn(True)
     presubmit.os.path.isdir(isdir).AndReturn(True)
     presubmit.os.path.exists(notfound).AndReturn(True)
     presubmit.os.path.isdir(notfound).AndReturn(False)
     presubmit.os.path.exists(flap).AndReturn(False)
-    presubmit.gclient_scm.CaptureSVNInfo(flap
+    presubmit.scm.SVN.CaptureInfo(flap
         ).AndReturn({'Node Kind': 'file'})
-    presubmit.gcl.GetSVNFileProperty(blat, 'svn:mime-type').AndReturn(None)
-    presubmit.gcl.GetSVNFileProperty(
+    presubmit.scm.SVN.GetFileProperty(blat, 'svn:mime-type').AndReturn(None)
+    presubmit.scm.SVN.GetFileProperty(
         binary, 'svn:mime-type').AndReturn('application/octet-stream')
-    presubmit.gcl.GetSVNFileProperty(
+    presubmit.scm.SVN.GetFileProperty(
         notfound, 'svn:mime-type').AndReturn('')
-    presubmit.gclient_scm.CaptureSVNInfo(blat).AndReturn(
+    presubmit.scm.SVN.CaptureInfo(blat).AndReturn(
             {'URL': 'svn:/foo/foo/blat.cc'})
-    presubmit.gclient_scm.CaptureSVNInfo(binary).AndReturn(
+    presubmit.scm.SVN.CaptureInfo(binary).AndReturn(
         {'URL': 'svn:/foo/binary.dll'})
-    presubmit.gclient_scm.CaptureSVNInfo(notfound).AndReturn({})
-    presubmit.gclient_scm.CaptureSVNInfo(flap).AndReturn(
+    presubmit.scm.SVN.CaptureInfo(notfound).AndReturn({})
+    presubmit.scm.SVN.CaptureInfo(flap).AndReturn(
             {'URL': 'svn:/foo/boo/flap.h'})
-    presubmit.gcl.ReadFile(blat).AndReturn('boo!\nahh?')
-    presubmit.gcl.ReadFile(notfound).AndReturn('look!\nthere?')
+    presubmit.gclient_utils.FileRead(blat, 'rU').AndReturn('boo!\nahh?')
+    presubmit.gclient_utils.FileRead(notfound, 'rU').AndReturn('look!\nthere?')
     self.mox.ReplayAll()
 
     change = presubmit.SvnChange('mychange', '\n'.join(description_lines),
                                  self.fake_root_dir, files, 0, 0)
     self.failUnless(change.Name() == 'mychange')
     self.failUnless(change.DescriptionText() ==
                     'Hello there\nthis is a change\nand some more regular text')
     self.failUnless(change.FullDescriptionText() ==
                     '\n'.join(description_lines))
 
@@ skipping 109 matching lines @@
     description_lines = ('Hello there',
                          'this is a change',
                          'STORY=http://tracker/123')
     files = [
       ['A', join('haspresubmit', 'blat.cc')],
     ]
     haspresubmit_path = join(self.fake_root_dir, 'haspresubmit', 'PRESUBMIT.py')
     root_path = join(self.fake_root_dir, 'PRESUBMIT.py')
     presubmit.os.path.isfile(root_path).AndReturn(True)
     presubmit.os.path.isfile(haspresubmit_path).AndReturn(True)
-    presubmit.gcl.ReadFile(root_path,
-                           'rU').AndReturn(self.presubmit_text)
-    presubmit.gcl.ReadFile(haspresubmit_path,
-                           'rU').AndReturn(self.presubmit_text)
+    presubmit.gclient_utils.FileRead(root_path,
+                                     'rU').AndReturn(self.presubmit_text)
+    presubmit.gclient_utils.FileRead(haspresubmit_path,
+                                     'rU').AndReturn(self.presubmit_text)
     presubmit.random.randint(0, 4).AndReturn(1)
     self.mox.ReplayAll()
 
     output = StringIO.StringIO()
     input = StringIO.StringIO('y\n')
     change = presubmit.Change('mychange', '\n'.join(description_lines),
                               self.fake_root_dir, files, 0, 0)
     self.failIf(presubmit.DoPresubmitChecks(change, False, True, output, input,
                                             None, False))
     self.assertEqual(output.getvalue().count('!!'), 2)
 
   def testDoPresubmitChecksPromptsAfterWarnings(self):
     join = presubmit.os.path.join
     description_lines = ('Hello there',
                          'this is a change',
                          'NOSUCHKEY=http://tracker/123')
     files = [
       ['A', join('haspresubmit', 'blat.cc')],
     ]
     presubmit_path = join(self.fake_root_dir, 'PRESUBMIT.py')
     haspresubmit_path = join(self.fake_root_dir, 'haspresubmit', 'PRESUBMIT.py')
     for i in range(2):
       presubmit.os.path.isfile(presubmit_path).AndReturn(True)
       presubmit.os.path.isfile(haspresubmit_path).AndReturn(True)
-      presubmit.gcl.ReadFile(presubmit_path, 'rU'
+      presubmit.gclient_utils.FileRead(presubmit_path, 'rU'
           ).AndReturn(self.presubmit_text)
-      presubmit.gcl.ReadFile(haspresubmit_path, 'rU'
+      presubmit.gclient_utils.FileRead(haspresubmit_path, 'rU'
           ).AndReturn(self.presubmit_text)
     presubmit.random.randint(0, 4).AndReturn(1)
     presubmit.random.randint(0, 4).AndReturn(1)
     self.mox.ReplayAll()
 
     output = StringIO.StringIO()
     input = StringIO.StringIO('n\n')  # say no to the warning
     change = presubmit.Change('mychange', '\n'.join(description_lines),
                               self.fake_root_dir, files, 0, 0)
     self.failIf(presubmit.DoPresubmitChecks(change, False, True, output, input,
@@ skipping 13 matching lines @@
                          'NOSUCHKEY=http://tracker/123',
                          'REALLYNOSUCHKEY=http://tracker/123')
     files = [
       ['A', join('haspresubmit', 'blat.cc')],
     ]
     presubmit_path = join(self.fake_root_dir, 'PRESUBMIT.py')
     haspresubmit_path = join(self.fake_root_dir, 'haspresubmit',
                              'PRESUBMIT.py')
     presubmit.os.path.isfile(presubmit_path).AndReturn(True)
     presubmit.os.path.isfile(haspresubmit_path).AndReturn(True)
-    presubmit.gcl.ReadFile(presubmit_path, 'rU').AndReturn(self.presubmit_text)
-    presubmit.gcl.ReadFile(haspresubmit_path, 'rU').AndReturn(
+    presubmit.gclient_utils.FileRead(presubmit_path, 'rU'
+                                     ).AndReturn(self.presubmit_text)
+    presubmit.gclient_utils.FileRead(haspresubmit_path, 'rU').AndReturn(
         self.presubmit_text)
     presubmit.random.randint(0, 4).AndReturn(1)
     self.mox.ReplayAll()
 
     output = StringIO.StringIO()
     input = StringIO.StringIO()  # should be unused
     change = presubmit.Change('mychange', '\n'.join(description_lines),
                               self.fake_root_dir, files, 0, 0)
     self.failIf(presubmit.DoPresubmitChecks(change, False, True, output, input,
                                             None, False))
@@ skipping 131 matching lines @@
                                                     str(result)))
 
   def testDoGetTrySlaves(self):
     join = presubmit.os.path.join
     filename = 'foo.cc'
     filename_linux = join('linux_only', 'penguin.cc')
     root_presubmit = join(self.fake_root_dir, 'PRESUBMIT.py')
     linux_presubmit = join(self.fake_root_dir, 'linux_only', 'PRESUBMIT.py')
 
     presubmit.os.path.isfile(root_presubmit).AndReturn(True)
-    presubmit.gcl.ReadFile(root_presubmit, 'rU').AndReturn(
+    presubmit.gclient_utils.FileRead(root_presubmit, 'rU').AndReturn(
         self.presubmit_tryslave % '["win"]')
 
     presubmit.os.path.isfile(root_presubmit).AndReturn(True)
     presubmit.os.path.isfile(linux_presubmit).AndReturn(True)
-    presubmit.gcl.ReadFile(root_presubmit, 'rU').AndReturn(
+    presubmit.gclient_utils.FileRead(root_presubmit, 'rU').AndReturn(
         self.presubmit_tryslave % '["win"]')
-    presubmit.gcl.ReadFile(linux_presubmit, 'rU').AndReturn(
+    presubmit.gclient_utils.FileRead(linux_presubmit, 'rU').AndReturn(
         self.presubmit_tryslave % '["linux"]')
     self.mox.ReplayAll()
 
     output = StringIO.StringIO()
     self.assertEqual(['win'],
                      presubmit.DoGetTrySlaves([filename], self.fake_root_dir,
                                               None, False, output))
     output = StringIO.StringIO()
     self.assertEqual(['win', 'linux'],
                      presubmit.DoGetTrySlaves([filename, filename_linux],
@@ skipping 35 matching lines @@
       'basename', 'cPickle', 'cStringIO', 'canned_checks', 'change', 'environ',
       'is_committing', 'marshal', 'os_path', 'pickle', 'platform',
       'python_executable',
       're', 'subprocess', 'tempfile', 'traceback', 'unittest', 'urllib2',
       'version',
     ]
     # If this test fails, you should add the relevant test.
     self.compareMembers(presubmit.InputApi(None, './.', False), members)
 
   def testDepotToLocalPath(self):
-    presubmit.gclient_scm.CaptureSVNInfo('svn://foo/smurf').AndReturn(
+    presubmit.scm.SVN.CaptureInfo('svn://foo/smurf').AndReturn(
         {'Path': 'prout'})
-    presubmit.gclient_scm.CaptureSVNInfo('svn:/foo/notfound/burp').AndReturn({})
+    presubmit.scm.SVN.CaptureInfo('svn:/foo/notfound/burp').AndReturn({})
     self.mox.ReplayAll()
 
     path = presubmit.InputApi(None, './p', False).DepotToLocalPath(
         'svn://foo/smurf')
     self.failUnless(path == 'prout')
     path = presubmit.InputApi(None, './p', False).DepotToLocalPath(
         'svn:/foo/notfound/burp')
     self.failUnless(path == None)
 
   def testLocalToDepotPath(self):
-    presubmit.gclient_scm.CaptureSVNInfo('smurf').AndReturn({'URL':
+    presubmit.scm.SVN.CaptureInfo('smurf').AndReturn({'URL':
                                                                'svn://foo'})
-    presubmit.gclient_scm.CaptureSVNInfo('notfound-food').AndReturn({})
+    presubmit.scm.SVN.CaptureInfo('notfound-food').AndReturn({})
     self.mox.ReplayAll()
 
     path = presubmit.InputApi(None, './p', False).LocalToDepotPath('smurf')
     self.assertEqual(path, 'svn://foo')
     path = presubmit.InputApi(None, './p', False).LocalToDepotPath(
         'notfound-food')
     self.failUnless(path == None)
 
   def testInputApiConstruction(self):
     self.mox.ReplayAll()
@@ skipping 30 matching lines @@
     beingdeleted = presubmit.normpath(join(self.fake_root_dir, files[6][1]))
     notfound = presubmit.normpath(join(self.fake_root_dir, files[7][1]))
     flap = presubmit.normpath(join(self.fake_root_dir, files[8][1]))
     for i in (blat, readme, binary, weird, another, third_party):
       presubmit.os.path.exists(i).AndReturn(True)
       presubmit.os.path.isdir(i).AndReturn(False)
     presubmit.os.path.exists(beingdeleted).AndReturn(False)
     presubmit.os.path.exists(notfound).AndReturn(False)
     presubmit.os.path.exists(flap).AndReturn(True)
     presubmit.os.path.isdir(flap).AndReturn(False)
-    presubmit.gclient_scm.CaptureSVNInfo(beingdeleted).AndReturn({})
-    presubmit.gclient_scm.CaptureSVNInfo(notfound).AndReturn({})
-    presubmit.gcl.GetSVNFileProperty(blat, 'svn:mime-type').AndReturn(None)
-    presubmit.gcl.GetSVNFileProperty(readme, 'svn:mime-type').AndReturn(None)
-    presubmit.gcl.GetSVNFileProperty(binary, 'svn:mime-type').AndReturn(
+    presubmit.scm.SVN.CaptureInfo(beingdeleted).AndReturn({})
+    presubmit.scm.SVN.CaptureInfo(notfound).AndReturn({})
+    presubmit.scm.SVN.GetFileProperty(blat, 'svn:mime-type').AndReturn(None)
+    presubmit.scm.SVN.GetFileProperty(readme, 'svn:mime-type').AndReturn(None)
+    presubmit.scm.SVN.GetFileProperty(binary, 'svn:mime-type').AndReturn(
         'application/octet-stream')
-    presubmit.gcl.GetSVNFileProperty(weird, 'svn:mime-type').AndReturn(None)
-    presubmit.gcl.GetSVNFileProperty(another, 'svn:mime-type').AndReturn(None)
-    presubmit.gcl.GetSVNFileProperty(third_party, 'svn:mime-type'
+    presubmit.scm.SVN.GetFileProperty(weird, 'svn:mime-type').AndReturn(None)
+    presubmit.scm.SVN.GetFileProperty(another, 'svn:mime-type').AndReturn(None)
+    presubmit.scm.SVN.GetFileProperty(third_party, 'svn:mime-type'
         ).AndReturn(None)
-    presubmit.gcl.ReadFile(blat).AndReturn('whatever\ncookie')
-    presubmit.gcl.ReadFile(another).AndReturn('whatever\ncookie2')
+    presubmit.gclient_utils.FileRead(blat, 'rU'
+                                     ).AndReturn('whatever\ncookie')
+    presubmit.gclient_utils.FileRead(another, 'rU'
+                                     ).AndReturn('whatever\ncookie2')
     self.mox.ReplayAll()
 
     change = presubmit.SvnChange('mychange', '\n'.join(description_lines),
                                  self.fake_root_dir, files, 0, 0)
     input_api = presubmit.InputApi(change,
                                    join(self.fake_root_dir, 'foo',
                                         'PRESUBMIT.py'),
                                    False)
     # Doesn't filter much
     got_files = input_api.AffectedFiles()
@@ skipping 91 matching lines @@
       self.assertEquals(len(results), len(item[1]))
 
   def testCustomFilter(self):
     def FilterSourceFile(affected_file):
       return 'a' in affected_file.LocalPath()
     files = [('A', 'eeaee'), ('M', 'eeabee'), ('M', 'eebcee')]
     for (action, item) in files:
       item = presubmit.os.path.join(self.fake_root_dir, item)
       presubmit.os.path.exists(item).AndReturn(True)
       presubmit.os.path.isdir(item).AndReturn(False)
-      presubmit.gcl.GetSVNFileProperty(item, 'svn:mime-type').AndReturn(None)
+      presubmit.scm.SVN.GetFileProperty(item, 'svn:mime-type').AndReturn(None)
     self.mox.ReplayAll()
 
     change = presubmit.SvnChange('mychange', '', self.fake_root_dir, files, 0,
                                  0)
     input_api = presubmit.InputApi(change,
                                    presubmit.os.path.join(self.fake_root_dir,
                                                           'PRESUBMIT.py'),
                                    False)
     got_files = input_api.AffectedSourceFiles(FilterSourceFile)
     self.assertEquals(len(got_files), 2)
     self.assertEquals(got_files[0].LocalPath(), 'eeaee')
     self.assertEquals(got_files[1].LocalPath(), 'eeabee')
 
   def testLambdaFilter(self):
     white_list = presubmit.InputApi.DEFAULT_BLACK_LIST + (r".*?a.*?",)
     black_list = [r".*?b.*?"]
     files = [('A', 'eeaee'), ('M', 'eeabee'), ('M', 'eebcee'), ('M', 'eecaee')]
     for (action, item) in files:
       item = presubmit.os.path.join(self.fake_root_dir, item)
       presubmit.os.path.exists(item).AndReturn(True)
       presubmit.os.path.isdir(item).AndReturn(False)
-      presubmit.gcl.GetSVNFileProperty(item, 'svn:mime-type').AndReturn(None)
+      presubmit.scm.SVN.GetFileProperty(item, 'svn:mime-type').AndReturn(None)
     self.mox.ReplayAll()
 
     change = presubmit.SvnChange('mychange', '', self.fake_root_dir, files, 0,
                                  0)
     input_api = presubmit.InputApi(change, './PRESUBMIT.py', False)
     # Sample usage of overiding the default white and black lists.
     got_files = input_api.AffectedSourceFiles(
         lambda x: input_api.FilterSourceFile(x, white_list, black_list))
     self.assertEquals(len(got_files), 2)
     self.assertEquals(got_files[0].LocalPath(), 'eeaee')
@@ skipping 55 matching lines @@
     self.mox.ReplayAll()
 
     change = presubmit.Change('foo', 'foo', self.fake_root_dir, [('M', 'AA')],
                               0, 0)
     input_api = presubmit.InputApi(
         change, presubmit.os.path.join(self.fake_root_dir, '/p'), False)
     self.assertRaises(IOError, input_api.ReadFile, 'boo', 'x')
 
   def testReadFileStringAccepted(self):
     path = presubmit.os.path.join(self.fake_root_dir, 'AA/boo')
-    presubmit.gcl.ReadFile(path, 'x').AndReturn(None)
+    presubmit.gclient_utils.FileRead(path, 'x').AndReturn(None)
     self.mox.ReplayAll()
 
     change = presubmit.Change('foo', 'foo', self.fake_root_dir, [('M', 'AA')],
                               0, 0)
     input_api = presubmit.InputApi(
         change, presubmit.os.path.join(self.fake_root_dir, '/p'), False)
     input_api.ReadFile(path, 'x')
 
   def testReadFileAffectedFileDenied(self):
     file = presubmit.AffectedFile('boo', 'M', 'Unrelated')
     self.mox.ReplayAll()
 
     change = presubmit.Change('foo', 'foo', self.fake_root_dir, [('M', 'AA')],
                               0, 0)
     input_api = presubmit.InputApi(
         change, presubmit.os.path.join(self.fake_root_dir, '/p'), False)
     self.assertRaises(IOError, input_api.ReadFile, file, 'x')
 
   def testReadFileAffectedFileAccepted(self):
     file = presubmit.AffectedFile('AA/boo', 'M', self.fake_root_dir)
-    presubmit.gcl.ReadFile(file.AbsoluteLocalPath(), 'x').AndReturn(None)
+    presubmit.gclient_utils.FileRead(file.AbsoluteLocalPath(), 'x'
+                                     ).AndReturn(None)
     self.mox.ReplayAll()
 
     change = presubmit.Change('foo', 'foo', self.fake_root_dir, [('M', 'AA')],
                               0, 0)
     input_api = presubmit.InputApi(
         change, presubmit.os.path.join(self.fake_root_dir, '/p'), False)
     input_api.ReadFile(file, 'x')
 
 
 class OuputApiUnittest(PresubmitTestsBase):
@@ skipping 61 matching lines @@
       'NewContents', 'OldContents', 'OldFileTempPath', 'Property', 'ServerPath',
     ]
     # If this test fails, you should add the relevant test.
     self.compareMembers(presubmit.AffectedFile('a', 'b'), members)
     self.compareMembers(presubmit.SvnAffectedFile('a', 'b'), members)
 
   def testAffectedFile(self):
     path = presubmit.os.path.join('foo', 'blat.cc')
     presubmit.os.path.exists(path).AndReturn(True)
     presubmit.os.path.isdir(path).AndReturn(False)
-    presubmit.gcl.ReadFile(path).AndReturn('whatever\ncookie')
-    presubmit.gclient_scm.CaptureSVNInfo(path).AndReturn(
+    presubmit.gclient_utils.FileRead(path, 'rU').AndReturn('whatever\ncookie')
+    presubmit.scm.SVN.CaptureInfo(path).AndReturn(
         {'URL': 'svn:/foo/foo/blat.cc'})
     self.mox.ReplayAll()
     af = presubmit.SvnAffectedFile('foo/blat.cc', 'M')
     self.failUnless(af.ServerPath() == 'svn:/foo/foo/blat.cc')
     self.failUnless(af.LocalPath() == presubmit.normpath('foo/blat.cc'))
     self.failUnless(af.Action() == 'M')
     self.assertEquals(af.NewContents(), ['whatever', 'cookie'])
     af = presubmit.AffectedFile('notfound.cc', 'A')
     self.failUnless(af.ServerPath() == '')
 
   def testProperty(self):
-    presubmit.gcl.GetSVNFileProperty('foo.cc', 'svn:secret-property'
+    presubmit.scm.SVN.GetFileProperty('foo.cc', 'svn:secret-property'
         ).AndReturn('secret-property-value')
     self.mox.ReplayAll()
     affected_file = presubmit.SvnAffectedFile('foo.cc', 'A')
     # Verify cache coherency.
     self.failUnless(affected_file.Property('svn:secret-property') ==
                     'secret-property-value')
     self.failUnless(affected_file.Property('svn:secret-property') ==
                     'secret-property-value')
 
   def testIsDirectoryNotExists(self):
     presubmit.os.path.exists('foo.cc').AndReturn(False)
-    presubmit.gclient_scm.CaptureSVNInfo('foo.cc').AndReturn({})
+    presubmit.scm.SVN.CaptureInfo('foo.cc').AndReturn({})
     self.mox.ReplayAll()
     affected_file = presubmit.SvnAffectedFile('foo.cc', 'A')
     # Verify cache coherency.
     self.failIf(affected_file.IsDirectory())
     self.failIf(affected_file.IsDirectory())
 
   def testIsDirectory(self):
     presubmit.os.path.exists('foo.cc').AndReturn(True)
     presubmit.os.path.isdir('foo.cc').AndReturn(True)
     self.mox.ReplayAll()
     affected_file = presubmit.SvnAffectedFile('foo.cc', 'A')
     # Verify cache coherency.
     self.failUnless(affected_file.IsDirectory())
     self.failUnless(affected_file.IsDirectory())
 
   def testIsTextFile(self):
     list = [presubmit.SvnAffectedFile('foo/blat.txt', 'M'),
             presubmit.SvnAffectedFile('foo/binary.blob', 'M'),
             presubmit.SvnAffectedFile('blat/flop.txt', 'D')]
     blat = presubmit.os.path.join('foo', 'blat.txt')
     blob = presubmit.os.path.join('foo', 'binary.blob')
     presubmit.os.path.exists(blat).AndReturn(True)
     presubmit.os.path.isdir(blat).AndReturn(False)
     presubmit.os.path.exists(blob).AndReturn(True)
     presubmit.os.path.isdir(blob).AndReturn(False)
-    presubmit.gcl.GetSVNFileProperty(blat, 'svn:mime-type').AndReturn(None)
-    presubmit.gcl.GetSVNFileProperty(blob, 'svn:mime-type'
+    presubmit.scm.SVN.GetFileProperty(blat, 'svn:mime-type').AndReturn(None)
+    presubmit.scm.SVN.GetFileProperty(blob, 'svn:mime-type'
         ).AndReturn('application/octet-stream')
     self.mox.ReplayAll()
 
     output = filter(lambda x: x.IsTextFile(), list)
     self.failUnless(len(output) == 1)
     self.failUnless(list[0] == output[0])
 
 
 class GclChangeUnittest(PresubmitTestsBase):
   def testMembersChanged(self):
@@ skipping 123 matching lines @@
     change1 = presubmit.SvnChange('mychange', '', self.fake_root_dir, [], 0, 0)
     input_api1 = self.MockInputApi(change1, committing)
     files1 = [
       presubmit.SvnAffectedFile('foo/bar.cc', 'A'),
       presubmit.SvnAffectedFile('foo.cc', 'M'),
     ]
     if use_source_file:
       input_api1.AffectedSourceFiles(None).AndReturn(files1)
     else:
       input_api1.AffectedFiles(include_deleted=False).AndReturn(files1)
-    presubmit.gcl.GetSVNFileProperty(presubmit.normpath('foo/bar.cc'),
-                                     property).AndReturn(value1)
-    presubmit.gcl.GetSVNFileProperty(presubmit.normpath('foo.cc'),
-                                     property).AndReturn(value1)
+    presubmit.scm.SVN.GetFileProperty(presubmit.normpath('foo/bar.cc'),
+                                      property).AndReturn(value1)
+    presubmit.scm.SVN.GetFileProperty(presubmit.normpath('foo.cc'),
+                                      property).AndReturn(value1)
     change2 = presubmit.SvnChange('mychange', '', self.fake_root_dir, [], 0, 0)
     input_api2 = self.MockInputApi(change2, committing)
     files2 = [
       presubmit.SvnAffectedFile('foo/bar.cc', 'A'),
       presubmit.SvnAffectedFile('foo.cc', 'M'),
     ]
     if use_source_file:
       input_api2.AffectedSourceFiles(None).AndReturn(files2)
     else:
       input_api2.AffectedFiles(include_deleted=False).AndReturn(files2)
 
-    presubmit.gcl.GetSVNFileProperty(presubmit.normpath('foo/bar.cc'),
-                                     property).AndReturn(value2)
-    presubmit.gcl.GetSVNFileProperty(presubmit.normpath('foo.cc'),
-                                     property).AndReturn(value2)
+    presubmit.scm.SVN.GetFileProperty(presubmit.normpath('foo/bar.cc'),
+                                      property).AndReturn(value2)
+    presubmit.scm.SVN.GetFileProperty(presubmit.normpath('foo.cc'),
+                                      property).AndReturn(value2)
     self.mox.ReplayAll()
 
     results1 = check(input_api1, presubmit.OutputApi, None)
     self.assertEquals(results1, [])
     results2 = check(input_api2, presubmit.OutputApi, None)
     self.assertEquals(len(results2), 1)
     self.assertEquals(results2[0].__class__, error_type)
 
   def testCannedCheckChangeHasBugField(self):
     self.DescriptionTest(presubmit_canned_checks.CheckChangeHasBugField,
@@ skipping 271 matching lines @@
     self.mox.ReplayAll()
 
     results = presubmit_canned_checks.RunPythonUnitTests(
         input_api, presubmit.OutputApi, ['test_module'])
     self.assertEquals(len(results), 0)
 
 
 if __name__ == '__main__':
   import unittest
   unittest.main()