wrote unit tests for _name handling of all the queries in the query dsl

Author: Mpdreamz

src/Nest/DSL/Query/BoolQueryDescriptor.cs

@@ -52,7 +52,7 @@ protected override void WrapInContainer(IQueryContainer container)
 		public double? Boost { get; set; }
 	}
 
-
+	//TODO 2.0 why is this separate from the descriptor
 	public class BoolBaseQueryDescriptor : IBoolQuery
 	{
 		[JsonProperty("must")]
@@ -99,6 +99,17 @@ public BoolQueryDescriptor<T> DisableCoord()
 			return this;
 		}
 
+		/// <summary>
+		/// 
+		/// </summary>
+		/// <param name="minimumShouldMatches"></param>
+		/// <returns></returns>
+		public BoolQueryDescriptor<T> Name(string name)
+		{
+			((IBoolQuery) this).Name = name;
+			return this;
+		}
+		
 		/// <summary>
 		/// Specifies a minimum number of the optional BooleanClauses which must be satisfied.
 		/// </summary>
@@ -109,6 +120,7 @@ public BoolQueryDescriptor<T> MinimumShouldMatch(int minimumShouldMatches)
 			((IBoolQuery)this).MinimumShouldMatch = minimumShouldMatches.ToString(CultureInfo.InvariantCulture);
 			return this;
 		}
+		
 		/// <summary>
 		/// Specifies a minimum number of the optional BooleanClauses which must be satisfied. String overload where you can specify percentages
 		/// </summary>
@@ -184,6 +196,7 @@ public BoolQueryDescriptor<T> MustNot(params Func<QueryDescriptor<T>, QueryConta
 			((IBoolQuery)this).MustNot = descriptors.HasAny() ? descriptors : null;
 			return this;
 		}
+		
 		/// <summary>
 		/// The clause (query) should appear in the matching document. A boolean query with no must clauses, one or more should clauses must match a document.
 		///  The minimum number of should clauses to match can be set using minimum_should_match parameter.
@@ -202,6 +215,7 @@ public BoolQueryDescriptor<T> MustNot(params QueryContainer[] queries)
 			((IBoolQuery)this).MustNot = descriptors.HasAny() ? descriptors : null;
 			return this;
 		}
+		
 		/// <summary>
 		/// The clause (query) must not appear in the matching documents. Note that it is not possible to search on documents that only consists of a must_not clauses.
 		/// </summary>

src/Nest/DSL/Query/BoostingQueryDescriptor.cs

@@ -51,8 +51,9 @@ bool IQuery.IsConditionless
 			{
 				if (Self.NegativeQuery == null && Self.PositiveQuery == null)
 					return true;
-				return (Self.PositiveQuery == null || Self.NegativeQuery.IsConditionless)
-					|| (Self.NegativeQuery == null || Self.PositiveQuery.IsConditionless);
+
+				return (Self.PositiveQuery == null && Self.NegativeQuery.IsConditionless)
+					|| (Self.NegativeQuery == null && Self.PositiveQuery.IsConditionless);
 			}
 		}
 

src/Nest/DSL/Query/IQuery.cs

@@ -1,6 +1,7 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using Newtonsoft.Json;
 
 namespace Nest
 {
@@ -9,6 +10,7 @@ public interface IQuery
 		/// <summary>
 		/// The _name of the query. this allows you to retrieve for each document what part of the query it matched on
 		/// </summary>
+		[JsonProperty(PropertyName = "_name")]
 		string Name { get; set; }
 		bool IsConditionless { get; }
 	}

src/Nest/DSL/Query/IdsQueryDescriptor.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.Globalization;
 using System.Linq;
 using Nest.Resolvers.Converters;
 using Newtonsoft.Json;
@@ -30,6 +31,66 @@ protected override void WrapInContainer(IQueryContainer container)
 		public IEnumerable<string> Values { get; set; }
 	}
 
+	[Obsolete("Scheduled to be renamed in 2.0")]
+	public class IdsQueryProperDescriptor : IIdsQuery
+	{
+		private IIdsQuery Self { get { return this; }}
+
+		IEnumerable<string> IIdsQuery.Values { get; set; }
+		IEnumerable<string> IIdsQuery.Type { get; set; }
+		string IQuery.Name { get; set; }
+		bool IQuery.IsConditionless
+		{
+			get
+			{
+				return !Self.Values.HasAny() || Self.Values.All(s=>s.IsNullOrEmpty());
+			}
+		}
+
+		public IdsQueryProperDescriptor Name(string name)
+		{
+			Self.Name = name;
+			return this;
+		}
+
+		public IdsQueryProperDescriptor Type(params string[] types)
+		{
+			Self.Type = types;
+			return this;
+		}
+
+		public IdsQueryProperDescriptor Type(IEnumerable<string> values)
+		{
+			return this.Type(values.ToArray());
+		}
+
+		public IdsQueryProperDescriptor Values(params long[] values)
+		{
+			if (values == null) return this;
+			return this.Values(values.Select(v=>v.ToString(CultureInfo.InvariantCulture)).ToArray());
+		}
+
+		public IdsQueryProperDescriptor Values(IEnumerable<long> values)
+		{
+			if (values == null) return this;
+			return this.Values(values.Select(v=>v.ToString(CultureInfo.InvariantCulture)).ToArray());
+		}
+	
+		public IdsQueryProperDescriptor Values(params string[] values)
+		{
+			Self.Values = values;
+			return this;
+		}
+
+		public IdsQueryProperDescriptor Values(IEnumerable<string> values)
+		{
+			if (values == null) return this;
+			return this.Values(values.ToArray());
+		}
+	}
+
+	
+	[Obsolete("Scheduled to be removed in 2.0")]
 	public class IdsQueryDescriptor : IIdsQuery
 	{
 		[JsonProperty(PropertyName = "_name")]

src/Nest/DSL/Query/QueryDescriptor.cs

@@ -10,7 +10,7 @@ namespace Nest
 	public class QueryDescriptor<T> : QueryContainer where T : class
 	{
 
-
+		//TODO remove all the shortcuts into descriptors except for .Term(s)()
 
 		public QueryDescriptor()
 		{
@@ -291,6 +291,7 @@ public QueryContainer Indices(Action<IndicesQueryDescriptor<T>> selector)
 
 			return this.New(query, q => q.Indices = query);
 		}
+
 		/// <summary>
 		/// Matches documents with fields that have terms within a certain range. The type of the Lucene query depends
 		/// on the field type, for string fields, the TermRangeQuery, while for number/date fields, the query is
@@ -303,6 +304,7 @@ public QueryContainer Range(Action<RangeQueryDescriptor<T>> selector)
 
 			return this.New(query, q => q.Range = query);
 		}
+
 		/// <summary>
 		/// Fuzzy like this query find documents that are “like” provided text by running it against one or more fields.
 		/// </summary>
@@ -444,6 +446,7 @@ public QueryContainer HasChild<K>(Action<HasChildQueryDescriptor<K>> selector) w
 
 			return this.New(query, q => q.HasChild = query);
 		}
+		
 		/// <summary>
 		/// The has_child query works the same as the has_child filter, by automatically wrapping the filter with a 
 		/// constant_score.
@@ -456,6 +459,7 @@ public QueryContainer HasParent<K>(Action<HasParentQueryDescriptor<K>> selector)
 
 			return this.New(query, q => q.HasParent = query);
 		}
+		
 		/// <summary>
 		/// The top_children query runs the child query with an estimated hits size, and out of the hit docs, aggregates 
 		/// it into parent docs. If there aren’t enough parent docs matching the requested from/size search request, 
@@ -469,6 +473,7 @@ public QueryContainer TopChildren<K>(Action<TopChildrenQueryDescriptor<K>> selec
 
 			return this.New(query, q => q.TopChildren = query);
 		}
+		
 		/// <summary>
 		/// A query that applies a filter to the results of another query. This query maps to Lucene FilteredQuery.
 		/// </summary>
@@ -500,6 +505,7 @@ public QueryContainer Dismax(Action<DisMaxQueryDescriptor<T>> selector)
 
 			return this.New(query, q => q.DisMax = query);
 		}
+		
 		/// <summary>
 		/// A query that wraps a filter or another query and simply returns a constant score equal to the query boost 
 		/// for every document in the filter. Maps to Lucene ConstantScoreQuery.
@@ -511,6 +517,7 @@ public QueryContainer ConstantScore(Action<ConstantScoreQueryDescriptor<T>> sele
 
 			return this.New(query, q => q.ConstantScore = query);
 		}
+		
 		/// <summary>
 		/// custom_boost_factor query allows to wrap another query and multiply its score by the provided boost_factor.
 		/// This can sometimes be desired since boost value set on specific queries gets normalized, while this 
@@ -524,6 +531,7 @@ public QueryContainer CustomBoostFactor(Action<CustomBoostFactorQueryDescriptor<
 
 			return this.New(query, q => q.CustomBoostFactor = query);
 		}
+		
 		/// <summary>
 		/// custom_score query allows to wrap another query and customize the scoring of it optionally with a 
 		/// computation derived from other field values in the doc (numeric ones) using script expression
@@ -536,6 +544,7 @@ public QueryContainer CustomScore(Action<CustomScoreQueryDescriptor<T>> customSc
 
 			return this.New(query, q => q.CustomScore = query);
 		}
+		
 		/// <summary>
 		/// custom_score query allows to wrap another query and customize the scoring of it optionally with a 
 		/// computation derived from other field values in the doc (numeric ones) using script or boost expression
@@ -547,6 +556,7 @@ public QueryContainer CustomFiltersScore(Action<CustomFiltersScoreQueryDescripto
 
 			return this.New(query, q => q.CustomFiltersScore = query);
 		}
+		
 		/// <summary>
 		/// A query that matches documents matching boolean combinations of other queries. The bool query maps to 
 		/// Lucene BooleanQuery. 
@@ -583,11 +593,13 @@ public QueryContainer Boosting(Action<BoostingQueryDescriptor<T>> boostingQuery)
 		/// boosting into account, the norms_field needs to be provided in order to explicitly specify which
 		/// field the boosting will be done on (Note, this will result in slower execution time).
 		/// </param>
-		public QueryContainer MatchAll(double? Boost = null, string NormField = null)
+		public QueryContainer MatchAll(double? Boost = null, string NormField = null, string Name = null)
 		{
+			//TODO introduce a proper optional query descriptor
 			var query = new MatchAllQuery() { NormField = NormField };
 			if (Boost.HasValue)
 				query.Boost = Boost.Value;
+			query.Name = Name;
 
 			return this.New(query, q => q.MatchAllQuery = query);
 		}
@@ -605,6 +617,7 @@ public QueryContainer Term<K>(Expression<Func<T, K>> fieldDescriptor, K value, d
 					t.Boost(Boost.Value);
 			});
 		}
+		
 		/// <summary>
 		/// Matches documents that have fields that contain a term (not analyzed). 
 		/// The term query maps to Lucene TermQuery. 
@@ -618,6 +631,7 @@ public QueryContainer Term(Expression<Func<T, object>> fieldDescriptor, object v
 					t.Boost(Boost.Value);
 			});
 		}
+		
 		/// <summary>
 		/// Matches documents that have fields that contain a term (not analyzed). 
 		/// The term query maps to Lucene TermQuery. 
@@ -631,6 +645,7 @@ public QueryContainer Term(string field, object value, double? Boost = null)
 					t.Boost(Boost.Value);
 			});
 		}
+		
 		/// <summary>
 		/// Matches documents that have fields that contain a term (not analyzed). 
 		/// The term query maps to Lucene TermQuery. 
@@ -641,6 +656,7 @@ public QueryContainer Term(Action<TermQueryDescriptor<T>> termSelector)
 			termSelector(termQuery);
 			return this.New(termQuery, q => q.Term = termQuery);
 		}
+		
 		/// <summary>
 		/// Matches documents that have fields matching a wildcard expression (not analyzed). 
 		/// Supported wildcards are *, which matches any character sequence (including the empty one), and ?, 
@@ -657,6 +673,7 @@ public QueryContainer Wildcard(Expression<Func<T, object>> fieldDescriptor, stri
 				if (Rewrite.HasValue) t.Rewrite(Rewrite.Value);
 			});
 		}
+		
 		/// <summary>
 		/// Matches documents that have fields matching a wildcard expression (not analyzed). 
 		/// Supported wildcards are *, which matches any character sequence (including the empty one), and ?,
@@ -687,6 +704,7 @@ public QueryContainer Wildcard(Action<WildcardQueryDescriptor<T>> wildcardSelect
 			wildcardSelector(wildcardQuery);
 			return this.New(wildcardQuery, q => q.Wildcard = wildcardQuery);
 		}
+		
 		/// <summary>
 		/// Matches documents that have fields containing terms with a specified prefix (not analyzed). 
 		/// The prefix query maps to Lucene PrefixQuery. 
@@ -725,6 +743,7 @@ public QueryContainer Prefix(Action<PrefixQueryDescriptor<T>> prefixSelector)
 			prefixSelector(prefixQuery);
 			return this.New(prefixQuery, q => q.Prefix = prefixQuery);
 		}
+		
 		/// <summary>
 		/// Filters documents that only have the provided ids. Note, this filter does not require 
 		/// the _id field to be indexed since it works using the _uid field.
@@ -758,6 +777,17 @@ public QueryContainer Ids(IEnumerable<string> types, IEnumerable<string> values)
 			return this.New(ids, q => q.Ids = ids);
 		}
 
+		/// <summary>
+		/// Filters documents that only have the provided ids. 
+		/// Note, this filter does not require the _id field to be indexed since 
+		/// it works using the _uid field.
+		/// </summary>
+		public QueryContainer Ids(Func<IdsQueryProperDescriptor, IdsQueryProperDescriptor> selector)
+		{
+			var ids = selector(new IdsQueryProperDescriptor());
+			return this.New(ids, c => c.Ids = ids);
+		}
+
 		/// <summary>
 		/// Matches spans containing a term. The span term query maps to Lucene SpanTermQuery. 
 		/// </summary>
@@ -791,6 +821,7 @@ public QueryContainer SpanTerm(Action<SpanTermQueryDescriptor<T>> spanTermSelect
 			spanTermSelector(spanTerm);
 			return this.New(spanTerm, q => q.SpanTerm = spanTerm);
 		}
+		
 		/// <summary>
 		/// Matches spans near the beginning of a field. The span first query maps to Lucene SpanFirstQuery. 
 		/// </summary>

src/Nest/DSL/Query/QueryStringDescriptor.cs

@@ -81,11 +81,17 @@ protected override void WrapInContainer(IQueryContainer container)
 		}
 
 		bool IQuery.IsConditionless { get { return false; } }
+
 		public string Name { get; set; }
+
 		public string Query { get; set; }
+
 		public PropertyPathMarker DefaultField { get; set; }
+
 		public IEnumerable<PropertyPathMarker> Fields { get; set; }
+
 		public Operator? DefaultOperator { get; set; }
+
 		public string Analyzer { get; set; }
 		public bool? AllowLeadingWildcard { get; set; }
 		public bool? LowercaseExpendedTerms { get; set; }
@@ -161,11 +167,13 @@ public QueryStringQueryDescriptor<T> Name(string name)
 			Self.Name = name;
 			return this;
 		}
+
 		public QueryStringQueryDescriptor<T> DefaultField(string field)
 		{
 			((IQueryStringQuery)this).DefaultField = field;
 			return this;
 		}
+
 		public QueryStringQueryDescriptor<T> DefaultField(Expression<Func<T, object>> objectPath)
 		{
 			((IQueryStringQuery)this).DefaultField = objectPath;

src/Nest/DSL/Query/RangeQueryDescriptor.cs

@@ -27,11 +27,9 @@ public interface IRangeQuery : IFieldNameQuery
 		double? Boost { get; set; }
 
 		[JsonProperty(PropertyName = "_cache")]
+		[Obsolete("scheduled to be removed in 2.o copy paste errror from filters")]
 		bool? Cache { get; set; }
 
-		[JsonProperty(PropertyName = "_name")]
-		string Name { get; set; }
-
 		[JsonProperty("time_zone")]
 		string TimeZone { get; set; }
 
@@ -81,8 +79,6 @@ public class RangeQueryDescriptor<T> : IRangeQuery where T : class
 		double? IRangeQuery.Boost { get; set; }
 
 		bool? IRangeQuery.Cache { get; set; }
-		
-		string IRangeQuery.Name { get; set; }
 
 		string IRangeQuery.TimeZone { get; set; }