[chore]: enable float-compare rule from testifylint

Signed-off-by: Matthieu MOREL <matthieu.morel35@gmail.com>
open-telemetry · Sep 12, 2024 · 6845ca5 · 6845ca5
1 parent 8d7e04d
commit 6845ca5
Show file tree

Hide file tree

Showing 32 changed files with 106 additions and 107 deletions.
diff --git a/.golangci.yml b/.golangci.yml
@@ -134,7 +134,6 @@ linters-settings:
 
   testifylint:
     disable:
-      - float-compare
       - formatter
       - go-require
       - require-error

diff --git a/Makefile.Common b/Makefile.Common
@@ -77,7 +77,7 @@ GOTESTSUM           := $(TOOLS_BIN_DIR)/gotestsum
 TESTIFYLINT         := $(TOOLS_BIN_DIR)/testifylint
 
 GOTESTSUM_OPT?= --rerun-fails=1
-TESTIFYLINT_OPT?= --enable-all --disable=float-compare,formatter,go-require,require-error,suite-subtest-run,useless-assert
+TESTIFYLINT_OPT?= --enable-all --disable=formatter,go-require,require-error,suite-subtest-run,useless-assert
 
 # BUILD_TYPE should be one of (dev, release).
 BUILD_TYPE?=release

diff --git a/connector/routingconnector/metrics_test.go b/connector/routingconnector/metrics_test.go
@@ -219,7 +219,7 @@ func TestMetricsAreCorrectlySplitPerResourceAttributeWithOTTL(t *testing.T) {
 		rmetric := defaultSink.AllMetrics()[0].ResourceMetrics().At(0)
 		attr, ok := rmetric.Resource().Attributes().Get("value")
 		assert.True(t, ok, "routing attribute must exist")
-		assert.Equal(t, attr.Double(), float64(-1.0))
+		assert.InDelta(t, attr.Double(), float64(-1.0), 0.01)
 	})
 
 	t.Run("metric matched by one expression, multiple pipelines", func(t *testing.T) {
@@ -386,7 +386,7 @@ func TestMetricsAreCorrectlyMatchOnceWithOTTL(t *testing.T) {
 		rmetric := defaultSink.AllMetrics()[0].ResourceMetrics().At(0)
 		attr, ok := rmetric.Resource().Attributes().Get("value")
 		assert.True(t, ok, "routing attribute must exist")
-		assert.Equal(t, attr.Double(), float64(-1.0))
+		assert.InDelta(t, attr.Double(), float64(-1.0), 0.01)
 	})
 
 	t.Run("metric matched by one expression, multiple pipelines", func(t *testing.T) {

diff --git a/exporter/alertmanagerexporter/alertmanager_exporter_test.go b/exporter/alertmanagerexporter/alertmanager_exporter_test.go
@@ -143,7 +143,7 @@ func TestAlertManagerExporterEventNameAttributes(t *testing.T) {
 	assert.Equal(t, "unittest-baz", attr.AsString())
 	attr, b = got[0].spanEvent.Attributes().Get("attr3")
 	assert.True(t, b)
-	assert.Equal(t, 5.14, attr.Double())
+	assert.InDelta(t, 5.14, attr.Double(), 0.01)
 }
 
 func TestAlertManagerExporterSeverity(t *testing.T) {

diff --git a/exporter/awsemfexporter/datapoint_test.go b/exporter/awsemfexporter/datapoint_test.go
@@ -1473,22 +1473,22 @@ func TestGetDataPoints(t *testing.T) {
 				dp := convertedDPS.NumberDataPointSlice.At(0)
 				switch dp.ValueType() {
 				case pmetric.NumberDataPointValueTypeDouble:
-					assert.Equal(t, 0.1, dp.DoubleValue())
+					assert.InDelta(t, 0.1, dp.DoubleValue(), 0.01)
 				case pmetric.NumberDataPointValueTypeInt:
 					assert.Equal(t, int64(1), dp.IntValue())
 				}
 				assert.Equal(t, tc.expectedAttributes, dp.Attributes().AsRaw())
 			case histogramDataPointSlice:
 				assert.Equal(t, 1, convertedDPS.Len())
 				dp := convertedDPS.HistogramDataPointSlice.At(0)
-				assert.Equal(t, 35.0, dp.Sum())
+				assert.InDelta(t, 35.0, dp.Sum(), 0.01)
 				assert.Equal(t, uint64(18), dp.Count())
 				assert.Equal(t, []float64{0, 10}, dp.ExplicitBounds().AsRaw())
 				assert.Equal(t, tc.expectedAttributes, dp.Attributes().AsRaw())
 			case exponentialHistogramDataPointSlice:
 				assert.Equal(t, 1, convertedDPS.Len())
 				dp := convertedDPS.ExponentialHistogramDataPointSlice.At(0)
-				assert.Equal(t, float64(0), dp.Sum())
+				assert.InDelta(t, float64(0), dp.Sum(), 0.01)
 				assert.Equal(t, uint64(4), dp.Count())
 				assert.Equal(t, []uint64{1, 0, 1}, dp.Positive().BucketCounts().AsRaw())
 				assert.Equal(t, []uint64{1, 0, 1}, dp.Negative().BucketCounts().AsRaw())
@@ -1499,11 +1499,11 @@ func TestGetDataPoints(t *testing.T) {
 				assert.Equal(t, expectedDPS.deltaMetricMetadata, convertedDPS.deltaMetricMetadata)
 				assert.Equal(t, 1, convertedDPS.Len())
 				dp := convertedDPS.SummaryDataPointSlice.At(0)
-				assert.Equal(t, 15.0, dp.Sum())
+				assert.InDelta(t, 15.0, dp.Sum(), 0.01)
 				assert.Equal(t, uint64(5), dp.Count())
 				assert.Equal(t, 2, dp.QuantileValues().Len())
-				assert.Equal(t, float64(1), dp.QuantileValues().At(0).Value())
-				assert.Equal(t, float64(5), dp.QuantileValues().At(1).Value())
+				assert.InDelta(t, float64(1), dp.QuantileValues().At(0).Value(), 0.01)
+				assert.InDelta(t, float64(5), dp.QuantileValues().At(1).Value(), 0.01)
 				assert.Equal(t, tc.expectedAttributes, dp.Attributes().AsRaw())
 			}
 		})

diff --git a/exporter/datadogexporter/internal/metrics/series_deprecated_test.go b/exporter/datadogexporter/internal/metrics/series_deprecated_test.go
@@ -20,9 +20,9 @@ func TestNewZorkianMetric(t *testing.T) {
 
 	assert.Equal(t, "test.metric", *metric.Metric)
 	// Assert timestamp conversion from uint64 ns to float64 s
-	assert.Equal(t, 1.0, *metric.Points[0][0])
+	assert.InDelta(t, 1.0, *metric.Points[0][0], 0.01)
 	// Assert value
-	assert.Equal(t, 2.0, *metric.Points[0][1])
+	assert.InDelta(t, 2.0, *metric.Points[0][1], 0.01)
 	// Assert tags
 	assert.Equal(t, []string{"tag:value"}, metric.Tags)
 }
@@ -53,9 +53,9 @@ func TestDefaultZorkianMetrics(t *testing.T) {
 	// Assert metrics list length (should be 1)
 	assert.Len(t, ms, 1)
 	// Assert timestamp
-	assert.Equal(t, 2.0, *ms[0].Points[0][0])
+	assert.InDelta(t, 2.0, *ms[0].Points[0][0], 0.01)
 	// Assert value (should always be 1.0)
-	assert.Equal(t, 1.0, *ms[0].Points[0][1])
+	assert.InDelta(t, 1.0, *ms[0].Points[0][1], 0.01)
 	// Assert hostname tag is set
 	assert.Equal(t, "test-host", *ms[0].Host)
 	// Assert no other tags are set

diff --git a/exporter/datadogexporter/internal/metrics/series_test.go b/exporter/datadogexporter/internal/metrics/series_test.go
@@ -23,7 +23,7 @@ func TestNewMetricSeries(t *testing.T) {
 	// Assert timestamp conversion from uint64 ns to int64 s
 	assert.Equal(t, int64(1), *metric.Points[0].Timestamp)
 	// Assert value
-	assert.Equal(t, 2.0, *metric.Points[0].Value)
+	assert.InDelta(t, 2.0, *metric.Points[0].Value, 0.01)
 	// Assert tags
 	assert.Equal(t, []string{"tag:value"}, metric.Tags)
 }
@@ -55,7 +55,7 @@ func TestDefaultMetrics(t *testing.T) {
 	// Assert timestamp
 	assert.Equal(t, int64(2), *ms[0].Points[0].Timestamp)
 	// Assert value (should always be 1.0)
-	assert.Equal(t, 1.0, *ms[0].Points[0].Value)
+	assert.InDelta(t, 1.0, *ms[0].Points[0].Value, 0.01)
 	// Assert hostname tag is set
 	assert.Equal(t, "test-host", *ms[0].Resources[0].Name)
 	// Assert no other tags are set
@@ -77,7 +77,7 @@ func TestDefaultMetricsWithRuntimeMetrics(t *testing.T) {
 	// Assert timestamp
 	assert.Equal(t, int64(2), *ms[0].Points[0].Timestamp)
 	// Assert value (should always be 1.0)
-	assert.Equal(t, 1.0, *ms[0].Points[0].Value)
+	assert.InDelta(t, 1.0, *ms[0].Points[0].Value, 0.01)
 	// Assert hostname tag is set
 	assert.Equal(t, "test-host", *ms[0].Resources[0].Name)
 	// Assert no other tags are set

diff --git a/exporter/datadogexporter/internal/metrics/sketches/sketches_test.go b/exporter/datadogexporter/internal/metrics/sketches/sketches_test.go
@@ -60,10 +60,10 @@ func check(t *testing.T, in SketchPoint, pb gogen.SketchPayload_Sketch_Dogsketch
 
 	// summary
 	require.Equal(t, b.Cnt, pb.Cnt)
-	require.Equal(t, b.Min, pb.Min)
-	require.Equal(t, b.Max, pb.Max)
-	require.Equal(t, b.Avg, pb.Avg)
-	require.Equal(t, b.Sum, pb.Sum)
+	require.InDelta(t, b.Min, pb.Min, 0.01)
+	require.InDelta(t, b.Max, pb.Max, 0.01)
+	require.InDelta(t, b.Avg, pb.Avg, 0.01)
+	require.InDelta(t, b.Sum, pb.Sum, 0.01)
 }
 
 func TestSketchSeriesListMarshal(t *testing.T) {

diff --git a/exporter/logzioexporter/exporter_test.go b/exporter/logzioexporter/exporter_test.go
@@ -295,11 +295,11 @@ func TestPushLogsData(tester *testing.T) {
 	assert.Equal(tester, testHost, jsonLog["host.name"])
 	assert.Equal(tester, testService, jsonLog["service.name"])
 	assert.Equal(tester, "server", jsonLog["app"])
-	assert.Equal(tester, 1.0, jsonLog["instance_num"])
+	assert.InDelta(tester, 1.0, jsonLog["instance_num"], 0.01)
 	assert.Equal(tester, "logScopeName", jsonLog["scopeName"])
 	assert.Equal(tester, "hello there", jsonLog["message"])
 	assert.Equal(tester, "bar", jsonLog["foo"])
-	assert.Equal(tester, 45.0, jsonLog["23"])
+	assert.InDelta(tester, 45.0, jsonLog["23"], 0.01)
 }
 
 func TestMergeMapEntries(tester *testing.T) {

diff --git a/exporter/prometheusexporter/accumulator_test.go b/exporter/prometheusexporter/accumulator_test.go
@@ -256,7 +256,7 @@ func TestAccumulateMetrics(t *testing.T) {
 				return true
 			})
 			require.Equal(t, m2Labels.Len(), vLabels.Len())
-			require.Equal(t, m2Value, vValue)
+			require.InDelta(t, m2Value, vValue, 0.01)
 			require.Equal(t, ts2.Unix(), vTS.Unix())
 			require.Greater(t, v.updated.Unix(), vTS.Unix())
 			require.Equal(t, m2Temporality, vTemporality)
@@ -280,7 +280,7 @@ func TestAccumulateMetrics(t *testing.T) {
 			v = m.(*accumulatedValue)
 			_, vTS, vValue, _, _ = getMetricProperties(v.value)
 
-			require.Equal(t, m3Value, vValue)
+			require.InDelta(t, m3Value, vValue, 0.01)
 			require.Equal(t, ts3.Unix(), vTS.Unix())
 		})
 	}
@@ -370,8 +370,8 @@ func TestAccumulateDeltaToCumulative(t *testing.T) {
 				return true
 			})
 			require.Equal(t, mLabels.Len(), vLabels.Len())
-			require.Equal(t, mValue, vValue)
-			require.Equal(t, dataPointValue1+dataPointValue2, vValue)
+			require.InDelta(t, mValue, vValue, 0.01)
+			require.InDelta(t, dataPointValue1+dataPointValue2, vValue, 0.01)
 			require.Equal(t, pmetric.AggregationTemporalityCumulative, vTemporality)
 			require.True(t, vIsMonotonic)
 
@@ -419,7 +419,7 @@ func TestAccumulateDeltaToCumulativeHistogram(t *testing.T) {
 		v := m.(*accumulatedValue).value.Histogram().DataPoints().At(0)
 		require.True(t, ok)
 
-		require.Equal(t, m1.Sum()+m2.Sum(), v.Sum())
+		require.InDelta(t, m1.Sum()+m2.Sum(), v.Sum(), 0.01)
 		require.Equal(t, m1.Count()+m2.Count(), v.Count())
 
 		for i := 0; i < v.BucketCounts().Len(); i++ {

diff --git a/internal/aws/containerinsight/utils_test.go b/internal/aws/containerinsight/utils_test.go
@@ -170,7 +170,7 @@ func checkMetricsAreExpected(t *testing.T, md pmetric.Metrics, fields map[string
 				dp := dps.At(0)
 				switch dp.ValueType() {
 				case pmetric.NumberDataPointValueTypeDouble:
-					assert.Equal(t, convertToFloat64(fields[metricName]), dp.DoubleValue())
+					assert.InDelta(t, convertToFloat64(fields[metricName]), dp.DoubleValue(), 0.01)
 				case pmetric.NumberDataPointValueTypeInt:
 					assert.Equal(t, convertToInt64(fields[metricName]), dp.IntValue())
 				}

diff --git a/internal/aws/metrics/metric_calculator_test.go b/internal/aws/metrics/metric_calculator_test.go
@@ -20,7 +20,7 @@ func TestFloat64RateCalculator(t *testing.T) {
 	c := newFloat64RateCalculator()
 	r, ok := c.Calculate(mKey, float64(50), initTime)
 	assert.False(t, ok)
-	assert.Equal(t, float64(0), r)
+	assert.InDelta(t, float64(0), r, 0.01)
 
 	nextTime := initTime.Add(100 * time.Millisecond)
 	r, ok = c.Calculate(mKey, float64(100), nextTime)
@@ -35,14 +35,14 @@ func TestFloat64RateCalculatorWithTooFrequentUpdate(t *testing.T) {
 	c := newFloat64RateCalculator()
 	r, ok := c.Calculate(mKey, float64(50), initTime)
 	assert.False(t, ok)
-	assert.Equal(t, float64(0), r)
+	assert.InDelta(t, float64(0), r, 0.01)
 
 	nextTime := initTime
 	for i := 0; i < 10; i++ {
 		nextTime = nextTime.Add(5 * time.Millisecond)
 		r, ok = c.Calculate(mKey, float64(105), nextTime)
 		assert.False(t, ok)
-		assert.Equal(t, float64(0), r)
+		assert.InDelta(t, float64(0), r, 0.01)
 	}
 
 	nextTime = nextTime.Add(5 * time.Millisecond)
@@ -75,7 +75,7 @@ func TestFloat64DeltaCalculator(t *testing.T) {
 		r, ok := c.Calculate(mKey, f, initTime)
 		assert.Equal(t, i > 0, ok)
 		if i == 0 {
-			assert.Equal(t, float64(0), r)
+			assert.InDelta(t, float64(0), r, 0.01)
 		} else {
 			assert.InDelta(t, f-testCases[i-1], r, f/10)
 		}
@@ -93,7 +93,7 @@ func TestFloat64DeltaCalculatorWithDecreasingValues(t *testing.T) {
 		r, ok := c.Calculate(mKey, f, initTime)
 		assert.Equal(t, i > 0, ok)
 		if ok {
-			assert.Equal(t, testCases[i]-testCases[i-1], r)
+			assert.InDelta(t, testCases[i]-testCases[i-1], r, 0.01)
 		}
 	}
 	require.NoError(t, c.Shutdown())
@@ -107,7 +107,7 @@ func TestMapWithExpiryAdd(t *testing.T) {
 	val, ok := store.Get(Key{MetricMetadata: "key1"})
 	store.Unlock()
 	assert.True(t, ok)
-	assert.Equal(t, value1, val.RawValue)
+	assert.InDelta(t, value1, val.RawValue, 0.01)
 
 	store.Lock()
 	defer store.Unlock()
@@ -135,7 +135,7 @@ func TestMapWithExpiryCleanup(t *testing.T) {
 	val, ok := store.Get(Key{MetricMetadata: "key1"})
 
 	assert.True(t, ok)
-	assert.Equal(t, value1, val.RawValue.(float64))
+	assert.InDelta(t, value1, val.RawValue.(float64), 0.01)
 	assert.Equal(t, 1, store.Size())
 	store.Unlock()
 

diff --git a/pkg/sampling/encoding_test.go b/pkg/sampling/encoding_test.go
@@ -101,9 +101,9 @@ func TestInvalidprobabilityToTValue(t *testing.T) {
 }
 
 func TestTValueToProbability(t *testing.T) {
-	require.Equal(t, 0.5, must(tValueToProbability("8")))
-	require.Equal(t, 1-0x444p-12, must(tValueToProbability("444")))
-	require.Equal(t, 1.0, must(tValueToProbability("0")))
+	require.InDelta(t, 0.5, must(tValueToProbability("8")), 0.01)
+	require.InDelta(t, 1-0x444p-12, must(tValueToProbability("444")), 0.01)
+	require.InDelta(t, 1.0, must(tValueToProbability("0")), 0.01)
 
 	// 0x55555554p-32 is very close to 1/3
 	require.InEpsilon(t, 1-1/3., must(tValueToProbability("55555554")), 1e-9)

diff --git a/pkg/sampling/oteltracestate_test.go b/pkg/sampling/oteltracestate_test.go
@@ -48,7 +48,7 @@ func TestOpenTelemetryTraceStateTValueSerialize(t *testing.T) {
 	require.Equal(t, "3", otts.TValue())
 	tv, hasTv := otts.TValueThreshold()
 	require.True(t, hasTv)
-	require.Equal(t, 1-0x3p-4, tv.Probability())
+	require.InDelta(t, 1-0x3p-4, tv.Probability(), 0.01)
 
 	require.NotEqual(t, "", otts.RValue())
 	require.Equal(t, "10000000000000", otts.RValue())
@@ -109,7 +109,7 @@ func TestOpenTelemetryTraceStateTValueUpdate(t *testing.T) {
 	require.Equal(t, "3", otts.TValue())
 	tv, hasTv := otts.TValueThreshold()
 	require.True(t, hasTv)
-	require.Equal(t, 1-0x3p-4, tv.Probability())
+	require.InDelta(t, 1-0x3p-4, tv.Probability(), 0.01)
 
 	const updated = "rv:abcdefabcdefab;th:3"
 	var w strings.Builder

diff --git a/processor/cumulativetodeltaprocessor/internal/tracking/tracker_test.go b/processor/cumulativetodeltaprocessor/internal/tracking/tracker_test.go
@@ -216,7 +216,7 @@ func TestMetricTracker_Convert(t *testing.T) {
 					if !ttt.noOut {
 						require.True(t, valid)
 						assert.Equal(t, ttt.wantOut.StartTimestamp, gotOut.StartTimestamp)
-						assert.Equal(t, ttt.wantOut.FloatValue, gotOut.FloatValue)
+						assert.InDelta(t, ttt.wantOut.FloatValue, gotOut.FloatValue, 0.01)
 					}
 
 					gotOut, valid = m.Convert(intPoint)

diff --git a/processor/cumulativetodeltaprocessor/processor_test.go b/processor/cumulativetodeltaprocessor/processor_test.go
@@ -485,7 +485,7 @@ func TestCumulativeToDeltaProcessor(t *testing.T) {
 					require.Equal(t, eDataPoints.Len(), aDataPoints.Len())
 
 					for j := 0; j < eDataPoints.Len(); j++ {
-						require.Equal(t, eDataPoints.At(j).DoubleValue(), aDataPoints.At(j).DoubleValue())
+						require.InDelta(t, eDataPoints.At(j).DoubleValue(), aDataPoints.At(j).DoubleValue(), 0.01)
 					}
 				}
 
@@ -500,7 +500,7 @@ func TestCumulativeToDeltaProcessor(t *testing.T) {
 						if math.IsNaN(eDataPoints.At(j).DoubleValue()) {
 							assert.True(t, math.IsNaN(aDataPoints.At(j).DoubleValue()))
 						} else {
-							require.Equal(t, eDataPoints.At(j).DoubleValue(), aDataPoints.At(j).DoubleValue())
+							require.InDelta(t, eDataPoints.At(j).DoubleValue(), aDataPoints.At(j).DoubleValue(), 0.01)
 						}
 						require.Equal(t, eDataPoints.At(j).Flags(), aDataPoints.At(j).Flags())
 					}
@@ -521,7 +521,7 @@ func TestCumulativeToDeltaProcessor(t *testing.T) {
 						if math.IsNaN(eDataPoints.At(j).Sum()) {
 							require.True(t, math.IsNaN(aDataPoints.At(j).Sum()))
 						} else {
-							require.Equal(t, eDataPoints.At(j).Sum(), aDataPoints.At(j).Sum())
+							require.InDelta(t, eDataPoints.At(j).Sum(), aDataPoints.At(j).Sum(), 0.01)
 						}
 						require.Equal(t, eDataPoints.At(j).BucketCounts(), aDataPoints.At(j).BucketCounts())
 						require.Equal(t, eDataPoints.At(j).Flags(), aDataPoints.At(j).Flags())

diff --git a/processor/deltatorateprocessor/processor_test.go b/processor/deltatorateprocessor/processor_test.go
@@ -157,7 +157,7 @@ func TestCumulativeToDeltaProcessor(t *testing.T) {
 					require.Equal(t, eDataPoints.Len(), aDataPoints.Len())
 
 					for j := 0; j < eDataPoints.Len(); j++ {
-						require.Equal(t, eDataPoints.At(j).DoubleValue(), aDataPoints.At(j).DoubleValue())
+						require.InDelta(t, eDataPoints.At(j).DoubleValue(), aDataPoints.At(j).DoubleValue(), 0.01)
 					}
 				}
 
@@ -169,7 +169,7 @@ func TestCumulativeToDeltaProcessor(t *testing.T) {
 					require.Equal(t, eM.Sum().AggregationTemporality(), aM.Sum().AggregationTemporality())
 
 					for j := 0; j < eDataPoints.Len(); j++ {
-						require.Equal(t, eDataPoints.At(j).DoubleValue(), aDataPoints.At(j).DoubleValue())
+						require.InDelta(t, eDataPoints.At(j).DoubleValue(), aDataPoints.At(j).DoubleValue(), 0.01)
 					}
 				}
 

diff --git a/processor/metricsgenerationprocessor/processor_test.go b/processor/metricsgenerationprocessor/processor_test.go
@@ -314,7 +314,7 @@ func TestMetricsGenerationProcessor(t *testing.T) {
 					for j := 0; j < eDataPoints.Len(); j++ {
 						switch eDataPoints.At(j).ValueType() {
 						case pmetric.NumberDataPointValueTypeDouble:
-							require.Equal(t, eDataPoints.At(j).DoubleValue(), aDataPoints.At(j).DoubleValue())
+							require.InDelta(t, eDataPoints.At(j).DoubleValue(), aDataPoints.At(j).DoubleValue(), 0.01)
 						case pmetric.NumberDataPointValueTypeInt:
 							require.Equal(t, eDataPoints.At(j).IntValue(), aDataPoints.At(j).IntValue())
 						}