Issue 33 : Code adjustments + Unit tests

Author: FortuneN

Community.Data.OData.Linq.xTests/Issues/Issue33.cs

@@ -0,0 +1,97 @@
+// Recursive loop of complex types
+namespace Community.OData.Linq.xTests.Issues33
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Text;
+    using System.Linq;
+
+    using Xunit;
+
+    public class RecursiveComplexType
+    {
+        public RecursiveComplexType SelfReference { get; set; }
+    }
+
+    public class ListItem
+    {
+        public int Id { get; set; }
+
+        public RecursiveComplexType RecursiveComplexType { get; set; }
+    }
+
+    public class Issue33
+    {
+        [Fact]
+        public void Recursive_Loops_Must_Not_Be_Allowed_By_Default()
+        {
+            // arrange
+
+            var queryable = new List<ListItem>()
+            {
+                new ListItem { Id = 1, RecursiveComplexType = new() },
+                new ListItem { Id = 2, RecursiveComplexType = new() }
+            }.AsQueryable();
+
+            // act
+
+            var exception = Assert.Throws<ArgumentException>(() => queryable.OData().Filter("Id eq 1").ToArray());
+            
+            // assert
+
+            Assert.Contains("recursive loop of complex types is not allowed", exception.Message);
+        }
+
+        [Fact]
+        public void Recursive_Loops_Must_Be_Allowed_If_Opted_Into_By_Inline_Configuration()
+        {
+            // arrange
+
+            var queryable = new List<ListItem>()
+            {
+                new ListItem { Id = 1, RecursiveComplexType = new() },
+                new ListItem { Id = 2, RecursiveComplexType = new() }
+
+            }.AsQueryable();
+
+            // act
+
+            var result = queryable.OData(x =>
+            {
+                x.AllowRecursiveLoopOfComplexTypes = true;
+
+            }).Filter("Id eq 1").ToArray();
+
+            // assert
+
+            Assert.Single(result);
+        }
+
+        [Fact]
+        public void Recursive_Loops_Must_Be_Allowed_If_Opted_Into_By_Global_Configuration()
+        {
+            // arrange
+
+            var queryable = new List<ListItem>()
+            {
+                new ListItem { Id = 1, RecursiveComplexType = new() },
+                new ListItem { Id = 2, RecursiveComplexType = new() }
+
+            }.AsQueryable();
+
+            ODataSettings.SetInitializer(x =>
+            {
+                x.AllowRecursiveLoopOfComplexTypes = true;
+
+            });
+
+            // act
+
+            var result = queryable.OData().Filter("Id eq 1").ToArray();
+
+            // assert
+
+            Assert.Single(result);
+        }
+    }
+}

Community.Data.OData.Linq/Builder/ODataModelBuilder.cs

@@ -141,9 +141,9 @@ public virtual IEnumerable<OperationConfiguration> Operations
         }
 
         /// <summary>
-        /// Gets/Sets the ability to allow recursion of complex types
+        /// Gets/Sets the configured settings
         /// </summary>
-        public bool AllowRecursiveLoopOfComplexTypes { get; set; }
+        public ODataSettings ODataSettings { get; set; }
 
         /// <summary>
         /// Gets or sets the navigation property binding options.

Community.Data.OData.Linq/Builder/StructuralTypeConfiguration.cs

@@ -383,7 +383,7 @@ public virtual ComplexPropertyConfiguration AddComplexProperty(PropertyInfo prop
                 throw Error.Argument("propertyInfo", SRResources.PropertyDoesNotBelongToType, propertyInfo.Name, this.ClrType.FullName);
             }
 
-            if (propertyInfo.PropertyType == this.ClrType && ModelBuilder?.AllowRecursiveLoopOfComplexTypes != true)
+            if (propertyInfo.PropertyType == this.ClrType && ModelBuilder?.ODataSettings?.AllowRecursiveLoopOfComplexTypes != true)
             {
                 throw Error.Argument("propertyInfo", SRResources.RecursiveComplexTypesNotAllowed, this.ClrType.FullName, propertyInfo.Name);
             }

Community.Data.OData.Linq/OdataLinqExtensions.cs

@@ -62,8 +62,9 @@ public static ODataQuery<T> OData<T>(this IQueryable<T> query, Action<ODataSetti
                 edmModel = Models.GetOrAdd(typeof(T), t =>
                 {
                     ODataConventionModelBuilder builder = new ODataConventionModelBuilder();
+                    builder.ODataSettings = settings;
                     builder.AddEntityType(t);
-                    builder.AddEntitySet(t.Name, new EntityTypeConfiguration(new ODataModelBuilder { AllowRecursiveLoopOfComplexTypes = settings.AllowRecursiveLoopOfComplexTypes }, t));
+                    builder.AddEntitySet(t.Name, new EntityTypeConfiguration(builder, t));
                     return builder.GetEdmModel();
                 });
             }