fix tests

KSemenenko · KSemenenko · commit 7fd690c17bed · 2023-05-24T16:40:49.000+02:00
diff --git a/ManagedCode.Orleans.RateLimiting.Client/Extensions/ClientBuilderExtensions.cs b/ManagedCode.Orleans.RateLimiting.Client/Extensions/ClientBuilderExtensions.cs
@@ -1,3 +1,4 @@
+using Microsoft.AspNetCore.Builder;
 using Orleans.Hosting;
 
 namespace ManagedCode.Orleans.RateLimiting.Client.Extensions;
diff --git a/ManagedCode.Orleans.RateLimiting.Client/Extensions/ServiceCollectionExtensions.cs b/ManagedCode.Orleans.RateLimiting.Client/Extensions/ServiceCollectionExtensions.cs
@@ -0,0 +1,14 @@
+using ManagedCode.Orleans.RateLimiting.Client.Middlewares;
+using Microsoft.Extensions.DependencyInjection;
+
+namespace ManagedCode.Orleans.RateLimiting.Client.Extensions;
+
+public static class ServiceCollectionExtensions
+{
+    public static IServiceCollection AddOrleansRateLimiting(this IServiceCollection collection)
+    {
+        //collection.AddTransient<OrleansUserRateLimitingMiddleware>();
+        //collection.AddTransient<OrleansIpRateLimitingMiddleware>();
+        return collection;
+    }
+}
diff --git a/ManagedCode.Orleans.RateLimiting.Client/Middlewares/OrleansBaseRateLimitingMiddleware.cs b/ManagedCode.Orleans.RateLimiting.Client/Middlewares/OrleansBaseRateLimitingMiddleware.cs
@@ -82,7 +82,7 @@ public async Task Invoke(HttpContext httpContext)
         return (attribute, postfix);
     }
 
-    protected ILimiterHolder? TryGetLimiterHolder(HttpContext httpContext, string key, string configurationName)
+    protected ILimiterHolder? TryGetLimiterHolder(string key, string configurationName)
     {
         var limiter = _client.GetRateLimiterByConfig(key, configurationName, _services.GetService<IEnumerable<RateLimiterConfig>>());
 
diff --git a/ManagedCode.Orleans.RateLimiting.Client/Middlewares/OrleansIpRateLimitingMiddleware.cs b/ManagedCode.Orleans.RateLimiting.Client/Middlewares/OrleansIpRateLimitingMiddleware.cs
@@ -10,7 +10,7 @@ namespace ManagedCode.Orleans.RateLimiting.Client.Middlewares;
 
 public class OrleansIpRateLimitingMiddleware : OrleansBaseRateLimitingMiddleware
 {
-    public OrleansIpRateLimitingMiddleware(ILogger<OrleansIpRateLimitingMiddleware> logger, RequestDelegate next, IClusterClient client, IServiceProvider services) :
+    public OrleansIpRateLimitingMiddleware(ILogger<OrleansIpRateLimitingMiddleware> logger, IClusterClient client, IServiceProvider services, RequestDelegate next) :
         base(logger, next, client, services)
     {
     }
@@ -25,8 +25,8 @@ private bool AddIpRateLimiter(HttpContext httpContext, GroupLimiterHolder holder
     {
         var attribute = TryGetAttribute<IpRateLimiterAttribute>(httpContext);
         if (attribute.HasValue)
-            return holder.AddLimiter(TryGetLimiterHolder(httpContext, CreateKey(httpContext.Request.GetClientIpAddress(), attribute.Value.postfix!),
-                attribute.Value.postfix!));
+            return holder.AddLimiter(TryGetLimiterHolder(CreateKey(httpContext.Request.GetClientIpAddress(), attribute.Value.postfix!),
+                attribute.Value.attribute.ConfigurationName));
 
         return false;
     }
diff --git a/ManagedCode.Orleans.RateLimiting.Client/Middlewares/OrleansUserRateLimitingMiddleware.cs b/ManagedCode.Orleans.RateLimiting.Client/Middlewares/OrleansUserRateLimitingMiddleware.cs
@@ -10,56 +10,54 @@ namespace ManagedCode.Orleans.RateLimiting.Client.Middlewares;
 
 public class OrleansUserRateLimitingMiddleware : OrleansBaseRateLimitingMiddleware
 {
-    protected OrleansUserRateLimitingMiddleware(ILogger logger, RequestDelegate next, IClusterClient client, IServiceProvider services) : base(logger, next, client,
-        services)
+    public OrleansUserRateLimitingMiddleware(ILogger<OrleansUserRateLimitingMiddleware> logger, IClusterClient client, IServiceProvider services, RequestDelegate next) 
+        : base(logger, next, client, services)
     {
     }
 
 
     protected override void AddLimiters(HttpContext httpContext, GroupLimiterHolder holder)
     {
-        AddAnonymousIpRateLimiter(httpContext, holder);
+        AddAnonymousRateLimiter(httpContext, holder);
 
         // if user is authenticated add in role limiter
-        if (!AddInRoleIpRateLimiter(httpContext, holder))
+        if (!AddInRoleRateLimiter(httpContext, holder))
             // if user is not authenticated add authorized limiter
-            AddAuthorizedIpRateLimiter(httpContext, holder);
+            AddAuthorizedRateLimiter(httpContext, holder);
     }
 
-    private bool AddAnonymousIpRateLimiter(HttpContext httpContext, GroupLimiterHolder holder)
+    private bool AddAnonymousRateLimiter(HttpContext httpContext, GroupLimiterHolder holder)
     {
         if (httpContext.User?.Identity?.IsAuthenticated is not true)
         {
             var attribute = TryGetAttribute<AnonymousIpRateLimiterAttribute>(httpContext);
             if (attribute.HasValue)
-                return holder.AddLimiter(TryGetLimiterHolder(httpContext, CreateKey(httpContext.Request.GetClientIpAddress(), attribute.Value.postfix!),
-                    attribute.Value.postfix!));
+                return holder.AddLimiter(TryGetLimiterHolder(CreateKey(httpContext.Request.GetClientIpAddress(), attribute.Value.postfix!),
+                    attribute.Value.attribute.ConfigurationName));
         }
 
         return false;
     }
 
-    private bool AddAuthorizedIpRateLimiter(HttpContext httpContext, GroupLimiterHolder holder)
+    private bool AddAuthorizedRateLimiter(HttpContext httpContext, GroupLimiterHolder holder)
     {
         if (httpContext.User?.Identity?.IsAuthenticated is true)
         {
             var attribute = TryGetAttribute<AuthorizedIpRateLimiterAttribute>(httpContext);
             if (attribute.HasValue)
-                return holder.AddLimiter(TryGetLimiterHolder(httpContext,
-                    CreateKey(httpContext.Request.GetClientIpAddress(), httpContext.User.Identity.Name!, attribute.Value.postfix!), attribute.Value.postfix!));
+                return holder.AddLimiter(TryGetLimiterHolder(CreateKey(httpContext.Request.GetClientIpAddress(), httpContext.User.Identity.Name ?? "rate-user-name", attribute.Value.postfix!), attribute.Value.attribute.ConfigurationName));
         }
 
         return false;
     }
 
-    private bool AddInRoleIpRateLimiter(HttpContext httpContext, GroupLimiterHolder holder)
+    private bool AddInRoleRateLimiter(HttpContext httpContext, GroupLimiterHolder holder)
     {
         var attribute = TryGetAttribute<InRoleIpRateLimiterAttribute>(httpContext);
         if (attribute.HasValue)
             if (httpContext.User?.Identity?.IsAuthenticated is true && httpContext.User.IsInRole(attribute.Value.attribute.Role))
-                return holder.AddLimiter(TryGetLimiterHolder(httpContext,
-                    CreateKey(httpContext.Request.GetClientIpAddress(), httpContext.User.Identity.Name!, attribute.Value.attribute.Role, attribute.Value.postfix!),
-                    attribute.Value.postfix!));
+                return holder.AddLimiter(TryGetLimiterHolder(CreateKey(httpContext.Request.GetClientIpAddress(), httpContext.User.Identity.Name!, attribute.Value.attribute.Role, attribute.Value.postfix!),
+                    attribute.Value.attribute.ConfigurationName));
 
         return false;
     }
diff --git a/ManagedCode.Orleans.RateLimiting.Tests/SignalRTests.cs b/ManagedCode.Orleans.RateLimiting.Tests/SignalRTests.cs
@@ -23,8 +23,21 @@ public SignalRTests(TestClusterApplication testApp, ITestOutputHelper outputHelp
     [Fact]
     public async Task Some()
     {
+        try
+        {
+            var anonymousHub11 = _testApp.CreateSignalRClient(nameof(TestHub));
+            await anonymousHub11.StartAsync();
+            anonymousHub11.State.Should().Be(HubConnectionState.Connected);
+        }
+        catch (Exception e)
+        {
+            Console.WriteLine(e);
+            throw;
+        }
+        
         var anonymousHub = _testApp.CreateSignalRClient(nameof(TestHub));
         await anonymousHub.StartAsync();
         anonymousHub.State.Should().Be(HubConnectionState.Connected);
+
     }
 }
diff --git a/ManagedCode.Orleans.RateLimiting.Tests/TestApp/Controllers/TestController.cs b/ManagedCode.Orleans.RateLimiting.Tests/TestApp/Controllers/TestController.cs
@@ -13,7 +13,7 @@ public class TestController : ControllerBase
     [HttpGet("authorize")]
     public async Task<ActionResult<string>> Authorize()
     {
-        await Task.Delay(300);
+        await Task.Delay(500);
         return "Authorize";
     }
 }
diff --git a/ManagedCode.Orleans.RateLimiting.Tests/TestApp/HttpHostProgram.cs b/ManagedCode.Orleans.RateLimiting.Tests/TestApp/HttpHostProgram.cs
@@ -3,6 +3,7 @@
 using ManagedCode.Orleans.RateLimiting.Core.Extensions;
 using Microsoft.AspNetCore.Builder;
 using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Logging;
 
 namespace ManagedCode.Orleans.RateLimiting.Tests.TestApp;
 
@@ -14,11 +15,14 @@ public static void Main(string[] args)
 
         builder.Services.AddControllers();
         builder.Services.AddSignalR();
+        builder.Services.AddLogging(log=>log.AddSimpleConsole());
 
+        builder.Services.AddOrleansRateLimiting();
+        
         builder.Services.AddOrleansRateLimiterOptions("ip", new FixedWindowRateLimiterOptions
         {
             QueueLimit = 5,
-            PermitLimit = 10,
+            PermitLimit = 5,
             Window = TimeSpan.FromSeconds(1)
         });
 
@@ -46,7 +50,7 @@ public static void Main(string[] args)
         app.UseOrleansIpRateLimiting();
         app.UseOrleansUserRateLimiting();
 
-        app.UseRateLimiter();
+        //app.UseRateLimiter();
 
         app.Run();
     }

Original file line number	Diff line number	Diff line change
`@@ -1,3 +1,4 @@`
	`1`	`+using Microsoft.AspNetCore.Builder;`
`1`	`2`	`using Orleans.Hosting;`
`2`	`3`
`3`	`4`	`namespace ManagedCode.Orleans.RateLimiting.Client.Extensions;`
Original file line number	Diff line number	Diff line change
`@@ -82,7 +82,7 @@ public async Task Invoke(HttpContext httpContext)`
`82`	`82`	`return (attribute, postfix);`
`83`	`83`	`}`
`84`	`84`
`85`		`- protected ILimiterHolder? TryGetLimiterHolder(HttpContext httpContext, string key, string configurationName)`
	`85`	`+ protected ILimiterHolder? TryGetLimiterHolder(string key, string configurationName)`
`86`	`86`	`{`
`87`	`87`	`var limiter = _client.GetRateLimiterByConfig(key, configurationName, _services.GetService<IEnumerable<RateLimiterConfig>>());`
`88`	`88`
Original file line number	Diff line number	Diff line change
`@@ -10,7 +10,7 @@ namespace ManagedCode.Orleans.RateLimiting.Client.Middlewares;`
`10`	`10`
`11`	`11`	`public class OrleansIpRateLimitingMiddleware : OrleansBaseRateLimitingMiddleware`
`12`	`12`	`{`
`13`		`- public OrleansIpRateLimitingMiddleware(ILogger<OrleansIpRateLimitingMiddleware> logger, RequestDelegate next, IClusterClient client, IServiceProvider services) :`
	`13`	`+ public OrleansIpRateLimitingMiddleware(ILogger<OrleansIpRateLimitingMiddleware> logger, IClusterClient client, IServiceProvider services, RequestDelegate next) :`
`14`	`14`	`base(logger, next, client, services)`
`15`	`15`	`{`
`16`	`16`	`}`
`@@ -25,8 +25,8 @@ private bool AddIpRateLimiter(HttpContext httpContext, GroupLimiterHolder holder`
`25`	`25`	`{`
`26`	`26`	`var attribute = TryGetAttribute<IpRateLimiterAttribute>(httpContext);`
`27`	`27`	`if (attribute.HasValue)`
`28`		`- return holder.AddLimiter(TryGetLimiterHolder(httpContext, CreateKey(httpContext.Request.GetClientIpAddress(), attribute.Value.postfix!),`
`29`		`- attribute.Value.postfix!));`
	`28`	`+ return holder.AddLimiter(TryGetLimiterHolder(CreateKey(httpContext.Request.GetClientIpAddress(), attribute.Value.postfix!),`
	`29`	`+ attribute.Value.attribute.ConfigurationName));`
`30`	`30`
`31`	`31`	`return false;`
`32`	`32`	`}`
Original file line number	Diff line number	Diff line change
`@@ -10,56 +10,54 @@ namespace ManagedCode.Orleans.RateLimiting.Client.Middlewares;`
`10`	`10`
`11`	`11`	`public class OrleansUserRateLimitingMiddleware : OrleansBaseRateLimitingMiddleware`
`12`	`12`	`{`
`13`		`- protected OrleansUserRateLimitingMiddleware(ILogger logger, RequestDelegate next, IClusterClient client, IServiceProvider services) : base(logger, next, client,`
`14`		`- services)`
	`13`	`+ public OrleansUserRateLimitingMiddleware(ILogger<OrleansUserRateLimitingMiddleware> logger, IClusterClient client, IServiceProvider services, RequestDelegate next)`
	`14`	`+ : base(logger, next, client, services)`
`15`	`15`	`{`
`16`	`16`	`}`
`17`	`17`
`18`	`18`
`19`	`19`	`protected override void AddLimiters(HttpContext httpContext, GroupLimiterHolder holder)`
`20`	`20`	`{`
`21`		`- AddAnonymousIpRateLimiter(httpContext, holder);`
	`21`	`+ AddAnonymousRateLimiter(httpContext, holder);`
`22`	`22`
`23`	`23`	`// if user is authenticated add in role limiter`
`24`		`- if (!AddInRoleIpRateLimiter(httpContext, holder))`
	`24`	`+ if (!AddInRoleRateLimiter(httpContext, holder))`
`25`	`25`	`// if user is not authenticated add authorized limiter`
`26`		`- AddAuthorizedIpRateLimiter(httpContext, holder);`
	`26`	`+ AddAuthorizedRateLimiter(httpContext, holder);`
`27`	`27`	`}`
`28`	`28`
`29`		`- private bool AddAnonymousIpRateLimiter(HttpContext httpContext, GroupLimiterHolder holder)`
	`29`	`+ private bool AddAnonymousRateLimiter(HttpContext httpContext, GroupLimiterHolder holder)`
`30`	`30`	`{`
`31`	`31`	`if (httpContext.User?.Identity?.IsAuthenticated is not true)`
`32`	`32`	`{`
`33`	`33`	`var attribute = TryGetAttribute<AnonymousIpRateLimiterAttribute>(httpContext);`
`34`	`34`	`if (attribute.HasValue)`
`35`		`- return holder.AddLimiter(TryGetLimiterHolder(httpContext, CreateKey(httpContext.Request.GetClientIpAddress(), attribute.Value.postfix!),`
`36`		`- attribute.Value.postfix!));`
	`35`	`+ return holder.AddLimiter(TryGetLimiterHolder(CreateKey(httpContext.Request.GetClientIpAddress(), attribute.Value.postfix!),`
	`36`	`+ attribute.Value.attribute.ConfigurationName));`
`37`	`37`	`}`
`38`	`38`
`39`	`39`	`return false;`
`40`	`40`	`}`
`41`	`41`
`42`		`- private bool AddAuthorizedIpRateLimiter(HttpContext httpContext, GroupLimiterHolder holder)`
	`42`	`+ private bool AddAuthorizedRateLimiter(HttpContext httpContext, GroupLimiterHolder holder)`
`43`	`43`	`{`
`44`	`44`	`if (httpContext.User?.Identity?.IsAuthenticated is true)`
`45`	`45`	`{`
`46`	`46`	`var attribute = TryGetAttribute<AuthorizedIpRateLimiterAttribute>(httpContext);`
`47`	`47`	`if (attribute.HasValue)`
`48`		`- return holder.AddLimiter(TryGetLimiterHolder(httpContext,`
`49`		`- CreateKey(httpContext.Request.GetClientIpAddress(), httpContext.User.Identity.Name!, attribute.Value.postfix!), attribute.Value.postfix!));`
	`48`	`+ return holder.AddLimiter(TryGetLimiterHolder(CreateKey(httpContext.Request.GetClientIpAddress(), httpContext.User.Identity.Name ?? "rate-user-name", attribute.Value.postfix!), attribute.Value.attribute.ConfigurationName));`
`50`	`49`	`}`
`51`	`50`
`52`	`51`	`return false;`
`53`	`52`	`}`
`54`	`53`
`55`		`- private bool AddInRoleIpRateLimiter(HttpContext httpContext, GroupLimiterHolder holder)`
	`54`	`+ private bool AddInRoleRateLimiter(HttpContext httpContext, GroupLimiterHolder holder)`
`56`	`55`	`{`
`57`	`56`	`var attribute = TryGetAttribute<InRoleIpRateLimiterAttribute>(httpContext);`
`58`	`57`	`if (attribute.HasValue)`
`59`	`58`	`if (httpContext.User?.Identity?.IsAuthenticated is true && httpContext.User.IsInRole(attribute.Value.attribute.Role))`
`60`		`- return holder.AddLimiter(TryGetLimiterHolder(httpContext,`
`61`		`- CreateKey(httpContext.Request.GetClientIpAddress(), httpContext.User.Identity.Name!, attribute.Value.attribute.Role, attribute.Value.postfix!),`
`62`		`- attribute.Value.postfix!));`
	`59`	`+ return holder.AddLimiter(TryGetLimiterHolder(CreateKey(httpContext.Request.GetClientIpAddress(), httpContext.User.Identity.Name!, attribute.Value.attribute.Role, attribute.Value.postfix!),`
	`60`	`+ attribute.Value.attribute.ConfigurationName));`
`63`	`61`
`64`	`62`	`return false;`
`65`	`63`	`}`
Original file line number	Diff line number	Diff line change
`@@ -13,7 +13,7 @@ public class TestController : ControllerBase`
`13`	`13`	`[HttpGet("authorize")]`
`14`	`14`	`public async Task<ActionResult<string>> Authorize()`
`15`	`15`	`{`
`16`		`- await Task.Delay(300);`
	`16`	`+ await Task.Delay(500);`
`17`	`17`	`return "Authorize";`
`18`	`18`	`}`
`19`	`19`	`}`