Refactor the unit tests.

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
 
-import __init__
 import gclient
-mox = __init__.mox
+import super_mox
+from super_mox import mox
 
 
-## Some utilities for generating arbitrary arguments.
+class BaseTestCase(super_mox.SuperMoxTestBase):
+  def setUp(self):
+    super_mox.SuperMoxTestBase.setUp(self)
+    self.mox.StubOutWithMock(gclient.os.path, 'exists')
+    self.mox.StubOutWithMock(gclient.os.path, 'isdir')
+    self.mox.StubOutWithMock(gclient.sys, 'stdout')
+    self.mox.StubOutWithMock(gclient, 'subprocess')
+    # These are not tested.
+    self.mox.StubOutWithMock(gclient, 'FileRead')
+    self.mox.StubOutWithMock(gclient, 'FileWrite')
+    self.mox.StubOutWithMock(gclient, 'SubprocessCall')
+    self.mox.StubOutWithMock(gclient, 'RemoveDirectory')
 
-
-def String(max_length):
-  return ''.join([random.choice(string.letters)
-                  for x in xrange(random.randint(1, max_length))])
-
-
-def Strings(max_arg_count, max_arg_length):
-  return [String(max_arg_length) for x in xrange(max_arg_count)]
-
-
-def Args(max_arg_count=8, max_arg_length=16):
-  return Strings(max_arg_count, random.randint(1, max_arg_length))
-
-
-def _DirElts(max_elt_count=4, max_elt_length=8):
-  return os.sep.join(Strings(max_elt_count, max_elt_length))
-
-
-def Dir(max_elt_count=4, max_elt_length=8):
-  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(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):
     BaseTestCase.setUp(self)
     # Mock them to be sure nothing bad happens.
-    self._CaptureSVN = gclient.CaptureSVN
-    gclient.CaptureSVN = self.mox.CreateMockAnything()
+    self.mox.StubOutWithMock(gclient, 'CaptureSVN')
     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()
-    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()
+    self.mox.StubOutWithMock(gclient, 'CaptureSVNInfo')
+    self.mox.StubOutWithMock(gclient, 'CaptureSVNStatus')
+    self.mox.StubOutWithMock(gclient, 'RunSVN')
+    self.mox.StubOutWithMock(gclient, 'RunSVNAndGetFileList')
     self._gclient_gclient = gclient.GClient
     gclient.GClient = self.mox.CreateMockAnything()
     self._scm_wrapper = gclient.SCMWrapper
     gclient.SCMWrapper = 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
     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
       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.platform = test_case.platform
 
   def setUp(self):
     GClientBaseTestCase.setUp(self)
     self.platform = 'darwin'
 
-    self.args = Args()
-    self.root_dir = Dir()
-    self.url = Url()
+    self.args = self.Args()
+    self.root_dir = self.Dir()
+    self.url = self.Url()
 
 
 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)
@@ skipping 875 matching lines @@
   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
 
   def setUp(self):
     GClientBaseTestCase.setUp(self)
-    self.root_dir = Dir()
-    self.args = Args()
-    self.url = Url()
+    self.root_dir = self.Dir()
+    self.args = self.Args()
+    self.url = self.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)
 
   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)
 
@@ skipping 216 matching lines @@
       'Schedule': 'normal',
       'Copied From URL': None,
       'Copied From Rev': None,
       'Path': '.',
       'Node Kind': 'dir',
     }
     self.assertEqual(file_info, expected)
 
 
 class RunSVNTestCase(BaseTestCase):
-  def setUp(self):
-    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)
 
 
 class SubprocessCallAndCaptureTestCase(BaseTestCase):
   def setUp(self):
     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)
+    self.mox.StubOutWithMock(gclient, '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:
       gclient.sys.stdout.write(i)
     gclient.subprocess.Popen(command, bufsize=0, cwd=in_directory,
-                             shell=(sys.platform == 'win32'),
+                             shell=(gclient.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'])
 
   def testCaptureSVNStatus(self):
     x = self
     def CaptureSVNMock(command, in_directory=None, print_error=True):
@@ skipping 62 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: