test: add error return tests

Author: guilhem

internal/controller/linodemachine_controller_helpers_test.go

@@ -6,7 +6,9 @@ import (
 	"context"
 	"crypto/rand"
 	b64 "encoding/base64"
+	"errors"
 	"fmt"
+	"net/http"
 	"slices"
 	"testing"
 
@@ -2727,3 +2729,108 @@ func TestBuildInstanceAddrs(t *testing.T) {
 		})
 	}
 }
+
+func TestRetryIfTransient(t *testing.T) {
+	t.Parallel()
+
+	tests := []struct {
+		name           string
+		err            error
+		expectRequeue  bool
+		expectError    bool
+		expectErrorMsg string
+	}{
+		{
+			name: "rate limit error (429) - should requeue without error",
+			err: &linodego.Error{
+				Code:    http.StatusTooManyRequests,
+				Message: "rate limited",
+			},
+			expectRequeue: true,
+			expectError:   false,
+		},
+		{
+			name: "internal server error (500) - should requeue without error",
+			err: &linodego.Error{
+				Code:    http.StatusInternalServerError,
+				Message: "internal error",
+			},
+			expectRequeue: true,
+			expectError:   false,
+		},
+		{
+			name: "bad gateway error (502) - should requeue without error",
+			err: &linodego.Error{
+				Code:    http.StatusBadGateway,
+				Message: "bad gateway",
+			},
+			expectRequeue: true,
+			expectError:   false,
+		},
+		{
+			name: "unauthorized error (401) - should return error",
+			err: &linodego.Error{
+				Code:    http.StatusUnauthorized,
+				Message: "Invalid Token",
+			},
+			expectRequeue:  false,
+			expectError:    true,
+			expectErrorMsg: "Invalid Token",
+		},
+		{
+			name: "forbidden error (403) - should return error",
+			err: &linodego.Error{
+				Code:    http.StatusForbidden,
+				Message: "Forbidden",
+			},
+			expectRequeue:  false,
+			expectError:    true,
+			expectErrorMsg: "Forbidden",
+		},
+		{
+			name: "bad request error (400) - should return error",
+			err: &linodego.Error{
+				Code:    http.StatusBadRequest,
+				Message: "bad request",
+			},
+			expectRequeue:  false,
+			expectError:    true,
+			expectErrorMsg: "bad request",
+		},
+		{
+			name: "not found error (404) - should return error",
+			err: &linodego.Error{
+				Code:    http.StatusNotFound,
+				Message: "not found",
+			},
+			expectRequeue:  false,
+			expectError:    true,
+			expectErrorMsg: "not found",
+		},
+		{
+			name:           "generic error - should return error",
+			err:            errors.New("some generic error"),
+			expectRequeue:  false,
+			expectError:    true,
+			expectErrorMsg: "some generic error",
+		},
+	}
+
+	for _, tt := range tests {
+		testcase := tt
+		t.Run(testcase.name, func(t *testing.T) {
+			t.Parallel()
+
+			result, err := retryIfTransient(testcase.err)
+
+			if testcase.expectError {
+				require.Error(t, err, "expected error but got nil")
+				assert.Contains(t, err.Error(), testcase.expectErrorMsg)
+				assert.True(t, result.IsZero(), "expected zero result for terminal errors")
+			} else {
+				require.NoError(t, err, "expected no error but got one")
+				assert.Positive(t, result.RequeueAfter, "expected requeue delay for retryable errors")
+			}
+		})
+	}
+}

util/helpers_test.go

@@ -121,6 +121,138 @@ func TestIsRetryableError(t *testing.T) {
 	}
 }
 
+func TestIsAuthenticationError(t *testing.T) {
+	t.Parallel()
+	tests := []struct {
+		name string
+		err  error
+		want bool
+	}{{
+		name: "unauthorized error (401)",
+		err: &linodego.Error{
+			Response: nil,
+			Code:     http.StatusUnauthorized,
+			Message:  "Invalid Token",
+		},
+		want: true,
+	}, {
+		name: "forbidden error (403)",
+		err: &linodego.Error{
+			Response: nil,
+			Code:     http.StatusForbidden,
+			Message:  "Forbidden",
+		},
+		want: true,
+	}, {
+		name: "bad request error (400)",
+		err: &linodego.Error{
+			Response: nil,
+			Code:     http.StatusBadRequest,
+			Message:  "bad request",
+		},
+		want: false,
+	}, {
+		name: "not found error (404)",
+		err: &linodego.Error{
+			Response: nil,
+			Code:     http.StatusNotFound,
+			Message:  "not found",
+		},
+		want: false,
+	}, {
+		name: "internal server error (500)",
+		err: &linodego.Error{
+			Response: nil,
+			Code:     http.StatusInternalServerError,
+			Message:  "internal error",
+		},
+		want: false,
+	}, {
+		name: "non-Linode error",
+		err:  errors.New("random error"),
+		want: false,
+	}}
+	for _, tt := range tests {
+		testcase := tt
+		t.Run(testcase.name, func(t *testing.T) {
+			t.Parallel()
+			if testcase.want != IsAuthenticationError(testcase.err) {
+				t.Errorf("IsAuthenticationError() = %v, want %v", IsAuthenticationError(testcase.err), testcase.want)
+			}
+		})
+	}
+}
+
+func TestIsTerminalError(t *testing.T) {
+	t.Parallel()
+	tests := []struct {
+		name string
+		err  error
+		want bool
+	}{{
+		name: "bad request error (400)",
+		err: &linodego.Error{
+			Response: nil,
+			Code:     http.StatusBadRequest,
+			Message:  "bad request",
+		},
+		want: true,
+	}, {
+		name: "unauthorized error (401)",
+		err: &linodego.Error{
+			Response: nil,
+			Code:     http.StatusUnauthorized,
+			Message:  "Invalid Token",
+		},
+		want: true,
+	}, {
+		name: "forbidden error (403)",
+		err: &linodego.Error{
+			Response: nil,
+			Code:     http.StatusForbidden,
+			Message:  "Forbidden",
+		},
+		want: true,
+	}, {
+		name: "not found error (404)",
+		err: &linodego.Error{
+			Response: nil,
+			Code:     http.StatusNotFound,
+			Message:  "not found",
+		},
+		want: true,
+	}, {
+		name: "internal server error (500)",
+		err: &linodego.Error{
+			Response: nil,
+			Code:     http.StatusInternalServerError,
+			Message:  "internal error",
+		},
+		want: false,
+	}, {
+		name: "too many requests (429)",
+		err: &linodego.Error{
+			Response: nil,
+			Code:     http.StatusTooManyRequests,
+			Message:  "rate limited",
+		},
+		want: false,
+	}, {
+		name: "non-Linode error",
+		err:  errors.New("random error"),
+		want: false,
+	}}
+	for _, tt := range tests {
+		testcase := tt
+		t.Run(testcase.name, func(t *testing.T) {
+			t.Parallel()
+			if testcase.want != IsTerminalError(testcase.err) {
+				t.Errorf("IsTerminalError() = %v, want %v", IsTerminalError(testcase.err), testcase.want)
+			}
+		})
+	}
+}
+
 func TestGetInstanceID(t *testing.T) {
 	t.Parallel()
 	tests := []struct {