test: implement unit test for summary metrics in Prometheus conversion

Co-authored-by: aider (openai/claude-sonnet-4) <aider@aider.chat>

Author: Trojan295

internal/castai/client_test.go

@@ -390,7 +390,142 @@ func TestConvertPrometheusMetricFamilies(t *testing.T) {
 	})
 
 	t.Run("summary", func(t *testing.T) {
-		// TODO: unit test for summary metrics
+		r := require.New(t)
+
+		metricName := "test_summary"
+		sampleCount := uint64(50)
+		sampleSum := 125.75
+
+		// Create summary quantiles
+		quantiles := []*dto.Quantile{
+			{
+				Quantile: lo.ToPtr(0.5),
+				Value:    lo.ToPtr(2.5),
+			},
+			{
+				Quantile: lo.ToPtr(0.9),
+				Value:    lo.ToPtr(8.1),
+			},
+			{
+				Quantile: lo.ToPtr(0.99),
+				Value:    lo.ToPtr(15.3),
+			},
+		}
+
+		labelName := "handler"
+		labelValue := "api"
+
+		family := &dto.MetricFamily{
+			Name: &metricName,
+			Metric: []*dto.Metric{
+				{
+					Label: []*dto.LabelPair{
+						{
+							Name:  &labelName,
+							Value: &labelValue,
+						},
+					},
+					Summary: &dto.Summary{
+						SampleCount: &sampleCount,
+						SampleSum:   &sampleSum,
+						Quantile:    quantiles,
+					},
+				},
+			},
+		}
+
+		result := convertPrometheusMetricFamilies(gatherTime, "ctrl_pod", []*dto.MetricFamily{family})
+
+		// Should have 3 quantile timeseries + 1 _sum + 1 _count = 5 total
+		r.Len(result.Timeseries, 5)
+
+		// Separate timeseries by type
+		quantileTimeseries := []PrometheusTimeseries{}
+		var sumTimeseries, countTimeseries *PrometheusTimeseries
+
+		for _, ts := range result.Timeseries {
+			// Check which type this timeseries is by looking at __name__ label
+			var metricNameValue string
+			for _, label := range ts.Labels {
+				if label.Name == "__name__" {
+					metricNameValue = label.Value
+					break
+				}
+			}
+
+			switch metricNameValue {
+			case metricName + "_quantile":
+				quantileTimeseries = append(quantileTimeseries, ts)
+			case metricName + "_sum":
+				sumTimeseries = &ts
+			case metricName + "_count":
+				countTimeseries = &ts
+			default:
+				t.Fatalf("Unexpected metric name: %s", metricNameValue)
+			}
+
+			// Verify common labels are present on all timeseries
+			assertLabelPresent(t, ts.Labels, "pod_name", "ctrl_pod")
+			assertLabelPresent(t, ts.Labels, labelName, labelValue)
+
+			// Verify timestamp and sample structure
+			r.Len(ts.Samples, 1)
+			r.Equal(expectedTimestamp, ts.Samples[0].Timestamp)
+		}
+
+		// Verify quantile timeseries (3 quantiles)
+		r.Len(quantileTimeseries, 3)
+
+		// Verify each expected quantile exists
+		expectedQuantiles := map[string]float64{
+			"0.500000": 2.5,
+			"0.900000": 8.1,
+			"0.990000": 15.3,
+		}
+
+		foundQuantiles := make(map[string]bool)
+		for _, ts := range quantileTimeseries {
+			assertLabelPresent(t, ts.Labels, "__name__", metricName+"_quantile")
+
+			// Find the 'quantile' label value
+			var quantileValue string
+			for _, label := range ts.Labels {
+				if label.Name == "quantile" {
+					quantileValue = label.Value
+					break
+				}
+			}
+
+			r.NotEmpty(quantileValue, "Quantile timeseries should have 'quantile' label")
+
+			expectedValue, exists := expectedQuantiles[quantileValue]
+			r.True(exists, "Unexpected quantile with quantile=%s", quantileValue)
+			r.Equal(expectedValue, ts.Samples[0].Value)
+			foundQuantiles[quantileValue] = true
+		}
+
+		// Ensure all expected quantiles were found
+		r.Len(foundQuantiles, len(expectedQuantiles))
+
+		// Verify _sum timeseries
+		r.NotNil(sumTimeseries)
+		assertLabelPresent(t, sumTimeseries.Labels, "__name__", metricName+"_sum")
+		r.Equal(sampleSum, sumTimeseries.Samples[0].Value)
+
+		// Verify _sum doesn't have 'quantile' label
+		for _, label := range sumTimeseries.Labels {
+			r.NotEqual("quantile", label.Name, "_sum should not have 'quantile' label")
+		}
+
+		// Verify _count timeseries
+		r.NotNil(countTimeseries)
+		assertLabelPresent(t, countTimeseries.Labels, "__name__", metricName+"_count")
+		r.Equal(float64(sampleCount), countTimeseries.Samples[0].Value)
+
+		// Verify _count doesn't have 'quantile' label
+		for _, label := range countTimeseries.Labels {
+			r.NotEqual("quantile", label.Name, "_count should not have 'quantile' label")
+		}
 	})
 }