added integration tests for booleans that assert that our boolean logic finds the same number of documents in elasticsearch as it does against an in memory List<Doc>

Author: Mpdreamz

src/Nest/Document/Multiple/Bulk/BulkRequest.cs

@@ -33,6 +33,9 @@ public BulkDescriptor Create<T>(Func<BulkCreateDescriptor<T>, BulkCreateDescript
 		public BulkDescriptor CreateMany<T>(IEnumerable<T> @objects, Func<BulkCreateDescriptor<T>, T, BulkCreateDescriptor<T>> bulkCreateSelector = null) where T : class =>
 			Assign(a => @objects.ForEach(o => AddOperation(bulkCreateSelector.InvokeOrDefault(new BulkCreateDescriptor<T>().Document(o), o))));
 
+		public BulkDescriptor Index<T>(T obj, Func<BulkIndexDescriptor<T>, BulkIndexDescriptor<T>> bulkIndexSelector = null) where T : class =>
+			Assign(a => AddOperation(bulkIndexSelector.InvokeOrDefault(new BulkIndexDescriptor<T>()).Document(obj)));
+
 		public BulkDescriptor Index<T>(Func<BulkIndexDescriptor<T>, BulkIndexDescriptor<T>> bulkIndexSelector) where T : class =>
 			Assign(a => AddOperation(bulkIndexSelector?.Invoke(new BulkIndexDescriptor<T>())));
 
@@ -43,6 +46,9 @@ public BulkDescriptor Index<T>(Func<BulkIndexDescriptor<T>, BulkIndexDescriptor<
 		/// <param name="bulkIndexSelector">A func called on each object to describe the individual index operation</param>
 		public BulkDescriptor IndexMany<T>(IEnumerable<T> @objects, Func<BulkIndexDescriptor<T>, T, BulkIndexDescriptor<T>> bulkIndexSelector = null) where T : class =>
 			Assign(a => @objects.ForEach(o => AddOperation(bulkIndexSelector.InvokeOrDefault(new BulkIndexDescriptor<T>().Document(o), o))));
+
+		public BulkDescriptor Delete<T>(T obj, Func<BulkDeleteDescriptor<T>, BulkDeleteDescriptor<T>> bulkDeleteSelector = null) where T : class =>
+			Assign(a => AddOperation(bulkDeleteSelector.InvokeOrDefault(new BulkDeleteDescriptor<T>().Document(obj))));
 
 		public BulkDescriptor Delete<T>(Func<BulkDeleteDescriptor<T>, BulkDeleteDescriptor<T>> bulkDeleteSelector) where T : class =>
 			Assign(a => AddOperation(bulkDeleteSelector?.Invoke(new BulkDeleteDescriptor<T>())));

src/Tests/ClientConcepts/ConnectionPooling/Sniffing/RoleDetection.doc.cs

@@ -79,7 +79,6 @@ public async Task DetectsDataNodes()
 		}
 	}
 
-
 	[CollectionDefinition(IntegrationContext.SniffRoleDetection)]
 	public class SniffRoleDetectionCluster : ClusterBase, ICollectionFixture<SniffRoleDetectionCluster>
 	{
@@ -144,4 +143,4 @@ private Node AssertSniffResponse()
 		}
 	}
 
-}
+}

src/Tests/Framework/Integration/IntegrationContext.cs

@@ -8,6 +8,7 @@ public static class IntegrationContext
 
 		public const string OwnIndex = "OwnIndex Cluster";
 		public const string Reindex = "Reindex Cluster";
-		public const string SniffRoleDetection = "SniffRoleDetection";
+		public const string SniffRoleDetection = "SniffRoleDetection";
+		public const string Bool = "Bool Cluster";
 	}
 }

src/Tests/QueryDsl/BoolDsl/BoolApiTests.cs

@@ -0,0 +1,135 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Elasticsearch.Net;
+using FluentAssertions;
+using Nest;
+using Newtonsoft.Json;
+using Newtonsoft.Json.Converters;
+using Tests.Framework;
+using Tests.Framework.Integration;
+using Xunit;
+using A = Tests.QueryDsl.BoolDsl.BoolCluster.A;
+using E = Tests.QueryDsl.BoolDsl.BoolCluster.E;
+using static Nest.Infer;
+
+
+namespace Tests.QueryDsl.BoolDsl
+{
+
+	internal static class BoolDslTestExtensions
+	{
+		public static QueryContainer Id(this QueryContainerDescriptor<A> q, int id) => q.Term(p => p.Id, id);
+		public static QueryContainer O(this QueryContainerDescriptor<A> q, E option) => q.Term(p => p.Option, option);
+	}
+	[CollectionDefinition(IntegrationContext.Bool)]
+	public class BoolCluster : ClusterBase, ICollectionFixture<BoolCluster>
+	{
+		//TODO discuss make this default?
+		[JsonConverter(typeof(StringEnumConverter))]
+		public enum E { Option1, Option2 }
+
+		public class A
+		{
+			public int Id { get; set; }
+			public E Option { get; set; }
+
+			private static E[] Options = new[] { E.Option1, E.Option2 };
+			public static IList<A> Documents => Enumerable.Range(0, 20).Select(i => new A { Id = i + 1, Option = Options[i % 2] }).ToList();
+		}
+
+		public override void Boostrap()
+		{
+			var client = this.Node.Client();
+			var index = client.CreateIndex(Index<A>(), i => i
+				.Mappings(map => map
+					.Map<A>(m => m
+						.AutoMap()
+						.Properties(props => props
+							.String(s => s.Name(p => p.Option).NotAnalyzed())
+						)
+					)
+				)
+			);
+			var bulkResponse = client.Bulk(b => b.IndexMany(A.Documents));
+			if (!bulkResponse.IsValid) throw new ApplicationException("Could not bootstrap bool cluster, bulk was invalid");
+			client.Refresh(Indices<A>());
+		}
+	}
+
+	[Collection(IntegrationContext.Bool)]
+	public class BoolsInPractice
+	{
+
+		private readonly BoolCluster _cluster;
+		private IConnectionSettingsValues _settings;
+
+		public BoolsInPractice(BoolCluster cluster)
+		{
+			this._cluster = cluster;
+		}
+
+		private async Task Bool(
+			Func<A, bool> programmatic,
+			Func<QueryContainerDescriptor<A>, QueryContainer> fluentQuery,
+			QueryContainer initializerQuery,
+			int expectedCount
+			)
+		{
+			var documents = A.Documents.Where(programmatic).ToList();
+			documents.Count().Should().Be(expectedCount, " filtering the documents in memory did not yield the expected count");
+
+			var client = this._cluster.Node.Client();
+
+			var fluent = client.Search<A>(s => s.Query(fluentQuery));
+			var fluentAsync = await client.SearchAsync<A>(s => s.Query(fluentQuery));
+
+			var initializer = client.Search<A>(new SearchRequest<A> { Query = initializerQuery });
+			var initializerAsync = await client.SearchAsync<A>(new SearchRequest<A> { Query = initializerQuery });
+
+			var responses = new[] { fluent, fluentAsync, initializer, initializerAsync };
+			foreach (var response in responses)
+			{
+				response.IsValid.Should().BeTrue();
+				response.Total.Should().Be(expectedCount);
+			}
+		}
+
+		private TermQuery Id(int id) => new TermQuery { Field = "id", Value = id };
+		private TermQuery O(E option) => new TermQuery { Field = "option", Value = option };
+
+		[I]
+		public async Task CompareBoolQueryTranslationsToRealBooleanLogic()
+		{
+			await Bool(
+				a => a.Id == 1 && a.Option == E.Option1,
+				a => a.Id(1) && a.O(E.Option1),
+				Id(1) && O(E.Option1),
+				expectedCount: 1
+			);
+
+			await Bool(
+				a => a.Id == 1 || a.Id == 2 || a.Id == 3 || a.Id == 4,
+				a => +a.Id(1) || +a.Id(2) || +a.Id(3) || +a.Id(4),
+				+Id(1) || +Id(2) || +Id(3) || +Id(4),
+				expectedCount: 4
+			);
+
+			await Bool(
+				a => a.Id == 1 || a.Id == 2 || a.Id == 3 || a.Id == 4 && (a.Option != E.Option1 || a.Option == E.Option2),
+				a => +a.Id(1) || +a.Id(2) || +a.Id(3) || +a.Id(4) && (!a.O(E.Option1) || a.O(E.Option2)),
+				+Id(1) || +Id(2) || +Id(3) || +Id(4) && (!O(E.Option1) || O(E.Option2)),
+				expectedCount: 4
+			);
+
+			await Bool(
+				a => a.Id == 1 || a.Id == 2 || a.Id == 3 || a.Id == 4 && a.Option != E.Option1 || a.Option == E.Option2,
+				a => +a.Id(1) || +a.Id(2) || +a.Id(3) || +a.Id(4) && !a.O(E.Option1) || a.O(E.Option2),
+				+Id(1) || +Id(2) || +Id(3) || +Id(4) && !O(E.Option1) || O(E.Option2),
+				expectedCount: 12
+			);
+		}
+	}
+}

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

@@ -135,7 +135,7 @@ private void AssertShape(IQueryContainer container)
 			complexBool.Should().NotBeNull();
 			//complex bool is 3 ors and the next simple nested or bool query also has 3 should clauses
 			//this can be rewritten to one boolquery with 6 clauses
-			complexBool.Should.Should().HaveCount(5);
+			complexBool.Should.Should().HaveCount(6);
 
 			//inner must nots
 			var mustNotsBool = (complexBool.Should.Cast<IQueryContainer>().FirstOrDefault(q => q.Bool != null && q.Bool.MustNot != null))?.Bool;

src/Tests/Tests.csproj

@@ -370,6 +370,7 @@
     <Compile Include="Modules\SnapshotAndRestore\Snapshot\SnapshotStatus\SnapshotStatusUrlTests.cs" />
     <Compile Include="Modules\SnapshotAndRestore\Snapshot\Snapshot\SnapshotApiTests.cs" />
     <Compile Include="Modules\SnapshotAndRestore\Snapshot\Snapshot\SnapshotUrlTests.cs" />
+    <Compile Include="QueryDsl\BoolDsl\BoolApiTests.cs" />
     <Compile Include="QueryDsl\BoolDsl\BoolDsl.doc.cs" />
     <Compile Include="QueryDsl\BoolDsl\Operators\UnaryAddOperatorUsageTests.cs" />
     <Compile Include="QueryDsl\BoolDsl\Operators\NotOperatorUsageTests.cs" />

src/Tests/tests.yaml

@@ -1,5 +1,5 @@
 # mode either u (unit test), i (integration test) or m (mixed mode)
-mode: u
+mode: i
 # the elasticsearch version that should be started
 elasticsearch_version: 2.0.1
 # whether we want to forcefully reseed on the node, if you are starting the tests with a node already running