Add test for maxRecursion on PutMappingDescriptor

Author: gmarz

src/Tests/ClientConcepts/HighLevel/Mapping/AutoMap.doc.cs

@@ -7,7 +7,7 @@
 using static Tests.Framework.RoundTripper;
 
 namespace Tests.ClientConcepts.HighLevel.Mapping
-{
+{
 	/** # Auto mapping properties
 	 * 
 	 * When creating a mapping (either when creating an index or via the put mapping API),
@@ -16,14 +16,14 @@ namespace Tests.ClientConcepts.HighLevel.Mapping
 	 * you're using attributes to map your properties, then calling AutoMap() is required
 	 * in order for your attributes to be applied.  We'll look at examples of both.
 	 *
-	**/
+	**/
 	public class AutoMap
-	{
+	{
 		/**
 		* For these examples, we'll define two POCOS.  A Company, which has a name
 		* and a collection of Employees.  And Employee, which has various properties of 
 		* different types, and itself has a collection of Employees. 
-		*/
+		*/
 		public class Company
 		{
 			public string Name { get; set; }
@@ -38,16 +38,16 @@ public class Employee
 			public DateTime Birthday { get; set; }
 			public bool IsManager { get; set; }
 			public List<Employee> Employees { get; set; }
-			public TimeSpan Hours { get; set;}
+			public TimeSpan Hours { get; set; }
 		}
 
 		[U]
 		public void MappingManually()
-		{
+		{
 			/** ## Manual mapping
 			 * To create a mapping for our Company type, we can use the fluent API
 			 * and map each property explicitly
-			 */
+			 */
 			var descriptor = new CreateIndexDescriptor("myindex")
 				.Mappings(ms => ms
 					.Map<Company>(m => m
@@ -72,13 +72,13 @@ public void MappingManually()
 							)
 						)
 					)
-				);
-
+				);
+
 			/**
 			 * Which is all fine and dandy, and useful for some use cases. However in most cases
 			 * this is becomes too cumbersome of an approach, and you simply just want to map *all*
 			 * the properties of your POCO in a single go.
-			 */
+			 */
 			var expected = new
 			{
 				mappings = new
@@ -115,22 +115,22 @@ public void MappingManually()
 				}
 			};
 
-			Expect(expected).WhenSerializing((ICreateIndexRequest) descriptor);
+			Expect(expected).WhenSerializing((ICreateIndexRequest)descriptor);
 		}
 
 		[U]
 		public void UsingAutoMap()
-		{
+		{
 			/** ## Simple Automapping
 			* This is exactly where `AutoMap()` becomes useful. Instead of manually mapping each property, 
 			* explicitly, we can instead call `.AutoMap()` for each of our mappings and let NEST do all the work
-			*/
+			*/
 			var descriptor = new CreateIndexDescriptor("myindex")
 				.Mappings(ms => ms
 					.Map<Company>(m => m.AutoMap())
 					.Map<Employee>(m => m.AutoMap())
-				);
-
+				);
+
 			/**
 			* Observe that NEST has inferred the Elasticsearch types based on the CLR type of our POCO properties.  
 			* In this example, 
@@ -140,7 +140,7 @@ public void UsingAutoMap()
 			* - Salary as an integer 
 			* - Employees as an object
 			* and the remaining string properties as strings.
-			*/
+			*/
 			var expected = new
 			{
 				mappings = new
@@ -168,7 +168,7 @@ public void UsingAutoMap()
 									},
 									hours = new
 									{
-										type = "long" 
+										type = "long"
 									},
 									isManager = new
 									{
@@ -229,30 +229,31 @@ public void UsingAutoMap()
 				}
 			};
 
-			Expect(expected).WhenSerializing((ICreateIndexRequest) descriptor);
-		}
-
+			Expect(expected).WhenSerializing((ICreateIndexRequest)descriptor);
+		}
+
 		/** ## Automapping with overrides
 		* In most cases, you'll want to map more than just the vanilla datatypes and also provide
 		* various options on your properties (analyzer, doc_values, etc...).  In that case, it's
 		* possible to use AutoMap() in conjuction with explicitly mapped properties.  
-		*/
-		[U] public void OverridingAutoMappedProperties()
-		{
+		*/
+		[U]
+		public void OverridingAutoMappedProperties()
+		{
 			/**
 			* Here we are using AutoMap() to automatically map our company type, but then we're
 			* overriding our employee property and making it a `nested` type, since by default,
 			* AutoMap() will infer objects as `object`.
-			*/
+			*/
 			var descriptor = new CreateIndexDescriptor("myindex")
 				.Mappings(ms => ms
 					.Map<Company>(m => m
 						.AutoMap()
 						.Properties(ps => ps
 							.Nested<Employee>(n => n
 								.Name(c => c.Employees)
-								.Properties(eps => eps
-									// snip
+								.Properties(eps => eps
+								// snip
 								)
 							)
 						)
@@ -274,21 +275,21 @@ [U] public void OverridingAutoMappedProperties()
 							employees = new
 							{
 								type = "nested",
-								properties = new {}
+								properties = new { }
 							}
 						}
 					}
 				}
 			};
 
-			Expect(expected).WhenSerializing((ICreateIndexRequest) descriptor);
-		}
-
+			Expect(expected).WhenSerializing((ICreateIndexRequest)descriptor);
+		}
+
 		/** ## Automap with attributes
 		 * It is also possible to define your mappings using attributes on your POCOS.  When you
 		 * use attributes, you MUST use AutoMap() in order for the attributes to be applied.
 		 * Here we define the same two types but this time using attributes.
-		 */
+		 */
 		[ElasticsearchType(Name = "company")]
 		public class CompanyWithAttributes
 		{
@@ -467,13 +468,13 @@ public void UsingAutoMapWithAttributes()
 			};
 
 			Expect(expected).WhenSerializing(descriptor as ICreateIndexRequest);
-		}
-
+		}
+
 		/**
 		 * Just as we were able to override the inferred properties in our earlier example, explicit (manual)
 		 * mappings also take precedence over attributes.  Therefore we can also override any mappings applied
 		 * via any attributes defined on the POCO
-		 */
+		 */
 		[U]
 		public void OverridingAutoMappedAttributes()
 		{
@@ -492,7 +493,7 @@ public void OverridingAutoMappedAttributes()
 						.TtlField(ttl => ttl
 							.Enable()
 							.Default("10m")
-						)							
+						)
 						.Properties(ps => ps
 							.String(s => s
 								.Name(e => e.FirstName)
@@ -633,7 +634,7 @@ public void OverridingAutoMappedAttributes()
 				}
 			};
 
-			Expect(expected).WhenSerializing((ICreateIndexRequest) descriptor);
+			Expect(expected).WhenSerializing((ICreateIndexRequest)descriptor);
 		}
 
 		[ElasticsearchType(Name = "company")]
@@ -699,7 +700,7 @@ public void IgnoringProperties()
 				)
 			);
 
-			settings.Expect(expected).WhenSerializing((ICreateIndexRequest) descriptor);
+			settings.Expect(expected).WhenSerializing((ICreateIndexRequest)descriptor);
 		}
 
 		/**
@@ -722,14 +723,14 @@ public class A
 
 		[U]
 		public void ControllingRecursionDepth()
-		{
-			/** By default, AutoMap() only goes as far as depth 1 */
+		{
+			/** By default, AutoMap() only goes as far as depth 1 */
 			var descriptor = new CreateIndexDescriptor("myindex")
 				.Mappings(ms => ms
 					.Map<A>(m => m.AutoMap())
-				);
-
-			/** Thus we do not map properties on the second occurrence of our Child property */
+				);
+
+			/** Thus we do not map properties on the second occurrence of our Child property */
 			var expected = new
 			{
 				mappings = new
@@ -748,15 +749,15 @@ public void ControllingRecursionDepth()
 				}
 			};
 
-			Expect(expected).WhenSerializing((ICreateIndexRequest) descriptor);
-
-			/** Now lets specify a maxRecursion of 3 */
+			Expect(expected).WhenSerializing((ICreateIndexRequest)descriptor);
+
+			/** Now lets specify a maxRecursion of 3 */
 			var withMaxRecursionDescriptor = new CreateIndexDescriptor("myindex")
 				.Mappings(ms => ms
 					.Map<A>(m => m.AutoMap(3))
-				);
-
-			/** AutoMap() has now mapped three levels of our Child property */
+				);
+
+			/** AutoMap() has now mapped three levels of our Child property */
 			var expectedWithMaxRecursion = new
 			{
 				mappings = new
@@ -796,9 +797,68 @@ public void ControllingRecursionDepth()
 				}
 			};
 
-			Expect(expectedWithMaxRecursion).WhenSerializing((ICreateIndexRequest) withMaxRecursionDescriptor);
+			Expect(expectedWithMaxRecursion).WhenSerializing((ICreateIndexRequest)withMaxRecursionDescriptor);
 		}
 
+		[U]
+		//hide
+		public void PutMappingAlsoAdheresToMaxRecursion()
+		{
+			var descriptor = new PutMappingDescriptor<A>().AutoMap();
+
+			var expected = new
+			{
+				properties = new
+				{
+					child = new
+					{
+						properties = new { },
+						type = "object"
+					}
+				}
+			};
+
+			Expect(expected).WhenSerializing((IPutMappingRequest)descriptor);
+
+			var withMaxRecursionDescriptor = new PutMappingDescriptor<A>().AutoMap(3);
+
+			var expectedWithMaxRecursion = new
+			{
+				properties = new
+				{
+					child = new
+					{
+						type = "object",
+						properties = new
+						{
+							child = new
+							{
+								type = "object",
+								properties = new
+								{
+									child = new
+									{
+										type = "object",
+										properties = new
+										{
+											child = new
+											{
+												type = "object",
+												properties = new { }
+											}
+										}
+									}
+								}
+							}
+						}
+					}
+				}
+			};
+
+			Expect(expectedWithMaxRecursion).WhenSerializing((IPutMappingRequest)withMaxRecursionDescriptor);
+		}
+		//endhide
+
 		/** # Applying conventions through the Visitor pattern
 		 * It is also possible to apply a transformation on all or specific properties.
 		 *
@@ -807,16 +867,16 @@ public void ControllingRecursionDepth()
 		 *
 		 * For instance, lets create a custom visitor that disables doc values for numeric and boolean types.
 		 * (Not really a good idea in practice, but let's do it anyway for the sake of a clear example.)
-		 */
+		 */
 		public class DisableDocValuesPropertyVisitor : NoopPropertyVisitor
-		{
-			/** Override the Visit method on INumberProperty and set DocValues = false */
+		{
+			/** Override the Visit method on INumberProperty and set DocValues = false */
 			public override void Visit(INumberProperty type, PropertyInfo propertyInfo, ElasticsearchPropertyAttributeBase attribute)
 			{
 				type.DocValues = false;
-			}
-
-			/** Similarily, override the Visit method on IBooleanProperty and set DocValues = false */
+			}
+
+			/** Similarily, override the Visit method on IBooleanProperty and set DocValues = false */
 			public override void Visit(IBooleanProperty type, PropertyInfo propertyInfo, ElasticsearchPropertyAttributeBase attribute)
 			{
 				type.DocValues = false;
@@ -825,17 +885,17 @@ public override void Visit(IBooleanProperty type, PropertyInfo propertyInfo, Ela
 
 		[U]
 		public void UsingACustomPropertyVisitor()
-		{
-			/** Now we can pass an instance of our custom visitor to AutoMap() */
+		{
+			/** Now we can pass an instance of our custom visitor to AutoMap() */
 			var descriptor = new CreateIndexDescriptor("myindex")
 				.Mappings(ms => ms
 					.Map<Employee>(m => m.AutoMap(new DisableDocValuesPropertyVisitor()))
-				);
-
+				);
+
 			/** and anytime it maps a property as a number (INumberProperty) or boolean (IBooleanProperty) 
 			 * it will apply the transformation defined in each Visit() respectively, which in this example
 			 * disables doc values.
-			 */
+			 */
 			var expected = new
 			{
 				mappings = new
@@ -875,12 +935,12 @@ public void UsingACustomPropertyVisitor()
 					}
 				}
 			};
-		}
-
+		}
+
 		/** You can even take the visitor approach a step further, and instead of visiting on IProperty types, visit
 		 * directly on your POCO properties (PropertyInfo).  For example, lets create a visitor that maps all CLR types 
 		 * to an Elasticsearch string (IStringProperty).
-		 */
+		 */
 		public class EverythingIsAStringPropertyVisitor : NoopPropertyVisitor
 		{
 			public override IProperty Visit(PropertyInfo propertyInfo, ElasticsearchPropertyAttributeBase attribute) => new StringProperty();