Convert gclient_test.py to mox.MoxTestBase and saves 40+ lines

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 46 matching lines @@
   return random.choice((os.sep, '')) + _DirElts(max_elt_count, max_elt_length)
 
 def Url(max_elt_count=4, max_elt_length=8):
   return ('svn://random_host:port/a' +
           _DirElts(max_elt_count, max_elt_length).replace(os.sep, '/'))
 
 def RootDir(max_elt_count=4, max_elt_length=8):
   return os.sep + _DirElts(max_elt_count, max_elt_length)
 
 
-class BaseTestCase(unittest.TestCase):
+class BaseTestCase(mox.MoxTestBase):
   # 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()
+    BaseTestCase.setUp(self)
     # 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
@@ skipping 22 matching lines @@
     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
     gclient.GClient = self._gclient_gclient
     gclient.SCMWrapper = self._scm_wrapper
+    BaseTestCase.tearDown(self)
 
 
 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
@@ skipping 20 matching lines @@
 
 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()
 
 class TestDoConfig(GclientTestCase):
-  def setUp(self):
-    GclientTestCase.setUp(self)
-
   def testMissingArgument(self):
     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)
     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')
     gclient.os.path.exists(options.config_filename).AndReturn(False)
     gclient.GClient('.', options).AndReturn(gclient.GClient)
     gclient.GClient.SetConfig(options.spec)
     gclient.GClient.SaveConfig()
 
     self.mox.ReplayAll()
     gclient.DoConfig(options, (1,),)
-    self.mox.VerifyAll()
 
   def testCreateClientFile(self):
     options = self.Options()
     gclient.os.path.exists(options.config_filename).AndReturn(False)
     gclient.GClient('.', options).AndReturn(gclient.GClient)
     gclient.GClient.SetDefaultConfig('the_name', 'http://svn/url/the_name',
                                      'other')
     gclient.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()
     gclient.DoHelp(options, ('config',))
-    self.mox.VerifyAll()
 
   def testTooManyArgs(self):
     self.mox.ReplayAll()
     options = self.Options()
     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.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()
     gclient.GClient.LoadCurrentConfig(options).AndReturn(gclient.GClient)
     gclient.GClient.RunOnDeps(command, self.args).AndReturn(return_value)
 
     self.mox.ReplayAll()
     result = function(options, self.args)
     self.assertEquals(result, return_value)
-    self.mox.VerifyAll()
 
   def BadClient(self, function):
     options = self.Options()
     gclient.GClient.LoadCurrentConfig(options).AndReturn(None)
 
     self.mox.ReplayAll()
     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)
     gclient.GClient.LoadCurrentConfig(options).AndReturn(gclient.GClient)
     text = "# Dummy content\nclient = 'my client'"
     gclient.GClient.ConfigContent().AndReturn(text)
     print(text)
     gclient.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)
   def testError(self):
     self.ReturnValue('cleanup', gclient.DoCleanup, 42)
   def testBadClient(self):
     self.BadClient(gclient.DoCleanup)
 
 class TestDoStatus(GenericCommandTestCase):
@@ skipping 23 matching lines @@
 
   def ReturnValue(self, command, function, return_value):
     options = self.Options()
     gclient.GClient.LoadCurrentConfig(options).AndReturn(gclient.GClient)
     gclient.GClient.GetVar("solutions")
     gclient.GClient.RunOnDeps(command, self.args).AndReturn(return_value)
 
     self.mox.ReplayAll()
     result = function(options, self.args)
     self.assertEquals(result, return_value)
-    self.mox.VerifyAll()
 
   def Verbose(self, command, function):
     options = self.Options(verbose=True)
     gclient.GClient.LoadCurrentConfig(options).AndReturn(gclient.GClient)
     gclient.GClient.GetVar("solutions")
     text = "# Dummy content\nclient = 'my client'"
     gclient.GClient.ConfigContent().AndReturn(text)
     print(text)
     gclient.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)
 
   def testBasic(self):
     self.ReturnValue('update', gclient.DoUpdate, 0)
   def testError(self):
     self.ReturnValue('update', gclient.DoUpdate, 42)
   def testBadClient(self):
     self.BadClient(gclient.DoUpdate)
@@ skipping 58 matching lines @@
     client.SetDefaultConfig(solution_name, solution_url, safesync_url)
     self.assertEqual(client.ConfigContent(), default_text)
     solutions = [{
       'name': solution_name,
       'url': solution_url,
       'custom_deps': {},
       'safesync_url': safesync_url
     }]
     self.assertEqual(client.GetVar('solutions'), solutions)
     self.assertEqual(client.GetVar('foo'), None)
-    self.mox.VerifyAll()
 
   def testLoadCurrentConfig(self):
     options = self.Options()
     path = os.path.realpath(self.root_dir)
     gclient.os.path.exists(os.path.join(path, options.config_filename)
         ).AndReturn(True)
     gclient.GClient(path, options).AndReturn(gclient.GClient)
     gclient.GClient._LoadConfig()
 
     self.mox.ReplayAll()
     client = self._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)
@@ skipping 25 matching lines @@
 
     # After everything is done, an attempt is made to write an entries
     # file.
     gclient.FileWrite(os.path.join(self.root_dir, options.entries_filename),
         entries_content)
 
     self.mox.ReplayAll()
     client = self._gclient_gclient(self.root_dir, options)
     client.SetConfig(gclient_config)
     client.RunOnDeps('update', self.args)
-    self.mox.VerifyAll()
 
   def testRunOnDepsRelativePaths(self):
     solution_name = 'testRunOnDepsRelativePaths_solution_name'
     gclient_config = (
       "solutions = [ {\n"
       "  'name': '%s',\n"
       "  'url': '%s',\n"
       "  'custom_deps': {},\n"
       "} ]\n"
     ) % (solution_name, self.url)
@@ skipping 46 matching lines @@
 
     # After everything is done, an attempt is made to write an entries
     # file.
     gclient.FileWrite(os.path.join(self.root_dir, options.entries_filename),
         entries_content)
 
     self.mox.ReplayAll()
     client = self._gclient_gclient(self.root_dir, options)
     client.SetConfig(gclient_config)
     client.RunOnDeps('update', self.args)
-    self.mox.VerifyAll()
 
   def testRunOnDepsCustomDeps(self):
     solution_name = 'testRunOnDepsCustomDeps_solution_name'
     gclient_config = (
       "solutions = [ {\n"
       "  'name': '%s',\n"
       "  'url': '%s',\n"
       "  'custom_deps': {\n"
       "    'src/b': None,\n"
       "    'src/n': 'svn://custom.n/trunk',\n"
@@ skipping 61 matching lines @@
 
     # After everything is done, an attempt is made to write an entries
     # file.
     gclient.FileWrite(os.path.join(self.root_dir, options.entries_filename),
         entries_content)
 
     self.mox.ReplayAll()
     client = self._gclient_gclient(self.root_dir, options)
     client.SetConfig(gclient_config)
     client.RunOnDeps('update', self.args)
-    self.mox.VerifyAll()
 
   # Regression test for Issue #11.
   # http://code.google.com/p/gclient/issues/detail?id=11
   def testRunOnDepsSharedDependency(self):
     name_a = 'testRunOnDepsSharedDependency_a'
     name_b = 'testRunOnDepsSharedDependency_b'
 
     url_a = self.url + '/a'
     url_b = self.url + '/b'
 
@@ skipping 63 matching lines @@
     scm_wrapper_dep.RunCommand('update', options, self.args, [])
 
     # After everything is done, an attempt is made to write an entries file.
     gclient.FileWrite(os.path.join(self.root_dir, options.entries_filename),
         entries_content)
 
     self.mox.ReplayAll()
     client = self._gclient_gclient(self.root_dir, options)
     client.SetConfig(gclient_config)
     client.RunOnDeps('update', self.args)
-    self.mox.VerifyAll()
 
   def testRunOnDepsSuccess(self):
     # Fake .gclient file.
     name = 'testRunOnDepsSuccess_solution_name'
     gclient_config = """solutions = [ {
   'name': '%s',
   'url': '%s',
   'custom_deps': {},
 }, ]""" % (name, self.url)
 
     options = self.Options()
     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)
     gclient.SCMWrapper(self.url, self.root_dir, name).AndReturn(
         gclient.SCMWrapper)
     gclient.SCMWrapper.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()
     client = self._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)
       return options.revision == str(rev)
     def OptIsRevNone(options):
       if options.revision:
         print("options.revision = %s" % options.revision)
       return options.revision == None
@@ skipping 102 matching lines @@
                        self.root_dir,
                        'src/third_party/python_24').AndReturn(
                             scm_wrapper_python)
     scm_wrapper_python.RunCommand('update', mox.Func(OptIsRevNone), self.args,
                                   [])
 
     self.mox.ReplayAll()
     client = self._gclient_gclient(self.root_dir, options)
     client.SetConfig(gclient_config)
     client.RunOnDeps('update', self.args)
-    self.mox.VerifyAll()
 
   def testRunOnDepsConflictingRevisions(self):
     # Fake .gclient file.
     name = 'testRunOnDepsConflictingRevisions_solution_name'
     gclient_config = """solutions = [ {
   'name': '%s',
   'url': '%s',
   'custom_deps': {},
   'custom_vars': {},
 }, ]""" % (name, self.url)
@@ skipping 62 matching lines @@
         ).AndReturn(webkit_path)
 
     gclient.SCMWrapper(webkit_path, self.root_dir,
                        'foo/third_party/WebKit').AndReturn(gclient.SCMWrapper)
     gclient.SCMWrapper.RunCommand('update', options, self.args, [])
 
     self.mox.ReplayAll()
     client = self._gclient_gclient(self.root_dir, options)
     client.SetConfig(gclient_config)
     client.RunOnDeps('update', self.args)
-    self.mox.VerifyAll()
 
   def testRunOnDepsSuccessCustomVars(self):
     # Fake .gclient file.
     name = 'testRunOnDepsSuccessCustomVars_solution_name'
     gclient_config = """solutions = [ {
   'name': '%s',
   'url': '%s',
   'custom_deps': {},
   'custom_vars': {'webkit': '/trunk/bar_custom/'},
 }, ]""" % (name, self.url)
@@ skipping 36 matching lines @@
         ).AndReturn(webkit_path)
 
     gclient.SCMWrapper(webkit_path, self.root_dir,
                        'foo/third_party/WebKit').AndReturn(gclient.SCMWrapper)
     gclient.SCMWrapper.RunCommand('update', options, self.args, [])
 
     self.mox.ReplayAll()
     client = self._gclient_gclient(self.root_dir, options)
     client.SetConfig(gclient_config)
     client.RunOnDeps('update', self.args)
-    self.mox.VerifyAll()
 
-  def testRunOnDepsFailueVars(self):
+  def testRunOnDepsFailureVars(self):
     # Fake .gclient file.
     name = 'testRunOnDepsFailureVars_solution_name'
     gclient_config = """solutions = [ {
   'name': '%s',
   'url': '%s',
   'custom_deps': {},
   'custom_vars': {},
 }, ]""" % (name, self.url)
     # Fake DEPS file.
     deps_content = """deps = {
   'foo/third_party/WebKit': Var('webkit') + 'WebKit',
 }"""
 
     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')
-
-    gclient.os.path.exists(os.path.join(self.root_dir, options.entries_filename)
-        ).AndReturn(False)
     gclient.SCMWrapper(self.url, self.root_dir, name).AndReturn(
         gclient.SCMWrapper)
     gclient.SCMWrapper.RunCommand('update', options, self.args, [])
 
     self.mox.ReplayAll()
     client = self._gclient_gclient(self.root_dir, options)
     client.SetConfig(gclient_config)
     exception = "Var is not defined: webkit"
     try:
       client.RunOnDeps('update', self.args)
     except gclient.Error, e:
       self.assertEquals(e.args[0], exception)
     else:
       self.fail('%s not raised' % exception)
 
   def testRunOnDepsFailureInvalidCommand(self):
     options = self.Options()
 
     self.mox.ReplayAll()
     client = self._gclient_gclient(self.root_dir, options)
     exception = "'foo' is an unsupported command"
     self.assertRaisesError(exception, self._gclient_gclient.RunOnDeps, client,
                            'foo', self.args)
-    self.mox.VerifyAll()
 
   def testRunOnDepsFailureEmpty(self):
     options = self.Options()
 
     self.mox.ReplayAll()
     client = self._gclient_gclient(self.root_dir, options)
     exception = "No solution specified"
     self.assertRaisesError(exception, self._gclient_gclient.RunOnDeps, client,
                            'update', self.args)
-    self.mox.VerifyAll()
 
   def testFromImpl(self):
     # TODO(maruel):  Test me!
     pass
 
   def test_PrintRevInfo(self):
     # TODO(aharper): no test yet for revinfo, lock it down once we've verified
     # implementation for Pulse plugin
     pass
 
@@ skipping 24 matching lines @@
   def setUp(self):
     GClientBaseTestCase.setUp(self)
     self.root_dir = Dir()
     self.args = Args()
     self.url = Url()
     self.relpath = 'asf'
     self._os_path_isdir = gclient.os.path.isdir
     gclient.os.path.isdir = self.mox.CreateMockAnything()
 
   def tearDown(self):
+    gclient.os.path.isdir = self._os_path_isdir
     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(self._scm_wrapper(), members)
 
   def testFullUrlForRelativeUrl(self):
     self.url = 'svn://a/b/c/d'
 
     self.mox.ReplayAll()
     scm = self._scm_wrapper(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)
     gclient.os.path.exists(os.path.join(self.root_dir, self.relpath, '.git')
         ).AndReturn(False)
 
     self.mox.ReplayAll()
     scm = self._scm_wrapper(url=self.url, root_dir=self.root_dir,
                             relpath=self.relpath)
     exception = "Unsupported argument(s): %s" % ','.join(self.args)
     self.assertRaisesError(exception, self._scm_wrapper.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)
     base_path = os.path.join(self.root_dir, self.relpath)
     gclient.os.path.isdir(base_path).AndReturn(False)
     # It'll to a checkout instead.
     gclient.os.path.exists(os.path.join(base_path, '.git')).AndReturn(False)
     print("\n_____ %s is missing, synching instead" % self.relpath)
     # Checkout.
     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 = self._scm_wrapper(url=self.url, root_dir=self.root_dir,
                             relpath=self.relpath)
     scm.revert(options, self.args, files_list)
-    self.mox.VerifyAll()
 
   def testRevertNone(self):
     options = self.Options(verbose=True)
     base_path = os.path.join(self.root_dir, self.relpath)
     gclient.os.path.isdir(base_path).AndReturn(True)
     gclient.CaptureSVNStatus(base_path).AndReturn([])
 
     self.mox.ReplayAll()
     scm = self._scm_wrapper(url=self.url, root_dir=self.root_dir,
                             relpath=self.relpath)
     file_list = []
     scm.revert(options, self.args, file_list)
-    self.mox.VerifyAll()
 
   def testRevert2Files(self):
     options = self.Options(verbose=True)
     base_path = os.path.join(self.root_dir, self.relpath)
     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 = self._scm_wrapper(url=self.url, root_dir=self.root_dir,
                             relpath=self.relpath)
     file_list = []
     scm.revert(options, self.args, file_list)
-    self.mox.VerifyAll()
 
   def testStatus(self):
     options = self.Options(verbose=True)
     base_path = os.path.join(self.root_dir, self.relpath)
     gclient.os.path.isdir(base_path).AndReturn(True)
     gclient.RunSVNAndGetFileList(['status'] + self.args, base_path,
                                  []).AndReturn(None)
 
     self.mox.ReplayAll()
     scm = self._scm_wrapper(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
     gclient.os.path.exists(os.path.join(base_path, '.git')).AndReturn(False)
     # Checkout.
     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 = self._scm_wrapper(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,
     }
     gclient.os.path.exists(os.path.join(base_path, '.git')).AndReturn(False)
     # Checkout or update.
     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 = self._scm_wrapper(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)
     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 = self._scm_wrapper(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>
@@ skipping 13 matching lines @@
       '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(self.url, '.', True)
     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>
@@ skipping 21 matching lines @@
       '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()
+    BaseTestCase.setUp(self)
     self._OldSubprocessCall = gclient.SubprocessCall
     gclient.SubprocessCall = self.mox.CreateMockAnything()
 
   def tearDown(self):
     gclient.SubprocessCall = self._OldSubprocessCall
+    BaseTestCase.tearDown(self)
 
   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()
+    BaseTestCase.setUp(self)
     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
+    BaseTestCase.tearDown(self)
 
   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:
       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, 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=".">
@@ skipping 56 matching lines @@
 """
     gclient.CaptureSVN = CaptureSVNMock
     info = gclient.CaptureSVNStatus(None)
     self.assertEquals(info, [])
 
 
 if __name__ == '__main__':
   unittest.main()
 
 # vim: ts=2:sw=2:tw=80:et: