flag for rate limit is enabled

equinox.go

@@ -15,6 +15,7 @@ import (
 	"github.com/Kyagara/equinox/clients/tft"
 	"github.com/Kyagara/equinox/clients/val"
 	"github.com/Kyagara/equinox/internal"
+	"github.com/Kyagara/equinox/ratelimit"
 	"github.com/allegro/bigcache/v3"
 	"github.com/rs/zerolog"
 )
@@ -77,8 +78,9 @@ func DefaultConfig(key string) (api.EquinoxConfig, error) {
 		HTTPClient: &http.Client{
 			Timeout: 15 * time.Second,
 		},
-		Retries: 3,
-		Cache:   cache,
+		Retries:   3,
+		Cache:     cache,
+		RateLimit: ratelimit.NewInternalRateLimit(),
 	}
 	return config, nil
 }

equinox_test.go

@@ -108,6 +108,7 @@ func TestRateLimitWithMock(t *testing.T) {
 	}
 
 	config := util.NewTestEquinoxConfig()
+	config.RateLimit = ratelimit.NewInternalRateLimit()
 	config.LogLevel = zerolog.WarnLevel
 	config.Retries = 3
 

internal/client.go

@@ -68,7 +68,7 @@ func NewInternalClient(config api.EquinoxConfig) (*Client, error) {
 			mutex:   sync.Mutex{},
 		},
 		cache:              config.Cache,
-		ratelimit:          ratelimit.NewInternalRateLimit(),
+		ratelimit:          config.RateLimit,
 		maxRetries:         config.Retries,
 		isCacheEnabled:     config.Cache.TTL != 0,
 		isRateLimitEnabled: config.RateLimit.Enabled,
@@ -139,7 +139,7 @@ func (c *Client) Execute(ctx context.Context, equinoxReq *api.EquinoxRequest, ta
 		}
 	}
 
-	if !equinoxReq.IsCDN {
+	if c.isRateLimitEnabled && !equinoxReq.IsCDN {
 		err := c.ratelimit.Take(ctx, equinoxReq.Logger, equinoxReq.Route, equinoxReq.MethodID)
 		if err != nil {
 			return err
@@ -190,7 +190,7 @@ func (c *Client) Execute(ctx context.Context, equinoxReq *api.EquinoxRequest, ta
 }
 
 func (c *Client) checkResponse(equinoxReq *api.EquinoxRequest, response *http.Response) (time.Duration, error) {
-	if !equinoxReq.IsCDN {
+	if c.isRateLimitEnabled && !equinoxReq.IsCDN {
 		c.ratelimit.Update(equinoxReq.Logger, equinoxReq.Route, equinoxReq.MethodID, &response.Header)
 	}
 
@@ -201,7 +201,7 @@ func (c *Client) checkResponse(equinoxReq *api.EquinoxRequest, response *http.Re
 
 	// 4xx and 5xx responses will be retried
 	if equinoxReq.Retries < c.maxRetries {
-		if response.StatusCode == http.StatusTooManyRequests {
+		if response.StatusCode == http.StatusTooManyRequests && c.isRateLimitEnabled {
 			equinoxReq.Logger.Warn().Msg("Received 429 response, checking Retry-After header")
 			return c.ratelimit.CheckRetryAfter(equinoxReq.Route, equinoxReq.MethodID, &response.Header)
 		}

internal/client_test.go

@@ -179,16 +179,6 @@ func TestInternalClientErrorResponses(t *testing.T) {
 			wantErr: api.ErrUnsupportedMediaType,
 			code:    415,
 		},
-		{
-			name:    "rate limited",
-			wantErr: api.ErrTooManyRequests,
-			code:    429,
-		},
-		{
-			name:    "rate limited but no retry-after header found",
-			wantErr: ratelimit.Err429ButNoRetryAfterHeader,
-			code:    429,
-		},
 		{
 			name:    "internal server error",
 			wantErr: api.ErrInternalServer,
@@ -224,6 +214,44 @@ func TestInternalClientErrorResponses(t *testing.T) {
 	for _, test := range tests {
 		t.Run(test.name, func(t *testing.T) {
 			config := util.NewTestEquinoxConfig()
+
+			gock.New(fmt.Sprintf(api.RIOT_API_BASE_URL_FORMAT, "tests", "")).
+				Get("/").
+				Reply(test.code)
+
+			internal, err := internal.NewInternalClient(config)
+			require.NoError(t, err)
+			l := internal.Logger("client_endpoint_method")
+			ctx := context.Background()
+			equinoxReq, err := internal.Request(ctx, l, api.RIOT_API_BASE_URL_FORMAT, http.MethodGet, "tests", "/", "", nil)
+			require.NoError(t, err)
+			var gotData interface{}
+			gotErr := internal.Execute(ctx, equinoxReq, gotData)
+			require.Equal(t, test.wantErr, gotErr)
+		})
+	}
+
+	tests = []struct {
+		name    string
+		wantErr error
+		code    int
+	}{
+		{
+			name:    "rate limited",
+			wantErr: api.ErrTooManyRequests,
+			code:    429,
+		},
+		{
+			name:    "rate limited but no retry-after header found",
+			wantErr: ratelimit.Err429ButNoRetryAfterHeader,
+			code:    429,
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			config := util.NewTestEquinoxConfig()
+			config.RateLimit = ratelimit.NewInternalRateLimit()
 			if test.name == "rate limited" {
 				config.Retries = 0
 			} else if test.name == "rate limited but no retry-after header found" {
@@ -250,6 +278,7 @@ func TestInternalClientErrorResponses(t *testing.T) {
 func TestInternalClientRetries(t *testing.T) {
 	config := util.NewTestEquinoxConfig()
 	config.Retries = 3
+	config.RateLimit = ratelimit.NewInternalRateLimit()
 	internal, err := internal.NewInternalClient(config)
 	require.NoError(t, err)