feat(errors): invalid user input error handling

docs/libs/errors.md

@@ -8,3 +8,6 @@ The `pkg/errors` package contains the `ReasonableError` type, which combines a n
 - `Errorf(...)` can be used to wrap an existing `ReasonableError` together with a new error, similarly to how `fmt.Errorf(...)` does it for standard errors.
 - `NewReasonableErrorList(...)` or `Join(...)` can be used to work with lists of errors. `Aggregate()` turns them into a single error again.
 
+### Ignore Invalid User Input
+
+`ErrInvalidUserInput` can be used to create errors that can be ignored with `IgnoreInvalidUserInput(...)` at the end of reconciliation. This allows you to handle errors properly and skip unnecessary requeues.

pkg/errors/errors.go

@@ -0,0 +1,16 @@
+package errors
+
+import (
+	"errors"
+)
+
+// ErrInvalidUserInput indicates invalid user input.
+var ErrInvalidUserInput = errors.New("invalid user input")
+
+// IgnoreUserInputError returns nil on invalid user input.
+func IgnoreInvalidUserInput(err error) error {
+	if errors.Is(err, ErrInvalidUserInput) {
+		return nil
+	}
+	return err
+}

pkg/errors/errors_test.go

@@ -0,0 +1,53 @@
+package errors_test
+
+import (
+	"errors"
+	"fmt"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+
+	ctrlutils "github.com/openmcp-project/controller-utils/pkg/errors"
+)
+
+func TestIgnoreInvalidUserInput(t *testing.T) {
+	tests := []struct {
+		name string // description of this test case
+		// Named input parameters for target function.
+		err          error
+		wrappedError error
+		wantErr      bool
+	}{
+		{
+			name:    "user input error is ignored",
+			err:     fmt.Errorf("value out of range %w", ctrlutils.ErrInvalidUserInput),
+			wantErr: false,
+		},
+		{
+			name:    "regular error is returned",
+			err:     errors.New("regular error"),
+			wantErr: true,
+		},
+		{
+			name:    "nil is nil",
+			err:     nil,
+			wantErr: false,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			gotErr := ctrlutils.IgnoreInvalidUserInput(tt.err)
+			if gotErr != nil {
+				if !tt.wantErr {
+					t.Errorf("IgnoreInvalidUserInput() failed: %v", gotErr)
+				}
+				assert.Equal(t, tt.err, gotErr)
+				if tt.wrappedError != nil {
+					assert.ErrorIs(t, tt.err, tt.wrappedError)
+				}
+				return
+			}
+			assert.False(t, tt.wantErr)
+		})
+	}
+}