markdr | dd1893d | 2018-02-05 17:13:47 -0800 | [diff] [blame] | 1 | #!/usr/bin/env python3 |
Alexander Dorokhine | 5eb366e | 2016-03-14 12:04:40 -0700 | [diff] [blame] | 2 | # |
| 3 | # Copyright 2016 - The Android Open Source Project |
| 4 | # |
| 5 | # Licensed under the Apache License, Version 2.0 (the "License"); |
| 6 | # you may not use this file except in compliance with the License. |
| 7 | # You may obtain a copy of the License at |
| 8 | # |
| 9 | # http://www.apache.org/licenses/LICENSE-2.0 |
| 10 | # |
| 11 | # Unless required by applicable law or agreed to in writing, software |
| 12 | # distributed under the License is distributed on an "AS IS" BASIS, |
| 13 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| 14 | # See the License for the specific language governing permissions and |
| 15 | # limitations under the License. |
| 16 | |
| 17 | import logging |
Alexander Dorokhine | 018ec4d | 2016-03-14 12:04:40 -0700 | [diff] [blame] | 18 | import mock |
Ang Li | 5e49480 | 2016-02-26 18:10:26 -0800 | [diff] [blame] | 19 | import os |
Ang Li | a5079ac | 2016-03-10 17:19:36 -0800 | [diff] [blame] | 20 | import shutil |
| 21 | import tempfile |
Alexander Dorokhine | 5eb366e | 2016-03-14 12:04:40 -0700 | [diff] [blame] | 22 | import unittest |
| 23 | |
Betty Zhou | d42223d | 2017-12-12 15:17:33 -0800 | [diff] [blame] | 24 | from acts import logger |
Alexander Dorokhine | 5eb366e | 2016-03-14 12:04:40 -0700 | [diff] [blame] | 25 | from acts.controllers import android_device |
Xianyuan Jia | c241526 | 2019-01-07 15:37:35 -0800 | [diff] [blame] | 26 | from acts.controllers.android_lib import errors |
Alexander Dorokhine | 5eb366e | 2016-03-14 12:04:40 -0700 | [diff] [blame] | 27 | |
Ang Li | 5e49480 | 2016-02-26 18:10:26 -0800 | [diff] [blame] | 28 | # Mock log path for a test run. |
| 29 | MOCK_LOG_PATH = "/tmp/logs/MockTest/xx-xx-xx_xx-xx-xx/" |
markdr | 07cf9fd | 2018-02-12 21:02:57 -0800 | [diff] [blame] | 30 | |
Ang Li | 5e49480 | 2016-02-26 18:10:26 -0800 | [diff] [blame] | 31 | # Mock start and end time of the adb cat. |
Betty Zhou | d42223d | 2017-12-12 15:17:33 -0800 | [diff] [blame] | 32 | MOCK_ADB_EPOCH_BEGIN_TIME = 191000123 |
Remi NGUYEN VAN | bcd01d3 | 2018-06-28 09:54:43 +0900 | [diff] [blame] | 33 | MOCK_ADB_LOGCAT_BEGIN_TIME = logger.normalize_log_line_timestamp( |
| 34 | logger.epoch_to_log_line_timestamp(MOCK_ADB_EPOCH_BEGIN_TIME)) |
| 35 | MOCK_ADB_LOGCAT_END_TIME = "1970-01-02 21:22:02.000" |
Ang Li | 5e49480 | 2016-02-26 18:10:26 -0800 | [diff] [blame] | 36 | |
markdr | d059795 | 2017-08-04 21:41:47 -0700 | [diff] [blame] | 37 | MOCK_SERIAL = 1 |
Sean Sutherland | 0a1238b | 2017-11-21 12:29:51 -0800 | [diff] [blame] | 38 | MOCK_RELEASE_BUILD_ID = "ABC1.123456.007" |
| 39 | MOCK_DEV_BUILD_ID = "ABC-MR1" |
| 40 | MOCK_NYC_BUILD_ID = "N4F27P" |
markdr | d059795 | 2017-08-04 21:41:47 -0700 | [diff] [blame] | 41 | |
Ang Li | a33ae4e | 2016-06-27 15:08:53 -0700 | [diff] [blame] | 42 | |
Ang Li | 0b8fa84 | 2016-05-25 19:02:16 -0700 | [diff] [blame] | 43 | def get_mock_ads(num): |
Alexander Dorokhine | 5eb366e | 2016-03-14 12:04:40 -0700 | [diff] [blame] | 44 | """Generates a list of mock AndroidDevice objects. |
| 45 | |
| 46 | The serial number of each device will be integer 0 through num - 1. |
| 47 | |
| 48 | Args: |
| 49 | num: An integer that is the number of mock AndroidDevice objects to |
| 50 | create. |
| 51 | """ |
| 52 | ads = [] |
| 53 | for i in range(num): |
Ang Li | a33ae4e | 2016-06-27 15:08:53 -0700 | [diff] [blame] | 54 | ad = mock.MagicMock(name="AndroidDevice", serial=i, h_port=None) |
Betty Zhou | 15d1780 | 2017-07-26 16:03:51 -0700 | [diff] [blame] | 55 | ad.ensure_screen_on = mock.MagicMock(return_value=True) |
Alexander Dorokhine | 5eb366e | 2016-03-14 12:04:40 -0700 | [diff] [blame] | 56 | ads.append(ad) |
| 57 | return ads |
| 58 | |
Ang Li | a33ae4e | 2016-06-27 15:08:53 -0700 | [diff] [blame] | 59 | |
Ang Li | 0b8fa84 | 2016-05-25 19:02:16 -0700 | [diff] [blame] | 60 | def mock_get_all_instances(): |
| 61 | return get_mock_ads(5) |
Alexander Dorokhine | 5eb366e | 2016-03-14 12:04:40 -0700 | [diff] [blame] | 62 | |
Ang Li | a33ae4e | 2016-06-27 15:08:53 -0700 | [diff] [blame] | 63 | |
Alexander Dorokhine | 5eb366e | 2016-03-14 12:04:40 -0700 | [diff] [blame] | 64 | def mock_list_adb_devices(): |
| 65 | return [ad.serial for ad in get_mock_ads(5)] |
| 66 | |
Ang Li | a33ae4e | 2016-06-27 15:08:53 -0700 | [diff] [blame] | 67 | |
markdr | d059795 | 2017-08-04 21:41:47 -0700 | [diff] [blame] | 68 | class MockAdbProxy(object): |
Ang Li | 5e49480 | 2016-02-26 18:10:26 -0800 | [diff] [blame] | 69 | """Mock class that swaps out calls to adb with mock calls.""" |
| 70 | |
Sean Sutherland | 0a1238b | 2017-11-21 12:29:51 -0800 | [diff] [blame] | 71 | def __init__(self, |
| 72 | serial, |
| 73 | fail_br=False, |
| 74 | fail_br_before_N=False, |
Mark De Ruyter | 1cf17a5 | 2018-04-19 12:24:43 -0700 | [diff] [blame] | 75 | build_id=MOCK_RELEASE_BUILD_ID, |
Xianyuan Jia | d6b2a63 | 2019-05-24 17:40:45 +0000 | [diff] [blame] | 76 | return_value=None): |
Ang Li | 5e49480 | 2016-02-26 18:10:26 -0800 | [diff] [blame] | 77 | self.serial = serial |
Ang Li | 2ffda55 | 2016-08-25 10:08:39 -0700 | [diff] [blame] | 78 | self.fail_br = fail_br |
Ang Li | 7c31ce1 | 2016-09-12 18:28:52 -0700 | [diff] [blame] | 79 | self.fail_br_before_N = fail_br_before_N |
Mark De Ruyter | 1cf17a5 | 2018-04-19 12:24:43 -0700 | [diff] [blame] | 80 | self.return_value = return_value |
markdr | d059795 | 2017-08-04 21:41:47 -0700 | [diff] [blame] | 81 | self.return_multiple = False |
Sean Sutherland | 0a1238b | 2017-11-21 12:29:51 -0800 | [diff] [blame] | 82 | self.build_id = build_id |
Ang Li | 5e49480 | 2016-02-26 18:10:26 -0800 | [diff] [blame] | 83 | |
Betty Zhou | ca24a07 | 2017-02-07 12:31:15 -0800 | [diff] [blame] | 84 | def shell(self, params, ignore_status=False, timeout=60): |
Ang Li | 5e49480 | 2016-02-26 18:10:26 -0800 | [diff] [blame] | 85 | if params == "id -u": |
Betty Zhou | e4fd314 | 2016-12-06 11:22:33 -0800 | [diff] [blame] | 86 | return "root" |
Ang Li | dcad363 | 2016-06-29 17:14:17 -0700 | [diff] [blame] | 87 | elif params == "bugreportz": |
Ang Li | 2ffda55 | 2016-08-25 10:08:39 -0700 | [diff] [blame] | 88 | if self.fail_br: |
Betty Zhou | e4fd314 | 2016-12-06 11:22:33 -0800 | [diff] [blame] | 89 | return "OMG I died!\n" |
| 90 | return "OK:/path/bugreport.zip\n" |
Ang Li | 7c31ce1 | 2016-09-12 18:28:52 -0700 | [diff] [blame] | 91 | elif params == "bugreportz -v": |
| 92 | if self.fail_br_before_N: |
Betty Zhou | e4fd314 | 2016-12-06 11:22:33 -0800 | [diff] [blame] | 93 | return "/system/bin/sh: bugreportz: not found" |
| 94 | return "1.1" |
markdr | d059795 | 2017-08-04 21:41:47 -0700 | [diff] [blame] | 95 | else: |
| 96 | if self.return_multiple: |
| 97 | return self.return_value.pop(0) |
| 98 | else: |
| 99 | return self.return_value |
Ang Li | 1d24f57 | 2016-10-17 18:41:44 -0700 | [diff] [blame] | 100 | |
| 101 | def getprop(self, params): |
| 102 | if params == "ro.build.id": |
Sean Sutherland | 0a1238b | 2017-11-21 12:29:51 -0800 | [diff] [blame] | 103 | return self.build_id |
markdr | ad37f40 | 2017-11-14 12:27:01 -0800 | [diff] [blame] | 104 | elif params == "ro.build.version.incremental": |
| 105 | return "123456789" |
Ang Li | 1d24f57 | 2016-10-17 18:41:44 -0700 | [diff] [blame] | 106 | elif params == "ro.build.type": |
| 107 | return "userdebug" |
| 108 | elif params == "ro.build.product" or params == "ro.product.name": |
| 109 | return "FakeModel" |
| 110 | elif params == "sys.boot_completed": |
| 111 | return "1" |
Ang Li | 5e49480 | 2016-02-26 18:10:26 -0800 | [diff] [blame] | 112 | |
Christopher Wiley | f2d1956 | 2016-10-26 10:16:29 -0700 | [diff] [blame] | 113 | def devices(self): |
Betty Zhou | e4fd314 | 2016-12-06 11:22:33 -0800 | [diff] [blame] | 114 | return "\t".join([str(self.serial), "device"]) |
Christopher Wiley | f2d1956 | 2016-10-26 10:16:29 -0700 | [diff] [blame] | 115 | |
Betty Zhou | ca24a07 | 2017-02-07 12:31:15 -0800 | [diff] [blame] | 116 | def bugreport(self, params, timeout=android_device.BUG_REPORT_TIMEOUT): |
Tom Turney | 07efec1 | 2017-06-20 19:32:38 +0000 | [diff] [blame] | 117 | expected = os.path.join( |
Xianyuan Jia | d6b2a63 | 2019-05-24 17:40:45 +0000 | [diff] [blame] | 118 | logging.log_path, "AndroidDevice%s" % self.serial, |
Xianyuan Jia | 0e39e55 | 2019-01-24 17:17:47 -0800 | [diff] [blame] | 119 | "AndroidDevice%s_%s.txt" % |
Betty Zhou | d42223d | 2017-12-12 15:17:33 -0800 | [diff] [blame] | 120 | (self.serial, |
| 121 | logger.normalize_log_line_timestamp(MOCK_ADB_LOGCAT_BEGIN_TIME))) |
Ang Li | dcad363 | 2016-06-29 17:14:17 -0700 | [diff] [blame] | 122 | assert expected in params, "Expected '%s', got '%s'." % (expected, |
Ang Li | 5e49480 | 2016-02-26 18:10:26 -0800 | [diff] [blame] | 123 | params) |
| 124 | |
| 125 | def __getattr__(self, name): |
| 126 | """All calls to the none-existent functions in adb proxy would |
| 127 | simply return the adb command string. |
| 128 | """ |
tturney | 0cda4c8 | 2016-11-23 15:06:14 -0800 | [diff] [blame] | 129 | |
Betty Zhou | ca24a07 | 2017-02-07 12:31:15 -0800 | [diff] [blame] | 130 | def adb_call(*args, **kwargs): |
Ang Li | 5e49480 | 2016-02-26 18:10:26 -0800 | [diff] [blame] | 131 | arg_str = ' '.join(str(elem) for elem in args) |
| 132 | return arg_str |
Ang Li | a33ae4e | 2016-06-27 15:08:53 -0700 | [diff] [blame] | 133 | |
Ang Li | 5e49480 | 2016-02-26 18:10:26 -0800 | [diff] [blame] | 134 | return adb_call |
| 135 | |
Ang Li | a33ae4e | 2016-06-27 15:08:53 -0700 | [diff] [blame] | 136 | |
Ang Li | 7f4c946 | 2016-09-21 14:14:21 -0700 | [diff] [blame] | 137 | class MockFastbootProxy(): |
| 138 | """Mock class that swaps out calls to adb with mock calls.""" |
| 139 | |
| 140 | def __init__(self, serial): |
| 141 | self.serial = serial |
| 142 | |
| 143 | def devices(self): |
Betty Zhou | e4fd314 | 2016-12-06 11:22:33 -0800 | [diff] [blame] | 144 | return "xxxx\tdevice\nyyyy\tdevice" |
Ang Li | 7f4c946 | 2016-09-21 14:14:21 -0700 | [diff] [blame] | 145 | |
| 146 | def __getattr__(self, name): |
| 147 | def fastboot_call(*args): |
| 148 | arg_str = ' '.join(str(elem) for elem in args) |
| 149 | return arg_str |
tturney | 0cda4c8 | 2016-11-23 15:06:14 -0800 | [diff] [blame] | 150 | |
Ang Li | 7f4c946 | 2016-09-21 14:14:21 -0700 | [diff] [blame] | 151 | return fastboot_call |
| 152 | |
| 153 | |
Alexander Dorokhine | 5eb366e | 2016-03-14 12:04:40 -0700 | [diff] [blame] | 154 | class ActsAndroidDeviceTest(unittest.TestCase): |
| 155 | """This test class has unit tests for the implementation of everything |
| 156 | under acts.controllers.android_device. |
| 157 | """ |
| 158 | |
Ang Li | a5079ac | 2016-03-10 17:19:36 -0800 | [diff] [blame] | 159 | def setUp(self): |
Ang Li | eb5e505 | 2016-06-24 18:07:11 -0700 | [diff] [blame] | 160 | # Set log_path to logging since acts logger setup is not called. |
| 161 | if not hasattr(logging, "log_path"): |
| 162 | setattr(logging, "log_path", "/tmp/logs") |
| 163 | # Creates a temp dir to be used by tests in this test class. |
Ang Li | a5079ac | 2016-03-10 17:19:36 -0800 | [diff] [blame] | 164 | self.tmp_dir = tempfile.mkdtemp() |
| 165 | |
| 166 | def tearDown(self): |
| 167 | """Removes the temp dir. |
| 168 | """ |
| 169 | shutil.rmtree(self.tmp_dir) |
| 170 | |
Ang Li | 5e49480 | 2016-02-26 18:10:26 -0800 | [diff] [blame] | 171 | # Tests for android_device module functions. |
| 172 | # These tests use mock AndroidDevice instances. |
| 173 | |
tturney | 0cda4c8 | 2016-11-23 15:06:14 -0800 | [diff] [blame] | 174 | @mock.patch.object( |
| 175 | android_device, "get_all_instances", new=mock_get_all_instances) |
| 176 | @mock.patch.object( |
| 177 | android_device, "list_adb_devices", new=mock_list_adb_devices) |
Alexander Dorokhine | 5eb366e | 2016-03-14 12:04:40 -0700 | [diff] [blame] | 178 | def test_create_with_pickup_all(self): |
| 179 | pick_all_token = android_device.ANDROID_DEVICE_PICK_ALL_TOKEN |
Ang Li | a11f2cf | 2016-05-05 11:54:40 -0700 | [diff] [blame] | 180 | actual_ads = android_device.create(pick_all_token) |
Alexander Dorokhine | 5eb366e | 2016-03-14 12:04:40 -0700 | [diff] [blame] | 181 | for actual, expected in zip(actual_ads, get_mock_ads(5)): |
| 182 | self.assertEqual(actual.serial, expected.serial) |
| 183 | |
| 184 | def test_create_with_empty_config(self): |
| 185 | expected_msg = android_device.ANDROID_DEVICE_EMPTY_CONFIG_MSG |
Xianyuan Jia | c241526 | 2019-01-07 15:37:35 -0800 | [diff] [blame] | 186 | with self.assertRaisesRegex(errors.AndroidDeviceConfigError, |
Betty Zhou | ca24a07 | 2017-02-07 12:31:15 -0800 | [diff] [blame] | 187 | expected_msg): |
Ang Li | a11f2cf | 2016-05-05 11:54:40 -0700 | [diff] [blame] | 188 | android_device.create([]) |
Alexander Dorokhine | 5eb366e | 2016-03-14 12:04:40 -0700 | [diff] [blame] | 189 | |
| 190 | def test_create_with_not_list_config(self): |
| 191 | expected_msg = android_device.ANDROID_DEVICE_NOT_LIST_CONFIG_MSG |
Xianyuan Jia | c241526 | 2019-01-07 15:37:35 -0800 | [diff] [blame] | 192 | with self.assertRaisesRegex(errors.AndroidDeviceConfigError, |
Betty Zhou | ca24a07 | 2017-02-07 12:31:15 -0800 | [diff] [blame] | 193 | expected_msg): |
Ang Li | a11f2cf | 2016-05-05 11:54:40 -0700 | [diff] [blame] | 194 | android_device.create("HAHA") |
Alexander Dorokhine | 5eb366e | 2016-03-14 12:04:40 -0700 | [diff] [blame] | 195 | |
| 196 | def test_get_device_success_with_serial(self): |
| 197 | ads = get_mock_ads(5) |
| 198 | expected_serial = 0 |
| 199 | ad = android_device.get_device(ads, serial=expected_serial) |
| 200 | self.assertEqual(ad.serial, expected_serial) |
| 201 | |
| 202 | def test_get_device_success_with_serial_and_extra_field(self): |
| 203 | ads = get_mock_ads(5) |
| 204 | expected_serial = 1 |
| 205 | expected_h_port = 5555 |
| 206 | ads[1].h_port = expected_h_port |
tturney | 0cda4c8 | 2016-11-23 15:06:14 -0800 | [diff] [blame] | 207 | ad = android_device.get_device( |
| 208 | ads, serial=expected_serial, h_port=expected_h_port) |
Alexander Dorokhine | 5eb366e | 2016-03-14 12:04:40 -0700 | [diff] [blame] | 209 | self.assertEqual(ad.serial, expected_serial) |
| 210 | self.assertEqual(ad.h_port, expected_h_port) |
| 211 | |
| 212 | def test_get_device_no_match(self): |
| 213 | ads = get_mock_ads(5) |
| 214 | expected_msg = ("Could not find a target device that matches condition" |
| 215 | ": {'serial': 5}.") |
Mark De Ruyter | 8e627fe | 2018-07-11 16:10:20 -0700 | [diff] [blame] | 216 | with self.assertRaisesRegex(ValueError, expected_msg): |
Alexander Dorokhine | 5eb366e | 2016-03-14 12:04:40 -0700 | [diff] [blame] | 217 | ad = android_device.get_device(ads, serial=len(ads)) |
| 218 | |
| 219 | def test_get_device_too_many_matches(self): |
| 220 | ads = get_mock_ads(5) |
| 221 | target_serial = ads[1].serial = ads[0].serial |
Ang Li | 5e49480 | 2016-02-26 18:10:26 -0800 | [diff] [blame] | 222 | expected_msg = "More than one device matched: \[0, 0\]" |
Mark De Ruyter | 8e627fe | 2018-07-11 16:10:20 -0700 | [diff] [blame] | 223 | with self.assertRaisesRegex(ValueError, expected_msg): |
Alexander Dorokhine | 5eb366e | 2016-03-14 12:04:40 -0700 | [diff] [blame] | 224 | ad = android_device.get_device(ads, serial=target_serial) |
| 225 | |
Ang Li | ffe657b | 2016-07-11 19:52:28 -0700 | [diff] [blame] | 226 | def test_start_services_on_ads(self): |
| 227 | """Makes sure when an AndroidDevice fails to start some services, all |
| 228 | AndroidDevice objects get cleaned up. |
| 229 | """ |
| 230 | msg = "Some error happened." |
| 231 | ads = get_mock_ads(3) |
| 232 | ads[0].start_services = mock.MagicMock() |
| 233 | ads[0].clean_up = mock.MagicMock() |
| 234 | ads[1].start_services = mock.MagicMock() |
| 235 | ads[1].clean_up = mock.MagicMock() |
| 236 | ads[2].start_services = mock.MagicMock( |
Xianyuan Jia | c241526 | 2019-01-07 15:37:35 -0800 | [diff] [blame] | 237 | side_effect=errors.AndroidDeviceError(msg)) |
Ang Li | ffe657b | 2016-07-11 19:52:28 -0700 | [diff] [blame] | 238 | ads[2].clean_up = mock.MagicMock() |
Xianyuan Jia | c241526 | 2019-01-07 15:37:35 -0800 | [diff] [blame] | 239 | with self.assertRaisesRegex(errors.AndroidDeviceError, msg): |
Ang Li | ffe657b | 2016-07-11 19:52:28 -0700 | [diff] [blame] | 240 | android_device._start_services_on_ads(ads) |
| 241 | ads[0].clean_up.assert_called_once_with() |
| 242 | ads[1].clean_up.assert_called_once_with() |
| 243 | ads[2].clean_up.assert_called_once_with() |
| 244 | |
Ang Li | 5e49480 | 2016-02-26 18:10:26 -0800 | [diff] [blame] | 245 | # Tests for android_device.AndroidDevice class. |
| 246 | # These tests mock out any interaction with the OS and real android device |
| 247 | # in AndroidDeivce. |
| 248 | |
markdr | d059795 | 2017-08-04 21:41:47 -0700 | [diff] [blame] | 249 | @mock.patch( |
| 250 | 'acts.controllers.adb.AdbProxy', |
| 251 | return_value=MockAdbProxy(MOCK_SERIAL)) |
tturney | 0cda4c8 | 2016-11-23 15:06:14 -0800 | [diff] [blame] | 252 | @mock.patch( |
| 253 | 'acts.controllers.fastboot.FastbootProxy', |
markdr | d059795 | 2017-08-04 21:41:47 -0700 | [diff] [blame] | 254 | return_value=MockFastbootProxy(MOCK_SERIAL)) |
Ang Li | 7f4c946 | 2016-09-21 14:14:21 -0700 | [diff] [blame] | 255 | def test_AndroidDevice_instantiation(self, MockFastboot, MockAdbProxy): |
Ang Li | 5e49480 | 2016-02-26 18:10:26 -0800 | [diff] [blame] | 256 | """Verifies the AndroidDevice object's basic attributes are correctly |
| 257 | set after instantiation. |
| 258 | """ |
markdr | d059795 | 2017-08-04 21:41:47 -0700 | [diff] [blame] | 259 | ad = android_device.AndroidDevice(serial=MOCK_SERIAL) |
Ang Li | 5e49480 | 2016-02-26 18:10:26 -0800 | [diff] [blame] | 260 | self.assertEqual(ad.serial, 1) |
| 261 | self.assertEqual(ad.model, "fakemodel") |
| 262 | self.assertIsNone(ad.adb_logcat_process) |
Ang Li | 0b8fa84 | 2016-05-25 19:02:16 -0700 | [diff] [blame] | 263 | expected_lp = os.path.join(logging.log_path, |
markdr | d059795 | 2017-08-04 21:41:47 -0700 | [diff] [blame] | 264 | "AndroidDevice%s" % MOCK_SERIAL) |
Ang Li | 5e49480 | 2016-02-26 18:10:26 -0800 | [diff] [blame] | 265 | self.assertEqual(ad.log_path, expected_lp) |
| 266 | |
markdr | d059795 | 2017-08-04 21:41:47 -0700 | [diff] [blame] | 267 | @mock.patch( |
| 268 | 'acts.controllers.adb.AdbProxy', |
| 269 | return_value=MockAdbProxy(MOCK_SERIAL)) |
tturney | 0cda4c8 | 2016-11-23 15:06:14 -0800 | [diff] [blame] | 270 | @mock.patch( |
| 271 | 'acts.controllers.fastboot.FastbootProxy', |
markdr | d059795 | 2017-08-04 21:41:47 -0700 | [diff] [blame] | 272 | return_value=MockFastbootProxy(MOCK_SERIAL)) |
markdr | ad37f40 | 2017-11-14 12:27:01 -0800 | [diff] [blame] | 273 | def test_AndroidDevice_build_info_release(self, MockFastboot, |
| 274 | MockAdbProxy): |
Betty Zhou | d1dd876 | 2016-10-07 17:02:09 -0700 | [diff] [blame] | 275 | """Verifies the AndroidDevice object's basic attributes are correctly |
| 276 | set after instantiation. |
| 277 | """ |
| 278 | ad = android_device.AndroidDevice(serial=1) |
| 279 | build_info = ad.build_info |
markdr | ad37f40 | 2017-11-14 12:27:01 -0800 | [diff] [blame] | 280 | self.assertEqual(build_info["build_id"], "ABC1.123456.007") |
Betty Zhou | d1dd876 | 2016-10-07 17:02:09 -0700 | [diff] [blame] | 281 | self.assertEqual(build_info["build_type"], "userdebug") |
| 282 | |
markdr | d059795 | 2017-08-04 21:41:47 -0700 | [diff] [blame] | 283 | @mock.patch( |
| 284 | 'acts.controllers.adb.AdbProxy', |
Sean Sutherland | 0a1238b | 2017-11-21 12:29:51 -0800 | [diff] [blame] | 285 | return_value=MockAdbProxy(MOCK_SERIAL, build_id=MOCK_DEV_BUILD_ID)) |
tturney | 0cda4c8 | 2016-11-23 15:06:14 -0800 | [diff] [blame] | 286 | @mock.patch( |
| 287 | 'acts.controllers.fastboot.FastbootProxy', |
markdr | d059795 | 2017-08-04 21:41:47 -0700 | [diff] [blame] | 288 | return_value=MockFastbootProxy(MOCK_SERIAL)) |
markdr | ad37f40 | 2017-11-14 12:27:01 -0800 | [diff] [blame] | 289 | def test_AndroidDevice_build_info_dev(self, MockFastboot, MockAdbProxy): |
| 290 | """Verifies the AndroidDevice object's basic attributes are correctly |
| 291 | set after instantiation. |
| 292 | """ |
markdr | ad37f40 | 2017-11-14 12:27:01 -0800 | [diff] [blame] | 293 | ad = android_device.AndroidDevice(serial=1) |
markdr | ad37f40 | 2017-11-14 12:27:01 -0800 | [diff] [blame] | 294 | build_info = ad.build_info |
| 295 | self.assertEqual(build_info["build_id"], "123456789") |
| 296 | self.assertEqual(build_info["build_type"], "userdebug") |
Sean Sutherland | 0a1238b | 2017-11-21 12:29:51 -0800 | [diff] [blame] | 297 | |
| 298 | @mock.patch( |
| 299 | 'acts.controllers.adb.AdbProxy', |
| 300 | return_value=MockAdbProxy(MOCK_SERIAL, build_id=MOCK_NYC_BUILD_ID)) |
| 301 | @mock.patch( |
| 302 | 'acts.controllers.fastboot.FastbootProxy', |
| 303 | return_value=MockFastbootProxy(MOCK_SERIAL)) |
| 304 | def test_AndroidDevice_build_info_nyc(self, MockFastboot, MockAdbProxy): |
| 305 | """Verifies the AndroidDevice object's build id is set correctly for |
| 306 | NYC releases. |
| 307 | """ |
| 308 | ad = android_device.AndroidDevice(serial=1) |
| 309 | build_info = ad.build_info |
| 310 | self.assertEqual(build_info["build_id"], MOCK_NYC_BUILD_ID) |
markdr | ad37f40 | 2017-11-14 12:27:01 -0800 | [diff] [blame] | 311 | |
| 312 | @mock.patch( |
| 313 | 'acts.controllers.adb.AdbProxy', |
| 314 | return_value=MockAdbProxy(MOCK_SERIAL)) |
| 315 | @mock.patch( |
| 316 | 'acts.controllers.fastboot.FastbootProxy', |
| 317 | return_value=MockFastbootProxy(MOCK_SERIAL)) |
Mark De Ruyter | 72f8df9 | 2020-02-12 13:44:49 -0800 | [diff] [blame^] | 318 | @mock.patch('os.makedirs') |
Ang Li | 5e49480 | 2016-02-26 18:10:26 -0800 | [diff] [blame] | 319 | @mock.patch('acts.utils.exe_cmd') |
Omar El Ayach | 4dc80ab | 2019-07-31 16:52:29 -0700 | [diff] [blame] | 320 | @mock.patch( |
| 321 | 'acts.controllers.android_device.AndroidDevice.device_log_path', |
| 322 | new_callable=mock.PropertyMock) |
Xianyuan Jia | 0e39e55 | 2019-01-24 17:17:47 -0800 | [diff] [blame] | 323 | def test_AndroidDevice_take_bug_report(self, mock_log_path, exe_mock, |
Mark De Ruyter | 72f8df9 | 2020-02-12 13:44:49 -0800 | [diff] [blame^] | 324 | mock_makedirs, FastbootProxy, |
Xianyuan Jia | 0e39e55 | 2019-01-24 17:17:47 -0800 | [diff] [blame] | 325 | MockAdbProxy): |
Ang Li | 5e49480 | 2016-02-26 18:10:26 -0800 | [diff] [blame] | 326 | """Verifies AndroidDevice.take_bug_report calls the correct adb command |
| 327 | and writes the bugreport file to the correct path. |
| 328 | """ |
markdr | d059795 | 2017-08-04 21:41:47 -0700 | [diff] [blame] | 329 | ad = android_device.AndroidDevice(serial=MOCK_SERIAL) |
Xianyuan Jia | 0e39e55 | 2019-01-24 17:17:47 -0800 | [diff] [blame] | 330 | mock_log_path.return_value = os.path.join( |
| 331 | logging.log_path, "AndroidDevice%s" % ad.serial) |
Xianyuan Jia | d6b2a63 | 2019-05-24 17:40:45 +0000 | [diff] [blame] | 332 | ad.take_bug_report("test_something", 234325.32) |
Mark De Ruyter | 72f8df9 | 2020-02-12 13:44:49 -0800 | [diff] [blame^] | 333 | mock_makedirs.assert_called_with(mock_log_path(), exist_ok=True) |
Ang Li | 5e49480 | 2016-02-26 18:10:26 -0800 | [diff] [blame] | 334 | |
tturney | 0cda4c8 | 2016-11-23 15:06:14 -0800 | [diff] [blame] | 335 | @mock.patch( |
| 336 | 'acts.controllers.adb.AdbProxy', |
markdr | d059795 | 2017-08-04 21:41:47 -0700 | [diff] [blame] | 337 | return_value=MockAdbProxy(MOCK_SERIAL, fail_br=True)) |
tturney | 0cda4c8 | 2016-11-23 15:06:14 -0800 | [diff] [blame] | 338 | @mock.patch( |
| 339 | 'acts.controllers.fastboot.FastbootProxy', |
markdr | d059795 | 2017-08-04 21:41:47 -0700 | [diff] [blame] | 340 | return_value=MockFastbootProxy(MOCK_SERIAL)) |
Mark De Ruyter | 72f8df9 | 2020-02-12 13:44:49 -0800 | [diff] [blame^] | 341 | @mock.patch('os.makedirs') |
Ang Li | 2ffda55 | 2016-08-25 10:08:39 -0700 | [diff] [blame] | 342 | @mock.patch('acts.utils.exe_cmd') |
Omar El Ayach | 4dc80ab | 2019-07-31 16:52:29 -0700 | [diff] [blame] | 343 | @mock.patch( |
| 344 | 'acts.controllers.android_device.AndroidDevice.device_log_path', |
| 345 | new_callable=mock.PropertyMock) |
Mark De Ruyter | 72f8df9 | 2020-02-12 13:44:49 -0800 | [diff] [blame^] | 346 | def test_AndroidDevice_take_bug_report_fail(self, mock_log_path, *_): |
Ang Li | 7c31ce1 | 2016-09-12 18:28:52 -0700 | [diff] [blame] | 347 | """Verifies AndroidDevice.take_bug_report writes out the correct message |
| 348 | when taking bugreport fails. |
Ang Li | 2ffda55 | 2016-08-25 10:08:39 -0700 | [diff] [blame] | 349 | """ |
markdr | d059795 | 2017-08-04 21:41:47 -0700 | [diff] [blame] | 350 | ad = android_device.AndroidDevice(serial=MOCK_SERIAL) |
Xianyuan Jia | 0e39e55 | 2019-01-24 17:17:47 -0800 | [diff] [blame] | 351 | mock_log_path.return_value = os.path.join( |
| 352 | logging.log_path, "AndroidDevice%s" % ad.serial) |
Ang Li | 2ffda55 | 2016-08-25 10:08:39 -0700 | [diff] [blame] | 353 | expected_msg = "Failed to take bugreport on 1: OMG I died!" |
Omar El Ayach | 4dc80ab | 2019-07-31 16:52:29 -0700 | [diff] [blame] | 354 | with self.assertRaisesRegex(errors.AndroidDeviceError, expected_msg): |
Betty Zhou | d42223d | 2017-12-12 15:17:33 -0800 | [diff] [blame] | 355 | ad.take_bug_report("test_something", 4346343.23) |
Ang Li | 2ffda55 | 2016-08-25 10:08:39 -0700 | [diff] [blame] | 356 | |
tturney | 0cda4c8 | 2016-11-23 15:06:14 -0800 | [diff] [blame] | 357 | @mock.patch( |
| 358 | 'acts.controllers.adb.AdbProxy', |
Xianyuan Jia | d6b2a63 | 2019-05-24 17:40:45 +0000 | [diff] [blame] | 359 | return_value=MockAdbProxy(MOCK_SERIAL, fail_br_before_N=True)) |
tturney | 0cda4c8 | 2016-11-23 15:06:14 -0800 | [diff] [blame] | 360 | @mock.patch( |
| 361 | 'acts.controllers.fastboot.FastbootProxy', |
markdr | d059795 | 2017-08-04 21:41:47 -0700 | [diff] [blame] | 362 | return_value=MockFastbootProxy(MOCK_SERIAL)) |
Mark De Ruyter | 72f8df9 | 2020-02-12 13:44:49 -0800 | [diff] [blame^] | 363 | @mock.patch('os.makedirs') |
Ang Li | 7c31ce1 | 2016-09-12 18:28:52 -0700 | [diff] [blame] | 364 | @mock.patch('acts.utils.exe_cmd') |
Omar El Ayach | 4dc80ab | 2019-07-31 16:52:29 -0700 | [diff] [blame] | 365 | @mock.patch( |
| 366 | 'acts.controllers.android_device.AndroidDevice.device_log_path', |
| 367 | new_callable=mock.PropertyMock) |
tturney | 0cda4c8 | 2016-11-23 15:06:14 -0800 | [diff] [blame] | 368 | def test_AndroidDevice_take_bug_report_fallback( |
Mark De Ruyter | 72f8df9 | 2020-02-12 13:44:49 -0800 | [diff] [blame^] | 369 | self, mock_log_path, exe_mock, mock_makedirs, FastbootProxy, |
Xianyuan Jia | 0e39e55 | 2019-01-24 17:17:47 -0800 | [diff] [blame] | 370 | MockAdbProxy): |
Ang Li | 7c31ce1 | 2016-09-12 18:28:52 -0700 | [diff] [blame] | 371 | """Verifies AndroidDevice.take_bug_report falls back to traditional |
| 372 | bugreport on builds that do not have bugreportz. |
| 373 | """ |
markdr | d059795 | 2017-08-04 21:41:47 -0700 | [diff] [blame] | 374 | ad = android_device.AndroidDevice(serial=MOCK_SERIAL) |
Xianyuan Jia | 0e39e55 | 2019-01-24 17:17:47 -0800 | [diff] [blame] | 375 | mock_log_path.return_value = os.path.join( |
| 376 | logging.log_path, "AndroidDevice%s" % ad.serial) |
Xianyuan Jia | d6b2a63 | 2019-05-24 17:40:45 +0000 | [diff] [blame] | 377 | ad.take_bug_report("test_something", MOCK_ADB_EPOCH_BEGIN_TIME) |
Mark De Ruyter | 72f8df9 | 2020-02-12 13:44:49 -0800 | [diff] [blame^] | 378 | mock_makedirs.assert_called_with(mock_log_path(), exist_ok=True) |
Ang Li | 7c31ce1 | 2016-09-12 18:28:52 -0700 | [diff] [blame] | 379 | |
markdr | d059795 | 2017-08-04 21:41:47 -0700 | [diff] [blame] | 380 | @mock.patch( |
| 381 | 'acts.controllers.adb.AdbProxy', |
| 382 | return_value=MockAdbProxy(MOCK_SERIAL)) |
tturney | 0cda4c8 | 2016-11-23 15:06:14 -0800 | [diff] [blame] | 383 | @mock.patch( |
| 384 | 'acts.controllers.fastboot.FastbootProxy', |
markdr | d059795 | 2017-08-04 21:41:47 -0700 | [diff] [blame] | 385 | return_value=MockFastbootProxy(MOCK_SERIAL)) |
xianyuanjia | 129f420 | 2018-12-03 12:25:11 -0800 | [diff] [blame] | 386 | @mock.patch('acts.libs.proc.process.Process') |
| 387 | def test_AndroidDevice_start_adb_logcat(self, proc_mock, FastbootProxy, |
| 388 | MockAdbProxy): |
| 389 | """Verifies the AndroidDevice method start_adb_logcat. Checks that the |
| 390 | underlying logcat process is started properly and correct warning msgs |
| 391 | are generated. |
Ang Li | f633813 | 2016-04-07 16:14:01 -0700 | [diff] [blame] | 392 | """ |
Omar El Ayach | 4dc80ab | 2019-07-31 16:52:29 -0700 | [diff] [blame] | 393 | with mock.patch(('acts.controllers.android_lib.logcat.' |
| 394 | 'create_logcat_keepalive_process'), |
| 395 | return_value=proc_mock) as create_proc_mock: |
xianyuanjia | 129f420 | 2018-12-03 12:25:11 -0800 | [diff] [blame] | 396 | ad = android_device.AndroidDevice(serial=MOCK_SERIAL) |
Mark De Ruyter | 6e3f146 | 2018-12-03 20:44:45 +0000 | [diff] [blame] | 397 | ad.start_adb_logcat() |
xianyuanjia | 129f420 | 2018-12-03 12:25:11 -0800 | [diff] [blame] | 398 | # Verify start did the correct operations. |
| 399 | self.assertTrue(ad.adb_logcat_process) |
Xianyuan Jia | 9eb6b7d | 2019-05-07 11:12:11 -0700 | [diff] [blame] | 400 | log_dir = "AndroidDevice%s" % ad.serial |
Omar El Ayach | 4dc80ab | 2019-07-31 16:52:29 -0700 | [diff] [blame] | 401 | create_proc_mock.assert_called_with(ad.serial, log_dir, '-b all') |
xianyuanjia | 129f420 | 2018-12-03 12:25:11 -0800 | [diff] [blame] | 402 | proc_mock.start.assert_called_with() |
| 403 | # Expect warning msg if start is called back to back. |
| 404 | expected_msg = "Android device .* already has a running adb logcat" |
| 405 | proc_mock.is_running.return_value = True |
| 406 | with self.assertLogs(level='WARNING') as log: |
| 407 | ad.start_adb_logcat() |
| 408 | self.assertRegex(log.output[0], expected_msg) |
Mark De Ruyter | 6e3f146 | 2018-12-03 20:44:45 +0000 | [diff] [blame] | 409 | |
| 410 | @mock.patch( |
| 411 | 'acts.controllers.adb.AdbProxy', |
| 412 | return_value=MockAdbProxy(MOCK_SERIAL)) |
| 413 | @mock.patch( |
| 414 | 'acts.controllers.fastboot.FastbootProxy', |
| 415 | return_value=MockFastbootProxy(MOCK_SERIAL)) |
xianyuanjia | 129f420 | 2018-12-03 12:25:11 -0800 | [diff] [blame] | 416 | @mock.patch('acts.controllers.android_lib.logcat.' |
| 417 | 'create_logcat_keepalive_process') |
| 418 | def test_AndroidDevice_start_adb_logcat_with_user_param( |
| 419 | self, create_proc_mock, FastbootProxy, MockAdbProxy): |
| 420 | """Verifies that start_adb_logcat generates the correct adb logcat |
| 421 | command if adb_logcat_param is specified. |
Mark De Ruyter | 6e3f146 | 2018-12-03 20:44:45 +0000 | [diff] [blame] | 422 | """ |
| 423 | ad = android_device.AndroidDevice(serial=MOCK_SERIAL) |
| 424 | ad.adb_logcat_param = "-b radio" |
xianyuanjia | 129f420 | 2018-12-03 12:25:11 -0800 | [diff] [blame] | 425 | ad.start_adb_logcat() |
| 426 | # Verify that create_logcat_keepalive_process is called with the |
| 427 | # correct command. |
Xianyuan Jia | 9eb6b7d | 2019-05-07 11:12:11 -0700 | [diff] [blame] | 428 | log_dir = "AndroidDevice%s" % ad.serial |
Omar El Ayach | 4dc80ab | 2019-07-31 16:52:29 -0700 | [diff] [blame] | 429 | create_proc_mock.assert_called_with(ad.serial, log_dir, '-b radio') |
xianyuanjia | 129f420 | 2018-12-03 12:25:11 -0800 | [diff] [blame] | 430 | |
| 431 | @mock.patch( |
| 432 | 'acts.controllers.adb.AdbProxy', |
| 433 | return_value=MockAdbProxy(MOCK_SERIAL)) |
| 434 | @mock.patch( |
| 435 | 'acts.controllers.fastboot.FastbootProxy', |
| 436 | return_value=MockFastbootProxy(MOCK_SERIAL)) |
| 437 | @mock.patch('acts.libs.proc.process.Process') |
| 438 | def test_AndroidDevice_stop_adb_logcat(self, proc_mock, FastbootProxy, |
Omar El Ayach | 4dc80ab | 2019-07-31 16:52:29 -0700 | [diff] [blame] | 439 | MockAdbProxy): |
xianyuanjia | 129f420 | 2018-12-03 12:25:11 -0800 | [diff] [blame] | 440 | """Verifies the AndroidDevice method stop_adb_logcat. Checks that the |
| 441 | underlying logcat process is stopped properly and correct warning msgs |
| 442 | are generated. |
| 443 | """ |
| 444 | ad = android_device.AndroidDevice(serial=MOCK_SERIAL) |
| 445 | ad.adb_logcat_process = proc_mock |
Mark De Ruyter | 6e3f146 | 2018-12-03 20:44:45 +0000 | [diff] [blame] | 446 | # Expect warning msg if stop is called before start. |
xianyuanjia | 129f420 | 2018-12-03 12:25:11 -0800 | [diff] [blame] | 447 | expected_msg = ( |
| 448 | "Android device .* does not have an ongoing adb logcat") |
| 449 | proc_mock.is_running.return_value = False |
Mark De Ruyter | 6e3f146 | 2018-12-03 20:44:45 +0000 | [diff] [blame] | 450 | with self.assertLogs(level='WARNING') as log: |
| 451 | ad.stop_adb_logcat() |
| 452 | self.assertRegex(log.output[0], expected_msg) |
xianyuanjia | 129f420 | 2018-12-03 12:25:11 -0800 | [diff] [blame] | 453 | |
| 454 | # Verify the underlying process is stopped. |
| 455 | proc_mock.is_running.return_value = True |
| 456 | ad.stop_adb_logcat() |
| 457 | proc_mock.stop.assert_called_with() |
Ang Li | f633813 | 2016-04-07 16:14:01 -0700 | [diff] [blame] | 458 | |
markdr | d059795 | 2017-08-04 21:41:47 -0700 | [diff] [blame] | 459 | @mock.patch( |
| 460 | 'acts.controllers.adb.AdbProxy', |
| 461 | return_value=MockAdbProxy(MOCK_SERIAL)) |
markdr | d059795 | 2017-08-04 21:41:47 -0700 | [diff] [blame] | 462 | def test_get_apk_process_id_process_cannot_find(self, adb_proxy): |
| 463 | ad = android_device.AndroidDevice(serial=MOCK_SERIAL) |
| 464 | ad.adb.return_value = "does_not_contain_value" |
| 465 | self.assertEqual(None, ad.get_package_pid("some_package")) |
| 466 | |
| 467 | @mock.patch( |
| 468 | 'acts.controllers.adb.AdbProxy', |
| 469 | return_value=MockAdbProxy(MOCK_SERIAL)) |
| 470 | def test_get_apk_process_id_process_exists_second_try(self, adb_proxy): |
| 471 | ad = android_device.AndroidDevice(serial=MOCK_SERIAL) |
| 472 | ad.adb.return_multiple = True |
| 473 | ad.adb.return_value = ["", "system 1 2 3 4 S com.some_package"] |
| 474 | self.assertEqual(1, ad.get_package_pid("some_package")) |
| 475 | |
| 476 | @mock.patch( |
| 477 | 'acts.controllers.adb.AdbProxy', |
| 478 | return_value=MockAdbProxy(MOCK_SERIAL)) |
| 479 | def test_get_apk_process_id_bad_return(self, adb_proxy): |
| 480 | ad = android_device.AndroidDevice(serial=MOCK_SERIAL) |
| 481 | ad.adb.return_value = "bad_return_index_error" |
| 482 | self.assertEqual(None, ad.get_package_pid("some_package")) |
| 483 | |
| 484 | @mock.patch( |
| 485 | 'acts.controllers.adb.AdbProxy', |
| 486 | return_value=MockAdbProxy(MOCK_SERIAL)) |
| 487 | def test_get_apk_process_id_bad_return(self, adb_proxy): |
| 488 | ad = android_device.AndroidDevice(serial=MOCK_SERIAL) |
| 489 | ad.adb.return_value = "bad return value error" |
| 490 | self.assertEqual(None, ad.get_package_pid("some_package")) |
| 491 | |
Omar El Ayach | 4dc80ab | 2019-07-31 16:52:29 -0700 | [diff] [blame] | 492 | @mock.patch( |
| 493 | 'acts.controllers.adb.AdbProxy', |
| 494 | return_value=MockAdbProxy(MOCK_SERIAL)) |
| 495 | def test_ensure_verity_enabled_only_system_enabled(self, adb_proxy): |
| 496 | ad = android_device.AndroidDevice(serial=MOCK_SERIAL) |
| 497 | root_user_id = '0' |
| 498 | |
| 499 | ad.adb.get_user_id = mock.MagicMock() |
| 500 | ad.adb.get_user_id.return_value = root_user_id |
| 501 | |
| 502 | ad.adb.getprop = mock.MagicMock(side_effect=[ |
| 503 | '', # system.verified |
| 504 | '2' |
| 505 | ]) # vendor.verified |
| 506 | ad.adb.ensure_user = mock.MagicMock() |
| 507 | ad.reboot = mock.MagicMock() |
| 508 | ad.ensure_verity_enabled() |
| 509 | ad.reboot.assert_called_once() |
| 510 | |
| 511 | ad.adb.ensure_user.assert_called_with(root_user_id) |
| 512 | |
| 513 | @mock.patch( |
| 514 | 'acts.controllers.adb.AdbProxy', |
| 515 | return_value=MockAdbProxy(MOCK_SERIAL)) |
| 516 | def test_ensure_verity_enabled_only_vendor_enabled(self, adb_proxy): |
| 517 | ad = android_device.AndroidDevice(serial=MOCK_SERIAL) |
| 518 | root_user_id = '0' |
| 519 | |
| 520 | ad.adb.get_user_id = mock.MagicMock() |
| 521 | ad.adb.get_user_id.return_value = root_user_id |
| 522 | |
| 523 | ad.adb.getprop = mock.MagicMock(side_effect=[ |
| 524 | '2', # system.verified |
| 525 | '' |
| 526 | ]) # vendor.verified |
| 527 | ad.adb.ensure_user = mock.MagicMock() |
| 528 | ad.reboot = mock.MagicMock() |
| 529 | |
| 530 | ad.ensure_verity_enabled() |
| 531 | |
| 532 | ad.reboot.assert_called_once() |
| 533 | ad.adb.ensure_user.assert_called_with(root_user_id) |
| 534 | |
| 535 | @mock.patch( |
| 536 | 'acts.controllers.adb.AdbProxy', |
| 537 | return_value=MockAdbProxy(MOCK_SERIAL)) |
| 538 | def test_ensure_verity_enabled_both_enabled_at_start(self, adb_proxy): |
| 539 | ad = android_device.AndroidDevice(serial=MOCK_SERIAL) |
| 540 | root_user_id = '0' |
| 541 | |
| 542 | ad.adb.get_user_id = mock.MagicMock() |
| 543 | ad.adb.get_user_id.return_value = root_user_id |
| 544 | |
| 545 | ad.adb.getprop = mock.MagicMock(side_effect=[ |
| 546 | '2', # system.verified |
| 547 | '2' |
| 548 | ]) # vendor.verified |
| 549 | ad.adb.ensure_user = mock.MagicMock() |
| 550 | ad.reboot = mock.MagicMock() |
| 551 | ad.ensure_verity_enabled() |
| 552 | |
| 553 | assert not ad.reboot.called |
| 554 | |
| 555 | @mock.patch( |
| 556 | 'acts.controllers.adb.AdbProxy', |
| 557 | return_value=MockAdbProxy(MOCK_SERIAL)) |
| 558 | def test_ensure_verity_disabled_system_already_disabled(self, adb_proxy): |
| 559 | ad = android_device.AndroidDevice(serial=MOCK_SERIAL) |
| 560 | root_user_id = '0' |
| 561 | |
| 562 | ad.adb.get_user_id = mock.MagicMock() |
| 563 | ad.adb.get_user_id.return_value = root_user_id |
| 564 | |
| 565 | ad.adb.getprop = mock.MagicMock(side_effect=[ |
| 566 | '2', # system.verified |
| 567 | '' |
| 568 | ]) # vendor.verified |
| 569 | ad.adb.ensure_user = mock.MagicMock() |
| 570 | ad.reboot = mock.MagicMock() |
| 571 | ad.ensure_verity_disabled() |
| 572 | |
| 573 | ad.reboot.assert_called_once() |
| 574 | |
| 575 | @mock.patch( |
| 576 | 'acts.controllers.adb.AdbProxy', |
| 577 | return_value=MockAdbProxy(MOCK_SERIAL)) |
| 578 | def test_ensure_verity_disabled_vendor_already_disabled(self, adb_proxy): |
| 579 | ad = android_device.AndroidDevice(serial=MOCK_SERIAL) |
| 580 | root_user_id = '0' |
| 581 | |
| 582 | ad.adb.get_user_id = mock.MagicMock() |
| 583 | ad.adb.get_user_id.return_value = root_user_id |
| 584 | |
| 585 | ad.adb.getprop = mock.MagicMock(side_effect=[ |
| 586 | '', # system.verified |
| 587 | '2' |
| 588 | ]) # vendor.verified |
| 589 | ad.adb.ensure_user = mock.MagicMock() |
| 590 | ad.reboot = mock.MagicMock() |
| 591 | |
| 592 | ad.ensure_verity_disabled() |
| 593 | |
| 594 | ad.reboot.assert_called_once() |
| 595 | ad.adb.ensure_user.assert_called_with(root_user_id) |
| 596 | |
| 597 | @mock.patch( |
| 598 | 'acts.controllers.adb.AdbProxy', |
| 599 | return_value=MockAdbProxy(MOCK_SERIAL)) |
| 600 | def test_ensure_verity_disabled_disabled_at_start(self, adb_proxy): |
| 601 | ad = android_device.AndroidDevice(serial=MOCK_SERIAL) |
| 602 | root_user_id = '0' |
| 603 | |
| 604 | ad.adb.get_user_id = mock.MagicMock() |
| 605 | ad.adb.get_user_id.return_value = root_user_id |
| 606 | |
| 607 | ad.adb.getprop = mock.MagicMock(side_effect=[ |
| 608 | '', # system.verified |
| 609 | '' |
| 610 | ]) # vendor.verified |
| 611 | ad.adb.ensure_user = mock.MagicMock() |
| 612 | ad.reboot = mock.MagicMock() |
| 613 | |
| 614 | ad.ensure_verity_disabled() |
| 615 | |
| 616 | assert not ad.reboot.called |
| 617 | |
| 618 | @mock.patch( |
| 619 | 'acts.controllers.adb.AdbProxy', |
| 620 | return_value=MockAdbProxy(MOCK_SERIAL)) |
| 621 | def test_push_system_file(self, adb_proxy): |
| 622 | ad = android_device.AndroidDevice(serial=MOCK_SERIAL) |
| 623 | ad.ensure_verity_disabled = mock.MagicMock() |
| 624 | ad.adb.remount = mock.MagicMock() |
| 625 | ad.adb.push = mock.MagicMock() |
| 626 | |
| 627 | ret = ad.push_system_file('asdf', 'jkl') |
| 628 | self.assertTrue(ret) |
| 629 | |
| 630 | @mock.patch( |
| 631 | 'acts.controllers.adb.AdbProxy', |
| 632 | return_value=MockAdbProxy(MOCK_SERIAL)) |
| 633 | def test_push_system_file_returns_false_on_error(self, adb_proxy): |
| 634 | ad = android_device.AndroidDevice(serial=MOCK_SERIAL) |
| 635 | ad.ensure_verity_disabled = mock.MagicMock() |
| 636 | ad.adb.remount = mock.MagicMock() |
| 637 | ad.adb.push = mock.MagicMock(return_value='error') |
| 638 | |
| 639 | ret = ad.push_system_file('asdf', 'jkl') |
| 640 | self.assertFalse(ret) |
| 641 | |
Ang Li | a33ae4e | 2016-06-27 15:08:53 -0700 | [diff] [blame] | 642 | |
Alexander Dorokhine | 5eb366e | 2016-03-14 12:04:40 -0700 | [diff] [blame] | 643 | if __name__ == "__main__": |
Ang Li | a33ae4e | 2016-06-27 15:08:53 -0700 | [diff] [blame] | 644 | unittest.main() |