#372 use period timespan to decide when client can make requests again (#404)

docs/features/ratelimiting.rst

@@ -19,7 +19,7 @@ OK so to get rate limiting working for a ReRoute you need to add the following j
 
 ClientWhitelist - This is an array that contains the whitelist of the client. It means that the client in this array will not be affected by the rate limiting.
 EnableRateLimiting - This value specifies enable endpoint rate limiting.
-Period - This value specifies the period, such as 1s, 5m, 1h,1d and so on.
+Period - This value specifies the period that the limit applies to, such as 1s, 5m, 1h,1d and so on. If you make more requests in the period than the limit allows then you need to wait for PeriodTimespan to elapse before you make another request.
 PeriodTimespan - This value specifies that we can retry after a certain number of seconds.
 Limit - This value specifies the maximum number of requests that a client can make in a defined period.
 

src/Ocelot/RateLimit/RateLimitCore.cs

@@ -34,7 +34,7 @@ namespace Ocelot.RateLimit
                 if (entry.HasValue)
                 {
                     // entry has not expired
-                    if (entry.Value.Timestamp + ConvertToTimeSpan(rule.Period) >= DateTime.UtcNow)
+                    if (entry.Value.Timestamp + TimeSpan.FromSeconds(rule.PeriodTimespan) >= DateTime.UtcNow)
                     {
                         // increment request count
                         var totalRequests = entry.Value.TotalRequests + 1;

test/Ocelot.AcceptanceTests/ClientRateLimitTests.cs

@@ -90,6 +90,71 @@ namespace Ocelot.AcceptanceTests
                 .BDDfy();
         }
 
+        [Fact]
+        public void should_wait_for_period_timespan_to_elapse_before_making_next_request()
+        {
+            var configuration = new FileConfiguration
+            {
+                ReRoutes = new List<FileReRoute>
+                    {
+                        new FileReRoute
+                        {
+                            DownstreamPathTemplate = "/api/ClientRateLimit",
+                            DownstreamHostAndPorts = new List<FileHostAndPort>
+                            {
+                                new FileHostAndPort
+                                {
+                                    Host = "localhost",
+                                    Port = 51926,
+                                }
+                            },
+                            DownstreamScheme = "http",
+                            UpstreamPathTemplate = "/api/ClientRateLimit",
+                            UpstreamHttpMethod = new List<string> { "Get" },
+                            RequestIdKey = _steps.RequestIdKey,
+                             
+                            RateLimitOptions = new FileRateLimitRule()
+                            {
+                                EnableRateLimiting = true,
+                                ClientWhitelist = new List<string>(),
+                                Limit = 3,
+                                Period = "1s",
+                                PeriodTimespan = 2
+                            }
+                        }
+                },
+                GlobalConfiguration = new FileGlobalConfiguration()
+                {
+                    RateLimitOptions = new FileRateLimitOptions()
+                    {
+                        ClientIdHeader = "ClientId",
+                        DisableRateLimitHeaders = false,
+                        QuotaExceededMessage = "",
+                        RateLimitCounterPrefix = "",
+                        HttpStatusCode = 428
+                    },
+                     RequestIdKey ="oceclientrequest"
+                }
+            };
+
+            this.Given(x => x.GivenThereIsAServiceRunningOn("http://localhost:51926", "/api/ClientRateLimit"))
+                .And(x => _steps.GivenThereIsAConfiguration(configuration))
+                .And(x => _steps.GivenOcelotIsRunning())
+                .When(x => _steps.WhenIGetUrlOnTheApiGatewayMultipleTimesForRateLimit("/api/ClientRateLimit",1))
+                .Then(x => _steps.ThenTheStatusCodeShouldBe(200))
+                .When(x => _steps.WhenIGetUrlOnTheApiGatewayMultipleTimesForRateLimit("/api/ClientRateLimit", 2))
+                .Then(x => _steps.ThenTheStatusCodeShouldBe(200))
+                .When(x => _steps.WhenIGetUrlOnTheApiGatewayMultipleTimesForRateLimit("/api/ClientRateLimit",1))
+                .Then(x => _steps.ThenTheStatusCodeShouldBe(428))
+                .And(x => _steps.GivenIWait(1000))
+                .When(x => _steps.WhenIGetUrlOnTheApiGatewayMultipleTimesForRateLimit("/api/ClientRateLimit",1))
+                .Then(x => _steps.ThenTheStatusCodeShouldBe(428))
+                .And(x => _steps.GivenIWait(1000))
+                .When(x => _steps.WhenIGetUrlOnTheApiGatewayMultipleTimesForRateLimit("/api/ClientRateLimit",1))
+                .Then(x => _steps.ThenTheStatusCodeShouldBe(200))
+                .BDDfy();
+        }
+
         [Fact]
         public void should_call_middleware_withWhitelistClient()
         {

test/Ocelot.AcceptanceTests/Steps.cs

@@ -183,6 +183,11 @@ namespace Ocelot.AcceptanceTests
             _ocelotClient = _ocelotServer.CreateClient();
         }
 
+        internal void GivenIWait(int wait)
+        {
+            Thread.Sleep(wait);
+        }
+
         public void GivenOcelotIsRunningWithMiddleareBeforePipeline<T>(Func<object, Task> callback)
         {
             _webHostBuilder = new WebHostBuilder();