More tests for #2086 compound conditionless logic fix

Author: gmarz

src/Tests/QueryDsl/Compound/And/AndQueryUsageTests.cs

@@ -55,5 +55,12 @@ protected override QueryContainer QueryFluent(QueryContainerDescriptor<Project>
 		{
 			{ q=>q.Filters = null }, { q=> q.Filters = Enumerable.Empty<QueryContainer>() }, { q=>q.Filters = new [] { ConditionlessQuery } }
 		};
+
+		protected override NotConditionlessWhen NotConditionlessWhen => new NotConditionlessWhen<IAndQuery>(a => a.And)
+		{
+			q => q.Filters = new [] { VerbatimQuery },
+			q => q.Filters = new [] { ConditionlessQuery, VerbatimQuery }
+		};
+
 	}
 }

src/Tests/QueryDsl/Compound/Bool/BoolQueryUsageTests.cs

@@ -79,6 +79,34 @@ protected override QueryContainer QueryFluent(QueryContainerDescriptor<Project>
 			},
 		};
 
+		protected override NotConditionlessWhen NotConditionlessWhen => new NotConditionlessWhen<IBoolQuery>(a => a.Bool)
+		{
+			q => {
+				q.MustNot = new [] { VerbatimQuery };
+				q.Should = null;
+				q.Must = null;
+				q.Filter = null;
+			},
+			q => {
+				q.MustNot = null;
+				q.Should = new [] { VerbatimQuery };
+				q.Must = null;
+				q.Filter = null;
+			},
+			q => {
+				q.MustNot = null;
+				q.Should = null;
+				q.Must = new [] { VerbatimQuery };
+				q.Filter = null;
+			},
+			q => {
+				q.MustNot = null;
+				q.Should = null;
+				q.Must = null;
+				q.Filter = new [] { VerbatimQuery };
+			},
+		};
+
 		[U]
 		public void NullQueryDoesNotCauseANullReferenceException()
 		{

src/Tests/QueryDsl/Compound/Boosting/BoostingQueryUsageTests.cs

@@ -57,5 +57,22 @@ protected override QueryContainer QueryFluent(QueryContainerDescriptor<Project>
 				q.PositiveQuery =  ConditionlessQuery;
 			},
 		};
+
+		protected override NotConditionlessWhen NotConditionlessWhen => new NotConditionlessWhen<IBoostingQuery>(a => a.Boosting)
+		{
+			q=> {
+				q.NegativeQuery = VerbatimQuery;
+				q.PositiveQuery = VerbatimQuery;
+			},
+			q => {
+				q.NegativeQuery =  null;
+				q.PositiveQuery =  VerbatimQuery;
+			},
+			q => {
+				q.NegativeQuery =  VerbatimQuery;
+				q.PositiveQuery =  null;
+			}
+		};
+
 	}
 }

src/Tests/QueryDsl/Compound/ConstantScore/ConstantScoreQueryUsageTests.cs

@@ -45,5 +45,9 @@ protected override QueryContainer QueryFluent(QueryContainerDescriptor<Project>
 			q => q.Filter = null ,
 			q => q.Filter =  ConditionlessQuery,
 		};
+		protected override NotConditionlessWhen NotConditionlessWhen => new NotConditionlessWhen<IConstantScoreQuery>(a => a.ConstantScore)
+		{
+			q => q.Filter = VerbatimQuery
+		};
 	}
 }

src/Tests/QueryDsl/Compound/Dismax/DismaxQueryUsageTests.cs

@@ -57,6 +57,12 @@ protected override QueryContainer QueryFluent(QueryContainerDescriptor<Project>
 			q => q.Queries = new [] { ConditionlessQuery },
 		};
 
+		protected override NotConditionlessWhen NotConditionlessWhen => new NotConditionlessWhen<IDisMaxQuery>(a => a.DisMax)
+		{
+			q => q.Queries = new [] { VerbatimQuery },
+			q => q.Queries = new [] { VerbatimQuery, ConditionlessQuery },
+		};
+
 		[U]
 		public void NullQueryDoesNotCauseANullReferenceException()
 		{

src/Tests/QueryDsl/Compound/Filtered/FilteredQueryUsageTests.cs

@@ -58,5 +58,21 @@ protected override QueryContainer QueryFluent(QueryContainerDescriptor<Project>
 				q.Query =  ConditionlessQuery;
 			},
 		};
+
+		protected override NotConditionlessWhen NotConditionlessWhen => new NotConditionlessWhen<IFilteredQuery>(a => a.Filtered)
+		{
+			q=> {
+				q.Filter = VerbatimQuery;
+				q.Query = null;
+			},
+			q => {
+				q.Filter =  null;
+				q.Query =  VerbatimQuery;
+			},
+			q => {
+				q.Filter =  null;
+				q.Query = new BoolQuery { Must = new [] { VerbatimQuery } };
+			},
+		};
 	}
 }

src/Tests/QueryDsl/Compound/Indices/IndicesNoMatchQueryUsageTests.cs

@@ -47,5 +47,17 @@ protected override QueryContainer QueryFluent(QueryContainerDescriptor<Project>
 			q => q.Query = null,
 			q => q.Query = ConditionlessQuery
 		};
+
+		protected override NotConditionlessWhen NotConditionlessWhen => new NotConditionlessWhen<IIndicesQuery>(p => p.Indices)
+		{
+			q => {
+				q.Query = VerbatimQuery;
+				q.NoMatchQuery = null;
+			},
+			q => {
+				q.Query = null;
+				q.NoMatchQuery = VerbatimQuery;
+			}
+		};
 	}
 }

src/Tests/QueryDsl/Compound/Not/NotQueryUsageTests.cs

@@ -55,5 +55,18 @@ protected override QueryContainer QueryFluent(QueryContainerDescriptor<Project>
 		{
 			{ q=>q.Filters = null }, { q=> q.Filters = Enumerable.Empty<QueryContainer>() }, { q=>q.Filters = new [] { ConditionlessQuery } }
 		};
+
+		protected override NotConditionlessWhen NotConditionlessWhen => new NotConditionlessWhen<INotQuery>(a => a.Not)
+		{
+			q => {
+				q.Filters = new [] { VerbatimQuery };
+			},
+			q => {
+				q.Filters = new [] { ConditionlessQuery, VerbatimQuery };
+			},
+			q => {
+				q.Filters = new [] { new QueryContainer(new BoolQuery { Filter = new [] { VerbatimQuery } }) };
+			},
+		};
 	}
 }

src/Tests/QueryDsl/Compound/Or/OrQueryUsageTests.cs

@@ -55,5 +55,18 @@ protected override QueryContainer QueryFluent(QueryContainerDescriptor<Project>
 		{
 			{ q=>q.Filters = null }, { q=> q.Filters = Enumerable.Empty<QueryContainer>() }, { q=>q.Filters = new [] { ConditionlessQuery } }
 		};
+
+		protected override NotConditionlessWhen NotConditionlessWhen => new NotConditionlessWhen<IOrQuery>(a => a.Or)
+		{
+			q => {
+				q.Filters = new [] { VerbatimQuery };
+			},
+			q => {
+				q.Filters = new [] { ConditionlessQuery, VerbatimQuery };
+			},
+			q => {
+				q.Filters = new [] { new QueryContainer(new BoolQuery { Filter = new [] { VerbatimQuery } }) };
+			},
+		};
 	}
 }

src/Tests/QueryDsl/QueryDslUsageTestsBase.cs

@@ -54,10 +54,13 @@ private void AssertIsNotConditionless(IQueryContainer c)
 				Query = this.QueryInitializer
 			};
 
+		protected virtual NotConditionlessWhen NotConditionlessWhen => null;
 		protected virtual ConditionlessWhen ConditionlessWhen => null;
 
 		protected QueryContainer ConditionlessQuery = new QueryContainer(new TermQuery { });
 
+		protected QueryContainer VerbatimQuery = new QueryContainer(new TermQuery { IsVerbatim = true });
+
 		[U]
 		public void SeenByVisitor()
 		{
@@ -84,6 +87,19 @@ public void ConditionlessWhenExpectedToBe()
 			((IQueryContainer)this.QueryInitializer).IsConditionless.Should().BeFalse();
 		}
 
+		[U]
+		public void NotConditionlessWhenExpectedToBe()
+		{
+			if (NotConditionlessWhen == null) return;
+			foreach (var when in NotConditionlessWhen)
+			{
+				var query = this.QueryFluent(new QueryContainerDescriptor<Project>());
+				when(query);
+				query = this.QueryInitializer;
+				when(query);
+			}
+		}
+
 		private void IsConditionless(IQueryContainer q, bool be) => q.IsConditionless.Should().Be(be);
 	}
 
@@ -114,4 +130,30 @@ private void Assert(IQueryContainer c, Action<TQuery> when)
 			c.IsConditionless.Should().BeTrue();
 		}
 	}
+
+	public abstract class NotConditionlessWhen : List<Action<QueryContainer>>
+	{
+	}
+	public class NotConditionlessWhen<TQuery> : NotConditionlessWhen where TQuery : IQuery
+	{
+		private readonly Func<IQueryContainer, TQuery> _dispatch;
+
+		public NotConditionlessWhen(Func<IQueryContainer, TQuery> dispatch)
+		{
+			_dispatch = dispatch;
+		}
+
+		public void Add(Action<TQuery> when)
+		{
+			this.Add(q => Assert(q, when));
+		}
+
+		private void Assert(IQueryContainer c, Action<TQuery> when)
+		{
+			TQuery q = this._dispatch(c);
+			when(q);
+			q.Conditionless.Should().BeFalse();
+			c.IsConditionless.Should().BeFalse();
+		}
+	}
 }