Expose Response on GetTaskResponse (#3966)

* Expose Response on GetTaskResponse

This commit exposes Response on GetTaskResponse. Response is the response object for the action performed by the Task, so will vary by action. For this reason, expose Response as an internal LazyDocument, with a method to retrieve a TResponse from the deserialized LazyDocument bytes.

* Deserialize response with RequestResponseSerializer

This commit updates the GetResponse<T>() impl on GetTaskResponse to use the RequestResponseDeserializer when deserializing the LazyDocument. This is exposed as an internal method only.
Remove LazyDocument ctor overloads that are superfluous.

Closes #3963

(cherry picked from commit ba5b1b1)

Author: russcam

src/Nest/Cluster/TaskManagement/GetTask/GetTaskResponse.cs

@@ -1,4 +1,5 @@
 using System.Runtime.Serialization;
+using Elasticsearch.Net;
 
 namespace Nest
 {
@@ -9,5 +10,15 @@ public class GetTaskResponse : ResponseBase
 
 		[DataMember(Name = "task")]
 		public TaskInfo Task { get; internal set; }
+
+		[DataMember(Name = "response")]
+		internal LazyDocument Response { get; set; }
+
+		/// <summary>
+		/// Gets the response for the request that the task represents, if available.
+		/// Because the response will have no associated <see cref="ApiCallDetails"/>, the value
+		/// of <see cref="IResponse.IsValid"/> should not be used.
+		/// </summary>
+		public TResponse GetResponse<TResponse>() where TResponse : class, IResponse => Response?.AsUsingRequestResponseSerializer<TResponse>();
 	}
 }

src/Nest/CommonAbstractions/LazyDocument/LazyDocument.cs

@@ -45,51 +45,53 @@ public interface ILazyDocument
 	[JsonFormatter(typeof(LazyDocumentFormatter))]
 	public class LazyDocument : ILazyDocument
 	{
-		private readonly IElasticsearchSerializer _serializer;
+		private readonly IElasticsearchSerializer _sourceSerializer;
+		private readonly IElasticsearchSerializer _requestResponseSerializer;
 		private readonly IMemoryStreamFactory _memoryStreamFactory;
 
-		internal LazyDocument(byte[] bytes, IJsonFormatterResolver formatterResolver) 
-			: this(bytes, formatterResolver.GetConnectionSettings()) { }
-
-		private LazyDocument(byte[] bytes, IConnectionSettingsValues settings) :
-			this(bytes, settings.SourceSerializer, settings.MemoryStreamFactory) { }
-		
-		private LazyDocument(byte[] bytes, IElasticsearchSerializer serializer, IMemoryStreamFactory memoryStreamFactory)
+		internal LazyDocument(byte[] bytes, IJsonFormatterResolver formatterResolver)
 		{
 			Bytes = bytes;
-			_serializer = serializer;
-			_memoryStreamFactory = memoryStreamFactory;
+			var settings = formatterResolver.GetConnectionSettings();
+			_sourceSerializer = settings.SourceSerializer;
+			_requestResponseSerializer = settings.RequestResponseSerializer;
+			_memoryStreamFactory = settings.MemoryStreamFactory;
 		}
 
-
 		internal byte[] Bytes { get; }
 
+		internal T AsUsingRequestResponseSerializer<T>()
+		{
+			using (var ms = _memoryStreamFactory.Create(Bytes))
+				return _requestResponseSerializer.Deserialize<T>(ms);
+		}
+
 		/// <inheritdoc />
 		public T As<T>()
 		{
 			using (var ms = _memoryStreamFactory.Create(Bytes))
-				return _serializer.Deserialize<T>(ms);
+				return _sourceSerializer.Deserialize<T>(ms);
 		}
 
 		/// <inheritdoc />
 		public object As(Type objectType)
 		{
 			using (var ms = _memoryStreamFactory.Create(Bytes))
-				return _serializer.Deserialize(objectType, ms);
+				return _sourceSerializer.Deserialize(objectType, ms);
 		}
-		
+
 		/// <inheritdoc />
 		public Task<T> AsAsync<T>(CancellationToken ct = default)
 		{
 			using (var ms = _memoryStreamFactory.Create(Bytes))
-				return _serializer.DeserializeAsync<T>(ms, ct);
+				return _sourceSerializer.DeserializeAsync<T>(ms, ct);
 		}
 
 		/// <inheritdoc />
 		public Task<object> AsAsync(Type objectType, CancellationToken ct = default)
 		{
 			using (var ms = _memoryStreamFactory.Create(Bytes))
-				return _serializer.DeserializeAsync(objectType, ms, ct);
+				return _sourceSerializer.DeserializeAsync(objectType, ms, ct);
 		}
 	}
 }

src/Tests/Tests/Cluster/TaskManagement/GetTask/GetTaskApiTests.cs

@@ -1,4 +1,5 @@
 using System;
+using System.Threading;
 using Elasticsearch.Net;
 using FluentAssertions;
 using Nest;
@@ -79,4 +80,97 @@ protected override void IntegrationSetup(IElasticClient client, CallUniqueValues
 			_taskId = response.Task;
 		}
 	}
+
+	/// <summary>
+	/// Similar to GetTaskApiTests, except the test is not performed until after the task is completed,
+	/// so that the response to which the task relates is available on GetTaskResponse
+	/// </summary>
+	public class GetTaskApiCompletedTaskTests : GetTaskApiTests
+	{
+		private static TaskId _taskId = new TaskId("fakeid:1");
+
+		public GetTaskApiCompletedTaskTests(WritableCluster cluster, EndpointUsage usage) : base(cluster, usage) { }
+
+		protected override bool ExpectIsValid => true;
+		protected override int ExpectStatusCode => 200;
+
+		protected override Func<GetTaskDescriptor, IGetTaskRequest> Fluent => s => s;
+		protected override HttpMethod HttpMethod => HttpMethod.GET;
+
+		protected override GetTaskRequest Initializer => new GetTaskRequest(_taskId);
+		protected override string UrlPath => $"/_tasks/fakeid%3A1";
+
+		protected override LazyResponses ClientUsage() => Calls(
+			(client, f) => client.Tasks.GetTask(_taskId, f),
+			(client, f) => client.Tasks.GetTaskAsync(_taskId, f),
+			(client, r) => client.Tasks.GetTask(r),
+			(client, r) => client.Tasks.GetTaskAsync(r)
+		);
+
+		protected override GetTaskDescriptor NewDescriptor() => new GetTaskDescriptor(_taskId);
+
+		protected override void ExpectResponse(GetTaskResponse response)
+		{
+			response.ShouldBeValid();
+			response.Task.Should().NotBeNull();
+			response.Completed.Should().BeTrue();
+
+			var task = response.Task;
+			task.Node.Should().NotBeNullOrEmpty();
+			task.Id.Should().BeGreaterThan(0);
+			task.Type.Should().Be("transport");
+			task.Action.Should().Be("indices:data/write/reindex");
+			task.Status.Should().NotBeNull();
+			task.StartTimeInMilliseconds.Should().BeGreaterThan(0);
+			task.RunningTimeInNanoseconds.Should().BeGreaterThan(0);
+			task.Cancellable.Should().BeTrue();
+
+			var reindexResponse = response.GetResponse<ReindexOnServerResponse>();
+			reindexResponse.Should().NotBeNull();
+			reindexResponse.Took.Should().BeGreaterThan(0);
+			reindexResponse.Failures.Should().BeEmpty();
+		}
+
+		protected override void IntegrationSetup(IElasticClient client, CallUniqueValues values)
+		{
+			// get a suitable load of projects in order to get a decent task status out
+			var sourceIndex = "project-get-completed-task";
+			var targetIndex = "tasks-lists-completed-get";
+			var bulkResponse = client.IndexMany(Project.Generator.Generate(500), sourceIndex);
+			if (!bulkResponse.IsValid)
+				throw new Exception("failure in setting up integration");
+
+			var createIndex = client.Indices.Create(targetIndex, i => i
+				.Settings(settings => settings.Analysis(DefaultSeeder.ProjectAnalysisSettings))
+				.Map<Project>(DefaultSeeder.ProjectTypeMappings)
+			);
+			createIndex.ShouldBeValid();
+
+			var response = client.ReindexOnServer(r => r
+				.Source(s => s.Index(sourceIndex))
+				.Destination(d => d
+					.Index(targetIndex)
+					.OpType(OpType.Create)
+				)
+				.Conflicts(Conflicts.Proceed)
+				.WaitForCompletion(false)
+				.Refresh()
+			);
+
+			_taskId = response.Task;
+
+			// poll until task is complete
+			var getTaskResponse = client.Tasks.GetTask(_taskId);
+			var completed = getTaskResponse.Completed;
+			while (!completed)
+			{
+				Thread.Sleep(2000);
+				getTaskResponse = client.Tasks.GetTask(_taskId);
+				if (getTaskResponse.IsValid)
+					completed = getTaskResponse.Completed;
+				else
+					throw new Exception($"problem setting up completed task: {getTaskResponse.DebugInformation}");
+			}
+		}
+	}
 }