Files
Chronos/tests/Titano.App.Tests/Server/ServerSessionSignInTests.cs
T
Claude e4bbf11da9 fix(app): exit without waiting for the UI thread, close the editor with the shell, cancel sign-in safely
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
2026-10-12 09:29:58 +00:00

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);
}
}
}