Aller au contenu

Tests unitaires SCL pour automates TIA Portal

Sur cette page

Un test unitaire dans TIA Portal vérifie un seul bloc d'automate (FB/FC) de manière isolée : écrivez des entrées définies (Arrange), laissez l'automate exécuter quelques cycles (Act) et comparez les sorties aux valeurs attendues (Assert), sur PLCSIM Advanced ou un automate S7 réel, de façon automatisée et reproductible.

Framework de tests unitaires intégré pour les blocs TIA. Rédigez, exécutez et évaluez des tests sur une instance PLCSIM Advanced en marche sans quitter l'application.

Prérequis :

  • Licence Pro+ ou supérieure
  • PLCSIM Advanced V3.0+ installé (licence Siemens séparée)
  • Un projet TIA ouvert contenant au moins un automate

Ouvrir l'espace de travail des tests unitaires

  1. Cliquez sur l'icône Tests unitaires (bécher) dans la barre d'activité, tout à gauche
  2. La barre latérale affiche alors la vue Explorateur de tests unitaires, l'arborescence des suites .tia-tests détectées. Sa barre de titre propose Exécuter toutes les suites de tests / Arrêter l'exécution des tests, Réexécuter les tests en échec, Afficher uniquement les échecs et Ouvrir le Test Bench ; Nouvelle suite de tests, Actualiser les suites de tests, Choisir le dossier de tests, Effacer le dossier de tests, Générer un pipeline CI et Exporter le rapport de test se trouvent dans le menu … de la barre de titre. Chaque ligne de suite et de cas propose une action Exécuter au survol. Les résultats de vos exécutions apparaissent dans l'onglet Exécution du Test Bench (voir Le Test Bench ci-dessous).
  3. Un clic sur une suite dans l'arborescence l'ouvre dans un Éditeur de suite de tests dans la zone d'édition ; un clic sur un cas de test ouvre sa suite avec ce cas déjà sélectionné. L'éditeur affiche la même suite dans trois vues commutables, Visuel, JSON et SCL, choisies avec le sélecteur à droite de son en-tête ; la vue active est mise en évidence dans la couleur de votre thème. L'en-tête contient aussi le bloc, l'automate et le type de connexion de la suite, Valider, Exécuter (la flèche à côté ouvre les options d'exécution, voir Options d'exécution ci-dessous), Enregistrer et un menu … avec Générer à partir des limites, Importer dans TIA (vue SCL), Ouvrir au format JSON, Paramètres de connexion et les actions de contrat et d'instantané.
  4. La vue Visuel est un éditeur en deux parties : la partie supérieure liste chaque cas de test sur une ligne (état, numéro, nom, description, entrées, assertions, exigences, cycles, priorité, étiquettes et dernier résultat) ; la partie inférieure édite le cas sélectionné. Au-dessus de la liste, un champ de filtre restreint les cas selon n'importe quel texte, et les listes déroulantes État, Priorité et Exigence filtrent davantage ; à côté, Ajouter (cas de test, cas de théorie ou cas générés à partir des valeurs limites), Dupliquer, Monter, Descendre et Supprimer agissent sur les lignes sélectionnées. Faites glisser le séparateur entre la liste et l'éditeur pour donner plus de place à l'une ou l'autre partie, ou repliez l'éditeur de cas avec le chevron à droite de sa première ligne (aussi Ctrl+Shift+J) ; les deux parties défilent indépendamment.
  5. L'éditeur de cas commence par le nom, les cycles, le délai d'expiration et la priorité, suivis de la description et des sections Entrées, Assertions, Étapes, Surveillance et Métadonnées (plus Paramètres pour un cas de théorie). Chaque section ajoute des lignes avec l'icône + de son en-tête, chaque ligne affiche le type de données de sa variable à côté du nom, et chaque ligne porte son icône de suppression à droite. Étapes et Surveillance restent repliées tant qu'elles sont vides, et Métadonnées affiche ses valeurs dans son en-tête jusqu'à ce que vous l'ouvriez. La liste déroulante des opérateurs d'une assertion est groupée (Comparaison, Plage, Booléen, Texte, Bits, Agrégat, Instantané) ; Tableau égal et Égalité profonde éditent leur valeur attendue dans une petite fenêtre JSON, et une assertion Instantané propose une fenêtre Exclusions pour les variables à exclure de la référence.
  6. Clavier : dans la liste des cas, Ctrl+Shift+N ajoute un cas, Ctrl+D duplique, Alt+Up / Alt+Down déplacent, Delete supprime (avec une confirmation lorsque le cas contient des assertions), Ctrl+Enter exécute les cas sélectionnés (toute la suite si aucun n'est sélectionné), Enter ou F2 passe au champ du nom et Escape revient à la liste ; Ctrl+1, Ctrl+2 et Ctrl+3 basculent entre Visuel, JSON et SCL.

Le Test Bench

Le Test Bench est l'espace de travail où vous choisissez un bloc, examinez son interface, exécutez ses tests et lisez les résultats. Ouvrez-le de l'une des façons suivantes :

  • Palette de commandes : Tests unitaires : Ouvrir le Test Bench
  • Ouvrir le Test Bench dans la barre de titre de la vue Explorateur de tests unitaires ; la suite sélectionnée dans l'arborescence est déjà choisie
  • Cliquez sur l'élément Tests unitaires de la barre d'état après une exécution ; le Test Bench s'ouvre sur l'onglet Exécution

En-tête. De gauche à droite :

Élément Fonction
Automate Choisissez l'automate. Le menu propose aussi Actualiser la liste des API lorsque vous êtes connecté à TIA Portal.
Bloc Choisissez le bloc à tester ; il affiche l'icône Siemens du type de bloc. Connecté à TIA Portal, la liste affiche les blocs de votre projet ; sans connexion, elle affiche les blocs utilisés par vos suites de tests.
Suite Choisissez une suite de tests ; le nombre entre parenthèses est son nombre de cas de test. Lorsqu'un bloc est choisi, la liste affiche les suites de ce bloc. Sans bloc, elle affiche les suites de l'automate choisi ou de tout le dossier de tests, groupées par automate et par bloc, et le choix d'une suite définit l'automate et le bloc pour vous. Lorsque le bloc a exactement une suite, elle est choisie pour vous. Lorsque vous ouvrez ou exécutez une suite, par exemple depuis la vue Explorateur de tests unitaires, un Test Bench ouvert bascule sur cette suite.
+ (Nouvelle suite pour ce bloc) Crée une suite de tests pour le bloc choisi sans rien demander et l'ouvre dans l'Éditeur de suite de tests à côté du Test Bench. La suite commence avec un cas de test vide, auquel vous ajoutez les entrées et les assertions nécessaires.
Connexion Gris Non connecté, bleu Dossier source lorsque vous travaillez hors ligne à partir d'un dossier de blocs exportés, ou vert avec la version de TIA Portal et le nom du projet connecté. Cliquez dessus pour Se connecter à TIA Portal ou Se déconnecter de TIA Portal, Choisir le dossier source… (ou Changer de dossier source… et Effacer le dossier source) et Ouvrir le tableau de bord PLCSIM.
Exécuter Exécute la suite choisie dans l'en-tête. La flèche à côté ouvre les options d'exécution : toutes les suites, la suite ou ses cas en échec, avec couverture, test de mutation ou vérification de contrat, et les options pour les cas instables et les références d'instantané (voir Options d'exécution ci-dessous). Arrêter apparaît pendant une exécution.
… Ouvrir la suite dans l'éditeur, Paramètres de connexion, Ouvrir le XML du bloc, Afficher la carte de couverture, Afficher les marqueurs de mutation, Exporter le rapport de test… et Générer un pipeline CI (ouvre la page Pipeline CI, voir Générer un pipeline CI/CD depuis l'application).

Une fine barre sous l'en-tête affiche la progression d'une exécution.

Test Bench étroit. Lorsque le Test Bench est étroit, l'en-tête place ses puces et ses boutons sur des lignes supplémentaires au lieu de les superposer, et un nom long d'automate, de bloc ou de suite se termine par des points de suspension ; pointez dessus pour lire le nom complet. Les onglets des deux colonnes passent aussi sur une deuxième ligne lorsqu'une colonne est étroite, si bien que chaque onglet reste accessible, et élargir une colonne avec le séparateur les réorganise aussitôt.

Colonne Bloc (à gauche). Une carte affiche le nom, le type et le langage du bloc ainsi que sa provenance (TIA Portal, votre dossier source ou les fichiers exportés du projet). En dessous se trouvent les onglets Interface, Limites, Dépendances et Espace d'adressage. Dès que vous choisissez un bloc, Interface et Limites se remplissent d'eux-mêmes, également sans TIA Portal lorsqu'un dossier source est défini. Pendant la lecture d'un bloc, une barre de progression défile en haut du Test Bench et les onglets indiquent l'étape en cours, par exemple « Chargement de l'interface de 'FB_Motor'… » ; lorsque les valeurs limites ne peuvent pas être déterminées, l'interface reste visible et Limites en indique la raison. Les Dépendances prennent plus de temps et ne sont lues que lorsque vous cliquez sur Analyser les dépendances dans l'en-tête de la colonne Bloc ; Actualiser l'analyse, juste à côté, relit le bloc.

Colonne Résultats (à droite). Les onglets Exécution, Historique, Qualité et Traçabilité, décrits dans les sections ci-dessous. Historique liste vos exécutions passées, compare aussi deux exécutions et affiche les tendances ; Qualité affiche les résultats de couverture et de test de mutation ; Traçabilité montre quels cas de test couvrent chaque exigence et leurs derniers résultats.

Avant une exécution. Le Test Bench exécute la suite enregistrée. Lorsque la suite est ouverte dans l'Éditeur de suite de tests avec des modifications non enregistrées, Studio demande s'il faut d'abord l'enregistrer (Enregistrer et exécuter). Lorsque l'éditeur signale des problèmes qui empêchent l'enregistrement, l'exécution ne démarre pas et un message nomme la suite. Il en va de même pour toute exécution depuis l'Éditeur de suite de tests ainsi que pour la couverture, le test de mutation et les vérifications de contrat.

Clavier. Lorsque le Test Bench a le focus, Ctrl+; puis S exécute la suite choisie dans l'en-tête, et Ctrl+; puis Q arrête un test en cours.

Après un redémarrage. Le Test Bench se rouvre avec le même automate, le même bloc, la même suite et les mêmes onglets, et affiche l'exécution qu'il affichait auparavant.

Changement d'onglet. Lorsque vous passez du Test Bench à un onglet de suite et inversement, les deux restent tels quels : le bloc, les résultats d'exécution et la suite ne sont pas rechargés.

Explorateur de tests unitaires

L'Explorateur de tests unitaires affiche les suites de tests du projet TIA auquel vous êtes actuellement connecté : chaque fichier de suite dans .tia-tests apparaît comme un nœud de suite avec ses cas de test comme enfants, classés dans les dossiers que vous avez créés (voir Organiser les suites de tests en dossiers). Tant qu'aucun dossier de tests n'est choisi et qu'aucun projet n'est connecté, la vue indique « Connectez un projet TIA ou choisissez un dossier de tests pour charger vos suites de tests. » ; dès qu'un dossier est choisi, ses suites apparaissent automatiquement (un dossier choisi sans suites affiche « Aucune suite de tests pour l'instant. » ; si le dossier choisi n'existe plus, il affiche « Dossier de tests sélectionné introuvable : <path> »).

Icônes d'état (affichées à nouveau après un redémarrage) :

  • Réussi : coche verte, le test a réussi lors de la dernière exécution
  • Échec : croix rouge, le test a échoué lors de la dernière exécution
  • Erreur : avertissement orange, le test s'est terminé sur une erreur (exception, délai dépassé, erreur S7)
  • Ignoré : cercle barré gris, le test a été exclu de la dernière exécution par un filtre
  • Non exécuté : cercle vide gris, aucun résultat enregistré pour l'instant

Interactions :

Action Résultat
Cliquez sur une suite (ou sélectionnez-la et appuyez sur Entrée) Ouvre la suite dans un Éditeur de suite de tests dans la zone d'édition
Cliquez sur un cas de test Ouvre sa suite dans l'Éditeur de suite de tests avec ce cas sélectionné
Pointez sur une suite, puis cliquez sur Exécuter la suite dans sa ligne Exécute uniquement cette suite
Pointez sur un cas de test, puis cliquez sur Exécuter un seul dans sa ligne Exécute uniquement ce cas de test
Exécuter toutes les suites de tests (barre de titre de la vue) Exécute successivement toutes les suites visibles
Arrêter l'exécution des tests (barre de titre de la vue, pendant une exécution) Annule l'exécution en cours au prochain point sûr
Nouvelle suite de tests / Actualiser les suites de tests (menu … de la barre de titre) Crée une nouvelle suite, ou analyse à nouveau le dossier .tia-tests/
Choisir le dossier de tests / Effacer le dossier de tests (menu … de la barre de titre) Choisissez le dossier qui contient vos suites de tests (lorsqu'un dossier est choisi, la liste le suit, sinon le projet connecté), ou annulez à nouveau la sélection

Un champ de filtre en haut de la vue Explorateur de tests unitaires restreint l'arborescence par nom de suite et de cas, le bouton bascule Afficher uniquement les échecs de la barre de titre masque tout ce qui n'a pas échoué, et une action Exécuter un seul par cas exécute un seul cas.

Prévu pour l'espace de travail de l'application. Une action Exécuter uniquement les suites concernées (réexécuter uniquement les suites dont le bloc sous-jacent a changé) est prévue. Aujourd'hui, les exécutions d'une suite, d'un cas ou de toutes les suites sont disponibles comme décrit ci-dessus ; en ligne de commande, tia-test-runner run --rerun-affected exécute déjà uniquement les suites dont le bloc sous-jacent a changé (voir Intégration CI/CD).

Prévu : badge de modification du bloc. Un petit point orange à côté d'une suite dont le bloc d'automate sous-jacent a changé depuis sa dernière exécution, avec l'info-bulle « Bloc modifié depuis la dernière exécution », est prévu pour la vue Explorateur de tests unitaires.

Un cas de test qui s'est montré instable au fil de ses exécutions récentes (réussi certaines fois, en échec d'autres) porte un badge Instable à côté de son nom, avec une info-bulle indiquant combien de fois son résultat a changé. Ce badge est calculé à partir de l'historique des exécutions ; il apparaît donc dès qu'un cas a à la fois réussi et échoué lors d'exécutions récentes. Le badge disparaît de lui-même dès que le cas retrouve un résultat stable : un test que vous avez corrigé n'est plus signalé après quelques exécutions cohérentes, et un cas qui échoue désormais à chaque fois est affiché comme un véritable échec plutôt que comme instable.

Organiser les suites de tests en dossiers

Classez vos suites de tests dans des dossiers, comme des fichiers dans les dossiers d'un explorateur de fichiers. Les dossiers sont listés au-dessus des suites, affichent une icône de dossier et le nombre de suites qu'ils contiennent, et s'ouvrent et se ferment d'un clic sur la flèche.

Action Résultat
Nouveau dossier (menu … de la barre de titre, ou clic droit sur un dossier) Crée un dossier dans le dossier sélectionné, ou dans le dossier de la suite sélectionnée. Si rien n'est sélectionné, le dossier est créé au premier niveau
Faites glisser une suite ou un dossier sur un dossier Le déplace dans ce dossier. Déposez-le sur une zone vide de la vue pour le ramener au premier niveau
Déplacer vers le dossier... (clic droit sur une suite ou un dossier) Choisit le dossier cible dans une liste, sans glisser
Renommer (clic droit sur un dossier, ou appuyez sur F2) Renomme le dossier
Supprimer (clic droit sur un dossier, ou appuyez sur la touche Suppr) Supprime le dossier ainsi que les suites qu'il contient, après une confirmation qui indique combien de suites seront supprimées avec lui
Nouvelle suite de tests (clic droit sur un dossier, ou avec un dossier sélectionné) Crée la nouvelle suite dans ce dossier
  • Un nom de suite doit être unique dans tous les dossiers. Studio refuse une deuxième suite portant le même nom, même dans un autre dossier.
  • L'historique des exécutions, le badge Instable et les exécutions validées restent liés à une suite lorsque vous la déplacez dans un autre dossier ou renommez le dossier.
  • Les suites ouvertes suivent le mouvement : l'Éditeur de suite de tests ouvert d'une suite que vous déplacez se rouvre au nouvel emplacement. Si la suite contient des modifications non enregistrées, Studio vous le demande d'abord.
  • Le déplacement, le renommage et la suppression ne sont pas possibles pendant une exécution de test.
  • Quelques noms de dossier sont réservés aux fichiers que Studio écrit dans le dossier de tests (par exemple reports), et les noms commençant par un point ou par deux traits de soulignement ne sont pas autorisés. Studio vous indique lorsqu'un nom ne peut pas être utilisé.
  • Les dossiers sont des dossiers ordinaires dans .tia-tests : le contrôle de version les prend donc en compte, et un dossier que vous créez dans l'Explorateur Windows apparaît également dans la vue.
  • L'assistant IA peut créer, renommer et supprimer des dossiers et déplacer des suites pour vous, et il peut créer une nouvelle suite directement dans un dossier que vous nommez.

Métadonnées des cas de test

L'éditeur de cas de la vue Visuel se termine par une section Métadonnées (repliée par défaut, sous Surveillance ; son en-tête affiche les valeurs actuelles). Cliquez sur l'en-tête de la section pour l'ouvrir et modifier les champs suivants pour chaque cas ; la priorité est aussi modifiable dans la première ligne de l'éditeur de cas, et les exigences, la priorité et les étiquettes apparaissent comme colonnes de la liste des cas :

Champ Rôle
Ordre Ordre d'exécution numérique. Laissez vide pour conserver l'ordre naturel de la suite
Étiquettes Libellés (par ex. safety, regression) utilisés pour les filtres des rapports HTML, saisis sous forme de puces (voir ci-dessous)
Priorité Une valeur parmi Faible / Normale / Élevée / Critique. Détermine l'ordre de tri des rapports
Responsable Responsable en texte libre (nom d'équipe, e-mail, etc.)
Exigences Identifiants d'exigences (par ex. REQ-123, REQ-456) pour la traçabilité, saisis sous forme de puces avec des suggestions issues de votre dossier de tests (voir ci-dessous)

Après Valider, chaque problème apparaît dans une bande sous l'en-tête de l'éditeur sous la forme N problèmes ; ouvrez-la et cliquez sur un problème pour accéder au cas et à la section concernés. Un cas comportant des problèmes porte aussi une marque d'avertissement dans la colonne d'état de la liste des cas, et Enregistrer et Exécuter restent désactivés tant que les erreurs bloquantes ne sont pas corrigées. Toutes les modifications sont enregistrées automatiquement avec le reste de la suite. Les suites créées avant cette version se chargent avec des métadonnées vides par défaut ; aucune migration n'est nécessaire.

Identifiants d'exigences et étiquettes

Étiquettes et Exigences affichent chaque entrée sous forme de puce. Saisissez du texte dans le champ après les puces et appuyez sur Entrée ou sur une virgule pour ajouter une entrée. Collez une liste séparée par des virgules ou des sauts de ligne pour ajouter une puce par entrée. Pour supprimer une puce, cliquez sur son x. Au clavier, Retour arrière dans le champ vide passe à la dernière puce, les touches fléchées passent d'une puce à l'autre, et Retour arrière ou Supprimer supprime la puce qui a le focus.

Pendant que vous saisissez un identifiant d'exigence, une liste propose les identifiants que les suites de tests enregistrées de votre dossier de tests utilisent déjà, chacun avec le nombre de cas de test et les suites qui le citent, ainsi que les identifiants que vous avez ajoutés à cette suite sans les avoir encore enregistrés. Ainsi, une même exigence s'écrit de la même façon dans chaque suite. Les suggestions n'incluent pas les modifications non enregistrées des autres suites ouvertes.

Un identifiant d'exigence est refusé, avec la raison sous le champ, lorsqu'il est vide, contient des caractères de contrôle ou de mise en forme invisibles, dépasse 256 caractères, lorsque le cas de test citerait plus de 50 identifiants, ou lorsque le cas le cite déjà. Une suite qui contient déjà un tel identifiant s'ouvre quand même : le problème apparaît dans la bande des problèmes, et Enregistrer et Exécuter restent désactivés jusqu'à ce que vous le corrigiez.

Lorsque deux identifiants ne diffèrent que par la casse, les espaces ou le style de tiret (par exemple REQ-1 et req-1), un avertissement apparaît sous les puces et dans la bande des problèmes. Si l'autre graphie est utilisée ailleurs dans votre dossier de tests, Utiliser REQ-1 remplace votre puce par celle-ci. Studio ne fusionne jamais les deux de lui-même : la couverture et les rapports les comptent comme des exigences différentes jusqu'à ce que vous choisissiez une graphie.

Les étiquettes sont suggérées à partir de la suite actuelle. Une étiquette de plus de 64 caractères, ou plus de 50 étiquettes sur un cas de test, affiche une remarque, car les rapports les raccourcissent.

La liste déroulante Exigence du filtre au-dessus de la liste des cas affiche les identifiants de cette suite avec le nombre de cas de test pour chacun, puis, sous Autres suites du dossier, les identifiants que seules d'autres suites utilisent. En choisir un affiche « Aucun cas de cette suite ne couvre ... » avec Effacer le filtre.

Dans le chat IA, vous pouvez demander « quels identifiants d'exigences existent dans mon dossier de tests ? » ; l'assistant les liste, et lorsqu'il ajoute des exigences à des cas de test, il suit les mêmes règles et signale les variantes de graphie.

Progression en direct pendant une exécution

Pendant l'exécution d'un test, vous pouvez la suivre à plusieurs endroits :

  • Barre d'état : l'élément Tests unitaires affiche la progression, par exemple « Test 4/36 ». À la fin de l'exécution, il affiche le résultat, par exemple « 36 réussis » ou « 35 réussis, 1 en échec ». Survolez-le pour voir le détail complet, cliquez dessus pour ouvrir l'onglet Exécution du Test Bench.
  • Test Bench : une fine barre de progression défile sous l'en-tête, et l'onglet Exécution se remplit à mesure que chaque cas de test se termine. La première exécution après le démarrage de Studio ouvre le Test Bench sur l'onglet Exécution ; lorsque vous avez lancé l'exécution depuis l'Éditeur de suite de tests, le Test Bench s'ouvre comme onglet en arrière-plan afin que votre éditeur reste au premier plan.
  • Vue Explorateur de tests unitaires : les icônes d'état se mettent à jour en direct pour chaque cas de test. Le flacon d'une suite en cours d'exécution se remplit à mesure que ses cas de test se terminent, ce qui vous montre la progression sans déplier la suite ; pointez sur le flacon pour voir combien de cas sont terminés. Pendant l'exécution d'une suite ou d'un cas de test, son bouton Exécuter devient Arrêter l'exécution des tests, si bien que vous pouvez arrêter l'exécution depuis la même ligne.
  • Arrêter l'exécution des tests : annule l'exécution en cours au prochain point sûr (la connexion S7 et l'instance PLCSIM sont toujours nettoyées). Cela fonctionne aussi pendant qu'une exécution de couverture ou de mutation est encore en préparation, par exemple pendant que Studio demande un mot de passe ; l'exécution se termine alors sans message d'erreur. Si PLCSIM Advanced ne répond pas dans les 30 secondes pendant que Studio vérifie la cible d'une telle exécution, l'exécution se termine avec un message qui l'indique.
  • Nouvelle exécution après un arrêt : lorsque vous arrêtez une exécution de couverture ou de mutation, Studio supprime d'abord ses copies de test et, pour une suite qui utilise S7 Native ou OPC UA, recharge votre projet dans l'instance PLCSIM Advanced. Une exécution que vous lancez entre-temps attend la fin de cette opération, de sorte que les deux n'utilisent jamais le projet ou l'instance en même temps.

Lire les résultats dans l'onglet Exécution

L'onglet Exécution du Test Bench affiche la dernière exécution, quel que soit l'endroit d'où vous l'avez lancée (Test Bench, vue Explorateur de tests unitaires, Éditeur de suite de tests, CodeLens au-dessus d'un bloc ou assistant IA). Un Exécuter tout affiche ensemble toutes les suites de l'exécution.

  • Ligne d'en-tête : le nom de la suite (ou par exemple « Exécuter tout, 7 suites »), l'heure de début, la durée, l'automate, la version de TIA Portal, le type de connexion et le nom de l'ordinateur. La liste de droite permet de passer d'une exécution de cette session à l'autre ; une exécution ouverte depuis l'historique est marquée « (historique) ».
  • Compteurs : total, réussis, en échec, erreurs et ignorés (avec le nombre de cas instables mis de côté) ; un compteur à zéro s'affiche sans couleur. À côté : Réexécuter répète la même exécution, Réexécuter les tests en échec ne répète que ses cas en échec, Exporter le rapport… ouvre le formulaire d'exportation de cette exécution (voir Exporter un rapport), et Comparer à… vous amène à l'onglet Historique pour choisir l'exécution avec laquelle la comparer.
  • Filtres : Échecs uniquement, les listes Suite, Bloc, Tag et Exigence, et un champ de texte qui recherche dans le cas, la suite, le bloc et le message.
  • Liste des cas : état, nom du cas (avec les marques Instable et Quarantaine), la suite (lorsque l'exécution couvrait plusieurs suites), durée et message. Double-cliquez sur un cas pour l'ouvrir dans l'Éditeur de suite de tests. Les largeurs de colonnes que vous définissez sont mémorisées.
  • Assertions : chaque assertion du cas sélectionné avec Variable, Opérateur, Attendu, Réel et État. Lorsqu'un instantané ne correspond plus à sa référence, Approuver la référence sur cette ligne accepte le nouveau résultat, et Approuver les références (N) au-dessus de la grille les accepte toutes après une confirmation. Les deux agissent sur l'exécution la plus récente de la session.
  • Chronologie : un graphique de l'évolution de chaque variable surveillée, cycle par cycle, actualisé en direct pendant l'exécution. Chaque variable a sa propre piste, et les pistes sont empilées l'une sous l'autre, de sorte que des variables de même valeur ne se recouvrent jamais : un Bool alterne entre FALSE et TRUE, une valeur numérique, de durée ou de date est mise à l'échelle sur sa propre plage. L'index de gauche nomme chaque piste avec sa couleur, son type de données et la plage de valeurs enregistrée ; les valeurs de durée et de date sont écrites comme dans TIA Portal, par exemple « T#0ms à T#500ms ». Déplacez le pointeur sur le graphique pour voir la valeur de chaque variable dans ce cycle à côté de son nom, et le numéro du cycle sous l'index. Avec de nombreuses variables surveillées, les pistes et l'index défilent ensemble. Les variables sans type numérique, de durée ou Bool, comme STRING, CHAR, DTL ou DATEANDTIME, n'ont pas de piste et sont listées sous le graphique. Repliez la section lorsque vous n'en avez pas besoin. Une entrée de surveillance peut aussi désigner un membre d'une structure ou un élément d'un tableau, par exemple motorData.speed ou values[2]. Un membre d'une temporisation, d'un compteur ou d'une détection de front, comme instTimer.ET ou instTimer.Q, obtient sa propre piste avec son propre type de données. Un membre d'une autre instance de bloc système obtient une piste lorsque ses valeurs enregistrées sont toutes TRUE ou FALSE, toutes des nombres ou toutes des durées, sinon il est listé sous le graphique. Une entrée qui ne figure pas dans l'interface du bloc n'est pas enregistrée ; les détails du cas dans l'onglet Exécution la listent sous « Variables surveillées absentes de l'interface du bloc, non enregistrées dans la chronologie », et les rapports HTML et JUnit de l'exécution la nomment dans la sortie du cas de test.
  • Ligne de validation : sous la ligne d'en-tête, une fois l'exécution enregistrée, indique si l'exécution est validée, par qui et quand, avec Valider… ou Révoquer… (voir Valider une exécution de test). Pour un Exécuter tout, elle indique par exemple « 3 exécutions sur 7 validées ».
  • Suites supprimées : lorsqu'une suite de l'exécution affichée a été supprimée, l'exécution reste visible et l'en-tête indique « Suite supprimée. L'exécution reste dans l'historique. » ; la liste des exécutions la marque « (suite supprimée) », et Réexécuter les tests en échec laisse de côté les suites supprimées.

Exécutions de l'historique. Une exécution ouverte depuis l'onglet Historique affiche les valeurs lues pendant cette exécution. Les valeurs attendues proviennent de la suite dans son état actuel, ce que l'en-tête signale par « Valeurs attendues de la suite actuelle ». Les valeurs que des exécutions plus anciennes n'ont pas pu enregistrer de façon lisible s'affichent comme « non enregistré ».

Pour collecter des données de surveillance, ajoutez un tableau "watch": ["Var1", "Var2"] à un cas de test dans le JSON de la suite et réglez "cycles" sur une valeur supérieure à 1. L'échantillonnage est limité à 100,000 cycles par cas de test. Les mêmes données sont aussi représentées sous forme de graphique temporel dans les rapports HTML produits par l'outil en ligne de commande tia-test-runner (voir Intégration CI/CD).

Les résultats des tests sont stockés sur votre ordinateur : ils survivent aux redémarrages de l'application et réapparaissent automatiquement dans la vue Explorateur de tests unitaires.

Historique

L'onglet Historique du Test Bench liste chaque exécution de test enregistrée, de la plus récente à la plus ancienne (jusqu'aux 200 dernières), quelle que soit la suite exécutée. Il propose trois modes, que vous sélectionnez avec Exécutions, Comparer et Tendance dans sa ligne supérieure. L'outil en ligne de commande tia-test-runner produit les mêmes informations sous forme de rapports HTML et CSV (voir Intégration CI/CD).

Exécutions

  • Colonnes : par défaut Démarré, Durée, Résultat, Validation, Suite, Bloc, Automate, Hôte et TIA, après un point d'état. Le point indique le résultat de l'exécution : Réussi, Échec (également lorsqu'un seul cas de test a échoué ou rencontré une erreur), Erreur (l'exécution s'est arrêtée prématurément, par exemple parce que la connexion a été perdue) ou Annulé ; pointez dessus pour lire le résultat. Validation indique si l'exécution est validée (survolez-la pour voir par qui et quand). La colonne Résultat affiche de petits compteurs colorés : réussis toujours, en échec, erreurs et ignorés uniquement s'il y en a. Lorsque des échecs instables ont été mis de côté, le compteur des ignorés indique par exemple « 2 (1 instable) » avec une bordure en pointillés.
  • Choix des colonnes : cliquez sur Colonnes dans la ligne supérieure et cochez les colonnes souhaitées. Total, Réussis, Échecs, Erreurs, Ignorés, Fichier de suite et ID d'exécution peuvent être ajoutés ; Réinitialiser les colonnes rétablit les valeurs par défaut. Au moins une colonne reste toujours visible. Votre choix et les largeurs de colonnes sont mémorisés, y compris pour les colonnes que vous masquez puis affichez à nouveau.
  • Suites supprimées : lorsque le fichier de suite d'une exécution ne se trouve plus dans le dossier de tests, la colonne Suite affiche son nom suivi de « (suite supprimée) », que l'exécution soit validée ou non. Les exécutions d'un autre dossier de tests gardent leur nom simple.
  • Champ de filtre : restreint la liste par suite, bloc, automate ou hôte.
  • Actualiser : l'icône d'actualisation ou F5 recharge la liste ; elle se recharge aussi d'elle-même après chaque exécution.
  • Ouvrir une exécution : double-cliquez sur une ligne ou appuyez sur Enter pour afficher cette exécution dans l'onglet Exécution.
  • Sélectionner plusieurs exécutions : utilisez Ctrl, Shift ou Ctrl+A comme dans toute liste, par exemple pour comparer deux exécutions, exporter plusieurs rapports à la fois ou supprimer plusieurs exécutions ensemble.

Clic droit sur une exécution (ou appuyez sur Shift+F10) :

Action Résultat
Ouvrir les résultats Affiche l'exécution dans l'onglet Exécution
Comparer à… Permet de choisir l'exécution avec laquelle la comparer (voir Comparaison ci-dessous)
Exporter le rapport… Ouvre le formulaire d'exportation pour cette exécution ou pour toutes les exécutions sélectionnées (voir Exporter un rapport)
Valider… Valide cette exécution, ou les exécutions sélectionnées qui peuvent être validées (voir Valider une exécution de test)
Révoquer la validation… Révoque la validation de cette exécution avec un motif
Supprimer l'exécution… Supprime définitivement l'exécution de l'historique après une confirmation. Lorsque plusieurs lignes sont sélectionnées, l'entrée indique par exemple Supprimer 3 exécutions… et supprime toutes les exécutions sélectionnées après une seule confirmation qui les nomme. Une exécution validée ne peut pas être supprimée tant que sa validation n'est pas révoquée ; les exécutions validées parmi celles sélectionnées restent dans l'historique, et un message les nomme. Si l'onglet Exécution ou une comparaison affichait une exécution supprimée, ils sont vidés

Delete a le même effet que Supprimer l'exécution… pour les lignes sélectionnées. La suppression d'exécutions ne lit rien dans TIA Portal.

L'historique des exécutions ne révèle pas le chemin du dossier de votre projet, et les exécutions d'un même projet restent associées d'un ordinateur à l'autre.

Comparaison

La comparaison montre ce qui a changé entre deux exécutions.

  • Deux exécutions sélectionnées : sélectionnez deux lignes et cliquez sur Comparer. L'exécution la plus ancienne devient la référence, la plus récente l'exécution actuelle. Comparer reste indisponible tant que deux exécutions ne sont pas sélectionnées.
  • Comparer à… : dans l'onglet Exécution ou dans le menu de ligne d'une exécution. L'onglet Historique s'ouvre avec cette exécution sélectionnée et la ligne « Choisissez l'exécution à comparer avec … ». Cliquez, double-cliquez ou appuyez sur Enter sur l'exécution que vous voulez comme référence, et la comparaison s'ouvre. Studio attend toujours l'exécution que vous choisissez ensuite, même si une autre comparaison était ouverte auparavant, et Annuler dans cette ligne revient à la liste des exécutions sans comparaison.

La comparaison affiche :

  • Référence et Actuelle côte à côte, chacune avec son heure de début, ses nombres de réussites et d'échecs et sa durée, et Permuter pour les inverser.
  • Compteurs récapitulatifs : Régressions, Corrigés, Nouveaux, Supprimés et Stables.
  • Filtre : Tous, Régressions, Corrigés, Nouveaux ou Supprimés restreint la liste des cas.
  • Liste des cas : chaque cas avec son changement (par exemple Régression, Corrigé ou Toujours en échec), son message et l'évolution de la durée, avec « N sur M cas » en dessous.

Tendance

La tendance montre l'évolution d'une suite dans le temps.

  • Suite et Cas : la liste des suites est construite à partir de votre historique des exécutions ; elle est donc remplie même si vous n'avez jamais ouvert la vue Explorateur de tests unitaires. Lorsque deux automates ont une suite du même nom, l'automate est indiqué entre parenthèses. La liste des cas provient de la suite choisie.
  • Période : 30 derniers jours, 90 derniers jours, ou vos propres dates Du et Au.
  • Graphique Taux de réussite pour l'automate de la suite choisie, graphique Durée pour la suite, et carte thermique Historique du cas pour le cas choisi, avec une cellule par exécution, colorée selon le résultat et marquée d'un symbole. Survolez une cellule pour voir quand l'exécution a démarré.
  • L'icône d'actualisation de la ligne supérieure recharge les graphiques.

À son ouverture, la tendance commence par la suite de l'exécution sélectionnée, sinon par la suite choisie dans l'en-tête du Test Bench, sinon par la suite de l'exécution la plus récente.

Partager

Partager, à droite de la ligne supérieure, propose selon le mode :

Mode Ce que propose Partager
Exécutions Exporter le rapport… pour les exécutions sélectionnées (ou l'exécution la plus récente), et Exporter en CSV… avec les lignes et les colonnes actuellement affichées, y compris qui a validé chaque exécution
Comparaison Exporter le rapport… pour la comparaison
Tendance Exporter en CSV… avec les points de la tendance

Les fichiers CSV sont écrits de sorte qu'un tableur n'exécute jamais une cellule comme une formule.

Exporter un rapport

Exporter le rapport… ouvre un petit formulaire à côté du bouton sur lequel vous avez cliqué. Vous y accédez depuis Partager dans l'onglet Historique, depuis le menu de ligne d'une exécution, depuis l'icône d'exportation de l'onglet Exécution, depuis Exporter le rapport de test… dans le menu … du Test Bench, et depuis la palette de commandes avec Tests unitaires : Exporter le rapport de test (qui ouvre l'onglet Historique avec l'exécution la plus récente sélectionnée).

  • Formats : Rapport HTML et XML JUnit. Une comparaison n'est exportée qu'au format HTML.
  • Portée : Cette exécution, Exécutions sélectionnées (avec le nombre d'exécutions sélectionnées) ou Comparaison (disponible après avoir comparé deux exécutions). Une portée qui ne correspond pas à votre sélection est grisée et en indique la raison.
  • Sortie : le Dossier de sortie, relatif au dossier des rapports de votre projet TIA (par défaut report). Le dossier doit se trouver dans ce dossier des rapports ; sinon le champ indique « Choisissez un dossier dans le dossier des rapports du projet. » et Exporter reste indisponible. Lorsque vous exportez plusieurs exécutions, chaque exécution obtient son propre sous-dossier nommé d'après son heure de début, de sorte qu'aucun rapport n'en écrase un autre. L'export le plus récent arrive toujours en haut de son dossier : si le dossier contient déjà le rapport d'une autre exécution, ce rapport antérieur est déplacé dans son propre sous-dossier sous runs et y reste vérifiable, et exporter à nouveau la même exécution remplace simplement son rapport. Si un export échoue, le dossier reste tel qu'il était.
  • Personnalisation : ouvrez cette section pour définir un Titre, un Pied de page et une Couleur d’accent (une couleur hexadécimale telle que #2563eb).

Cliquez sur Exporter (ou Exporter 3 rapports, etc.), ou appuyez sur Ctrl+Enter ; Escape ferme le formulaire. Tant que vous n'êtes pas connecté à un projet TIA, Exporter est indisponible et le formulaire l'indique, car les rapports sont écrits dans le projet. Le rapport HTML de l'exécution exportée la plus récente s'ouvre dans Studio sous forme de page dès qu'il est prêt, et un message indique le dossier dans lequel les fichiers ont été écrits et, lorsqu'un rapport antérieur a été déplacé, où il se trouve. Cliquez sur Ouvrir le dossier dans ce message pour voir les fichiers dans l'Explorateur de fichiers. Le formulaire mémorise vos formats, votre dossier et votre personnalisation pour l'export suivant.

Qualité : couverture et mutation

L'onglet Qualité du Test Bench montre dans quelle mesure les tests d'une suite exercent leur bloc. Il se rapporte à la suite choisie dans l'en-tête du Test Bench ; s'il n'y en a pas, il affiche la suite de votre exécution la plus récente. Il comporte deux sections, que vous pouvez replier et déplier ; Studio mémorise celles qui sont repliées.

Couverture. La ligne sous le titre indique l'exécution à laquelle elle se rapporte, et si cette exécution a mesuré la couverture ligne par ligne. Jusqu'à cinq barres montrent ce que les tests ont atteint : Exigence, Interface, Blocs appelés, et après une exécution avec instrumentation de couverture aussi Instruction et Branche. Chaque barre affiche le nombre couvert sur le total et un pourcentage, ou s. o. lorsque le bloc ne contient rien de ce type. Ouvrez une barre pour voir ce qui n'a pas été atteint ; pour les instructions et les branches, cliquez sur une ligne pour ouvrir le bloc à cette ligne. Les icônes du titre de la section sont Actualiser, Exporter la couverture… (écrit un fichier Cobertura dans le dossier des rapports de votre projet TIA ; le message nomme le dossier, indique où un rapport antérieur qu'il contenait a été déplacé, et propose Ouvrir le dossier) et Exécuter avec instrumentation de couverture.

Mutation. Affiche le dernier résultat du test de mutation de la suite (voir Test de mutation ci-dessous), même si vous avez exécuté la suite normalement après l'exécution de mutation. Les icônes du titre de la section sont Actualiser, Activer/désactiver les marqueurs de mutation (coché tant que les marqueurs sont affichés dans l'éditeur, le même paramètre que Afficher les marqueurs de mutation dans le menu … du Test Bench) et Exécuter le test de mutation.

Lancer une exécution depuis cet onglet. Exécuter avec instrumentation de couverture et Exécuter le test de mutation exécutent la suite de la section. Comme toute exécution depuis le Test Bench, elles demandent d'abord d'enregistrer la suite lorsqu'elle contient des modifications non enregistrées. Elles sont grisées, avec la raison, lorsque vous n'êtes pas connecté à TIA Portal ; pour une suite CODESYS, les deux nécessitent seulement que le projet CODESYS soit ouvert dans Studio (voir Tester des blocs CODESYS). Les deux fonctionnent pour les suites qui utilisent PLCSIM Advanced, S7 Native ou OPC UA ; pour S7 Native et OPC UA, l'adresse doit appartenir à une instance PLCSIM Advanced de cet ordinateur (voir Exécution du test de mutation ci-dessous). Pendant et après une telle exécution, le Test Bench reste sur l'onglet Qualité et les deux sections se mettent à jour à la fin de l'exécution.

Test de mutation

Le test de mutation répond à une question que la couverture ne peut pas trancher : vos tests détectent-ils réellement un défaut ? Il apporte une série de minuscules modifications à une copie de votre bloc (par exemple en remplaçant un > par un >=, en échangeant un AND contre un OR ou en supprimant une affectation de sortie), exécute votre suite de tests existante sur chaque copie modifiée et signale les modifications que vos tests n'ont pas remarquées. Une modification détectée par votre suite est un mutant « tué » ; une modification passée inaperçue alors que tous les tests restent au vert est un mutant « survivant », et cela révèle une lacune dans vos tests.

Votre bloc d'origine n'est jamais modifié. Chaque modification est effectuée sur une copie jetable que Studio supprime après chaque exécution.

Lancer le test de mutation

  1. Choisissez une suite de tests dans la vue Explorateur de tests unitaires.
  2. Assurez-vous d'être connecté à TIA Portal et que votre suite s'exécute sur une instance PLCSIM Advanced de cet ordinateur. Le test de mutation charge des copies modifiées de votre bloc, il ne s'exécute donc jamais sur un automate réel :

    • Une suite qui utilise PLCSIM Advanced s'exécute sur son instance comme d'habitude.
    • Une suite qui utilise S7 Native ou OPC UA ne s'exécute que si son adresse enregistrée appartient à exactement une instance PLCSIM Advanced en marche sur cet ordinateur. Studio le vérifie au démarrage de l'exécution et refuse sinon l'exécution en indiquant la raison, par exemple lorsque la suite n'a pas d'adresse S7 enregistrée ou que l'adresse appartient à un automate réel. Studio charge alors les copies de test uniquement dans cette instance, la passe en RUN et y recharge votre projet à la fin de l'exécution. Si la CPU est protégée, Studio demande son mot de passe comme pour tout chargement. Si l'instance demande un effacement général, Studio vous le demande d'abord, comme le fait Charger dans l'appareil, et un effacement refusé met fin à l'exécution avec un message. Si le chargement donne à l'instance l'adresse configurée dans votre projet, l'exécution s'arrête avec un message qui indique cette adresse, afin que vous puissiez la définir comme adresse S7 de la suite ou modifier l'adresse dans le projet.

    Il en va de même pour Exécuter avec instrumentation de couverture.

  3. Lancez Exécuter le test de mutation depuis la palette de commandes.
  4. Studio exécute d'abord la suite une fois sur le bloc non modifié. La suite doit d'abord réussir (le test de mutation mesure si vos tests réussis sont rigoureux, il vous demande donc de corriger les cas en échec avant de continuer). Il génère ensuite les mutants et exécute la suite sur chacun d'eux.

Vous pouvez aussi le lancer avec Exécuter le test de mutation dans la section Mutation de l'onglet Qualité, ou en choisissant Test de mutation dans les options d'exécution du Test Bench ; le Test Bench reste alors sur l'onglet Qualité.

L'exécution peut prendre un certain temps, car chaque mutant est compilé, chargé et testé tour à tour. Vous pouvez l'arrêter à tout moment, et Studio supprime quand même les copies temporaires qu'il a créées.

Lorsqu'une copie ne peut pas être supprimée. Si Studio ne parvient pas à supprimer l'un de ses blocs de test temporaires après une exécution de couverture ou de mutation, un avertissement nomme les blocs de test restants ; supprimez-les dans TIA Portal avant le prochain chargement. Pour une suite qui utilise S7 Native ou OPC UA, Studio ne recharge alors pas votre projet dans l'instance, car les blocs de test seraient chargés avec lui : l'avertissement nomme aussi l'instance et son adresse, et l'instance continue d'exécuter le programme de test jusqu'à ce que vous supprimiez ces blocs et chargiez vous-même le projet dans l'instance.

Noms très longs. Lorsque le nom du bloc ou de son bloc de données d'instance dépasse 120 caractères, Studio ne peut pas créer ses copies de test : Exécuter avec instrumentation de couverture vous indique alors que la couverture des instructions n'est pas disponible pour le bloc, et le test de mutation s'arrête après la première exécution avec un message qui donne cette raison.

Lire les résultats

La section Mutation de l'onglet Qualité du Test Bench affiche :

  • Un score de mutation (le pourcentage de mutants détectés par vos tests, sans compter ceux qui n'ont pas pu s'exécuter), avec le nombre de mutants tués, survivants et mort-nés.
  • Une liste Mutants survivants, une ligne par lacune : la ligne, le type de modification et ce qui a été modifié. Cliquez sur une ligne pour accéder directement à cette ligne dans la source du bloc.
  • Des listes repliables des mutants tués et mort-nés.

Les mutants survivants sont aussi mis en évidence dans l'éditeur : les lignes concernées prennent une teinte rouge et un repère rouge dans la marge, avec une info-bulle qui décrit la modification qu'aucun test n'a détectée. Utilisez Afficher les marqueurs de mutation dans le menu … du Test Bench, Activer/désactiver les marqueurs de mutation dans la palette de commandes, ou Activer/désactiver les marqueurs de mutation dans la section Mutation de l'onglet Qualité pour les afficher ou les masquer.

Chaque modification est décrite comme un remplacement, par exemple « > remplacé par >= ».

Historique après le test de mutation. Un test de mutation laisse une seule exécution dans Historique : celle du bloc non modifié. Les exécutions sur les copies modifiées sont supprimées dès que chaque copie est testée, si bien que l'onglet Qualité affiche la couverture et le score de mutation de la même exécution, et que les tendances et la détection des cas instables ne sont pas faussées par les défauts testés.

Un score élevé signifie que vos tests ont détecté presque tous les défauts. Un score faible, ou une longue liste de survivants, vous indique précisément où ajouter ou renforcer des cas de test.

Paramètres

  • Nombre maximal de mutants par exécution définit combien de modifications Studio essaie en une exécution. Un nombre plus élevé trouve davantage de lacunes, mais prend plus de temps.
  • Opérateurs de mutation vous permet de choisir les types de modification à appliquer : comparaisons relationnelles, opérateurs logiques, constantes et arithmétique, et suppression d'instructions. Tous sont activés par défaut.

Traçabilité des exigences

L'onglet Traçabilité du Test Bench indique, pour chaque identifiant d'exigence de votre dossier de tests, quels cas de test le couvrent et quels sont leurs derniers résultats. Il couvre l'ensemble du dossier de tests, quels que soient l'automate, le bloc ou la suite affichés dans l'en-tête du Test Bench. Ouvrez-le depuis son onglet à côté de Qualité, ou lancez Tests unitaires : Afficher la traçabilité des exigences depuis la palette de commandes. Lorsqu'une exigence est choisie dans le filtre Exigence de l'éditeur de suite de tests, Afficher dans la traçabilité ouvre l'onglet avec cette exigence sélectionnée.

La liste des exigences. Le tableau supérieur affiche une ligne par exigence avec son état, le nombre de cas de test, une pastille par résultat (par exemple 2 réussis, 1 en échec), les suites et l'heure de la dernière preuve. Les lignes sont triées par état, la plus urgente en premier :

État Signification
Échec Au moins un cas de test de l'exigence a échoué ou s'est terminé par une erreur lors de sa dernière exécution
Non couvert Votre liste d'exigences importée nomme l'exigence, mais aucun cas de test ne la nomme encore
Non exécuté Un cas de test de l'exigence ne s'est pas exécuté lors des exécutions récentes de sa suite
Obsolète Un cas de test a été modifié après sa dernière exécution, ou une nouvelle référence d'instantané de sa suite a été approuvée ; exécutez-le à nouveau
Inconnu La dernière exécution a été enregistrée avant que Studio puisse détecter les modifications ; exécutez-la à nouveau
Incomplet Un cas de test a été ignoré ou mis en quarantaine comme instable
Réussi Chaque cas de test de l'exigence a réussi lors de sa dernière exécution

Studio examine les 20 dernières exécutions de chaque suite. Lorsque vous n'exécutez qu'un cas de test ou une sélection, cette exécution ne compte que pour ces cas ; les autres cas conservent le résultat de leur dernière exécution complète. Modifier la connexion d'une suite (instance PLCSIM, adresse IP, mots de passe) ne rend pas les résultats obsolètes.

Les cas de test d'une exigence. Sélectionnez une exigence pour voir ses cas de test dans la section Cas ci-dessous : suite, cas, état, heure de début de l'exécution qui a produit le résultat (marquée « exécution partielle » lorsque seuls certains cas ont été exécutés), validation ou non de cette exécution, et message. Double-cliquez sur un cas, ou appuyez sur Entrée, pour ouvrir cette exécution dans l'onglet Exécution avec le cas sélectionné. Cliquez avec le bouton droit sur un cas pour Afficher l'exécution, Ouvrir dans l'éditeur de suite et Copier l'identifiant d'exigence. Faites glisser le séparateur pour redimensionner les sections, ou appuyez sur Tab jusqu'à ce que le séparateur ait le focus et utilisez les flèches Haut et Bas (avec Maj pour des pas plus grands, Début et Fin pour le déplacer jusqu'au bout). Réduisez la section Cas avec son en-tête.

Filtre. Saisissez du texte dans le champ de filtre pour rechercher des identifiants d'exigence, des titres, des suites, des cas et des blocs. État limite la liste à un seul état. Cas non tracés liste les cas de test qui ne nomment aucune exigence, pour retrouver les tests qui ont encore besoin d'un identifiant d'exigence. Les compteurs à droite de la ligne supérieure résument la liste, par exemple « 12 exigences, 1 en échec, 2 non couvertes ». Actualiser (F5) recharge l'onglet ; il s'actualise aussi de lui-même après une exécution et lorsque vous enregistrez une suite.

Partager. Le bouton Partager, à droite de la ligne supérieure, propose :

  • Exporter en CSV… écrit les lignes actuellement affichées (une ligne par exigence et cas de test, avec la validation de l'exécution qui a produit chaque résultat) dans un fichier CSV pour vos dossiers qualité. Les cellules qu'un tableur exécuterait comme formule sont écrites en texte brut.
  • Exporter le rapport HTML écrit un rapport de traçabilité dans le dossier des rapports de votre projet TIA (le sous-dossier traceability du dossier de sortie que vous avez choisi en dernier dans Exporter le rapport, ou report/traceability si vous n'en avez pas choisi) et l'ouvre sous forme de page. Il liste chaque exigence avec son état et ses cas de test, les cas de test non tracés, les problèmes de votre liste d'exigences et une légende des états, avec le titre, le pied de page et la couleur d'accent de votre dernier rapport. Vous pouvez vérifier plus tard avec tia-test-runner verify que personne n'a modifié les fichiers. Cette entrée est disponible tant que vous êtes connecté au projet TIA.

L'onglet, l'exigence sélectionnée, le filtre d'état et le bouton Cas non tracés sont conservés lorsque vous redémarrez Studio.

Importer une liste d'exigences

Importez la liste d'exigences de votre projet (par exemple un export de votre outil ALM ou de gestion des exigences, ou un tableur enregistré au format CSV) pour voir quelles exigences n'ont pas encore de test. Ouvrez Liste d'exigences dans la ligne supérieure de l'onglet Traçabilité et choisissez Importer la liste d'exigences…, ou lancez Tests unitaires : Importer la liste d'exigences... depuis la palette de commandes, puis choisissez le fichier.

  • Fichiers : fichiers CSV ou texte jusqu'à 10 MB et 20,000 lignes. Les fichiers UTF-8, UTF-16 (le « texte Unicode » des tableurs) et ANSI sont lus ; les colonnes peuvent être séparées par des virgules, des points-virgules ou des tabulations. Enregistrez la liste en UTF-8 pour conserver exactement les caractères spéciaux.
  • Colonnes : la première ligne nomme les colonnes. La colonne des identifiants d'exigence peut s'appeler id, requirement, requirement id, req id ou req ; une colonne de titre facultative title, name ou summary ; une colonne de description facultative description, text ou details. Les autres colonnes sont ignorées. Un fichier avec une seule colonne d'identifiants et sans en-tête fonctionne aussi.
  • Avant toute écriture, Studio vérifie le fichier et affiche ce qu'il a trouvé, par exemple « 124 exigences trouvées. 1 ligne est ignorée. », avec les éventuels problèmes, et propose Importer. Les lignes avec un identifiant vide ou non valide sont ignorées, un identifiant en double conserve sa première ligne, et les titres ou descriptions trop longs sont raccourcis. Un fichier qui ne peut pas du tout être importé (trop volumineux, sans colonne d'identifiants, guillemet non fermé) est refusé avec la raison.
  • La liste est stockée dans le dossier de tests à côté de vos suites (.tia-tests/requirements.csv) : elle les accompagne ainsi dans le contrôle de version, et l'exécuteur en ligne de commande la trouve aussi. Une nouvelle importation la remplace ; votre fichier d'origine n'est jamais modifié.

Avec une liste, l'onglet Traçabilité ajoute une colonne Titre, affiche les exigences listées sans cas de test comme Non couvert et marque les identifiants d'exigence de vos suites que la liste ne contient pas avec « Absent de la liste d'exigences ». Lorsqu'un identifiant est écrit différemment dans la liste et dans les suites (par exemple REQ-1 et req-1), une remarque au-dessus du tableau le signale. Les problèmes de la liste sont résumés au-dessus du tableau, et les identifiants de la liste sont proposés lorsque vous saisissez un identifiant d'exigence dans un cas de test.

Ouvrir la liste d'exigences ouvre la liste stockée dans un éditeur de texte. Si vous l'ouvrez plutôt dans un tableur, les cellules qui commencent par =, +, - ou @ sont calculées comme des formules ; Studio conserve ces identifiants, titres et descriptions exactement tels qu'ils sont écrits et vous en avertit. Supprimer la liste d'exigences… place la liste dans la corbeille après confirmation ; les exigences qu'aucun cas de test ne nomme disparaissent alors de l'onglet.

Dans le chat IA, vous pouvez demander « quelles exigences échouent ? » ou « quelles exigences n'ont pas encore de test ? » ; l'assistant lit les mêmes états que l'onglet. Il peut aussi vérifier et importer un fichier de liste d'exigences pour vous ; il vous demande votre accord avant de remplacer la liste et avant de vérifier un fichier situé hors de votre espace de travail. La suppression de la liste vous est réservée.

Valider une exécution de test

Avec un forfait Pro+ ou Enterprise (également pendant la version d'essai), vous pouvez valider une exécution de test pour attester que vous avez vérifié et accepté son résultat, par exemple avant un test de réception en usine. La validation indique votre compte et l'heure, et peut comporter un commentaire. Vous pouvez valider vos propres exécutions. Chaque exécution ne peut être validée qu'une fois ; pour modifier une validation, révoquez-la et validez à nouveau.

Exécutions pouvant être validées. Une exécution terminée d'une suite complète. Une exécution annulée, une exécution de certains cas de test seulement et une exécution dont la suite a été modifiée ensuite ne peuvent pas être validées ; exécutez à nouveau la suite et validez la nouvelle exécution. Les exécutions enregistrées avant que la validation soit disponible nécessitent aussi une nouvelle exécution. Lorsqu'une exécution comporte des cas de test en échec, en erreur ou en quarantaine, un commentaire expliquant pourquoi le résultat est accepté est obligatoire.

Valider.

  1. Ouvrez l'exécution dans l'onglet Exécution et cliquez sur Valider… dans sa ligne de validation, ou cliquez avec le bouton droit sur l'exécution dans l'onglet Historique et choisissez Valider…. Vous pouvez aussi lancer Tests unitaires : Valider l'exécution de test… depuis la palette de commandes, qui ouvre l'onglet Historique avec l'exécution sélectionnée ou la plus récente.
  2. Un petit formulaire affiche les exécutions avec leurs résultats et le compte avec lequel vous validez (« Validation en tant que … »). Saisissez un commentaire si vous le souhaitez (jusqu'à 1,000 caractères, sauts de ligne autorisés).
  3. Cliquez sur Valider ou appuyez sur Ctrl+Enter.

Pour valider plusieurs exécutions à la fois, sélectionnez-les dans Historique (jusqu'à 50) et choisissez Valider… sur l'une d'elles, ou cliquez sur Valider… dans l'onglet Exécution après une exécution de toutes les suites. Soit toutes les exécutions sont validées, soit aucune : si une exécution ne peut pas être validée, le formulaire indique la raison à côté de cette exécution et rien n'est enregistré.

Révoquer. Cliquez sur Révoquer… dans l'onglet Exécution, choisissez Révoquer la validation… sur l'exécution dans Historique, ou lancez Tests unitaires : Révoquer la validation de l'exécution de test…. Seul le compte qui a validé l'exécution peut la révoquer. Saisissez la raison (obligatoire) et cliquez sur Révoquer la validation. La validation et la raison restent dans l'historique de l'exécution, et l'exécution peut être validée à nouveau.

Signification des états.

État Signification
Validé L'exécution et sa suite n'ont pas changé depuis la validation
Obsolète La suite a été modifiée après la validation ; exécutez-la à nouveau et validez la nouvelle exécution
Validé, suite supprimée Le fichier de la suite a été supprimé après la validation
Rompu L'exécution enregistrée ne correspond plus à ce qui a été validé
Révoqué La validation a été révoquée ; l'exécution peut être validée à nouveau
Non validé Personne n'a validé l'exécution

Dans l'onglet Exécution, survolez l'état pour voir qui a validé, quand, ainsi que chaque validation et révocation antérieure de l'exécution.

Les exécutions validées sont conservées. Une exécution validée ne peut pas être supprimée de Historique tant que vous n'avez pas révoqué sa validation. Supprimer une suite ne supprime jamais ses exécutions ; la confirmation vous indique combien d'exécutions validées de la suite restent dans Historique. Lorsque les anciennes exécutions sont effacées de la base de résultats, les exécutions validées sont conservées.

Dans les rapports. Le rapport HTML d'une exécution affiche son état de validation tel qu'il était lors de l'export du rapport, avec le compte, l'heure, le commentaire et, pour une validation révoquée, la raison. Le rapport JUnit XML contient les mêmes détails, afin que votre système CI puisse les afficher. tia-test-runner verify affiche la validation d'un rapport et échoue lorsque ses détails ont été modifiés après l'export.

Bon à savoir. La validation est enregistrée sur l'ordinateur qui contient l'exécution, dans sa base de résultats locale, pour le compte avec lequel vous êtes connecté. Elle détecte les modifications ultérieures de l'exécution, de la suite et de la validation elle-même, mais ce n'est pas une signature électronique. Vous devez être connecté avec votre compte ; si Studio vous demande de vous reconnecter, connectez-vous avant de valider. Si Studio refuse de valider ou de révoquer à cause de l'heure, vérifiez l'heure système de votre ordinateur. L'assistant IA peut vous dire si des exécutions sont validées, mais vous seul pouvez valider ou révoquer.

Analyse du bloc (avant l'exécution des tests)

Lorsque vous ouvrez une suite, AnyAutomation Studio extrait l'interface du bloc depuis le projet TIA, afin que l'éditeur connaisse les vrais noms et types des paramètres et que les grilles des entrées et des assertions puissent s'y référer pour la validation.

Vous n'avez pas besoin que TIA Portal soit ouvert pour cela. Si vous n'êtes pas connecté à TIA Portal, Studio lit le bloc depuis une copie que vous avez exportée auparavant (exportez-la depuis l'explorateur de projet). Si le bloc n'a pas encore été exporté, Studio affiche un message vous demandant de l'exporter d'abord ou de vous connecter à TIA Portal, au lieu de laisser l'interface vide. Il en va de même lorsque vous exécutez une suite : sans bloc exporté et sans connexion, Studio nomme le bloc, vous demande de l'exporter ou de vous connecter avec Ouvrir le projet TIA ou Attacher à TIA Portal en cours d'exécution, et n'exécute rien.

Pour un bloc d'une suite CODESYS, Studio lit l'interface depuis le projet CODESYS ouvert, et la carte de la colonne Bloc affiche le nom de ce projet. Analyser les dépendances liste alors les blocs appelés, les variables globales et les types de données que le bloc et ses méthodes utilisent ; si Studio n'a pas pu lire tous les objets du projet, l'onglet indique que la liste peut être incomplète. Lorsque le projet CODESYS est fermé, la colonne Bloc n'analyse pas le bloc.

Choisir un dossier source. Choisir le dossier source… dans le menu de connexion de l'en-tête du Test Bench vous permet d'indiquer à Studio où se trouvent vos blocs exportés. Choisissez le dossier qui contient vos fichiers d'export, et la structure de dossiers à l'intérieur n'a plus d'importance : que les fichiers se trouvent directement dans le dossier ou dans des sous-dossiers, Studio trouve le bon fichier pour le bloc. Vous pouvez ainsi analyser et exécuter des tests sans TIA Portal ouvert. Le dossier source choisi est mémorisé, il est donc de nouveau prêt juste après un redémarrage. Le même menu propose ensuite Changer le dossier source… et Effacer le dossier source. Pour des résultats optimaux, choisissez le dossier dans lequel vous avez exporté, pas un dossier parent de plusieurs projets.

La colonne Bloc du Test Bench comporte les onglets Interface, Limites et Dépendances. Choisissez un bloc dans l'en-tête, et Interface et Limites se remplissent aussitôt ; les Dépendances sont lues lorsque vous cliquez sur Analyser les dépendances. Ces onglets résument :

  • Interface : tous les paramètres du bloc (Input, Output, InOut, Static, Temp) avec leurs types ; survolez un type pour voir sa valeur par défaut. Les structures, les types de données d'automate et les multi-instances sont d'abord réduits : cliquez sur l'un d'eux pour le développer, ou utilisez Tout développer et Tout réduire en haut de l'onglet.
  • Limites : valeurs min/max/zéro/un générées automatiquement par type de paramètre (avec une action Générer des cas limites qui enregistre un cas paramétré comme nouvelle suite)
  • Dépendances : blocs appelés, DB référencés, UDT référencés

Créer une nouvelle suite de tests

  1. Cliquez sur Nouvelle suite de tests dans la barre de titre de la vue Explorateur de tests unitaires (ou lancez la commande depuis la palette de commandes)
  2. Lorsque vous êtes connecté à un projet TIA contenant des automates, choisissez l'Automate, puis le Bloc à tester : le nom de la suite est dérivé automatiquement sous la forme <Block>_Tests. (Ce n'est que lorsqu'aucun automate n'est disponible que vous répondez à la place à trois invites de texte libre successives : le Nom de la suite, le Bloc à tester et le Nom de l’automate.)
  3. La nouvelle suite est écrite dans <projectDir>/.tia-tests/{name}.json et apparaît dans la vue Explorateur de tests unitaires
  4. L'éditeur de suite de tests s'ouvre avec un cas de test vide, Case_1. Ajoutez les variables dont vous avez besoin avec Ajouter une entrée et Ajouter une assertion : chaque nouvelle ligne commence vide, et la liste du champ Variable affiche chaque membre de l'interface du bloc, y compris les membres des structures, des types de données d'automate et des multi-instances ; choisissez une entrée dans la liste ou saisissez le nom. Une nouvelle ligne d'entrée appartient au cas dès qu'elle a un nom ; avant cela, son icône de suppression l'abandonne. Un nom déjà présent dans la liste est marqué en rouge, et la ligne reste afin que vous puissiez le corriger. L'interface du bloc est lue depuis le projet TIA, de sorte que les grilles des entrées et des assertions valident par rapport aux vrais noms de paramètres. Une entrée que le cas ne définit pas conserve la valeur qu'elle a dans l'automate au démarrage du cas : définissez donc chaque entrée dont votre test dépend. Pour partir plutôt de cas remplis avec des valeurs limites, utilisez Générer à partir des limites dans le menu ….
  5. Utilisez le mode Visuel (maître-détail basé sur des formulaires) pour ajouter, supprimer ou dupliquer des cas de test à l'aide de champs et de grilles : Nom, Description, Cycles, Balises, Priorité + grille Arrange-Inputs + grille Assertions + liste de surveillance. Passez à tout moment à Ouvrir au format JSON pour modifier le JSON brut. La vue SCL affiche le code de test SCL généré et est également modifiable (voir Gérer les suites et les cas de test)
  6. Cliquez sur Enregistrer (Ctrl+S) pour enregistrer vos modifications

Renommer une suite depuis le champ JSON name

Lorsque vous modifiez le champ name en haut du JSON de la suite et appuyez sur Enregistrer, le fichier est renommé sur le disque en conséquence ({newName}.json), et le titre de l'éditeur est mis à jour dans la même étape. Si une suite portant le nouveau nom existe déjà dans le même dossier, l'enregistrement est interrompu avec une erreur et laisse les deux fichiers intacts, afin que vous puissiez choisir un autre nom.

Le champ blockName est indépendant et continue d'identifier le bloc TIA testé ; il n'est pas affecté par un changement de nom.

Schéma JSON d'une suite de tests

Chaque fichier .tia-tests/*.json suit la même structure. Champs de premier niveau :

  • name

    Type
    string
    Obligatoire
    oui
    Rôle
    Identifiant de la suite (doit correspondre au nom du fichier sans .json)
  • blockName

    Type
    string
    Obligatoire
    oui
    Rôle
    Nom exact du bloc TIA (sensible à la casse)
  • plcName

    Type
    string
    Obligatoire
    oui
    Rôle
    Nom de l'automate ou de la CPU dans le projet TIA (p. ex. PLC_1)
  • config

    Type
    object
    Obligatoire
    oui
    Rôle
    Paramètres de connexion et de transport (voir ci-dessous)
  • testCases

    Type
    array
    Obligatoire
    oui
    Rôle
    Une entrée par cas de test (voir ci-dessous)
  • wiring

    Type
    object
    Obligatoire
    non
    Rôle
    Variable de bloc de données que le programme appelant transmet à chaque entrée, écrite à cet endroit par le test (voir Câbler les entrées au programme appelant)

config (champs facultatifs, valeurs par défaut indiquées) :

  • cycles

    Valeur par défaut
    1
    Rôle
    Nombre de cycles d'automate par défaut par cas de test (remplaçable par cas via act.cycles)
  • cycleWaitMs

    Valeur par défaut
    100
    Rôle
    Durée d'un cycle de test sur PLCSim Advanced, OPC UA et S7 Native (voir Signification d'un cycle de test) ; avec Pas à pas, le temps de cycle fixe de chaque scrutation. Non utilisé par les suites CODESYS, qui ont leur Intervalle de tâche (ms)
  • timeoutMs

    Valeur par défaut
    5000
    Rôle
    Délai d'expiration strict par cas de test
  • instanceDbName

    Valeur par défaut
    ""
    Rôle
    DB d'instance à lire et écrire ; vide → <blockName>_DB (convention Siemens)
  • preferFc

    Valeur par défaut
    false
    Rôle
    Tolère les blocs FC (sans DB d'instance) ; à activer lorsque la cible est une fonction et non un bloc fonctionnel
  • transport

    Valeur par défaut
    "plcSimApi"
    Rôle
    "plcSimApi" pour l'API Tag de PLCSIM en accès direct (par défaut), "s7CommPlus" pour se connecter directement à un automate S7 réel (voir Connexion via S7 Native)
  • s7IpAddress

    Valeur par défaut
    192.168.0.1
    Rôle
    Cible de connexion S7, utilisée uniquement lorsque preparationMode = "external" (automate réel). Pour les modes basés sur PLCSIM (userPreloaded, tiaTcpDownload), l'exécuteur se connecte à la place à plcSimIp, quel que soit le transport
  • s7Port

    Valeur par défaut
    102
    Rôle
    Port S7 ISO-on-TCP. La valeur par défaut 102 correspond à tous les réglages par défaut de Siemens ; ne la modifiez que si l'automate a été reconfiguré sur un port TCP non standard
  • s7User, s7PasswordKeyId

    Valeur par défaut
    "" / null
    Rôle
    Référence des identifiants (le mot de passe est défini sur la page Paramètres de connexion et n'est jamais écrit dans le fichier de la suite). Obligatoire uniquement lorsque l'automate impose une authentification des utilisateurs ; la plupart des projets le laissent vide
  • plcSimInstanceName

    Valeur par défaut
    "TiaUnitTest"
    Rôle
    Nom de l'instance PLCSIM Advanced. Utilisé par les deux transports dès que preparationMode != "external"
  • plcSimIp

    Valeur par défaut
    "192.168.0.100"
    Rôle
    IP de l'adaptateur virtuel PLCSIM. C'est la cible de connexion S7 effective pour s7CommPlus + userPreloaded/tiaTcpDownload : définissez-la sur l'IP que vous avez attribuée à l'adaptateur Ethernet virtuel Siemens PLCSIM, pas sur l'IP du projet de l'automate
  • preparationMode

    Valeur par défaut
    "userPreloaded"
    Rôle
    userPreloaded (par défaut ; suppose que l'instance PLCSIM est déjà en marche avec votre projet chargé), tiaTcpDownload (compile et charge depuis le projet TIA ouvert, voir les prérequis ci-dessous) ou external (automate réel ; utilise s7IpAddress)
  • masterSecretPasswordKeyId

    Valeur par défaut
    null
    Rôle
    Référence du mot de passe maître du projet. Obligatoire pour tiaTcpDownload uniquement lorsque le projet TIA utilise la protection des données de configuration confidentielles de l'automate. Le mot de passe est défini sur la page Paramètres de connexion et n'est jamais écrit dans le fichier de la suite
  • autoConnectS7

    Valeur par défaut
    true
    Rôle
    Connexion S7 automatique avant le début de l'exécution. Ne la définissez sur false que dans des configurations avancées où un autre client (WinCC, HMI personnalisée) détient déjà la session et où l'exécuteur doit lire et écrire par son intermédiaire
  • keepInstanceAfterRun

    Valeur par défaut
    false
    Rôle
    Maintient l'instance PLCSIM active après l'exécution. N'a d'effet qu'en mode tiaTcpDownload ; userPreloaded et external ne gèrent jamais le cycle de vie de l'instance

Chaque entrée de testCases :

  • name

    Type
    string
    Obligatoire
    oui
    Rôle
    Nom du scénario en PascalCase (p. ex. Start_FromIdle_Runs)
  • description

    Type
    string
    Obligatoire
    non
    Rôle
    Une phrase : quoi et pourquoi
  • arrange.inputs

    Type
    object
    Obligatoire
    oui
    Rôle
    { "MemberName": value, … }, écrit dans le DB avant Act
  • act.cycles

    Type
    int
    Obligatoire
    non (par défaut config.cycles)
    Rôle
    Cycles d'automate entre Arrange et Assert ; doit être > 1 pour que watch[] se déclenche. Mutuellement exclusif avec act.steps (le oneOf du schéma refuse les deux sur le même act)
  • act.timeoutMs

    Type
    int
    Obligatoire
    non (par défaut config.timeoutMs)
    Rôle
    Délai d'expiration par cas. Couvre toute la séquence steps de bout en bout lorsque steps est défini
  • act.steps

    Type
    array
    Obligatoire
    non
    Rôle
    Séquence ordonnée facultative d'étapes write / wait / assert qui s'exécute entre Arrange et le assertions de premier niveau. Voir Étapes multiphases ci-dessous. Mutuellement exclusif avec act.cycles
  • assertions

    Type
    array
    Obligatoire
    oui
    Rôle
    [ { "variable": "X", "operator": "equal", "expected": v, "tolerance": t? }, … ]
  • watch

    Type
    string[]
    Obligatoire
    non
    Rôle
    Variables échantillonnées une fois par cycle pendant Act → graphique chronologique dans les rapports HTML
  • tags

    Type
    string[]
    Obligatoire
    non
    Rôle
    Libellés libres
  • priority

    Type
    string
    Obligatoire
    non
    Rôle
    "low" / "normal" (par défaut) / "high" / "critical"
  • requirements

    Type
    string[]
    Obligatoire
    non
    Rôle
    Liens de traçabilité
  • order

    Type
    int
    Obligatoire
    non
    Rôle
    Clé de tri stable dans l'interface

Valeurs operator prises en charge : equal, notEqual, greaterThan, lessThan, greaterThanOrEqual, lessThanOrEqual, inRange (attend expected: [min, max]), inRangeExclusive, approximately, isTrue, isFalse, contains, startsWith, endsWith, matches, bitsSet, bitsClear, arrayEquals, allEqual, anyEqual, noneEqual, deepEquals. Pour les valeurs de date et d'heure (DT, DTL, LDT), les opérateurs d'égalité, de plage et d'ordre ainsi que approximately comparent l'instant, de sorte que expected peut être un littéral tel que LDT#2024-05-17-08:30:15 ou le nombre de nanosecondes depuis 1970, et le tolerance de approximately est indiqué en nanosecondes. tolerance s'applique à inRange, approximately, arrayEquals, allEqual, anyEqual, noneEqual et deepEquals (par défaut 0.0001), pas à equal/notEqual ; utilisez approximately pour une égalité Real/LReal approximative. expected est exigé par le schéma pour chaque assertion (définissez-le sur n'importe quelle valeur, comme false, true ou 0, pour isTrue/isFalse, car l'exécuteur l'ignore).

Sécurité : les valeurs d'exemple sont des espaces réservés. Lorsque l'éditeur ne peut pas déduire les vrais noms d'Input/Output à partir de l'interface du bloc, l'exemple pré-rempli utilise des valeurs par défaut sûres (Enable: false, Running: false), afin qu'une exécution en un clic ne puisse pas activer accidentellement des moteurs, des vannes ou d'autres sorties sur du matériel réel. Vérifiez toujours chaque valeur arrange.inputs et chaque assertion avant de lancer l'exécuteur sur un automate réel.

Important : watch[] est le tableau de diagnostic du cas de test, PAS la table de surveillance TIA. Les variables listées dans watch sont échantillonnées une fois par cycle d'automate pendant la phase Act (à condition que act.cycles > 1) et affichées sous forme de graphique chronologique dans les rapports HTML. Cela est indépendant de la table de surveillance externe de TIA Portal et de tout abonnement OPC UA.

Exemple complet

Une suite minimale complète avec un cas de test qui exerce chaque bloc et utilise watch[] :

{
  "name": "FB_Motor_Tests",
  "blockName": "FB_Motor",
  "plcName": "PLC_1",
  "config": {
    "cycles": 1,
    "timeoutMs": 5000,
    "instanceDbName": "FB_Motor_DB",
    "transport": "plcSimApi",
    "autoConnectS7": true,
    "preparationMode": "userPreloaded"
  },
  "testCases": [
    {
      "name": "Start_FromIdle_RunsWithinThreeCycles",
      "description": "Asserting Run goes high after StartCmd is set; watch shows trajectory.",
      "arrange": {
        "inputs": {
          "StartCmd": true,
          "Reset":    false,
          "Speed":    50.0
        }
      },
      "act": { "cycles": 5 },
      "assertions": [
        { "variable": "Run",       "operator": "equal",     "expected": true },
        { "variable": "Speed_Act", "operator": "inRange",   "expected": [49.5, 50.5] },
        { "variable": "Error",     "operator": "isFalse", "expected": false }
      ],
      "watch": ["Run", "Speed_Act", "StartCmd"],
      "tags": ["happy-path", "smoke"],
      "priority": "normal"
    }
  ]
}

Après l'exécution, l'onglet Exécution du Test Bench affiche la réussite ou l'échec de chaque assertion, et le rapport HTML affiche un graphique chronologique des trois variables watch sur les 5 cycles. Pour surveiller davantage de variables dans un cas existant, ajoutez-les au tableau watch et augmentez act.cycles jusqu'au plus petit nombre qui donne une couverture utile (3-10 en général).

Étapes multiphases (act.steps)

Lorsqu'un simple Arrange puis Assert ne suffit pas (par exemple réinitialiser → attendre → démarrer → attendre → vérifier), utilisez act.steps au lieu de act.cycles. Trois types d'étapes sont disponibles :

  • "write"

    Champs obligatoires
    inputs (objet, même structure que arrange.inputs)
    Effet
    Écrit les membres listés en complément de ce qui se trouve déjà dans le DB. Les membres non listés conservent leur valeur.
  • "wait"

    Champs obligatoires
    ms (int, 0..3 600 000)
    Effet
    Attente asynchrone. L'automate continue ses cycles. Lorsque watch[] n'est pas vide et que config.cycleWaitMs > 0, les variables surveillées sont échantillonnées toutes les config.cycleWaitMs ms pendant toute la fenêtre d'attente. Avec Pas à pas, l'attente exécute à la place une scrutation par cycle de test.
  • "assert"

    Champs obligatoires
    assertions (tableau, même structure que le assertions de premier niveau)
    Effet
    Point de contrôle par étape. Un échec interrompt immédiatement le cas et signale Step <N> (assert): <reason> (numérotation à partir de 1).

Ordre des opérations :

  1. arrange.inputs est écrit une fois au démarrage du cas (il n'est pas rejoué entre les étapes).
  2. Chaque entrée de steps s'exécute dans l'ordre de déclaration.
  3. Après la dernière étape, le assertions[] de premier niveau s'exécute comme contrôle final. Les assertions par étape et celles de premier niveau sont indépendantes ; les deux doivent réussir. Le schéma exige minItems: 1 sur le assertions de premier niveau : rédigez donc au moins une assertion triviale de premier niveau, même si vous vous appuyez surtout sur les assertions par étape.
  4. watch[] continue d'échantillonner pendant chaque étape wait (dans les conditions ci-dessus) ; le graphique chronologique annote les limites entre étapes.

Plafonds (appliqués par l'exécuteur) :

Limite Valeur
Étapes par cas 1024
Entrées par étape write 256
Assertions par étape assert 256
wait.ms 0..3 600 000 (1 heure)

Éditeur visuel : la vue détaillée du cas affiche une section Steps (optional) avec les boutons + Write, + Wait, + Assert pour ajouter des étapes, des boutons ↑ / ↓ par étape pour les réordonner, et - pour en supprimer. L'éditeur omet automatiquement cycles du JSON sérialisé dès que la section Steps n'est pas vide (le schéma refuse la combinaison cycles + steps, l'éditeur évite donc de la produire).

Rétrocompatibilité : un cas sans steps suit le chemin monophase existant basé sur cycles, sans changement de comportement. Les suites plus anciennes ne nécessitent aucune migration.

Exemple complet : démarrage temporisé d'un moteur

StartCmd est activé après une fenêtre de réinitialisation 500 ms, puis on attend 2 s que le FB atteigne Run, avec un contrôle final de la vitesse.

{
  "name": "MotorStart_ReachesRun",
  "description": "Reset, wait, start, wait, check Run.",
  "arrange": { "inputs": { "Enable": true } },
  "act": {
    "timeoutMs": 10000,
    "steps": [
      { "type": "write", "inputs": { "Reset": true } },
      { "type": "wait",  "ms": 500 },
      { "type": "write", "inputs": { "Reset": false, "StartCmd": true } },
      { "type": "wait",  "ms": 2000 },
      { "type": "assert", "assertions": [
          { "variable": "Run", "operator": "isTrue", "expected": true }
        ]
      }
    ]
  },
  "assertions": [
    { "variable": "Speed_Act", "operator": "greaterThan", "expected": 1000 }
  ],
  "watch": ["Run", "Speed_Act"]
}

Si le assert d'une étape échoue (par exemple si Run n'est pas passé à vrai en 2 s), l'exécuteur émet Step 5 (assert): variable Run is not true et interrompt le cas. Si toutes les assertions par étape réussissent mais que le Speed_Act > 1000 de premier niveau échoue, le cas échoue avec le message de l'assertion de premier niveau.

En cas de doute, écrivez d'abord un cas simple Arrange + cycles ≥ N + Assert. Ne le convertissez en séquence steps que lorsque la forme simple ne peut pas exprimer la temporisation dont le test dépend réellement.

Ouvrir une suite existante

  • Depuis la vue Explorateur de tests unitaires : cliquez sur la suite dans l'arborescence (elle s'ouvre dans l'éditeur de suite de tests) ; un clic sur l'un de ses cas de test ouvre la suite avec ce cas sélectionné
  • Depuis l'ouverture rapide : appuyez sur Ctrl+P et tapez le nom du fichier de la suite sous .tia-tests/

Où les suites de tests sont-elles stockées ?

Les suites de tests se trouvent dans un dossier caché nommé .tia-tests, directement à côté du fichier de votre projet TIA (*.ap21, *.ap20, …), ou dans des dossiers que vous créez à l'intérieur (voir Organiser les suites de tests en dossiers). Les suites pour les blocs CODESYS se trouvent dans le même type de dossier à côté du fichier du projet CODESYS, utilisé lorsqu'aucun projet TIA n'est connecté. Un dossier de tests choisi avec Choisir le dossier de tests s'applique aux deux. L'assistant IA écrit dans le même dossier. Si vous n'avez pas encore choisi de dossier de tests, la vue Suites de tests affiche « Choisissez un dossier de tests pour charger vos suites de tests. » Choisissez d'abord un dossier.

Vous choisissez vous-même le dossier : dans la barre de titre de la vue Explorateur de tests unitaires, cliquez sur Choisir le dossier de tests et choisissez le dossier qui contient vos tests. Lorsqu'un dossier est choisi, la liste des suites de tests suit ce dossier : changer de projet ne le modifie pas ; sans dossier choisi, elle suit le projet TIA connecté. Le choix est mémorisé, de sorte que vos tests réapparaissent au prochain démarrage de l'application, même sans connexion TIA. Cela vous aide aussi à récupérer les tests d'une configuration antérieure : choisissez simplement le dossier dans lequel ils se trouvent. Effacer le dossier de tests (affiché uniquement lorsqu'un dossier est choisi) annule la sélection ; si le dossier choisi n'existe plus, la vue affiche « Dossier de tests sélectionné introuvable ».

L'IA peut lire, lister et modifier ces fichiers de suites de tests directement via le chat. Demandez à l'assistant où vos suites sont stockées : il nomme le dossier et indique s'il provient de votre choix ou du projet TIA. Si vous voulez placer les suites ailleurs, par exemple dans votre espace de travail Git, demandez-lui d'utiliser ce dossier ; il vous demande confirmation, puis fonctionne comme Choisir le dossier de tests. Les suites déjà enregistrées ne sont pas déplacées.

Exécuter les tests

  1. Assurez-vous que PLCSIM Advanced V3.0+ est installé
  2. Ouvrez le Test Bench et choisissez l'automate, le bloc et la suite dans son en-tête (ou sélectionnez la suite dans la vue Explorateur de tests unitaires)
  3. Lancez-la : cliquez sur Exécuter dans l'en-tête du Test Bench, sur Exécuter la suite dans la ligne d'une suite de la vue Explorateur de tests unitaires, sur Exécuter toutes les suites de tests dans la barre de titre de la vue, ou utilisez une action du menu contextuel (clic droit)
  4. Suivez la progression en direct dans la barre d'état et dans l'onglet Exécution du Test Bench
  5. Une fois l'exécution terminée, les icônes d'état de la vue Explorateur de tests unitaires sont mises à jour et les résultats sont enregistrés

Automatiquement, l'exécuteur :

  • Crée une instance PLCSIM Advanced (nom configurable dans le JSON de la suite)
  • La met sous tension et compile le projet d'automate actuel
  • Connecte un client S7 à l'instance
  • Écrit les entrées de test, attend le nombre de cycles configuré, lit les sorties et évalue les assertions
  • Ferme la connexion S7 et annule l'enregistrement de l'instance

Options d'exécution

La flèche à côté de Exécuter, dans l'en-tête du Test Bench et dans l'en-tête de l'éditeur de suite de tests, ouvre les options d'exécution. Elles se composent de quatre parties :

  • Portée : ce qu'il faut exécuter. Dans le Test Bench : Toutes les suites (chaque suite du dossier de tests du projet), Suite (la suite choisie dans l'en-tête) ou Cas en échec (les cas qui ont échoué lors de la dernière exécution). Dans l'éditeur de suite de tests : Suite, Cas en échec ou Cas sélectionnés (les lignes que vous avez sélectionnées dans la liste des cas ; choisi automatiquement lorsque des lignes sont sélectionnées). Un cas de théorie s'exécute avec toutes ses lignes de paramètres. Chaque entrée indique combien de suites ou de cas elle exécute.
  • Mode : Standard, Couverture, Test de mutation ou Contrats d'interface. La couverture et le test de mutation nécessitent une connexion à TIA Portal et une cible PLCSIM Advanced, soit directement, soit via S7 Native ou OPC UA à l'adresse d'une instance PLCSIM Advanced de cet ordinateur (une suite CODESYS nécessite seulement que son projet CODESYS soit ouvert dans Studio) ; la vérification des contrats d'un bloc TIA nécessite une connexion à TIA Portal. Ces trois modes exécutent une seule suite.
  • Options (exécutions Standard uniquement) :
    • Réexécution de confirmation des cas instables : un cas qui échoue mais qui a réussi et échoué lors d'exécutions récentes est exécuté une fois de plus ; s'il réussit alors, il compte comme réussi.
    • Mettre en quarantaine les cas instables : un cas qui échoue mais qui a été instable lors d'exécutions récentes est signalé comme ignoré (en quarantaine) au lieu d'en échec.
    • Mettre à jour les références d'instantané : remplace les références d'instantané enregistrées par les valeurs de cette exécution. Studio vous demande d'abord de confirmer. Non disponible pour les suites qui se connectent via S7 Native.
    • Conserver l'instance PLCSim après l'exécution : laisse l'instance PLCSIM Advanced en marche après l'exécution. Uniquement pour les suites qui chargent le projet via TCP.
  • Cible : l'endroit où la suite s'exécute, par exemple « PLCSim Advanced, PLC_SIM1 (192.168.0.5) ». Modifier ouvre les paramètres de connexion de la suite.

Une entrée non disponible est grisée ; survolez-la pour savoir pourquoi. Lancez l'exécution avec le bouton du bas (par exemple Exécuter la suite ou Exécuter 2 cas) ou appuyez sur Ctrl+Enter ; Escape ferme sans exécuter. Tab passe d'une partie à l'autre, les touches fléchées d'une entrée à l'autre au sein d'une partie.

Ce que mémorise le bouton Exécuter. Un simple clic sur Exécuter lance la suite avec votre dernier choix de Réexécution de confirmation des cas instables et Mettre en quarantaine les cas instables ; le même choix s'applique aux exécutions lancées depuis la vue Explorateur de tests unitaires, la palette de commandes et l'onglet Exécution. Mettre à jour les références d'instantané et Conserver l'instance PLCSim après l'exécution s'appliquent uniquement à l'exécution que vous lancez depuis les options. Si votre dernière exécution depuis les options utilisait Couverture ou Test de mutation, ce bouton Exécuter s'intitule Exécuter (couverture) ou Exécuter (test de mutation) et répète le mode ; choisissez une fois Standard pour revenir aux exécutions normales. Survolez Exécuter pour voir le choix actuel.

Choisir un transport

Le transport détermine comment les lectures et écritures du test circulent entre AnyAutomation Studio et l'automate. Vous le définissez dans le JSON de la suite via config.transport (voir le schéma ci-dessus) :

  • PLCSim Advanced (plcSimApi) : accès direct via l'API PLCSim de Siemens, plus rapide et sans session S7 active nécessaire. C'est le transport par défaut. Les valeurs de tous les types d'heure et de date, y compris DTL, LDT et LTIMEOFDAY, sont écrites et lues dans les entrées, les sorties, les mémentos et les blocs de données avec leur taille exacte, de sorte qu'une adresse voisine n'est jamais touchée. Les valeurs DT, DTL et LDT sont relues sous forme de littéraux, par exemple LDT#2024-05-17-08:30:15.123456789.
  • OPC UA : se connecte au serveur OPC UA d'un automate, réel ou simulé. Voir Connexion via OPC UA.
  • S7 Native : se connecte directement à un automate S7 réel, avec le même type de connexion que la vue PLC / OPC UA. Choisissez ce transport lorsque vous voulez exécuter une suite sur du matériel S7-1200 / S7-1500 en service. Voir Connexion via S7 Native pour les champs à remplir et la demande de confirmation avant une exécution en direct. Inclus dans Tests unitaires (forfait Pro+), également pendant l'essai gratuit.
  • CODESYS : exécute une suite pour un bloc fonctionnel ou une fonction CODESYS dans la simulation CODESYS ou sur l'automate logiciel CODESYS Control Win de votre ordinateur. C'est le seul transport d'une suite CODESYS. Voir Tester des blocs CODESYS.

Chaque suite est ciblée indépendamment. Pour S7 Native, la suite possède sa propre adresse IP, son port, son nom d'utilisateur et son mot de passe ; il n'y a pas de recherche partagée depuis la vue PLC / OPC UA.

Vous choisissez le transport et tous les autres paramètres de la connexion sur la page Paramètres de connexion de la suite, décrite dans la section suivante. Vous pouvez toujours modifier les valeurs directement dans le JSON de la suite via Ouvrir au format JSON dans l'éditeur de suite de tests.

Paramètres de connexion

Chaque suite possède sa propre page de paramètres de connexion. Ouvrez-la de l'une des manières suivantes :

  • cliquez sur le type de connexion dans l'en-tête de l'Éditeur de suite de tests, ou choisissez Paramètres de connexion dans son menu … ;
  • choisissez Paramètres de connexion dans le menu … du Test Bench, pour la suite choisie dans son en-tête ;
  • faites un clic droit sur une suite dans la vue Explorateur de tests unitaires et choisissez Paramètres de connexion ;
  • cliquez sur Modifier à côté de la cible dans les options d'exécution ;
  • lancez Tests unitaires : Paramètres de connexion depuis la Palette de commandes et choisissez la suite.

La page s'ouvre dans un onglet nommé Connexion : suivi du nom de la suite. Elle comporte quatre parties :

  • Transport : PLCSim Advanced, OPC UA ou S7 Native. Pour PLCSim Advanced, également le Mode de préparation : Préchargé par l’utilisateur ou Téléchargement TCP (voir Mode de préparation PLCSIM) ; Externe (API réel) n'est pas encore disponible. Une suite pour un bloc CODESYS ne propose que CODESYS (voir Tester des blocs CODESYS).
  • La cible du transport choisi :
    • PLCSim Advanced : Instance (propose les instances connues de PLCSIM Advanced), Adresse IP, Mode réseau, Contrôle du cycle (voir Contrôle du cycle Pas à pas ci-dessous), Attente de cycle (ms), Connexion automatique et Conserver l’instance après l’exécution. Choisissez un Mode réseau (TCPIPSingleAdapter, TCPIPMultipleAdapter ou Softbus) si PLCSim a du mal à démarrer sur un ordinateur doté de plusieurs cartes réseau ; (laisser inchangé) conserve votre réglage PLCSim actuel.
    • OPC UA : les champs du serveur et Attente de cycle (ms), voir Connexion via OPC UA.
    • S7 Native : les champs de l'automate et Attente de cycle (ms), voir Connexion via S7 Native.
  • Secret maître (téléchargement TCP) : uniquement pour le téléchargement TCP, voir Exécution sur un projet protégé.
  • Isolation : le Mode est Temporelle (par défaut) ou Isolée (chaque cas de test part d'un état connu). Le Mode de réinitialisation (Aucun, Valeurs par défaut ou Effacement mémoire) s'applique aux exécutions isolées ; Effacement mémoire nécessite PLCSim Advanced. Une suite CODESYS a ses propres valeurs par défaut, voir Paramètres de connexion d'une suite CODESYS. Lorsque la suite contient un élément qu'une exécution isolée ne prend pas encore en charge (stubs, cas en plusieurs étapes, surveillances de chronogramme, assertions de snapshot), la page l'indique sous Isolation.

Tant que la page est ouverte, changer de transport conserve ce que vous avez saisi pour les autres transports, de sorte que vous pouvez revenir en arrière sans tout ressaisir. L'enregistrement ne stocke dans la suite que les paramètres du transport choisi.

Mots de passe. La page n'affiche jamais un mot de passe, seulement s'il est stocké : Défini (mémorisé), Défini (cette session uniquement), Non disponible, saisissez-le à nouveau ou (non défini). Pour S7 Native, Non défini, le mot de passe par défaut s'applique ou Non disponible, le mot de passe par défaut s'applique signifie que la suite n'a pas de mot de passe propre et que le mot de passe par défaut enregistré avec Enregistrer par défaut pour cette adresse, ce port et cet utilisateur est utilisé. Cliquez sur Modifier pour saisir un nouveau mot de passe, puis choisissez Mémoriser (magasin de secrets du système) pour le conserver sur cet ordinateur pour les exécutions suivantes, ou Cette session uniquement pour le conserver jusqu'à la fermeture de Studio. Effacer supprime le mot de passe lors de l'enregistrement ; Annuler revient sur Modifier ou Effacer. Un mot de passe que vous ne modifiez pas reste tel quel lors de l'enregistrement. Si vous modifiez l'adresse du serveur, le port ou l'utilisateur d'une connexion, Studio redemande le mot de passe. Lorsque le transport choisi n'utilise plus un mot de passe stocké, la page affiche Supprimé à l’enregistrement, car le transport ne l’utilise pas, et l'enregistrement le supprime de cet ordinateur. Les mots de passe ne sont jamais écrits dans le fichier de la suite, vous pouvez donc partager une suite ou en faire un commit sans les exposer.

Tester la connexion vérifie les paramètres de la page avant que vous ne les enregistriez. Le résultat s'affiche à côté du bouton :

  • PLCSim Advanced nécessite une connexion à TIA Portal. La vérification vous indique si le PLCSIM Advanced Runtime Manager est en cours d'exécution et si l'instance existe. L’exécution met l’instance sous tension. signifie que l'instance existe mais qu'elle est éteinte ; l'exécution la démarre. Avec Téléchargement TCP, une instance qui n'existe pas encore ne pose pas de problème (L’exécution crée l’instance.) ; avec Préchargé par l’utilisateur, elle est signalée comme un problème, car l'exécution démarrerait une instance vide.
  • OPC UA se connecte une fois au serveur et indique Accessible (le certificat du serveur n’est pas vérifié). ainsi que l'index d'espace de noms détecté. Une connexion ouverte dans l'onglet Espace d'adressage reste telle quelle. Comme une exécution de test, la vérification accepte le certificat du serveur sans demander.
  • S7 Native n'a pas de vérification. Une exécution vous demande de confirmer une fois avant de se connecter à un automate réel ; une adresse qui appartient à une instance PLCSIM Advanced sur cet ordinateur ne nécessite aucune confirmation.

Enregistrement. Enregistrer (ou Ctrl+S) écrit les paramètres dans la suite. Enregistrer par défaut les conserve en outre comme point de départ pour les nouvelles suites : chaque suite que vous créez ensuite, depuis le Test Bench, la Palette de commandes ou l'assistant, démarre avec cette connexion. Pour S7 Native, il conserve aussi le mot de passe comme mot de passe par défaut pour la même adresse, le même port et le même utilisateur, mémorisé sur cet ordinateur ou pour cette session uniquement, selon votre choix pour le mot de passe. Chaque suite à cette adresse, ce port et cet utilisateur qui n'a pas de mot de passe propre s'exécute alors avec lui ; le mot de passe propre d'une suite est toujours prioritaire. Les autres mots de passe ne sont pas conservés. Si vous effacez le mot de passe puis utilisez Enregistrer par défaut, le mot de passe par défaut est supprimé ; la ligne d'état l'indique. Une suite qui n'a pas de mot de passe propre et s'exécute avec le mot de passe par défaut le conserve lorsque vous y utilisez Enregistrer par défaut. Annuler abandonne vos modifications et ferme la page. Un champ qui pose problème est marqué avec la raison, et Enregistrer reste désactivé jusqu'à sa correction.

Si la suite est aussi ouverte dans l'Éditeur de suite de tests avec des modifications non enregistrées, l'éditeur les conserve et les enregistre avec la nouvelle connexion lors du prochain enregistrement. Si le fichier de la suite change sur le disque alors que la page contient des modifications non enregistrées, une barre propose Recharger (reprendre les paramètres du fichier) ou Conserver mes modifications.

Ce que signifie un cycle de test

Le nombre de cycles d'un cas de test et ses étapes d'attente se comptent en cycles de test. Ce qu'est un cycle de test dépend de la connexion de la suite :

  • PLCSim Advanced avec Contrôle du cycle Temporisé (par défaut), OPC UA et S7 Native : une attente de Attente de cycle (ms) en temps réel (100 ms par défaut) pendant que l'automate fonctionne librement. Le nombre de cycles programme compris dans un cycle de test dépend du temps de cycle de l'automate.
  • PLCSim Advanced avec Pas à pas : exactement un cycle programme avec le Temps de cycle par cycle programme (ms) fixe, voir Contrôle du cycle Pas à pas ci-dessous.
  • CODESYS : un cycle du programme de test, dont la durée est fixée par Intervalle de tâche (ms) (voir Paramètres de connexion d'une suite CODESYS).

Une étape d'attente dure son temps divisé par la durée d'un cycle de test, arrondi à l'unité supérieure : une étape d'attente de 250 ms avec un cycle de 100 ms dure 3 cycles de test. Choisissez Pas à pas lorsqu'un test vérifie des fronts, des séquences d'étapes, des compteurs ou un nombre exact de cycles programme. Gardez Temporisé pour une logique qui dépend de la date ou de l'heure et pour les longues exécutions, et utilisez une Attente de cycle (ms) adaptée sur OPC UA et S7 Native, où le pas à pas n'est pas disponible.

Contrôle du cycle Pas à pas

Pour une suite sur PLCSim Advanced avec Préchargé par l’utilisateur ou Téléchargement TCP, la partie cible de la page comporte aussi Contrôle du cycle :

  • Temporisé (par défaut) : la CPU simulée fonctionne librement, et un cycle de test est une attente de Attente de cycle (ms) en temps réel. Le nombre de cycles programme compris dans un cycle dépend du temps de cycle de l'instance.
  • Pas à pas : l'exécution maintient l'instance entre deux cycles programme et lui laisse exécuter exactement un cycle programme par cycle de test. Le champ ci-dessous s'appelle alors Temps de cycle par cycle programme (ms) et fixe le temps de cycle de chaque cycle programme, de 1 à 6000 ms. Les cycles, les étapes d'attente et les temporisations du programme gardent leur signification, et les fronts, les séquences d'étapes et les compteurs donnent le même résultat à chaque exécution. Une étape d'attente de 250 ms avec un temps de cycle de 10 ms exécute 25 cycles programme.

Points à garder à l'esprit avec le pas à pas :

  • Temps réel. Une exécution dure au moins le nombre de cycles multiplié par le temps de cycle, généralement plus, car chaque cycle programme attend Studio. Donnez aux longs cas de test un Délai d'expiration adapté.
  • Valeurs en millisecondes des temporisations. PLCSim ne tient pas chaque cycle programme à la microseconde près, de sorte que le temps écoulé ET d'une temporisation, ou toute différence de temps en millisecondes, peut afficher 1 ms de plus que ne le laisse supposer le nombre de cycles programme : un test de temporisation de 5 cycles de 100 ms affiche 401 au lieu de 400 dans certaines exécutions. L'écart augmente lentement avec le nombre de cycles programme. Le nombre de cycles programme, l'ordre des événements et les valeurs qui dépendent des cycles programme sont exacts. Vérifiez ET et les différences de temps avec une tolérance de 1 ms, plus environ 1 ms par tranche de 50 cycles programme pour les longues exécutions, ou vérifiez plutôt la sortie Q de la temporisation, les bits d'étape ou le nombre de cycles.
  • Horloge de la CPU simulée. L'horloge de l'instance s'arrête tant que l'instance est maintenue, elle prend donc d'autant de retard sur le temps réel. Testez une logique qui dépend de la date ou de l'heure avec Temporisé.
  • Valeurs figées. Pendant qu'une exécution fait avancer l'instance pas à pas, les moniteurs PLC / OPC UA, les tables de surveillance et les vues en ligne de TIA Portal affichent les valeurs du dernier cycle programme ; elles ne changent que d'un cycle programme à l'autre. Studio vous le rappelle au démarrage d'une telle exécution.
  • Un seul utilisateur à la fois. Une exécution Pas à pas ne démarre pas tant que la Simulation matérielle utilise l'instance ou qu'une autre exécution la fait avancer pas à pas, y compris une exécution de l'outil en ligne de commande, et la Simulation matérielle ne peut pas se connecter à une instance qu'une exécution fait avancer pas à pas.
  • Non combinable avec le mode de test isolé : Enregistrer reste désactivé, avec une remarque sous Contrôle du cycle et Isolation. Les exécutions de couverture et de mutation utilisent toujours des cycles temporisés. Les suites sur OPC UA, S7 Native ou CODESYS ne proposent pas ce choix.
  • Snapshots. Faire passer une suite de Temporisé à Pas à pas ou inversement change ce qu'elle mesure, enregistrez donc à nouveau ses références de snapshot après le changement.

À la fin, en cas d'échec ou d'arrêt de l'exécution, l'instance revient d'elle-même au fonctionnement normal, y compris lorsque Studio se ferme pendant l'exécution. Si une instance reste malgré tout maintenue, par exemple parce qu'un autre programme l'a fait avancer pas à pas, sa carte dans le tableau de bord PLCSim Advanced affiche l'état Gelé et une ligne qui indique qui la maintient. Cliquez sur Reprendre le fonctionnement normal sur la carte, ou lancez PLCSim : Reprendre le fonctionnement normal depuis la Palette de commandes, puis confirmez. Une exécution qui fait encore avancer l'instance s'arrête alors avec une erreur à son étape suivante. Vous pouvez aussi demander à l'assistant de reprendre le fonctionnement normal ; il vous demande d'abord votre confirmation.

Connexion via OPC UA

Une suite de tests peut s'exécuter sur un automate via OPC UA, en plus de PLCSim Advanced. Ouvrez les Paramètres de connexion de la suite (voir Paramètres de connexion) et choisissez OPC UA sous Transport.

Pour une connexion OPC UA, vous indiquez :

  • URL du point de terminaison : l'adresse du serveur OPC UA de l'automate, par exemple opc.tcp://192.168.0.5:4840.
  • Mode de sécurité : Aucun, Signer ou Signer et chiffrer. Choisissez le mode que votre serveur est configuré pour accepter ; Signer et chiffrer offre la protection la plus élevée.
  • Authentification : soit Anonyme, soit Nom d'utilisateur et mot de passe. Si vous choisissez Nom d'utilisateur et mot de passe, saisissez les identifiants attendus par votre automate. Le mot de passe est stocké de manière sécurisée sur votre ordinateur et n'est jamais écrit dans le fichier de test, vous pouvez donc partager une suite ou en faire un commit sans l'exposer.
  • Index d'espace de noms : laissez ce champ vide et Studio détecte automatiquement le bon espace de noms sur l'automate ; c'est le cas normal. N'indiquez un nombre que pour un serveur inhabituel où la détection automatique ne le trouve pas.
  • Attente de cycle (ms) : la durée d'un cycle de test, 100 ms par défaut (voir Ce que signifie un cycle de test).

La première fois que vous vous connectez à un serveur dont AnyAutomation Studio ne reconnaît pas encore le certificat, une invite vous demande de confirmer la connexion. Choisissez Se connecter quand même pour faire confiance à ce serveur et continuer ; l'invite ne réapparaît pas pour ce serveur lors de l'exécution suivante.

Rendez les variables de l'automate accessibles via OPC UA. Pour que les tests puissent lire et écrire vos variables, les blocs de données qu'ils utilisent doivent être accessibles via le serveur OPC UA de l'automate. Activez l'accès OPC UA pour les blocs de données concernés dans votre projet TIA Portal et chargez-le dans l'automate avant d'exécuter la suite. Les variables non exposées ne peuvent être ni lues ni écrites, et les cas de test concernés échoueront.

Parcourir l'espace d'adressage

Dans l'onglet Espace d'adressage de la colonne Bloc du Test Bench, vous pouvez explorer ce que propose un serveur OPC UA avant d'écrire ou d'exécuter des tests. La première ligne de l'onglet contient l'adresse du serveur. Lorsque la suite choisie dans l'en-tête s'exécute via OPC UA, son adresse est déjà renseignée ; sinon, c'est la dernière adresse utilisée.

  • N'importe quel serveur : saisissez une adresse telle que opc.tcp://192.168.0.5:4840. La deuxième ligne vous permet de choisir le Mode de sécurité des messages (None, Sign, Sign and Encrypt) et l'Authentification (Anonymous, ou Username and Password avec Nom d'utilisateur et Mot de passe). Un mot de passe saisi ici n'est utilisé que pour cette connexion et n'est pas enregistré.
  • Le serveur de votre suite OPC UA : lorsque l'adresse est celle de la suite de l'en-tête, la deuxième ligne affiche Paramètres de la suite à la place ; survolez-la pour voir la sécurité et l'authentification utilisées par la suite. Studio se connecte avec celles-ci et avec le mot de passe enregistré pour cette suite, sans rien demander. Si aucun mot de passe n'est enregistré pour elle, ou si le serveur refuse le nom d'utilisateur ou le mot de passe, Studio demande le mot de passe directement dans cette ligne ; il n'est utilisé que pour cette session et n'est jamais enregistré.

Cliquez sur Connecter ou appuyez sur Enter dans n'importe quel champ ; Déconnecter met fin à la connexion. L'espace d'adressage s'affiche sous forme d'arborescence que vous pouvez déplier pour parcourir les nœuds disponibles et voir quelles variables sont accessibles. Utilisez-le pour vérifier le nom d'une variable et qu'elle est bien exposée via OPC UA, afin que vos cas de test ciblent les bons éléments. Les variables structurées (types de données automate, structures et tableaux) affichent le nom de leur type de données, par exemple typMotor ou Array of Bool, et se déplient sur leurs membres, de sorte que vous pouvez descendre jusqu'à l'élément qu'un cas de test lit ou écrit. Dans un cas de test, adressez un tel élément par son chemin, par exemple DB_Motor.Setpoints[3] ou DB_Motor.StartTimer.Q.

À côté de son type de données, chaque variable affiche sa valeur actuelle, par exemple CPU 1516F-3 PN/DP pour le modèle de CPU ou [false, true] pour un tableau. Les valeurs sont lues lorsque vous ouvrez une branche. Cliquez sur Actualiser les valeurs dans la première ligne de l'onglet pour relire toutes les valeurs affichées. Une valeur de qualité incertaine s'affiche dans la couleur d'avertissement ; une variable dont la valeur ne peut pas être lue reste vide. L'onglet affiche un instantané, pas des valeurs en direct. Pour suivre l'évolution des valeurs, utilisez PLC / OPC UA.

Créer et exécuter des tests via OPC UA

Une fois la connexion définie, les suites OPC UA se comportent exactement comme les suites PLCSim. Vous créez les cas de test de la même manière, vous les exécutez avec les mêmes actions Exécuter la suite de tests / Exécuter toutes les suites de tests, vous suivez la même progression en direct et vous obtenez les mêmes résultats et le même historique des exécutions. La seule différence est l'endroit où les tests se connectent, et TIA Portal n'a pas besoin d'être ouvert pour les créer ou les exécuter.

Pour les pipelines et la CI, une suite configurée pour OPC UA s'exécute aussi dans le pipeline généré. Comme le mot de passe OPC UA n'est pas stocké dans le fichier de test, vous fournissez le mot de passe OPC UA à l'exécution du pipeline afin que le serveur de build puisse se connecter sans intervention.

Connexion via S7 Native

Une suite de tests peut aussi s'exécuter directement sur un automate S7 réel via S7 Native. Ouvrez les Paramètres de connexion de la suite (voir Paramètres de connexion) et choisissez S7 Native sous Transport. Ce type de connexion est inclus dans les tests unitaires (forfait Pro+), y compris pendant l'essai gratuit.

Pour une connexion S7 Native, vous indiquez :

  • Adresse IP : l'adresse de l'automate, par exemple 192.168.0.10. Écrivez une adresse IPv4 sous forme de quatre nombres sans zéros initiaux ; la page n'accepte pas une forme telle que 192.168.0.010.
  • Port : le port TCP de l'automate. La valeur par défaut est 102, qui convient à la plupart des automates. Ne la modifiez que si votre automate a été configuré sur un autre port.
  • Nom d'utilisateur (facultatif) : nécessaire uniquement lorsque votre automate exige une connexion utilisateur. La plupart des projets laissent ce champ vide.
  • Mot de passe : le mot de passe attendu par votre automate. Il est stocké de manière sécurisée sur votre ordinateur et n'est jamais écrit dans le fichier de test, vous pouvez donc partager une suite ou en faire un commit sans l'exposer.
  • Attente de cycle (ms) : la durée d'un cycle de test, 100 ms par défaut (voir Ce que signifie un cycle de test).

Utilisez Enregistrer par défaut sur la page pour faire de ces valeurs le point de départ des nouvelles suites, afin de ne pas avoir à les ressaisir à chaque fois. Le mot de passe est conservé comme mot de passe par défaut pour la même adresse, le même port et le même utilisateur, de sorte que les nouvelles suites sur cet automate s'exécutent sans le ressaisir.

Créer et exécuter des tests via S7 Native

Une fois la connexion définie, vous créez les cas de test de la même manière que pour une suite PLCSim et vous les exécutez avec les mêmes actions Exécuter la suite de tests / Exécuter toutes les suites de tests. La seule différence est l'endroit où les tests se connectent : une suite S7 Native se connecte directement à l'automate indiqué, écrit les entrées de test dans l'automate en marche et y vérifie les résultats.

Comme une exécution écrit sur du matériel en service, une invite vous demande de confirmer avant son démarrage. Lorsque vous exécutez plusieurs suites S7 Native à la fois, par exemple avec Exécuter toutes les suites de tests, l'invite n'apparaît qu'une fois et liste les suites qui vont vers un automate réel avec leurs adresses. Ne confirmez que lorsque l'installation est dans un état de test sûr, et l'exécution commence. Annulez l'invite et aucune suite de l'exécution ne démarre.

Lorsque l'adresse d'une suite appartient à une instance PLCSIM Advanced sur cet ordinateur, aucune invite n'apparaît pour cette suite. Studio le vérifie à nouveau juste avant le démarrage de la suite : si l'instance a été arrêtée entre-temps, cette suite et les suivantes ne sont pas exécutées, et un message vous demande de relancer l'exécution. Une instance PLCSIM Advanced sur un autre ordinateur compte comme un automate réel.

Vous pouvez aussi exécuter des tests sur un automate de sécurité (F). L'invite de confirmation vous avertit que la cible peut être un automate de sécurité et que vous devez vous assurer que l'automate peut être manipulé sans danger et que l'installation est dans un état de test sûr avant de continuer. Il n'y a pas de blocage automatique : c'est vous qui décidez de confirmer ou d'annuler.

Espace de travail de simulation

Prévu pour l'espace de travail intégré à l'application. Une vue Simulation dédiée à la gestion des instances PLCSim Advanced depuis AnyAutomation Studio est prévue. Les fonctionnalités qu'elle proposerait sont décrites ci-dessous.

Une vue Simulation de gestion des instances PLCSim Advanced afficherait :

  • La version de l'API, le mode d'accès en ligne (PLCSim / TCP/IP single / TCP/IP multi), l'option de temporisation stricte des mouvements et le port du Runtime Manager.
  • Une ligne Virtual Adapter indiquant en permanence l'état de l'adaptateur Ethernet virtuel Siemens PLCSIM (Ready / APIPA / Disabled / Not Installed / No IPv4), son adresse IPv4 et un bouton d'actualisation. Si l'adaptateur reste bloqué dans la plage APIPA 169.254.x.y, les chargements ne seront pas fiables ; attribuez une adresse IPv4 statique dans les paramètres réseau de Windows.
  • Chaque instance PLCSim enregistrée, avec des boutons d'action intégrés : Power On, Run, Stop, Memory Reset, Power Off, Settings, Network, Delete. Chaque ligne affiche l'adresse IP configurée ; si l'instance possède plusieurs interfaces avec une adresse IP, elles sont listées sous la forme X1: 192.168.0.1, X2: 10.0.0.5.
  • Une liste déroulante API TIA par carte d'instance : choisissez l'automate TIA Portal associé à l'instance. Utilisez-la lorsque l'instance PLCSim a été chargée avec un snapshot compilé à partir d'un autre automate TIA que celui sous lequel elle est enregistrée (par exemple une instance nommée PLC_2 qui contient en réalité le programme de PLC_1). Sans choix explicite, l'application effectue la correspondance par nom et se rabat sur le seul automate du projet lorsqu'il n'y en a qu'un, ce qui suffit pour la plupart des configurations mais produit une arborescence de variables vide lorsque les noms ne concordent pas. Le choix est mémorisé par instance.
  • Un bouton Nouvelle instance qui demande un nom et un type de CPU.
  • Un volet Explorateur de variables qui se connecte à n'importe quelle instance listée et affiche toutes les variables exposées par le programme en cours, filtrables par recherche de nom, zone (entrées / sorties / mémentos / blocs de données) et type de données. L'actualisation automatique peut être activée pour observer les valeurs en direct. Chaque variable accessible en écriture possède un bouton crayon qui ouvre une boîte de dialogue d'écriture adaptée au type (bascule pour Bool, saisie numérique avec la plage propre au type pour les entiers et les réels, champ d'un caractère pour Char/WChar). Les variables String sont en lecture seule. Les variables de structure et de tableau sont listées avec leurs membres et éléments internes sous forme de lignes dépliables, de sorte que vous pouvez rechercher, surveiller et modifier directement des champs individuels comme OUT[5] ou DI10.Channel ; les boutons Expand all et Collapse all de la barre d'outils déplient ou replient toute l'arborescence d'un coup. Les variables d'entrée/sortie structurées dont la disposition provient d'une définition de type du projet (par exemple un bloc MixerIO à %I0.0 déclaré comme Array[0..63] of Byte) se déplient en lignes de membres nommés lorsque l'application est connectée au projet TIA Portal qui les définit, ce qui vous permet d'écrire IN.MixerIO[12] depuis la même boîte de dialogue que pour le reste de l'arborescence.
  • Une section Instances enregistrées en bas de la vue, qui liste chaque instance PLCSim Advanced conservée sur la carte mémoire SIMATIC virtuelle. Le titre affiche un compteur avec le nombre total d'instances enregistrées ; la liste affiche jusqu'à trois lignes à la fois et défile s'il y en a davantage, afin que la zone de simulation au-dessus reste visible. Cliquez sur Charger pour en réenregistrer une et la reprendre ; PLCSim récupère automatiquement le type de CPU, la mémoire image des E/S et le programme stockés. Cliquez sur Supprimer (avec confirmation) pour supprimer le dossier conservé.

Le choix de la vue serait mémorisé d'une session à l'autre, et le changement de vue laisse intacts les éditeurs de suite ouverts.

Mode de préparation PLCSIM

Le mode de préparation détermine la manière dont le runner met votre projet en ligne avant l'exécution des tests. Vous le choisissez sur la page Paramètres de connexion de la suite, ou dans le JSON de la suite via config.preparationMode :

  • Je le charge moi-même (userPreloaded, recommandé) : le runner attend une instance PLCSIM que vous avez déjà démarrée et chargée manuellement via TIA Portal. Il ignore la compilation et le chargement et se connecte directement pour exécuter les tests. C'est l'option la plus rapide si vous itérez sur le même projet.
  • Téléchargement TCP automatique (tiaTcpDownload) : le runner compile le projet, démarre une nouvelle instance PLCSIM et effectue le chargement via TCP par le PLCSIM Virtual Adapter. Aucune intervention manuelle dans TIA Portal n'est nécessaire. Il suffit de lancer l'exécution.
  • Automate réel (sans PLCSim) (external) : ignore entièrement le cycle de vie de PLCSim et préparerait une exécution sur du matériel S7 en service sans aucune instance PLCSim. Ce mode de préparation n'est pas encore disponible pour les exécutions dans l'application. Il s'agit d'une option distincte et prévue, qui n'est pas la même chose que la connexion S7 Native : pour exécuter des tests sur un automate réel aujourd'hui, choisissez plutôt le type de connexion S7 Native (voir Connexion via S7 Native et Exécuter des tests sur un automate réel).

Avant d'utiliser le téléchargement TCP automatique : quatre prérequis doivent être remplis, sinon l'exécution échoue avec une erreur de transport générique : (1) le PLCSIM Virtual Adapter doit être installé et avoir une adresse IPv4 statique qui correspond au plcSimIp de la suite ; (2) le projet doit être ouvert dans TIA Portal : le runner déclenche une compilation du projet ouvert avant le chargement ; (3) si le projet active Protect confidential PLC configuration data, vous devez fournir le mot de passe du secret maître sur la page Paramètres de connexion de la suite (voir Exécution sur un projet protégé) ; (4) toute instance PLCSIM existante portant le même nom est détruite puis recréée à chaque exécution, de sorte que les autres applications connectées à cette instance perdent leur session.

Exécuter des tests sur un automate réel

Vous pouvez exécuter des tests directement sur du matériel S7-1200 / S7-1500 en service à l'aide d'une connexion S7 Native, sans PLCSim :

  1. Assurez-vous que l'installation est dans un état de test sûr : actionneurs isolés ou verrouillés, aucune charge de production sur l'automate, opérateurs informés.
  2. Sur la page Paramètres de connexion de la suite, choisissez S7 Native sous Transport et renseignez l'adresse IP de l'automate, son port et (uniquement si l'automate l'exige) le nom d'utilisateur et le mot de passe. Voir Connexion via S7 Native pour les détails.
  3. Exécutez la suite depuis la vue Explorateur de tests unitaires.
  4. Avant que les tests n'atteignent l'automate, une invite vous demande de confirmer l'exécution sur du matériel en service, une seule fois pour toute l'exécution. Confirmez-la une fois l'installation dans un état de test sûr, et l'exécution commence.

Quelques points à connaître sur les exécutions sur un automate en service :

  • Identifiants incorrects : si l'automate refuse l'accès parce que le mot de passe est manquant ou incorrect, Studio demande le mot de passe S7 et relance la suite. Le mot de passe saisi est utilisé pour les suites suivantes sur le même automate sans nouvelle demande, et il remplace un mot de passe incorrect enregistré pour la suite. Si vous annulez, l'exécution s'arrête immédiatement avec un message vous invitant à vérifier le nom d'utilisateur et le mot de passe, au lieu d'échouer plus tard avec un message déroutant « variable not found ». Studio demande au plus trois fois par suite.
  • Exécutions groupées : Exécuter toutes les suites de tests exécute aussi les suites S7 Native. Vous confirmez une fois avant le démarrage de l'exécution, pour toutes les suites qui vont vers un automate réel.
  • L'automate doit être en marche : une exécution sur un automate en service vérifie d'abord l'état de fonctionnement de l'automate et s'arrête s'il n'est pas en RUN, afin que rien ne soit écrit tant que le programme ne s'exécute pas.

Automates de sécurité (F). Lorsque vous exécutez des tests de manière interactive, vous pouvez cibler un automate de sécurité (F) : l'invite de confirmation vous avertit que la cible peut être un automate de sécurité et que vous devez vous assurer que l'automate peut être manipulé sans danger et que l'installation est dans un état de test sûr, et c'est vous qui décidez de confirmer ou d'annuler. Les exécutions assistées par l'IA sont différentes : l'assistant n'exécute pas de lui-même des tests sur une logique de sécurité, c'est donc toujours vous qui lancez une exécution sur un automate de sécurité.

Tester des blocs CODESYS

Les blocs fonctionnels et les fonctions d'un projet CODESYS se testent de la même manière que les blocs TIA, dans la simulation CODESYS ou sur l'automate logiciel CODESYS Control Win de votre ordinateur. Il vous faut un forfait Pro+, CODESYS installé sur le même ordinateur et le projet CODESYS ouvert dans la barre latérale CODESYS (voir CODESYS). CODESYS Control Win ne doit être en marche que lorsque vous testez dessus.

Créer une suite

  1. Dans l'arborescence du projet CODESYS, cliquez avec le bouton droit sur un bloc fonctionnel ou une fonction et choisissez Créer une suite de tests unitaires.
  2. Confirmez ou modifiez le nom de suite proposé.

Studio lit l'interface du bloc, crée la suite avec un cas de test vide et l'ouvre dans l'éditeur de suite de tests. La suite est enregistrée dans le dossier .tia-tests à côté du fichier de projet CODESYS, ou dans le dossier de test que vous avez choisi, et apparaît dans la vue Explorateur de tests unitaires. Ajoutez des entrées et des assertions comme pour toute autre suite.

Paramètres de connexion d'une suite CODESYS

La page Paramètres de connexion d'une suite CODESYS propose un seul transport, CODESYS, avec la section Cible CODESYS. Sous Exécuter sur, vous choisissez où les tests s'exécutent :

  • Simulation : la simulation CODESYS, sans appareil ni runtime. Une nouvelle suite démarre avec ce choix. La simulation exécute aussi les projets dont l'appareil est configuré pour un autre automate.
  • CODESYS Control Win sur cet ordinateur : l'automate logiciel de votre ordinateur. L'exécution remplace l'application qui y tourne.
  • Autre appareil : non disponible dans cette version.

Les champs de la section :

  • Passerelle et Port de la passerelle (CODESYS Control Win uniquement) : la passerelle par laquelle Studio atteint CODESYS Control Win, localhost et 1217 par défaut. Seul un runtime sur cet ordinateur est accepté.
  • Intervalle de tâche (ms) : la fréquence d'exécution du programme de test, 10 ms par défaut. Une étape d'attente d'un cas de test dure le nombre de cycles correspondant.
  • Utilisateur du runtime (CODESYS Control Win uniquement) : l'utilisateur de CODESYS Control Win avec lequel l'exécution se connecte.

La section Isolation définit la relation entre les cas de test de la suite. Avec Isolée et le mode de réinitialisation Valeurs par défaut, chaque cas de test part d'une copie réinitialisée du bloc ; une suite qui n'a pas encore de réglage se comporte ainsi, et Valider vous le signale. Nouvelle instance par cas donne à chaque cas de test sa propre instance du bloc, de sorte que son initialisation s'exécute à nouveau ; utilisez-la pour un bloc fonctionnel qui stocke une référence à lui-même, car une copie le fausse. Temporelle et le mode de réinitialisation Aucun conservent l'état entre les cas de test. Une nouvelle instance par cas est refusée lorsque les instances d'une suite nécessiteraient trop de mémoire.

Le mot de passe du runtime n'est pas enregistré avec la suite. Studio le demande à la première exécution d'une session et le conserve jusqu'à la fermeture de Studio ; si CODESYS Control Win le refuse, Studio le redemande à l'exécution suivante. La simulation n'a besoin d'aucun mot de passe.

Tester la connexion vérifie la cible choisie sans rien charger : pour la simulation, il indique si le projet peut y être exécuté, pour CODESYS Control Win, il se connecte et affiche l'appareil et la version du runtime. Si une exécution devait être refusée, la ligne en indique la raison, par exemple lorsque l'appareil de votre projet ne correspond pas à CODESYS Control Win ; choisissez alors Simulation.

Exécuter les tests

Cliquez avec le bouton droit sur le bloc dans l'arborescence du projet CODESYS et choisissez Exécuter les tests unitaires, ou exécutez la suite depuis la vue Explorateur de tests unitaires ou le Test Bench comme d'habitude. Studio copie votre projet enregistré, ajoute un programme de test à la copie et le compile. Dans la simulation, la version de test s'exécute immédiatement, sans confirmation, car aucun appareil n'est concerné. Sur CODESYS Control Win, Studio vous demande d'abord de confirmer, car la version de test remplace l'application qui y tourne. Votre propre projet n'est pas modifié. Les résultats, l'historique, les tendances et les rapports s'affichent comme pour toute autre exécution. Si la version de test présente des erreurs de compilation, l'exécution les signale avec l'objet auquel elles appartiennent.

La boîte de dialogue d'exécution affiche la cible sous TARGET, par exemple « simulation CODESYS » ou « CODESYS Control Win sur cet ordinateur » avec le nom du projet CODESYS ouvert, et ne propose pas de bouton Modifier pour celle-ci. Sans projet CODESYS ouvert, ou avec une passerelle sur un autre ordinateur, Exécuter la suite reste désactivé et la boîte de dialogue en indique la raison.

Après une exécution sur CODESYS Control Win, l'automate logiciel continue d'exécuter la version de test. Chargez à nouveau votre propre projet depuis la vue CODESYS, ou redémarrez CODESYS Control Win pour relancer son application de démarrage.

Ce que les suites CODESYS ne prennent pas encore en charge

  • Les programmes comme bloc testé ; les blocs fonctionnels et fonctions de test.
  • Le câblage des entrées.
  • Une assertion d'instantané dans une étape ; placez-la dans les assertions finales du cas de test.
  • Des tableaux et structures entiers comme valeurs vérifiées ; vérifiez leurs éléments ou leurs membres.
  • Un automate CODESYS autre que la simulation et CODESYS Control Win sur cet ordinateur.

Si un fichier de suite contient déjà l'un de ces éléments, Studio le conserve lors de l'enregistrement. Valider affiche un avertissement pour chaque élément ; cliquez sur un avertissement concernant un élément que seule la vue JSON affiche, et la vue JSON s'ouvre sur cet élément. Exécuter s'arrête avant de demander le mot de passe du runtime et nomme l'élément. Lorsque vous exécutez plusieurs suites à la fois, Studio les vérifie toutes d'abord, de sorte que rien ne s'exécute tant qu'une suite CODESYS contient encore un tel élément.

Surveillance et instantanés. Surveillance enregistre les variables listées une fois par cycle, juste après l'appel du bloc, et les affiche sur la chronologie du Test Bench. Une structure ou un tableau apparaît sous forme de ses éléments individuels. L'axe du temps correspond au numéro de cycle multiplié par l'Intervalle de tâche de la suite. Une assertion Instantané compare toutes les sorties et variables d'entrée-sortie d'un cas de test, ainsi que la valeur de retour d'une fonction, à une référence approuvée ; la première exécution enregistre la référence, même lorsqu'une autre vérification du cas de test échoue, et la sortie du cas de test le signale alors. Approuver la référence, Approuver la référence d'instantané et Mettre à jour les références d'instantané reprennent une modification que vous souhaitez. Une variable exclue de l'instantané sous Excludes peut tout de même figurer dans Surveillance : elle reste sur la chronologie et n'est pas comparée. Les deux fonctionnent dans tous les modes d'isolation.

Un cas de test enregistre au plus 100 000 cycles et 256 variables, un cas de test avec instantané au plus 1 000 cycles, et une exécution au plus 300 000 valeurs. Valider signale ces limites lorsque c'est possible, et Exécuter s'arrête avec un message avant tout chargement. Studio n'omet jamais de valeurs pour rester dans une limite, réduisez donc les cycles ou les variables surveillées.

Stubs. Un stub remplace une fonction ou un bloc fonctionnel appelé par le bloc testé, pour un cas de test. Sélectionnez le cas de test, ouvrez Stubs et choisissez Ajouter un stub. Choisissez le bloc ; Studio propose les blocs appelés par le bloc testé. Avec Ajouter une valeur, vous définissez ce que le stub fournit : Ret_Val pour la valeur de retour d'une fonction, ou le nom d'une variable de sortie ou d'entrée-sortie, également un élément tel que stData.iSpeed ou aValues[1]. Seule la sortie ou l'élément que vous nommez est écrit : tout le reste reste inchangé, de sorte qu'une variable d'entrée-sortie conserve la valeur du bloc appelant dans tous les autres éléments, et qu'une fonction sans valeur renvoie la valeur par défaut de son type. Un stub remplace le code principal d'un bloc : les méthodes, actions et propriétés d'un bloc fonctionnel continuent d'exécuter leur propre code. Les cas de test sans le stub exécutent le code d'origine. La modification n'existe que dans la copie de test de votre projet ; votre propre projet reste inchangé.

Vous pouvez remplacer par un stub les fonctions et les blocs fonctionnels de votre projet écrits en texte structuré. Les blocs de bibliothèque, les programmes, les blocs dans d'autres langages et le bloc testé lui-même ne peuvent pas être remplacés par un stub, et chaque valeur doit correspondre à sa sortie. Valider nomme ce qui ne peut pas s'exécuter et avertit lorsque le bloc testé ne semble pas appeler un bloc remplacé par un stub, y compris lorsqu'il n'appelle qu'une de ses méthodes, auquel cas le stub n'a aucun effet. Exécuter s'arrête avec le même message avant tout chargement. Après une exécution, l'onglet Exécuter du Test Bench indique au-dessus des vérifications quels blocs ont été remplacés par un stub dans le cas de test sélectionné. Vous pouvez aussi demander à l'assistant de définir des stubs ; il nomme les blocs remplacés lorsqu'il vous demande de confirmer.

Couverture. Cliquez avec le bouton droit sur une suite CODESYS dans la vue Explorateur de tests unitaires et choisissez Exécuter avec instrumentation de couverture, ou lancez-la depuis l'onglet Qualité du Test Bench ou depuis la boîte de dialogue d'exécution ; aucune connexion à TIA Portal n'est nécessaire. Studio demande la même confirmation et le même mot de passe du runtime que pour Exécuter, compte dans la copie de test quelles lignes et branches du bloc testé s'exécutent, y compris ses méthodes, actions et accesseurs de propriétés, puis affiche Instruction et Branche à côté de Interface et Blocs appelés dans l'onglet Qualité. Chaque ligne nomme l'objet auquel elle appartient, par exemple FB_Pump/Start ; cliquez dessus pour ouvrir l'implémentation de cet objet à cette ligne, et la carte thermique de couverture colore les lignes dans l'éditeur. Exporter la couverture… écrit un fichier Cobertura avec une entrée par objet dans le dossier des rapports à côté du projet CODESYS. Les blocs appelés par le bloc testé et son bloc fonctionnel de base ne sont pas comptés. Un bloc, une méthode ou une action dans un langage graphique, du code avec des sauts ou des étiquettes, une gestion d'exceptions avec __TRY, des pragmas conditionnels et un objet nommé GVL_AaCov dans votre projet arrêtent l'exécution avant tout chargement, avec l'objet et la raison. Si les compteurs ne peuvent pas être relus après l'exécution, Studio le signale et conserve les résultats de test, mais n'affiche pas de couverture partielle. Votre propre projet reste inchangé.

Test de mutation. Cliquez avec le bouton droit sur une suite CODESYS dans la vue Explorateur de tests unitaires et choisissez Exécuter le test de mutation, ou lancez-le depuis l'onglet Qualité du Test Bench, la boîte de dialogue d'exécution ou la palette de commandes ; aucune connexion à TIA Portal n'est nécessaire. L'exécution utilise la cible de la suite : la simulation CODESYS, ou CODESYS Control Win sur cet ordinateur, jamais un autre appareil. Sur CODESYS Control Win, Studio demande la même confirmation et le même mot de passe du runtime que pour Exécuter. Il exécute ensuite la suite une fois avec couverture. Chaque cas de test doit réussir ; sinon, Studio vous indique combien échouent et s'arrête. Il modifie ensuite le bloc testé, ses méthodes, actions et accesseurs de propriétés par petites étapes, uniquement aux lignes atteintes par vos cas de test, et exécute la suite contre chaque modification : une modification qui fait échouer un cas de test, ou arrêter l'application, est tuée, une modification que tous les cas de test réussissent encore a survécu, et une modification qui ne compile pas est mort-née. Une modification prend environ cinq secondes. L'onglet Qualité affiche le score de mutation et les modifications, chacune avec l'objet et la ligne, par exemple FB_Pump/Start, line 4 ; cliquez sur l'une d'elles pour ouvrir l'implémentation de cet objet à cette ligne, et les marqueurs de mutation affichent les modifications survivantes dans l'éditeur de cet objet. Le nombre de modifications d'une exécution (au plus 100 pour CODESYS) et leurs types se règlent sous Paramètres > Tests unitaires, comme pour les blocs TIA. Un bloc, une méthode ou une action dans un langage graphique, du code avec des sauts ou des étiquettes, des pragmas conditionnels, un stub sur le bloc testé lui-même et des cas de test qui lisent plus de 20 000 valeurs arrêtent l'exécution avant la première modification, avec la raison, de sorte que vous n'obtenez jamais de score partiel. Avant la première modification, Studio exécute aussi une fois de plus le bloc non modifié de la même manière ; si un cas de test y échoue, ou si un cycle du bloc dure si longtemps que CODESYS Control Win arrête l'application, l'exécution s'arrête avec la raison au lieu de compter chaque modification comme tuée. Si vous avez modifié le bloc ou la suite après l'exécution avec couverture, ou ajouté une méthode, une action ou une propriété au bloc, Studio vous demande d'exécuter à nouveau la suite avec couverture. Un cas de test avec une vérification d'instantané a d'abord besoin de sa référence enregistrée : exécutez la suite une fois normalement et vérifiez la référence. Si une exécution risque de durer plus de 55 minutes, Studio ne la lance pas et vous demande de réduire le nombre de modifications. Si une valeur ne peut pas être lue pendant l'exécution, celle-ci s'arrête sans score au lieu de compter la modification comme tuée. Dans la simulation, un cycle beaucoup trop long n'arrête l'application qu'au bout de quelques secondes, de sorte qu'une modification qui ne fait que ralentir le bloc peut y survivre alors qu'elle serait tuée sur CODESYS Control Win. Après une exécution sur CODESYS Control Win, l'application de test est à nouveau supprimée ; si vous appuyez sur Arrêter, la modification en cours à ce moment peut rester sur CODESYS Control Win jusqu'à l'exécution suivante. Arrêter met fin à l'exécution sans score. Votre propre projet reste inchangé.

Fixtures et hooks. Une suite peut nommer des entrées réutilisables (fixtures) qu'un cas de test reprend, et un cas de test peut définir des valeurs avant son démarrage et après sa fin. Les valeurs d'un cas de test l'emportent sur celles de sa fixture, et les valeurs de fin sont aussi définies lorsqu'une vérification a échoué. Vous les modifiez dans la vue JSON de l'éditeur de suite de tests, ou demandez à l'assistant.

Contrats d'interface. Approuver le contrat d'interface et Vérifier les contrats d'interface fonctionnent comme pour les blocs TIA, sans connexion à TIA Portal. La vérification lit le bloc, ses blocs fonctionnels de base et les structures du projet qu'il utilise depuis le projet CODESYS ouvert, y compris lorsqu'un membre contient un tableau d'une telle structure ou un pointeur ou une référence vers elle, de sorte qu'une modification incompatible dans l'un d'eux apparaît avec son chemin. Les énumérations et les alias ne comptent que par leur nom, et un type de données ou un bloc fonctionnel de base issu d'une bibliothèque reste hors de la vérification. Le projet CODESYS doit être ouvert dans Studio.

L'assistant crée une suite CODESYS avec sa propre action. Il peut aussi ajouter et modifier des cas de test, définir l'isolation et les fixtures, vérifier et approuver le contrat d'interface, approuver une référence d'instantané et exécuter la suite, y compris avec de nouvelles références ou avec couverture, et exécuter le test de mutation, chaque modification après votre confirmation. Il peut aussi lister les blocs, les variables globales et les types de données qu'utilise un bloc CODESYS.

Exécuter sur un projet protégé

Si l'option "Protect confidential PLC configuration data" (protéger les données de configuration confidentielles de l'automate) est activée dans votre projet TIA, le mode de chargement TCP automatique exige le mot de passe du secret maître du projet :

  1. Sur la page Paramètres de connexion de la suite, choisissez PLCSim Advanced et le mode de préparation Téléchargement TCP
  2. Sous Secret maître (téléchargement TCP), cliquez sur Modifier et saisissez le mot de passe du secret maître du projet
  3. Choisissez Mémoriser (magasin de secrets du système) pour que chaque exécution ultérieure le reprenne sans le demander, ou Cette session uniquement pour le conserver jusqu'à la fermeture de Studio, puis cliquez sur Enregistrer
  4. Exécutez la suite

La page affiche alors Défini (mémorisé) ou Défini (cette session uniquement). Laissez-la telle quelle pour conserver le mot de passe enregistré ; Effacer le supprime lors de l'enregistrement. Si aucun mot de passe n'est disponible au démarrage d'une exécution, Studio le demande et le conserve pour la session en cours.

Le mot de passe n'est jamais écrit dans le fichier de suite, dans un journal ou dans un fichier de paramètres, et les autres utilisateurs Windows de l'ordinateur ne peuvent pas le lire.

Câbler les entrées au programme appelant

De nombreux blocs ne sont pas appelés avec des valeurs fixes, mais avec des variables d'un bloc de données, par exemple "idb_FB_MotorControl"(bStart := "dbMotorControl".Control.Start, ...). Le programme appelant transmet ces variables au bloc à chaque cycle. Une valeur qu'un test écrit directement dans les données propres du bloc serait remplacée au cycle suivant, et le test signalerait une erreur ou un résultat faux. Le câblage indique au test d'où le programme appelant prend chaque entrée, de sorte que le test y écrit ses valeurs et que le bloc les reçoit de la même manière qu'en production.

Définir le câblage

  1. Ouvrez la suite dans l'éditeur de suite de tests et sélectionnez un cas de test. Dans la partie inférieure, le tableau INPUTS du cas comporte une colonne Écrit dans à côté de la valeur de chaque entrée. L'en-tête du tableau nomme le DB d'instance du bloc et le nombre d'entrées câblées.
  2. Vérifiez le DB d'instance avec Choose Instance DB... dans l'en-tête du tableau. Il nomme le bloc de données que le programme appelant utilise pour cette instance de bloc ; vous pouvez aussi saisir le nom.
  3. Pour chaque entrée que le programme transmet, cliquez sur Choose from DB... dans sa ligne, choisissez le bloc de données puis la variable qu'il contient. Les variables du même type que l'entrée sont listées en premier. Vous pouvez aussi saisir la variable dans le champ Écrit dans, par exemple "dbPlant".rcp.rTempSet, et un élément de tableau tel que "dbRecipes".Recipe[3].rQtyA fonctionne de la même manière. Clear wiring le supprime à nouveau ; une entrée sans câblage est écrite dans le DB d'instance comme auparavant.
  4. Enregistrez la suite. Le câblage appartient à la suite : la même entrée est écrite dans la même variable dans chaque cas de test, vous la définissez donc une seule fois et la voyez dans chaque cas.

Ce qu'il faut savoir

  • Les entrées que le programme alimente avec une valeur fixe, un calcul ou une variable temporaire ne peuvent pas être pilotées par un test. Laissez-les non câblées et hors de vos cas de test ; la valeur définie par le programme reste en vigueur.
  • Une fois le bloc câblé, ses valeurs de démarrage déclarées ne lui parviennent plus. Écrivez dans ce cas de test chaque entrée dont il dépend.
  • Les valeurs câblées restent dans le bloc de données d'un cas de test à l'autre. Les entrées qui réagissent à un front montant, comme une commande de démarrage, nécessitent une séquence explicite dans des étapes multiphases : écrire FALSE, attendre, écrire TRUE.
  • Avant le démarrage de l'exécution, Studio lit les valeurs actuelles de toutes les variables câblées et les rétablit à la fin de l'exécution, de sorte que le programme appelant continue avec les valeurs qu'il avait avant le test.
  • Si une variable câblée est introuvable sur l'automate, l'exécution s'arrête avant le premier cas de test et nomme la variable. Vérifiez le nom du bloc de données, le chemin de la variable et, via OPC UA, que le bloc de données est accessible pour OPC UA.
  • Seules les sorties sont encore lues depuis le DB d'instance. Câbler une sortie n'a aucun effet sur l'exécution.
  • L'assistant peut définir le câblage pour vous : il recherche dans le projet comment le bloc est appelé, câble chaque entrée en conséquence et vous indique quelles entrées le programme fixe (voir Suites de tests rédigées par l'IA).

Cliquez sur Valider dans l'éditeur de suite de tests pour vérifier chaque nom de variable et chaque câblage par rapport au bloc, majuscules et minuscules comprises. Les problèmes sont listés au-dessus de la liste des cas, et Enregistrer et Exécuter restent indisponibles jusqu'à leur correction. Une suite dont le câblage n'est pas valide ne démarre pas.

Gérer les suites et les cas de test

  • Renommez une suite en modifiant le champ JSON name en haut de la suite et en appuyant sur Enregistrer : le fichier est renommé sur le disque en conséquence (voir Renommer une suite depuis le champ JSON name). Pour supprimer une suite, cliquez dessus avec le bouton droit dans la vue Explorateur de tests unitaires et choisissez Supprimer. Pour trier les suites, utilisez des dossiers (voir Organiser les suites de tests en dossiers).
  • Modifiez un cas de test dans le mode Visuel de l'éditeur de suite de tests : chaque ligne de cas permet de le renommer, de modifier sa description, de le Dupliquer, de le supprimer et de réordonner ses étapes multiphases avec Déplacer vers le haut / Déplacer vers le bas.
  • Modifiez le code de test SCL généré dans la vue SCL de l'éditeur de suite de tests : renommez des cas de test, changez les affectations des valeurs d'entrée, modifiez, ajoutez ou supprimez des vérifications d'assertion, et ajoutez ou supprimez des blocs de cas de test entiers. Les modifications sont reportées automatiquement dans les cas de test : les vues visuelle et JSON les affichent immédiatement, et les détails de cas que le texte SCL n'affiche pas (description, cycles, étapes multiphases, tolérance, liste de surveillance, balises, priorité, responsable, exigences) sont conservés. Le bloc d'exécution à la fin est maintenu automatiquement ; ses modifications n'ont aucun effet. Si le texte ne correspond plus à la structure des blocs de test, un message d'erreur avec le numéro de ligne apparaît, et Enregistrer et Importer dans TIA sont bloqués jusqu'à la correction. Passer à un autre onglet de l'éditeur abandonne le texte SCL qui n'a pas encore été appliqué ; les modifications déjà appliquées sont conservées.
  • Les paramètres de connexion sont propres à chaque suite. Le transport, le nom de l'instance PLCSim, l'adresse IP, le temps d'attente de cycle, la cible S7 Native (IP, port, utilisateur, mot de passe) et le comportement de connexion automatique se trouvent tous dans le bloc config du fichier de suite. Ils sont enregistrés avec la suite, de sorte que les mêmes valeurs s'appliquent la prochaine fois que vous l'ouvrez. Les mots de passe sont stockés sur cet ordinateur ; le fichier de suite ne contient jamais de mot de passe. (La page Paramètres de connexion de la suite les modifie sans toucher au JSON, voir Paramètres de connexion.)
  • Cliquez sur Valider dans l'éditeur de suite de tests pour vérifier chaque nom de variable et chaque câblage par rapport au bloc, majuscules et minuscules comprises. Les problèmes sont listés au-dessus de la liste des cas, et Enregistrer et Exécuter restent indisponibles jusqu'à leur correction.
  • Lorsqu'un cas de test échoue, son message apparaît dans la colonne Message de l'onglet Exécuter, et la section Assertions marque l'assertion en échec à côté de ses valeurs attendue et réelle. Double-cliquez sur le cas pour l'ouvrir dans l'éditeur de suite de tests.
  • Si un fichier de suite est modifié de l'extérieur (ou renommé via le champ JSON name ci-dessus), l'éditeur ouvert se recharge automatiquement, sauf si vous avez des modifications non enregistrées, auquel cas vos modifications sont conservées.

Dépannage

  • Les icônes d'état ne se mettent pas à jour après une exécution : vérifiez que la suite est enregistrée et que son fichier se trouve dans le dossier .tia-tests (ou dans le dossier de test que vous avez choisi).
  • Action d'exécution indisponible : un projet TIA doit être ouvert, et le document de suite actif doit être un JSON valide.
  • L'Explorateur de tests est vide : le répertoire de travail n'a pas encore de dossier .tia-tests/. Cliquez sur Nouvelle suite de tests pour créer la première ; le dossier est créé automatiquement.
  • Erreurs PLCSIM : vérifiez que PLCSIM Advanced V3.0+ est installé et sous licence. La version exacte est détectée automatiquement à l'exécution. Une erreur pendant une exécution nomme l'instance, ce que faisait l'exécution, l'état de fonctionnement de l'instance et si le bloc de données est connu de l'instance. Lorsqu'elle indique que le bloc n'est peut-être pas chargé, chargez le programme dans l'instance (ou utilisez le mode de préparation Téléchargement TCP) et passez l'instance en RUN.
  • « TIA Portal est en ligne avec l'automate … » : une exécution ou une analyse de bloc doit lire le bloc depuis TIA Portal, ce qui n'est pas possible tant que TIA Portal est en ligne avec cet automate. Passez hors ligne dans TIA Portal et recommencez.
  • Exécution avec un projet ouvert hors ligne : tant qu'un projet est ouvert avec Ouvrir un projet TIA (hors ligne), les exécutions de test et l'analyse de bloc du Test Bench lisent le bloc depuis ce projet, puis depuis son fichier exporté, même lorsque Studio est aussi connecté à TIA Portal. Si aucun des deux ne contient le bloc, l'exécution s'arrête avec un message qui nomme le projet hors ligne : vérifiez que la suite nomme un automate et un bloc de ce projet, ou exportez le bloc.
  • Capturer le trafic TLS pour le support (avancé) : si le support demande une capture Wireshark d'une connexion S7 Native chiffrée, définissez la variable d'environnement SSLKEYLOGFILE sur un chemin de fichier absolu avant de démarrer l'application (par exemple setx SSLKEYLOGFILE "C:\Temp\s7-keys.log"), puis redémarrez. Faites pointer la préférence TLS de Wireshark (Pre)-Master-Secret log filename vers le même fichier. Un avertissement est écrit dans le journal de l'application à chaque connexion tant que cette option est active, pour que vous n'oubliiez pas de la désactiver. Laissez la variable vide en fonctionnement normal.

Suites de tests rédigées par l'IA (Pro+)

Le chat IA peut rédiger, affiner et (au besoin) exécuter pour vous des suites de tests unitaires SCL complètes. Nécessite une licence Pro+ ou supérieure.

Compétence Écrire des tests unitaires (chat principal)

  1. Ouvrez Chat IA et choisissez la compétence Écrire des tests unitaires dans le sélecteur de compétences, ou demandez simplement : « écrivez des tests unitaires pour FB_MotorControl »
  2. L'assistant lit l'interface du bloc, calcule les valeurs limites, planifie les cas de test et résume le plan dans le chat (sans énormes blocs JSON)
  3. Lorsqu'il est prêt à écrire la suite, une carte de confirmation apparaît dans le chat. Cliquez sur Autoriser pour laisser l'assistant enregistrer la suite dans .tia-tests/, ou choisissez Autoriser dans cette session sur la carte pour ne plus être sollicité pendant le reste de la session de chat
  4. Si vous avez aussi demandé à l'assistant d'exécuter la suite, une deuxième carte demande confirmation avant l'exécution elle-même. Les résultats reviennent sous forme de résumé réussite/échec dans le chat, et l'assistant propose d'affiner les cas en échec
  5. L'assistant n'écrase jamais une suite : lorsque le nom demandé est déjà pris, y compris avec d'autres majuscules, ou qu'un fichier de suite portant ce nom ne peut pas être lu, il demande un autre nom
  6. La vue Explorateur de tests unitaires détecte automatiquement la nouvelle suite : ouvrez-la, vérifiez-la en mode visuel ou en texte JSON, et exécutez-la vous-même quand vous le souhaitez
  7. Vous pouvez aussi demander à l'assistant d'« ouvrir cette suite » après sa création ; la suite s'ouvre dans l'éditeur de suite de tests sans que vous ayez à passer à la vue Explorateur de tests unitaires

Laisser l'assistant modifier une suite ouverte

Lorsqu'une suite est ouverte dans l'éditeur de suite de tests, vous pouvez demander à l'assistant dans le chat IA de la modifier, par exemple « ajoutez un test de dépassement pour Counter_Value » ou « resserrez la tolérance de toutes les assertions REAL à 0.01 ».

  1. L'assistant lit la suite ouverte et prépare sa modification. L'éditeur affiche une barre : « Les modifications de l'IA sont en attente de vérification. Conservez-les pour les appliquer, ou annulez-les pour les abandonner. »
  2. Cliquez sur JSON dans l'éditeur pour comparer la suite avant et après la modification ; la comparaison s'ouvre sur la première modification.
  3. Si l'assistant effectue plusieurs modifications à la suite, elles s'additionnent et apparaissent toutes dans la même comparaison.
  4. Cliquez sur Conserver pour appliquer toutes les modifications en attente (enregistrez ensuite la suite comme d'habitude), ou sur Annuler pour toutes les abandonner.

Lorsque l'assistant modifie directement la suite alors qu'une modification est en attente, par exemple en ajoutant un cas de test ou en changeant les paramètres, cette modification est enregistrée et également ajoutée à la version en attente, de sorte que Conserver ne l'annule pas. Si elle ne correspond pas à la version en attente, par exemple parce que la modification en attente a renommé le cas, l'assistant vous demande d'abord de conserver ou d'annuler la modification en attente.

L'assistant vérifie les noms et types de variables par rapport au bloc réel, de sorte que les incohérences sont détectées avant que vous conserviez une modification. Évitez de saisir dans la suite pendant qu'une modification est en attente : Conserver applique la version de la suite de l'assistant. L'onglet de la suite passe au premier plan lorsque l'assistant prépare une modification, pour que vous voyiez Conserver et Annuler ; si l'onglet ne peut pas les afficher, l'assistant vous demande de l'ouvrir. La connexion d'une suite n'est pas modifiée de cette manière, voir Laisser l'assistant configurer la connexion.

Choisir les outils de l'assistant autorisés à agir. Dans le chat IA, Ouvrir les personnalisations, Autorisations d'outils liste les outils de tests unitaires dans le groupe unit-tests. Pour chaque outil qui écrit ou exécute (par exemple créer ou supprimer une suite, modifier une suite ouverte ou exécuter une suite), vous pouvez choisir d'être sollicité à chaque fois, de toujours l'autoriser ou de toujours le refuser ; un outil refusé reste bloqué même lorsque le chat approuve les outils automatiquement. Les outils qui ne font que lire ne demandent jamais.

Vérifier les cas de test rédigés par l'IA

Les cas de test écrits par l'assistant ne portent aucun badge AI visible dans l'arborescence de l'Explorateur de tests ni dans l'éditeur visuel ; seul un badge Theory (N rows) apparaît pour les cas paramétrés.

Vérifiez les cas de test rédigés par l'IA comme vous le feriez pour la pull request d'un collègue : lisez chaque assertion, contrôlez la plausibilité des valeurs attendues, puis exécutez sur le simulateur avant de passer au matériel réel.

Laisser l'assistant configurer la connexion

Vous pouvez demander à l'assistant de modifier la manière dont une suite se connecte et s'exécute, par exemple « exécutez cette suite via S7 Native sur mon instance PLCSIM Advanced à 192.168.0.20 » ou « réglez le délai d'expiration sur 10 secondes ». Une carte de confirmation liste chaque paramètre qu'il s'apprête à enregistrer avec sa nouvelle valeur. Après Autoriser, la modification est enregistrée de la même manière que sur la page Paramètres de connexion, de sorte que la suite, une page de paramètres de connexion ouverte et l'éditeur de suite de tests affichent les nouvelles valeurs. Si la page de paramètres de connexion de la suite contient des modifications non enregistrées, l'assistant vous demande d'abord de les enregistrer ou de les abandonner, et pendant qu'un test s'exécute, il attend la fin de l'exécution.

L'assistant peut aussi vérifier la connexion d'une suite de la même manière que Tester la connexion avant de lancer une exécution. La connexion par défaut avec laquelle démarrent les nouvelles suites reste votre réglage. Via S7 Native ou OPC UA, l'assistant n'exécute des tests que sur une instance PLCSIM Advanced de cet ordinateur, jamais sur un automate réel : une exécution sur un automate réel est toujours lancée par vous sur le Test Bench.

L'assistant ne voit ni ne saisit jamais de mot de passe. Lorsqu'une nouvelle adresse, un nouveau port ou un nouvel utilisateur en nécessite un, le mot de passe enregistré de l'ancienne cible est supprimé et l'assistant vous demande de saisir le nouveau sur la page des paramètres de connexion.

À partir du forfait Pro+, l'assistant peut aussi créer, démarrer et adresser l'instance PLCSIM Advanced sur laquelle une suite s'exécute, voir PLCSIM Advanced.

L'assistant sait quels paramètres utilise chaque type de connexion. Pour S7 Native, il n'a besoin que de l'adresse IP de la CPU et du port (102 par défaut) ; il n'y a ni rack ni emplacement à définir. Si vous demandez un paramètre que le type de connexion choisi n'utilise pas, l'assistant vous indique que la suite ne le conserve pas.

Lorsque vous créez avec l'assistant une suite pour une instance PLCSIM Advanced et que certains membres du bloc ne sont pas accessibles depuis HMI/OPC UA/Web API, l'assistant vous avertit : PLCSIM Advanced ne peut pas atteindre ces membres. Il propose alors de passer la suite en S7 Native ou d'activer l'accessibilité de ces membres dans TIA Portal.

Sur quelles cibles l'assistant peut exécuter des tests

L'assistant n'exécute une suite que sur une simulation de votre ordinateur :

  • Les suites qui utilisent PLCSIM Advanced s'exécutent sur l'instance nommée.
  • Les suites qui utilisent S7 Native ou OPC UA ne s'exécutent que si leur adresse appartient à une instance PLCSIM Advanced de cet ordinateur qui est en RUN ou en STOP, avec PLCSIM Advanced réglé sur un mode réseau TCP/IP. Une instance qui a obtenu son adresse lors d'une exécution précédente de l'assistant ne compte pas, car l'assistant a choisi cette adresse lui-même. Studio le vérifie lui-même avant chaque exécution.
  • Toute autre adresse compte comme un automate réel. L'assistant n'exécute pas la suite et vous demande de lancer l'exécution vous-même depuis le Test Bench, où vous la confirmez.

N'exécuter que certains cas. Vous pouvez demander à l'assistant de n'exécuter que certains cas de test d'une suite, par exemple « exécutez uniquement StartReachesNominalSpeed et NoEnableStaysStopped ». L'exécution est la même que Cas sélectionnés dans l'éditeur de suite de tests, et Historique l'affiche comme une exécution partielle. Un nom de cas qui n'existe pas est refusé avant tout démarrage, avec les noms les plus proches.

L'assistant ne lance pas d'exécution pendant qu'un autre test s'exécute, et il n'arrête jamais une exécution que vous avez lancée.

La carte de confirmation d'une exécution nomme le type de connexion, la cible et, pour une exécution partielle, les cas sélectionnés. Après une exécution, demandez à l'assistant quels cas ont échoué : il peut lister chaque cas avec son message d'erreur ainsi que la valeur attendue et la valeur réelle de chaque assertion en échec.

Vous pouvez aussi poser une question sur un seul cas de test, par exemple « pourquoi StopWhileRunningStops échoue-t-il ? ». L'assistant lit ce cas sans charger toute la suite et affiche ses résultats sur les exécutions récentes : depuis quelle exécution il échoue, si la suite a changé depuis et si le cas est instable, c'est-à-dire qu'il réussit et échoue en alternance.

Protection Safety (F-CPU)

La rédaction de tests par l'IA est restreinte pour les blocs Safety :

  • Création de tests : l'assistant refuse de rédiger des tests pour un bloc F-CPU sans confirmation explicite de votre part dans la conversation. Sans cette confirmation, aucun test n'est écrit
  • Exécution de tests : l'assistant ne peut pas exécuter de tests sur des blocs Safety. Point final, sans dérogation possible. La vérification des blocs Safety exige une méthodologie certifiée (TÜV/CE), pas une exécution générée par l'IA. Si vous souhaitez exécuter un test sur un bloc Safety, lancez l'exécution vous-même depuis l'Explorateur de tests

Licences

La compétence Écrire des tests unitaires et les outils de tests unitaires du chat IA nécessitent Pro+ ou supérieur. Avec un forfait inférieur, la compétence affiche un message de licence avant tout appel à l'IA.

Intégration CI/CD

L'outil en ligne de commande tia-test-runner exécute vos suites de tests unitaires SCL sur un serveur de build, sans interface et sans clic manuel. Indiquez-lui un projet TIA Portal : il découvre les suites dans .tia-tests/, les exécute, écrit des rapports lisibles par machine et renvoie un code de sortie que votre pipeline peut exploiter. Il ouvre TIA Portal en mode headless (sans fenêtre) et fonctionne donc proprement sur un agent de build ; passez --show-ui pour le suivre à l'écran pendant le débogage. C'est une fonctionnalité Pro+ (Pro+ et supérieur) ; l'agent a besoin d'un fichier de licence CI que vous enregistrez depuis Studio (voir Licences pour la CI ci-dessous).

L'outil en ligne de commande tia-test-runner

L'outil est livré sous le nom tia-test-runner.exe et propose neuf verbes. tia-test-runner --help et tia-test-runner <verb> --help affichent les options sur l'agent.

  • run

    Fichier de licence requis
    Oui
    Fonction
    Exécute les suites de tests d'un projet TIA ou d'un projet CODESYS enregistré, enregistre les résultats sur l'agent et écrit les rapports
  • validate

    Fichier de licence requis
    Non
    Fonction
    Vérifie les fichiers de suite, et avec --config le fichier de configuration, à la recherche d'erreurs sans rien exécuter
  • verify

    Fichier de licence requis
    Non
    Fonction
    Vérifie que les fichiers de rapport d'une exécution n'ont pas changé depuis que l'exécution les a écrits, et affiche la validation de l'exécution
  • compare

    Fichier de licence requis
    Oui
    Fonction
    Écrit un rapport HTML qui compare deux exécutions enregistrées
  • trend

    Fichier de licence requis
    Oui
    Fonction
    Exporte l'historique de réussite/échec d'un automate, d'une suite ou d'un cas au format CSV
  • flaky

    Fichier de licence requis
    Oui
    Fonction
    Liste les cas d'une suite qui alternent entre réussite et échec lors des exécutions récentes
  • traceability

    Fichier de licence requis
    Oui
    Fonction
    Vérifie la traçabilité des exigences et fait échouer le build en cas d'exigences en échec ou non testées (voir Contrôle de traçabilité des exigences ci-dessous)
  • check-contracts

    Fichier de licence requis
    Oui
    Fonction
    Compare l'interface de chaque bloc testé avec son contrat enregistré, sans TIA et sans PLCSim, et fait échouer le build en cas de changement incompatible
  • version

    Fichier de licence requis
    Non
    Fonction
    Affiche la version du runner, de son moteur, du build, de .NET et du système d'exploitation, par exemple pour une demande d'assistance

compare, trend, flaky et traceability lisent les résultats que run a enregistrés sur le même agent sous le même utilisateur Windows.

Options pour tous les verbes :

Option Signification
--log-level <LEVEL> Niveau de journalisation du runner : Verbose, Debug, Information, Warning (par défaut), Error ou Fatal. Les lignes de journal vont sur la sortie d'erreur, de sorte que la sortie normale ne contient que les résultats.
--log-file <PATH> Écrit le fichier journal à ce chemin au lieu du fichier journal quotidien sous %LocalAppData%\AnyAutomation\Logs (les 14 derniers sont conservés).
--lang <LANGUAGE> Langue des titres de l'aide : en (par défaut), de, fr ou it (l'italien affiche l'anglais). Les résultats sont toujours en anglais.
--ansi, --no-ansi Force ou désactive la sortie en couleur.
--license-offline <PATH> Le fichier de licence CI (voir Licences pour la CI).

Un niveau de journalisation ou une langue inconnus, --ansi et --no-ansi ensemble, ou un --log-file impossible à écrire se terminent par le code de sortie 3.

Exécution des tests : run

Une exécution typique :

tia-test-runner run ^
  --project "C:\Projects\Plant\Plant.ap20" ^
  --out-dir "C:\Projects\Plant\.tia-tests\reports\ci" ^
  --license-offline "C:\agent\anyautomation-ci.json"

Le runner trouve les suites dans le dossier .tia-tests à côté du fichier de projet, ouvre le projet TIA (sans fenêtre), exécute chaque suite l'une après l'autre et écrit les rapports. Il ouvre le projet même lorsque toutes les suites s'exécutent via OPC UA ou S7 Native : fermez donc le projet dans Studio avant de lancer le runner sur le même ordinateur.

Emplacement des rapports. Les rapports vont toujours dans un dossier situé dans .tia-tests\reports du dossier du projet. Un --out-dir relatif part de ce dossier, ainsi --out-dir ci écrit dans .tia-tests\reports\ci à côté du fichier de projet, quel que soit l'endroit où la commande s'exécute. Un chemin absolu doit se trouver dans .tia-tests\reports ; tout autre dossier termine l'exécution avec le code de sortie 3 avant le début des tests. Un dossier du chemin qui est un lien ou une jonction vers un autre emplacement est refusé de la même manière.

Options de run :

Option Signification
--project <PATH> Fichier de projet TIA (par exemple .ap20) ou projet CODESYS enregistré (.project). Obligatoire, sauf si le fichier de configuration le définit. Un chemin réseau (\server...) n'est pas accepté.
--out-dir <PATH> Dossier des rapports dans .tia-tests\reports du dossier du projet ; un chemin relatif part de là (voir ci-dessus). Obligatoire, sauf si le fichier de configuration le définit.
--suite-filter <PATTERN> N'exécute que les suites dont le nom de fichier (sans .json) correspond au modèle. * représente n'importe quel texte, ? un seul caractère, tout le reste est pris littéralement, sans distinction entre majuscules et minuscules. L'absence de suite correspondante se termine par le code de sortie 3.
--plc <NAME> N'exécute que les suites de cet automate (sans distinction entre majuscules et minuscules). L'absence de suite pour cet automate se termine par le code de sortie 3. --rerun-affected vérifie les modifications de cet automate.
--tag <TAG> N'exécute que les cas de test qui portent ce tag (répétable, l'une des valeurs suffit, sans distinction entre majuscules et minuscules, 256 au maximum). Les tags d'un cas théorie s'appliquent à toutes ses lignes de paramètres.
--priority-min <LEVEL> N'exécute que les cas de test ayant au moins cette priorité : Low, Normal, High ou Critical. Toute autre valeur se termine par le code de sortie 3.
--owner <NAME> N'exécute que les cas de test de ce responsable (sans distinction entre majuscules et minuscules).
--rerun-affected N'exécute que les suites dont le bloc a changé depuis la dernière exécution où tout a réussi. Nécessite --plc, sur la ligne de commande ou dans le fichier de configuration ; sans lui, l'exécution se termine avec le code de sortie 3. Si rien n'a changé, l'exécution se termine avec le code de sortie 0. Projets TIA uniquement.
--report-format <FORMAT> junit, html ou cobertura, répétable, 16 au maximum. Par défaut : JUnit et HTML. Avec la couverture, Cobertura est ajouté automatiquement.
--brand-title <TEXT>, --brand-footer <TEXT>, --brand-color <#RRGGBB>, --brand-logo <PATH> Titre, pied de page, couleur d'accent et logo du rapport HTML. Le logo doit être un fichier PNG, JPG ou SVG de 500 KB au maximum ; un logo manquant ou inutilisable termine l'exécution avec le code de sortie 2 avant l'exécution de la première suite. Une couleur qui n'est pas écrite sous la forme #RRGGBB est ignorée.
--report-classname-pattern <PATTERN> Nom de classe du rapport JUnit (voir Noms de classe des rapports ci-dessous).
--fail-fast S'arrête au premier cas de test en échec : les cas restants de cette suite sont signalés comme ignorés avec le nom du cas en échec, et les suites suivantes ne s'exécutent pas. Une suite qui ne peut pas s'exécuter arrête aussi l'exécution. Dans une suite CODESYS, l'exécution s'arrête après la suite, car ses cas s'exécutent comme un seul programme.
--timeout-minutes <N> Durée maximale de toute l'exécution, de 1 à 10080 (une semaine). Par défaut 60. Une fois cette durée atteinte, l'exécution se termine avec le code de sortie 4.
--cycle-wait-ms <MS> Attente de cycle de chaque suite en millisecondes, de 0 à 3600000, au lieu de la valeur enregistrée dans la suite. En pas à pas, il s'agit du temps de cycle fixe de chaque scrutation, de 1 à 6000.
--cycle-mode <MODE> timed ou single-step pour les suites sur PLCSim Advanced, au lieu du paramètre enregistré dans la suite (voir Contrôle du cycle pas à pas). Une suite qui ne peut pas s'exécuter en pas à pas, par exemple une suite OPC UA ou une suite en mode de test isolé, arrête l'exécution avec le code de sortie 3. Une suite dont l'instance PLCSim est occupée par une autre exécution pas à pas n'est pas exécutée et compte comme une erreur ; l'exécution continue avec la suite suivante.
--attach S'attache à un TIA Portal déjà en cours d'exécution au lieu d'ouvrir le fichier de projet. Projets TIA uniquement.
--show-ui Ouvre TIA Portal avec sa fenêtre visible au lieu de sans fenêtre. Pratique pour suivre une exécution lors d'un débogage local. Projets TIA uniquement.
--update-snapshots Enregistre à nouveau les références de snapshot au lieu de les comparer. Non disponible pour les suites S7 Native (code de sortie 3).
--opcua-password <VALUE> Mot de passe d'une suite OPC UA avec connexion par nom d'utilisateur (jamais journalisé). À défaut, la variable d'environnement ANYAUTOMATION_OPCUA_PASSWORD est utilisée.
--s7-password <VALUE> Mot de passe d'une suite S7 Native protégée par mot de passe (jamais journalisé). À défaut, la variable d'environnement ANYAUTOMATION_S7_PASSWORD est utilisée.
--codesys-password <VALUE> Mot de passe de l'utilisateur runtime d'une suite CODESYS (jamais journalisé). À défaut, la variable d'environnement ANYAUTOMATION_CODESYS_PASSWORD est utilisée. Inutile dans la simulation CODESYS.
--quarantine Requalifie un cas en échec en cas ignoré non bloquant lorsqu'il a été instable lors des exécutions récentes, afin qu'un échec instable ne casse pas le build (voir Tests instables et quarantaine).
--quarantine-window <N> Nombre d'exécutions récentes à examiner pour détecter l'instabilité (10 par défaut).
--quarantine-min-flips <N> Nombre minimal de changements réussite/échec dans cette fenêtre pour qu'un cas soit considéré comme instable (1 par défaut).
--flaky-confirm Exécute une fois de plus un cas instable en échec ; si la deuxième tentative réussit, le cas compte comme réussi.
--retry-max <N> Nombre de nouvelles tentatives d'une suite après une erreur d'infrastructure telle qu'une connexion perdue (0 les désactive ; 3 par défaut).
--retry-delay-ms <MS> Attente entre ces tentatives en millisecondes (5000 par défaut).
--coverage Mesure la couverture des exigences, de l'interface et des blocs appelés, écrit un rapport Cobertura et affiche un tableau de couverture par suite. Projets TIA uniquement.
--coverage-min-requirement <PCT>, --coverage-min-interface <PCT>, --coverage-min-called-block <PCT> Couverture minimale en pourcentage (0 à 100). En définir une active --coverage. Une valeur inférieure au minimum termine l'exécution avec le code de sortie 7, si rien d'autre n'a échoué.
--ci-env-capture Enregistre les détails du job CI dans les rapports (voir Capture des détails de l'environnement CI).
--skip-version-check Ignore la vérification de la version de TIA Portal.
--config <PATH> Lit les valeurs par défaut dans un fichier de configuration (voir Fichier de configuration YAML ci-dessous).

Une suite qui a besoin d'un mot de passe que ni l'option ni la variable d'environnement ne fournit termine l'exécution avec le code de sortie 3.

Commutateurs. Un commutateur tel que --fail-fast, --coverage ou --quarantine accepte aussi true ou false, par exemple --fail-fast false. Cela désactive un paramètre que le fichier de configuration active.

Filtrage des cas de test. --tag, --priority-min et --owner utilisent les tags, la priorité et le responsable que vous définissez sur les cas de test (voir Métadonnées des cas de test), et ils se combinent : un cas doit les satisfaire tous. Les autres cas sont signalés comme ignorés. Une suite dont aucun cas ne correspond est ignorée dans son ensemble, avec une ligne Skipped <suite>: no test case matches the case filters., et n'écrit aucun rapport. Si aucun cas d'aucune suite ne correspond, l'exécution se termine avec le code de sortie 3 avant le début des tests, de sorte qu'un filtre mal saisi ne peut pas faire passer un build.

Suites CODESYS sur le serveur de build. Passez le projet CODESYS enregistré avec --project (par exemple --project "C:\Projects\Line\Line.project") et gardez ses suites dans le dossier .tia-tests à côté de celui-ci. Chaque suite s'exécute sur la cible enregistrée dans la suite : dans la simulation CODESYS, qui ne nécessite ni appareil ni runtime, ou sur CODESYS Control Win sur le serveur de build. Placez --out-dir sous .tia-tests\reports du dossier du projet, comme pour TIA. Les options de couverture, --attach, --show-ui et --rerun-affected ne s'appliquent qu'aux projets TIA et terminent une exécution CODESYS avec le code de sortie 3.

Ce que l'exécution affiche. Une ligne par suite ([1/3] Running ...), les tableaux de couverture si vous les demandez, un tableau de chaque cas mis en quarantaine, et une ligne de synthèse avec le nombre de cas réussis, en échec, en erreur, ignorés et en quarantaine, ainsi que le code de sortie. Un cas en quarantaine est toujours listé, jamais masqué.

Ce que l'exécution écrit. La dernière exécution se trouve toujours au premier niveau de --out-dir : junit.xml pour le rapporteur de tests de votre CI, le rapport HTML autonome à votre image report.html, cobertura.xml lorsque la couverture a été demandée, un résumé summary.json, et les fichiers d'intégrité manifest.json et checksums.txt. Chaque exécution précédente est déplacée dans son propre sous-dossier sous runs avec son propre manifeste, et dès que le dossier contient plus d'une exécution, aggregate-summary.json les recense toutes. Avec plusieurs suites dans un même appel, les fichiers du premier niveau appartiennent à la dernière suite : publiez donc **/junit.xml pour obtenir toutes les suites. L'identifiant d'exécution dont compare a besoin est l'entrée run_id de manifest.json ou summary.json.

Codes de sortie de run (le contrat du pipeline) :

Code Signification
0 Tous les tests ont réussi (y compris lorsque --rerun-affected n'a rien trouvé à exécuter)
1 Au moins un cas de test a échoué ou s'est terminé par une erreur
2 Erreur d'exécution : aucune licence valide, impossible d'ouvrir TIA ou le projet, une autre exécution utilise le même dossier de rapports, une suite n'a pas pu s'exécuter, les rapports n'ont pas pu être écrits, PLCSim s'est arrêté trois fois de suite, une version de TIA non prise en charge (sauf avec --skip-version-check), un logo de marque inutilisable
3 Erreur d'argument ou de configuration : une option manquante ou incorrecte, un fichier de configuration illisible, un dossier de rapports hors de .tia-tests\reports, aucune suite correspondante, aucune suite pour le --plc, --rerun-affected sans --plc, aucun cas de test correspondant aux filtres de cas, un fichier de suite non valide, une suite qui ne peut pas s'exécuter comme demandé
4 La durée maximale de --timeout-minutes a été atteinte
5 Annulé avec Ctrl+C (un second Ctrl+C arrête immédiatement le runner)
7 Couverture inférieure à une valeur --coverage-min-...

Vérifier les suites sans les exécuter : validate

tia-test-runner validate --project "C:\Projects\Plant\Plant.ap20" --config "C:\Projects\Plant\runner.yaml"
Option Signification
--project <PATH> Le fichier de projet TIA, le projet CODESYS enregistré ou le dossier du projet. Obligatoire.
--suite-filter <PATTERN> Ne vérifie que les suites correspondantes, comme pour run.
--config <PATH> Vérifie aussi le format du fichier de configuration, avec un avertissement pour chaque clé inconnue (voir Fichier de configuration YAML).

Chaque problème est affiché avec le fichier, la ligne et un code court, les avertissements étant marqués WARNING, puis une ligne telle que 3 suites OK, config OK. Rien n'est écrit et aucun fichier de licence n'est nécessaire, ce qui convient à un hook de pre-commit. Codes de sortie : 0 aucune erreur (avertissements autorisés), 3 une erreur, un chemin incorrect, ou aucune suite trouvée lorsqu'aucun --config n'est indiqué, 5 Ctrl+C.

Vérifier les rapports archivés : verify

tia-test-runner verify --manifest "C:\Projects\Plant\.tia-tests\reports\ci\manifest.json"

--manifest <PATH> (obligatoire) désigne le manifest.json d'un dossier de rapports. Le runner recalcule la somme de contrôle de chaque fichier qui y est listé et affiche Integrity OK (n files) ou la liste des fichiers modifiés ou manquants, ainsi que la validation de l'exécution, avec une remarque si les détails de validation ont été modifiés après coup. La vérification montre que les fichiers n'ont pas changé depuis que l'exécution les a écrits ; il s'agit d'une liste de sommes de contrôle, pas d'une signature, elle ne montre donc pas qui les a écrits. Codes de sortie : 0 inchangé, 1 fichiers modifiés ou manquants ou validation modifiée, 2 manifeste manquant ou illisible, 3 chemin incorrect, 5 Ctrl+C. Aucun fichier de licence n'est nécessaire, si bien que les rapports de réception archivés peuvent être vérifiés des années plus tard.

Comparer deux exécutions : compare

tia-test-runner compare ^
  --baseline 3f2a9c1e-0b6d-4d1e-9a51-2c7e8f4b6a10 ^
  --current 8c41d7b2-5e93-4a0f-b2c6-91d3e7a5f024 ^
  --out-dir "C:\Projects\Plant\compare"

--baseline et --current sont des identifiants d'exécution (le run_id du manifest.json ou du summary.json de chaque exécution, en majuscules ou en minuscules, avec ou sans accolades) ; --out-dir est le dossier du rapport. Le runner écrit compare-<first 8 characters of the baseline id>-<first 8 of the current id>.html avec ses propres manifest.json et checksums.txt, et affiche le nombre de régressions et de cas corrigés, nouveaux et supprimés. verify vérifie le dossier comme n'importe quel dossier de rapports. Utilisez un dossier dédié : un dossier qui contient déjà un autre rapport, par exemple les rapports d'une exécution, est refusé avec le code de sortie 3, et le message suggère un dossier compare à l'intérieur. Un dossier écrit par compare d'une version plus ancienne est également refusé ; choisissez-en un nouveau. Les régressions ne font pas échouer l'étape ; le code de sortie est 0 dès que le rapport a été écrit, 2 lorsqu'un identifiant d'exécution est inconnu ou que le rapport n'a pas pu être écrit, 3 pour un identifiant qui n'est pas un identifiant d'exécution valide ou un chemin incorrect, 5 pour Ctrl+C.

Historique de réussite/échec en CSV : trend

tia-test-runner trend --plc PLC_1 --suite FB_Motor --from 2026-10-01 --to 2026-11-01 --out-file trend.csv
Option Signification
--plc <NAME> L'automate dont les exécutions sont exportées. Obligatoire.
--suite <NAME> Exporte l'historique de cette suite au lieu de celui de tout l'automate.
--case <NAME> Exporte le résultat de ce cas dans chaque exécution (nécessite --suite).
--from <DATE> Premier instant inclus, par exemple 2026-10-01 ou 2026-10-01T06:00:00. Sans lui, tout l'historique.
--to <DATE> Dernier instant inclus, maintenant par défaut. Une date seule inclut toute la journée, ainsi --to 2026-11-01 se termine par la dernière exécution du 1er novembre ; une heure inclut les exécutions qui ont démarré à cet instant. Les heures sans fuseau horaire sont comptées en UTC.
--out-file <PATH> Le fichier CSV. Obligatoire.

Le CSV contient une ligne par exécution avec le taux de réussite, le nombre de cas réussis, en échec, en erreur et ignorés, et la durée ; pour un cas, une ligne par exécution avec son résultat (PASS, FAIL, ERROR, SKIP ou NOT_RUN). Codes de sortie : 0 écrit, 2 historique illisible ou fichier impossible à écrire, 3 option incorrecte, 5 Ctrl+C.

Contrôle de contrat des interfaces de bloc : check-contracts

tia-test-runner check-contracts --project "C:\Projects\Plant\Plant.ap20"
Option Signification
--project <PATH> Le fichier de projet TIA, le projet CODESYS enregistré ou le dossier du projet. Obligatoire. Un dossier de projet inexistant se termine par le code de sortie 3.
--suite-filter <PATTERN> Ne vérifie que les suites correspondantes, comme pour run.
--approve-contracts Enregistre les interfaces actuelles comme nouveaux contrats au lieu de comparer.

Pour chaque suite, le runner lit le fichier de bloc exporté dans le dossier d'exportation enregistré dans la suite (un dossier d'exportation relatif est lu à partir du dossier du projet), compare son interface avec le contrat enregistré de la suite et affiche un tableau Contract drift des changements incompatibles. Une suite sans contrat enregistré en reçoit un lors de la première vérification. Codes de sortie : 0 aucun changement incompatible, une première capture ou --approve-contracts, 8 un changement incompatible, 3 un chemin incorrect, aucune suite, un fichier de suite non valide ou un bloc non exporté, 2 aucune licence valide, 5 Ctrl+C.

Informations de version : version

tia-test-runner version affiche la version du runner, de son moteur, de la connexion TIA installée avec lui (ligne Bridge, "not found next to the runner" lorsqu'elle est absente), du build, de .NET et du système d'exploitation. Il ne nécessite aucun fichier de licence et ne démarre rien.

Contrôle de traçabilité des exigences

tia-test-runner traceability vérifie la traçabilité des exigences sur l'agent de build et fait échouer le pipeline lorsque des exigences ont échoué ou n'ont pas de test. Il lit les résultats de test que le verbe run a enregistrés sur le même agent ainsi que la liste des exigences du dossier de test, s'il y en a une.

tia-test-runner traceability ^
  --project "C:\Projects\Plant\Plant.ap20" ^
  --runs-from "C:\Projects\Plant\.tia-tests\reports\ci" ^
  --out-dir "C:\Projects\Plant\.tia-tests\reports\ci\traceability" ^
  --fail-on failed,uncovered
Indicateur Signification
--project <PATH> Fichier de projet TIA Portal ou son dossier. Obligatoire.
--runs-from <DIR> N'utilise que les exécutions dont les rapports se trouvent dans ce dossier, normalement le --out-dir de l'étape run qui précède. Un chemin relatif part de .tia-tests\reports du dossier du projet, comme le --out-dir de run ; un chemin absolu peut pointer n'importe où, par exemple vers des rapports d'exécution qu'un job CI a téléchargés. Recommandé : sans lui, un résultat enregistré par un autre pipeline ou une autre branche sur le même agent pourrait être pris en compte.
--fail-on <LIST> Les états d'exigence qui font échouer le build : n'importe lesquels parmi failed, uncovered, notRun, outdated, incomplete, ou none. Par défaut failed,uncovered. outdated couvre aussi les exigences dont la dernière exécution a été enregistrée avant que les modifications puissent être détectées.
--requirements <PATH> Une liste d'exigences à utiliser à la place de celle du dossier de test, par exemple une liste exportée de votre outil ALM pendant le build.
--suite-filter <PATTERN> Ne vérifie que les suites dont le nom de fichier correspond au modèle, les mêmes suites que celles qu'exécute run --suite-filter (par exemple Conveyor*). Les exigences que seules les autres suites nomment sont écartées ; les exigences de votre liste qu'aucune suite ne nomme comptent toujours comme non testées.
--run-window <N> Nombre de dernières exécutions de chaque suite à examiner (1 à 100, 20 par défaut).
--format <text|json> Sortie sous forme de tableau (par défaut) ou en JSON. Avec json, la sortie standard ne contient que le document JSON, de sorte qu'un script peut le lire directement.
--json-file <PATH> Écrit aussi le document JSON dans un fichier.
--out-dir <DIR> Écrit le rapport de traçabilité HTML et son manifeste d'intégrité dans ce dossier. Utilisez un dossier dédié, tel que traceability dans le dossier de rapports de l'exécution, et non le dossier d'un rapport d'exécution lui-même. Comme pour run, le dossier se trouve dans .tia-tests\reports du dossier du projet et un chemin relatif part de là ; tout autre dossier termine le contrôle avec le code de sortie 3.
--brand-title, --brand-footer, --brand-color, --brand-logo Image de marque du rapport HTML, comme pour run.

Le tableau liste chaque exigence avec son statut, son nombre de cas de test, sa dernière preuve et son titre, suivi d'un résumé tel que « 12 exigences : 1 en échec, 2 non couvertes, 0 non vérifiée ». Outre les codes de sortie de run, le verbe renvoie :

Code Signification
1 Une exigence a échoué (lorsque failed figure dans --fail-on)
3 Problème d'entrée : par exemple une erreur dans la liste des exigences, un fichier de suite illisible, un --suite-filter qui ne correspond à aucune suite, ou aucun rapport d'exécution dans le dossier --runs-from
9 Une exigence n'a aucun cas de test (lorsque uncovered figure dans --fail-on)
10 Une exigence n'est pas vérifiée : non exécutée, obsolète ou incomplète (lorsque cet état est choisi dans --fail-on)

Il renvoie aussi 2 lorsque les résultats ne peuvent pas être lus, que le rapport ne peut pas être écrit ou que le fichier de licence est absent, et 5 pour Ctrl+C. Les avertissements concernant la liste des exigences sont affichés mais ne font jamais échouer le build. Comme run, le verbe nécessite le fichier de licence CI.

Tests instables et quarantaine

Un test instable réussit lors de certaines exécutions et échoue lors d'autres sans que le bloc testé ait réellement changé, généralement à cause d'un effet de timing ou d'environnement. Pour voir quels cas d'une suite sont instables sur son historique récent :

tia-test-runner flaky --suite-file "C:\Projects\Plant\.tia-tests\FB_Motor.json" --out-file flaky.csv

Il affiche un tableau de chaque cas instable avec le nombre de fois où il a alterné entre réussite et échec et sa séquence de résultats récents, séparés par des virgules, par exemple Pass, Fail, Pass. Ajoutez --window <N> pour changer le nombre d'exécutions récentes examinées (10 par défaut, 1000 au maximum), et --out-file <CSV> pour écrire aussi la liste en CSV avec les colonnes Case, FlipCount et RecentStatuses. Lorsqu'aucun cas n'est instable, le runner affiche "No flaky tests in the last N runs." et écrit quand même le CSV, avec la seule ligne d'en-tête, de sorte qu'un fichier d'un appel précédent est remplacé. Un --window supérieur à 1000 lit les 1000 dernières exécutions. Les cas instables ne font jamais échouer l'étape : le code de sortie est 0 sauf si l'historique ne peut pas être lu ou si le fichier ne peut pas être écrit (2) ou si le chemin --out-file est incorrect (3). Indiquez --suite-file exactement comme le chemin de suite avec lequel les exécutions ont été enregistrées.

Ajoutez --quarantine à un run pour éviter que des échecs instables ne cassent le build : un cas qui échoue lors de l'exécution en cours mais qui a été instable dans l'historique récent est requalifié en cas ignoré non bloquant et signalé comme quarantined (flaky) dans la sortie JUnit et le résumé de l'exécution, tandis que les échecs réels et stables font toujours échouer le build. Ajustez-le avec --quarantine-window et --quarantine-min-flips. Dans Studio, la quarantaine est l'option Mettre en quarantaine les cas instables de la section Exécution (voir Options d'exécution). La quarantaine ne masque jamais un cas requalifié : chacun est listé avant le résumé de l'exécution.

Noms de classe des rapports

Par défaut, les valeurs classname de JUnit suivent le modèle {PlcName}.{BlockName}, que la plupart des visionneuses de tests CI regroupent en une arborescence lisible. Remplacez-le avec --report-classname-pattern en combinant à votre gré ces espaces réservés :

  • {PlcName} : le nom de l'automate/CPU
  • {BlockName} : le bloc soumis au test
  • {SuiteName} : le nom de la suite de tests
  • {ProjectName} : le nom du projet

Exemple : --report-classname-pattern "{ProjectName}/{PlcName}/{SuiteName}".

Capture des détails de l'environnement CI

Passez --ci-env-capture pour enregistrer un petit ensemble fixe de variables CI dans la provenance de l'exécution, afin que les rapports indiquent quel pipeline, quel commit et quel agent ont produit chaque exécution. La capture est facultative : rien n'est enregistré si vous ne le demandez pas. L'outil reconnaît GitHub Actions, Jenkins, Azure DevOps et GitLab CI (ainsi qu'un marqueur générique CI) ; seul un ensemble autorisé d'identifiants (ID d'exécution/de build, SHA du commit, branche/ref, nom du workflow/job, nom de l'agent/du runner) est lu, chacun tronqué à une longueur sûre.

Fichier de configuration YAML

Pour éviter de longues lignes de commande dans votre pipeline, placez les valeurs par défaut de run dans un fichier YAML et passez --config <PATH>. La page Pipeline CI de Studio écrit un tel fichier sous le nom runner.yaml. Exemple :

project: C:\Projects\Plant\Plant.ap20
out_dir: C:\Projects\Plant\.tia-tests\reports\ci
suite_filter: FB_*
report_formats:
  - junit
  - html
timeout_minutes: 45
cycle_mode: single-step
ci_env_capture: true

Clés. Chaque clé est le nom d'une option de run sans les tirets initiaux et avec des traits de soulignement à la place des traits d'union : project, out_dir, suite_filter, tags (liste, pour --tag), plc, rerun_affected, priority_min, owner, report_formats (liste, pour --report-format), brand_title, brand_footer, brand_color, brand_logo, report_classname_pattern, fail_fast, timeout_minutes, cycle_wait_ms, cycle_mode, attach, show_ui, ci_env_capture, skip_version_check, quarantine, quarantine_window, quarantine_min_flips, flaky_confirm, retry_max, retry_delay_ms, coverage, coverage_min_requirement, coverage_min_interface, coverage_min_called_block. Uniquement sur la ligne de commande : les mots de passe, --update-snapshots, --license-offline et les options valables pour tous les verbes. Sur la ligne de commande, --cycle-mode ne distingue pas les majuscules des minuscules, mais dans le fichier cycle_mode doit être écrit exactement timed ou single-step ; toute autre orthographe se termine par le code de sortie 3.

Une clé mal orthographiée est signalée et ignorée. run et validate --config affichent un avertissement pour chaque clé qu'ils ne connaissent pas et nomment la clé correcte la plus proche, par exemple « Clé runner-config inconnue 'reportformat', vouliez-vous dire 'reportformats' ? La clé est ignorée. » L'exécution elle-même se poursuit.

Quelle valeur l'emporte :

  • Une valeur sur la ligne de commande l'emporte sur le fichier, et le fichier l'emporte sur le paramètre enregistré dans la suite (pour cycle_wait_ms et cycle_mode).
  • Une liste sur la ligne de commande (--tag, --report-format) remplace la liste du fichier.
  • Un commutateur sur la ligne de commande l'emporte aussi : --fail-fast false désactive fail_fast: true du fichier.
  • --timeout-minutes sur la ligne de commande l'emporte toujours, même avec la valeur 60.
  • Un project ou brand_logo relatif dans le fichier est lu à partir du dossier du fichier, un out_dir relatif à partir de .tia-tests\reports du dossier du projet. Les autres chemins relatifs sur la ligne de commande, tels que --project ou --brand-logo, sont lus à partir du dossier courant de la commande ; --out-dir est toujours lu à partir de .tia-tests\reports.

Un fichier qui n'est pas du YAML valide, qui est trop volumineux ou qui contient une valeur du mauvais type se termine par le code de sortie 3.

Jenkins (pipeline déclaratif)

pipeline {
  agent { label 'tia-windows' }
  stages {
    stage('Checkout') {
      steps { checkout scm }
    }
    stage('Unit Tests') {
      steps {
        bat 'tia-test-runner run --project "%WORKSPACE%\\Plant.ap20" --out-dir "%WORKSPACE%\\.tia-tests\\reports\\ci" --ci-env-capture'
      }
    }
  }
  post {
    always {
      junit '.tia-tests/reports/ci/**/junit.xml'
      archiveArtifacts artifacts: '.tia-tests/reports/ci/**/*.html', allowEmptyArchive: true
    }
  }
}

GitHub Actions

name: TIA Unit Tests
on: [push]
jobs:
  unit-tests:
    runs-on: [self-hosted, windows, tia]
    steps:
      - uses: actions/checkout@v4
      - name: Run SCL unit tests
        run: tia-test-runner run --project "${{ github.workspace }}\Plant.ap20" --out-dir "${{ github.workspace }}\.tia-tests\reports\ci" --ci-env-capture
      - name: Publish test report
        if: always()
        uses: dorny/test-reporter@v1
        with:
          name: TIA Unit Tests
          path: .tia-tests/reports/ci/**/junit.xml
          reporter: java-junit
      - name: Upload HTML report
        if: always()
        uses: actions/upload-artifact@v4
        with:
          name: tia-html-report
          path: .tia-tests/reports/ci/**/*.html

Azure DevOps

pool:
  name: tia-windows
steps:
  - checkout: self
  - script: tia-test-runner run --project "$(Build.SourcesDirectory)\Plant.ap20" --out-dir "$(Build.SourcesDirectory)\.tia-tests\reports\ci" --ci-env-capture
    displayName: Run SCL unit tests
  - task: PublishTestResults@2
    condition: always()
    inputs:
      testResultsFormat: JUnit
      testResultsFiles: '$(Build.SourcesDirectory)/.tia-tests/reports/ci/**/junit.xml'
      testRunTitle: TIA Unit Tests
  - publish: $(Build.SourcesDirectory)\.tia-tests\reports\ci
    artifact: tia-html-report
    condition: always()

GitLab CI

unit-tests:
  tags: [tia-windows]
  script:
    - tia-test-runner run --project "$CI_PROJECT_DIR\Plant.ap20" --out-dir "$CI_PROJECT_DIR\.tia-tests\reports\ci" --ci-env-capture
  artifacts:
    when: always
    paths:
      - .tia-tests/reports/ci/
    reports:
      junit: .tia-tests/reports/ci/**/junit.xml

Générer un pipeline CI/CD depuis l'application

Au lieu d'écrire les fichiers de configuration à la main, laissez AnyAutomation Studio les générer. Studio produit deux fichiers prêts à être commités pour un projet TIA : un runner.yaml qui contient les valeurs par défaut de la ligne de commande, et un fichier de pipeline pour le système CI de votre choix. Vous les configurez sur la page Pipeline CI, qui affiche les fichiers finis pendant que vous remplissez le formulaire.

Ouvrez la page. Exécutez Générer un pipeline CI depuis la palette de commandes, depuis le menu … de la vue Explorateur de tests unitaires, ou depuis le menu … du Test Bench. La page s'ouvre pour le projet TIA auquel vous êtes connecté. Sans connexion, Studio vous demande d'abord de choisir le fichier de projet. Chaque projet a sa propre page, intitulée Pipeline CI : <projet> ; exécuter à nouveau la commande vous y ramène.

Remplissez le formulaire. La partie gauche de la page comporte ces sections :

Section Ce que vous définissez
Projet Le fichier de projet (affiché, non modifiable), un Dossier du dépôt facultatif (voir ci-dessous), le Nom de l’automate (tant que vous êtes connecté au projet, le champ propose ses automates et renseigne le premier lorsqu'il est vide), un Filtre de suite facultatif, Attente de cycle (ms), Contrôle du cycle (Paramètre de la suite, Temporisé ou Pas à pas ; le pas à pas s'applique aux suites sur PLCSim Advanced, fait de l'attente de cycle le temps de cycle fixe de chaque scrutation, de 1 à 6000 ms, et fait échouer l'exécution pour une suite sur un autre transport) et Capturer l’environnement CI.
Rapports Rapport HTML et XML JUnit (au moins l'un des deux), le Dossier de sortie des rapports dans le dossier de rapports du projet .tia-tests\reports (vide signifie tia-test-results ; le pipeline publie les rapports à partir de là), le Modèle de nom de classe, et sous Image de marque le Titre, le Pied de page et la Couleur d’accent du rapport HTML.
Cible CI Le système CI : GitHub Actions, GitLab CI, Azure DevOps ou Jenkins, et un Libellé de l'agent facultatif qui choisit l'agent de build (voir la remarque sur les agents de build ci-dessous).
Déclencheurs Branches de push et Branches de pull request (séparées par des virgules) facultatives, ainsi qu'une Planification (cron) facultative. Laissez les trois vides pour démarrer le pipeline à la main.
Matrice de build Cellules parallèles facultatives, voir Matrice de build ci-dessous.
Couverture Publier la couverture et trois pourcentages minimaux facultatifs, que vous pouvez renseigner lorsque Publier la couverture est activé. Échouer sur les exigences en échec ou non couvertes ajoute après l'exécution des tests une étape qui vérifie la traçabilité des exigences par rapport à cette exécution, conserve le rapport de traçabilité avec les autres rapports et fait échouer le build ; sous Échouer sur, choisissez les états d'exigence qui le font échouer (Failed et Uncovered par défaut). Avec un filtre de suite, la vérification couvre les mêmes suites que l'exécution des tests.
Runner CI L'indication que le runner en ligne de commande est installé ou non sur cet ordinateur, et Enregistrer le fichier de licence CI (voir Licences pour la CI).

Un champ qui pose problème est signalé et explique ce qu'il faut modifier, par exemple « Saisissez le nom de l'automate. » ou « Une cellule portant ce nom existe déjà. » ; la ligne en bas de la page répète le premier problème.

Suivez les fichiers. La partie droite de la page affiche les fichiers générés. Cliquez sur un nom de fichier au-dessus du texte, ou utilisez les touches fléchées Gauche et Droite, pour basculer entre runner.yaml et le fichier de pipeline. Les fichiers se mettent à jour environ une demi-seconde après la fin de votre saisie. Tant qu'un champ pose problème, l'aperçu affiche à la place « Complétez les champs mis en évidence pour prévisualiser les fichiers. » Faites glisser le séparateur entre le formulaire et l'aperçu pour donner plus de place à l'un ou l'autre côté.

Écrivez les fichiers.

  • Aperçu en tant que fichiers sans titre ouvre les deux fichiers dans des éditeurs non enregistrés, pour que vous puissiez les copier ou les enregistrer ailleurs.
  • Écrire les fichiers enregistre le runner.yaml dans le dossier du projet et le fichier de pipeline dans le dossier du dépôt (le dossier du projet lorsque Dossier du dépôt est vide). Si l'un d'eux existe déjà, une seule question liste tout ce qui serait remplacé ; Annuler n'écrit rien.

Les deux boutons ne sont disponibles que tant que le formulaire ne présente aucun problème. Un champ ne peut pas contenir ${{ ou $(, car votre système CI les évaluerait, et la Planification (cron) nécessite cinq champs (minute, heure, jour du mois, mois, jour de la semaine) ; le message sous le champ vous indique ce qu'il faut modifier. Le runner.yaml est écrit dans le dossier du projet, et le fichier de pipeline au chemin attendu par son système CI dans le dossier du dépôt : .github/workflows/tia-tests.yml pour GitHub Actions, Jenkinsfile pour Jenkins, azure-pipelines.yml pour Azure DevOps et .gitlab-ci.yml pour GitLab CI. Commitez les deux fichiers.

Point de départ de votre dépôt. Le pipeline désigne le fichier de projet, le runner.yaml et les dossiers de rapports par rapport au dossier que l'agent de build extrait. Si votre dépôt commence au dossier du projet, laissez Dossier du dépôt vide. Si le dossier du projet se trouve plus profondément, par exemple comme dossier MixingPlant du dépôt, saisissez le chemin complet du dossier racine du dépôt sur votre ordinateur : le fichier de pipeline y est alors placé, et ses chemins partent de là (MixingPlant/MixingPlant.ap20). Un dossier qui ne contient pas le dossier du projet, ou un chemin sans lecteur, affiche un message sous le champ, et les fichiers ne peuvent pas être écrits.

Vos paramètres sont conservés. Vous pouvez fermer la page à tout moment sans rien perdre : Studio mémorise le formulaire de chaque projet et l'affiche à nouveau la prochaine fois que vous ouvrez la page, même après un redémarrage. Une page ouverte à la fermeture de Studio se rouvre avec lui. Lorsque vous êtes connecté à un autre projet que celui de la page, une ligne en haut indique « Cette page appartient à <project file>. » ; la page continue d'écrire dans son propre dossier de projet.

Quand le pipeline s'exécute. Par défaut, le pipeline généré s'exécute à la demande : lancez-le manuellement depuis votre système CI chaque fois que vous voulez tester. Renseignez Déclencheurs pour l'exécuter aussi automatiquement à chaque push ou pull request vers les branches listées, ou selon une planification cron pour des exécutions nocturnes. (Pour GitLab, la planification elle-même se définit dans l'écran des planifications de pipeline de GitLab ; pour Jenkins, les exécutions de push et de pull request proviennent du webhook de votre dépôt.)

Le pipeline doit s'exécuter sur un agent de build Windows auto-hébergé. Les tests pilotent TIA Portal et PLCSIM : la machine qui exécute le pipeline doit donc disposer de TIA Portal installé, de PLCSIM et d'une licence Pro+ ou supérieure active. Les runners hébergés dans le cloud ne peuvent pas exécuter les tests. Le pipeline généré demande donc un agent Windows auto-hébergé : sur GitHub Actions un runner avec les étiquettes self-hosted et Windows, sur Azure DevOps un agent Windows du pool Default, sur GitLab CI un runner avec le tag windows, sur Jenkins un agent avec l'étiquette windows. Saisissez un Libellé de l'agent sur la page pour utiliser à la place votre propre étiquette, pool ou tag.

L'agent a besoin de bash. L'étape de test des pipelines GitHub Actions, GitLab CI, Azure DevOps et Jenkins générés s'exécute dans bash : un agent de build Windows doit donc avoir Git Bash installé et présent dans le PATH ; un runner GitLab peut garder son shell PowerShell. Un fichier de pipeline généré avec une version antérieure continue de fonctionner tel quel jusqu'à ce que vous le génériez à nouveau.

Matrice de build

Ajoutez une ou plusieurs cellules avec Ajouter une cellule dans l'en-tête de la section Matrice de build : chaque cellule exécute vos suites de tests comme un job parallèle distinct dans le pipeline généré. Utilisez-la pour tester les mêmes suites sur plusieurs projets, ou pour répartir un grand ensemble de suites en tranches parallèles, afin que l'exécution CI complète se termine plus vite et rende compte de chaque cellule séparément.

Chaque cellule est une ligne du tableau :

  • Nom (obligatoire) : un libellé court composé de lettres, de chiffres, de _ ou de -, unique dans la matrice. Une nouvelle cellule commence avec un nom libre tel que cell1.
  • Fichier de projet (facultatif) : laissez-le vide pour utiliser le projet de la page, ou dirigez la cellule vers un autre fichier de projet. Indiquez-le relativement au dossier du dépôt (le dossier du projet de la page lorsque Dossier du dépôt est vide), par exemple Cells/A/A.ap20 ; un chemin complet doit se trouver dans ce dossier ou en dessous, sinon un message sous le champ le signale et les fichiers ne peuvent pas être écrits.
  • Filtre de suite (facultatif) : n'exécute que certaines des suites dans cette cellule. Laissez-le vide pour toutes les exécuter.

Supprimez une cellule avec l'icône de suppression en fin de ligne. Chaque cellule écrit ses résultats dans son propre dossier de rapports, de sorte que les cellules ne s'écrasent jamais et que vous pouvez les comparer côte à côte. La matrice de build est disponible pour les quatre systèmes CI. La laisser vide produit le pipeline normal à exécution unique.

Licences pour la CI

Les tests unitaires sont une fonctionnalité Pro+ (Pro+ et supérieur) : le runner vérifie donc votre licence avant toute opération. Un agent de build obtient sa licence au moyen d'un fichier de licence CI que vous enregistrez depuis Studio et remettez à l'agent.

Enregistrez le fichier. Dans Studio, exécutez Générer un pipeline CI, cliquez sur Enregistrer le fichier de licence CI dans la section Runner CI de la page Pipeline CI, puis choisissez un emplacement. Vous devez être connecté avec une licence Pro+ active.

Remettez-le à l'agent. Placez le fichier sur l'agent et indiquez-le au runner :

tia-test-runner run --license-offline "C:\agent\anyautomation-ci.json" --project "C:\Projects\Plant\Plant.ap20" --out-dir "C:\Projects\Plant\.tia-tests\reports\ci"

ou stockez le contenu du fichier dans une variable de pipeline masquée nommée ANYAUTOMATION_CI_ENTITLEMENT, soit tel qu'il a été enregistré, soit encodé en base64 (certains systèmes CI ne masquent que les valeurs base64 sur une seule ligne). Le runner lit cette variable lorsqu'aucun chemin n'est indiqué.

Le chemin --license-offline doit pointer vers un lecteur local de l'agent ; un chemin de partage réseau (\server...) est refusé. Si le fichier se trouve sur un partage, copiez-le sur l'agent ou utilisez plutôt la variable.

Traitez le fichier comme un secret. Il contient vos droits d'utilisation : quiconque l'obtient peut exécuter les verbes sous licence. Stockez-le dans une variable masquée ou secrète, ne l'affichez jamais dans un journal de build et ne le commitez pas dans votre dépôt.

Le fichier cesse de fonctionner à la fin de votre abonnement, et dans tous les cas 90 jours après son enregistrement. Enregistrez-en un nouveau depuis Studio lorsqu'un pipeline signale une licence expirée. Le fichier fonctionne sur n'importe quel agent de build ; le runner le vérifie sur l'agent lui-même et n'a pas besoin de connexion Internet pour cela.

--license-key n'est plus accepté et se termine avec le code 3. Utilisez plutôt le fichier de licence.

Ces verbes n'ont pas besoin de fichier de licence : version, verify et validate. verify reste volontairement ouvert pour que vous puissiez revérifier l'intégrité d'un rapport de réception archivé des années plus tard, y compris après la fin d'un abonnement, et validate est un simple contrôle de schéma que vous pouvez exécuter dans un hook de pre-commit.

Accès réseau

Le runner ne contacte aucun serveur de licences : il vérifie le fichier de licence CI sur l'agent, aucun paramètre de proxy n'est donc nécessaire pour la licence. Il se connecte uniquement à ce que vos suites indiquent (TIA Portal et PLCSim sur l'agent, le serveur OPC UA ou l'automate d'une suite).

Environnements pris en charge

  • Windows 11 (poste de travail)

    Pris en charge ?
    Oui
    Remarques
    Environnement de référence.
  • Windows Server 2022 avec Expérience de bureau (Desktop Experience)

    Pris en charge ?
    Oui
    Remarques
    TIA Portal et PLCSIM Advanced nécessitent une session de bureau interactive.
  • Windows Server Core

    Pris en charge ?
    Non
    Remarques
    TIA Portal Openness a besoin du shell de bureau complet ; l'installation headless Server Core ne le fournit pas.
  • Docker / conteneur Windows

    Pris en charge ?
    Non
    Remarques
    TIA Portal et PLCSIM Advanced ne sont pas pris en charge dans des conteneurs.

Dépannage des exécutions CI

Symptôme Cause et solution
Code de sortie 3, "--project is required" Un argument obligatoire est manquant ou la configuration YAML n'a pas pu être lue. Vérifiez les chemins --project, --out-dir et --config.
Code de sortie 2, message de licence L'agent n'a pas de fichier de licence CI valide. Enregistrez-en un nouveau depuis Studio et indiquez-le au runner, ou définissez la variable masquée ANYAUTOMATION_CI_ENTITLEMENT.
Code de sortie 3, "--out-dir resolves under a protected Windows directory" ou "--out-dir must lie inside the reports folder ... of the project" --out-dir pointe en dehors de .tia-tests\reports du dossier du projet. Indiquez un dossier relatif tel que ci, qui part de là.
Code de sortie 3, "No suites found for PLC ..." ou "No test case of the selected suites matches the case filters" (aucun cas de test ne correspond aux filtres) --plc, --tag, --priority-min ou --owner ne sélectionne rien. Vérifiez le nom d'automate des suites ainsi que les tags, la priorité et le responsable des cas de test.
Code de sortie 4, délai dépassé L'exécution a dépassé --timeout-minutes. Augmentez la limite ou divisez les grandes suites ; vérifiez que la connexion à l'automate est joignable depuis l'agent.
Aucun rapport de test n'apparaît dans la CI L'étape du rapporteur de tests ne pointe pas vers junit.xml, ou elle ne s'exécute qu'en cas de succès. Publiez les rapports avec une condition always()/when: always et dirigez-la vers **/junit.xml sous le dossier de rapports de l'exécution.

Confidentialité

Ni la CLI ni l'interface ne collectent de télémétrie. Les variables CI présentées dans les rapports ne sont enregistrées que si vous l'activez avec --ci-env-capture, et les rapports ne révèlent pas le chemin du projet. Les rapports HTML satisfont au niveau WCAG 2.1 AA, vérifié par des contrôles automatisés ; une validation manuelle avec lecteur d'écran (NVDA) fait partie du test de bout en bout de chaque version.