def assert_lessthan(found: Any, boundary: Any, api: Optional[str] = None): """ Verifies that the specified return result from the specified API has a value less than the boundary specified. If the verification fails then an :class:`AKitAssertionError` is created and returned, otherwise None is returned. It is the resposibility of the calling test to raise the returned error. :param found: The value being compared :param boundry: The boundary value being compared against :param api: The name of the API that returned the result being inspected. :returns: None or an :class:`AKitAssertionError` for the caller to raise. """ if not found < boundary: msg_prefix = PREFIX_STD if api is None else PREFIX_API.format(api) err_msg_lines = [ "{} verification failed because the found value was not less than the boundary value:" .format(msg_prefix) ] bndry_format_lines = pformat(boundary, indent=4).strip().splitlines() if len(bndry_format_lines) == 1: err_msg_lines.append("BOUNDARY: {}".format(bndry_format_lines[0])) elif len(bndry_format_lines) > 1: err_msg_lines.append("BOUNDARY:") bndry_format_lines = indent_lines(bndry_format_lines, 1) err_msg_lines.extend(bndry_format_lines) found_format_lines = pformat(found, indent=4).splitlines() if len(found_format_lines) == 1: err_msg_lines.append("FOUND: {}".format(found_format_lines[0])) elif len(found_format_lines) > 1: err_msg_lines.append("FOUND:") found_format_lines = indent_lines(found_format_lines, 1) err_msg_lines.extend(found_format_lines) errmsg = os.linesep.join(err_msg_lines) raise AKitAssertionError(errmsg) return
def assert_equal(found: Any, expected: Any, api: Optional[str] = None): """ Verifies that the specified return result from the specified API has the specified expected value. If the verification fails then an :class:`AKitAssertionError` is created and returned, otherwise None is returned. It is the resposibility of the calling test to raise the returned error. :param found: The value to be compared :param expected: The expected value :param api: The name of the API that returned the result being inspected. :returns: None or an :class:`AKitAssertionError` for the caller to raise. """ if found != expected: msg_prefix = PREFIX_STD if api is None else PREFIX_API.format(api) err_msg_lines = [ "{} verification failed because the found value did not match expected value:" .format(msg_prefix), "EXPECTED:" ] exp_format_lines = pformat(expected, indent=4).strip().splitlines() if len(exp_format_lines) == 1: err_msg_lines.append("EXPECTED: {}".format(exp_format_lines[0])) elif len(exp_format_lines) > 1: err_msg_lines.append("EXPECTED:") exp_format_lines = indent_lines(exp_format_lines, 1) err_msg_lines.extend(exp_format_lines) found_format_lines = pformat(found, indent=4).splitlines() if len(found_format_lines) == 1: err_msg_lines.append("FOUND: {}".format(found_format_lines[0])) elif len(found_format_lines) > 1: err_msg_lines.append("FOUND:") found_format_lines = indent_lines(found_format_lines, 1) err_msg_lines.extend(found_format_lines) errmsg = os.linesep.join(err_msg_lines) raise AKitAssertionError(errmsg) return
def execute(self, parameters: Optional[dict] = None, topology: Optional[dict] = None, **kwargs) -> int: self._logger.info("STEP: %s - %d" % (self._label, self._ordinal)) locals().update({"parameters": parameters, "topology": topology}) locals().update(kwargs) script_content = os.linesep.join(self._script) script_content = indent_lines(script_content, level=3) exit_status = 0 try: # Execute the inline python script in the context of the current # globals and locals. exec(script_content, globals(), locals()) except: exit_status = 1 return exit_status
def establish_connectivity(cls): """ This API is called so the `IntegrationMixIn` can establish connectivity with any compute or storage resources. :raises :class:`akit.exceptins.AKitInitialConnectivityError`: """ upnp_agent = UpnpAgent(interface=cls.correspondance_interface) cls.upnp_agent = upnp_agent upnp_agent.start() upnp_agent.begin_search() upnp_hint_list = cls.landscape.get_upnp_devices() # IMPORTANT: We need to make sure all the devices have been found by the UpnpAgent before we continue # the setup of the automation run. upnp_agent.wait_for_devices(upnp_hint_list) found_msg = "==================== DEVICES FOUND ====================\n" for device in upnp_agent.children: devstr = str(device) found_msg += devstr found_msg += "\n\n" cls.logger.info(found_msg) # Go through all the devices found and pull out references to all the devices # that are in the expected list. These are the devices we want to work with # in automation expected_devices_found = [] expected_devices_missing = [dev for dev in upnp_hint_list] for device in upnp_agent.children: devmac = device.MACAddress if devmac in expected_devices_missing: expected_devices_found.append(device) expected_devices_missing.remove(devmac) # IMPORTANT: Make sure there were no expected devices missing and fail loudly if there were if len(expected_devices_missing) > 0: # If we got here, then there are devices missing from the testbed that were # expected to be there. We should not continue the automation run missingmsg = "ERROR: The following devices were missing:\n" for devmac in expected_devices_missing: missingmsg += " %s\n" % devmac raise AKitMissingResourceError(missingmsg) cls.logger.info("All expected devices were found.") cls.expected_device_table = {} for device in expected_devices_found: devmac = device.MACAddress cls.expected_device_table[devmac] = device # IMPORTANT: Make sure we have the minimum automation connectivity with each device failing_devices = HardwarePlayerPoolMixin.verify_expected_device_table_connectivity( cls.expected_device_table) if len(failing_devices) > 0: # If there were devices that failed to have the minimum amount of connectivity\ # then we need to fail loudly here. conn_err_msg = "ERROR: Device connectivity issues were encountered:\n" for device, failurereport in failing_devices: dev_msg += " DEVICE: %s\n" % device dev_msg += indent_lines(failurereport, 2) conn_err_msg += "%s\n" % dev_msg raise AKitInitialConnectivityError(conn_err_msg) return