validations: Update the test structure and remove unused conditions

Author: LoginovIlia

pkg/validations/property/enum_test.go

@@ -192,40 +192,51 @@ func TestEnum(t *testing.T) {
 }
 
 func TestValidateEnumConfig(t *testing.T) {
-	t.Run("nil config", func(t *testing.T) {
-		if err := ValidateEnumConfig(nil); err != nil {
-			t.Fatalf("ValidateEnumConfig(nil) returned error: %v", err)
-		}
-	})
+	testcases := []struct {
+		name               string
+		cfg                *EnumConfig
+		wantErr            error
+		wantAdditionPolicy AdditionPolicy
+	}{
+		{
+			name: "nil config",
+			cfg:  nil,
+		},
+		{
+			name:               "defaults addition policy",
+			cfg:                &EnumConfig{},
+			wantAdditionPolicy: AdditionPolicyDisallow,
+		},
+		{
+			name:               "allows valid addition policies",
+			cfg:                &EnumConfig{AdditionPolicy: AdditionPolicyAllow},
+			wantAdditionPolicy: AdditionPolicyAllow,
+		},
+		{
+			name:    "invalid addition policy",
+			cfg:     &EnumConfig{AdditionPolicy: "invalid"},
+			wantErr: errUnknownAdditionPolicy,
+		},
+	}
 
-	t.Run("defaults addition policy", func(t *testing.T) {
-		cfg := &EnumConfig{}
-		if err := ValidateEnumConfig(cfg); err != nil {
-			t.Fatalf("unexpected error: %v", err)
-		}
-		if cfg.AdditionPolicy != AdditionPolicyDisallow {
-			t.Fatalf("expected default addition policy %q, got %q", AdditionPolicyDisallow, cfg.AdditionPolicy)
-		}
-	})
+	for _, tc := range testcases {
+		tc := tc
+		t.Run(tc.name, func(t *testing.T) {
+			err := ValidateEnumConfig(tc.cfg)
+			if tc.wantErr != nil {
+				if !errors.Is(err, tc.wantErr) {
+					t.Fatalf("expected error %v, got %v", tc.wantErr, err)
+				}
+				return
+			}
 
-	t.Run("allows valid addition policies", func(t *testing.T) {
-		cfg := &EnumConfig{AdditionPolicy: AdditionPolicyAllow}
-		if err := ValidateEnumConfig(cfg); err != nil {
-			t.Fatalf("unexpected error: %v", err)
-		}
-		if cfg.AdditionPolicy != AdditionPolicyAllow {
-			t.Fatalf("expected addition policy to remain %q, got %q", AdditionPolicyAllow, cfg.AdditionPolicy)
-		}
-	})
+			if err != nil {
+				t.Fatalf("unexpected error: %v", err)
+			}
 
-	t.Run("invalid addition policy", func(t *testing.T) {
-		cfg := &EnumConfig{AdditionPolicy: "invalid"}
-		err := ValidateEnumConfig(cfg)
-		if err == nil {
-			t.Fatalf("expected error, got nil")
-		}
-		if !errors.Is(err, errUnknownAdditionPolicy) {
-			t.Fatalf("expected errUnknownAdditionPolicy, got %v", err)
-		}
-	})
+			if tc.cfg != nil && tc.cfg.AdditionPolicy != tc.wantAdditionPolicy {
+				t.Fatalf("expected addition policy %q, got %q", tc.wantAdditionPolicy, tc.cfg.AdditionPolicy)
+			}
+		})
+	}
 }

pkg/validations/property/pattern.go

@@ -123,7 +123,7 @@ func (p *Pattern) Compare(a, b *apiextensionsv1.JSONSchemaProps) validations.Com
 		err = fmt.Errorf("%w : %q -> %q", ErrPatternAdded, a.Pattern, b.Pattern)
 	case a.Pattern != "" && b.Pattern == "" && p.RemovalPolicy != PatternRemovalPolicyAllow:
 		err = fmt.Errorf("%w : %q -> %q", ErrPatternRemoved, a.Pattern, b.Pattern)
-	case a.Pattern != "" && b.Pattern != "" && a.Pattern != b.Pattern:
+	case b.Pattern != "" && a.Pattern != b.Pattern:
 		err = fmt.Errorf("%w : %q -> %q", ErrPatternChanged, a.Pattern, b.Pattern)
 	}
 

pkg/validations/property/pattern_test.go

@@ -92,40 +92,51 @@ func TestPattern(t *testing.T) {
 }
 
 func TestValidatePatternConfig(t *testing.T) {
-	t.Run("nil config", func(t *testing.T) {
-		if err := ValidatePatternConfig(nil); err != nil {
-			t.Fatalf("ValidatePatternConfig(nil) returned error: %v", err)
-		}
-	})
+	testcases := []struct {
+		name              string
+		cfg               *PatternConfig
+		wantErr           error
+		wantRemovalPolicy PatternRemovalPolicy
+	}{
+		{
+			name: "nil config",
+			cfg:  nil,
+		},
+		{
+			name:              "defaults removal policy",
+			cfg:               &PatternConfig{},
+			wantRemovalPolicy: PatternRemovalPolicyDisallow,
+		},
+		{
+			name:              "allows valid removal policy",
+			cfg:               &PatternConfig{RemovalPolicy: PatternRemovalPolicyAllow},
+			wantRemovalPolicy: PatternRemovalPolicyAllow,
+		},
+		{
+			name:    "invalid removal policy mentions valid values",
+			cfg:     &PatternConfig{RemovalPolicy: "invalid"},
+			wantErr: errUnknownPatternRemovalPolicy,
+		},
+	}
 
-	t.Run("defaults removal policy", func(t *testing.T) {
-		cfg := &PatternConfig{}
-		if err := ValidatePatternConfig(cfg); err != nil {
-			t.Fatalf("unexpected error: %v", err)
-		}
-		if cfg.RemovalPolicy != PatternRemovalPolicyDisallow {
-			t.Fatalf("expected default removal policy %q, got %q", PatternRemovalPolicyDisallow, cfg.RemovalPolicy)
-		}
-	})
+	for _, tc := range testcases {
+		tc := tc
+		t.Run(tc.name, func(t *testing.T) {
+			err := ValidatePatternConfig(tc.cfg)
+			if tc.wantErr != nil {
+				if !errors.Is(err, tc.wantErr) {
+					t.Fatalf("expected error %v, got %v", tc.wantErr, err)
+				}
+				return
+			}
 
-	t.Run("allows valid removal policy", func(t *testing.T) {
-		cfg := &PatternConfig{RemovalPolicy: PatternRemovalPolicyAllow}
-		if err := ValidatePatternConfig(cfg); err != nil {
-			t.Fatalf("unexpected error: %v", err)
-		}
-		if cfg.RemovalPolicy != PatternRemovalPolicyAllow {
-			t.Fatalf("expected removal policy to remain %q, got %q", PatternRemovalPolicyAllow, cfg.RemovalPolicy)
-		}
-	})
+			if err != nil {
+				t.Fatalf("unexpected error: %v", err)
+			}
 
-	t.Run("invalid removal policy mentions valid values", func(t *testing.T) {
-		cfg := &PatternConfig{RemovalPolicy: "invalid"}
-		err := ValidatePatternConfig(cfg)
-		if err == nil {
-			t.Fatalf("expected error, got nil")
-		}
-		if !errors.Is(err, errUnknownPatternRemovalPolicy) {
-			t.Fatalf("expected errUnknownPatternRemovalPolicy, got %v", err)
-		}
-	})
+			if tc.cfg != nil && tc.cfg.RemovalPolicy != tc.wantRemovalPolicy {
+				t.Fatalf("expected removal policy %q, got %q", tc.wantRemovalPolicy, tc.cfg.RemovalPolicy)
+			}
+		})
+	}
 }