diff --git a/Febe.slnx b/Febe.slnx index 62cccd4..38a7235 100644 --- a/Febe.slnx +++ b/Febe.slnx @@ -11,6 +11,7 @@ + diff --git a/docs/decisioni.md b/docs/decisioni.md index 5e2105a..7a5cf79 100644 --- a/docs/decisioni.md +++ b/docs/decisioni.md @@ -244,3 +244,14 @@ Ogni scelta tecnica presa strada facendo, con data e motivo (specifica §15). | 2026-10-20 | Processo in `docs/processo.md`: rami `/` da `main`, commit piccoli in italiano, una richiesta di unione per ramo con il modello di `.gitea/` (comprese le 14 regole di §2), unione con commit di unione e ramo cancellato; `main` protetto con i quattro lavori di `verifica` come controlli richiesti e «blocca se indietro»; tag `v*` protetti; Alberto proprietario di tutto (`CODEOWNERS`) | Decisione di Alberto del 20 ottobre (processo da grande azienda); con il ramo aggiornato il commit di unione ha lo stesso contenuto del commit verificato, quindi in `main` entra solo codice provato. Le approvazioni richieste dipendono da chi apre le richieste (Gitea non conta quella dell'autore): domanda aperta per Alberto | | 2026-10-20 | Nella verifica il lavoro «immagine» viene dopo «prove» e «installatore» (`needs: [prove, installatore]`) | `:main` e `:sha-` devono uscire solo da un commit con tutta la verifica verde, come dice `docs/docker.md`; sull'unico runner i lavori vanno comunque uno alla volta, quindi la durata non cambia. Su un ramo, se l'installatore fallisce l'immagine si salta: la richiesta di unione è già bloccata dall'installatore | | 2026-10-20 | Anche nel rilascio il lavoro «immagine» viene dopo «prove» e «windows» (`needs: [prove, windows]`) | Come nella verifica: `:X.Y.Z` e `:latest` si pubblicano solo se anche la release potrà uscire; prima, con l'installatore rosso, l'immagine usciva senza release | +| 2026-10-20 | Nuovo progetto di prove `tests/Febe.Tests.Windows` (`net10.0-windows`, WPF, solo MSTest e riferimenti ai progetti, nella soluzione): WebView2 vero su un thread STA con un `Dispatcher` di WPF vero, il sito di prova in processo; si compila anche da Linux (`EnableWindowsTargeting`), gira solo su Windows, senza runtime WebView2 è inconcludente | L'errore che bloccava Febe per Windows (14 e 19 ottobre) si vedeva solo con WebView2 vero e un thread dell'interfaccia vero: le prove su Linux con il finto `IWebView2DevTools` non potevano coglierlo | +| 2026-10-20 | `WebView2Host` legge sul thread dell'interfaccia, durante l'avvio, i valori che servono altrove (versione di WebView2, numero del processo del browser) e li espone come valori semplici; nessun membro di un oggetto di WebView2 si legge fuori da quel thread | Causa dell'errore: `Version` leggeva `BrowserVersionString` dell'ambiente da un thread del pool, dopo `ConfigureAwait(false)`, e WebView2 lanciava `InvalidOperationException` | +| 2026-10-20 | Nel ciclo di avvio di `WebView2Browser` si riprova solo l'eccezione dell'avvio stesso: stato e riga «Browser di Febe pronto» stanno fuori dal blocco dei tentativi | La riga del registro, dentro il `try`, trasformava ogni avvio riuscito in un avvio fallito: chiusura del WebView buono e nuovi tentativi per sempre | +| 2026-10-20 | Avvio, ripartenza e arresto di `WebView2Host` uno alla volta (un `SemaphoreSlim` preso sul thread dell'interfaccia); l'arresto aspetta al più 30 s chi è in corso, poi chiude quello che c'è | Ognuno aspetta WebView2 sul thread dell'interfaccia e fra un'attesa e l'altra potevano intrecciarsi (per esempio una ripartenza dopo un arresto del processo e «Scollega»); l'uscita da Febe non deve restare appesa a un avvio che WebView2 non completa | +| 2026-10-20 | Arresto del processo del browser: annunciato solo dopo che il gestore di `ProcessFailed` è tornato e solo per il WebView in uso (numero di generazione); se capita durante un avvio fa fallire quell'avvio; la ripartenza (e quella dopo un «Scollega» la cui ripartenza fallisce) usa gli stessi tentativi del primo avvio, un solo ciclo alla volta sul pool | Modello dei thread di WebView2: niente chiusure né ricreazioni dentro i suoi gestori. Prima: un solo tentativo, poi browser morto fino al riavvio di Febe; dopo «Scollega» restava fermo anche il motore, perché l'errore non era di cartella e `DisconnectAsync` non lo gestiva | +| 2026-10-20 | `WebView2CdpSession.Attach` chiama i gestori di `Reconnected` uno per uno: l'errore di uno va nel registro e non esce da `Attach` (l'avviso resta sincrono) | `Attach` è dentro l'avvio del nuovo WebView: un'eccezione di chi ascolta avrebbe disfatto un avvio riuscito, ancora e ancora | +| 2026-10-20 | La finestra dell'interfaccia apre gli indirizzi esterni nel browser predefinito dopo che il gestore di WebView2 è tornato (in coda sul dispatcher) | La shell di Windows può far girare un ciclo di messaggi suo e WebView2 non regge di essere richiamato dentro i propri gestori | +| 2026-10-20 | Le prove per Windows hanno un `CompressedClock` e un fuso «mezzogiorno» propri, copie di quelli della suite per Linux; `Febe.Desktop` concede gli `internal` a `Febe.Tests.Windows` e `WebView2Host` espone la sua finestra come `internal` (da leggere sul thread dell'interfaccia) | Un progetto di prove non può dipendere dall'altro; la finestra serve alle prove del primo piano e del fuori vista | +| 2026-10-20 | Un solo WebView alla volta in `WebView2Host`: l'avvio, dentro la sezione esclusiva, non fa nulla se un WebView è già collegato, chiude prima i resti di uno morto, e se fallisce chiude da sé ciò che ha creato (il ciclo dei tentativi non chiude più niente da fuori); la ripartenza dopo un arresto del processo usa lo stesso avvio; chiudere un WebView ne cambia la generazione, così i suoi eventi tardivi non contano | Revisione del ramo: un «Scollega» durante i tentativi del primo avvio faceva partire il browser, poi il tentativo in attesa ne apriva un secondo nella stessa finestra senza chiudere il primo. Il processo orfano teneva il profilo: il «Scollega» dopo aspettava 20 s e non cancellava la sessione di Instagram, l'uscita aspettava 15 s a vuoto | +| 2026-10-20 | All'uscita il primo avvio e il ciclo di ripartenza di `WebView2Browser` smettono subito di aspettare WebView2: `WebView2Host.StartAsync` onora il suo token (un avvio non ancora cominciato non comincia, uno in corso finisce da sé e l'arresto chiude ciò che lascia, anche se arriva dopo i 30 s); `WebView2Browser.DisposeAsync` aspetta il ciclo al più 30 s. «Scollega», una volta cominciato, va fino in fondo e resta coperto dai 30 s dell'arresto | Revisione del ramo: il limite di 30 s copriva solo un «Scollega» in corso. `FebeApp` aspetta `RunAsync` prima di chiudere il browser, e `RunAsync` e il ciclo aspettavano WebView2 senza limite; interrompere «Scollega» a metà lascerebbe invece fermo il motore | +| 2026-10-20 | Collegamento, pannello «collegato» senza nome dell'account (subito dopo «Ho finito», prima del primo giro): titolo «Collegato» e sotto «Nome non ancora noto», come il riquadro di stato | Provando a mano su Windows la pagina diceva «Collegato come @»; il mockup 10 mostra solo il caso con il nome | diff --git a/docs/windows.md b/docs/windows.md index c02a64f..a850571 100644 --- a/docs/windows.md +++ b/docs/windows.md @@ -8,10 +8,23 @@ un'applicazione per Windows 10 e 11. La finestra di Febe mostra l'interfaccia; i > rischio per l'account (ritmo umano, tetti, fermo al primo segnale), ma non può azzerarlo. Le storie che Febe apre > risultano viste da te. -> **Stato.** Questa versione è stata costruita e provata su Linux: tutto ciò che non dipende da Windows ha le sue prove -> automatiche, ma **nessuna parte che richiede Windows è ancora stata eseguita su un Windows vero** (finestre, WebView2, -> area di notifica, registro, programma di installazione). Le prove da fare sono in fondo a questa pagina e in -> `docs/prove-dal-vivo.md`, parte C. +> **Stato (20 ottobre 2026).** Con la 0.1.0 il browser di Febe per Windows non diventava mai disponibile, e l'accesso a +> Instagram non poteva nemmeno cominciare: WebView2 partiva, ma subito dopo Febe ne leggeva la versione da un thread +> diverso da quello dell'interfaccia, WebView2 lo rifiutava e Febe, credendo fallito l'avvio, chiudeva il browser e +> riprovava per sempre (nel registro, a ogni tentativo: «WebView2 non parte (InvalidOperationException: +> CoreWebView2Environment members can only be accessed from the UI thread.)»). **È corretto**: su un Windows vero +> (Windows 11 Pro, runtime WebView2 155.0.4283.62) il browser di Febe parte al primo tentativo, in un paio di secondi. +> +> Ora ci sono anche **prove automatiche che girano su Windows**, con WebView2 vero e il sito di prova (mai Instagram): +> S1 con la finestra fuori vista (navigazione, corpi delle risposte, lettura della pagina, scorrimento con la rotella, +> fotogrammi, scaricamenti dal CDN, comandi vietati rifiutati), la finestra che viene in primo piano e torna fuori vista +> con il motore fermo nel frattempo, «Scollega», la ripartenza da sola dopo l'arresto del processo del browser, la +> «composizione» di S2 e una sessione di raccolta intera, con i file che arrivano nella libreria. Vedi «Prove +> automatiche su Windows», più sotto. +> +> **Restano da provare a mano** (parte C di `docs/prove-dal-vivo.md`): l'installazione su un Windows pulito, S2 con la +> finestra di Febe ridotta a icona e con lo schermo bloccato, S3 (il collegamento che sopravvive a «Esci» e al riavvio di +> Windows), area di notifica, notifiche, avvio con il computer, e l'accesso vero a Instagram. ## Che cosa serve @@ -173,9 +186,18 @@ della specifica (§6.6); si sceglie con `--browser` e la scelta resta: che lo chiude insieme a Febe.exe, anche se Febe si chiude all'improvviso o da Gestione attività: un Edge rimasto aperto terrebbe la porta 9222 e il browser di Febe non ripartirebbe più. +Come tutti gli oggetti di WebView2, ambiente, controllo, pagina e ricevitori degli eventi DevTools vivono sul thread +dell'interfaccia: Febe li tocca solo da lì (i comandi del motore arrivano da altri thread e ci passano attraverso il +dispatcher di WPF), e il resto del programma legge solo valori semplici presi durante l'avvio, come la versione per il +registro. Se il processo del browser si chiude da solo, Febe lo fa ripartire con lo stesso profilo e con gli stessi +tentativi del primo avvio (5, 15, 30, 60 secondi, poi ogni 5 minuti), e lo stesso se dopo «Scollega» non ripartisse. +Nella finestra c'è sempre un solo browser: se «Scollega» lo fa ripartire mentre il primo avvio aspetta il prossimo +tentativo, quel tentativo lo trova già in funzione e non ne apre un secondo. + Le prove da fare su un Windows vero, con la procedura esatta, sono in `docs/prove-dal-vivo.md`, **parte C**. In breve: -- **S1** — con il sito di prova: una sessione intera (gesti, corpo delle risposte, scaricamenti) e l'anteprima di Attività. +- **S1** — con il sito di prova: una sessione intera (gesti, corpo delle risposte, scaricamenti) e l'anteprima di + Attività. La parte che non dipende dall'installazione è già una prova automatica su Windows (sotto). - **S2** — la stessa sessione con il browser fuori vista, con la finestra di Febe ridotta a icona e con lo schermo bloccato; poi, se serve, `composizione` e `edge`. - **S3** — accesso a mano, «Esci», riapertura, riavvio di Windows: il collegamento deve restare. @@ -207,11 +229,42 @@ L'icona `src/Febe.Desktop/Febe.ico` (16, 24, 32, 48, 64, 128 e 256 pixel) è dis SkiaSharp e scritta a mano: per rigenerarla dopo un cambio del marchio, `FEBE_RIGENERA_ICONA=1 dotnet test tests/Febe.Tests --filter IconTests`. +## Prove automatiche su Windows + +`tests/Febe.Tests.Windows` contiene le prove che hanno bisogno di Windows e di WebView2 vero. Si compila anche da Linux +(la CI compila tutta la soluzione), ma gira solo su Windows, con il .NET SDK 10 e il runtime WebView2; dove il runtime +manca le prove risultano inconcludenti, non rosse: + +```sh +dotnet test tests/Febe.Tests.Windows +dotnet test tests/Febe.Tests.Windows --filter "FullyQualifiedName~WebView2CdpTests" # una classe sola +``` + +Ogni prova crea un thread dell'interfaccia di WPF vero (come quello di `Febe.exe`), il proprio sito di prova su porte +libere di 127.0.0.1 (il suo «CDN» su 127.0.0.2) e cartelle temporanee in `%TEMP%`: niente tocca la cartella dei dati né +la libreria vere. La finestra «Browser di Febe» resta fuori dallo schermo, tranne in due prove che la portano in primo +piano per un attimo: una prova il primo piano da solo, l'altra il percorso intero di «Accedi a Instagram» e «Ho finito». +Una prova chiude, con il suo numero di processo, il processo del browser che lei stessa ha avviato, per vedere Febe +farlo ripartire. Tutte insieme durano due o tre minuti, quasi tutti della sessione di raccolta. + +| Classe | Che cosa prova | +|---|---| +| `WebView2BrowserStartTests` | Avviato da un thread del pool, come fa la composizione, il browser è pronto al primo tentativo e il registro dice «Browser di Febe pronto: WebView2 …» (l'errore del 14 ottobre) | +| `WebView2LifecycleTests` | Un avvio che fallisce davvero si riprova e poi va; primo piano e fuori vista con il permesso di guida; «Scollega»; «Scollega» mentre il primo avvio aspetta di riprovare (un solo browser nella finestra, il «Scollega» dopo riesce subito); «Esci» mentre l'avvio non si completa (non lo aspetta); ripartenza dopo l'arresto del processo; «composizione» di S2 | +| `WebView2CdpTests` | S1: i comandi dell'elenco su WebView2 contro il sito di prova, con la finestra fuori vista, e i comandi vietati rifiutati | +| `WebView2CollectionTests` | Una sessione vera della composizione (`FebeApp` con `DesktopPlatform`) su WebView2: i file arrivano nella libreria | +| `WebView2ConnectionTests` | Il collegamento dal servizio vero della composizione: «Accedi a Instagram» porta in primo piano la finestra con la pagina di accesso (del sito di prova), «Ho finito» trova la sessione e la rimette fuori vista, «Scollega» cancella il profilo e il motore riparte | + +Quello che di `WebView2CdpSession` non chiede Windows (per esempio: un errore di chi ascolta la ripartenza non disfa +l'avvio) si prova invece in `tests/Febe.Tests/Desktop/WebView2CdpSessionTests.cs`, con un finto WebView2: gira anche +sulla CI per Linux. + ## Problemi comuni | Che cosa vedi | Che cosa fare | |---|---| | All'avvio: «Manca il runtime WebView2 di Microsoft» | Installa il runtime dalla pagina ufficiale (il messaggio offre di aprirla), poi riapri Febe | +| Nel registro, a ogni tentativo: «WebView2 non parte (InvalidOperationException: CoreWebView2Environment members can only be accessed from the UI thread.)»; «Accedi a Instagram» risponde che il browser di Febe non è in funzione | È l'errore della 0.1.0: il browser di Febe non diventava mai disponibile. Installa una versione successiva alla 0.1.0 | | «La cartella dei dati è su un disco di rete» o «non può scrivere» | Riapri Febe con una cartella dei dati su un disco locale (`--dati`), oppure libera la cartella | | Aprendo Febe si porta solo in primo piano la finestra già aperta | È voluto: un solo Febe per cartella dei dati. Per fermarlo: menu dell'icona ▸ Esci | | Il collegamento risulta perso dopo un riavvio | È l'ipotesi S3: riferiscilo (parte C di `docs/prove-dal-vivo.md`) con l'ora e il registro di quel giorno | diff --git a/src/Febe.Browser/WebView2/WebView2CdpSession.cs b/src/Febe.Browser/WebView2/WebView2CdpSession.cs index 5f641ed..80f3fd2 100644 --- a/src/Febe.Browser/WebView2/WebView2CdpSession.cs +++ b/src/Febe.Browser/WebView2/WebView2CdpSession.cs @@ -113,7 +113,7 @@ public sealed class WebView2CdpSession : ICdpSession, ICdpConnectionEvents, IAsy _log.Write(BrowserLogLevel.Debug, "CDP: WebView2 collegato."); if (reconnect) { - Reconnected?.Invoke(this, EventArgs.Empty); + RaiseReconnected(); } } @@ -275,6 +275,31 @@ public sealed class WebView2CdpSession : ICdpSession, ICdpConnectionEvents, IAsy return JsonElement.ParseValue(ref reader); } + /// + /// , on the thread of (WebView2's UI thread), one handler at a time: an + /// error of a handler is logged and never reaches , so it cannot undo the start of the new + /// WebView that called it. Handlers only queue their work (re-enabling a domain is a command, never sent from here). + /// + private void RaiseReconnected() + { + if (Reconnected is not { } handlers) + { + return; + } + + foreach (var handler in handlers.GetInvocationList().Cast()) + { + try + { + handler(this, EventArgs.Empty); + } + catch (Exception ex) when (ex is not OutOfMemoryException) + { + _log.Write(BrowserLogLevel.Warning, "CDP: errore in chi ascolta il nuovo collegamento con WebView2.", ex); + } + } + } + private IDisposable SubscribeNative(IWebView2DevTools devTools, string eventName) => devTools.Subscribe(eventName, json => _events.Writer.TryWrite(new QueuedEvent(eventName, json ?? string.Empty, null))); diff --git a/src/Febe.Desktop/Browser/WebView2Browser.cs b/src/Febe.Desktop/Browser/WebView2Browser.cs index f717b11..36c8405 100644 --- a/src/Febe.Desktop/Browser/WebView2Browser.cs +++ b/src/Febe.Desktop/Browser/WebView2Browser.cs @@ -12,16 +12,31 @@ namespace Febe.Desktop.Browser; /// /// The browser of Instagram on Windows as the shared composition sees it (): a /// started with retries like starts Chromium, started again -/// when its browser process goes away, and emptied by «Scollega» (spec §4.1) once WebView2 has closed. +/// (with the same retries) when its browser process goes away, and emptied by «Scollega» (spec §4.1) once WebView2 has +/// closed. /// +/// +/// Only a failed start is retried: what follows a start that worked (the log line, the state) is outside the retries, +/// and reads only plain values of the host, never WebView2 objects — this class runs on the threads of the composition, +/// while every WebView2 object lives on the UI thread (the error of 14 October 2026: the version of WebView2 read here, +/// on a thread-pool thread, threw after every successful start, and the start was undone and retried for ever). +/// internal sealed class WebView2Browser : IFebeBrowser { private static readonly TimeSpan[] Retry = [TimeSpan.FromSeconds(5), TimeSpan.FromSeconds(15), TimeSpan.FromSeconds(30), TimeSpan.FromMinutes(1), TimeSpan.FromMinutes(5)]; + /// How long stopping waits for the restart loop to end before closing WebView2 anyway. + private static readonly TimeSpan StopWait = TimeSpan.FromSeconds(30); + private readonly WebView2BrowserSettings _settings; private readonly FebePlatformContext _context; private readonly IClock _wallClock; private readonly BrowserOptions _options; + private readonly CancellationTokenSource _lifetime = new(); + private readonly Lock _gate = new(); + private Task? _restartLoop; + private bool _restartWanted; + private Exception? _restartFailure; private volatile bool _started; private volatile string? _lastError; @@ -39,7 +54,7 @@ internal sealed class WebView2Browser : IFebeBrowser ui, new WebView2HostOptions(settings.Hosting, settings.AdditionalBrowserArguments, icon, () => context.Tracker.MarkUsed(context.Clock.Now)), context.Log); - Host.BrowserProcessFailed += (_, _) => _ = RecoverAsync(); + Host.BrowserProcessFailed += (_, _) => RequestRestart(null); } /// The host: window «Browser di Febe», WebView2, CDP. @@ -63,35 +78,10 @@ internal sealed class WebView2Browser : IFebeBrowser public async Task RunAsync(CancellationToken ct) { - for (var attempt = 0; !ct.IsCancellationRequested; attempt++) + using var stop = CancellationTokenSource.CreateLinkedTokenSource(ct, _lifetime.Token); + if (await StartWithRetriesAsync(token => Host.StartAsync(_options, token), stop.Token).ConfigureAwait(false)) { - try - { - await Host.StartAsync(_options, ct).ConfigureAwait(false); - _started = true; - _lastError = null; - _context.Log.Info("browser", $"Browser di Febe pronto: WebView2 {Host.Version}, pagina {WindowWidth.ToString(CultureInfo.InvariantCulture)}×{WindowHeight.ToString(CultureInfo.InvariantCulture)}, {BrowserHostingNames.Name(_settings.Hosting)}, fuori vista."); - return; - } - catch (OperationCanceledException) when (ct.IsCancellationRequested) - { - return; - } - catch (Exception ex) when (ex is not OutOfMemoryException) - { - _lastError = $"WebView2 non parte ({ex.GetType().Name}: {FirstLine(ex.Message)})."; - var wait = Retry[Math.Min(attempt, Retry.Length - 1)]; - _context.Log.Error("browser", $"{_lastError} Nuovo tentativo fra {wait.TotalSeconds.ToString("0", CultureInfo.InvariantCulture)} s."); - await Host.ResetAsync().ConfigureAwait(false); - try - { - await _wallClock.Delay(wait, ct).ConfigureAwait(false); - } - catch (OperationCanceledException) - { - return; - } - } + _context.Log.Info("browser", ReadyMessage("Browser di Febe pronto")); } } @@ -101,56 +91,218 @@ internal sealed class WebView2Browser : IFebeBrowser public Task HideFromUserAsync(CancellationToken ct) => Host.HideFromUserAsync(); - /// «Scollega»: WebView2 closes and its process exits, Dati\browser is deleted, the browser starts empty. + /// + /// «Scollega»: WebView2 closes and its process exits, Dati\browser is deleted, the browser starts empty. When + /// the profile cannot be deleted completely an says so (the browser starts again anyway); + /// when WebView2 does not start again, the same retries as at start-up bring it back in the background, and + /// «Scollega» has still done its part (the connection service starts the engine again either way). + /// public async Task RestartWithEmptyProfileAsync(CancellationToken ct) { + Exception? deletion = null; + async Task DeleteProfileQuietlyAsync() + { + try + { + await DeleteProfileAsync().ConfigureAwait(true); + } + catch (Exception ex) when (ex is IOException or UnauthorizedAccessException) + { + deletion = ex; + } + } + + var restarted = false; try { - await Host.RestartAsync(DeleteProfileAsync, ct).ConfigureAwait(false); + await Host.RestartAsync(DeleteProfileQuietlyAsync, ct).ConfigureAwait(false); + MarkStarted(); + restarted = true; } - catch (Exception ex) when (ex is IOException or UnauthorizedAccessException) + catch (Exception ex) when (ex is not (OutOfMemoryException or ObjectDisposedException)) { - throw new IOException($"La cartella del browser ({ProfileDirectory}) non si è potuta cancellare del tutto: esci da Febe e cancellala tu, contiene la sessione di Instagram.", ex); + // The start that follows the deletion failed: never a dead browser after «Scollega». + RequestRestart(ex); } - _context.Log.Info("browser", "Profilo del browser cancellato; il browser è ripartito vuoto."); + if (deletion is not null) + { + throw new IOException($"La cartella del browser ({ProfileDirectory}) non si è potuta cancellare del tutto: esci da Febe e cancellala tu, contiene la sessione di Instagram.", deletion); + } + + _context.Log.Info("browser", restarted + ? "Profilo del browser cancellato; il browser è ripartito vuoto." + : "Profilo del browser cancellato; il browser ripartirà vuoto."); } - public ValueTask DisposeAsync() => Host.DisposeAsync(); - - /// The browser process of WebView2 went away by itself: it starts again with the same profile. - private async Task RecoverAsync() + /// + /// Stops the retries, waits for the restart loop to notice (it stops waiting for WebView2 as soon as + /// _lifetime is cancelled; at most in any case), then closes WebView2 and its window. + /// _lifetime stays undisposed on purpose: a late caller may still read its (cancelled) token. + /// + public async ValueTask DisposeAsync() { + await _lifetime.CancelAsync().ConfigureAwait(false); + Task? restarting; + lock (_gate) + { + restarting = _restartLoop; + } + + if (restarting is not null) + { + try + { + await restarting.WaitAsync(StopWait).ConfigureAwait(false); + } + catch (TimeoutException) + { + _context.Log.Warn("browser", "WebView2: la ripartenza del browser non si è fermata in tempo; Febe si chiude lo stesso."); + } + } + + await Host.DisposeAsync().ConfigureAwait(false); + } + + /// + /// Runs until it works (true) or is cancelled (false), waiting + /// between attempts. With the first attempt already failed with it. + /// Only an exception of the start itself is a failed start; this method never throws. + /// + private async Task StartWithRetriesAsync(Func start, CancellationToken ct, Exception? failedFirst = null) + { + var attempt = 0; + if (failedFirst is not null && !await AfterFailedStartAsync(failedFirst, attempt++, ct).ConfigureAwait(false)) + { + return false; + } + + while (!ct.IsCancellationRequested) + { + try + { + await start(ct).ConfigureAwait(false); + } + catch (Exception ex) when (ct.IsCancellationRequested && ex is (OperationCanceledException or ObjectDisposedException)) + { + return false; + } + catch (Exception ex) when (ex is not OutOfMemoryException) + { + if (!await AfterFailedStartAsync(ex, attempt++, ct).ConfigureAwait(false)) + { + return false; + } + + continue; + } + + MarkStarted(); + return true; + } + + return false; + } + + /// + /// A start failed: it is said, and the next attempt waits. False when cancelled. What the failed start created it + /// closed itself, inside the host: a close from here could catch a browser that «Scollega» started meanwhile. + /// + private async Task AfterFailedStartAsync(Exception error, int attempt, CancellationToken ct) + { + var wait = Retry[Math.Min(attempt, Retry.Length - 1)]; + _lastError = $"WebView2 non parte ({error.GetType().Name}: {FirstLine(error.Message)})."; + _context.Log.Error("browser", $"{_lastError} Nuovo tentativo fra {wait.TotalSeconds.ToString("0", CultureInfo.InvariantCulture)} s."); try { - await Host.RestartAsync(null, CancellationToken.None).ConfigureAwait(false); - _context.Log.Info("browser", "Browser di Febe ripartito dopo l'arresto del suo processo."); + await _wallClock.Delay(wait, ct).ConfigureAwait(false); + return true; } - catch (Exception ex) when (ex is not OutOfMemoryException) + catch (OperationCanceledException) { - _started = false; - _lastError = $"WebView2 non riparte ({ex.GetType().Name})."; - _context.Log.Error("browser", _lastError); + return false; } } - /// Deletes the profile; a process of WebView2 may still hold a file for a moment. + private void MarkStarted() + { + _started = true; + _lastError = null; + } + + /// + /// The browser must start again (its process went away by itself, or the start after «Scollega» failed with + /// ): one loop at a time starts it, with the retries of the first start, on the thread + /// pool — never inside an event handler of WebView2. A request that comes while the loop runs makes it go round + /// again. The loop only starts what is not running: when another way in (the first start, «Scollega») brought the + /// browser back first, its attempt finds it running and is done. + /// + private void RequestRestart(Exception? failure) + { + lock (_gate) + { + if (_lifetime.IsCancellationRequested) + { + return; + } + + _restartWanted = true; + _restartFailure ??= failure; + _restartLoop ??= Task.Run(RestartLoopAsync); + } + } + + private async Task RestartLoopAsync() + { + while (true) + { + Exception? failure; + lock (_gate) + { + if (!_restartWanted || _lifetime.IsCancellationRequested) + { + _restartLoop = null; + return; + } + + _restartWanted = false; + failure = _restartFailure; + _restartFailure = null; + } + + if (await StartWithRetriesAsync(token => Host.StartAsync(_options, token), _lifetime.Token, failure).ConfigureAwait(false)) + { + _context.Log.Info("browser", ReadyMessage("Browser di Febe ripartito")); + } + } + } + + /// Plain values only (the version was read on the UI thread during the start). + private string ReadyMessage(string what) => + $"{what}: WebView2 {Host.Version ?? "di versione sconosciuta"}, pagina {WindowWidth.ToString(CultureInfo.InvariantCulture)}×{WindowHeight.ToString(CultureInfo.InvariantCulture)}, {BrowserHostingNames.Name(_settings.Hosting)}, fuori vista."; + + /// + /// Deletes the profile — off the UI thread, it can be large — retrying while a process of WebView2 still holds a + /// file for a moment. + /// private async Task DeleteProfileAsync() { for (var attempt = 0; ; attempt++) { try { - if (Directory.Exists(ProfileDirectory)) + await Task.Run(() => { - Directory.Delete(ProfileDirectory, recursive: true); - } - + if (Directory.Exists(ProfileDirectory)) + { + Directory.Delete(ProfileDirectory, recursive: true); + } + }).ConfigureAwait(true); return; } catch (Exception ex) when ((ex is IOException or UnauthorizedAccessException) && attempt < 10) { - await Task.Delay(500).ConfigureAwait(true); + await _wallClock.Delay(TimeSpan.FromMilliseconds(500), CancellationToken.None).ConfigureAwait(true); } } } diff --git a/src/Febe.Desktop/Browser/WebView2Host.cs b/src/Febe.Desktop/Browser/WebView2Host.cs index 22d4b95..51db2fc 100644 --- a/src/Febe.Desktop/Browser/WebView2Host.cs +++ b/src/Febe.Desktop/Browser/WebView2Host.cs @@ -1,3 +1,4 @@ +using System.Runtime.ExceptionServices; using System.Runtime.InteropServices; using System.Windows.Media; using System.Windows.Threading; @@ -35,27 +36,49 @@ internal sealed record WebView2HostOptions(BrowserHosting Hosting, string Additi /// «Ho finito»; using and closing it marks the browser as used for «Riprendi». /// Stopping closes the WebView and waits for its browser process to exit, so the session is on disk (S3); /// («Scollega») does the same before deleting the profile. -/// Every WebView2 call runs on the UI thread through its dispatcher. +/// Threads: every WebView2 object (environment, controller, CoreWebView2, its settings and DevTools +/// receivers) and the window are touched only on the UI thread, through its dispatcher; WebView2 throws on any other +/// thread. Callers on other threads (the composition, the engine) get only plain values captured on the UI thread +/// during the start (, ), the CDP session, and tasks. Start, +/// restart and stop run one at a time. +/// One WebView at a time, whoever starts it (the first start and its retries, «Scollega», the start after a +/// crash): a start finds the WebView running and does nothing, closes what a dead one left before creating a new one, +/// and when it fails it closes what it created itself. Events of a closed WebView never count. /// /// internal sealed class WebView2Host : IBrowserHost { private static readonly TimeSpan ExitWait = TimeSpan.FromSeconds(15); + /// How long stopping waits for a start or restart in progress before closing what there is. + private static readonly TimeSpan StopWait = TimeSpan.FromSeconds(30); + private readonly Dispatcher _ui; private readonly WebView2HostOptions _settings; private readonly FebeLog _log; private readonly WebView2CdpSession _session; + + // Start, restart and dispose each await WebView2 on the UI thread: without this they could interleave there. + private readonly SemaphoreSlim _lifecycle = new(1, 1); + + // The fields below are touched on the UI thread only. private BrowserOptions? _options; private BrowserWindow? _window; private CoreWebView2Environment? _environment; private CoreWebView2Controller? _controller; + private CoreWebView2? _core; private CompositionHost? _composition; private CoreWebView2DevTools? _devTools; private TaskCompletionSource? _exited; private IDisposable? _lease; + private int _generation; + private bool _starting; + private bool _crashedWhileStarting; private bool _closing; - private bool _restarting; + + // Plain values read on the UI thread during the start: any thread may read them. + private volatile string? _version; + private int _browserProcessId; public WebView2Host(Dispatcher ui, WebView2HostOptions settings, FebeLog log) { @@ -79,18 +102,41 @@ internal sealed class WebView2Host : IBrowserHost /// True while a WebView is attached (commands can be sent). public bool IsAttached => _session.IsAttached; - /// The version of the WebView2 runtime in use (for the log). - public string? Version => _environment?.BrowserVersionString; + /// + /// The version of the WebView2 runtime of the browser in use (for the log), read on the UI thread when it started; + /// null before the first start. Any thread: it is a plain value, never a member of a WebView2 object. + /// + public string? Version => _version; - /// Raised on the UI thread when the browser process of WebView2 went away by itself (the owner restarts). + /// The browser process of WebView2 when it last started (0 before the first start). Any thread. + public int BrowserProcessId => Volatile.Read(ref _browserProcessId); + + /// The window «Browser di Febe» (null before the first start). UI thread only, like every WPF object. + internal BrowserWindow? Window => _window; + + /// + /// Raised on the UI thread when the browser process of WebView2 went away by itself (the owner restarts), after the + /// handler of WebView2's own event has returned: WebView2 does not support closing and recreating inside it. + /// public event EventHandler? BrowserProcessFailed; - /// Creates the window (once), the environment and the controller, and attaches the CDP session. + /// + /// Creates the window (once), the environment and the controller, and attaches the CDP session — unless a WebView + /// is already running, because another way in started it («Scollega», the start after a crash): then it does nothing + /// and the start counts as done. A failed start leaves nothing open. When is cancelled (Febe + /// is exiting) the caller stops waiting at once, even while WebView2 has not answered: a start not yet begun does not + /// begin, one under way on the UI thread ends by itself, and stopping closes what it leaves. + /// public Task StartAsync(BrowserOptions options, CancellationToken ct) { ArgumentNullException.ThrowIfNull(options); _options = options; - return OnUiAsync(StartCoreAsync); + var start = OnUiAsync(() => ExclusiveAsync(() => + { + ct.ThrowIfCancellationRequested(); + return StartCoreAsync(); + })); + return UntilCancelledAsync(start, ct); } public Task ShowToUserAsync() => OnUiAsync(() => @@ -104,8 +150,18 @@ internal sealed class WebView2Host : IBrowserHost window.Activate(); window.Topmost = true; window.Topmost = false; - _controller?.MoveFocus(CoreWebView2MoveFocusReason.Programmatic); + + // The lease first: once the window is on screen the engine must be still, whatever happens to the focus. TakeLease(); + try + { + _controller?.MoveFocus(CoreWebView2MoveFocusReason.Programmatic); + } + catch (Exception ex) when (ex is COMException or InvalidOperationException) + { + // The browser process is gone (it is starting again): the window is on screen anyway. + } + return Task.CompletedTask; }); @@ -119,55 +175,50 @@ internal sealed class WebView2Host : IBrowserHost /// /// Closes the WebView, waits for its browser process to exit (the profile is free and written), runs /// — «Scollega» deletes the profile there — and starts it again. - /// stays the same object. The browser starts again even when fails; its error is - /// thrown afterwards. + /// stays the same object. The browser starts again even when fails with an + /// or ; that error is thrown afterwards. A failed + /// start throws its own error and, like a failed , leaves nothing open. Once begun it goes + /// to the end whatever says (the profile with the Instagram session must go, and the engine + /// starts again after it); stopping waits for it at most . /// - public Task RestartAsync(Func? whileStopped, CancellationToken ct) => OnUiAsync(async () => + public Task RestartAsync(Func? whileStopped, CancellationToken ct) => OnUiAsync(() => ExclusiveAsync(async () => { - _restarting = true; - try + ObjectDisposedException.ThrowIf(_closing, this); + Exception? failure = null; + await CloseWebViewAsync().ConfigureAwait(true); + if (whileStopped is not null) { - await CloseWebViewAsync().ConfigureAwait(true); - Exception? failure = null; try { - if (whileStopped is not null) - { - await whileStopped().ConfigureAwait(true); - } + await whileStopped().ConfigureAwait(true); } catch (Exception ex) when (ex is IOException or UnauthorizedAccessException) { failure = ex; } - - await StartCoreAsync().ConfigureAwait(true); - if (failure is not null) - { - throw failure; - } } - finally + + await StartCoreAsync().ConfigureAwait(true); + if (failure is not null) { - _restarting = false; + ExceptionDispatchInfo.Throw(failure); } - }); - - /// Closes what a failed start left, so that the next start begins clean. - public Task ResetAsync() => OnUiAsync(CloseWebViewAsync); + })); public async ValueTask DisposeAsync() { try { - await OnUiAsync(async () => - { - _closing = true; - ReleaseLease(); - await CloseWebViewAsync().ConfigureAwait(true); - _window?.CloseForGood(); - _window = null; - }).ConfigureAwait(false); + await OnUiAsync(() => ExclusiveAsync( + async () => + { + _closing = true; + ReleaseLease(); + await CloseWebViewAsync().ConfigureAwait(true); + _window?.CloseForGood(); + _window = null; + }, + StopWait)).ConfigureAwait(false); } catch (Exception ex) when (ex is InvalidOperationException or TaskCanceledException) { @@ -177,9 +228,71 @@ internal sealed class WebView2Host : IBrowserHost await _session.DisposeAsync().ConfigureAwait(false); } + /// True while a WebView is in the window and attached to the session (its browser process did not die). + private bool IsRunning => _controller is not null && _session.IsAttached; + + /// + /// UI thread, one at a time (): the only place a WebView is created, so the window never + /// holds two. A WebView already running stays (the start is done); what a dead one left is closed first; a failed + /// start closes what it created. + /// private async Task StartCoreAsync() { + _ui.VerifyAccess(); + ObjectDisposedException.ThrowIf(_closing, this); var options = _options ?? throw new InvalidOperationException("Opzioni del browser mancanti."); + + // Started already, by «Scollega» or by the start after a crash, while this start waited for its turn or for its + // next attempt: a second WebView would orphan the first, whose browser process then holds the profile. + if (IsRunning) + { + return; + } + + // A WebView whose browser process died (the session is detached) is closed before the new one exists. + await CloseWebViewAsync().ConfigureAwait(true); + _starting = true; + _crashedWhileStarting = false; + try + { + await CreateWebViewAsync(options).ConfigureAwait(true); + + // The browser process went away while the start awaited WebView2: this start failed, the caller retries. + if (_crashedWhileStarting) + { + throw new InvalidOperationException("Il processo del browser WebView2 si è chiuso durante l'avvio."); + } + + // Stopping gave up waiting for this start (WebView2 took longer than StopWait) and closed what there was: + // what this start created goes too. + ObjectDisposedException.ThrowIf(_closing, this); + } + catch (Exception ex) when (ex is not OutOfMemoryException) + { + // Nothing stays open after a failed start, whoever retries it and whenever: here, inside the same step. + await CloseAfterFailedStartAsync().ConfigureAwait(true); + throw; + } + finally + { + _starting = false; + } + } + + private async Task CloseAfterFailedStartAsync() + { + try + { + await CloseWebViewAsync().ConfigureAwait(true); + } + catch (Exception ex) when (ex is not OutOfMemoryException) + { + _log.Warn("browser", "WebView2: quello che l'avvio non riuscito ha lasciato aperto non si è chiuso del tutto.", ex); + } + } + + private async Task CreateWebViewAsync(BrowserOptions options) + { if (_window is null) { var window = new BrowserWindow(options.WindowWidth, options.WindowHeight, _settings.Icon); @@ -196,24 +309,31 @@ internal sealed class WebView2Host : IBrowserHost var profile = Path.GetFullPath(options.ProfileDirectory); Directory.CreateDirectory(profile); var environmentOptions = new CoreWebView2EnvironmentOptions { AdditionalBrowserArguments = _settings.AdditionalBrowserArguments }; - _environment = await CoreWebView2Environment.CreateAsync(null, profile, environmentOptions).ConfigureAwait(true); + var environment = await CoreWebView2Environment.CreateAsync(null, profile, environmentOptions).ConfigureAwait(true); + _environment = environment; _exited = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously); - _environment.BrowserProcessExited += OnBrowserProcessExited; + environment.BrowserProcessExited += OnBrowserProcessExited; + + // Read here, on the UI thread, for the log line the composition writes from another thread: a member of the + // environment read there throws «CoreWebView2Environment members can only be accessed from the UI thread». + _version = environment.BrowserVersionString; var hwnd = _window.Handle; + CoreWebView2Controller controller; if (_settings.Hosting == BrowserHosting.Composition) { - var composition = await _environment.CreateCoreWebView2CompositionControllerAsync(hwnd).ConfigureAwait(true); + var composition = await environment.CreateCoreWebView2CompositionControllerAsync(hwnd).ConfigureAwait(true); + controller = composition; + _controller = controller; _composition = new CompositionHost(hwnd, () => _window?.PageBounds ?? default); _composition.Attach(composition); - _controller = composition; } else { - _controller = await _environment.CreateCoreWebView2ControllerAsync(hwnd).ConfigureAwait(true); + controller = await environment.CreateCoreWebView2ControllerAsync(hwnd).ConfigureAwait(true); + _controller = controller; } - var controller = _controller; controller.BoundsMode = CoreWebView2BoundsMode.UseRawPixels; controller.Bounds = _window.PageBounds; @@ -221,6 +341,8 @@ internal sealed class WebView2Host : IBrowserHost controller.IsVisible = true; var core = controller.CoreWebView2; + _core = core; + Volatile.Write(ref _browserProcessId, unchecked((int)core.BrowserProcessId)); var s = core.Settings; s.IsPasswordAutosaveEnabled = false; s.IsGeneralAutofillEnabled = false; @@ -228,11 +350,14 @@ internal sealed class WebView2Host : IBrowserHost s.IsZoomControlEnabled = false; s.IsPinchZoomEnabled = false; s.IsSwipeNavigationEnabled = false; + + // Events of an earlier WebView (closed, or crashed) must not act on this one. + var generation = ++_generation; core.NewWindowRequested += OnNewWindowRequested; core.DownloadStarting += (_, e) => e.Cancel = true; core.PermissionRequested += (_, e) => e.State = CoreWebView2PermissionState.Deny; core.SourceChanged += (_, _) => _window?.ShowAddress(Addresses.WithoutQuery(core.Source)); - core.ProcessFailed += OnProcessFailed; + core.ProcessFailed += (sender, e) => OnProcessFailed(generation, sender, e); core.Navigate(CdpPageExtensions.RestUrl); _devTools = new CoreWebView2DevTools(_ui, core); @@ -240,19 +365,37 @@ internal sealed class WebView2Host : IBrowserHost await _session.SendAsync("Page.enable", null, CancellationToken.None).ConfigureAwait(true); } - /// Closes the controller and waits for the browser process to exit (the profile is written). UI thread. + /// + /// Closes the controller and waits for the browser process to exit (the profile is written). UI thread. From here on + /// the events of the WebView being closed belong to an old generation: they change nothing. + /// private async Task CloseWebViewAsync() { + _ui.VerifyAccess(); + _generation++; _session.Detach(); _devTools?.Close(); _devTools = null; + _core = null; var exited = _exited; + if (_composition is { } composition) + { + _composition = null; + try + { + composition.Dispose(); + } + catch (Exception ex) when (ex is COMException or InvalidOperationException) + { + // The visual tree goes with the window. + } + } + if (_controller is { } controller) { _controller = null; try { - _composition?.Dispose(); controller.Close(); } catch (Exception ex) when (ex is COMException or InvalidOperationException) @@ -260,7 +403,6 @@ internal sealed class WebView2Host : IBrowserHost // The browser process is already gone (it crashed): nothing left to close. } - _composition = null; if (exited is not null) { await Task.WhenAny(exited.Task, Task.Delay(ExitWait)).ConfigureAwait(true); @@ -276,24 +418,42 @@ internal sealed class WebView2Host : IBrowserHost private void OnBrowserProcessExited(object? sender, CoreWebView2BrowserProcessExitedEventArgs e) => _exited?.TrySetResult(); - private void OnProcessFailed(object? sender, CoreWebView2ProcessFailedEventArgs e) + private void OnProcessFailed(int generation, object? sender, CoreWebView2ProcessFailedEventArgs e) { - _log.Warn("browser", $"WebView2: processo terminato ({e.ProcessFailedKind})."); - if (_closing || _restarting) + var kind = e.ProcessFailedKind; + _log.Warn("browser", $"WebView2: processo terminato ({kind})."); + + // A WebView that is closing, closed or replaced is not ours any more (a restart, «Scollega», a failed start). + if (_closing || generation != _generation) { return; } - if (e.ProcessFailedKind == CoreWebView2ProcessFailedKind.BrowserProcessExited) + // During a start the failure is the start's own error: the start closes what it created and the caller retries. + if (_starting) { - // The whole browser is gone: the owner starts it again (same profile), as the supervisor does with Chromium. - _session.Detach(); - BrowserProcessFailed?.Invoke(this, EventArgs.Empty); + _crashedWhileStarting |= kind == CoreWebView2ProcessFailedKind.BrowserProcessExited; + return; } - else if (e.ProcessFailedKind is CoreWebView2ProcessFailedKind.RenderProcessExited or CoreWebView2ProcessFailedKind.RenderProcessUnresponsive) + + if (kind == CoreWebView2ProcessFailedKind.BrowserProcessExited) + { + // The whole browser is gone: commands fail from now on, and the owner starts it again (same profile), as + // the supervisor does with Chromium — once this handler has returned (threading model of WebView2). + _session.Detach(); + _ = _ui.InvokeAsync(() => BrowserProcessFailed?.Invoke(this, EventArgs.Empty), DispatcherPriority.Background); + } + else if (kind is CoreWebView2ProcessFailedKind.RenderProcessExited or CoreWebView2ProcessFailedKind.RenderProcessUnresponsive) { // The page crashed: back to the rest page (spec §6.1); a running recipe ends on its own errors. - (sender as CoreWebView2)?.Navigate(CdpPageExtensions.RestUrl); + try + { + (sender as CoreWebView2)?.Navigate(CdpPageExtensions.RestUrl); + } + catch (Exception ex) when (ex is COMException or InvalidOperationException) + { + // The browser went with the page: its own ProcessFailed follows. + } } } @@ -331,19 +491,40 @@ internal sealed class WebView2Host : IBrowserHost private void UserNavigation(Action action, Func allowed) { // «Indietro» and «Ricarica» of the bar are Alberto's own navigation (rule 7): never an engine action. - if (_controller?.CoreWebView2 is { } core && allowed(core)) + if (_core is not { } core) { - TakeLease(); - action(core); + return; + } + + try + { + if (allowed(core)) + { + TakeLease(); + action(core); + } + } + catch (Exception ex) when (ex is COMException or InvalidOperationException) + { + // The browser process is gone (it is starting again): the button does nothing. } } private void UpdateBounds() { - if (_controller is { } controller && _window is { } window) + if (_controller is not { } controller || _window is not { } window) + { + return; + } + + try { controller.Bounds = window.PageBounds; } + catch (Exception ex) when (ex is COMException or InvalidOperationException) + { + // The browser process is gone: the next start sizes the new WebView. + } } private void TakeLease() @@ -368,5 +549,75 @@ internal sealed class WebView2Host : IBrowserHost } } - private Task OnUiAsync(Func action) => _ui.CheckAccess() ? action() : _ui.InvokeAsync(action).Task.Unwrap(); + /// + /// Runs one step of the life of the WebView (start, restart, stop) after the others. UI thread. With + /// the step runs anyway once that time has passed (stopping must not hang behind a start + /// that WebView2 never completes). + /// + private async Task ExclusiveAsync(Func step, TimeSpan? wait = null) + { + var entered = true; + if (wait is { } limit) + { + entered = await _lifecycle.WaitAsync(limit).ConfigureAwait(true); + } + else + { + await _lifecycle.WaitAsync().ConfigureAwait(true); + } + + try + { + await step().ConfigureAwait(true); + } + finally + { + if (entered) + { + _lifecycle.Release(); + } + } + } + + /// + /// Waits for until is cancelled. Then the caller goes on and the work + /// is left to end by itself; its outcome is observed here, so a late error is never an unobserved task. + /// + private static async Task UntilCancelledAsync(Task work, CancellationToken ct) + { + try + { + await work.WaitAsync(ct).ConfigureAwait(false); + } + catch (OperationCanceledException) when (ct.IsCancellationRequested) + { + _ = work.ContinueWith( + static done => _ = done.Exception, + CancellationToken.None, + TaskContinuationOptions.OnlyOnFaulted | TaskContinuationOptions.ExecuteSynchronously, + TaskScheduler.Default); + throw; + } + } + + /// + /// Runs on the UI thread — at once when already there — and returns its task: an exception + /// is always in the task, never thrown to the caller. + /// + private Task OnUiAsync(Func action) + { + if (!_ui.CheckAccess()) + { + return _ui.InvokeAsync(action).Task.Unwrap(); + } + + try + { + return action(); + } + catch (Exception ex) when (ex is not OutOfMemoryException) + { + return Task.FromException(ex); + } + } } diff --git a/src/Febe.Desktop/Febe.Desktop.csproj b/src/Febe.Desktop/Febe.Desktop.csproj index d66b943..4e44622 100644 --- a/src/Febe.Desktop/Febe.Desktop.csproj +++ b/src/Febe.Desktop/Febe.Desktop.csproj @@ -38,6 +38,10 @@ + + + + diff --git a/src/Febe.Desktop/LEGGIMI.md b/src/Febe.Desktop/LEGGIMI.md index 881169a..7868c2f 100644 --- a/src/Febe.Desktop/LEGGIMI.md +++ b/src/Febe.Desktop/LEGGIMI.md @@ -2,7 +2,8 @@ L'eseguibile per Windows (WPF, `net10.0-windows`; specifica §5, §12). Si compila anche da Linux (`EnableWindowsTargeting`), ma gira solo su Windows: tutto ciò che si può provare altrove sta in -`src/Febe.Desktop.Core` (`net10.0`, prove in `tests/Febe.Tests/Desktop`). Guida per l'uso: `docs/windows.md`. +`src/Febe.Desktop.Core` (`net10.0`, prove in `tests/Febe.Tests/Desktop`); il resto si prova su Windows, con WebView2 +vero, in `tests/Febe.Tests.Windows` (`dotnet test tests/Febe.Tests.Windows`). Guida per l'uso: `docs/windows.md`. ## Come è fatto @@ -23,9 +24,22 @@ L'eseguibile per Windows (WPF, `net10.0-windows`; specifica §5, §12). Si compi | `Native/Win32.cs` | Le poche chiamate Win32 e le interfacce di DirectComposition | | `Febe.ico` | Il marchio (appendice C) a 16–256 pixel, generato da `BrandMark`/`IcoWriter` (`FEBE_RIGENERA_ICONA=1 dotnet test --filter IconTests`) | -Regole che valgono anche qui: le chiamate a WebView2 solo sul thread dell'interfaccia; il browser di Febe non si nasconde -e non si riduce mai a icona (S2); nel registro mai indirizzi con il gettone, cookie o tasti; nessun pacchetto oltre a -`Microsoft.Web.WebView2` (WPF e Windows Forms vengono con il .NET per Windows). +Regole che valgono anche qui: + +- Ogni oggetto di WebView2 (ambiente, controllo, `CoreWebView2`, impostazioni, ricevitori DevTools) e ogni finestra si + tocca solo sul thread dell'interfaccia, anche solo per leggere una proprietà: WebView2 lancia + `InvalidOperationException` su ogni altro thread. Chi sta su un altro thread (composizione, motore) passa dal + dispatcher o legge valori semplici presi durante l'avvio (`WebView2Host.Version`, `BrowserProcessId`). Attenzione a + `ConfigureAwait(false)`: dopo, si è su un thread del pool. È l'errore del 14 ottobre 2026 (il browser non partiva mai). +- Dentro un gestore di un evento di WebView2 niente chiusure, ricreazioni, cicli di messaggi o shell: si mette in coda + sul dispatcher e si fa dopo (modello dei thread di WebView2). +- Si riprova solo un avvio fallito: ciò che segue un avvio riuscito (registro, stato) non lo disfa mai. +- Un solo WebView alla volta, chiunque lo avvii (primo avvio e suoi tentativi, «Scollega», ripartenza dopo un arresto + del processo): l'avvio, dentro la sezione esclusiva di `WebView2Host`, trova quello in funzione e non fa nulla, chiude + prima i resti di uno morto, e se fallisce chiude da sé ciò che ha creato. Un WebView orfano terrebbe vivo il processo + del browser sul profilo, e «Scollega» non potrebbe più cancellarlo. +- Il browser di Febe non si nasconde e non si riduce mai a icona (S2); nel registro mai indirizzi con il gettone, cookie + o tasti; nessun pacchetto oltre a `Microsoft.Web.WebView2` (WPF e Windows Forms vengono con il .NET per Windows). ## Pubblicazione diff --git a/src/Febe.Desktop/MainWindow.cs b/src/Febe.Desktop/MainWindow.cs index cf395fd..8dfb6ab 100644 --- a/src/Febe.Desktop/MainWindow.cs +++ b/src/Febe.Desktop/MainWindow.cs @@ -1,6 +1,7 @@ using System.ComponentModel; using System.Windows; using System.Windows.Media; +using System.Windows.Threading; using Microsoft.Web.WebView2.Core; using Microsoft.Web.WebView2.Wpf; @@ -120,7 +121,7 @@ internal sealed class MainWindow : Window e.Cancel = true; if (uri.Scheme is "http" or "https") { - _ = _openOutside(uri); + OpenOutsideLater(uri); } } @@ -138,7 +139,13 @@ internal sealed class MainWindow : Window } else if (uri.Scheme is "http" or "https") { - _ = _openOutside(uri); + OpenOutsideLater(uri); } } + + /// + /// Opens in Alberto's browser once the handler of WebView2's event has returned: the shell + /// may run a message loop of its own, and WebView2 does not support re-entering its handlers (threading model). + /// + private void OpenOutsideLater(Uri uri) => Dispatcher.InvokeAsync(() => _openOutside(uri), DispatcherPriority.Background); } diff --git a/src/Febe.Web/wwwroot/js/pages/connection.js b/src/Febe.Web/wwwroot/js/pages/connection.js index 3959399..752312d 100644 --- a/src/Febe.Web/wwwroot/js/pages/connection.js +++ b/src/Febe.Web/wwwroot/js/pages/connection.js @@ -220,9 +220,12 @@ export async function mountConnection(page) { function drawConnected() { waitingResume = false; closeView(); + // Before the first round the name of the account is not known yet: «Collegato» and «Nome non ancora noto», never «@». + const nome = status.username || ''; + const sotto = nome ? status.displayName : t('stato.accountDaLeggere'); fill(left, h('div.pannello.collegato', - h('div.chi-collegato', avatar(status.username || '', 'g'), - h('div', h('h2', t('impostazioni.collegamento.collegatoCome', { nome: status.username || '' })), status.displayName ? h('span.muto', status.displayName) : null)), + h('div.chi-collegato', avatar(nome, 'g'), + h('div', h('h2', nome ? t('impostazioni.collegamento.collegatoCome', { nome }) : t('stato.collegato')), sotto ? h('span.muto', sotto) : null)), h('p', t('impostazioni.collegamento.collegatoTesto')), h('div.azioni-collegato', h('button.btn', { type: 'button', onclick: useBrowser }, icon('app-window', 's'), t('impostazioni.collegamento.usaBrowser')), diff --git a/tests/Febe.Tests.Windows/Febe.Tests.Windows.csproj b/tests/Febe.Tests.Windows/Febe.Tests.Windows.csproj new file mode 100644 index 0000000..404c8cf --- /dev/null +++ b/tests/Febe.Tests.Windows/Febe.Tests.Windows.csproj @@ -0,0 +1,31 @@ + + + + net10.0-windows + true + true + false + true + + + + + + + + + + + + + + + + + + + diff --git a/tests/Febe.Tests.Windows/MSTestSettings.cs b/tests/Febe.Tests.Windows/MSTestSettings.cs new file mode 100644 index 0000000..2900593 --- /dev/null +++ b/tests/Febe.Tests.Windows/MSTestSettings.cs @@ -0,0 +1,2 @@ +// One WebView2 at a time: every test starts its own browser process, window and UI thread. +[assembly: DoNotParallelize] diff --git a/tests/Febe.Tests.Windows/Support/BrowserBed.cs b/tests/Febe.Tests.Windows/Support/BrowserBed.cs new file mode 100644 index 0000000..4861f03 --- /dev/null +++ b/tests/Febe.Tests.Windows/Support/BrowserBed.cs @@ -0,0 +1,127 @@ +using Febe.App; +using Febe.Core.Abstractions; +using Febe.Core.Library; +using Febe.Data; +using Febe.Desktop.Browser; +using Febe.Desktop.Core; +using Febe.Web.Engine; + +namespace Febe.Tests.Windows.Support; + +/// +/// The browser of Febe for Windows on its own, as the composition builds it ( through +/// DesktopShell): a with its window «Browser di Febe» and WebView2 on a real UI +/// thread, a profile in a temporary Data folder, the switches of S2 and the log of Febe captured. +/// +internal sealed class BrowserBed : IAsyncDisposable +{ + private BrowserBed(TestFolder folder, UiThread ui, LogLines lines, FebeLog log, FebeDatabase database, BrowserUseTracker tracker, WebView2Browser browser) + { + Folder = folder; + Ui = ui; + Lines = lines; + Log = log; + Database = database; + Tracker = tracker; + Browser = browser; + } + + public TestFolder Folder { get; } + + public UiThread Ui { get; } + + /// What Febe wrote in its log. + public LogLines Lines { get; } + + public FebeLog Log { get; } + + public FebeDatabase Database { get; } + + /// When Alberto last used the browser («Riprendi» after a verification). + public BrowserUseTracker Tracker { get; } + + public WebView2Browser Browser { get; } + + public static async Task CreateAsync(string name, BrowserHosting hosting = BrowserHosting.Window) + { + var folder = new TestFolder(name); + var ui = await UiThread.StartAsync(); + var lines = new LogLines(); + var clock = new SystemClock(); + var log = new FebeLog(null, lines, clock); + var data = new DataFolderLayout(folder.Combine("dati")); + var database = await FebeDatabase.OpenAsync(data.Root); + var options = new FebeAppOptions { DataFolder = data.Root, LibraryFolder = folder.Combine("libreria") }; + var tracker = new BrowserUseTracker(); + var context = new FebePlatformContext(options, data, database, clock, log, tracker); + var settings = new WebView2BrowserSettings(data.BrowserProfile, 1280, 900, hosting, BrowserArguments.ForWebView2()); + + // Built off the UI thread, as DesktopPlatform.CreateBrowserAsync does after its awaits. + var browser = new WebView2Browser(ui.Dispatcher, settings, context, icon: null); + return new BrowserBed(folder, ui, lines, log, database, tracker, browser); + } + + /// Waits (real time) until holds; fails with and the log otherwise. + public async Task WaitUntilAsync(Func condition, TimeSpan timeout, string what, CancellationToken ct) + { + var deadline = DateTime.UtcNow + timeout; + while (!condition()) + { + if (DateTime.UtcNow > deadline) + { + Assert.Fail($"Tempo scaduto: {what}.\n{Lines.Text}"); + } + + await Task.Delay(50, ct); + } + } + + /// Reads a value of the UI thread (the window, its position) through the dispatcher. + public Task OnUiAsync(Func read) => Ui.InvokeAsync(read); + + /// The class names of the child windows of «Browser di Febe»: one per WebView hosted in it. + public Task> ChildWindowsAsync() => + OnUiAsync(() => Browser.Host.Window is { } window ? ChildWindows.Of(window.Handle) : (IReadOnlyList)[]); + + /// + /// Starts the browser from a thread-pool thread, like FebeApp.BringUpBrowserAsync, and waits until + /// returns. Fails at once when the log reports a failed start: the loop of + /// retries would otherwise go on for ever. + /// + public async Task StartAsync(CancellationToken ct, TimeSpan? timeout = null) + { + var run = Task.Run(() => Browser.RunAsync(ct), ct); + var deadline = DateTime.UtcNow + (timeout ?? TimeSpan.FromSeconds(60)); + while (!run.IsCompleted) + { + if (Lines.Any("non parte")) + { + Assert.Fail("Il browser di Febe non è partito al primo tentativo:\n" + Lines.Text); + } + + if (DateTime.UtcNow > deadline) + { + Assert.Fail("Il browser di Febe non è diventato disponibile in tempo:\n" + Lines.Text); + } + + await Task.Delay(50, ct); + } + + await run; + } + + public async ValueTask DisposeAsync() + { + try + { + await Browser.DisposeAsync(); + } + finally + { + await Ui.DisposeAsync(); + await Database.DisposeAsync(); + Log.Dispose(); + Folder.Dispose(); + } + } +} diff --git a/tests/Febe.Tests.Windows/Support/ChildWindows.cs b/tests/Febe.Tests.Windows/Support/ChildWindows.cs new file mode 100644 index 0000000..4d85210 --- /dev/null +++ b/tests/Febe.Tests.Windows/Support/ChildWindows.cs @@ -0,0 +1,31 @@ +using System.Runtime.InteropServices; + +namespace Febe.Tests.Windows.Support; + +/// +/// The direct child windows of a window, by class name. WebView2 hosted in a window («finestra») puts one child window +/// per controller into its parent: two of them in «Browser di Febe» mean two WebViews, one of them orphaned. +/// +internal static class ChildWindows +{ + /// The class names of the direct children of , in Z order. + public static IReadOnlyList Of(IntPtr parent) + { + var names = new List(); + var buffer = new char[256]; + var child = IntPtr.Zero; + while ((child = FindWindowEx(parent, child, null, null)) != IntPtr.Zero) + { + var length = GetClassName(child, buffer, buffer.Length); + names.Add(new string(buffer, 0, Math.Max(length, 0))); + } + + return names; + } + + [DllImport("user32.dll", EntryPoint = "FindWindowExW", CharSet = CharSet.Unicode)] + private static extern IntPtr FindWindowEx(IntPtr parent, IntPtr childAfter, string? className, string? windowName); + + [DllImport("user32.dll", EntryPoint = "GetClassNameW", CharSet = CharSet.Unicode)] + private static extern int GetClassName(IntPtr window, [Out] char[] className, int maxCount); +} diff --git a/tests/Febe.Tests.Windows/Support/CompositionSupport.cs b/tests/Febe.Tests.Windows/Support/CompositionSupport.cs new file mode 100644 index 0000000..54f2c73 --- /dev/null +++ b/tests/Febe.Tests.Windows/Support/CompositionSupport.cs @@ -0,0 +1,78 @@ +using Febe.Core.Abstractions; +using Febe.Desktop.Core; + +namespace Febe.Tests.Windows.Support; + +/// +/// A clock that compresses time, like the one of the Linux suite: waits for real only a fraction +/// of the requested time and moves on by the whole of it, so the engine keeps its order of events +/// while a session lasts minutes instead of hours. +/// +internal sealed class CompressedClock(double factor, TimeZoneInfo zone) : IClock +{ + private readonly Lock _gate = new(); + private TimeSpan _offset; + + public TimeZoneInfo LocalZone { get; } = zone; + + public DateTimeOffset Now + { + get + { + lock (_gate) + { + return DateTimeOffset.UtcNow + _offset; + } + } + } + + public async Task Delay(TimeSpan time, CancellationToken ct) + { + if (time <= TimeSpan.Zero) + { + ct.ThrowIfCancellationRequested(); + return; + } + + var real = TimeSpan.FromTicks((long)(time.Ticks / factor)); + if (real >= TimeSpan.FromMilliseconds(1)) + { + await Task.Delay(real, ct).ConfigureAwait(false); + } + else + { + ct.ThrowIfCancellationRequested(); + await Task.Yield(); + } + + lock (_gate) + { + _offset += time - real; + } + } +} + +internal static class TestZones +{ + /// + /// A fixed-offset zone where it is between 12:00 and 13:00 now: inside the active window of every caution profile, + /// whatever the hour of the test. + /// + public static TimeZoneInfo Noon() + { + var offset = 12 - DateTimeOffset.UtcNow.Hour; + return TimeZoneInfo.CreateCustomTimeZone("Febe/Mezzogiorno", TimeSpan.FromHours(offset), "Mezzogiorno di prova", "Mezzogiorno di prova"); + } +} + +/// The registry values «CartellaDati» and «NuovaCartellaDati», in memory. +internal sealed class MemoryLocations : IDataFolderLocationStore +{ + public string? Current { get; private set; } + + public string? Pending { get; private set; } + + public void SetCurrent(string? folder) => Current = folder; + + public void SetPending(string? folder) => Pending = folder; +} diff --git a/tests/Febe.Tests.Windows/Support/DesktopBed.cs b/tests/Febe.Tests.Windows/Support/DesktopBed.cs new file mode 100644 index 0000000..8a1e1af --- /dev/null +++ b/tests/Febe.Tests.Windows/Support/DesktopBed.cs @@ -0,0 +1,150 @@ +using System.Net; +using System.Net.Http; +using System.Text; +using System.Text.Json; +using Febe.App; +using Febe.Core.Abstractions; +using Febe.Desktop; +using Febe.Desktop.Browser; +using Febe.Desktop.Core; +using Febe.SitoDiProva; +using Febe.Web.Native; + +namespace Febe.Tests.Windows.Support; + +/// +/// The shared composition () as Febe.exe composes it — , +/// DesktopShell, the window «Browser di Febe» on a WPF UI thread — against its own test site, in temporary +/// folders, on a clock ten times faster and in a zone where it is noon. The interface is asked like the main window asks +/// it: with the token of this start and the Origin of the interface. +/// +internal sealed class DesktopBed : IAsyncDisposable +{ + private readonly HttpClient _client; + + private DesktopBed(TestSite site, TestFolder folder, UiThread ui, LogLines lines, CompressedClock clock, DesktopPlatform platform, FebeApp app) + { + Site = site; + Folder = folder; + Ui = ui; + Lines = lines; + Clock = clock; + Platform = platform; + App = app; + _client = new HttpClient(new HttpClientHandler { UseCookies = false, AllowAutoRedirect = false, UseProxy = false }) + { + BaseAddress = app.Address, + Timeout = TimeSpan.FromSeconds(30), + }; + } + + public TestSite Site { get; } + + public TestFolder Folder { get; } + + public UiThread Ui { get; } + + /// What Febe wrote in its log. + public LogLines Lines { get; } + + public CompressedClock Clock { get; } + + public DesktopPlatform Platform { get; } + + public FebeApp App { get; } + + /// The browser of Febe: WebView2 (Febe.exe never uses another one unless asked with --browser edge). + public WebView2Browser Browser => App.Browser as WebView2Browser ?? throw new AssertFailedException("Il browser della composizione non è WebView2."); + + /// Prefix of the temporary folder. + /// --accesso-di-prova: the composition opens the test site once at start-up. + public static async Task StartAsync(string name, bool autoLogin, CancellationToken ct) + { + var site = await TestSite.StartAsync(new TestSiteOptions(), ct); + var folder = new TestFolder(name); + var ui = await UiThread.StartAsync(); + try + { + var lines = new LogLines(); + var data = folder.Combine("dati"); + List arguments = + [ + "--dati", data, "--libreria", folder.Combine("libreria"), + "--sito-di-prova", site.SiteUrl, "--cdn-di-prova", site.CdnUrl, "--prima-sessione", "1", + ]; + if (autoLogin) + { + arguments.Add("--accesso-di-prova"); + } + + if (!DesktopCommandLine.TryParse([.. arguments], out var options, out var problem)) + { + throw new ArgumentException(problem); + } + + var zone = TestZones.Noon(); + var clock = new CompressedClock(10, zone); + var shell = new DesktopShell(ui.Dispatcher, null, BrowserShell.Instance); + var platform = new DesktopPlatform(options, shell, new MemoryLocations(), dataFolderFixed: true); + var appOptions = options.AppOptions(data, new DesktopFolders(folder.Combine("AppData"), folder.Combine("Immagini"))) with { Zone = zone, ZoneId = zone.Id }; + var hooks = new FebeAppHooks { Clock = clock, Random = new SeededRandom(20261020), Console = lines, ShutdownTimeout = TimeSpan.FromSeconds(1) }; + var app = await FebeApp.StartAsync(appOptions, platform, hooks, ct); + return new DesktopBed(site, folder, ui, lines, clock, platform, app); + } + catch + { + await ui.DisposeAsync(); + folder.Dispose(); + await site.DisposeAsync(); + throw; + } + } + + /// A request as the main window sends it; the answer must be 200 with JSON. + public async Task JsonAsync(HttpMethod method, string path, string? json, CancellationToken ct) + { + using var request = new HttpRequestMessage(method, path); + request.Headers.TryAddWithoutValidation(Febe.Web.Security.AccessToken.HeaderName, Platform.AccessToken); + request.Headers.TryAddWithoutValidation("Origin", $"{App.Address.Scheme}://{App.Address.Authority}"); + if (json is not null) + { + request.Content = new StringContent(json, Encoding.UTF8, "application/json"); + } + + using var response = await _client.SendAsync(request, ct); + var text = await response.Content.ReadAsStringAsync(ct); + Assert.AreEqual(HttpStatusCode.OK, response.StatusCode, $"{path}: {text}"); + return JsonDocument.Parse(text).RootElement.Clone(); + } + + /// Waits (real time) until holds; fails with and the log otherwise. + public async Task WaitUntilAsync(Func> condition, TimeSpan timeout, string what, CancellationToken ct) + { + var deadline = DateTime.UtcNow + timeout; + while (!await condition()) + { + if (DateTime.UtcNow > deadline) + { + Assert.Fail($"Tempo scaduto: {what}.\n{Lines.Text}"); + } + + await Task.Delay(250, ct); + } + } + + /// Stops the composition (the browser of Febe closes on its UI thread), then the UI thread, folders, site. + public async ValueTask DisposeAsync() + { + _client.Dispose(); + try + { + await App.DisposeAsync(); + } + finally + { + await Ui.DisposeAsync(); + Folder.Dispose(); + await Site.DisposeAsync(); + } + } +} diff --git a/tests/Febe.Tests.Windows/Support/LogLines.cs b/tests/Febe.Tests.Windows/Support/LogLines.cs new file mode 100644 index 0000000..4354225 --- /dev/null +++ b/tests/Febe.Tests.Windows/Support/LogLines.cs @@ -0,0 +1,54 @@ +using System.Text; + +namespace Febe.Tests.Windows.Support; + +/// The «console» of in a test: the lines Alberto would find in his log. +internal sealed class LogLines : TextWriter +{ + private readonly Lock _gate = new(); + private readonly List _lines = []; + private readonly StringBuilder _current = new(); + + public override Encoding Encoding => Encoding.UTF8; + + public IReadOnlyList Lines + { + get + { + lock (_gate) + { + return [.. _lines]; + } + } + } + + public string Text => string.Join('\n', Lines); + + public bool Any(string fragment) => Lines.Any(l => l.Contains(fragment, StringComparison.Ordinal)); + + public override void Write(char value) + { + lock (_gate) + { + if (value == '\n') + { + _lines.Add(_current.ToString().TrimEnd('\r')); + _current.Clear(); + } + else + { + _current.Append(value); + } + } + } + + public override void WriteLine(string? value) + { + lock (_gate) + { + _current.Append(value); + _lines.Add(_current.ToString()); + _current.Clear(); + } + } +} diff --git a/tests/Febe.Tests.Windows/Support/TestFolder.cs b/tests/Febe.Tests.Windows/Support/TestFolder.cs new file mode 100644 index 0000000..d121231 --- /dev/null +++ b/tests/Febe.Tests.Windows/Support/TestFolder.cs @@ -0,0 +1,39 @@ +namespace Febe.Tests.Windows.Support; + +/// +/// A temporary folder under (TEMP: on Alberto's PC a work folder outside drive C:), +/// removed at the end of the test. WebView2 may hold a file of its profile for a moment after it closed: removal is +/// retried and a leftover folder is not an error. +/// +internal sealed class TestFolder : IDisposable +{ + public TestFolder(string prefix) + { + Path = System.IO.Path.Combine(System.IO.Path.GetTempPath(), "febe-prove-windows", prefix + "-" + Guid.NewGuid().ToString("N")[..10]); + Directory.CreateDirectory(Path); + } + + public string Path { get; } + + public string Combine(params string[] parts) => System.IO.Path.Combine([Path, .. parts]); + + public void Dispose() + { + for (var attempt = 0; attempt < 10; attempt++) + { + try + { + if (Directory.Exists(Path)) + { + Directory.Delete(Path, recursive: true); + } + + return; + } + catch (Exception ex) when (ex is IOException or UnauthorizedAccessException) + { + Thread.Sleep(300); + } + } + } +} diff --git a/tests/Febe.Tests.Windows/Support/UiThread.cs b/tests/Febe.Tests.Windows/Support/UiThread.cs new file mode 100644 index 0000000..441b7c1 --- /dev/null +++ b/tests/Febe.Tests.Windows/Support/UiThread.cs @@ -0,0 +1,55 @@ +using System.Windows.Threading; + +namespace Febe.Tests.Windows.Support; + +/// +/// A UI thread like the one of Febe.exe: an STA thread running a WPF +/// (its message pump and its ). The browser of Febe is created on it, +/// while the test itself — like the engine of Febe — runs on thread-pool threads. +/// +internal sealed class UiThread : IAsyncDisposable +{ + private readonly Thread _thread; + + private UiThread(Thread thread, Dispatcher dispatcher) + { + _thread = thread; + Dispatcher = dispatcher; + } + + public Dispatcher Dispatcher { get; } + + /// The managed id of the UI thread (to tell where code ran). + public int ThreadId => _thread.ManagedThreadId; + + public static async Task StartAsync() + { + var ready = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously); + var thread = new Thread(() => + { + ready.SetResult(Dispatcher.CurrentDispatcher); + Dispatcher.Run(); + }) + { + IsBackground = true, + Name = "Febe: thread dell'interfaccia (prove)", + }; + thread.SetApartmentState(ApartmentState.STA); + thread.Start(); + var dispatcher = await ready.Task.WaitAsync(TimeSpan.FromSeconds(10)).ConfigureAwait(false); + return new UiThread(thread, dispatcher); + } + + /// Runs on the UI thread and waits for it. + public Task InvokeAsync(Func action) => Dispatcher.InvokeAsync(action).Task; + + public async ValueTask DisposeAsync() + { + if (!Dispatcher.HasShutdownStarted) + { + Dispatcher.BeginInvokeShutdown(DispatcherPriority.Background); + } + + await Task.Run(() => _thread.Join(TimeSpan.FromSeconds(15))).ConfigureAwait(false); + } +} diff --git a/tests/Febe.Tests.Windows/Support/WebView2Runtime.cs b/tests/Febe.Tests.Windows/Support/WebView2Runtime.cs new file mode 100644 index 0000000..b9a52c6 --- /dev/null +++ b/tests/Febe.Tests.Windows/Support/WebView2Runtime.cs @@ -0,0 +1,39 @@ +using System.Runtime.CompilerServices; +using Microsoft.Web.WebView2.Core; + +namespace Febe.Tests.Windows.Support; + +/// Whether these tests can run here: Windows with the WebView2 runtime (the tests are inconclusive otherwise). +internal static class WebView2Runtime +{ + /// Null when WebView2 can run; otherwise why not, in Italian (the text of the inconclusive result). + public static string? UnavailableReason() + { + if (!OperatingSystem.IsWindows()) + { + return "Prova solo per Windows: qui non c'è WebView2."; + } + + try + { + return InstalledVersion() is null ? "Runtime WebView2 non installato su questo Windows." : null; + } + catch (Exception ex) when (ex is WebView2RuntimeNotFoundException or DllNotFoundException or BadImageFormatException) + { + return $"Runtime WebView2 non disponibile ({ex.GetType().Name})."; + } + } + + /// The version of the installed WebView2 runtime, e.g. «141.0.3537.71». + [MethodImpl(MethodImplOptions.NoInlining)] + public static string? InstalledVersion() => CoreWebView2Environment.GetAvailableBrowserVersionString(); + + /// Marks the test inconclusive where WebView2 cannot run. + public static void Require() + { + if (UnavailableReason() is { } reason) + { + Assert.Inconclusive(reason); + } + } +} diff --git a/tests/Febe.Tests.Windows/WebView2BrowserStartTests.cs b/tests/Febe.Tests.Windows/WebView2BrowserStartTests.cs new file mode 100644 index 0000000..1d00073 --- /dev/null +++ b/tests/Febe.Tests.Windows/WebView2BrowserStartTests.cs @@ -0,0 +1,50 @@ +using System.Text.RegularExpressions; +using Febe.Browser.Cdp; +using Febe.Tests.Windows.Support; + +namespace Febe.Tests.Windows; + +/// +/// The start of the browser of Febe on a real Windows (regression of 14 and 19 October 2026: «WebView2 non parte +/// (InvalidOperationException: CoreWebView2Environment members can only be accessed from the UI thread.)» at every +/// attempt, for ever). The composition starts the browser from a thread-pool thread; every WebView2 object lives on the +/// UI thread of WPF. +/// +[TestClass] +public sealed partial class WebView2BrowserStartTests +{ + public TestContext TestContext { get; set; } = null!; + + [TestInitialize] + public void RequireWebView2() => WebView2Runtime.Require(); + + [TestMethod] + [Timeout(120_000, CooperativeCancellation = true)] + public async Task StartedFromAThreadPoolThreadTheBrowserIsReadyAtTheFirstAttempt() + { + var ct = TestContext.CancellationToken; + await using var bed = await BrowserBed.CreateAsync("avvio"); + + await bed.StartAsync(ct); + + TestContext.WriteLine(bed.Lines.Text); + Assert.IsTrue(bed.Browser.IsAvailable, "the browser is available once RunAsync returned"); + Assert.IsNull(bed.Browser.LastError); + var ready = bed.Lines.Lines.Where(l => l.Contains("Browser di Febe pronto: WebView2 ", StringComparison.Ordinal)).ToList(); + Assert.HasCount(1, ready, "one «ready» line: " + bed.Lines.Text); + Assert.MatchesRegex(ReadyLine(), ready[0]); + Assert.IsFalse(bed.Lines.Any("non parte"), "no failed attempt: " + bed.Lines.Text); + Assert.IsFalse(bed.Lines.Any("ERRORE"), "no error at all: " + bed.Lines.Text); + + // The version is a plain value now: it can be read from any thread. + var version = await Task.Run(() => bed.Browser.Host.Version, ct); + Assert.IsNotNull(version); + StringAssert.Contains(ready[0], version); + + // The engine's threads use the page through the session: the command hops to the UI thread and back. + Assert.AreEqual("about:blank", await Task.Run(() => bed.Browser.Cdp.GetMainFrameUrlAsync(ct), ct)); + } + + [GeneratedRegex(@"\[browser\] Browser di Febe pronto: WebView2 \d+\.\d+\.\d+\.\d+, pagina 1280×900, finestra, fuori vista\.$")] + private static partial Regex ReadyLine(); +} diff --git a/tests/Febe.Tests.Windows/WebView2CdpTests.cs b/tests/Febe.Tests.Windows/WebView2CdpTests.cs new file mode 100644 index 0000000..920b1d4 --- /dev/null +++ b/tests/Febe.Tests.Windows/WebView2CdpTests.cs @@ -0,0 +1,200 @@ +using System.Collections.Concurrent; +using System.Text.Json; +using System.Text.Json.Nodes; +using Febe.Browser.Capture; +using Febe.Browser.Cdp; +using Febe.Browser.Download; +using Febe.Browser.Gestures; +using Febe.Browser.Hosting; +using Febe.Browser.RemoteView; +using Febe.Browser.WebView2; +using Febe.Browser.Recipes; +using Febe.Core.Abstractions; +using Febe.Core.Collection; +using Febe.SitoDiProva; +using Febe.Tests.Windows.Support; + +namespace Febe.Tests.Windows; + +/// +/// S1 on a real Windows (docs/prove-dal-vivo.md, C3): the DevTools protocol of WebView2 through the real +/// and its allowlist, against the local test site (never Instagram), from thread-pool +/// threads as the engine sends it, with the window «Browser di Febe» out of view as it always is. +/// +[TestClass] +public sealed class WebView2CdpTests +{ + public TestContext TestContext { get; set; } = null!; + + [TestInitialize] + public void RequireWebView2() => WebView2Runtime.Require(); + + [TestMethod] + [Timeout(180_000, CooperativeCancellation = true)] + public async Task S1TheProtocolWorksOnTheTestSiteWithTheWindowOutOfView() + { + var ct = TestContext.CancellationToken; + await using var site = await TestSite.StartAsync(new TestSiteOptions(), ct); + await using var bed = await BrowserBed.CreateAsync("s1"); + await bed.StartAsync(ct); + var cdp = bed.Browser.Cdp; + Assert.IsInstanceOfType(cdp, "the real session of WebView2, with its allowlist"); + var clock = new SystemClock(); + var testSite = CollectionSite.TestSite(site.SiteHost, site.CdnHost); + + await Task.Run( + async () => + { + // Response bodies: Network.enable and the events are subscribed from this thread, the bodies come + // through Network.getResponseBody. + var bodies = new BodyCollector(); + await using var tap = new ResponseTap(cdp, testSite.Hosts, clock); + tap.AddConsumer(bodies); + await tap.StartAsync(ct); + + // Navigation. + var navigation = await cdp.NavigateAsync(site.Url("/profilo/luca.prova/"), ct); + Assert.IsTrue(navigation.Succeeded, navigation.ErrorText); + Assert.IsTrue(await cdp.WaitForLoadAsync(clock, TimeSpan.FromSeconds(20), ct), "the profile page loaded"); + await WaitUntilAsync(() => bodies.Paths.Contains("/dati/profilo/luca.prova"), TimeSpan.FromSeconds(20), "il corpo JSON del profilo", ct); + var profile = bodies.Json("/dati/profilo/luca.prova"); + Assert.AreEqual("luca.prova", profile.GetProperty("profilo").GetProperty("nome").GetString()); + Assert.IsTrue(tap.Stats.JsonBodies >= 1); + + // Read-only Runtime.evaluate: what the page sees, out of view (S2: visible, never «hidden»). + var seen = await cdp.EvaluateAsync( + "({ visibility: document.visibilityState, hidden: document.hidden, webdriver: navigator.webdriver, width: innerWidth, height: innerHeight, path: location.pathname, tiles: document.querySelectorAll('#griglia a').length })", + ct); + TestContext.WriteLine("La pagina vede: " + seen.GetRawText()); + Assert.AreEqual("/profilo/luca.prova/", seen.GetProperty("path").GetString()); + Assert.AreEqual("visible", seen.GetProperty("visibility").GetString(), "out of view the page stays visible (S2)"); + Assert.IsFalse(seen.GetProperty("hidden").GetBoolean()); + Assert.IsFalse(seen.GetProperty("webdriver").GetBoolean(), "an ordinary browser: navigator.webdriver is false"); + Assert.AreEqual(1280, seen.GetProperty("width").GetInt32(), "the page has its fixed width"); + Assert.IsGreaterThan(0, seen.GetProperty("tiles").GetInt32(), "the page drew the grid from the JSON"); + + // The session cookie of the site exists (only its name is looked at). + Assert.IsTrue(await SessionCookieProbe.HasSessionCookieAsync(cdp, testSite.SessionCookie, ct)); + + // Scrolling with Input.dispatchMouseEvent (mouseWheel), as the recipes do. + var height = (await cdp.EvaluateAsync("document.documentElement.scrollHeight", ct)).GetDouble(); + Assert.IsGreaterThan(seen.GetProperty("height").GetInt32() + 400.0, height, "a page long enough to scroll"); + Assert.AreEqual(0, (await cdp.EvaluateAsync("window.scrollY", ct)).GetDouble()); + var gestures = new HumanGestures(cdp, clock, new SeededRandom(20261020)); + await gestures.MoveToAsync(new PagePoint(640, 450), ct); + var requested = await gestures.ScrollBurstAsync(ct: ct); + await Task.Delay(800, ct); + var scrolled = (await cdp.EvaluateAsync("window.scrollY", ct)).GetDouble(); + TestContext.WriteLine($"Scorrimento: chiesti {requested} pixel, pagina scesa di {scrolled}."); + Assert.IsGreaterThan(100.0, scrolled, "the wheel really scrolled the page out of view"); + + // Page.captureScreenshot: a JPEG of the page, out of view (the preview of Attività). + var jpeg = await PagePreview.CaptureAsync(cdp, 60, ct); + TestContext.WriteLine($"Fotogramma: {jpeg.Length} byte."); + Assert.IsGreaterThan(5_000, jpeg.Length, "a real frame, not an empty one"); + Assert.AreEqual(0xFF, jpeg[0]); + Assert.AreEqual(0xD8, jpeg[1]); + + // A file of the CDN through the browser (Network.loadNetworkResource, IO.read, IO.close). + var media = FirstCdnAddress(profile, site.CdnUrl) ?? throw new AssertFailedException("nessun indirizzo del CDN nel JSON del profilo"); + var fetcher = new BrowserFileFetcher(cdp, testSite.Hosts); + using var file = new MemoryStream(); + var fetched = await fetcher.FetchAsync(new Uri(media), file, null, ct); + Assert.AreEqual(FetchOutcome.Completed, fetched.Outcome, fetched.Error); + Assert.IsGreaterThan(1_000L, fetched.Bytes); + Assert.AreEqual(0xFF, file.GetBuffer()[0], "a JPEG of the CDN"); + var refused = await fetcher.FetchAsync(new Uri(site.Url("/dati/inizio")), Stream.Null, null, ct); + Assert.AreEqual(FetchOutcome.HostNotAllowed, refused.Outcome, "only the CDN is downloaded"); + + // Forbidden commands are refused before WebView2, and change nothing. + await Assert.ThrowsExactlyAsync(() => cdp.SendAsync("Emulation.setTimezoneOverride", new JsonObject { ["timezoneId"] = "America/New_York" }, ct)); + await Assert.ThrowsExactlyAsync(() => cdp.SendAsync("Network.setUserAgentOverride", new JsonObject { ["userAgent"] = "Febe" }, ct)); + await Assert.ThrowsExactlyAsync(() => cdp.SendAsync("Page.addScriptToEvaluateOnNewDocument", new JsonObject { ["source"] = "1" }, ct)); + await Assert.ThrowsExactlyAsync(() => cdp.SendAsync("Fetch.enable", null, ct)); + await Assert.ThrowsExactlyAsync(() => cdp.SendAsync("Target.createTarget", new JsonObject { ["url"] = "about:blank" }, ct)); + var before = (await cdp.EvaluateAsync("window.scrollY", ct)).GetDouble(); + await Assert.ThrowsExactlyAsync(() => cdp.EvaluateAsync("window.scrollBy(0, 500)", ct)); + await Task.Delay(300, ct); + var after = (await cdp.EvaluateAsync("window.scrollY", ct)).GetDouble(); + Assert.IsLessThan(100.0, Math.Abs(after - before), "the refused script did not run (it would have scrolled 500 px)"); + var zone = (await cdp.EvaluateAsync("Intl.DateTimeFormat().resolvedOptions().timeZone", ct)).GetString(); + Assert.AreNotEqual("America/New_York", zone); + + // Back to the rest page. + await bed.Browser.RestAsync(ct); + await cdp.WaitForLoadAsync(clock, TimeSpan.FromSeconds(10), ct); + Assert.AreEqual(CdpPageExtensions.RestUrl, await cdp.GetMainFrameUrlAsync(ct)); + }, + ct); + + // The log has actions and outcomes only: no signed address of the CDN, no error. + TestContext.WriteLine(bed.Lines.Text); + Assert.IsFalse(bed.Lines.Any("firma="), "no signed address in the log"); + Assert.IsFalse(bed.Lines.Any("ERRORE"), bed.Lines.Text); + } + + private static string? FirstCdnAddress(JsonElement element, string cdnUrl) + { + switch (element.ValueKind) + { + case JsonValueKind.Object: + foreach (var property in element.EnumerateObject()) + { + if (property.Name == "indirizzo" && property.Value.ValueKind == JsonValueKind.String + && property.Value.GetString() is { } address && address.StartsWith(cdnUrl, StringComparison.Ordinal) && address.Contains(".jpg", StringComparison.Ordinal)) + { + return address; + } + + if (FirstCdnAddress(property.Value, cdnUrl) is { } found) + { + return found; + } + } + + return null; + case JsonValueKind.Array: + foreach (var item in element.EnumerateArray()) + { + if (FirstCdnAddress(item, cdnUrl) is { } found) + { + return found; + } + } + + return null; + default: + return null; + } + } + + private static async Task WaitUntilAsync(Func condition, TimeSpan timeout, string what, CancellationToken ct) + { + var deadline = DateTime.UtcNow + timeout; + while (!condition()) + { + if (DateTime.UtcNow > deadline) + { + Assert.Fail($"Tempo scaduto: {what}."); + } + + await Task.Delay(50, ct); + } + } + + /// The JSON bodies the page received, by path. + private sealed class BodyCollector : IResponseConsumer + { + private readonly ConcurrentDictionary _bodies = new(StringComparer.Ordinal); + + public ICollection Paths => _bodies.Keys; + + public JsonElement Json(string path) => JsonDocument.Parse(_bodies[path]).RootElement.Clone(); + + public ValueTask ConsumeAsync(ResponseDescriptor response, JsonDocument body, CancellationToken ct) + { + _bodies.TryAdd(response.Path, body.RootElement.GetRawText()); + return ValueTask.CompletedTask; + } + } +} diff --git a/tests/Febe.Tests.Windows/WebView2CollectionTests.cs b/tests/Febe.Tests.Windows/WebView2CollectionTests.cs new file mode 100644 index 0000000..d645996 --- /dev/null +++ b/tests/Febe.Tests.Windows/WebView2CollectionTests.cs @@ -0,0 +1,102 @@ +using System.Net.Http; +using Febe.App; +using Febe.Core.Domain; +using Febe.Desktop.Browser; +using Febe.Tests.Windows.Support; + +namespace Febe.Tests.Windows; + +/// +/// One real collection session of the shared composition () running on WebView2, as Febe.exe +/// composes it, against the local test site, with files arriving in a temporary library. The Linux suite has the +/// equivalent with Chromium (ServerEndToEndTests). Never Instagram: the browser only sees 127.0.0.1. +/// +[TestClass] +public sealed class WebView2CollectionTests +{ + public TestContext TestContext { get; set; } = null!; + + [TestInitialize] + public void RequireWebView2() => WebView2Runtime.Require(); + + [TestMethod] + [Timeout(420_000, CooperativeCancellation = true)] + public async Task ARealSessionOfTheCompositionRunsOnWebView2AndTheFilesArriveInTheLibrary() + { + var ct = TestContext.CancellationToken; + await using var bed = await DesktopBed.StartAsync("raccolta", autoLogin: true, ct); + var app = bed.App; + Assert.IsEmpty(app.Problems, string.Join("; ", app.Problems.Select(p => p.Title))); + + // The browser starts from a thread of the composition (the path that failed on Alberto's PC), the pipeline and + // the engine follow. + await app.Running.WaitAsync(TimeSpan.FromSeconds(120), ct); + Assert.IsInstanceOfType(app.Browser); + Assert.IsTrue(bed.Lines.Any("Browser di Febe pronto: WebView2 "), bed.Lines.Text); + Assert.IsFalse(bed.Lines.Any("non parte"), bed.Lines.Text); + Assert.AreEqual(Febe.Web.Connection.ConnectionState.Connected, (await app.Connection!.GetStatusAsync(ct)).State, "the test site's automatic login"); + + // Accounts and «Controlla ora» through the interface, as from the main window. + var added = await bed.JsonAsync(HttpMethod.Post, "/api/accounts", """{"usernames":["marta.prova","luca.prova"],"start":"everything"}""", ct); + Assert.AreEqual(2, added.GetProperty("added").GetInt32()); + var marta = await app.Database.Accounts.FindByUsernameAsync("marta.prova", ct) ?? throw new AssertFailedException("marta.prova manca"); + var check = await bed.JsonAsync(HttpMethod.Post, $"/api/accounts/{marta.Id}/check-now", null, ct); + if (check.GetProperty("status").GetString() == "needsConfirmation") + { + check = await bed.JsonAsync(HttpMethod.Post, $"/api/accounts/{marta.Id}/check-now", $$"""{"token":"{{check.GetProperty("token").GetString()}}"}""", ct); + } + + Assert.AreEqual("queued", check.GetProperty("status").GetString(), check.GetProperty("message").GetString()); + + // A session of the engine acts on the site through WebView2: every action has its Governor's permit. + await bed.WaitUntilAsync( + async () => (await app.Database.ActionLog.ListAsync(DateTimeOffset.UnixEpoch, bed.Clock.Now.AddDays(1), ct)).Any(a => a.AccountId == marta.Id), + TimeSpan.FromSeconds(120), + "un'azione del motore su marta.prova nel registro delle azioni", + ct); + + // Files arrive in the library, complete, downloaded through the browser from the test site's CDN. + var library = app.Library ?? throw new AssertFailedException("nessuna libreria"); + List stored = []; + await bed.WaitUntilAsync( + async () => + { + stored = await StoredAsync(app, marta.Id, ct); + return stored.Count >= 3; + }, + TimeSpan.FromSeconds(180), + "tre file di marta.prova nella libreria", + ct); + foreach (var media in stored) + { + var path = library.FullPath(marta, media.RelativePath!); + Assert.IsTrue(File.Exists(path), path); + Assert.AreEqual(media.Bytes, new FileInfo(path).Length, path); + StringAssert.StartsWith(path, bed.Folder.Path, "inside the temporary library"); + } + + var actions = await app.Database.ActionLog.ListAsync(DateTimeOffset.UnixEpoch, bed.Clock.Now.AddDays(1), ct); + Assert.IsTrue(actions.All(a => a.SessionId is not null), "every counted action belongs to a session"); + TestContext.WriteLine($"File di marta.prova: {stored.Count}; azioni: {actions.Count}; CDN: {bed.Site.Control.CdnFilesServed} file serviti."); + TestContext.WriteLine(bed.Lines.Text); + Assert.IsFalse(bed.Lines.Any("non parte"), "the browser never failed to start"); + Assert.IsFalse(bed.Lines.Any("firma="), "no signed address in the log"); + } + + private static async Task> StoredAsync(FebeApp app, long accountId, CancellationToken ct) + { + var list = new List(); + foreach (var entry in await app.Database.Entries.ListByAccountAsync(accountId, null, ct)) + { + foreach (var media in await app.Database.Media.ListByEntryAsync(entry.Id, ct)) + { + if (media.State == MediaState.Downloaded && media.RelativePath is not null && media.Sha256 is not null && entry.Kind != EntryKind.ProfilePicture) + { + list.Add(media); + } + } + } + + return list; + } +} diff --git a/tests/Febe.Tests.Windows/WebView2ConnectionTests.cs b/tests/Febe.Tests.Windows/WebView2ConnectionTests.cs new file mode 100644 index 0000000..8dd5722 --- /dev/null +++ b/tests/Febe.Tests.Windows/WebView2ConnectionTests.cs @@ -0,0 +1,67 @@ +using Febe.Core.Storage; +using Febe.Tests.Windows.Support; +using Febe.Web.Connection; + +namespace Febe.Tests.Windows; + +/// +/// The login on Windows through the real connection service of the composition (spec §4.1, docs/windows.md «Il primo +/// collegamento a Instagram»), on WebView2 and the test site: «Accedi a Instagram» opens the login page in the window +/// «Browser di Febe», which comes on screen while the engine is still; «Ho finito» checks the session (the cookie's name +/// only) and puts the window back out of view; «Scollega» deletes the profile with the session and the browser comes +/// back empty. The window comes on screen for a moment, as for Alberto. +/// +[TestClass] +public sealed class WebView2ConnectionTests +{ + public TestContext TestContext { get; set; } = null!; + + [TestInitialize] + public void RequireWebView2() => WebView2Runtime.Require(); + + [TestMethod] + [Timeout(240_000, CooperativeCancellation = true)] + public async Task TheLoginBringsTheWindowAndScollegaEmptiesTheProfile() + { + var ct = TestContext.CancellationToken; + await using var bed = await DesktopBed.StartAsync("collegamento", autoLogin: false, ct); + var app = bed.App; + await app.Running.WaitAsync(TimeSpan.FromSeconds(120), ct); + var connection = app.Connection!; + var browser = bed.Browser; + Assert.AreEqual(ConnectionState.NotConnected, (await connection.GetStatusAsync(ct)).State, "a new profile is not connected"); + var window = await bed.Ui.InvokeAsync(() => browser.Host.Window) ?? throw new AssertFailedException("nessuna finestra"); + Assert.IsFalse(await bed.Ui.InvokeAsync(() => window.IsOnScreen)); + + // «Accedi a Instagram» (here the test site's welcome page, whose first visit starts its session). + await connection.BeginUserDrivingAsync(openLogin: true, ct); + var driving = await connection.GetStatusAsync(ct); + Assert.IsTrue(driving.UserIsDriving); + Assert.IsTrue(browser.UserIsDriving, "the engine is still while Alberto is at the browser"); + Assert.IsTrue(await bed.Ui.InvokeAsync(() => window.IsOnScreen), "the window «Browser di Febe» came on screen"); + StringAssert.StartsWith(driving.CurrentUrl, bed.Site.SiteUrl, "the login page of the configured site, never Instagram in tests"); + + // «Ho finito». + var finish = await connection.FinishAsync(ct); + Assert.IsTrue(finish.Connected, finish.Message); + Assert.IsFalse(browser.UserIsDriving, "«Ho finito» ends the driving"); + Assert.IsFalse(await bed.Ui.InvokeAsync(() => window.IsOnScreen), "and puts the window back out of view"); + Assert.AreEqual(ConnectionState.Connected, (await connection.GetStatusAsync(ct)).State); + Assert.IsNotNull(await app.Database.Settings.GetInt64Async(Febe.App.BrowserConnectionService.FirstConnectionKey, ct), "first connection recorded"); + + // «Scollega»: engine stopped, WebView2 closed, profile deleted, browser started again empty, engine started again. + var marker = Path.Combine(browser.ProfileDirectory, "segno-della-prova"); + await File.WriteAllTextAsync(marker, "x", ct); + await connection.DisconnectAsync(ct); + Assert.IsFalse(File.Exists(marker), "the profile folder was deleted"); + Assert.IsTrue(browser.IsAvailable, "the browser runs again, with an empty profile"); + Assert.AreEqual(ConnectionState.NotConnected, (await connection.GetStatusAsync(ct)).State); + Assert.IsFalse(browser.UserIsDriving); + await bed.WaitUntilAsync(() => Task.FromResult(app.Engine!.Services.Runtime.IsRunning), TimeSpan.FromSeconds(10), "il motore di nuovo in funzione", ct); + + TestContext.WriteLine(bed.Lines.Text); + Assert.IsTrue(bed.Lines.Any("«Scollega»: motore fermo, profilo del browser cancellato, browser ripartito vuoto."), bed.Lines.Text); + Assert.IsFalse(bed.Lines.Any("non parte"), bed.Lines.Text); + Assert.IsFalse(bed.Lines.Any("ERRORE"), bed.Lines.Text); + } +} diff --git a/tests/Febe.Tests.Windows/WebView2LifecycleTests.cs b/tests/Febe.Tests.Windows/WebView2LifecycleTests.cs new file mode 100644 index 0000000..155254e --- /dev/null +++ b/tests/Febe.Tests.Windows/WebView2LifecycleTests.cs @@ -0,0 +1,299 @@ +using System.Diagnostics; +using Febe.Browser.Cdp; +using Febe.Browser.Hosting; +using Febe.Browser.Recipes; +using Febe.Browser.RemoteView; +using Febe.Core.Abstractions; +using Febe.Desktop.Core; +using Febe.SitoDiProva; +using Febe.Tests.Windows.Support; + +namespace Febe.Tests.Windows; + +/// +/// The life of the browser of Febe on a real Windows, driven from thread-pool threads as the composition and the +/// connection service drive it: a start that really fails is retried (and only that), the window comes on screen and +/// goes away with the «driving» lease (the login), «Scollega» empties the profile and the browser comes back, a browser +/// process that dies is started again, and the second hosting of S2 (composition) starts and draws. +/// +/// Two tests bring the window «Browser di Febe» on screen for a moment, as «Accedi a Instagram» does. +[TestClass] +public sealed class WebView2LifecycleTests +{ + public TestContext TestContext { get; set; } = null!; + + [TestInitialize] + public void RequireWebView2() => WebView2Runtime.Require(); + + [TestMethod] + [Timeout(120_000, CooperativeCancellation = true)] + public async Task AStartThatReallyFailsIsRetriedAndThenTheBrowserIsReady() + { + var ct = TestContext.CancellationToken; + await using var bed = await BrowserBed.CreateAsync("tentativi"); + + // A file where the profile folder must go: WebView2 cannot start. + var profile = bed.Browser.ProfileDirectory; + Directory.CreateDirectory(Path.GetDirectoryName(profile)!); + await File.WriteAllTextAsync(profile, "occupa il posto della cartella del profilo", ct); + + var run = Task.Run(() => bed.Browser.RunAsync(ct), ct); + await bed.WaitUntilAsync(() => bed.Lines.Any("non parte"), TimeSpan.FromSeconds(30), "il primo avvio non riuscito", ct); + Assert.IsFalse(bed.Browser.IsAvailable); + StringAssert.StartsWith(bed.Browser.LastError, "WebView2 non parte (IOException:"); + StringAssert.EndsWith(bed.Lines.Lines.Single(l => l.Contains("non parte", StringComparison.Ordinal)), "Nuovo tentativo fra 5 s."); + + // The obstacle goes away: the next attempt, 5 s later, works. + File.Delete(profile); + await run.WaitAsync(TimeSpan.FromSeconds(60), ct); + + TestContext.WriteLine(bed.Lines.Text); + Assert.IsTrue(bed.Browser.IsAvailable); + Assert.IsNull(bed.Browser.LastError); + Assert.HasCount(1, bed.Lines.Lines.Where(l => l.Contains("non parte", StringComparison.Ordinal)), "one failed attempt only"); + Assert.HasCount(1, bed.Lines.Lines.Where(l => l.Contains("Browser di Febe pronto: WebView2 ", StringComparison.Ordinal))); + Assert.AreEqual(CdpPageExtensions.RestUrl, await Task.Run(() => bed.Browser.Cdp.GetMainFrameUrlAsync(ct), ct)); + } + + [TestMethod] + [Timeout(120_000, CooperativeCancellation = true)] + public async Task TheWindowComesOnScreenWithTheLeaseAndGoesAwayWithIt() + { + var ct = TestContext.CancellationToken; + await using var bed = await BrowserBed.CreateAsync("finestra"); + await bed.StartAsync(ct); + var window = await bed.OnUiAsync(() => bed.Browser.Host.Window) ?? throw new AssertFailedException("nessuna finestra"); + Assert.IsTrue(await bed.OnUiAsync(() => window.IsVisible), "the window is open"); + Assert.IsFalse(await bed.OnUiAsync(() => window.IsOnScreen), "after the start it is parked out of view"); + Assert.IsFalse(bed.Browser.UserIsDriving); + + // «Accedi a Instagram» / «Portalo in primo piano», from the connection service's thread. + await Task.Run(() => bed.Browser.ShowToUserAsync(ct), ct); + Assert.IsTrue(await bed.OnUiAsync(() => window.IsOnScreen), "the window came on screen"); + Assert.IsTrue(bed.Browser.UserIsDriving, "while it is in front the engine is still"); + Assert.IsNotNull(bed.Tracker.LastUsedAt, "using it counts for «Riprendi»"); + + // «Ho finito». + await Task.Run(() => bed.Browser.HideFromUserAsync(ct), ct); + Assert.IsFalse(await bed.OnUiAsync(() => window.IsOnScreen)); + Assert.IsFalse(bed.Browser.UserIsDriving); + + // Closing the window is «ho finito» too: out of view, still open, still painting. + await Task.Run(() => bed.Browser.ShowToUserAsync(ct), ct); + Assert.IsTrue(bed.Browser.UserIsDriving); + await bed.OnUiAsync(() => + { + window.Close(); + return true; + }); + Assert.IsFalse(bed.Browser.UserIsDriving); + Assert.IsTrue(await bed.OnUiAsync(() => window.IsVisible), "closing it never closes it"); + Assert.IsFalse(await bed.OnUiAsync(() => window.IsOnScreen)); + var jpeg = await Task.Run(() => PagePreview.CaptureAsync(bed.Browser.Cdp, 50, ct), ct); + Assert.AreEqual(0xFF, jpeg[0], "the page still draws out of view"); + Assert.IsTrue(bed.Browser.IsAvailable); + } + + [TestMethod] + [Timeout(180_000, CooperativeCancellation = true)] + public async Task ScollegaDeletesTheProfileWithTheSessionAndTheBrowserComesBackEmpty() + { + var ct = TestContext.CancellationToken; + await using var site = await TestSite.StartAsync(new TestSiteOptions(), ct); + await using var bed = await BrowserBed.CreateAsync("scollega"); + await bed.StartAsync(ct); + var cdp = bed.Browser.Cdp; + var cookie = CollectionSite.TestSite(site.SiteHost, site.CdnHost).SessionCookie; + var clock = new SystemClock(); + + // «Collegato»: the site's session cookie is in the profile. + await Task.Run( + async () => + { + await cdp.NavigateAsync(site.Url("/"), ct); + await cdp.WaitForLoadAsync(clock, TimeSpan.FromSeconds(15), ct); + }, + ct); + Assert.IsTrue(await Task.Run(() => SessionCookieProbe.HasSessionCookieAsync(cdp, cookie, ct), ct), "connected to the test site"); + var marker = Path.Combine(bed.Browser.ProfileDirectory, "segno-della-prova"); + await File.WriteAllTextAsync(marker, "x", ct); + var before = bed.Browser.Host.BrowserProcessId; + + // «Scollega», from the connection service's thread. + await Task.Run(() => bed.Browser.RestartWithEmptyProfileAsync(ct), ct); + + TestContext.WriteLine(bed.Lines.Text); + Assert.IsFalse(File.Exists(marker), "the profile folder was deleted"); + Assert.IsTrue(bed.Browser.IsAvailable, "the browser runs again"); + Assert.AreNotEqual(before, bed.Browser.Host.BrowserProcessId, "with a new browser process"); + Assert.IsFalse(await Task.Run(() => SessionCookieProbe.HasSessionCookieAsync(cdp, cookie, ct), ct), "the session went with the profile"); + Assert.AreEqual(CdpPageExtensions.RestUrl, await Task.Run(() => cdp.GetMainFrameUrlAsync(ct), ct)); + Assert.IsTrue(bed.Lines.Any("Profilo del browser cancellato; il browser è ripartito vuoto.")); + Assert.IsFalse(bed.Lines.Any("ERRORE"), bed.Lines.Text); + } + + /// + /// Regression (review of 20 October 2026): «Scollega» while the first start waits for its next attempt started the + /// browser, then the waiting attempt started a second WebView in the same window without closing the first. The + /// orphan kept its browser process alive on the profile: the next «Scollega» waited 15 s for nothing and could not + /// delete the profile (the Instagram session stayed on disk), and exiting waited 15 s more. + /// + [TestMethod] + [Timeout(180_000, CooperativeCancellation = true)] + public async Task ScollegaWhileTheFirstStartWaitsToRetryLeavesOneWebViewAndTheNextScollegaWorks() + { + var ct = TestContext.CancellationToken; + await using var bed = await BrowserBed.CreateAsync("scollega-nei-tentativi"); + + // A file where the profile folder must go: the first start fails, and fails again 5 s later. + var profile = bed.Browser.ProfileDirectory; + Directory.CreateDirectory(Path.GetDirectoryName(profile)!); + await File.WriteAllTextAsync(profile, "occupa il posto della cartella del profilo", ct); + var run = Task.Run(() => bed.Browser.RunAsync(ct), ct); + await bed.WaitUntilAsync(() => bed.Lines.Any("Nuovo tentativo fra 15 s."), TimeSpan.FromSeconds(40), "il secondo avvio non riuscito", ct); + File.Delete(profile); + + // «Scollega» while RunAsync waits 15 s for its third attempt: the browser starts with it. + await Task.Run(() => bed.Browser.RestartWithEmptyProfileAsync(ct), ct); + Assert.IsTrue(bed.Browser.IsAvailable, bed.Lines.Text); + var pid = bed.Browser.Host.BrowserProcessId; + + // The waiting attempt finds the browser running: no second WebView, the one of «Scollega» untouched. + await run.WaitAsync(TimeSpan.FromSeconds(40), ct); + var children = await bed.ChildWindowsAsync(); + Assert.HasCount(1, children, "one WebView in the window: " + string.Join(", ", children)); + Assert.AreEqual(pid, bed.Browser.Host.BrowserProcessId, "the browser process of «Scollega» is still the one in use"); + Assert.IsTrue(bed.Lines.Any("Browser di Febe pronto: WebView2 "), bed.Lines.Text); + Assert.IsTrue(bed.Browser.IsAvailable); + + // The next «Scollega»: the only browser process exits at once, the profile goes, the browser comes back. + var marker = Path.Combine(profile, "segno-della-prova"); + await File.WriteAllTextAsync(marker, "x", ct); + var watch = Stopwatch.StartNew(); + await Task.Run(() => bed.Browser.RestartWithEmptyProfileAsync(ct), ct); + TestContext.WriteLine($"Secondo «Scollega»: {watch.Elapsed.TotalSeconds:0.0} s."); + Assert.IsLessThan(10, watch.Elapsed.TotalSeconds, "no wait for a browser process that never exits"); + Assert.IsFalse(File.Exists(marker), "the profile with the session was deleted"); + Assert.HasCount(1, await bed.ChildWindowsAsync()); + Assert.IsTrue(bed.Browser.IsAvailable); + + // Exiting closes the only WebView and its process exits: no wait in vain. + watch.Restart(); + await bed.Browser.DisposeAsync(); + TestContext.WriteLine($"Arresto: {watch.Elapsed.TotalSeconds:0.0} s."); + TestContext.WriteLine(bed.Lines.Text); + Assert.IsLessThan(10, watch.Elapsed.TotalSeconds, "exiting waits for nothing"); + Assert.HasCount(2, bed.Lines.Lines.Where(l => l.Contains("ERRORE", StringComparison.Ordinal)), "only the two failed starts: " + bed.Lines.Text); + } + + /// + /// «Esci» while the start does not complete (review of 20 October 2026): the composition awaits + /// before it closes the browser, so RunAsync must stop + /// waiting as soon as it is cancelled. Here the UI thread is kept busy, as when WebView2 does not answer. + /// + [TestMethod] + [Timeout(120_000, CooperativeCancellation = true)] + public async Task OnExitTheStartStopsWaitingForAUiThreadThatDoesNotAnswer() + { + var ct = TestContext.CancellationToken; + await using var bed = await BrowserBed.CreateAsync("uscita"); + var released = false; + var busy = bed.Ui.Dispatcher.InvokeAsync(() => + { + // Thread.Sleep does not pump: nothing else runs on the UI thread meanwhile. + var until = DateTime.UtcNow.AddSeconds(60); + while (!Volatile.Read(ref released) && DateTime.UtcNow < until) + { + Thread.Sleep(20); + } + }); + + using var lifetime = CancellationTokenSource.CreateLinkedTokenSource(ct); + var run = Task.Run(() => bed.Browser.RunAsync(lifetime.Token), ct); + await Task.Delay(500, ct); + Assert.IsFalse(run.IsCompleted, "the start waits for the UI thread"); + + // «Esci»: FebeApp cancels its lifetime, then waits for RunAsync. + var watch = Stopwatch.StartNew(); + await lifetime.CancelAsync(); + try + { + await run.WaitAsync(TimeSpan.FromSeconds(10), ct); + } + finally + { + Volatile.Write(ref released, true); + await busy.Task; + } + + TestContext.WriteLine($"RunAsync è tornato {watch.Elapsed.TotalSeconds:0.0} s dopo la cancellazione."); + Assert.IsLessThan(3, watch.Elapsed.TotalSeconds, "RunAsync stops waiting at once"); + Assert.IsFalse(bed.Browser.IsAvailable); + + // The start that was waiting for the UI thread does not begin after the exit, and stopping is quick. + watch.Restart(); + await bed.Browser.DisposeAsync(); + Assert.IsLessThan(10, watch.Elapsed.TotalSeconds); + Assert.IsNull(await bed.OnUiAsync(() => bed.Browser.Host.Window), "no window was created after the exit"); + Assert.AreEqual(0, bed.Browser.Host.BrowserProcessId, "no browser process was started after the exit"); + Assert.IsFalse(bed.Lines.Any("ERRORE"), bed.Lines.Text); + Assert.IsFalse(bed.Lines.Any("Browser di Febe pronto"), bed.Lines.Text); + } + + [TestMethod] + [Timeout(180_000, CooperativeCancellation = true)] + public async Task WhenItsBrowserProcessDiesTheBrowserStartsAgainByItself() + { + var ct = TestContext.CancellationToken; + await using var bed = await BrowserBed.CreateAsync("arresto"); + await bed.StartAsync(ct); + var reconnected = 0; + bed.Browser.Host.Connection.Reconnected += (_, _) => Interlocked.Increment(ref reconnected); + + // The browser process this test started — by its id, never by name. + var pid = bed.Browser.Host.BrowserProcessId; + Assert.AreNotEqual(0, pid); + using (var process = Process.GetProcessById(pid)) + { + Assert.AreEqual("msedgewebview2", process.ProcessName, "the browser process of WebView2"); + process.Kill(); + } + + await bed.WaitUntilAsync(() => bed.Lines.Any("Browser di Febe ripartito: WebView2 "), TimeSpan.FromSeconds(90), "la ripartenza del browser", ct); + + TestContext.WriteLine(bed.Lines.Text); + Assert.IsTrue(bed.Lines.Any("WebView2: processo terminato (BrowserProcessExited).")); + Assert.IsTrue(bed.Browser.IsAvailable); + Assert.AreNotEqual(pid, bed.Browser.Host.BrowserProcessId, "a new browser process"); + Assert.AreEqual(1, Volatile.Read(ref reconnected), "the subscriptions of the session moved to the new WebView once"); + Assert.AreEqual(CdpPageExtensions.RestUrl, await Task.Run(() => bed.Browser.Cdp.GetMainFrameUrlAsync(ct), ct)); + Assert.IsFalse(bed.Lines.Any("non parte"), "the new start worked at once"); + } + + [TestMethod] + [Timeout(120_000, CooperativeCancellation = true)] + public async Task TheCompositionHostingOfS2StartsAndDrawsThePage() + { + var ct = TestContext.CancellationToken; + await using var site = await TestSite.StartAsync(new TestSiteOptions(), ct); + await using var bed = await BrowserBed.CreateAsync("composizione", BrowserHosting.Composition); + await bed.StartAsync(ct); + Assert.IsTrue(bed.Lines.Any(", composizione, fuori vista."), bed.Lines.Text); + var cdp = bed.Browser.Cdp; + var clock = new SystemClock(); + + var seen = await Task.Run( + async () => + { + await cdp.NavigateAsync(site.Url("/profilo/marta.prova/"), ct); + await cdp.WaitForLoadAsync(clock, TimeSpan.FromSeconds(15), ct); + return await cdp.EvaluateAsync("({ visibility: document.visibilityState, width: innerWidth, height: innerHeight })", ct); + }, + ct); + TestContext.WriteLine("La pagina vede: " + seen.GetRawText()); + Assert.AreEqual("visible", seen.GetProperty("visibility").GetString()); + Assert.AreEqual(1280, seen.GetProperty("width").GetInt32()); + var jpeg = await Task.Run(() => PagePreview.CaptureAsync(cdp, 60, ct), ct); + Assert.IsGreaterThan(5_000, jpeg.Length, "a real frame"); + } +} diff --git a/tests/Febe.Tests/Desktop/WebView2CdpSessionTests.cs b/tests/Febe.Tests/Desktop/WebView2CdpSessionTests.cs index f8635f1..1e85dee 100644 --- a/tests/Febe.Tests/Desktop/WebView2CdpSessionTests.cs +++ b/tests/Febe.Tests/Desktop/WebView2CdpSessionTests.cs @@ -286,6 +286,26 @@ public sealed class WebView2CdpSessionTests CollectionAssert.AreEqual(new[] { "uno", "due" }, received.ToArray()); } + [TestMethod] + public async Task AFailingReconnectionHandlerDoesNotUndoTheAttach() + { + // Attach runs inside the start of the new WebView: an error of whoever listens must not turn a start that worked + // into a failed one, retried with the same outcome for ever. + var log = new RecordingBrowserLog(); + await using var session = new WebView2CdpSession(log); + var later = 0; + session.Reconnected += (_, _) => throw new InvalidOperationException("guasto di chi ascolta"); + session.Reconnected += (_, _) => later++; + + session.Attach(new FakeDevTools()); + session.Attach(new FakeDevTools()); + + Assert.IsTrue(session.IsAttached, "the new WebView stays attached"); + Assert.AreEqual(1, later, "the other handlers still hear of it"); + Assert.IsTrue(log.Lines.Any(l => l.StartsWith("Warning ", StringComparison.Ordinal) && l.Contains("InvalidOperationException", StringComparison.Ordinal)), log.All); + Assert.AreEqual("{}", (await session.SendAsync("Page.enable", ct: TestContext.CancellationToken)).GetRawText()); + } + [TestMethod] public void ProtocolErrorsAreReadFromTheMessageOfWebView2() { diff --git a/tests/Febe.Tests/Web/InterfaceTests.cs b/tests/Febe.Tests/Web/InterfaceTests.cs index a32bfe4..52fce79 100644 --- a/tests/Febe.Tests/Web/InterfaceTests.cs +++ b/tests/Febe.Tests/Web/InterfaceTests.cs @@ -112,6 +112,21 @@ public sealed class InterfaceTests CollectionAssert.AreEqual(new[] { "begin:False", "finish" }, connection.Snapshot(), "«Ho finito» already gave the browser back"); } + [TestMethod] + public async Task ConnectedBeforeTheFirstRoundSaysTheNameIsNotKnownYet() + { + // Right after «Ho finito» the session exists but no round has read the name of the account yet. + var connection = new RecordingConnection { Status = new ConnectionStatus(ConnectionState.Connected, null, null, false, null) }; + await using var server = await DockerAsync(connection, new FakeRemoteViewHost()); + await using var ui = await UiBrowser.StartAsync(); + + await ui.OpenAsync(new Uri(server.Address, "/impostazioni/collegamento")); + await ui.WaitAsync("document.querySelector('.pannello.collegato') !== null", "collegato"); + Assert.AreEqual("Collegato", (await ui.EvalAsync("document.querySelector('.chi-collegato h2').textContent")).GetString()); + Assert.AreEqual("Nome non ancora noto", (await ui.EvalAsync("document.querySelector('.chi-collegato .muto').textContent")).GetString()); + Assert.IsFalse((await ui.EvalAsync("document.querySelector('.chi-collegato').textContent.includes('@')")).GetBoolean(), "no «@» without a name"); + } + [TestMethod] public async Task HoFinitoOnCollegamentoClosesTheRemoteView() {