@the-bearded-bear/claude-craft 8.8.1 → 8.8.2

package/Dev/i18n/es/ReactNative/commands/check-testing.md

@@ -1,262 +1,320 @@
 ---
-description: Verificación de Testing
+description: Verificar Testing de React Native
+argument-hint: [arguments]
 ---
 
-# Verificación de Testing
+# Verificar Testing de React Native
 
-Verifica la cobertura y calidad de los tests en React Native.
+## Argumentos
 
-## 1. Ejecutar Tests
+$ARGUMENTS
 
-```bash
-# Todos los tests
-npm test
+## Modo Plan
 
-# En modo watch
-npm test -- --watch
+> El modo plan se activa automáticamente cuando el alcance abarca varios módulos o requiere una investigación transversal.
 
-# Con cobertura
-npm test -- --coverage
+## MISIÓN
 
-# Tests específicos
-npm test -- UserProfile
-```
+Eres un experto en auditoría de testing de React Native. Tu misión es analizar la estrategia de pruebas y la cobertura de acuerdo con los estándares definidos en `.claude/rules/07-testing.md` y `.claude/rules/08-quality-tools.md`.
 
-## Modo Plan
+### Paso 1: Análisis de la configuración de pruebas
 
-> El modo plan se activa automáticamente cuando el alcance abarca varios módulos o requiere una investigación transversal.
+1. Verificar la presencia y configuración de Jest
+2. Verificar la presencia y configuración de React Native Testing Library (RNTL)
+3. Verificar la presencia y configuración de Detox (pruebas E2E)
+4. Analizar los scripts de prueba en package.json
+
+### Paso 2: Configuración de Jest (5 puntos)
+
+#### 🧪 Archivos de configuración
 
-## 2. Análisis de Cobertura
+- [ ] **(1 pt)** `jest.config.js` o configuración en package.json presente
+- [ ] **(1 pt)** Preset de React Native configurado (`@react-native/jest-preset` o equivalente)
+- [ ] **(1 pt)** Archivos de configuración definidos (`setupFilesAfterEnv`)
+- [ ] **(1 pt)** Cobertura de código habilitada (coverage)
+- [ ] **(1 pt)** Transformaciones configuradas para TypeScript y React Native
 
+**Archivos a verificar:**
 ```bash
-# Generar reporte de cobertura
-npm test -- --coverage
+jest.config.js
+jest.setup.js
+package.json
+```
 
-# Ver reporte HTML
-open coverage/lcov-report/index.html
+#### 📊 Configuración de cobertura
+
+Verificar en `jest.config.js`:
+```javascript
+coverageThreshold: {
+  global: {
+    branches: 80,
+    functions: 80,
+    lines: 80,
+    statements: 80
+  }
+}
 ```
 
-**Objetivos de Cobertura:**
-- Statements: > 80%
-- Branches: > 80%
-- Functions: > 80%
-- Lines: > 80%
+- [ ] Umbrales de cobertura definidos (≥ 80% recomendado)
+- [ ] Recopilación desde las carpetas correctas (src/, app/)
+- [ ] Exclusiones apropiadas (node_modules, __tests__, etc.)
 
-## 3. Tipos de Tests
+### Paso 3: Pruebas Unitarias con RNTL (8 puntos)
 
-### Tests Unitarios
+Referencia: `.claude/rules/07-testing.md`
 
-```typescript
-// Component.test.tsx
-describe('Button', () => {
-  it('renders correctly', () => {
-    const { getByText } = render(<Button>Click me</Button>);
-    expect(getByText('Click me')).toBeTruthy();
-  });
-});
-```
+#### 📁 Organización de pruebas
 
-**Checklist:**
-- [ ] Componentes críticos testeados
-- [ ] Hooks personalizados testeados
-- [ ] Utils y helpers testeados
-- [ ] Edge cases cubiertos
+- [ ] **(1 pt)** Pruebas colocadas junto a los componentes o en `__tests__/`
+- [ ] **(1 pt)** Convención de nomenclatura: `*.test.tsx` o `*.spec.tsx`
+- [ ] **(1 pt)** Estructura AAA (Arrange, Act, Assert) respetada
 
-### Tests de Integración
+**Archivos a verificar:**
+```bash
+src/**/__tests__/
+src/**/*.test.tsx
+src/**/*.spec.tsx
+```
 
-```typescript
-// Feature.integration.test.tsx
-describe('User Flow', () => {
-  it('completes registration', async () => {
-    const { getByText, getByPlaceholder } = render(<App />);
+#### 🧩 Calidad de las pruebas unitarias
 
-    // Navegar a registro
-    fireEvent.press(getByText('Sign Up'));
+Analizar entre 5 y 10 archivos de prueba:
 
-    // Llenar formulario
-    fireEvent.changeText(getByPlaceholder('Email'), 'user@test.com');
+- [ ] **(1 pt)** Uso de `@testing-library/react-native` (render, fireEvent, waitFor)
+- [ ] **(1 pt)** Pruebas de componentes aisladas con props simuladas
+- [ ] **(1 pt)** Pruebas de hooks personalizados con `@testing-library/react-hooks`
+- [ ] **(1 pt)** Mocks apropiados para módulos nativos (AsyncStorage, etc.)
+- [ ] **(1 pt)** Pruebas de casos límite y errores
 
-    // Submit
-    fireEvent.press(getByText('Submit'));
+**Ejemplo de buena prueba:**
+```typescript
+describe('LoginButton', () => {
+  it('should call onPress when pressed', () => {
+    const onPress = jest.fn();
+    const { getByText } = render(<LoginButton onPress={onPress} />);
+
+    fireEvent.press(getByText('Login'));
 
-    // Verificar
-    await waitFor(() => {
-      expect(getByText('Welcome')).toBeTruthy();
-    });
+    expect(onPress).toHaveBeenCalledTimes(1);
   });
 });
 ```
 
-**Checklist:**
-- [ ] Flujos de usuario críticos testeados
-- [ ] Navegación testeada
-- [ ] Formularios completos testeados
-- [ ] Integración con APIs mockeada
+### Paso 4: Pruebas de Integración (4 puntos)
 
-### Tests E2E (Detox)
+- [ ] **(1 pt)** Pruebas de flujos de usuario completos
+- [ ] **(1 pt)** Pruebas de navegación entre pantallas
+- [ ] **(1 pt)** Pruebas de llamadas a API simuladas
+- [ ] **(1 pt)** Pruebas de gestión del estado (Context, Redux, Zustand)
 
-```typescript
-// e2e/login.e2e.ts
-describe('Login Flow', () => {
-  it('should login successfully', async () => {
-    await element(by.id('email-input')).typeText('user@example.com');
-    await element(by.id('password-input')).typeText('password123');
-    await element(by.id('login-button')).tap();
-
-    await waitFor(element(by.text('Dashboard')))
-      .toBeVisible()
-      .withTimeout(5000);
-  });
-});
+**Archivos a verificar:**
+```bash
+src/**/*.integration.test.tsx
+__tests__/integration/
 ```
 
-**Checklist:**
-- [ ] Flujos críticos E2E
-- [ ] Login/Logout
-- [ ] Flujos de compra/reserva
-- [ ] Configuración Detox correcta
+### Paso 5: Pruebas E2E con Detox (4 puntos)
 
-## 4. Calidad de los Tests
+#### 🤖 Configuración de Detox
 
-### Buenos Tests
+- [ ] **(1 pt)** `.detoxrc.js` o configuración de Detox presente
+- [ ] **(1 pt)** Configuración para iOS y Android
+- [ ] **(1 pt)** Scripts de prueba E2E en package.json (`test:e2e`)
 
-```typescript
-// ✅ BIEN - Descripción clara, AAA pattern
-describe('UserProfile', () => {
-  it('displays user name after successful fetch', async () => {
-    // Arrange
-    const mockUser = { name: 'John Doe' };
-    server.use(
-      http.get('/api/user', () => HttpResponse.json(mockUser))
-    );
-
-    // Act
-    const { findByText } = render(<UserProfile />);
-
-    // Assert
-    const nameElement = await findByText('John Doe');
-    expect(nameElement).toBeTruthy();
-  });
-});
+**Archivos a verificar:**
+```bash
+.detoxrc.js
+.detoxrc.json
+e2e/
+package.json
 ```
 
-**Checklist:**
-- [ ] Nombres descriptivos
-- [ ] Patrón AAA (Arrange, Act, Assert)
-- [ ] Un solo concepto por test
-- [ ] Tests independientes
-- [ ] Sin lógica compleja en tests
+#### 🎬 Pruebas E2E
 
-## 5. Mocking
+- [ ] **(1 pt)** Al menos 3 escenarios E2E críticos probados (inicio de sesión, navegación principal, acción clave)
 
-```typescript
-// Mock de módulos
-jest.mock('@/services/api', () => ({
-  fetchUser: jest.fn()
-}));
-
-// Mock de hooks
-jest.mock('@react-navigation/native', () => ({
-  useNavigation: () => ({
-    navigate: jest.fn()
-  })
-}));
-
-// Mock de AsyncStorage
-jest.mock('@react-native-async-storage/async-storage', () =>
-  require('@react-native-async-storage/async-storage/jest/async-storage-mock')
-);
+**Archivos a verificar:**
+```bash
+e2e/**/*.e2e.ts
+e2e/**/*.e2e.js
 ```
 
-**Checklist:**
-- [ ] APIs mockeadas con MSW
-- [ ] AsyncStorage mockeado
-- [ ] Navigation mockeada
-- [ ] Módulos nativos mockeados
+### Paso 6: Cobertura de Pruebas (4 puntos)
 
-## 6. Snapshot Tests
+Ejecutar el comando de cobertura:
 
-```typescript
-it('matches snapshot', () => {
-  const tree = renderer
-    .create(<Button variant="primary">Click me</Button>)
-    .toJSON();
-  expect(tree).toMatchSnapshot();
-});
+```bash
+npm run test -- --coverage
+# o
+yarn test --coverage
 ```
 
-**Checklist:**
-- [ ] Componentes UI críticos con snapshots
-- [ ] Snapshots actualizados regularmente
-- [ ] Cambios de snapshot revisados
-- [ ] No abusar de snapshots
+Analizar el informe de cobertura:
 
-## 7. Tests de Performance
+- [ ] **(1 pt)** Cobertura global ≥ 80%
+- [ ] **(1 pt)** Cobertura de ramas ≥ 75%
+- [ ] **(1 pt)** Componentes críticos cubiertos al 100%
+- [ ] **(1 pt)** Informe de cobertura generado (coverage/lcov-report/)
 
-```typescript
-it('renders large list efficiently', () => {
-  const items = Array.from({ length: 1000 }, (_, i) => ({ id: i }));
+**Archivos a verificar:**
+```bash
+coverage/lcov-report/index.html
+coverage/coverage-summary.json
+```
 
-  const start = performance.now();
-  render(<ItemList items={items} />);
-  const end = performance.now();
+### Paso 7: Calcular la puntuación
 
-  expect(end - start).toBeLessThan(100); // menos de 100ms
-});
+```
+┌──────────────────────────────────┬─────────┬────────┐
+│ Criterio                         │ Puntos  │ Estado │
+├──────────────────────────────────┼─────────┼────────┤
+│ Configuración de Jest            │ XX/5    │ ✅/⚠️/❌│
+│ Pruebas Unitarias (RNTL)         │ XX/8    │ ✅/⚠️/❌│
+│ Pruebas de Integración           │ XX/4    │ ✅/⚠️/❌│
+│ Pruebas E2E (Detox)              │ XX/4    │ ✅/⚠️/❌│
+│ Cobertura de Código              │ XX/4    │ ✅/⚠️/❌│
+├──────────────────────────────────┼─────────┼────────┤
+│ TOTAL TESTING                    │ XX/25   │ ✅/⚠️/❌│
+└──────────────────────────────────┴─────────┴────────┘
 ```
 
-## 8. Reporte de Tests
+**Leyenda:**
+- ✅ Excelente (≥ 20/25)
+- ⚠️ Advertencia (15-19/25)
+- ❌ Crítico (< 15/25)
 
-```bash
-# Ver reporte de cobertura
-npm test -- --coverage
+### Paso 8: Informe detallado
 
-# Ver tests fallidos
-npm test -- --onlyFailures
+## 📊 RESULTADOS DE LA AUDITORÍA DE TESTING
 
-# Ver tests lentos
-npm test -- --verbose
-```
+### ✅ Fortalezas
 
-## Métricas Clave
+Enumerar las buenas prácticas identificadas:
+- [Práctica 1 con ejemplo de prueba]
+- [Práctica 2 con ejemplo de prueba]
 
-| Métrica | Objetivo | Actual |
-|---------|----------|--------|
-| Cobertura Total | > 80% | ___% |
-| Tests Unitarios | > 500 | ___ |
-| Tests Integración | > 50 | ___ |
-| Tests E2E | > 10 | ___ |
-| Tiempo Ejecución | < 5 min | ___ |
+### ⚠️ Puntos de Mejora
 
-## Problemas Comunes
+Enumerar los problemas identificados por prioridad:
 
-### Tests Lentos
-```bash
-# Identificar tests lentos
-npm test -- --verbose
+1. **[Problema 1]**
+   - **Gravedad:** Crítica/Alta/Media
+   - **Ubicación:** [Archivos/componentes sin pruebas]
+   - **Impacto:** [Riesgo de regresión]
+   - **Recomendación:** [Acciones a tomar]
 
-# Usar test.concurrent para paralelizar
-it.concurrent('test 1', async () => {});
+2. **[Problema 2]**
+   - **Gravedad:** Crítica/Alta/Media
+   - **Ubicación:** [Archivos/componentes sin pruebas]
+   - **Impacto:** [Riesgo de regresión]
+   - **Recomendación:** [Acciones a tomar]
+
+### 📈 Métricas de Testing
+
+#### Cobertura de código
+
+```
+┌─────────────────┬──────────┬──────────┬──────────┬──────────┐
+│ Tipo            │ Líneas   │ Ramas    │ Funciones│ Sentencias│
+├─────────────────┼──────────┼──────────┼──────────┼──────────┤
+│ Global          │ XX.XX%   │ XX.XX%   │ XX.XX%   │ XX.XX%   │
+│ Componentes     │ XX.XX%   │ XX.XX%   │ XX.XX%   │ XX.XX%   │
+│ Hooks           │ XX.XX%   │ XX.XX%   │ XX.XX%   │ XX.XX%   │
+│ Utils           │ XX.XX%   │ XX.XX%   │ XX.XX%   │ XX.XX%   │
+│ Servicios       │ XX.XX%   │ XX.XX%   │ XX.XX%   │ XX.XX%   │
+└─────────────────┴──────────┴──────────┴──────────┴──────────┘
 ```
 
-### Tests Flaky
-- Usar waitFor para esperas asíncronas
-- No usar timeouts arbitrarios
-- Mockear APIs correctamente
-- Limpiar estado entre tests
-
-### Baja Cobertura
-- Identificar archivos sin cobertura
-- Priorizar componentes críticos
-- Escribir tests antes del código (TDD)
-- Refactorizar código no testeable
-
-## Reporte Final
-
-**Estado de Testing:**
-- [ ] Cobertura > 80%
-- [ ] Todos los tests pasando
-- [ ] Sin tests flaky
-- [ ] Tests rápidos (< 5 min)
-- [ ] CI/CD configurado
-- [ ] Tests E2E funcionando
+#### Estadísticas de pruebas
+
+- **Número total de pruebas:** XX
+  - Pruebas unitarias: XX
+  - Pruebas de integración: XX
+  - Pruebas E2E: XX
+- **Pruebas aprobadas:** XX
+- **Pruebas fallidas:** XX
+- **Tiempo total de ejecución:** XX segundos
+- **Ratio pruebas/código:** XX pruebas para YY líneas de código
+
+#### Componentes sin pruebas
+
+Enumerar los componentes críticos sin pruebas:
+1. `[Ruta/Componente]` - [Razón de criticidad]
+2. `[Ruta/Componente]` - [Razón de criticidad]
+3. `[Ruta/Componente]` - [Razón de criticidad]
+
+#### Funcionalidades críticas probadas
+
+- [ ] Autenticación (login, logout, refresh token)
+- [ ] Navegación principal
+- [ ] Formularios críticos
+- [ ] Llamadas principales a la API
+- [ ] Manejo de errores
+- [ ] Estados de carga
+- [ ] Gestión offline
+
+### 🎯 TOP 3 ACCIONES PRIORITARIAS
+
+#### 1. [ACCIÓN #1]
+- **Esfuerzo:** Bajo/Medio/Alto
+- **Impacto:** Crítico/Alto/Medio
+- **Descripción:** [Componentes/funcionalidades a probar con prioridad]
+- **Cobertura actual:** XX%
+- **Cobertura objetivo:** YY%
+- **Archivos afectados:**
+  - `[archivo1]` (cobertura: XX%)
+  - `[archivo2]` (cobertura: XX%)
+- **Ejemplo de pruebas a añadir:**
+```typescript
+describe('[Componente]', () => {
+  it('should [comportamiento]', () => {
+    // Prueba a implementar
+  });
+});
+```
+
+#### 2. [ACCIÓN #2]
+- **Esfuerzo:** Bajo/Medio/Alto
+- **Impacto:** Crítico/Alto/Medio
+- **Descripción:** [Configuración o mejora de pruebas]
+- **Archivos afectados:** [Lista]
+
+#### 3. [ACCIÓN #3]
+- **Esfuerzo:** Bajo/Medio/Alto
+- **Impacto:** Crítico/Alto/Medio
+- **Descripción:** [Pruebas E2E o de integración a añadir]
+- **Escenarios a cubrir:**
+  - [Escenario 1]
+  - [Escenario 2]
+
+---
+
+## 🚀 Recomendaciones
+
+### Victorias Rápidas (Bajo esfuerzo, alto impacto)
+- [Mejora rápida 1]
+- [Mejora rápida 2]
+
+### Inversiones (Esfuerzo medio/alto, alto impacto)
+- [Mejora estructural 1]
+- [Mejora estructural 2]
+
+### Buenas prácticas a adoptar
+- Escribir pruebas junto al código (TDD)
+- Apuntar a una cobertura mínima del 80%
+- Probar casos límite y errores
+- Mantener las pruebas actualizadas con el código
+- Usar snapshots con moderación
+
+---
+
+## 📚 Referencias
+
+- `.claude/rules/07-testing.md` - Estándares de testing
+- `.claude/rules/08-quality-tools.md` - Herramientas de calidad
+- [React Native Testing Library](https://callstack.github.io/react-native-testing-library/)
+- [Detox Documentation](https://wix.github.io/Detox/)
+
+---
+
+**Puntuación final: XX/25**