def _test_100_disable(self):
"""Test case for disable()"""
try:
self.device.ethernet_switch_api.disable()
asserts.assert_false(self.device.ethernet_switch_api.status,
"status should be False")
except Exception:
traceback_message = traceback.format_exc()
asserts.fail("Error happened during unlock: " + traceback_message)
def _verify_no_unexpected_reboots(self, start_time):
"""Verify no unexpected reboots after start time."""
bootups = self.device.event_parser.get_unexpected_reboots()
unexpected_timestamps = [
event["system_timestamp"] for event in bootups
if event["system_timestamp"] > start_time
]
asserts.assert_false(
unexpected_timestamps,
"There were {} unexpected bootups after {} at {}".format(
len(unexpected_timestamps), start_time, unexpected_timestamps))
def test_1117_get_event_related_methods_return_appropriate_results(self):
"""Verify Parser accepts valid event label for get_last_event* methods.
"""
event_data = self.device.event_parser.get_last_event(
["optional_description.my_message"])
asserts.assert_false(
event_data.results_list,
"Expecting empty list for 'optional_description.my_message' "
"event label but found {!r} instead.".format(event_data))
event_data = self.device.event_parser.get_last_event()
asserts.assert_false(event_data.timedout,
"Expecting EventResult with .timedout == False")
event_history = self.device.event_parser.get_event_history(
["optional_description.my_message"])
asserts.assert_false(
event_history.results_list, "Expecting empty list for history of "
"'optional_description.my_message' event label "
"but found {!r} instead.".format(event_history))
event_history = self.device.event_parser.get_event_history(count=1)
asserts.assert_false(event_data.timedout,
"Expecting EventResult with .timedout == False")
event_history_count = self.device.event_parser.get_event_history_count(
"optional_description.my_message")
asserts.assert_true(
event_history_count.count == 0,
"Expecting event history count of 0 for "
"'optional_description.my_message' event label "
"but found {} instead.".format(event_history_count))
def expect_false(condition, msg, extras=None):
"""Expects an expression evaluates to False.
If the expectation is not met, the test is marked as fail after its
execution finishes.
Args:
expr: The expression that is evaluated.
msg: A string explaining the details in case of failure.
extras: An optional field for extra information to be included in test
result.
"""
try:
asserts.assert_false(condition, msg, extras)
except signals.TestSignal as e:
logging.exception('Expected a `False` value, got `True`.')
recorder.add_error(e)
def test_02_install_and_uninstalled_package(self):
"""Verify the capability to install and uninstall a package."""
# Install the package and check if it is in the package list.
self.logger.info('Installing package {} from {}'.format(
self._package_name, self._package_path))
self.device.package_management.install_package(self._package_path)
packages_on_device = self.device.package_management.list_packages()
asserts.assert_true(
self._package_name in packages_on_device,
'New installed package {} should be in the package list.'.format(
self._package_name))
# Uninstall the package and check if it is not in the package list.
self.logger.info('Uninstalling package {}'.format(self._package_name))
self.device.package_management.uninstall_package(self._package_name)
packages_on_device = self.device.package_management.list_packages()
asserts.assert_false(
self._package_name in packages_on_device,
'Package {} should be uninstalled and not in the package list.'.
format(self._package_name))
def test_assert_false(self):
asserts.assert_false(False, MSG_EXPECTED_EXCEPTION)
with self.assertRaisesRegex(signals.TestFailure,
MSG_EXPECTED_EXCEPTION):
asserts.assert_false(True, MSG_EXPECTED_EXCEPTION)
def test_2003_redetect(self):
"""Executes the code in the device class that supports device detection."""
self.device.close()
time.sleep(.2)
new_file_devices_name = os.path.join(self.log_path,
"test_2003_devices.json")
new_file_options_name = os.path.join(self.log_path,
"test_2003_device_options.json")
shutil.copy(self.manager.device_file_name, new_file_devices_name)
shutil.copy(self.manager.device_options_file_name,
new_file_options_name)
# self.manager._devices
new_manager = gazoo_device.Manager(
device_file_name=new_file_devices_name,
device_options_file_name=new_file_options_name,
log_directory=self.log_path,
gdm_log_file=os.path.join(self.log_path, "test_2003_gdm.txt"))
new_manager.redetect(self.device.name, self.log_path)
new_manager.close()
asserts.assert_true(
(self.device.name in new_manager._devices
or self.device.name in new_manager.other_devices),
"Device was not successfully detected. "
"See test_2003_gdm.txt and {}_detect.txt for more info".format(
self.device.device_type))
if self.device.name in new_manager._devices:
old_dict = self.manager._devices[self.device.name]["persistent"]
new_dict = new_manager._devices[self.device.name]["persistent"]
else:
old_dict = self.manager.other_devices[
self.device.name]["persistent"]
new_dict = new_manager.other_devices[
self.device.name]["persistent"]
for name, a_dict in [("Old", old_dict), ("Detected", new_dict)]:
self.logger.info("{} configuration: ".format(name))
for key, value in a_dict.items():
self.logger.info("\t{}:{}".format(key, value))
missing_props = []
bad_values = []
for prop, old_value in old_dict.items():
if prop in new_dict:
new_value = new_dict[prop]
if old_value != new_value:
bad_values.append("{}: {!r} was previously {!r}".format(
prop, new_value, old_value))
elif prop not in DEPRECATED_PROPERTIES:
missing_props.append(prop)
msg = ""
if missing_props:
msg += "{} is missing the following previous props: {}.\n".format(
self.device.name, missing_props)
if bad_values:
msg += "{} has the following mismatched values: {}.".format(
self.device.name, ", ".join(bad_values))
self.logger.info(msg)
asserts.assert_false(missing_props or bad_values, msg)
def isFalse(self):
assert_false(self._value, "")