[Android] Add zip pushing and refine push mode selection.

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 67 matching lines @@
   def osStatResult(
       st_mode=None, st_ino=None, st_dev=None, st_nlink=None, st_uid=None,
       st_gid=None, st_size=None, st_atime=None, st_mtime=None, st_ctime=None):
     MockOSStatResult = collections.namedtuple('MockOSStatResult', [
         'st_mode', 'st_ino', 'st_dev', 'st_nlink', 'st_uid', 'st_gid',
         'st_size', 'st_atime', 'st_mtime', 'st_ctime'])
     return MockOSStatResult(st_mode, st_ino, st_dev, st_nlink, st_uid, st_gid,
                             st_size, st_atime, st_mtime, st_ctime)
 
   MOCKED_FUNCTIONS = [
+    ('os.listdir', []),
     ('os.path.abspath', ''),
     ('os.path.dirname', ''),
     ('os.path.exists', False),
     ('os.path.getsize', 0),
     ('os.path.isdir', False),
     ('os.stat', osStatResult.__func__()),
     ('os.walk', []),
   ]
 
   def _get(self, mocked, path, default_val):
@@ skipping 12 matching lines @@
     self._patched_functions = [
         self._patched(m, d) for m, d in type(self).MOCKED_FUNCTIONS]
     self._verbose = verbose
 
   def addMockFile(self, path, **kw):
     self._addMockThing(path, False, **kw)
 
   def addMockDirectory(self, path, **kw):
     self._addMockThing(path, True, **kw)
 
-  def _addMockThing(self, path, is_dir, size=0, stat=None, walk=None):
+  def _addMockThing(self, path, is_dir, listdir=None, size=0, stat=None,
+                    walk=None):
+    if listdir is None:
+      listdir = []
     if stat is None:
       stat = self.osStatResult()
     if walk is None:
       walk = []
+
+    dirname = os.sep.join(path.rstrip(os.sep).split(os.sep)[:-1])
+    if dirname and not dirname in self.mock_file_info:
+      self._addMockThing(dirname, True)
+
     self.mock_file_info[path] = {
+      'os.listdir': listdir,
       'os.path.abspath': path,
-      'os.path.dirname': '/' + '/'.join(path.strip('/').split('/')[:-1]),
+      'os.path.dirname': dirname,
       'os.path.exists': True,
       'os.path.isdir': is_dir,
       'os.path.getsize': size,
       'os.stat': stat,
       'os.walk': walk,
     }
 
   def __enter__(self):
     for p in self._patched_functions:
       p.mocked = p.patched.__enter__()
@@ skipping 63 matching lines @@
     return type(self).AndroidCommandsCalls(self, [(cmd, ret)], comp)
 
   def assertCallsSequence(self, cmd_ret, comp=str.__eq__):
     return type(self).AndroidCommandsCalls(self, cmd_ret, comp)
 
   def setUp(self):
     self.device = device_utils.DeviceUtils(
         '0123456789abcdef', default_timeout=1, default_retries=0)
 
 
+class DeviceUtilsNewImplTest(unittest.TestCase):
+
+  def setUp(self):
+    test_serial = '0123456789abcdef'
+    self.adb = mock.Mock(spec=adb_wrapper.AdbWrapper)
+    self.adb.__str__ = mock.Mock(return_value=test_serial)
+    self.adb.GetDeviceSerial.return_value = test_serial
+    self.device = device_utils.DeviceUtils(
+        self.adb, default_timeout=1, default_retries=0)
+
+
+class DeviceUtilsHybridImplTest(DeviceUtilsOldImplTest):
+
+  def setUp(self):
+    super(DeviceUtilsHybridImplTest, self).setUp()
+    self.device.adb = self.adb = mock.Mock(spec=adb_wrapper.AdbWrapper)
+
+
 class DeviceUtilsIsOnlineTest(DeviceUtilsOldImplTest):
 
   def testIsOnline_true(self):
     with self.assertCalls('adb -s 0123456789abcdef devices',
                                  '00123456789abcdef  device\r\n'):
       self.assertTrue(self.device.IsOnline())
 
   def testIsOnline_false(self):
     with self.assertCalls('adb -s 0123456789abcdef devices', '\r\n'):
       self.assertFalse(self.device.IsOnline())
@@ skipping 615 matching lines @@
 
 class DeviceUtilsSendKeyEventTest(DeviceUtilsOldImplTest):
 
   def testSendKeyEvent(self):
     with self.assertCalls(
         "adb -s 0123456789abcdef shell 'input keyevent 66'",
         ''):
       self.device.SendKeyEvent(66)
 
 
-class DeviceUtilsPushChangedFilesTest(DeviceUtilsOldImplTest):
+class DeviceUtilsPushChangedFilesIndividuallyTest(DeviceUtilsNewImplTest):
+
+  def testPushChangedFilesIndividually_empty(self):
+    test_files = []
+    self.device._PushChangedFilesIndividually(test_files)
+    self.assertEqual(0, self.adb.Push.call_count)
+
+  def testPushChangedFilesIndividually_single(self):
+    test_files = [('/test/host/path', '/test/device/path')]
+    self.device._PushChangedFilesIndividually(test_files)
+    self.adb.Push.assert_called_once_with(
+        '/test/host/path', '/test/device/path')
+
+  def testPushChangedFilesIndividually_multiple(self):
+    test_files = [
+        ('/test/host/path/file1', '/test/device/path/file1'),
+        ('/test/host/path/file2', '/test/device/path/file2')]
+    self.device._PushChangedFilesIndividually(test_files)
+    self.assertEqual(2, self.adb.Push.call_count)
+    self.adb.Push.assert_any_call(
+        '/test/host/path/file1', '/test/device/path/file1')
+    self.adb.Push.assert_any_call(
+        '/test/host/path/file2', '/test/device/path/file2')
 
 
-  def testPushChangedFiles_noHostPath(self):
-    with mock.patch('os.path.exists', return_value=False):
-      with self.assertRaises(device_errors.CommandFailedError):
-        self.device.PushChangedFiles('/test/host/path', '/test/device/path')
+class DeviceUtilsPushChangedFilesZippedTest(DeviceUtilsHybridImplTest):
 
-  def testPushChangedFiles_file_noChange(self):
-    self.device.old_interface._push_if_needed_cache = {}
+  def setUp(self):
+    super(DeviceUtilsPushChangedFilesZippedTest, self).setUp()
+    self.original_install_commands = self.device._InstallCommands
+    self.device._InstallCommands = mock.Mock()
 
-    host_file_path = '/test/host/path'
-    device_file_path = '/test/device/path'
+  def testPushChangedFilesZipped_empty(self):
+    test_files = []
+    self.device._PushChangedFilesZipped(test_files)
+    self.assertEqual(0, self.adb.Push.call_count)
 
-    mock_fs = MockFileSystem()
-    mock_fs.addMockFile(host_file_path, size=100)
+  def testPushChangedFilesZipped_single(self):
+    test_files = [('/test/host/path/file1', '/test/device/path/file1')]
 
-    self.device.old_interface.GetFilesChanged = mock.Mock(return_value=[])
+    self.device._GetExternalStoragePathImpl = mock.Mock(
+        return_value='/test/device/external_dir')
+    self.device._IsOnlineImpl = mock.Mock(return_value=True)
+    self.device._RunShellCommandImpl = 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)
 
-    with mock_fs:
-      # GetFilesChanged is mocked, so its adb calls are omitted.
-      with self.assertNoAdbCalls():
-        self.device.PushChangedFiles(host_file_path, device_file_path)
+    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(
+        ['unzip', '/test/device/external_dir/tmp.zip'],
+        as_root=True, check_return=True,
+        env={'PATH': '$PATH:/data/local/tmp/bin'})
+    self.device._RunShellCommandImpl.assert_any_call(
+        ['rm', '/test/device/external_dir/tmp.zip'])
 
-  def testPushChangedFiles_file_changed(self):
-    self.device.old_interface._push_if_needed_cache = {}
+  def testPushChangedFilesZipped_multiple(self):
+    test_files = [('/test/host/path/file1', '/test/device/path/file1'),
+                  ('/test/host/path/file2', '/test/device/path/file2')]
 
-    host_file_path = '/test/host/path'
-    device_file_path = '/test/device/path'
+    self.device._GetExternalStoragePathImpl = mock.Mock(
+        return_value='/test/device/external_dir')
+    self.device._IsOnlineImpl = mock.Mock(return_value=True)
+    self.device._RunShellCommandImpl = 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_fs = MockFileSystem()
-    mock_fs.addMockFile(
-        host_file_path, size=100,
-        stat=MockFileSystem.osStatResult(st_mtime=1000000000))
-
-    self.device.old_interface.GetFilesChanged = mock.Mock(
-        return_value=[('/test/host/path', '/test/device/path')])
-
-    with mock_fs:
-      with self.assertCalls('adb -s 0123456789abcdef push '
-          '/test/host/path /test/device/path', '100 B/s (100 B in 1.000s)\r\n'):
-        self.device.PushChangedFiles(host_file_path, device_file_path)
-
-  def testPushChangedFiles_directory_nothingChanged(self):
-    self.device.old_interface._push_if_needed_cache = {}
-
-    host_file_path = '/test/host/path'
-    device_file_path = '/test/device/path'
-
-    mock_fs = MockFileSystem()
-    mock_fs.addMockDirectory(
-        host_file_path, size=256,
-        stat=MockFileSystem.osStatResult(st_mtime=1000000000))
-    mock_fs.addMockFile(
-        host_file_path + '/file1', size=251,
-        stat=MockFileSystem.osStatResult(st_mtime=1000000001))
-    mock_fs.addMockFile(
-        host_file_path + '/file2', size=252,
-        stat=MockFileSystem.osStatResult(st_mtime=1000000002))
-
-    self.device.old_interface.GetFilesChanged = mock.Mock(return_value=[])
-
-    with mock_fs:
-      with self.assertCallsSequence([
-          ("adb -s 0123456789abcdef shell 'mkdir -p \"/test/device/path\"'",
-           '')]):
-        self.device.PushChangedFiles(host_file_path, device_file_path)
-
-  def testPushChangedFiles_directory_somethingChanged(self):
-    self.device.old_interface._push_if_needed_cache = {}
-
-    host_file_path = '/test/host/path'
-    device_file_path = '/test/device/path'
-
-    mock_fs = MockFileSystem()
-    mock_fs.addMockDirectory(
-        host_file_path, size=256,
-        stat=MockFileSystem.osStatResult(st_mtime=1000000000),
-        walk=[('/test/host/path', [], ['file1', 'file2'])])
-    mock_fs.addMockFile(
-        host_file_path + '/file1', size=256,
-        stat=MockFileSystem.osStatResult(st_mtime=1000000001))
-    mock_fs.addMockFile(
-        host_file_path + '/file2', size=256,
-        stat=MockFileSystem.osStatResult(st_mtime=1000000002))
-
-    self.device.old_interface.GetFilesChanged = mock.Mock(
-        return_value=[('/test/host/path/file1', '/test/device/path/file1')])
-
-    with mock_fs:
-      with self.assertCallsSequence([
-          ("adb -s 0123456789abcdef shell 'mkdir -p \"/test/device/path\"'",
-           ''),
-          ('adb -s 0123456789abcdef push '
-              '/test/host/path/file1 /test/device/path/file1',
-           '256 B/s (256 B in 1.000s)\r\n')]):
-        self.device.PushChangedFiles(host_file_path, device_file_path)
-
-  def testPushChangedFiles_directory_everythingChanged(self):
-    self.device.old_interface._push_if_needed_cache = {}
-
-    host_file_path = '/test/host/path'
-    device_file_path = '/test/device/path'
-
-    mock_fs = MockFileSystem()
-    mock_fs.addMockDirectory(
-        host_file_path, size=256,
-        stat=MockFileSystem.osStatResult(st_mtime=1000000000))
-    mock_fs.addMockFile(
-        host_file_path + '/file1', size=256,
-        stat=MockFileSystem.osStatResult(st_mtime=1000000001))
-    mock_fs.addMockFile(
-        host_file_path + '/file2', size=256,
-        stat=MockFileSystem.osStatResult(st_mtime=1000000002))
-
-    self.device.old_interface.GetFilesChanged = mock.Mock(
-        return_value=[('/test/host/path/file1', '/test/device/path/file1'),
-                      ('/test/host/path/file2', '/test/device/path/file2')])
-
-    with mock_fs:
-      with self.assertCallsSequence([
-          ("adb -s 0123456789abcdef shell 'mkdir -p \"/test/device/path\"'",
-           ''),
-          ('adb -s 0123456789abcdef push /test/host/path /test/device/path',
-           '768 B/s (768 B in 1.000s)\r\n')]):
-        self.device.PushChangedFiles(host_file_path, device_file_path)
+    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(
+        ['unzip', '/test/device/external_dir/tmp.zip'],
+        as_root=True, check_return=True,
+        env={'PATH': '$PATH:/data/local/tmp/bin'})
+    self.device._RunShellCommandImpl.assert_any_call(
+        ['rm', '/test/device/external_dir/tmp.zip'])
 
 
 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'):
       self.assertTrue(self.device.FileExists('/data/app/test.file.exists'))
@@ skipping 538 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)