Что такое REST API?

Ответ

REST API (Representational State Transfer Application Programming Interface) — это архитектурный стиль для построения веб-сервисов, основанный на стандартах HTTP. В контексте тестирования это основной объект проверки для API-тестировщика.

Ключевые принципы, которые мы проверяем:

  • Единообразие интерфейса (Uniform Interface): Ресурсы идентифицируются URI (например, /api/v1/users), а манипуляции с ними выполняются через стандартные HTTP-методы.
  • Отсутствие состояния (Stateless): Каждый запрос от клиента должен содержать всю информацию, необходимую для его обработки. Сервер не хранит состояние сессии между запросами. Это критически важно для тестирования на воспроизводимость и масштабируемость.
  • Кэшируемость (Cacheable): Ответы должны явно или неявно определять, можно ли их кэшировать. Тестировщик проверяет корректность заголовков кэширования (например, Cache-Control).
Основные HTTP-методы и их семантика для тестирования: Метод Операция Идемпотентность* Безопасность*
GET Получение ресурса Да Да
POST Создание ресурса Нет Нет
PUT Полное обновление ресурса Да Нет
DELETE Удаление ресурса Да Нет
PATCH Частичное обновление Нет Нет

*Идемпотентность — многократный вызов дает тот же результат, что и однократный. Безопасность — метод не изменяет состояние ресурса на сервере.

Пример тестового сценария (валидация GET-запроса):

// Пример на JavaScript (часто используется в Postman/Newman)
pm.test("GET /users возвращает статус 200 и корректную структуру", function () {
    pm.response.to.have.status(200);
    pm.response.to.have.jsonSchema({
        "type": "object",
        "properties": {
            "data": {
                "type": "array",
                "items": {
                    "type": "object",
                    "properties": {
                        "id": {"type": "number"},
                        "name": {"type": "string"}
                    },
                    "required": ["id", "name"]
                }
            }
        },
        "required": ["data"]
    });
});

Что проверяет QA-инженер в REST API:

  1. Функциональность: Корректность CRUD-операций, бизнес-логика.
  2. Надежность: Обработка ошибок (4xx, 5xx), идемпотентность, согласованность данных.
  3. Производительность: Время отклика, нагрузочное тестирование.
  4. Безопасность: Аутентификация (OAuth, JWT), авторизация, валидация входных данных, защита от инъекций.
  5. Совместимость: Форматы данных (JSON/XML), обратная совместимость версий API.

Ответ 18+ 🔞

Давай разберём эту REST API хрень, чтобы было понятно, как мужик с паяльником. Представь, что ты пришёл в библиотеку, но вместо книг там одни данные, а ты — библиотекарь-тестировщик, которому надо проверить, не перепутали ли томик Пушкина с инструкцией к микроволновке.

REST API (или, по-простому, «способ для программ болтать через интернет») — это, по сути, свод правил, как одна железяка может попросить у другой данные или сказать ей что-то сделать. И правила эти, надо сказать, иногда проще, чем инструкция к китайскому чайнику.

На чём стоит этот цирк? На трёх китах, которые мы и тыкаем палкой:

  • Единый интерфейс: У каждой штуки в системе есть свой уникальный адрес, как прописка. Хочешь получить список пользователей? Иди на /api/v1/users. Как будто приходишь в квартиру и кричишь: «Эй, пользователи, вылазьте!». А чтобы что-то с ними сделать, есть стандартные команды — GET, POST и прочие. Главное — не пытаться вынести холодильник через окно, если дверь открыта (то есть использовать методы по назначению).
  • Без состояния (Stateless): Это, блядь, самый важный принцип! Сервер — как золотая рыбка с памятью в три секунды. Каждый твой запрос должен быть самодостаточным и нести в себе всё: кто ты, что хочешь и пароль от шкафа. Никаких «помнишь, я вчера заходил...». Нет, не помнит. Проверяем это жёстко, потому что если сервер начинает что-то «помнить» между запросами — это пиздец и потенциальная дыра размером с чёрную дыру.
  • Кэшируемость: Чтобы каждый раз не бегать в подвал за картошкой, ответы можно иногда класть в «холодильник» (кэш). Наша задача — проверить, правильно ли API говорит «этот ответ можно закэшировать на час» или «этот — ни в коем случае». Иначе пользователям будут приходить данные, которые уже накрылись медным тазом.

Основные команды (HTTP-методы), или «Что можно сделать с этой штукой»:

Смотри, тут всё как в жизни. Есть ресурс, ну, скажем, «профиль в соцсети».

Метод Что делает Идемпотентность* (можно тыкать много раз?) Безопасность* (не испортит ничего?)
GET Смотрит на профиль. «О, какие фотки!» Да (смотри хоть сто раз) Да (просто посмотрел)
POST Создаёт новый профиль. «Я теперь тоже тут!» Нет (создаст сто профилей) Нет (изменил базу)
PUT Полностью переписывает профиль. «Всё было херня, давайте заново» Да (перезапишет сто раз одним и тем же) Нет (конечно, изменил)
DELETE Удаляет профиль. «Всё, завязываю с этим» Да (удалит, а потом будет пытаться удалить призрак) Нет (ну ты понял)
PATCH Чуть-чуть правит профиль. «Сменил только аватарку» Нет (может начудить) Нет

Идемпотентность — это когда от десяти одинаковых ударов молотком по гвоздю гвоздь не уходит в иной мир, а просто забивается. Безопасность — это когда ты просто смотришь на гвоздь, а не бьёшь по пальцу.

Вот тебе кусок кода, как мы это проверяем на практике. Не трогай его, он и так хорош:

// Проверяем, что запрос за пользователями работает не как попало
pm.test("GET /users возвращает статус 200 и корректную структуру", function () {
    pm.response.to.have.status(200); // Чтобы не 404 и не 500, ёпта!
    pm.response.to.have.jsonSchema({ // А структура ответа — как договаривались?
        "type": "object",
        "properties": {
            "data": {
                "type": "array",
                "items": {
                    "type": "object",
                    "properties": {
                        "id": {"type": "number"},
                        "name": {"type": "string"}
                    },
                    "required": ["id", "name"] // Чтобы без id не присылали какую-нибудь манду с ушами
                }
            }
        },
        "required": ["data"]
    });
});

И вот на что мы, QA-инженеры, тратим свою светлую жизнь, тестируя эти API:

  1. Функциональность: Работает ли вообще? Создаётся ли пользователь? Удаляется? Если отправить ему в поле возраста слово «бессмертный» — сервер сгорит или gracefully скажет «иди на хуй» (в виде 400 ошибки)?
  2. Надёжность: А что будет, если дернуть один и тот же платёжный запрос пять раз? Спишутся деньги пять раз (кошмар!) или один (идемпотентность, привет!)? Как обрабатываются ошибки? Приходит ли вменяемое сообщение, а не {"error": "всё плохо, ядрёна вошь"}.
  3. Производительность: Сколько времени ждать ответа? Если десять тысяч человек одновременно спросят про погоду — сервер ляжет и будет тихо бздеть в уголке или выдержит?
  4. Безопасность: А если я попробую посмотреть чужие данные, просто поменяв ID в запросе? Меня посодют или пропустят? Правильно ли проверяются токены? Нельзя ли отправить такой JSON, от которого СУБД ебанётся и всё расскажет? Доверия к разработчикам в этом плане — ноль ебать, поэтому проверяем всё.
  5. Совместимость: А если новый сервис ждёт JSON, а старый клиент шлёт XML? Война будет или мир? А если выкатили новую версию API — старые приложения не накрылись ли? Вот это всё.

Короче, работа весёлая. Сидишь и постоянно думаешь: «А что будет, если вот так? А если эдак? А если отправить сюда хуй в пальто?». И иногда оказывается, что будет очень даже интересно.

Видео-ответы