Simplify some functions by removing the options.stdout mock. Fix the unit tes...

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
 #
 # Unless required by applicable law or agreed to in writing, software
 # distributed under the License is distributed on an "AS IS" BASIS,
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
 """Unit tests for gclient.py."""
 
 __author__ = 'stephen5.ng@gmail.com (Stephen Ng)'
 
 import __builtin__
 import copy
 import os
 import random
 import string
+import StringIO
 import subprocess
 import sys
 import unittest
 
 directory, _file = os.path.split(__file__)
 if directory:
   directory += os.sep
 sys.path.append(os.path.abspath(directory + '../pymox'))
 
 import gclient
@@ skipping 34 matching lines @@
 class BaseTestCase(unittest.TestCase):
   # Like unittest's assertRaises, but checks for Gclient.Error.
   def assertRaisesError(self, msg, fn, *args, **kwargs):
     try:
       fn(*args, **kwargs)
     except gclient.Error, e:
       self.assertEquals(e.args[0], msg)
     else:
       self.fail('%s not raised' % msg)
 
+  def compareMembers(self, object, members):
+    """If you add a member, be sure to add the relevant test!"""
+    # Skip over members starting with '_' since they are usually not meant to
+    # be for public use.
+    actual_members = [x for x in sorted(dir(object))
+                      if not x.startswith('_')]
+    expected_members = sorted(members)
+    if actual_members != expected_members:
+      diff = ([i for i in actual_members if i not in expected_members] +
+              [i for i in expected_members if i not in actual_members])
+      print diff
+    self.assertEqual(actual_members, expected_members)
+
+
+class GClientBaseTestCase(BaseTestCase):
   def Options(self, *args, **kwargs):
     return self.OptionsObject(self, *args, **kwargs)
 
   def setUp(self):
     self.mox = mox.Mox()
     # Mock them to be sure nothing bad happens.
     self._CaptureSVN = gclient.CaptureSVN
     gclient.CaptureSVN = self.mox.CreateMockAnything()
     self._CaptureSVNInfo = gclient.CaptureSVNInfo
     gclient.CaptureSVNInfo = self.mox.CreateMockAnything()
     self._CaptureSVNStatus = gclient.CaptureSVNStatus
     gclient.CaptureSVNStatus = self.mox.CreateMockAnything()
     self._FileRead = gclient.FileRead
     gclient.FileRead = self.mox.CreateMockAnything()
     self._FileWrite = gclient.FileWrite
     gclient.FileWrite = self.mox.CreateMockAnything()
     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()
-    # Doesn't seem to work very well:
-    self._os = gclient.os
-    gclient.os = self.mox.CreateMock(os)
-    self._sys = gclient.sys
-    gclient.sys = self.mox.CreateMock(sys)
+    self._sys_stdout = gclient.sys.stdout
+    gclient.sys.stdout = self.mox.CreateMock(self._sys_stdout)
     self._subprocess = gclient.subprocess
-    gclient.subprocess = self.mox.CreateMock(subprocess)
+    gclient.subprocess = self.mox.CreateMock(self._subprocess)
 
   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
-    # Doesn't seem to work very well:
-    gclient.os = self._os
-    gclient.sys = self._sys
+    gclient.sys.stdout = self._sys_stdout
     gclient.subprocess = self._subprocess
 
 
-class GclientTestCase(BaseTestCase):
+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.stdout = test_case.stdout
       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):
-    BaseTestCase.setUp(self)
-    self.stdout = self.mox.CreateMock(sys.stdout)
+    GClientBaseTestCase.setUp(self)
     #self.subprocess = self.mox.CreateMock(subprocess)
     # Stub os.path.exists.
     self.path_exists = self.mox.CreateMockAnything()
-    self.sys = self.mox.CreateMock(sys)
     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()
 
 
-class GClientCommandsTestCase(BaseTestCase):
+class GClientCommandsTestCase(GClientBaseTestCase):
   def testCommands(self):
     known_commands = [gclient.DoCleanup, gclient.DoConfig, gclient.DoDiff,
                       gclient.DoHelp, gclient.DoStatus, gclient.DoUpdate,
                       gclient.DoRevert, gclient.DoRunHooks, gclient.DoRevInfo]
     for (k,v) in gclient.gclient_command_map.iteritems():
       # If it fails, you need to add a test case for the new command.
       self.assert_(v in known_commands)
     self.mox.ReplayAll()
     self.mox.VerifyAll()
 
@@ skipping 40 matching lines @@
     options.gclient.SaveConfig()
 
     self.mox.ReplayAll()
     gclient.DoConfig(options,
                      ('http://svn/url/the_name', 'other', 'args', 'ignored'))
     self.mox.VerifyAll()
 
 
 class TestDoHelp(GclientTestCase):
   def testGetUsage(self):
+    print(gclient.COMMAND_USAGE_TEXT['config'])
+    self.mox.ReplayAll()
     options = self.Options()
-    print >> options.stdout, gclient.COMMAND_USAGE_TEXT['config']
-
-    self.mox.ReplayAll()
     gclient.DoHelp(options, ('config',))
     self.mox.VerifyAll()
 
   def testTooManyArgs(self):
+    self.mox.ReplayAll()
     options = self.Options()
-    self.mox.ReplayAll()
     self.assertRaisesError("unknown subcommand 'config'; see 'gclient help'",
                            gclient.DoHelp, options, ('config',
                                                      'another argument'))
     self.mox.VerifyAll()
 
   def testUnknownSubcommand(self):
+    self.mox.ReplayAll()
     options = self.Options()
-    self.mox.ReplayAll()
     self.assertRaisesError("unknown subcommand 'xyzzy'; see 'gclient help'",
                            gclient.DoHelp, options, ('xyzzy',))
     self.mox.VerifyAll()
 
 
 class GenericCommandTestCase(GclientTestCase):
   def ReturnValue(self, command, function, return_value):
     options = self.Options()
     self.gclient.LoadCurrentConfig(options).AndReturn(self.gclient)
     self.gclient.RunOnDeps(command, self.args).AndReturn(return_value)
@@ skipping 11 matching lines @@
     self.assertRaisesError(
         "client not configured; see 'gclient config'",
         function, options, self.args)
     self.mox.VerifyAll()
 
   def Verbose(self, command, function):
     options = self.Options(verbose=True)
     self.gclient.LoadCurrentConfig(options).AndReturn(self.gclient)
     text = "# Dummy content\nclient = 'my client'"
     self.gclient.ConfigContent().AndReturn(text)
-    print >>self.stdout, text
+    print(text)
     self.gclient.RunOnDeps(command, self.args).AndReturn(0)
 
     self.mox.ReplayAll()
     result = function(options, self.args)
     self.assertEquals(result, 0)
     self.mox.VerifyAll()
 
 class TestDoCleanup(GenericCommandTestCase):
   def testGoodClient(self):
     self.ReturnValue('cleanup', gclient.DoCleanup, 0)
@@ skipping 37 matching lines @@
     result = function(options, self.args)
     self.assertEquals(result, return_value)
     self.mox.VerifyAll()
 
   def Verbose(self, command, function):
     options = self.Options(verbose=True)
     self.gclient.LoadCurrentConfig(options).AndReturn(self.gclient)
     self.gclient.GetVar("solutions")
     text = "# Dummy content\nclient = 'my client'"
     self.gclient.ConfigContent().AndReturn(text)
-    print >>self.stdout, text
+    print(text)
     self.gclient.RunOnDeps(command, self.args).AndReturn(0)
 
     self.mox.ReplayAll()
     result = function(options, self.args)
     self.assertEquals(result, 0)
     self.mox.VerifyAll()
 
   def Options(self, verbose=False, *args, **kwargs):
     return self.OptionsObject(self, verbose=verbose, *args, **kwargs)
 
@@ skipping 25 matching lines @@
   def testBasic(self):
     self.ReturnValue('revert', gclient.DoRevert, 0)
   def testError(self):
     self.ReturnValue('revert', gclient.DoRevert, 42)
   def testBadClient(self):
     self.BadClient(gclient.DoRevert)
 
 
 class GClientClassTestCase(GclientTestCase):
   def testDir(self):
-    members = ['ConfigContent', 'FromImpl', '_VarImpl', '_ParseAllDeps',
-      '_ParseSolutionDeps', 'GetVar', '_LoadConfig', 'LoadCurrentConfig',
-      '_ReadEntries', '_RunHookAction', '_RunHooks', 'RunOnDeps', 'SaveConfig',
-      '_SaveEntries', 'SetConfig', 'SetDefaultConfig', 'supported_commands',
-      'PrintRevInfo']
+    members = [
+      'ConfigContent', 'FromImpl', 'GetVar', 'LoadCurrentConfig',
+      'RunOnDeps', 'SaveConfig', 'SetConfig', 'SetDefaultConfig',
+      'supported_commands', 'PrintRevInfo',
+    ]
 
     # If you add a member, be sure to add the relevant test!
-    actual_members = [x for x in sorted(dir(gclient.GClient))
-                      if not x.startswith('__')]
-    self.assertEqual(actual_members, sorted(members))
-    self.mox.ReplayAll()
-    self.mox.VerifyAll()
+    self.compareMembers(gclient.GClient('root_dir', 'options'), members)
 
   def testSetConfig_ConfigContent_GetVar_SaveConfig_SetDefaultConfig(self):
     options = self.Options()
     text = "# Dummy content\nclient = 'my client'"
     gclient.FileWrite(os.path.join(self.root_dir, options.config_filename),
                       text)
 
     self.mox.ReplayAll()
     client = gclient.GClient(self.root_dir, options)
     client.SetConfig(text)
@@ skipping 322 matching lines @@
 
     self.mox.ReplayAll()
     client = gclient.GClient(self.root_dir, options)
     client.SetConfig(gclient_config)
     client.RunOnDeps('update', self.args)
     self.mox.VerifyAll()
 
   def testRunOnDepsRevisions(self):
     def OptIsRev(options, rev):
       if not options.revision == str(rev):
-        print "options.revision = %s" % options.revision
+        print("options.revision = %s" % options.revision)
       return options.revision == str(rev)
     def OptIsRevNone(options):
       if options.revision:
-        print "options.revision = %s" % options.revision
+        print("options.revision = %s" % options.revision)
       return options.revision == None
     def OptIsRev42(options):
       return OptIsRev(options, 42)
     def OptIsRev123(options):
       return OptIsRev(options, 123)
     def OptIsRev333(options):
       return OptIsRev(options, 333)
 
     # Fake .gclient file.
     gclient_config = """solutions = [ {
@@ skipping 302 matching lines @@
   def test_LoadConfig(self):
     pass
   def test_ReadEntries(self):
     pass
   def test_SaveEntries(self):
     pass
   def test_VarImpl(self):
     pass
 
 
-class SCMWrapperTestCase(BaseTestCase):
+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.stdout = test_case.stdout
       self.path_exists = test_case.path_exists
 
   def setUp(self):
-    BaseTestCase.setUp(self)
+    GClientBaseTestCase.setUp(self)
     self.root_dir = Dir()
     self.args = Args()
     self.url = Url()
     self.relpath = 'asf'
-    self.stdout = self.mox.CreateMock(sys.stdout)
     # Stub os.path.exists.
     self.path_exists = self.mox.CreateMockAnything()
 
   def testDir(self):
-    members = ['FullUrlForRelativeUrl', 'RunCommand',
-      'cleanup', 'diff', 'revert', 'status', 'update']
+    members = [
+      'FullUrlForRelativeUrl', 'RunCommand', 'cleanup', 'diff', 'relpath',
+      'revert', 'scm_name', 'status', 'update', 'url',
+    ]
 
     # If you add a member, be sure to add the relevant test!
-    actual_members = [x for x in sorted(dir(gclient.SCMWrapper))
-                      if not x.startswith('__')]
-    self.assertEqual(actual_members, sorted(members))
-    self.mox.ReplayAll()
-    self.mox.VerifyAll()
+    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()
 
@@ skipping 14 matching lines @@
     # 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)
-    print >>options.stdout, ("\n_____ %s is missing, synching instead" %
-                             self.relpath)
+    print("\n_____ %s is missing, synching instead" % self.relpath)
     # Checkout.
     options.path_exists(base_path).AndReturn(False)
     files_list = self.mox.CreateMockAnything()
-    gclient.RunSVNAndGetFileList(options, ['checkout', self.url, base_path],
+    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(options, base_path).AndReturn([])
+    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 = [
       gclient.FileStatus('a', 'M', ' ', ' ', ' '), 
       gclient.FileStatus('b', 'A', ' ', ' ', ' '),
     ]
-    gclient.CaptureSVNStatus(options, base_path).AndReturn(items)
+    gclient.CaptureSVNStatus(base_path).AndReturn(items)
 
-    print >>options.stdout, os.path.join(base_path, 'a')
-    print >>options.stdout, os.path.join(base_path, 'b')
-    gclient.RunSVN(options, ['revert', 'a', 'b'], base_path)
+    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(options, ['status'] + self.args, base_path,
+    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)
     # Checkout.
     options.path_exists(base_path).AndReturn(False)
     files_list = self.mox.CreateMockAnything()
-    gclient.RunSVNAndGetFileList(options, ['checkout', self.url, base_path],
+    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)
     # Checkout or update.
     options.path_exists(base_path).AndReturn(True)
-    gclient.CaptureSVNInfo(options, os.path.join(base_path, "."), '.'
+    gclient.CaptureSVNInfo(os.path.join(base_path, "."), '.'
         ).AndReturn(file_info)
     # Cheat a bit here.
-    gclient.CaptureSVNInfo(options, file_info['URL'], '.').AndReturn(file_info)
+    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(options, ['update', base_path] + additional_args,
+    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')
         ).AndReturn(True)
-    print >> options.stdout, (
-        "________ found .git directory; skipping %s" % self.relpath)
+    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()
 
   def testGetSVNFileInfo(self):
     xml_text = r"""<?xml version="1.0"?>
 <info>
 <entry kind="file" path="%s" revision="14628">
 <url>http://src.chromium.org/svn/trunk/src/chrome/app/d</url>
 <repository><root>http://src.chromium.org/svn</root></repository>
 <wc-info>
 <schedule>add</schedule>
 <depth>infinity</depth>
 <copy-from-url>http://src.chromium.org/svn/trunk/src/chrome/app/DEPS</copy-from-url>
 <copy-from-rev>14628</copy-from-rev>
 <checksum>369f59057ba0e6d9017e28f8bdfb1f43</checksum>
 </wc-info>
 </entry>
 </info>
 """ % self.url
-    options = self.Options(verbose=True)
-    gclient.CaptureSVN(options, ['info', '--xml', self.url],
-                       '.').AndReturn(xml_text)
+    gclient.CaptureSVN(['info', '--xml', self.url], '.').AndReturn(xml_text)
     expected = {
       'URL': 'http://src.chromium.org/svn/trunk/src/chrome/app/d',
       'UUID': None,
       'Repository Root': 'http://src.chromium.org/svn',
       'Schedule': 'add',
       'Copied From URL': 'http://src.chromium.org/svn/trunk/src/chrome/app/DEPS',
       'Copied From Rev': '14628',
       'Path': self.url,
       'Revision': 14628,
       'Node Kind': 'file',
     }
     self.mox.ReplayAll()
-    file_info = self._CaptureSVNInfo(options, self.url, '.')
+    file_info = self._CaptureSVNInfo(self.url, '.')
     self.assertEquals(sorted(file_info.items()), sorted(expected.items()))
     self.mox.VerifyAll()
 
   def testCaptureSvnInfo(self):
     xml_text = """<?xml version="1.0"?>
 <info>
 <entry
    kind="dir"
    path="."
    revision="35">
 <url>%s</url>
 <repository>
 <root>%s</root>
 <uuid>7b9385f5-0452-0410-af26-ad4892b7a1fb</uuid>
 </repository>
 <wc-info>
 <schedule>normal</schedule>
 <depth>infinity</depth>
 </wc-info>
 <commit
    revision="35">
 <author>maruel</author>
 <date>2008-12-04T20:12:19.685120Z</date>
 </commit>
 </entry>
 </info>
 """ % (self.url, self.root_dir)
-    options = self.Options(verbose=True)
-    gclient.CaptureSVN(options, ['info', '--xml', self.url],
-                       '.').AndReturn(xml_text)
+    gclient.CaptureSVN(['info', '--xml', self.url], '.').AndReturn(xml_text)
     self.mox.ReplayAll()
-    file_info = self._CaptureSVNInfo(options, self.url, '.')
+    file_info = self._CaptureSVNInfo(self.url, '.')
     expected = {
       'URL': self.url,
       'UUID': '7b9385f5-0452-0410-af26-ad4892b7a1fb',
       'Revision': 35,
       'Repository Root': self.root_dir,
       'Schedule': 'normal',
       'Copied From URL': None,
       'Copied From Rev': None,
       'Path': '.',
       'Node Kind': 'dir',
     }
     self.assertEqual(file_info, expected)
     self.mox.VerifyAll()
 
 
+class RunSVNTestCase(BaseTestCase):
+  def setUp(self):
+    self.mox = mox.Mox()
+    self._OldSubprocessCall = gclient.SubprocessCall
+    gclient.SubprocessCall = self.mox.CreateMockAnything()
+
+  def tearDown(self):
+    gclient.SubprocessCall = self._OldSubprocessCall
+
+  def testRunSVN(self):
+    param2 = 'bleh'
+    gclient.SubprocessCall(['svn', 'foo', 'bar'], param2).AndReturn(None)
+    self.mox.ReplayAll()
+    gclient.RunSVN(['foo', 'bar'], param2)
+    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()
+
+  def tearDown(self):
+    gclient.sys.stdout = self._sys_stdout
+    gclient.subprocess.Popen = self._subprocess_Popen
+
+  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.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()
+
+
 if __name__ == '__main__':
   unittest.main()
 
 # vim: ts=2:sw=2:tw=80:et: