1
00:00:03,767 --> 00:00:05,718
Esto es testbed-qemu.

2
00:00:05,718 --> 00:00:09,619
Arranca un router prplOS
real dentro de QEMU.

3
00:00:10,120 --> 00:00:14,300
A ese router lo llamamos
dispositivo bajo prueba, o DUT.

4
00:00:14,800 --> 00:00:19,373
Ejecuta las pruebas cram de prplOS,
las mismas que ejecuta la CI.

5
00:00:19,873 --> 00:00:24,837
Arranca el DUT en tu equipo, con
la imagen de prplOS que elijas.

6
00:00:29,197 --> 00:00:33,692
Docker Compose o Podman sin root
ejecuta el contenedor de testbed-qemu.

7
00:00:33,692 --> 00:00:38,740
Dentro del contenedor, el host de pruebas
ejecuta cram, SSH y la consola serial.

8
00:00:38,740 --> 00:00:43,235
A su lado, QEMU arranca el DUT
y usa KVM si el host lo tiene.

9
00:00:43,235 --> 00:00:45,586
Tres cables conectan ambos lados.

10
00:00:45,586 --> 00:00:47,937
La LAN lleva tu tráfico de pruebas.

11
00:00:47,937 --> 00:00:52,086
La WAN obtiene su dirección de
un servidor DHCP del contenedor,

12
00:00:52,086 --> 00:00:54,922
y sale al mundo exterior a través de él.

13
00:00:54,922 --> 00:00:57,480
El tercer cable es la consola serial.

14
00:00:57,480 --> 00:01:02,805
El host le da al contenedor el árbol de
prplOS y, en solo lectura, la imagen.

15
00:01:02,805 --> 00:01:07,092
También le da una carpeta para
logs y resultados y, para el shell,

16
00:01:07,092 --> 00:01:09,374
una carpeta para su disco persistente.

17
00:01:13,734 --> 00:01:19,603
Necesitas un host Linux con Docker Compose
o Podman sin root, además de git y make.

18
00:01:19,603 --> 00:01:23,020
Con KVM, el DUT arranca
en cerca de medio minuto.

19
00:01:23,020 --> 00:01:26,065
Sin KVM, QEMU sigue
funcionando, pero despacio.

20
00:01:26,565 --> 00:01:29,388
Clona el repositorio de testbed-qemu.

21
00:01:32,900 --> 00:01:34,361
Luego, make fetch.

22
00:01:34,361 --> 00:01:38,892
Descarga la imagen fijada de
prplOS y verifica su checksum.

23
00:01:38,892 --> 00:01:43,716
También escribe un árbol de pruebas
reducido de prplOS en la carpeta qa-cache.

24
00:01:44,216 --> 00:01:46,580
Luego ejecuta make test-qemu-shell.

25
00:01:46,580 --> 00:01:49,575
La primera vez, construye el contenedor.

26
00:01:49,575 --> 00:01:53,595
Arranca el DUT y abre un
shell en el contenedor.

27
00:01:57,955 --> 00:02:01,838
Los buckets como smoke necesitan
un clon real de prplOS,

28
00:02:01,838 --> 00:02:04,655
no el árbol reducido de make fetch.

29
00:02:04,655 --> 00:02:08,614
Así que clona prplOS en el
commit que fija testbed-qemu.

30
00:02:09,114 --> 00:02:10,802
Luego, make test-qemu.

31
00:02:10,802 --> 00:02:14,318
Indícale el clon y elige el smoke bucket.

32
00:02:14,318 --> 00:02:18,256
Arranca un DUT nuevo y espera
a SSH y al modelo de datos.

33
00:02:18,256 --> 00:02:23,038
Luego ejecuta las seis pruebas smoke
que el clon indica para esta placa.

34
00:02:25,502 --> 00:02:30,410
En la CI de prplOS, una merge request
puede lanzar a mano el mismo smoke bucket,

35
00:02:30,410 --> 00:02:33,967
como job de QEMU, en el mismo
contenedor de testbed-qemu.

36
00:02:33,967 --> 00:02:37,453
Ejecuta las seis pruebas
smoke y omite una de ellas.

37
00:02:37,453 --> 00:02:39,444
Luego ejecuta dos pruebas post.

38
00:02:39,444 --> 00:02:44,708
La ejecución pasó, y aun así el job
recogió información de depuración del DUT.

39
00:02:44,708 --> 00:02:47,838
El job se ejecuta en un
runner de GitLab con KVM.

40
00:02:52,198 --> 00:02:55,002
El modo shell es make test-qemu-shell.

41
00:02:55,002 --> 00:02:59,409
Obtienes un shell al instante,
mientras el DUT aún arranca.

42
00:02:59,967 --> 00:03:01,655
Presiona la flecha arriba.

43
00:03:01,655 --> 00:03:07,875
El historial del shell ya contiene
testbed-qemu wait y testbed-qemu ssh.

44
00:03:07,875 --> 00:03:12,673
El comando wait se queda esperando
hasta que el DUT responda por SSH.

45
00:03:12,673 --> 00:03:16,138
Luego ssh abre un shell de root en el DUT.

46
00:03:16,638 --> 00:03:21,446
Ahora trabajas en el DUT como root,
por ejemplo para listar sus rutas.

47
00:03:25,638 --> 00:03:31,755
Si necesitas la consola serial en vez
de SSH, ejecuta testbed-qemu console.

48
00:03:31,755 --> 00:03:33,909
Presiona Enter para ver un prompt.

49
00:03:33,909 --> 00:03:36,924
Ctrl-] te devuelve al shell.

50
00:03:41,284 --> 00:03:42,410
Agrega una prueba.

51
00:03:42,410 --> 00:03:47,967
Guárdala en el árbol de prplOS de tu
equipo: el shell ve los mismos archivos.

52
00:03:47,967 --> 00:03:52,848
Una prueba cram es un archivo de texto:
un comando y luego la salida esperada.

53
00:03:52,848 --> 00:03:56,828
Esta comprueba que SSH
llega al DUT por la LAN.

54
00:03:57,328 --> 00:03:59,474
Ejecútala con testbed-qemu cram.

55
00:03:59,474 --> 00:04:02,480
Se ejecuta contra el DUT
que ya está en marcha,

56
00:04:02,480 --> 00:04:05,270
así que la puedes repetir
sin otro arranque.

57
00:04:05,770 --> 00:04:09,455
Ahora rómpela: cambia la
salida esperada en el archivo.

58
00:04:12,270 --> 00:04:13,194
Repítela.

59
00:04:13,194 --> 00:04:18,593
Cram muestra un diff: la línea que la
prueba espera y la línea que obtuvo.

60
00:04:20,770 --> 00:04:26,064
Si la salida nueva es correcta, acéptala
con el comando cp que imprime el runner,

61
00:04:26,064 --> 00:04:26,858
en el host.

62
00:04:32,630 --> 00:04:34,940
Cuando un job de QEMU falla en la CI,

63
00:04:34,940 --> 00:04:41,043
reprodúcelo primero en tu equipo: ejecuta
la misma prueba con make test-qemu.

64
00:04:41,543 --> 00:04:45,620
Aquí ejecutamos la prueba de
reinicio del propio testbed-qemu.

65
00:04:45,620 --> 00:04:50,770
Escribe un archivo marcador, reinicia
el DUT y espera a que vuelva SSH.

66
00:04:50,770 --> 00:04:55,706
Luego comprueba que el marcador
sobrevivió y que el uptime se reinició.

67
00:04:55,706 --> 00:04:59,568
La CI de testbed-qemu ejecuta
esta prueba en cada pipeline.

68
00:05:00,068 --> 00:05:03,827
En modo lote, make test-qemu
siempre arranca una copia privada

69
00:05:03,827 --> 00:05:06,054
de la imagen, en estado de fábrica.

70
00:05:06,054 --> 00:05:10,092
El shell graba su propio disco
desde la imagen la primera vez,

71
00:05:10,092 --> 00:05:14,755
y conserva ese disco entre sesiones,
en la carpeta qemu-disk-state.

72
00:05:14,755 --> 00:05:17,748
Para limpiarlo, ejecuta
testbed-qemu disk reset.

73
00:05:17,748 --> 00:05:21,438
Luego, el próximo arranque
controlado sale como de fábrica.

74
00:05:21,938 --> 00:05:23,150
Ante un fallo,

75
00:05:23,150 --> 00:05:26,786
testbed-qemu recoge información
de depuración del DUT

76
00:05:26,786 --> 00:05:28,925
antes de apagar el DUT.

77
00:05:28,925 --> 00:05:34,914
El job de CI de prplOS que viste antes
la recoge en cada ejecución, aunque pase.

78
00:05:34,914 --> 00:05:38,265
En un shell activo, puedes
pedirla cuando quieras.

79
00:05:42,625 --> 00:05:45,473
testbed-qemu trae además
una skill para agentes.

80
00:05:45,473 --> 00:05:49,880
La skill lista los comandos exactos,
los códigos de salida y un runbook.

81
00:05:49,880 --> 00:05:53,067
Aquí Claude Code, con Sonnet,
trabaja en modo auto.

82
00:05:53,067 --> 00:05:56,729
Carga la skill y revisa
el host con el doctor,

83
00:05:56,729 --> 00:05:59,373
que primero crea la imagen del contenedor.

84
00:05:59,373 --> 00:06:03,984
Luego la prueba arranca el DUT en QEMU,
espera a SSH y al modelo de datos,

85
00:06:03,984 --> 00:06:06,086
y lanza la prueba de conectividad.

86
00:06:06,086 --> 00:06:09,679
Indica que la prueba pasó,
con las comprobaciones post,

87
00:06:09,679 --> 00:06:11,917
los tiempos de arranque y artefactos.

88
00:06:11,917 --> 00:06:16,324
La línea de estado muestra cuánto
costó en tokens, tiempo y dinero.

89
00:06:18,985 --> 00:06:24,049
testbed-qemu arranca la imagen de prplOS
que descargas, con todo su userspace.

90
00:06:24,049 --> 00:06:27,739
Le da al DUT una LAN, una WAN
y una consola serial reales.

91
00:06:27,739 --> 00:06:30,198
No reemplaza al hardware real,

92
00:06:30,198 --> 00:06:34,033
y no modela ni un switch
ni un gateway celular.