Dans le scénario réel, nous testons la fonction d'enregistrement simple, qui nécessite un nom d'utilisateur et un mot de passe. Le nom d'utilisateur/mot de passe peut avoir certaines règles, ce qui nécessite une variété de règles de données différentes pour vérifier la fonction d'enregistrement. Bien sûr, nous pouvons écrire plusieurs cas, les requêtes sont les mêmes mais les données de la requête sont différentes. Mais il y a un problème avec cela, cela entraînera beaucoup de code en double et n’est pas facile à gérer. Alors comment le résoudre avec élégance ? Bien sûr, il s'agit de paramétrage, alors comment pytest effectue-t-il le paramétrage ? Explorez ensemble avec des questions.
Introduction au paramétrage pytest
Les tests paramétrés font référence à l'exécution de plusieurs tests en transmettant différents paramètres dans le scénario de test pour vérifier les différentes entrées et sorties de la fonction ou de la méthode testée.
Le paramétrage de Pytest nous permet d'étendre facilement les cas de test, de réduire le code redondant et d'améliorer l'efficacité des tests.
Comment utiliser le paramétrage pytest
La méthode d'utilisation est encore très simple. Regardons d'abord un cas. Peut-être que vous le comprendrez d'un coup d'œil.
@pytest.mark.parametrize("input, expected", [
(2, 4),
(3, 9),
(4, 16)
])
def test_square(input, expected):
assert input**2 == expected
Le code ci-dessus définit un scénario de test nommé test_square, qui est paramétré à l'aide du décorateur @pytest.mark.parametrize. La liste des paramètres paramétrés contient plusieurs ensembles d'entrées et de sorties souhaitées, séparés par des virgules entre chaque ensemble de paramètres.
Ensuite, nous exécutons le test et voyons les résultats :
Exécutez le test en exécutant la commande suivante sur la ligne de commande :
============================= test session starts ==============================
collecting ... collected 3 items
test_demo.py::test_square[2-4]
test_demo.py::test_square[3-9]
test_demo.py::test_square[4-16]
============================== 3 passed in 0.13s ===============================
Scénarios d'application
La méthode d'utilisation est identique au cas ci-dessus, elle est très simple. Concentrons-nous sur le scénario d'application.
Application paramétrique unique
Scénarios d'utilisation courants : une seule donnée change dans la méthode de test, c'est-à-dire que plusieurs ensembles de données de test sont transmis via un paramètre. Lors de l'exécution, chaque ensemble de données est exécuté une fois.
Par exemple, si nous nous inscrivons pour obtenir un code de vérification, plusieurs numéros de téléphone mobile doivent actuellement être enregistrés :
import pytest
@pytest.mark.parametrize("mobile", [
16300000000,
16300000001,
16300000002
])
def test_register(mobile):
print(f"当前注册手机号为：{mobile}")
Les résultats d'exécution sont les suivants :
PASSED [ 33%]当前注册手机号为：16300000000
PASSED [ 66%]当前注册手机号为：16300000001
PASSED [100%]当前注册手机号为：16300000002
On peut voir qu'un scénario de test sera exécuté plusieurs fois s'il contient plusieurs éléments de données.
Application multi-paramètres
Les données d'entrée du test peuvent être une expression et les paramètres d'entrée peuvent être multiples. Plusieurs données peuvent être organisées en tuples.
Par exemple, si on teste la fonction de calcul, on peut l'écrire comme ceci :
import pytest
@pytest.mark.parametrize("input, expected", [
(2+2, 4),
(10-1, 9),
(4**2, 16)
])
def test_square(input, expected):
print(input)
assert input == expected
Ce code effectue différentes opérations de calcul sur les valeurs d'entrée et vérifie que les résultats sont conformes aux attentes.
plusieurs paramétrages
Un cas d'utilisation peut être marqué à l'aide de plusieurs @pytest.mark.parametrizes. Par exemple:
import pytest
@pytest.mark.parametrize('input', [1, 2, 3])
@pytest.mark.parametrize("output, expected", [
(4, 5),
(6, 7)
])
def test_square(input, output, expected):
print(f"input:{input},output:{output},expected:{expected}")
result = input + output
assert result == expected
Nous utilisons deux niveaux de décorateurs @pytest.mark.parametrize imbriqués. Le décorateur paramétré externe spécifie la plage de valeurs du paramètre d'entrée comme [1, 2, 3], et le décorateur paramétré interne spécifie chaque ensemble de valeurs pour les paramètres de sortie et attendus.
La combinaison du paramétrage et du montage
Les appareils peuvent également être paramétrés. Ils sont présentés en détail dans l’article précédent. Je ne les présenterai pas dans cet article. Les étudiants qui ne savent pas comment faire peuvent lire cet article.
pytestmark implémente le paramétrage
pytestmark peut être utilisé pour appliquer des décorateurs au niveau du module de test ou au niveau de la classe. En utilisant pytestmark, nous pouvons appliquer le paramétrage de manière uniforme pour plusieurs fonctions de test dans le module de test.
Regardons le cas :
import pytest
pytestmark = pytest.mark.parametrize('input', [1, 2, 3])
def test_square(input):
result = input ** 2
assert result == 4
Dans ce code, nous utilisons le décorateur pytest.mark.parametrize dans la variable pytestmark au niveau du module et définissons le paramètre d'entrée sur une valeur paramétrée de [1, 2, 3].
Cela signifie que pour chaque fonction de test du module de test, le paramétrage est appliqué et le test est exécuté pour chaque valeur de [1, 2, 3]. Dans la fonction de test test_square, nous utilisons directement l'entrée comme paramètre pour accéder à la valeur paramétrée, calculer le carré de l'entrée et affirmer que le résultat est 4.
En utilisant pytestmark, nous pouvons facilement appliquer le paramétrage dans tout le module de test sans répéter le même décorateur dans chaque fonction de test. Cette approche est particulièrement utile lorsque le même paramétrage doit être appliqué uniformément à plusieurs fonctions de test.
Il est important de noter que lors de l'utilisation de pytestmark, il appliquera le paramétrage à toutes les fonctions de test dans l'ensemble du module. Si vous souhaitez uniquement appliquer le paramétrage à une fonction de test spécifique, vous pouvez appliquer le décorateur directement à cette fonction sans utiliser la variable pytestmark.
Approfondir le paramétrage
Jetons d'abord un coup d'œil au code source : /_pytest/python.py
def parametrize(
self,
argnames: Union[str, Sequence[str]],
argvalues: Iterable[Union[ParameterSet, Sequence[object], object]],
indirect: Union[bool, Sequence[str]] = False,
ids: Optional[
Union[Iterable[Optional[object]], Callable[[Any], Optional[object]]]
] = None,
scope: "Optional[_ScopeName]" = None,
*,
_param_mark: Optional[Mark] = None,
) -> None:
argnames : nom du paramètre, qui peut être une chaîne ou une liste de chaînes, représentant les noms des paramètres dans la fonction de test. S'il existe plusieurs paramètres, plusieurs noms peuvent être spécifiés via une liste.
argvalues : valeurs de paramètres, qui peuvent être un objet itérable, où chaque élément représente un ensemble de valeurs de paramètres. Chaque ensemble de valeurs de paramètres peut être un tuple, une liste ou un objet unique.
indirect : s'il faut utiliser le paramètre comme paramètre indirect de la fonction testée. S'ils sont définis sur True ou spécifient certains noms de paramètres, lorsque la fonction de test est exécutée, les paramètres sont transmis en tant que valeurs de retour d'autres fonctions de luminaire plutôt que directement en tant que valeurs de paramètres.
ids : L'identifiant du scénario de test, utilisé pour mieux distinguer les différents scénarios de test paramétrés dans le rapport de test. Vous pouvez spécifier un itérable ou une fonction pour générer l'identité.
scope : La portée du paramètre, utilisée lors du partage de paramètres entre plusieurs fonctions de test. Peut être défini sur « fonction » (par défaut), « classe », « module » ou « session ».
_param_mark : paramètre interne, utilisé pour spécifier la marque du paramètre. En général, pas besoin d'y prêter attention.
Plusieurs ensembles de paramétrages différents peuvent être ajoutés à la fonction de test en appelant la fonction pytest.parametrize plusieurs fois, chaque appel appliquant le paramétrage en plus du paramétrage précédemment ajouté.
Notez que la fonction pytest.parametrize est paramétrée pendant la phase de collecte des scénarios de test, plutôt que de générer dynamiquement des paramètres à chaque fois qu'un scénario de test est exécuté.
Utilisez la fonction hook pytest_generate_tests combinée avec paramétrize pour générer dynamiquement des cas de test.
pytest.param
En tant que framework de test puissant et facile à utiliser, Pytest fournit le décorateur @pytest.mark.parametrize pour prendre en charge les tests paramétrés. La fonction pytest.param est un outil pour améliorer encore les tests paramétrés, ce qui nous permet de définir et de contrôler les cas de tests paramétrés de manière plus flexible.
Identification paramétrique
Dans les tests paramétriques, chaque scénario de test peut contenir plusieurs ensembles de paramètres et produire un grand nombre de résultats de test. À ce stade, afin de mieux comprendre et déboguer les résultats des tests, il est logique d'attribuer un identifiant facile à comprendre à chaque scénario de test paramétré. Le paramètre id de la fonction pytest.param peut le faire.
Par exemple, dans un test de multiplication, on peut définir un cas de test paramétré comme suit :
import pytest
@pytest.mark.parametrize("input, expected", [
pytest.param(2, 4, id="case1"),
pytest.param(3, 9, id="case2"),
pytest.param(5, 25, id="case3")
])
def test_multiply(input, expected):
assert input * input == expected
En utilisant pytest.param pour chaque scénario de test paramétré, nous pouvons spécifier un identifiant pour chaque scénario de test, ce qui le rend plus facile à lire et à comprendre. Une fois le test terminé, l'identification dans le rapport de test nous aidera à mieux localiser le problème.
Options personnalisées
En plus de l'identification des paramètres, la fonction pytest.param peut également accepter des paramètres supplémentaires, tels que le paramètre marks, qui est utilisé pour appliquer des marqueurs personnalisés pour des cas de test individuels. En utilisant le paramètre marks, nous pouvons ajouter de manière flexible diverses options de personnalisation dans les tests paramétrés.
Par exemple, en supposant que nous ayons un scénario de test paramétré qui doit être ignoré, nous pouvons le définir comme ceci :
import pytest
@pytest.mark.parametrize("input, expected", [
pytest.param(2, 4, marks=pytest.mark.skip),
pytest.param(3, 9, marks=pytest.mark.skip),
pytest.param(5, 25)
])
def test_multiply(input, expected):
assert input * input == expected
Dans l'exemple ci-dessus, nous utilisons la marque pytest.mark.skip pour ignorer les deux premiers cas de test. De cette façon, nous pouvons appliquer différentes marques à différents cas de test paramétrés, tels que pytest.mark.skip, pytest.mark.xfail, etc., pour obtenir un contrôle de test plus flexible.
enfin
Grâce à l'introduction de cet article, nous avons découvert le concept, l'utilisation et la démonstration de cas du paramétrage pytest. Le paramétrage de Pytest peut grandement simplifier l'écriture des cas de test et améliorer la réutilisabilité et la maintenabilité du code. Dans les tests logiciels réels, une utilisation raisonnable du paramétrage pytest nous aidera à tester plus efficacement et à détecter plus rapidement les problèmes potentiels. De plus, nous avons également introduit l'utilisation avancée de paramétrize, qui peut être combinée avec la fonction hook pytest_generate_tests pour implémenter des scénarios complexes. Enfin, nous avons introduit une fonction très utile pytest.param, qui fournit plus d'options de personnalisation et de contrôle pour les tests paramétrés. Par conséquent, lors de l'écriture de tests paramétrés, vous souhaiterez peut-être envisager d'utiliser pytest.param pour améliorer la qualité et l'efficacité des tests.
Enfin : le didacticiel vidéo complet sur les tests de logiciels ci-dessous a été compilé et téléchargé. Les amis qui en ont besoin peuvent l'obtenir eux-mêmes.【保证100%免费】
Document d'entretien sur les tests logiciels
"Nous devons étudier pour trouver un emploi bien rémunéré. Les questions d'entretien suivantes proviennent des derniers documents d'entretien de sociétés Internet de premier plan telles que Alibaba, Tencent, Byte, etc., et certains patrons de Byte ont donné des réponses faisant autorité. Après avoir terminé cela Je crois que tout le monde peut trouver un emploi satisfaisant sur la base des informations recueillies lors de l'entretien.
