Xamarin.UITest

Xamarin.UITest ist ein C#-Testframework, das NUnit für Benutzeroberflächenakzeptanztests unter iOS- und Android-Apps verwendet. Es lässt sich eng in Xamarin.iOS- und Xamarin.Android-Projekte integrieren, kann aber auch mit nativen iOS- und Android-Projekten verwendet werden. Xamarin.UITest ist die Automatisierungsbibliothek , mit der die NUnit-Tests auf Android- und iOS-Geräten ausgeführt werden können. Die Tests interagieren wie ein Benutzer mit der Benutzeroberfläche: Eingeben von Text, Tippen auf Schaltflächen und Gesten ( z. B. Wischen).

In der Regel wird jeder Xamarin.UITest als Methode geschrieben, die als [Test]bezeichnet wird. Die Klasse, die den Test enthält, wird als [TestFixture]bezeichnet. Die Testvorrichtung enthält einen einzelnen Test oder eine Gruppe von Tests. Die Vorrichtung ist auch für die Einrichtung des Testlaufs und der Bereinigung verantwortlich, die nach Abschluss des Tests ausgeführt werden müssen. Jeder Test sollte dem Muster Arrange-Act-Assert folgen:

1. Anordnen: Der Test richtet Bedingungen ein und initialisiert Dinge, sodass der Test ausgeführt werden kann.
2. Act: Der Test interagiert mit der Anwendung, gibt Text ein, drückt Schaltflächen usw.
3. Assert: Der Test untersucht die Ergebnisse der aktionen, die im Schritt Act ausgeführt werden, um die Richtigkeit zu bestimmen. Beispielsweise kann die Anwendung überprüfen, ob eine bestimmte Fehlermeldung angezeigt wird.

Die beste Zeit für die ersten Schritte mit Xamarin.UITest ist die Entwicklung einer mobilen Anwendung. Automatisierte Tests werden geschrieben, während ein Feature gemäß den in der folgenden Liste beschriebenen Schritten entwickelt wird:

1. Entwickeln Sie das Feature in der Android- oder iOS-Anwendung.
2. Schreiben Sie die Tests, und führen Sie sie lokal aus, um die Funktionalität zu überprüfen.
3. Erstellen Sie einen neuen Testlauf in App Center Test, oder verwenden Sie einen vorhandenen Testlauf.
4. Kompilieren Sie das IPA oder APK, und laden Sie es dann zusammen mit den Tests in App Center Test hoch.
5. Beheben Sie alle Probleme oder Fehler, die von App Center Test verfügbar gemacht werden.
6. Wiederholen Sie den Vorgang, indem Sie mit dem nächsten Feature für die Anwendung fortbewegen.

Bei vorhandenen Anwendungen, die sich nicht mehr in der aktiven Entwicklung befinden, ist es möglicherweise nicht kostengünstig, automatisierte Tests nachträglich hinzuzufügen. Stattdessen besteht ein besserer Ansatz darin, Xamarin.UITest zum Beheben von Fehlern zu verwenden. Betrachten Sie beispielsweise eine Anwendung ohne automatisierte Tests, und ein Benutzer meldet einen Fehler. Ein Entwickler, der mit der Behebung dieses Fehlers beauftragt ist, kann einige (oder alle) der folgenden Aktionen ausführen:

• Überprüfen Sie den Fehler oder die Regression manuell.
• Schreiben Sie einen Test mit Xamarin.UITest, der den Fehler veranschaulicht.
• Übermitteln Sie den Test an den App Center-Test, um einen Einblick in den Umfang und die Auswirkungen des Fehlers auf relevanten Geräten zu erhalten.
• Beheben des Fehlers
• Beweisen Sie, dass der Fehler mit einem übergebenen Xamarin.UITest behoben wurde.
• Übermitteln Sie die Fixes und tests an App Center Test, um zu überprüfen, ob der Fehler auf den relevanten Geräten behoben wurde.
• Überprüfen Sie die Übergeben von Tests an die Versionskontrolle.

Automatisierte Benutzeroberflächentests hängen stark von der Suche und Interaktion mit Ansichten auf dem Bildschirm ab. Xamarin.UITest erfüllt diese Anforderung mit zwei wichtigen Sätzen von APIs, die miteinander arbeiten:

1. Aktionen , die für Ansichten ausgeführt werden können: Xamarin.UITest stellt APIs bereit, mit denen ein Test allgemeine Benutzeraktionen wie Tippen auf die Ansicht, Eingeben von Text oder Wischen in der Ansicht simulieren kann.
2. Abfragen zum Suchen von Ansichten auf dem Bildschirm: Teil des Xamarin.UITest-Frameworks sind APIs, die die Ansichten auf einem Bildschirm suchen. Abfragen suchen Sichten zur Laufzeit, indem sie Attribute für die Ansicht überprüfen und ein Objekt zurückgeben, für das die Aktionen möglicherweise funktionieren. Abfragen auf diese Weise ist eine leistungsstarke Technik, mit der Tests für Benutzeroberflächen geschrieben werden können, unabhängig von Bildschirmgröße, Ausrichtung oder Layout.

Um beim Schreiben von Tests zu helfen, stellt Xamarin.UITest eine read-eval-print-loop (REPL) bereit. Die REPL ermöglicht Entwicklern und Testern die Interaktion mit einem Bildschirm, während die Anwendung ausgeführt wird, und vereinfacht die Erstellung der Abfragen.

Einführung in die Xamarin.UITest-API

Alle Testinteraktionen mit der mobilen Anwendung erfolgen über eine instance von Xamarin.UITest.IApp. Diese Schnittstelle definiert die Methoden, die für die Zusammenarbeit mit der Anwendung und die Interaktion mit der Benutzeroberfläche für den Test von entscheidender Bedeutung sind. Es gibt zwei konkrete Implementierungen dieser Schnittstelle:

• Xamarin.UITest.iOS.iOSApp Diese Klasse automatisiert Tests für iOS.
• Xamarin.UITest.Android.AndroidApp Diese Klasse dient zum Automatisieren von Tests unter Android.

iOSApp und AndroidApp -Objekte werden nicht direkt instanziiert. Stattdessen werden sie mithilfe der Hilfsklasse ConfigureApp erstellt. Diese Klasse ist ein Generator, der sicherstellt, dass oder iOSAppAndroidApp ordnungsgemäß instanziiert wird.

Es wird empfohlen, für jeden Test eine neue IApp instance zu verwenden. Eine neue instance verhindert, dass der Zustand eines Tests in einen anderen überläuft. Es gibt zwei Stellen, an denen ein NUnit-Test eine instance von IAppinitialisieren könnte:

• In der -Methode In der SetUp Regel ist eine Testeinrichtung eine logische Gruppierung verwandter Tests, die jeweils unabhängig von den anderen ausgeführt werden. In diesem Szenario sollte in IApp der SetUp -Methode initialisiert werden, um sicherzustellen, dass für jeden Test ein neues IApp verfügbar ist.
• In der TestFixtureSetup -Methode In einigen Situationen kann ein einzelner Test eine eigene Prüfvorrichtung erfordern. In diesem Fall kann es sinnvoller sein, das IApp Objekt einmal in der TestFixtureSetup -Methode zu initialisieren.

Nachdem IApp konfiguriert wurde, kann ein Test mit der getesteten Anwendung interagieren. Dazu müssen Verweise auf die Ansichten abgerufen werden, die auf dem Bildschirm angezeigt werden. Viele Methoden in Xamarin.UITest verwenden einen Func<AppQuery, AppQuery> Parameter, um die Ansichten zu suchen. Der folgende Codeausschnitt zeigt beispielsweise, wie Sie auf eine Schaltfläche tippen:

app.Tap(c=>c.Button("ValidateButton"));

Es gibt zwei Implementierungen der IApp Schnittstelle innerhalb des Xamarin.UITest-Frameworks, eine für iOS und eine für Android.

Initialisieren von IApp für iOS-Anwendungen

Wenn Xamarin.UITest einen Test unter iOS ausführt, startet es eine instance des iOS-Simulators, stellt die Anwendung bereit, startet sie und beginnt mit der Ausführung der Tests. Die iOS-Anwendung muss bereits erstellt werden. Xamarin.UITest kompiliert die Anwendung nicht und erstellt das App-Paket nicht für Sie.

Die AppBundle -Methode kann verwendet werden, um anzugeben, wo sich das App-Bundle im Dateisystem befindet. Es gibt zwei Möglichkeiten, dies zu tun, mit einem absoluten Pfad oder einem relativen Pfad. Dieser Codeausschnitt zeigt die Verwendung eines absoluten Pfads zum App-Paket:

IApp app = ConfigureApp
    .iOS
    .AppBundle("/path/to/iosapp.app")
    .StartApp();

Partielle Pfade müssen relativ zur Xamarin.UITest-Assembly sein. Dieser Codeausschnitt ist ein Beispiel:

IApp app = ConfigureApp
    .iOS
    .AppBundle("../../../iOSAppProject/bin/iPhoneSimulator/Debug/iosapp.app")
    .StartApp();

Im Beispiel des relativen Pfads wird aufgefordert AppBundle , drei Verzeichnisse aus der Xamarin.UITest-Assembly nach oben zu wechseln und dann in der Projektstruktur des iOS-Anwendungsprojekts nach unten zu navigieren, um das App-Paket zu finden.

ConfigureApp verfügt über andere Methoden zum Konfigurieren IAppvon . Weitere Informationen finden Sie in der iOSAppConfigurator-Klasse . Einige der interessanteren Methoden werden in der folgenden Tabelle beschrieben:

Weitere Informationen zum Ausführen von iOS-Tests für einen bestimmten iOS-Simulator finden Sie unter Ermitteln der Geräte-ID für einen iOS-Simulator.

Initialisieren von IApp für Android-Anwendungen

Xamarin.UITest stellt ein vorhandenes APK auf einem angefügten Gerät oder einem instance des bereits ausgeführten Android-Emulators bereit. Die App wird gestartet, und dann wird der Test ausgeführt. Xamarin.UITest kann weder das APK erstellen noch eine instance des Android-Emulators starten.

Die ApkFile -Methode von IApp wird verwendet, um anzugeben, wo sich das APK im Dateisystem befindet. Es gibt zwei Möglichkeiten, dies zu tun, mit einem absoluten Pfad oder einem relativen Pfad. Dieser Codeausschnitt zeigt die Verwendung eines absoluten Pfads zum APK:

IApp app = ConfigureApp
    .Android
    .ApkFile("/path/to/android.apk")
    .StartApp();

Partielle Pfade müssen relativ zur Xamarin.UITest-Assembly sein. Dieser Codeausschnitt ist ein Beispiel:

IApp app = ConfigureApp
    .Android
    .ApkFile("../../../AndroidProject/bin/Debug/android.apk")
    .StartApp();

Das relative Pfadbeispiel besagt ApkFile , dass Sie drei Verzeichnisse aus der Xamarin.UITest-Assembly nach oben navigieren und dann in der Projektstruktur des Android-Anwendungsprojekts nach unten navigieren, um die APK-Datei zu finden.

Wenn mehrere Geräte oder Emulatoren verbunden sind, stoppt Xamarin.UITest die Testausführung und zeigt eine Fehlermeldung an, da das gewünschte Ziel für den Test nicht aufgelöst werden kann. In diesem Fall muss die serielle ID des Geräts oder Emulators angegeben werden, um den Test auszuführen. Betrachten Sie beispielsweise die folgende Ausgabe des adb devices Befehls, der alle Geräte (oder Emulatoren) auflistet, die an den Computer angefügt sind (zusammen mit ihrer seriellen ID):

$ adb devices
List of devices attached
192.168.56.101:5555 device
03f80ddae07844d3    device

Das Gerät kann mit der DeviceSerial -Methode angegeben werden:

IApp app = ConfigureApp.Android.ApkFile("/path/to/android.apk")
                               .DeviceSerial("03f80ddae07844d3")
                               .StartApp();

Interagieren mit der Benutzeroberfläche

Um mit Ansichten zu interagieren, verwenden viele IApp Methoden einen Func<AppQuery, AppQuery> Delegat, um die Ansicht zu suchen. Dieser Delegat verwendet AppQuery den Kern der Xamarin.UITest-Suche nach Ansichten.

AppQuery ist eine fluent-Schnittstelle zum Erstellen der Abfragen zum Suchen von Ansichten. Von den Methoden, die AppQuery bereitgestellt werden, ist die Marked Methode eine der einfachsten und flexibelsten. Diese Methode verwendet eine Heuristik zum Suchen von Ansichten und wird im folgenden Abschnitt ausführlicher erläutert. Vorerst ist es wichtig zu verstehen, dass IApp es viele Methoden für die Interaktion mit einer Anwendung gibt. Diese Methoden verwenden ein Func<AppQuery, AppQuery> , um einen Verweis auf die Ansicht abzurufen, mit der sie interagieren soll. Einige der interessanteren Methoden, die von AppQuery bereitgestellt werden, sind unten aufgeführt:

Mit der folgenden Methode wird beispielsweise veranschaulicht, wie ein Tippen auf eine Schaltfläche namens "SaveUserdataButton" simuliert wird:

app.Tap(c=>c.Marked("SaveUserDataButton"));

Da AppQuery es sich um eine fluent-Schnittstelle handelt, ist es möglich, mehrere Methodenaufrufe miteinander zu verketten. Betrachten Sie dieses kompliziertere Beispiel für das Tippen auf eine Ansicht:

app.Tap(c=>c.Marked("Pending")
            .Parent()
            .Class("AppointmentListCell").Index(0));

Hier wird zuerst eine Ansicht gefunden, AppQuery die markiert ist Pending, und wählen Sie dann das erste übergeordnete Element dieser Ansicht aus, das ein AppointmentListCell Typ ist.

Es kann schwierig sein, diese Abfragen zu erstellen, indem Sie sich eine mobile App ansehen. Xamarin.UITest stellt eine REPL bereit, die verwendet werden kann, um die Ansichtshierarchie eines Bildschirms zu untersuchen, mit dem Erstellen von Abfragen zu experimentieren und sie für die Interaktion mit einer Anwendung zu verwenden.

Verwenden der REPL

Die einzige Möglichkeit zum Starten der REPL besteht darin, die IApp.Repl Methode innerhalb eines vorhandenen Tests aufzurufen. Dies erfordert das Erstellen einer NUnit TestFixtureund das Konfigurieren einer instance, die IApp in einer Test -Methode verwendet werden kann. Der folgende Codeausschnitt zeigt ein Beispiel dafür:

[TestFixture]
public class ValidateCreditCard
{
    IApp app;

    [SetUp]
    public void Setup()
    {
        app = ConfigureApp.Android.ApkFile("/path/to/application.apk").StartApp();
    }
    [Test]
    public void CreditCardNumber_TooLong_DisplayErrorMessage()
    {
        app.Repl();
    }
}

So führen Sie den Test aus, indem Sie mit der rechten Maustaste in die Dachrinne von Visual Studio klicken und Ausführen auswählen:

Der Test wird ausgeführt, und wenn die Repl Methode aufgerufen wird, startet Xamarin.UITest die REPL in einer Terminalsitzung, wie im folgenden Screenshot gezeigt:

Die REPL hat eine instance von initialisiert, die IApp mit appder Anwendung interagiert. Eines der ersten Schritte ist das Erkunden der Benutzeroberfläche. Die REPL verfügt dazu über einen tree Befehl. Es wird die Hierarchie der Ansichten im angezeigten Bildschirm gedruckt. Betrachten Sie als Beispiel den folgenden Screenshot einer Anwendung:

Wir können den tree Befehl verwenden, um die folgende Hierarchie dieses Bildschirms anzuzeigen:

App has been initialized to the 'app' variable.
Exit REPL with ctrl-c or see help for more commands.

>>> tree
[UIWindow > UILayoutContainerView]
  [UINavigationTransitionView > ... > UIView]
    [UITextView] id: "CreditCardTextField"
      [_UITextContainerView]
    [UIButton] id: "ValidateButton"
      [UIButtonLabel] text: "Validate Credit Card"
    [UILabel] id: "ErrorrMessagesTestField"
  [UINavigationBar] id: "Credit Card Validation"
    [_UINavigationBarBackground]
      [_UIBackdropView > _UIBackdropEffectView]
      [UIImageView]
    [UINavigationItemView]
      [UILabel] text: "Credit Card Validation"
>>>

Wir können sehen, dass es in dieser Ansicht einen UIButton mit dem id von ValidateButton gibt. Wir können die vom tree Befehl angezeigten Informationen verwenden, um die erforderlichen Abfragen zum Suchen und Interagieren mit Ansichten zu erstellen. Der folgende Code simuliert beispielsweise ein Tippen auf die Schaltfläche:

app.Tap(c=>c.Marked("ValidateButton"))

Wenn Befehle eingegeben werden, werden sie von der REPL in einem Puffer gespeichert. Die REPL stellt einen copy Befehl bereit, der den Inhalt dieses Puffers in die Zwischenablage kopiert. Dadurch können wir einen Test prototypieren. Wir können die in der REPL ausgeführten Arbeiten mit copyin die Zwischenablage kopieren und dann diese Befehle in eine [Test]einfügen.

Verwenden von Markierten zum Suchen von Ansichten

Die AppQuery.Marked-Methode ist eine praktische und leistungsstarke Möglichkeit, Ansichten auf dem Bildschirm abzufragen. Es funktioniert, indem die Ansichtshierarchie für eine Ansicht auf dem Bildschirm überprüft und versucht wird, die Eigenschaften der Ansicht mit der bereitgestellten Zeichenfolge abzugleichen. Marked funktioniert je nach Betriebssystem unterschiedlich.

Suchen nach iOS-Ansichten mit Markiert

iOS-Ansichten werden mithilfe eines der folgenden Attribute gefunden:

• der AccessibilityIdentifier Ansicht
• der AccessibilityLabel Ansicht

Betrachten Sie als Beispiel den folgenden C#-Codeausschnitt, der ein UILabel erstellt und festlegt AccessibilityLabel:

UILabel errorMessagesTextField = new UILabel(new RectangleF(10, 210, 300, 40));
errorMessagesTextField.AccessibilityLabel = "ErrorMessagesTextField";
errorMessagesTextField.Text = String.Empty;

Diese Ansicht kann mit der folgenden Abfrage gefunden werden:

AppResult[] results = app.Marked("ErrorMessagesTextField");

Suchen nach Android-Ansichten mit Markiert

Android-Ansichten werden basierend auf einer der folgenden Eigenschaften gefunden:

• der Id Ansicht
• der ContentDescription Ansicht
• der Text einer Ansicht

Betrachten Sie beispielsweise ein Android-Layout, in dem die folgende Schaltfläche definiert ist:

<Button
    android:text="Action 1"
    android:layout_width="wrap_content"
    android:layout_height="match_parent"
    android:id="@+id/action1_button"
    android:layout_weight="1"
    android:layout_marginLeft="5dp" />

Wir können sehen, dass die android:id dieser Schaltfläche action1_button ist und dass die android:textAktion 1 ist. Eine der folgenden beiden Abfragen sucht die Schaltfläche auf dem Bildschirm:

• app.Query(c=>c.Marked("action1_button"));
• app.Query(c=>c.Marked("Action 1"));

Steuern der Anwendung mit Xamarin.UITest.IApp

Nach der IApp Konfiguration und Initialisierung beginnt der Test möglicherweise mit der Interaktion mit der Anwendung. Ein Beispiel für eine Methode, die verwendet Func<AppQuery, AppQuery> wird, ist die IApp.Query() -Methode. Diese Methode führt die Abfrage aus und gibt die Ergebnisse zurück. Das einfachste Beispiel wird im folgenden Codeausschnitt gezeigt, der eine Liste aller Ansichten zurückgibt, die auf dem Bildschirm sichtbar sind:

AppResult[] results = app.Query(c=>c.All())

Die folgende Tabelle zeigt einige weitere Beispiele für die Verwendung AppQuery zum Suchen von Ansichten auf dem Bildschirm:

In der nächsten Tabelle sind einige (aber nicht alle) der von bereitgestellten Methoden aufgeführt, die zum Interagieren oder Bearbeiten von IApp Ansichten auf dem Bildschirm verwendet werden können:

Weitere Informationen zur IApp Schnittstelle finden Sie in der API-Dokumentation für IApp, AndroidAppund iOSApp.

Als Beispiel für die Verwendung dieser Methoden betrachten Sie den folgenden Test für den screenshot, der oben angezeigt wurde. Bei diesem Test wird eine 17-stellige Zahl für ein Guthaben Karte in ein Textfeld eingegeben und dann auf eine Schaltfläche auf dem Bildschirm tippen. Anschließend wird der Bildschirm auf eine Fehlermeldung überprüft, in der der Benutzer darüber informiert wird, dass die Nummer zu lang ist, um ein gültiges Guthaben Karte Nummer zu sein:

[Test]
public void CreditCardNumber_TooLong_DisplayErrorMessage()
{
    /* Arrange - set up our queries for the views */
    // Nothing to do here, app has been instantiated in the [SetUp] method.

    /* Act */
    app.EnterText(c => c.Marked("CreditCardTextField"), new string('9', 17));
    // Screenshot can be used to break this test up into "steps".
    // The screenshot can be inspected after the test run to verify
    // the visual correctness of the screen.
    app.Screenshot("Entering a 17 digit credit card number.");

    app.Tap(c => c.Marked("ValidateButton"));
    app.Screenshot("The validation results.");

    /* Assert */
    AppResult[] result = app.Query(c => c.Class("UILabel").Text("Credit card number is too long."));
    Assert.IsTrue(result.Any(), "The error message isn't being displayed.");
}

Dieser Test verwendet auch die Screenshot -Methode, um Während der Testausführung an wichtigen Punkten Bilder zu machen. Wenn dieser Test ausgeführt wird, erstellt App Center die Screenshots und zeigt sie in den Testergebnissen an. Die -Methode ermöglicht es, einen Test in Schritte aufzuteilen und Beschreibungen für die Screenshots bereitzustellen.