extend testing library (error matching with ShouldNotReconcile)

Author: Diaphteiros

pkg/testing/complex_environment.go

@@ -8,6 +8,7 @@ import (
 	"time"
 
 	"github.com/onsi/gomega"
+	"github.com/onsi/gomega/types"
 	"k8s.io/apimachinery/pkg/runtime"
 	"k8s.io/apimachinery/pkg/util/uuid"
 	clientgoscheme "k8s.io/client-go/kubernetes/scheme"
@@ -18,6 +19,7 @@ import (
 	"sigs.k8s.io/controller-runtime/pkg/reconcile"
 
 	"github.com/openmcp-project/controller-utils/pkg/logging"
+	"github.com/openmcp-project/controller-utils/pkg/testing/matchers"
 )
 
 /////////////////
@@ -84,27 +86,37 @@ func (e *ComplexEnvironment) shouldEventuallyReconcile(reconciler string, req re
 
 // ShouldNotReconcile calls the given reconciler with the given request and expects an error.
 func (e *ComplexEnvironment) ShouldNotReconcile(reconciler string, req reconcile.Request, optionalDescription ...interface{}) reconcile.Result {
-	return e.shouldNotReconcile(reconciler, req, optionalDescription...)
+	return e.shouldNotReconcile(reconciler, req, nil, optionalDescription...)
 }
 
-func (e *ComplexEnvironment) shouldNotReconcile(reconciler string, req reconcile.Request, optionalDescription ...interface{}) reconcile.Result {
+// ShouldNotReconcileWithError calls the given reconciler with the given request and expects an error that matches the given matcher.
+func (e *ComplexEnvironment) ShouldNotReconcileWithError(reconciler string, req reconcile.Request, matcher types.GomegaMatcher, optionalDescription ...interface{}) reconcile.Result {
+	return e.shouldNotReconcile(reconciler, req, matcher, optionalDescription...)
+}
+
+func (e *ComplexEnvironment) shouldNotReconcile(reconciler string, req reconcile.Request, matcher types.GomegaMatcher, optionalDescription ...interface{}) reconcile.Result {
 	res, err := e.Reconcilers[reconciler].Reconcile(e.Ctx, req)
-	gomega.ExpectWithOffset(2, err).To(gomega.HaveOccurred(), optionalDescription...)
+	gomega.ExpectWithOffset(2, err).To(gomega.And(gomega.HaveOccurred(), matchers.MaybeMatch(matcher)), optionalDescription...)
 	return res
 }
 
 // ShouldEventuallyNotReconcile calls the given reconciler with the given request and retries until an error occurred or the timeout is reached.
 func (e *ComplexEnvironment) ShouldEventuallyNotReconcile(reconciler string, req reconcile.Request, timeout, poll time.Duration, optionalDescription ...interface{}) reconcile.Result {
-	return e.shouldEventuallyNotReconcile(reconciler, req, timeout, poll, optionalDescription...)
+	return e.shouldEventuallyNotReconcile(reconciler, req, nil, timeout, poll, optionalDescription...)
+}
+
+// ShouldEventuallyNotReconcileWithError calls the given reconciler with the given request and retries until an error that matches the given matcher occurred or the timeout is reached.
+func (e *ComplexEnvironment) ShouldEventuallyNotReconcileWithError(reconciler string, req reconcile.Request, matcher types.GomegaMatcher, timeout, poll time.Duration, optionalDescription ...interface{}) reconcile.Result {
+	return e.shouldEventuallyNotReconcile(reconciler, req, matcher, timeout, poll, optionalDescription...)
 }
 
-func (e *ComplexEnvironment) shouldEventuallyNotReconcile(reconciler string, req reconcile.Request, timeout, poll time.Duration, optionalDescription ...interface{}) reconcile.Result {
+func (e *ComplexEnvironment) shouldEventuallyNotReconcile(reconciler string, req reconcile.Request, matcher types.GomegaMatcher, timeout, poll time.Duration, optionalDescription ...interface{}) reconcile.Result {
 	var err error
 	var res reconcile.Result
 	gomega.EventuallyWithOffset(1, func() error {
 		res, err = e.Reconcilers[reconciler].Reconcile(e.Ctx, req)
 		return err
-	}, timeout, poll).ShouldNot(gomega.Succeed(), optionalDescription...)
+	}, timeout, poll).ShouldNot(gomega.And(gomega.Succeed(), matchers.MaybeMatch(matcher)), optionalDescription...)
 	return res
 }
 

pkg/testing/environment.go

@@ -8,6 +8,8 @@ import (
 	"sigs.k8s.io/controller-runtime/pkg/client"
 	"sigs.k8s.io/controller-runtime/pkg/reconcile"
 
+	"github.com/onsi/gomega/types"
+
 	"github.com/openmcp-project/controller-utils/pkg/logging"
 )
 
@@ -48,12 +50,22 @@ func (e *Environment) ShouldEventuallyReconcile(req reconcile.Request, timeout,
 
 // ShouldNotReconcile calls the given reconciler with the given request and expects an error.
 func (e *Environment) ShouldNotReconcile(req reconcile.Request, optionalDescription ...interface{}) reconcile.Result {
-	return e.shouldNotReconcile(SimpleEnvironmentDefaultKey, req, optionalDescription...)
+	return e.shouldNotReconcile(SimpleEnvironmentDefaultKey, req, nil, optionalDescription...)
 }
 
 // ShouldEventuallyNotReconcile calls the given reconciler with the given request and retries until an error occurred or the timeout is reached.
 func (e *Environment) ShouldEventuallyNotReconcile(req reconcile.Request, timeout, poll time.Duration, optionalDescription ...interface{}) reconcile.Result {
-	return e.shouldEventuallyNotReconcile(SimpleEnvironmentDefaultKey, req, timeout, poll, optionalDescription...)
+	return e.shouldEventuallyNotReconcile(SimpleEnvironmentDefaultKey, req, nil, timeout, poll, optionalDescription...)
+}
+
+// ShouldNotReconcileWithError calls the given reconciler with the given request and expects an error that matches the given matcher.
+func (e *Environment) ShouldNotReconcileWithError(req reconcile.Request, matcher types.GomegaMatcher, optionalDescription ...interface{}) reconcile.Result {
+	return e.shouldNotReconcile(SimpleEnvironmentDefaultKey, req, matcher, optionalDescription...)
+}
+
+// ShouldEventuallyNotReconcileWithError calls the given reconciler with the given request and retries until an error that matches the given matcher occurred or the timeout is reached.
+func (e *Environment) ShouldEventuallyNotReconcileWithError(req reconcile.Request, matcher types.GomegaMatcher, timeout, poll time.Duration, optionalDescription ...interface{}) reconcile.Result {
+	return e.shouldEventuallyNotReconcile(SimpleEnvironmentDefaultKey, req, matcher, timeout, poll, optionalDescription...)
 }
 
 //////////////////////////////////

pkg/testing/matchers/maybematch.go

@@ -0,0 +1,44 @@
+package matchers
+
+import (
+	"fmt"
+
+	"github.com/onsi/gomega/types"
+)
+
+// MaybeMatch returns a Gomega matcher that passes the matching logic to the provided matcher,
+// but always succeeds if the passed in matcher is nil.
+func MaybeMatch(matcher types.GomegaMatcher) types.GomegaMatcher {
+	return &maybeMatcher{matcher: matcher}
+}
+
+type maybeMatcher struct {
+	matcher types.GomegaMatcher
+}
+
+func (m *maybeMatcher) GomegaString() string {
+	if m == nil || m.matcher == nil {
+		return "<nil>"
+	}
+	return fmt.Sprintf("MaybeMatch(%v)", m.matcher)
+}
+
+var _ types.GomegaMatcher = &maybeMatcher{}
+
+// Match implements types.GomegaMatcher.
+func (m *maybeMatcher) Match(actualRaw any) (success bool, err error) {
+	if m.matcher == nil {
+		return true, nil
+	}
+	return m.matcher.Match(actualRaw)
+}
+
+// FailureMessage implements types.GomegaMatcher.
+func (m *maybeMatcher) FailureMessage(actual any) (message string) {
+	return m.matcher.FailureMessage(actual)
+}
+
+// NegatedFailureMessage implements types.GomegaMatcher.
+func (m *maybeMatcher) NegatedFailureMessage(actual any) (message string) {
+	return m.matcher.NegatedFailureMessage(actual)
+}