~/studies/work 2026-11-09 · published 2026-11-21
Testear con un reloj congelado
Mundos controlados para tests en hakoniwa: un reloj que puedes saltar, una base de datos que puedes bifurcar, fallas que puedes sembrar. Qué probaron los spikes y el benchmark donde el tiempo de pared no mejoró.
- testing
- clock
- postgres
- benchmark
- ~/project/versatile-sh
La idea
Los tests de navegador son flaky por razones que no tienen que ver con el código bajo prueba: pasa el tiempo real, se filtra estado compartido, un servicio externo responde tarde. hakoniwa, el motor de tests, ejecuta en cambio un test dentro de un mundo controlado: el reloj es un valor que tú fijas, la base de datos es un fork de un snapshot y los servicios alrededor de la app son dobles a los que puedes hacer portarse mal.
Este post trata de dos cosas que medí. Una es si un mundo así es sólido cuando saltas el tiempo con fuerza. La otra es si el motor hace más rápida la suite. Lo primero funcionó en su mayor parte. Lo segundo no, y los números están abajo.
Un reloj que puedes saltar
Una llamada Advance fija tres cosas a la vez: los dobles (el servicio de pagos), un seam en el código propio de la app (una interfaz de reloj) y un archivo de offset de libfaketime que lee Postgres 18. El spike S8 saltó +1 h, +1 d y +30 d en secuencia, cada uno en un contenedor limitado a 2 CPUs y 4 GB.
| Salto | Advance | Orden pendiente tras el salto | La orden nueva se resuelve |
|---|---|---|---|
| +1 h | 158 ms | paid at 1 ms | 2.29 s |
| +1 d | 154 ms | paid at 1 ms | 2.02 s |
| +30 d | 155 ms | paid at 2 ms | 2.02 s |
- now(), clock_timestamp() y statement_timestamp() siguieron cada salto, en una conexión persistente y en una nueva.
- Autovacuum corrió dentro de 0.5 a 1 s del churn tras cada salto. Cada salto causó un checkpoint inmediato y luego se retomó la cadencia normal de 30 s.
- El log de Postgres contenía solo las dos líneas de arranque. Ningún ERROR, WARNING ni PANIC.
Salvedades del mismo spike: libfaketime se aplica a todo el árbol de procesos de un servidor, así que un mundo necesita su propio Postgres y no un fork en uno compartido. Cuando el archivo de offset se elimina al desmontar, el reloj del servidor retrocede la cantidad saltada, así que el servidor debe morir con su mundo. pg_cron no se probó.
Saltar mientras corre tráfico
Un salto en medio de una solicitud es el caso peligroso. El mundo solo mueve el reloj cuando juzga que la app está quieta, muestreando el trabajo en curso dos veces. El spike S10 midió con qué frecuencia ese juicio era erróneo: compradores guionados hacían pedidos, pagaban y mostraban órdenes por HTTP mientras un saltador emitía 100 saltos de +10 s con pausas de 50 a 200 ms.
| Carga | Solicitudes | Aceptados / rechazados | En curso en el salto | Fallas de webhook |
|---|---|---|---|---|
| 3 compradores, 50 a 150 ms de pausa | 3006 | 100 / 0 | 0 | 0 of 2997 |
| 4 compradores, 20 a 60 ms de pausa | 14450 | 100 / 0 | 0 | 0 of 14383 |
En más de 400 saltos aceptados, uno fue una probable falsa quietud (0.25%). Con el código final fueron 0 de 200, con un límite superior del 95% de 1.5%. Bajo carga de saturación la sonda rechazó: 106 de 106 saltos devolvieron world not quiet after 10 s, y ninguno saltó en silencio. La carrera residual es el hueco entre la última muestra y la escritura de la hora nueva.
Medir también encontró un bug del motor. Bajo carga de saturación el mundo dejaba un CPU al máximo y tardó más de 18 minutos en desmontarse tras 221k solicitudes. Un volcado de goroutines mostró al doble de pagos reescaneando cada intent en cada entrega. Ahora las liquidaciones esperan en una FIFO ordenada por tiempo, y la misma ventana atendió 55% más solicitudes con un desmontaje de 0.1 s.
Cuántos controles hacen falta
Un veredicto de reproducción compara corridas de tratamiento contra corridas de control del mundo sin modificar. El spike S11 corrió 149 controles contados en la app de checkout y vio 0 fallas. Una corrida adicional no fue ejecutable: la app perdió una carrera por un puerto, lo que cuesta una corrida y no un veredicto.
Con cero fallas, el límite unilateral del 95% sobre la tasa de flake de control es 1 - 0.05^(1/N). Es 45.1% con N = 5, el valor por defecto entonces, 25.9% con N = 10 y 5.82% con N = 50. Bajar de 5% requiere N = 59, que el máximo de 50 prohíbe. La recomendación fue subir el valor por defecto a 10 y el máximo a 60.
El negativo honesto: tiempo de pared
La meta del ADR-0011 era al menos 50% menos de tiempo de pared y de CPU-segundos que Playwright simple (config A), con los mismos veredictos. El benchmark corrió una suite de 17 specs en contenedores limitados a 4 CPUs y 6 GB, mediana de 3. B es el motor sobre Chromium con todos los atajos apagados, B+ agrega atajos solo de bench y C agrega Lightpanda.
| Config | Wall s | vs A | CPU-s | vs A | Peak MB |
|---|---|---|---|---|---|
| A | 5.3 | - | 16.4 | - | 1687 |
| B | 5.1 | -4% | 10.4 | -37% | 817 |
| B+ | 5.2 | -3% | 10.2 | -38% | 816 |
| C | 5.1 | -5% | 10.1 | -39% | 627 |
Los veredictos coincidieron con A en cada repetición. El CPU bajó 37 a 39% y la memoria cerca de la mitad, pero el tiempo de pared se mantuvo dentro del ruido. La meta no se cumplió.
Una corrida con traza explica por qué. El motor paga cerca de 1.8 s antes del primer paso: unos 0.26 s listando ids de tests, 0.24 s cargando y cerca de 0.3 s bifurcando workers y lanzando navegadores. Los 17 specs toman luego de 2.5 a 3 s con cuatro workers. Una suite de 5 s no puede amortizar un arranque fijo de ese tamaño.
Fue peor bajo una falla sembrada (una búsqueda que ignora su consulta, 3 de 17 specs fallando, una sola repetición): el tiempo de pared subió 61% para B y 130% para C. Cada spec que falla se ejecuta de nuevo con una traza, así que una falla cuesta dos intentos que esperan cada uno el timeout de expect de 5 s.
Así que el motor ahorró CPU y memoria, no tiempo, en esta suite. Lo que aún movería el tiempo de pared, según las propias notas del benchmark: un runner ya caliente cuando llega la primera corrida, ninguna pasada de listado aparte y una suite más grande sobre la cual se amortice el arranque. Ninguna de esas cosas se construyó ni se midió.
Qué me llevo
Un mundo controlado se gana su lugar en determinismo: un reloj que salta limpio, controles que no son flaky, un veredicto con un límite declarado. No se ganó una suite más rápida, y prefiero decirlo antes que citar solo la línea de CPU. La próxima medición que quiero es una suite lo bastante grande como para esconder el arranque de 1.8 s.