Partager via

Test d'une grande application avec plusieurs mappages d'IU

  • Article

Cette rubrique explique comment utiliser des tests codés de l'interface utilisateur lorsque vous testez une application volumineuse à l'aide de plusieurs mappages d'IU.

Configuration requise

  • Visual Studio Ultimate, Visual Studio Premium

Lorsque vous créez un test codé de l'interface utilisateur, l'infrastructure de test Visual Studio génère par défaut le code du test dans une classe UIMap.Pour plus d'informations sur l'enregistrement des tests codés de l'interface utilisateur, consultez Créer des tests codés de l'interface utilisateur et Anatomie d'un test codé de l'interface utilisateur.

Le code généré du mappage d'IU contient une classe pour chaque objet avec lequel le test interagit.Pour chaque méthode générée, une classe auxiliaire des paramètres de méthode est générée spécifiquement pour cette méthode.Si votre application contient un grand nombre d'objets, de pages, de formulaires et de contrôles, le mappage d'IU peut devenir volumineux.En outre, si plusieurs personnes travaillent sur les tests, l'application devient complexe avec un seul fichier de mappage d'IU volumineux.

À l'aide de plusieurs fichiers de mappage d'IU, vous pouvez fournir les avantages suivants :

  • Chaque plan peut être associé à un sous-ensemble logique de l'application.Cela simplifie la gestion des modifications.

  • Chaque testeur peut travailler sur une partie de l'application et archiver leur code sans interférer avec les autres testeurs qui travaillent sur d'autres parties de l'application.

  • Les ajouts apportés à l'interface utilisateur de 'application peuvent être mis à l'échelle de façon incrémentielle avec un effet minime sur les tests des autres parties de l'interface utilisateur.

Avez besoin-vous de plusieurs mappages d'interface utilisateur ?

Créez plusieurs mappages d'IU dans chacune des situations suivantes :

  • Plusieurs ensembles complexes de contrôles d'IU composites qui ensemble exécutent une opération logique, telle qu'une page d'inscription sur un site Web ou la page d'un panier d'achat.

  • Ensemble indépendant de contrôles accessibles à partir de différents points de l'application, par exemple un Assistant avec plusieurs pages d'opérations.Si chaque page d'un Assistant est particulièrement complexe, vous pouvez créer des mappages d'IU distincts pour chaque page.

Ajout de plusieurs mappages d'IU

Pour ajouter un mappage d'IU à votre projet de test d'UI codée.

  1. Dans l'Explorateur de solutions, pour créer un dossier dans votre projet de test d'UI codée pour y stocker tous les mappages d'IU, cliquez avec le bouton droit sur le fichier de projet de test d'UI codée, pointez sur Ajouter, puis cliquez sur Nouveau dossier.Par exemple, vous pouvez le nommer UIMaps.

    Le nouveau dossier s'affiche sous le projet de test d'UI codée.

  2. Cliquez avec le bouton droit sur le dossier UIMaps, pointez sur Ajouter, puis cliquez sur Nouvel élément.

    La boîte de dialogue Ajouter un nouvel élément s'affiche.

    [!REMARQUE]

    Vous devez être dans un projet de test d'UI codée pour ajouter un nouveau plan de test codé de l'interface utilisateur.

  3. Sélectionnez Mappage de test codé de l'interface utilisateur dans la liste.

    Dans la zone Nom, entrez un nom pour le nouveau mappage d'IU.Utilisez le nom du composant ou de la page que le plan représente, par exemple, HomePageMap.

  4. Sélectionnez Ajouter.

    La fenêtre Visual Studio est réduite et la boîte de dialogue Générateur de test codé de l'interface utilisateur s'affiche.

  5. Enregistrez les actions pour la première méthode et cliquez sur Générer le code.

  6. Après avoir enregistré toutes les actions et assertions pour le premier composant ou la première page et que vous les avez regroupés dans des méthodes, fermez la boîte de dialogue Générateur de test codé de l'interface utilisateur.

  7. Continuez à créer les mappages d'IU.Enregistrez les actions et les assertions, regroupez-les dans les méthodes de chaque composant, puis générez le code.

Dans de nombreux cas, la fenêtre de niveau supérieur de votre application reste constante pour tous les Assistants, formulaires et pages.Même si chaque mappage d'IU possède une classe pour la fenêtre de niveau supérieur, tous les plans font référence probablement à la même fenêtre de niveau supérieur dans laquelle tous les composants de votre application sont exécutés.Les tests codés de l'interface utilisateur recherchent les contrôles de manière hiérarchique du haut vers le bas, en commençant par la fenêtre de niveau supérieur, et donc dans une application complexe, la véritable fenêtre de niveau supérieur peut être dupliquée dans chaque mappage d'IU.Si la fenêtre de niveau supérieur réelle est dupliquée, plusieurs modifications sont effectuées si cette fenêtre change.Cela peut nuire aux performances lorsque vous basculez entre les pages d'IU.

Pour réduire cet effet, vous pouvez utiliser la méthode CopyFrom() pour vous assurer que la nouvelle fenêtre de niveau supérieur dans ce mappage d'IU est identique à la fenêtre de niveau supérieur principale.

Exemple

L'exemple suivant fait partie d'une classe utilitaire qui fournit l'accès à chaque composant et à leurs contrôles enfants représentés par les classes générées dans les différents mappages d'IU.

Dans cet exemple, une application Web nommée Contoso présente une page d'accueil, une page de produit et une page de panier d'achat.Chacune de ces pages partage une fenêtre de niveau supérieur commune qui est la fenêtre du navigateur.Chaque page est associée à un mappage d'IU et la classe utilitaire contient du code semblable à l'exemple suivant :

using ContosoProject.UIMaps;
using ContosoProject.UIMaps.HomePageClasses;
using ContosoProject.UIMaps.ProductPageClasses;
using ContosoProject.UIMaps.ShoppingCartClasses;

namespace ContosoProject
{
    public class TestRunUtility
    {
        // Private fields for the properties
        private HomePage homePage = null;
        private ProductPage productPage = null;
        private ShoppingCart shoppingCart = null;

        public TestRunUtility()
        {
            homePage = new HomePage();
        }

        // Properties that get each UI Map
        public HomePage HomePage
        {
            get { return homePage; }
            set { homePage = value; }
        }

        // Gets the ProductPage from the ProductPageMap.
        public ProductPage ProductPageObject
        {
            get
            {
                if (productPage == null)
                {
                    // Instantiate a new page from the UI Map classes
                    productPage = new ProductPage();

                    // Since the Product Page and Home Page both use
                    // the same browser page as the top level window,
                    // get the top level window properties from the
                    // Home Page.
                    productPage.UIContosoFinalizeWindow.CopyFrom(
                        HomePage.UIContosoWindowsIWindow);
                }
                return productPage;
            }
        }

    // Continue to create properties for each page, getting the 
    // page object from the corresponding UI Map and copying the 
    // top level window properties from the Home Page.
}

Voir aussi

Référence

UIMap

CopyFrom

Concepts

Vérification du code à l'aide de tests codés de l'interface utilisateur

Anatomie d'un test codé de l'interface utilisateur

Autres ressources

Créer des tests codés de l'interface utilisateur