diff options
Diffstat (limited to 'ice_validator/tests/utils')
| -rw-r--r-- | ice_validator/tests/utils/ports.py | 186 |
1 files changed, 90 insertions, 96 deletions
diff --git a/ice_validator/tests/utils/ports.py b/ice_validator/tests/utils/ports.py index c005e32..afce592 100644 --- a/ice_validator/tests/utils/ports.py +++ b/ice_validator/tests/utils/ports.py @@ -36,120 +36,114 @@ # ============LICENSE_END============================================ # # -from .network_roles import get_network_role_and_type -from tests.structures import Heat, NeutronPortProcessor -from tests.helpers import parameter_type_to_heat_type +from tests.structures import Heat +from tests.helpers import parameter_type_to_heat_type, prop_iterator from . import nested_dict -def check_ip_format(yaml_file, regx, port_type, resource_property, nested_property): +def check_parameter_format(yaml_file, regx, intext, resource_processor, *properties): """ yaml_file: input file to check regx: dictionary containing the regex to use to validate parameter - port_type: internal or external - resource_property: OS::Neutron::Port property to check for parameter - nested_property: resource_property will be a list of dicts, this is the key to index into + intext: internal or external + resource_processor: resource type specific helper, defined in structures.py + properties: arg list of property that is being checked """ - invalid_ips = [] + + invalid_parameters = [] heat = Heat(filepath=yaml_file) - ports = heat.get_resource_by_type("OS::Neutron::Port") + resource_type = resource_processor.resource_type + resources = heat.get_resource_by_type(resource_type) heat_parameters = heat.parameters - - for rid, resource in ports.items(): - network_role, network_type = get_network_role_and_type(resource) - if ( - network_type != port_type - ): # skipping if port type (internal/external) doesn't match - continue - - name, port_match = NeutronPortProcessor.get_rid_match_tuple(rid) + for rid, resource in resources.items(): + resource_intext, port_match = resource_processor.get_rid_match_tuple(rid) if not port_match: continue # port resource ID not formatted correctely - params = nested_dict.get(resource, "properties", resource_property, default={}) + if ( + resource_intext != intext + ): # skipping if type (internal/external) doesn't match + continue - for param in params: - prop = nested_dict.get(param, nested_property) + for param in prop_iterator(resource, *properties): if ( - not prop - or not isinstance(prop, dict) - or "get_resource" in prop - or "get_attr" in prop - # or "str_replace" in prop - should str_replace be checked? + param + and isinstance(param, dict) + and "get_resource" not in param + and "get_attr" not in param ): - continue # lets only check parameters shall we? - - # checking parameter uses get_param - parameter = nested_dict.get(prop, "get_param") - if not parameter: - msg = ( - "Unexpected parameter format for OS::Neutron::Port {} property {}: {}. " - + "Please consult the heat guidelines documentation for details." - ).format(rid, resource_property, prop) - invalid_ips.append(msg) # should this be a failure? - continue - - # getting parameter if the get_param uses list, and getting official HEAT parameter type - parameter_type = parameter_type_to_heat_type(parameter) - if parameter_type == "comma_delimited_list": - parameter = parameter[0] - elif parameter_type != "string": - continue - - # checking parameter format = type defined in template - heat_parameter_type = nested_dict.get(heat_parameters, parameter, "type") - if not heat_parameter_type or heat_parameter_type != parameter_type: - msg = ( - "OS::Neutron::Port {} parameter {} defined as type {} " - + "is being used as type {} in the heat template" - ).format( - resource_property, parameter, heat_parameter_type, parameter_type - ) - invalid_ips.append(msg) - continue - - # if parameter type is not in regx dict, then it is not supported by automation - regx_dict = regx[port_type].get(parameter_type) - if not regx_dict: - msg = ( - "WARNING: OS::Neutron::Port {} parameter {} defined as type {} " - + "is not supported by platform automation. If this VNF is not able " - + "to adhere to this requirement, please consult the Heat Orchestration " - + "Template guidelines for alternative solutions. If already adhering to " - + "an alternative provided by the heat guidelines, please disregard this " - + "message." - ).format(resource_property, parameter, parameter_type) - invalid_ips.append(msg) - continue - - # checking if param adheres to guidelines format - regexp = regx[port_type][parameter_type]["machine"] - readable_format = regx[port_type][parameter_type]["readable"] - match = regexp.match(parameter) - if not match: - msg = "{} parameter {} does not follow format {}".format( - resource_property, parameter, readable_format - ) - invalid_ips.append(msg) - continue - - # checking that parameter includes correct vm_type/network_role - parameter_checks = regx.get("parameter_to_resource_comparisons", []) - for check in parameter_checks: - resource_match = port_match.group(check) - if ( - resource_match - and not parameter.startswith(resource_match) - and parameter.find("_{}_".format(resource_match)) == -1 - ): + + # checking parameter uses get_param + parameter = param.get("get_param") + if not parameter: + msg = ( + "Unexpected parameter format for {} {} property {}: {}. " + + "Please consult the heat guidelines documentation for details." + ).format(resource_type, rid, properties, param) + invalid_parameters.append(msg) # should this be a failure? + continue + + # getting parameter if the get_param uses list, and getting official HEAT parameter type + parameter_type = parameter_type_to_heat_type(parameter) + if parameter_type == "comma_delimited_list": + parameter = parameter[0] + elif parameter_type != "string": + continue + + # checking parameter format = parameter type defined in parameters section + heat_parameter_type = nested_dict.get(heat_parameters, parameter, "type") + if not heat_parameter_type or heat_parameter_type != parameter_type: msg = ( - "OS::Neutron::Port {0} property {1} parameter " - + "{2} {3} does match resource {3} {4}" - ).format(rid, resource_property, parameter, check, resource_match) - invalid_ips.append(msg) + "{} {} parameter {} defined as type {} " + + "is being used as type {} in the heat template" + ).format( + resource_type, properties, parameter, heat_parameter_type, parameter_type + ) + invalid_parameters.append(msg) # should this actually be an error? + continue + + # if parameter type is not in regx dict, then it is not supported by automation + regx_dict = regx[resource_intext].get(parameter_type) + if not regx_dict: + msg = ( + "WARNING: {} {} parameter {} defined as type {} " + "is not supported by platform automation. If this VNF is not able " + "to adhere to this requirement, please consult the Heat Orchestration " + "Template guidelines for alternative solutions. If already adhering to " + "an alternative provided by the heat guidelines, please disregard this " + "message." + ).format(resource_type, properties, parameter, parameter_type) + invalid_parameters.append(msg) + continue + + # checking if param adheres to guidelines format + regexp = regx[resource_intext][parameter_type]["machine"] + readable_format = regx[resource_intext][parameter_type]["readable"] + match = regexp.match(parameter) + if not match: + msg = "{} {} property {} parameter {} does not follow {} format {}".format( + resource_type, rid, properties, parameter, resource_intext, readable_format + ) + invalid_parameters.append(msg) continue - assert not invalid_ips, "%s" % "\n".join(invalid_ips) + # checking that parameter includes correct vm_type/network_role + parameter_checks = regx.get("parameter_to_resource_comparisons", []) + for check in parameter_checks: + resource_match = port_match.group(check) + if ( + resource_match + and not parameter.startswith(resource_match) + and parameter.find("_{}_".format(resource_match)) == -1 + ): + msg = ( + "{0} {1} property {2} parameter " + "{3} {4} does match resource {4} {5}" + ).format(resource_type, rid, properties, parameter, check, resource_match) + invalid_parameters.append(msg) + continue + + assert not invalid_parameters, "%s" % "\n".join(invalid_parameters) def get_list_of_ports_attached_to_nova_server(nova_server): |