The formatted-text estimate ignored the numeral and formatting options the cells use and called a fully shown session time cut; a probe TextBlock with the same properties is measured instead. The CI screenshot shows the times whole at 1200 px. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_012iLMBNwBE2GnphAsu4cjaC
314 lines
16 KiB
C#
314 lines
16 KiB
C#
using System.Windows;
|
||
using System.Windows.Automation;
|
||
using System.Windows.Controls;
|
||
using System.Windows.Controls.Primitives;
|
||
using System.Windows.Input;
|
||
using System.Windows.Media;
|
||
using Titano.App.Import;
|
||
using Titano.App.Infrastructure;
|
||
using Titano.App.Sections;
|
||
using Titano.App.Shell;
|
||
using Titano.App.Tests.Windows;
|
||
using Titano.Core.Localization;
|
||
using Titano.Testing;
|
||
using Titano.Ui.Controls;
|
||
|
||
namespace Titano.App.Tests.Import;
|
||
|
||
/// <summary>
|
||
/// Every Import state of <c>--capture</c> (<see cref="ImportScenes"/>) on the simulated cards, rendered in both themes
|
||
/// in the real main window at the 1200 × 788 capture size, with the figures and gates each state must show — and the
|
||
/// buttons really enabled, named for screen readers, nothing that matters cut off, and paths, numbers and times
|
||
/// readable in a right-to-left language.
|
||
/// </summary>
|
||
[WindowsOnly]
|
||
[Serial]
|
||
[Timeout(300_000)]
|
||
public sealed class ImportScreenSmokeTests
|
||
{
|
||
[Test]
|
||
public Task EveryImportStateRendersInBothThemes() => ScreenHost.RunAsync(async () =>
|
||
{
|
||
await using var app = await ScreenSmokeTests.SampleApp.StartAsync();
|
||
await app.Sample.FillAsync();
|
||
var import = app.Shell.Import;
|
||
|
||
await ShowAsync(app, "inserted");
|
||
await UseCaptureSizeAsync(app);
|
||
Assert.NotEmpty(app.FindAll<ToastHost>().SelectMany(host => host.Toasts), "the insertion toast");
|
||
Assert.False(import.FolderPath.HasErrors, "the folder path is not checked while Archive is the destination");
|
||
await app.ExpectAsync<ImportView>("import-inserted");
|
||
|
||
await ShowAsync(app, "plan");
|
||
Assert.Equal(ImportPhase.Ready, import.Phase);
|
||
Assert.Equal("EOS R5 · card A", import.SourceTitle);
|
||
Assert.Equal(3, import.Sessions.Count, "night, dawn and sunset");
|
||
Assert.Equal(50, import.Plan!.CopyCount);
|
||
Assert.Equal("Harbour sunset", import.Plan.Sessions[^1].Title);
|
||
Assert.Null(import.StartBlocker);
|
||
Assert.Empty(app.FindAll<ToastHost>().SelectMany(host => host.Toasts));
|
||
await app.ExpectAsync<ImportView>("import-plan");
|
||
Assert.True(ButtonFor(app, import.StartCommand).IsEnabled, "the Import button is enabled once the plan is ready");
|
||
Assert.True(ButtonFor(app, import.Sessions[1].MergeCommand).IsEnabled, "a session can merge into the one before");
|
||
Assert.False(Validation.GetHasError(Named<TextBox>(app, "FolderPathBox")), "the folder path is not checked while Archive is the destination");
|
||
foreach (var session in import.Sessions)
|
||
Assert.True(Fits(TextFor(app, session.Row.TimeText)), $"the session time '{session.Row.TimeText}' is cut at 1200 px");
|
||
foreach (var item in DeviceItems(app))
|
||
{
|
||
Assert.NotNull(item.FocusVisualStyle, "a device shows keyboard focus");
|
||
Assert.Equal(((ImportSource)item.DataContext).ToolTip, item.ToolTip as string);
|
||
}
|
||
AssertEveryButtonIsNamed(app);
|
||
await AssertFourDigitsFitAsync(app, import);
|
||
await AssertFolderPathIsCheckedOnlyForFolderAsync(app, import);
|
||
|
||
await ShowAsync(app, "showplan");
|
||
Assert.True(import.IsDetailsOpen);
|
||
Assert.Equal(50 + 3, import.Details!.Rows.Count);
|
||
await app.ExpectAsync<ImportView>("import-showplan");
|
||
var file = import.Details.Rows[2];
|
||
Assert.True(Fits(TextFor(app, file.SourceText)), "a file's name on the card is shown whole");
|
||
Assert.True(Fits(TextFor(app, file.DestinationText)), "a file's new name is shown whole");
|
||
Assert.True(Fits(TextFor(app, import.Details.Rows[0].SourceText)), "a session heading is shown whole");
|
||
Assert.Within(Left(app, TextFor(app, Loc.L("Import.Details.Column.Action"))), 0, Left(app, TextFor(app, file.ActionText)), 0, 2,
|
||
"the Action header lines up with its cells");
|
||
AssertEveryButtonIsNamed(app);
|
||
|
||
await ShowAsync(app, "running");
|
||
Assert.True(import.IsRunning);
|
||
Assert.False(import.IsFormEnabled);
|
||
Assert.False(import.Sessions[0].IsEditable, "titles lock while copying");
|
||
await app.ExpectAsync<ImportView>("import-running");
|
||
Assert.True(ButtonFor(app, import.CancelCommand).IsEnabled, "Cancel is enabled while copying");
|
||
foreach (var item in DeviceItems(app))
|
||
{
|
||
Assert.False(item.IsEnabled, "the source of a running import stays selected");
|
||
Assert.Equal(Loc.L("Import.Blocked.Copying"), item.ToolTip as string);
|
||
}
|
||
Assert.Equal(0.4, TextFor(app, Loc.L("Import.Scan.Frames")).Opacity, "unit words dim with their field");
|
||
var progress = Named<TextBlock>(app, "ProgressLine");
|
||
Assert.Equal(AutomationLiveSetting.Polite, AutomationProperties.GetLiveSetting(progress));
|
||
Assert.Same(progress, AutomationProperties.GetLabeledBy(app.FindAll<ProgressBar>().First(p => p.IsVisible && IsInImport(p))));
|
||
|
||
await ShowAsync(app, "failed");
|
||
Assert.True(import.IsFailed);
|
||
Assert.Equal("EOS R5 · card A is no longer available.", import.ErrorText);
|
||
Assert.Contains(SampleCards.Card(app.Services.Environment.DataDirectory).Root, import.FailureToolTip);
|
||
await app.ExpectAsync<ImportView>("import-failed");
|
||
Assert.True(ButtonFor(app, import.RetryCommand).IsEnabled, "Retry is enabled after a failure");
|
||
var failure = Named<TextBlock>(app, "FailureLine");
|
||
Assert.Equal(AutomationLiveSetting.Assertive, AutomationProperties.GetLiveSetting(failure));
|
||
Assert.True(Fits(failure), "the failure sentence is shown whole");
|
||
Assert.Null(app.FindAll<Button>().FirstOrDefault(b => b.IsVisible && ReferenceEquals(b.Command, app.Shell.NavigateCommand) && IsInImport(b)),
|
||
"an error offers one action");
|
||
|
||
await ShowAsync(app, "done");
|
||
Assert.True(import.IsDone);
|
||
var result = import.Result!;
|
||
Assert.True(result.IsComplete);
|
||
Assert.True(result.OffersDelete);
|
||
Assert.True(result.Actions.CanDelete, "a verified import and its dry run allow deleting");
|
||
Assert.Equal(49, result.Actions.DeleteCount);
|
||
Assert.False(result.Actions.CanFormat, "a photo touched since the import keeps the card from being formatted");
|
||
Assert.Empty(app.FindAll<ToastHost>().SelectMany(host => host.Toasts));
|
||
Assert.False(import.IsFormEnabled, "a finished import keeps its form until New import");
|
||
Assert.False(import.TotalsText.Contains(Loc.L("Import.Plan.About", string.Empty).Trim(), StringComparison.Ordinal), "no estimate after the import");
|
||
Assert.Equal(string.Empty, import.SpaceText);
|
||
await app.ExpectAsync<ImportView>("import-done");
|
||
Assert.True(ButtonFor(app, result.DeleteCommand).IsEnabled, "the Delete button follows the dry run");
|
||
AssertEveryButtonIsNamed(app);
|
||
|
||
await ShowAsync(app, "newcard");
|
||
Assert.True(import.IsNicknameOpen, "a new card asks for its nickname");
|
||
Assert.Equal("SONY", import.SourceTitle);
|
||
Assert.False(import.SelectedSource!.IsKnown, "a card without a nickname is still new, though its plan remembered it");
|
||
Assert.NotEmpty(app.FindAll<ToastHost>().SelectMany(host => host.Toasts));
|
||
await app.ExpectAsync<ImportView>("import-newcard");
|
||
AssertEveryButtonIsNamed(app);
|
||
});
|
||
|
||
[Test]
|
||
public Task PathsNumbersAndTimesStayReadableRightToLeft() => ScreenHost.RunAsync(async () =>
|
||
{
|
||
await using var app = await ScreenSmokeTests.SampleApp.StartAsync();
|
||
await app.Sample.FillAsync();
|
||
UiLanguage.Apply("ar");
|
||
try
|
||
{
|
||
var import = app.Shell.Import;
|
||
await ShowAsync(app, "plan");
|
||
Assert.Equal(ImportPhase.Ready, import.Phase);
|
||
Assert.Equal(FlowDirection.RightToLeft, WindowOf(app).FlowDirection);
|
||
Assert.Equal(FlowDirection.LeftToRight, Named<TextBox>(app, "FolderPathBox").FlowDirection);
|
||
Assert.Equal(FlowDirection.LeftToRight, Named<TextBox>(app, "GapBox").FlowDirection);
|
||
foreach (var template in app.FindAll<TextBox>().Where(t => EditBehavior.GetField(t) is { } f && (f == import.FolderTemplate || f == import.FileTemplate)))
|
||
Assert.Equal(FlowDirection.LeftToRight, template.FlowDirection, "name templates read left to right");
|
||
Assert.Equal(FlowDirection.LeftToRight, TextFor(app, import.NamePreview).FlowDirection, "the name preview reads left to right");
|
||
var size = TextFor(app, import.Sessions[0].Row.SizeText);
|
||
Assert.Equal(FlowDirection.LeftToRight, size.FlowDirection);
|
||
Assert.Equal(TextAlignment.Right, size.TextAlignment, "numbers stay right-aligned");
|
||
Assert.Contains("←", import.Sessions[0].Row.TimeText);
|
||
await app.ExpectAsync<ImportView>("import-plan-ar");
|
||
|
||
await ShowAsync(app, "showplan");
|
||
var file = import.Details!.Rows[2];
|
||
Assert.Equal(FlowDirection.LeftToRight, TextFor(app, file.SourceText).FlowDirection);
|
||
Assert.Equal(FlowDirection.LeftToRight, TextFor(app, file.DestinationText).FlowDirection);
|
||
await app.ExpectAsync<ImportView>("import-showplan-ar");
|
||
}
|
||
finally
|
||
{
|
||
UiLanguage.Apply("en");
|
||
}
|
||
});
|
||
|
||
/// <summary>As <c>--capture</c> does: toasts of the previous state go, those of an insertion state stay.</summary>
|
||
private static async Task ShowAsync(ScreenSmokeTests.SampleApp app, string state)
|
||
{
|
||
DismissToasts(app);
|
||
await ImportScenes.ShowAsync(app.Shell, state);
|
||
if (!ImportScenes.ShowsToast(state)) DismissToasts(app);
|
||
await SettleAsync(app);
|
||
}
|
||
|
||
private static void DismissToasts(ScreenSmokeTests.SampleApp app)
|
||
{
|
||
foreach (var host in app.FindAll<ToastHost>())
|
||
{
|
||
foreach (var toast in host.Toasts.ToList()) host.Dismiss(toast);
|
||
}
|
||
}
|
||
|
||
/// <summary>The size CI captures at (and the window's minimum width): nothing may be cut there.</summary>
|
||
private static async Task UseCaptureSizeAsync(ScreenSmokeTests.SampleApp app)
|
||
{
|
||
var window = WindowOf(app);
|
||
window.Width = 1200;
|
||
window.Height = 788;
|
||
await SettleAsync(app);
|
||
}
|
||
|
||
private static async Task SettleAsync(ScreenSmokeTests.SampleApp app)
|
||
{
|
||
var window = WindowOf(app);
|
||
window.UpdateLayout();
|
||
await window.Dispatcher.InvokeAsync(() => { }, System.Windows.Threading.DispatcherPriority.ApplicationIdle);
|
||
window.UpdateLayout();
|
||
}
|
||
|
||
private static async Task WaitUntilAsync(ScreenSmokeTests.SampleApp app, Func<bool> condition, string what)
|
||
{
|
||
for (var i = 0; i < 200 && !condition(); i++) await Task.Delay(25);
|
||
Assert.True(condition(), what);
|
||
await SettleAsync(app);
|
||
}
|
||
|
||
/// <summary>The empty folder path is fine for the archive; choosing Folder makes it invalid and offers "Choose folder".</summary>
|
||
private static async Task AssertFolderPathIsCheckedOnlyForFolderAsync(ScreenSmokeTests.SampleApp app, ImportViewModel import)
|
||
{
|
||
var box = Named<TextBox>(app, "FolderPathBox");
|
||
import.IsFolderDestination = true;
|
||
await WaitUntilAsync(app, () => import.Phase == ImportPhase.NoSource, "the plan stops without a folder");
|
||
Assert.True(Validation.GetHasError(box), "an empty path is an error once Folder is chosen");
|
||
Assert.True(import.HasStatusAction);
|
||
Assert.Equal(Loc.L("Import.Destination.Choose"), import.StatusActionText);
|
||
Assert.True(Named<Button>(app, "StatusActionButton").IsVisible, "the status sentence comes with its action");
|
||
import.IsArchiveDestination = true;
|
||
await WaitUntilAsync(app, () => import.Phase == ImportPhase.Ready, "the archive plan is back");
|
||
Assert.False(Validation.GetHasError(box));
|
||
Assert.Equal("Harbour sunset", import.Plan!.Sessions[^1].Title, "typed titles survive the round trip");
|
||
}
|
||
|
||
/// <summary>The 56 px gap box shows its largest value, 1440, whole.</summary>
|
||
private static async Task AssertFourDigitsFitAsync(ScreenSmokeTests.SampleApp app, ImportViewModel import)
|
||
{
|
||
import.GapMinutes.Text = "1440";
|
||
await SettleAsync(app);
|
||
var host = Descendants(Named<TextBox>(app, "GapBox")).OfType<ScrollViewer>().First();
|
||
Assert.LessOrEqual(host.ExtentWidth, host.ViewportWidth + 1, "1440 fits the gap box");
|
||
import.GapMinutes.Revert();
|
||
}
|
||
|
||
/// <summary>Every button, check box and radio button of the screen has a name screen readers can announce.</summary>
|
||
private static void AssertEveryButtonIsNamed(ScreenSmokeTests.SampleApp app)
|
||
{
|
||
foreach (var button in app.FindAll<ButtonBase>().Where(b => b.IsVisible && b.Focusable && IsInImport(b)))
|
||
{
|
||
var name = AutomationProperties.GetName(button);
|
||
if (string.IsNullOrEmpty(name)) name = button.Content as string;
|
||
Assert.False(string.IsNullOrWhiteSpace(name), $"{button.GetType().Name} '{button.Name}' bound to {button.Command} has no accessible name");
|
||
}
|
||
}
|
||
|
||
private static Window WindowOf(ScreenSmokeTests.SampleApp app) => Window.GetWindow(app.FindAll<FrameworkElement>().First())!;
|
||
|
||
private static ImportView View(ScreenSmokeTests.SampleApp app) => app.FindAll<ImportView>().First(v => v.IsVisible);
|
||
|
||
private static bool IsInImport(DependencyObject element) => FindAncestor<ImportView>(element) is not null;
|
||
|
||
private static T? FindAncestor<T>(DependencyObject element)
|
||
where T : DependencyObject
|
||
{
|
||
for (var node = VisualTreeHelper.GetParent(element); node is not null; node = VisualTreeHelper.GetParent(node))
|
||
{
|
||
if (node is T match) return match;
|
||
}
|
||
return null;
|
||
}
|
||
|
||
private static IEnumerable<DependencyObject> Descendants(DependencyObject root)
|
||
{
|
||
for (var i = 0; i < VisualTreeHelper.GetChildrenCount(root); i++)
|
||
{
|
||
var child = VisualTreeHelper.GetChild(root, i);
|
||
yield return child;
|
||
foreach (var below in Descendants(child)) yield return below;
|
||
}
|
||
}
|
||
|
||
private static T Named<T>(ScreenSmokeTests.SampleApp app, string name)
|
||
where T : FrameworkElement =>
|
||
Assert.NotNull(app.FindAll<T>().FirstOrDefault(e => e.Name == name), $"{typeof(T).Name} {name}");
|
||
|
||
private static TextBlock TextFor(ScreenSmokeTests.SampleApp app, string text) =>
|
||
Assert.NotNull(app.FindAll<TextBlock>().FirstOrDefault(t => t.IsVisible && t.Text == text && IsInImport(t)), $"a visible text '{text}'");
|
||
|
||
private static IEnumerable<ListBoxItem> DeviceItems(ScreenSmokeTests.SampleApp app) =>
|
||
app.FindAll<ListBoxItem>().Where(i => i.IsVisible && i.DataContext is ImportSource);
|
||
|
||
/// <summary>
|
||
/// The text is shown whole: a copy with the same font, numerals and padding, measured by the same layout engine,
|
||
/// needs no more room than the layout gave the shown one (a formatted-text estimate differs by a few pixels).
|
||
/// </summary>
|
||
private static bool Fits(TextBlock text)
|
||
{
|
||
var probe = new TextBlock
|
||
{
|
||
Text = text.Text,
|
||
FontFamily = text.FontFamily,
|
||
FontSize = text.FontSize,
|
||
FontStyle = text.FontStyle,
|
||
FontWeight = text.FontWeight,
|
||
FontStretch = text.FontStretch,
|
||
FlowDirection = text.FlowDirection,
|
||
Language = text.Language,
|
||
Padding = text.Padding,
|
||
TextWrapping = text.TextWrapping,
|
||
};
|
||
System.Windows.Documents.Typography.SetNumeralAlignment(probe, System.Windows.Documents.Typography.GetNumeralAlignment(text));
|
||
TextOptions.SetTextFormattingMode(probe, TextOptions.GetTextFormattingMode(text));
|
||
if (text.TextWrapping != TextWrapping.NoWrap)
|
||
{
|
||
probe.Measure(new Size(text.ActualWidth, double.PositiveInfinity));
|
||
return probe.DesiredSize.Height <= text.ActualHeight + 0.5;
|
||
}
|
||
probe.Measure(new Size(double.PositiveInfinity, double.PositiveInfinity));
|
||
return probe.DesiredSize.Width <= text.ActualWidth + 1;
|
||
}
|
||
|
||
private static double Left(ScreenSmokeTests.SampleApp app, FrameworkElement element) => element.TranslatePoint(new Point(0, 0), View(app)).X;
|
||
|
||
private static Button ButtonFor(ScreenSmokeTests.SampleApp app, ICommand command) =>
|
||
Assert.NotNull(app.FindAll<Button>().FirstOrDefault(b => ReferenceEquals(b.Command, command) && b.IsVisible), "a visible button bound to the command");
|
||
}
|