def test_AndroidDevice_take_logcat_with_user_param(
self, check_proc_mock, stop_proc_mock, start_proc_mock,
creat_dir_mock, FastbootProxy, MockAdbProxy):
"""Verifies the steps of collecting adb logcat on an AndroidDevice
object, including various function calls and the expected behaviors of
the calls.
"""
ad = android_device.AndroidDevice(serial=MOCK_SERIAL)
ad.adb_logcat_param = "-b radio"
expected_msg = ("Android device .* does not have an ongoing adb logcat"
" collection.")
# Expect error if stop is called before start.
with self.assertRaisesRegex(android_device.AndroidDeviceError,
expected_msg):
ad.stop_adb_logcat()
ad.start_adb_logcat()
# Verify start did the correct operations.
self.assertTrue(ad.adb_logcat_process)
expected_log_path = os.path.join(logging.log_path,
"AndroidDevice%s" % ad.serial,
"adblog,fakemodel,%s.txt" % ad.serial)
creat_dir_mock.assert_called_with(os.path.dirname(expected_log_path))
adb_cmd = 'adb -s %s logcat -T 1 -v year -b radio >> %s'
start_proc_mock.assert_called_with(adb_cmd %
(ad.serial, expected_log_path))
self.assertEqual(ad.adb_logcat_file_path, expected_log_path)
def test_AndroidDevice_build_info_nyc(self, MockFastboot, MockAdbProxy):
"""Verifies the AndroidDevice object's build id is set correctly for
NYC releases.
"""
ad = android_device.AndroidDevice(serial=1)
build_info = ad.build_info
self.assertEqual(build_info["build_id"], MOCK_NYC_BUILD_ID)
def test_AndroidDevice_cat_adb_log(self, check_proc_mock,
mock_timestamp_getter, stop_proc_mock,
start_proc_mock, FastbootProxy,
MockAdbProxy):
"""Verifies that AndroidDevice.cat_adb_log loads the correct adb log
file, locates the correct adb log lines within the given time range,
and writes the lines to the correct output file.
"""
mock_serial = 1
ad = android_device.AndroidDevice(serial=mock_serial)
# Expect error if attempted to cat adb log before starting adb logcat.
expected_msg = ("Attempting to cat adb log when none has been "
"collected on Android device .*")
with self.assertRaisesRegex(android_device.AndroidDeviceError,
expected_msg):
ad.cat_adb_log("some_test", MOCK_ADB_LOGCAT_BEGIN_TIME)
ad.start_adb_logcat()
# Direct the log path of the ad to a temp dir to avoid racing.
ad.log_path = os.path.join(self.tmp_dir, ad.log_path)
mock_adb_log_path = os.path.join(
ad.log_path, "adblog,%s,%s.txt" % (ad.model, ad.serial))
with open(mock_adb_log_path, 'w') as f:
f.write(MOCK_ADB_LOGCAT)
ad.cat_adb_log("some_test", MOCK_ADB_LOGCAT_BEGIN_TIME)
cat_file_path = os.path.join(
ad.log_path, "AdbLogExcerpts",
("some_test,02-29 14:02:20.123,%s,%s.txt") % (ad.model, ad.serial))
with open(cat_file_path, 'r') as f:
actual_cat = f.read()
self.assertEqual(actual_cat, ''.join(MOCK_ADB_LOGCAT_CAT_RESULT))
# Stops adb logcat.
ad.stop_adb_logcat()
def test_AndroidDevice_build_info_dev(self, MockFastboot, MockAdbProxy):
"""Verifies the AndroidDevice object's basic attributes are correctly
set after instantiation.
"""
ad = android_device.AndroidDevice(serial=1)
build_info = ad.build_info
self.assertEqual(build_info["build_id"], "123456789")
self.assertEqual(build_info["build_type"], "userdebug")
def test_push_system_file_returns_false_on_error(self, adb_proxy):
ad = android_device.AndroidDevice(serial=MOCK_SERIAL)
ad.ensure_verity_disabled = mock.MagicMock()
ad.adb.remount = mock.MagicMock()
ad.adb.push = mock.MagicMock(return_value='error')
ret = ad.push_system_file('asdf', 'jkl')
self.assertFalse(ret)
def test_push_system_file(self, adb_proxy):
ad = android_device.AndroidDevice(serial=MOCK_SERIAL)
ad.ensure_verity_disabled = mock.MagicMock()
ad.adb.remount = mock.MagicMock()
ad.adb.push = mock.MagicMock()
ret = ad.push_system_file('asdf', 'jkl')
self.assertTrue(ret)
def test_AndroidDevice_take_bug_report_fail(self, mock_log_path, *_):
"""Verifies AndroidDevice.take_bug_report writes out the correct message
when taking bugreport fails.
"""
ad = android_device.AndroidDevice(serial=MOCK_SERIAL)
mock_log_path.return_value = os.path.join(
logging.log_path, "AndroidDevice%s" % ad.serial)
expected_msg = "Failed to take bugreport on 1: OMG I died!"
with self.assertRaisesRegex(errors.AndroidDeviceError, expected_msg):
ad.take_bug_report("test_something", 4346343.23)
def get_mock_android_device(serial='', ssh_connection=None):
"""Returns a mocked AndroidDevice with a mocked adb/fastboot."""
with mock.patch('acts.controllers.adb.AdbProxy') as adb_proxy, (
mock.patch('acts.controllers.fastboot.FastbootProxy')) as fb_proxy:
fb_proxy.return_value.devices.return_value = ""
ret = mock.Mock(
android_device.AndroidDevice(serial=serial,
ssh_connection=ssh_connection))
fb_proxy.reset_mock()
return ret
def test_AndroidDevice_take_bug_report(self, exe_mock, create_dir_mock,
FastbootProxy, MockAdbProxy):
"""Verifies AndroidDevice.take_bug_report calls the correct adb command
and writes the bugreport file to the correct path.
"""
ad = android_device.AndroidDevice(serial=MOCK_SERIAL)
ad.take_bug_report("test_something", 234325.32)
expected_path = os.path.join(logging.log_path,
"AndroidDevice%s" % ad.serial,
"test_something")
create_dir_mock.assert_called_with(expected_path)
def test_AndroidDevice_take_bug_report(self, mock_log_path, exe_mock,
mock_makedirs, FastbootProxy,
MockAdbProxy):
"""Verifies AndroidDevice.take_bug_report calls the correct adb command
and writes the bugreport file to the correct path.
"""
ad = android_device.AndroidDevice(serial=MOCK_SERIAL)
mock_log_path.return_value = os.path.join(
logging.log_path, "AndroidDevice%s" % ad.serial)
ad.take_bug_report("test_something", 234325.32)
mock_makedirs.assert_called_with(mock_log_path(), exist_ok=True)
def test_AndroidDevice_take_bug_report_fail(self, exe_mock,
create_dir_mock, FastbootProxy,
MockAdbProxy):
"""Verifies AndroidDevice.take_bug_report writes out the correct message
when taking bugreport fails.
"""
ad = android_device.AndroidDevice(serial=MOCK_SERIAL)
expected_msg = "Failed to take bugreport on 1: OMG I died!"
with self.assertRaisesRegex(android_device.AndroidDeviceError,
expected_msg):
ad.take_bug_report("test_something", 4346343.23)
def test_AndroidDevice_instantiation(self, MockFastboot, MockAdbProxy):
"""Verifies the AndroidDevice object's basic attributes are correctly
set after instantiation.
"""
ad = android_device.AndroidDevice(serial=MOCK_SERIAL)
self.assertEqual(ad.serial, 1)
self.assertEqual(ad.model, "fakemodel")
self.assertIsNone(ad.adb_logcat_process)
expected_lp = os.path.join(logging.log_path,
"AndroidDevice%s" % MOCK_SERIAL)
self.assertEqual(ad.log_path, expected_lp)
def test_AndroidDevice_start_adb_logcat_with_user_param(
self, create_proc_mock, FastbootProxy, MockAdbProxy):
"""Verifies that start_adb_logcat generates the correct adb logcat
command if adb_logcat_param is specified.
"""
ad = android_device.AndroidDevice(serial=MOCK_SERIAL)
ad.adb_logcat_param = "-b radio"
ad.start_adb_logcat()
# Verify that create_logcat_keepalive_process is called with the
# correct command.
log_dir = "AndroidDevice%s" % ad.serial
create_proc_mock.assert_called_with(ad.serial, log_dir, '-b radio')
def test_AndroidDevice_take_bug_report_fallback(self, mock_log_path,
exe_mock, mock_makedirs,
FastbootProxy,
MockAdbProxy):
"""Verifies AndroidDevice.take_bug_report falls back to traditional
bugreport on builds that do not have bugreportz.
"""
ad = android_device.AndroidDevice(serial=MOCK_SERIAL)
mock_log_path.return_value = os.path.join(
logging.log_path, "AndroidDevice%s" % ad.serial)
ad.take_bug_report("test_something", MOCK_ADB_EPOCH_BEGIN_TIME)
mock_makedirs.assert_called_with(mock_log_path(), exist_ok=True)
def test_AndroidDevice_take_bug_report_fallback(self, exe_mock,
create_dir_mock,
FastbootProxy,
MockAdbProxy):
"""Verifies AndroidDevice.take_bug_report falls back to traditional
bugreport on builds that do not have bugreportz.
"""
ad = android_device.AndroidDevice(serial=MOCK_SERIAL)
ad.take_bug_report("test_something", MOCK_ADB_EPOCH_BEGIN_TIME)
expected_path = os.path.join(logging.log_path,
"AndroidDevice%s" % ad.serial,
"test_something")
create_dir_mock.assert_called_with(expected_path)
def test_AndroidDevice_take_bug_report(self, exe_mock, create_dir_mock,
MockAdbProxy):
"""Verifies AndroidDevice.take_bug_report calls the correct adb command
and writes the bugreport file to the correct path.
"""
mock_serial = 1
ml = get_mock_logger()
ad = android_device.AndroidDevice(serial=mock_serial, logger=ml)
ad.take_bug_report("test_something", "sometime")
expected_path = os.path.join(MOCK_LOG_PATH,
"AndroidDevice%s" % ad.serial,
"BugReports")
create_dir_mock.assert_called_with(expected_path)
def test_AndroidDevice_instantiation(self, MockAdbProxy):
"""Verifies the AndroidDevice object's basic attributes are correctly
set after instantiation.
"""
mock_serial = 1
ml = get_mock_logger()
ad = android_device.AndroidDevice(serial=mock_serial, logger=ml)
self.assertEqual(ad.serial, 1)
self.assertEqual(ad.model, "fakemodel")
self.assertIsNone(ad.adb_logcat_process)
self.assertIsNone(ad.adb_logcat_file_path)
expected_lp = os.path.join(ml.log_path,
"AndroidDevice%s" % mock_serial)
self.assertEqual(ad.log_path, expected_lp)
def test_AndroidDevice_take_bug_report_fallback(self, exe_mock,
create_dir_mock,
FastbootProxy,
MockAdbProxy):
"""Verifies AndroidDevice.take_bug_report falls back to traditional
bugreport on builds that do not have bugreportz.
"""
mock_serial = 1
ad = android_device.AndroidDevice(serial=mock_serial)
ad.take_bug_report("test_something", "sometime")
expected_path = os.path.join(logging.log_path,
"AndroidDevice%s" % ad.serial,
"BugReports")
create_dir_mock.assert_called_with(expected_path)
def test_ensure_verity_enabled_both_enabled_at_start(self, adb_proxy):
ad = android_device.AndroidDevice(serial=MOCK_SERIAL)
root_user_id = '0'
ad.adb.get_user_id = mock.MagicMock()
ad.adb.get_user_id.return_value = root_user_id
ad.adb.getprop = mock.MagicMock(side_effect=[
'2', # system.verified
'2'
]) # vendor.verified
ad.adb.ensure_user = mock.MagicMock()
ad.reboot = mock.MagicMock()
ad.ensure_verity_enabled()
assert not ad.reboot.called
def test_ensure_verity_disabled_system_already_disabled(self, adb_proxy):
ad = android_device.AndroidDevice(serial=MOCK_SERIAL)
root_user_id = '0'
ad.adb.get_user_id = mock.MagicMock()
ad.adb.get_user_id.return_value = root_user_id
ad.adb.getprop = mock.MagicMock(side_effect=[
'2', # system.verified
''
]) # vendor.verified
ad.adb.ensure_user = mock.MagicMock()
ad.reboot = mock.MagicMock()
ad.ensure_verity_disabled()
ad.reboot.assert_called_once()
def test_AndroidDevice_stop_adb_logcat(self, proc_mock, FastbootProxy,
MockAdbProxy):
"""Verifies the AndroidDevice method stop_adb_logcat. Checks that the
underlying logcat process is stopped properly and correct warning msgs
are generated.
"""
ad = android_device.AndroidDevice(serial=MOCK_SERIAL)
ad.adb_logcat_process = proc_mock
# Expect warning msg if stop is called before start.
expected_msg = (
"Android device .* does not have an ongoing adb logcat")
proc_mock.is_running.return_value = False
with self.assertLogs(level='WARNING') as log:
ad.stop_adb_logcat()
self.assertRegex(log.output[0], expected_msg)
# Verify the underlying process is stopped.
proc_mock.is_running.return_value = True
ad.stop_adb_logcat()
proc_mock.stop.assert_called_with()
def __init__(self, serial_number):
"""Initializes the ACTS library components.
@param serial_number Serial number of the android device to be tested,
None if there is only one device connected to the host.
"""
if not serial_number:
ads = android_device.get_all_instances()
if not ads:
msg = "No android device found, abort!"
logging.error(msg)
raise XmlRpcServerError(msg)
self.ad = ads[0]
elif serial_number in android_device.list_adb_devices():
self.ad = android_device.AndroidDevice(serial_number)
else:
msg = ("Specified Android device %s can't be found, abort!"
) % serial_number
logging.error(msg)
raise XmlRpcServerError(msg)
def test_AndroidDevice_start_adb_logcat(self, proc_mock, FastbootProxy,
MockAdbProxy):
"""Verifies the AndroidDevice method start_adb_logcat. Checks that the
underlying logcat process is started properly and correct warning msgs
are generated.
"""
with mock.patch(('acts.controllers.android_lib.logcat.'
'create_logcat_keepalive_process'),
return_value=proc_mock) as create_proc_mock:
ad = android_device.AndroidDevice(serial=MOCK_SERIAL)
ad.start_adb_logcat()
# Verify start did the correct operations.
self.assertTrue(ad.adb_logcat_process)
log_dir = "AndroidDevice%s" % ad.serial
create_proc_mock.assert_called_with(ad.serial, log_dir, '-b all')
proc_mock.start.assert_called_with()
# Expect warning msg if start is called back to back.
expected_msg = "Android device .* already has a running adb logcat"
proc_mock.is_running.return_value = True
with self.assertLogs(level='WARNING') as log:
ad.start_adb_logcat()
self.assertRegex(log.output[0], expected_msg)
def test_AndroidDevice_take_logcat(self, check_proc_mock, stop_proc_mock,
start_proc_mock, creat_dir_mock,
FastbootProxy, MockAdbProxy):
"""Verifies the steps of collecting adb logcat on an AndroidDevice
object, including various function calls and the expected behaviors of
the calls.
"""
mock_serial = 1
ad = android_device.AndroidDevice(serial=mock_serial)
expected_msg = ("Android device .* does not have an ongoing adb logcat"
" collection.")
# Expect error if stop is called before start.
with self.assertRaisesRegex(android_device.AndroidDeviceError,
expected_msg):
ad.stop_adb_logcat()
ad.start_adb_logcat()
# Verify start did the correct operations.
self.assertTrue(ad.adb_logcat_process)
expected_log_path = os.path.join(logging.log_path,
"AndroidDevice%s" % ad.serial,
"adblog,fakemodel,%s.txt" % ad.serial)
creat_dir_mock.assert_called_with(os.path.dirname(expected_log_path))
adb_cmd = 'adb -s %s logcat -v threadtime -b all >> %s'
start_proc_mock.assert_called_with(adb_cmd %
(ad.serial, expected_log_path))
self.assertEqual(ad.adb_logcat_file_path, expected_log_path)
expected_msg = ("Android device .* already has an adb logcat thread "
"going on. Cannot start another one.")
# Expect error if start is called back to back.
with self.assertRaisesRegex(android_device.AndroidDeviceError,
expected_msg):
ad.start_adb_logcat()
# Verify stop did the correct operations.
ad.stop_adb_logcat()
stop_proc_mock.assert_called_with("process")
self.assertIsNone(ad.adb_logcat_process)
self.assertEqual(ad.adb_logcat_file_path, expected_log_path)
def test_get_apk_process_id_bad_return(self, adb_proxy):
ad = android_device.AndroidDevice(serial=MOCK_SERIAL)
ad.adb.return_value = "bad return value error"
self.assertEqual(None, ad.get_package_pid("some_package"))
def test_get_apk_process_id_process_exists_second_try(self, adb_proxy):
ad = android_device.AndroidDevice(serial=MOCK_SERIAL)
ad.adb.return_multiple = True
ad.adb.return_value = ["", "system 1 2 3 4 S com.some_package"]
self.assertEqual(1, ad.get_package_pid("some_package"))
def test_get_apk_process_id_process_cannot_find(self, adb_proxy):
ad = android_device.AndroidDevice(serial=MOCK_SERIAL)
ad.adb.return_value = "does_not_contain_value"
self.assertEqual(None, ad.get_package_pid("some_package"))
def __init__(self, serial_number, log_dir, test_station):
"""Initializes the ACTS library components.
@test_station string represting teststation's hostname.
@param serial_number Serial number of the android device to be tested,
None if there is only one device connected to the host.
@param log_dir Path to store output logs of this run.
"""
# Cleanup all existing logs for this device when starting.
shutil.rmtree(log_dir, ignore_errors=True)
logger.setup_test_logger(log_path=log_dir, prefix="ANDROID_XMLRPC")
if not serial_number:
ads = android_device.get_all_instances()
if not ads:
msg = "No android device found, abort!"
logging.error(msg)
raise XmlRpcServerError(msg)
self.ad = ads[0]
elif serial_number in android_device.list_adb_devices():
self.ad = android_device.AndroidDevice(serial_number)
else:
msg = ("Specified Android device %s can't be found, abort!"
) % serial_number
logging.error(msg)
raise XmlRpcServerError(msg)
# Even if we find one attenuator assume the rig has attenuators for now.
# With the single IP attenuator, this will be a easy check.
rig_has_attenuator = False
count = 0
for i in range(1, self.NUM_ATTEN + 1):
atten_addr = test_station + '-attenuator-' + '%d' % i
if subprocess.Popen(['ping', '-c', '2', atten_addr],
stdout=subprocess.PIPE).communicate()[0]:
rig_has_attenuator = True
count = count + 1
if rig_has_attenuator and count == self.NUM_ATTEN:
atten = attenuator.create([{
"Address": test_station + '-attenuator-1',
"Port": 23,
"Model": "minicircuits",
"InstrumentCount": 1,
"Paths": ["Attenuator-1"]
}, {
"Address": test_station + '-attenuator-2',
"Port": 23,
"Model": "minicircuits",
"InstrumentCount": 1,
"Paths": ["Attenuator-2"]
}, {
"Address": test_station + '-attenuator-3',
"Port": 23,
"Model": "minicircuits",
"InstrumentCount": 1,
"Paths": ["Attenuator-3"]
}, {
"Address": test_station + '-attenuator-4',
"Port": 23,
"Model": "minicircuits",
"InstrumentCount": 1,
"Paths": ["Attenuator-4"]
}])
device = 0
# Set attenuation on all attenuators to 0.
for device in range(len(atten)):
atten[device].set_atten(0)
attenuator.destroy(atten)
elif rig_has_attenuator and count < self.NUM_ATTEN:
msg = 'One or more attenuators are down.'
logging.error(msg)
raise XmlRpcServerError(msg)