Hoe Appium-testcode te schrijven - uw complete gids 2023-24

Appium is een open-source automatiseringstool waarmee u scripts kunt schrijven om mobiele applicaties op te testen verschillende platforms zoals Android en iOS. Met Appium kunt u automatiseren het testproces, verzekeren dat je mobiele app functioneert zoals bedoeld verschillende apparaten en besturingssystemen.

Overzicht van Appium-testen

Appium-testen wel een populaire keuze onder ontwikkelaars en testers vanwege zijn flexibiliteit en gebruiksgemak. Het ondersteunt meerdere programmeertaals, waaronder Java, Python, Ruby en C#, waardoor het toegankelijk is voor een breed scala van ontwikkelaars.

Appium werkt door interactie met de geteste applicatie, net als een echte gebruiker zou. Het gebruikt het WebDriver-protocol om te communiceren met het mobiele apparaat of de emulator, zodat u acties kunt uitvoeren zoals tikkende knoppen, tekst invoeren en veegbewegingen.

Een van de de belangrijkste voordelen van Appium is de platformonafhankelijke ondersteuning. Het maakt het mogelijk om te schrijven één testscript waarop uitgevoerd kan worden beide Android en iOS-apparaten, waardoor u tijd en moeite bespaart. Deze platformonafhankelijke mogelijkheid maakt Appium een ​​waardevol hulpmiddel voor organisaties die mobiele applicaties ontwikkelen meerdere platforms.

Ondersteunde platforms (Android en iOS)

Appium ondersteunt beide Android en iOS-platforms, waardoor het een veelzijdige keuze is voor testen van mobiele apps.

Android-testen

Als het om testen gaat Android-applicaties met Appium kun je schrijven uw testscripts gebruikt elke programmeertaal die Appium ondersteunt. Je kunt gebruiken populaire frameworks zoals JUnit of TestNG om te structureren uw testen en daar uitspraken over doen het gedrag of jouw app.

Om Android-tests te automatiseren, moet u de benodigde tools en afhankelijkheden instellen. Dit omvat het installeren van de Android SDK, opzetten de Android Virtual Device (AVD)-emulatoren het configureren van de Appium-server.

Eens de opzet voltooid is, kunt u beginnen met schrijven uw testscriptS. Appium biedt een breed scala van API's en methoden waarmee u kunt communiceren de Android-applicatie wordt getest. Je kunt acties uitvoeren zoals tikkende knoppen, tekst invoeren, verifiëren tekstinhouden valideren UI-elementen.

iOS-testen

Appium ondersteunt ook testen iOS-applicaties, waarmee u testscripts kunt schrijven met behulp van hetzelfde programmeertaals en raamwerken als Android-testen.

Automatiseren iOS-testen, moet u de benodigde tools en afhankelijkheden instellen. Dit omvat het installeren van Xcode, inclusief de noodzakelijke iOS-simulator om uit te proberen. Ook moet u de Appium-server configureren en de gewenste mogelijkheden instellen uw iOS-apparaat.

Eens de opzet voltooid is, kunt u beginnen met schrijven uw testscriptS. Appium biedt API's en methoden die speciaal zijn ontworpen voor iOS-testen. Je kunt ermee communiceren UI-elementen, gebaren uitvoeren, valideren tekstinhouden navigeer er doorheen verschillende schermen of uw iOS-applicatie.

Hoe u het app-pakket en de activiteit in Android kunt vinden

Apppakket 1

Om effectieve scripts voor Appium-testen te schrijven, is het cruciaal om het app-pakket en de activiteit ervan te identificeren de Android-applicatie je wilt automatiseren. Het app-pakket vertegenwoordigt de unieke identificatie van de aanvraag, terwijl de activiteit verwijst naar het specifieke scherm of functionaliteit binnen de app. In dit gedeelte onderzoeken we de stappen om het app-pakket en de activiteit in Android te vinden het bevels For zowel Windows- als Mac/Linux-platforms.

Stappen om app-pakket en activiteit te vinden

  1. Schakel ontwikkelaarsopties in: Voordat u doorgaat, moet u ervoor zorgen dat de ontwikkelaarsopties zijn ingeschakeld op uw Android-apparaat. Ga hiervoor naar de apparaatinstellingen, scrol omlaag naar het gedeelte 'Over de telefoon'en tik op het “Buildnummer'Meerdere keren totdat je het ziet Een boodschap wat aangeeft dat u dat nu bent een ontwikkelaar.
  2. Toegang tot ontwikkelaarsopties: Zodra u de ontwikkelaarsopties heeft ingeschakeld, gaat u terug naar het hoofdinstellingenmenu en zoek naar het nieuw ontgrendelde item "Ontwikkelaarsopties".. Tik erop om toegang te krijgen de ontwikkelaarsinstellingen.
  3. USB-debugging inschakelen: Zoek in de ontwikkelaarsopties de optie “USB-foutopsporing”. en schakel het in. Hierdoor kan uw computer communiceren met het Android-apparaat een USB-aansluiting.
  4. Verbind Android-apparaat met computer: Verbind uw Android-apparaat met uw computer via een USB-kabel. Zorg ervoor dat u toestemming geeft de computer's RSA-sleutelvingerafdruk op uw apparaat als daarom wordt gevraagd.
  5. Open de opdrachtprompt of terminal: Open in Windows de opdrachtprompt door op de Windows-toets + R te drukken, 'cmd' te typen en op Enter te drukken. Op Mac/Linux opent u de Terminal door ernaar te zoeken in de toepassingen of door de sneltoets Command + Spatie te gebruiken en 'Terminal' te typen.
  6. Navigeer naar Android SDK-hulpmiddelen: Navigeer in de opdrachtprompt of terminal naar de map waar u hebt geïnstalleerd de Android SDK tools. Deze bevindt zich doorgaans in de map “platform-tools”. binnen de Android SDK installatiemap.
  7. Voer ADB-opdrachten uit: Zodra je binnen bent de Android SDK tools directory, voert u de volgende opdracht uit om weer te geven allen de aangesloten apparaten:

adb devices

Dit wordt weergegeven: de apparaat-ID of uw verbonden Android-apparaat.

  1. Zoek apppakket en activiteit: Voer de volgende opdracht uit om het app-pakket en de activiteit te vinden:

adb shell dumpsys window windows | grep -E 'mCurrentFocus|mFocusedApp'

Dit commando zal je voorzien van het huidige app-pakket en activiteitsdetails.

Commando's voor Windows en Mac/Linux

Hier zijn het bevels voor het vinden van het app-pakket en de activiteit in Android met behulp van Appium zowel Windows- als Mac/Linux-platforms:

Windows:

  1. Schakel ontwikkelaarsopties in op uw Android-apparaat.
  2. Verbind uw Android-apparaat via USB met uw computer.
  3. Open de opdrachtprompt door op de Windows-toets + R te drukken, 'cmd' te typen en op Enter te drukken.
  4. Navigeer naar de Android SDK tools map met behulp van de cd opdracht.
  5. Uitvoeren het bevel adb devices te vermelden de aangesloten apparaten.
  6. Uitvoeren het bevel adb shell dumpsys window windows | grep -E 'mCurrentFocus|mFocusedApp' om het app-pakket en de activiteit te vinden.

Mac / Linux:

  1. Schakel ontwikkelaarsopties in op uw Android-apparaat.
  2. Verbind uw Android-apparaat via USB met uw computer.
  3. Open de Terminal door ernaar te zoeken in de toepassingen of door de sneltoets Command + Spatie te gebruiken en 'Terminal' te typen.
  4. Navigeer naar de Android SDK tools map met behulp van de cd opdracht.
  5. Uitvoeren het bevel ./adb devices te vermelden de aangesloten apparaten.
  6. Uitvoeren het bevel ./adb shell dumpsys window windows | grep -E 'mCurrentFocus|mFocusedApp' om het app-pakket en de activiteit te vinden.

Door deze stappen te volgen en uit te voeren de juiste commando's, kunt u eenvoudig het app-pakket en de activiteit van vinden een Android-applicatie. Deze informatie is essentieel voor het schrijven van effectieve scripts bij Appium-testen, omdat u hiermee kunt communiceren specifieke schermen en functionaliteiten binnen de app.

Hoe u een Maven-project voor Appium-testen maakt

Ontwerp zonder titel 3

Appium is een open-source automatiseringstool die wordt gebruikt voor het testen van mobiele applicaties. Hiermee kunt u scripts schrijven divers programmeertaals automatiseren het testproces. In deze sectie bespreken we hoe u een Maven-project voor Appium-testen kunt maken, waarmee u afhankelijkheden kunt beheren en uw project efficiënter kunt opbouwen.

Vereisten voor het maken van een Maven-project

Voordat we ons verdiepen in het maken van een Maven-project voor Appium-testen, moeten we ervoor zorgen dat dit het geval is de noodzakelijke randvoorwaarden in situ. Hier zijn een paar dingen je hebt nodig:

  1. Java-ontwikkelkit (JDK): Zorg ervoor dat u de nieuwste versie van JDK hebt geïnstalleerd uw systeem. Maven vereist dat JDK wordt gecompileerd en uitgevoerd jouw code.
  2. meester: Maven installeren op uw machine. U kunt de nieuwste versie van Maven downloaden van de officiële Apache Maven-website.
  3. Integrated Development Environment (IDE): Kies een IDE of jouw voorkeur. Populaire keuzes omvatten Eclipse, IntelliJ IDEA en Visual Studio-code. Installeer de benodigde plug-ins voor Maven-integratie.
  4. Appium-server: Download en installeer de Appium-server op uw machine. Appium-server fungeert als brug tussen uw testscripts en het mobiele apparaat of de emulator.

Stappen om een ​​Maven-project te maken

Nu dat we hebben de voorwaarden gesorteerd, laten we verder gaan met het maken van een Maven-project voor Appium-testen. Volg deze stappen:

  1. Open uw IDE: Lancering uw favoriete IDE en creëren een nieuw Maven-project. Kiezen het juiste Maven-archetype voor uw project. Voor Appium-testen, het archetype ‘maven-archetype-quickstart’ wordt veel gebruikt.
  2. Projectdetails configureren: Zorgen voor de nodige gegevens zoals Groeps-ID en Artefact-ID voor jouw project. Deze details wordt gebruikt om uw project binnenin te identificeren het Maven-ecosysteem.
  3. Project structuur: Zodra het project is gemaakt, ziet u het een vooraf gedefinieerde projectstructuur. De belangrijkste broncodebestanden bevindt zich onder de map "src/main/java".
  4. Maak een testklasse: Maak in de map “src/main/java” een een nieuw pakket For uw testscriptS. Creëren een nieuwe Java-klasse binnen dit pakket om uw Appium-testscripts te schrijven.
  5. Afhankelijkheden configureren: We zullen nu de nodige afhankelijkheden toevoegen het pom.xml-bestand van het project. Dit bestand ligt in de hoofdmap van uw project. Open het bestand pom.xml en voeg de vereiste afhankelijkheden voor Appium-testen toe.

Afhankelijkheden toevoegen aan het pom.xml-bestand

Om succesvol te kunnen rennen Appium-tests, moeten we de vereiste afhankelijkheden toevoegen aan het pom.xml-bestand. Deze afhankelijkheden wordt gedownload door Maven en opgenomen in het klassenpad van uw project. Hier zijn enkele veelgebruikte afhankelijkheden voor Appium-testen:

Afhankelijkheid Omschrijving
io.appium Bevat de kernklassen en methoden voor interactie met de Appium-server.
org.testng Biedt het TestNG-framework voor het schrijven en uitvoeren van testcases.
org.seleniumhq.selenium Bevat de Selenium WebDriver, die wordt gebruikt voor het automatiseren van browserinteracties.
org.apache.commons Biedt hulpprogrammaklassen en -methoden die nuttig kunnen zijn bij uw testscripts.

Toevoegen deze afhankelijkheden, open het bestand pom.xml en zoek het bestand <dependencies> sectie. Voeg de benodigde afhankelijkheden toe binnen het <dependencies> labels. Hier is Een voorbeeld:

xml
<dependencies>
<dependency>
<groupId>io.appium</groupId>
<artifactId>java-client</artifactId>
<version>7.5.1</version>
</dependency>
<dependency>
<groupId>org.testng</groupId>
<artifactId>testng</artifactId>
<version>7.4.0</version>
</dependency>
<dependency>
<groupId>org.seleniumhq.selenium</groupId>
<artifactId>selenium-java</artifactId>
<version>3.141.59</version>
</dependency>
<dependency>
<groupId>org.apache.commons</groupId>
<artifactId>commons-lang3</artifactId>
<version>3.12.0</version>
</dependency>
</dependencies>

Zodra je hebt toegevoegd de afhankelijkheden, sla het pom.xml-bestand op. Maven downloadt automatisch de vereiste afhankelijkheden en maakt deze beschikbaar in uw project.

Gefeliciteerd! U hebt met succes een Maven-project voor Appium-testen gemaakt en de benodigde afhankelijkheden toegevoegd. Nu kunt u beginnen met het schrijven van uw Appium-testscripts en deze uitvoeren met Maven.

In het volgende gedeelte, we zullen onderzoeken hoe we moeten schrijven effectieve testscripts in Appium en bespreken 'best practices' For script ontwikkeling. Blijf op de hoogte!

Gewenste capaciteiten bij Appium-testen

Ontwerp zonder titel 8

Bij Appium-testen spelen de gewenste mogelijkheden een cruciale rol bij het configureren en aanpassen de test automatisering . Gewenste mogelijkheden zijn een set sleutel-waardeparen die de kenmerken van de testomgeving definiëren, zoals het platform, het apparaat en de toepassingsinstellingen. Door te specificeren deze mogelijkheden, kunnen testers daarvoor zorgen hun Appium-scripts run on het gewenste doelapparaat of emulator.

Bij het schrijven van scripts in Appium is het essentieel om te begrijpen hoe je de gewenste mogelijkheden correct instelt. Laten we eens kijken naar de gewenste mogelijkheden voor Android- en iPhone-apparaten.

Gewenste mogelijkheden voor Android

bij het testen Android-applicaties met Appium zijn er meerdere gewenste mogelijkheden die u kunt instellen om de testomgeving te configureren. Hier zijn enkele veelgebruikte gewenste mogelijkheden voor Android:

  1. platformName: specificeert het platform waarop de test wordt uitgevoerd, zoals 'Android' of 'iOS'.
  2. deviceName: Specificeert de naam van het Android-apparaat of de emulator waarop de test wordt uitgevoerd.
  3. app: Specificeert het pad naar het APK-bestand or de pakketnaam van de geteste applicatie.
  4. automationName: Specificeert de automatiseringsmotor te gebruiken, zoals “UiAutomator2” of “Espresso.”
  5. appPackage en appActivity: Specificeert de pakketnaam en naam van de activiteit van de applicatie die wordt getest.
  6. udid: Specificeert de unieke apparaat-ID (UDID) van het Android-apparaat.

Door in te stellen deze gewenste mogelijkheden, kunt u de testomgeving hierop afstemmen uw specifieke wensen voor Android-testen.

Gewenste mogelijkheden voor iPhone

Ontwerp zonder titel 9

Vergelijkbaar met Android, tijdens het testen iPhone-applicaties met Appium kunt u de gewenste mogelijkheden instellen om de testomgeving aan te passen. Hier zijn enkele veelgebruikte gewenste mogelijkheden voor de iPhone:

  1. platformName: specificeert het platform waarop de test wordt uitgevoerd, zoals 'Android' of 'iOS'.
  2. deviceName: Specificeert de naam van het iPhone-apparaat of de simulator waarop de test zal worden uitgevoerd.
  3. app: Specificeert het pad naar het .app-bestand or de bundel-ID van de geteste applicatie.
  4. automationName: Specificeert de automatiseringsmotor te gebruiken, zoals “XCUITest” of “UIAutomation.”
  5. bundleId: Specificeert de bundel-ID van de geteste applicatie.
  6. udid: Specificeert de unieke apparaat-ID (UDID) van het iPhone-apparaat.

Door in te stellen deze gewenste mogelijkheden, kunt u de testomgeving hierop afstemmen uw specifieke wensen For iPhone testen.

Hoe u een Appium-testscript voor Android schrijft

App-pakket1

Appium is een open-source automatiseringstool waarmee u tests voor mobiele applicaties kunt schrijven en uitvoeren. Het ondersteunt beide Android en iOS-platforms, waardoor het een populaire keuze tussen ontwikkelaars en testers. In deze sectie bespreken we de stappen die betrokken zijn bij het schrijven van een Appium-testscript voor Android en bieden we deze aan een voorbeeldcode als referentie.

Stappen voor het schrijven van een Appium-testscript

Het schrijven van een Appium-testscript vereist een systematische aanpak te zorgen nauwkeurige en efficiënte testuitvoering. Hier zijn de stappen die u kunt volgen om een ​​Appium-testscript voor Android te schrijven:

  1. De ontwikkelomgeving instellen: Voordat u begint met het schrijven van het script, moet u de ontwikkelomgeving instellen. Dit is inclusief installeren de benodigde software, zoals Java Development Kit (JDK), Android SDKen Appium-server. Zorg ervoor dat u configureert milieu variabelen naar behoren.
  2. Identificeer de testscenario's: Bepalen het testscenarios die u in uw script wilt behandelen. Het gaat hierbij om het begrijpen van de functionaliteit van de applicatie en het identificeren ervan de belangrijkste kenmerken die getest moeten worden. Het is belangrijk om te hebben een duidelijk begrip van het verwachte gedrag van de toepassing onder verschillende omstandigheden.
  3. Inspecteer de applicatie: Gebruik de Appium Inspector-tool om de elementen van de applicatie te inspecteren. Deze tool stelt u in staat zich te identificeren de unieke identificaties (zoals resource-id, naam van de klasseof xpath) voor de elementen waarmee u tijdens de test wilt communiceren. Het inspecteren van de applicatie helpt u bij het nauwkeurig lokaliseren van de elementen in uw script.
  4. Schrijf het testscript: Zodra u zich heeft geïdentificeerd het testscenarios en de applicatie geïnspecteerd, kunt u beginnen met het schrijven van het testscript. Het script moet worden geschreven a programmeertaal dat wordt ondersteund door Appium, zoals Java, Python of JavaScript. Je kunt alles gebruiken Geïntegreerde ontwikkelomgeving (IDE) van uw keuze om het script te schrijven.
  5. Configureer de gewenste mogelijkheden: Voordat u het testscript uitvoert, moet u de gewenste mogelijkheden configureren. Gewenste mogelijkheden zijn een set sleutel-waardeparen die de kenmerken van de testomgeving definiëren, zoals de apparaatnaam, platform naam en naam van applicatiepakket. Deze mogelijkheden helpen Appium bij het tot stand brengen van een verbinding met het apparaat en het starten van de applicatie.
  6. Testacties implementeren: In het testscript moet u implementeren de acties testen die gebruikersinteracties met de applicatie simuleren. Deze acties Dit kan bestaan ​​uit het tikken op elementen, het invoeren van tekst, vegen, scrollen of elke andere actie die u tijdens de test wilt uitvoeren. Je kunt gebruiken de elementlocators geïdentificeerd tijdens de inspectiefase om met de elementen om te gaan.
  7. Voeg beweringen toe: Beweringen worden gebruikt om het verwachte gedrag van de applicatie te verifiëren. Je kunt beweringen toevoegen uw testscript om te controleren of de toepassing zich gedraagt ​​zoals verwacht. Dat kun je bijvoorbeeld beweren een bepaald element aanwezig is op het scherm, of de tekst ingevoerd in een tekstveld, wordt correct weergegeven.
  8. Voer het testscript uit: Nadat u het testscript heeft geschreven, kunt u het uitvoeren via de Appium-server. Zorg ervoor dat u het apparaat of de emulator aansluit de computer en start de Appium-server voordat u het script uitvoert. De server zal een verbinding tot stand brengen met het apparaat en het testscript uitvoeren, waarbij u de testresultaten.

Voorbeeldcode ter referentie

Hier is een voorbeeldcode fragment in Java dat laat zien hoe u een Appium-testscript voor Android schrijft:

''Java
importeren
io.appium.java_client.android.AndroidDriver;
importeer io.appium.java_client.android.AndroidElement;
importeer org.openqa.selenium.remote.Gewenste mogelijkheden;
java.net importeren.URL;

openbare klasse AppiumTestScript {
openbare statische leegte hoofd(String[] argumenten) genereert uitzondering {
// Stel de gewenste mogelijkheden in
DesiredCapabilities-limieten = nieuwe DesiredCapabilities();
caps.setCapability(“deviceName”, “Android-apparaat”);
caps.setCapability(“platformnaam”, “Android”);
caps.setCapability(“appPackage”, “com.example.app”);
caps.setCapability(“appActivity”, “com.example.app.MainActivity”);

    // Create a new instance of the AndroidDriver
    AndroidDriver<AndroidElement> driver = new AndroidDriver<>(new URL("http://localhost:4723/wd/hub"), caps);

    // Perform test actions
    // ...

    // Add assertions
    // ...

    // Close the driver
    driver.quit();
}

}
''

Deze code stelt de gewenste mogelijkheden in, creëert een instantie of de AndroidDriver, presteert acties testen, voegt beweringen toe en sluit ten slotte het stuurprogramma. U kunt de code aanpassen volgens uw testscenario's en toepassing.

Het schrijven van een Appium-testscript voor Android vereist een combinatie of technische vaardigheden en begrip van de geteste toepassing. Door de hierboven genoemde stappen te volgen en te verwijzen naar de voorbeeldcode, kunt u effectieve en betrouwbare testscripts voor jouw Android-applicaties met behulp van Appium.

Hoe u een Appium-testscript voor iPhone schrijft

Appium is een open-source automatiseringstool waarmee u kunt automatiseren testen van mobiele apps over verschillende platforms, inclusief iOS. In deze sectie zullen we de stappen onderzoeken om een ​​Appium-testscript voor iPhone te schrijven en aan te bieden een voorbeeldcode als referentie.

Stappen voor het schrijven van een Appium-testscript

Het schrijven van een Appium-testscript voor iPhone houdt in verschillende stappen. Laten we ze een voor een bekijken:

  1. Stel de omgeving in: Voordat u begint met het schrijven van het script, moet u ervoor zorgen dat de benodigde tools zijn geïnstalleerd. Dit omvat Appium, Xcode en de iOS Simulator. Je kunt installeren deze hulpmiddelen door te volgen de officiële documentatie aangeboden door Appium en Apple.
  2. Maak een nieuw project: Een keer je omgeving is ingesteld, maakt u een nieuw project aan uw voorkeur programmeertaal. Appium ondersteunt meerdere programmeertaals, zoals Java, Python en JavaScript. Kiezen de taal waar u zich prettig bij voelt en een nieuw project aanmaakt.
  3. Importeer de benodigde bibliotheken: Importeer in uw project de benodigde bibliotheken of afhankelijkheden die vereist zijn voor Appium. Deze bibliotheken zorgen voor De functies en methoden die nodig zijn om te communiceren met de Appium-server en de iOS Simulator te besturen.
  4. Stel de gewenste mogelijkheden in: Stel voordat u de Appium-server start de gewenste mogelijkheden in je iPhone-apparaat. Deze mogelijkheden omvatten de apparaatnaam, platformversie en app-pakketnaam. De gewenste mogelijkheden specifiek voor jouw toestel kun je terugvinden in de Appium documentatie.
  5. Start de Appium-server: Start de Appium-server met de gewenste mogelijkheden die u instelt de vorige stap. De Appium-server fungeert als een brug tussen uw script en de iOS-simulator, waardoor u met de app kunt communiceren.
  6. Testcases schrijven: Nu is het tijd om te schrijven de daadwerkelijke testgevallen in je schrift. Test gevallen zijn een reeks instructies die gebruikersinteracties met de app simuleren. U kunt bijvoorbeeld testcases schrijven om op te tikken een knop, voer tekst in een tekstveld in of verifieer de aanwezigheid of een element op het scherm.
  7. Voer het script uit: Zodra je hebt geschreven de testcases, voer het script uit. Het script communiceert met de Appium-server, die op zijn beurt communiceert met de iOS Simulator en presteert de acties gespecificeerd in de testcases.

Voorbeeldcode ter referentie

Hier is een voorbeeldcode fragment in Java dat laat zien hoe u een Appium-testscript voor iPhone schrijft:

''Java
importeren
io.appium.java_client.MobileElement;
importeer io.appium.java_client.ios.IOSDriver;
importeer org.openqa.selenium.remote.Gewenste mogelijkheden;

openbare klasse AppiumTest {
openbare statische leegte hoofd(String[] argumenten) {
// Stel de gewenste mogelijkheden in
DesiredCapabilities-limieten = nieuwe DesiredCapabilities();
caps.setCapability(“platformnaam”, “iOS”);
caps.setCapability(“platformVersion”, “14.5”);
caps.setCapability(“apparaatnaam”, “iPhone 12”);
caps.setCapability(“app”, “pad/naar/uw/app”);

    // Create driver instance
    IOSDriver<MobileElement> driver = new IOSDriver<>("http://localhost:4723/wd/hub", caps);

    // Write test cases
    // ...

    // Execute the script
    // ...

    // Quit the driver
    driver.quit();
}

}
''

In dit codefragment, we importeren de benodigde bibliotheken, stellen de gewenste mogelijkheden voor het iPhone-apparaat in, creëren een instantie van de driver, schrijf testcases, voer het script uit en sluit uiteindelijk de driver.

Voel vrij om te wijzigen en aan te passen deze voorbeeldcode volgens uw specifieke testvereisten.

Door deze stappen te volgen en te verwijzen naar de voorbeeldcode, je kunt beginnen met schrijven uw eigen Appium-testscript voor iPhone. Vergeet niet om de Appium-documentatie te verkennen en ermee te experimenteren verschillende testgevallen te zorgen uitgebreide testdekking For je mobiele app.

TestNG Assert in Appium-testen

Uitleg van TestNG-verklaring

Als het gaat om appium-testen, is een van de essentiële aspecten is de mogelijkheid om te verifiëren of aan het verwachte gedrag van de applicatie wordt voldaan. Dit is waar TestNG Assert in het spel komt. TestNG is een testframework dat een reeks biedt bewering methoden valideren de verwachte uitkomsts of uw testgevallen.

Met TestNG Assert kunt u controleren of een bepaalde toestand is waar en gooit een uitzondering als het niet is. Het helpt ervoor te zorgen dat de app naar verwachting functioneert en helpt bij het identificeren eventuele discrepanties of bugs in de applicatie.

Gebruik van TestNG Assert in de code

Begrijpen het gebruik van TestNG Assert bij het testen van appium, laten we eens kijken Een voorbeeld scenario. Stel dat we dat hebben gedaan een app dat heeft een login-functionaliteit, en we willen verifiëren of de login is succesvol.

Hier leest u hoe u TestNG Assert kunt gebruiken jouw appium-testscript:

  1. import de nodige TestNG en appium-bibliotheken:

java
import org.testng.Assert;
import io.appium.java_client.MobileElement;
import io.appium.java_client.android.AndroidDriver;

  1. Stel de gewenste mogelijkheden in en initialiseer de appium-driver:

''Java
Gewenste mogelijkheden
caps = nieuwe DesiredCapabilities();
caps.setCapability(“apparaatnaam”, “Uw_apparaatnaam”);
caps.setCapability(“platformnaam”, “Android”);
caps.setCapability(“appPackage”, “com.example.app”);
caps.setCapability(“appActivity”, “com.example.app.MainActivity”);

AndroidDriver stuurprogramma = nieuwe AndroidDriver(nieuwe URL(“http://127.0.0.1:4723/wd/hub”), hoofdletters);
''

  1. Schrijven de testcase verifiëren de login functionaliteit:

"`java"
@Toets
openbare leegte testLogin
() {
// Voer acties uit om naartoe te navigeren de login scherm

// Enter valid credentials
driver.findElement(By.id("username")).sendKeys("testuser");
driver.findElement(By.id("password")).sendKeys("password");

// Click on the login button
driver.findElement(By.id("loginButton")).click();

// Verify if the login is successful
Assert.assertTrue(driver.findElement(By.id("welcomeMessage")).isDisplayed(), "Login failed!");

}
''

In het bovenstaande codefragment, waar we eerst naar navigeren de login scherm en voer in geldige legitimatiegegevens. Vervolgens klikken wij door de login knop. Ten slotte gebruiken we TestNG Assert om te controleren of het welkomstbericht wordt daarna weergegeven een succesvolle aanmelding. Indien het welkomstbericht wordt niet weergegeven, de bewering zal mislukken en de opgegeven foutmelding “Aanmelden mislukt!” wordt weergegeven.

Door TestNG Assert te gebruiken, kunt u eenvoudig valideren verschillende aspecten of jouw app's functionaliteit, zoals controleren of elementen aanwezig zijn, verifiëren tekst waardenof valideren verwachte gedragingen.

Samengevat

Referenties

Hier zijn enkele waardevolle hulpbronnen die u kunnen helpen bij het schrijven van scripts voor Appium-testen:

  1. Maven-documentatie: Maven is een populaire tool voor bouwautomatisering gebruikt in Java-projecten. Het vereenvoudigt het proces van het beheren van afhankelijkheden en bouwprojecten. De Maven-documentatie biedt gedetailleerde informatie over hoe u Maven instelt uw Appium-testproject, waaronder de benodigde configuraties en afhankelijkheden. Het biedt ook richtlijnen voor het structureren en beheren van uw project zijn levenscyclus. Je kunt vinden de officiële Maven-documentatie hier..
  2. TestNG-documentatie: TestNG is een testframework dat met Appium kan worden geïntegreerd om te creëren robuuste en schaalbare testscripts. Het zorgt voor geavanceerde functies zoals parallelle testuitvoering, datagedreven testenen test de configuratie door XML-bestanden. De TestNG-documentatie aanbiedingen uitgebreide begeleiding over het schrijven van testscripts met behulp van TestNG-annotaties, beweringen, en andere mogelijkheden. Het behandelt ook onderwerpen als testconfiguratie, testsuitesen rapportage. Je hebt toegang de officiële TestNG-documentatie hier..

Door te verwijzen naar deze bronnen, je kunt verbeteren jouw begrip van Appium-testen en uw script verbeteren schrijfvaardigheden. Deze documentatiebronnen stapsgewijze instructies geven, code voorbeelden en 'best practices' om je te helpen schrijven efficiënte en onderhoudbare testscripts.

Bovendien kun je verkennen online forums, blogs en tutorials gewijd aan Appium-testen. Deze platforms vaak voorzien praktische voorbeelden, tips en trucs gedeeld door ervaren professionals in het veld. Meedoen met de Appium-testgemeenschap verder kan uitbreiden je kennis en helpen u up-to-date te blijven de laatste ontwikkelingen in het veld.

Houd er rekening mee dat het schrijven van effectieve scripts vereist dat u een combinatie of technische kennis, inzicht in de geteste toepassing, en een systematische aanpak. door gebruik te maken van de bronnen hierboven vermeld en voortdurend oefenen en verfijnen your skills, kunt u zich bekwamen in het schrijven van scripts voor Appium-testen.

Veelgestelde Vragen / FAQ

Hoe appium-tests schrijven?

Schrijven appium-testen, moet u deze stappen volgen:
1. Zet de benodigde omgeving voor appium op.
2. Schrijf het testscript met de appium-scripttaal.
3. Gebruiken de juiste appium-opdrachten om te communiceren met de mobiele applicatie.
4. Voer het testscript uit en analyseer de resultaten.

Hoe schrijf je een testscript voor het testen van software?

Schrijven een testscript For software testen, je kunt volgen deze richtlijnen:
1. Identificeer het testscenario en de verwachte uitkomst.
2. Bepaal de benodigde testgegevens en testomgeving.
3. Schrijven de teststappen in een duidelijke en beknopte manier.
4. Voeg beweringen toe om de verwachte resultaten te valideren.
5. Overweeg foutafhandeling en uitzonderingsscenario's.
6. Voer het testscript uit en analyseer het testresultaten.

Hoe voer ik appium-scripts uit in Jenkins?

Om appium-scripts in Jenkins uit te voeren, kunt u deze stappen volgen:
1. Installeer de benodigde plug-ins voor appium-integratie in Jenkins.
2. Instellen de Jenkins-baan om het appium-script uit te voeren.
3. configureren de baan gebruiken de juiste appium-server- en apparaatconfiguraties.
4. Schema de baan om naar toe te rennen de gewenste frequentie of activeer deze handmatig.
5. Monitor de Jenkins-console-uitvoer For de resultaten van de testuitvoering.

Hoe schrijf ik geautomatiseerde testscripts?

Schrijven geautomatiseerde testscriptskunt u deze stappen volgen:
1. Identificeer het testscenarios die geautomatiseerd kunnen worden.
2. Kiezen een appeen geschikt automatiseringsframework of -tool.
3. Zet de benodigde omgeving op test automatisering.
4. Schrijven de testscripts gebruik de gekozen automatiseringstool or programmeertaal.
5. Voeg beweringen en validaties toe om de verwachte resultaten te verifiëren.
6. Voer de geautomatiseerde testscripts en analyseer de testresultaten.

Hoe schrijf ik appium-code in Eclipse?

Schrijven appium-code in Eclipse kunt u deze stappen volgen:
1. Installeer de benodigde plug-ins voor appium-integratie in Eclipse.
2. Zet het project op en configureer het het bouwpad.
3. creëren een nieuwe klasse of pakket om de appium-code.
4. Schrijf het appium-script met behulp van de appium-scripttaal.
5. Gebruiken de juiste appium-opdrachten om te communiceren met de mobiele applicatie.
6. Voer het appium-script uit vanuit Eclipse en analyseer de resultaten.

Wat is een testscript bij het testen van software met voorbeeld?

Een testscript in software testen is een reeks instructies of opdrachten die de stappen definiëren die moeten worden uitgevoerd om de functionaliteit van te valideren een softwareapplicatie. Het omvat doorgaans de invoergegevens, de verwachte opbrengst en eventuele beweringen of uit te voeren validaties.

Bijvoorbeeld een testscript For een login-functionaliteit kan stappen omvatten zoals invoeren geldige legitimatiegegevens, klikken de login knop en verifieer dat de gebruiker is succesvol ingelogd.

Hoe schrijf je een appium-testscriptvoorbeeld?

Schrijven een appium-testscriptvoorbeeld kunt u deze stappen volgen:
1. Zet de benodigde omgeving voor appium op.
2. Schrijf het testscript met de appium-scripttaal.
3. Gebruiken appium-opdrachten om te communiceren met de mobiele applicatie.
4. Voeg beweringen of validaties toe om de verwachte resultaten te verifiëren.
5. Voer het testscript uit en analyseer de resultaten.

Wat zijn de best practices voor appium-scriptontwikkeling?

sommige 'best practices' voor appium script ontwikkeling omvatten:
1. Gebruik beschrijvende en betekenisvolle namen van variabelen en methoden.
2. De code organiseren in herbruikbare functies of modules.
3. Implementeren juiste foutafhandeling en afhandeling van uitzonderingen.
4. Gebruik passende wachttijden en synchronisatie technieken.
5. Implementeren registratie- en rapportagemechanismen.
6. Regelmatig beoordelenen refactoring van de code voor betere onderhoudbaarheid.

Hoe appium-scripts te debuggen?

Om appium-scripts te debuggen, kunt u deze stappen volgen:
1. in staat stellen de foutopsporingsmodus in jouw appium-opstelling.
2. Gebruik breekpunten of logboekinstructies in uw script om te identificeren het probleem.
3. Analyseren de logboeken en foutmeldingen aanwijzen het probleem.
4. Gebruiken de appiuminspecteur or andere foutopsporingstools inspecteren de applicatiestatus gedurende scriptuitvoering.
5. Maken nodige veranderingen naar het script en voer het opnieuw uit om te verifiëren de oplossing.

Wat zijn enkele tips voor het schrijven van appium-scripts?

Hier zijn een aantal tips voor het schrijven van appium-scripts:
1. Plan en ontwerp uw testscenario's voordat u het script schrijft.
2. Gebruiken beschrijvende en betekenisvolle namen voor elementen en variabelen.
3. Implementeren juiste foutafhandeling en afhandeling van uitzonderingen.
4. Gebruiken passende wachttijden en synchronisatie technieken.
5. Voeg beweringen of validaties toe om de verwachte resultaten te verifiëren.
6. Regelmatig beoordelen en herstructureer uw script voor betere onderhoudbaarheid.