Cypress ir lieliski piemērots priekšgala testēšanai, taču tas var arī efektīvi pārbaudīt jūsu API.

Cypress ir populāra testēšanas sistēma, kas pielāgota JavaScript lietojumprogrammām. Lai gan tas galvenokārt ir paredzēts, lai pārbaudītu lietotāja interfeisa komponentus un mijiedarbību ar lietotāja interfeisa elementiem pārlūkprogrammā, tas arī ir paredzēts labi piemērots API testēšanai. Varat izmantot ietvaru, lai pārbaudītu RESTful API, izmantojot HTTP pieprasījumus, un apstiprinātu atbildes.

Cypress ļauj rakstīt visaptverošus testus, kas aptver visu jūsu tīmekļa lietojumprogrammas darbplūsmas spektru.

Darba sākšana ar API testēšanu, izmantojot Cypress

Cypress palīdz jums pārbaudīt, vai jūsu API darbojas, kā jūs gaidāt. Šis process parasti ietver API galapunktu, ievades datu un HTTP atbilžu testēšanu. Varat pārbaudīt integrāciju ar jebkuriem ārējiem pakalpojumiem un apstiprināt, ka kļūdu apstrādes mehānismi darbojas pareizi.

API testēšana nodrošina, ka tās ir funkcionālas, uzticamas un atbilst to lietotņu vajadzībām, kuras ir atkarīgas no tām. Tas palīdz savlaicīgi identificēt un novērst kļūdas, novēršot problēmas rašanos ražošanā.

instagram viewer

Ciprese ir lielisks UI testēšanas rīks, ko izmanto daži no populāri JavaScript ietvari. Tā spēja veikt un pārbaudīt HTTP pieprasījumus padara to vienlīdz efektīvu API testēšanā.

Tas tiek darīts, izmantojot Node.js kā dzinēju, lai veiktu HTTP pieprasījumus un apstrādātu to atbildes.

Jūs varat atrast šī projekta kodu tajā GitHub krātuve.

Izveidojiet Express.js REST API

Lai sāktu, izveidot Express tīmekļa serveri, un instalējiet šo pakotni savā projektā:

npm install cors

Pēc tam pievienojiet savam projektam paketi Cypress:

npm install cypress --save-dev

Visbeidzot, atjauniniet savu pack.json failu, lai iekļautu šo testa skriptu:

"test": "npx cypress open"

Definējiet API kontrolierus

Reālā gadījumā jūs veiktu API izsaukumus, lai lasītu un rakstītu datus no datu bāzes vai ārējā API. Tomēr šajā piemērā jūs simulēsit un pārbaudīsit šādus API izsaukumus, pievienojot un ienesot lietotāja datus no masīva.

Projekta mapes saknes direktorijā izveidojiet a controllers/userControllers.js failu un pievienojiet šādu kodu.

Pirmkārt, definējiet a reģistrētieslietotājs kontroliera funkcija, kas pārvaldīs lietotāja reģistrācijas maršrutu. Tas izvilks lietotāja datus no pieprasījuma pamatteksta, izveidos jaunu lietotāja objektu un pievienos to lietotājiem masīvs. Ja process ir veiksmīgs, tam ir jāatbild ar statusa kodu 201 un ziņojumu, kas norāda, ka lietotājs ir reģistrējis.

const users = [];
exports.registerUser = async (req, res) => {
const { username, password } = req.body;
try {
const newUser = { username, password };
 users.push(newUser);
 res.status(201).send({ message: 'User registered successfully' });
 } catch (error) {
console.error(error);
 res.status(500).send({ message: 'An error occurred!!' });
 }
};

Pievienojiet otru funkciju —getUsers— lai izgūtu lietotāja datus no masīva un atgrieztu tos kā JSON atbildi.

exports.getUsers = async (req, res) => {
try {
 res.json(users);
 } catch (error) {
console.error(error);
 res.status(500).send({ message: 'An error occurred!!' });
 }
};

Visbeidzot, varat arī simulēt pieteikšanās mēģinājumus. Tajā pašā failā pievienojiet šo kodu, lai pārbaudītu, vai norādītais lietotājvārds un parole atbilst kādiem lietotāja datiem failā lietotājiem masīvs:

exports.loginUser = async (req, res) => {
const { username, password } = req.body;
try {
const user = users.find((u) =>
 u.username username && u.password password);
if (user) {
 res.status(200).send({ message: 'Login successful' });
 } else {
 res.status(401).send({ message: 'Invalid credentials' });
 }
 } catch (error) {
console.error(error);
 res.status(500).send({ message: 'An error occurred!!' });
 }
};

Definējiet API maršrutus

Lai definētu maršrutus savai Express REST API, izveidojiet jaunu routes/userRoutes.js failu saknes direktorijā un pievienojiet tam šo kodu:

const express = require('express');
const router = express.Router();
const userControllers = require('../controllers/userControllers');
const baseURL = '/v1/api/';


router.post(baseURL + 'register', userControllers.registerUser);
router.get(baseURL + 'users', userControllers.getUsers);
router.post(baseURL + 'login', userControllers.loginUser);
module.exports = router;

Atjauniniet failu Server.js

Atjauniniet serveris.js failu, lai konfigurētu API šādi:

const express = require('express');
const cors = require('cors');
const app = express();
const port = 5000;
app.use(express.json());
app.use(express.urlencoded({ extended: true }));
app.use(cors());


const userRoutes = require('./routes/userRoutes');
app.use('/', userRoutes);


app.listen(port, () => {
console.log(`Server is listening at http://localhost:${port}`);
});
module.exports = app;

Iestatiet testa vidi

Kad ir izveidota demonstrācijas API, jūs esat gatavs iestatīt testēšanas vidi. Sāciet izstrādes serveri ar šo termināļa komandu:

node server.js

Pēc tam atsevišķā terminālī palaidiet testa skripta komandu:

npm run test

Šī komanda palaidīs Cypress darbvirsmas klientu, kas nodrošina testēšanas vidi. Kad tas ir atvērts, noklikšķiniet uz E2E pārbaude pogu. Pilnīgas pārbaudes nodrošina, ka tiek pārbaudīta Express API kopumā, kas nozīmē, ka Cypress būs piekļuve tīmekļa serverim, maršrutiem un saistītajām kontrollera funkcijām.

Tālāk noklikšķiniet uz Turpināt lai pievienotu Cypress konfigurācijas failus.

Kad iestatīšanas process ir pabeigts, projektā vajadzētu redzēt jaunu Cypress mapi. Cypress pievienos arī a cypress.config.js failu, kurā ir jūsu testu konfigurācijas iestatījumi.

Turpiniet un atjauniniet šo failu, lai iekļautu servera bāzes URL, kā norādīts tālāk.

const { defineConfig } = require("cypress");
module.exports = defineConfig({
 chromeWebSecurity: false,
 e2e: {
 baseUrl: 'http://localhost: 5000',
 setupNodeEvents(on, config) { 
 },
 },
});

Uzrakstiet pārbaudes gadījumus

Tagad esat gatavs rakstīt dažus pārbaudes gadījumus. Vispirms atlasiet pārlūkprogrammu, kurā Cypress tiks palaists, lai palaistu testus no Cypress klienta opcijām.

Pēc tam noklikšķiniet uz Izveidot jaunu specifikāciju pogu, lai izveidotu testa failu, un norādiet nosaukumu. Pēc tam noklikšķiniet Izveidot spec.

Tagad atveriet cypress/fixtures/example.json failu un atjauniniet tā saturu, izmantojot tālāk norādītos lietotāja akreditācijas datus. Fixtures ir faili, kas satur statiskus testa datus, kurus varat izmantot testa gadījumos.

{
"username": "testuser",
"password": "password123"
}

Cypress nodrošina a cy.pieprasījums metode HTTP pieprasījumu veikšanai tīmekļa serverim. Varat to izmantot, lai pārbaudītu dažāda veida HTTP galapunktus, kas pārvalda dažādas darbības, tostarp GET, POST, PUT un DELETE.

Lai pārbaudītu trīs iepriekš definētos API maršrutus, vispirms aprakstiet reģistra galapunkta pārbaudes gadījumu. Šajā testa gadījumā ir jāpārbauda, ​​vai galapunkts darbojas pareizi, veiksmīgi reģistrējot jaunu lietotāju un apstiprinot apgalvojumus.

Atveriet cypress/e2e/user.routes.spec.cy.js failu un atjauniniet tā saturu ar šādu kodu.

describe('User Routes', () => {
 it('registers a new user', () => { 
 cy.fixture('example').then((testUser) => { 
 cy.request({
 method: 'POST',
 url: `${baseUrl}/v1/api/register`, 
 body: testUser, 
 }).then((response) => { 
 expect(response.status).to.eq(201); 
 expect(response.body.message).to.eq('User registered successfully');
 });
 });
 });

Šajā testā Cypress ielādēs testa datus armatūras failā un veiks POST pieprasījumus norādītajam galapunktam ar datiem pieprasījuma pamattekstā. Ja visi apgalvojumi izturēsies, testa gadījums tiks izturēts. Pretējā gadījumā tas neizdosies.

Ir vērts atzīmēt, ka Cypress testu sintakse ļoti līdzinās Mocha testos izmantotajai sintaksei, ko Cypress ir pieņēmis.

Tagad aprakstiet testu lietotājiem maršruts. Pārbaudē ir jāpārbauda, ​​vai atbilde satur lietotāja datus, kad tiek veikti pieprasījumi šim galapunktam. Lai to panāktu, sadaļā pievienojiet šādu kodu aprakstīt testa bloks.

 it('gets users data and the username matches test data', () => {
 cy.fixture('example').then((expectedUserData) => {
 cy.request({
 method: 'GET',
 url: `${baseUrl}/v1/api/users`,
 }).then((response) => {
 expect(response.status).to.eq(200);
const username = response.body[0].username;
 expect(username).to.eq(expectedUserData.username);
 });
 });
 });

Visbeidzot, iekļaujiet testa gadījumu, kas pārbaudīs pieteikšanās galapunktu un apstiprinās, ka atbildes statuss ir 200, kas norāda uz veiksmīgu pieteikšanās mēģinājumu.

 it('logs in a user', () => { 
 cy.fixture('example').then((loginData) => {
 cy.request({
 method: 'POST',
 url: `${baseUrl}/v1/api/login`, 
 body: loginData, 
 }).then((response) => {
 expect(response.status).to.eq(200);
 });
 });
 });
});

Lai palaistu testus, atgriezieties pārlūkprogrammas versijā, ko pārvalda Cypress, un atlasiet konkrēto testa failu, kuru vēlaties palaist.

Cypress testa skrējējs veiks testus un reģistrēs to rezultātus, parādot katra testa gadījuma sekmīgu vai nesekmīgu statusu.

Iepriekš minētie piemēri ilustrē, kā varat pārbaudīt dažādus maršrutus un tiem atbilstošās kontrollera funkcijas, lai nodrošinātu to funkcionalitāti un paredzēto darbību. Lai gan ir svarīgi pārbaudīt API funkcionalitāti, jums nevajadzētu ierobežot testēšanas jomu tikai ar šo aspektu.

Visaptverošā API testēšanas stratēģijā jāiekļauj arī veiktspējas, slodzes un integrācijas ar citiem pakalpojumiem testi. Iekļaujot dažāda veida pārbaudes metodes savā stratēģijā varat sasniegt rūpīgu testu pārklājumu un nodrošināt, ka jūsu API ir gan funkcionālas, gan uzticamas pirms koda izvietošanas ražošanā.

Visas savas tīmekļa pieredzes pārbaude, izmantojot Cypress

Cypress ir fantastisks rīks tīmekļa lietojumprogrammu testēšanai, nevainojami aptverot gan priekšgala, gan aizmugures testus.

Pateicoties lietotājam draudzīgajām testēšanas funkcijām, varat viegli un ātri izveidot testēšanas vidi vienā platformā. Pēc tam varat to izmantot, lai rūpīgi pārbaudītu dažādus lietojumprogrammas aspektus un garantētu visaugstāko veiktspēju.