[Backport 8.4] Add more integration and unit tests

src/Elastic.Clients.Elasticsearch/Common/UrlParameters/TaskId/TaskId.cs

@@ -5,6 +5,7 @@
 using System;
 using System.Diagnostics;
 using System.Globalization;
+using System.Runtime;
 using System.Text.Json;
 using System.Text.Json.Serialization;
 using Elastic.Transport;
@@ -71,6 +72,19 @@ public override int GetHashCode()
 
 internal sealed class TaskIdConverter : JsonConverter<TaskId>
 {
+	public override void WriteAsPropertyName(Utf8JsonWriter writer, TaskId value, JsonSerializerOptions options)
+	{
+		if (options.TryGetClientSettings(out var settings))
+		{
+			writer.WritePropertyName(value.GetString(settings));
+			return;
+		}
+
+		throw new JsonException("Unable to retrive client settings during property name serialization.");
+	}
+
+	public override TaskId ReadAsPropertyName(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options) => reader.GetString();
+
 	public override TaskId? Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
 	{
 		if (reader.TokenType == JsonTokenType.Null)

src/Elastic.Clients.Elasticsearch/_Generated/Api/ClearScrollRequest.g.cs

@@ -33,7 +33,10 @@ public sealed partial class ClearScrollRequest : PlainRequestBase<ClearScrollReq
 	{
 		internal override ApiUrls ApiUrls => ApiUrlsLookups.NoNamespaceClearScroll;
 		protected override HttpMethod HttpMethod => HttpMethod.DELETE;
-		protected override bool SupportsBody => false;
+		protected override bool SupportsBody => true;
+		[JsonInclude]
+		[JsonPropertyName("scroll_id")]
+		public Elastic.Clients.Elasticsearch.ScrollIds? ScrollId { get; set; }
 	}
 
 	public sealed partial class ClearScrollRequestDescriptor : RequestDescriptorBase<ClearScrollRequestDescriptor, ClearScrollRequestParameters>
@@ -45,9 +48,25 @@ public ClearScrollRequestDescriptor()
 
 		internal override ApiUrls ApiUrls => ApiUrlsLookups.NoNamespaceClearScroll;
 		protected override HttpMethod HttpMethod => HttpMethod.DELETE;
-		protected override bool SupportsBody => false;
+		protected override bool SupportsBody => true;
+		private Elastic.Clients.Elasticsearch.ScrollIds? ScrollIdValue { get; set; }
+
+		public ClearScrollRequestDescriptor ScrollId(Elastic.Clients.Elasticsearch.ScrollIds? scrollId)
+		{
+			ScrollIdValue = scrollId;
+			return Self;
+		}
+
 		protected override void Serialize(Utf8JsonWriter writer, JsonSerializerOptions options, IElasticsearchClientSettings settings)
 		{
+			writer.WriteStartObject();
+			if (ScrollIdValue is not null)
+			{
+				writer.WritePropertyName("scroll_id");
+				JsonSerializer.Serialize(writer, ScrollIdValue, options);
+			}
+
+			writer.WriteEndObject();
 		}
 	}
 }

tests/Tests.Configuration/tests.default.yaml

@@ -5,10 +5,10 @@
 # tracked by git).
 
 # mode either u (unit test), i (integration test) or m (mixed mode)
-mode: u
+mode: i
 # the elasticsearch version that should be started
 # Can be a snapshot version of sonatype or "latest" to get the latest snapshot of sonatype
-elasticsearch_version: 8.5.0-SNAPSHOT
+elasticsearch_version: 8.4.2
 # cluster filter allows you to only run the integration tests of a particular cluster (cluster suffix not needed)
 # cluster_filter:
 # whether we want to forcefully reseed on the node, if you are starting the tests with a node already running

tests/Tests.Core/ManagedElasticsearch/Clusters/ReindexCluster.cs

@@ -0,0 +1,12 @@
+// Licensed to Elasticsearch B.V under one or more agreements.
+// Elasticsearch B.V licenses this file to you under the Apache 2.0 License.
+// See the LICENSE file in the project root for more information.
+
+using Tests.Core.ManagedElasticsearch.NodeSeeders;
+
+namespace Tests.Core.ManagedElasticsearch.Clusters;
+
+public class ReindexCluster : ClientTestClusterBase
+{
+	protected override void SeedNode() => new DefaultSeeder(Client).SeedNodeNoData();
+}

tests/Tests/AsyncSearch/AsyncSearchApiTests.cs

@@ -14,159 +14,157 @@
 using Tests.Framework.EndpointTests.TestState;
 using System;
 
-namespace Tests.AsyncSearch
+namespace Tests.AsyncSearch;
+
+public class AsyncSearchApiTests : CoordinatedIntegrationTestBase<ReadOnlyCluster>
 {
-	public class AsyncSearchApiTests : CoordinatedIntegrationTestBase<ReadOnlyCluster>
-	{
-		private const string SubmitStep = nameof(SubmitStep);
-		private const string StatusStep = nameof(StatusStep);
-		private const string GetStep = nameof(GetStep);
-		private const string DeleteStep = nameof(DeleteStep);
+	private const string SubmitStep = nameof(SubmitStep);
+	private const string StatusStep = nameof(StatusStep);
+	private const string GetStep = nameof(GetStep);
+	private const string DeleteStep = nameof(DeleteStep);
 
-		public AsyncSearchApiTests(ReadOnlyCluster cluster, EndpointUsage usage) : base(new CoordinatedUsage(cluster, usage)
+	public AsyncSearchApiTests(ReadOnlyCluster cluster, EndpointUsage usage) : base(new CoordinatedUsage(cluster, usage)
+	{
 		{
-			{
-				SubmitStep, u =>
-				u.Calls<AsyncSearchSubmitRequestDescriptor<Project>, AsyncSearchSubmitRequest<Project>, AsyncSearchSubmitResponse<Project>>(
-					v => new AsyncSearchSubmitRequest<Project>
+			SubmitStep, u =>
+			u.Calls<AsyncSearchSubmitRequestDescriptor<Project>, AsyncSearchSubmitRequest<Project>, AsyncSearchSubmitResponse<Project>>(
+				v => new AsyncSearchSubmitRequest<Project>
+				{
+					Query = new MatchAllQuery(),
+					KeepOnCompletion = true,
+					WaitForCompletionTimeout = Duration.MinusOne,
+					Aggregations = new TermsAggregation("states")
 					{
-						Query = new MatchAllQuery(),
-						KeepOnCompletion = true,
-						WaitForCompletionTimeout = Duration.MinusOne,
-						Aggregations = new TermsAggregation("states")
+						Field = Infer.Field<Project>(p => p.State.Suffix("keyword")),
+						MinDocCount = 2,
+						Size = 5,
+						ShardSize = 100,
+						ExecutionHint = TermsAggregationExecutionHint.Map,
+						//Missing = "n/a",
+						// TODO - Review terms agg and fix this
+						//Include = new TermsInclude(new[] { StateOfBeing.Stable.ToString(), StateOfBeing.VeryActive.ToString() }),
+						Order =new []
 						{
-							Field = Infer.Field<Project>(p => p.State.Suffix("keyword")),
-							MinDocCount = 2,
-							Size = 5,
-							ShardSize = 100,
-							ExecutionHint = TermsAggregationExecutionHint.Map,
-							//Missing = "n/a",
+							AggregateOrder.KeyAscending,
+							AggregateOrder.CountDescending
+						},
+						Meta = new Dictionary<string, object> { { "foo", "bar" } }
+					}
+				},
+				(v, d) => d
+					.MatchAll()
+					.KeepOnCompletion()
+					.WaitForCompletionTimeout(-1)
+					.Aggregations(a => a
+						.Terms("states", st => st
+							.Field(p => p.State.Suffix("keyword"))
+							.MinDocCount(2)
+							.Size(5)
+							.ShardSize(100)
+							.ExecutionHint(TermsAggregationExecutionHint.Map)
+							//.Missing("n/a")
 							// TODO - Review terms agg and fix this
-							//Include = new TermsInclude(new[] { StateOfBeing.Stable.ToString(), StateOfBeing.VeryActive.ToString() }),
-							Order =new []
+							//.Include(new[] { StateOfBeing.Stable.ToString(), StateOfBeing.VeryActive.ToString() })
+							.Order(new []
 							{
 								AggregateOrder.KeyAscending,
 								AggregateOrder.CountDescending
-							},
-							Meta = new Dictionary<string, object> { { "foo", "bar" } }
-						}
-					},
-					(v, d) => d
-						.MatchAll()
-						.KeepOnCompletion()
-						.WaitForCompletionTimeout(-1)
-						.Aggregations(a => a
-							.Terms("states", st => st
-								.Field(p => p.State.Suffix("keyword"))
-								.MinDocCount(2)
-								.Size(5)
-								.ShardSize(100)
-								.ExecutionHint(TermsAggregationExecutionHint.Map)
-								//.Missing("n/a")
-								// TODO - Review terms agg and fix this
-								//.Include(new[] { StateOfBeing.Stable.ToString(), StateOfBeing.VeryActive.ToString() })
-								.Order(new []
-								{
-									AggregateOrder.KeyAscending,
-									AggregateOrder.CountDescending
-								})
-								.Meta(m => m
-									.Add("foo", "bar")
-								)
+							})
+							.Meta(m => m
+								.Add("foo", "bar")
 							)
-						),
-					(v, c, f) => c.AsyncSearch.Submit(f),
-					(v, c, f) => c.AsyncSearch.SubmitAsync(f),
-					(v, c, r) => c.AsyncSearch.Submit<Project>(r),
-					(v, c, r) => c.AsyncSearch.SubmitAsync<Project>(r),
-					onResponse: (r, values) => values.ExtendedValue("id", r.Id)
-				)
-			},
-			{
-				StatusStep, u =>
-				u.Calls<AsyncSearchStatusRequestDescriptor, AsyncSearchStatusRequest, AsyncSearchStatusResponse>(
-					v => new AsyncSearchStatusRequest(v),
-					(v, d) => d,
-					(v, c, f) => c.AsyncSearch.Status(v, f),
-					(v, c, f) => c.AsyncSearch.StatusAsync(v, f),
-					(v, c, r) => c.AsyncSearch.Status(r),
-					(v, c, r) => c.AsyncSearch.StatusAsync(r),
-					uniqueValueSelector: values => values.ExtendedValue<string>("id")
-				)
-			},
-			{
-				GetStep, u =>
-				u.Calls<GetAsyncSearchRequestDescriptor<Project>, GetAsyncSearchRequest, GetAsyncSearchResponse<Project>>(
-					v => new GetAsyncSearchRequest(v),
-					(v, d) => d,
-					(v, c, f) => c.AsyncSearch.Get(v, f),
-					(v, c, f) => c.AsyncSearch.GetAsync(v, f),
-					(v, c, r) => c.AsyncSearch.Get<Project>(r),
-					(v, c, r) => c.AsyncSearch.GetAsync<Project>(r),
-					uniqueValueSelector: values => values.ExtendedValue<string>("id")
-				)
-			},
-			{
-				DeleteStep, u =>
-				u.Calls<DeleteAsyncSearchRequestDescriptor, DeleteAsyncSearchRequest, DeleteAsyncSearchResponse>(
-					v => new DeleteAsyncSearchRequest(v),
-					(v, d) => d,
-					(v, c, f) => c.AsyncSearch.Delete(v, f),
-					(v, c, f) => c.AsyncSearch.DeleteAsync(v, f),
-					(v, c, r) => c.AsyncSearch.Delete(r),
-					(v, c, r) => c.AsyncSearch.DeleteAsync(r),
-					uniqueValueSelector: values => values.ExtendedValue<string>("id")
-				)
-			},
-		})
-		{ }
-
-		[I]
-		public async Task AsyncSearchSubmitResponse() => await Assert<AsyncSearchSubmitResponse<Project>>(SubmitStep, r =>
+						)
+					),
+				(v, c, f) => c.AsyncSearch.Submit(f),
+				(v, c, f) => c.AsyncSearch.SubmitAsync(f),
+				(v, c, r) => c.AsyncSearch.Submit<Project>(r),
+				(v, c, r) => c.AsyncSearch.SubmitAsync<Project>(r),
+				onResponse: (r, values) => values.ExtendedValue("id", r.Id)
+			)
+		},
 		{
-			r.ShouldBeValid();
-			r.Id.Should().NotBeNullOrEmpty();
-			// TODO - MORE ASSERTIONS
-			r.Response.Should().NotBeNull();
-			r.Response.Took.Should().BeGreaterOrEqualTo(0);
-		});
-
-		[I]
-		public async Task AsyncSearchStatusResponse() => await Assert<AsyncSearchStatusResponse>(StatusStep, r =>
+			StatusStep, u =>
+			u.Calls<AsyncSearchStatusRequestDescriptor, AsyncSearchStatusRequest, AsyncSearchStatusResponse>(
+				v => new AsyncSearchStatusRequest(v),
+				(v, d) => d,
+				(v, c, f) => c.AsyncSearch.Status(v, f),
+				(v, c, f) => c.AsyncSearch.StatusAsync(v, f),
+				(v, c, r) => c.AsyncSearch.Status(r),
+				(v, c, r) => c.AsyncSearch.StatusAsync(r),
+				uniqueValueSelector: values => values.ExtendedValue<string>("id")
+			)
+		},
+		{
+			GetStep, u =>
+			u.Calls<GetAsyncSearchRequestDescriptor<Project>, GetAsyncSearchRequest, GetAsyncSearchResponse<Project>>(
+				v => new GetAsyncSearchRequest(v),
+				(v, d) => d,
+				(v, c, f) => c.AsyncSearch.Get(v, f),
+				(v, c, f) => c.AsyncSearch.GetAsync(v, f),
+				(v, c, r) => c.AsyncSearch.Get<Project>(r),
+				(v, c, r) => c.AsyncSearch.GetAsync<Project>(r),
+				uniqueValueSelector: values => values.ExtendedValue<string>("id")
+			)
+		},
 		{
-			r.ShouldBeValid();
-			r.StartTimeInMillis.Should().BeGreaterThan(DateTimeOffset.UtcNow.AddMinutes(-10).ToUnixTimeMilliseconds());
-			r.StartTimeInMillis.Should().BeLessOrEqualTo(DateTimeOffset.UtcNow.ToUnixTimeMilliseconds());
-			r.ExpirationTimeInMillis.Should().BeGreaterOrEqualTo(DateTimeOffset.UtcNow.ToUnixTimeMilliseconds());
+			DeleteStep, u =>
+			u.Calls<DeleteAsyncSearchRequestDescriptor, DeleteAsyncSearchRequest, DeleteAsyncSearchResponse>(
+				v => new DeleteAsyncSearchRequest(v),
+				(v, d) => d,
+				(v, c, f) => c.AsyncSearch.Delete(v, f),
+				(v, c, f) => c.AsyncSearch.DeleteAsync(v, f),
+				(v, c, r) => c.AsyncSearch.Delete(r),
+				(v, c, r) => c.AsyncSearch.DeleteAsync(r),
+				uniqueValueSelector: values => values.ExtendedValue<string>("id")
+			)
+		},
+	})
+	{ }
+
+	[I]
+	public async Task AsyncSearchSubmitResponse() => await Assert<AsyncSearchSubmitResponse<Project>>(SubmitStep, r =>
+	{
+		r.ShouldBeValid();
+		r.Id.Should().NotBeNullOrEmpty();
+		r.Response.Should().NotBeNull();
+		r.Response.Took.Should().BeGreaterOrEqualTo(0);
+	});
 
-			if (r.IsRunning)
-				r.CompletionStatus.HasValue.Should().BeFalse();
-			else
-				r.CompletionStatus?.Should().Be(200);
+	[I]
+	public async Task AsyncSearchStatusResponse() => await Assert<AsyncSearchStatusResponse>(StatusStep, r =>
+	{
+		r.ShouldBeValid();
+		r.StartTimeInMillis.Should().BeGreaterThan(DateTimeOffset.UtcNow.AddMinutes(-10).ToUnixTimeMilliseconds());
+		r.StartTimeInMillis.Should().BeLessOrEqualTo(DateTimeOffset.UtcNow.ToUnixTimeMilliseconds());
+		r.ExpirationTimeInMillis.Should().BeGreaterOrEqualTo(DateTimeOffset.UtcNow.ToUnixTimeMilliseconds());
 
-			r.Shards.Total.Should().BeGreaterOrEqualTo(1);
-		});
+		if (r.IsRunning)
+			r.CompletionStatus.HasValue.Should().BeFalse();
+		else
+			r.CompletionStatus?.Should().Be(200);
 
-		[I]
-		public async Task AsyncSearchGetResponse() => await Assert<GetAsyncSearchResponse<Project>>(GetStep, (s, r) =>
-		{
-			r.ShouldBeValid();
-			r.Id.Should().NotBeNullOrEmpty();
-			r.StartTimeInMillis.Should().BeGreaterThan(DateTimeOffset.UtcNow.AddMinutes(-10).ToUnixTimeMilliseconds());
-			r.StartTimeInMillis.Should().BeLessOrEqualTo(DateTimeOffset.UtcNow.ToUnixTimeMilliseconds());
-			r.ExpirationTimeInMillis.Should().BeGreaterOrEqualTo(DateTimeOffset.UtcNow.ToUnixTimeMilliseconds());
-			r.Response.Should().NotBeNull();
-			r.Response.Took.Should().BeGreaterOrEqualTo(0);
-			r.Response.Hits.Should().HaveCount(10);
-			var terms = r.Response.Aggregations.GetTerms("states");
-			terms.Should().NotBeNull();
-		});
+		r.Shards.Total.Should().BeGreaterOrEqualTo(1);
+	});
 
-		[I]
-		public async Task AsyncSearchDeleteResponse() => await Assert<DeleteAsyncSearchResponse>(DeleteStep, r =>
-		{
-			r.ShouldBeValid();
-			r.Acknowledged.Should().BeTrue();
-		});
-	}
+	[I]
+	public async Task AsyncSearchGetResponse() => await Assert<GetAsyncSearchResponse<Project>>(GetStep, (s, r) =>
+	{
+		r.ShouldBeValid();
+		r.Id.Should().NotBeNullOrEmpty();
+		r.StartTimeInMillis.Should().BeGreaterThan(DateTimeOffset.UtcNow.AddMinutes(-10).ToUnixTimeMilliseconds());
+		r.StartTimeInMillis.Should().BeLessOrEqualTo(DateTimeOffset.UtcNow.ToUnixTimeMilliseconds());
+		r.ExpirationTimeInMillis.Should().BeGreaterOrEqualTo(DateTimeOffset.UtcNow.ToUnixTimeMilliseconds());
+		r.Response.Should().NotBeNull();
+		r.Response.Took.Should().BeGreaterOrEqualTo(0);
+		r.Response.Hits.Should().HaveCount(10);
+		var terms = r.Response.Aggregations.GetTerms("states");
+		terms.Should().NotBeNull();
+	});
+
+	[I]
+	public async Task AsyncSearchDeleteResponse() => await Assert<DeleteAsyncSearchResponse>(DeleteStep, r =>
+	{
+		r.ShouldBeValid();
+		r.Acknowledged.Should().BeTrue();
+	});
 }