refactor(AuthClientTests): Umbenennung der Variablennamen

- umbenannt in SendMessageAsync als SendKeyAsync

DigitalData.Auth.Abstractions/IAuthClient.cs

@@ -1,6 +1,6 @@
 namespace DigitalData.Auth.Abstractions;
 
-public interface IAuthClient : IAuthClientHandler
+public interface IAuthClient : IAuthListenHandler, IAuthSenderHandler
 {
     bool IsConnected { get; }
 

DigitalData.Auth.Abstractions/IAuthClientHandler.cs

@@ -1,6 +0,0 @@
-namespace DigitalData.Auth.Abstractions;
-
-public interface IAuthClientHandler
-{
-    Task ReceiveMessageAsync(string user, string message);
-}

DigitalData.Auth.Abstractions/IAuthListenHandler.cs

@@ -0,0 +1,6 @@
+namespace DigitalData.Auth.Abstractions;
+
+public interface IAuthListenHandler
+{
+    Task ReceiveKeyAsync(string topic, string key);
+}

DigitalData.Auth.Abstractions/IAuthSenderHandler.cs

@@ -0,0 +1,6 @@
+namespace DigitalData.Auth.Abstractions;
+
+public interface IAuthSenderHandler
+{
+    Task SendKeyAsync(string topic, string key);
+}

DigitalData.Auth.Client/AuthClient.cs

@@ -5,7 +5,7 @@ using Microsoft.Extensions.Options;
 
 namespace DigitalData.Auth.Client;
 
-public class AuthClient : IAuthClient
+public class AuthClient : IAuthClient, IAsyncDisposable
 {
     private readonly HubConnection _connection;
 
@@ -21,7 +21,7 @@ public class AuthClient : IAuthClient
             .WithUrl(paramsOptions.Value.Url)
             .Build();
 
-        _connection.On<string, string>(nameof(ReceiveMessageAsync), ReceiveMessageAsync);
+        _connection.On<string, string>(nameof(ReceiveKeyAsync), ReceiveKeyAsync);
 
         _logger = logger;
 
@@ -61,5 +61,13 @@ public class AuthClient : IAuthClient
         }
     }
 
-    public Task ReceiveMessageAsync(string user, string message) => Task.Run(() => _params.Events.OnMessageReceived(user, message, _logger));
+    public Task ReceiveKeyAsync(string user, string message) => Task.Run(() => _params.Events.OnMessageReceived(user, message, _logger));
+
+    public Task SendKeyAsync(string user, string message) => _connection.InvokeAsync(nameof(SendKeyAsync), user, message);
+
+    public virtual async ValueTask DisposeAsync()
+    {
+        await _connection.StopAsync();
+        await _connection.DisposeAsync();
+    }
 }

DigitalData.Auth.Tests/Client/AuthClientTests.cs

@@ -1,33 +1,77 @@
 using DigitalData.Auth.Abstractions;
+using DigitalData.Auth.API.Hubs;
 using DigitalData.Auth.Client;
+using Microsoft.AspNetCore.Builder;
 using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Hosting;
 
 namespace DigitalData.Auth.Tests.Client;
 
+// TODO: The test checks if the services are working. Performance measurement is ignored. Update it to measure performance as well.
 [TestFixture]
 public class AuthClientTests
 {
-    private static readonly string HubUrl = "https://localhost:7192/auth-hub";
+    private string _hubUrl;
 
     private Func<Action<ClientParams>, ServiceProvider> Build;
 
+    private WebApplication? _app = null;
+
+    private static int AvailablePort
+    {
+        get
+        {
+            using var listener = new System.Net.Sockets.TcpListener(System.Net.IPAddress.Loopback, 0);
+            listener.Start();
+            int port = ((System.Net.IPEndPoint)listener.LocalEndpoint).Port;
+            listener.Stop();
+            return port;
+        }
+    }
+
     [SetUp]
     public void Setup()
     {
         Build = options => new ServiceCollection()
         .AddAuthHubClient(options)
         .BuildServiceProvider();
+
+        // Create and run test server
+        // Create builder and add SignalR service
+        var builder = WebApplication.CreateBuilder();
+        builder.Services.AddSignalR();
+
+        // Listen AvailablePort and map hub
+        var _app = builder.Build();
+        var url = $"http://localhost:{AvailablePort}";
+        var hubRoute = "/auth-hub";
+        _hubUrl = url + hubRoute;
+        _app.Urls.Add(url);
+        _app.MapHub<AuthHub>(hubRoute);
+        _app.Start();
+    }
+
+    [TearDown]
+    public async Task TearDown()
+    {
+        // Stop test server
+        if (_app is not null)
+        {
+            await _app.StopAsync();
+            await _app.DisposeAsync();
+            Console.WriteLine("Test server stopped.");
+        }
     }
 
     [Test]
     public async Task StartAsync_ShouldConnectSuccessfully()
     {
         // Arrange
-        using var provider = Build(opt => opt.Url = HubUrl);
+        using var provider = Build(opt => opt.Url = _hubUrl);
         var client = provider.GetRequiredService<IAuthClient>();
 
         // Act
-        await client.TryStartAsync();
+        await client.StartAsync();
 
         // Assert
         Assert.Multiple(() =>
@@ -42,37 +86,41 @@ public class AuthClientTests
     public async Task ReceiveMessage_ShouldCallOnMessageReceived()
     {
         // Arrange
-        string rcv_user = string.Empty;
+        string rcv_topic = string.Empty;
-        string rcv_msg = string.Empty;
+        string rcv_key = string.Empty;
 
         // Sender client
-        using var provider_sender = Build(opt => opt.Url = HubUrl);
+        using var provider_sender = Build(opt => opt.Url = _hubUrl);
         var sender_client = provider_sender.GetRequiredService<IAuthClient>();
-        await sender_client.TryStartAsync();
+        await sender_client.StartAsync();
 
         // Receiver client
         using var provider_receiver = Build(opt =>
         {
-            opt.Url = HubUrl;
+            opt.Url = _hubUrl;
-            opt.Events.OnMessageReceived = (user, message, logger) =>
+            opt.Events.OnMessageReceived = (topic, key, logger) =>
             {
-                rcv_user = user;
+                rcv_topic = topic;
-                rcv_msg = message;
+                rcv_key = key;
             };
         });
         var client_receiver = provider_receiver.GetRequiredService<IAuthClient>();
+        await client_receiver.StartAsync();
 
-        string user = "user";
+        string topic = "topic";
-        string message = "message";
+        string key = "key";
 
         // Act
-        await client_receiver.ReceiveMessageAsync(user, message);
+        await sender_client.SendKeyAsync(topic, key);
+
+        // delay fort getting answer
+        await Task.Delay(2000);
 
         // Assert
         Assert.Multiple(() =>
         {
-            Assert.That(rcv_user, Is.EqualTo(user));
+            Assert.That(rcv_topic, Is.EqualTo(topic));
-            Assert.That(rcv_msg, Is.EqualTo(message));
+            Assert.That(rcv_key, Is.EqualTo(key));
         });
     }
 }

src/DigitalData.Auth.API/Hubs/AuthHub.cs

@@ -3,14 +3,14 @@ using Microsoft.AspNetCore.SignalR;
 
 namespace DigitalData.Auth.API.Hubs;
 
-public class AuthHub : Hub<IAuthClientHandler>
+public class AuthHub : Hub<IAuthListenHandler>, IAuthSenderHandler
 {
-    public async Task SendMessage(string user, string message)
+    public async Task SendKeyAsync(string user, string message)
-        => await Clients.All.ReceiveMessageAsync(user, message);
+        => await Clients.All.ReceiveKeyAsync(user, message);
 
     public async Task SendMessageToCaller(string user, string message)
-        => await Clients.Caller.ReceiveMessageAsync(user, message);
+        => await Clients.Caller.ReceiveKeyAsync(user, message);
 
     public async Task SendMessageToGroup(string user, string message)
-        => await Clients.Group("Auth.API Consumers").ReceiveMessageAsync(user, message);
+        => await Clients.Group("Auth.API Consumers").ReceiveKeyAsync(user, message);
 }