408 lines
17 KiB
C#
408 lines
17 KiB
C#
using System;
|
||
using System.Collections.Generic;
|
||
using System.Globalization;
|
||
using System.IO;
|
||
using System.Linq;
|
||
using System.Threading;
|
||
using System.Threading.Tasks;
|
||
using Avalonia;
|
||
using Avalonia.Controls;
|
||
using Avalonia.Headless;
|
||
using Avalonia.Media;
|
||
using Avalonia.Media.Imaging;
|
||
using Avalonia.Threading;
|
||
using Avalonia.VisualTree;
|
||
using Omika.App.Local.Abstractions;
|
||
using Omika.App.Navigation;
|
||
using Omika.App.Services;
|
||
using Omika.App.ViewModels;
|
||
using Omika.App.Views;
|
||
using Omika.Core.Constants;
|
||
using Omika.Core.Contracts.Mobile.Sync;
|
||
using SkiaSharp;
|
||
using Xunit;
|
||
using Path = Avalonia.Controls.Shapes.Path;
|
||
|
||
namespace Omika.Tests.Mobile;
|
||
|
||
/// <summary>
|
||
/// Régression mesurée : dans le menu bas principal, l'icône du bouton « Sites »
|
||
/// (repère Material de 14×20) n'était pas centrée. Les tracés sont dessinés dans
|
||
/// un gabarit 24×24 et centrés en (12 ; 12) ; rendus en 18×18 avec
|
||
/// <c>Stretch="Uniform"</c>, Avalonia ramenait les limites du tracé sur le coin
|
||
/// haut-gauche de la boîte et laissait les 5 px de jeu à droite : le repère
|
||
/// sortait <b>2,5 px à gauche</b> de son bouton (les autres icônes étaient
|
||
/// décalées de 0 à 3 px selon leur forme).
|
||
/// </summary>
|
||
/// <remarks>
|
||
/// Ces tests mesurent le rendu Skia RÉEL du Shell complet (barre basse et rail
|
||
/// latéral), icône par icône : aucune hypothèse sur la géométrie, sur
|
||
/// <c>Stretch</c> ni sur les styles. Ils rejoignent la collection
|
||
/// « ApplicationRuntimeContext » car le localisateur d'Avalonia est global au
|
||
/// processus.
|
||
/// </remarks>
|
||
[Collection("ApplicationRuntimeContext")]
|
||
public sealed class BarreNavigationIconesTests : IDisposable
|
||
{
|
||
/// <summary>Largeur d'un petit téléphone : sous 600 px, les libellés sont masqués.</summary>
|
||
private const double LargeurTelephoneEtroit = 360;
|
||
|
||
/// <summary>Largeur desktop : au-dessus de 960 px, c'est le rail latéral qui est affiché.</summary>
|
||
private const double LargeurBureau = 1200;
|
||
|
||
/// <summary>Très petit téléphone : tout doit rester dans l'écran.</summary>
|
||
private const double LargeurPetitEcran = 320;
|
||
|
||
/// <summary>Largeur au-dessus de laquelle les libellés de la barre basse sont affichés.</summary>
|
||
private const double LargeurLibelles = 700;
|
||
|
||
/// <summary>Tolérance (px) : l'encre est comptée en pixels entiers.</summary>
|
||
private const double Tolerance = 1.0;
|
||
|
||
private readonly HeadlessUnitTestSession _session =
|
||
HeadlessUnitTestSession.StartNew(typeof(LayoutTestAppBuilder));
|
||
|
||
public void Dispose() => _session.Dispose();
|
||
|
||
[Fact]
|
||
public void BarreBasse_ChaqueIcone_EstCentreeDansSonBouton()
|
||
=> Executer((fenetre, items) =>
|
||
{
|
||
Button[] boutons = Boutons(fenetre, "bottomNavItem");
|
||
|
||
Assert.Equal(items.Count, boutons.Length);
|
||
foreach (Button bouton in boutons)
|
||
{
|
||
VerifierIcone(bouton, items, "barre basse", Disposition.IconeSeuleDansLeBouton);
|
||
}
|
||
}, LargeurTelephoneEtroit);
|
||
|
||
/// <summary>
|
||
/// Au-dessus de 600 px, les libellés apparaissent : le groupe icône + libellé
|
||
/// doit rester centré dans le bouton et la barre entière doit tenir dans
|
||
/// l'écran (le rembourrage des boutons ne doit pas la faire déborder).
|
||
/// </summary>
|
||
[Fact]
|
||
public void BarreBasse_LibellesAffiches_LeGroupeResteCentreEtDansLEcran()
|
||
=> Executer((fenetre, items) =>
|
||
{
|
||
Button[] boutons = Boutons(fenetre, "bottomNavItem");
|
||
|
||
Assert.Equal(items.Count, boutons.Length);
|
||
foreach (Button bouton in boutons)
|
||
{
|
||
VerifierIcone(bouton, items, "barre basse (libellés)", Disposition.IconeAuDessusDuLibelle);
|
||
}
|
||
|
||
double droite = boutons.Max(b => b.TranslatePoint(new Point(b.Bounds.Width, 0), fenetre)!.Value.X);
|
||
Assert.True(
|
||
droite <= LargeurLibelles + 0.5,
|
||
$"La barre basse dépasse l'écran de {droite - LargeurLibelles:0.#} px " +
|
||
$"à {LargeurLibelles} px.");
|
||
}, LargeurLibelles);
|
||
|
||
/// <summary>
|
||
/// Rail latéral : l'icône est en tête de ligne, suivie du libellé — elle n'est
|
||
/// donc pas centrée dans le bouton (pleine largeur), mais elle doit y être
|
||
/// dessinée à sa taille et à sa position natives, comme dans la barre basse.
|
||
/// </summary>
|
||
[Fact]
|
||
public void RailLateral_ChaqueIcone_EstRendueEnTailleNative()
|
||
=> Executer((fenetre, items) =>
|
||
{
|
||
Button[] boutons = Boutons(fenetre, "navItem");
|
||
|
||
Assert.Equal(items.Count, boutons.Length);
|
||
foreach (Button bouton in boutons)
|
||
{
|
||
VerifierIcone(bouton, items, "rail latéral", Disposition.IconeAvantLeLibelle);
|
||
}
|
||
}, LargeurBureau);
|
||
|
||
/// <summary>
|
||
/// Sur un très petit écran (320 px), les sept boutons de la barre basse
|
||
/// (icônes de 24 px, libellés masqués) doivent tous tenir dans la largeur,
|
||
/// sans être rognés : le panneau répartit l'espace restant, il ne réduit
|
||
/// jamais les boutons.
|
||
/// </summary>
|
||
[Fact]
|
||
public void BarreBasse_TousLesBoutons_TiennentDansLaLargeur_AEcran320()
|
||
=> Executer((fenetre, items) =>
|
||
{
|
||
Button[] boutons = Boutons(fenetre, "bottomNavItem");
|
||
|
||
Assert.Equal(items.Count, boutons.Length);
|
||
|
||
double droite = boutons.Max(b => b.TranslatePoint(new Point(b.Bounds.Width, 0), fenetre)!.Value.X);
|
||
string detail = string.Join(
|
||
", ",
|
||
boutons.Select(b => $"{b.CommandParameter}={b.Bounds.Width:0.#}px"));
|
||
|
||
Assert.True(
|
||
droite <= LargeurPetitEcran + 0.5,
|
||
$"La barre basse dépasse l'écran de {droite - LargeurPetitEcran:0.#} px " +
|
||
$"à {LargeurPetitEcran} px (boutons : {detail}).");
|
||
}, LargeurPetitEcran);
|
||
|
||
/// <summary>
|
||
/// Le rendu en taille native n'est possible que si chaque tracé tient dans le
|
||
/// gabarit carré 24×24 : un tracé plus grand serait rogné (et le centrage
|
||
/// perdu). Ce test verrouille la contrainte pour tout futur ajout d'icône.
|
||
/// </summary>
|
||
[Fact]
|
||
public void IconesDeNavigation_TiennentDansLeGabaritCarre24x24()
|
||
=> ExecuterSansVue(() =>
|
||
{
|
||
foreach (NavigationItem item in new NavigationService().Items)
|
||
{
|
||
Geometry geo = Geometrie(item.Icon);
|
||
Rect limites = geo.Bounds;
|
||
|
||
Assert.True(
|
||
limites.X >= 0 && limites.Y >= 0 && limites.Right <= 24 && limites.Bottom <= 24,
|
||
$"L'icône « {item.Icon} » dépasse le gabarit 24×24 : {limites} — " +
|
||
"elle serait rognée en taille native (Stretch=\"None\").");
|
||
}
|
||
});
|
||
|
||
// ===== Outils =====
|
||
|
||
/// <summary>Exécute des vérifications sur le thread d'interface, sans ouvrir de vue.</summary>
|
||
private void ExecuterSansVue(Action scenario)
|
||
=> _session.Dispatch(
|
||
() =>
|
||
{
|
||
scenario();
|
||
return true;
|
||
},
|
||
CancellationToken.None).GetAwaiter().GetResult();
|
||
|
||
/// <summary>Construit le Shell réel et exécute les vérifications sur le rendu.</summary>
|
||
private void Executer(Action<Window, IReadOnlyList<NavigationItem>> scenario, double largeur)
|
||
{
|
||
_session.Dispatch(
|
||
() =>
|
||
{
|
||
var permissions = new PermissionService();
|
||
permissions.SetRights(MobilePermissionKeys.All.ToDictionary(k => k, _ => true));
|
||
|
||
var navigation = new NavigationService(permissions);
|
||
var shell = new ShellViewModel(
|
||
navigation,
|
||
null!,
|
||
new FakeSyncEngine(),
|
||
new FakePageFactory(),
|
||
null!,
|
||
permissions,
|
||
new FakeOutboxService(),
|
||
null!);
|
||
|
||
Window fenetre = MesureGeometrique.Ouvrir(new ShellView { DataContext = shell }, largeur);
|
||
|
||
scenario(fenetre, navigation.Items);
|
||
|
||
fenetre.Close();
|
||
|
||
// Le Shell déclenche des lectures locales en tâche de fond : on
|
||
// vide la file d'attente avant de rendre la main, pour que la
|
||
// session headless se termine sans travail en suspens.
|
||
Dispatcher.UIThread.RunJobs();
|
||
Dispatcher.UIThread.RunJobs();
|
||
return true;
|
||
},
|
||
CancellationToken.None).GetAwaiter().GetResult();
|
||
}
|
||
|
||
/// <summary>Boutons visibles de la barre basse (ou du rail latéral).</summary>
|
||
private static Button[] Boutons(Window fenetre, string classe)
|
||
=> fenetre.GetVisualDescendants()
|
||
.OfType<Button>()
|
||
.Where(b => b.Classes.Contains(classe) && b.IsVisible && b.Bounds.Width > 0)
|
||
.ToArray();
|
||
|
||
/// <summary>
|
||
/// Vérifie, sur le rendu réel, que le tracé est dessiné <b>à sa taille et à sa
|
||
/// position natives</b> dans la boîte du <c>Path</c> (c'est-à-dire sans
|
||
/// décalage ni mise à l'échelle cachée), puis le placement attendu selon la
|
||
/// disposition de l'élément de navigation.
|
||
/// </summary>
|
||
private static void VerifierIcone(
|
||
Button bouton,
|
||
IReadOnlyList<NavigationItem> items,
|
||
string zone,
|
||
Disposition disposition)
|
||
{
|
||
var page = (AppPage)bouton.CommandParameter!;
|
||
NavigationItem item = items.Single(i => i.Page == page);
|
||
Path chemin = bouton.GetVisualDescendants().OfType<Path>().Single();
|
||
|
||
int cote = (int)Math.Round(chemin.Bounds.Width);
|
||
int hauteur = (int)Math.Round(chemin.Bounds.Height);
|
||
Assert.True(cote > 0 && hauteur > 0, $"L'icône « {item.Icon} » ({zone}) n'a pas été disposée.");
|
||
|
||
using var cible = new RenderTargetBitmap(new PixelSize(cote, hauteur), new Vector(96, 96));
|
||
cible.Render(chemin);
|
||
|
||
using var flux = new MemoryStream();
|
||
cible.Save(flux);
|
||
using var bitmap = SKBitmap.Decode(flux.ToArray());
|
||
|
||
(int x0, int y0, int x1, int y1) = EncreDe(bitmap);
|
||
Assert.True(x1 >= x0, $"Aucune encre rendue pour l'icône « {item.Icon} » ({zone}).");
|
||
|
||
string detail =
|
||
$"« {item.Icon} » ({zone}) : encre=[{x0},{y0} .. {x1},{y1}] dans une boîte {cote}x{hauteur}";
|
||
|
||
// 1. Taille et position natives : l'encre doit occuper exactement les
|
||
// limites du tracé, à l'échelle 1:1 depuis l'origine de la boîte. Un
|
||
// Stretch="Uniform" (même partiel) ou une boîte mal dimensionnée
|
||
// déplace ou rétrécit l'encre : c'est le défaut mesuré à l'origine
|
||
// (repère « site » sorti 2,5 px à gauche).
|
||
Rect attendu = Geometrie(item.Icon).Bounds;
|
||
|
||
Assert.True(
|
||
Math.Abs(x0 - attendu.X) <= Tolerance
|
||
&& Math.Abs(y0 - attendu.Y) <= Tolerance
|
||
&& Math.Abs(x1 + 1 - attendu.Right) <= Tolerance
|
||
&& Math.Abs(y1 + 1 - attendu.Bottom) <= Tolerance,
|
||
$"L'icône « {item.Icon} » ({zone}) n'est pas dessinée à sa place native " +
|
||
$"(attendu [{attendu.X:0.#},{attendu.Y:0.#} .. {attendu.Right:0.#},{attendu.Bottom:0.#}]) — {detail}.");
|
||
|
||
Point? origine = chemin.TranslatePoint(new Point(0, 0), bouton);
|
||
Assert.NotNull(origine);
|
||
|
||
double centreEncreX = origine!.Value.X + (x0 + x1) / 2.0;
|
||
double centreEncreY = origine.Value.Y + (y0 + y1) / 2.0;
|
||
double centreBoutonX = (bouton.Bounds.Width - 1) / 2.0;
|
||
double centreBoutonY = (bouton.Bounds.Height - 1) / 2.0;
|
||
|
||
if (disposition == Disposition.IconeAvantLeLibelle)
|
||
{
|
||
// Rail latéral : le libellé suit l'icône sur la même ligne.
|
||
TextBlock etiquette = bouton.GetVisualDescendants().OfType<TextBlock>().Single();
|
||
Point? etiquetteOrigine = etiquette.TranslatePoint(new Point(0, 0), bouton);
|
||
|
||
Assert.True(
|
||
etiquetteOrigine is not null && etiquetteOrigine.Value.X >= origine.Value.X + cote,
|
||
$"Le libellé « {item.Title} » ({zone}) chevauche l'icône — {detail}.");
|
||
return;
|
||
}
|
||
|
||
// L'icône doit être centrée horizontalement dans son bouton, dans les deux
|
||
// dispositions de la barre basse. Tolérance élargie : le centre optique
|
||
// d'un tracé Material n'est pas toujours exactement le centre de la boîte
|
||
// (jusqu'à 1 px).
|
||
Assert.True(
|
||
Math.Abs(centreEncreX - centreBoutonX) <= Tolerance + 0.5,
|
||
$"Icône non centrée horizontalement dans son bouton — {detail} " +
|
||
$"(centres : icône={centreEncreX:0.#}, bouton={centreBoutonX:0.#}).");
|
||
|
||
if (disposition == Disposition.IconeAuDessusDuLibelle)
|
||
{
|
||
// Libellés affichés : c'est le groupe icône + libellé qui est centré
|
||
// verticalement dans le bouton (pas l'icône seule).
|
||
StackPanel pile = bouton.GetVisualDescendants().OfType<StackPanel>().First();
|
||
TextBlock etiquette = bouton.GetVisualDescendants().OfType<TextBlock>().Single();
|
||
Point? pileOrigine = pile.TranslatePoint(new Point(0, 0), bouton);
|
||
|
||
Assert.True(etiquette.IsVisible, $"Le libellé « {item.Title} » ({zone}) devrait être affiché.");
|
||
Assert.NotNull(pileOrigine);
|
||
Assert.True(
|
||
Math.Abs(pileOrigine!.Value.Y + (pile.Bounds.Height - 1) / 2.0 - centreBoutonY) <= Tolerance,
|
||
$"Le groupe icône + libellé « {item.Title} » ({zone}) n'est pas centré dans son bouton " +
|
||
$"(groupe={pile.Bounds.Height:0.#} px, bouton={bouton.Bounds.Height:0.#} px).");
|
||
return;
|
||
}
|
||
|
||
// Icône seule (libellés masqués sur écran étroit) : centrage dans les deux
|
||
// axes — c'est le critère visible par l'utilisateur.
|
||
Assert.True(
|
||
Math.Abs(centreEncreY - centreBoutonY) <= Tolerance + 0.5,
|
||
$"Icône non centrée verticalement dans son bouton — {detail} " +
|
||
$"(centres : icône={centreEncreY:0.#}, bouton={centreBoutonY:0.#}).");
|
||
}
|
||
|
||
/// <summary>Placement attendu de l'icône selon l'élément de navigation.</summary>
|
||
private enum Disposition
|
||
{
|
||
/// <summary>Barre basse, libellés masqués : l'icône est seule dans le bouton.</summary>
|
||
IconeSeuleDansLeBouton,
|
||
|
||
/// <summary>Barre basse, libellés affichés : icône au-dessus du libellé.</summary>
|
||
IconeAuDessusDuLibelle,
|
||
|
||
/// <summary>Rail latéral : icône puis libellé, sur la même ligne.</summary>
|
||
IconeAvantLeLibelle
|
||
}
|
||
|
||
private static Geometry Geometrie(string cle)
|
||
=> (Geometry)NavIconGeometryConverter.Instance
|
||
.Convert(cle, typeof(Geometry), null, CultureInfo.InvariantCulture)!;
|
||
|
||
/// <summary>Boîte englobante des pixels non transparents du rendu.</summary>
|
||
private static (int X0, int Y0, int X1, int Y1) EncreDe(SKBitmap bitmap)
|
||
{
|
||
int x0 = int.MaxValue;
|
||
int y0 = int.MaxValue;
|
||
int x1 = -1;
|
||
int y1 = -1;
|
||
|
||
for (int y = 0; y < bitmap.Height; y++)
|
||
{
|
||
for (int x = 0; x < bitmap.Width; x++)
|
||
{
|
||
if (bitmap.GetPixel(x, y).Alpha < 16)
|
||
{
|
||
continue;
|
||
}
|
||
|
||
x0 = Math.Min(x0, x);
|
||
y0 = Math.Min(y0, y);
|
||
x1 = Math.Max(x1, x);
|
||
y1 = Math.Max(y1, y);
|
||
}
|
||
}
|
||
|
||
return (x0, y0, x1, y1);
|
||
}
|
||
|
||
/// <summary>Page vide : la barre de navigation ne dépend d'aucun écran réel.</summary>
|
||
private sealed class PageVide : ViewModelBase;
|
||
|
||
/// <summary>Fabrique de pages neutre : aucune donnée métier n'est nécessaire.</summary>
|
||
private sealed class FakePageFactory : IPageViewModelFactory
|
||
{
|
||
public ViewModelBase Create(AppPage page) => new PageVide();
|
||
|
||
public ViewModelBase Create(AppPage page, object? parameter) => new PageVide();
|
||
}
|
||
|
||
private sealed class FakeSyncEngine : ISyncEngine
|
||
{
|
||
public Task<SyncCycleResult> PushAsync(CancellationToken cancellationToken = default)
|
||
=> Task.FromResult(new SyncCycleResult());
|
||
|
||
public Task<SyncCycleResult> SyncAsync(CancellationToken cancellationToken = default)
|
||
=> Task.FromResult(new SyncCycleResult());
|
||
}
|
||
|
||
private sealed class FakeOutboxService : IOutboxService
|
||
{
|
||
public Task<Guid> EnqueueAsync(
|
||
string entityType,
|
||
SyncOperationType operationType,
|
||
Guid requestedEntityGuid,
|
||
string payload,
|
||
string? dependencyEntityType = null,
|
||
Guid? dependencyRequestedEntityGuid = null,
|
||
CancellationToken cancellationToken = default)
|
||
=> Task.FromResult(Guid.NewGuid());
|
||
|
||
public Task<int> CountPendingAsync(CancellationToken cancellationToken = default)
|
||
=> Task.FromResult(0);
|
||
|
||
public Task<int> CountNotYetSentAsync(CancellationToken cancellationToken = default)
|
||
=> Task.FromResult(0);
|
||
}
|
||
}
|