Files
Chronos/tests/Chronos.App.Tests/Uploader/ConnectViewModelTests.cs
T
Alby96andClaude Opus 5.5 369e754bec fix(server): public ports as settings, container port lock and client address; clients default to 8443 and name non-Chronos servers
The owner's Uploader could not connect: the panel showed the container's
listening ports (8080/8443) as if clients used them, the public ports were
only environment variables (CHRONOS_PUBLIC_HTTP_PORT not even in the Unraid
template), and the clients mapped a bare host to 443, where another service
answered.

- Public HTTP/HTTPS ports are settings (server.json, or locked by
  CHRONOS_PUBLIC_*) and apply at once; ServerSettingsDto gains appended
  PublicHttpPort, PublicHttpsPort and InContainer members.
- In a container the listening ports are fixed by the template: locked in the
  panel, and saved values from earlier versions are ignored with a warning.
- Settings > Network and TLS shows the client address with a Copy button; the
  discovery tooltip says a container needs network type Host.
- ChronosAddress (shared by Chronos and the Uploader): no scheme and no port is
  https on 8443, https:// keeps 443, a typed port is kept, IPv6 is bracketed.
- GetInfoAsync throws NotChronosServerException for answers that are not a
  Chronos server; another service's certificate is never offered for trust
  and no credentials are sent to it. Both clients name the address asked.
- Unraid template, compose file, user guide, README, BRIEF, DECISIONS,
  CHANGELOG (with an Unraid upgrade note) and ARCHITECTURE updated; en/it
  strings added.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-04 09:53:49 +01:00

207 lines
7.6 KiB
C#
Raw Blame History

This file contains invisible Unicode characters
This file contains invisible Unicode characters that are indistinguishable to humans but may be processed differently by a computer. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
using System.ComponentModel;
using Chronos.Core.Localization;
using Chronos.Protocol;
using Chronos.Testing;
using Chronos.Uploader.Server;
using Chronos.Uploader.Shell;
using Chronos.Uploader.Uploads;
namespace Chronos.App.Tests.Uploader;
/// <summary>
/// The sign-in form puts each failure where DESIGN §4 wants it: a refused address or password marks that field
/// (message in its tooltip), other failures are one sentence, with Retry only where trying again can help.
/// </summary>
public sealed class ConnectViewModelTests
{
private const string Fingerprint = "AB:CD";
[Test]
public void NoFieldShowsAnErrorBeforeSigningIn()
{
var form = Form(new FakeSession());
Assert.False(form.HasErrors);
Assert.Empty(form.GetErrors(nameof(ConnectViewModel.Address)));
Assert.Null(form.PasswordError);
Assert.Null(form.ErrorText);
Assert.False(form.CanRetry);
Assert.Equal(Loc.L("Tooltips.Uploader.ServerAddress"), form.AddressToolTip);
Assert.Equal(Loc.L("Tooltips.Uploader.Password"), form.PasswordToolTip);
}
[Test]
public void AnInvalidAddressMarksTheServerFieldUntilItChanges()
{
var form = Form(new FakeSession(SignInResult.InvalidAddress));
var changed = new List<string?>();
form.ErrorsChanged += (_, e) => changed.Add(e.PropertyName);
form.SignInCommand.Execute(null);
var message = Loc.L("Uploader.Connect.Error.InvalidAddress");
Assert.True(form.HasErrors);
Assert.SequenceEqual([message], form.GetErrors(nameof(ConnectViewModel.Address)).Cast<string>());
Assert.Equal(message, form.AddressToolTip);
Assert.Contains(nameof(ConnectViewModel.Address), changed);
Assert.Null(form.ErrorText, "a field error is not repeated under the form");
Assert.False(form.CanRetry);
form.Address = "https://nas.local:9443";
Assert.False(form.HasErrors);
Assert.Equal(Loc.L("Tooltips.Uploader.ServerAddress"), form.AddressToolTip);
}
[Test]
public void AServerThatIsNotChronosMarksTheServerField()
{
var form = Form(new FakeSession(SignInResult.NotChronos));
// Owner review 3: the address as it was asked, port included, so the user sees which port answered.
form.Address = "192.168.30.23";
form.SignInCommand.Execute(null);
Assert.Equal(Loc.L("Uploader.Connect.Error.NotChronosAt", "‪https://192.168.30.23:8443‬"), form.AddressError);
Assert.Contains("https://192.168.30.23:8443", form.AddressToolTip);
Assert.Null(form.ErrorText);
}
[Test]
public void AWrongPasswordMarksThePasswordFieldUntilTheUserTypes()
{
var form = Form(new FakeSession(SignInResult.BadCredentials));
form.SignInCommand.Execute(null);
var message = Loc.L("Uploader.Connect.Error.BadCredentials");
Assert.Equal(message, form.PasswordError);
Assert.Equal(message, form.PasswordToolTip);
Assert.False(form.HasErrors, "the address is not in question");
Assert.Null(form.ErrorText);
Assert.False(form.CanRetry, "the same password would fail again");
form.Password = "another";
Assert.Null(form.PasswordError);
}
[Theory]
[Case(SignInResult.Unreachable, "Uploader.Connect.Error.Unreachable")]
[Case(SignInResult.Failed, "Uploader.Connect.Error.Failed")]
public void FailuresThatMayPassOfferRetry(SignInResult result, string key)
{
var form = Form(new FakeSession(result));
form.SignInCommand.Execute(null);
Assert.Equal(Loc.L(key), form.ErrorText);
Assert.True(form.CanRetry);
Assert.False(form.HasErrors);
Assert.Null(form.PasswordError);
}
[Test]
public void ADeclinedCertificateIsReportedWithoutRetry()
{
var session = new FakeSession(SignInResult.Untrusted);
var form = Form(session, trust: false);
form.SignInCommand.Execute(null);
Assert.Equal(Loc.L("Uploader.Connect.Error.Untrusted"), form.ErrorText);
Assert.False(form.CanRetry);
Assert.Equal(1, session.Attempts);
Assert.Null(session.Trusted);
}
[Test]
public void ATrustedCertificateSignsInAgainAndClearsEveryError()
{
var session = new FakeSession(SignInResult.BadCredentials, SignInResult.Untrusted, SignInResult.Success);
var form = Form(session, trust: true);
form.SignInCommand.Execute(null);
Assert.NotNull(form.PasswordError);
form.SignInCommand.Execute(null);
Assert.Equal(Fingerprint, session.Trusted);
Assert.Equal(3, session.Attempts);
Assert.Null(form.PasswordError);
Assert.Null(form.ErrorText);
Assert.False(form.HasErrors);
}
[Test]
public void TheFormSaysWhileItsOwnSignInRuns()
{
var session = new FakeSession(SignInResult.Unreachable);
var form = Form(session);
session.During = () => Assert.True(form.IsSigningIn, "signing in while the request runs");
form.SignInCommand.Execute(null);
Assert.Equal(1, session.Attempts);
Assert.False(form.IsSigningIn);
}
private static ConnectViewModel Form(FakeSession session, bool trust = false) =>
new(session, new FakeDialogs(trust), "https://nas.local:8443/", "alberto") { Password = "secret" };
/// <summary>Answers each sign-in with the next scripted result, moving through SigningIn as the real session does.</summary>
private sealed class FakeSession(params SignInResult[] results) : IServerSession
{
private ConnectionState _state = ConnectionState.SignedOut;
public event PropertyChangedEventHandler? PropertyChanged;
public event EventHandler<ServerProblem>? SessionEnded
{
add { }
remove { }
}
public int Attempts { get; private set; }
public string? Trusted { get; private set; }
public Action? During { get; set; }
public ConnectionState State => _state;
public string? Address => "https://nas.local:8443/";
public string? Username => "alberto";
public long QuotaBytes => 0;
public long UsedBytes => 0;
public int BandwidthLimit { get; set; }
public Task<(SignInResult Result, string? Fingerprint)> SignInAsync(string address, string username, string password, CancellationToken ct)
{
var result = results[Math.Min(Attempts, results.Length - 1)];
Attempts++;
SetState(ConnectionState.SigningIn);
During?.Invoke();
SetState(result == SignInResult.Success ? ConnectionState.Connected : ConnectionState.SignedOut);
return Task.FromResult<(SignInResult, string?)>((result, result == SignInResult.Untrusted ? Fingerprint : null));
}
public void Trust(string fingerprint) => Trusted = fingerprint;
public Task SignOutAsync() => Task.CompletedTask;
public Task RefreshAsync() => Task.CompletedTask;
public Task<IReadOnlyList<SequenceDto>> ListSequencesAsync(CancellationToken ct) => Task.FromResult<IReadOnlyList<SequenceDto>>([]);
private void SetState(ConnectionState state)
{
_state = state;
PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(nameof(State)));
}
}
private sealed class FakeDialogs(bool trust) : IUploaderDialogs
{
public IReadOnlyList<string> PickFiles() => [];
public string? PickFolder() => null;
public string? PickWatchFolder() => null;
public bool ConfirmTrust(string address, string fingerprint) => trust;
public bool ConfirmDeleteAfterUpload() => false;
}
}