Merge remote-tracking branch 'origin/develop' into workflow

Author: IharYakimush

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

@@ -0,0 +1,95 @@
+// Issue 33 : Recursive loop of complex types
+
+namespace Community.OData.Linq.xTests.Issues33
+{
+    using System;
+    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[]
+            {
+                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[]
+            {
+                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[]
+            {
+                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

@@ -140,6 +140,11 @@ public virtual IEnumerable<OperationConfiguration> Operations
             get { return this._operations; }
         }
 
+        /// <summary>
+        /// Gets/Sets the configured settings
+        /// </summary>
+        public ODataSettings ODataSettings { get; set; }
+
         /// <summary>
         /// Gets or sets the navigation property binding options.
         /// </summary>

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)
+            if (propertyInfo.PropertyType == this.ClrType && ModelBuilder?.ODataSettings?.AllowRecursiveLoopOfComplexTypes != true)
             {
                 throw Error.Argument("propertyInfo", SRResources.RecursiveComplexTypesNotAllowed, this.ClrType.FullName, propertyInfo.Name);
             }

Community.Data.OData.Linq/ODataSettings.cs

@@ -49,6 +49,8 @@ public static void SetInitializer(Action<ODataSettings> initializer)
 
         public bool EnableCaseInsensitive { get; set; } = true;
 
+        public bool AllowRecursiveLoopOfComplexTypes { get; set; } = false;
+
         public DefaultQuerySettings DefaultQuerySettings { get; } =
             new DefaultQuerySettings
             {

Community.Data.OData.Linq/OdataLinqExtensions.cs

@@ -54,13 +54,17 @@ public static ODataQuery<T> OData<T>(this IQueryable<T> query, Action<ODataSetti
         {
             if (query == null) throw new ArgumentNullException(nameof(query));
 
+            ODataSettings settings = new ODataSettings();
+            configuration?.Invoke(settings);
+
             if (edmModel == null)
             {
                 edmModel = Models.GetOrAdd(typeof(T), t =>
                 {
                     ODataConventionModelBuilder builder = new ODataConventionModelBuilder();
+                    builder.ODataSettings = settings;
                     builder.AddEntityType(t);
-                    builder.AddEntitySet(t.Name, new EntityTypeConfiguration(new ODataModelBuilder(), t));
+                    builder.AddEntitySet(t.Name, new EntityTypeConfiguration(builder, t));
                     return builder.GetEdmModel();
                 });
             }
@@ -72,14 +76,12 @@ public static ODataQuery<T> OData<T>(this IQueryable<T> query, Action<ODataSetti
                 }
             }
 
-            ODataSettings settings = new ODataSettings();
-            configuration?.Invoke(settings);
-
             int settingsHash = HashCode.Combine(
                 settings.QuerySettings, 
                 settings.DefaultQuerySettings, 
                 settings.ParserSettings.MaximumExpansionCount, 
-                settings.ParserSettings.MaximumExpansionDepth);
+                settings.ParserSettings.MaximumExpansionDepth,
+                settings.AllowRecursiveLoopOfComplexTypes);
 
             ServiceContainer baseContainer = Containers.GetOrAdd(settingsHash, i =>
             {