Rate limit error при тестировании API: как избежать блокировки

Способ 1: Используйте Mock API Лучший способ

Mock API — это имитация реального API без rate limits. Вы создаете endpoints с теми же URL и ответами, но без ограничений.

✅ Преимущества:

• Без rate limits — неограниченное тестирование
• Быстрее реального API (нет сетевых задержек)
• Стабильные тесты (нет внешних зависимостей)
• Работает офлайн
• Можно тестировать edge cases

Пример с LightBox API:

// Вместо реального API:
const REAL_API = 'https://api.github.com';

// Используйте Mock API:
const MOCK_API = 'https://api.lightboxapi.ru/mock/your-workspace';

// В тестах:
const API_URL = process.env.NODE_ENV === 'test' 
  ? MOCK_API 
  : REAL_API;

// Теперь тесты используют Mock API без rate limits!
test('should fetch user', async () => {
  const response = await fetch(`${API_URL}/users/1`);
  const user = await response.json();
  expect(user.id).toBe(1);
});

Настройка Mock API за 5 минут:

# 1. Создайте workspace на lightboxapi.ru
# 2. Добавьте endpoints (через UI или импортируйте OpenAPI)
# 3. Получите URL вашего Mock API

# 4. Замените в тестах:
export MOCK_API_URL="https://api.lightboxapi.ru/mock/your-workspace"

# 5. Запускайте тесты без rate limits!
npm test

Способ 2: Кэшируйте запросы

Сохраняйте ответы API и используйте их повторно вместо новых запросов.

Пример для Node.js:

// api-cache.js
const fs = require('fs');
const crypto = require('crypto');

class APICache {
  constructor(cacheDir = '.api-cache') {
    this.cacheDir = cacheDir;
    if (!fs.existsSync(cacheDir)) {
      fs.mkdirSync(cacheDir);
    }
  }

  getCacheKey(url, method, body) {
    const data = `${method}:${url}:${JSON.stringify(body)}`;
    return crypto.createHash('md5').update(data).digest('hex');
  }

  get(url, method = 'GET', body = null) {
    const key = this.getCacheKey(url, method, body);
    const cachePath = `${this.cacheDir}/${key}.json`;
    
    if (fs.existsSync(cachePath)) {
      return JSON.parse(fs.readFileSync(cachePath, 'utf8'));
    }
    return null;
  }

  set(url, method, body, response) {
    const key = this.getCacheKey(url, method, body);
    const cachePath = `${this.cacheDir}/${key}.json`;
    fs.writeFileSync(cachePath, JSON.stringify(response, null, 2));
  }
}

// Использование:
const cache = new APICache();

async function fetchWithCache(url) {
  // Проверяем кэш
  const cached = cache.get(url);
  if (cached) {
    console.log('Using cached response');
    return cached;
  }

  // Если нет в кэше — делаем запрос
  const response = await fetch(url);
  const data = await response.json();
  
  // Сохраняем в кэш
  cache.set(url, 'GET', null, data);
  return data;
}

// В тестах:
test('should fetch user', async () => {
  // Первый запрос — к API (считается в лимит)
  // Последующие — из кэша (не считаются)
  const user = await fetchWithCache('https://api.github.com/users/octocat');
  expect(user.login).toBe('octocat');
});

Пример для Python (pytest):

# conftest.py
import pytest
import json
import hashlib
from pathlib import Path

class APICache:
    def __init__(self, cache_dir='.pytest_cache/api'):
        self.cache_dir = Path(cache_dir)
        self.cache_dir.mkdir(parents=True, exist_ok=True)
    
    def get_key(self, url, method='GET'):
        data = f"{method}:{url}"
        return hashlib.md5(data.encode()).hexdigest()
    
    def get(self, url, method='GET'):
        key = self.get_key(url, method)
        cache_file = self.cache_dir / f"{key}.json"
        if cache_file.exists():
            return json.loads(cache_file.read_text())
        return None
    
    def set(self, url, method, response):
        key = self.get_key(url, method)
        cache_file = self.cache_dir / f"{key}.json"
        cache_file.write_text(json.dumps(response, indent=2))

@pytest.fixture
def api_cache():
    return APICache()

# test_api.py
def test_fetch_user(api_cache):
    url = "https://api.github.com/users/octocat"
    
    # Проверяем кэш
    cached = api_cache.get(url)
    if cached:
        data = cached
    else:
        # Запрос к API
        response = requests.get(url)
        data = response.json()
        api_cache.set(url, 'GET', data)
    
    assert data['login'] == 'octocat'

Способ 3: Exponential backoff

Автоматически повторяйте запросы с увеличивающейся задержкой при получении 429 ошибки.

Пример для JavaScript:

async function fetchWithRetry(url, maxRetries = 5) {
  let attempt = 0;
  
  while (attempt < maxRetries) {
    try {
      const response = await fetch(url);
      
      // Если rate limit — ждем и повторяем
      if (response.status === 429) {
        const retryAfter = response.headers.get('Retry-After');
        const delay = retryAfter 
          ? parseInt(retryAfter) * 1000 
          : Math.pow(2, attempt) * 1000; // Exponential: 1s, 2s, 4s, 8s, 16s
        
        console.log(`Rate limit hit. Retrying after ${delay}ms...`);
        await sleep(delay);
        attempt++;
        continue;
      }
      
      // Успех
      return await response.json();
    } catch (error) {
      attempt++;
      if (attempt >= maxRetries) throw error;
      await sleep(Math.pow(2, attempt) * 1000);
    }
  }
  
  throw new Error('Max retries exceeded');
}

function sleep(ms) {
  return new Promise(resolve => setTimeout(resolve, ms));
}

// Использование:
test('should fetch user with retry', async () => {
  const user = await fetchWithRetry('https://api.github.com/users/octocat');
  expect(user.login).toBe('octocat');
}, 60000); // Увеличиваем timeout для retry

Пример для Python:

import time
import requests
from requests.adapters import HTTPAdapter
from requests.packages.urllib3.util.retry import Retry

def create_session_with_retry():
    session = requests.Session()
    
    # Настройка retry стратегии
    retry_strategy = Retry(
        total=5,  # Максимум 5 попыток
        status_forcelist=[429, 500, 502, 503, 504],
        backoff_factor=2,  # Exponential: 2s, 4s, 8s, 16s, 32s
        respect_retry_after_header=True
    )
    
    adapter = HTTPAdapter(max_retries=retry_strategy)
    session.mount("http://", adapter)
    session.mount("https://", adapter)
    
    return session

# Использование:
session = create_session_with_retry()

def test_fetch_user():
    response = session.get('https://api.github.com/users/octocat')
    user = response.json()
    assert user['login'] == 'octocat'

Способ 4: Используйте множественные API ключи

Если у вас есть несколько API ключей, ротируйте их для увеличения общего лимита.

Пример ротации ключей:

class APIKeyRotator {
  constructor(keys) {
    this.keys = keys;
    this.currentIndex = 0;
    this.keyUsage = new Map();
    
    // Инициализируем счетчики
    keys.forEach(key => this.keyUsage.set(key, 0));
  }

  getNextKey() {
    // Находим ключ с минимальным использованием
    let minUsage = Infinity;
    let selectedKey = null;
    
    for (const [key, usage] of this.keyUsage) {
      if (usage < minUsage) {
        minUsage = usage;
        selectedKey = key;
      }
    }
    
    // Увеличиваем счетчик
    this.keyUsage.set(selectedKey, minUsage + 1);
    return selectedKey;
  }

  resetKey(key) {
    // Сбрасываем счетчик когда лимит обновляется
    this.keyUsage.set(key, 0);
  }
}

// Использование:
const rotator = new APIKeyRotator([
  'key1_abc123',
  'key2_def456',
  'key3_ghi789'
]);

async function fetchWithRotation(url) {
  const key = rotator.getNextKey();
  
  try {
    const response = await fetch(url, {
      headers: { 'Authorization': `Bearer ${key}` }
    });
    
    if (response.status === 429) {
      // Этот ключ исчерпал лимит
      console.log('Key exhausted, trying another...');
      return fetchWithRotation(url); // Рекурсивно пробуем другой ключ
    }
    
    return await response.json();
  } catch (error) {
    throw error;
  }
}

// Теперь у вас 3x лимита!
// Если каждый ключ дает 100 req/min, у вас 300 req/min

Способ 5: Параллельное тестирование с лимитами

Контролируйте количество параллельных запросов, чтобы не превышать rate limit.

Пример с p-limit (Node.js):

const pLimit = require('p-limit');

// Ограничиваем до 10 параллельных запросов
const limit = pLimit(10);

// Если лимит API = 100 req/min, и каждый запрос занимает 1с,
// 10 параллельных запросов = 600 запросов/мин
// Но мы контролируем это!

const urls = [
  'https://api.example.com/users/1',
  'https://api.example.com/users/2',
  // ... 1000 URLs
];

// Запускаем все запросы с ограничением
const results = await Promise.all(
  urls.map(url => limit(() => fetch(url).then(r => r.json())))
);

console.log(`Fetched ${results.length} users without rate limit!`);

Пример для Jest тестов:

// jest.config.js
module.exports = {
  maxWorkers: 2, // Только 2 параллельных теста
  testTimeout: 30000,
  // Или процент от CPU:
  // maxWorkers: "50%"
};

// В тестах можно добавить задержки:
beforeEach(async () => {
  // Задержка между тестами
  await new Promise(resolve => setTimeout(resolve, 100));
});