James Evers

RateLimiter.Tests/RateLimiter.Tests.csproj

@@ -9,6 +9,7 @@
   </ItemGroup>
   <ItemGroup>
     <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.5.0" />
+    <PackageReference Include="Moq" Version="4.20.72" />
     <PackageReference Include="NUnit" Version="3.13.3" />
     <PackageReference Include="NUnit3TestAdapter" Version="4.4.2" />
   </ItemGroup>

RateLimiter.Tests/RejectRateLimiterTest.cs

@@ -0,0 +1,80 @@
+using NUnit.Framework;
+using System;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace RateLimiter.Tests;
+
+[TestFixture]
+public class RejectRateLimiterTest
+{
+	[Test]
+	public void Example()
+	{
+		Assert.That(true, Is.True);
+	}
+
+	[Test]
+	public void AllowedLimitTest()
+	{
+		var callLimiter = new RejectRateLimiter(2,TimeSpan.FromSeconds(5));
+		var limiterToken = "1:1";
+
+		Assert.That(callLimiter.CheckRequest(limiterToken), Is.True);
+		Assert.That(callLimiter.CheckRequest(limiterToken), Is.True);
+		Assert.That(callLimiter.CheckRequest(limiterToken), Is.False);
+		Thread.Sleep(TimeSpan.FromSeconds(5));
+		Assert.That(callLimiter.CheckRequest(limiterToken), Is.True);
+	}
+
+	[Test]
+	public void IntervalTest() { 
+		var callLimiter = new RejectRateLimiter(1, TimeSpan.FromSeconds(5));
+		var limiterToken = "1:1";
+        Assert.That(callLimiter.CheckRequest(limiterToken), Is.True);
+        Assert.That(callLimiter.CheckRequest(limiterToken), Is.False);
+        Assert.That(callLimiter.CheckRequest(limiterToken), Is.False);
+        Thread.Sleep(TimeSpan.FromSeconds(5));
+        Assert.That(callLimiter.CheckRequest(limiterToken), Is.True);
+    }
+
+    [Test]
+    public void Multithreaded_Test_For_RejectRateLimiter()
+    {
+        var callLimiter = new RejectRateLimiter(2, TimeSpan.FromSeconds(5));
+        var limiterToken = "1:1";
+
+        int successfulRequests = 0;
+        int failedRequests = 0;
+
+        // Define a multithreaded task
+        var tasks = new Task[10];
+        for (int i = 0; i < tasks.Length; i++)
+        {
+            tasks[i] = Task.Run(() =>
+            {
+                if (callLimiter.CheckRequest(limiterToken))
+                {
+                    Interlocked.Increment(ref successfulRequests);
+                }
+                else
+                {
+                    Interlocked.Increment(ref failedRequests);
+                }
+            });
+        }
+
+        // Wait for all tasks to complete
+        Task.WaitAll(tasks);
+
+        // Validate the results
+        Assert.That(successfulRequests, Is.EqualTo(2)); // Only 2 requests should succeed
+        Assert.That(failedRequests, Is.EqualTo(8));    // The rest should fail
+
+        // Sleep for the time limit to reset
+        Thread.Sleep(TimeSpan.FromSeconds(5));
+
+        // Validate that after the time reset, a request succeeds
+        Assert.That(callLimiter.CheckRequest(limiterToken), Is.True);
+    }
+}

RateLimiter.Tests/UserRateLimiter.cs

@@ -0,0 +1,27 @@
+using Moq;
+using NUnit.Framework;
+using RateLimiter.ExampleUserSetup;
+using System;
+using System.Threading;
+
+namespace RateLimiter.Tests;
+
+[TestFixture]
+public class UserRateLimiterTest
+{
+    [Test]
+    public void Test_User_Resource()
+    {
+        var rateLimiter = new RejectRateLimiter(2,TimeSpan.FromSeconds(5));
+
+        var userRateLimiter = new UsersRateLimiter(rateLimiter);
+
+        var mockUser = new Mock<IUser>();
+        mockUser.SetupGet(x => x.Name).Returns("Mary");
+        var user = mockUser.Object;
+
+        Assert.That(userRateLimiter.CheckRequest(user, "DoSomething"), Is.True);
+        Assert.That(userRateLimiter.CheckRequest(user, "DoSomething"), Is.True);
+        Assert.That(userRateLimiter.CheckRequest(user, "DoSomething"), Is.False);
+    }
+}

RateLimiter/ExampleUserSetup/IUser.cs

@@ -0,0 +1,13 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace RateLimiter.ExampleUserSetup
+{
+    public interface IUser
+    {
+        string Name { get; }
+    }
+}

RateLimiter/ExampleUserSetup/UserRateLimiter.cs

@@ -0,0 +1,24 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Resources;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace RateLimiter.ExampleUserSetup
+{
+    public class UsersRateLimiter
+    {
+        private IRateLimiter RateLimiter { get; }
+        public UsersRateLimiter(IRateLimiter rateLimiter)
+        {
+            RateLimiter = rateLimiter;
+        }
+        public bool CheckRequest(IUser user, string route)
+        {
+            return RateLimiter.CheckRequest($"{user.Name}:{route}");
+        }
+
+
+    }
+}

RateLimiter/IRateLimiter.cs

@@ -0,0 +1,15 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace RateLimiter
+{
+    public interface IRateLimiter
+    {
+        int RequestLimit { get; }
+        TimeSpan Interval { get; }
+        bool CheckRequest(string limiterToken);
+    }
+}

RateLimiter/RateLimiter.csproj

@@ -4,4 +4,7 @@
     <LangVersion>latest</LangVersion>
     <Nullable>enable</Nullable>
   </PropertyGroup>
+  <ItemGroup>
+    <PackageReference Include="EntityFramework" Version="6.5.1" />
+  </ItemGroup>
 </Project>  

RateLimiter/RejectRateLimiter.cs

@@ -0,0 +1,46 @@
+using System;
+using System.Collections.Concurrent;
+using System.Collections.Generic;
+using System.Data;
+using System.Linq;
+
+namespace RateLimiter
+{
+    public class RejectRateLimiter : IRateLimiter
+    {
+        private readonly ConcurrentDictionary<string, List<DateTime>> requests = new();
+        private readonly ConcurrentDictionary<string, object> tokenLocks = new();
+
+        private readonly object lockObject = new();
+        public int RequestLimit { get; }
+        public TimeSpan Interval { get; }   
+        public RejectRateLimiter(int requestLimit = 10, TimeSpan interval = default)
+        { 
+            RequestLimit = requestLimit;
+            if (interval == default)
+                Interval = TimeSpan.FromMinutes(1);
+            Interval = interval;
+        }
+        public bool CheckRequest(string limiterToken)
+        {
+            var tokenLock = tokenLocks.GetOrAdd(limiterToken, _ => new object());
+
+            lock (tokenLock) // Lock for this specific token
+            {
+                var currentRequests = requests.GetOrAdd(limiterToken, new List<DateTime>());
+                currentRequests = currentRequests
+                    .Where(x => x > DateTime.Now.Subtract(Interval))
+                    .ToList();
+
+                if (currentRequests.Count < RequestLimit)
+                {
+                    currentRequests.Add(DateTime.Now);
+                    requests[limiterToken] = currentRequests; // Update the dictionary with the filtered list
+                    return true;
+                }
+
+                return false;
+            }
+        }
+    }
+}