Introduction

Cypress est largement connu pour ses capacités de test de bout en bout, mais c'est également un outil puissant pour tester les API. Les tests d'API sont un élément essentiel pour garantir la fiabilité, les performances et la sécurité des applications Web modernes, car de nombreuses applications dépendent aujourd'hui fortement des services backend et des API. Cet article vous expliquera les bases des tests d'API à l'aide de Cypress, notamment la configuration des tests d'API, l'envoi de requêtes, la validation des réponses et l'automatisation du processus.

Pourquoi utiliser Cypress pour les tests API ?

1. Fonctionnalités intégrées : Cypress dispose de fonctionnalités intégrées pour effectuer des requêtes HTTP, des assertions et gérer des tests asynchrones.
2. Intégration facile : Vous pouvez facilement intégrer des tests API dans votre suite de tests Cypress existante, aux côtés de vos tests d'interface utilisateur.
3. Excellente expérience de développement : Cypress offre une interface conviviale, des commentaires rapides et un débogage en temps réel.
4. Automation : Vous pouvez automatiser les tests d'API dans votre pipeline CI/CD, garantissant ainsi que les API sont testées de manière cohérente à chaque déploiement.

Premiers pas avec les tests d'API dans Cypress

Si Cypress est déjà installé pour les tests de bout en bout, vous êtes prêt à commencer les tests d'API. Sinon, suivez les étapes d'installation ci-dessous.

Étape 1 : Installer Cypress

npm install cypress --save-dev

Une fois installé, vous pouvez exécuter Cypress avec la commande suivante :

npx cypress open

Étape 2 : configuration de votre premier test d'API
Cypress fournit une méthode cy.request() que vous pouvez utiliser pour envoyer des requêtes HTTP. Voici un exemple simple de test d'une API qui renvoie une liste d'utilisateurs :

describe('API Testing with Cypress', () => {
  it('should retrieve a list of users', () => {
    cy.request('GET', 'https://jsonplaceholder.typicode.com/users')
      .then((response) => {
        // Validate the status code
        expect(response.status).to.eq(200);

        // Validate the response body
        expect(response.body).to.have.length(10);
        expect(response.body[0]).to.have.property('name');
      });
  });
});

Dans cet exemple, nous testons une requête GET pour récupérer une liste d'utilisateurs. Cypress valide le code d'état de la réponse et vérifie que le corps de la réponse contient 10 utilisateurs.

Méthodes HTTP courantes dans les tests d'API

Voici comment effectuer des requêtes HTTP courantes telles que GET, POST, PUT et DELETE dans Cypress.

Demande GET
Les requêtes GET sont utilisées pour récupérer des données du serveur. Par exemple:

cy.request('GET', 'https://jsonplaceholder.typicode.com/posts/1')
  .then((response) => {
    expect(response.status).to.eq(200);
    expect(response.body).to.have.property('id', 1);
  });

Demande POST
Les requêtes POST sont utilisées pour créer de nouvelles ressources sur le serveur. Voici comment tester une requête POST :

cy.request('POST', 'https://jsonplaceholder.typicode.com/posts', {
  title: 'New Post',
  body: 'This is the content of the new post.',
  userId: 1
})
  .then((response) => {
    expect(response.status).to.eq(201);
    expect(response.body).to.have.property('title', 'New Post');
  });

Demande PUT
Les requêtes PUT sont utilisées pour mettre à jour les ressources existantes. Exemple:

cy.request('PUT', 'https://jsonplaceholder.typicode.com/posts/1', {
  id: 1,
  title: 'Updated Post Title',
  body: 'Updated content',
  userId: 1
})
  .then((response) => {
    expect(response.status).to.eq(200);
    expect(response.body).to.have.property('title', 'Updated Post Title');
  });

Demande DELETE
Les requêtes DELETE sont utilisées pour supprimer des ressources. Exemple:

cy.request('DELETE', 'https://jsonplaceholder.typicode.com/posts/1')
  .then((response) => {
    expect(response.status).to.eq(200);
  });

Techniques avancées de test d'API

Une fois que vous maîtrisez les requêtes API de base, vous pouvez passer à des techniques de test d'API plus avancées, telles que la gestion de l'authentification, le test des échecs d'API et le chaînage des appels d'API.

Gestion de l'authentification
Certaines API nécessitent une authentification via des jetons ou des clés API. Cypress peut gérer l'authentification en définissant des en-têtes personnalisés. Par exemple:

cy.request({
  method: 'GET',
  url: 'https://api.example.com/protected',
  headers: {
    Authorization: `Bearer ${Cypress.env('auth_token')}`
  }
})
  .then((response) => {
    expect(response.status).to.eq(200);
  });

Ici, l'en-tête Authorization est utilisé pour envoyer un jeton avec la demande.

Test des échecs de l'API
Il est essentiel de tester le comportement de votre API en cas de problème, comme des entrées non valides ou des ressources manquantes. Par exemple, tester une erreur 404 :

cy.request({
  method: 'GET',
  url: 'https://jsonplaceholder.typicode.com/posts/9999',
  failOnStatusCode: false
})
  .then((response) => {
    expect(response.status).to.eq(404);
  });

En définissant failOnStatusCode : false, Cypress n'échouera pas automatiquement au test pour les réponses non-2xx, vous permettant ainsi de valider les réponses d'erreur.

Chaînage des appels API
Parfois, vous devez enchaîner plusieurs appels d'API, par exemple, créer une ressource puis l'utiliser dans un test ultérieur :

cy.request('POST', 'https://jsonplaceholder.typicode.com/posts', {
  title: 'Post for chaining',
  body: 'Chained post content',
  userId: 1
}).then((postResponse) => {
  cy.request('GET', `https://jsonplaceholder.typicode.com/posts/${postResponse.body.id}`)
    .then((getResponse) => {
      expect(getResponse.body).to.have.property('title', 'Post for chaining');
    });
});

Dans cet exemple, la requête POST crée une nouvelle publication et la requête GET récupère cette publication en fonction de l'ID renvoyé lors du premier appel.

Automatisation des tests API dans les pipelines CI/CD

Pour garantir la stabilité de vos API, il est crucial d'exécuter vos tests d'API dans le cadre de votre pipeline d'intégration continue/déploiement continu (CI/CD). Cypress peut être facilement intégré aux outils CI/CD tels que Jenkins, GitHub Actions ou Travis CI.

Voici un exemple de workflow GitHub Actions qui exécute des tests Cypress à chaque push :

name: CI

on:
  push:
    branches:
      - main

jobs:
  test:
    runs-on: ubuntu-latest

    steps:
      - name: Checkout code
        uses: actions/checkout@v2

      - name: Set up Node.js
        uses: actions/setup-node@v2
        with:
          node-version: '14'

      - name: Install dependencies
        run: npm install

      - name: Run Cypress tests
        run: npx cypress run

Ce workflow garantit que les tests d'API sont automatiquement exécutés chaque fois que le code est poussé vers la branche principale.

Meilleures pratiques pour les tests d'API avec Cypress

Pour garantir que vos tests d'API sont fiables, maintenables et efficaces, suivez ces bonnes pratiques :

1. Utiliser des variables d'environnement : Stockez des données sensibles telles que des clés API, des jetons ou des URL de base dans des variables d'environnement.
2. Réponses simulées si nécessaire : Si vous ne souhaitez pas accéder à la véritable API à chaque fois, simulez les réponses de l'API à l'aide de cy.intercept().
3. Gérer les limites de débit : Si votre API a des limites de débit, assurez-vous que vos tests les gèrent correctement en ajoutant des tentatives ou des délais entre les requêtes.
4. Gardez les tests indépendants : Assurez-vous que chaque test d'API est indépendant des autres, afin qu'ils puissent être exécutés dans n'importe quel ordre sans problèmes de dépendance.
5. Concentrez-vous sur les cas extrêmes : Testez à la fois le chemin heureux et les cas extrêmes (par exemple, entrées non valides, grands ensembles de données, limitation de débit) pour couvrir tous les scénarios potentiels.

Conclusion

Les tests d'API sont un élément essentiel pour garantir que votre application fonctionne de manière transparente, même lorsqu'elle s'appuie sur des services externes ou des API backend. Cypress fournit un moyen simple mais puissant de tester les API parallèlement à vos tests d'interface utilisateur, ce qui en fait un excellent choix pour les développeurs travaillant avec des applications JavaScript modernes. En tirant parti de fonctionnalités telles que cy.request(), les assertions et l'intégration CI/CD, vous pouvez créer une suite de tests d'API robuste et fiable qui détecte les problèmes rapidement et garantit la qualité de vos API.

Commencez à tester vos API avec Cypress dès aujourd'hui et améliorez votre flux de travail de développement avec des tests automatisés et fiables !