Allow context to be specified on the painless execute API (#3435)

(cherry picked from commit ae5ae5b)

Author: Mpdreamz

src/Nest/Modules/Scripting/ExecutePainlessScript/ExecutePainlessScriptRequest.cs

@@ -3,23 +3,50 @@
 
 namespace Nest
 {
+	/// <summary> The Painless execute API allows an arbitrary script to be executed and a result to be returned. </summary>
 	public partial interface IExecutePainlessScriptRequest
 	{
+		/// <summary> The script to execute </summary>
 		[JsonProperty("script")]
 		IInlineScript Script { get; set; }
+
+		/// <summary> The context the script should be executed in </summary>
+		[JsonProperty("context")]
+		string Context { get; set; }
+
+		/// <inheritdoc cref="IPainlessContextSetup"/>
+		[JsonProperty("context_setup")]
+		IPainlessContextSetup ContextSetup { get; set; }
 	}
 
+	/// <inheritdoc cref="IExecutePainlessScriptRequest"/>
 	public partial class ExecutePainlessScriptRequest
 	{
+		/// <inheritdoc cref="IExecutePainlessScriptRequest.Script"/>
 		public IInlineScript Script { get; set; }
+		/// <inheritdoc cref="IExecutePainlessScriptRequest.Context"/>
+		public string Context { get; set; }
+		/// <inheritdoc cref="IExecutePainlessScriptRequest.ContextSetup"/>
+		public IPainlessContextSetup ContextSetup { get; set; }
 	}
 
+	/// <inheritdoc cref="IExecutePainlessScriptRequest"/>
 	[DescriptorFor("ScriptsPainlessExecute")]
 	public partial class ExecutePainlessScriptDescriptor
 	{
 		IInlineScript IExecutePainlessScriptRequest.Script { get; set; }
+		string IExecutePainlessScriptRequest.Context { get; set; }
+		IPainlessContextSetup IExecutePainlessScriptRequest.ContextSetup { get; set; }
 
+		/// <inheritdoc cref="IExecutePainlessScriptRequest.Script"/>
 		public ExecutePainlessScriptDescriptor Script(Func<InlineScriptDescriptor, IInlineScript> selector) =>
 			Assign(a => a.Script = selector?.Invoke(new InlineScriptDescriptor()));
+
+		/// <inheritdoc cref="IExecutePainlessScriptRequest.ContextSetup"/>
+		public ExecutePainlessScriptDescriptor ContextSetup(Func<PainlessContextSetupDescriptor, IPainlessContextSetup> selector) =>
+			Assign(a => a.ContextSetup = selector?.Invoke(new PainlessContextSetupDescriptor()));
+
+		/// <inheritdoc cref="IExecutePainlessScriptRequest.Context"/>
+		public ExecutePainlessScriptDescriptor Context(string context) => Assign(a => a.Context = context);
 	}
 }

src/Nest/Modules/Scripting/ExecutePainlessScript/PainlessContextSetup.cs

@@ -0,0 +1,55 @@
+using System;
+using Newtonsoft.Json;
+
+namespace Nest
+{
+	/// <summary>
+	/// Sets up contextual scope for the painless script the execute under.
+	/// </summary>
+	[JsonConverter(typeof(ReadAsTypeJsonConverter<PainlessContextSetup>))]
+	public interface IPainlessContextSetup
+	{
+		/// <summary>
+		/// Contains the document that will be temporarily indexed in-memory and is accessible from the script.
+		/// </summary>
+		[JsonProperty("document")]
+		object Document { get; set; }
+		/// <summary>
+		/// The name of an index containing a mapping that is compatible with the document being indexed.
+		/// </summary>
+		[JsonProperty("index")]
+		IndexName Index { get; set; }
+		/// <summary>
+		/// If _score is used in the script then a query can specified that will be used to compute a score.
+		/// </summary>
+		[JsonProperty("query")]
+		QueryContainer Query { get; set; }
+	}
+
+	/// <inheritdoc cref="IPainlessContextSetup"/>
+	public class PainlessContextSetup : IPainlessContextSetup
+	{
+		/// <inheritdoc cref="IPainlessContextSetup.Document"/>
+		public object Document { get; set; }
+		/// <inheritdoc cref="IPainlessContextSetup.Index"/>
+		public IndexName Index { get; set; }
+		/// <inheritdoc cref="IPainlessContextSetup.Query"/>
+		public QueryContainer Query { get; set; }
+	}
+
+	/// <inheritdoc cref="IPainlessContextSetup"/>
+	public class PainlessContextSetupDescriptor : DescriptorBase<PainlessContextSetupDescriptor, IPainlessContextSetup>, IPainlessContextSetup
+	{
+		object IPainlessContextSetup.Document { get; set; }
+		IndexName IPainlessContextSetup.Index { get; set; }
+		QueryContainer IPainlessContextSetup.Query { get; set; }
+
+		/// <inheritdoc cref="IPainlessContextSetup.Document"/>
+		public PainlessContextSetupDescriptor Document<T>(T document) => Assign(a => a.Document = document);
+		/// <inheritdoc cref="IPainlessContextSetup.Index"/>
+		public PainlessContextSetupDescriptor Index(IndexName index) => Assign(a => a.Index = index);
+		/// <inheritdoc cref="IPainlessContextSetup.Query"/>
+		public PainlessContextSetupDescriptor Query<T>(Func<QueryContainerDescriptor<T>, QueryContainer> querySelector) where T : class =>
+			Assign(a => a.Query = querySelector?.Invoke(new QueryContainerDescriptor<T>()));
+	}
+}

src/Tests/Tests/Framework/EndpointTests/TestState/CallUniqueValues.cs

@@ -6,10 +6,15 @@
 
 namespace Tests.Framework.Integration
 {
+	/// <summary>
+	/// Holds unique values for the the two DSL's and the exposed sync and async methods we expose
+	/// <see cref="ClientMethod"/>
+	/// </summary>
 	public class CallUniqueValues : Dictionary<ClientMethod, string>
 	{
 		private readonly string _prefix;
 		private string UniqueValue => $"{this._prefix}-{ViewName}-{Guid.NewGuid().ToString("N").Substring(0, 8)}";
+    public string FixedForAllCallsValue { get; }
 
 		private IDictionary<ClientMethod, ConcurrentDictionary<string, object>> ExtendedValues { get; }
 			= new Dictionary<ClientMethod, ConcurrentDictionary<string, object>>();
@@ -28,6 +33,7 @@ public T ExtendedValue<T>(string key, Func<T> value) where T : class =>
 		public CallUniqueValues(string prefix = "nest")
 		{
 			this._prefix = prefix;
+      this.FixedForAllCallsValue = this.UniqueValue;
 			this.SetupClientMethod(Fluent);
 			this.SetupClientMethod(FluentAsync);
 			this.SetupClientMethod(Initializer);

src/Tests/Tests/Modules/Scripting/ExecutePainlessScript/ExecutePainlessScriptApiTests.cs

@@ -1,6 +1,5 @@
 using System;
 using System.Collections.Generic;
-using System.Threading.Tasks;
 using Elastic.Xunit.XunitPlumbing;
 using Elasticsearch.Net;
 using FluentAssertions;
@@ -9,8 +8,6 @@
 using Tests.Core.ManagedElasticsearch.Clusters;
 using Tests.Framework;
 using Tests.Framework.Integration;
-using Tests.Framework.ManagedElasticsearch.Clusters;
-using Xunit;
 
 namespace Tests.Modules.Scripting.ExecutePainlessScript
 {
@@ -69,4 +66,90 @@ protected override void ExpectResponse(IExecutePainlessScriptResponse<string> re
 			response.Result.Should().NotBeNullOrWhiteSpace();
 		}
 	}
+
+	[SkipVersion("<6.4.0", "Context only tested on 6.4.0 when they were introduced")]
+	public class ExecutePainlessScriptContextApiTests
+		: ApiIntegrationTestBase<WritableCluster, IExecutePainlessScriptResponse<string>, IExecutePainlessScriptRequest, ExecutePainlessScriptDescriptor, ExecutePainlessScriptRequest>
+	{
+		public ExecutePainlessScriptContextApiTests(WritableCluster cluster, EndpointUsage usage) : base(cluster, usage) { }
+
+		private static readonly string _painlessScript = "doc['rank'].value / params.max_rank";
+
+		protected override LazyResponses ClientUsage() => Calls(
+			fluent: (client, f) => client.ExecutePainlessScript<string>(f),
+			fluentAsync: (client, f) => client.ExecutePainlessScriptAsync<string>(f),
+			request: (client, r) => client.ExecutePainlessScript<string>(r),
+			requestAsync: (client, r) => client.ExecutePainlessScriptAsync<string>(r)
+		);
+
+		protected override HttpMethod HttpMethod => HttpMethod.POST;
+		protected override string UrlPath => "/_scripts/painless/_execute";
+		protected override int ExpectStatusCode => 200;
+		protected override bool ExpectIsValid => true;
+		protected override bool SupportsDeserialization => false;
+
+		private class ScriptDocument
+		{
+			public string Field { get; set; }
+			public long Rank  { get; set; }
+		}
+
+		protected override void IntegrationSetup(IElasticClient client, CallUniqueValues values)
+		{
+			var create =client.CreateIndex(values.FixedForAllCallsValue, c => c.Mappings(map => map.Map<ScriptDocument>(m => m.AutoMap())));
+			create.ShouldBeValid();
+		}
+
+		protected override object ExpectJson => new
+		{
+			context = "score",
+			context_setup = new
+			{
+				document = new { rank = 4 },
+				index = this.UniqueValues.FixedForAllCallsValue,
+				query = new { match_all = new {} }
+			},
+			script = new
+			{
+				source = _painlessScript,
+				@params = new { max_rank = 5.0 }
+			},
+		};
+
+		protected override Func<ExecutePainlessScriptDescriptor, IExecutePainlessScriptRequest> Fluent => d => d
+			.ContextSetup(cs=>cs
+				.Index(this.UniqueValues.FixedForAllCallsValue)
+				.Document(new ScriptDocument { Rank = 4 })
+				.Query<ScriptDocument>(q=>q.MatchAll())
+			)
+			.Context("score")
+			.Script(s=>s
+				.Source(_painlessScript)
+				.Params(p => p.Add("max_rank", 5.0))
+			);
+
+		protected override ExecutePainlessScriptRequest Initializer => new ExecutePainlessScriptRequest
+		{
+			ContextSetup = new PainlessContextSetup
+			{
+				Index = this.UniqueValues.FixedForAllCallsValue,
+				Document =  new ScriptDocument { Rank = 4 },
+				Query = new MatchAllQuery()
+			},
+			Context = "score",
+			Script = new InlineScript(_painlessScript)
+			{
+				Params = new Dictionary<string, object>
+				{
+					{ "max_rank", 5.0 },
+				}
+			}
+		};
+
+		protected override void ExpectResponse(IExecutePainlessScriptResponse<string> response)
+		{
+			response.ShouldBeValid();
+			response.Result.Should().NotBeNullOrWhiteSpace();
+		}
+	}
 }