make SignificantTermsBucket generic on key type (#3890)

Supersedes: #3795

Key of SignificantTermsBucket is generic to allow for returning
both string and numeric key values.

Co-authored-by: kevinphelps <[email protected]>

Author: russcam

src/Nest/Aggregations/AggregateDictionary.cs

@@ -122,34 +122,38 @@ public FiltersAggregate Filters(string key)
 
 		public GeoCentroidAggregate GeoCentroid(string key) => TryGet<GeoCentroidAggregate>(key);
 
-		public SignificantTermsAggregate SignificantTerms(string key)
+		public SignificantTermsAggregate<TKey> SignificantTerms<TKey>(string key)
 		{
 			var bucket = TryGet<BucketAggregate>(key);
 			return bucket == null
 				? null
-				: new SignificantTermsAggregate
+				: new SignificantTermsAggregate<TKey>
 				{
 					BgCount = bucket.BgCount,
 					DocCount = bucket.DocCount,
-					Buckets = bucket.Items.OfType<SignificantTermsBucket>().ToList(),
+					Buckets = GetSignificantTermsBuckets<TKey>(bucket.Items).ToList(),
 					Meta = bucket.Meta
 				};
 		}
 
-		public SignificantTermsAggregate SignificantText(string key)
+		public SignificantTermsAggregate<string> SignificantTerms(string key) => SignificantTerms<string>(key);
+
+		public SignificantTermsAggregate<TKey> SignificantText<TKey>(string key)
 		{
 			var bucket = TryGet<BucketAggregate>(key);
 			return bucket == null
 				? null
-				: new SignificantTermsAggregate
+				: new SignificantTermsAggregate<TKey>
 				{
 					BgCount = bucket.BgCount,
 					DocCount = bucket.DocCount,
-					Buckets = bucket.Items.OfType<SignificantTermsBucket>().ToList(),
+					Buckets = GetSignificantTermsBuckets<TKey>(bucket.Items).ToList(),
 					Meta = bucket.Meta
 				};
 		}
 
+		public SignificantTermsAggregate<string> SignificantText(string key) => SignificantText<string>(key);
+
 		public TermsAggregate<TKey> Terms<TKey>(string key)
 		{
 			var bucket = TryGet<BucketAggregate>(key);
@@ -255,5 +259,19 @@ private IEnumerable<KeyedBucket<TKey>> GetKeyedBuckets<TKey>(IEnumerable<IBucket
 					DocCountErrorUpperBound = bucket.DocCountErrorUpperBound
 				};
 		}
+
+		private IEnumerable<SignificantTermsBucket<TKey>> GetSignificantTermsBuckets<TKey>(IEnumerable<IBucket> items)
+		{
+			var buckets = items.Cast<SignificantTermsBucket<object>>();
+
+			foreach (var bucket in buckets)
+				yield return new SignificantTermsBucket<TKey>(bucket.BackingDictionary)
+				{
+					Key = (TKey)Convert.ChangeType(bucket.Key, typeof(TKey)),
+					BgCount = bucket.BgCount,
+					DocCount = bucket.DocCount,
+					Score = bucket.Score
+				};
+		}
 	}
 }

src/Nest/Aggregations/AggregateFormatter.cs

@@ -864,9 +864,9 @@ private IBucket GetSignificantTermsBucket(ref JsonReader reader, IJsonFormatterR
 				subAggregates = GetSubAggregates(ref reader, propertyName, formatterResolver);
 			}
 
-			return new SignificantTermsBucket(subAggregates)
+			return new SignificantTermsBucket<object>(subAggregates)
 			{
-				Key = (string)key,
+				Key = key,
 				DocCount = docCount.GetValueOrDefault(0),
 				BgCount = bgCount,
 				Score = score

src/Nest/Aggregations/Bucket/SignificantTerms/SignificantTermsAggregate.cs

@@ -1,6 +1,6 @@
 namespace Nest
 {
-	public class SignificantTermsAggregate : MultiBucketAggregate<SignificantTermsBucket>
+	public class SignificantTermsAggregate<TKey> : MultiBucketAggregate<SignificantTermsBucket<TKey>>
 	{
 		/// <summary>
 		/// The background count

src/Nest/Aggregations/Bucket/SignificantTerms/SignificantTermsBucket.cs

@@ -2,14 +2,14 @@
 
 namespace Nest
 {
-	public class SignificantTermsBucket : BucketBase, IBucket
+	public class SignificantTermsBucket<TKey> : BucketBase, IBucket
 	{
 		public SignificantTermsBucket(IReadOnlyDictionary<string, IAggregate> dict) : base(dict) { }
 
 		public long BgCount { get; set; }
 		public long DocCount { get; set; }
 
-		public string Key { get; set; }
+		public TKey Key { get; set; }
 		public double Score { get; set; }
 	}
 }

src/Tests/Tests.Domain/Project.cs

@@ -63,7 +63,7 @@ public class Project
 				.RuleFor(p => p.LocationPoint, f => SimpleGeoPoint.Generator.Generate())
 				.RuleFor(p => p.LocationShape, f => new PointGeoShape(new GeoCoordinate(f.Address.Latitude(), f.Address.Latitude())))
 				.RuleFor(p => p.NumberOfCommits, f => Gimme.Random.Number(1, 1000))
-				.RuleFor(p => p.NumberOfContributors, f => Gimme.Random.Number(1, 200))
+				.RuleFor(p => p.NumberOfContributors, f => Gimme.Random.Number(1, 50))
 				.RuleFor(p => p.Ranges, f => Ranges.Generator.Generate())
 				.RuleFor(p => p.Branches, f => Gimme.Random.ListItems(new List<string> { "master", "dev", "release", "qa", "test" }))
 				.RuleFor(p => p.SourceOnly, f =>

src/Tests/Tests/Aggregations/Bucket/SignificantTerms/SignificantTermsAggregationUsageTests.cs

@@ -196,4 +196,52 @@ protected override void ExpectResponse(ISearchResponse<Project> response)
 			sigNames.DocCount.Should().BeGreaterThan(0);
 		}
 	}
+
+	/**
+	 * [float]
+	 * [[significant-terms-numeric-field]]
+	 * == Numeric fields
+	 *
+	 * A significant terms aggregation on a numeric field
+	 */
+	public class NumericSignificantTermsAggregationUsageTests : AggregationUsageTestBase
+	{
+		public NumericSignificantTermsAggregationUsageTests(ReadOnlyCluster i, EndpointUsage usage) : base(i, usage) { }
+
+		protected override object AggregationJson => new
+		{
+			commits = new
+			{
+				significant_terms = new
+				{
+					field = "numberOfContributors"
+				}
+			}
+		};
+
+		protected override Func<AggregationContainerDescriptor<Project>, IAggregationContainer> FluentAggs => a => a
+			.SignificantTerms("commits", st => st
+				.Field(p => p.NumberOfContributors)
+			);
+
+		protected override AggregationDictionary InitializerAggs =>
+			new SignificantTermsAggregation("commits")
+			{
+				Field = Field<Project, int>(p => p.NumberOfContributors)
+			};
+
+		protected override void ExpectResponse(ISearchResponse<Project> response)
+		{
+			response.ShouldBeValid();
+			var commits = response.Aggregations.SignificantTerms<int>("commits");
+			commits.Should().NotBeNull();
+			commits.Buckets.Should().NotBeNull();
+			commits.Buckets.Count.Should().BeGreaterThan(0);
+			foreach (var item in commits.Buckets)
+			{
+				item.Key.Should().BeGreaterThan(0);
+				item.DocCount.Should().BeGreaterOrEqualTo(1);
+			}
+		}
+	}
 }