The task cancel API test was a bit flakey,

It was setting additional values in the integration setup on the class
itself but this setup is run once for possibly multiple classes e.g

EndpointUsage x;
new TestClass(x).Test1();
new TestClass(x).Test2();
new TestClass(x).Test3();
new TestClass(x).Test4();
new TestClass(x).Test5();

integration setup is an override per TestClass but only one of them will
be called per instance of `x`. So if the callback defines setting
variables on the `TestClass` instance using `this` other TestClass
instances won't see this.

This PR makes CallIsolatedValues a class of its own that allows you to
register extended values that can be shared amongst all TestClass
instances.

Author: Mpdreamz

src/Tests/Cat/CatRepositories/CatRepositoriesApiTests.cs

@@ -17,10 +17,10 @@ public class CatRepositoriesApiTests : ApiIntegrationTestBase<ICatResponse<CatRe
 
 		public CatRepositoriesApiTests(IndexingCluster cluster, EndpointUsage usage) : base(cluster, usage) { }
 
-		protected override void BeforeAllCalls(IElasticClient client, IDictionary<ClientMethod, string> values)
+		protected override void IntegrationSetup(IElasticClient client, CallUniqueValues values)
 		{
 			if (!TestClient.Configuration.RunIntegrationTests) return;
-			var repositoryLocation = Path.Combine(this._cluster.Node.RepositoryPath, RandomString());
+			var repositoryLocation = Path.Combine(this.Cluster.Node.RepositoryPath, RandomString());
 
 			var create = this.Client.CreateRepository(RepositoryName, cr => cr
 				.FileSystem(fs => fs

src/Tests/Cat/CatSnapshots/CatSnapshotsApiTests.cs

@@ -19,10 +19,10 @@ public class CatSnapshotsApiTests : ApiIntegrationTestBase<ICatResponse<CatSnaps
 
 		public CatSnapshotsApiTests(IndexingCluster cluster, EndpointUsage usage) : base(cluster, usage) { }
 
-		protected override void BeforeAllCalls(IElasticClient client, IDictionary<ClientMethod, string> values)
+		protected override void IntegrationSetup(IElasticClient client, CallUniqueValues values)
 		{
 			if (!TestClient.Configuration.RunIntegrationTests) return;
-			var repositoryLocation = Path.Combine(this._cluster.Node.RepositoryPath, RandomString());
+			var repositoryLocation = Path.Combine(this.Cluster.Node.RepositoryPath, RandomString());
 
 			var create = this.Client.CreateRepository(RepositoryName, cr => cr
 				.FileSystem(fs => fs

src/Tests/Framework/EndpointTests/ApiTestBase.cs

@@ -16,87 +16,110 @@ public abstract class ApiTestBase<TResponse, TInterface, TDescriptor, TInitializ
 		where TInitializer : class, TInterface
 		where TInterface : class
 	{
-		protected readonly IIntegrationCluster _cluster;
+		private readonly EndpointUsage _usage;
 		private readonly LazyResponses _responses;
+		private readonly int _port;
+		private readonly CallUniqueValues _uniqueValues;
 
 		protected static string RandomString() => Guid.NewGuid().ToString("N").Substring(0, 8);
-		protected virtual ConnectionSettings GetConnectionSettings(ConnectionSettings settings) => settings;
-		protected virtual IElasticClient Client => this._cluster.Client(GetConnectionSettings);
+		protected bool RanIntegrationSetup => this._usage?.CalledSetup ?? false;
+
+		protected IIntegrationCluster Cluster { get; }
 
-		protected IDictionary<Integration.ClientMethod, string> UniqueValues { get; }
-		protected string CallIsolatedValue { get; private set; }
+		protected string CallIsolatedValue => _uniqueValues.Value;
+		protected T ExtendedValue<T>(string key) where T : class => this._uniqueValues.ExtendedValue<T>(key);
 
-		protected virtual void BeforeAllCalls(IElasticClient client, IDictionary<Integration.ClientMethod, string> values) { }
+		protected virtual void IntegrationSetup(IElasticClient client, CallUniqueValues values) { }
 		protected virtual void OnBeforeCall(IElasticClient client) { }
 		protected virtual void OnAfterCall(IElasticClient client) { }
 
-		protected virtual int Port { get; set; } = 9200;
+		protected IElasticClient Client => this.Cluster.Client(GetConnectionSettings);
+		protected virtual ConnectionSettings GetConnectionSettings(ConnectionSettings settings) => settings;
 
-		protected virtual TInitializer Initializer { get; }
+		protected virtual TDescriptor NewDescriptor() => Activator.CreateInstance<TDescriptor>();
 		protected virtual Func<TDescriptor, TInterface> Fluent { get; }
+		protected virtual TInitializer Initializer { get; }
 
-		protected virtual TDescriptor ClientDoesThisInternally(TDescriptor d) => d;
 		protected abstract LazyResponses ClientUsage();
 
-		protected virtual TDescriptor NewDescriptor() => Activator.CreateInstance<TDescriptor>();
-
 		protected abstract string UrlPath { get; }
 		protected abstract HttpMethod HttpMethod { get; }
 
 		protected ApiTestBase(IIntegrationCluster cluster, EndpointUsage usage)
 		{
-			this._cluster = cluster;
+			this._usage = usage;
+			this.Cluster = cluster;
+
 			this._responses = usage.CallOnce(this.ClientUsage);
-			this.Port = cluster.Node.Port;
-			this.UniqueValues = usage.CallUniqueValues;
-			this.CallIsolatedValue = UniqueValues[Integration.ClientMethod.Fluent];
+			this._port = cluster.Node.Port;
+			this._uniqueValues = usage.CallUniqueValues;
 			this.SetupSerialization();
 		}
 
-		protected virtual LazyResponses Calls(
+		[U] protected async Task HitsTheCorrectUrl() =>
+			await this.AssertOnAllResponses(r => this.AssertUrl(r.ApiCall.Uri));
+
+		[U] protected async Task UsesCorrectHttpMethod() =>
+			await this.AssertOnAllResponses(r => r.CallDetails.HttpMethod.Should().Be(this.HttpMethod));
+
+		[U] protected void SerializesInitializer() =>
+			this.AssertSerializesAndRoundTrips<TInterface>(this.Initializer);
+
+		[U] protected void SerializesFluent() =>
+			this.AssertSerializesAndRoundTrips(this.Fluent?.Invoke(NewDescriptor()));
+
+		protected LazyResponses Calls(
 			Func<IElasticClient, Func<TDescriptor, TInterface>, TResponse> fluent,
 			Func<IElasticClient, Func<TDescriptor, TInterface>, Task<TResponse>> fluentAsync,
 			Func<IElasticClient, TInitializer, TResponse> request,
 			Func<IElasticClient, TInitializer, Task<TResponse>> requestAsync
 		)
 		{
+			//this client is outside the lambda so that the callstack is one where we can get the method name
+			//of the current running test and send that as a header, great for e.g fiddler to relate requests with the test that sent it
 			var client = this.Client;
 			return new LazyResponses(async () =>
 			{
-				this.BeforeAllCalls(client, UniqueValues);
+				if (TestClient.Configuration.RunIntegrationTests)
+				{
+					this.IntegrationSetup(client, _uniqueValues);
+				}
+
+				this._usage.CalledSetup = true;
 
 				var dict = new Dictionary<ClientMethod, IResponse>();
-				this.CallIsolatedValue = UniqueValues[ClientMethod.Fluent];
+				_uniqueValues.CurrentView = ClientMethod.Fluent;
+
 				OnBeforeCall(client);
 				dict.Add(ClientMethod.Fluent, fluent(client, this.Fluent));
 				OnAfterCall(client);
 
-				this.CallIsolatedValue = UniqueValues[ClientMethod.FluentAsync];
+				_uniqueValues.CurrentView = ClientMethod.FluentAsync;
 				OnBeforeCall(client);
 				dict.Add(ClientMethod.FluentAsync, await fluentAsync(client, this.Fluent));
 				OnAfterCall(client);
 
-				this.CallIsolatedValue = UniqueValues[ClientMethod.Initializer];
+				_uniqueValues.CurrentView = ClientMethod.Initializer;
 				OnBeforeCall(client);
 				dict.Add(ClientMethod.Initializer, request(client, this.Initializer));
 				OnAfterCall(client);
 
-				this.CallIsolatedValue = UniqueValues[ClientMethod.InitializerAsync];
+				_uniqueValues.CurrentView = ClientMethod.InitializerAsync;
 				OnBeforeCall(client);
 				dict.Add(ClientMethod.InitializerAsync, await requestAsync(client, this.Initializer));
 				OnAfterCall(client);
 				return dict;
 			});
 		}
 
-		protected virtual void AssertUrl(Uri u)
+		private void AssertUrl(Uri u)
 		{
 			var paths = (this.UrlPath ?? "").Split(new[] { '?' }, 2);
 			string path = paths.First(), query = string.Empty;
 			if (paths.Length > 1)
 				query = paths.Last();
 
-			var expectedUri = new UriBuilder("http", "localhost", Port, path, "?" + query).Uri;
+			var expectedUri = new UriBuilder("http", "localhost", this._port, path, "?" + query).Uri;
 
 			u.AbsolutePath.Should().Be(expectedUri.AbsolutePath);
 			u = new UriBuilder(u.Scheme, u.Host, u.Port, u.AbsolutePath, u.Query.Replace("pretty=true&", "").Replace("pretty=true", "")).Uri;
@@ -131,7 +154,7 @@ protected virtual async Task AssertOnAllResponses(Action<TResponse> assert)
 				var response = kv.Value as TResponse;
 				try
 				{
-					this.CallIsolatedValue = UniqueValues[kv.Key];
+					this._uniqueValues.CurrentView = kv.Key;
 					assert(response);
 				}
 #pragma warning disable 7095 //enable this if you expect a single overload to act up
@@ -143,16 +166,5 @@ protected virtual async Task AssertOnAllResponses(Action<TResponse> assert)
 			}
 		}
 
-		[U] protected async Task HitsTheCorrectUrl() =>
-			await this.AssertOnAllResponses(r => this.AssertUrl(r.ApiCall.Uri));
-
-		[U] protected async Task UsesCorrectHttpMethod() =>
-			await this.AssertOnAllResponses(r => r.CallDetails.HttpMethod.Should().Be(this.HttpMethod));
-
-		[U] protected void SerializesInitializer() =>
-			this.AssertSerializesAndRoundTrips<TInterface>(this.Initializer);
-
-		[U] protected void SerializesFluent() =>
-			this.AssertSerializesAndRoundTrips(this.Fluent?.Invoke(this.ClientDoesThisInternally(NewDescriptor())));
 	}
 }

src/Tests/Framework/Integration/CallUniqueValues.cs

@@ -0,0 +1,33 @@
+using System;
+using System.Collections.Generic;
+
+namespace Tests.Framework.Integration
+{
+	public class CallUniqueValues : Dictionary<ClientMethod, string>
+	{
+		private string UniqueValue => "nest-" + Guid.NewGuid().ToString("N").Substring(0, 8);
+
+		private IDictionary<ClientMethod, IDictionary<string, object>> ExtendedValues { get; }
+			= new Dictionary<ClientMethod, IDictionary<string, object>>();
+
+		public ClientMethod CurrentView { get; set; } = ClientMethod.Fluent;
+		public ClientMethod[] Views { get; } = new[] { ClientMethod.Fluent, ClientMethod.FluentAsync, ClientMethod.Initializer, ClientMethod.InitializerAsync };
+
+		public string Value => this[CurrentView];
+		public T ExtendedValue<T>(string key) where T : class => this.ExtendedValues[CurrentView][key] as T;
+		public void ExtendedValue<T>(string key, T value) where T : class => this.ExtendedValues[CurrentView][key] = value;
+
+		public CallUniqueValues()
+		{
+			this.Add(ClientMethod.Fluent, this.UniqueValue);
+			this.Add(ClientMethod.FluentAsync, this.UniqueValue);
+			this.Add(ClientMethod.Initializer, this.UniqueValue);
+			this.Add(ClientMethod.InitializerAsync, this.UniqueValue);
+
+			this.ExtendedValues.Add(ClientMethod.Fluent, new Dictionary<string, object>());
+			this.ExtendedValues.Add(ClientMethod.FluentAsync, new Dictionary<string, object>());
+			this.ExtendedValues.Add(ClientMethod.Initializer, new Dictionary<string, object>());
+			this.ExtendedValues.Add(ClientMethod.InitializerAsync, new Dictionary<string, object>());
+		}
+	}
+}

src/Tests/Framework/Integration/ClientMethod.cs

@@ -0,0 +1,10 @@
+namespace Tests.Framework.Integration
+{
+	public enum ClientMethod
+	{
+		Fluent,
+		FluentAsync,
+		Initializer,
+		InitializerAsync
+	}
+}

src/Tests/tests.yaml

@@ -1,5 +1,5 @@
 # mode either u (unit test), i (integration test) or m (mixed mode)
-mode: m
+mode: u
 # 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: 5.0.0-alpha3