Java >> Java Tutorial >  >> Tag >> class

Verwendung von TestProject-Aktionen in unseren Testklassen

class

Nachdem wir benutzerdefinierte TestProject-Aktionen geschrieben haben, wollen wir sie in unseren Testklassen verwenden. Leider haben wir keine Ahnung, wie wir das machen können.

Während dieses Blogbeitrags werden wir zwei Tests für die Suchfunktion meines Blogs schreiben und beide Testklassen verwenden die benutzerdefinierten Aktionen, die wir in den vorherigen Teilen meines TestProject-Tutorials geschrieben haben.

Nachdem wir diesen Blogbeitrag fertiggestellt haben, werden wir:

  • Wissen Sie, wie wir einen TestProject-Addon-Proxy herunterladen können.
  • Verstehen, wie wir die vom heruntergeladenen Addon-Proxy bereitgestellten Aktionen verwenden können.
  • Kann TestProject-Aktionen in unseren Testklassen verwenden.

Beginnen wir damit, herauszufinden, wie wir einen TestProject-Addon-Proxy herunterladen können.

Herunterladen eines TestProject-Addon-Proxys

Wenn wir ein benutzerdefiniertes Add-On aus dem TestProject-Add-On-Store verwenden möchten, müssen wir eine Add-On-Proxy-JAR-Datei herunterladen. Ein Addon-Proxy ist eine Komponente, die es uns ermöglicht, die eigentlichen Aktionen aufzurufen, die von einem TestProject-Addon bereitgestellt werden.

Wenn ein Addon-Proxy vom TestProject SDK aufgerufen wird, kommuniziert das TestProject SDK mit der Agent-API der app.testproject.io-Website und lädt die aufgerufene Aktion herunter (falls die Aktion nicht zuvor heruntergeladen wurde). Nachdem das TestProject SDK die aufgerufene Aktion heruntergeladen hat, führt es die Aktion in einem separaten Prozess aus.

Wir können einen TestProject-Addon-Proxy von der Website app.testproject.io herunterladen, indem wir diesen Schritten folgen:

Zuerst , müssen wir das Addon auswählen, das wir verwenden möchten. Die Website app.testproject.io verfügt über einen Addon-Store, der es uns ermöglicht, unsere privaten Addons und Addons herunterzuladen, die von den anderen Mitgliedern der TestProject-Community geteilt werden. Dieser Store hat auch eine Suchfunktion, die uns eine einfache Möglichkeit bietet, Addons zu finden, die nicht auf der Hauptseite des Addon-Stores aufgeführt sind.

Nachdem wir ein Addon gefunden haben, das wir verwenden möchten, müssen wir den Download-Dialog öffnen, indem wir auf das Element klicken, das die grundlegenden Informationen des Addons anzeigt.

Die folgende Abbildung zeigt das Layout der Seite „Addons“ (der Hauptseite des Addon-Shops):

Da wir jedoch das benutzerdefinierte Addon verwenden möchten, das wir in den vorherigen Teilen meines TestProject-Tutorials geschrieben haben, müssen wir die Seite 'Meine Addons' öffnen und den Download-Dialog unseres benutzerdefinierten Addons (Blog Search Addon) öffnen.

Die folgende Abbildung veranschaulicht das Layout der Seite „Meine Addons“:

Zweiter , müssen wir die Addon-Proxy-JAR-Datei herunterladen, indem wir auf den Link „Proxy“ klicken, den Sie im Abschnitt „Downloads“ des modalen Dialogfelds finden.

Die folgende Abbildung veranschaulicht diesen Schritt:

Wir haben jetzt die JAR-Datei heruntergeladen, die unseren Addon-Proxy enthält. Als nächstes werden wir herausfinden, wie wir unseren Addon-Proxy zum Klassenpfad hinzufügen können.

Hinzufügen des heruntergeladenen Addon-Proxys zum Klassenpfad

Bevor wir die in der heruntergeladenen JAR-Datei gefundenen Aktionen verwenden können, müssen wir die JAR-Datei zu unserem Klassenpfad hinzufügen. Wir können dies tun, indem wir diesen Schritten folgen:

Zuerst , müssen wir die JAR-Datei kopieren (blog.search.addon.proxy.jar ) zu den libs Verzeichnis, das im Stammverzeichnis unseres Gradle-Projekts gefunden wird. Nachdem wir unsere JAR-Datei in die libs kopiert haben Verzeichnis, sollte der Inhalt wie folgt aussehen:

libs
|__ blog.search.addon.proxy.jar
|__ io.testproject.sdk.java.jar

Zweiter , da wir Code schreiben werden, der die in blog.search.addon.proxy.jar gefundenen Klassen verwendet -Datei müssen wir diese JAR-Datei zu compile hinzufügen Abhängigkeitskonfiguration. Nachdem wir die erforderlichen Änderungen an unserer build.gradle vorgenommen haben Datei, ihr dependencies Block sieht wie folgt aus:

dependencies {
 compile files('libs/blog.search.addon.proxy.jar')
 tpsdk files('libs/io.testproject.sdk.java.jar')
}

Wir haben jetzt unser Addon-Proxy-Jar zu unserem Klassenpfad hinzugefügt. Lassen Sie uns weitermachen und herausfinden, wie wir Tests schreiben können, die benutzerdefinierte TestProject-Aktionen verwenden.

Schreiben von Testklassen, die TestProject-Aktionen verwenden

Lassen Sie uns diese zwei Testfälle für die Suchfunktion meines Blogs schreiben:

  • Wir müssen sicherstellen, dass die Suchergebnisseite den erwarteten Titel hat.
  • Wir müssen überprüfen, ob auf der Suchergebnisseite mindestens ein Suchergebnis angezeigt wird.

Bevor wir unsere Klassen schreiben können, müssen wir herausfinden, wie wir Code schreiben können, der TestProject-Aktionen ausführt. Als nächstes werden wir herausfinden, wie wir diesen Code schreiben können.

Ausführen von TestProject-Aktionen

Wir können eine TestProject-Aktion ausführen, indem wir executeProxy() aufrufen Methode des WebTestHelper Klasse. Wenn wir diese Methode verwenden, müssen wir diese drei Dinge wissen:

  • Es führt die aufgerufene Aktion aus (ein ActionProxy Objekt) als Methodenparameter.
  • Er gibt einen Wert von ExecutionResult zurück Aufzählung. Der Rückgabewert von executeProxy() Methode gibt das Ergebnis der aufgerufenen Aktion an (ExecutionResult.PASSED oder ExecutionResult.FAILED ).
  • Es kann eine überprüfte Erwartung auslösen (ein Exception Objekt).

Mit anderen Worten, wenn wir execute() aufrufen -Methode müssen wir Fehlerbehandlungscode schreiben, der Folgendes sicherstellt:

  • Unser Test schlägt fehl, wenn execute() Methode gibt ExecutionResult.FAILED zurück .
  • Unser Test schlägt fehl, wenn execute() -Methode löst eine Ausnahme aus.

Das Problem ist, dass wir uns in unseren Testklassen nicht um diese Dinge kümmern können, weil wir unserer Testsuite keinen doppelten Code hinzufügen möchten. Aus diesem Grund müssen wir eine Hilfsklasse erstellen, die TestProject-Aktionen ausführen und Fehler behandeln kann, die durch die aufgerufenen Aktionen verursacht wurden.

Wir können diese Utility-Klasse schreiben, indem wir diesen Schritten folgen:

Zuerst , müssen wir eine private Paketklasse namens ActionRunner erstellen . Nachdem wir diese Klasse erstellt haben, sieht ihr Quellcode wie folgt aus:

class ActionRunner {

}

Zweiter , müssen wir einen final hinzufügen WebTestHelper Feld zum ActionRunner Klasse und implementieren Sie einen Konstruktor, der den Wert von WebTestHelper festlegt -Feld mithilfe der Konstruktorinjektion. Nachdem wir unseren Konstruktor implementiert haben, wird der Quellcode der ActionRunner Klasse sieht wie folgt aus:

import io.testproject.java.sdk.v2.tests.helpers.WebTestHelper;

class ActionRunner {

 private final WebTestHelper webTestHelper;

 ActionRunner(WebTestHelper webTestHelper) {
 this.webTestHelper = webTestHelper;
 }
}

Dritter , müssen wir einen privaten privaten runAction() hinzufügen Methode zum ActionRunner Klasse. Diese Methode benötigt einen ActionProxy Objekt als Methodenparameter und kann einen FailureException auslösen . Nachdem wir diese Methode zum ActionRunner hinzugefügt haben Klasse, müssen wir sie wie folgt implementieren:

  1. Führen Sie die TestProject-Aktion aus.
  2. Falls die aufgerufene Aktion ExecutionResult.FAILED zurückgegeben hat , wirf einen FailureException das besteht unseren Test nicht.
  3. Wenn die aufgerufene Aktion einen Exception ausgegeben hat , werfen Sie einen FailureException das besteht unseren Test nicht.

Nachdem wir den runAction() implementiert haben Methode, der Quellcode von ActionRunner Klasse sieht wie folgt aus:

 
import io.testproject.java.sdk.v2.addons.proxy.ActionProxy;
import io.testproject.java.sdk.v2.enums.ExecutionResult;
import io.testproject.java.sdk.v2.exceptions.FailureException;
import io.testproject.java.sdk.v2.tests.helpers.WebTestHelper;

class ActionRunner {

 private final WebTestHelper webTestHelper;

 ActionRunner(WebTestHelper webTestHelper) {
 this.webTestHelper = webTestHelper;
 }

 void runAction(ActionProxy proxy) throws FailureException {
 try {
 ExecutionResult result = webTestHelper.executeProxy(proxy);
 if (result == ExecutionResult.FAILED) {
 throw new FailureException(String.format(
 "The invocation of the action proxy: %s failed ",
 proxy.getDescriptor().getClassName()
 ));
 }
 } 
 catch (Exception e) {
 throw new FailureException(e.getMessage(), e);
 }
 }
}

Wir sind jetzt bereit, unsere Testklassen zu schreiben. Fahren wir fort und finden heraus, wie wir sicherstellen können, dass die Suchergebnisseite den erwarteten Titel hat.

Test 1:Die Suchergebnisseite hat den erwarteten Titel

Wenn wir sicherstellen möchten, dass die Suchergebnisseite den erwarteten Titel hat, müssen wir unsere Testklasse schreiben, indem wir diesen Schritten folgen:

Zuerst , müssen wir eine neue Testklasse erstellen und den Namen und die Beschreibung unseres Testfalls konfigurieren. Nachdem wir eine neue Testklasse erstellt haben, sieht ihr Quellcode wie folgt aus:

import io.testproject.java.annotations.v2.Test;
import io.testproject.java.sdk.v2.tests.WebTest;

@Test(
 name = "The search result page must have the expected title",
 description = "Verify that the search result page has the expected title"
)
public class BlogSearchResultTitleTest implements WebTest {
 
}

Zweiter , müssen wir unserer Testklasse drei Eingabeparameter hinzufügen:

  • Der searchPageUrl gibt die URL der Seite an, die das Suchformular anzeigt.
  • Der searchTerm definiert den verwendeten Suchbegriff.
  • Der expectedSearchResultPageTitle gibt den erwarteten Titel der Suchergebnisseite an.

Nachdem wir diese Eingabeparameter zu unserer Testklasse hinzugefügt haben, sieht ihr Quellcode wie folgt aus:

import io.testproject.java.annotations.v2.Parameter;
import io.testproject.java.annotations.v2.Test;
import io.testproject.java.sdk.v2.tests.WebTest;

@Test(
 name = "The search result page must have the expected title",
 description = "Verify that the search result page has the expected title"
)
public class BlogSearchResultTitleTest implements WebTest {

 @Parameter(description = "Contains the url of the search page")
 private String searchPageUrl;

 @Parameter(description = "Contains the submitted search term")
 private String searchTerm;

 @Parameter(description = "Contains the expected title of the search result page")
 private String expectedSearchResultPageTitle;
}

Dritter , müssen wir den execute() implementieren Methode des WebTest Schnittstelle, indem Sie diesen Schritten folgen:

  1. Suchseite öffnen.
  2. Löschen Sie das Suchfeld mit ClearBlogSearchFieldAction Klasse, die wir in einem früheren Teil dieses Tutorials erstellt haben.
  3. Senden Sie das Suchformular mit BlogSearchAction Klasse, die wir in einem früheren Teil dieses Tutorials erstellt haben.
  4. Stellen Sie sicher, dass die Suchergebnisseite den erwarteten Titel hat.

Nachdem wir den execute() implementiert haben Methode des WebTest Schnittstelle sieht der Quellcode unserer Testklasse wie folgt aus:

import io.testproject.java.annotations.v2.Parameter;
import io.testproject.java.annotations.v2.Test;
import io.testproject.java.sdk.v2.drivers.WebDriver;
import io.testproject.java.sdk.v2.enums.ExecutionResult;
import io.testproject.java.sdk.v2.exceptions.FailureException;
import io.testproject.java.sdk.v2.tests.WebTest;
import io.testproject.java.sdk.v2.tests.helpers.WebTestHelper;
import io.testproject.proxy.addon.BlogSearchAddon;
import io.testproject.proxy.addon.net.petrikainulainen.testproject.addon.BlogSearchAction;
import io.testproject.proxy.addon.net.petrikainulainen.testproject.addon.ClearBlogSearchFieldAction;

@Test(
 name = "The search result page must have the expected title",
 description = "Verify that the search result page has the expected title"
)
public class BlogSearchResultTitleTest implements WebTest {

 @Parameter(description = "Contains the url of the search page")
 private String searchPageUrl;

 @Parameter(description = "Contains the submitted search term")
 private String searchTerm;

 @Parameter(description = "Contains the expected title of the search result page")
 private String expectedSearchResultPageTitle;

 @Override
 public ExecutionResult execute(WebTestHelper webTestHelper) 
 throws FailureException {
 
 WebDriver browser = webTestHelper.getDriver();
 browser.get(searchPageUrl);

 ActionRunner actionRunner = new ActionRunner(webTestHelper);

 ClearBlogSearchFieldAction clearSearchField = BlogSearchAddon
 .getClearBlogSearchFieldAction();
 actionRunner.runAction(clearSearchField);

 BlogSearchAction blogSearch = BlogSearchAddon.blogSearchAction(searchTerm);
 actionRunner.runAction(blogSearch);

 return browser.getTitle().equals(expectedSearchResultPageTitle)
 ? ExecutionResult.PASSED
 : ExecutionResult.FAILED;
 }
}

Wir haben jetzt eine Testklasse geschrieben, die sicherstellt, dass die Suchergebnisseite den erwarteten Titel hat. Als Nächstes schreiben wir eine Testklasse, die überprüft, ob die Suchergebnisseite mindestens ein Suchergebnis anzeigt.

Test 2:Die Suchergebnisseite zeigt mindestens ein Suchergebnis an

Wenn wir sicherstellen möchten, dass die Suchergebnisseite mindestens ein Suchergebnis anzeigt, müssen wir unsere Testklasse schreiben, indem wir diesen Schritten folgen:

Zuerst , müssen wir eine neue Testklasse erstellen und den Namen und die Beschreibung unseres Testfalls konfigurieren. Nachdem wir eine neue Testklasse erstellt haben, sieht ihr Quellcode wie folgt aus:

import io.testproject.java.annotations.v2.Test;
import io.testproject.java.sdk.v2.tests.WebTest;

@Test(
 name = "The search result page must display at least one search result",
 description = "Verify that the search result page displays at least one search result"
)
public class BlogSearchResultCountTest implements WebTest {
 
}

Zweiter , müssen wir unserer Testklasse zwei Eingabeparameter hinzufügen:

  • Der searchPageUrl gibt die URL der Seite an, die das Suchformular anzeigt.
  • Der searchTerm definiert den verwendeten Suchbegriff.

Nachdem wir diese Eingabeparameter zu unserer Testklasse hinzugefügt haben, sieht ihr Quellcode wie folgt aus:

import io.testproject.java.annotations.v2.Parameter;
import io.testproject.java.annotations.v2.Test;
import io.testproject.java.sdk.v2.tests.WebTest;

@Test(
 name = "The search result page must display at least one search result",
 description = "Verify that the search result page displays at least one search result"
)
public class BlogSearchResultCountTest implements WebTest {

 @Parameter(description = "Contains the url of the search page")
 private String searchPageUrl;

 @Parameter(description = "Contains the submitted search term")
 private String searchTerm;
}

Dritter , müssen wir den execute() implementieren Methode des WebTest Benutzeroberfläche, indem Sie diesen Schritten folgen:

  1. Suchseite öffnen.
  2. Löschen Sie das Suchfeld mit ClearBlogSearchFieldAction Klasse, die wir in einem früheren Teil dieses Tutorials erstellt haben.
  3. Senden Sie das Suchformular mit dem BlogSearchAction Klasse, die wir in einem früheren Teil dieses Tutorials erstellt haben.
  4. Extrahieren Sie die Anzahl der Suchergebnisse von der Suchergebnisseite, indem Sie den BlogSearchResultFinderAction verwenden Klasse, die wir in einem früheren Teil dieses Tutorials erstellt haben.
  5. Stellen Sie sicher, dass auf der Suchergebnisseite mindestens ein Suchergebnis angezeigt wird.

Nachdem wir den execute() implementiert haben Methode des WebTest Schnittstelle sieht der Quellcode unserer Testklasse wie folgt aus:

import io.testproject.java.annotations.v2.Parameter;
import io.testproject.java.annotations.v2.Test;
import io.testproject.java.sdk.v2.drivers.WebDriver;
import io.testproject.java.sdk.v2.enums.ExecutionResult;
import io.testproject.java.sdk.v2.exceptions.FailureException;
import io.testproject.java.sdk.v2.tests.WebTest;
import io.testproject.java.sdk.v2.tests.helpers.WebTestHelper;
import io.testproject.proxy.addon.BlogSearchAddon;
import io.testproject.proxy.addon.net.petrikainulainen.testproject.addon.BlogSearchAction;
import io.testproject.proxy.addon.net.petrikainulainen.testproject.addon.BlogSearchResultFinderAction;
import io.testproject.proxy.addon.net.petrikainulainen.testproject.addon.ClearBlogSearchFieldAction;

@Test(
 name = "The search result page must display at least one search result",
 description = "Verify that the search result page displays at least one search result"
)
public class BlogSearchResultCountTest implements WebTest {

 @Parameter(description = "Contains the url of the search page")
 private String searchPageUrl;

 @Parameter(description = "Contains the submitted search term")
 private String searchTerm;

 @Override
 public ExecutionResult execute(WebTestHelper webTestHelper) 
 throws FailureException {
 
 WebDriver browser = webTestHelper.getDriver();
 browser.get(searchPageUrl);

 ActionRunner actionRunner = new ActionRunner(webTestHelper);

 ClearBlogSearchFieldAction clearSearchField = BlogSearchAddon
 .getClearBlogSearchFieldAction();
 actionRunner.runAction(clearSearchField);

 BlogSearchAction blogSearch = BlogSearchAddon.blogSearchAction(searchTerm);
 actionRunner.runAction(blogSearch);

 BlogSearchResultFinderAction searchResults = BlogSearchAddon
 .getBlogSearchResultFinderAction();
 actionRunner.runAction(searchResults);

 return searchResults.actualSearchResultCount > 0 
 ? ExecutionResult.PASSED 
 : ExecutionResult.FAILED;
 }
}

Wir haben jetzt zwei Testfälle geschrieben, die zeigen, wie wir TestProject-Aktionen in unseren Testklassen verwenden können. Fassen wir zusammen, was wir aus diesem Blogbeitrag gelernt haben.

Zusammenfassung

Dieser Blogbeitrag hat uns sechs Dinge beigebracht:

  • Wenn wir ein benutzerdefiniertes Addon aus dem TestProject-Addon-Store verwenden möchten, müssen wir eine Addon-Proxy-JAR-Datei herunterladen.
  • Ein Addon-Proxy ist eine Komponente, die es uns ermöglicht, die tatsächlichen Aktionen aufzurufen, die von einem TestProject-Addon bereitgestellt werden.
  • Wenn wir ein Addon in unseren Testklassen verwenden wollen, müssen wir die heruntergeladene Addon-Proxy-JAR-Datei zu compile hinzufügen Abhängigkeitskonfiguration.
  • Wir können eine TestProject-Aktion ausführen, indem wir executeProxy() aufrufen Methode des WebTestHelper Klasse.
  • Wenn wir unserer Testsuite keinen doppelten Fehlerbehandlungscode hinzufügen wollen, müssen wir eine Hilfsklasse erstellen, die TestProject-Aktionen ausführen und Fehler behandeln kann, die durch die aufgerufenen Aktionen verursacht wurden.
  • Wir sollten den aufgerufenen ActionProxy erstellen Objekte, indem Sie die Factory-Methoden verwenden, die von [AddonName]Addon bereitgestellt werden Klasse.

Java-Tag