Prove dell'interfaccia: Attività lasciata mentre carica non ascolta più la libreria e non mostra avvisi
Il controllo «nothing of Attività drawn over the Libreria», aggiunto con
la correzione dell'issue #8, guardava solo main: render() mette in main
la cornice della pagina nuova prima ancora di caricare il modulo, e
Attività disegna solo nei nodi della propria cornice, già staccata. Una
copia rotta apposta lo fa fallire solo scrivendo direttamente in main;
con l'ascolto della libreria rimasto, o con l'errore delle richieste
annullate mostrato come avviso sulla Libreria, la prova passava. Il
messaggio del commit 248e9f7 diceva quindi più di quanto la prova
provasse (rilievo R3 della revisione).
Ora, dopo la risposta in ritardo, la prova controlla ciò che una pagina
lasciata mentre carica può davvero lasciare: il timer di un minuto (come
prima), gli avvisi (registrati da un MutationObserver, anche quelli già
spariti) e l'ascolto della libreria. Per l'ascolto manda alla pagina un
evento «libreria» sul suo EventSource, come farebbe il flusso degli
eventi, aspetta che la Libreria richieda i suoi giorni e controlla che
Attività non abbia chiesto altro. Il controllo su main resta, con il
messaggio di ciò che prova. Una modifica pubblicata sul server non
darebbe lo stesso ordine: il flusso si iscrive in un Task.Run senza dire
quando, e raccoglie le modifiche per 300 ms.
Sulla pagina rimasta aperta la stessa modifica deve ricaricare Attività:
così la prova mostra anche che l'evento arriva davvero a chi ascolta.
Con copie rotte apposta, a velocità normale (2 giri) e con Chrome
rallentato 20 volte (1 giro): timer rimasto, ascolto rimasto, avviso
mostrato e nodo scritto in main trovati ogni volta, ciascuno dal suo
controllo; una copia senza ricarica alla modifica la trova il controllo
della pagina aperta; la copia intatta passa 2 volte su 2 e 3 su 3.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
1 parent
4b35178880
commit
44f7f93783
2 files changed
+40
-2
No files matched your search
@@ -283,3 +283,4 @@ Ogni scelta tecnica presa strada facendo, con data e motivo (specifica §15).
|
||||
| 2026-10-21 | Che dopo «Ho finito», dopo «Riprendi» o lasciando una pagina il browser non sia preso né restituito un'altra volta, le prove lo controllano quando la pagina è quieta (`WaitForQuietAsync`: nessuna richiesta in volo, quindi ogni comando è arrivato al server e la pagina ha finito il seguito di ogni risposta, comprese le richieste che fa partire lì; non aspetta ciò che la pagina rimanda, come le richieste di un osservatore, di un fotogramma, di un timer, del flusso degli eventi o di un modulo che si carica dopo, e qui basta perché il comando sbagliato partirebbe lasciando la pagina o nel seguito di una risposta) sull'elenco delle richieste della pagina (`__asked`) e su quelle viste dal server; non dopo una pausa di 300 o 500 ms. La vista chiusa sul server si aspetta | Con la pausa una macchina lenta poteva controllare prima che il comando sbagliato arrivasse, e la prova passava lo stesso; dopo «Riprendi» la vista chiusa si controllava dopo 300 ms, e lì una macchina lenta faceva fallire la prova. Con copie dell'interfaccia rotte apposta (un «cancel» dopo «Ho finito» nelle pagine Browser e Collegamento, un «begin» dopo «Riprendi», un «begin» che parte solo dopo una risposta del motore) le quattro prove falliscono in ogni giro provato, anche con Chrome rallentato 20 volte. La quiete non copre ciò che parte più tardi (rilievo della revisione): sulla Libreria con 40 elementi, al primo momento senza richieste in volo le 11 righe del mosaico, chieste da un IntersectionObserver dopo il disegno dei giorni, non erano ancora partite in 3 giri su 6 |
|
||||
| 2026-10-21 | La prova dei tasti della vista remota li manda quando il WebSocket della pagina è aperto (`__sockets` di `UiBrowser.Requests`), non 300 ms dopo che il server ha aperto la vista; la prova del mouse scrive meta e fotogramma senza pausa | Il server apre la vista prima di rispondere al socket (`RemoteViewSocket.HandleAsync`) e la pagina scarta i messaggi finché il socket non è aperto: su una macchina più lenta di 300 ms i tasti andavano persi e la prova falliva dopo 30 s. Ciò che il server scrive resta nella vista finché il socket non è aperto e la pagina ascolta da subito, quindi la pausa del mouse non serviva: il primo fotogramma sullo schermo dice già che il socket è aperto |
|
||||
| 2026-10-21 | I ridisegni rimandati di una pagina (`later`: 150 ms in «In evidenza») le prove li aspettano come timer: `PageTimers` dice quali timeout erano in sospeso in un dato momento e quando sono finiti; dopo un cambio di dimensione si aspetta un ResizeObserver della prova, chiamato dopo quelli della pagina, e i timer che quelli hanno lasciato. Il trascinamento della maniglia della fascia aspetta ogni passo nel campo dell'ora prima del successivo; l'intestazione dell'account non ha più una pausa fra un'azione e l'altra | Con pause di 500 e 600 ms il ridisegno sbagliato poteva arrivare dopo il controllo. Con 60 ms fra un passo e l'altro una macchina lenta può consegnare più passi come un solo movimento: la prova vedeva solo l'ultimo e non provava più che la maniglia segua tutto il trascinamento. La pausa dell'intestazione non proteggeva nulla: ogni giro aspetta già il menu ridisegnato. Con copie rotte apposta (ridisegno non annullato, osservatore non staccato, tessere tardive disegnate, trascinamento che finisce al primo passo) le prove falliscono in ogni giro provato, anche a 20x; il ridisegno non annullato si vede quando è ancora in sospeso al cambio di filtro, come prima (in tutti i giri provati lo era) |
|
||||
| 2026-10-21 | `APageLeftWhileLoadingLeavesNothingBehind` controlla che Attività, lasciata mentre carica, non lasci né il timer di un minuto, né l'ascolto della libreria, né avvisi sulla Libreria; e che, aperta, a una modifica della libreria si ricarichi. La modifica la prova la manda alla pagina come la manda il flusso degli eventi (un evento «libreria» sul suo `EventSource`, che chiama subito chi ascolta) e ne ha conferma quando la Libreria richiede i suoi giorni; gli avvisi li registra un MutationObserver, anche quelli già spariti | Rilievo della revisione: il controllo «niente di Attività sulla Libreria» guardava solo `main`, dove Attività non disegna (la sua cornice ne esce prima ancora che il modulo si carichi), e poteva fallire solo per un nodo messo lì direttamente. Con copie rotte apposta la prova di prima passava con l'ascolto della libreria rimasto e con l'errore delle richieste annullate mostrato sulla Libreria; ora le trova entrambe, a velocità normale e con Chrome rallentato 20 volte. Una modifica pubblicata sul server non darebbe lo stesso ordine: il flusso si iscrive alle modifiche in un `Task.Run`, senza dire quando, e le raccoglie per 300 ms |
|
||||
@@ -570,6 +570,29 @@ public sealed class InterfaceTests
|
||||
window.setInterval = (fn, ms, ...rest) => { const id = set(fn, ms, ...rest); live.set(id, ms); return id; };
|
||||
window.clearInterval = (id) => { live.delete(id); clear(id); };
|
||||
window.__intervals = (ms) => [...live.values()].filter((v) => v === ms).length;
|
||||
// Every short notice shown, also one already gone again.
|
||||
window.__notices = [];
|
||||
new MutationObserver((records) => {
|
||||
for (const record of records) {
|
||||
for (const node of record.addedNodes) {
|
||||
if (node.nodeType === 1 && node.matches('.brevi > *')) window.__notices.push(node.textContent);
|
||||
}
|
||||
}
|
||||
}).observe(document, { childList: true, subtree: true });
|
||||
// A change of the library as the event stream brings it: every page that listens is called before this
|
||||
// returns (the number of streams).
|
||||
const NativeSource = window.EventSource;
|
||||
const streams = [];
|
||||
window.EventSource = class extends NativeSource {
|
||||
constructor(...args) {
|
||||
super(...args);
|
||||
streams.push(this);
|
||||
}
|
||||
};
|
||||
window.__libraryChanged = () => {
|
||||
for (const stream of streams) stream.dispatchEvent(new MessageEvent('libreria', { data: '{}' }));
|
||||
return streams.length;
|
||||
};
|
||||
})();
|
||||
""");
|
||||
await ui.OpenAsync(new Uri(server.Address, "/libreria"));
|
||||
@@ -584,11 +607,25 @@ public sealed class InterfaceTests
|
||||
await ui.EvalAsync("window.__release('/api/alerts')");
|
||||
await ui.WaitAsync("window.__done['/api/alerts'] >= 1", "risposta in ritardo arrivata");
|
||||
Assert.AreEqual(0, (await ui.EvalAsync("window.__intervals(60000)")).GetInt32(), "the minute timer of Attività is gone with its page");
|
||||
Assert.IsTrue((await ui.EvalAsync("document.querySelector('main .attivita') === null && document.querySelector('main .benvenuto') !== null")).GetBoolean(), "nothing of Attività drawn over the Libreria " + ui.Report());
|
||||
|
||||
// The page that stays open still works as usual.
|
||||
// Nothing of it is shown over the Libreria: what it draws went with its frame, so only a short notice, or a
|
||||
// node put straight into the page area, could show.
|
||||
var notices = await ui.EvalAsync<string[]>("window.__notices");
|
||||
Assert.IsEmpty(notices, "no notice of Attività over the Libreria: " + string.Join(" | ", notices));
|
||||
Assert.IsTrue((await ui.EvalAsync("document.querySelector('main .attivita') === null && document.querySelector('main .benvenuto') !== null")).GetBoolean(), "nothing of Attività in the page area " + ui.Report());
|
||||
|
||||
// Nor does it still listen to the library: a change reaches the Libreria, which asks for its days again, and
|
||||
// Attività asks for nothing more than when it was opened.
|
||||
var days = (await ui.AskedAsync("GET /api/library/days")).Length;
|
||||
Assert.AreEqual(1, (await ui.EvalAsync("window.__libraryChanged()")).GetInt32(), "the event stream of the interface");
|
||||
await ui.WaitAsync($"window.__asked.filter((r) => r.includes('GET /api/library/days')).length > {days}", "Libreria aggiornata dopo la modifica");
|
||||
CollectionAssert.AreEqual(new[] { "GET /api/alerts" }, await ui.AskedAsync("/api/alerts"), "Attività, left, no longer listens to the library");
|
||||
|
||||
// The page that stays open still works as usual: its minute timer runs, and a change of the library reloads it.
|
||||
await ui.NavigateAsync("/attivita");
|
||||
await ui.WaitAsync("window.__intervals(60000) === 1", "Attività aperta");
|
||||
await ui.EvalAsync("window.__libraryChanged()");
|
||||
await ui.WaitAsync("window.__asked.filter((r) => r.includes('/api/alerts')).length >= 3", "Attività aggiornata dopo la modifica");
|
||||
await ui.NavigateAsync("/libreria");
|
||||
await ui.WaitAsync("window.__intervals(60000) === 0", "Attività lasciata");
|
||||
}
|
||||
|
||||
Reference in new issue
Block a user