Skip to content
The Chat Archive
gemini-2.5-flash· Google LMArena Human Preference 140K

напиши простой пример на nock для вызова EventSource используя hapi

  1. User

    напиши простой пример на nock для вызова EventSource используя hapi

  2. Assistant

    Конечно! Давайте рассмотрим, как использовать nock для мока вызовов EventSource, когда вашим сервером является Hapi.

    Важно понимать, что когда вы тестируете клиент, который вызывает EventSource, вы обычно не запускаете ваш реальный Hapi-сервер для этого конкретного теста. Вместо этого, nock будет перехватывать HTTP-запрос, который EventSource делает, и отвечать ему так, как будто это сделал ваш Hapi-сервер, отправляя поток данных Server-Sent Events (SSE).

    Ниже приведен пример, который демонстрирует:

    1. Hapi SSE Endpoint: Как выглядит простой SSE-эндпоинт в Hapi. (Это для демонстрации того, что Hapi должен делать, но Nock будет это мокать).
    2. Nock Mock: Как настроить nock для перехвата запроса EventSource и ответа потоком SSE-данных.
    3. EventSource Client: Как клиент EventSource будет подключаться и получать данные.

    Установка зависимостей

    npm install @hapi/hapi nock eventsource
    

    Пример кода

    const Hapi = require('@hapi/hapi');
    const nock = require('nock');
    const { Readable } = require('stream');
    const EventSource = require('eventsource'); // Полифил для Node.js
    
    // --- 1. Конфигурация ---
    const BASE_URL = 'http://localhost:8080';
    const SSE_PATH = '/sse/updates';
    const FULL_SSE_URL = `${BASE_URL}${SSE_PATH}`;
    
    // --- 2. Hapi Server (для демонстрации, что Hapi делает на самом деле) ---
    // В реальном тесте, где вы используете nock, этот сервер не запускается.
    async function createAndStartHapiServer() {
      const server = Hapi.server({
        port: 8080,
        host: 'localhost',
      });
    
      server.route({
        method: 'GET',
        path: SSE_PATH,
        handler: (request, h) => {
          console.log('[Hapi Server]: Client connected to SSE endpoint.');
          const sseStream = new Readable({
            read() {} // Оставляем пустым, так как пушим вручную
          });
    
          let counter = 0;
          const intervalId = setInterval(() => {
            counter++;
            const data = `data: {"eventNum": ${counter}, "message": "Real Hapi server update"}\n\n`;
            sseStream.push(data);
            console.log(`[Hapi Server]: Sent real event ${counter}`);
            if (counter >= 3) {
              clearInterval(intervalId);
              sseStream.push(null); // Завершаем поток
              console.log('[Hapi Server]: Finished sending real events.');
            }
          }, 500);
    
          // Важные заголовки для SSE
          return h.response(sseStream)
            .header('Content-Type', 'text/event-stream')
            .header('Cache-Control', 'no-cache')
            .header('Connection', 'keep-alive');
        },
      });
    
      await server.start();
      console.log(`[Hapi Server]: Реальный Hapi сервер запущен на ${server.info.uri}`);
      return server;
    }
    
    // --- 3. Nock Mock для EventSource ---
    function setupNockMock() {
      nock.cleanAll(); // Очищаем все предыдущие моки
    
      const mockSseStream = new Readable({
        read() {} // Оставляем пустым, так как пушим вручную
      });
    
      console.log('[Nock Mock]: Настраиваем перехват EventSource запроса...');
    
      // После первого вызова, Nock будет возвращать mockSseStream
      const nockScope = nock(BASE_URL)
        .get(SSE_PATH)
        // reply принимает функцию, которая возвращает поток
        .reply(200, () => {
          console.log('[Nock Mock]: Запрос перехвачен! Начинаем имитацию стриминга SSE...');
    
          // Имитируем отправку событий с задержкой
          setTimeout(() => {
            mockSseStream.push('id: 1\n');
            mockSseStream.push('data: {"status": "started", "source": "nock"}\n\n');
            console.log('[Nock Mock]: Отправлено событие 1');
          }, 100);
    
          setTimeout(() => {
            mockSseStream.push('event: progress\n');
            mockSseStream.push('data: {"percent": 50, "source": "nock"}\n\n');
            console.log('[Nock Mock]: Отправлено событие "progress"');
          }, 300);
    
          setTimeout(() => {
            mockSseStream.push('event: complete\n');
            mockSseStream.push('data: {"result": "success", "source": "nock"}\n\n');
            mockSseStream.push(null); // Завершаем поток, EventSource закроет соединение
            console.log('[Nock Mock]: Отправлено событие "complete" и завершение потока.');
          }, 600);
    
          return mockSseStream;
        }, {
          // Важные заголовки для SSE
          'Content-Type': 'text/event-stream',
          'Cache-Control': 'no-cache',
          'Connection': 'keep-alive',
          'Access-Control-Allow-Origin': '*', // Для CORS в браузере, если нужно
        });
    
      return nockScope;
    }
    
    // --- 4. EventSource Client ---
    async function runEventSourceClient(serverInstance) {
      // Важно: в реальном тестовом сценарии вы бы не запускали serverInstance.
      // Nock перехватил бы запрос до того, как он дошел до реального сервера.
    
      const nockScope = setupNockMock(); // Настраиваем Nock для перехвата запроса
    
      console.log(`[Client]: Попытка подключения EventSource к ${FULL_SSE_URL}`);
      const es = new EventSource(FULL_SSE_URL);
    
      return new Promise((resolve, reject) => {
        es.onopen = () => {
          console.log('[Client]: Соединение EventSource открыто.');
        };
    
        es.onmessage = (event) => {
          console.log(`[Client]: Получено стандартное сообщение (id: ${event.lastEventId}):`, event.data);
        };
    
        es.addEventListener('progress', (event) => {
          console.log(`[Client]: Получено событие 'progress':`, event.data);
        });
    
        es.addEventListener('complete', (event) => {
          console.log(`[Client]: Получено событие 'complete':`, event.data);
          es.close(); // Закрываем соединение после получения последнего ожидаемого события
          console.log('[Client]: Соединение EventSource закрыто.');
    
          // Проверка, что nock был вызван
          if (nockScope.isDone()) {
            console.log('\n✅ [Test Result]: Nock успешно перехватил и ответил на запрос EventSource!');
            resolve();
          } else {
            console.error('\n❌ [Test Result]: Nock НЕ перехватил запрос EventSource.');
            reject(new Error('Nock scope not satisfied.'));
          }
        });
    
        es.onerror = (err) => {
          console.error('[Client]: Ошибка EventSource:', err);
          if (es.readyState === EventSource.CLOSED) {
            console.log('[Client]: Соединение EventSource было закрыто (возможно, Nock завершил поток).');
          }
          es.close();
          reject(err);
        };
    
        // Таймаут для гарантии завершения теста, если что-то пойдет не так
        setTimeout(() => {
          if (!nockScope.isDone()) {
            console.error('\n❌ [Test Result]: Таймаут: Nock scope не завершен.');
            es.close();
            reject(new Error('Test timeout'));
          }
        }, 2000);
      });
    }
    
    // --- Запуск примера ---
    async function main() {
      let hapiServer;
      try {
        // Запускаем реальный Hapi сервер только для того, чтобы показать его существование.
        // Nock будет перехватывать запросы до него.
        hapiServer = await createAndStartHapiServer();
    
        console.log('\n--- Запуск EventSource клиента с Nock ---');
        await runEventSourceClient(hapiServer);
    
      } catch (error) {
        console.error('Произошла ошибка в основном процессе:', error);
      } finally {
        if (hapiServer) {
          await hapiServer.stop();
          console.log('[Hapi Server]: Реальный Hapi сервер остановлен.');
        }
      }
    }
    
    main();
    

    Как это работает:

    1. createAndStartHapiServer(): Эта функция создает и запускает настоящий Hapi-сервер с SSE-эндпоинтом. Этот эндпоинт будет отправлять реальные события. Однако, когда вы запускаете EventSource клиент, nock перехватит запрос до того, как он достигнет этого реального сервера. Это сделано для демонстрации, что nock имитирует поведение Hapi-сервера.

    2. setupNockMock():

      • nock.cleanAll(): Очищает все предыдущие моки nock.
      • nock(BASE_URL).get(SSE_PATH): Это говорит nock, чтобы перехватывать все GET запросы к http://localhost:8080/sse/updates.
      • .reply(200, () => { /* stream logic */ }, { /* headers */ }): Это ключевая часть. nock возвращает HTTP-статус 200 и в качестве тела ответа передает функцию, которая возвращает Readable поток. Использование функции здесь важно, так как это гарантирует, что каждый раз, когда EventSource попытается подключиться, nock будет создавать новый поток, а не пытаться использовать уже завершенный.
      • Внутри функции reply, мы создаем Readable поток и используем setTimeout для имитации асинхронной отправки данных, как это делает реальный SSE-сервер.
      • sseStream.push('data: ...\n\n'): Мы отправляем данные в стандартном формате SSE (с двойным переводом строки \n\n в конце каждого события).
      • sseStream.push(null): Это сигнализирует Readable потоку, что данные закончились, что приводит к закрытию соединения EventSource.
      • Заголовки: Content-Type: text/event-stream, Cache-Control: no-cache, Connection: keep-alive абсолютно необходимы для правильной работы SSE.
    3. runEventSourceClient():

      • Эта функция сначала вызывает setupNockMock() для настройки перехвата.
      • Затем она создает экземпляр EventSource, указывая на тот же URL, который nock настроен перехватывать.
      • Обработчики onopen, onmessage, addEventListener, onerror используются для отслеживания состояния соединения и получения данных.
      • После получения последнего ожидаемого события (complete), соединение EventSource закрывается (es.close()), и мы проверяем, был ли nock успешно вызван (nockScope.isDone()).

    Запуск примера

    1. Сохраните код как hapi_nock_sse.js.
    2. Выполните в терминале: node hapi_nock_sse.js

    Вы увидите логи, показывающие, как Nock перехватывает запрос и имитирует отправку событий, а клиент EventSource успешно их получает. Логи реального Hapi-сервера будут минимальны, так как nock блокирует запросы до него.

    Этот подход позволяет вам тестировать логику вашего фронтенда (или любого другого клиента), которая взаимодействует с SSE, без необходимости запускать реальный бэкенд-сервер Hapi.

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.