8 промтов для написания unit-тестов и интеграционных тестов на Python и JavaScript

Напиши unit-тесты на pytest для функции, которая принимает список чисел и возвращает среднее арифметическое. Используй фикстуру @pytest.fixture для подготовки тестовых данных. Добавь тесты для пустого списка, списка с одним элементом, отрицательных чисел и больших значений (например, 10^6).

def average(numbers: list[float]) -> float:
    if not numbers:
        return 0.0
    return sum(numbers) / len(numbers)

import pytest

@pytest.fixture
def sample_numbers():
    return [1.0, 2.0, 3.0, 4.0, 5.0]

def test_average_positive(sample_numbers):
    assert average(sample_numbers) == 3.0

def test_average_empty():
    assert average([]) == 0.0

def test_average_single():
    assert average([10.0]) == 10.0

def test_average_negative():
    assert average([-5.0, 5.0]) == 0.0

def test_average_large():
    large_list = [1e6] * 1000
    assert average(large_list) == 1e6

Создай интеграционный тест на pytest для функции, которая сохраняет пользователя в SQLite-базу (таблица users с полями id, name, email). Используй фикстуру для создания временной БД в памяти. Проверь вставку, выборку по id и обработку дубликатов (уникальность email).

import sqlite3

def create_user(conn: sqlite3.Connection, name: str, email: str) -> int:
    cursor = conn.execute("INSERT INTO users (name, email) VALUES (?, ?)", (name, email))
    conn.commit()
    return cursor.lastrowid

import pytest
import sqlite3

@pytest.fixture
def db_conn():
    conn = sqlite3.connect(":memory:")
    conn.execute("CREATE TABLE users (id INTEGER PRIMARY KEY, name TEXT, email TEXT UNIQUE)")
    yield conn
    conn.close()

def test_create_user(db_conn):
    user_id = create_user(db_conn, "Alice", "alice@example.com")
    assert user_id == 1

def test_get_user(db_conn):
    create_user(db_conn, "Bob", "bob@example.com")
    row = db_conn.execute("SELECT * FROM users WHERE id=1").fetchone()
    assert row[1] == "Bob"

def test_duplicate_email(db_conn):
    create_user(db_conn, "Alice", "alice@example.com")
    with pytest.raises(sqlite3.IntegrityError):
        create_user(db_conn, "Charlie", "alice@example.com")

Напиши интеграционный тест на pytest для функции, которая делает GET-запрос к /api/users и возвращает список пользователей. Используй библиотеку responses для мокирования HTTP-ответов. Проверь статус 200, пустой ответ и ошибку 500.

import requests

def get_users(base_url: str) -> list:
    response = requests.get(f"{base_url}/api/users")
    response.raise_for_status()
    return response.json()

import pytest
import responses

def test_get_users_success():
    with responses.RequestsMock() as rsps:
        rsps.add(responses.GET, "http://test/api/users", json=[{"id": 1, "name": "Alice"}], status=200)
        result = get_users("http://test")
        assert result == [{"id": 1, "name": "Alice"}]

def test_get_users_empty():
    with responses.RequestsMock() as rsps:
        rsps.add(responses.GET, "http://test/api/users", json=[], status=200)
        result = get_users("http://test")
        assert result == []

def test_get_users_error():
    with responses.RequestsMock() as rsps:
        rsps.add(responses.GET, "http://test/api/users", status=500)
        with pytest.raises(requests.exceptions.HTTPError):
            get_users("http://test")

Напиши unit-тесты на unittest для функции, которая проверяет, является ли строка палиндромом (игнорируя пробелы и регистр). Используй TestCase с методом subTest для передачи разных входных данных: "A man a plan a canal Panama", "racecar", "hello", "".

def is_palindrome(s: str) -> bool:
    cleaned = ''.join(c.lower() for c in s if c.isalnum())
    return cleaned == cleaned[::-1]

import unittest

class TestPalindrome(unittest.TestCase):
    def test_palindromes(self):
        test_cases = [
            ("A man a plan a canal Panama", True),
            ("racecar", True),
            ("hello", False),
            ("", True),
        ]
        for input_str, expected in test_cases:
            with self.subTest(input=input_str):
                self.assertEqual(is_palindrome(input_str), expected)

if __name__ == '__main__':
    unittest.main()

Напиши тест на Jest с React Testing Library для компонента Counter, который отображает число и кнопки "+" и "-". Проверь начальное значение 0, увеличение при клике на "+", уменьшение при клике на "-", и что значение не становится отрицательным (минимум 0).

function Counter() {
  const [count, setCount] = React.useState(0);
  return (
    <div>
      <p data-testid="count">{count}</p>
      <button onClick={() => setCount(prev => prev + 1)}>+</button>
      <button onClick={() => setCount(prev => Math.max(0, prev - 1))}>-</button>
    </div>
  );
}

import { render, screen, fireEvent } from '@testing-library/react';
import Counter from './Counter';

test('initial count is 0', () => {
  render(<Counter />);
  expect(screen.getByTestId('count')).toHaveTextContent('0');
});

test('increment increases count', () => {
  render(<Counter />);
  fireEvent.click(screen.getByText('+'));
  expect(screen.getByTestId('count')).toHaveTextContent('1');
});

test('decrement decreases count but not below 0', () => {
  render(<Counter />);
  fireEvent.click(screen.getByText('-'));
  expect(screen.getByTestId('count')).toHaveTextContent('0');
  fireEvent.click(screen.getByText('+'));
  fireEvent.click(screen.getByText('-'));
  expect(screen.getByTestId('count')).toHaveTextContent('0');
});

Напиши unit-тест на pytest-asyncio для асинхронной функции, которая имитирует задержку в 1 секунду и возвращает строку "done". Используй декоратор @pytest.mark.asyncio. Проверь, что результат корректен и что функция выполняется не дольше 2 секунд.

import asyncio

async def delayed_message() -> str:
    await asyncio.sleep(1)
    return "done"

import pytest
import asyncio

@pytest.mark.asyncio
async def test_delayed_message():
    result = await delayed_message()
    assert result == "done"

@pytest.mark.asyncio
async def test_delayed_message_timeout():
    with pytest.raises(asyncio.TimeoutError):
        await asyncio.wait_for(delayed_message(), timeout=0.5)

Напиши unit-тест на pytest с использованием unittest.mock для функции, которая отправляет email через внешний сервис. Функция send_email(recipient, subject, body) вызывает API. Проверь, что при успешном ответе возвращается True, а при ошибке — False. Используй mock.patch для замены requests.post.

import requests

def send_email(recipient: str, subject: str, body: str) -> bool:
    response = requests.post("https://api.mailservice.com/send", json={
        "to": recipient, "subject": subject, "body": body
    })
    return response.status_code == 200

from unittest.mock import patch, Mock
import pytest

def test_send_email_success():
    with patch('requests.post') as mock_post:
        mock_post.return_value = Mock(status_code=200)
        result = send_email("alice@example.com", "Test", "Hello")
        assert result is True
        mock_post.assert_called_once_with(
            "https://api.mailservice.com/send",
            json={"to": "alice@example.com", "subject": "Test", "body": "Hello"}
        )

def test_send_email_failure():
    with patch('requests.post') as mock_post:
        mock_post.return_value = Mock(status_code=500)
        result = send_email("bob@example.com", "Fail", "Oops")
        assert result is False

Напиши тест на pytest с использованием библиотеки schemathesis для проверки REST API по OpenAPI-спецификации (файл swagger.yaml). Протестируй эндпоинт GET /users на соответствие схеме ответа (массив объектов с полями id и name).

openapi: 3.0.0
paths:
  /users:
    get:
      responses:
        '200':
          content:
            application/json:
              schema:
                type: array
                items:
                  type: object
                  properties:
                    id: { type: integer }
                    name: { type: string }

import schemathesis

schema = schemathesis.from_path("swagger.yaml")

@schema.parametrize(endpoint="/users", method="GET")
def test_users_api(case):
    response = case.call()
    case.validate_response(response)