Configuration initiale de l'envirnonement

Pour commencer, installez la bibliothèque YAML requise. Depuis votre terminal, lancez la commande suivante :

pip3 install pyyaml

Créez un module de base pour encapsuler les fonctionnalités de navigation. Sauvegardez-le sous noyau/navigateur.py :

from selenium.webdriver.common.by import By
from selenium.webdriver.support.wait import WebDriverWait
from selenium import webdriver
import time as temporisateur

class PiloteWeb:
    def __init__(self):
        self.instance_pilote = webdriver.Chrome()
        self.instance_pilote.maximize_window()

    def localiser_element_unique(self, *selecteur):
        return self.instance_pilote.find_element(*selecteur)

    def collecter_elements_multiples(self, *selecteur):
        return self.instance_pilote.find_elements(*selecteur)

    def integrer_cadre(self, identifiant):
        self.instance_pilote.switch_to.frame(identifiant)

    @property
    def recuperer_titre(self):
        return self.instance_pilote.title

    @property
    def extraire_url(self):
        temporisateur.sleep(2)
        return self.instance_pilote.current_url

Structuration des fichiers de données

Dans le dossier ressources, générez un fichier de données au format JSON ou YAML. Par exemple, pour un fichier JSON nommé identifiants_service.json :

{
  "authentification": {
    "champ_requis": "L'adresse courriel est obligatoire",
    "format_incorrect": "Le format de l'adresse courriel est invalide",
    "identifiants_errones": "Échec de la connexion",
    "courriel_valide": "utilisateur@domaine.com",
    "mot_de_passe_correct": "MotDePasseComplex123"
  }
}

Alternativement, avec un fichier YAML nommé identifiants_service.yaml :

authentification:
  champ_requis: L'adresse courriel est obligatoire
  format_incorrect: Le format de l'adresse courriel est invalide
  identifiants_errones: Échec de la connexion
  courriel_valide: utilisateur@domaine.com
  mot_de_passe_correct: MotDePasseComplex123

Séparez les paramètres d'environnement dans un fichier de configuration, par exemple config/environnement.yaml :

serveur:
  application: https://service.exemple.com/connexion

Initialisation des tests

Dans le dossier initialisation, préparez la classe de configuration des tests :

import unittest
from selenium import webdriver

class PreparationTestCase(unittest.TestCase):
    def setUp(self):
        self.pilote = webdriver.Chrome()
        self.pilote.maximize_window()
        self.pilote.get(obtenir_url_configuration())
        self.pilote.implicitly_wait(30)

    def tearDown(self):
        self.pilote.quit()

Fonctions utilitaires pour la gestion des fichiers

Développez des helpers dans le dossier outils.

Fichier chemin_projet.py :

import os

def determiner_racine():
    return os.path.dirname(os.path.dirname(__file__))

def construire_chemin(repertoire='ressources', nom=None):
    return os.path.join(determiner_racine(), repertoire, nom)

Fichier chargeur_json.py :

import json
from outils.chemin_projet import construire_chemin

def importer_donnees_json():
    with open(construire_chemin(repertoire='ressources', nom='identifiants_service.json'), encoding='utf-8') as source:
        return json.load(source)

Fichier chargeur_yaml.py :

import yaml
from outils.chemin_projet import construire_chemin

def lire_donnees_yaml():
    with open(construire_chemin(repertoire='ressources', nom='identifiants_service.yaml'), encoding='utf-8') as source:
        return yaml.safe_load(source)

def obtenir_url_configuration():
    with open(construire_chemin(repertoire='config', nom='environnement.yaml'), encoding='utf-8') as source:
        return yaml.safe_load(source)['serveur']['application']

Conception des tests

Créez un cas de test dans le dossier scenarios. Exemple avec verifier_connexion_json.py :

import unittest
from initialisation.preparation import PreparationTestCase
from outils.chargeur_json import importer_donnees_json

class ScenariConnexion(PreparationTestCase):
    def test_identifiants_absents(self):
        '''Contrôle avec des champs laissés vides'''
        self.executer_connexion(courriel='', secret='')
        message_attendu = importer_donnees_json()['authentification']['champ_requis']
        self.assertEqual(self.lire_notification(), message_attendu)

    def test_adresse_invalide(self):
        '''Contrôle avec une adresse courriel mal formatée'''
        self.executer_connexion(courriel='@#%^', secret='1245')
        message_attendu = importer_donnees_json()['authentification']['format_incorrect']
        self.assertEqual(self.lire_notification(), message_attendu)

    def test_ecchec_authentification(self):
        '''Contrôle avec des identifiants erronés'''
        self.executer_connexion(courriel='faux@domaine.com', secret='mauvais_mdp')
        message_attendu = importer_donnees_json()['authentification']['identifiants_errones']
        self.assertEqual(self.lire_notification(), message_attendu)

    def test_connexion_valide(self):
        '''Contrôle avec des identifiants corrects'''
        donnees = importer_donnees_json()
        self.executer_connexion(
            courriel=donnees['authentification']['courriel_valide'],
            secret=donnees['authentification']['mot_de_passe_correct']
        )
        url_resultat = importer_donnees_json()['authentification']['url_final']
        self.assertEqual(self.extraire_url_courante(), url_resultat)

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

Résolution des problèmes courants

Une erreur de type UnicodeDecodeError indique un problème d'encodage. Pour y remédier :

• Configurez votre environnement de développement pour utiliser l'encodage UTF-8 par défaut.
• Spécifiez explicitement encoding='utf-8' lors de l'ouverture de tous les fichiers dans vos scripts utilitairse.

Asurez-vous que les fichiers JSON utilisent systématiquement des guillemets doubles pour délimiter les chaînes de caractères.