FormNexus : Une nouvelle façon de tester les formulaires web

Les Tests automatisés pour les formulaires web ont toujours été un vrai défi à cause de la manière dont ces formulaires sont conçus pour être utilisés par des humains et de leurs designs compliqués qui doivent fonctionner sur différents appareils. Cet article présente une nouvelle méthode appelée FormNexus pour générer des tests automatisés pour les formulaires web. Cette méthode se concentre sur la compréhension du sens des éléments individuels du formulaire et de leurs relations entre eux. En regardant le texte utilisé, la structure du modèle d'objet (DOM) et l'agencement des éléments, FormNexus vise à recueillir des informations utiles. Ces informations sont organisées dans ce qu'on appelle le Graphique de Relation d'Entités de Formulaire (FERG), qui aide les ordinateurs à mieux comprendre les infos dans les formulaires.

FormNexus utilise aussi de Grands Modèles de Langage (LLMs) pour créer un processus qui s'améliore avec le temps. Ce processus aide à générer et affiner les règles nécessaires pour les entrées en fonction des réponses obtenues lors de la soumission des formulaires. En fin de compte, cette méthode produit un ensemble complet de cas de test qui évaluent minutieusement les formulaires web en testant systématiquement les entrées invalides. Nos résultats montrent que FormNexus, couplé avec GPT-4, couvre plus d'états de soumission de formulaire que les modèles existants.

Dans le monde numérique d'aujourd'hui, les applications web sont essentielles pour nos tâches quotidiennes. Ces applications sont devenues de plus en plus complexes, permettant aux utilisateurs d'interagir de manière avancée. Un aspect clé de cette interaction se fait à travers des formulaires, qui sont cruciaux pour collecter des infos utilisateur et faciliter la communication entre utilisateurs et logiciels. Vu leur importance, il est essentiel de tester ces formulaires de manière rigoureuse pour s'assurer qu'ils fonctionnent correctement.

Bien qu'il y ait eu des améliorations dans les méthodes de test des applications web, le domaine des tests de formulaire reste encore peu exploré. La création de valeurs d'entrée et de cas de test pour les formulaires pose un ensemble unique de défis. Comme les formulaires sont conçus pour l'interaction humaine, générer des valeurs appropriées nécessite une compréhension des spécificités de chaque champ d'entrée : reconnaître ce que chaque champ signifie et comment ils se connectent. La complexité augmente avec le Document Object Model (DOM) qui ajoute un niveau de difficulté supplémentaire, pouvant éclipser les significations originales du formulaire. De plus, le besoin pour les applications web de fonctionner sans accroc sur différents appareils complique la conception des structures HTML, rendant les tests plus difficiles.

Il y a un besoin croissant de comprendre les significations des formulaires pour une génération de tests automatisés efficace, ce qui fait des techniques de traitement du langage naturel (NLP) une solution prometteuse. Avec les avancées récentes dans des LLMs comme GPT-4 et Llama-2, la gamme de méthodes possibles s'est élargie de manière significative. Ces LLMs peuvent imiter la compréhension et la génération de langage de type humain, offrant une nouvelle manière d'aborder la tâche. Des études récentes ont déjà utilisé des LLMs pour des tâches comme la création de tests unitaires et le remplissage de formulaires d'applications mobiles, ouvrant de nouvelles possibilités pour s'attaquer aux complexités de la génération de tests automatisés pour les formulaires web.

Cet article introduit FormNexus, une technique novatrice conçue pour générer des tests pour les formulaires web grâce aux LLMs. Au cœur de cette méthode, on traite des complexités liées à la compréhension du contexte des champs d'entrée. Nous faisons cela en transformant la mise en page du formulaire dans le DOM en une structure plus organisée appelée le Graphique de Relation d'Entités de Formulaire. Cette nouvelle structure clarifie les significations et les relations des éléments du formulaire, ce qui les rend plus adaptés à l'interprétation par les machines. Pour parvenir à cette transformation, nous analysons les caractéristiques de chaque nœud, y compris le texte et sa position dans la hiérarchie DOM. En fonction de ces facteurs, nous identifions des similitudes entre différents nœuds et établissons des relations potentielles, ce qui fournit des aperçus sur les significations des entrées individuelles et les connexions qui existent entre elles.

Une fois que les relations sémantiques entre les éléments du formulaire sont définies, nous appliquons un processus basé sur le retour d'information qui prend ces connexions et utilise les LLMs pour créer des cas de test pour le formulaire. Le processus commence par déterminer des règles initiales basées sur les liens sémantiques, puis génère des valeurs d'entrée selon ces règles. L'étape suivante consiste à vérifier ces règles, à les modifier si nécessaire et à générer de nouvelles valeurs d'entrée pour soumettre le formulaire sous ces règles ajustées. Notre objectif est de confirmer les règles en analysant les retours reçus après les soumissions. Une fois que les règles sont validées, elles sont transformées en un ensemble solide de cas de test qui peuvent être utilisés pour vérifier le fonctionnement du formulaire au fil du temps.

Pour évaluer la performance de FormNexus, nous utilisons diverses applications réelles et open source, en utilisant GPT-4 comme LLM. Les résultats montrent que FormNexus combiné avec GPT-4 obtient la meilleure performance en couvrant les états de soumission de formulaire, surpassant de manière significative le modèle comparable le plus proche.

Les applications web aujourd'hui sont intégrales à nos interactions quotidiennes, grandissant en complexité et permettant un engagement utilisateur sophistiqué. Une partie cruciale de cet engagement se produit via des formulaires, qui collectent des informations utilisateur et établissent une communication entre utilisateurs et applications. Par conséquent, il est essentiel de tester rigoureusement ces formulaires pour garantir leur précision et leur fiabilité.

Bien qu'il y ait eu des améliorations dans les méthodologies de test, le domaine de la génération de tests de formulaire reste encore peu exploré. La création de valeurs d'entrée et de cas de test pour les formulaires pose des défis uniques en raison de leur conception pour l'interaction humaine. Générer des valeurs appropriées nécessite de comprendre la sémantique des champs d'entrée et les relations entre eux. Dans le contexte de la génération de tests boîte noire pour les formulaires web, les complexités introduites par le DOM peuvent souvent masquer les significations inhérentes du formulaire.

La flexibilité du codage qui permet des affichages visuellement similaires complique encore l'architecture des formulaires web. La tendance visant à ce que les applications web soient agnostiques aux appareils impacte également la conception HTML, créant des défis supplémentaires pour le test automatisé des formulaires web.

Pour générer des entrées appropriées pour la génération de tests automatisés, il est vital de saisir la sémantique des éléments du formulaire. L'utilisation de techniques NLP pour la génération d'entrées se révèle être une approche prometteuse. L'introduction de LLMs comme GPT-4 et Llama-2 a significativement élargi le potentiel des méthodologies. La capacité des LLMs à reproduire le traitement et la génération du langage de type humain offre une nouvelle avenue pour s'attaquer à ce domaine. Plusieurs études ont déjà exploré l'application des LLMs à travers diverses tâches, démontrant leur polyvalence dans la génération d'entrées et les tests.

Dans cet article, nous présentons FormNexus, une méthode indépendante des LLMs spécifiquement créée pour générer des tests pour les formulaires web. Cette technique s'attaque aux complexités de la compréhension des contextes des champs d'entrée en réorganisant le DOM du formulaire en le Graphique de Relation d'Entités de Formulaire. Cette transformation améliore l'information contextuelle pour chaque champ d'entrée et capture comment les entités de formulaire pertinentes sont liées les unes aux autres.

S'appuyer uniquement sur des attributs textuels ou structurels des éléments de formulaire peut ne pas révéler de manière exhaustive leurs interconnexions. Nous émettons l'hypothèse que la combinaison de ces attributs produira une compréhension plus claire des connexions entre les éléments, comparé à les examiner séparément. Pour y parvenir, nous utilisons des techniques d'embedding pour fusionner des caractéristiques individuelles, ce qui aide à répondre à leurs limitations uniques. Ces embeddings combinés sont utilisés pour découvrir des relations potentielles parmi les éléments de formulaire, résultant en un graphique qui illustre la nature interconnectée de ces éléments.

La première étape de la construction du graphique implique la mise en place d'un espace d'embedding pour les éléments au sein du formulaire. Nous commençons par générer des embeddings textuels et structurels pour les éléments non conteneurs, qui sont définis comme ceux qui contiennent du texte ou qui servent d'éléments d'entrée. Pour la génération d'embeddings textuels, nous utilisons des embeddings ADA, tandis que la méthode node2vec est employée pour éclaircir les relations structurelles dans l'arbre DOM. Chaque nœud dans l'arbre DOM se voit attribuer un vecteur d'embedding unique.

En itérant sur les nœuds pertinents de l'arbre DOM, nous calculons des embeddings textuels et structurels. Nous combinons ces embeddings pour créer un espace d'embedding qui reflète la similarité entre différents nœuds. Par exemple, les nœuds qui sont structurellement proches et partagent un texte similaire devraient se regrouper dans cet espace.

Le premier type de contexte que nous clarifions est le contexte textuel local, qui inclut tout texte qui clarifie un champ d'entrée, comme des étiquettes ou des retours d'information. Ces relations aident grandement à comprendre la nature de chaque entrée.

Par exemple, les éléments textuels liés à un champ d'entrée sont généralement positionnés assez près les uns des autres. Cette proximité permet une association facile entre le champ d'entrée et son texte associé, ce qui est crucial pour une interprétation précise. Ainsi, nous commençons par connecter les éléments qui bordent visuellement les uns les autres à cette étape de notre méthodologie.

Ensuite, nous calculons les similarités cosinus entre les champs d'entrée et leurs éléments textuels adjacents. Ces calculs forment un graphique où les nœuds représentent des éléments au sein du formulaire, et les arêtes connectent des éléments visuellement liés. Le poids de ces arêtes est déterminé par la similarité cosinus entre les vecteurs d'embedding des éléments.

Cependant, être voisins ne garantit pas une relation significative. Par exemple, un texte de retour qui borde un champ d'entrée peut ne pas s'appliquer à celui-ci. Ainsi, après avoir formé le graphique initial, nous appliquons un processus de nettoyage. Nous catégorisons les nœuds au sein du formulaire comme étant des entités principales ou auxiliaires. Les champs d'entrée sont vus comme des entités principales, tandis que les éléments auxiliaires dépendent de la présence de champs d'entrée pour leur signification.

Lors de la phase de nettoyage, nous examinons les nœuds auxiliaires et leurs arêtes connectées pour nous assurer que seules les associations les plus fortes restent dans le graphique. En filtrant les connexions avec des scores de similarité plus bas, nous affinons le graphique pour mieux représenter les relations significatives entre les éléments.

Après avoir développé le contexte textuel pour chaque champ d'entrée, l'étape suivante consiste à découvrir des entrées liées qui partagent des connexions. Les champs d'entrée qui sont interconnectés partagent souvent un contexte textuel similaire et sont généralement situés près les uns des autres. Comprendre ces relations est intuitif pour les humains, mais cela pose des défis pour les systèmes informatiques qui doivent reconnaître les relations d'entrée.

Nous utilisons les embeddings créés plus tôt pour évaluer le degré d'interconnexion entre des groupes de champs d'entrée. Le score de relation entre deux champs d'entrée est défini sur la base des scores de similarité maximum obtenus à partir des comparaisons champ-à-champ et étiquette-à-étiquette.

Reconnaître que les connexions entre les champs d'entrée ne signifient pas toujours des relations obligatoires nous permet d'adopter une approche statistique pour identifier et séparer les connexions significatives de celles qui pourraient manquer de pertinence.

Avec le contexte établi, notre prochain objectif est d'inférer une série de contraintes qui s'alignent sur les caractéristiques et les relations des champs d'entrée. Un processus itératif consiste à interroger le graphique construit pour extraire des éléments pertinents pour chaque champ d'entrée. Nous créons des invites basées sur ces informations et chargeons le LLM de générer des contraintes et des valeurs.

Les contraintes générées initialement guident notre compréhension des exigences de chaque champ d'entrée. En offrant des informations contextuelles pertinentes, nous anticipons que le LLM agira de manière similaire à une inférence humaine.

Après avoir généré des contraintes, l'étape suivante consiste à générer des valeurs basées sur ces contraintes. Le contexte du formulaire, le champ d'entrée spécifique et le contexte local sont fournis comme orientation pour le LLM. De cette manière, le LLM est dirigé pour créer des valeurs d'entrée appropriées conformes aux contraintes définies.

Une fois que nous avons un ensemble de valeurs d'entrée, nous soumettons le formulaire pour observer les résultats. Le formulaire peut soit rester sur la même page, soit rediriger vers une nouvelle. Dans les deux cas, nous recherchons des indicateurs textuels qui signalent si la soumission a réussi ou échoué.

Pour évaluer le succès ou l'échec de la soumission du formulaire, nous définissons des critères simples. Une soumission réussie déplace l'utilisateur vers la destination prévue, tandis qu'un échec génère un retour d'erreur. Nous utilisons une méthode heuristique pour évaluer l'état du formulaire après la soumission. Cette méthode consiste à examiner les différences dans l'arbre DOM avant et après la soumission, en filtrant les résultats pour les indicateurs généralement associés aux messages de retour d'information.

Une fois le formulaire soumis, nous pouvons reconnecter les retours à leurs champs d'entrée respectifs en utilisant le contexte local établi. Cependant, il peut y avoir des cas de retour global qui s'appliquent à plusieurs champs. Tout retour qui n'est pas lié à un champ d'entrée spécifique est traité comme un retour global et intégré dans le processus de raffinement des contraintes.

En utilisant les retours reçus lors de la soumission, nous pouvons affiner nos contraintes pour nous assurer qu'elles reflètent fidèlement les exigences du formulaire. Ce processus de mise à jour des contraintes conduit à la génération de nouvelles valeurs, qui sont soumises à nouveau. Ce cycle continue jusqu'à ce que nous obtenions une soumission de formulaire réussie, signalant que nos contraintes dérivées correspondent aux besoins réels du formulaire.

Après des soumissions réussies, nous enregistrons diverses valeurs d'entrée et les retours reçus comme cas de test potentiels pour un usage futur. Chaque cas de test est structuré pour confirmer que le formulaire peut fonctionner correctement sous différentes conditions d'entrée. Ce processus permet une couverture exhaustive des états de soumission de formulaire.

Notre méthode de génération de tests automatisés a été mise en œuvre en Python et s'intègre parfaitement avec des LLMs avancés. Pour générer des embeddings textuels, nous avons utilisé l'architecture ADA et l'implémentation standard de node2vec pour capturer la structure sous-jacente du graphique.

Dans l'évaluation de notre technique, nous avons formulé des questions de recherche pour mesurer l'efficacité de notre approche. Nous avons cherché à déterminer à quel point notre méthode était efficace pour générer des tests pour les formulaires web, comment elle se comparait à d'autres techniques, et quelles contributions des composants spécifiques ont été apportées aux résultats finaux.

Étant donné le manque de jeux de données publiquement disponibles pour les valeurs de formulaire et les états de soumission, nous avons constitué et annoté une liste de formulaires web. Nous avons sélectionné des formulaires représentant divers domaines d'applications web et veillé à ce qu'ils incluent une validation des valeurs d'entrée pour évaluer la performance de notre technique.

Pour évaluer l'efficacité de notre méthode, nous avons mesuré le nombre d'états de soumission de formulaire couverts, ce qui inclut à la fois des soumissions réussies et échouées. En soumettant systématiquement des valeurs variées et en capturant des retours, nous avons cherché à développer une compréhension complète des exigences de chaque formulaire.

Bien que le processus de génération de tests pour les formulaires web soit peu exploré, notre approche démontre des avancées notables par rapport aux méthodes existantes. Nous avons constaté que notre technique améliore considérablement la couverture des états de soumission de formulaire par rapport aux méthodes statiques et aux robots web qui génèrent des valeurs aléatoires.

L'application et les taux de succès des cas de test générés indiquent l'efficacité de notre méthode. Notre approche permet une exploration plus profonde des comportements des formulaires et améliore la précision des tests automatisés pour les formulaires web.

Malgré ses avantages, notre méthode fait face à des limitations, en particulier dans les cas où les retours d'erreur manquent de spécificité ou de pertinence. Traiter ces problèmes pourrait améliorer les futures itérations de notre approche. Néanmoins, FormNexus a montré un potentiel considérable pour découvrir divers états de soumission et offre un cadre de base pour la recherche continue dans les tests automatisés de formulaires web.

À travers ces constatations, nous pouvons clairement voir le potentiel qui existe dans l'amélioration des méthodes de tests automatisés pour les formulaires web. Combler les lacunes actuelles dans les tests de formulaires peut conduire à de meilleures performances logicielles, une satisfaction utilisateur accrue et moins d'erreurs dans les applications web.