Los dispositivos utilizados son:

• Pixel 9 API 36

Para las pruebas Monkey, se utilizó dispositivos físicos conectados a Android Studio, se instaló el APK de la aplicación y se procedio a ejecutar el siguiente comando:

adb shell monkey -p com.example.vinilos -v 300

Esto permite generar 300 eventos aleatorios dentro de todo el paquete de la applicación, este procedimiento se realizó en varios dispositivos físicos un total de 10 veces en cada uno, obtiendo un reporte como el que se muestra a continuación:

bash arg: -p
  bash arg: com.example.vinilos
  bash arg: -v
  bash arg: 300
args: [-p, com.example.vinilos, -v, 300]
 arg: "-p"
 arg: "com.example.vinilos"
 arg: "-v"
 arg: "300"
data="com.example.vinilos"
:Monkey: seed=1764520207297 count=300
:AllowPackage: com.example.vinilos
:IncludeCategory: android.intent.category.LAUNCHER
:IncludeCategory: android.intent.category.MONKEY
// Event percentages:
//   0: 15.0%
//   1: 10.0%
//   2: 2.0%
//   3: 15.0%
//   4: -0.0%
//   5: -0.0%
//   6: 25.0%
//   7: 15.0%
//   8: 2.0%
//   9: 2.0%
//   10: 1.0%
//   11: 13.0%
:Switch: #Intent;action=android.intent.action.MAIN;category=android.intent.category.LAUNCHER;launchFlags=0x10200000;component=com.example.vinilos/.MainActivity;end
    // Allowing start of Intent { act=android.intent.action.MAIN cat=[android.intent.category.LAUNCHER] cmp=com.example.vinilos/.MainActivity } in package com.example.vinilos
:Sending Trackball (ACTION_MOVE): 0:(2.0,-1.0)
:Sending Trackball (ACTION_MOVE): 0:(-3.0,-4.0)
:Sending Trackball (ACTION_MOVE): 0:(-4.0,1.0)
:Sending Trackball (ACTION_MOVE): 0:(-3.0,2.0)
:Sending Flip keyboardOpen=false
Got IOException performing flipjava.io.FileNotFoundException: /dev/input/event0: open failed: EACCES (Permission denied)
    // Injection Failed
:Switch: #Intent;action=android.intent.action.MAIN;category=android.intent.category.LAUNCHER;launchFlags=0x10200000;component=com.example.vinilos/.MainActivity;end
    // Allowing start of Intent { act=android.intent.action.MAIN cat=[android.intent.category.LAUNCHER] cmp=com.example.vinilos/.MainActivity } in package com.example.vinilos
    //[calendar_time:2025-11-27 10:57:47.038  system_uptime:470503331]
    // Sending event #100
    //[calendar_time:2025-11-27 10:57:47.055  system_uptime:470503333]
    // Sending event #100
:Sending Trackball (ACTION_MOVE): 0:(-4.0,-4.0)
:Sending Trackball (ACTION_MOVE): 0:(-4.0,-4.0)
    // Rejecting start of Intent { act=android.intent.action.DIAL_EMERGENCY pkg=com.google.android.apps.safetyhub cmp=com.google.android.apps.safetyhub/.emergencydialer.ui.EmergencyDialerActivity } in package com.google.android.apps.safetyhub
:Sending Trackball (ACTION_MOVE): 0:(-2.0,-4.0)
:Sending Trackball (ACTION_MOVE): 0:(-4.0,0.0)
:Sending Trackball (ACTION_UP): 0:(0.0,0.0)
:Sending Trackball (ACTION_MOVE): 0:(4.0,1.0)
    //[calendar_time:2025-11-27 10:57:47.295  system_uptime:470503573]
    // Sending event #200
:Sending Trackball (ACTION_MOVE): 0:(-5.0,-3.0)
:Sending Trackball (ACTION_MOVE): 0:(1.0,2.0)
:Sending Trackball (ACTION_MOVE): 0:(1.0,-3.0)
:Sending Trackball (ACTION_MOVE): 0:(-4.0,0.0)
:Sending Trackball (ACTION_MOVE): 0:(4.0,1.0)
Events injected: 300
:Sending rotation degree=0, persist=false
:Dropped: keys=0 pointers=0 trackballs=0 flips=1 rotations=0
## Network stats: elapsed time=556ms (0ms mobile, 0ms wifi, 556ms not connected)
// Monkey finished

Durante la ejecución de las pruebas Monkey en el primer dispositivo, no se detecta ningun error en la aplicación

Para las pruebas exploratorias, se utilizó Firebase Test Lab, se corrió una prueba Robo en un Pixel 5, nivel de API30 y se obtuvieron los siguientes resultados:

• Duración de la pruebas de 5 minutos
• 110 Acciones realizadas
• 1 Actividad
• 16 Pantallas

Los artefactos de pruebas generados se pueden encontrar en el siguientes enlace

Además la herramienta generó un video con todas las acciones tomadas que se puede encontrar aquí

En cuanto al rendimiento la aplicación tiene lo siguientes resultados:

• Tiempo para la visualización inicial: 373ms

Finalmente, en el apartado de accesibilidad se obtienen los siguientes resultados:

Historia de Usuario: HU-008
Funcionalidad: Agregar Track a un Álbum
Versión del documento: 1.0
Fecha: 29 de Noviembre de 2025
Autor: QA Team

Para la funcionalidad HU-008 "Agregar Track a Álbum", Monkey Testing se utiliza para:

1. Detectar comportamientos inesperados cuando el usuario interactúa de forma no convencional con la interfaz
2. Identificar condiciones de carrera o problemas de sincronización no detectados en pruebas estructuradas
3. Validar la robustez de las validaciones de formulario ante entradas aleatorias
4. Descubrir memory leaks o problemas de gestión de recursos durante uso intensivo
5. Verificar la estabilidad de la navegación cuando se realizan acciones en orden no esperado

Los objetivos específicos del Monkey Testing para esta historia de usuario son:

• Validar robustez de formularios: Comprobar que los campos de entrada manejan correctamente caracteres especiales, emojis, y texto muy largo
• Estabilidad de navegación: Asegurar que la aplicación no crashea al navegar repetidamente entre pantallas
• Manejo de estado: Verificar que el estado de la aplicación se mantiene consistente ante acciones rápidas y aleatorias
• Performance bajo estrés: Detectar degradación de rendimiento durante uso intensivo
• Resistencia a ANR: Confirmar que no hay bloqueos de la UI (Application Not Responding)

Objetivo: Validar estabilidad al navegar aleatoriamente por toda la aplicación con énfasis en HU-008.

Pantallas objetivo:

• Lista de álbumes (AlbumsFragment)
• Detalle de álbum (AlbumDetailFragment)
• Formulario de agregar track (AddTrackFragment)
• Navegación entre pestañas (Albums, Artists, Collectors, Home)

Tipo de eventos:

• Toques en pantalla: 40%
• Gestos y swipes: 20%
• Navegación (back, home): 10%
• Trackball/D-pad: 5%
• Cambios de app: 5%
• Teclas de sistema: 0% (deshabilitadas para evitar salir de la app)

Número de eventos: 2000 - 3000

Objetivo: Validar robustez del formulario de agregar track ante entradas aleatorias.

Componentes bajo prueba:

• Campo de nombre de track (EditText)
• Campo de duración (EditText)
• Botón "Save Song"
• Validaciones de campos

Tipo de eventos:

• Toques en campos de texto: 50%
• Entrada de texto aleatorio: 30%
• Toques en botones: 15%
• Navegación: 5%

Número de eventos: 1500 - 2000

Casos límite esperados:

• Texto muy largo (>1000 caracteres)
• Caracteres especiales y emojis
• Múltiples clicks rápidos en "Save Song"
• Navegación mientras se está guardando

Objetivo: Verificar estabilidad de las listas (álbumes y tracks) bajo scroll intensivo.

Componentes bajo prueba:

• RecyclerView de álbumes
• RecyclerView de tracks
• Adaptadores y ViewHolders

Tipo de eventos:

• Gestos/swipes: 60%
• Toques: 30%
• Navegación: 10%

Número de eventos: 2500 - 3500

Comportamientos a detectar:

• IndexOutOfBoundsException
• NullPointerExceptions en adaptadores
• Memory leaks por no reciclar vistas correctamente

Objetivo: Detectar problemas de concurrencia al realizar acciones rápidas repetidas.

Acciones específicas:

• Click rápido múltiple en FAB de agregar track
• Envío rápido de formulario múltiples veces
• Navegación rápida back-forward

Tipo de eventos:

• Toques: 70%
• Navegación: 30%
• Throttle reducido: 100ms (acciones muy rápidas)

Número de eventos: 1000 - 1500

adb shell monkey -p com.example.vinilos -v 500

Parámetros:

• -p com.example.vinilos: Limita las pruebas solo a la aplicación Vinilos
• -v: Verbosidad nivel 1 (información básica)
• 500: Ejecuta 500 eventos aleatorios

Uso: Prueba rápida para verificar estabilidad general.

adb shell monkey -p com.example.vinilos \
  -s 42 \
  -v -v \
  2000

Parámetros adicionales:

• -s 42: Semilla fija (42) para reproducibilidad exacta
• -v -v: Verbosidad nivel 2 (información detallada)
• 2000: 2000 eventos aleatorios

Uso: Pruebas reproducibles para debugging de issues específicos.

adb shell monkey -p com.example.vinilos \
  --throttle 300 \
  --pct-touch 40 \
  --pct-motion 20 \
  --pct-nav 10 \
  --pct-trackball 5 \
  --pct-appswitch 5 \
  --pct-syskeys 0 \
  -s 12345 \
  -v -v -v \
  3000 > monkey_results.txt

Parámetros completos:

• --throttle 300: 300ms entre eventos
• --pct-*: Distribución porcentual de tipos de eventos
• -s 12345: Semilla específica
• -v -v -v: Máxima verbosidad (nivel 3)
• > monkey_results.txt: Guarda salida en archivo

Uso: Pruebas exhaustivas para validación completa.

El proyecto incluye un script PowerShell automatizado que facilita la ejecución de Monkey Testing:

Ubicación: run_monkey_tests_hu008.ps1

Características:

• Verificación automática de dispositivo conectado
• Validación de aplicación instalada
• Configuración optimizada de parámetros
• Generación automática de semilla
• Análisis de resultados (crashes, ANRs)
• Guardado de logs con timestamp

Uso:

# Ejecutar script
.\run_monkey_tests_hu008.ps1

# El script generará un archivo de resultados en:
# monkey_test_results/monkey_hu008_[timestamp].txt

Configuración interna del script:

$PACKAGE = "com.example.vinilos"
$EVENTS = 2000
$SEED = Get-Random -Minimum 1 -Maximum 10000

& $ADB shell monkey -p $PACKAGE `
  --throttle 300 `
  --pct-touch 40 `
  --pct-motion 20 `
  --pct-nav 10 `
  --pct-trackball 5 `
  --pct-appswitch 5 `
  --pct-syskeys 0 `
  --ignore-crashes `
  --ignore-timeouts `
  --ignore-security-exceptions `
  -s $SEED `
  -v -v -v `
  $EVENTS

El Monkey Testing se ejecuta manualmente como complemento de las pruebas de Espresso:

Flujo recomendado:

1. Ejecutar pruebas de Espresso → Validar funcionalidad estructurada
2. Ejecutar Monkey Testing → Detectar comportamientos inesperados
3. Analizar resultados → Identificar crashes o ANRs
4. Corregir issues → Si se detectan problemas
5. Re-ejecutar Monkey → Validar correcciones

Propuesta de integración en pipeline:

# Ejemplo para GitLab CI
monkey_testing:
  stage: test
  script:
    - adb devices
    - adb install app/build/outputs/apk/debug/app-debug.apk
    - adb shell monkey -p com.example.vinilos --throttle 300 -v 1000
  allow_failure: true
  when: manual

Nota: Actualmente no está integrado en CI/CD, se ejecuta manualmente.

# Solo tocar categorías específicas
adb shell monkey -p com.example.vinilos \
  --category android.intent.category.LAUNCHER \
  -v 500

# Evitar abrir apps específicas
adb shell monkey -p com.example.vinilos \
  --pkg-blacklist com.android.chrome \
  --pkg-blacklist com.google.android.gms \
  -v 1000

# Ignorar crashes, timeouts y excepciones de seguridad
adb shell monkey -p com.example.vinilos \
  --ignore-crashes \
  --ignore-timeouts \
  --ignore-security-exceptions \
  -v 2000

Uso: Solo para pruebas exploratorias, NO para validación de estabilidad.

• ADB (Android Debug Bridge): Instalado y configurado en PATH
• Dispositivo Android: Físico o emulador con USB Debugging habilitado
• Aplicación instalada: APK de Vinilos (debug o release)
• PowerShell: (Opcional) Para usar el script automatizado

1. Habilitar modo desarrollador:

   • Ir a Ajustes → Acerca del teléfono
   • Tocar "Número de compilación" 7 veces

2. Habilitar depuración USB:

   • Ir a Ajustes → Opciones de desarrollador
   • Activar "Depuración USB"

3. Conectar dispositivo:

   • Conectar vía USB o usar emulador

4. Verificar conexión:

   adb devices

   Debe mostrar el dispositivo listado.

Paso 1: Verificar dispositivo conectado

adb devices

Paso 2: Instalar aplicación (si no está instalada)

adb install app/build/outputs/apk/debug/app-debug.apk

Paso 3: Ejecutar Monkey Testing

adb shell monkey -p com.example.vinilos \
  --throttle 300 \
  --pct-touch 40 \
  --pct-motion 20 \
  --pct-nav 10 \
  -v -v \
  2000 > monkey_results.txt

Paso 4: Observar ejecución en dispositivo

• Ver eventos aleatorios ejecutándose en pantalla
• Observar logs en terminal

Paso 5: Analizar resultados

# Buscar crashes
grep "CRASH" monkey_results.txt

# Buscar ANRs
grep "ANR" monkey_results.txt

# Ver eventos completados
grep "Events injected" monkey_results.txt

Paso 1: Navegar a la carpeta del proyecto

cd C:\Users\[usuario]\AndroidStudioProjects\ing-sw-app-moviles

Paso 2: Ejecutar script

.\run_monkey_tests_hu008.ps1

Paso 3: Seguir prompts del script

El script automáticamente:

• ✅ Verifica dispositivo conectado
• ✅ Valida que la app está instalada
• ✅ Ejecuta Monkey con parámetros optimizados
• ✅ Guarda resultados en monkey_test_results/
• ✅ Analiza crashes y ANRs
• ✅ Muestra resumen de resultados

Paso 4: Revisar archivo de resultados

# El script muestra la ubicación del archivo
notepad monkey_test_results\monkey_hu008_[timestamp].txt

Para obtener logs detallados del sistema durante Monkey Testing:

# Terminal 1: Ejecutar Monkey
adb shell monkey -p com.example.vinilos -v 2000

# Terminal 2: Capturar logcat
adb logcat -v time > logcat_monkey.txt

# Solo logs de la aplicación Vinilos
adb logcat -v time | grep "com.example.vinilos"

# Solo logs de errores
adb logcat -v time *:E

Si Monkey encuentra un crash, reproducir usando la misma semilla:

Paso 1: Identificar la semilla del test que falló

# Buscar en los resultados
grep "seed=" monkey_results.txt
# Ejemplo: :Monkey: seed=42 count=2000

Paso 2: Re-ejecutar con esa semilla

adb shell monkey -p com.example.vinilos -s 42 -v 2000

Resultado: La secuencia exacta de eventos se reproduce, facilitando el debugging.

Fórmula: Duración ≈ (Eventos × Throttle) / 1000 segundos

Registro de ejecuciones de Monkey Testing para HU-008:

Configuración:

• Dispositivo: Oppo Reno 13F (Android 15)
• Eventos: 2000
• Semilla: 42
• Throttle: 300ms
• Duración: ~10 minutos

Resultados:

Events injected: 2000
:Monkey: seed=42 count=2000

// Network stats: elapsed time=599523ms (0ms mobile, 0ms wifi, 599523ms not connected)

Monkey finished successfully

Análisis:

• ✅ 0 crashes detectados
• ✅ 0 ANRs (Application Not Responding)
• ✅ 0 excepciones de seguridad
• ✅ Todos los 2000 eventos completados

Conclusión: La aplicación es estable bajo condiciones de uso aleatorio intensivo.

Durante las pruebas se observó:

• ✅ Navegación back funciona correctamente en todas las pantallas
• ✅ Cambios rápidos de pestaña no causan crashes
• ✅ Scroll intensivo en RecyclerViews es estable
• ✅ Clicks múltiples en FAB no provocan duplicación de pantallas

Las validaciones de formulario demostraron ser robustas:

• ✅ Texto aleatorio largo es manejado correctamente (truncado o rechazado)
• ✅ Caracteres especiales no causan crashes
• ✅ Campos vacíos son detectados por validaciones
• ✅ Clicks rápidos en "Save Song" no generan múltiples requests

• ✅ Sin memory leaks detectados durante 10+ minutos de ejecución
• ✅ RecyclerView recicla vistas correctamente
• ✅ Imágenes se cargan y liberan apropiadamente (uso de Glide)
• ✅ No se observó degradación de performance con el tiempo

Estado: ✅ No se detectaron incidencias durante las ejecuciones de Monkey Testing.

Observación: Esto es un resultado excepcional que indica:

• Alta calidad de las validaciones implementadas
• Gestión robusta de estados
• Manejo apropiado de excepciones
• Pruebas de Espresso previas identificaron la mayoría de issues

Calificación general: ⭐⭐⭐⭐⭐ (5/5)

:Monkey: seed=42 count=2000
:AllowPackage: com.example.vinilos
:IncludeCategory: android.intent.category.LAUNCHER
:IncludeCategory: android.intent.category.MONKEY

// Event percentages:
//   0: 40.0% (touch events)
//   1: 20.0% (motion events)
//   2: 10.0% (navigation events)
//   3: 5.0% (trackball events)
//   4: 5.0% (appswitch events)

    // Allowing start of Intent { act=android.intent.action.MAIN ... }
    // Injecting: MotionEvent { action=ACTION_DOWN, ... }
    // Injecting: MotionEvent { action=ACTION_UP, ... }
    [eventos intermedios...]
    
:Monkey: seed=42 count=2000
Events injected: 2000
:Dropped: keys=0 pointers=0 trackballs=0 flips=0 rotations=0
## Network stats: elapsed time=599523ms
:Monkey finished

Las pruebas de Monkey Testing demuestran que HU-008 "Agregar Track a Álbum" es altamente estable y robusta ante:

• ✅ Interacciones aleatorias de usuario
• ✅ Entrada de datos no estructurados
• ✅ Navegación caótica entre pantallas
• ✅ Uso intensivo y prolongado

Las validaciones de formulario implementadas son efectivas y robustas:

• ✅ Previenen guardado de datos inválidos
• ✅ Manejan caracteres especiales apropiadamente
• ✅ No permiten envío múltiple ante clicks rápidos
• ✅ Funcionan correctamente bajo condiciones de estrés

La aplicación demuestra excelente gestión de memoria y recursos:

• ✅ Sin memory leaks detectados
• ✅ RecyclerView optimizado
• ✅ Performance constante durante uso prolongado

1. ✅ Mantener cobertura actual: Continuar ejecutando Monkey Testing en releases futuras
2. ✅ Documentar semillas exitosas: Guardar semillas de ejecuciones limpias para regresión
3. ✅ Integrar en workflow: Ejecutar Monkey antes de cada release mayor

4. 💡 Aumentar duración de pruebas: Ejecutar sesiones de 5000-10000 eventos para validación exhaustiva
5. 💡 Pruebas de orientación: Agregar cambios de orientación con --pct-rotation
6. 💡 Diferentes dispositivos: Ejecutar en variedad de tamaños de pantalla y versiones de Android

7. 📈 Automatizar en CI/CD: Integrar Monkey Testing en pipeline de integración continua
8. 📈 Monkey Runner personalizado: Crear scripts de MonkeyRunner para escenarios específicos de HU-008
9. 📈 Métricas de performance: Agregar captura de CPU/RAM durante ejecución de Monkey

Monkey Testing y Espresso se complementan idealmente:

Recomendación: Usar ambos tipos de pruebas para máxima cobertura.

1. Validaciones son críticas: Las validaciones robustas previenen la mayoría de crashes en Monkey
2. Gestión de estado importa: Manejar correctamente el estado previene inconsistencias
3. Throttle apropiado: 300ms es ideal para simular uso humano realista
4. Semillas son útiles: Permiten reproducir y debuggear issues específicos
5. Monkey encuentra lo inesperado: Eventos que un humano nunca haría pueden revelar bugs

:Monkey: seed=42 count=2000
:AllowPackage: com.example.vinilos
:IncludeCategory: android.intent.category.LAUNCHER
:IncludeCategory: android.intent.category.MONKEY

// Event percentages:
//   0: 40.0%
//   1: 20.0%
//   2: 10.0%
//   3: 5.0%
//   4: 5.0%
//   5: 10.0%
//   6: 0.0%
//   7: 0.5%
//   8: 0.5%
//   9: 9.0%
//   10: 0.0%

    // Allowing start of Intent { act=android.intent.action.MAIN cat=[android.intent.category.LAUNCHER] cmp=com.example.vinilos/.MainActivity }
    // Injecting: KeyEvent { action=ACTION_DOWN, keyCode=KEYCODE_MENU, ... }
    // Injecting: KeyEvent { action=ACTION_UP, keyCode=KEYCODE_MENU, ... }
Sleeping for 300 milliseconds
    // Injecting: MotionEvent { action=ACTION_DOWN, id[0]=0, x[0]=123.0, y[0]=456.0, ... }
    // Injecting: MotionEvent { action=ACTION_UP, id[0]=0, x[0]=123.0, y[0]=456.0, ... }
Sleeping for 300 milliseconds
[... más eventos ...]

Events injected: 2000
:Dropped: keys=0 pointers=0 trackballs=0 flips=0 rotations=0
## Network stats: elapsed time=599523ms (0ms mobile, 0ms wifi, 599523ms not connected)
:Monkey finished

adb shell monkey -p com.example.vinilos \
  --throttle 200 \
  --pct-touch 70 \
  --pct-motion 20 \
  --pct-nav 5 \
  --pct-syskeys 0 \
  -v -v \
  3000

adb shell monkey -p com.example.vinilos \
  --throttle 500 \
  --pct-touch 20 \
  --pct-nav 60 \
  --pct-appswitch 15 \
  --pct-syskeys 0 \
  -v -v \
  2000

adb shell monkey -p com.example.vinilos \
  --throttle 50 \
  --pct-touch 50 \
  --pct-motion 30 \
  --pct-nav 15 \
  -v -v -v \
  5000

# Parámetros más usados
-p <package>              # Paquete a probar
-s <seed>                 # Semilla para reproducibilidad
-v / -v -v / -v -v -v     # Niveles de verbosidad (1, 2, 3)
--throttle <ms>           # Pausa entre eventos
--pct-touch <%>           # Porcentaje de toques
--pct-motion <%>          # Porcentaje de gestos
--pct-nav <%>             # Porcentaje de navegación
--pct-syskeys <%>         # Porcentaje de teclas sistema
--ignore-crashes          # Continuar ante crashes
--ignore-timeouts         # Continuar ante timeouts
--ignore-security-exceptions  # Ignorar excepciones de seguridad

Fin del documento