Update from https://crrev.com/303153

build/android/pylib/device/device_utils_test.py

 #!/usr/bin/env python
 # Copyright 2014 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.
 
 """
 Unit tests for the contents of device_utils.py (mostly DeviceUtils).
 """
 
 # pylint: disable=C0321
@@ skipping 295 matching lines @@
   def assertShellCallSequence(self, calls):
     '''Assert that we expect a sequence of calls to adb.Shell.
 
     Args:
       calls: a sequence of (cmd, return_value) pairs, where |cmd| is the
         expected shell command to run on the device (with any quoting already
         applied), and |return_value| is either a string to give as mock output
         or a _ShellError object to raise an AdbShellCommandFailedError.
     '''
     def mk_expected_call(cmd, return_value):
-      expected_args = Args(cmd, expect_rc=0, timeout=10, retries=0)
+      expected_args = Args(cmd, expect_rc=0)
       if isinstance(return_value, _ShellError):
         return_value = device_errors.AdbShellCommandFailedError(cmd,
             return_value.return_code, return_value.output, str(self.device))
       elif isinstance(return_value, _CmdTimeout):
         return_value = device_errors.CommandTimeoutError(return_value.msg,
                                                          str(self.device))
       return (expected_args, return_value)
 
     expected_calls = (mk_expected_call(a, r) for a, r in calls)
     return MockCallSequence(self, self.adb, 'Shell', expected_calls)
@@ skipping 14 matching lines @@
   def testIsOnline_true(self):
     self.adb.GetState = mock.Mock(return_value='device')
     self.assertTrue(self.device.IsOnline())
     self.adb.GetState.assert_called_once_with()
 
   def testIsOnline_false(self):
     self.adb.GetState = mock.Mock(return_value='offline')
     self.assertFalse(self.device.IsOnline())
     self.adb.GetState.assert_called_once_with()
 
+  def testIsOnline_error(self):
+    self.adb.GetState = mock.Mock(
+     side_effect=device_errors.CommandFailedError('falied'))
+    self.assertFalse(self.device.IsOnline())
+    self.adb.GetState.assert_called_once_with()
 
 class DeviceUtilsHasRootTest(DeviceUtilsNewImplTest):
 
   def testHasRoot_true(self):
     with self.assertShellCall('ls /root', 'foo\r\n'):
       self.assertTrue(self.device.HasRoot())
 
   def testHasRoot_false(self):
     with self.assertShellCall('ls /root', _ShellError()):
       self.assertFalse(self.device.HasRoot())
@@ skipping 72 matching lines @@
       with self.assertRaises(device_errors.CommandFailedError):
         self.device.GetApplicationPath('android')
 
 
 class DeviceUtilsWaitUntilFullyBootedTest(DeviceUtilsNewImplTest):
 
   def testWaitUntilFullyBooted_succeedsNoWifi(self):
     with self.assertShellCallSequence([
         # sc_card_ready
         ('echo $EXTERNAL_STORAGE', '/fake/storage/path\r\n'),
-        ('ls /fake/storage/path', '/fake/storage/path\r\n'),
+        ('test -d /fake/storage/path', ''),
         # pm_ready
         ('pm path android', 'package:this.is.a.test.package\r\n'),
         # boot_completed
         ('getprop sys.boot_completed', '1\r\n')]):
       self.device.WaitUntilFullyBooted(wifi=False)
       self.adb.WaitForDevice.assert_called_once_with()
 
   def testWaitUntilFullyBooted_succeedsWithWifi(self):
     with self.assertShellCallSequence([
         # sc_card_ready
         ('echo $EXTERNAL_STORAGE', '/fake/storage/path\r\n'),
-        ('ls /fake/storage/path', '/fake/storage/path\r\n'),
+        ('test -d /fake/storage/path', ''),
         # pm_ready
         ('pm path android', 'package:this.is.a.test.package\r\n'),
         # boot_completed
         ('getprop sys.boot_completed', '1\r\n'),
         # wifi_enabled
         ('dumpsys wifi', 'stuff\r\nWi-Fi is enabled\r\nmore stuff\r\n')]):
       self.device.WaitUntilFullyBooted(wifi=True)
       self.adb.WaitForDevice.assert_called_once_with()
 
   def testWaitUntilFullyBooted_sdCardReadyFails_noPath(self):
     with self.assertShellCallSequence([
         # sc_card_ready
         ('echo $EXTERNAL_STORAGE', '\r\n')]):
       with self.assertRaises(device_errors.CommandFailedError):
         self.device.WaitUntilFullyBooted(wifi=False)
 
   def testWaitUntilFullyBooted_sdCardReadyFails_emptyPath(self):
     with mock.patch('time.sleep'):
       with self.assertShellCallSequence([
           # sc_card_ready
           ('echo $EXTERNAL_STORAGE', '/fake/storage/path\r\n'),
-          ('ls /fake/storage/path', '\r\n'),
+          ('test -d /fake/storage/path', _ShellError()),
           # sc_card_ready
-          ('ls /fake/storage/path', '\r\n'),
+          ('test -d /fake/storage/path', _ShellError()),
           # sc_card_ready
-          ('ls /fake/storage/path', _CmdTimeout())]):
+          ('test -d /fake/storage/path', _CmdTimeout())]):
         with self.assertRaises(device_errors.CommandTimeoutError):
           self.device.WaitUntilFullyBooted(wifi=False)
 
   def testWaitUntilFullyBooted_devicePmFails(self):
     with mock.patch('time.sleep'):
       with self.assertShellCallSequence([
           # sc_card_ready
           ('echo $EXTERNAL_STORAGE', '/fake/storage/path\r\n'),
-          ('ls /fake/storage/path', '/fake/storage/path\r\n'),
+          ('test -d /fake/storage/path', ''),
           # pm_ready
           ('pm path android', 'Error. Is package manager running?\r\n'),
           # pm_ready
           ('pm path android', 'Error. Is package manager running?\r\n'),
           # pm_ready
           ('pm path android', _CmdTimeout())]):
         with self.assertRaises(device_errors.CommandTimeoutError):
           self.device.WaitUntilFullyBooted(wifi=False)
 
   def testWaitUntilFullyBooted_bootFails(self):
     with mock.patch('time.sleep'):
       with self.assertShellCallSequence([
           # sc_card_ready
           ('echo $EXTERNAL_STORAGE', '/fake/storage/path\r\n'),
-          ('ls /fake/storage/path', '/fake/storage/path\r\n'),
+          ('test -d /fake/storage/path', ''),
           # pm_ready
           ('pm path android', 'package:this.is.a.test.package\r\n'),
           # boot_completed
           ('getprop sys.boot_completed', '0\r\n'),
           # boot_completed
           ('getprop sys.boot_completed', '0\r\n'),
           # boot_completed
           ('getprop sys.boot_completed', _CmdTimeout())]):
         with self.assertRaises(device_errors.CommandTimeoutError):
           self.device.WaitUntilFullyBooted(wifi=False)
 
   def testWaitUntilFullyBooted_wifiFails(self):
     with mock.patch('time.sleep'):
       with self.assertShellCallSequence([
           # sc_card_ready
           ('echo $EXTERNAL_STORAGE', '/fake/storage/path\r\n'),
-          ('ls /fake/storage/path', '/fake/storage/path\r\n'),
+          ('test -d /fake/storage/path', ''),
           # pm_ready
           ('pm path android', 'package:this.is.a.test.package\r\n'),
           # boot_completed
           ('getprop sys.boot_completed', '1\r\n'),
           # wifi_enabled
           ('dumpsys wifi', 'stuff\r\nmore stuff\r\n'),
           # wifi_enabled
           ('dumpsys wifi', 'stuff\r\nmore stuff\r\n'),
           # wifi_enabled
           ('dumpsys wifi', _CmdTimeout())]):
         with self.assertRaises(device_errors.CommandTimeoutError):
           self.device.WaitUntilFullyBooted(wifi=True)
 
 
 class DeviceUtilsRebootTest(DeviceUtilsNewImplTest):
 
   def testReboot_nonBlocking(self):
     self.adb.Reboot = mock.Mock()
     self.device.IsOnline = mock.Mock(return_value=False)
     self.device.Reboot(block=False)
     self.adb.Reboot.assert_called_once_with()
     self.device.IsOnline.assert_called_once_with()
 
   def testReboot_blocking(self):
     self.adb.Reboot = mock.Mock()
     self.device.IsOnline = mock.Mock(return_value=False)
     with self.assertShellCallSequence([
         # sc_card_ready
         ('echo $EXTERNAL_STORAGE', '/fake/storage/path\r\n'),
-        ('ls /fake/storage/path', '/fake/storage/path\r\n'),
+        ('test -d /fake/storage/path', ''),
         # pm_ready
         ('pm path android', 'package:this.is.a.test.package\r\n'),
         # boot_completed
         ('getprop sys.boot_completed', '1\r\n')]):
       self.device.Reboot(block=True)
       self.adb.Reboot.assert_called_once_with()
       self.device.IsOnline.assert_called_once_with()
       self.adb.WaitForDevice.assert_called_once_with()
 
 
@@ skipping 115 matching lines @@
   def testNewRunShellImpl_withCwd(self):
     with self.assertShellCall('cd /some/test/path && ls'):
       self.device.RunShellCommand('ls', cwd='/some/test/path')
 
   def testNewRunShellImpl_withCwdQuoted(self):
     with self.assertShellCall("cd '/some test/path with/spaces' && ls"):
       self.device.RunShellCommand('ls', cwd='/some test/path with/spaces')
 
   def testRunShellCommand_withSu(self):
     with self.assertShellCallSequence([
-        ('ls /root', _ShellError()),
+        ('su -c ls /root && ! ls /root', ''),
         ('su -c setprop service.adb.root 0', '')]):
       self.device.RunShellCommand('setprop service.adb.root 0', as_root=True)
 
   def testRunShellCommand_withRoot(self):
     with self.assertShellCallSequence([
-        ('ls /root', '\r\n'),
+        ('su -c ls /root && ! ls /root', _ShellError()),
         ('setprop service.adb.root 0', '')]):
       self.device.RunShellCommand('setprop service.adb.root 0', as_root=True)
 
   def testRunShellCommand_manyLines(self):
     cmd = 'ls /some/path'
     with self.assertShellCall(cmd, 'file1\r\nfile2\r\nfile3\r\n'):
       self.assertEquals(['file1', 'file2', 'file3'],
                         self.device.RunShellCommand(cmd))
 
   def testRunShellCommand_singleLine_success(self):
@@ skipping 77 matching lines @@
                'this.is.a.test.process\r\n'),
         ('ps', 'USER   PID   PPID  VSIZE  RSS   WCHAN    PC       NAME\r\n')]):
         self.assertEquals(1,
             self.device.KillAll('this.is.a.test.process', blocking=True))
 
   def testKillAll_root(self):
     with self.assertShellCallSequence([
         ('ps', 'USER   PID   PPID  VSIZE  RSS   WCHAN    PC       NAME\r\n'
                'u0_a1  1234  174   123456 54321 ffffffff 456789ab '
                'this.is.a.test.process\r\n'),
-        ('ls /root', _ShellError()),
+        ('su -c ls /root && ! ls /root', ''),
         ('su -c kill -9 1234', '')]):
       self.assertEquals(1,
           self.device.KillAll('this.is.a.test.process', as_root=True))
 
   def testKillAll_sigterm(self):
     with self.assertShellCallSequence([
         ('ps', 'USER   PID   PPID  VSIZE  RSS   WCHAN    PC       NAME\r\n'
                'u0_a1  1234  174   123456 54321 ffffffff 456789ab '
                'this.is.a.test.process\r\n'),
         ('kill -15 1234', '')]):
@@ skipping 280 matching lines @@
     test_files = []
     self.device._PushChangedFilesZipped(test_files)
     self.assertEqual(0, self.adb.Push.call_count)
 
   def testPushChangedFilesZipped_single(self):
     test_files = [('/test/host/path/file1', '/test/device/path/file1')]
 
     self.device._GetExternalStoragePathImpl = mock.Mock(
         return_value='/test/device/external_dir')
     self.device.IsOnline = mock.Mock(return_value=True)
-    self.device._RunShellCommandImpl = mock.Mock()
+    self.device.RunShellCommand = mock.Mock()
     mock_zip_temp = mock.mock_open()
     mock_zip_temp.return_value.name = '/test/temp/file/tmp.zip'
     with mock.patch('multiprocessing.Process') as mock_zip_proc, (
          mock.patch('tempfile.NamedTemporaryFile', mock_zip_temp)):
       self.device._PushChangedFilesZipped(test_files)
 
     mock_zip_proc.assert_called_once_with(
         target=device_utils.DeviceUtils._CreateDeviceZip,
         args=('/test/temp/file/tmp.zip', test_files))
     self.adb.Push.assert_called_once_with(
         '/test/temp/file/tmp.zip', '/test/device/external_dir/tmp.zip')
-    self.assertEqual(2, self.device._RunShellCommandImpl.call_count)
-    self.device._RunShellCommandImpl.assert_any_call(
+    self.assertEqual(2, self.device.RunShellCommand.call_count)
+    self.device.RunShellCommand.assert_any_call(
         ['unzip', '/test/device/external_dir/tmp.zip'],
         as_root=True,
         env={'PATH': '$PATH:/data/local/tmp/bin'},
         check_return=True)
-    self.device._RunShellCommandImpl.assert_any_call(
+    self.device.RunShellCommand.assert_any_call(
         ['rm', '/test/device/external_dir/tmp.zip'], check_return=True)
 
   def testPushChangedFilesZipped_multiple(self):
     test_files = [('/test/host/path/file1', '/test/device/path/file1'),
                   ('/test/host/path/file2', '/test/device/path/file2')]
 
     self.device._GetExternalStoragePathImpl = mock.Mock(
         return_value='/test/device/external_dir')
     self.device.IsOnline = mock.Mock(return_value=True)
-    self.device._RunShellCommandImpl = mock.Mock()
+    self.device.RunShellCommand = mock.Mock()
     mock_zip_temp = mock.mock_open()
     mock_zip_temp.return_value.name = '/test/temp/file/tmp.zip'
     with mock.patch('multiprocessing.Process') as mock_zip_proc, (
          mock.patch('tempfile.NamedTemporaryFile', mock_zip_temp)):
       self.device._PushChangedFilesZipped(test_files)
 
     mock_zip_proc.assert_called_once_with(
         target=device_utils.DeviceUtils._CreateDeviceZip,
         args=('/test/temp/file/tmp.zip', test_files))
     self.adb.Push.assert_called_once_with(
         '/test/temp/file/tmp.zip', '/test/device/external_dir/tmp.zip')
-    self.assertEqual(2, self.device._RunShellCommandImpl.call_count)
-    self.device._RunShellCommandImpl.assert_any_call(
+    self.assertEqual(2, self.device.RunShellCommand.call_count)
+    self.device.RunShellCommand.assert_any_call(
         ['unzip', '/test/device/external_dir/tmp.zip'],
         as_root=True,
         env={'PATH': '$PATH:/data/local/tmp/bin'},
         check_return=True)
-    self.device._RunShellCommandImpl.assert_any_call(
+    self.device.RunShellCommand.assert_any_call(
         ['rm', '/test/device/external_dir/tmp.zip'], check_return=True)
 
 
 class DeviceUtilsFileExistsTest(DeviceUtilsOldImplTest):
 
   def testFileExists_usingTest_fileExists(self):
     with self.assertCalls(
         "adb -s 0123456789abcdef shell "
             "'test -e \"/data/app/test.file.exists\"; echo $?'",
         '0\r\n'):
@@ skipping 221 matching lines @@
     with self.assertShellCall('echo some.string > /test/file/to.write'):
       self.device.WriteTextFile('/test/file/to.write', 'some.string')
 
   def testWriteTextFileTest_quoted(self):
     with self.assertShellCall(
         "echo 'some other string' > '/test/file/to write'"):
       self.device.WriteTextFile('/test/file/to write', 'some other string')
 
   def testWriteTextFileTest_asRoot(self):
     with self.assertShellCallSequence([
-        ('ls /root', _ShellError()),
+        ('su -c ls /root && ! ls /root', ''),
         ('su -c echo string > /test/file', '')]):
       self.device.WriteTextFile('/test/file', 'string', as_root=True)
 
 class DeviceUtilsLsTest(DeviceUtilsOldImplTest):
 
   def testLs_nothing(self):
     with self.assertCallsSequence([
         ("adb -s 0123456789abcdef shell 'ls -lR /this/file/does.not.exist'",
          '/this/file/does.not.exist: No such file or directory\r\n'),
         ("adb -s 0123456789abcdef shell 'date +%z'", '+0000')]):
@@ skipping 284 matching lines @@
     self.device = device_utils.DeviceUtils(None)
     with self.assertCalls('adb  get-serialno', 'unknown'), (
          self.assertRaises(device_errors.NoDevicesError)):
       str(self.device)
 
 
 if __name__ == '__main__':
   logging.getLogger().setLevel(logging.DEBUG)
   unittest.main(verbosity=2)