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

напиши mock с помощью nock для sse

  1. User

    напиши mock с помощью nock для sse

  2. Assistant

    Да, можно создать мок для Server-Sent Events (SSE) с помощью Nock, но это потребует немного больше усилий, чем для обычного HTTP запроса/ответа.

    Nock в основном предназначен для перехвата запросов и возврата статических или одноразовых ответов. SSE же предполагает длительное соединение и отправку множества порций данных (событий) во времени.

    Чтобы замокать SSE с помощью Nock, мы должны сделать следующее:

    1. Создать Nock перехватчик: Указать URL и метод (обычно GET) для SSE эндпоинта.
    2. Установить правильные заголовки: Ответ должен иметь Content-Type: text/event-stream. Также полезно добавить Cache-Control: no-cache и Connection: keep-alive.
    3. Вернуть поток данных: Вместо простого тела ответа, нужно вернуть Node.js Readable поток, который будет отправлять данные в формате SSE (data: ...\n\n, event: ...\n data: ...\n\n и т.д.) с течением времени.

    Вот пример кода:

    const nock = require('nock');
    const http = require('http'); // Можно использовать https или другую библиотеку, которая умеет работать с потоками ответов
    const { Readable } = require('stream');
    
    // --- Настройка Nock ---
    const baseUrl = 'http://localhost:3000'; // Замените на ваш базовый URL
    const ssePath = '/events';            // Замените на путь к вашему SSE эндпоинту
    
    // --- Создание пользовательского потока для имитации SSE ---
    class MockSseStream extends Readable {
      constructor(events, options) {
        super(options);
        // Список событий для отправки. Каждое событие - объект.
        // { data: '...', event: '...', id: '...', delay: 200 }
        this.events = events;
        this.index = 0; // Индекс текущего события
        this.isPushing = false; // Флаг для предотвращения повторных setTimeout
      }
    
      // Метод _read вызывается, когда поток готов принять больше данных
      _read() {
        if (this.isPushing) {
          // Уже запланирована отправка следующего события
          return;
        }
    
        if (this.index >= this.events.length) {
          // Все события отправлены, завершаем поток
          console.log('MockSseStream: All events sent, ending stream.');
          this.push(null);
          return;
        }
    
        this.isPushing = true; // Устанавливаем флаг
    
        const eventData = this.events[this.index];
        let chunk = '';
    
        // Форматируем данные в SSE формат
        if (eventData.id !== undefined) chunk += `id: ${eventData.id}\n`;
        if (eventData.event !== undefined) chunk += `event: ${eventData.event}\n`;
    
        // Обрабатываем многострочные данные data:
        const dataLines = eventData.data.split('\n');
        dataLines.forEach(line => {
            chunk += `data: ${line}\n`;
        });
    
        chunk += '\n'; // Разделитель событий (двойной перевод строки)
    
        const delay = eventData.delay || 100; // Задержка перед отправкой текущего события (по умолчанию 100мс)
    
        console.log(`MockSseStream: Scheduling event ${this.index} ("${eventData.event || 'message'}") with delay ${delay}ms`);
    
        // Имитируем задержку перед отправкой следующего события
        setTimeout(() => {
          console.log(`MockSseStream: Pushing event ${this.index} ("${eventData.event || 'message'}"). Chunk size: ${chunk.length}`);
          const canPushMore = this.push(chunk); // Отправляем порцию данных
          this.index++; // Переходим к следующему событию
          this.isPushing = false; // Сбрасываем флаг
    
          // Если поток еще не заполнен (canPushMore === true), он сразу же вызовет _read снова.
          // Если canPushMore === false, _read будет вызван позже, когда буфер освободится.
          // В любом случае, логика setTimeout гарантирует, что события отправляются с задержкой.
          if (canPushMore) {
              // Если буфер не полный, пробуем отправить следующее событие немедленно
              // (это не отменяет setTimeout для следующего события, но позволяет потоку работать более эффективно)
              // Или просто полагаемся на следующий вызов _read
          } else {
              console.log('MockSseStream: Consumer buffer is full, waiting...');
          }
        }, delay);
      }
    }
    
    // --- Определяем события, которые будут отправлены моком ---
    const mockEvents = [
      { data: 'Начало стрима', id: '1' },
      { data: 'Первое сообщение', id: '2', event: 'update', delay: 500 },
      { data: 'Второе\nмногострочное\nсообщение', event: 'data_event', delay: 300 },
      { data: 'Сообщение без id и event', delay: 400 },
      { data: 'Конец стрима', id: '3', delay: 200 }
    ];
    
    // --- Настраиваем Nock для перехвата запроса и возврата потока SSE ---
    console.log(`Setting up Nock mock for GET ${baseUrl}${ssePath}`);
    
    // Используем функцию в reply, чтобы создать новый поток MockSseStream
    // каждый раз при вызове мока. Это важно, если мок может быть вызван несколько раз.
    const sseScope = nock(baseUrl)
      .get(ssePath)
      .reply(200, () => {
         console.log('Nock: Request received, returning MockSseStream...');
         return new MockSseStream(mockEvents);
      }, {
        'Content-Type': 'text/event-stream',
        'Cache-Control': 'no-cache',
        'Connection': 'keep-alive'
      });
    
    // --- Пример использования (имитация клиента) ---
    // Используем стандартный http модуль Node.js для получения потока
    console.log(`Making client request to ${baseUrl}${ssePath}`);
    
    const req = http.get(`${baseUrl}${ssePath}`, (res) => {
      console.log(`Client: Connected. Status: ${res.statusCode}, Content-Type: ${res.headers['content-type']}`);
    
      if (res.statusCode !== 200 || res.headers['content-type'] !== 'text/event-stream') {
        console.error('Client: Did not receive expected SSE response.');
        return;
      }
    
      // Базовая логика парсинга SSE на стороне клиента
      let buffer = '';
      res.on('data', (chunk) => {
        buffer += chunk.toString();
        // console.log('Client: Received chunk (raw):\n', chunk.toString()); // Отладочный вывод сырых чанков
    
        let eventEnd;
        // Ищем разделитель событий '\n\n' в буфере
        while ((eventEnd = buffer.indexOf('\n\n')) !== -1) {
          const eventChunk = buffer.substring(0, eventEnd + 2);
          buffer = buffer.substring(eventEnd + 2);
    
          // Парсим одно событие
          const lines = eventChunk.split('\n').filter(line => line.length > 0 && !line.startsWith(':')); // Фильтруем пустые строки и комментарии
          let id, event, data = [];
          lines.forEach(line => {
            if (line.startsWith('id: ')) id = line.substring(4);
            else if (line.startsWith('event: ')) event = line.substring(7);
            else if (line.startsWith('data: ')) data.push(line.substring(6)); // Объединяем многострочные data
          });
    
          console.log('\n--- Client: Parsed SSE Event ---');
          if (id !== undefined) console.log('ID:', id);
          if (event !== undefined) console.log('Event:', event);
          console.log('Data:', data.join('\n')); // Соединяем части данных обратно
          console.log('------------------------------\n');
        }
      });
    
      res.on('end', () => {
        console.log('Client: Connection ended.');
        if (buffer.length > 0) {
            console.log('Client: Remaining buffer after end:', buffer);
        }
        // Проверяем, что мок был вызван
        sseScope.done();
        console.log('Nock: Mock called successfully.');
      });
    
      res.on('close', () => {
          console.log('Client: Connection closed unexpectedly.');
      });
    
      res.on('error', (err) => {
        console.error('Client: Error during stream:', err);
      });
    
    });
    
    req.on('error', (err) => {
      console.error('Client: Request failed:', err);
    });
    
    // Чтобы остановить клиент до завершения стрима (опционально для тестирования)
    // setTimeout(() => {
    //     console.log('Client: Aborting request after 1.5 seconds...');
    //     req.abort(); // Или req.destroy()
    // }, 1500);
    

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

    1. nock(baseUrl).get(ssePath): Создает перехватчик для GET запросов к http://localhost:3000/events.
    2. .reply(200, () => new MockSseStream(mockEvents), { ... }): Указывает Nock ответить статусом 200. Важно: в качестве тела ответа передается функция. Эта функция вызывается Nock при получении запроса и должна вернуть что-то, что может быть отправлено как тело ответа. В данном случае, она возвращает новый экземпляр MockSseStream. Это гарантирует, что для каждого запроса создается новый поток, начиная с первого события.
    3. MockSseStream: Этот класс расширяет stream.Readable. Метод _read() вызывается автоматически, когда поток готов отправить больше данных потребителю.
    4. _read() логика:
      • Проверяет, есть ли еще события в списке this.events.
      • Если события есть, форматирует текущее событие (this.events[this.index]) в строку по правилам SSE (id:...\n, event:...\n, data:...\n, \n).
      • Использует setTimeout для имитации задержки перед "отправкой" этого события.
      • Внутри setTimeout вызывает this.push(chunk) для отправки сформированной строки в выходной буфер потока.
      • Увеличивает this.index и сбрасывает флаг isPushing.
      • Если событий больше нет, вызывает this.push(null) для сигнализации конца потока.
    5. Клиентская часть (имитация): Стандартный модуль http используется для выполнения запроса. Слушатели data собирают приходящие части потока. Базовая логика внутри обработчика data ищет разделитель \n\n и, найдя его, парсит полученную порцию данных как одно SSE событие, выводя его в консоль.
    6. sseScope.done(): В конце клиентского соединения (или в тесте после выполнения запроса), вызов scope.done() проверяет, что настроенный мок был вызван хотя бы один раз.

    Как запустить:

    1. Убедитесь, что у вас установлен Node.js.
    2. Создайте новый проект или используйте существующий.
    3. Установите nock: npm install nock
    4. Сохраните код выше в файл (например, mock_sse.js).
    5. Запустите файл из командной строки: node mock_sse.js

    Вы увидите вывод в консоли, показывающий настройку Nock, выполнение клиентского запроса, "отправку" событий моком с задержками и "прием" и парсинг этих событий клиентской частью.

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