enable goerr113

.golangci.yaml

@@ -30,7 +30,6 @@ linters:
     - goconst
     - gocritic
     - godox
-    - goerr113
     - gomnd
     - gosec
     - inamedparam

hack/e2e/common/eventing/publisher.go

@@ -22,6 +22,11 @@ const (
 	CloudEventPublishEndpointFormat = "%s/publish"
 )
 
+var (
+	ErrFailedSendingCE      = errors.New("failed to send cloudevent")
+	ErrEncodingNotSupported = errors.New("unsupported cloudevent encoding")
+)
+
 type Publisher struct {
 	clientCE     client.Client
 	clientHTTP   *http.Client
@@ -123,7 +128,7 @@ func (p *Publisher) SendCloudEvent(event *cloudevents.Event, encoding binding.En
 		}
 	default:
 		{
-			return fmt.Errorf("failed to use unsupported cloudevent encoding:[%s]", encoding.String())
+			return fmt.Errorf("%w:[%s]", ErrEncodingNotSupported, encoding.String())
 		}
 	}
 
@@ -140,11 +145,11 @@ func (p *Publisher) SendCloudEvent(event *cloudevents.Event, encoding binding.En
 	switch {
 	case cloudevents.IsUndelivered(result):
 		{
-			return fmt.Errorf("failed to send cloudevent-%s undelivered:[%s] response:[%s]", encoding.String(), ce.Type(), result)
+			return fmt.Errorf("%w: encoding:[%s] undelivered:[%s] response:[%s]", ErrFailedSendingCE, encoding.String(), ce.Type(), result)
 		}
 	case cloudevents.IsNACK(result):
 		{
-			return fmt.Errorf("failed to send cloudevent-%s nack:[%s] response:[%s]", encoding.String(), ce.Type(), result)
+			return fmt.Errorf("%w: encoding:[%s] nack:[%s] response:[%s]", ErrFailedSendingCE, encoding.String(), ce.Type(), result)
 		}
 	case cloudevents.IsACK(result):
 		{
@@ -153,7 +158,7 @@ func (p *Publisher) SendCloudEvent(event *cloudevents.Event, encoding binding.En
 		}
 	default:
 		{
-			return fmt.Errorf("failed to send cloudevent-%s unknown:[%s] response:[%s]", encoding.String(), ce.Type(), result)
+			return fmt.Errorf("%w: encoding:[%s] unknown:[%s] response:[%s]", ErrFailedSendingCE, encoding.String(), ce.Type(), result)
 		}
 	}
 }

hack/e2e/common/eventing/utils.go

@@ -93,7 +93,7 @@ func NewCloudEvent(eventSource, eventType string, encoding binding.Encoding) (*c
 	ce.SetType(eventType)
 	ce.SetSource(eventSource)
 	if err := ce.SetData(cloudevents.ApplicationJSON, data); err != nil {
-		return nil, fmt.Errorf("failed to set cloudevent-%s data with error:[%s]", encoding.String(), err)
+		return nil, fmt.Errorf("failed to set cloudevent-%s data with error:[%w]", encoding.String(), err)
 	}
 	return &ce, nil
 }

hack/e2e/common/testenvironment/test_environment.go

@@ -40,6 +40,15 @@ const (
 	ThreeAttempts = 3
 )
 
+var (
+	ErrSubscriptionNotReconciled = errors.New("subscription not reconciled")
+	ErrSubscriptionNotReady      = errors.New("subscription not READY")
+	ErrDeploymentNotReady        = errors.New("deployment not READY")
+	ErrWrongActiveType           = errors.New("specified backend not active")
+	ErrEventingNotReady          = errors.New("eventing not READY")
+	ErrInvalidDeployment         = errors.New("deployment.spec invalid")
+)
+
 // TestEnvironment provides mocked resources for integration tests.
 type TestEnvironment struct {
 	Logger           *zap.Logger
@@ -216,15 +225,15 @@ func (te *TestEnvironment) WaitForSubscription(ctx context.Context, subsToTest e
 				"in namespace: %s to get recocniled by backend: %s", subsToTest.Name, te.TestConfigs.TestNamespace,
 				te.TestConfigs.BackendType)
 			te.Logger.Debug(errMsg)
-			return errors.New(errMsg)
+			return fmt.Errorf("%s, %w", errMsg, ErrSubscriptionNotReconciled)
 		}
 
 		// check if subscription is ready.
 		if !gotSub.Status.Ready {
 			errMsg := fmt.Sprintf("waiting subscription: %s "+
 				"in namespace: %s to get ready", subsToTest.Name, te.TestConfigs.TestNamespace)
 			te.Logger.Debug(errMsg)
-			return errors.New(errMsg)
+			return fmt.Errorf("%s, %w", errMsg, ErrSubscriptionNotReady)
 		}
 		return nil
 	})
@@ -321,7 +330,7 @@ func (te *TestEnvironment) WaitForDeploymentReady(name, namespace, image string)
 
 		// if image is provided, then check if the deployment has correct image.
 		if image != "" && gotDeployment.Spec.Template.Spec.Containers[0].Image != image {
-			err = fmt.Errorf("expected deployment (%s) image to be: %s, but found: %s", name, image,
+			err = fmt.Errorf("%w: expected deployment (%s) image to be: %s, but found: %s", ErrInvalidDeployment, name, image,
 				gotDeployment.Spec.Template.Spec.Containers[0].Image,
 			)
 			te.Logger.Debug(err.Error())
@@ -332,7 +341,7 @@ func (te *TestEnvironment) WaitForDeploymentReady(name, namespace, image string)
 		if *gotDeployment.Spec.Replicas != gotDeployment.Status.UpdatedReplicas ||
 			*gotDeployment.Spec.Replicas != gotDeployment.Status.ReadyReplicas ||
 			*gotDeployment.Spec.Replicas != gotDeployment.Status.AvailableReplicas {
-			err = fmt.Errorf("waiting for deployment: %s to get ready", name)
+			err = fmt.Errorf("waiting for deployment: %s to get ready: %w", name, ErrDeploymentNotReady)
 			te.Logger.Debug(err.Error())
 			return err
 		}
@@ -549,13 +558,13 @@ func (te *TestEnvironment) WaitForEventingCRReady() error {
 		}
 
 		if gotEventingCR.Spec.Backend.Type != gotEventingCR.Status.ActiveBackend {
-			err := fmt.Errorf("waiting for Eventing CR to switch backend")
-			te.Logger.Debug(err.Error())
-			return err
+			msg := "waiting for Eventing CR to switch backend"
+			te.Logger.Debug(msg)
+			return fmt.Errorf("%s: %w", msg, ErrWrongActiveType)
 		}
 
 		if gotEventingCR.Status.State != operatorv1alpha1.StateReady {
-			err := fmt.Errorf("waiting for Eventing CR to get ready state")
+			err := fmt.Errorf("waiting for Eventing CR to get ready state: %w", ErrEventingNotReady)
 			te.Logger.Debug(err.Error())
 			return err
 		}

internal/controller/errors/skip_unit_test.go

@@ -5,17 +5,21 @@ import (
 	"fmt"
 	"testing"
 
+	"github.com/stretchr/testify/require"
+
 	controllererrors "github.com/kyma-project/eventing-manager/internal/controller/errors"
 )
 
+var ErrGeneric = errors.New("some error")
+
 func Test_NewSkippable(t *testing.T) {
 	testCases := []struct {
 		error error
 	}{
 		{error: controllererrors.NewSkippable(nil)},
 		{error: controllererrors.NewSkippable(controllererrors.NewSkippable(nil))},
-		{error: controllererrors.NewSkippable(fmt.Errorf("some error"))},
-		{error: controllererrors.NewSkippable(controllererrors.NewSkippable(fmt.Errorf("some error")))},
+		{error: controllererrors.NewSkippable(ErrGeneric)},
+		{error: controllererrors.NewSkippable(controllererrors.NewSkippable(ErrGeneric))},
 	}
 
 	for _, tc := range testCases {
@@ -24,9 +28,7 @@ func Test_NewSkippable(t *testing.T) {
 			t.Errorf("test NewSkippable retuned nil error")
 			continue
 		}
-		if err := errors.Unwrap(skippableErr); tc.error != err {
-			t.Errorf("test NewSkippable failed, want: %#v but got: %#v", tc.error, err)
-		}
+		require.ErrorIs(t, skippableErr, tc.error)
 	}
 }
 
@@ -43,17 +45,17 @@ func Test_IsSkippable(t *testing.T) {
 		},
 		{
 			name:          "skippable error, should be skipped",
-			givenError:    controllererrors.NewSkippable(fmt.Errorf("some errore")),
+			givenError:    controllererrors.NewSkippable(ErrGeneric),
 			wantSkippable: true,
 		},
 		{
 			name:          "not-skippable error, should not be skipped",
-			givenError:    fmt.Errorf("some error"),
+			givenError:    ErrGeneric,
 			wantSkippable: false,
 		},
 		{
 			name:          "not-skippable error which wraps a skippable error, should not be skipped",
-			givenError:    fmt.Errorf("some error %w", controllererrors.NewSkippable(fmt.Errorf("some error"))),
+			givenError:    fmt.Errorf("some error %w", controllererrors.NewSkippable(ErrGeneric)),
 			wantSkippable: false,
 		},
 	}

internal/controller/eventing/subscription/eventmesh/utils.go

@@ -13,6 +13,8 @@ import (
 	eventingv1alpha2 "github.com/kyma-project/eventing-manager/api/eventing/v1alpha2"
 )
 
+var ErrInvalidSink = errors.New("invalid sink")
+
 // isInDeletion checks if the Subscription shall be deleted.
 func isInDeletion(subscription *eventingv1alpha2.Subscription) bool {
 	return !subscription.DeletionTimestamp.IsZero()
@@ -55,7 +57,7 @@ func removeFinalizer(sub *eventingv1alpha2.Subscription) {
 func getSvcNsAndName(url string) (string, string, error) {
 	parts := strings.Split(url, ".")
 	if len(parts) < 2 {
-		return "", "", fmt.Errorf("invalid sinkURL for cluster local svc: %s", url)
+		return "", "", fmt.Errorf("%w url: %s", ErrInvalidSink, url)
 	}
 	return parts[1], parts[0], nil
 }

internal/controller/eventing/subscription/jetstream/matchers_test.go

@@ -40,6 +40,7 @@ func BeJetStreamSubscriptionWithSubject(source, subject string,
 		}
 		result := info.Config.FilterSubject == js.GetJetStreamSubject(source, subject, typeMatching)
 		if !result {
+			//nolint: goerr113 // no production code, but test helper functionality
 			return false, fmt.Errorf(
 				"BeJetStreamSubscriptionWithSubject expected %v to be equal to %v",
 				info.Config.FilterSubject,

internal/controller/operator/eventing/controller.go

@@ -71,6 +71,14 @@ const (
 	SubscriptionExistsErrMessage = "cannot delete the eventing module as subscription exists"
 )
 
+var (
+	ErrSubscriptionExists      = errors.New(SubscriptionExistsErrMessage)
+	ErrUnsupportedBackedType   = errors.New("backend type not supported")
+	ErrNatsModuleMissing       = errors.New("NATS module has to be installed")
+	ErrNATSServerUnavailable   = errors.New(NatsServerNotAvailableMsg)
+	ErrAPIGatewayModuleMissing = errors.New("API-Gateway module is needed for EventMesh backend. APIRules CRD is not installed")
+)
+
 // Reconciler reconciles an Eventing object
 //
 //go:generate go run github.com/vektra/mockery/v2 --name=Controller --dir=../../../../vendor/sigs.k8s.io/controller-runtime/pkg/controller --outpkg=mocks --case=underscore
@@ -387,8 +395,7 @@ func (r *Reconciler) handleEventingDeletion(ctx context.Context, eventing *opera
 	}
 	if exists {
 		eventing.Status.SetStateWarning()
-		return kctrl.Result{Requeue: true}, r.syncStatusWithDeletionErr(ctx, eventing,
-			errors.New(SubscriptionExistsErrMessage), log)
+		return kctrl.Result{Requeue: true}, r.syncStatusWithDeletionErr(ctx, eventing, ErrSubscriptionExists, log)
 	}
 
 	log.Info("handling Eventing deletion...")
@@ -474,7 +481,7 @@ func (r *Reconciler) handleEventingReconcile(ctx context.Context,
 	case operatorv1alpha1.EventMeshBackendType:
 		return r.reconcileEventMeshBackend(ctx, eventing, log)
 	default:
-		return kctrl.Result{Requeue: false}, fmt.Errorf("not supported backend type %s", eventing.Spec.Backend.Type)
+		return kctrl.Result{Requeue: false}, fmt.Errorf("%w: %s", ErrUnsupportedBackedType, eventing.Spec.Backend.Type)
 	}
 }
 
@@ -515,7 +522,7 @@ func (r *Reconciler) reconcileNATSBackend(ctx context.Context, eventing *operato
 			log.Infof("NATS module not enabled, deleting publisher proxy resources")
 			delErr := r.eventingManager.DeletePublisherProxyResources(ctx, eventing)
 			// update the Eventing CR status.
-			notFoundErr := fmt.Errorf("NATS module has to be installed: %v", err)
+			notFoundErr := fmt.Errorf("%w: %v", ErrNatsModuleMissing, err)
 			return kctrl.Result{}, errors.Join(r.syncStatusWithNATSErr(ctx, eventing, notFoundErr, log), delErr)
 		}
 		return kctrl.Result{}, err
@@ -553,7 +560,7 @@ func (r *Reconciler) checkNATSAvailability(ctx context.Context, eventing *operat
 		return err
 	}
 	if !natsAvailable {
-		return fmt.Errorf(NatsServerNotAvailableMsg)
+		return ErrNATSServerUnavailable
 	}
 	return nil
 }
@@ -592,8 +599,7 @@ func (r *Reconciler) reconcileEventMeshBackend(ctx context.Context, eventing *op
 	if err != nil {
 		return kctrl.Result{}, r.syncStatusWithSubscriptionManagerErr(ctx, eventing, err, log)
 	} else if !isAPIRuleCRDEnabled {
-		apiRuleMissingErr := errors.New("API-Gateway module is needed for EventMesh backend. APIRules CRD is not installed")
-		return kctrl.Result{}, r.syncStatusWithSubscriptionManagerErr(ctx, eventing, apiRuleMissingErr, log)
+		return kctrl.Result{}, r.syncStatusWithSubscriptionManagerErr(ctx, eventing, ErrAPIGatewayModuleMissing, log)
 	}
 
 	// Start the EventMesh subscription controller

internal/controller/operator/eventing/controller_test.go

@@ -2,7 +2,6 @@ package eventing
 
 import (
 	"context"
-	"errors"
 	"fmt"
 	"testing"
 
@@ -177,13 +176,13 @@ func Test_handleBackendSwitching(t *testing.T) {
 			),
 			givenNATSSubManagerMock: func() *submgrmanagermocks.Manager {
 				managerMock := new(submgrmanagermocks.Manager)
-				managerMock.On("Stop", true).Return(errors.New("failed to stop")).Once()
+				managerMock.On("Stop", true).Return(ErrFailedToStop).Once()
 				return managerMock
 			},
 			givenEventMeshSubManagerMock: func() *submgrmanagermocks.Manager {
 				return new(submgrmanagermocks.Manager)
 			},
-			wantError:                 errors.New("failed to stop"),
+			wantError:                 ErrFailedToStop,
 			wantEventingState:         operatorv1alpha1.StateReady,
 			wantEventingConditionsLen: 1,
 			wantNATSStopped:           false,
@@ -224,10 +223,10 @@ func Test_handleBackendSwitching(t *testing.T) {
 			},
 			givenEventMeshSubManagerMock: func() *submgrmanagermocks.Manager {
 				managerMock := new(submgrmanagermocks.Manager)
-				managerMock.On("Stop", true).Return(errors.New("failed to stop")).Once()
+				managerMock.On("Stop", true).Return(ErrFailedToStop).Once()
 				return managerMock
 			},
-			wantError:                 errors.New("failed to stop"),
+			wantError:                 ErrFailedToStop,
 			wantEventingState:         operatorv1alpha1.StateReady,
 			wantEventingConditionsLen: 1,
 			wantNATSStopped:           false,
@@ -321,7 +320,7 @@ func Test_startNatsCRWatch(t *testing.T) {
 		{
 			name:         "NATS watcher error",
 			watchStarted: false,
-			watchErr:     errors.New("NATS watcher error"),
+			watchErr:     ErrUseMeInMocks,
 		},
 	}
 

internal/controller/operator/eventing/domain.go

@@ -2,18 +2,21 @@ package eventing
 
 import (
 	"context"
+	"errors"
 	"fmt"
 )
 
 const (
 	shootInfoConfigMapName      = "shoot-info"
 	shootInfoConfigMapNamespace = "kube-system"
 	shootInfoConfigMapKeyDomain = "domain"
-	domainMissingMessageFormat  = `domain configuration is missing. domain must be configured in either the Eventing` +
+	domainMissingMessageFormat  = `%w. domain must be configured in either the Eventing` +
 		` CustomResource under "Spec.Backend.Config.Domain" or in the ConfigMap "%s/%s" under "data.%s"`
-	domainMissingMessageFormatWithError = domainMissingMessageFormat + `: %v`
+	domainMissingMessageFormatWithError = domainMissingMessageFormat + `: %w`
 )
 
+var ErrDomainConfigMissing = errors.New("domain configuration missing")
+
 func (r *Reconciler) readDomainFromConfigMap(ctx context.Context) (string, error) {
 	cm, err := r.kubeClient.GetConfigMap(ctx, shootInfoConfigMapName, shootInfoConfigMapNamespace)
 	if err != nil {
@@ -25,13 +28,12 @@ func (r *Reconciler) readDomainFromConfigMap(ctx context.Context) (string, error
 func domainMissingError(err error) error {
 	if err != nil {
 		return fmt.Errorf(
-			domainMissingMessageFormatWithError,
+			domainMissingMessageFormatWithError, ErrDomainConfigMissing,
 			shootInfoConfigMapNamespace, shootInfoConfigMapName, shootInfoConfigMapKeyDomain, err,
 		)
 	}
-
 	return fmt.Errorf(
-		domainMissingMessageFormat,
+		domainMissingMessageFormat, ErrDomainConfigMissing,
 		shootInfoConfigMapNamespace, shootInfoConfigMapName, shootInfoConfigMapKeyDomain,
 	)
 }

internal/controller/operator/eventing/domain_test.go

@@ -2,10 +2,9 @@ package eventing
 
 import (
 	"context"
-	"fmt"
-	"strings"
 	"testing"
 
+	"github.com/pkg/errors"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 	kcorev1 "k8s.io/api/core/v1"
@@ -46,7 +45,7 @@ func Test_readDomainFromConfigMap(t *testing.T) {
 func Test_domainMissingError(t *testing.T) {
 	// given
 	const errorMessage = "some error"
-	err := fmt.Errorf(errorMessage)
+	err := errors.New(errorMessage)
 
 	// when
 	err0 := domainMissingError(nil)
@@ -55,6 +54,8 @@ func Test_domainMissingError(t *testing.T) {
 	// then
 	require.Error(t, err0)
 	require.Error(t, err1)
-	require.False(t, strings.Contains(strings.ToLower(err0.Error()), "nil"))
-	require.True(t, strings.Contains(err1.Error(), errorMessage))
+	require.ErrorIs(t, err0, ErrDomainConfigMissing)
+	require.ErrorIs(t, err1, ErrDomainConfigMissing)
+	require.NotErrorIs(t, err0, err)
+	require.ErrorIs(t, err1, err)
 }