added more termlevel query dsl tests

Author: Mpdreamz

src/Nest/CommonAbstractions/SerializationBehavior/ElasticContractResolver.cs

@@ -111,7 +111,7 @@ protected override IList<JsonProperty> CreateProperties(Type type, MemberSeriali
 
 			defaultProperties = PropertiesOf<IQuery>(type, memberSerialization, defaultProperties, lookup);
 			defaultProperties = PropertiesOf<ISpecialField>(type, memberSerialization, defaultProperties, lookup);
-			defaultProperties = PropertiesOf<IExternalFieldDeclaration>(type, memberSerialization, defaultProperties, lookup);
+			defaultProperties = PropertiesOf<IFieldLookup>(type, memberSerialization, defaultProperties, lookup);
 			defaultProperties = PropertiesOf<IQueryContainer>(type, memberSerialization, defaultProperties, lookup);
 			defaultProperties = PropertiesOf<IRequest>(type, memberSerialization, defaultProperties, lookup);
 			defaultProperties = PropertiesOf<IQueryContainer>(type, memberSerialization, defaultProperties, lookup);

src/Nest/CommonOptions/MinimumShouldMatch/MinimumShouldMatch.cs

@@ -15,10 +15,11 @@ public MinimumShouldMatch(int count) : base(count) { }
 		public MinimumShouldMatch(string percentage) : base(percentage) { }
 
 		public static MinimumShouldMatch Fixed(int count) => count;
-		public static MinimumShouldMatch Percentage(float percentage) => $"{percentage}%";
+		public static MinimumShouldMatch Percentage(double percentage) => $"{percentage}%";
 
 		public static implicit operator MinimumShouldMatch(string first) => new MinimumShouldMatch(first);
 		public static implicit operator MinimumShouldMatch(int second) => new MinimumShouldMatch(second);
+		public static implicit operator MinimumShouldMatch(double second) => Percentage(second);
 	}
 
 	internal class MinimumShouldMatchJsonConverter :JsonConverter 

src/Nest/Nest.csproj

@@ -838,7 +838,7 @@
     <Compile Include="QueryDsl\Joining\HasParent\ParentScoreMode.cs" />
     <Compile Include="Search\Percolator\RegisterPercolator\RegisterPercolatorRequest.cs" />
     <Compile Include="Search\Percolator\Percolate\PercolateRequest.cs" />
-    <Compile Include="QueryDsl\ExternalFieldDeclaration.cs" />
+    <Compile Include="QueryDsl\FieldLookup.cs" />
     <Compile Include="QueryDsl\FullText\MultiMatch\MultiMatchQuery.cs" />
     <Compile Include="Cluster\ClusterState\ElasticClient-ClusterState.cs" />
     <Compile Include="CommonAbstractions\SerializationBehavior\StatefulDeserialization\ConcreteTypeConverter.cs" />

src/Nest/QueryDsl/ExternalFieldDeclaration.cs

@@ -0,0 +1,79 @@
+using System;
+using System.Globalization;
+using System.Linq.Expressions;
+using Newtonsoft.Json;
+
+namespace Nest
+{
+	[JsonConverter(typeof(ReadAsTypeJsonConverter<FieldLookup>))]
+	public interface IFieldLookup
+	{
+		[JsonProperty("index")]
+		IndexName Index { get; set; }
+		
+		[JsonProperty("type")]
+		TypeName Type { get; set; }
+		
+		[JsonProperty("id")]
+		Id Id { get; set; }
+		
+		[JsonProperty("path")]
+		Field Path { get; set; }
+	}
+
+	public class FieldLookup : IFieldLookup
+	{
+		public IndexName Index { get; set; }
+		public TypeName Type { get; set; }
+		public Id Id { get; set; }
+		public Field Path { get; set; }
+	}
+
+	public class FieldLookupDescriptor<T> : IFieldLookup 
+		where T : class
+	{
+		internal Type _ClrType => typeof(T);
+
+		private IFieldLookup Self => this;
+
+		IndexName IFieldLookup.Index { get; set; }
+		
+		TypeName IFieldLookup.Type { get; set; }
+		
+		Id IFieldLookup.Id { get; set; }
+		
+		Field IFieldLookup.Path { get; set; }
+
+		public FieldLookupDescriptor()
+		{
+			Self.Type = new TypeName { Type = this._ClrType };
+			Self.Index = new IndexName { Type = this._ClrType };
+		}
+
+		public FieldLookupDescriptor<T> Index(IndexName index)
+		{
+			Self.Index = index;
+			return this;
+		}
+		public FieldLookupDescriptor<T> Id(Id id)
+		{
+			Self.Id = id;
+			return this;
+		}
+		public FieldLookupDescriptor<T> Type(TypeName type)
+		{
+			Self.Type = type;
+			return this;
+		}
+		public FieldLookupDescriptor<T> Path(Field path)
+		{
+			Self.Path = path;
+			return this;
+		}
+		public FieldLookupDescriptor<T> Path(Expression<Func<T, object>> objectPath)
+		{
+			Self.Path = objectPath;
+			return this;
+		}
+	}
+}

src/Nest/QueryDsl/FieldLookup.cs

@@ -119,9 +119,6 @@ public static QueryContainer Term<K>(Expression<Func<T, object>> fieldDescriptor
 		public static QueryContainer Term<K>(string field, K value, double? Boost = null) => 
 			new QueryContainerDescriptor<T>().Term(field, value, Boost);
 
-		public static QueryContainer Terms(string field, params string[] terms) => 
-			new QueryContainerDescriptor<T>().Terms(field, terms);
-
 		public static QueryContainer TermsDescriptor(Func<TermsQueryDescriptor<T, object>, ITermsQuery> selector) => 
 			new QueryContainerDescriptor<T>().Terms(selector);
 

src/Nest/QueryDsl/Query.cs

@@ -83,30 +83,13 @@ public QueryContainer SimpleQueryString(Func<SimpleQueryStringQueryDescriptor<T>
 		/// <summary>
 		/// A query that match on any (configurable) of the provided terms. This is a simpler syntax query for using a bool query with several term queries in the should clauses.
 		/// </summary>
-		public QueryContainer Terms(string field, IEnumerable<string> terms) =>
-			this.Terms(t => t.Field(field).Terms(terms));
-
-		/// <summary>
-		/// A query that match on any (configurable) of the provided terms. This is a simpler syntax query for using a bool query with several term queries in the should clauses.
-		/// </summary>
-		public QueryContainer Terms<K>(Expression<Func<T, object>> objectPath, IEnumerable<K> terms) =>
-			this.Terms<K>(t => t.Field(objectPath).Terms(terms));
-
-		/// <summary>
-		/// A query that match on any (configurable) of the provided terms. This is a simpler syntax query for using a bool query with several term queries in the should clauses.
-		/// </summary>
-		public QueryContainer Terms(Func<TermsQueryDescriptor<T, object>, ITermsQuery> selector) =>
-			this.Terms<object>(selector);
+		public QueryContainer Terms<TValue>(Func<TermsQueryDescriptor<T, TValue>, ITermsQuery> selector) =>
+			this._assignSelector(selector, (query, container) => container.Terms = query);
 
 		/// <summary>
 		/// A query that match on any (configurable) of the provided terms. This is a simpler syntax query for using a bool query with several term queries in the should clauses.
 		/// </summary>
-		public QueryContainer Terms(Expression<Func<T, object>> objectPath, IEnumerable<string> terms) =>
-			this.Terms(t => t.Field(objectPath).Terms(terms));
-		/// <summary>
-		/// A query that match on any (configurable) of the provided terms. This is a simpler syntax query for using a bool query with several term queries in the should clauses.
-		/// </summary>
-		public QueryContainer Terms<K>(Func<TermsQueryDescriptor<T, K>, ITermsQuery> selector) =>
+		public QueryContainer Terms(Func<TermsQueryDescriptor<T, string>, ITermsQuery> selector) =>
 			this._assignSelector(selector, (query, container) => container.Terms = query);
 
 		/// <summary>
@@ -604,5 +587,13 @@ public QueryContainer Script(Func<ScriptQueryDescriptor<T>, IScriptQuery> select
 		public QueryContainer Exists(Func<ExistsQueryDescriptor<T>, IExistsQuery> selector) =>
 			this._assignSelector(selector, (query, container) => container.Exists = query);
 
+		public QueryContainer Missing(Func<MissingQueryDescriptor<T>, IMissingQuery> selector) =>
+			this._assignSelector(selector, (query, container) => container.Missing = query);
+
+		public QueryContainer Type(Func<TypeQueryDescriptor, ITypeQuery> selector) =>
+			this._assignSelector(selector, (query, container) => container.Type = query);
+
+		public QueryContainer Type<TOther>() => this.Type(q => q.Value<TOther>());
+
 	}
 }

src/Nest/QueryDsl/QueryContainerDescriptor.cs

@@ -6,10 +6,12 @@
 
 namespace Nest
 {
-	[JsonConverter(typeof(ReadAsTypeJsonConverter<MissingQuery>))]
 	[JsonObject(MemberSerialization = MemberSerialization.OptIn)]
-	public interface IMissingQuery : IFieldNameQuery
+	[JsonConverter(typeof(ReadAsTypeJsonConverter<MissingQuery>))]
+	public interface IMissingQuery : IQuery
 	{
+		[JsonProperty(PropertyName = "field")]
+		Field Field { get; set; }
 
 		[JsonProperty(PropertyName = "existence")]
 		bool? Existence { get; set; }
@@ -18,25 +20,30 @@ public interface IMissingQuery : IFieldNameQuery
 		bool? NullValue { get; set; }
 	}
 
-	public class MissingQuery : FieldNameQueryBase, IMissingQuery
+	public class MissingQuery : QueryBase, IMissingQuery
 	{
 		bool IQuery.Conditionless => IsConditionless(this);
 		public bool? Existence { get; set; }
 		public bool? NullValue { get; set; }
+		public Field Field { get; set; }
 		protected override void WrapInContainer(IQueryContainer container) => container.Missing = this;
 		internal static bool IsConditionless(IMissingQuery q) => q.Field.IsConditionless();
 	}
 
 	public class MissingQueryDescriptor<T> 
-		: FieldNameQueryDescriptorBase<MissingQueryDescriptor<T>, IMissingQuery, T>
+		: QueryDescriptorBase<MissingQueryDescriptor<T>, IMissingQuery>
 		, IMissingQuery where T : class
 	{
 		bool IQuery.Conditionless => MissingQuery.IsConditionless(this);
 		bool? IMissingQuery.Existence { get; set; }
 		bool? IMissingQuery.NullValue { get; set; }
+		Field IMissingQuery.Field { get; set; }
+
+		public MissingQueryDescriptor<T> Existence(bool? existence = true) => Assign(a => a.Existence = existence);
 
-		public MissingQueryDescriptor<T> Existence(bool existence = true) => Assign(a => a.Existence = existence);
+		public MissingQueryDescriptor<T> NullValue(bool? nullValue = true) => Assign(a => a.NullValue = nullValue);
 
-		public MissingQueryDescriptor<T> NullValue(bool nullValue = true) => Assign(a => a.NullValue = nullValue);
+		public MissingQueryDescriptor<T> Field(Field field) => Assign(a => a.Field = field);
+		public MissingQueryDescriptor<T> Field(Expression<Func<T, object>> objectPath) => Assign(a => a.Field = objectPath);
 	}
 }

src/Nest/QueryDsl/TermLevel/Missing/MissingQuery.cs

@@ -11,24 +11,24 @@ namespace Nest
 	[JsonConverter(typeof(TermsQueryJsonConverter))]
 	public interface ITermsQuery : IFieldNameQuery
 	{
-		string MinimumShouldMatch { get; set; }
+		MinimumShouldMatch MinimumShouldMatch { get; set; }
 		bool? DisableCoord { get; set; }
 		IEnumerable<object> Terms { get; set; }
-		IExternalFieldDeclaration ExternalField { get; set; }
+		IFieldLookup TermsLookup { get; set; }
 	}
 
 	public class TermsQuery : FieldNameQueryBase, ITermsQuery
 	{
 		bool IQuery.Conditionless => IsConditionless(this);
-		public string MinimumShouldMatch { get; set; }
+		public MinimumShouldMatch MinimumShouldMatch { get; set; }
 		public bool? DisableCoord { get; set; }
 		public IEnumerable<object> Terms { get; set; }
-		public IExternalFieldDeclaration ExternalField { get; set; }
+		public IFieldLookup TermsLookup { get; set; }
 
 		protected override void WrapInContainer(IQueryContainer c) => c.Terms = this;
 		internal static bool IsConditionless(ITermsQuery q)
 		{
-			return q.Field.IsConditionless() || (!q.Terms.HasAny() && q.ExternalField == null);
+			return q.Field.IsConditionless() || (!q.Terms.HasAny() && q.TermsLookup == null);
 		}
 	}
 
@@ -37,40 +37,27 @@ internal static bool IsConditionless(ITermsQuery q)
 	/// This is a simpler syntax query for using a bool query with several term queries in the should clauses.
 	/// </summary>
 	/// <typeparam name="T">The type that represents the expected hit type</typeparam>
-	/// <typeparam name="K">The type of the field that we want to specfify terms for</typeparam>
-	public class TermsQueryDescriptor<T, K> 
-		: FieldNameQueryDescriptorBase<TermsQueryDescriptor<T, K>, ITermsQuery, T>
+	/// <typeparam name="TValue">The type of the field that we want to specfify terms for</typeparam>
+	public class TermsQueryDescriptor<T, TValue> 
+		: FieldNameQueryDescriptorBase<TermsQueryDescriptor<T, TValue>, ITermsQuery, T>
 		, ITermsQuery where T : class
 	{
 		bool IQuery.Conditionless => TermsQuery.IsConditionless(this);
-		string ITermsQuery.MinimumShouldMatch { get; set; }
+		MinimumShouldMatch ITermsQuery.MinimumShouldMatch { get; set; }
 		bool? ITermsQuery.DisableCoord { get; set; }
 		IEnumerable<object> ITermsQuery.Terms { get; set; }
-		IExternalFieldDeclaration ITermsQuery.ExternalField { get; set; }
+		IFieldLookup ITermsQuery.TermsLookup { get; set; }
 
-		public TermsQueryDescriptor<T, K> OnExternalField<TOther>(
-			Func<ExternalFieldDeclarationDescriptor<TOther>, ExternalFieldDeclarationDescriptor<TOther>> selector)
-			where TOther : class => Assign(a => a.ExternalField = selector(new ExternalFieldDeclarationDescriptor<TOther>()));
+		public TermsQueryDescriptor<T, TValue> TermsLookup<TOther>(Func<FieldLookupDescriptor<TOther>, IFieldLookup> selector)
+			where TOther : class => Assign(a => a.TermsLookup = selector(new FieldLookupDescriptor<TOther>()));
 
-		public TermsQueryDescriptor<T, K> MinimumShouldMatch(string minMatch) => 
-			Assign(a => a.MinimumShouldMatch = minMatch);
+		public TermsQueryDescriptor<T, TValue> MinimumShouldMatch(MinimumShouldMatch minMatch) => Assign(a => a.MinimumShouldMatch = minMatch);
 
-		public TermsQueryDescriptor<T, K> MinimumShouldMatch(int minMatch) => Assign(a => a.MinimumShouldMatch = minMatch.ToString(CultureInfo.InvariantCulture));
+		public TermsQueryDescriptor<T, TValue> DisableCoord(bool? disable = true) => Assign(a => a.DisableCoord = disable);
 
-		public TermsQueryDescriptor<T, K> DisableCoord() => Assign(a => a.DisableCoord = true);
+		public TermsQueryDescriptor<T, TValue> Terms(IEnumerable<TValue> terms) => Assign(a => a.Terms = terms.Cast<object>());
 
-		public TermsQueryDescriptor<T, K> Terms(IEnumerable<string> terms) => Assign(a =>
-		{
-			if (terms.HasAny())
-				terms = terms.Where(t => !t.IsNullOrEmpty());
-			a.Terms = terms;
-		});
+		public TermsQueryDescriptor<T, TValue> Terms(params TValue[] terms) => Assign(a => a.Terms = terms.Cast<object>());
 
-		public TermsQueryDescriptor<T, K> Terms(IEnumerable<K> terms) => Assign(a =>
-		{
-			if (terms.HasAny())
-				terms = terms.Where(t => t != null).ToArray();
-			a.Terms = terms.Cast<object>();
-		});
 	}
 }