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

Напиши unit-тесты на pytest для функции calculate_discount(price: float, discount: float) -> float, которая возвращает цену со скидкой. Учти: price > 0, discount от 0 до 100. Добавь тесты для краевых случаев: price = 0, discount = 0, discount = 100.

# Код функции:
def calculate_discount(price: float, discount: float) -> float:
    return price * (1 - discount / 100)

# Сгенерированные тесты:
import pytest

def test_calculate_discount_normal():
    assert calculate_discount(100, 10) == 90

def test_calculate_discount_zero_discount():
    assert calculate_discount(100, 0) == 100

def test_calculate_discount_full_discount():
    assert calculate_discount(100, 100) == 0

def test_calculate_discount_zero_price():
    assert calculate_discount(0, 10) == 0

Создай интеграционный тест на pytest для Flask-приложения с эндпоинтом POST /users, который принимает JSON с полями name и email. Используй фикстуру client для тестирования. Проверь: успешный ответ 201, ошибку при пустом name, ошибку при невалидном email.

import pytest
from app import app

@pytest.fixture
def client():
    app.config['TESTING'] = True
    return app.test_client()

def test_create_user_success(client):
    response = client.post('/users', json={'name': 'Alice', 'email': 'alice@test.com'})
    assert response.status_code == 201

def test_create_user_missing_name(client):
    response = client.post('/users', json={'email': 'alice@test.com'})
    assert response.status_code == 400

def test_create_user_invalid_email(client):
    response = client.post('/users', json={'name': 'Alice', 'email': 'invalid'})
    assert response.status_code == 400

Напиши параметризованный тест на pytest для функции is_palindrome(s: str) -> bool. Используй @pytest.mark.parametrize с как минимум 5 наборами данных: "racecar", "hello", "", "a", "Aba". Учти регистр.

import pytest

def is_palindrome(s: str) -> bool:
    return s.lower() == s.lower()[::-1]

@pytest.mark.parametrize('input_str, expected', [
    ('racecar', True),
    ('hello', False),
    ('', True),
    ('a', True),
    ('Aba', True),
])
def test_is_palindrome(input_str, expected):
    assert is_palindrome(input_str) == expected

Напиши unit-тесты на unittest для класса User с методом get_full_name(), который возвращает "firstName lastName". Учти: firstName и lastName могут быть пустыми. Используй setUp для создания экземпляра.

import unittest

class User:
    def __init__(self, first_name: str, last_name: str):
        self.first_name = first_name
        self.last_name = last_name

    def get_full_name(self) -> str:
        return f'{self.first_name} {self.last_name}'.strip()

class TestUser(unittest.TestCase):
    def setUp(self):
        self.user = User('John', 'Doe')

    def test_get_full_name_normal(self):
        self.assertEqual(self.user.get_full_name(), 'John Doe')

    def test_get_full_name_empty_first(self):
        user = User('', 'Doe')
        self.assertEqual(user.get_full_name(), 'Doe')

    def test_get_full_name_empty_last(self):
        user = User('John', '')
        self.assertEqual(user.get_full_name(), 'John')

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

Создай тест на pytest с использованием unittest.mock.patch для функции fetch_user_data(user_id: int), которая вызывает внешний API. Замокируй requests.get и проверь, что функция возвращает корректные данные при статусе 200.

import pytest
from unittest.mock import patch
import requests

def fetch_user_data(user_id: int) -> dict:
    response = requests.get(f'https://api.example.com/users/{user_id}')
    return response.json()

@patch('requests.get')
def test_fetch_user_data(mock_get):
    mock_get.return_value.status_code = 200
    mock_get.return_value.json.return_value = {'id': 1, 'name': 'Alice'}
    result = fetch_user_data(1)
    assert result == {'id': 1, 'name': 'Alice'}

Напиши асинхронный тест на pytest с использованием pytest-asyncio для функции async get_user_by_id(db, user_id: int), которая возвращает пользователя из БД. Используй фикстуру для временной БД.

import pytest
import asyncio

async def get_user_by_id(db, user_id: int) -> dict:
    return await db.fetch_one('SELECT * FROM users WHERE id = :id', {'id': user_id})

@pytest.fixture
async def db():
    # Настройка временной БД
    yield db_mock

@pytest.mark.asyncio
async def test_get_user_by_id(db):
    result = await get_user_by_id(db, 1)
    assert result['id'] == 1

Создай тест на pytest, который проверяет, что функция divide(a, b) вызывает ZeroDivisionError при b = 0. Используй pytest.raises. Также проверь возврат результата при b != 0.

import pytest

def divide(a: float, b: float) -> float:
    if b == 0:
        raise ZeroDivisionError('Division by zero')
    return a / b

def test_divide_zero_division():
    with pytest.raises(ZeroDivisionError):
        divide(10, 0)

def test_divide_normal():
    assert divide(10, 2) == 5.0

Напиши unit-тесты на Jest для функции sumArray(arr: number[]): number, которая возвращает сумму элементов. Добавь тесты для пустого массива, массива с одним элементом и массива с отрицательными числами.

// Функция:
function sumArray(arr) {
  return arr.reduce((acc, curr) => acc + curr, 0);
}

// Тесты:
test('sumArray returns sum of numbers', () => {
  expect(sumArray([1, 2, 3])).toBe(6);
});

test('sumArray returns 0 for empty array', () => {
  expect(sumArray([])).toBe(0);
});

test('sumArray works with negative numbers', () => {
  expect(sumArray([-1, 1])).toBe(0);
});

Создай тест на Jest с React Testing Library для компонента Button, который принимает props label и onClick. Проверь, что кнопка отображает текст и вызывается обработчик при клике.

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

test('Button renders with label and handles click', () => {
  const handleClick = jest.fn();
  render(<Button label="Click me" onClick={handleClick} />);
  const button = screen.getByText('Click me');
  expect(button).toBeInTheDocument();
  fireEvent.click(button);
  expect(handleClick).toHaveBeenCalledTimes(1);
});

Напиши интеграционный тест на pytest для функции insert_user(collection, user_data: dict), которая вставляет документ в MongoDB. Используй фикстуру для временной коллекции. Проверь, что документ вставлен и имеет _id.

import pytest

def insert_user(collection, user_data: dict):
    return collection.insert_one(user_data)

@pytest.fixture
def collection():
    from pymongo import MongoClient
    client = MongoClient()
    db = client.test_database
    yield db.users
    client.drop_database('test_database')

def test_insert_user(collection):
    result = insert_user(collection, {'name': 'Alice', 'email': 'alice@test.com'})
    assert result.inserted_id is not None
    assert collection.find_one({'name': 'Alice'}) is not None

Создай фикстуру на pytest для экземпляра класса Database, который подключается к тестовой БД. Используй scope='function'. Напиши тест, который использует эту фикстуру для проверки выполнения запроса.

import pytest

class Database:
    def __init__(self):
        self.connected = True

    def query(self, sql):
        return [{'id': 1, 'name': 'Alice'}]

@pytest.fixture(scope='function')
def db():
    db = Database()
    yield db

def test_db_query(db):
    result = db.query('SELECT * FROM users')
    assert len(result) == 1
    assert result[0]['name'] == 'Alice'

Напиши интеграционный тест на Jest с supertest для Express-приложения с эндпоинтом GET /api/users. Проверь, что возвращается статус 200 и массив пользователей.

const request = require('supertest');
const app = require('./app');

describe('GET /api/users', () => {
  it('should return 200 and users array', async () => {
    const res = await request(app).get('/api/users');
    expect(res.statusCode).toBe(200);
    expect(Array.isArray(res.body)).toBe(true);
  });
});

Создай тест на pytest для функции get_cached_data(cache, key: str), которая возвращает данные из кэша или вызывает функцию загрузки. Используй mock для проверки, что функция загрузки вызывается только при отсутствии кэша.

import pytest
from unittest.mock import MagicMock

def get_cached_data(cache, key: str, load_func):
    if key in cache:
        return cache[key]
    data = load_func()
    cache[key] = data
    return data

def test_get_cached_data_hit():
    cache = {'user_1': 'Alice'}
    load_func = MagicMock()
    result = get_cached_data(cache, 'user_1', load_func)
    assert result == 'Alice'
    load_func.assert_not_called()

def test_get_cached_data_miss():
    cache = {}
    load_func = MagicMock(return_value='Bob')
    result = get_cached_data(cache, 'user_2', load_func)
    assert result == 'Bob'
    load_func.assert_called_once()

Напиши тест на pytest для функции process_order(order: dict, inventory: dict), которая проверяет наличие товаров и возвращает статус. Учти сценарии: товар есть, товара нет, частичная доступность.

import pytest

def process_order(order, inventory):
    for item in order['items']:
        if item['sku'] not in inventory:
            return {'status': 'failed', 'reason': 'Item not found'}
        if inventory[item['sku']] < item['quantity']:
            return {'status': 'failed', 'reason': 'Insufficient stock'}
    return {'status': 'success'}

def test_process_order_success():
    order = {'items': [{'sku': 'A1', 'quantity': 2}]}
    inventory = {'A1': 10}
    assert process_order(order, inventory) == {'status': 'success'}

def test_process_order_item_not_found():
    order = {'items': [{'sku': 'B1', 'quantity': 1}]}
    inventory = {'A1': 10}
    assert process_order(order, inventory)['status'] == 'failed'

Создай тест на pytest с использованием caplog для функции log_user_action(action: str), которая записывает лог уровня INFO. Проверь, что сообщение содержит слово "Action" и уровень лога INFO.

import pytest
import logging

def log_user_action(action: str):
    logging.info(f'Action: {action}')

def test_log_user_action(caplog):
    with caplog.at_level(logging.INFO):
        log_user_action('login')
    assert 'Action: login' in caplog.text
    assert caplog.records[0].levelname == 'INFO'