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)