github.com/aavshr/aws-sdk-go@v1.41.3/aws/request/retryer_test.go (about)

     1  package request
     2  
     3  import (
     4  	"errors"
     5  	"fmt"
     6  	"net/http"
     7  	"testing"
     8  
     9  	"github.com/aavshr/aws-sdk-go/aws"
    10  	"github.com/aavshr/aws-sdk-go/aws/awserr"
    11  	"github.com/aavshr/aws-sdk-go/aws/client/metadata"
    12  )
    13  
    14  func TestRequestIsErrorThrottle(t *testing.T) {
    15  	cases := []struct {
    16  		Err      error
    17  		Throttle bool
    18  		Req      Request
    19  	}{
    20  		{
    21  			Err:      awserr.New("ProvisionedThroughputExceededException", "", nil),
    22  			Throttle: true,
    23  		},
    24  		{
    25  			Err:      awserr.New("ThrottledException", "", nil),
    26  			Throttle: true,
    27  		},
    28  		{
    29  			Err:      awserr.New("Throttling", "", nil),
    30  			Throttle: true,
    31  		},
    32  		{
    33  			Err:      awserr.New("ThrottlingException", "", nil),
    34  			Throttle: true,
    35  		},
    36  		{
    37  			Err:      awserr.New("RequestLimitExceeded", "", nil),
    38  			Throttle: true,
    39  		},
    40  		{
    41  			Err:      awserr.New("RequestThrottled", "", nil),
    42  			Throttle: true,
    43  		},
    44  		{
    45  			Err:      awserr.New("TooManyRequestsException", "", nil),
    46  			Throttle: true,
    47  		},
    48  		{
    49  			Err:      awserr.New("PriorRequestNotComplete", "", nil),
    50  			Throttle: true,
    51  		},
    52  		{
    53  			Err:      awserr.New("TransactionInProgressException", "", nil),
    54  			Throttle: true,
    55  		},
    56  		{
    57  			Err:      awserr.New("EC2ThrottledException", "", nil),
    58  			Throttle: true,
    59  		},
    60  		{
    61  			Err: awserr.NewRequestFailure(
    62  				awserr.New(ErrCodeSerialization, "some error",
    63  					awserr.NewUnmarshalError(nil, "blah", []byte{}),
    64  				),
    65  				503,
    66  				"request-id",
    67  			),
    68  			Req: Request{
    69  				HTTPResponse: &http.Response{
    70  					StatusCode: 503,
    71  					Header:     http.Header{},
    72  				},
    73  			},
    74  			Throttle: true,
    75  		},
    76  		{
    77  			Err: awserr.NewRequestFailure(
    78  				awserr.New(ErrCodeSerialization, "some error",
    79  					awserr.NewUnmarshalError(nil, "blah", []byte{}),
    80  				),
    81  				400,
    82  				"request-id",
    83  			),
    84  			Req: Request{
    85  				HTTPResponse: &http.Response{
    86  					StatusCode: 400,
    87  					Header:     http.Header{},
    88  				},
    89  			},
    90  			Throttle: false,
    91  		},
    92  	}
    93  
    94  	for i, c := range cases {
    95  		req := c.Req
    96  		req.Error = c.Err
    97  		if e, a := c.Throttle, req.IsErrorThrottle(); e != a {
    98  			t.Errorf("%d, expect %v to be throttled, was %t", i, c.Err, a)
    99  		}
   100  	}
   101  }
   102  
   103  type mockTempError bool
   104  
   105  func (e mockTempError) Error() string {
   106  	return fmt.Sprintf("mock temporary error: %t", e.Temporary())
   107  }
   108  func (e mockTempError) Temporary() bool {
   109  	return bool(e)
   110  }
   111  
   112  func TestRequestIsErrorRetryable(t *testing.T) {
   113  	cases := []struct {
   114  		Err       error
   115  		Req       Request
   116  		Retryable bool
   117  	}{
   118  		{
   119  			Err:       awserr.New(ErrCodeSerialization, "temporary error", mockTempError(true)),
   120  			Retryable: true,
   121  		},
   122  		{
   123  			Err:       awserr.New(ErrCodeSerialization, "temporary error", mockTempError(false)),
   124  			Retryable: false,
   125  		},
   126  		{
   127  			Err:       awserr.New(ErrCodeSerialization, "some error", errors.New("blah")),
   128  			Retryable: true,
   129  		},
   130  		{
   131  			Err: awserr.NewRequestFailure(
   132  				awserr.New(ErrCodeSerialization, "some error",
   133  					awserr.NewUnmarshalError(nil, "blah", []byte{}),
   134  				),
   135  				503,
   136  				"request-id",
   137  			),
   138  			Req: Request{
   139  				HTTPResponse: &http.Response{
   140  					StatusCode: 503,
   141  					Header:     http.Header{},
   142  				},
   143  			},
   144  			Retryable: false, // classified as throttled not retryable
   145  		},
   146  		{
   147  			Err: awserr.NewRequestFailure(
   148  				awserr.New(ErrCodeSerialization, "some error",
   149  					awserr.NewUnmarshalError(nil, "blah", []byte{}),
   150  				),
   151  				400,
   152  				"request-id",
   153  			),
   154  			Req: Request{
   155  				HTTPResponse: &http.Response{
   156  					StatusCode: 400,
   157  					Header:     http.Header{},
   158  				},
   159  			},
   160  			Retryable: false,
   161  		},
   162  		{
   163  			Err:       awserr.New("SomeError", "some error", nil),
   164  			Retryable: false,
   165  		},
   166  		{
   167  			Err:       awserr.New(ErrCodeRequestError, "some error", nil),
   168  			Retryable: true,
   169  		},
   170  		{
   171  			Err:       nil,
   172  			Retryable: false,
   173  		},
   174  	}
   175  
   176  	for i, c := range cases {
   177  		req := c.Req
   178  		req.Error = c.Err
   179  
   180  		if e, a := c.Retryable, req.IsErrorRetryable(); e != a {
   181  			t.Errorf("%d, expect %v to be retryable, was %t", i, c.Err, a)
   182  		}
   183  	}
   184  }
   185  
   186  func TestRequest_NilRetyer(t *testing.T) {
   187  	clientInfo := metadata.ClientInfo{Endpoint: "https://mock.region.amazonaws.com"}
   188  	req := New(aws.Config{}, clientInfo, Handlers{}, nil, &Operation{}, nil, nil)
   189  
   190  	if req.Retryer == nil {
   191  		t.Fatalf("expect retryer to be set")
   192  	}
   193  
   194  	if e, a := 0, req.MaxRetries(); e != a {
   195  		t.Errorf("expect no retries, got %v", a)
   196  	}
   197  }