Pruebas de Notificaciones Push: Guía Completa de Validación FCM y APNs

// Verificar inicialización de FCM en tu app
import messaging from '@react-native-firebase/messaging';

async function checkFCMSetup() {
  try {
    // Verificar si Firebase está inicializado correctamente
    const isSupported = await messaging().isDeviceRegisteredForRemoteMessages();
    console.log('Dispositivo registrado para FCM:', isSupported);

    // Recuperar y registrar el token FCM
    const token = await messaging().getToken();
    console.log('Token FCM:', token);

    // Verificar token APNs en iOS
    if (Platform.OS === 'ios') {
      const apnsToken = await messaging().getAPNSToken();
      console.log('Token APNs:', apnsToken);
    }

    return { success: true, token };
  } catch (error) {
    console.error('Error de configuración FCM:', error);
    return { success: false, error };
  }
}

// Lado del servidor: Enviar notificación FCM usando Admin SDK
const admin = require('firebase-admin');

async function sendFCMNotification(deviceToken, payload) {
  const message = {
    notification: {
      title: 'Notificación de Prueba',
      body: 'Este es un mensaje de prueba',
    },
    data: {
      type: 'test',
      timestamp: Date.now().toString(),
      action: 'open_screen',
      screen: 'home'
    },
    token: deviceToken,
    android: {
      priority: 'high',
      notification: {
        channelId: 'default',
        sound: 'default',
        color: '#FF0000'
      }
    },
    apns: {
      payload: {
        aps: {
          sound: 'default',
          badge: 1,
          contentAvailable: true
        }
      }
    }
  };

  try {
    const response = await admin.messaging().send(message);
    console.log('Mensaje enviado exitosamente:', response);
    return { success: true, messageId: response };
  } catch (error) {
    console.error('Error al enviar mensaje:', error);
    return { success: false, error };
  }
}

// iOS: Registrar para notificaciones remotas
import UserNotifications

func registerForPushNotifications() {
    UNUserNotificationCenter.current().requestAuthorization(
        options: [.alert, .sound, .badge]
    ) { granted, error in
        print("Permiso otorgado: \(granted)")

        guard granted else { return }

        DispatchQueue.main.async {
            UIApplication.shared.registerForRemoteNotifications()
        }
    }
}

// Manejar registro exitoso
func application(
    _ application: UIApplication,
    didRegisterForRemoteNotificationsWithDeviceToken deviceToken: Data
) {
    let tokenParts = deviceToken.map { data in String(format: "%02.2hhx", data) }
    let token = tokenParts.joined()
    print("Token del Dispositivo: \(token)")

    // Enviar token al servidor backend
    sendTokenToServer(token)
}

// Manejar errores de registro
func application(
    _ application: UIApplication,
    didFailToRegisterForRemoteNotificationsWithError error: Error
) {
    print("Fallo al registrar: \(error)")
}

# Enviar notificación APNs usando curl
curl -v \
  --header "apns-topic: com.tuapp.bundle" \
  --header "apns-push-type: alert" \
  --header "apns-priority: 10" \
  --header "authorization: bearer $AUTH_TOKEN" \
  --data '{"aps":{"alert":{"title":"Prueba","body":"Mensaje de prueba APNs"},"badge":1,"sound":"default"}}' \
  --http2 \
  https://api.push.apple.com/3/device/$DEVICE_TOKEN

// React Native: Programar notificación local
import PushNotification from 'react-native-push-notification';

function scheduleLocalNotification() {
  PushNotification.localNotificationSchedule({
    title: 'Notificación Programada',
    message: 'Esta notificación fue programada localmente',
    date: new Date(Date.now() + 60 * 1000), // 1 minuto desde ahora
    playSound: true,
    soundName: 'default',
    actions: ['Ver', 'Descartar'],
    userInfo: {
      type: 'local',
      action: 'open_detail'
    }
  });
}

// Probar notificación local inmediata
function showLocalNotification() {
  PushNotification.localNotification({
    title: 'Notificación Inmediata',
    message: 'Esta notificación aparece inmediatamente',
    bigText: 'Este es el texto más largo que se mostrará cuando se expanda la notificación',
    largeIcon: 'ic_launcher',
    smallIcon: 'ic_notification'
  });
}

// iOS: Manejar notificación remota
func userNotificationCenter(
    _ center: UNUserNotificationCenter,
    didReceive response: UNNotificationResponse,
    withCompletionHandler completionHandler: @escaping () -> Void
) {
    let userInfo = response.notification.request.content.userInfo

    // Extraer datos personalizados
    if let type = userInfo["type"] as? String,
       let action = userInfo["action"] as? String {
        handleNotificationAction(type: type, action: action)
    }

    completionHandler()
}

{
  "message": {
    "token": "token_fcm_dispositivo",
    "notification": {
      "title": "Noticias de Última Hora",
      "body": "Nuevo artículo publicado",
      "image": "https://ejemplo.com/imagen.jpg"
    },
    "data": {
      "article_id": "12345",
      "category": "tecnologia",
      "priority": "high",
      "click_action": "ABRIR_ARTICULO"
    },
    "android": {
      "priority": "high",
      "ttl": "3600s",
      "notification": {
        "channel_id": "actualizaciones_noticias",
        "color": "#FF5722",
        "sound": "sonido_notificacion",
        "tag": "noticias",
        "click_action": "ABRIR_ARTICULO"
      }
    },
    "apns": {
      "headers": {
        "apns-priority": "10",
        "apns-expiration": "1609459200"
      },
      "payload": {
        "aps": {
          "alert": {
            "title": "Noticias de Última Hora",
            "body": "Nuevo artículo publicado",
            "launch-image": "imagen_notificacion"
          },
          "badge": 5,
          "sound": "notification.caf",
          "category": "CATEGORIA_NOTICIAS",
          "thread-id": "hilo-noticias"
        },
        "article_id": "12345"
      }
    }
  }
}

{
  "aps": {
    "alert": {
      "title": "Pago Recibido",
      "subtitle": "$500.00 depositados",
      "body": "Tu pago ha sido procesado exitosamente"
    },
    "badge": 1,
    "sound": "pago_exitoso.caf",
    "category": "CATEGORIA_PAGO",
    "thread-id": "pago-12345",
    "content-available": 1,
    "mutable-content": 1
  },
  "transaction_id": "TXN-67890",
  "amount": "500.00",
  "timestamp": "2025-10-04T10:30:00Z"
}

// Validar carga útil de notificación
function validateNotificationPayload(payload) {
  const errors = [];

  // Verificar campos requeridos
  if (!payload.notification?.title) {
    errors.push('Falta título de notificación');
  }

  if (!payload.notification?.body) {
    errors.push('Falta cuerpo de notificación');
  }

  // Validar longitud del título (límite FCM: 65 caracteres)
  if (payload.notification?.title?.length > 65) {
    errors.push('Título excede 65 caracteres');
  }

  // Validar longitud del cuerpo (límite FCM: 240 caracteres)
  if (payload.notification?.body?.length > 240) {
    errors.push('Cuerpo excede 240 caracteres');
  }

  // Validar tamaño de carga útil de datos (límite 4KB)
  const dataSize = JSON.stringify(payload.data || {}).length;
  if (dataSize > 4096) {
    errors.push('Carga útil de datos excede límite de 4KB');
  }

  // Verificar claves reservadas
  const reservedKeys = ['from', 'notification', 'message_type'];
  if (payload.data) {
    reservedKeys.forEach(key => {
      if (key in payload.data) {
        errors.push(`Clave reservada '${key}' usada en carga útil de datos`);
      }
    });
  }

  return {
    valid: errors.length === 0,
    errors
  };
}

// Lado del cliente: Rastrear recepción de notificación
import messaging from '@react-native-firebase/messaging';
import analytics from '@react-native-firebase/analytics';

messaging().onMessage(async remoteMessage => {
  console.log('Notificación recibida (primer plano):', remoteMessage);

  // Registrar recepción para analytics
  await analytics().logEvent('notification_received', {
    notification_id: remoteMessage.data?.notification_id,
    type: remoteMessage.data?.type,
    timestamp: Date.now()
  });

  // Enviar confirmación de entrega al servidor
  await confirmNotificationDelivery(remoteMessage.data?.notification_id);
});

messaging().setBackgroundMessageHandler(async remoteMessage => {
  console.log('Notificación recibida (segundo plano):', remoteMessage);

  await analytics().logEvent('notification_received_background', {
    notification_id: remoteMessage.data?.notification_id
  });
});

// Rastrear estado de entrega de notificación
async function trackNotificationDelivery(notificationId) {
  const db = admin.firestore();

  try {
    await db.collection('notifications').doc(notificationId).update({
      delivery_status: 'delivered',
      delivered_at: admin.firestore.FieldValue.serverTimestamp(),
      delivery_latency_ms: Date.now() - sentTimestamp
    });
  } catch (error) {
    console.error('Fallo al rastrear entrega:', error);
  }
}

// Definir categorías de notificación con acciones
import PushNotificationIOS from '@react-native-community/push-notification-ios';

PushNotificationIOS.setNotificationCategories([
  {
    id: 'CATEGORIA_MENSAJE',
    actions: [
      { id: 'reply', title: 'Responder', options: { foreground: true } },
      { id: 'mark_read', title: 'Marcar como Leído', options: { foreground: false } },
      { id: 'delete', title: 'Eliminar', options: { destructive: true } }
    ]
  },
  {
    id: 'CATEGORIA_EVENTO',
    actions: [
      { id: 'accept', title: 'Aceptar', options: { foreground: true } },
      { id: 'decline', title: 'Rechazar', options: { foreground: false } }
    ]
  }
]);

// Manejar acciones de notificación
PushNotificationIOS.addEventListener('notificationAction', (notification) => {
  const action = notification.action;
  const userInfo = notification.userInfo;

  switch(action) {
    case 'reply':
      navigateToChat(userInfo.chat_id);
      break;
    case 'mark_read':
      markMessageAsRead(userInfo.message_id);
      break;
    case 'delete':
      deleteMessage(userInfo.message_id);
      break;
  }

  notification.finish(PushNotificationIOS.FetchResult.NoData);
});

// Manejar deep links desde notificaciones
import { Linking } from 'react-native';

async function handleNotificationDeepLink(notification) {
  const deepLink = notification.data?.deep_link;

  if (!deepLink) return;

  try {
    // Validar formato de deep link
    const url = new URL(deepLink);

    // Parsear parámetros de deep link
    const route = url.pathname;
    const params = Object.fromEntries(url.searchParams);

    // Navegar a pantalla apropiada
    switch(route) {
      case '/article':
        navigation.navigate('Article', { id: params.article_id });
        break;
      case '/profile':
        navigation.navigate('Profile', { userId: params.user_id });
        break;
      case '/settings':
        navigation.navigate('Settings', { tab: params.tab });
        break;
      default:
        navigation.navigate('Home');
    }
  } catch (error) {
    console.error('Deep link inválido:', error);
  }
}

// Solicitar permisos de notificación
import { PermissionsAndroid, Platform } from 'react-native';
import messaging from '@react-native-firebase/messaging';

async function requestNotificationPermission() {
  try {
    if (Platform.OS === 'android' && Platform.Version >= 33) {
      // Android 13+ requiere permiso en tiempo de ejecución
      const granted = await PermissionsAndroid.request(
        PermissionsAndroid.PERMISSIONS.POST_NOTIFICATIONS
      );
      return granted === PermissionsAndroid.RESULTS.GRANTED;
    } else if (Platform.OS === 'ios') {
      // Solicitud de permiso iOS
      const authStatus = await messaging().requestPermission({
        alert: true,
        badge: true,
        sound: true,
        provisional: false
      });

      return authStatus === messaging.AuthorizationStatus.AUTHORIZED ||
             authStatus === messaging.AuthorizationStatus.PROVISIONAL;
    }

    return true; // Android < 13 no requiere permiso en tiempo de ejecución
  } catch (error) {
    console.error('Fallo solicitud de permiso:', error);
    return false;
  }
}

// Verificar estado actual de permiso
async function checkNotificationPermission() {
  const authStatus = await messaging().getNotificationSettings();

  return {
    enabled: authStatus.authorizationStatus === messaging.AuthorizationStatus.AUTHORIZED,
    provisional: authStatus.authorizationStatus === messaging.AuthorizationStatus.PROVISIONAL,
    denied: authStatus.authorizationStatus === messaging.AuthorizationStatus.DENIED,
    alert: authStatus.alert === 1,
    badge: authStatus.badge === 1,
    sound: authStatus.sound === 1
  };
}

// Manejar notificaciones cuando app está en primer plano
messaging().onMessage(async remoteMessage => {
  console.log('Notificación en primer plano:', remoteMessage);

  // Mostrar notificación personalizada dentro de la app
  showInAppNotification({
    title: remoteMessage.notification.title,
    body: remoteMessage.notification.body,
    onPress: () => handleNotificationPress(remoteMessage.data)
  });

  // Actualizar contador de insignia
  if (Platform.OS === 'ios') {
    PushNotificationIOS.setApplicationIconBadgeNumber(
      remoteMessage.data?.badge_count || 1
    );
  }
});

// Manejar notificaciones cuando app está en segundo plano
messaging().setBackgroundMessageHandler(async remoteMessage => {
  console.log('Notificación en segundo plano:', remoteMessage);

  // Procesar mensajes solo de datos
  if (!remoteMessage.notification && remoteMessage.data) {
    await processBackgroundData(remoteMessage.data);
  }

  // Actualizar base de datos local
  await updateLocalCache(remoteMessage.data);

  return Promise.resolve();
});

// Manejar apertura de notificación desde segundo plano/estado detenido
messaging().onNotificationOpenedApp(remoteMessage => {
  console.log('Notificación abierta (segundo plano):', remoteMessage);
  handleNotificationNavigation(remoteMessage.data);
});

// Verificar si notificación abrió app desde estado detenido
messaging().getInitialNotification().then(remoteMessage => {
  if (remoteMessage) {
    console.log('Notificación abierta (estado detenido):', remoteMessage);
    handleNotificationNavigation(remoteMessage.data);
  }
});

// iOS: Habilitar modos de fondo en Info.plist
// <key>UIBackgroundModes</key>
// <array>
//   <string>remote-notification</string>
//   <string>fetch</string>
// </array>

// Manejar notificación silenciosa
messaging().setBackgroundMessageHandler(async remoteMessage => {
  if (remoteMessage.data?.silent === 'true') {
    // Realizar sincronización en segundo plano
    await syncDataInBackground();

    // Descargar contenido
    if (remoteMessage.data?.content_url) {
      await downloadContent(remoteMessage.data.content_url);
    }

    // Actualizar insignia de app
    if (remoteMessage.data?.badge) {
      await updateBadgeCount(parseInt(remoteMessage.data.badge));
    }
  }
});

{
  "message": {
    "token": "device_token",
    "data": {
      "silent": "true",
      "sync_type": "messages",
      "badge": "5"
    },
    "apns": {
      "headers": {
        "apns-priority": "5",
        "apns-push-type": "background"
      },
      "payload": {
        "aps": {
          "content-available": 1
        }
      }
    },
    "android": {
      "priority": "normal"
    }
  }
}

// Crear canales de notificación (Android 8.0+)
import PushNotification from 'react-native-push-notification';

PushNotification.createChannel(
  {
    channelId: 'messages',
    channelName: 'Mensajes',
    channelDescription: 'Notificaciones para mensajes nuevos',
    playSound: true,
    soundName: 'message_sound.mp3',
    importance: 4, // Importancia alta
    vibrate: true
  },
  created => console.log(`Canal creado: ${created}`)
);

PushNotification.createChannel({
  channelId: 'promotions',
  channelName: 'Promociones',
  channelDescription: 'Notificaciones promocionales',
  playSound: false,
  importance: 2, // Importancia baja
  vibrate: false
});

// Crear contenido de notificación con identificador de hilo
let content = UNMutableNotificationContent()
content.title = "Nuevo Mensaje"
content.body = "Tienes un nuevo mensaje de Juan"
content.threadIdentifier = "mensaje-hilo-123"
content.summaryArgument = "Juan"
content.summaryArgumentCount = 1

// Manejo integral de errores
async function sendNotificationWithErrorHandling(deviceToken, payload) {
  try {
    const response = await admin.messaging().send({
      token: deviceToken,
      ...payload
    });

    return { success: true, messageId: response };
  } catch (error) {
    console.error('Error de notificación:', error);

    // Manejar códigos de error específicos
    switch(error.code) {
      case 'messaging/invalid-registration-token':
      case 'messaging/registration-token-not-registered':
        // Token inválido, eliminar de base de datos
        await removeInvalidToken(deviceToken);
        return { success: false, error: 'Token inválido', action: 'removed' };

      case 'messaging/message-rate-exceeded':
        // Demasiados mensajes, implementar retroceso
        return { success: false, error: 'Límite de tasa', action: 'retry' };

      case 'messaging/mismatched-credential':
        // Credenciales FCM incorrectas
        return { success: false, error: 'Error de autenticación', action: 'check_config' };

      case 'messaging/invalid-payload':
        // Carga útil mal formada
        return { success: false, error: 'Carga útil inválida', action: 'validate' };

      default:
        return { success: false, error: error.message, action: 'log' };
    }
  }
}

// Pruebas automatizadas de notificación con Jest
describe('Pruebas de Notificaciones Push', () => {
  let testDeviceToken;

  beforeAll(async () => {
    // Configurar entorno de prueba
    testDeviceToken = await getTestDeviceToken();
  });

  test('debería enviar y recibir notificación', async () => {
    const notificationId = `test-${Date.now()}`;

    // Enviar notificación
    const result = await sendTestNotification(testDeviceToken, {
      title: 'Notificación de Prueba',
      body: 'Prueba automatizada',
      data: { notification_id: notificationId }
    });

    expect(result.success).toBe(true);

    // Esperar entrega
    await new Promise(resolve => setTimeout(resolve, 3000));

    // Verificar recepción
    const delivered = await checkNotificationDelivered(notificationId);
    expect(delivered).toBe(true);
  });

  test('debería manejar token inválido elegantemente', async () => {
    const invalidToken = 'token-invalido-12345';

    const result = await sendTestNotification(invalidToken, {
      title: 'Prueba',
      body: 'Debería fallar'
    });

    expect(result.success).toBe(false);
    expect(result.error).toContain('Token inválido');
  });

  test('debería validar estructura de carga útil', () => {
    const validPayload = {
      notification: { title: 'Prueba', body: 'Mensaje' },
      data: { key: 'value' }
    };

    const validation = validateNotificationPayload(validPayload);
    expect(validation.valid).toBe(true);
    expect(validation.errors).toHaveLength(0);
  });

  test('debería rechazar carga útil de gran tamaño', () => {
    const largeData = 'x'.repeat(5000);
    const invalidPayload = {
      notification: { title: 'Prueba', body: 'Mensaje' },
      data: { large_field: largeData }
    };

    const validation = validateNotificationPayload(invalidPayload);
    expect(validation.valid).toBe(false);
    expect(validation.errors).toContain('Carga útil de datos excede límite de 4KB');
  });
});

// Pruebas E2E de notificación con Detox
describe('Pruebas E2E de Notificaciones', () => {
  beforeAll(async () => {
    await device.launchApp({
      permissions: { notifications: 'YES' }
    });
  });

  it('debería solicitar permiso de notificación', async () => {
    await element(by.id('enable-notifications-btn')).tap();
    await expect(element(by.text('Permiso Otorgado'))).toBeVisible();
  });

  it('debería mostrar notificación en primer plano', async () => {
    // Enviar notificación de prueba
    await sendE2ENotification({
      title: 'Prueba E2E',
      body: 'Probando visualización de notificación'
    });

    // Verificar que aparece notificación dentro de la app
    await waitFor(element(by.text('Prueba E2E')))
      .toBeVisible()
      .withTimeout(5000);
  });

  it('debería navegar al tocar notificación', async () => {
    await sendE2ENotification({
      title: 'Prueba de Navegación',
      data: { deep_link: 'miapp://articulo/123' }
    });

    await device.sendToHome();
    await device.launchApp({ newInstance: false });

    // Tocar notificación en bandeja del sistema
    await device.openNotification();

    // Verificar que se abrió pantalla correcta
    await expect(element(by.id('article-screen'))).toBeVisible();
  });
});