Public Access
jaap-jan
9a76eced14
Rebuilds the client's shell from an imported design: a titlebar and nav rail it draws itself, real multi-session tabs over the one WebView, a Ctrl+K host search, and a vault screen that merges keys, passwords and pinned host keys into one table. Hosts left the vault column for their own screen beside the terminal, which is what the design asks for and turned out to be the better split anyway. Two screens the design shows have nothing behind them yet — file transfer and teams — and say so plainly rather than rendering invented data; every other gap between the design and this build is recorded in docs/design-import-gaps.md.
471 lines
18 KiB
C#
471 lines
18 KiB
C#
using Avalonia.Controls;
|
|
using Avalonia.VisualTree;
|
|
using DodoSSH.Client.App.ViewModels;
|
|
using DodoSSH.Client.App.Views;
|
|
using DodoSSH.Client.Session;
|
|
using DodoSSH.Client.Session.Tests;
|
|
using DodoSSH.Client.Ssh;
|
|
using DodoSSH.Client.Storage;
|
|
using DodoSSH.Client.Terminal;
|
|
using DodoSSH.Crypto;
|
|
using NSubstitute;
|
|
|
|
namespace DodoSSH.Client.App.Layout.Tests;
|
|
|
|
/// <summary>
|
|
/// Whether each screen fits in the space the window gives it.
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// <para>
|
|
/// This suite used to measure one control, <c>VaultColumn</c>, because there was one. The design import
|
|
/// split it in two — the host list lives beside the terminal, and everything else in the vault has a screen
|
|
/// of its own — and added a titlebar, a nav rail and a status bar. That is five things to measure, and the
|
|
/// split is what keeps every one of them measurable: none contains the terminal's WebView, and
|
|
/// <c>MainWindow</c> still cannot be laid out here at all, because WebView2's adapter refuses the headless
|
|
/// dispatcher's MTA thread. <see cref="LayoutHarnessTests"/> pins that.
|
|
/// </para>
|
|
/// <para>
|
|
/// One test per shape a user can put a screen into, because a shape that is never laid out is a shape never
|
|
/// checked. The host sidebar has three — list, list with the editor open, and list folded away — and the
|
|
/// vault screen has one per category plus one per editor.
|
|
/// </para>
|
|
/// <para>
|
|
/// A real <c>VaultViewModel</c> over a real unlocked vault, rather than a stand-in. Compiled bindings
|
|
/// resolve against the declared data type, so a stand-in would have to be the same type anyway — and the
|
|
/// editors' height depends on real content: a key with a real armour block in the box is taller than an
|
|
/// empty one.
|
|
/// </para>
|
|
/// </remarks>
|
|
public sealed class ScreenLayoutTests : IAsyncLifetime
|
|
{
|
|
private const string Passphrase = "a sufficiently long passphrase";
|
|
private const string ServerUrl = "https://dodossh.example";
|
|
|
|
/// <remarks>Far below the shipped profile: nothing here attacks a wrap.</remarks>
|
|
private static readonly Argon2Profile CheapProfile =
|
|
Argon2Profile.FromStoredParameters(memoryKibibytes: 8 * 1024, passes: 1, parallelism: 1);
|
|
|
|
private readonly FakeAccountServer server = new();
|
|
private readonly StubKeyBinding keyBinding = new();
|
|
private readonly VaultKnownHostStore knownHosts = new();
|
|
|
|
private ClientCacheFactory caches = null!;
|
|
private TerminalWorkspace workspace = null!;
|
|
private VaultSession session = null!;
|
|
private VaultViewModel vault = null!;
|
|
|
|
private static CancellationToken Token => TestContext.Current.CancellationToken;
|
|
|
|
/// <inheritdoc />
|
|
public async ValueTask InitializeAsync()
|
|
{
|
|
caches = ClientCacheFactory.ForMemory($"layout-{Guid.CreateVersion7():N}");
|
|
await caches.MigrateAsync(Token);
|
|
|
|
await new AccountProvisioner(server, keyBinding, caches, TimeProvider.System, CheapProfile)
|
|
.EnrollAsync(ServerUrl, Passphrase, "laptop", "Personal", Token);
|
|
|
|
var outcome = await new SessionOpener(caches, TimeProvider.System).UnlockAsync(Passphrase, Token);
|
|
outcome.IsUnlocked.ShouldBeTrue(outcome.Message);
|
|
session = outcome.Session!;
|
|
|
|
// Never started and never connected through: no screen's layout depends on the terminal, and the
|
|
// substitute is here only because the view model's constructor asks for one.
|
|
workspace = new TerminalWorkspace(
|
|
new InMemoryTerminalAssetProvider(new Dictionary<string, TerminalAsset>(StringComparer.Ordinal)),
|
|
Substitute.For<ISshConnectionFactory>(),
|
|
TimeProvider.System);
|
|
|
|
await knownHosts.OpenAsync(session, Token);
|
|
|
|
// Offline. A null connection is what these screens show on a laptop with no network, and it keeps
|
|
// every sync pass out of a suite that is only measuring rectangles.
|
|
vault = new VaultViewModel(session, workspace, knownHosts, static () => null);
|
|
|
|
await SeedAsync();
|
|
}
|
|
|
|
/// <inheritdoc />
|
|
public async ValueTask DisposeAsync()
|
|
{
|
|
await vault.DisposeAsync();
|
|
knownHosts.Close();
|
|
await workspace.DisposeAsync();
|
|
await session.DisposeAsync();
|
|
caches.Dispose();
|
|
}
|
|
|
|
// ---- The host sidebar ----
|
|
|
|
[Fact]
|
|
public async Task TheHostSidebarFitsWithNoEditorOpen()
|
|
{
|
|
await MeasureSidebarAsync(faults => faults.ShouldBeEmpty());
|
|
}
|
|
|
|
/// <remarks>
|
|
/// The tight one, and the reason this suite still exists. The sidebar is 268 pixels wide against the old
|
|
/// column's 340, and the host editor is the tallest thing in it: six fields, an authentication picker
|
|
/// with a two-line item template, a checkbox, a paragraph of hint text and three buttons, all sharing a
|
|
/// column with the list above them.
|
|
/// </remarks>
|
|
[Fact]
|
|
public async Task TheHostSidebarFitsWithItsEditorOpen()
|
|
{
|
|
vault.SelectedHost = vault.Hosts[0];
|
|
vault.EditSelectedHostCommand.Execute(null);
|
|
|
|
vault.EditorAuthenticationChoices.Count
|
|
.ShouldBeGreaterThan(1, "the picker has to be populated for this to measure anything");
|
|
|
|
// Measured with a credential selected, because an empty picker is shorter than one showing a
|
|
// qualifier beside a label.
|
|
vault.EditorSelectedAuthentication = vault.EditorAuthenticationChoices
|
|
.First(choice => choice.Kind is AuthenticationKind.Credential);
|
|
|
|
await MeasureSidebarAsync(faults => faults.ShouldBeEmpty());
|
|
}
|
|
|
|
/// <remarks>
|
|
/// Folding the list away is the one thing a user can do to this control that changes which of its parts
|
|
/// is on screen, so it is a shape worth laying out on its own.
|
|
/// </remarks>
|
|
[Fact]
|
|
public async Task TheHostSidebarFitsWithItsListFoldedAway()
|
|
{
|
|
vault.ToggleHostsCommand.Execute(null);
|
|
vault.AreHostsExpanded.ShouldBeFalse();
|
|
|
|
await MeasureSidebarAsync(faults => faults.ShouldBeEmpty());
|
|
}
|
|
|
|
/// <remarks>
|
|
/// <para>
|
|
/// The one thing a wrong answer here breaks is unrecoverable from the keyboard: <c>MainWindow</c> takes
|
|
/// the keyboard off the terminal's native child window first and then focuses this target, so a target
|
|
/// that cannot take focus leaves the user with no focused element and no way back except the mouse.
|
|
/// </para>
|
|
/// <para>
|
|
/// Which is why this asserts that focus was <i>taken</i> rather than that the right control was named.
|
|
/// A <c>ListBox</c> is not focusable by default, so the call returns false against a list that has not
|
|
/// asked to be — and <c>Focus()</c> on a collapsed control is a no-op that is not replayed when it is
|
|
/// revealed, which is exactly what the folded-away case would hit.
|
|
/// </para>
|
|
/// </remarks>
|
|
[Fact]
|
|
public async Task TheSidebarsKeyboardTargetTakesFocusInBothOfItsShapes()
|
|
{
|
|
await OnTheSidebarAsync((sidebar, _) =>
|
|
{
|
|
sidebar.KeyboardTarget.ShouldBeSameAs(sidebar.HostList);
|
|
sidebar.KeyboardTarget.Focus().ShouldBeTrue("the list is showing");
|
|
});
|
|
|
|
vault.ToggleHostsCommand.Execute(null);
|
|
|
|
await OnTheSidebarAsync((sidebar, _) =>
|
|
{
|
|
sidebar.KeyboardTarget.ShouldBeSameAs(sidebar.HostFilter);
|
|
sidebar.KeyboardTarget.Focus().ShouldBeTrue("the list is folded away, so the filter takes it");
|
|
});
|
|
}
|
|
|
|
/// <remarks>
|
|
/// The editor open with the list still on screen behind it, which is the state a user is most likely to
|
|
/// leave the sidebar in — so it is the state the keyboard answer most has to hold in.
|
|
/// </remarks>
|
|
[Fact]
|
|
public async Task TheSidebarsKeyboardTargetStillTakesFocusWithTheEditorOpen()
|
|
{
|
|
vault.NewHostCommand.Execute(null);
|
|
|
|
await OnTheSidebarAsync((sidebar, _) =>
|
|
{
|
|
sidebar.HostList.IsEffectivelyVisible.ShouldBeTrue();
|
|
sidebar.KeyboardTarget.Focus().ShouldBeTrue();
|
|
});
|
|
}
|
|
|
|
// ---- The vault screen ----
|
|
|
|
[Fact]
|
|
public async Task TheVaultScreenFitsInEveryCategory()
|
|
{
|
|
foreach (var section in new[]
|
|
{
|
|
VaultSection.All, VaultSection.Keys, VaultSection.Credentials, VaultSection.KnownHosts,
|
|
})
|
|
{
|
|
vault.Section = section;
|
|
|
|
await MeasureVaultAsync(faults => faults.ShouldBeEmpty($"the {section} category"));
|
|
}
|
|
}
|
|
|
|
/// <remarks>
|
|
/// The tall one: a private key needs a real text area, and the vault screen's detail pane is 244 pixels
|
|
/// wide — the narrowest column any form in this application has to fit into.
|
|
/// </remarks>
|
|
[Fact]
|
|
public async Task TheVaultScreenFitsWithTheKeyEditorOpen()
|
|
{
|
|
vault.NewKeyCommand.Execute(null);
|
|
vault.IsEditingKey.ShouldBeTrue();
|
|
vault.ShowsKeys.ShouldBeTrue("opening an editor has to bring its own category into view");
|
|
|
|
vault.KeyEditorPrivateKey = string.Join(
|
|
'\n',
|
|
Enumerable.Repeat("b3BlbnNzaC1rZXktdjEAAAAABG5vbmUAAAAEbm9uZQAAAAAAAAABAAAAMwAAAAtzc2gt", 6));
|
|
|
|
await MeasureVaultAsync(faults => faults.ShouldBeEmpty());
|
|
}
|
|
|
|
[Fact]
|
|
public async Task TheVaultScreenFitsWithThePasswordEditorOpen()
|
|
{
|
|
vault.NewCredentialCommand.Execute(null);
|
|
vault.IsEditingCredential.ShouldBeTrue();
|
|
vault.ShowsCredentials.ShouldBeTrue("opening an editor has to bring its own category into view");
|
|
|
|
await MeasureVaultAsync(faults => faults.ShouldBeEmpty());
|
|
}
|
|
|
|
/// <remarks>
|
|
/// The detail pane with something selected, which is what the design's right-hand column is really about
|
|
/// — and the pin is the one carrying a full fingerprint on a wrapped monospace line.
|
|
/// </remarks>
|
|
[Fact]
|
|
public async Task TheVaultScreenFitsWithAPinSelected()
|
|
{
|
|
vault.Section = VaultSection.KnownHosts;
|
|
vault.VaultItems.ShouldNotBeEmpty("an empty list is the easy case and proves nothing here");
|
|
|
|
vault.SelectedVaultItem = vault.VaultItems[0];
|
|
vault.SelectedItemIsPin.ShouldBeTrue();
|
|
|
|
await MeasureVaultAsync(faults => faults.ShouldBeEmpty());
|
|
}
|
|
|
|
/// <remarks>
|
|
/// The rail is the only way to reach a category, so a button that lands on nothing walls off three
|
|
/// quarters of the screen. The fit tests above prove the buttons are inside the window; this proves they
|
|
/// are the size a pointer can find, which a zero-height row in a collapsed border would not be.
|
|
/// </remarks>
|
|
[Fact]
|
|
public async Task TheCategoryRailIsBigEnoughToClick()
|
|
{
|
|
await OnTheVaultAsync((screen, _) =>
|
|
{
|
|
var buttons = screen.GetVisualDescendants()
|
|
.OfType<Button>()
|
|
.Where(button => button.Classes.Contains("cat"))
|
|
.ToList();
|
|
|
|
buttons.Count.ShouldBe(4, "one per category that exists");
|
|
|
|
foreach (var button in buttons)
|
|
{
|
|
button.Bounds.Height.ShouldBeGreaterThan(20);
|
|
button.Bounds.Width.ShouldBeGreaterThan(120);
|
|
}
|
|
});
|
|
}
|
|
|
|
// ---- The chrome ----
|
|
|
|
/// <remarks>
|
|
/// <para>
|
|
/// The two constants the whole height budget is subtracted from, held against the markup that declares
|
|
/// them. If either bar grows, every screen gets less room than this suite thinks it does and every
|
|
/// measurement above quietly becomes optimistic.
|
|
/// </para>
|
|
/// <para>
|
|
/// Laid out with no data context, which is the point: these are fixed-height strips and their geometry
|
|
/// must not depend on what is bound into them. A binding that made one of them grow with its contents
|
|
/// would fail here.
|
|
/// </para>
|
|
/// </remarks>
|
|
[Fact]
|
|
public async Task TheChromeIsTheHeightTheBudgetAssumes()
|
|
{
|
|
await LayoutHarness.OnTheUiThreadAsync(
|
|
() =>
|
|
{
|
|
var titleBar = new TitleBar();
|
|
var titleWindow = LayoutHarness.HostAtMinimumSize(
|
|
titleBar, LayoutHarness.MinimumWidth, LayoutHarness.TitleBarHeight);
|
|
|
|
try
|
|
{
|
|
titleBar.Bounds.Height.ShouldBe(LayoutHarness.TitleBarHeight);
|
|
LayoutHarness.Unreachable(titleWindow).ShouldBeEmpty();
|
|
}
|
|
finally
|
|
{
|
|
titleWindow.Close();
|
|
}
|
|
|
|
var statusBar = new StatusBar();
|
|
var statusWindow = LayoutHarness.HostAtMinimumSize(
|
|
statusBar, LayoutHarness.MinimumWidth, LayoutHarness.StatusBarHeight);
|
|
|
|
try
|
|
{
|
|
statusBar.Bounds.Height.ShouldBe(LayoutHarness.StatusBarHeight);
|
|
}
|
|
finally
|
|
{
|
|
statusWindow.Close();
|
|
}
|
|
},
|
|
Token);
|
|
}
|
|
|
|
/// <remarks>
|
|
/// Five destinations in a 54-pixel column. The rail runs vertically, so what runs out here is height
|
|
/// rather than width — at the window's minimum the five entries have to leave room for each other, which
|
|
/// is the same failure the old four-button selector was one label away from.
|
|
/// </remarks>
|
|
[Fact]
|
|
public async Task TheNavRailHoldsFiveDestinationsAtTheWindowsMinimum()
|
|
{
|
|
await LayoutHarness.OnTheUiThreadAsync(
|
|
() =>
|
|
{
|
|
var rail = new NavRail();
|
|
var window = LayoutHarness.HostAtMinimumSize(
|
|
rail, LayoutHarness.NavRailWidth, LayoutHarness.ScreenHeight);
|
|
|
|
try
|
|
{
|
|
var buttons = rail.GetVisualDescendants().OfType<Button>().ToList();
|
|
|
|
buttons.Count.ShouldBe(5, "one per screen the rail reaches");
|
|
|
|
foreach (var button in buttons)
|
|
{
|
|
button.Bounds.Height.ShouldBeGreaterThan(20);
|
|
|
|
// One pixel narrower than the rail, because the rail draws its own divider down its
|
|
// right edge and that comes out of the content. Stated exactly rather than as a
|
|
// lower bound: a button that stopped filling the rail would leave a dead strip
|
|
// beside every destination, which is precisely the kind of near-miss a bound hides.
|
|
button.Bounds.Width.ShouldBe(LayoutHarness.NavRailWidth - 1);
|
|
}
|
|
|
|
LayoutHarness.Unreachable(window).ShouldBeEmpty();
|
|
}
|
|
finally
|
|
{
|
|
window.Close();
|
|
}
|
|
},
|
|
Token);
|
|
}
|
|
|
|
// ---- Helpers ----
|
|
|
|
/// <summary>Lays the sidebar out at the width the hosts screen gives it.</summary>
|
|
private Task MeasureSidebarAsync(Action<IReadOnlyList<string>> assert) =>
|
|
OnTheSidebarAsync((_, window) => assert(LayoutHarness.Unreachable(window)));
|
|
|
|
private Task OnTheSidebarAsync(Action<HostSidebar, Window> body) =>
|
|
LayoutHarness.OnTheUiThreadAsync(
|
|
() =>
|
|
{
|
|
var sidebar = new HostSidebar { DataContext = vault };
|
|
|
|
var window = LayoutHarness.HostAtMinimumSize(
|
|
sidebar, LayoutHarness.HostSidebarWidth, LayoutHarness.ScreenHeight);
|
|
|
|
try
|
|
{
|
|
body(sidebar, window);
|
|
}
|
|
finally
|
|
{
|
|
window.Close();
|
|
}
|
|
},
|
|
Token);
|
|
|
|
/// <summary>Lays the vault screen out at the width it gets once the nav rail has taken its column.</summary>
|
|
private Task MeasureVaultAsync(Action<IReadOnlyList<string>> assert) =>
|
|
OnTheVaultAsync((_, window) => assert(LayoutHarness.Unreachable(window)));
|
|
|
|
private Task OnTheVaultAsync(Action<VaultScreen, Window> body) =>
|
|
LayoutHarness.OnTheUiThreadAsync(
|
|
() =>
|
|
{
|
|
var screen = new VaultScreen { DataContext = vault };
|
|
|
|
var window = LayoutHarness.HostAtMinimumSize(
|
|
screen, LayoutHarness.ScreenWidth, LayoutHarness.ScreenHeight);
|
|
|
|
try
|
|
{
|
|
body(screen, window);
|
|
}
|
|
finally
|
|
{
|
|
window.Close();
|
|
}
|
|
},
|
|
Token);
|
|
|
|
/// <remarks>
|
|
/// Enough rows in every list that none is empty, because an empty list is the easiest case and the one
|
|
/// least worth certifying.
|
|
/// </remarks>
|
|
private async Task SeedAsync()
|
|
{
|
|
for (var i = 0; i < 6; i++)
|
|
{
|
|
vault.NewHostCommand.Execute(null);
|
|
vault.EditorLabel = $"host-{i}";
|
|
vault.EditorHostname = $"host-{i}.internal";
|
|
vault.EditorUsername = "deploy";
|
|
await vault.SaveHostCommand.ExecuteAsync(null);
|
|
}
|
|
|
|
for (var i = 0; i < 4; i++)
|
|
{
|
|
vault.NewKeyCommand.Execute(null);
|
|
vault.KeyEditorLabel = $"key-{i}";
|
|
vault.KeyEditorPrivateKey =
|
|
$"-----BEGIN OPENSSH PRIVATE KEY-----\nMATERIAL-{i}\n-----END OPENSSH PRIVATE KEY-----\n";
|
|
await vault.SaveKeyCommand.ExecuteAsync(null);
|
|
}
|
|
|
|
for (var i = 0; i < 3; i++)
|
|
{
|
|
vault.NewCredentialCommand.Execute(null);
|
|
vault.CredentialEditorLabel = $"credential-{i}";
|
|
vault.CredentialEditorPassword = $"password-{i}";
|
|
vault.CredentialEditorUsername = $"account-{i}";
|
|
await vault.SaveCredentialCommand.ExecuteAsync(null);
|
|
}
|
|
|
|
// Pins come from approving a fingerprint at connect time, not from an editor, so they are seeded
|
|
// through the store the connect path writes to. Two for one endpoint, because a host offering keys
|
|
// of two algorithms is ordinary and the duplicate is one of the things this list has to show.
|
|
foreach (var (host, algorithm) in new[]
|
|
{
|
|
("host-0.internal", "ssh-ed25519"),
|
|
("host-0.internal", "ecdsa-sha2-nistp256"),
|
|
("gone.internal", "ssh-ed25519"),
|
|
})
|
|
{
|
|
await knownHosts.TrustAsync(
|
|
new HostKeyPresentation(
|
|
host, 22, algorithm, $"SHA256:{algorithm}-fingerprint-0123456789abcdefghijklmnop"),
|
|
Token);
|
|
}
|
|
|
|
// Back to where the vault screen opens, so every test starts from the state a user would see.
|
|
vault.Section = VaultSection.All;
|
|
|
|
await vault.LoadAsync(Token);
|
|
}
|
|
}
|