Bump ginkgolinter to v0.9.0 and add configurations

ginkgolinter version v0.9.0 brings two new rules. Both rules can be
disabled from the configuration.

This PR bumps the ginkgolinter to v0.9.0 and add the new configurations.

The two new rules are:
* haveLen(0) rule: `HaveLen(0)` ==> `BeEmpty()`
* wrong comparison rule: `Expect(x == y).To(BeTrue())` ==>
`Expect(x).To(Equal(y))`

Full details are in the ginkgolinter README.md file, here:
https://github.com/nunnatsa/ginkgolinter#readme.

Author: nunnatsa

.golangci.reference.yml

@@ -418,6 +418,14 @@ linters-settings:
     # Default: false
     suppress-err-assertion: true
 
+    # Suppress the wrong comparison assertion warning.
+    # Default: false
+    suppress-compare-assertion: true
+
+    # Don't trigger warnings for HaveLen(0)
+    # Default: false
+    allow-havelen-zero: true
+
   gocognit:
     # Minimal code complexity to report.
     # Default: 30 (but we recommend 10-20)

go.mod

@@ -74,7 +74,7 @@ require (
 	github.com/nakabonne/nestif v0.3.1
 	github.com/nishanths/exhaustive v0.9.5
 	github.com/nishanths/predeclared v0.2.2
-	github.com/nunnatsa/ginkgolinter v0.8.1
+	github.com/nunnatsa/ginkgolinter v0.9.0
 	github.com/polyfloyd/go-errorlint v1.2.0
 	github.com/quasilyte/go-ruleguard/dsl v0.3.22
 	github.com/ryancurrah/gomodguard v1.3.0
@@ -128,7 +128,7 @@ require (
 	github.com/fsnotify/fsnotify v1.5.4 // indirect
 	github.com/go-ole/go-ole v1.2.6 // indirect
 	github.com/go-toolsmith/astcast v1.1.0 // indirect
-	github.com/go-toolsmith/astcopy v1.0.3 // indirect
+	github.com/go-toolsmith/astcopy v1.1.0 // indirect
 	github.com/go-toolsmith/astequal v1.1.0 // indirect
 	github.com/go-toolsmith/astfmt v1.1.0 // indirect
 	github.com/go-toolsmith/astp v1.1.0 // indirect
@@ -178,7 +178,7 @@ require (
 	go.uber.org/multierr v1.6.0 // indirect
 	go.uber.org/zap v1.17.0 // indirect
 	golang.org/x/exp v0.0.0-20220722155223-a9213eeb770e // indirect
-	golang.org/x/exp/typeparams v0.0.0-20230203172020-98cc5a0785f9 // indirect
+	golang.org/x/exp/typeparams v0.0.0-20230224173230-c95f2b4c22f2 // indirect
 	golang.org/x/mod v0.8.0 // indirect
 	golang.org/x/sync v0.1.0 // indirect
 	golang.org/x/sys v0.5.0 // indirect

go.sum

@@ -325,9 +325,11 @@ type GciSettings struct {
 }
 
 type GinkgoLinterSettings struct {
-	SuppressLenAssertion bool `mapstructure:"suppress-len-assertion"`
-	SuppressNilAssertion bool `mapstructure:"suppress-nil-assertion"`
-	SuppressErrAssertion bool `mapstructure:"suppress-err-assertion"`
+	SuppressLenAssertion     bool `mapstructure:"suppress-len-assertion"`
+	SuppressNilAssertion     bool `mapstructure:"suppress-nil-assertion"`
+	SuppressErrAssertion     bool `mapstructure:"suppress-err-assertion"`
+	SuppressCompareAssertion bool `mapstructure:"suppress-compare-assertion"`
+	AllowHaveLenZero         bool `mapstructure:"allow-havelen-zero"`
 }
 
 type GocognitSettings struct {

pkg/config/linters_settings.go

@@ -14,9 +14,11 @@ func NewGinkgoLinter(cfg *config.GinkgoLinterSettings) *goanalysis.Linter {
 	cfgMap := make(map[string]map[string]interface{})
 	if cfg != nil {
 		cfgMap[a.Name] = map[string]interface{}{
-			"suppress-len-assertion": cfg.SuppressLenAssertion,
-			"suppress-nil-assertion": cfg.SuppressNilAssertion,
-			"suppress-err-assertion": cfg.SuppressErrAssertion,
+			"suppress-len-assertion":     cfg.SuppressLenAssertion,
+			"suppress-nil-assertion":     cfg.SuppressNilAssertion,
+			"suppress-err-assertion":     cfg.SuppressErrAssertion,
+			"suppress-compare-assertion": cfg.SuppressCompareAssertion,
+			"allow-havelen-0":            cfg.AllowHaveLenZero,
 		}
 	}
 

pkg/golinters/ginkgolinter.go

@@ -0,0 +1,3 @@
+linters-settings:
+  ginkgolinter:
+    allow-havelen-zero: true

test/testdata/ginkgolinter/configs/ginkgolinter_allow_havelen0.yml

@@ -0,0 +1,3 @@
+linters-settings:
+  ginkgolinter:
+    suppress-compare-assertion: true

test/testdata/ginkgolinter/configs/ginkgolinter_suppress_compare.yml

@@ -49,3 +49,18 @@ func ErrorUsecase() {
 	Expect(err != nil).To(BeTrue())      // want "ginkgo-linter: wrong error assertion; consider using .Expect\\(err\\)\\.To\\(HaveOccurred\\(\\)\\). instead"
 	Expect(funcReturnsErr()).To(BeNil()) // want "ginkgo-linter: wrong error assertion; consider using .Expect\\(funcReturnsErr\\(\\)\\)\\.To\\(Succeed\\(\\)\\). instead"
 }
+
+func HaveLen0Usecase() {
+	x := make([]string, 0)
+	Expect(x).To(HaveLen(0)) // want "ginkgo-linter: wrong length assertion; consider using .Expect\\(x\\)\\.To\\(BeEmpty\\(\\)\\). instead"
+}
+
+func WrongComparisonUsecase() {
+	x := 8
+	Expect(x == 8).To(BeTrue())    // want "ginkgo-linter: wrong comparison assertion; consider using .Expect\\(x\\)\\.To\\(Equal\\(8\\)\\). instead"
+	Expect(x < 9).To(BeTrue())     // want "ginkgo-linter: wrong comparison assertion; consider using .Expect\\(x\\)\\.To\\(BeNumerically\\(\"<\", 9\\)\\). instead"
+	Expect(x < 7).To(Equal(false)) // want "ginkgo-linter: wrong comparison assertion; consider using .Expect\\(x\\)\\.ToNot\\(BeNumerically\\(\"<\", 7\\)\\). instead"
+
+	p1, p2 := &x, &x
+	Expect(p1 == p2).To(Equal(true)) // want "ginkgo-linter: wrong comparison assertion; consider using .Expect\\(p1\\).To\\(BeIdenticalTo\\(p2\\)\\). instead"
+}

test/testdata/ginkgolinter/ginkgolinter.go

@@ -0,0 +1,67 @@
+//golangcitest:config_path configs/ginkgolinter_allow_havelen0.yml
+//golangcitest:args --disable-all -Eginkgolinter
+package ginkgolinter
+
+import (
+	"errors"
+	. "github.com/onsi/gomega"
+)
+
+func LenUsecase_havelen0() {
+	var fakeVarUnderTest []int
+	Expect(fakeVarUnderTest).Should(BeEmpty())     // valid
+	Expect(fakeVarUnderTest).ShouldNot(HaveLen(5)) // valid
+
+	Expect(len(fakeVarUnderTest)).Should(Equal(0))           // want "ginkgo-linter: wrong length assertion; consider using .Expect\\(fakeVarUnderTest\\)\\.Should\\(BeEmpty\\(\\)\\). instead"
+	Expect(len(fakeVarUnderTest)).ShouldNot(Equal(2))        // want "ginkgo-linter: wrong length assertion; consider using .Expect\\(fakeVarUnderTest\\)\\.ShouldNot\\(HaveLen\\(2\\)\\). instead"
+	Expect(len(fakeVarUnderTest)).To(BeNumerically("==", 0)) // // want "ginkgo-linter: wrong length assertion; consider using .Expect\\(fakeVarUnderTest\\)\\.To\\(BeEmpty\\(\\)\\). instead"
+
+	fakeVarUnderTest = append(fakeVarUnderTest, 3)
+	Expect(len(fakeVarUnderTest)).ShouldNot(Equal(0))        // want "ginkgo-linter: wrong length assertion; consider using .Expect\\(fakeVarUnderTest\\)\\.ShouldNot\\(BeEmpty\\(\\)\\). instead"
+	Expect(len(fakeVarUnderTest)).Should(Equal(1))           // want "ginkgo-linter: wrong length assertion; consider using .Expect\\(fakeVarUnderTest\\)\\.Should\\(HaveLen\\(1\\)\\). instead"
+	Expect(len(fakeVarUnderTest)).To(BeNumerically(">", 0))  // want "ginkgo-linter: wrong length assertion; consider using .Expect\\(fakeVarUnderTest\\)\\.ToNot\\(BeEmpty\\(\\)\\). instead"
+	Expect(len(fakeVarUnderTest)).To(BeNumerically(">=", 1)) // want "ginkgo-linter: wrong length assertion; consider using .Expect\\(fakeVarUnderTest\\)\\.ToNot\\(BeEmpty\\(\\)\\). instead"
+	Expect(len(fakeVarUnderTest)).To(BeNumerically("!=", 0)) // want "ginkgo-linter: wrong length assertion; consider using .Expect\\(fakeVarUnderTest\\)\\.ToNot\\(BeEmpty\\(\\)\\). instead"
+}
+
+func NilUsecase_havelen0() {
+	y := 5
+	x := &y
+	Expect(x == nil).To(Equal(true)) // want "ginkgo-linter: wrong nil assertion; consider using .Expect\\(x\\)\\.To\\(BeNil\\(\\)\\). instead"
+	Expect(nil == x).To(Equal(true)) // want "ginkgo-linter: wrong nil assertion; consider using .Expect\\(x\\)\\.To\\(BeNil\\(\\)\\). instead"
+	Expect(x != nil).To(Equal(true)) // want "ginkgo-linter: wrong nil assertion; consider using .Expect\\(x\\)\\.ToNot\\(BeNil\\(\\)\\). instead"
+	Expect(x == nil).To(BeTrue())    // want "ginkgo-linter: wrong nil assertion; consider using .Expect\\(x\\)\\.To\\(BeNil\\(\\)\\). instead"
+	Expect(x == nil).To(BeFalse())   // want "ginkgo-linter: wrong nil assertion; consider using .Expect\\(x\\)\\.ToNot\\(BeNil\\(\\)\\). instead"
+}
+func BooleanUsecase_havelen0() {
+	x := true
+	Expect(x).To(Equal(true)) // want "ginkgo-linter: wrong boolean assertion; consider using .Expect\\(x\\)\\.To\\(BeTrue\\(\\)\\). instead"
+	x = false
+	Expect(x).To(Equal(false)) // want "ginkgo-linter: wrong boolean assertion; consider using .Expect\\(x\\)\\.To\\(BeFalse\\(\\)\\). instead"
+}
+
+func ErrorUsecase_havelen0() {
+	err := errors.New("fake error")
+	funcReturnsErr := func() error { return err }
+
+	Expect(err).To(BeNil())              // want "ginkgo-linter: wrong error assertion; consider using .Expect\\(err\\)\\.ToNot\\(HaveOccurred\\(\\)\\). instead"
+	Expect(err == nil).To(Equal(true))   // want "ginkgo-linter: wrong error assertion; consider using .Expect\\(err\\)\\.ToNot\\(HaveOccurred\\(\\)\\). instead"
+	Expect(err == nil).To(BeFalse())     // want "ginkgo-linter: wrong error assertion; consider using .Expect\\(err\\)\\.To\\(HaveOccurred\\(\\)\\). instead"
+	Expect(err != nil).To(BeTrue())      // want "ginkgo-linter: wrong error assertion; consider using .Expect\\(err\\)\\.To\\(HaveOccurred\\(\\)\\). instead"
+	Expect(funcReturnsErr()).To(BeNil()) // want "ginkgo-linter: wrong error assertion; consider using .Expect\\(funcReturnsErr\\(\\)\\)\\.To\\(Succeed\\(\\)\\). instead"
+}
+
+func HaveLen0Usecase_havelen0() {
+	x := make([]string, 0)
+	Expect(x).To(HaveLen(0))
+}
+
+func WrongComparisonUsecase_havelen0() {
+	x := 8
+	Expect(x == 8).To(BeTrue())    // want "ginkgo-linter: wrong comparison assertion; consider using .Expect\\(x\\)\\.To\\(Equal\\(8\\)\\). instead"
+	Expect(x < 9).To(BeTrue())     // want "ginkgo-linter: wrong comparison assertion; consider using .Expect\\(x\\)\\.To\\(BeNumerically\\(\"<\", 9\\)\\). instead"
+	Expect(x < 7).To(Equal(false)) // want "ginkgo-linter: wrong comparison assertion; consider using .Expect\\(x\\)\\.ToNot\\(BeNumerically\\(\"<\", 7\\)\\). instead"
+
+	p1, p2 := &x, &x
+	Expect(p1 == p2).To(Equal(true)) // want "ginkgo-linter: wrong comparison assertion; consider using .Expect\\(p1\\).To\\(BeIdenticalTo\\(p2\\)\\). instead"
+}

test/testdata/ginkgolinter/ginkgolinter_havelen0.go

@@ -0,0 +1,68 @@
+//golangcitest:config_path configs/ginkgolinter_suppress_compare.yml
+//golangcitest:args --disable-all -Eginkgolinter
+package ginkgolinter
+
+import (
+	"errors"
+	. "github.com/onsi/gomega"
+)
+
+func LenUsecase_compare() {
+	var fakeVarUnderTest []int
+	Expect(fakeVarUnderTest).Should(BeEmpty())     // valid
+	Expect(fakeVarUnderTest).ShouldNot(HaveLen(5)) // valid
+
+	Expect(len(fakeVarUnderTest)).Should(Equal(0))           // want "ginkgo-linter: wrong length assertion; consider using .Expect\\(fakeVarUnderTest\\)\\.Should\\(BeEmpty\\(\\)\\). instead"
+	Expect(len(fakeVarUnderTest)).ShouldNot(Equal(2))        // want "ginkgo-linter: wrong length assertion; consider using .Expect\\(fakeVarUnderTest\\)\\.ShouldNot\\(HaveLen\\(2\\)\\). instead"
+	Expect(len(fakeVarUnderTest)).To(BeNumerically("==", 0)) // // want "ginkgo-linter: wrong length assertion; consider using .Expect\\(fakeVarUnderTest\\)\\.To\\(BeEmpty\\(\\)\\). instead"
+
+	fakeVarUnderTest = append(fakeVarUnderTest, 3)
+	Expect(len(fakeVarUnderTest)).ShouldNot(Equal(0))        // want "ginkgo-linter: wrong length assertion; consider using .Expect\\(fakeVarUnderTest\\)\\.ShouldNot\\(BeEmpty\\(\\)\\). instead"
+	Expect(len(fakeVarUnderTest)).Should(Equal(1))           // want "ginkgo-linter: wrong length assertion; consider using .Expect\\(fakeVarUnderTest\\)\\.Should\\(HaveLen\\(1\\)\\). instead"
+	Expect(len(fakeVarUnderTest)).To(BeNumerically(">", 0))  // want "ginkgo-linter: wrong length assertion; consider using .Expect\\(fakeVarUnderTest\\)\\.ToNot\\(BeEmpty\\(\\)\\). instead"
+	Expect(len(fakeVarUnderTest)).To(BeNumerically(">=", 1)) // want "ginkgo-linter: wrong length assertion; consider using .Expect\\(fakeVarUnderTest\\)\\.ToNot\\(BeEmpty\\(\\)\\). instead"
+	Expect(len(fakeVarUnderTest)).To(BeNumerically("!=", 0)) // want "ginkgo-linter: wrong length assertion; consider using .Expect\\(fakeVarUnderTest\\)\\.ToNot\\(BeEmpty\\(\\)\\). instead"
+}
+
+func NilUsecase_compare() {
+	y := 5
+	x := &y
+	Expect(x == nil).To(Equal(true)) // want "ginkgo-linter: wrong nil assertion; consider using .Expect\\(x\\)\\.To\\(BeNil\\(\\)\\). instead"
+	Expect(nil == x).To(Equal(true)) // want "ginkgo-linter: wrong nil assertion; consider using .Expect\\(x\\)\\.To\\(BeNil\\(\\)\\). instead"
+	Expect(x != nil).To(Equal(true)) // want "ginkgo-linter: wrong nil assertion; consider using .Expect\\(x\\)\\.ToNot\\(BeNil\\(\\)\\). instead"
+	Expect(x == nil).To(BeTrue())    // want "ginkgo-linter: wrong nil assertion; consider using .Expect\\(x\\)\\.To\\(BeNil\\(\\)\\). instead"
+	Expect(x == nil).To(BeFalse())   // want "ginkgo-linter: wrong nil assertion; consider using .Expect\\(x\\)\\.ToNot\\(BeNil\\(\\)\\). instead"
+}
+func BooleanUsecase_compare() {
+	x := true
+	Expect(x).To(Equal(true)) // want "ginkgo-linter: wrong boolean assertion; consider using .Expect\\(x\\)\\.To\\(BeTrue\\(\\)\\). instead"
+	x = false
+	Expect(x).To(Equal(false)) // want "ginkgo-linter: wrong boolean assertion; consider using .Expect\\(x\\)\\.To\\(BeFalse\\(\\)\\). instead"
+}
+
+func ErrorUsecase_compare() {
+	err := errors.New("fake error")
+	funcReturnsErr := func() error { return err }
+
+	Expect(err).To(BeNil())              // want "ginkgo-linter: wrong error assertion; consider using .Expect\\(err\\)\\.ToNot\\(HaveOccurred\\(\\)\\). instead"
+	Expect(err == nil).To(Equal(true))   // want "ginkgo-linter: wrong error assertion; consider using .Expect\\(err\\)\\.ToNot\\(HaveOccurred\\(\\)\\). instead"
+	Expect(err == nil).To(BeFalse())     // want "ginkgo-linter: wrong error assertion; consider using .Expect\\(err\\)\\.To\\(HaveOccurred\\(\\)\\). instead"
+	Expect(err != nil).To(BeTrue())      // want "ginkgo-linter: wrong error assertion; consider using .Expect\\(err\\)\\.To\\(HaveOccurred\\(\\)\\). instead"
+	Expect(funcReturnsErr()).To(BeNil()) // want "ginkgo-linter: wrong error assertion; consider using .Expect\\(funcReturnsErr\\(\\)\\)\\.To\\(Succeed\\(\\)\\). instead"
+}
+
+func HaveLen0Usecase_compare() {
+	x := make([]string, 0)
+	Expect(x).To(HaveLen(0)) // want "ginkgo-linter: wrong length assertion; consider using .Expect\\(x\\)\\.To\\(BeEmpty\\(\\)\\). instead"
+}
+
+// WrongComparisonUsecase_compare should not trigger any warning
+func WrongComparisonUsecase_compare() {
+	x := 8
+	Expect(x == 8).To(BeTrue())
+	Expect(x < 9).To(BeTrue())
+	Expect(x < 7).To(Equal(false))
+
+	p1, p2 := &x, &x
+	Expect(p1 == p2).To(Equal(true))
+}

test/testdata/ginkgolinter/ginkgolinter_suppress_compare.go

@@ -40,6 +40,7 @@ func BooleanUsecase_err() {
 	Expect(x).To(Equal(false)) // want "ginkgo-linter: wrong boolean assertion; consider using .Expect\\(x\\)\\.To\\(BeFalse\\(\\)\\). instead"
 }
 
+// ErrorUsecase_err should not trigger any warning
 func ErrorUsecase_err() {
 	err := errors.New("fake error")
 	funcReturnsErr := func() error { return err }
@@ -50,3 +51,18 @@ func ErrorUsecase_err() {
 	Expect(err != nil).To(BeTrue())
 	Expect(funcReturnsErr()).To(BeNil())
 }
+
+func HaveLen0Usecase_err() {
+	x := make([]string, 0)
+	Expect(x).To(HaveLen(0)) // want "ginkgo-linter: wrong length assertion; consider using .Expect\\(x\\)\\.To\\(BeEmpty\\(\\)\\). instead"
+}
+
+func WrongComparisonUsecase_err() {
+	x := 8
+	Expect(x == 8).To(BeTrue())    // want "ginkgo-linter: wrong comparison assertion; consider using .Expect\\(x\\)\\.To\\(Equal\\(8\\)\\). instead"
+	Expect(x < 9).To(BeTrue())     // want "ginkgo-linter: wrong comparison assertion; consider using .Expect\\(x\\)\\.To\\(BeNumerically\\(\"<\", 9\\)\\). instead"
+	Expect(x < 7).To(Equal(false)) // want "ginkgo-linter: wrong comparison assertion; consider using .Expect\\(x\\)\\.ToNot\\(BeNumerically\\(\"<\", 7\\)\\). instead"
+
+	p1, p2 := &x, &x
+	Expect(p1 == p2).To(Equal(true)) // want "ginkgo-linter: wrong comparison assertion; consider using .Expect\\(p1\\).To\\(BeIdenticalTo\\(p2\\)\\). instead"
+}

test/testdata/ginkgolinter/ginkgolinter_suppress_err.go

@@ -7,6 +7,7 @@ import (
 	. "github.com/onsi/gomega"
 )
 
+// LenUsecase_len should not trigger any warning
 func LenUsecase_len() {
 	var fakeVarUnderTest []int
 	Expect(fakeVarUnderTest).Should(BeEmpty())     // valid
@@ -50,3 +51,18 @@ func ErrorUsecase_len() {
 	Expect(err != nil).To(BeTrue())      // want "ginkgo-linter: wrong error assertion; consider using .Expect\\(err\\)\\.To\\(HaveOccurred\\(\\)\\). instead"
 	Expect(funcReturnsErr()).To(BeNil()) // want "ginkgo-linter: wrong error assertion; consider using .Expect\\(funcReturnsErr\\(\\)\\)\\.To\\(Succeed\\(\\)\\). instead"
 }
+
+func HaveLen0Usecase_len() {
+	x := make([]string, 0)
+	Expect(x).To(HaveLen(0)) // want "ginkgo-linter: wrong length assertion; consider using .Expect\\(x\\)\\.To\\(BeEmpty\\(\\)\\). instead"
+}
+
+func WrongComparisonUsecase_len() {
+	x := 8
+	Expect(x == 8).To(BeTrue())    // want "ginkgo-linter: wrong comparison assertion; consider using .Expect\\(x\\)\\.To\\(Equal\\(8\\)\\). instead"
+	Expect(x < 9).To(BeTrue())     // want "ginkgo-linter: wrong comparison assertion; consider using .Expect\\(x\\)\\.To\\(BeNumerically\\(\"<\", 9\\)\\). instead"
+	Expect(x < 7).To(Equal(false)) // want "ginkgo-linter: wrong comparison assertion; consider using .Expect\\(x\\)\\.ToNot\\(BeNumerically\\(\"<\", 7\\)\\). instead"
+
+	p1, p2 := &x, &x
+	Expect(p1 == p2).To(Equal(true)) // want "ginkgo-linter: wrong comparison assertion; consider using .Expect\\(p1\\).To\\(BeIdenticalTo\\(p2\\)\\). instead"
+}