Тестирование Push-уведомлений: Полное Руководство по Валидации FCM и APNs

// Проверка инициализации FCM в приложении
import messaging from '@react-native-firebase/messaging';

async function checkFCMSetup() {
  try {
    // Проверить, правильно ли инициализирован Firebase
    const isSupported = await messaging().isDeviceRegisteredForRemoteMessages();
    console.log('Устройство зарегистрировано для FCM:', isSupported);

    // Получить и записать FCM токен
    const token = await messaging().getToken();
    console.log('FCM Токен:', token);

    // Проверить APNs токен на iOS
 (как обсуждается в [Cross-Platform Mobile Testing: Strategies for Multi-Device Success](/blog/cross-platform-mobile-testing)) (как обсуждается в [Appium 2.0: New Architecture and Cloud Integration for Modern Mobile Testing](/blog/appium-2-architecture-cloud))    if (Platform.OS === 'ios') {
      const apnsToken = await messaging().getAPNSToken();
      console.log('APNs Токен:', apnsToken);
    }

    return { success: true, token };
  } catch (error) {
    console.error('Ошибка настройки FCM:', error);
    return { success: false, error };
  }
}

// Сторона сервера: Отправка FCM уведомления через Admin SDK
const admin = require('firebase-admin');

async function sendFCMNotification(deviceToken, payload) {
  const message = {
    notification: {
      title: 'Тестовое Уведомление',
      body: 'Это тестовое сообщение',
    },
    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('Сообщение успешно отправлено:', response);
    return { success: true, messageId: response };
  } catch (error) {
    console.error('Ошибка отправки сообщения:', error);
    return { success: false, error };
  }
}

// iOS: Регистрация для удалённых уведомлений
import UserNotifications

func registerForPushNotifications() {
    UNUserNotificationCenter.current().requestAuthorization(
        options: [.alert, .sound, .badge]
    ) { granted, error in
        print("Разрешение предоставлено: \(granted)")

        guard granted else { return }

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

// Обработка успешной регистрации
func application(
    _ application: UIApplication,
    didRegisterForRemoteNotificationsWithDeviceToken deviceToken: Data
) {
    let tokenParts = deviceToken.map { data in String(format: "%02.2hhx", data) }
    let token = tokenParts.joined()
    print("Токен Устройства: \(token)")

    // Отправить токен на backend-сервер
    sendTokenToServer(token)
}

// Обработка ошибок регистрации
func application(
    _ application: UIApplication,
    didFailToRegisterForRemoteNotificationsWithError error: Error
) {
    print("Не удалось зарегистрировать: \(error)")
}

# Отправка APNs уведомления через curl
curl -v \
  --header "apns-topic: com.yourapp.bundle" \
  --header "apns-push-type: alert" \
  --header "apns-priority: 10" \
  --header "authorization: bearer $AUTH_TOKEN" \
  --data '{"aps":{"alert":{"title":"Тест","body":"Тестовое сообщение APNs"},"badge":1,"sound":"default"}}' \
  --http2 \
  https://api.push.apple.com/3/device/$DEVICE_TOKEN

// React Native: Запланировать локальное уведомление
import PushNotification from 'react-native-push-notification';

function scheduleLocalNotification() {
  PushNotification.localNotificationSchedule({
    title: 'Запланированное Уведомление',
    message: 'Это уведомление было запланировано локально',
    date: new Date(Date.now() + 60 * 1000), // 1 минута с текущего момента
    playSound: true,
    soundName: 'default',
    actions: ['Просмотреть', 'Отклонить'],
    userInfo: {
      type: 'local',
      action: 'open_detail'
    }
  });
}

// Протестировать немедленное локальное уведомление
function showLocalNotification() {
  PushNotification.localNotification({
    title: 'Немедленное Уведомление',
    message: 'Это уведомление появляется немедленно',
    bigText: 'Это более длинный текст, который будет отображен при раскрытии уведомления',
    largeIcon: 'ic_launcher',
    smallIcon: 'ic_notification'
  });
}

// iOS: Обработка удалённого уведомления
func userNotificationCenter(
    _ center: UNUserNotificationCenter,
    didReceive response: UNNotificationResponse,
    withCompletionHandler completionHandler: @escaping () -> Void
) {
    let userInfo = response.notification.request.content.userInfo

    // Извлечь пользовательские данные
    if let type = userInfo["type"] as? String,
       let action = userInfo["action"] as? String {
        handleNotificationAction(type: type, action: action)
    }

    completionHandler()
}

{
  "message": {
    "token": "fcm_токен_устройства",
    "notification": {
      "title": "Срочные Новости",
      "body": "Опубликована новая статья",
      "image": "https://example.com/image.jpg"
    },
    "data": {
      "article_id": "12345",
      "category": "технологии",
      "priority": "high",
      "click_action": "ОТКРЫТЬ_СТАТЬЮ"
    },
    "android": {
      "priority": "high",
      "ttl": "3600s",
      "notification": {
        "channel_id": "новости_обновления",
        "color": "#FF5722",
        "sound": "звук_уведомления",
        "tag": "новости",
        "click_action": "ОТКРЫТЬ_СТАТЬЮ"
      }
    },
    "apns": {
      "headers": {
        "apns-priority": "10",
        "apns-expiration": "1609459200"
      },
      "payload": {
        "aps": {
          "alert": {
            "title": "Срочные Новости",
            "body": "Опубликована новая статья",
            "launch-image": "изображение_уведомления"
          },
          "badge": 5,
          "sound": "notification.caf",
          "category": "КАТЕГОРИЯ_НОВОСТИ",
          "thread-id": "поток-новости"
        },
        "article_id": "12345"
      }
    }
  }
}

{
  "aps": {
    "alert": {
      "title": "Платёж Получен",
      "subtitle": "$500.00 зачислено",
      "body": "Ваш платёж был успешно обработан"
    },
    "badge": 1,
    "sound": "успешный_платёж.caf",
    "category": "КАТЕГОРИЯ_ПЛАТЁЖ",
    "thread-id": "платёж-12345",
    "content-available": 1,
    "mutable-content": 1
  },
  "transaction_id": "TXN-67890",
  "amount": "500.00",
  "timestamp": "2025-10-04T10:30:00Z"
}

// Валидация полезной нагрузки уведомления
function validateNotificationPayload(payload) {
  const errors = [];

  // Проверить обязательные поля
  if (!payload.notification?.title) {
    errors.push('Отсутствует заголовок уведомления');
  }

  if (!payload.notification?.body) {
    errors.push('Отсутствует тело уведомления');
  }

  // Валидировать длину заголовка (лимит FCM: 65 символов)
  if (payload.notification?.title?.length > 65) {
    errors.push('Заголовок превышает 65 символов');
  }

  // Валидировать длину тела (лимит FCM: 240 символов)
  if (payload.notification?.body?.length > 240) {
    errors.push('Тело превышает 240 символов');
  }

  // Валидировать размер полезной нагрузки данных (лимит 4KB)
  const dataSize = JSON.stringify(payload.data || {}).length;
  if (dataSize > 4096) {
    errors.push('Полезная нагрузка данных превышает лимит 4KB');
  }

  // Проверить зарезервированные ключи
  const reservedKeys = ['from', 'notification', 'message_type'];
  if (payload.data) {
    reservedKeys.forEach(key => {
      if (key in payload.data) {
        errors.push(`Зарезервированный ключ '${key}' использован в данных`);
      }
    });
  }

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

// Сторона клиента: Отслеживание получения уведомления
import messaging from '@react-native-firebase/messaging';
import analytics from '@react-native-firebase/analytics';

messaging().onMessage(async remoteMessage => {
  console.log('Уведомление получено (передний план):', remoteMessage);

  // Залогировать получение для аналитики
  await analytics().logEvent('notification_received', {
    notification_id: remoteMessage.data?.notification_id,
    type: remoteMessage.data?.type,
    timestamp: Date.now()
  });

  // Отправить подтверждение доставки на сервер
  await confirmNotificationDelivery(remoteMessage.data?.notification_id);
});

messaging().setBackgroundMessageHandler(async remoteMessage => {
  console.log('Уведомление получено (фон):', remoteMessage);

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

// Отслеживать статус доставки уведомления
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('Не удалось отследить доставку:', error);
  }
}

// Определить категории уведомлений с действиями
import PushNotificationIOS from '@react-native-community/push-notification-ios';

PushNotificationIOS.setNotificationCategories([
  {
    id: 'КАТЕГОРИЯ_СООБЩЕНИЕ',
    actions: [
      { id: 'reply', title: 'Ответить', options: { foreground: true } },
      { id: 'mark_read', title: 'Отметить Прочитанным', options: { foreground: false } },
      { id: 'delete', title: 'Удалить', options: { destructive: true } }
    ]
  },
  {
    id: 'КАТЕГОРИЯ_СОБЫТИЕ',
    actions: [
      { id: 'accept', title: 'Принять', options: { foreground: true } },
      { id: 'decline', title: 'Отклонить', options: { foreground: false } }
    ]
  }
]);

// Обработка действий уведомлений
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);
});

// Обработка deep links из уведомлений
import { Linking } from 'react-native';

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

  if (!deepLink) return;

  try {
    // Валидировать формат deep link
    const url = new URL(deepLink);

    // Парсить параметры deep link
    const route = url.pathname;
    const params = Object.fromEntries(url.searchParams);

    // Навигировать к соответствующему экрану
    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:', error);
  }
}

// Запрос разрешений на уведомления
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+ требует runtime разрешение
      const granted = await PermissionsAndroid.request(
        PermissionsAndroid.PERMISSIONS.POST_NOTIFICATIONS
      );
      return granted === PermissionsAndroid.RESULTS.GRANTED;
    } else if (Platform.OS === 'ios') {
      // Запрос разрешения 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 не требует runtime разрешение
  } catch (error) {
    console.error('Запрос разрешения не удался:', error);
    return false;
  }
}

// Проверить текущий статус разрешения
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
  };
}

// Обработка уведомлений когда приложение на переднем плане
messaging().onMessage(async remoteMessage => {
  console.log('Уведомление на переднем плане:', remoteMessage);

  // Показать кастомное уведомление внутри приложения
  showInAppNotification({
    title: remoteMessage.notification.title,
    body: remoteMessage.notification.body,
    onPress: () => handleNotificationPress(remoteMessage.data)
  });

  // Обновить счётчик бейджа
  if (Platform.OS === 'ios') {
    PushNotificationIOS.setApplicationIconBadgeNumber(
      remoteMessage.data?.badge_count || 1
    );
  }
});

// Обработка уведомлений когда приложение в фоне
messaging().setBackgroundMessageHandler(async remoteMessage => {
  console.log('Уведомление в фоне:', remoteMessage);

  // Обработать сообщения только с данными
  if (!remoteMessage.notification && remoteMessage.data) {
    await processBackgroundData(remoteMessage.data);
  }

  // Обновить локальную базу данных
  await updateLocalCache(remoteMessage.data);

  return Promise.resolve();
});

// Обработать открытие уведомления из фона/остановленного состояния
messaging().onNotificationOpenedApp(remoteMessage => {
  console.log('Уведомление открыто (фон):', remoteMessage);
  handleNotificationNavigation(remoteMessage.data);
});

// Проверить, открыло ли уведомление приложение из остановленного состояния
messaging().getInitialNotification().then(remoteMessage => {
  if (remoteMessage) {
    console.log('Уведомление открыто (остановленное состояние):', remoteMessage);
    handleNotificationNavigation(remoteMessage.data);
  }
});

// iOS: Включить фоновые режимы в Info.plist
// <key>UIBackgroundModes</key>
// <array>
//   <string>remote-notification</string>
//   <string>fetch</string>
// </array>

// Обработать тихое уведомление
messaging().setBackgroundMessageHandler(async remoteMessage => {
  if (remoteMessage.data?.silent === 'true') {
    // Выполнить фоновую синхронизацию
    await syncDataInBackground();

    // Скачать контент
    if (remoteMessage.data?.content_url) {
      await downloadContent(remoteMessage.data.content_url);
    }

    // Обновить бейдж приложения
    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"
    }
  }
}

// Создать каналы уведомлений (Android 8.0+)
import PushNotification from 'react-native-push-notification';

PushNotification.createChannel(
  {
    channelId: 'messages',
    channelName: 'Сообщения',
    channelDescription: 'Уведомления о новых сообщениях',
    playSound: true,
    soundName: 'message_sound.mp3',
    importance: 4, // Высокая важность
    vibrate: true
  },
  created => console.log(`Канал создан: ${created}`)
);

PushNotification.createChannel({
  channelId: 'promotions',
  channelName: 'Акции',
  channelDescription: 'Рекламные уведомления',
  playSound: false,
  importance: 2, // Низкая важность
  vibrate: false
});

// Создать содержимое уведомления с идентификатором потока
let content = UNMutableNotificationContent()
content.title = "Новое Сообщение"
content.body = "У вас новое сообщение от Ивана"
content.threadIdentifier = "сообщение-поток-123"
content.summaryArgument = "Иван"
content.summaryArgumentCount = 1

// Комплексная обработка ошибок
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);

    // Обработать специфичные коды ошибок
    switch(error.code) {
      case 'messaging/invalid-registration-token':
      case 'messaging/registration-token-not-registered':
        // Токен невалиден, удалить из базы данных
        await removeInvalidToken(deviceToken);
        return { success: false, error: 'Невалидный токен', action: 'removed' };

      case 'messaging/message-rate-exceeded':
        // Слишком много сообщений, реализовать backoff
        return { success: false, error: 'Превышен лимит', action: 'retry' };

      case 'messaging/mismatched-credential':
        // Неправильные учётные данные FCM
        return { success: false, error: 'Ошибка авторизации', action: 'check_config' };

      case 'messaging/invalid-payload':
        // Некорректная полезная нагрузка
        return { success: false, error: 'Невалидная нагрузка', action: 'validate' };

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

// Автоматизированное тестирование уведомлений с Jest
describe('Тесты Push-уведомлений', () => {
  let testDeviceToken;

  beforeAll(async () => {
    // Настроить тестовое окружение
    testDeviceToken = await getTestDeviceToken();
  });

  test('должно отправить и получить уведомление', async () => {
    const notificationId = `test-${Date.now()}`;

    // Отправить уведомление
    const result = await sendTestNotification(testDeviceToken, {
      title: 'Тестовое Уведомление',
      body: 'Автоматизированный тест',
      data: { notification_id: notificationId }
    });

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

    // Ждать доставки
    await new Promise(resolve => setTimeout(resolve, 3000));

    // Проверить получение
    const delivered = await checkNotificationDelivered(notificationId);
    expect(delivered).toBe(true);
  });

  test('должно корректно обработать невалидный токен', async () => {
    const invalidToken = 'невалидный-токен-12345';

    const result = await sendTestNotification(invalidToken, {
      title: 'Тест',
      body: 'Должно упасть'
    });

    expect(result.success).toBe(false);
    expect(result.error).toContain('Невалидный токен');
  });

  test('должно валидировать структуру нагрузки', () => {
    const validPayload = {
      notification: { title: 'Тест', body: 'Сообщение' },
      data: { key: 'value' }
    };

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

  test('должно отклонить слишком большую нагрузку', () => {
    const largeData = 'x'.repeat(5000);
    const invalidPayload = {
      notification: { title: 'Тест', body: 'Сообщение' },
      data: { large_field: largeData }
    };

    const validation = validateNotificationPayload(invalidPayload);
    expect(validation.valid).toBe(false);
    expect(validation.errors).toContain('Полезная нагрузка данных превышает лимит 4KB');
  });
});

// E2E тестирование уведомлений с Detox
describe('E2E Тесты Уведомлений', () => {
  beforeAll(async () => {
    await device.launchApp({
      permissions: { notifications: 'YES' }
    });
  });

  it('должно запросить разрешение на уведомления', async () => {
    await element(by.id('enable-notifications-btn')).tap();
    await expect(element(by.text('Разрешение Предоставлено'))).toBeVisible();
  });

  it('должно показать уведомление на переднем плане', async () => {
    // Отправить тестовое уведомление
    await sendE2ENotification({
      title: 'E2E Тест',
      body: 'Тестирование отображения уведомления'
    });

    // Проверить что уведомление внутри приложения появляется
    await waitFor(element(by.text('E2E Тест')))
      .toBeVisible()
      .withTimeout(5000);
  });

  it('должно навигировать при нажатии на уведомление', async () => {
    await sendE2ENotification({
      title: 'Тест Навигации',
      data: { deep_link: 'myapp://article/123' }
    });

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

    // Нажать уведомление в системном трее
    await device.openNotification();

    // Проверить что открылся правильный экран
    await expect(element(by.id('article-screen'))).toBeVisible();
  });
});