Remove enum type from OData V2

Despite implementing enum for V2 the first mention of enum in
specification is only in later versions of OData. Thus, it should not be
possible to parse enum using V2 parser.

Author: mamiksik

pyodata/v2/__init__.py

@@ -11,9 +11,8 @@
 
 from pyodata.v2.elements import NavigationTypeProperty, EndRole, Association, AssociationSetEndRole, AssociationSet, \
     ReferentialConstraint, Schema
-from pyodata.model.elements import StructTypeProperty, StructType, ComplexType, EntityType, \
-    EnumType, EntitySet, ExternalAnnotation, Annotation, ValueHelper, ValueHelperParameter, \
-    FunctionImport, Typ
+from pyodata.model.elements import StructTypeProperty, StructType, ComplexType, EntityType, EntitySet, \
+    ExternalAnnotation, Annotation, ValueHelper, ValueHelperParameter, FunctionImport, Typ
 
 
 import pyodata.v2.build_functions as build_functions_v2
@@ -36,7 +35,6 @@ def build_functions():
             NavigationTypeProperty: build_functions_v2.build_navigation_type_property,
             ComplexType: build_functions.build_complex_type,
             EntityType: build_functions.build_entity_type,
-            EnumType: build_functions.build_enum_type,
             EntitySet: build_functions.build_entity_set,
             EndRole: build_functions_v2.build_end_role,
             ReferentialConstraint: build_functions_v2.build_referential_constraint,

pyodata/v2/build_functions.py

@@ -9,8 +9,8 @@
 
 from pyodata.config import Config
 from pyodata.exceptions import PyODataParserError, PyODataModelError
-from pyodata.model.elements import EntityType, ComplexType, EnumType, NullType, build_element, \
-    EntitySet, FunctionImport, ExternalAnnotation, Annotation, Typ, Identifier, Types
+from pyodata.model.elements import EntityType, ComplexType, NullType, build_element, EntitySet, FunctionImport, \
+    ExternalAnnotation, Annotation, Typ, Identifier, Types
 from pyodata.policies import ParserError
 from pyodata.v2.elements import AssociationSetEndRole, Association, AssociationSet, NavigationTypeProperty, EndRole, \
     Schema, NullAssociation, ReferentialConstraint, PrincipalRole, DependentRole
@@ -37,15 +37,6 @@ def build_schema(config: Config, schema_nodes):
         decl = Schema.Declaration(namespace)
         schema._decls[namespace] = decl
 
-        for enum_type in schema_node.xpath('edm:EnumType', namespaces=config.namespaces):
-            try:
-                etype = build_element(EnumType, config, type_node=enum_type, namespace=namespace)
-            except (PyODataParserError, AttributeError) as ex:
-                config.err_policy(ParserError.ENUM_TYPE).resolve(ex)
-                etype = NullType(enum_type.get('Name'))
-
-            decl.add_enum_type(etype)
-
         for complex_type in schema_node.xpath('edm:ComplexType', namespaces=config.namespaces):
             try:
                 ctype = build_element(ComplexType, config, type_node=complex_type)

tests/metadata.xml

@@ -114,23 +114,6 @@
                 <Property Name="Number" Type="Edm.String" Nullable="false"/>
                 <Property Name="Owner" Type="Edm.String" Nullable="false"/>
             </EntityType>
-
-            <EntityType Name="EnumTest">
-                <Property Name="CountryOfOrigin" Type="Country"/>
-            </EntityType>
-
-            <EnumType Name="Country" UnderlyingType="Edm.Int32">
-                <Member Name="USA"/>
-                <Member Name="China"/>
-                <Member Name="Slovakia"/>
-            </EnumType>
-
-            <EnumType Name="Language" UnderlyingType="Edm.Int32" IsFlags="True">
-                <Member Name="English"/>
-                <Member Name="Czech"/>
-                <Member Name="Japanese"/>
-            </EnumType>
-
             <ComplexType Name="ComplexNumber">
                 <Property Name="Real" Type="Edm.Double" Nullable="false"/>
                 <Property Name="Imaginary" Type="Edm.Double" Nullable="false"/>
@@ -201,7 +184,6 @@
                            sap:topable="true"/>
                 <EntitySet Name="CarIDPics" EntityType="EXAMPLE_SRV.CarIDPic" sap:countable="false" sap:pageable="false"
                            sap:topable="false"/>
-                <EntitySet Name="EnumTests" EntityType="EXAMPLE_SRV.EnumTest" />
                 <FunctionImport Name="retrieve" ReturnType="Edm.Boolean" EntitySet="MasterEntities" m:HttpMethod="GET"
                                 sap:action-for="EXAMPLE_SRV.MasterEntity">
                     <Parameter Name="Param" Type="Edm.String" Mode="In" MaxLenght="5"/>

tests/metadata_v4.xml

@@ -148,6 +148,19 @@
               </Key>
               <Property Name="ID" Type="Edm.String" Nullable="false" />
             </EntityType>
+            <EntityType Name="EnumTest">
+                <Property Name="CountryOfOrigin" Type="Country"/>
+            </EntityType>
+            <EnumType Name="Country" UnderlyingType="Edm.Int32">
+                <Member Name="USA"/>
+                <Member Name="China"/>
+                <Member Name="Slovakia"/>
+            </EnumType>
+            <EnumType Name="Language" UnderlyingType="Edm.Int32" IsFlags="True">
+                <Member Name="English"/>
+                <Member Name="Czech"/>
+                <Member Name="Japanese"/>
+            </EnumType>
             <Function Name="GetFavoriteAirline" IsBound="true" EntitySetPath="person/Trips/PlanItems/Microsoft.OData.SampleService.Models.TripPin.Flight/Airline" IsComposable="true">
                 <Parameter Name="person" Type="Microsoft.OData.SampleService.Models.TripPin.Person" Nullable="false" />
                 <ReturnType Type="Microsoft.OData.SampleService.Models.TripPin.Airline" Nullable="false" />
@@ -173,6 +186,7 @@
                 <Parameter Name="tripId" Type="Edm.Int32" Nullable="false" />
             </Action>
             <EntityContainer Name="DefaultContainer">
+                <EntitySet Name="EnumTests" EntityType="Microsoft.OData.SampleService.Models.TripPin.EnumTest" />
                 <EntitySet Name="Photos" EntityType="Microsoft.OData.SampleService.Models.TripPin.Photo">
                     <Annotation Term="Org.OData.Core.V1.ResourcePath" String="Photos" />
                     <Annotation Term="Org.OData.Capabilities.V1.SearchRestrictions">

tests/test_model_v2.py

@@ -35,7 +35,6 @@ def test_edmx(schema):
         'CarIDPic',
         'Customer',
         'Order',
-        'EnumTest'
     }
 
     assert set((entity_set.name for entity_set in schema.entity_sets)) == {
@@ -51,12 +50,6 @@ def test_edmx(schema):
         'CarIDPics',
         'Customers',
         'Orders',
-        'EnumTests'
-    }
-
-    assert set((enum_type.name for enum_type in schema.enum_types)) == {
-        'Country',
-        'Language'
     }
 
     master_entity = schema.entity_type('MasterEntity')
@@ -879,8 +872,6 @@ def test_null_type(xml_builder_factory):
             <Property Name="Key" Type="Edm.UnknownType" />
         </EntityType>
         
-        <EnumType Name="MasterEnum" UnderlyingType="Edm.String" />
-        
          <ComplexType Name="MasterComplex">
                 <Property Name="Width" Type="Edm.Double" />
                 <Property Name="Width" Type="Edm.Double" />
@@ -903,8 +894,6 @@ def test_null_type(xml_builder_factory):
     type_info = TypeInfo(namespace=None, name='MasterProperty', is_collection=False)
     assert isinstance(schema.get_type(type_info).proprty('Key').typ, NullType)
 
-    type_info = TypeInfo(namespace=None, name='MasterEnum', is_collection=False)
-    assert isinstance(schema.get_type(type_info), NullType)
 
     type_info = TypeInfo(namespace=None, name='MasterComplex', is_collection=False)
     assert isinstance(schema.get_type(type_info), NullType)
@@ -1175,77 +1164,6 @@ def test_whitelisted_edm_namespace_2007_05(mocked, xml_builder_factory):
     mocked.assert_called_once()
 
 
-def test_enum_parsing(schema):
-    """Test correct parsing of enum"""
-
-    country = schema.enum_type('Country').USA
-    assert str(country) == "Country'USA'"
-
-    country2 = schema.enum_type('Country')['USA']
-    assert str(country2) == "Country'USA'"
-
-    try:
-        schema.enum_type('Country').Cyprus
-    except PyODataException as ex:
-        assert str(ex) == f'EnumType EnumType(Country) has no member Cyprus'
-
-    c = schema.enum_type('Country')[1]
-    assert str(c) == "Country'China'"
-
-    try:
-        schema.enum_type('Country')[15]
-    except PyODataException as ex:
-        assert str(ex) == f'EnumType EnumType(Country) has no member with value {15}'
-
-    type_info = TypeInfo(namespace=None, name='Country', is_collection=False)
-
-    try:
-        schema.get_type(type_info)
-    except PyODataModelError as ex:
-        assert str(ex) == f'Neither primitive types nor types parsed from service metadata contain requested type {type_info[0]}'
-
-    language = schema.enum_type('Language')
-    assert language.is_flags is True
-
-    try:
-        schema.enum_type('ThisEnumDoesNotExist')
-    except KeyError as ex:
-        assert str(ex) == f'\'EnumType ThisEnumDoesNotExist does not exist in any Schema Namespace\''
-
-    try:
-        schema.enum_type('Country', 'WrongNamespace').USA
-    except KeyError as ex:
-        assert str(ex) == '\'EnumType Country does not exist in Schema Namespace WrongNamespace\''
-
-
-def test_unsupported_enum_underlying_type(xml_builder_factory):
-    """Test if parser will parse only allowed underlying types"""
-    xml_builder = xml_builder_factory()
-    xml_builder.add_schema('Test', '<EnumType Name="UnsupportedEnumType" UnderlyingType="Edm.Bool" />')
-    xml = xml_builder.serialize()
-
-    try:
-        MetadataBuilder(xml).build()
-    except PyODataParserError as ex:
-        assert str(ex).startswith(f'Type Edm.Bool is not valid as underlying type for EnumType - must be one of')
-
-
-def test_enum_value_out_of_range(xml_builder_factory):
-    """Test if parser will check for values ot of range defined by underlying type"""
-    xml_builder = xml_builder_factory()
-    xml_builder.add_schema('Test', """
-        <EnumType Name="Num" UnderlyingType="Edm.Byte">
-            <Member Name="TooBig" Value="-130" />
-        </EnumType>
-        """)
-    xml = xml_builder.serialize()
-
-    try:
-        MetadataBuilder(xml).build()
-    except BaseException as ex:
-        assert str(ex) == f'Value -130 is out of range for type Edm.Byte'
-
-
 @patch('logging.Logger.warning')
 def test_missing_property_referenced_in_annotation(mock_warning, xml_builder_factory):
     """Test that correct behavior when non existing property is referenced in annotation"""

tests/test_model_v4.py

@@ -3,10 +3,11 @@
 import geojson
 import pytest
 
+from pyodata.policies import PolicyIgnore
 from pyodata.model.builder import MetadataBuilder
-from pyodata.exceptions import PyODataModelError
+from pyodata.exceptions import PyODataModelError, PyODataException, PyODataParserError
 from pyodata.model.type_traits import TypTraits
-from pyodata.model.elements import Types
+from pyodata.model.elements import Types, TypeInfo, NullType
 
 from pyodata.config import Config
 from pyodata.v4 import ODataV4
@@ -172,3 +173,93 @@ def test_referential_constraint(schema_v4):
     assert repr(nav_property.referential_constraints[0]) == \
         'ReferentialConstraint(StructTypeProperty(CategoryID), StructTypeProperty(ID))'
 
+
+def test_enum_parsing(schema_v4):
+    """Test correct parsing of enum"""
+
+    country = schema_v4.enum_type('Country').USA
+    assert str(country) == "Country'USA'"
+
+    country2 = schema_v4.enum_type('Country')['USA']
+    assert str(country2) == "Country'USA'"
+
+    try:
+        schema_v4.enum_type('Country').Cyprus
+    except PyODataException as ex:
+        assert str(ex) == f'EnumType EnumType(Country) has no member Cyprus'
+
+    c = schema_v4.enum_type('Country')[1]
+    assert str(c) == "Country'China'"
+
+    try:
+        schema_v4.enum_type('Country')[15]
+    except PyODataException as ex:
+        assert str(ex) == f'EnumType EnumType(Country) has no member with value {15}'
+
+    type_info = TypeInfo(namespace=None, name='Country', is_collection=False)
+
+    try:
+        schema_v4.get_type(type_info)
+    except PyODataModelError as ex:
+        assert str(ex) == f'Neither primitive types nor types parsed from service metadata contain requested type {type_info[0]}'
+
+    language = schema_v4.enum_type('Language')
+    assert language.is_flags is True
+
+    try:
+        schema_v4.enum_type('ThisEnumDoesNotExist')
+    except KeyError as ex:
+        assert str(ex) == f'\'EnumType ThisEnumDoesNotExist does not exist in any Schema Namespace\''
+
+    try:
+        schema_v4.enum_type('Country', 'WrongNamespace').USA
+    except KeyError as ex:
+        assert str(ex) == '\'EnumType Country does not exist in Schema Namespace WrongNamespace\''
+
+
+def test_unsupported_enum_underlying_type(xml_builder_factory):
+    """Test if parser will parse only allowed underlying types"""
+    xml_builder = xml_builder_factory()
+    xml_builder.add_schema('Test', '<EnumType Name="UnsupportedEnumType" UnderlyingType="Edm.Bool" />')
+    xml = xml_builder.serialize()
+
+    try:
+        MetadataBuilder(xml, Config(ODataV4)).build()
+    except PyODataParserError as ex:
+        assert str(ex).startswith(f'Type Edm.Bool is not valid as underlying type for EnumType - must be one of')
+
+
+def test_enum_value_out_of_range(xml_builder_factory):
+    """Test if parser will check for values ot of range defined by underlying type"""
+    xml_builder = xml_builder_factory()
+    xml_builder.add_schema('Test', """
+        <EnumType Name="Num" UnderlyingType="Edm.Byte">
+            <Member Name="TooBig" Value="-130" />
+        </EnumType>
+        """)
+    xml = xml_builder.serialize()
+
+    try:
+        MetadataBuilder(xml, Config(ODataV4)).build()
+    except BaseException as ex:
+        assert str(ex) == f'Value -130 is out of range for type Edm.Byte'
+
+
+def test_enum_null_type(xml_builder_factory):
+    """ Test NullType being correctly assigned to invalid types"""
+    xml_builder = xml_builder_factory()
+    xml_builder.add_schema('TEST.NAMESPACE', """
+        <EnumType Name="MasterEnum" UnderlyingType="Edm.String" />
+    """)
+
+    metadata = MetadataBuilder(
+        xml_builder.serialize(),
+        config=Config(
+            ODataV4,
+            default_error_policy=PolicyIgnore()
+        ))
+
+    schema = metadata.build()
+
+    type_info = TypeInfo(namespace=None, name='MasterEnum', is_collection=False)
+    assert isinstance(schema.get_type(type_info), NullType)

tests/test_service_v2.py

@@ -86,32 +86,6 @@ def test_create_entity_code_400(service):
     assert str(e_info.value).startswith('HTTP POST for Entity Set')
 
 
-@responses.activate
-def test_create_entity_containing_enum(service):
-    """Basic test on creating entity with enum"""
-
-    # pylint: disable=redefined-outer-name
-
-    responses.add(
-        responses.POST,
-        "{0}/EnumTests".format(service.url),
-        headers={'Content-type': 'application/json'},
-        json={'d': {
-            'CountryOfOrigin': 'USA',
-        }},
-        status=201)
-
-    result = service.entity_sets.EnumTests.create_entity().set(**{'CountryOfOrigin': 'USA'}).execute()
-
-    USA = service.schema.enum_type('Country').USA
-    assert result.CountryOfOrigin == USA
-
-    traits = service.schema.enum_type('Country').traits
-    literal = traits.to_literal(USA)
-
-    assert literal == "EXAMPLE_SRV.Country\'USA\'"
-    assert traits.from_literal(literal).name == 'USA'
-
 @responses.activate
 def test_create_entity_nested(service):
     """Basic test on creating entity"""