def test_empty_navigation_property(self):
namespace_name = "namespace_name"
navigation_property_name = "navigation_property_name"
navigation_property_type = "navigation_property_type"
navigation_property_doc = """
<NavigationProperty name="{navigation_property_name}" type="{navigation_property_type}" />
""".format(navigation_property_name=navigation_property_name,
navigation_property_type=navigation_property_type)
navigation_property_soup = self._get_navigation_property_soup_from_navigation_property_text(
navigation_property_doc)
tested_navigation_property = Property(MetadataContainer(),
namespace_name,
navigation_property_soup)
self.assertEqual(tested_navigation_property.name,
navigation_property_name)
self.assertEqual(tested_navigation_property.type,
".".join([namespace_name, navigation_property_type]))
self.assertFalse(tested_navigation_property.is_collection)
self.assertTrue(tested_navigation_property.nullable)
self.assertFalse(tested_navigation_property.is_required)
self.assertFalse(tested_navigation_property.annotations)
def setUp(self):
self.metadata_container = MetadataContainer()
base_enum_type_soup = self._get_enum_type_soup_from_enum_type_text("""
<EnumType name="{base_enum_type}">
<Member name="member1"/>
<Member name="member2"/>
</EnumType>
""".format(
base_enum_type=EnumMemberValidationUnitTest.BASE_ENUM_TYPE))
derived_enum_type_soup = self._get_enum_type_soup_from_enum_type_text(
"""
<EnumType name="{derived_enum_type}" BaseType="{base_enum_type}">
<Member name="member3"/>
</EnumType>
""".format(derived_enum_type=EnumMemberValidationUnitTest.
DERIVED_ENUM_TYPE,
base_enum_type=EnumMemberValidationUnitTest.BASE_ENUM_TYPE))
self.metadata_container.types[
EnumMemberValidationUnitTest.BASE_ENUM_TYPE] = EnumType(
self.metadata_container, "base", base_enum_type_soup)
self.metadata_container.types[
EnumMemberValidationUnitTest.DERIVED_ENUM_TYPE] = EnumType(
self.metadata_container, "derived", derived_enum_type_soup)
def setUp(self):
self.metadata_container = MetadataContainer()
type_definition_doc = """
<TypeDefinition name="{type_definition_name}" UnderlyingType="{base_type}" />
""".format(type_definition_name=TypeDefinitionValidationUnitTest.
TYPE_DEFINITION_NAME_EXISTING,
base_type=TypeDefinitionValidationUnitTest.UNDERLYING_TYPE)
self.metadata_container.types[
TypeDefinitionValidationUnitTest.
TYPE_DEFINITION_NAME_EXISTING] = TypeDefinition(
self.metadata_container, "type",
BeautifulSoup(type_definition_doc,
"lxml").find_all(TYPE_DEFINITION)[0])
type_definition_doc = """
<TypeDefinition name="{type_definition_name}" UnderlyingType="not_existing.type" />
""".format(
type_definition_name=TypeDefinitionValidationUnitTest.
TYPE_DEFINITION_NAME_EXISTING,
base_type=TypeDefinitionValidationUnitTest.UNDERLYING_TYPE)
self.metadata_container.types[
TypeDefinitionValidationUnitTest.
TYPE_DEFINITION_NAME_NOT_EXISTING] = TypeDefinition(
self.metadata_container, "type",
BeautifulSoup(type_definition_doc,
"lxml").find_all(TYPE_DEFINITION)[0])
def test_property_has_value_from_allowable_list(self):
enum_type_doc = """
<EnumType Name="ABCEnum">
<Member Name="A">
<Member Name="B"/>
<Member Name="C"/>
</EnumType>
"""
complex_type_doc = """
<ComplexType Name="complex_type">
<Property Name="abc" type="namespace.ABCEnum" />
</ComplexType>
"""
enum_soup = BeautifulSoup(enum_type_doc,
"lxml").find_all("enumtype")[0]
complex_soup = BeautifulSoup(complex_type_doc,
"lxml").find_all("complextype")[0]
metadata_container = MetadataContainer()
enum_type = EnumType(metadata_container, "namespace", enum_soup)
complex_type = ComplexType(metadata_container, "namespace",
complex_soup)
metadata_container.types[enum_type.name] = enum_type
metadata_container.types[complex_type.name] = complex_type
obj = {'abc': 'C', '*****@*****.**': ['C']}
self.assertEqual(ValidationStatus.PASSED,
complex_type.validate(obj, ""))
def __init__(self, qualifiers, ignore_types=None, map_types=None):
self.qualifiers = qualifiers
self.ignore_types = ignore_types if ignore_types is not None else set()
self.map_types = map_types if map_types is not None else dict()
self._metadata_container = MetadataContainer(ignore_types=self.ignore_types,
map_types=self.map_types)
self.loaded_xmls = set()
self.api_caller = None
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 test_base_type(self):
base_type = "base_type.base_type"
complex_type_doc = """
<ComplexType Name="complex_name_name" BaseType="{base_type}"/>
""".format(base_type=base_type)
complex_type_soup = self._get_complex_type_from_complex_type_text(
complex_type_doc)
complex_type = ComplexType(MetadataContainer(), "", complex_type_soup)
self.assertEqual(complex_type.base_type, base_type)
def test_entity_allow_additional_properties(self):
entity_doc = """
<EntityType Name="entity_name">
<Annotation Term="OData.AdditionalProperties" Bool="true"/>
</EntityType>
"""
entity_soup = self._get_entity_soup_from_entity_text(entity_doc)
entity = Entity(MetadataContainer(), "", entity_soup)
self.assertTrue(entity.allow_additional_properties)
def test_entity_navigation_property(self):
entity_doc = """
<EntityType Name="entity_name">
<NavigationProperty Name="property_name" type="property_type" />
</EntityType>
"""
entity_soup = self._get_entity_soup_from_entity_text(entity_doc)
entity = Entity(MetadataContainer(), "", entity_soup)
self.assertFalse(entity.properties)
self.assertEqual(len(entity.navigation_properties), 1)
def test_complex_name_allow_additional_properties(self):
complex_type_doc = """
<ComplexType Name="complex_name_name">
<Annotation Term="OData.AdditionalProperties" Bool="true"/>
</ComplexType>
"""
complex_type_soup = self._get_complex_type_from_complex_type_text(
complex_type_doc)
complex_type = ComplexType(MetadataContainer(), "", complex_type_soup)
self.assertTrue(complex_type.allow_additional_properties)
def test_navigation_property_nullable(self):
navigation_property_doc = """
<NavigationProperty name="navigation_property_name" type="navigation_property_type" nullable="true"/>
"""
navigation_property_soup = self._get_navigation_property_soup_from_navigation_property_text(
navigation_property_doc)
tested_navigation_property = Property(MetadataContainer(), "",
navigation_property_soup)
self.assertTrue(tested_navigation_property.nullable)
def test_complex_name_navigation_property(self):
complex_type_doc = """
<ComplexType Name="complex_type_name">
<NavigationProperty Name="property_name" type="property_type" />
</ComplexType>
"""
complex_type_doc = self._get_complex_type_from_complex_type_text(
complex_type_doc)
complex_type = ComplexType(MetadataContainer(), "", complex_type_doc)
self.assertFalse(complex_type.properties)
self.assertEqual(len(complex_type.navigation_properties), 1)
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_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 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_navigation_property_annotation(self):
navigation_property_doc = """
<NavigationProperty name="navigation_property_name" type="navigation_property_type">
<Annotation />
</NavigationProperty>
"""
navigation_property_soup = self._get_navigation_property_soup_from_navigation_property_text(
navigation_property_doc)
tested_navigation_property = Property(MetadataContainer(), "",
navigation_property_soup)
self.assertEqual(len(tested_navigation_property.annotations), 1)
def test_navigation_property_collection(self):
navigation_property_doc = """
<NavigationProperty name="navigation_property_name" type="Collection(navigation_property_type)">
<Annotation />
</NavigationProperty>
"""
navigation_property_soup = self._get_navigation_property_soup_from_navigation_property_text(
navigation_property_doc)
tested_navigation_property = Property(MetadataContainer(), "",
navigation_property_soup)
self.assertTrue(tested_navigation_property.is_collection)
def setUp(self):
base_complex_type_doc = """
<ComplexType Name="{base_complex_type}">
<Annotation Term="OData.AdditionalProperties" Bool="false"/>
<Property Name="property" type="{property_type}" />
<NavigationProperty Name="navigation_property" type="{navigation_property_type}" />
<Property Name="RequiredProperty" Nullable="false" Type="Edm.String">
<Annotation Term="OData.Permissions" EnumMember="OData.Permissions/Read"/>
<Annotation Term="OData.Description" String="Required property"/>
<Annotation Term="OData.LongDescription" String="This property is required"/>
<Annotation Term="Redfish.Required"/>
</Property>
</ComplexType>
""".format(
base_complex_type=ComplexTypeValidationUnitTest.BASE_COMPLEX_TYPE,
property_type=ComplexTypeValidationUnitTest.PROPERTY_TYPE,
navigation_property_type=ComplexTypeValidationUnitTest.
NAVIGATION_PROPERTY_TYPE)
derived_complex_type_doc = """
<ComplexType Name="{derived_complex_type}" BaseType="{base_complex_type}">
<Annotation Term="OData.AdditionalProperties" Bool="true"/>
</ComplexType>
""".format(
derived_complex_type=ComplexTypeValidationUnitTest.
DERIVED_COMPLEX_TYPE,
base_complex_type=ComplexTypeValidationUnitTest.BASE_COMPLEX_TYPE)
base_complex_type_soup = BeautifulSoup(
base_complex_type_doc, "lxml").find_all(COMPLEX_TYPE)[0]
derived_complex_type_soup = BeautifulSoup(
derived_complex_type_doc, "lxml").find_all(COMPLEX_TYPE)[0]
self.metadata_container = MetadataContainer()
base_complex_type = ComplexType(self.metadata_container, "base",
base_complex_type_soup)
derived_complex_type = ComplexType(self.metadata_container, "derived",
derived_complex_type_soup)
self.metadata_container.types[
derived_complex_type.name] = derived_complex_type
self.metadata_container.types[
base_complex_type.name] = base_complex_type
self.metadata_container.types[
ComplexTypeValidationUnitTest.PROPERTY_TYPE] = MagicMock()
self.metadata_container.types[
ComplexTypeValidationUnitTest.PROPERTY_TYPE].validate = Mock(
return_value=ValidationStatus.PASSED)
def test_annotation_given(self):
namespace_name = "namespace_name"
metadata_type_name = "metadata_type_name"
metadata_type_doc = """
<tag name="{metadata_type_name}">
<Annotation />
</tag>
""".format(metadata_type_name=metadata_type_name)
metadata_type_soup = self._get_metadata_type_soup_from_metadata_type_text(
metadata_type_doc)
metadata_type = MetadataType(MetadataContainer(), namespace_name,
metadata_type_soup)
self.assertEqual(len(metadata_type.annotations), 1)
def test_empty_entity(self):
namespace_name = "namespace_name"
entity_name = "entity_name"
entity_doc = """
<EntityType Name="{entity_name}" />
""".format(entity_name=entity_name)
entity_soup = self._get_entity_soup_from_entity_text(entity_doc)
entity = Entity(MetadataContainer(), namespace_name, entity_soup)
self.assertEqual(entity.name, ".".join([namespace_name, entity_name]))
self.assertTrue(entity.allow_additional_properties)
self.assertIsNone(entity.base_type)
self.assertFalse(entity.abstract)
self.assertFalse(entity.annotations)
self.assertFalse(entity.properties)
self.assertFalse(entity.navigation_properties)
def test_annotations_with_my_qualifiers_are_not_filtered_out(self):
namespace_name = "namespace_name"
metadata_type_name = "metadata_type_name"
metadata_type_doc = """
<tag name="{metadata_type_name}">
<Annotation Term="OData.Permissions" EnumMember="OData.Permission/Read" Qualifier="A"/>
<Annotation Term="OData.Description" String="This indicates drive firmware version."/>
</tag>
""".format(metadata_type_name=metadata_type_name)
metadata_type_soup = self._get_metadata_type_soup_from_metadata_type_text(
metadata_type_doc)
metadata_type = MetadataType(MetadataContainer(), namespace_name,
metadata_type_soup, ["A", "B"])
self.assertEqual(len(metadata_type.annotations), 2)
def test_annotation_given(self):
base_type = "base_namespace.base_type"
namespace_name = "namespace_name"
type_definition_name = "type_definition_name"
type_definition_doc = """
<TypeDefinition name="{type_definition_name}" UnderlyingType="{base_type}">
<Annotation />
</TypeDefinition>
""".format(type_definition_name=type_definition_name,
base_type=base_type)
type_definition_soup = self._get_type_definition_soup_from_type_definition_text(
type_definition_doc)
type_definition = TypeDefinition(MetadataContainer(), namespace_name,
type_definition_soup)
self.assertEqual(len(type_definition.annotations), 1)
def test_empty_metadata_type(self):
namespace_name = "namespace_name"
metadata_type_name = "metadata_type_name"
metadata_type_doc = """
<tag name="{metadata_type_name}"/>
""".format(metadata_type_name=metadata_type_name)
metadata_type_soup = self._get_metadata_type_soup_from_metadata_type_text(
metadata_type_doc)
metadata_type = MetadataType(MetadataContainer(), namespace_name,
metadata_type_soup)
self.assertEqual(metadata_type.name,
".".join([namespace_name, metadata_type_name]))
self.assertFalse(metadata_type.annotations)
self.assertIsNone(metadata_type.base_type)
self.assertIsNone(metadata_type.type_category)
def test_members_given(self):
namespace_name = "namespace_name"
enum_type_name = "enum_type_name"
enum_type_doc = """
<EnumType name="{enum_type_name}">
<Member name="member1"/>
<Member name="member2"/>
</EnumType>
""".format(enum_type_name=enum_type_name)
enum_type_soup = self._get_enum_type_soup_from_enum_type_text(
enum_type_doc)
enum_type = EnumType(MetadataContainer(), namespace_name,
enum_type_soup)
self.assertEqual(len(enum_type.members), 2)
self.assertIn("member1", enum_type.members)
self.assertIn("member2", enum_type.members)
def test_empty_enum_type(self):
namespace_name = "namespace_name"
enum_type_name = "enum_type_name"
enum_type_doc = """
<EnumType name="{enum_type_name}"/>
""".format(enum_type_name=enum_type_name)
enum_type_soup = self._get_enum_type_soup_from_enum_type_text(
enum_type_doc)
enum_type = EnumType(MetadataContainer(), namespace_name,
enum_type_soup)
self.assertEqual(enum_type.name,
".".join([namespace_name, enum_type_name]))
self.assertFalse(enum_type.annotations)
self.assertIsNone(enum_type.base_type)
self.assertEqual(enum_type.type_category,
MetadataTypeCategories.ENUM_TYPE)
self.assertFalse(enum_type.members)
def test_empty_type_definition(self):
namespace_name = "namespace_name"
type_definition_name = "type_definition_name"
base_type = "base_namespace.base_type"
type_definition_doc = """
<TypeDefinition name="{type_definition_name}" UnderlyingType="{base_type}" />
""".format(type_definition_name=type_definition_name,
base_type=base_type)
type_definition_soup = self._get_type_definition_soup_from_type_definition_text(
type_definition_doc)
type_definition = TypeDefinition(MetadataContainer(), namespace_name,
type_definition_soup)
self.assertEqual(type_definition.name,
".".join([namespace_name, type_definition_name]))
self.assertFalse(type_definition.annotations)
self.assertEqual(type_definition.base_type, base_type)
self.assertEqual(type_definition.type_category,
MetadataTypeCategories.TYPE_DEFINITION)
def test_empty_complex_name(self):
namespace_name = "namespace_name"
complex_type_name = "complex_type_name"
complex_type_doc = """
<ComplexType Name="{complex_type_name}" />
""".format(complex_type_name=complex_type_name)
complex_type_soup = self._get_complex_type_from_complex_type_text(
complex_type_doc)
complex_type = ComplexType(MetadataContainer(), namespace_name,
complex_type_soup)
self.assertEqual(complex_type.name,
".".join([namespace_name, complex_type_name]))
self.assertTrue(complex_type.allow_additional_properties)
self.assertEqual(complex_type.type_category,
MetadataTypeCategories.COMPLEX_TYPE)
self.assertIsNone(complex_type.base_type)
self.assertFalse(complex_type.annotations)
self.assertFalse(complex_type.properties)
self.assertFalse(complex_type.navigation_properties)
