Restart codereview issue 6792042

lib/cros_build_lib_unittest.py

 #!/usr/bin/python
 #
-# Copyright (c) 2010 The Chromium OS Authors. All rights reserved.
+# Copyright (c) 2011 The Chromium OS Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 import errno
 import os
 import shutil
+import shlex
 import signal
 import subprocess
 import tempfile
 import unittest
 import cros_build_lib
 import mox
 
 
 class TestRunCommand(unittest.TestCase):
 
@@ skipping 95 matching lines @@
     """--enter_chroot=True and --cmd is an array of strings."""
     self.proc_mock.returncode = 0
     cmd_list = ['foo', 'bar', 'roger']
     real_cmd = ['./enter_chroot.sh', '--'] + cmd_list
     self._TestCmd(cmd_list, real_cmd, rc_kv=dict(enter_chroot=True))
 
   def testReturnCodeNotZeroErrorOkNotRaisesError(self):
     """Raise error when proc.communicate() returns non-zero."""
     self.proc_mock.returncode = 1
     cmd = 'test cmd'
-    self._TestCmd(cmd, cmd, rc_kv=dict(error_ok=True))
+    real_cmd = [ 'sh', '-c', cmd ]
+    self._TestCmd(cmd, real_cmd, rc_kv=dict(error_ok=True))
 
-  def testSubprocessCommunicateExceptionRaisesError(self, ignore_sigint=False):
+  def testCommandFailureRaisesError(self, ignore_sigint=False):
     """Verify error raised by communicate() is caught.
 
     Parameterized so this can also be used by some other tests w/ alternate
     params to RunCommand().
 
     Args:
       ignore_sigint: If True, we'll tell RunCommand to ignore sigint.
     """
     cmd = 'test cmd'
 
     # If requested, RunCommand will ignore sigints; record that.
     if ignore_sigint:
       signal.signal(signal.SIGINT, signal.SIG_IGN).AndReturn(self._old_sigint)
 
+    subprocess.Popen(['sh', '-c', cmd ], cwd=None, env=None,
+                     stdin=None, stdout=None, stderr=None,
+                     shell=False).AndReturn(self.proc_mock)
+    self.proc_mock.communicate(None).AndReturn((self.output, self.error))
+
+    # If it ignored them, RunCommand will restore sigints; record that.
+    if ignore_sigint:
+      signal.signal(signal.SIGINT, self._old_sigint).AndReturn(signal.SIG_IGN)
+
+    self.mox.ReplayAll()
+    self.assertRaises(cros_build_lib.RunCommandError,
+                      cros_build_lib.RunCommand, cmd,
+                      ignore_sigint=ignore_sigint, error_ok=False)
+    self.mox.VerifyAll()
+
+  def testSubprocessCommunicateExceptionRaisesError(self, ignore_sigint=False):
+    """Verify error raised by communicate() is caught.
+
+    Parameterized so this can also be used by some other tests w/ alternate
+    params to RunCommand().
+
+    Args:
+      ignore_sigint: If True, we'll tell RunCommand to ignore sigint.
+    """
+    cmd = ['test', 'cmd']
+
+    # If requested, RunCommand will ignore sigints; record that.
+    if ignore_sigint:
+      signal.signal(signal.SIGINT, signal.SIG_IGN).AndReturn(self._old_sigint)
+
     subprocess.Popen(cmd, cwd=None, env=None,
                      stdin=None, stdout=None, stderr=None,
                      shell=False).AndReturn(self.proc_mock)
     self.proc_mock.communicate(None).AndRaise(ValueError)
 
     # If it ignored them, RunCommand will restore sigints; record that.
     if ignore_sigint:
       signal.signal(signal.SIGINT, self._old_sigint).AndReturn(signal.SIG_IGN)
 
     self.mox.ReplayAll()
     self.assertRaises(ValueError, cros_build_lib.RunCommand, cmd,
                       ignore_sigint=ignore_sigint)
     self.mox.VerifyAll()
 
   def testSignalRestoreExceptionCase(self):
     """Test RunCommand() properly sets/restores sigint.  Exception case."""
     self.testSubprocessCommunicateExceptionRaisesError(ignore_sigint=True)
 
   def testSubprocessCommunicateExceptionNotRaisesError(self):
     """Don't re-raise error from communicate() when --error_ok=True."""
-    cmd = 'test cmd'
-    real_cmd = './enter_chroot.sh -- %s' % cmd
+    cmd = ['test', 'cmd']
+    real_cmd = ['./enter_chroot.sh', '--'] + cmd
     expected_result = cros_build_lib.CommandResult()
     expected_result.cmd = real_cmd
 
     subprocess.Popen(real_cmd, cwd=None, env=None,
                      stdin=None, stdout=None, stderr=None,
                      shell=False).AndReturn(self.proc_mock)
     self.proc_mock.communicate(None).AndRaise(ValueError)
 
     self.mox.ReplayAll()
     actual_result = cros_build_lib.RunCommand(cmd, error_ok=True,
@@ skipping 11 matching lines @@
     # This is a simple case, copied from testReturnCodeZeroWithArrayCmd()
     self.proc_mock.returncode = 0
     cmd_list = ['foo', 'bar', 'roger']
 
     # Run.  We expect the env= to be passed through from sp (subprocess.Popen)
     # to rc (RunCommand).
     self._TestCmd(cmd_list, cmd_list,
                   sp_kv=dict(env=env),
                   rc_kv=dict(env=env, exit_code=True))
 
+  def testExtraEnvOnlyWorks(self):
+    """Test RunCommand(..., extra_env=xyz) works."""
+    # We'll put this bogus environment together, just to make sure
+    # subprocess.Popen gets passed it.
+    extra_env = {'Pinky' : 'Brain'}
+    ## This is a little bit circular, since the same logic is used to compute
+    ## the value inside, but at least it checks that this happens.
+    total_env = os.environ.copy()
+    total_env.update(extra_env)
+
+    # This is a simple case, copied from testReturnCodeZeroWithArrayCmd()
+    self.proc_mock.returncode = 0
+    cmd_list = ['foo', 'bar', 'roger']
+
+    # Run.  We expect the env= to be passed through from sp (subprocess.Popen)
+    # to rc (RunCommand).
+    self._TestCmd(cmd_list, cmd_list,
+                  sp_kv=dict(env=total_env),
+                  rc_kv=dict(extra_env=extra_env, exit_code=True))
+
+  def testExtraEnvTooWorks(self):
+    """Test RunCommand(..., env=xy, extra_env=z) works."""
+    # We'll put this bogus environment together, just to make sure
+    # subprocess.Popen gets passed it.
+    env = {'Tom': 'Jerry', 'Itchy': 'Scratchy'}
+    extra_env = {'Pinky': 'Brain'}
+    total_env = {'Tom': 'Jerry', 'Itchy': 'Scratchy', 'Pinky': 'Brain'}
+
+    # This is a simple case, copied from testReturnCodeZeroWithArrayCmd()
+    self.proc_mock.returncode = 0
+    cmd_list = ['foo', 'bar', 'roger']
+
+    # Run.  We expect the env= to be passed through from sp (subprocess.Popen)
+    # to rc (RunCommand).
+    self._TestCmd(cmd_list, cmd_list,
+                  sp_kv=dict(env=total_env),
+                  rc_kv=dict(env=env, extra_env=extra_env, exit_code=True))
+
+
 
   def testExceptionEquality(self):
     """Verify equality methods for RunCommandError"""
 
     e1 = cros_build_lib.RunCommandError('Message 1', ['ls', 'arg'])
     e2 = cros_build_lib.RunCommandError('Message 1', ['ls', 'arg'])
     e_diff_msg = cros_build_lib.RunCommandError('Message 2', ['ls', 'arg'])
     e_diff_cmd = cros_build_lib.RunCommandError('Message 1', ['ls', 'arg1'])
 
     self.assertTrue(e1 == e2)
@@ skipping 129 matching lines @@
 
   def testGetChromeosVersionWithEmptyInputReturnsDefault(self):
     self._TestChromeosVersion('')
 
   def testGetChromeosVersionWithNoneInputReturnsDefault(self):
     self._TestChromeosVersion(None)
 
 
 if __name__ == '__main__':
   unittest.main()