Remove the options.path_exists which only existed as a seam. It's not really ...

tests/gclient_test.py

 #!/usr/bin/python
 #
 # Copyright 2008-2009 Google Inc.  All Rights Reserved.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at
 #
 #      http://www.apache.org/licenses/LICENSE-2.0
 #
@@ skipping 101 matching lines @@
     self._RemoveDirectory = gclient.RemoveDirectory
     gclient.RemoveDirectory = self.mox.CreateMockAnything()
     self._RunSVN = gclient.RunSVN
     gclient.RunSVN = self.mox.CreateMockAnything()
     self._RunSVNAndGetFileList = gclient.RunSVNAndGetFileList
     gclient.RunSVNAndGetFileList = self.mox.CreateMockAnything()
     self._sys_stdout = gclient.sys.stdout
     gclient.sys.stdout = self.mox.CreateMock(self._sys_stdout)
     self._subprocess = gclient.subprocess
     gclient.subprocess = self.mox.CreateMock(self._subprocess)
+    self._os_path_exists = gclient.os.path.exists
+    gclient.os.path.exists = self.mox.CreateMockAnything()
 
   def tearDown(self):
     gclient.CaptureSVN = self._CaptureSVN
     gclient.CaptureSVNInfo = self._CaptureSVNInfo
     gclient.CaptureSVNStatus = self._CaptureSVNStatus
     gclient.FileRead = self._FileRead
     gclient.FileWrite = self._FileWrite
     gclient.RemoveDirectory = self._RemoveDirectory
     gclient.RunSVN = self._RunSVN
     gclient.RunSVNAndGetFileList = self._RunSVNAndGetFileList
     gclient.sys.stdout = self._sys_stdout
     gclient.subprocess = self._subprocess
+    gclient.os.path.exists = self._os_path_exists
 
 
 class GclientTestCase(GClientBaseTestCase):
   class OptionsObject(object):
     def __init__(self, test_case, verbose=False, spec=None,
                  config_filename='a_file_name',
                  entries_filename='a_entry_file_name',
                  deps_file='a_deps_file_name', force=False):
       self.verbose = verbose
       self.spec = spec
       self.config_filename = config_filename
       self.entries_filename = entries_filename
       self.deps_file = deps_file
       self.force = force
       self.revisions = []
       self.manually_grab_svn_rev = True
       self.deps_os = None
       self.head = False
 
       # Mox
-      self.path_exists = test_case.path_exists
       self.platform = test_case.platform
       self.gclient = test_case.gclient
       self.scm_wrapper = test_case.scm_wrapper
 
   def setUp(self):
     GClientBaseTestCase.setUp(self)
-    #self.subprocess = self.mox.CreateMock(subprocess)
-    # Stub os.path.exists.
-    self.path_exists = self.mox.CreateMockAnything()
     self.platform = 'darwin'
 
     self.gclient = self.mox.CreateMock(gclient.GClient)
     self.scm_wrapper = self.mox.CreateMock(gclient.SCMWrapper)
 
     self.args = Args()
     self.root_dir = Dir()
     self.url = Url()
 
 
@@ skipping 18 matching lines @@
     exception_msg = "required argument missing; see 'gclient help config'"
 
     self.mox.ReplayAll()
     self.assertRaisesError(exception_msg, gclient.DoConfig, self.Options(), ())
     self.mox.VerifyAll()
 
   def testExistingClientFile(self):
     options = self.Options()
     exception_msg = ('%s file already exists in the current directory' %
                         options.config_filename)
-    self.path_exists(options.config_filename).AndReturn(True)
+    gclient.os.path.exists(options.config_filename).AndReturn(True)
 
     self.mox.ReplayAll()
     self.assertRaisesError(exception_msg, gclient.DoConfig, options, (1,))
     self.mox.VerifyAll()
 
   def testFromText(self):
     options = self.Options(spec='config_source_content')
-    options.path_exists(options.config_filename).AndReturn(False)
+    gclient.os.path.exists(options.config_filename).AndReturn(False)
     options.gclient('.', options).AndReturn(options.gclient)
     options.gclient.SetConfig(options.spec)
     options.gclient.SaveConfig()
 
     self.mox.ReplayAll()
     gclient.DoConfig(options, (1,),)
     self.mox.VerifyAll()
 
   def testCreateClientFile(self):
     options = self.Options()
-    options.path_exists(options.config_filename).AndReturn(False)
+    gclient.os.path.exists(options.config_filename).AndReturn(False)
     options.gclient('.', options).AndReturn(options.gclient)
     options.gclient.SetDefaultConfig('the_name', 'http://svn/url/the_name',
                                      'other')
     options.gclient.SaveConfig()
 
     self.mox.ReplayAll()
     gclient.DoConfig(options,
                      ('http://svn/url/the_name', 'other', 'args', 'ignored'))
     self.mox.VerifyAll()
 
@@ skipping 191 matching lines @@
     }]
     self.assertEqual(client.GetVar('solutions'), solutions)
     self.assertEqual(client.GetVar('foo'), None)
     self.mox.VerifyAll()
 
   def testLoadCurrentConfig(self):
     # pymox has trouble to mock the class object and not a class instance.
     self.gclient = self.mox.CreateMockAnything()
     options = self.Options()
     path = os.path.realpath(self.root_dir)
-    options.path_exists(os.path.join(path, options.config_filename)
+    gclient.os.path.exists(os.path.join(path, options.config_filename)
         ).AndReturn(True)
     options.gclient(path, options).AndReturn(options.gclient)
     options.gclient._LoadConfig()
 
     self.mox.ReplayAll()
     client = gclient.GClient.LoadCurrentConfig(options, self.root_dir)
     self.mox.VerifyAll()
 
   def testRunOnDepsNoDeps(self):
     solution_name = 'testRunOnDepsNoDeps_solution_name'
     gclient_config = (
       "solutions = [ {\n"
       "  'name': '%s',\n"
       "  'url': '%s',\n"
       "  'custom_deps': {},\n"
       "} ]\n"
     ) % (solution_name, self.url)
 
     entries_content = (
       'entries = [\n'
       '  "%s",\n'
       ']\n'
     ) % solution_name
 
     self.scm_wrapper = self.mox.CreateMockAnything()
     scm_wrapper_sol = self.mox.CreateMock(gclient.SCMWrapper)
 
     options = self.Options()
 
+    checkout_path = os.path.join(self.root_dir, solution_name)
+    gclient.os.path.exists(os.path.join(checkout_path, '.git')).AndReturn(False)
     # Expect a check for the entries file and we say there is not one.
-    options.path_exists(os.path.join(self.root_dir, options.entries_filename)
+    gclient.os.path.exists(os.path.join(self.root_dir, options.entries_filename)
         ).AndReturn(False)
 
     # An scm will be requested for the solution.
     options.scm_wrapper(self.url, self.root_dir, solution_name
         ).AndReturn(scm_wrapper_sol)
     # Then an update will be performed.
     scm_wrapper_sol.RunCommand('update', options, self.args, [])
     # Then an attempt will be made to read its DEPS file.
     gclient.FileRead(os.path.join(self.root_dir,
                      solution_name,
@@ skipping 32 matching lines @@
       '  "%s",\n'
       ']\n'
     ) % (os.path.join(solution_name, 'src', 't'), solution_name)
 
     self.scm_wrapper = self.mox.CreateMockAnything()
     scm_wrapper_sol = self.mox.CreateMock(gclient.SCMWrapper)
     scm_wrapper_t = self.mox.CreateMock(gclient.SCMWrapper)
 
     options = self.Options()
 
+    gclient.os.path.exists(os.path.join(self.root_dir, solution_name, 'src',
+                                        't', '.git')
+        ).AndReturn(False)
+    gclient.os.path.exists(os.path.join(self.root_dir, solution_name, '.git')
+        ).AndReturn(False)
     # Expect a check for the entries file and we say there is not one.
-    options.path_exists(os.path.join(self.root_dir, options.entries_filename)
+    gclient.os.path.exists(os.path.join(self.root_dir, options.entries_filename)
         ).AndReturn(False)
 
     # An scm will be requested for the solution.
     options.scm_wrapper(self.url, self.root_dir, solution_name
         ).AndReturn(scm_wrapper_sol)
     # Then an update will be performed.
     scm_wrapper_sol.RunCommand('update', options, self.args, [])
     # Then an attempt will be made to read its DEPS file.
     gclient.FileRead(os.path.join(self.root_dir,
                      solution_name,
@@ skipping 47 matching lines @@
       ']\n'
     ) % solution_name
 
     self.scm_wrapper = self.mox.CreateMockAnything()
     scm_wrapper_sol = self.mox.CreateMock(gclient.SCMWrapper)
     scm_wrapper_t = self.mox.CreateMock(gclient.SCMWrapper)
     scm_wrapper_n = self.mox.CreateMock(gclient.SCMWrapper)
 
     options = self.Options()
 
+    checkout_path = os.path.join(self.root_dir, solution_name)
+    gclient.os.path.exists(os.path.join(checkout_path, '.git')).AndReturn(False)
+    gclient.os.path.exists(os.path.join(self.root_dir, 'src/n', '.git')
+        ).AndReturn(False)
+    gclient.os.path.exists(os.path.join(self.root_dir, 'src/t', '.git')
+        ).AndReturn(False)
+
     # Expect a check for the entries file and we say there is not one.
-    options.path_exists(os.path.join(self.root_dir, options.entries_filename)
+    gclient.os.path.exists(os.path.join(self.root_dir, options.entries_filename)
         ).AndReturn(False)
 
     # An scm will be requested for the solution.
     options.scm_wrapper(self.url, self.root_dir, solution_name
         ).AndReturn(scm_wrapper_sol)
     # Then an update will be performed.
     scm_wrapper_sol.RunCommand('update', options, self.args, [])
     # Then an attempt will be made to read its DEPS file.
-    gclient.FileRead(os.path.join(self.root_dir,
-                     solution_name,
-                     options.deps_file)).AndReturn(deps)
+    gclient.FileRead(os.path.join(checkout_path, options.deps_file)
+        ).AndReturn(deps)
 
     # Next we expect an scm to be request for dep src/n even though it does not
     # exist in the DEPS file.
     options.scm_wrapper('svn://custom.n/trunk',
                         self.root_dir,
                         "src/n").AndReturn(scm_wrapper_n)
 
     # Next we expect an scm to be request for dep src/t but it should
     # use the url specified in custom_deps.
     options.scm_wrapper('svn://custom.t/trunk',
@@ skipping 49 matching lines @@
       '  "src/t",\n'
       ']\n') % (name_a, name_b)
 
     self.scm_wrapper = self.mox.CreateMockAnything()
     scm_wrapper_a = self.mox.CreateMock(gclient.SCMWrapper)
     scm_wrapper_b = self.mox.CreateMock(gclient.SCMWrapper)
     scm_wrapper_dep = self.mox.CreateMock(gclient.SCMWrapper)
 
     options = self.Options()
 
+    gclient.os.path.exists(os.path.join(self.root_dir, name_a, '.git')
+        ).AndReturn(False)
+    gclient.os.path.exists(os.path.join(self.root_dir, name_b, '.git')
+        ).AndReturn(False)
+    gclient.os.path.exists(os.path.join(self.root_dir, 'src/t', '.git')
+        ).AndReturn(False)
+
     # Expect a check for the entries file and we say there is not one.
-    options.path_exists(os.path.join(self.root_dir, options.entries_filename)
+    gclient.os.path.exists(os.path.join(self.root_dir, options.entries_filename)
         ).AndReturn(False)
 
     # An scm will be requested for the first solution.
     options.scm_wrapper(url_a, self.root_dir, name_a).AndReturn(
         scm_wrapper_a)
     # Then an attempt will be made to read it's DEPS file.
     gclient.FileRead(os.path.join(self.root_dir, name_a, options.deps_file)
         ).AndReturn(deps_a)
     # Then an update will be performed.
     scm_wrapper_a.RunCommand('update', options, self.args, [])
@@ skipping 28 matching lines @@
     name = 'testRunOnDepsSuccess_solution_name'
     gclient_config = """solutions = [ {
   'name': '%s',
   'url': '%s',
   'custom_deps': {},
 }, ]""" % (name, self.url)
 
     # pymox has trouble to mock the class object and not a class instance.
     self.scm_wrapper = self.mox.CreateMockAnything()
     options = self.Options()
-    options.path_exists(os.path.join(self.root_dir, options.entries_filename)
+    gclient.os.path.exists(os.path.join(self.root_dir, name, '.git')
+        ).AndReturn(False)
+    gclient.os.path.exists(os.path.join(self.root_dir, options.entries_filename)
         ).AndReturn(False)
     options.scm_wrapper(self.url, self.root_dir, name).AndReturn(
         options.scm_wrapper)
     options.scm_wrapper.RunCommand('update', options, self.args, [])
     gclient.FileRead(os.path.join(self.root_dir, name, options.deps_file)
         ).AndReturn("Boo = 'a'")
     gclient.FileWrite(os.path.join(self.root_dir, options.entries_filename),
                       'entries = [\n  "%s",\n]\n' % name)
 
     self.mox.ReplayAll()
@@ skipping 61 matching lines @@
     options.revisions = [ 'src@123', 'foo/third_party/WebKit@42',
                           'src/third_party/cygwin@333' ]
 
     # Also, pymox doesn't verify the order of function calling w.r.t. different
     # mock objects. Pretty lame. So reorder as we wish to make it clearer.
     gclient.FileRead(os.path.join(self.root_dir, 'src', options.deps_file)
         ).AndReturn(deps_content)
     gclient.FileWrite(os.path.join(self.root_dir, options.entries_filename),
                       entries_content)
 
-    options.path_exists(os.path.join(self.root_dir, options.entries_filename)
+    gclient.os.path.exists(os.path.join(self.root_dir, 'src', '.git')
+        ).AndReturn(False)
+    gclient.os.path.exists(os.path.join(self.root_dir, 'foo/third_party/WebKit',
+                                        '.git')
+        ).AndReturn(False)
+    gclient.os.path.exists(os.path.join(self.root_dir, 'src/third_party/cygwin',
+                                        '.git')
+        ).AndReturn(False)
+    gclient.os.path.exists(os.path.join(self.root_dir,
+                                         'src/third_party/python_24', '.git')
+        ).AndReturn(False)
+    gclient.os.path.exists(os.path.join(self.root_dir, 'src/breakpad/bar',
+                                        '.git')
+        ).AndReturn(False)
+    gclient.os.path.exists(os.path.join(self.root_dir, options.entries_filename)
         ).AndReturn(False)
 
     options.scm_wrapper(self.url, self.root_dir, 'src').AndReturn(
         scm_wrapper_src)
     scm_wrapper_src.RunCommand('update', mox.Func(OptIsRev123), self.args, [])
 
     options.scm_wrapper(self.url, self.root_dir,
                         None).AndReturn(scm_wrapper_src2)
     scm_wrapper_src2.FullUrlForRelativeUrl('/trunk/deps/third_party/cygwin@3248'
         ).AndReturn(cygwin_path)
@@ skipping 84 matching lines @@
     self.scm_wrapper = self.mox.CreateMockAnything()
     scm_wrapper_webkit = self.mox.CreateMock(gclient.SCMWrapper)
     scm_wrapper_src = self.mox.CreateMock(gclient.SCMWrapper)
 
     options = self.Options()
     gclient.FileRead(os.path.join(self.root_dir, name, options.deps_file)
         ).AndReturn(deps_content)
     gclient.FileWrite(os.path.join(self.root_dir, options.entries_filename),
                       entries_content)
 
-    options.path_exists(os.path.join(self.root_dir, options.entries_filename)
+    gclient.os.path.exists(os.path.join(self.root_dir, 'foo/third_party/WebKit',
+                                        '.git')).AndReturn(False)
+    gclient.os.path.exists(os.path.join(self.root_dir, name, '.git')
+        ).AndReturn(False)
+    gclient.os.path.exists(os.path.join(self.root_dir, options.entries_filename)
         ).AndReturn(False)
     options.scm_wrapper(self.url, self.root_dir, name).AndReturn(
         options.scm_wrapper)
     options.scm_wrapper.RunCommand('update', options, self.args, [])
 
     options.scm_wrapper(self.url, self.root_dir,
                         None).AndReturn(scm_wrapper_src)
     scm_wrapper_src.FullUrlForRelativeUrl('/trunk/bar/WebKit'
         ).AndReturn(webkit_path)
 
@@ skipping 33 matching lines @@
     self.scm_wrapper = self.mox.CreateMockAnything()
     scm_wrapper_webkit = self.mox.CreateMock(gclient.SCMWrapper)
     scm_wrapper_src = self.mox.CreateMock(gclient.SCMWrapper)
 
     options = self.Options()
     gclient.FileRead(os.path.join(self.root_dir, name, options.deps_file)
         ).AndReturn(deps_content)
     gclient.FileWrite(os.path.join(self.root_dir, options.entries_filename),
                       entries_content)
 
-    options.path_exists(os.path.join(self.root_dir, options.entries_filename)
+    gclient.os.path.exists(os.path.join(self.root_dir, 'foo/third_party/WebKit',
+                                        '.git')
+        ).AndReturn(False)
+    gclient.os.path.exists(os.path.join(self.root_dir, name, '.git')
+        ).AndReturn(False)
+    gclient.os.path.exists(os.path.join(self.root_dir, options.entries_filename)
         ).AndReturn(False)
     options.scm_wrapper(self.url, self.root_dir, name).AndReturn(
         options.scm_wrapper)
     options.scm_wrapper.RunCommand('update', options, self.args, [])
 
     options.scm_wrapper(self.url, self.root_dir,
                         None).AndReturn(scm_wrapper_src)
     scm_wrapper_src.FullUrlForRelativeUrl('/trunk/bar_custom/WebKit'
         ).AndReturn(webkit_path)
 
@@ skipping 23 matching lines @@
 
     # pymox has trouble to mock the class object and not a class instance.
     self.scm_wrapper = self.mox.CreateMockAnything()
 
     options = self.Options()
     gclient.FileRead(os.path.join(self.root_dir, name, options.deps_file)
         ).AndReturn(deps_content)
     gclient.FileWrite(os.path.join(self.root_dir, options.entries_filename),
                       'dummy entries content')
 
-    options.path_exists(os.path.join(self.root_dir, options.entries_filename)
+    gclient.os.path.exists(os.path.join(self.root_dir, options.entries_filename)
         ).AndReturn(False)
     options.scm_wrapper(self.url, self.root_dir, name).AndReturn(
         options.scm_wrapper)
     options.scm_wrapper.RunCommand('update', options, self.args, [])
 
     self.mox.ReplayAll()
     client = gclient.GClient(self.root_dir, options)
     client.SetConfig(gclient_config)
     exception = "Var is not defined: webkit"
     try:
@@ skipping 49 matching lines @@
 
 class SCMWrapperTestCase(GClientBaseTestCase):
   class OptionsObject(object):
      def __init__(self, test_case, verbose=False, revision=None):
       self.verbose = verbose
       self.revision = revision
       self.manually_grab_svn_rev = True
       self.deps_os = None
       self.force = False
 
-      # Mox
-      self.path_exists = test_case.path_exists
-
   def setUp(self):
     GClientBaseTestCase.setUp(self)
     self.root_dir = Dir()
     self.args = Args()
     self.url = Url()
     self.relpath = 'asf'
-    # Stub os.path.exists.
-    self.path_exists = self.mox.CreateMockAnything()
+    self._os_path_isdir = gclient.os.path.isdir
+    gclient.os.path.isdir = self.mox.CreateMockAnything()
+
+  def tearDown(self):
+    GClientBaseTestCase.tearDown(self)
+    gclient.os.path.isdir = self._os_path_isdir
 
   def testDir(self):
     members = [
       'FullUrlForRelativeUrl', 'RunCommand', 'cleanup', 'diff', 'relpath',
       'revert', 'scm_name', 'status', 'update', 'url',
     ]
 
     # If you add a member, be sure to add the relevant test!
     self.compareMembers(gclient.SCMWrapper(), members)
 
   def testFullUrlForRelativeUrl(self):
     self.url = 'svn://a/b/c/d'
 
     self.mox.ReplayAll()
     scm = gclient.SCMWrapper(url=self.url, root_dir=self.root_dir,
                              relpath=self.relpath)
     self.assertEqual(scm.FullUrlForRelativeUrl('/crap'), 'svn://a/b/crap')
     self.mox.VerifyAll()
 
   def testRunCommandException(self):
     options = self.Options(verbose=False)
-    options.path_exists(os.path.join(self.root_dir, self.relpath, '.git')
+    gclient.os.path.exists(os.path.join(self.root_dir, self.relpath, '.git')
         ).AndReturn(False)
 
     self.mox.ReplayAll()
     scm = gclient.SCMWrapper(url=self.url, root_dir=self.root_dir,
                              relpath=self.relpath)
     exception = "Unsupported argument(s): %s" % ','.join(self.args)
     self.assertRaisesError(exception, gclient.SCMWrapper.RunCommand,
                            scm, 'update', options, self.args)
     self.mox.VerifyAll()
 
   def testRunCommandUnknown(self):
     # TODO(maruel): if ever used.
     pass
 
   def testRevertMissing(self):
     options = self.Options(verbose=True)
-    gclient.os.path.isdir = self.mox.CreateMockAnything()
     base_path = os.path.join(self.root_dir, self.relpath)
     gclient.os.path.isdir(base_path).AndReturn(False)
     # It'll to a checkout instead.
-    options.path_exists(os.path.join(base_path, '.git')).AndReturn(False)
+    gclient.os.path.exists(os.path.join(base_path, '.git')).AndReturn(False)
     print("\n_____ %s is missing, synching instead" % self.relpath)
     # Checkout.
-    options.path_exists(base_path).AndReturn(False)
+    gclient.os.path.exists(base_path).AndReturn(False)
     files_list = self.mox.CreateMockAnything()
     gclient.RunSVNAndGetFileList(['checkout', self.url, base_path],
                                  self.root_dir, files_list)
 
     self.mox.ReplayAll()
     scm = gclient.SCMWrapper(url=self.url, root_dir=self.root_dir,
                              relpath=self.relpath)
     scm.revert(options, self.args, files_list)
     self.mox.VerifyAll()
-    gclient.os.path.isdir = os.path.isdir
 
   def testRevertNone(self):
     options = self.Options(verbose=True)
     base_path = os.path.join(self.root_dir, self.relpath)
-    gclient.os.path.isdir = self.mox.CreateMockAnything()
     gclient.os.path.isdir(base_path).AndReturn(True)
     gclient.CaptureSVNStatus(base_path).AndReturn([])
 
     self.mox.ReplayAll()
     scm = gclient.SCMWrapper(url=self.url, root_dir=self.root_dir,
                              relpath=self.relpath)
     file_list = []
     scm.revert(options, self.args, file_list)
     self.mox.VerifyAll()
-    gclient.os.path.isdir = os.path.isdir
 
   def testRevert2Files(self):
     options = self.Options(verbose=True)
     base_path = os.path.join(self.root_dir, self.relpath)
-    gclient.os.path.isdir = self.mox.CreateMockAnything()
     gclient.os.path.isdir(base_path).AndReturn(True)
     items = [
       ('M      ', 'a'),
       ('A      ', 'b'),
     ]
     gclient.CaptureSVNStatus(base_path).AndReturn(items)
 
     print(os.path.join(base_path, 'a'))
     print(os.path.join(base_path, 'b'))
     gclient.RunSVN(['revert', 'a', 'b'], base_path)
 
     self.mox.ReplayAll()
     scm = gclient.SCMWrapper(url=self.url, root_dir=self.root_dir,
                              relpath=self.relpath)
     file_list = []
     scm.revert(options, self.args, file_list)
     self.mox.VerifyAll()
-    gclient.os.path.isdir = os.path.isdir
 
   def testStatus(self):
     options = self.Options(verbose=True)
     base_path = os.path.join(self.root_dir, self.relpath)
-    gclient.os.path.isdir = self.mox.CreateMockAnything()
     gclient.os.path.isdir(base_path).AndReturn(True)
     gclient.RunSVNAndGetFileList(['status'] + self.args, base_path,
                                  []).AndReturn(None)
 
     self.mox.ReplayAll()
     scm = gclient.SCMWrapper(url=self.url, root_dir=self.root_dir,
                              relpath=self.relpath)
     file_list = []
     self.assertEqual(scm.status(options, self.args, file_list), None)
     self.mox.VerifyAll()
 
 
   # TODO(maruel):  TEST REVISIONS!!!
   # TODO(maruel):  TEST RELOCATE!!!
   def testUpdateCheckout(self):
     options = self.Options(verbose=True)
     base_path = os.path.join(self.root_dir, self.relpath)
     file_info = gclient.PrintableObject()
     file_info.root = 'blah'
     file_info.url = self.url
     file_info.uuid = 'ABC'
     file_info.revision = 42
-    options.path_exists(os.path.join(base_path, '.git')).AndReturn(False)
+    gclient.os.path.exists(os.path.join(base_path, '.git')).AndReturn(False)
     # Checkout.
-    options.path_exists(base_path).AndReturn(False)
+    gclient.os.path.exists(base_path).AndReturn(False)
     files_list = self.mox.CreateMockAnything()
     gclient.RunSVNAndGetFileList(['checkout', self.url, base_path],
                                  self.root_dir, files_list)
     self.mox.ReplayAll()
     scm = gclient.SCMWrapper(url=self.url, root_dir=self.root_dir,
                              relpath=self.relpath)
     scm.update(options, (), files_list)
     self.mox.VerifyAll()
 
   def testUpdateUpdate(self):
     options = self.Options(verbose=True)
     base_path = os.path.join(self.root_dir, self.relpath)
     options.force = True
     file_info = {
       'Repository Root': 'blah',
       'URL': self.url,
       'UUID': 'ABC',
       'Revision': 42,
     }
-    options.path_exists(os.path.join(base_path, '.git')).AndReturn(False)
+    gclient.os.path.exists(os.path.join(base_path, '.git')).AndReturn(False)
     # Checkout or update.
-    options.path_exists(base_path).AndReturn(True)
+    gclient.os.path.exists(base_path).AndReturn(True)
     gclient.CaptureSVNInfo(os.path.join(base_path, "."), '.'
         ).AndReturn(file_info)
     # Cheat a bit here.
     gclient.CaptureSVNInfo(file_info['URL'], '.').AndReturn(file_info)
     additional_args = []
     if options.manually_grab_svn_rev:
       additional_args = ['--revision', str(file_info['Revision'])]
     files_list = []
     gclient.RunSVNAndGetFileList(['update', base_path] + additional_args,
                                  self.root_dir, files_list)
 
     self.mox.ReplayAll()
     scm = gclient.SCMWrapper(url=self.url, root_dir=self.root_dir,
                              relpath=self.relpath)
     scm.update(options, (), files_list)
     self.mox.VerifyAll()
 
   def testUpdateGit(self):
     options = self.Options(verbose=True)
-    options.path_exists(os.path.join(self.root_dir, self.relpath, '.git')
+    gclient.os.path.exists(os.path.join(self.root_dir, self.relpath, '.git')
         ).AndReturn(True)
     print("________ found .git directory; skipping %s" % self.relpath)
 
     self.mox.ReplayAll()
     scm = gclient.SCMWrapper(url=self.url, root_dir=self.root_dir,
                              relpath=self.relpath)
     file_list = []
     scm.update(options, self.args, file_list)
     self.mox.VerifyAll()
 
@@ skipping 91 matching lines @@
     self.mox.VerifyAll()
 
 
 class SubprocessCallAndCaptureTestCase(BaseTestCase):
   def setUp(self):
     self.mox = mox.Mox()
     self._sys_stdout = gclient.sys.stdout
     gclient.sys.stdout = self.mox.CreateMock(self._sys_stdout)
     self._subprocess_Popen = gclient.subprocess.Popen
     gclient.subprocess.Popen = self.mox.CreateMockAnything()
+    self._CaptureSVN = gclient.CaptureSVN
+    gclient.CaptureSVN = self.mox.CreateMockAnything()
 
   def tearDown(self):
     gclient.sys.stdout = self._sys_stdout
     gclient.subprocess.Popen = self._subprocess_Popen
+    gclient.CaptureSVN = self._CaptureSVN
 
   def testSubprocessCallAndCapture(self):
     command = ['boo', 'foo', 'bar']
     in_directory = 'bleh'
     fail_status = None
     pattern = 'a(.*)b'
     test_string = 'ahah\naccb\nallo\naddb\n'
     class Mock(object):
       stdout = StringIO.StringIO(test_string)
       def wait(self):
         pass
     kid = Mock()
     print("\n________ running 'boo foo bar' in 'bleh'")
     for i in test_string:
-      sys.stdout.write(i)
+      gclient.sys.stdout.write(i)
     gclient.subprocess.Popen(command, bufsize=0, cwd=in_directory,
                              shell=(sys.platform == 'win32'),
                              stdout=gclient.subprocess.PIPE).AndReturn(kid)
     self.mox.ReplayAll()
     capture_list = []
     gclient.SubprocessCallAndCapture(command, in_directory, fail_status,
                                      pattern, capture_list)
     self.assertEquals(capture_list, ['cc', 'dd'])
     self.mox.VerifyAll()
 
   def testCaptureSVNStatus(self):
     x = self
-    def CaptureSVNMock(command):
+    def CaptureSVNMock(command, in_directory=None, print_error=True):
+      x.assertEquals(in_directory, None)
+      x.assertEquals(print_error, True)
       x.assertEquals(['status', '--xml', '.'], command)
       return r"""<?xml version="1.0"?>
 <status>
 <target path=".">
 <entry path="unversionned_file.txt">
 <wc-status props="none" item="unversioned"></wc-status>
 </entry>
 <entry path="build\internal\essential.vsprops">
 <wc-status props="normal" item="modified" revision="14628">
 <commit revision="13818">
@@ skipping 31 matching lines @@
       ('?      ', 'unversionned_file.txt'),
       ('M      ', 'build\\internal\\essential.vsprops'),
       ('A  +   ', 'chrome\\app\\d'),
       ('MM     ', 'chrome\\app\\DEPS'),
       ('C      ', 'scripts\\master\\factory\\gclient_factory.py'),
     ]
     self.assertEquals(sorted(info), sorted(expected))
 
   def testCaptureSVNStatusEmpty(self):
     x = self
-    def CaptureSVNMock(command):
+    def CaptureSVNMock(command, in_directory=None, print_error=True):
+      x.assertEquals(in_directory, None)
       x.assertEquals(['status', '--xml'], command)
       return r"""<?xml version="1.0"?>
 <status>
 <target
    path="perf">
 </target>
 </status>
 """
     gclient.CaptureSVN = CaptureSVNMock
     info = gclient.CaptureSVNStatus(None)
     self.assertEquals(info, [])
 
 
 if __name__ == '__main__':
   unittest.main()
 
 # vim: ts=2:sw=2:tw=80:et: