Test des applications Windows Phone avec des tests codés de l'interface utilisateur

Utilisez des tests codés de l'interface utilisateur pour tester vos applications Windows Phone.

Créer une application Windows Phone simple

1. Créer un projet pour une application Windows Phone vide à l'aide d'un modèle Visual C# ou Visual Basic.

   

2. Dans l'Explorateur de solutions, ouvrez MainPage.xaml.Dans la barre d'outils, faites glisser un contrôle bouton et un contrôle textbox sur l'aire de conception.

   

3. Dans la fenêtre Propriétés, nommez le contrôle bouton.

   

4. Nommez le contrôle textbox.

   

5. Sur l'aire de conception, double-cliquez sur le contrôle bouton et ajoutez le code suivant :

   private void button_Click_1(object sender, RoutedEventArgs e)
   {
       this.textBox.Text = this.button.Name;
   }
   

   Public NotInheritable Class MainPage
       Inherits Page
   
       Private Sub button_Click(sender As Object, e As RoutedEventArgs) Handles Button.Click
           Me.textBox.Text = Me.button.Name
       End Sub
   End Class
   

6. Appuyez sur F5 pour exécuter votre application Windows Phone dans l'émulateur et vérifier si elle fonctionne.

   

7. Quittez l'émulateur.

Déployer l'application Windows Phone

• Pour qu'un test codé de l'interface utilisateur puisse mapper les contrôles d'une application, vous devez la déployer.

  

  L'émulateur démarre.L'application est maintenant disponible pour les tests.

  

  Laissez l'émulateur en cours d'exécution pendant que vous créez votre test codé de l'interface utilisateur.

Créer un test codé de l'interface utilisateur pour l'application Windows Phone

1. Ajoutez un nouveau projet de test codé de l'interface utilisateur à la solution avec l'application Windows Phone.

   

2. Choisissez de modifier le mappage d'IU à l'aide de la croix.

   

3. Utilisez la croix pour sélectionner l'application, puis copiez la valeur de la propriété AutomationId de l'application, qui sera utilisée ultérieurement pour démarrer l'application lors du test.

   

4. Dans l'émulateur, démarrez l'application et utilisez la croix pour sélectionner le contrôle bouton.Ensuite, ajoutez le contrôle bouton au mappage de contrôle d'IU.

   

5. Pour ajouter le contrôle textbox au mappage de contrôle d'interface utilisateur, répétez l'étape précédente.

   

6. Générez le code pour créer le code pour les modifications apportées au mappage de contrôle d'interface utilisateur.

   

7. Utilisez la croix pour sélectionner le contrôle textbox, puis sélectionnez la propriété Texte.

   

8. Ajoutez une assertion.Elle sera utilisée lors du test pour vérifier que la valeur est correcte.

   

9. Ajoutez et générez le code pour la méthode assert.

   

10. Visual C#

    Dans l'Explorateur de solutions, ouvrez le fichier UIMap.Designer.cs pour afficher le code que vous venez d'ajouter pour la méthode assert et les contrôles.

    Visual Basic

    Dans l'Explorateur de solutions, ouvrez le fichier CodedUITest1.vb.Dans le code de la méthode de test CodedUITestMethod1(), cliquez avec le bouton droit sur l'appel à la méthode d'assertion qui a été ajouté automatiquement Me.UIMap.AssertMethod1() et choisissez Atteindre la définition.Le fichier UIMap.Designer.vb s'ouvre dans l'éditeur de code, ce qui vous permet de voir le code que vous avez ajouté pour la méthode assert et les contrôles.

    Attention
    Ne modifiez pas le fichier UIMap.Designer.cs ou UIMap.Designer.vb directement.Si vous le faites, les modifications apportées au fichier seront remplacées à chaque génération du test.

    Méthode Assert

    public void AssertMethod1()
    {
        #region Variable Declarations
        XamlEdit uITextBoxEdit = this.UIApp1Window.UITextBoxEdit;
        #endregion
    
        // Verify that the 'Text' property of 'textBox' text box equals 'button'
        Assert.AreEqual(this.AssertMethod1ExpectedValues.UITextBoxEditText, uITextBoxEdit.Text);
    }
    

    Public Sub AssertMethod1()
        Dim uITextBoxEdit As XamlEdit = Me.UIApp1Window.UITextBoxEdit
    
        'Verify that the 'Text' property of 'textBox' text box equals 'button'
        Assert.AreEqual(Me.AssertMethod1ExpectedValues.UITextBoxEditText, uITextBoxEdit.Text)
    End Sub
    

    Contrôles

    #region Properties
    public virtual AssertMethod1ExpectedValues AssertMethod1ExpectedValues
    {
        get
        {
            if ((this.mAssertMethod1ExpectedValues == null))
            {
                this.mAssertMethod1ExpectedValues = new AssertMethod1ExpectedValues();
            }
            return this.mAssertMethod1ExpectedValues;
        }
    }
    
    public UIApp1Window UIApp1Window
    {
        get
        {
            if ((this.mUIApp1Window == null))
            {
                this.mUIApp1Window = new UIApp1Window();
            }
            return this.mUIApp1Window;
        }
    }
    #endregion
    
    #region Fields
    private AssertMethod1ExpectedValues mAssertMethod1ExpectedValues;
    
    private UIApp1Window mUIApp1Window;
    #endregion
    

    #Region "Properties"
    Public ReadOnly Property UIButtonButton() As XamlButton
        Get
            If (Me.mUIButtonButton Is Nothing) Then
                Me.mUIButtonButton = New XamlButton(Me)
                Me.mUIButtonButton.SearchProperties(XamlButton.PropertyNames.AutomationId) = "button"
            End If
            Return Me.mUIButtonButton
        End Get
    End Property
    
    Public ReadOnly Property UITextBoxEdit() As XamlEdit
        Get
            If (Me.mUITextBoxEdit Is Nothing) Then
                Me.mUITextBoxEdit = New XamlEdit(Me)
                Me.mUITextBoxEdit.SearchProperties(XamlEdit.PropertyNames.AutomationId) = "textBox"
            End If
            Return Me.mUITextBoxEdit
        End Get
    End Property
    #End Region
    
    #Region "Fields"
    Private mUIButtonButton As XamlButton
    
    Private mUITextBoxEdit As XamlEdit
    #End Region
    

11. Dans l'Explorateur de solutions, ouvrez le fichier CodedUITest1.cs ou CodedUITest1.vb.Vous pouvez maintenant ajouter du code à la méthode CodedUTTestMethod1 pour les actions nécessaires à l'exécution du test.Utilisez les contrôles qui ont été ajoutés au mappage d'IU pour ajouter du code :

    1. Lancez l'application Windows Phone à l'aide de la propriété d'ID d'automation que vous avez copiée précédemment dans le Presse-papiers :

       XamlWindow myAppWindow = XamlWindow.Launch("ed85f6ff-2fd1-4ec5-9eef-696026c3fa7b_cyrqexqw8cc7c!App");
       

       XamlWindow.Launch("ed85f6ff-2fd1-4ec5-9eef-696026c3fa7b_cyrqexqw8cc7c!App");
       

    2. Ajoutez un mouvement pour appuyer sur le contrôle bouton :

       Gesture.Tap(this.UIMap.UIApp1Window.UIButtonButton);
       

       Gesture.Tap(Me.UIMap.UIApp1Window.UIButtonButton)
       

    3. Vérifiez que l'appel à la méthode assert généré automatiquement se produit après le lancement de l'application et le mouvement d'appui sur le bouton :

       this.UIMap.AssertMethod1();
       

       Me.UIMap.AssertMethod1()
       

    Une fois le code ajouté, la méthode de test CodedUITestMethod1 doit ressembler à ce qui suit :

    [TestMethod]
    public void CodedUITestMethod1()
    {
        // To generate code for this test, select "Generate Code for Coded UI Test" from the shortcut menu and select one of the menu items.
    
        // Launch the app.
        XamlWindow myAppWindow = XamlWindow.Launch("ed85f6ff-2fd1-4ec5-9eef-696026c3fa7b_cyrqexqw8cc7c!App");
    
        // Tap the button.
        Gesture.Tap(this.UIMap.UIApp1Window.UIButtonButton);
    
        this.UIMap.AssertMethod1();
    }
    

    <CodedUITest>
    Public Class CodedUITest1
    
        <TestMethod()>
        Public Sub CodedUITestMethod1()
            '            
            ' To generate code for this test, select "Generate Code for Coded UI Test" from the shortcut menu and select one of the menu items.
            '
            ' Launch the app.
            XamlWindow.Launch("ed85f6ff-2fd1-4ec5-9eef-696026c3fa7b_cyrqexqw8cc7c!App")
    
            '// Tap the button.
            Gesture.Tap(Me.UIMap.UIApp1Window.UIButtonButton)
    
            Me.UIMap.AssertMethod1()
        End Sub
    

Exécuter le test codé de l'interface utilisateur

• Générez votre test et exécutez-le à l'aide de l'Explorateur de tests.

  

  L'application Windows Phone démarre, l'action d'appui sur le bouton est exécutée et la propriété Texte du contrôle textbox est remplie et validée à l'aide de la méthode assert.

  

  Une fois le test terminé, l'Explorateur de tests confirme que le test a réussi.

  

Utiliser les tests codés de l'interface utilisateur pilotés par les données sur des applications Windows Phone

Pour tester différentes conditions, un test codé de l'interface utilisateur peut être exécuté plusieurs fois avec différents jeux de données.

Les tests codés de l'interface utilisateur pilotés par les données pour Windows Phone sont définis à l'aide de l'attribut DataRow sur une méthode de test.Dans l'exemple suivant, x et y utilisent les valeurs 1 et 2 pour la première itération et -1 et -2 pour la seconde itération du test.

[DataRow(1, 2, DisplayName = "Add positive numbers")]
[DataRow(-1, -2, DisplayName = "Add negative numbers")]
[TestMethod]
public void DataDrivingDemo_MyTestMethod(int x, int y)

Q et R

Q : Je ne trouve pas de modèle pour créer un projet de test codé de l'interface utilisateur Windows Phone. Pourquoi ?

R : Vérifiez que vous avez installé Visual Studio 2013 Update 2 ou version ultérieure.

Q : Suis-je obligé de déployer l'application Windows Phone dans l'émulateur pour mapper des contrôles d'interface utilisateur ?

R : Oui, le générateur de test codé de l'interface utilisateur exige qu'un émulateur soit en cours d'exécution et que l'application soit déployée dessus.Sinon, il génère un message d'erreur signalant qu'aucun émulateur en cours d'exécution n'a été détecté.

Q : Les tests peuvent-ils être exécutés uniquement sur l'émulateur, ou puis-je aussi utiliser un périphérique physique ?

R : les deux options sont prises en charge.Vous pouvez modifier la cible d'exécution des tests en changeant le type d'émulateur ou en sélectionnant Périphérique dans la barre d'outils Périphérique.Si vous sélectionnez Périphérique, un périphérique Phone Blue doit être connecté à l'un des ports USB de l'ordinateur.

Q : Pourquoi l'option d'enregistrement de mon test codé de l'interface utilisateur ne figure-t-elle pas dans la boîte de dialogue Générer le code pour le test codé de l'interface utilisateur ?

R : l'option d'enregistrement n'est pas prise en charge pour les applications Windows Phone.

Q : Puis-je créer un test codé de l'interface utilisateur pour mes applications Windows Phone basées sur WinJS, Silverlight ou HTML5 ?

R : Non, seules les applications XAML sont prises en charge.

Q : Puis-je créer des tests codés de l'interface utilisateur pour mes applications Windows Phone sur un système qui n'exécute pas Windows 8.1 ?

R : Non, le modèle Projet de test codé de l'interface utilisateur (applications Windows Phone) est disponible uniquement sur Windows 8.1.

Q : Puis-je sélectionner des contrôles qui sont en dehors de l'émulateur ?

R : Non, car le générateur ne les détectera pas.

Q : Puis-je utiliser le générateur de test codé de l'interface utilisateur pour mapper des contrôles à l'aide d'un périphérique physique (téléphone) ?

R : Non, le générateur ne peut mapper des éléments d'interface utilisateur que si votre application a été déployée sur l'émulateur.

Q : Pourquoi ne puis-je pas modifier le code du fichier UIMap.Designer ?

R : Toutes les modifications de code que vous effectuez dans le fichier UIMapDesigner.cs sont remplacées chaque fois que vous générez du code dans UIMap - Générateur de test codé de l'interface utilisateur.Si vous devez modifier une méthode enregistrée, vous devez la copier dans le fichier UIMap.cs et la renommer.Le fichier UIMap.cs peut être utilisé pour remplacer les méthodes et les propriétés dans le fichier UIMapDesigner.cs.Vous devez supprimer la référence à la méthode d'origine dans le fichier Coded UITest.cs et la remplacer par le nom de la méthode renommée.

Q : Puis-je exécuter un test codé de l'interface utilisateur sur mon application Windows Phone à partir de la ligne de commande ?

R : Oui, vous pouvez utiliser un fichier runsettings pour spécifier le périphérique cible pour l'exécution du test.Par exemple :

vstest.console.exe “pathToYourCodedUITestDll” /settings:devicetarget.runsettings

Exemple de fichier runsettings :

<?xml version="1.0" encoding="utf-8"?>
<RunSettings>
<MSPhoneTest>
<!--to specify test execution on device, use a TargetDevice option as follows-->
<TargetDevice>Device</TargetDevice>
<!--to specify an emulator instead, use a TargetDevice option like below-->
<!--<TargetDevice>Emulator 8.1 WVGA 4 inch 512MB</TargetDevice>-->
</MSPhoneTest>
</RunSettings>

Q : Quelles sont les différences entre les tests codés de l'interface utilisateur pour applications du Windows Store en XAML et les applications Windows Phone ?

R: Il existe quelques différences majeures :

Pour plus d'informations sur les tests codés de l'interface utilisateur pour les applications du Windows Store, voir Test des applications du Windows Store avec des tests codés de l'interface utilisateur.

Ressources externes

Blog sur la gestion du cycle de vie des applications Microsoft Visual Studio : Using Coded UI to test XAML-based Windows Phone apps

Voir aussi

Concepts

Test de l'interface utilisateur avec des tests codés de l'interface utilisateur automatisés