Menu

Transformations d'arguments d'étape et tables Specflow

  • Principal
  • Autre
  • Transformations d'arguments d'étape et tables Specflow

step argument transformations specflow tables

Essayez Notre Instrument Pour Éliminer Les Problèmes

Tutoriel Step Argument Transformations & Specflow Tables:

Notre précédent tutoriel Specflow nous a tout expliqué Liaisons partagées et étendues, crochets et réutilisation d'étape en détail. Ici, dans ce didacticiel, nous explorerons plus en détail les transformations d'arguments d'étape dans Specflow.

N'hésitez pas à lire notre Guide complet de formation Specflow pour les débutants pour une compréhension claire du concept. La fonction de transformation d'argument d'étape de Specflow permet à un utilisateur de fournir une transformation personnalisée pour les paramètres fournis dans les étapes.

Il permet d'ajouter une logique personnalisée pour convertir les paramètres d'entrée en un paramètre spécifique. Par exemple, vous pouvez directement créer un objet de classe à partir des paramètres et renvoyer l'objet construit à partir de la fonction de transformation.

Transformations d

Une autre fonctionnalité de Specflow que nous allons examiner est les tables Specflow qui permettent de transmettre les données d'entrée sous forme de tableau en une seule étape et les assistants de table peuvent les mapper directement à une instance Object comme souhaité.

Voir la vidéo:

Voici un didacticiel vidéo sur les transformations d'arguments d'étape et les tables Specflow:

Ce que vous apprendrez:

Transformations d'argument d'étape

Pour mieux comprendre les transformations d'argument, essayons d'abord de déterminer dans quelle mesure Specflow correspond exactement aux paramètres. Comme nous l'avons vu dans nos articles précédents, pour l'exemple de recherche YouTube, nous transmettions le terme de recherche en tant que paramètre pour le scénario à exécuter.

La correspondance de paramètre se produit généralement via une expression régulière et l'expression régulière correspondante entraîne la définition du paramètre de méthode sur le terme de recherche fourni à l'étape.

Essayons d'abord de comprendre quelles sont les conversions par défaut prises en charge dans Specflow et quand les transformations d'arguments peuvent être utiles.

Conversions prises en charge

Specflow prend en charge de nombreuses conversions prêtes à l'emploi, en examinant le type de données lui-même après la correspondance regex. Il peut automatiquement prendre en charge des conversions telles que - Chaîne, entier, GUID, Enums, etc.

Voyons ci-dessous un exemple de certains d’entre eux:

Scenario: Get Transactions in my account Given I have entered customer name as Test Customer And I have entered customer account id as 0f8fad5b-d9cb-469f-a165-70867728950e And I select sorting order as DESCENDING And I select number of transactions to be displayed as 25 Then I should see my account transactions

Dans l'exemple de code ci-dessus, nous avons mis en évidence différents types d'entrée que nous transmettons dans les étapes, et dans les implémentations d'étape, ceux-ci sont convertis en types de données respectifs.

Voyons les implémentations des étapes ci-dessous (pour plus de simplicité, nous venons de faire une console pour chacune des étapes afin d'illustrer que l'argument fourni est automatiquement converti dans le type attendu):

(Given(@'I have entered customer name as (.*)')) public void GivenIHaveEnteredCustomerNameAsTestCustomer(String customerName) { Console.Out.WriteLine(customerName); } (Given(@'I have entered customer account id as (.*)')) public void GivenIHaveEnteredCustomerAccountIdAs(Guid accountId) { Console.Out.WriteLine(accountId.ToString()); } (Given(@'I select sorting order as (.*)')) public void GivenISelectSortingOrderAsAscending(SortOrder sortOrder) { Console.Out.WriteLine(sortOrder.ToString()); } (Then(@'I should see my account transactions')) public void ThenIShouldSeeMyAccountTransactions() { Console.Out.WriteLine('success!'); } (Given(@'I select number of transactions to be displayed as (.*)')) public void GivenISelectNumberOfTransactionsToBeDisplayedAs(int p0) { Console.Out.WriteLine(p0.ToString());

Lors de l'exécution du scénario ci-dessus, la sortie imprime toutes les valeurs avec succès en indiquant que la conversion automatique des arguments en types de données attendus a réussi.

Voici à quoi ressemble la sortie:

Given I have entered customer name as Test Customer Test Customer -> done: SupportedSpecflowConversions.GivenIHaveEnteredCustomerNameAsTestCustomer('Test Customer') (0.0s) And I have entered customer account id as 0f8fad5b-d9cb-469f-a165-70867728950e 0f8fad5b-d9cb-469f-a165-70867728950e -> done: SupportedSpecflowConversions.GivenIHaveEnteredCustomerAccountIdAs(0f8fad5b-d9cb-469...) (0.0s) And I select sorting order as DESCENDING DESCENDING -> done: SupportedSpecflowConversions.GivenISelectSortingOrderAsAscending(DESCENDING) (0.0s) And I select number of transactions to be displayed as 25 25 -> done: SupportedSpecflowConversions.GivenISelectNumberOfTransactionsToBeDisplayedAs(25) (0.0s) Then I should see my account transactions success! -> done: SupportedSpecflowConversions.ThenIShouldSeeMyAccountTransactions() (0.0s)

Transformations d'argument

Voyons un exemple en action pour comprendre cela. Support, vous disposez d'une application qui convertit l'heure donnée et la convertit en minutes. Exemple: Si l'entrée utilisateur est 1 jour - la sortie est - 1440, si l'entrée utilisateur est 1 jour 2 heure 2 minutes, alors la sortie doit être 1562.

Maintenant, on peut voir que pour prendre en charge différents types d'entrées, il faudra écrire différentes implémentations de liaison en fonction du type d'entrées. Par exemple: Pour les entrées ayant juste une tranche horaire, il y aura une implémentation d'étape distincte, pour les entrées ayant une partie jour, mois - il y aura une implémentation d'étape séparée, etc.

Voyons comment cela peut être implémenté via une implémentation en une seule étape via la transformation Step Argument et l'entrée fournie est simplement convertie en objet horodatage et renvoyée à l'étape d'origine appelée transformation par étape.

Considérez-le comme une analyse regex de premier niveau vers votre entrée qui renvoie la valeur partiellement transformée à l'étape appelante.

Regardez le fichier d'entités ayant 3 variantes d'entrée différentes, avec une seule transformation en le convertissant en objet de durée complète et en revenant.

Scenario: Convert timestamp to minutes - variant 1 Given I have entered 50 days into the timestamp to minute converter When I press calculate Then the result should be 72000.00 on the screen Scenario: Convert timestamp to minutes - variant 2 Given I have entered 1 day, 2 hours, 3 minutes into the timestamp to minute converter When I press calculate Then the result should be 1563.00 on the screen Scenario: Convert timestamp to minutes - variant 3 Given I have entered 1 day, 1 hour, 1 minute, 30 seconds into the timestamp to minute converter When I press calculate Then the result should be 1501.50 on the screen

Regardez les valeurs en surbrillance dans l'exemple de code ci-dessus. Tous ces éléments seront pris en charge exactement de la même transformation et le résultat final sera une valeur d'entrée TimeSpan transformée qui est renvoyée à l'étape Specflow appelante.

Examinons la mise en œuvre de la transformation ci-dessous:

(StepArgumentTransformation(@'(?:(d*) day(?:s)?(?:, )?)?(?:(d*) hour(?:s)?(?:, )?)?(?:(d*) minute(?:s)?(?:, )?)?(?:(d*) second(?:s)?(?:, )?)?')) public TimeSpan convertToTimeSpan(String days, String hours, String minutes, String seconds) { int daysValue; int hoursValue; int minutesValue; int secondsValue; int.TryParse(days, out daysValue); int.TryParse(hours, out hoursValue); int.TryParse(minutes, out minutesValue); int.TryParse(seconds, out secondsValue); return new TimeSpan(daysValue, hoursValue, minutesValue, secondsValue); }

Pour que l'infrastructure sache qu'il s'agit d'une liaison de transformation, l'attribut StepArgumentTransformation doit être ajouté à la méthode implémentant la conversion d'argument.

Les autres points importants à noter concernant les conversions d'arguments sont:

#1) Les transformations d'argument d'étape s'exécutent pour chaque étape correspondante, c'est-à-dire quel que soit le type d'étape, c'est-à-dire qu'elle est donnée, quand ou alors, la transformation se produira pour chaque expression régulière correspondante.

#deux) Selon le type de retour de la sortie transformée, si l'étape d'appel réelle n'a pas le type de retour correspondant pour le paramètre d'entrée, la transformation n'aura pas lieu.

Cela signifie que, supposons que l'étape appelante nécessite une entrée transformée mais qu'elle a l'horodatage d'entrée mentionné comme quelque chose qui ne correspond pas au type de retour de la méthode transformée, alors la correspondance regex sera remplacée et la conversion n'aura pas lieu.

Examinons la mise en œuvre de l’appel de l’étape «Étant donné»:

private TimeSpan ts; (Given(@'I have entered (.*) into the timestamp to minute converter')) public void GivenIHaveEnteredDaysIntoTheTimestampToMinuteConverter(TimeSpan tsTransformed) { ts = tsTransformed; }

Regardez le type de paramètre d'entrée ici, c'est-à-dire son TimeSpan, qui correspond au type renvoyé par l'étape de transformation s'il est changé en un autre type. Par exemple String, la conversion d'argument ne se produira pas et la correspondance regex sera remplacée par l'implémentation Step d'origine.

Conseil pro: Un point important à noter ici est que tout le texte qui doit être transformé doit être alimenté / mis en correspondance par la transformation d'argument d'étape. Par conséquent, l'étape Donnée va maintenant envelopper tous les formats d'entrée possibles dans une seule chaîne et la transformation regex le convertira en un objet TimeSpan et retournera en arrière.

Tables Specflow

Les tables Specflow sont un moyen de transmettre une liste des valeurs à la fonction d'implémentation d'étape. Dans nos articles précédents, nous avons examiné la manière d'implémenter des tests pilotés par les données à l'aide d'un aperçu de scénario et d'exemples. Mais c'était principalement pour exécuter le scénario avec différentes entrées.

Ici, dans les tableaux, il s'agit de transmettre toutes les données à la fois sous forme de tableau à l'étape d'implémentation qui fournit les données.

Par exemple, prenons un exemple où vous testez un système de gestion des étudiants et afin de créer un nouvel objet étudiant, vous êtes invité à remplir de nombreux détails tels que le prénom, le nom, l'âge, l'année de naissance, etc.

Une façon est de transmettre chacune de ces informations comme une étape distincte qui sera essentiellement un grand nombre de code standard et à chaque étape, vous finirez par mettre à jour le même objet qui doit être testé. Une autre façon peut être de créer une expression régulière complexe et d'essayer de transmettre toutes les données à la même étape, mais elle est assez sujette aux erreurs et irrégulière.

Les tables viennent à notre secours ici. Toutes les données d'entrée liées aux étudiants peuvent être envoyées dans la même implémentation d'étape de manière tabulaire grâce à la fonction de table de specflow.

Voyons un exemple de code ci-dessous pour la mise en œuvre des fonctionnalités et des étapes:

Scenario: Pass data through Specflow tables for StudentInfo object Given I have entered following info for Student | FirstName | LastName | Age | YearOfBirth | | test | student | 20 | 1995 | When I press add Then i student should get added to database and entered info should be displayed on the screen

Les données du tableau sont mises en évidence dans l'étape de scénario ci-dessus.

sql questions d'entretien avec réponses pdf

Specflow fournit de nombreux TableHelpers, qui permettent directement des fonctionnalités utiles telles que la création d'une instance d'objet à partir des données d'entrée fournies par l'utilisateur plutôt que l'analyse de chaque champ par vous-même.

Voyons l’étape de mise en œuvre ci-dessous:

private StudentInfo studInfo; (Given(@'I have entered following info for Student')) public void GivenIHaveEnteredFollowingInfoForStudent(Table table) { // converting supplied input data directly to instance of StudentInfo object studInfo = table.CreateInstance(); }

Regardez la section en surbrillance ci-dessus. Voici juste une petite ligne de code, l'ensemble de l'objet StudentInfo (qui est un POCO contenant les champs de données de l'élève, c'est-à-dire le prénom, le nom, l'âge, l'année de naissance, etc.)

Certaines autres fonctionnalités / concepts liés aux tables Specflow sont présentés ci-dessous:

#1) Les tableaux peuvent être horizontaux ou verticaux. Les tableaux verticaux ressemblent davantage à des paires clé-valeur et dans le scénario ci-dessus plus à des mappages nom-valeur, tandis que les tableaux horizontaux contiennent toutes les données d'un objet sur une seule ligne (comme nous l'avons vu dans notre exemple).

#deux) Les tableaux verticaux peuvent être mappés à un seul objet .NET, tandis que les tableaux horizontaux peuvent également être mappés à un ensemble ou une collection d'objets.

# 3) Chaque valeur de champ dans la table doit être atomique car elle sera mappée à un seul champ correspondant dans l'objet analysé.

Un point important à noter ici est que même si vous générer automatiquement des liaisons d'étape avec les données tabulaires, le générateur de liaison Specflow tiendra automatiquement compte de ces types d'entrée et les reconnaîtra comme des données tabulaires valides.

Conclusion

Dans cet article, nous avons essayé d'expliquer 2 concepts importants et pratiques dans Specflow.

La première étape est la Transformations d'argument d'étape qui permettent des conversions de type personnalisées pour les arguments Specflow afin d'éviter le code standard (et permet au script de test de paraître plus modulaire et logique) et la deuxième fonctionnalité que nous avons examinée est Tables Specflow ce qui est pratique lorsque vous devez transmettre un grand nombre de champs / données en une seule étape dans un format tabulaire convivial.

Dans notre prochain didacticiel, nous en apprendrons davantage sur la façon dont vous pouvez générer automatiquement une belle documentation à l'aide de Specflow dans différents formats à l'aide d'outils open source tels que Pickles, qui peuvent servir de référence facile pour toutes les parties prenantes du projet.

Tutoriel PREV | Tutoriel SUIVANT

lecture recommandée

^