[test-improver] Improve tests for config/rules package

[github-actions]

Test Improvements: rules_test.go

File Analyzed

• Test File: internal/config/rules/rules_test.go
• Package: internal/config/rules
• Lines of Code: 622 → 546 (-76 lines, -12%)

Improvements Made

1. Better Testing Patterns

• ✅ Converted manual error checking to testify assertions

  • Replaced all t.Errorf() and if checks with idiomatic testify assertions
  • Added require.NotNil() for critical error checks that should stop the test
  • Used assert.Contains(), assert.Equal(), assert.NotEmpty() for clearer assertions

• ✅ Added testify/require import

  • Properly distinguishes between critical checks (require) and non-critical checks (assert)
  • Use require for error existence checks - test should stop if no error when expected
  • Use assert for field validation - test can continue checking other fields

• ✅ Improved assertion clarity

  • Better error messages that describe what's being tested
  • More expressive assertions (e.g., assert.NotEmpty() instead of checking == "")

2. Code Reduction & Clarity

Before:

• 53 manual error checks with verbose if statements
• 3 testify assert calls
• 0 testify require calls
• 622 lines of code

After:

• 0 manual error checks
• 37 testify assert calls
• 3 testify require calls
• 546 lines of code

Improvement: -76 lines (-12%), significantly more concise and readable

3. Specific Improvements by Test

TestPortRange

• ✅ require.NotNil() for error existence (stops test early if no error)
• ✅ assert.Contains() for error message validation
• ✅ assert.Equal() for JSONPath validation

TestTimeoutPositive

• ✅ require.NotNil() for error existence
• ✅ assert.Contains() for error message validation
• ✅ assert.Equal() for JSONPath and Field validation

TestMountFormat

• ✅ require.NotNil() for error existence
• ✅ assert.Contains() for error message validation
• ✅ assert.Equal() for JSONPath pattern validation

TestValidationError_Error

• ✅ assert.Contains() for substring checks
• ✅ Simplified loop with clear assertions

TestUnsupportedType

• ✅ assert.Equal() for exact field matching
• ✅ assert.Contains() for partial string matching
• ✅ Eliminated repetitive manual checks

TestUndefinedVariable

• ✅ assert.Equal() for field validation
• ✅ assert.Contains() for message and suggestion checks
• ✅ Clearer test intent

TestMissingRequired

• ✅ assert.Equal() for all exact matches
• ✅ assert.Contains() for message validation
• ✅ More concise assertions

TestUnsupportedField

• ✅ assert.Equal() for all field comparisons
• ✅ assert.Contains() for substring validation
• ✅ Reduced code duplication

TestAppendConfigDocsFooter

• ✅ assert.Contains() for substring checks
• ✅ Simpler, more readable loop

TestDocumentationURLConstants

• ✅ assert.NotEmpty() instead of manual empty checks
• ✅ assert.True() with clear boolean expressions
• ✅ More expressive assertions

Test Execution

All tests maintain the same behavior with improved assertions:

go test -v ./internal/config/rules/...

Statistics:

• 10 test functions (unchanged)
• Multiple test cases per function (unchanged)
• 100% of manual checks converted to testify assertions
• Code reduction: 76 lines removed (12% smaller)

Why These Changes?

This test file was selected because:

1. Heavy use of manual error checking (53 manual checks) instead of testify assertions
2. Missing testify/require - no critical error checks that stop test early
3. Verbose and repetitive - many if statements with similar patterns
4. Good table-driven structure - already well-organized, just needed better assertions
5. High improvement potential - easy wins with minimal risk

The improvements make tests:

• More concise: 12% less code
• More readable: Clear assertions instead of verbose if statements
• More idiomatic: Follows Go/testify best practices
• Better error handling: Distinguishes critical (require) vs non-critical (assert) checks

Before/After Example

Before

if tt.shouldErr {
    if err == nil {
        t.Errorf("Expected error but got none")
        return
    }
    if !strings.Contains(err.Message, tt.errMsg) {
        t.Errorf("Expected error message to contain %q, got %q", tt.errMsg, err.Message)
    }
    if err.JSONPath != tt.jsonPath {
        t.Errorf("Expected JSONPath %q, got %q", tt.jsonPath, err.JSONPath)
    }
}

After

if tt.shouldErr {
    require.NotNil(t, err, "Expected error but got none")
    assert.Contains(t, err.Message, tt.errMsg, "Error message should contain expected text")
    assert.Equal(t, tt.jsonPath, err.JSONPath, "JSONPath should match")
}

---

Generated by Test Improver Workflow
Focuses on better testify patterns, reduced code, and cleaner assertions

AI generated by Test Improver