Prove dell'interfaccia: ridisegni rimandati e trascinamento senza pause
AfterInEvidenzaTheOtherTabsStayTheirs aspettava 500 e 600 ms perché un ridisegno rimasto di «In evidenza» (150 ms dopo un cambio di dimensione) avesse il tempo di coprire i post. Ora aspetta i timer della pagina che erano in sospeso al cambio di filtro (PageTimers) e, dopo il cambio di dimensione, un ResizeObserver della prova, chiamato dopo quelli della pagina, e i timer che quelli hanno lasciato. TheWindowBarHandleFollowsTheWholeDrag lasciava 60 ms fra un passo e l'altro del trascinamento: su una macchina lenta più passi possono arrivare come un solo movimento, e la prova non provava più che la maniglia segua tutto il trascinamento. Ora ogni passo aspetta il suo orario nel campo prima del successivo. TheAccountHeaderFollowsEveryMenuAction aveva 200 ms fra un'azione e l'altra che non proteggevano nulla: ogni giro aspetta già l'intestazione ridisegnata. Con copie dell'interfaccia 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 con Chrome rallentato 20 volte. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
1 parent
7a9c235552
commit
7513f41d4d
2 files changed
+75
-8
No files matched your search
@@ -282,3 +282,4 @@ Ogni scelta tecnica presa strada facendo, con data e motivo (specifica §15).
|
||||
| 2026-10-21 | Nelle prove dell'interfaccia una risposta è in ritardo perché la prova la trattiene, mai per un tempo fisso. `UiBrowser.Requests` (al posto di `FetchDelays`) trattiene le richieste scelte finché la prova non le rilascia (`__hold`, `__release`), conta quelle partite (`__started`) e quelle finite (`__done`: dopo la continuazione della pagina e, se lo legge, dopo il corpo della risposta) e registra ogni richiesta della pagina (`__asked`). La prova aspetta che la pagina abbia chiesto, fa ciò che deve venire prima (lasciare la pagina, cambiare filtro), rilascia e controlla quando la pagina ne ha finito | Issue #8: `APageLeftWhileLoadingLeavesNothingBehind` tornava alla Libreria 200 ms dopo `navigate('/attivita')`. Su una macchina lenta Attività non aveva ancora caricato `activity.js` e `day-strip.js`: la pagina era lasciata prima di montarsi, `/api/alerts` non partiva mai e l'attesa scadeva dopo 30 s. Con Chrome rallentato 20 volte (`Emulation.setCPUThrottlingRate`, solo in locale) falliva 3 volte su 3 con lo stesso messaggio e la stessa riga, e in 4 giri su 5 i due moduli arrivavano dopo il ritorno alla Libreria (fra 212 e 549 ms). `ABrowserPageLeftWhileLoadingNeverTakesTheBrowser` aveva una finestra di 150 ms, e la sua regola di 600 ms tratteneva anche un `begin` mandato per errore, che arrivava al server dopo il controllo: con la pagina Browser rotta apposta la prova passava |
|
||||
| 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 ogni risposta è stata usata, anche quando ne fa partire un'altra) 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 |
|
||||
| 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) |
|
||||
@@ -50,6 +50,33 @@ public sealed class InterfaceTests
|
||||
})();
|
||||
""";
|
||||
|
||||
/// <summary>
|
||||
/// Installed before the page scripts: <c>window.__timers()</c> lists the timeouts of the page still pending and
|
||||
/// <c>window.__timersOver(ids)</c> says whether those have all run or been cleared. A test waits for the timers that
|
||||
/// were pending at a given moment (a debounced redraw, say) to be over, instead of a pause that may be too short.
|
||||
/// </summary>
|
||||
private const string PageTimers = """
|
||||
(() => {
|
||||
const set = window.setTimeout.bind(window);
|
||||
const clear = window.clearTimeout.bind(window);
|
||||
const pending = new Set();
|
||||
window.setTimeout = (fn, ms, ...rest) => {
|
||||
const id = set((...args) => {
|
||||
pending.delete(id);
|
||||
fn(...args);
|
||||
}, ms, ...rest);
|
||||
pending.add(id);
|
||||
return id;
|
||||
};
|
||||
window.clearTimeout = (id) => {
|
||||
pending.delete(id);
|
||||
clear(id);
|
||||
};
|
||||
window.__timers = () => [...pending];
|
||||
window.__timersOver = (ids) => ids.every((id) => !pending.has(id));
|
||||
})();
|
||||
""";
|
||||
|
||||
// ------------------------------------------------------------------------------------------ the driving lease
|
||||
|
||||
[TestMethod]
|
||||
@@ -325,15 +352,47 @@ public sealed class InterfaceTests
|
||||
|
||||
await using var ui = await UiBrowser.StartAsync();
|
||||
await ui.AddInitScriptAsync(UiBrowser.Requests);
|
||||
await ui.AddInitScriptAsync(PageTimers);
|
||||
await ui.OpenAsync(new Uri(server.Address, $"/account/{account.Id}?tipo=evidenza"));
|
||||
await ui.WaitAsync("document.querySelector('main .raccolta-titolo') !== null", "raccolte in evidenza");
|
||||
|
||||
// «Post» after «In evidenza»: the posts stay, also when the area changes size.
|
||||
await ui.EvalAsync("document.querySelectorAll('.strumenti .filtri button')[0].click()");
|
||||
// «Post» after «In evidenza»: the posts stay, also once what «In evidenza» left pending has run (it redraws
|
||||
// itself 150 ms after a change of size, and it has just been drawn).
|
||||
await ui.EvalAsync("""
|
||||
(() => {
|
||||
window.__pendingAtSwitch = window.__timers();
|
||||
document.querySelectorAll('.strumenti .filtri button')[0].click();
|
||||
return true;
|
||||
})()
|
||||
""");
|
||||
await ui.WaitAsync("document.querySelector('main .mosaico .gruppo-giorno') !== null", "mosaico dei post");
|
||||
await Task.Delay(500);
|
||||
await ui.WaitAsync("window.__timersOver(window.__pendingAtSwitch)", "attese di «In evidenza» finite");
|
||||
await AssertPostsShownAsync(ui);
|
||||
|
||||
// The area changes size. The page's own observers see it before this one, which came last: what they left
|
||||
// pending then (a redraw, a frame) runs, and the posts are still there.
|
||||
await ui.EvalAsync("""
|
||||
(() => {
|
||||
let before = null;
|
||||
window.__afterResize = null;
|
||||
new ResizeObserver((entries, observer) => {
|
||||
const width = entries[0].contentRect.width;
|
||||
if (before === null) {
|
||||
before = width;
|
||||
return;
|
||||
}
|
||||
if (Math.abs(width - before) < 1) return;
|
||||
observer.disconnect();
|
||||
const pending = window.__timers();
|
||||
requestAnimationFrame(() => { window.__afterResize = pending; });
|
||||
}).observe(document.querySelector('main .corpo > div'));
|
||||
window.__resizeWatched = () => before !== null;
|
||||
return true;
|
||||
})()
|
||||
""");
|
||||
await ui.WaitAsync("window.__resizeWatched()", "dimensione dei contenuti osservata");
|
||||
await ui.SendAsync("Emulation.setDeviceMetricsOverride", new JsonObject { ["width"] = 1100, ["height"] = 900, ["deviceScaleFactor"] = 1, ["mobile"] = false });
|
||||
await Task.Delay(600);
|
||||
await ui.WaitAsync("window.__afterResize !== null && window.__timersOver(window.__afterResize)", "contenuti ridisegnati alla nuova larghezza");
|
||||
await AssertPostsShownAsync(ui);
|
||||
|
||||
// «In evidenza» and at once «Post», while the tiles of the collections are still loading: they come after the
|
||||
@@ -464,7 +523,6 @@ public sealed class InterfaceTests
|
||||
})()
|
||||
""",
|
||||
$"intestazione aggiornata dopo «{choice}»");
|
||||
await Task.Delay(200);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -547,19 +605,27 @@ public sealed class InterfaceTests
|
||||
var handle = await ui.EvalAsync("(() => { const r = document.querySelector('.fascia-barra .maniglia').getBoundingClientRect(); return [r.left + r.width / 2, r.top + r.height / 2]; })()");
|
||||
var (handleX, handleY) = (handle[0].GetDouble(), handle[1].GetDouble());
|
||||
var left = barX - (barWidth / 2);
|
||||
string TimeAt(double at)
|
||||
{
|
||||
var minutes = (int)(Math.Round((at - left) / barWidth * 1440 / 15) * 15);
|
||||
return $"{minutes / 60:00}:{minutes % 60:00}";
|
||||
}
|
||||
|
||||
await ui.MouseAsync("mouseMoved", handleX, handleY);
|
||||
await ui.MouseAsync("mousePressed", handleX, handleY, buttons: 1);
|
||||
var x = handleX;
|
||||
foreach (var ratio in new[] { 0.30, 0.34, 0.38, 0.42, 0.46 })
|
||||
{
|
||||
// Each step is followed before the next one moves: a handle drawn again would lose the drag after the
|
||||
// first step, and steps sent together may reach the page as one move.
|
||||
x = left + (barWidth * ratio);
|
||||
await ui.MouseAsync("mouseMoved", x, barY, buttons: 1);
|
||||
await Task.Delay(60);
|
||||
var step = TimeAt(x);
|
||||
await ui.WaitAsync($"document.querySelector('#fascia-inizio').value === '{step}'", $"inizio della fascia a {step} durante il trascinamento");
|
||||
}
|
||||
|
||||
await ui.MouseAsync("mouseReleased", x, barY);
|
||||
var minutes = (int)(Math.Round((x - left) / barWidth * 1440 / 15) * 15);
|
||||
var expected = $"{minutes / 60:00}:{minutes % 60:00}";
|
||||
var expected = TimeAt(x);
|
||||
await ui.WaitAsync($"document.querySelector('#fascia-inizio').value === '{expected}'", $"inizio della fascia a {expected}");
|
||||
}
|
||||
|
||||
|
||||
Reference in new issue
Block a user