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()
{