Pourquoi les tests à sec sont-ils meilleurs que…

Les tests avec mocks permettent d'isoler le composant testé, sans dépendre de la disponibilité ou du fonctionnement des services externes. Cela assure la stabilité et la reproductibilité des tests, accélère l'exécution des scénarios de test et simplifie l'identification des erreurs directement liées à la logique testée.

Postman, même en utilisant des mocks, teste l'interaction avec des dépendances externes au niveau des requêtes/réponses, et n'intègre pas directement les mocks dans le code de test ou le composant lui-même. C'est moins granulaire et plus difficile à automatiser dans les pipelines CI/CD.

Avantages des tests avec mocks par rapport à Postman pour les tests automatisés:

Isolation: Seul le code est testé, pas l'intégration avec des systèmes externes.
Stabilité: Les tests ne échouent pas à cause de problèmes avec des services externes.
Vitesse: Exécution rapide des tests sans attendre de réponses de services réels.
Granularité: Possibilité de mocker des méthodes ou fonctions spécifiques dans le code.
Automatisation: Facile à intégrer dans des tests unitaires et d'intégration exécutés automatiquement.
Test de scénarios extrêmes: Facilité de simuler différents scénarios de réponses des dépendances (erreurs, délais, données non standard).

Exemple d'utilisation de mock en Java (Mockito):

// Création d'un mock pour la dépendance
ExternalService mockService = mock(ExternalService.class);

// Configuration du comportement du mock lors de l'appel d'une méthode spécifique
when(mockService.getData(anyString())).thenReturn("données simulées");

// Test du composant en utilisant le mock
Processor processor = new Processor(mockService);
String result = processor.process("entrée");

// Vérification du résultat
assertEquals("traité données simulées", result);

// Vérification que la méthode du mock a été appelée
verify(mockService).getData("entrée");

Exemple d'utilisation de mock en Python (unittest.mock):

# mock_example.py

def get_data_from_external_service(id):
  # Simulation d'un appel à un service externe
  pass

def process_data(id):
  data = get_data_from_external_service(id)
  return f"traité {data}"

# test_mock_example.py
import unittest
from unittest.mock import patch
from . mock_example import process_data

class TestProcessData(unittest.TestCase):
  @patch('mock_example.get_data_from_external_service')
  def test_process_data_with_mock(self, mock_get_data):
  # Configuration de la valeur de retour du mock
  mock_get_data.return_value = "données simulées"

  # Appel de la fonction testée qui utilise le mock
  result = process_data("quelque_id")

  # Vérification du résultat
  self.assertEqual(result, "traité données simulées")

  # Vérification que le mock a été appelé avec l'argument attendu
  mock_get_data.assert_called_once_with("quelque_id")

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

Postman est plus adapté pour les tests manuels d'API, les tests exploratoires ou la création de requêtes de démonstration. Pour les tests automatisés dans le cadre de CI/CD, les tests avec mocks au niveau du code sont préférables.

Pourquoi les tests à sec sont-ils meilleurs que l'utilisation de Postman?