DESK-1: SyncHost's dispose, session switch and stop now continue on the thread pool (ConfigureAwait(false)) and keep the running agent in one reference. A signed-in user whose archive is not polled no longer waits 10 s at every exit, after which the job engine and the index were never closed. DESK-7: ShellViewModel.Dispose disposes the Sequence section first, so the open editor stops its runners and closes its source before the engine and the index go. DESK-8: Cancel stays available while the server answers a sign-in. It now cancels the request; an answer that still arrives changes nothing (the connection flow ignores answers for a client it dropped), and a sign-in that completed just before the cancel was handled is signed out again. The form no longer sets a result after it closed, and an unexpected failure shows inline instead of escaping async void. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_012iLMBNwBE2GnphAsu4cjaC
155 lines
6.4 KiB
C#
155 lines
6.4 KiB
C#
using System.Net;
|
|
using Titano.App.Infrastructure;
|
|
using Titano.App.Server;
|
|
using Titano.Protocol;
|
|
using Titano.Protocol.Client;
|
|
using Titano.Testing;
|
|
|
|
namespace Titano.App.Tests.Server;
|
|
|
|
/// <summary>The login form cancelled while the server is still answering (DESK-8): nothing signs this PC in afterwards.</summary>
|
|
public sealed class ServerSessionSignInTests
|
|
{
|
|
[Test]
|
|
public async Task CancelEndsTheSignInStillWaitingForTheServer()
|
|
{
|
|
var server = new GatedServer { HonoursCancellation = true };
|
|
var settings = new AppSettings();
|
|
using var session = new ServerSession(settings, () => { }, server, new PlainProtector());
|
|
Task<string?>? pending = null;
|
|
var dialogs = new Dialogs((_, _, signIn) =>
|
|
{
|
|
pending = signIn("alberto", "secret");
|
|
return false;
|
|
});
|
|
|
|
Assert.False(await session.ConnectAsync("nas.local:8443", dialogs));
|
|
// The request the form left behind was cancelled, and the session dropped the connection it belonged to.
|
|
await Assert.ThrowsAsync<OperationCanceledException>(() => pending!);
|
|
Assert.False(session.IsConnected);
|
|
Assert.Equal(ConnectStep.Idle, session.Flow.Step);
|
|
Assert.Null(settings.ProtectedToken);
|
|
}
|
|
|
|
[Test]
|
|
public async Task AnAnswerArrivingAfterCancelSignsNothingIn()
|
|
{
|
|
var server = new GatedServer { HonoursCancellation = false };
|
|
var settings = new AppSettings();
|
|
using var session = new ServerSession(settings, () => { }, server, new PlainProtector());
|
|
Task<string?>? pending = null;
|
|
var dialogs = new Dialogs((_, _, signIn) =>
|
|
{
|
|
pending = signIn("alberto", "secret");
|
|
return false;
|
|
});
|
|
|
|
Assert.False(await session.ConnectAsync("nas.local:8443", dialogs));
|
|
// The server accepts the password only now: the answer belongs to a connection that is gone.
|
|
server.Answer();
|
|
Assert.NotNull(await pending!);
|
|
Assert.False(session.IsConnected);
|
|
Assert.Equal(ConnectStep.Idle, session.Flow.Step);
|
|
Assert.Null(session.Flow.Token);
|
|
Assert.Null(settings.ProtectedToken);
|
|
Assert.Null(settings.ServerUrl);
|
|
}
|
|
|
|
[Test]
|
|
public async Task SignedInJustBeforeTheCancelSignsOutAgain()
|
|
{
|
|
var server = new GatedServer { HonoursCancellation = false };
|
|
server.Answer();
|
|
var settings = new AppSettings();
|
|
using var session = new ServerSession(settings, () => { }, server, new PlainProtector());
|
|
var dialogs = new Dialogs((_, _, signIn) =>
|
|
{
|
|
// The server's answer was handled first, then the click on Cancel closed the form.
|
|
Assert.Null(signIn("alberto", "secret").GetAwaiter().GetResult());
|
|
return false;
|
|
});
|
|
|
|
Assert.False(await session.ConnectAsync("nas.local:8443", dialogs));
|
|
Assert.False(session.IsConnected);
|
|
Assert.Equal(1, server.Logouts);
|
|
Assert.Null(settings.ProtectedToken);
|
|
}
|
|
|
|
[Test]
|
|
public async Task ASignInTheFormConfirmsIsRemembered()
|
|
{
|
|
var server = new GatedServer { HonoursCancellation = true };
|
|
server.Answer();
|
|
var settings = new AppSettings();
|
|
using var session = new ServerSession(settings, () => { }, server, new PlainProtector());
|
|
var dialogs = new Dialogs((_, _, signIn) => signIn("alberto", "secret").GetAwaiter().GetResult() is null);
|
|
|
|
Assert.True(await session.ConnectAsync("nas.local:8443", dialogs));
|
|
Assert.True(session.IsConnected);
|
|
Assert.Equal("token-1", settings.ProtectedToken);
|
|
Assert.Equal(0, server.Logouts);
|
|
}
|
|
|
|
private sealed class Dialogs(Func<string, string?, Func<string, string, Task<string?>>, bool> signIn) : IAppDialogs
|
|
{
|
|
public string? PickFolder(string title, string? initialFolder = null) => null;
|
|
public string? PickJsonFile(string title) => null;
|
|
public bool Confirm(ConfirmRequest request) => true;
|
|
public bool SignIn(string server, string? username, Func<string, string, Task<string?>> callback) => signIn(server, username, callback);
|
|
}
|
|
|
|
private sealed class PlainProtector : ITokenProtector
|
|
{
|
|
public string Protect(string token) => token;
|
|
public string? Unprotect(string protectedToken) => protectedToken;
|
|
}
|
|
|
|
/// <summary>A server whose login answers only when the test says so.</summary>
|
|
private sealed class GatedServer : IServerApiFactory
|
|
{
|
|
private readonly TaskCompletionSource _answer = new();
|
|
|
|
/// <summary>The request ends when its token is cancelled (as over HTTP); otherwise the answer is already on its way.</summary>
|
|
public bool HonoursCancellation { get; init; }
|
|
|
|
public int Logins { get; private set; }
|
|
public int Logouts { get; private set; }
|
|
|
|
public void Answer() => _answer.TrySetResult();
|
|
|
|
public IServerApi Create(Uri baseAddress, IReadOnlyCollection<string> trustedFingerprints) => new Client(this, baseAddress);
|
|
|
|
private sealed class Client(GatedServer server, Uri baseAddress) : IServerApi
|
|
{
|
|
public Uri BaseAddress { get; } = baseAddress;
|
|
public string? Token { get; set; }
|
|
|
|
public Task<ServerInfo> GetInfoAsync(CancellationToken ct) =>
|
|
Task.FromResult(new ServerInfo("Studio NAS", "1.3.0", 1, [], null, [], new ServerLimits(0, 0)));
|
|
|
|
public async Task<LoginResponse> LoginAsync(string username, string password, CancellationToken ct)
|
|
{
|
|
server.Logins++;
|
|
await (server.HonoursCancellation ? server._answer.Task.WaitAsync(ct) : server._answer.Task);
|
|
if (password != "secret") throw new TitanoApiException(HttpStatusCode.Unauthorized, new ApiError("bad_credentials", "Wrong"));
|
|
return new LoginResponse("token-" + server.Logins, User(username), false, DateTimeOffset.UtcNow.AddDays(1));
|
|
}
|
|
|
|
public Task<UserDto> MeAsync(CancellationToken ct) => Task.FromResult(User("alberto"));
|
|
|
|
public Task LogoutAsync(CancellationToken ct)
|
|
{
|
|
server.Logouts++;
|
|
return Task.CompletedTask;
|
|
}
|
|
|
|
public void Dispose()
|
|
{
|
|
}
|
|
|
|
private static UserDto User(string name) =>
|
|
new(Guid.Empty, name, null, "editor", 0, 5_000_000_000_000, 0, false, false, DateTimeOffset.UtcNow, null);
|
|
}
|
|
}
|
|
}
|