BUG 1824497: Enable error checks to unwrap errors

pkg/controller/machine/controller.go

@@ -18,6 +18,7 @@ package machine
 
 import (
 	"context"
+	"errors"
 	"fmt"
 	"time"
 
@@ -396,19 +397,19 @@ func (r *ReconcileMachine) deleteNode(ctx context.Context, name string) error {
 }
 
 func delayIfRequeueAfterError(err error) (reconcile.Result, error) {
-	switch t := err.(type) {
-	case *RequeueAfterError:
-		klog.Infof("Actuator returned requeue-after error: %v", err)
-		return reconcile.Result{Requeue: true, RequeueAfter: t.RequeueAfter}, nil
+	var requeueAfterError *RequeueAfterError
+	if errors.As(err, &requeueAfterError) {
+		klog.Infof("Actuator returned requeue-after error: %v", requeueAfterError)
+		return reconcile.Result{Requeue: true, RequeueAfter: requeueAfterError.RequeueAfter}, nil
 	}
 	return reconcile.Result{}, err
 }
 
 func isInvalidMachineConfigurationError(err error) bool {
-	switch t := err.(type) {
-	case *MachineError:
-		if t.Reason == machinev1.InvalidConfigurationMachineError {
-			klog.Infof("Actuator returned invalid configuration error: %v", err)
+	var machineError *MachineError
+	if errors.As(err, &machineError) {
+		if machineError.Reason == machinev1.InvalidConfigurationMachineError {
+			klog.Infof("Actuator returned invalid configuration error: %v", machineError)
 			return true
 		}
 	}

pkg/controller/machine/controller_test.go

@@ -18,8 +18,10 @@ package machine
 
 import (
 	"context"
+	"fmt"
 	"reflect"
 	"testing"
+	"time"
 
 	machinev1 "github.com/openshift/machine-api-operator/pkg/apis/machine/v1beta1"
 	corev1 "k8s.io/api/core/v1"
@@ -563,3 +565,135 @@ func TestNodeIsUnreachable(t *testing.T) {
 		})
 	}
 }
+
+func TestIsInvalidMachineConfigurationError(t *testing.T) {
+	invalidMachineConfigurationError := InvalidMachineConfiguration("invalidConfiguration")
+	createError := CreateMachine("createFailed")
+
+	testCases := []struct {
+		name     string
+		err      error
+		expected bool
+	}{
+		{
+			name:     "With an InvalidMachineConfigurationError",
+			err:      invalidMachineConfigurationError,
+			expected: true,
+		},
+		{
+			name:     "With a CreateError",
+			err:      createError,
+			expected: false,
+		},
+		{
+			name:     "With a wrapped InvalidMachineConfigurationError",
+			err:      fmt.Errorf("Wrap: %w", invalidMachineConfigurationError),
+			expected: true,
+		},
+		{
+			name:     "With a wrapped CreateError",
+			err:      fmt.Errorf("Wrap: %w", createError),
+			expected: false,
+		},
+		{
+			name:     "With a double wrapped InvalidMachineConfigurationError",
+			err:      fmt.Errorf("Wrap: %w", fmt.Errorf("Wrap: %w", invalidMachineConfigurationError)),
+			expected: true,
+		},
+		{
+			name:     "With a double wrapped CreateError",
+			err:      fmt.Errorf("Wrap: %w", fmt.Errorf("Wrap: %w", createError)),
+			expected: false,
+		},
+	}
+
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			if actual := isInvalidMachineConfigurationError(tc.err); actual != tc.expected {
+				t.Errorf("Case: %s, got: %v, expected: %v", tc.name, actual, tc.expected)
+			}
+		})
+	}
+}
+
+func TestDelayIfRequeueAfterError(t *testing.T) {
+	requeueAfter30s := &RequeueAfterError{RequeueAfter: 30 * time.Second}
+	requeueAfter1m := &RequeueAfterError{RequeueAfter: time.Minute}
+	createError := CreateMachine("createFailed")
+	wrappedCreateError := fmt.Errorf("Wrap: %w", createError)
+	doubleWrappedCreateError := fmt.Errorf("Wrap: %w", fmt.Errorf("Wrap: %w", createError))
+
+	testCases := []struct {
+		name           string
+		err            error
+		expectedErr    error
+		expectedResult reconcile.Result
+	}{
+		{
+			name:           "with a RequeAfterError (30s)",
+			err:            requeueAfter30s,
+			expectedErr:    nil,
+			expectedResult: reconcile.Result{Requeue: true, RequeueAfter: 30 * time.Second},
+		},
+		{
+			name:           "with a RequeAfterError (1m)",
+			err:            requeueAfter1m,
+			expectedErr:    nil,
+			expectedResult: reconcile.Result{Requeue: true, RequeueAfter: time.Minute},
+		},
+		{
+			name:           "with a CreateError",
+			err:            createError,
+			expectedErr:    createError,
+			expectedResult: reconcile.Result{},
+		},
+		{
+			name:           "with a wrapped RequeAfterError (30s)",
+			err:            fmt.Errorf("Wrap: %w", requeueAfter30s),
+			expectedErr:    nil,
+			expectedResult: reconcile.Result{Requeue: true, RequeueAfter: 30 * time.Second},
+		},
+		{
+			name:           "with a wrapped RequeAfterError (1m)",
+			err:            fmt.Errorf("Wrap: %w", requeueAfter1m),
+			expectedErr:    nil,
+			expectedResult: reconcile.Result{Requeue: true, RequeueAfter: time.Minute},
+		},
+		{
+			name:           "with a wrapped CreateError",
+			err:            wrappedCreateError,
+			expectedErr:    wrappedCreateError,
+			expectedResult: reconcile.Result{},
+		},
+		{
+			name:           "with a double wrapped RequeAfterError (30s)",
+			err:            fmt.Errorf("Wrap: %w", fmt.Errorf("Wrap: %w", requeueAfter30s)),
+			expectedErr:    nil,
+			expectedResult: reconcile.Result{Requeue: true, RequeueAfter: 30 * time.Second},
+		},
+		{
+			name:           "with a double wrapped RequeAfterError (1m)",
+			err:            fmt.Errorf("Wrap: %w", fmt.Errorf("Wrap: %w", requeueAfter1m)),
+			expectedErr:    nil,
+			expectedResult: reconcile.Result{Requeue: true, RequeueAfter: time.Minute},
+		},
+		{
+			name:           "with a double wrapped CreateError",
+			err:            doubleWrappedCreateError,
+			expectedErr:    doubleWrappedCreateError,
+			expectedResult: reconcile.Result{},
+		},
+	}
+
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			result, err := delayIfRequeueAfterError(tc.err)
+			if err != tc.expectedErr {
+				t.Errorf("Case: %s, got: %v, expected: %v", tc.name, err, tc.expectedErr)
+			}
+			if result != tc.expectedResult {
+				t.Errorf("Case: %s, got: %v, expected: %v", tc.name, result, tc.expectedResult)
+			}
+		})
+	}
+}