new checker 'equal-values' (#223)

* new checker 'equal-values'

* self-review fixes

Author: Antonboom

CONTRIBUTING.md

@@ -59,9 +59,9 @@ By default, we disable the checker if we doubt its 100% usefulness.
 
 Create new `TimeCompareTestsGenerator` in `internal/testgen/gen_time_compare.go`.
 
-See examples in adjacent files.
+See examples in adjacent files, e.g. [internal/testgen/gen_regexp.go](internal/testgen/gen_regexp.go).
 
-In the first iteration, these can be a very simple tests for debugging checker's proof of concept.
+In the first iteration, these can be a simple tests for debugging checker's proof of concept.
 And after the implementation of the checker, you can add various cycles, variables, etc. to the template.
 
 `GoldenTemplate` is usually an `ErroredTemplate` with some strings replaced.
@@ -211,19 +211,6 @@ func (s *ServiceIntegrationSuite) TearDownTest() {
 
 ---
 
-### equal-values
-
-```go
-❌   assert.Equal(t, int64(100), price.Amount)
-✅   assert.EqualValues(t, 100, price.Amount)
-```
-
-**Autofix**: true. <br>
-**Enabled by default**: maybe? <br>
-**Reason**: Code simplification.
-
----
-
 ### float-compare
 
 1) Support other tricky cases

README.md

@@ -97,6 +97,7 @@ https://golangci-lint.run/usage/linters/#testifylint
 | [contains](#contains)                               | ✅                  | ✅       |
 | [empty](#empty)                                     | ✅                  | ✅       |
 | [encoded-compare](#encoded-compare)                 | ✅                  | ✅       |
+| [equal-values](#equal-values)                       | ✅                  | ✅       |
 | [error-is-as](#error-is-as)                         | ✅                  | 🤏      |
 | [error-nil](#error-nil)                             | ✅                  | ✅       |
 | [expected-actual](#expected-actual)                 | ✅                  | ✅       |
@@ -308,6 +309,30 @@ needed.
 
 ---
 
+### equal-values
+
+```go
+❌
+assert.EqualValues(t, 42, result.IntField)
+assert.NotEqualValues(t, 42, result.IntField)
+// And other variations with similar types (strings, numerics, structs, etc.)...
+
+✅
+assert.Equal(t, 42, result.IntField)
+assert.NotEqual(t, 42, result.IntField)
+```
+
+**Autofix**: true. <br>
+**Enabled by default**: true. <br>
+**Reason**: Using more appropriate and more error-proof `testify` API.
+
+In additional:
+
+1. Overflow-underflow issues are [covered by testify itself](https://github.com/stretchr/testify/pull/1531).
+2. Nil comparisons are covered by [nil-compare](#nil-compare).
+
+---
+
 ### error-is-as
 
 ```go

analyzer/analyzer_test.go

@@ -68,6 +68,10 @@ func TestTestifyLint_NotDefaultCases(t *testing.T) {
 			dir:   "encoded-compare-issue198",
 			flags: map[string]string{"disable-all": "true", "enable": checkers.NewEncodedCompare().Name()},
 		},
+		{
+			dir:   "equal-values-different-pkg",
+			flags: map[string]string{"disable-all": "true", "enable": checkers.NewEqualValues().Name()},
+		},
 		{
 			dir:   "error-as-target",
 			flags: map[string]string{"disable-all": "true", "enable": checkers.NewErrorIsAs().Name()},

analyzer/checkers_factory_test.go

@@ -27,6 +27,7 @@ func Test_newCheckers(t *testing.T) {
 		checkers.NewEncodedCompare(),
 		checkers.NewExpectedActual(),
 		checkers.NewLen(),
+		checkers.NewEqualValues(),
 		checkers.NewRegexp(),
 		checkers.NewSuiteExtraAssertCall(),
 		checkers.NewSuiteDontUsePkg(),
@@ -46,6 +47,7 @@ func Test_newCheckers(t *testing.T) {
 		checkers.NewEncodedCompare(),
 		checkers.NewExpectedActual(),
 		checkers.NewLen(),
+		checkers.NewEqualValues(),
 		checkers.NewRegexp(),
 		checkers.NewSuiteExtraAssertCall(),
 		checkers.NewSuiteDontUsePkg(),

analyzer/testdata/src/checkers-default/equal-values/equal_values_test.go

@@ -0,0 +1,141 @@
+// Code generated by testifylint/internal/testgen. DO NOT EDIT.
+
+package equalvalues
+
+import (
+	"crypto/tls"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+type S []string
+
+type Request struct{ ID string }
+type RequestWithTags struct {
+	ID string `json:"name"`
+}
+type Arg struct{ ID string }
+
+func TestEqualValuesChecker(t *testing.T) {
+	var (
+		i   int
+		i8  int8
+		i16 int16
+		i32 int32
+		i64 int64
+	)
+	var (
+		ui   uint
+		ui8  uint8
+		ui16 uint16
+		ui32 uint32
+		ui64 uint64
+	)
+	var (
+		str         string
+		req         Request
+		reqWithTags RequestWithTags
+		dto         Arg
+		ss          struct{ int }
+		m           map[string]string
+		mm          map[any]any
+		b           []byte
+		f           func() bool
+	)
+	tlsConf := new(tls.Config)
+
+	// Invalid.
+	{
+		assert.Equal(t, 42, i)                                                         // want "equal-values: use assert\\.Equal"
+		assert.Equalf(t, 42, i, "msg with args %d %s", 42, "42")                       // want "equal-values: use assert\\.Equalf"
+		assert.Equal(t, int8(42), i8)                                                  // want "equal-values: use assert\\.Equal"
+		assert.Equalf(t, int8(42), i8, "msg with args %d %s", 42, "42")                // want "equal-values: use assert\\.Equalf"
+		assert.Equal(t, int16(42), i16)                                                // want "equal-values: use assert\\.Equal"
+		assert.Equalf(t, int16(42), i16, "msg with args %d %s", 42, "42")              // want "equal-values: use assert\\.Equalf"
+		assert.Equal(t, int32(42), i32)                                                // want "equal-values: use assert\\.Equal"
+		assert.Equalf(t, int32(42), i32, "msg with args %d %s", 42, "42")              // want "equal-values: use assert\\.Equalf"
+		assert.Equal(t, int64(42), i64)                                                // want "equal-values: use assert\\.Equal"
+		assert.Equalf(t, int64(42), i64, "msg with args %d %s", 42, "42")              // want "equal-values: use assert\\.Equalf"
+		assert.Equal(t, uint(42), ui)                                                  // want "equal-values: use assert\\.Equal"
+		assert.Equalf(t, uint(42), ui, "msg with args %d %s", 42, "42")                // want "equal-values: use assert\\.Equalf"
+		assert.Equal(t, uint8(42), ui8)                                                // want "equal-values: use assert\\.Equal"
+		assert.Equalf(t, uint8(42), ui8, "msg with args %d %s", 42, "42")              // want "equal-values: use assert\\.Equalf"
+		assert.Equal(t, uint16(42), ui16)                                              // want "equal-values: use assert\\.Equal"
+		assert.Equalf(t, uint16(42), ui16, "msg with args %d %s", 42, "42")            // want "equal-values: use assert\\.Equalf"
+		assert.Equal(t, uint32(42), ui32)                                              // want "equal-values: use assert\\.Equal"
+		assert.Equalf(t, uint32(42), ui32, "msg with args %d %s", 42, "42")            // want "equal-values: use assert\\.Equalf"
+		assert.Equal(t, uint64(42), ui64)                                              // want "equal-values: use assert\\.Equal"
+		assert.Equalf(t, uint64(42), ui64, "msg with args %d %s", 42, "42")            // want "equal-values: use assert\\.Equalf"
+		assert.Equal(t, "42", str)                                                     // want "equal-values: use assert\\.Equal"
+		assert.Equalf(t, "42", str, "msg with args %d %s", 42, "42")                   // want "equal-values: use assert\\.Equalf"
+		assert.Equal(t, req, req)                                                      // want "equal-values: use assert\\.Equal"
+		assert.Equalf(t, req, req, "msg with args %d %s", 42, "42")                    // want "equal-values: use assert\\.Equalf"
+		assert.Equal(t, struct{ int }{}, ss)                                           // want "equal-values: use assert\\.Equal"
+		assert.Equalf(t, struct{ int }{}, ss, "msg with args %d %s", 42, "42")         // want "equal-values: use assert\\.Equalf"
+		assert.Equal(t, map[any]any{}, mm)                                             // want "equal-values: use assert\\.Equal"
+		assert.Equalf(t, map[any]any{}, mm, "msg with args %d %s", 42, "42")           // want "equal-values: use assert\\.Equalf"
+		assert.Equal(t, []byte(nil), b)                                                // want "equal-values: use assert\\.Equal"
+		assert.Equalf(t, []byte(nil), b, "msg with args %d %s", 42, "42")              // want "equal-values: use assert\\.Equalf"
+		assert.Equal(t, map[string]string(nil), m)                                     // want "equal-values: use assert\\.Equal"
+		assert.Equalf(t, map[string]string(nil), m, "msg with args %d %s", 42, "42")   // want "equal-values: use assert\\.Equalf"
+		assert.Equal(t, (*tls.Config)(nil), tlsConf)                                   // want "equal-values: use assert\\.Equal"
+		assert.Equalf(t, (*tls.Config)(nil), tlsConf, "msg with args %d %s", 42, "42") // want "equal-values: use assert\\.Equalf"
+		assert.NotEqual(t, 42, i)                                                      // want "equal-values: use assert\\.NotEqual"
+		assert.NotEqualf(t, 42, i, "msg with args %d %s", 42, "42")                    // want "equal-values: use assert\\.NotEqualf"
+	}
+
+	// Valid.
+	{
+		assert.Equal(t, 42, i)
+		assert.Equalf(t, 42, i, "msg with args %d %s", 42, "42")
+		assert.Equal(t, int8(42), i8)
+		assert.Equalf(t, int8(42), i8, "msg with args %d %s", 42, "42")
+		assert.Equal(t, int16(42), i16)
+		assert.Equalf(t, int16(42), i16, "msg with args %d %s", 42, "42")
+		assert.Equal(t, int32(42), i32)
+		assert.Equalf(t, int32(42), i32, "msg with args %d %s", 42, "42")
+		assert.Equal(t, int64(42), i64)
+		assert.Equalf(t, int64(42), i64, "msg with args %d %s", 42, "42")
+		assert.Equal(t, uint(42), ui)
+		assert.Equalf(t, uint(42), ui, "msg with args %d %s", 42, "42")
+		assert.Equal(t, uint8(42), ui8)
+		assert.Equalf(t, uint8(42), ui8, "msg with args %d %s", 42, "42")
+		assert.Equal(t, uint16(42), ui16)
+		assert.Equalf(t, uint16(42), ui16, "msg with args %d %s", 42, "42")
+		assert.Equal(t, uint32(42), ui32)
+		assert.Equalf(t, uint32(42), ui32, "msg with args %d %s", 42, "42")
+		assert.Equal(t, uint64(42), ui64)
+		assert.Equalf(t, uint64(42), ui64, "msg with args %d %s", 42, "42")
+		assert.Equal(t, "42", str)
+		assert.Equalf(t, "42", str, "msg with args %d %s", 42, "42")
+		assert.Equal(t, req, req)
+		assert.Equalf(t, req, req, "msg with args %d %s", 42, "42")
+		assert.Equal(t, struct{ int }{}, ss)
+		assert.Equalf(t, struct{ int }{}, ss, "msg with args %d %s", 42, "42")
+		assert.Equal(t, map[any]any{}, mm)
+		assert.Equalf(t, map[any]any{}, mm, "msg with args %d %s", 42, "42")
+		assert.Equal(t, []byte(nil), b)
+		assert.Equalf(t, []byte(nil), b, "msg with args %d %s", 42, "42")
+		assert.Equal(t, map[string]string(nil), m)
+		assert.Equalf(t, map[string]string(nil), m, "msg with args %d %s", 42, "42")
+		assert.Equal(t, (*tls.Config)(nil), tlsConf)
+		assert.Equalf(t, (*tls.Config)(nil), tlsConf, "msg with args %d %s", 42, "42")
+		assert.NotEqual(t, 42, i)
+		assert.NotEqualf(t, 42, i, "msg with args %d %s", 42, "42")
+		assert.EqualValues(t, 2048, mm["Etype"])
+		assert.EqualValuesf(t, 2048, mm["Etype"], "msg with args %d %s", 42, "42")
+		assert.EqualValues(t, req, dto)
+		assert.EqualValuesf(t, req, dto, "msg with args %d %s", 42, "42")
+		assert.EqualValues(t, req, reqWithTags)
+		assert.EqualValuesf(t, req, reqWithTags, "msg with args %d %s", 42, "42")
+		assert.EqualValues(t, S{"1"}, []string{"1"})
+		assert.EqualValuesf(t, S{"1"}, []string{"1"}, "msg with args %d %s", 42, "42")
+		assert.EqualValues(t, f, (func())(nil))
+		assert.EqualValuesf(t, f, (func())(nil), "msg with args %d %s", 42, "42")
+		assert.EqualValues(t, (func())(nil), f)
+		assert.EqualValuesf(t, (func())(nil), f, "msg with args %d %s", 42, "42")
+		assert.NotEqualValues(t, 2048, mm["Etype"])
+		assert.NotEqualValuesf(t, 2048, mm["Etype"], "msg with args %d %s", 42, "42")
+	}
+}