feat(AuthClient): implementiert IHostedService.

- Aktualisiert um AuthClient zu den Diensten als Hosted Service hinzuzufügen.
 - Der zugehörige Unit-Test wurde aktualisiert, um IHost anstelle von IServiceProvider zu verwenden, um gehostete Dienste testen zu können.

DigitalData.Auth.Tests/Client/AuthClientTests.cs

@@ -18,7 +18,7 @@ public class AuthClientTests
 {
     private string _hubUrl;
 
-    private Func<Action<ClientParams>, ServiceProvider> Build;
+    private Func<Action<ClientParams>, IHost> Build;
 
     private WebApplication? _app;
 
@@ -84,13 +84,18 @@ public class AuthClientTests
     {
         Build = options =>
         {
-            var provider =  new ServiceCollection()
-                    .AddAuthHubClient(options: options)
-                    .BuildServiceProvider();
+            var host = Host.CreateDefaultBuilder()
+                .ConfigureServices(services =>
+                {
+                    services.AddAuthHubClient(options: options)
+                                .BuildServiceProvider();
+                })
+                .Build();
 
-            _disposableAsync.Enqueue(provider);
+            if(host is IAsyncDisposable disposable)
+                _disposableAsync.Enqueue(disposable);
 
-            return provider;
+            return host;
         };
 
         // Create and run test server
@@ -104,26 +109,38 @@ public class AuthClientTests
         // Stop test server
         if (_app is not null)
         {
+            await _app.StopAsync();
             await _app.DisposeAsync();
             Console.WriteLine("Test server stopped.");
         }
 
         while (_disposableAsync.Count > 0)
-            await _disposableAsync.Dequeue().DisposeAsync();
+        {
+            var disposable = _disposableAsync.Dequeue();
+            if (disposable is IHost host)
+                await host.StopAsync();
+            await disposable.DisposeAsync();
+        }
     }
 
     [Test]
-    public async Task StartAsync_ShouldConnectSuccessfully()
+    [TestCase(true, false, true, TestName = "ShouldStart_WhenHostStartsEvenIfClientDoesNot")]
+    [TestCase(false, true, true, TestName = "ShouldStart_WhenClientStartsEvenIfHostDoesNot")]
+    public async Task StartAsync_ShouldConnectSuccessfully(bool startHost, bool startClient, bool expectedIsConnected)
     {
         // Arrange
-        var provider = Build(opt => opt.Url = _hubUrl);
-        var client = provider.GetRequiredService<IAuthClient>();
+        var host = Build(opt => opt.Url = _hubUrl);
+        var client = host.Services.GetRequiredService<IAuthClient>();
 
         // Act
-        await client.StartAsync();
+        if (startHost)
+            await host.StartAsync();
+
+        if (startClient)
+            await client.StartAsync();
 
         // Assert
-        Assert.That(client.IsConnected);
+        Assert.That(client.IsConnected, Is.EqualTo(expectedIsConnected));
     }
 
     [Test]
@@ -135,12 +152,12 @@ public class AuthClientTests
         string rcv_key = string.Empty;
 
         // Sender client
-        var provider_sender = Build(opt => opt.Url = _hubUrl);
-        var sender_client = provider_sender.GetRequiredService<IAuthClient>();
+        var sender_host = Build(opt => opt.Url = _hubUrl);
+        var sender_client = sender_host.Services.GetRequiredService<IAuthClient>();
         await sender_client.StartAsync();
 
         // Receiver client
-        var provider_receiver = Build(opt =>
+        var receiver_host = Build(opt =>
         {
             opt.Url = _hubUrl;
             opt.OnPublicKeyReceived += (client, issuer, audience, key, logger) =>
@@ -150,7 +167,7 @@ public class AuthClientTests
                 rcv_key = key;
             };
         });
-        var client_receiver = provider_receiver.GetRequiredService<IAuthClient>();
+        var client_receiver = receiver_host.Services.GetRequiredService<IAuthClient>();
         await client_receiver.StartAsync();
 
         string issuer = "issuer";
@@ -177,12 +194,12 @@ public class AuthClientTests
     {
         // Arrange
         string? publicKey = null;
-        var provider = Build(opt =>
+        var host = Build(opt =>
         {
             opt.Url = _hubUrl;
             opt.OnPublicKeyReceived += (client, issuer, audience, key, logger) => publicKey = key;
         });
-        var client = provider.GetRequiredService<IAuthClient>();
+        var client = host.Services.GetRequiredService<IAuthClient>();
         await client.StartAsync();
 
         
@@ -207,12 +224,12 @@ public class AuthClientTests
     {
         // Arrange
         var publicKey = new ClientPublicKey() { Issuer = "Foo", Audience = "Bar" };
-        var provider = Build(opt =>
+        var host = Build(opt =>
         {
             opt.Url = _hubUrl;
             opt.PublicKeys.Add(publicKey);
         });
-        var client = provider.GetRequiredService<IAuthClient>();
+        var client = host.Services.GetRequiredService<IAuthClient>();
         await client.StartAsync();
         
         // Act
@@ -230,18 +247,18 @@ public class AuthClientTests
     {
         // Arrange
         var publicKey = new ClientPublicKey() { Issuer = "Foo", Audience = "Bar" };
-        var provider = Build(opt =>
+        var host = Build(opt =>
         {
             opt.Url = _hubUrl;
             opt.PublicKeys.Add(publicKey);
             opt.RetryDelay = new TimeSpan(0, 0, 1);
         });
-        var client = provider.GetRequiredService<IAuthClient>();
+        var client = host.Services.GetRequiredService<IAuthClient>();
         await client.StartAsync();
 
         // Act
         CancellationToken cancellationToken = default;
-        await _app.StopAsync(cancellationToken);
+        await _app!.StopAsync(cancellationToken);
         _app = null;
 
         var newApp = CreateWebApplication(_port);