Тестирование, хотя оно и может занять много времени, является важным этапом в цикле разработки любого приложения. Это гарантирует, что вы обнаружите ошибки и проблемы на ранней стадии, прежде чем запускать код в производство.
Вы можете использовать Jest для тестирования Express Rest API. Создав простой CRUD API, узнайте, как писать тесты для каждой конечной точки.
Что такое шутка?
Существует множество библиотек тестирования JavaScript, из которых вы можете выбирать, но Шутка с чего проще всего начать. Это тестовая библиотека, разработанная Facebook, которая в основном используется для тестирования проектов React. Однако вы также можете использовать его для тестирования Node и других проектов на основе JavaScript. Он был разработан на основе Jasmine, другого инструмента тестирования, и поставляется в комплекте с собственной библиотекой утверждений.
Хотя вам не понадобится библиотека утверждений для написания тестов в Jest, вам понадобится инструмент для выполнения HTTP-запросов. В этой статье используется SuperTest.
Что такое супертест?
Супертест — это библиотека тестирования Node для HTTP-вызовов. Он расширяет библиотеку тестирования суперагентов и позволяет выполнять такие запросы, как GET, POST, PUT и DELETE.
SuperTest предоставляет объект запроса, который вы можете использовать для выполнения HTTP-запросов.
константа запрос = требовать(«супертест»)
запрос("https://icanhazdadjoke.com")
.получить('/slack')
.конец(функция(ошибка, разрешение) {
если (ошибка) бросать ошибаться;
приставка.журнал(разрешение.тело.вложения);
});
Здесь вы передаете базовый URL-адрес API объекту запроса, а затем связываете метод HTTP с остальной частью URL-адреса. конец() метод вызывает сервер API, а функция обратного вызова обрабатывает его ответ.
Получив ответ от API, вы можете использовать Jest для его проверки.
Создать экспресс-API
Чтобы протестировать собственные конечные точки API, необходимо создать REST-API первый. API, который вы создадите, довольно прост. Он вставляет, извлекает, обновляет и удаляет элементы из массива.
Начните с создания нового каталога с именем node-jest и инициализации npm.
mkdir узел-шутка
инициализация npm -y
Затем создайте новый файл с именем index.js а также создать экспресс-сервер.
константа экспресс = требовать("выражать")
константа приложение = экспресс()
app.listen (3000, () => console.log("Прослушивание порта 3000"))
Протестируйте конечную точку GET /todos
Первая конечная точка, которую вы создадите, — это конечная точка GET /todos. Он возвращает все элементы массива. В index.js добавьте следующее.
константа дела = [
];
// Получить все задачи
приложение.получить("/todos", (треб., реш.) => {
возвращатьсяразрешение.статус(200).json({
данные: задачи,
ошибка: нулевой,
});
});
Обратите внимание, что ответ имеет код состояния 200 и объект JSON, содержащий элемент списка дел в массиве данных и сообщение об ошибке. Это то, что вы будете тестировать с помощью Jest.
Теперь установите Jest и SuperTest:
нпм установить шутка супертест
Затем добавьте тестовый скрипт в пакет.json следующим образом:
{
"сценарии": {
"тест": "шутка"
}
}
Прежде чем вы начнете писать свои собственные тесты, вы должны понять, как написать базовый тест в Jest.
Рассмотрим следующую функцию:
функциясумма(а, б) {
возвращаться а + б;
}
модуль.экспорт = сумма;
В тестовом файле нужно:
- Импортируйте функцию.
- Опишите, что должен делать тест.
- Вызов функции.
- Подтвердите ожидаемый ответ фактическим ответом функции.
константа { сумма } = требовать(""./сумма")
описывать("Сумма двух предметов", асинхронный() => {
тест("Он должен вернуть 4", () => {
ожидать(сумма(2,2)).быть(4)
})
})
описывать ключевое слово указывает группу тестов и тест оператор указывает конкретный тест. Если значение, возвращаемое функцией, совпадает со значением, переданным в быть, тест проходит.
При тестировании конечных точек API вы будете не вызывать функцию, а отправлять запрос с помощью SuperTest или другой клиентской библиотеки HTTP.
Вернувшись к конечной точке GET, создайте новый файл с именем API.test.js. Здесь вы будете писать все тесты конечной точки. Именование тестового файла с помощью .тест infix гарантирует, что Jest распознает его как тестовый файл.
В api.test.js импортируйте supertest и установите базовый URL-адрес следующим образом:
константа запрос = требовать(«супертест»)
константа базовый URL = "http://локальный: 3000"
Затем создайте первый тест в блоке описания:
описывать("ПОЛУЧИТЬ /todos", () => {
константа новыйTodo = {
я бы: крипто.randomUUID(),
вещь: "Пить воду",
завершенный: ЛОЖЬ,
}
перед всем(асинхронный () => {
// настраиваем задачу
ожидание запроса (базовый URL).post("/todo").отправить (новое задание);
})
после всего(асинхронный () => {
Ждите запрос (базовый URL).удалить(`/что делать/${новыйTodo.id}`)
})
Это("должен вернуть 200", асинхронный () => {
константа ответ = Ждите запрос (базовыйURL).получить("/todos");
ожидать(отклик.statusCode).быть(200);
ожидать(отклик.тело.ошибка).быть(нулевой);
});
Это("должны вернуться todos", асинхронный () => {
константа ответ = Ждите запрос (базовыйURL).получить("/todos");
ожидать (ответ.тело.данные.длина >= 1).быть(истинный);
});
});
Перед запуском тестов вам необходимо определить функции настройки и демонтажа. Эти функции будут заполнять массив todo элементом перед тестом и удалять фиктивные данные после каждого теста.
Код, который выполняется перед всеми тестами, находится в функции beforeAll(). Код, который запускается после всех тестов, находится в функции afterAll().
В этом примере вы просто нажимаете конечные точки POST и DELETE для каждого. В реальном приложении вы, вероятно, подключитесь к фиктивной базе данных, содержащей тестовые данные.
В этом тесте вы сначала сделали запрос к конечной точке GET /todos и сравнили отправленный ответ с ожидаемыми результатами. Этот набор тестов будет пройден, если ответ имеет Код состояния HTTP 200, данные не пусты, а сообщение об ошибке равно null.
Протестируйте конечную точку POST /todo
В index.js создайте конечную точку POST /todo:
приложение.пост("/todo", (треб., реш.) => {
пытаться {
константа {идентификатор, элемент, выполнено} = req.body;
константа новыйTodo = {
я бы,
вещь,
завершенный,
};
дела.толкать(новыйTodo);
возвращатьсяразрешение.статус(201).json({
данные: задачи,
ошибка: нулевой,
});
} ловить (ошибка) {
возвращатьсяразрешение.статус(500).json({
данные: нулевой,
ошибка: ошибка,
});
}
});
В этом тесте вам нужно будет отправить сведения о задаче в теле запроса с помощью метода send().
запрос (базовый URL).post("/todo").отправить (новое задание)
Запрос POST /todo должен возвращать код состояния 201 и массив todos с новым элементом, добавленным в конце. Вот как может выглядеть тест:
описывать("ПОСТ / задача", () => {
константа новыйTodo = {
// сделать
}
после всего(асинхронный () => {
Ждите запрос (базовый URL).удалить(`/что делать/${новыйTodo.id}`)
})
Это("следует добавить элемент в массив todos", асинхронный () => {
константа ответ = Ждите запрос (базовый URL).post("/todo").send(newTodo);
константа lastItem = ответ.тело.данные[ответ.тело.данные.длина-1]
ожидать(отклик.statusCode).быть(201);
ожидать(последний элемент.вещь).быть(новыйTodo["вещь"]);
ожидать(последний элемент.завершенный).быть(новыйTodo["завершенный"]);
});
});
Здесь вы передаете данные todo методу send() в качестве аргумента. Ответ должен иметь код состояния 201, а также содержать все элементы задач в объекте данных. Чтобы проверить, действительно ли была создана задача, проверьте, соответствует ли последняя запись в возвращенных задачах той, которую вы отправили в запросе.
Конечная точка PUT /todos/:id должна возвращать обновленный элемент:
app.put("/todos/:id", (треб., реш.) => {
пытаться {
константа идентификатор = req.params.id
константа todo = todos.find((todo) => todo.id == id);
если (! сделать) {
бросатьновыйОшибка(«Задание не найдено»)
}
todo.completed = req.body.completed;
возвращатьсяразрешение.статус(201).json({
данные: дела,
ошибка: нулевой,
});
} ловить (ошибка) {
возвращатьсяразрешение.статус(500).json({
данные: нулевой,
ошибка: ошибка,
});
}
});
Проверьте ответ следующим образом:
описывать("Обновите одну задачу", () => {
константа новыйTodo = {
// сделать
}
перед всем(асинхронный () => {
ожидание запроса (базовый URL).post("/todo").отправить (новое задание);
})
после всего(асинхронный () => {
Ждите запрос (базовый URL).удалить(`/что делать/${новыйTodo.id}`)
})
Это("должен обновить элемент, если он существует", асинхронный () => {
константа ответ = Ждите запрос (базовый URL).put(`/тодос/${новыйTodo.id}`).Отправить({
завершенный: истинный,
});
ожидать(отклик.statusCode).быть(201);
ожидать(отклик.тело.данные.завершенный).быть(истинный);
});
});
Завершенное значение в теле ответа должно быть истинным. Не забудьте включить идентификатор элемента, который вы хотите обновить, в URL-адрес.
Проверьте конечную точку DELETE /todos/:id
В index.js создайте конечную точку DELETE. Он должен вернуть данные todo без удаленного элемента.
приложение.удалить("/todos/:id", (треб., реш.) => {
пытаться {
константа идентификатор = req.params.id
константа дело = дело[0]
если (что делать) {
дела.сращивание(я бы, 1)
}
возвращатьсяразрешение.статус(200).json({
данные: задачи,
ошибка: нулевой,
});
} ловить (ошибка) {
возвращатьсяразрешение.статус(500).json({
данные: нулевой,
ошибка: ошибка,
});
}
});
Чтобы проверить конечную точку, вы можете проверить, существует ли удаленный элемент в возвращаемых данных:
описывать("Удалить одну задачу", () => {
константа новыйTodo = {
// сделать
}
перед всем(асинхронный () => {
ожидание запроса (базовый URL).post("/todo").отправить (новое задание);
})
Это("следует удалить один элемент", асинхронный () => {
константа ответ = Ждите запрос (базовый URL).удалить(`/тодос/${новыйTodo.id}`);
константа todos = ответ.тело.данные
константа существует = todos.find (todo => {
newTodo.id == todoId
})
ожидать (существует).toBe(неопределенный)
});
});
Данные, возвращаемые конечной точкой DELETE, не должны содержать удаленный элемент. Поскольку возвращаемые элементы находятся в массиве, вы можете использовать Array[id], чтобы проверить, правильно ли API удалил элемент. Результат должен быть ложным.
Создание REST API
В этой статье вы узнали, как протестировать Express Rest API с помощью Jest API. Вы написали тесты для HTTP-запросов GET, PUT, POST и DELETE и увидели, как отправлять данные в конечную точку в URL-адресе и запросе. Вы должны уметь применять эти знания при тестировании собственного Rest API.