[Android] Unit tests for DeviceUtils.

build/android/pylib/android_commands.py

 # Copyright (c) 2012 The Chromium Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 """Provides an interface to communicate with the device via the adb command.
 
 Assumes adb binary is currently on system path.
 """
 # pylint: disable-all
 
@@ skipping 21 matching lines @@
 except ImportError:
   pexpect = None
 
 sys.path.append(os.path.join(
     constants.DIR_SOURCE_ROOT, 'third_party', 'android_testrunner'))
 import adb_interface
 import am_instrument_parser
 import errors
 
 from pylib.device import device_blacklist
+from pylib.device import device_errors
 
 # Pattern to search for the next whole line of pexpect output and capture it
 # into a match group. We can't use ^ and $ for line start end with pexpect,
 # see http://www.noah.org/python/pexpect/#doc for explanation why.
 PEXPECT_LINE_RE = re.compile('\n([^\r]*)\r')
 
 # Set the adb shell prompt to be a unique marker that will [hopefully] not
 # appear at the start of any line of a command's output.
 SHELL_PROMPT = '~+~PQ\x17RS~+~'
 
@@ skipping 328 matching lines @@
       self._adb.SendCommand('wait-for-device')
       return return_value
 
   def GetDeviceYear(self):
     """Returns the year information of the date on device."""
     return self.RunShellCommand('date +%Y')[0]
 
   def GetExternalStorage(self):
     if not self._external_storage:
       self._external_storage = self.RunShellCommand('echo $EXTERNAL_STORAGE')[0]
-      assert self._external_storage, 'Unable to find $EXTERNAL_STORAGE'
+      if not self._external_storage:
+        raise device_errors.CommandFailedError(
+            ['shell', "'echo $EXTERNAL_STORAGE'"],
+            'Unable to find $EXTERNAL_STORAGE')
     return self._external_storage
 
   def WaitForDevicePm(self):
     """Blocks until the device's package manager is available.
 
     To workaround http://b/5201039, we restart the shell and retry if the
     package manager isn't back after 120 seconds.
 
     Raises:
       errors.WaitForResponseTimedOutError after max retries reached.
@@ skipping 240 matching lines @@
       output = self.RunShellCommand('ls ' + external_storage)
       if output:
         sdcard_ready = True
       else:
         time.sleep(wait_period)
         attempts += 1
     if not sdcard_ready:
       raise errors.WaitForResponseTimedOutError(
           'SD card not ready after %s seconds' % timeout_time)
 
-  def _CheckCommandIsValid(self, command):
-    """Raises a ValueError if the command is not valid."""
-
-    # A dict of commands the user should not run directly and a mapping to the
-    # API they should use instead.
-    preferred_apis = {
-        'getprop': 'system_properties[<PROPERTY>]',
-        'setprop': 'system_properties[<PROPERTY>]',
-        }
-
-    # A dict of commands to methods that may call them.
-    whitelisted_callers = {
-        'getprop': 'ProvisionDevices',
-        }
-
-    base_command = shlex.split(command)[0].strip(';')
-    if (base_command in preferred_apis and
-        (base_command not in whitelisted_callers or
-         whitelisted_callers[base_command] not in [
-          f[3] for f in inspect.stack()])):
-      error_msg = ('%s should not be run directly. Instead use: %s' %
-                   (base_command, preferred_apis[base_command]))
-      raise ValueError(error_msg)
-
   def GetAndroidToolStatusAndOutput(self, command, lib_path=None, *args, **kw):
     """Runs a native Android binary, wrapping the command as necessary.
 
     This is a specialization of GetShellCommandStatusAndOutput, which is meant
     for running tools/android/ binaries and handle properly: (1) setting the
     lib path (for component=shared_library), (2) using the PIE wrapper on ICS.
     See crbug.com/373219 for more context.
 
     Args:
       command: String containing the command to send.
@@ skipping 32 matching lines @@
       command: String containing the shell command to send. Must not include
                the single quotes as we use them to escape the whole command.
       timeout_time: Number of seconds to wait for command to respond before
         retrying, used by AdbInterface.SendShellCommand.
       log_result: Boolean to indicate whether we should log the result of the
                   shell command.
 
     Returns:
       list containing the lines of output received from running the command
     """
-    self._CheckCommandIsValid(command)
     self._LogShell(command)
     if "'" in command:
       logging.warning(command + " contains ' quotes")
     result = self._adb.SendShellCommand(
         "'%s'" % command, timeout_time).splitlines()
     # TODO(b.kelemen): we should really be able to drop the stderr of the
     # command or raise an exception based on what the caller wants.
     result = [ l for l in result if not l.startswith('WARNING') ]
     if ['error: device not found'] == result:
       raise errors.DeviceUnresponsiveError('device not found')
@@ skipping 1159 matching lines @@
       dest: absolute path of destination directory
     """
     logging.info('In EfficientDeviceDirectoryCopy %s %s', source, dest)
     with DeviceTempFile(self, suffix=".sh") as temp_script_file:
       host_script_path = os.path.join(constants.DIR_SOURCE_ROOT,
                                       'build',
                                       'android',
                                       'pylib',
                                       'efficient_android_directory_copy.sh')
       self._adb.Push(host_script_path, temp_script_file.name)
-      self.EnableAdbRoot
       out = self.RunShellCommand(
           'sh %s %s %s' % (temp_script_file.name, source, dest),
           timeout_time=120)
       if self._device:
         device_repr = self._device[-4:]
       else:
         device_repr = '????'
       for line in out:
         logging.info('[%s]> %s', device_repr, line)
 
@@ skipping 65 matching lines @@
   """
   def __init__(self, output):
     self._output = output
 
   def write(self, data):
     data = data.replace('\r\r\n', '\n')
     self._output.write(data)
 
   def flush(self):
     self._output.flush()