fix(validator): robust value comparison and add integration test

valuesEqual now normalizes numeric and boolean types before comparing,
preventing false drift reports from YAML int vs JSON float64 (e.g.,
1 vs 1.0) and boolean casing (True vs true).

Add helm_values_check_test.go integration test wrapper so the
registered TestName maps to an actual test function that the
validator Job runner can invoke.

Author: mchmarny

pkg/validator/checks/deployment/helm_values_check.go

@@ -19,6 +19,7 @@ import (
 	"fmt"
 	"log/slog"
 	"sort"
+	"strconv"
 	"strings"
 
 	"github.com/NVIDIA/aicr/pkg/errors"
@@ -163,7 +164,32 @@ func flattenValuesRecursive(data map[string]any, prefix string, result map[strin
 }
 
 // valuesEqual compares two string representations of values, normalizing
-// common type differences (e.g., "true"/"true", "1"/"1").
+// common type differences between YAML parsing and Helm's JSON storage.
+// For example, YAML parses 1 as int while JSON parses it as float64;
+// both flatten to "1" but edge cases like "1.0" vs "1" need handling.
 func valuesEqual(expected, actual string) bool {
-	return strings.TrimSpace(expected) == strings.TrimSpace(actual)
+	expected = strings.TrimSpace(expected)
+	actual = strings.TrimSpace(actual)
+
+	if expected == actual {
+		return true
+	}
+
+	// Numeric normalization: parse both as float64 to handle
+	// int vs float differences (YAML int 1 vs JSON float64 1.0).
+	if ef, ee := strconv.ParseFloat(expected, 64); ee == nil {
+		if af, ae := strconv.ParseFloat(actual, 64); ae == nil {
+			return ef == af
+		}
+	}
+
+	// Boolean normalization: case-insensitive comparison
+	// handles "True"/"true", "FALSE"/"false".
+	if eb, ee := strconv.ParseBool(expected); ee == nil {
+		if ab, ae := strconv.ParseBool(actual); ae == nil {
+			return eb == ab
+		}
+	}
+
+	return false
 }

pkg/validator/checks/deployment/helm_values_check_test.go

@@ -0,0 +1,53 @@
+// Copyright (c) 2025, NVIDIA CORPORATION.  All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package deployment
+
+import (
+	"testing"
+
+	"github.com/NVIDIA/aicr/pkg/validator/checks"
+)
+
+// TestCheckHelmValues is the integration test for helm-values.
+// This runs inside validator Jobs and invokes the validator.
+func TestCheckHelmValues(t *testing.T) {
+	if testing.Short() {
+		t.Skip("Skipping integration test in short mode")
+	}
+
+	// Load Job environment
+	runner, err := checks.NewTestRunner(t)
+	if err != nil {
+		t.Skipf("Not in Job environment: %v", err)
+	}
+	defer runner.Cancel()
+
+	// Check if this check is enabled in recipe
+	if !runner.HasCheck("deployment", "helm-values") {
+		t.Skip("Check helm-values not enabled in recipe")
+	}
+
+	t.Logf("Running check: helm-values")
+
+	// Run the validator
+	ctx := runner.Context()
+	err = validateHelmValues(ctx)
+
+	if err != nil {
+		t.Errorf("Check failed: %v", err)
+	} else {
+		t.Logf("✓ Check passed: helm-values")
+	}
+}

pkg/validator/checks/deployment/helm_values_check_unit_test.go

@@ -26,7 +26,7 @@ import (
 	"github.com/NVIDIA/aicr/pkg/validator/checks"
 )
 
-func TestCheckHelmValues(t *testing.T) {
+func TestValidateHelmValues(t *testing.T) {
 	tests := []struct {
 		name        string
 		setup       func() *checks.ValidationContext
@@ -246,6 +246,38 @@ func TestCheckHelmValues(t *testing.T) {
 			},
 			wantErr: false,
 		},
+		{
+			name: "float vs int normalization - 1.0 equals 1",
+			setup: func() *checks.ValidationContext {
+				return &checks.ValidationContext{
+					Context: context.Background(),
+					Snapshot: snapshotWithHelm(map[string]string{
+						"gpu-operator.chart":           "gpu-operator",
+						"gpu-operator.values.replicas": "1.0",
+					}),
+					Recipe: recipeWithOverrides(map[string]any{
+						"replicas": 1,
+					}),
+				}
+			},
+			wantErr: false,
+		},
+		{
+			name: "boolean case normalization - True equals true",
+			setup: func() *checks.ValidationContext {
+				return &checks.ValidationContext{
+					Context: context.Background(),
+					Snapshot: snapshotWithHelm(map[string]string{
+						"gpu-operator.chart":                 "gpu-operator",
+						"gpu-operator.values.driver.enabled": "True",
+					}),
+					Recipe: recipeWithOverrides(map[string]any{
+						"driver": map[string]any{"enabled": true},
+					}),
+				}
+			},
+			wantErr: false,
+		},
 		{
 			name: "snapshot key not present for recipe key - skip that key",
 			setup: func() *checks.ValidationContext {
@@ -402,6 +434,38 @@ func TestFlattenValues(t *testing.T) {
 	}
 }
 
+func TestValuesEqual(t *testing.T) {
+	tests := []struct {
+		name     string
+		expected string
+		actual   string
+		want     bool
+	}{
+		{"exact match", "foo", "foo", true},
+		{"whitespace trim", " foo ", "foo", true},
+		{"different strings", "foo", "bar", false},
+		{"int vs float same value", "1", "1.0", true},
+		{"float vs int same value", "3.0", "3", true},
+		{"different numbers", "1", "2", false},
+		{"float precision", "3.14", "3.14", true},
+		{"float mismatch", "3.14", "3.15", false},
+		{"bool true case insensitive", "true", "True", true},
+		{"bool false case insensitive", "false", "FALSE", true},
+		{"bool mismatch", "true", "false", false},
+		{"bool vs string", "true", "yes", false},
+		{"numeric string vs non-numeric", "1", "one", false},
+		{"empty strings", "", "", true},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if got := valuesEqual(tt.expected, tt.actual); got != tt.want {
+				t.Errorf("valuesEqual(%q, %q) = %v, want %v", tt.expected, tt.actual, got, tt.want)
+			}
+		})
+	}
+}
+
 // snapshotWithHelm creates a snapshot with K8s helm subtype data from flat key-value pairs.
 func snapshotWithHelm(data map[string]string) *snapshotter.Snapshot {
 	helmData := make(map[string]measurement.Reading, len(data))