139 lines
3.8 KiB
C#
139 lines
3.8 KiB
C#
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 string _hubUrl;
|
|
|
|
private Func<Action<ClientParams>, ServiceProvider> Build;
|
|
|
|
private WebApplication? _app = null;
|
|
|
|
private readonly Queue<IAsyncDisposable> _disposableAsync = new();
|
|
|
|
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 =>
|
|
{
|
|
var provider = new ServiceCollection()
|
|
.AddAuthHubClient(options)
|
|
.BuildServiceProvider();
|
|
|
|
_disposableAsync.Enqueue(provider);
|
|
|
|
return provider;
|
|
};
|
|
|
|
// 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();
|
|
|
|
_disposableAsync.Enqueue(_app);
|
|
}
|
|
|
|
[TearDown]
|
|
public async Task TearDown()
|
|
{
|
|
// Stop test server
|
|
if (_app is not null)
|
|
{
|
|
await _app.StopAsync();
|
|
Console.WriteLine("Test server stopped.");
|
|
}
|
|
|
|
while (_disposableAsync.Count > 0)
|
|
await _disposableAsync.Dequeue().DisposeAsync();
|
|
}
|
|
|
|
[Test]
|
|
public async Task StartAsync_ShouldConnectSuccessfully()
|
|
{
|
|
// Arrange
|
|
var provider = Build(opt => opt.Url = _hubUrl);
|
|
var client = provider.GetRequiredService<IAuthClient>();
|
|
|
|
// Act
|
|
await client.StartAsync();
|
|
|
|
// Assert
|
|
Assert.Multiple(() =>
|
|
{
|
|
Assert.That(client.IsConnected);
|
|
Assert.That(!client.IsConnectionFailed);
|
|
Assert.That(client.ConnectionError, Is.Null);
|
|
});
|
|
}
|
|
|
|
[Test]
|
|
public async Task ReceiveMessage_ShouldCallOnMessageReceived()
|
|
{
|
|
// Arrange
|
|
string rcv_topic = string.Empty;
|
|
string rcv_key = string.Empty;
|
|
|
|
// Sender client
|
|
var provider_sender = Build(opt => opt.Url = _hubUrl);
|
|
var sender_client = provider_sender.GetRequiredService<IAuthClient>();
|
|
await sender_client.StartAsync();
|
|
|
|
// Receiver client
|
|
var provider_receiver = Build(opt =>
|
|
{
|
|
opt.Url = _hubUrl;
|
|
opt.Events.OnMessageReceived = (topic, key, logger) =>
|
|
{
|
|
rcv_topic = topic;
|
|
rcv_key = key;
|
|
};
|
|
});
|
|
var client_receiver = provider_receiver.GetRequiredService<IAuthClient>();
|
|
await client_receiver.StartAsync();
|
|
|
|
string topic = "topic";
|
|
string key = "key";
|
|
|
|
// Act
|
|
await sender_client.SendKeyAsync(topic, key);
|
|
|
|
// delay fort getting answer
|
|
await Task.Delay(2000);
|
|
|
|
// Assert
|
|
Assert.Multiple(() =>
|
|
{
|
|
Assert.That(rcv_topic, Is.EqualTo(topic));
|
|
Assert.That(rcv_key, Is.EqualTo(key));
|
|
});
|
|
}
|
|
} |