def __init__(self, metadata_container, namespace_name, navigation_property_soup, qualifiers): """ :type metadata_container: cts_core.metadata.metadata_container.MetadataContainer :type namespace_name: str :type navigation_property_soup: bs4.element.Tag """ Property.__init__(self, metadata_container, namespace_name, navigation_property_soup, qualifiers) self.contains_target = navigation_property_soup.get(CONTAINS_TARGET, False)
def __init__(self, metadata_container, namespace_name, navigation_property_soup, qualifiers): """ :type metadata_container: cts_core.metadata.metadata_container.MetadataContainer :type namespace_name: str :type navigation_property_soup: bs4.element.Tag """ Property.__init__(self, metadata_container, namespace_name, navigation_property_soup, qualifiers) self.contains_target = navigation_property_soup.get( CONTAINS_TARGET, False)
def __init__(self, namespace_name, entity_soup): self.name = Commons.parse_type_name(entity_soup[NAME], namespace_name) try: self.base_type = Commons.parse_type_name(entity_soup[BASE_TYPE], namespace_name) except KeyError: # does not have base type (item?) self.base_type = None self.abstract = entity_soup.get(ABSTRACT, False) self.annotation = [ Annotation(annotation_soup) for annotation_soup in entity_soup.find_all(ANNOTATION, recursive=False) ] self.properties = [ Property(namespace_name, property_soup) for property_soup in entity_soup.find_all(PROPERTY, recursive=False) ] self.navigation_properties = [ NavigationProperty(namespace_name, navigation_property_soup) for navigation_property_soup in entity_soup.find_all( NAVIGATION_PROPERTY, recursive=False) ] self.additional_items = True self.set_additional_items()
def ad_hoc_type_definition(self, property_name, odata_type): raw_soup = """ <Property Name="{name}" Type="{type}"> </Property> """ soup = BeautifulSoup( raw_soup.format(name=property_name, type=odata_type), "lxml").find_all("property")[0] adhoc_description = Property(self._metadata_container, None, soup) return adhoc_description
def _validate_property_list(self, context, variable_path, property_list): """ :type context: Context :type variable_path: list [str or int] :type property_list: list[cts_core.metadata.model.property.Property] :rtype: str """ api_resource = context.api_resource status = ValidationStatus.PASSED # use local copy - api resource will be modified while test is executed local_property_list = list(property_list) for property_description in local_property_list: status = ValidationStatus.join_statuses( self._validate_property(context, variable_path, property_description), status) # validate additional properties try: body = api_resource.get_value_from_path(variable_path) except KeyError as key: cts_warning("Unable to access {odataid:id}->{path}. Key={key}", odataid=api_resource.odata_id, path="->".join(variable_path), key=key) body = None if body is not None: all_properties = set(body.keys()) known_properties = set( [property.name for property in local_property_list]) additional_properties = all_properties - known_properties for additional_property_name in additional_properties: property_value = body[additional_property_name] if isinstance(property_value, dict) and "@odata.type" in property_value: raw_soup = """ <Property Name="{name}" Type="{type}"> <Annotation Term="OData.Permissions" EnumMember="OData.Permission/ReadWrite"/> </Property> """ soup = BeautifulSoup( raw_soup.format(name=additional_property_name, type=get_odata_type(property_value)), "lxml").find_all("property")[0] adhoc_description = Property(self._metadata_container, None, soup) status = ValidationStatus.join_statuses( self._validate_property(context, variable_path, adhoc_description), status) return status
def test_property_nullable(self): property_doc = """ <Property name="property_name" type="property_type" nullable="true"/> """ property_soup = self._get_property_soup_from_property_text( property_doc) tested_property = Property(MetadataContainer(), "", property_soup) self.assertTrue(tested_property.nullable)
def __init__(self, namespace_name, action_soup): self.name = Commons.parse_type_name(action_soup["name"], namespace_name) try: self.is_bound = action_soup[IS_BOUND] == "true" except KeyError: self.is_bound = False self.properties = [Property(namespace_name, property_soup) for property_soup in action_soup.find_all(PROPERTY, recursive=False)] self.annotation = [Annotation(annotation_soup) for annotation_soup in action_soup.find_all(ANNOTATION, recursive=False)]
def test_property_required(self): property_doc = """ <Property name="property_name" type="property_type"> <Annotation Term="Redfish.Required" /> </Property> """ property_soup = self._get_property_soup_from_property_text( property_doc) tested_property = Property(MetadataContainer(), "", property_soup) self.assertTrue(tested_property.is_required)
def test_property_collection(self): property_doc = """ <Property name="property_name" type="Collection(property_type)"> <Annotation /> </Property> """ property_soup = self._get_property_soup_from_property_text( property_doc) tested_property = Property(MetadataContainer(), "", property_soup) self.assertTrue(tested_property.is_collection)
def test_property_annotation(self): property_doc = """ <Property name="property_name" type="property_type"> <Annotation /> </Property> """ property_soup = self._get_property_soup_from_property_text( property_doc) tested_property = Property(MetadataContainer(), "", property_soup) self.assertEqual(len(tested_property.annotations), 1)
def __init__(self, namespace_name, type_soup): Type.__init__(self, namespace_name, type_soup) try: self.base_type = Commons.parse_type_name(type_soup[BASE_TYPE], namespace_name) except KeyError: pass self.type = ValueTypesCategory.COMPLEX_TYPE self.properties = [Property(namespace_name, property_soup) for property_soup in type_soup.find_all(PROPERTY, recursive=False)] self.navigation_properties = [NavigationProperty(namespace_name, property_soup) for property_soup in type_soup.find_all(NAVIGATION_PROPERTY, recursive=False)] self.additional_items = True self.set_additional_items()
def __init__(self, metadata_container, namespace_name, type_soup, qualifiers=None): """ :type metadata_container: cts_core.metadata.metadata_container.MetadataContainer :type namespace_name: str :type type_soup: bs4.element.Tag """ MetadataType.__init__(self, metadata_container, namespace_name, type_soup, qualifiers) self.type_category = MetadataTypeCategories.COMPLEX_TYPE self.base_type = type_soup.get(BASE_TYPE, None) properties = [Property(self.metadata_container, namespace_name, property_soup, qualifiers) for property_soup in type_soup.find_all(PROPERTY, recursive=False)] self._properties = {prop.name: prop for prop in properties} navigation_properties = [NavigationProperty(self.metadata_container, namespace_name, navigation_property_soup, qualifiers) for navigation_property_soup in type_soup.find_all(NAVIGATION_PROPERTY, recursive=False)] self._navigation_properties = {navigation_property.name: navigation_property for navigation_property in navigation_properties}
def __init__(self, metadata_container, namespace_name, entity_soup, qualifiers=None): """ :type metadata_container: cts_core.metadata.metadata_container.MetadataContainer :type namespace_name: str :type entity_soup: bs4.element.Tag """ MetadataModel.__init__(self, metadata_container, entity_soup, qualifiers) self.name = Commons.parse_type_name(entity_soup[NAME], namespace_name) try: self.base_type = Commons.parse_type_name(entity_soup[BASE_TYPE], namespace_name) except KeyError: # does not have base type self.base_type = None self.abstract = entity_soup.get(ABSTRACT, False) properties = [ Property(self.metadata_container, namespace_name, property_soup, qualifiers) for property_soup in entity_soup.find_all(PROPERTY, recursive=False) ] self._properties = {prop.name: prop for prop in properties} navigation_properties = [ NavigationProperty(self.metadata_container, namespace_name, navigation_property_soup, qualifiers) for navigation_property_soup in entity_soup.find_all( NAVIGATION_PROPERTY, recursive=False) ] self._navigation_properties = { navigation_property.name: navigation_property for navigation_property in navigation_properties }
def test_empty_property(self): namespace_name = "namespace_name" property_name = "property_name" property_type = "property_type" property_doc = """ <Property name="{property_name}" type="{property_type}" /> """.format(property_name=property_name, property_type=property_type) property_soup = self._get_property_soup_from_property_text( property_doc) tested_property = Property(MetadataContainer(), namespace_name, property_soup) self.assertEqual(tested_property.name, property_name) self.assertEqual(tested_property.type, ".".join([namespace_name, property_type])) self.assertFalse(tested_property.is_collection) self.assertTrue(tested_property.nullable) self.assertFalse(tested_property.is_required) self.assertFalse(tested_property.annotations)
def __init__(self, namespace_name, property_soup): Property.__init__(self, namespace_name, property_soup) self.contains_target = property_soup.get(CONTAINS_TARGET, False)