tests are fine now

Author: KSemenenko

.editorconfig

@@ -23,4 +23,4 @@ public static ISignalRServerBuilder AddOrleans(this ISignalRServerBuilder signal
         signalrBuilder.Services.AddSingleton(typeof(HubLifetimeManager<>), typeof(OrleansHubLifetimeManager<>));
         return signalrBuilder;
     }
-}
+}

ManagedCode.Orleans.SignalR.Client/Extensions/OrleansDependencyInjectionExtensions.cs

@@ -19,28 +19,28 @@ public class OrleansSignalROptions
     ///     Set to false only if you don't want to send messages to the specific connectionId.
     /// </summary>
     public bool KeepEachConnectionAlive { get; set; } = true;
-    
+
     /// <summary>
     ///     This property determines the duration for which messages are stored when a client is disconnected.
     ///     The default timeout is 1.1 minute.
     /// </summary>
     public TimeSpan KeepMessageInterval { get; set; } = TimeSpan.FromMinutes(1.1);
-    
+
     /// <summary>
     ///     Number of partitions to use for connection distribution.
     ///     Set to 1 to disable partitioning.
     ///     Increase this value for better scalability with millions of connections.
     ///     The default value is 4.
     /// </summary>
     public uint ConnectionPartitionCount { get; set; } = 4;
-    
+
     /// <summary>
     ///     Target number of concurrent connections per partition.
     ///     Used as a hint when determining how many partitions to allocate dynamically.
     ///     Lower values result in more partitions.
     /// </summary>
     public int ConnectionsPerPartitionHint { get; set; } = 10_000;
-    
+
     /// <summary>
     ///     Number of partitions to use for group distribution.
     ///     Set to 1 to disable partitioning.

ManagedCode.Orleans.SignalR.Core/Config/OrleansSignalROptions.cs

@@ -7,78 +7,76 @@ public static partial class Logs
     [LoggerMessage(
         Level = LogLevel.Trace,
         Message = "{grainType}:{grainId} OnDeactivateAsync")]
-    public static partial void OnDeactivateAsync(ILogger logger, string grainType, string grainId);    
-    
+    public static partial void OnDeactivateAsync(ILogger logger, string grainType, string grainId);
+
     [LoggerMessage(
         Level = LogLevel.Trace,
         Message = "{grainType}:{grainId} Ping")]
     public static partial void Ping(ILogger logger, string grainType, string grainId);
-    
+
     [LoggerMessage(
         Level = LogLevel.Debug,
         Message = "{grainType}:{grainId} AddConnection `{connectionId}`")]
     public static partial void AddConnection(ILogger logger, string grainType, string grainId, string connectionId);
-    
+
     [LoggerMessage(
         Level = LogLevel.Debug,
         Message = "{grainType}:{grainId} RemoveConnection `{connectionId}`")]
     public static partial void RemoveConnection(ILogger logger, string grainType, string grainId, string connectionId);
-    
+
     [LoggerMessage(
         Level = LogLevel.Debug,
         Message = "{grainType}:{grainId} SendToAll")]
-    public static partial void SendToAll(ILogger logger, string grainType, string grainId);    
-    
+    public static partial void SendToAll(ILogger logger, string grainType, string grainId);
+
     [LoggerMessage(
         Level = LogLevel.Debug,
         Message = "{grainType}:{grainId} SendToAllExcept")]
     public static partial void SendToAllExcept(ILogger logger, string grainType, string grainId, string[] expectedConnectionIds);
-    
+
     [LoggerMessage(
         Level = LogLevel.Debug,
         Message = "{grainType}:{grainId} SendToConnection")]
     public static partial void SendToConnection(ILogger logger, string grainType, string grainId, string connectionId);
-    
+
     [LoggerMessage(
         Level = LogLevel.Debug,
         Message = "{grainType}:{grainId} SendToConnections")]
     public static partial void SendToConnections(ILogger logger, string grainType, string grainId, string[] expectedConnectionIds);
-    
-    
+
     [LoggerMessage(
         Level = LogLevel.Debug,
         Message = "{grainType}:{grainId} SendToGroup")]
     public static partial void SendToGroup(ILogger logger, string grainType, string grainId);
-    
+
     [LoggerMessage(
         Level = LogLevel.Debug,
         Message = "{grainType}:{grainId} SendToGroupExcept")]
     public static partial void SendToGroupExcept(ILogger logger, string grainType, string grainId, string[] expectedConnectionIds);
-    
+
     [LoggerMessage(
         Level = LogLevel.Debug,
         Message = "{grainType}:{grainId} TryCompleteResult")]
     public static partial void TryCompleteResult(ILogger logger, string grainType, string grainId, string connectionId);
-    
+
     [LoggerMessage(
         Level = LogLevel.Debug,
         Message = "{grainType}:{grainId} TryGetReturnType")]
     public static partial void TryGetReturnType(ILogger logger, string grainType, string grainId);
-    
+
     [LoggerMessage(
         Level = LogLevel.Debug,
         Message = "{grainType}:{grainId} AddInvocation")]
     public static partial void AddInvocation(ILogger logger, string grainType, string grainId, string invocationId, string connectionId);
-        
+
     [LoggerMessage(
         Level = LogLevel.Trace,
         Message = "{grainType}:{grainId} RemoveInvocation")]
-    public static partial void RemoveInvocation(ILogger logger, string grainType, string grainId);     
-    
+    public static partial void RemoveInvocation(ILogger logger, string grainType, string grainId);
+
     [LoggerMessage(
         Level = LogLevel.Debug,
         Message = "{grainType}:{grainId} SendToUser")]
-    public static partial void SendToUser(ILogger logger, string grainType, string grainId);  
-        
-        
+    public static partial void SendToUser(ILogger logger, string grainType, string grainId);
+
 }

ManagedCode.Orleans.SignalR.Core/Helpers/Logs.cs

@@ -1,7 +1,7 @@
 using System;
+using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.Linq;
-using System.Collections.Concurrent;
 using System.Security.Cryptography;
 using System.Text;
 
@@ -11,14 +11,18 @@ public static class PartitionHelper
 {
     private const int VirtualNodesPerPartition = 150; // Number of virtual nodes per physical partition
     private static readonly ConcurrentDictionary<RingCacheKey, ConsistentHashRing> RingCache = new();
-    
+
     public static int GetPartitionId(string connectionId, uint partitionCount)
     {
         if (string.IsNullOrEmpty(connectionId))
+        {
             throw new ArgumentException("Connection ID cannot be null or empty", nameof(connectionId));
+        }
 
         if (partitionCount <= 0)
+        {
             throw new ArgumentException("Partition count must be greater than 0", nameof(partitionCount));
+        }
 
         var ring = RingCache.GetOrAdd(new RingCacheKey((int)partitionCount, VirtualNodesPerPartition),
             key => new ConsistentHashRing(key.PartitionCount, key.VirtualNodes));
@@ -30,14 +34,14 @@ public static int GetOptimalPartitionCount(int expectedConnections)
     {
         return GetOptimalPartitionCount(expectedConnections, 10_000);
     }
-    
+
     public static int GetOptimalPartitionCount(int expectedConnections, int connectionsPerPartition)
     {
         var perPartition = Math.Max(1, connectionsPerPartition);
         var partitions = Math.Max(1, (expectedConnections + perPartition - 1) / perPartition);
         return ToPowerOfTwo(partitions);
     }
-    
+
     public static int GetOptimalGroupPartitionCount(int expectedGroups)
     {
         return GetOptimalGroupPartitionCount(expectedGroups, 1_000);
@@ -104,16 +108,22 @@ private static SortedList<uint, int> InitializeRing(int partitionCount, int virt
     public int GetPartition(string key)
     {
         if (_keys.Length == 0)
+        {
             return 0;
+        }
 
         var hash = GetHash(key);
 
         var index = Array.BinarySearch(_keys, hash);
         if (index < 0)
+        {
             index = ~index;
+        }
 
         if (index >= _keys.Length)
+        {
             index = 0;
+        }
 
         return _partitions[index];
     }

ManagedCode.Orleans.SignalR.Core/Helpers/PartitionHelper.cs

@@ -13,7 +13,9 @@ public static TimeSpan GetClientTimeoutInterval(IOptions<OrleansSignalROptions>
         var timeSpan = orleansSignalOptions.Value.ClientTimeoutInterval;
 
         if (hubOptions.Value.ClientTimeoutInterval.HasValue && timeSpan > hubOptions.Value.ClientTimeoutInterval)
+        {
             timeSpan = hubOptions.Value.ClientTimeoutInterval.Value;
+        }
 
         return timeSpan;
     }
@@ -25,26 +27,33 @@ public static TimeSpan GetClientTimeoutInterval(IOptions<OrleansSignalROptions>
 
         if (globalHubOptions.Value.ClientTimeoutInterval.HasValue &&
             timeSpan > globalHubOptions.Value.ClientTimeoutInterval)
+        {
             timeSpan = globalHubOptions.Value.ClientTimeoutInterval.Value;
+        }
 
         if (hubOptions.Value.ClientTimeoutInterval.HasValue && timeSpan > hubOptions.Value.ClientTimeoutInterval)
+        {
             timeSpan = hubOptions.Value.ClientTimeoutInterval.Value;
+        }
 
         return timeSpan;
     }
 
-
     public static TimeSpan GetClientTimeoutInterval(IOptions<HubOptions> globalHubOptions,
         IOptions<HubOptions> hubOptions)
     {
         var timeSpan = TimeSpan.FromSeconds(15);
 
         if (globalHubOptions.Value.ClientTimeoutInterval.HasValue &&
             timeSpan > globalHubOptions.Value.ClientTimeoutInterval)
+        {
             timeSpan = globalHubOptions.Value.ClientTimeoutInterval.Value;
+        }
 
         if (hubOptions.Value.ClientTimeoutInterval.HasValue && timeSpan > hubOptions.Value.ClientTimeoutInterval)
+        {
             timeSpan = hubOptions.Value.ClientTimeoutInterval.Value;
+        }
 
         return timeSpan;
     }
@@ -54,16 +63,20 @@ public static TimeSpan GetKeepAliveInterval(IOptions<HubOptions> globalHubOption
         var timeSpan = TimeSpan.FromSeconds(15);
 
         if (globalHubOptions.Value.ClientTimeoutInterval.HasValue)
+        {
             timeSpan = globalHubOptions.Value.ClientTimeoutInterval.Value;
+        }
 
         if (hubOptions.Value.ClientTimeoutInterval.HasValue)
+        {
             timeSpan = hubOptions.Value.ClientTimeoutInterval.Value;
+        }
 
         return timeSpan;
     }
-    
+
     public static TimeSpan AddExpirationIntervalBuffer(TimeSpan timeSpan)
     {
         return timeSpan * 1.2;
     }
-}
+}

ManagedCode.Orleans.SignalR.Core/Helpers/TimeIntervalHelper.cs

@@ -16,4 +16,4 @@ public interface IOrleansHubContext<THub, TClient> where THub : Hub
     ///     Gets a <see cref="IGroupManager" /> that can be used to add and remove connections to named groups.
     /// </summary>
     IGroupManager Groups { get; }
-}
+}

ManagedCode.Orleans.SignalR.Core/HubContext/IOrleansHubContext.cs

@@ -46,4 +46,4 @@ public T Users(IReadOnlyList<string> userIds)
     {
         return TypedClientBuilder<T>.Build(hubClients.Users(userIds));
     }
-}
+}

ManagedCode.Orleans.SignalR.Core/HubContext/OrleansHubClients.cs

@@ -16,4 +16,4 @@ public class OrleansHubContext<THub, TClient>(IHubContext<THub> context) : IOrle
     ///     Gets a <see cref="IGroupManager" /> that can be used to add and remove connections to named groups.
     /// </summary>
     public IGroupManager Groups { get; } = context.Groups;
-}
+}