Merge pull request #456 from nextmv-io/merschformann/golden-rounding

Enhance golden file testing with rounding functionality

Author: merschformann

golden/config.go

@@ -162,6 +162,9 @@ type OutputProcessConfig struct {
 	// VolatileRegexReplacements defines regex replacements to be applied to the
 	// golden file before comparison.
 	VolatileRegexReplacements []VolatileRegexReplacement
+	// RoundingConfig defines how to round fields in the output before
+	// comparison.
+	RoundingConfig []RoundingConfig
 	// VolatileDataFiles are files that contain volatile data and should get
 	// post-processed to be more stable. This is only supported in directory
 	// mode ([BashTest]) of golden bash testing, i.e., this will be ignored in
@@ -173,6 +176,14 @@ type OutputProcessConfig struct {
 	RelativeDestination string
 }
 
+// RoundingConfig defines how to round a field in the output before comparison.
+type RoundingConfig struct {
+	// Key is the JSONPath-like key to the field that should be rounded.
+	Key string
+	// Precision is the number of decimal places to round to.
+	Precision int
+}
+
 // ExecutionConfig defines the configuration for non-SDK golden file tests.
 type ExecutionConfig struct {
 	// Command is the command of the entrypoint of the app to be executed. E.g.,

golden/file.go

@@ -153,6 +153,8 @@ func comparison(
 	inputPath string,
 	config Config,
 ) {
+	var err error
+
 	goldenPath := inputPath + goldenExtension
 	if config.OutputProcessConfig.RelativeDestination != "" {
 		goldenPath = filepath.Join(
@@ -171,6 +173,10 @@ func comparison(
 
 		flattenedOutput = flatten(output)
 		flattenedOutput = replaceTransient(flattenedOutput, config.TransientFields...)
+		flattenedOutput, err = roundFields(flattenedOutput, config.OutputProcessConfig.RoundingConfig...)
+		if err != nil {
+			t.Fatal(err)
+		}
 		nestedOutput, err := nest(flattenedOutput)
 		if err != nil {
 			t.Fatal(err)

golden/map.go

@@ -2,7 +2,9 @@ package golden
 
 import (
 	"fmt"
+	"math"
 	"reflect"
+	"regexp"
 	"strconv"
 	"strings"
 	"time"
@@ -22,17 +24,32 @@ func replaceTransient(
 
 	replaced := map[string]any{}
 	for key, value := range original {
+		// Keep the original value.
 		replaced[key] = value
+
+		// Check if the field is meant to be replaced. If not, continue.
+		// We also check for wildcard replacements that are meant to replace all
+		// fields in a slice.
 		replacement, isTransient := transientLookup[key]
-		if !isTransient {
+		cleanedKey := replaceIndicesInKeys(key)
+		replacementCleaned, isTransientCleaned := transientLookup[cleanedKey]
+		if !isTransient && !isTransientCleaned {
+			// No replacement defined, continue and keep the original value.
 			continue
 		}
+		if isTransientCleaned {
+			replacement = replacementCleaned
+		}
 
+		// Replace the value with the replacement value.
 		if replacement != nil {
 			replaced[key] = replacement
 			continue
 		}
 
+		// No replacement defined, we fall back to default stable values here
+		// (based on type).
+
 		if stringValue, isString := value.(string); isString {
 			if _, err := time.Parse(time.RFC3339, stringValue); err == nil {
 				replaced[key] = StableTime
@@ -67,6 +84,69 @@ func replaceTransient(
 	return replaced
 }
 
+// roundFields rounds all the values in a map whose key is contained in the
+// variadic list of roundingConfigs. The rounded value has a stable value
+// according to the data type.
+func roundFields(
+	original map[string]any,
+	roundedFields ...RoundingConfig,
+) (map[string]any, error) {
+	roundingLookup := map[string]int{}
+	for _, field := range roundedFields {
+		roundingLookup[field.Key] = field.Precision
+	}
+
+	replaced := map[string]any{}
+	for key, value := range original {
+		// Keep the original value.
+		replaced[key] = value
+
+		// Check if the field is meant to be rounded. If not, continue.
+		// We also check for wildcard replacements that are meant to replace all
+		// fields in a slice.
+		cleanedKey := replaceIndicesInKeys(key)
+		replacement, isRounded := roundingLookup[key]
+		replacementCleaned, isRoundedCleaned := roundingLookup[cleanedKey]
+		if !isRounded && !isRoundedCleaned {
+			// No rounding defined, continue and keep the original value.
+			continue
+		}
+		if isRoundedCleaned {
+			replacement = replacementCleaned
+		}
+
+		// We don't deal with negative precision values.
+		if replacement < 0 {
+			continue
+		}
+
+		// Replace the value with the rounded value.
+		if _, isFloat := value.(float64); isFloat {
+			replaced[key] = round(value.(float64), replacement)
+			continue
+		}
+
+		// If the value was not a float, return an error.
+		return nil, fmt.Errorf("field %s is not a float", key)
+	}
+
+	return replaced, nil
+}
+
+// round rounds a float64 value to a given precision.
+func round(value float64, precision int) float64 {
+	shift := math.Pow(10, float64(precision))
+	return math.Round(value*shift) / shift
+}
+
+var keyIndexMatcher = regexp.MustCompile(`\[\d+\]`)
+
+// replaceIndicesInKeys replaces all the indices in a key with "[]" to make it
+// easier to match them with configuration defined in jq-style.
+func replaceIndicesInKeys(key string) string {
+	return keyIndexMatcher.ReplaceAllString(key, "[]")
+}
+
 /*
 flatten takes a nested map and flattens it into a single level map. The
 flattening roughly follows the [JSONPath] standard. Please see test function to

golden/map_test.go

@@ -1,6 +1,7 @@
 package golden
 
 import (
+	"fmt"
 	"reflect"
 	"testing"
 )
@@ -464,3 +465,34 @@ func Test_nest(t *testing.T) {
 		})
 	}
 }
+
+func Test_round(t *testing.T) {
+	tests := []struct {
+		num       float64
+		want      float64
+		precision int
+	}{
+		{
+			num:       1.23456789,
+			want:      1.235,
+			precision: 3,
+		},
+		{
+			num:       1.234567891234567891234,
+			want:      1.23456789123456789123,
+			precision: 20,
+		},
+		{
+			num:       1.234567891234567891234,
+			want:      1,
+			precision: 0,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(fmt.Sprintf("round %d", tt.precision), func(t *testing.T) {
+			if got := round(tt.num, tt.precision); got != tt.want {
+				t.Errorf("round() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}