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)
