Tests Unitaires d’une Feature Auth

Méthodologie complète pour tester une authentification en React Native avec Jest et Testing Library.

carrière

Le test des fonctionnalités d'authentification dans les applications React Native représente un enjeu critique pour garantir la sécurité et la fiabilité de votre application. Contrairement aux tests de composants UI simples, les tests d'authentification nécessitent une approche plus complexe qui prend en compte les appels API, la gestion des tokens, la persistance des données et la navigation conditionnelle.

Points essentiels à retenir:

  • Isoler vos tests en utilisant des mocks pour les API et le stockage
  • Tester en priorité les fonctions de login, register et token refresh
  • Ne pas oublier les cas d'erreur (401, réseau coupé, token expiré)
  • Vérifier les flux de navigation conditionnelle (redirection après login)
  • Simuler le cycle de vie complet de l'authentification (login → utilisation → logout)

1. Stratégie et Préparation des Tests

Éléments à tester en priorité

  • Services d'authentification: fonctions de login, register, logout, refresh token
  • Hooks personnalisés: useAuth, useLogin, useRegister, etc.
  • Context/Provider Auth: état d'authentification, mises à jour de l'état
  • Navigation conditionnelle: redirection selon l'état d'authentification
  • Gestion des tokens: stockage, récupération, rafraîchissement
  • Gestion des erreurs: erreurs d'API, erreurs de validation, expiration de session

Configuration de l'environnement

Pour bien tester l'authentification, il faut d'abord configurer correctement l'environnement de test avec Jest et les outils nécessaires :

  • Installer jest, @testing-library/react-native, jest-fetch-mock
  • Configurer les mocks pour AsyncStorage, axios et react-navigation
  • Créer des mocks spécifiques pour vos services d'authentification
AuthService login(), register(), logout() API (mocked in tests) Token Storage (AsyncStorage mock) API calls Store/retrieve tokens

2. Tests des Services d'Authentification

Les services d'authentification sont le cœur de votre système. Voici les principes clés pour les tester :

  • Mock des appels API : Utiliser jest.mock pour simuler les réponses d'API
  • Tester tous les cas : Succès, échec d'authentification, erreurs réseau, timeouts
  • Vérifier la persistance : S'assurer que les tokens sont correctement stockés/supprimés
  • Tester le refresh token : Simuler l'expiration et le rafraîchissement automatique

Dans vos tests, utilisez mockedAxios.post.mockResolvedValueOnce() pour simuler une réponse d'API réussie et mockedAxios.post.mockRejectedValueOnce() pour simuler des erreurs. N'oubliez pas de vérifier les appels à AsyncStorage pour confirmer que les tokens sont gérés correctement.

3. Tests des Hooks et du Context

Les hooks et le Context sont l'interface entre vos services et vos composants :

AuthProvider Context, State, Methods useAuth useLogin useRegister LoginScreen RegisterScreen ProfileScreen

Pour tester les hooks et le Context d'authentification :

  • Utiliser renderHook pour tester les hooks personnalisés de manière isolée
  • Créer un composant de test qui utilise le hook/Context pour vérifier son comportement
  • Tester le chargement initial : s'assurer que le Context vérifie l'authentification au démarrage
  • Tester les changements d'état : vérifier que les états sont mis à jour correctement après login/logout
  • Simuler les interactions : utiliser act() pour déclencher les fonctions et waitFor() pour attendre les mises à jour asynchrones

Principe clé : pour tester un Context, créez un composant simple qui l'utilise, puis vérifiez que ce composant affiche les bonnes informations et répond correctement aux interactions.

4. Tests de Navigation

La navigation conditionnelle est cruciale dans une feature d'authentification :

  • Mocker @react-navigation/native pour simuler les fonctions de navigation
  • Vérifier les redirections : après login réussi, après logout, en cas d'accès non-autorisé
  • Tester les guards de route : composants qui protègent les routes privées
  • Simuler différents états : utilisateur connecté, déconnecté, token expiré

Exemple d'approche pour tester la navigation :

  1. Configurer un navigateur de test avec vos routes
  2. Simuler différents états d'authentification avant le rendu
  3. Vérifier que l'utilisateur est redirigé vers les bonnes routes

5. Tests de Cas Spécifiques

Ne pas oublier ces scénarios particuliers :

  • Token expiré : vérifier que le rafraîchissement est tenté et que l'utilisateur est redirigé en cas d'échec
  • Problèmes réseau : tester le comportement de l'application en cas de timeouts ou d'erreurs réseau
  • Validation des formulaires : tester que les erreurs de validation sont correctement affichées
  • Tentatives multiples : vérifier le comportement après plusieurs échecs de connexion
  • Persistance entre sessions : simuler un redémarrage de l'application pour vérifier que l'état d'authentification est préservé

Astuce : Pour tester la persistance, manipulez directement AsyncStorage, puis montez vos composants et vérifiez que l'état d'authentification est correctement restauré.

À Retenir

  • Tests isolés : Utilisez des mocks pour isoler vos tests des dépendances externes.
  • Tests complets : Testez les cas positifs ET négatifs (erreurs, déconnexions, expirations).
  • Scenarios réels : Simulez le cycle de vie complet de l'authentification, y compris les scénarios edge-case.
  • Sécurité : Les tests ne remplacent pas les audits de sécurité, mais ils aident à maintenir un niveau de base de fiabilité.
  • Couverture cible : Visez >90% pour les services d'authentification, >75% pour les hooks et composants.