Fix test for random initialized node (#4134) (#4144)

The test was using a local method that yielded a single pool while later .Take(50)
was requested on this sequence. This always yields an enumeration with 1 element
which increases the chances for the assertion to turn false.

Rather than relying on Thread.Sleep to create different seeded randoms the StaticConnectionPool
now defines a protected constructor that allows one to pass in a seed value.

(cherry picked from commit 9734f04)

Author: russcam

src/Elasticsearch.Net/ConnectionPool/SniffingConnectionPool.cs

@@ -17,7 +17,7 @@ public SniffingConnectionPool(IEnumerable<Node> nodes, bool randomize = true, ID
 			: base(nodes, randomize, dateTimeProvider) { }
 
 		public SniffingConnectionPool(IEnumerable<Node> nodes, Func<Node, float> nodeScorer, IDateTimeProvider dateTimeProvider = null)
-			: base(nodes, nodeScorer, false, dateTimeProvider) { }
+			: base(nodes, nodeScorer, dateTimeProvider) { }
 
 		/// <inheritdoc />
 		public override IReadOnlyCollection<Node> Nodes

src/Elasticsearch.Net/ConnectionPool/StaticConnectionPool.cs

@@ -12,18 +12,36 @@ public class StaticConnectionPool : IConnectionPool
 		private readonly Func<Node, float> _nodeScorer;
 
 		public StaticConnectionPool(IEnumerable<Uri> uris, bool randomize = true, IDateTimeProvider dateTimeProvider = null)
-			: this(uris.Select(uri => new Node(uri)), randomize, dateTimeProvider) { }
+			: this(uris.Select(uri => new Node(uri)), randomize, null, dateTimeProvider) { }
 
 		public StaticConnectionPool(IEnumerable<Node> nodes, bool randomize = true, IDateTimeProvider dateTimeProvider = null)
-			: this(nodes, null, randomize, dateTimeProvider) { }
+			: this(nodes, randomize, null, dateTimeProvider) { }
 
+		protected StaticConnectionPool(IEnumerable<Node> nodes, bool randomize, int? randomizeSeed = null, IDateTimeProvider dateTimeProvider = null)
+		{
+			Randomize = randomize;
+			Random = !randomize || !randomizeSeed.HasValue
+				? new Random()
+				: new Random(randomizeSeed.Value);
+
+			Initialize(nodes, dateTimeProvider);
+		}
 		//this constructor is protected because nodeScorer only makes sense on subclasses that support reseeding
 		//otherwise just manually sort `nodes` before instantiating.
-		protected StaticConnectionPool(IEnumerable<Node> nodes, Func<Node, float> nodeScorer = null, bool randomize = true, IDateTimeProvider dateTimeProvider = null)
+		protected StaticConnectionPool(IEnumerable<Node> nodes, Func<Node, float> nodeScorer = null, IDateTimeProvider dateTimeProvider = null)
 		{
-			nodes.ThrowIfEmpty(nameof(nodes));
+			_nodeScorer = nodeScorer;
+			Initialize(nodes, dateTimeProvider);
+		}
+
+		private void Initialize(IEnumerable<Node> nodes, IDateTimeProvider dateTimeProvider)
+		{
+			var nodesProvided = nodes?.ToList() ?? throw new ArgumentNullException(nameof(nodes));
+			nodesProvided.ThrowIfEmpty(nameof(nodes));
+			DateTimeProvider = dateTimeProvider ?? Net.DateTimeProvider.Default;
+
 			string scheme = null;
-			foreach (var node in nodes)
+			foreach (var node in nodesProvided)
 			{
 				if (scheme == null)
 				{
@@ -34,10 +52,7 @@ protected StaticConnectionPool(IEnumerable<Node> nodes, Func<Node, float> nodeSc
 					throw new ArgumentException("Trying to instantiate a connection pool with mixed URI Schemes");
 			}
 
-			DateTimeProvider = dateTimeProvider ?? Net.DateTimeProvider.Default;
-			Randomize = randomize;
-			_nodeScorer = nodeScorer;
-			InternalNodes = SortNodes(nodes)
+			InternalNodes = SortNodes(nodesProvided)
 				.DistinctBy(n => n.Uri)
 				.ToList();
 			LastUpdate = DateTimeProvider.Now();
@@ -62,7 +77,7 @@ protected StaticConnectionPool(IEnumerable<Node> nodes, Func<Node, float> nodeSc
 		public virtual bool SupportsReseeding => false;
 
 		/// <inheritdoc />
-		public bool UsingSsl { get; }
+		public bool UsingSsl { get; private set; }
 
 		protected List<Node> AliveNodes
 		{
@@ -75,10 +90,10 @@ protected List<Node> AliveNodes
 			}
 		}
 
-		protected IDateTimeProvider DateTimeProvider { get; }
+		protected IDateTimeProvider DateTimeProvider { get; private set; }
 
 		protected List<Node> InternalNodes { get; set; }
-		protected Random Random { get; } = new Random();
+		protected Random Random { get; }
 		protected bool Randomize { get; }
 
 		/// <summary>

src/Tests/Tests/ClientConcepts/ConnectionPooling/BuildingBlocks/ConnectionPooling.doc.cs

@@ -7,6 +7,7 @@
 using Elasticsearch.Net;
 using FluentAssertions;
 using Nest;
+using Tests.Configuration;
 using Tests.Framework;
 using Tests.XPack.Security.Privileges;
 
@@ -216,20 +217,30 @@ [U] public void Static()
 			}
 		}
 
+		//hide
+		private class SeededRandomConectionPool : StaticConnectionPool
+		{
+			public SeededRandomConectionPool(IEnumerable<Node> nodes, int seed)
+				: base(nodes, randomize: true, randomizeSeed: seed, dateTimeProvider: null)
+			{}
+		}
+
 		// hide
 		[U] public void RandomizedInitialNodes()
 		{
-			IEnumerable<StaticConnectionPool> CreatStaticConnectionPools()
+			IEnumerable<StaticConnectionPool> CreateSeededPools(int nodeCount, int pools)
 			{
-				Thread.Sleep(1);
-				var uris = Enumerable.Range(1, 50).Select(i => new Uri($"https://10.0.0.{i}:9200/"));
-				yield return new StaticConnectionPool(uris);
+				var seed = TestConfiguration.Instance.Seed;
+				var nodes = Enumerable.Range(1, nodeCount)
+					.Select(i => new Node(new Uri($"https://10.0.0.{i}:9200/")))
+					.ToList();
+				for(var i = 0; i < nodeCount; i++)
+					yield return new SeededRandomConectionPool(nodes, seed + i);
 			}
 
-			// assertion works on the probability of seeing a Uri other than https://10.0.0.1:9200/
-			// as the first value over 50 runs, when randomized.
-			CreatStaticConnectionPools()
-				.Take(50)
+			var connectionPools = CreateSeededPools(100, 100).ToList();
+			connectionPools.Should().HaveCount(100);
+			connectionPools
 				.Select(p => p.CreateView().First().Uri.ToString())
 				.All(uri => uri == "https://10.0.0.1:9200/")
 				.Should()