Run pychecker over most scripts in depot_tools. Catched a few bugs.

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 32 matching lines @@
 
 
 class BaseTestCase(super_mox.SuperMoxTestBase):
   def setUp(self):
     super_mox.SuperMoxTestBase.setUp(self)
 
   # Like unittest's assertRaises, but checks for Gclient.Error.
   def assertRaisesError(self, msg, fn, *args, **kwargs):
     try:
       fn(*args, **kwargs)
-    except gclient.Error, e:
+    except gclient_utils.Error, e:
       self.assertEquals(e.args[0], msg)
     else:
       self.fail('%s not raised' % msg)
 
 
 class GClientBaseTestCase(BaseTestCase):
   def Options(self, *args, **kwargs):
     return self.OptionsObject(self, *args, **kwargs)
 
   def setUp(self):
     BaseTestCase.setUp(self)
     self.mox.StubOutWithMock(gclient.os.path, 'exists')
     self.mox.StubOutWithMock(gclient.os.path, 'isfile')
     self.mox.StubOutWithMock(gclient.os.path, 'isdir')
     self.mox.StubOutWithMock(gclient.os, 'remove')
     self.mox.StubOutWithMock(gclient.sys, 'stdout')
     self.mox.StubOutWithMock(gclient_utils, 'subprocess')
     # These are not tested.
-    self.mox.StubOutWithMock(gclient, 'FileRead')
-    self.mox.StubOutWithMock(gclient, 'FileWrite')
+    self.mox.StubOutWithMock(gclient_utils, 'FileRead')
+    self.mox.StubOutWithMock(gclient_utils, 'FileWrite')
     self.mox.StubOutWithMock(gclient_utils, 'SubprocessCall')
     self.mox.StubOutWithMock(gclient_utils, 'RemoveDirectory')
     # Mock them to be sure nothing bad happens.
     self.mox.StubOutWithMock(gclient_scm, 'CaptureSVN')
     self._CaptureSVNInfo = gclient_scm.CaptureSVNInfo
     self.mox.StubOutWithMock(gclient_scm, 'CaptureSVNInfo')
     self.mox.StubOutWithMock(gclient_scm, 'CaptureSVNStatus')
     self.mox.StubOutWithMock(gclient_scm, 'RunSVN')
     self.mox.StubOutWithMock(gclient_scm, 'RunSVNAndGetFileList')
     self._gclient_gclient = gclient.GClient
@@ skipping 34 matching lines @@
 
     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.DoExport, gclient.DoHelp, gclient.DoStatus,
-                      gclient.DoUpdate, gclient.DoRevert, gclient.DoRunHooks,
-                      gclient.DoRevInfo, gclient.DoPack]
+                      gclient.DoUpdate, gclient.DoRevert, gclient.DoRunHooks,
+                      gclient.DoRevInfo, gclient.DoPack]
     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()
 
 class TestDoConfig(GclientTestCase):
   def testMissingArgument(self):
     exception_msg = "required argument missing; see 'gclient help config'"
 
     self.mox.ReplayAll()
@@ skipping 206 matching lines @@
       'RunOnDeps', 'SaveConfig', 'SetConfig', 'SetDefaultConfig',
       'supported_commands', 'PrintRevInfo',
     ]
 
     # If you add a member, be sure to add the relevant test!
     self.compareMembers(self._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)
+    gclient_utils.FileWrite(
+        os.path.join(self.root_dir, options.config_filename),
+        text)
 
     self.mox.ReplayAll()
     client = self._gclient_gclient(self.root_dir, options)
     client.SetConfig(text)
     self.assertEqual(client.ConfigContent(), text)
     self.assertEqual(client.GetVar('client'), 'my client')
     self.assertEqual(client.GetVar('foo'), None)
     client.SaveConfig()
 
     solution_name = 'solution name'
@@ skipping 54 matching lines @@
     gclient.os.path.exists(os.path.join(self.root_dir, options.entries_filename)
         ).AndReturn(False)
 
     # An scm will be requested for the solution.
     scm_wrapper_sol = self.mox.CreateMockAnything()
     gclient_scm.CreateSCM(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)).AndRaise(IOError(2, 'No DEPS file'))
+    gclient_utils.FileRead(os.path.join(self.root_dir,
+                                        solution_name,
+                                        options.deps_file)
+                           ).AndRaise(IOError(2, 'No DEPS file'))
 
     # After everything is done, an attempt is made to write an entries
     # file.
-    gclient.FileWrite(os.path.join(self.root_dir, options.entries_filename),
+    gclient_utils.FileWrite(
+        os.path.join(self.root_dir, options.entries_filename),
         IsOneOf((entries_content1, entries_content2)))
 
     self.mox.ReplayAll()
     client = self._gclient_gclient(self.root_dir, options)
     client.SetConfig(gclient_config)
     client.RunOnDeps('update', self.args)
 
   def testRunOnDepsRelativePaths(self):
     solution_name = 'testRunOnDepsRelativePaths_solution_name'
     gclient_config = (
@@ skipping 29 matching lines @@
     # Expect a check for the entries file and we say there is not one.
     gclient.os.path.exists(os.path.join(self.root_dir, options.entries_filename)
         ).AndReturn(False)
 
     # An scm will be requested for the solution.
     gclient_scm.CreateSCM(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_utils.FileRead(os.path.join(self.root_dir,
+                                        solution_name,
+                                        options.deps_file)).AndReturn(deps)
 
     # Next we expect an scm to be request for dep src/t but it should
     # use the url specified in deps and the relative path should now
     # be relative to the DEPS file.
     gclient_scm.CreateSCM(
         'svn://scm.t/trunk',
         self.root_dir,
         os.path.join(solution_name, "src", "t")).AndReturn(scm_wrapper_t)
     scm_wrapper_t.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),
+    gclient_utils.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)
 
   def testRunOnDepsCustomDeps(self):
     solution_name = 'testRunOnDepsCustomDeps_solution_name'
     gclient_config = (
@@ skipping 37 matching lines @@
     # Expect a check for the entries file and we say there is not one.
     gclient.os.path.exists(os.path.join(self.root_dir, options.entries_filename)
         ).AndReturn(False)
 
     # An scm will be requested for the solution.
     gclient_scm.CreateSCM(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(checkout_path, options.deps_file)
+    gclient_utils.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.
     gclient_scm.CreateSCM('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.
     gclient_scm.CreateSCM('svn://custom.t/trunk',
                        self.root_dir,
                        "src/t").AndReturn(scm_wrapper_t)
 
     scm_wrapper_n.RunCommand('update', options, self.args, [])
     scm_wrapper_t.RunCommand('update', options, self.args, [])
 
     # NOTE: the dep src/b should not create an scm at all.
 
     # After everything is done, an attempt is made to write an entries
     # file.
-    gclient.FileWrite(os.path.join(self.root_dir, options.entries_filename),
+    gclient_utils.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)
 
   # Regression test for Issue #11.
   # http://code.google.com/p/gclient/issues/detail?id=11
   def testRunOnDepsSharedDependency(self):
@@ skipping 42 matching lines @@
         ).AndReturn(False)
 
     # Expect a check for the entries file and we say there is not one.
     gclient.os.path.exists(os.path.join(self.root_dir, options.entries_filename)
         ).AndReturn(False)
 
     # An scm will be requested for the first solution.
     gclient_scm.CreateSCM(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)
+    gclient_utils.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, [])
 
     # An scm will be requested for the second solution.
     gclient_scm.CreateSCM(url_b, self.root_dir, name_b).AndReturn(
         scm_wrapper_b)
     # Then an attempt will be made to read its DEPS file.
-    gclient.FileRead(os.path.join(self.root_dir, name_b, options.deps_file)
+    gclient_utils.FileRead(
+        os.path.join(self.root_dir, name_b, options.deps_file)
         ).AndReturn(deps_b)
     # Then an update will be performed.
     scm_wrapper_b.RunCommand('update', options, self.args, [])
 
     # Finally, an scm is requested for the shared dep.
     gclient_scm.CreateSCM('http://svn.t/trunk', self.root_dir, 'src/t'
         ).AndReturn(scm_wrapper_dep)
     # And an update is run on it.
     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),
+    gclient_utils.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)
 
   def testRunOnDepsSuccess(self):
     # Fake .gclient file.
     name = 'testRunOnDepsSuccess_solution_name'
     gclient_config = """solutions = [ {
   'name': '%s',
   'url': '%s',
   'custom_deps': {},
 }, ]""" % (name, self.url)
 
     entries_content = (
       "entries = \\\n"
       "{ '%s': '%s'}\n"
     ) % (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_scm.CreateSCM(self.url, self.root_dir, name).AndReturn(
         gclient_scm.CreateSCM)
     gclient_scm.CreateSCM.RunCommand('update', options, self.args, [])
-    gclient.FileRead(os.path.join(self.root_dir, name, options.deps_file)
+    gclient_utils.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_content)
+    gclient_utils.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)
 
   def testRunOnDepsRevisions(self):
     def OptIsRev(options, rev):
       if not options.revision == str(rev):
         print("options.revision = %s" % options.revision)
@@ skipping 50 matching lines @@
     scm_wrapper_webkit = self.mox.CreateMockAnything()
     scm_wrapper_breakpad = self.mox.CreateMockAnything()
     scm_wrapper_cygwin = self.mox.CreateMockAnything()
     scm_wrapper_python = self.mox.CreateMockAnything()
     options = self.Options()
     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)
+    gclient_utils.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)
+    gclient_utils.FileWrite(
+        os.path.join(self.root_dir, options.entries_filename),
+        entries_content)
 
     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,
@@ skipping 61 matching lines @@
 }"""
 
     options = self.Options()
     options.revisions = [ 'foo/third_party/WebKit@42',
                           'foo/third_party/WebKit@43' ]
     client = self._gclient_gclient(self.root_dir, options)
     client.SetConfig(gclient_config)
     exception = "Conflicting revision numbers specified."
     try:
       client.RunOnDeps('update', self.args)
-    except gclient.Error, e:
+    except gclient_utils.Error, e:
       self.assertEquals(e.args[0], exception)
     else:
       self.fail('%s not raised' % exception)
 
   def testRunOnDepsSuccessVars(self):
     # Fake .gclient file.
     name = 'testRunOnDepsSuccessVars_solution_name'
     gclient_config = """solutions = [ {
   'name': '%s',
   'url': '%s',
@@ skipping 13 matching lines @@
     entries_content = (
       "entries = \\\n"
       "{ 'foo/third_party/WebKit': '%s',\n"
       "  '%s': '%s'}\n"
     ) % (webkit_path, name, self.url)
 
     scm_wrapper_webkit = self.mox.CreateMockAnything()
     scm_wrapper_src = self.mox.CreateMockAnything()
 
     options = self.Options()
-    gclient.FileRead(os.path.join(self.root_dir, name, options.deps_file)
+    gclient_utils.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)
+    gclient_utils.FileWrite(
+        os.path.join(self.root_dir, options.entries_filename),
+        entries_content)
 
     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)
     gclient_scm.CreateSCM(self.url, self.root_dir, name).AndReturn(
         gclient_scm.CreateSCM)
     gclient_scm.CreateSCM.RunCommand('update', options, self.args, [])
@@ skipping 34 matching lines @@
     entries_content = (
       "entries = \\\n"
       "{ 'foo/third_party/WebKit': '%s',\n"
       "  '%s': '%s'}\n"
     ) % (webkit_path, name, self.url)
 
     scm_wrapper_webkit = self.mox.CreateMockAnything()
     scm_wrapper_src = self.mox.CreateMockAnything()
 
     options = self.Options()
-    gclient.FileRead(os.path.join(self.root_dir, name, options.deps_file)
+    gclient_utils.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)
+    gclient_utils.FileWrite(
+        os.path.join(self.root_dir, options.entries_filename),
+        entries_content)
 
     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)
     gclient_scm.CreateSCM(self.url, self.root_dir, name).AndReturn(
         gclient_scm.CreateSCM)
@@ skipping 21 matching lines @@
   '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)
+    gclient_utils.FileRead(
+        os.path.join(self.root_dir, name, options.deps_file)
         ).AndReturn(deps_content)
     gclient_scm.CreateSCM(self.url, self.root_dir, name).AndReturn(
         gclient_scm.CreateSCM)
     gclient_scm.CreateSCM.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:
+    except gclient_utils.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"
@@ skipping 140 matching lines @@
 """
     gclient_scm.CaptureSVN = CaptureSVNMock
     info = gclient_scm.CaptureSVNStatus(None)
     self.assertEquals(info, [])
 
 
 if __name__ == '__main__':
   unittest.main()
 
 # vim: ts=2:sw=2:tw=80:et: